>> [Review: Quiz 1]
[Ali Nahm, Oreoluwa Barbarinsa, Lucas Freitas, Rob Bowden] [Harvard Egyetem]
[Ez a CS50.] [CS50.TV]
[Lucas Freitas] Üdvözlünk mindenkit. Ez a felülvizsgálat a kvíz 1.
Ahogy a felelősségi nyilatkozat, ez - úgy értem, fogunk próbálja fedezni
annyi anyagot, amennyit csak lehetséges, de ez nem jelenti azt, hogy
fogjuk, hogy minden olyan dolog, hogy lehet kvíz 1..
Tehát biztos, akkor is vessen egy pillantást előadás, szakaszok, mindent, amit lehet.
Kvíz 1. lesz szerdán, jövő szerdán.
Tehát biztos, hogy tanulni. Ez lesz, nagyjából, mint az első teszt
tekintve formátumban, de ez valószínűleg lesz sokkal nehezebb.
Legalábbis tavaly, amikor vettem 50, azt hittem, sokkal nehezebb.
Tehát tanulni sokat.
>> Fogom fedezni adatstruktúrák és Huffman kódolás.
Ez olyan dolog, hogy sok ember úgy gondolja, összetett,
de meg fogom próbálni, hogy ez olyan egyszerű, amennyire csak lehetséges.
Először is, amit szeretnénk, ha tudnátok a kvíz 1, hogy
megérteni a fogalmi leírásokat az egyes adatszerkezetek, hogy én fogom bemutatni.
Ez azt jelenti, hogy nem kell, hogy ténylegesen
végre egy hash tábla a kvíz 1..
Nem akarjuk, hogy végre egy egész hash tábla, talán megpróbáljuk
, hogy ha végre bizonyos funkciókat,
leggyakoribb műveleteket, de nem fogunk, hogy ha végre mindent.
Ezért fontos, hogy megértsék a koncepció mögött minden adatstruktúra
és azt is, hogy meg tudja-e kódolni C,
csak a leggyakoribb műveletek vannak az egyes adatstruktúra.
És azt is tudja, hogy felülvizsgálja mutatók és struktúrákat,
mert úgy tűnik, sokat ezek az adatok struktúrákat.
>> Első kapcsolódó listákat. Csatolt listák valójában nagyon hasonlít a tömbök,
de a különbség a láncolt lista és egy sor,
először is, az, hogy egy láncolt lista van egy nagyon rugalmas méret,
míg a tömbök van, hogy vagy válasszon egy nagyon nagy méretű a tömb,
így tudod, hogy fogsz tudni tárolja az összes adatot, hogy tömbben,
vagy meg kell használni malloc, hogy egy rugalmas hossza tömb.
A kapcsolt listák nagyon könnyű, hogy csak minél több elemet,
fel több elemet a láncolt lista, vagy távolítsa el elemeket.
És valóban, ha nem akarja, hogy a láncolt lista kell válogatni,
lehet keresni, és távolítsa el elemek állandó időben,
így O (1) idő, így nagyon kényelmes.
Csak óvatosnak kell lennünk, hogy mindig emlékezni malloc és ingyenes a csomópontok,
csak azért, mert ha nem, akkor memóriavesztés.
Így kapcsolódik listák - meghatározása a csomópont, mint amit mi ott.
Tettem int n, de tárolni kívánt adatokat.
Tehát, ha szeretné tárolni egy string, semmi baj.
Ha szeretne tárolni a struct, ez rendben van, egy dupla, amit akarsz.
Én az imént int n a példák itt.
És van egy mutató a következő csomópontot.
Tehát, alapjában véve, a láncolt lista néhány adat, és akkor pont a következő csomópontot.
Ha ez az utolsó elem a láncolt lista, hogy fog mutatni a NULL.
Tehát ez egy példa egy láncolt lista.
>> Oké, most nézzük meg, mit kell tennünk, ha azt szeretnénk beszúrni egy elemet a láncolt lista.
Először is, a funkció betét típusú lesz érvénytelen
mert nem akarom, hogy vissza semmit.
És fogok venni egy int argumentumként,
mert azt akarom, hogy tudja, mit akarok szúrni.
Tehát mi az első dolog, amit meg kell csinálni? Nos, azt kell malloc on newnode,
úgy, hogy az első sorban.
Én csak egy új csomópont, hogy a láncolt lista.
Szóval, mit tehetek? Nos, tudjuk, hogy a mi megvalósításai kapcsolt listák
osztályban, mindig fel a fejét, mint egy globális változót.
Tehát mit tehetünk a változás a fejét.
Tudom, hogy ez az új csomópont lesz az új vezetője,
és ez fogja mutatni az előző fejét.
Hogyan tudjuk ezt? Az első dolog, amit meg kell tennie,
megváltozik az "n" az új csomópont értéket,
melyet át a funkciót.
Ezután newnode a következő lépés lesz a feje.
A fej lesz newnode. Szóval, ez elég egyszerű.
Törlése egy csomópont, meg tudjuk csinálni, mint a -
Ennek egyik módja, amit tehetünk, hogy mondjam,
rendben van, ha akartam törölni, például 3,
mit tehetnék ez csak pont az előző csomópont
a következő csomópontot 3.
Szóval, én csak ilyet.
De mi az a probléma ezzel, hogy?
Van egy memóriavesztés, így nem férnek hozzá a 3-as szám már.
A probléma azzal van, hogy én nem lesz képes felszabadítani a csomópont.
Megyek, hogy a memóriavesztés és (érthetetlen) fog utálni.
Tehát ahelyett, hogy talán érdemes egy ideiglenes mutató.
Így tettem temp. Ez lesz, hogy pont a csomópont, amit törölni kíván.
És akkor tudom mozgatni az előző csomópontok pont a következő csomópont
A csomópont, amit törölni kíván.
És végül, azt is szabad a mutatót.
Van, hogy szabad a mutató, amit teremtett ott?
Nem kell, csak azért, mert -
A különbség az, hogy ez a csomópont jött létre malloc,
így ez a halom, míg ez csak nyilvánították NULL kapcsoló a verem.
Szóval nem kell kiszabadítani.
>> Oké. Most beszéljünk stack.
Stacks nagyon egyszerű.
Mi volt stack és sorok az osztályban csak a tömbök,
de meg kell ismernie - csak tudatában kell lennie
hogy akkor is ezt halom a sorban a kapcsolt listák is.
Tehát, ha van egy tömb, mi lenne a stack?
Egy halom egyrészt lesz, hogy a méretet.
Meg kell tárolni mekkora a verem, hogy van most.
És azt is meg kellett volna egy sor, ebben az esetben a számok,
de ha akarod, akkor egy tömb
a vonósok, egy sor struktúra, bármit, amit szeretnénk tárolni.
A stack: A különbség egy verem, és a láncolt lista
az, hogy a halom csak férnek hozzá az utolsó elem került a verem.
Úgy hívják utolsó, first out.
Csakúgy, mint hogy van egy halom tálcák,
ha tesz egy tálcát a tetején a verem,
el kell távolítani ezt a tálcát, hogy hozzáférjenek a többi tálcát.
Ez ugyanaz a dolog halom.
Tehát, ha azt akarom, hogy például egy elemet egy köteg, mit tegyek?
Úgy hívják push, és ez elég egyértelmű.
Az első dolog, amit meg kell tennie, hogy ellenőrizze, hogy a méret a verem
nem nagyobb vagy egyenlő, mint a kapacitás a verem.
Mert ha már vannak teljes kapacitással, akkor nem lehet hozzá semmi mást.
És ha nem, akkor csak meg kell hozzá az elemet a verem.
És végül, növelni a méretét. Szóval ez elég egyértelmű.
Szóval, én csak hozzá a 2-es szám.
És ha azt akarom, hogy a pop, ami azt jelenti, hogy az eltávolítani kívánt
Az utolsó elem, amely adunk hozzá, és visszatér az érték az elem,
Az első dolog, amit meg kell ellenőrizni, hogy a verem nem üres.
Mert ha ez üres, nem tudok vissza semmit.
Ebben az esetben, én vissza -1.
Egyébként, én megyek csökkentse a méret a spec,
és vissza a számok (s.size).
Miért csökkentse a méretet, majd vissza s.size?
Ez azért van, mert ebben az esetben a spec van 4-es méretű,
és azt akarom, hogy visszatérjen a negyedik elem, nem igaz?
De mi is az index a negyedik elem? Három.
Mivel én nem méret - lesz 3, én csak vissza s.numbers (s.size)
mert 3. Tehát csak az index.
>> Most sorba. Sorok nagyjából ugyanaz a dolog.
Az egyetlen különbség az, hogy ahelyett, hogy utolsó, first out,
akkor az első be, első ki.
Talán ha várja, hogy menjen egy koncertre,
akkor nem lenne boldog, ha már egy halom, hanem a sorban.
Mivel az utolsó, aki jött volna az első, aki meg a koncert.
Valószínűleg nem lenne boldog.
A sorban az első, aki kap is az első, aki kijutni.
Így a meghatározása sor, amellett, hogy a méret a tömbben,
akkor is van, hogy a fej, amely az index, hogy a fejét a verem.
Tehát az első elem most.
Enqueue az ugyanaz, mint a push stack.
Ha nagyon naiv, akkor csak azt mondom,
Nos, csak nem pontosan ugyanaz a dolog, mint én a push.
Én csak ellenőrizni, ha ez nem túl a kapacitást.
Ha így van, akkor return false, különben csak exportálni az új értéket
majd növelni a méretét.
De miért van ez a baj?
Nézzük ezt a példát.
Próbálok sorba állítását egy csomó dolgot,
aztán megyek dequeue és sorba állítását.
Van egy csomó parancs, de ez nagyon egyszerű.
Megyek sorba állítását 5, adjunk hozzá 5, majd a 7,
1., 4., 6., és akkor szeretnék dequeue valamit,
ami azt jelenti, hogy megyek, hogy távolítsa el az első elemet.
Szóval megyek, hogy távolítsa el a 3-as szám, nem igaz?
Az első elem. Oké.
Most, ha megpróbálom sorba állítását valami mást, hogy mi fog történni?
Szerint a végrehajtás,
Azt akartam, hogy a következő szám az index q.size.
Ebben az esetben, a mérete 8,
így az index 8 lesz itt az utolsó pozícióban.
Ha megpróbálom sorba állítását 1. itt, azt is felülírja az utolsó pozíció
Az 1-es szám, ami teljesen rossz.
Amit én akarok a kerületi és menj az első helyen.
Lehet, hogy azt mondjuk, nos, csak azt kell ellenőrizni
ha ténylegesen tenni valamit.
Ha nem, én csak azt mondom, ó, az új, teljes kapacitással
valójában mennyiség - 1, és nem tudod elem van.
De mi a probléma? A probléma az, hogy ha én csak dequeue mindent itt
és aztán megpróbálja felvenni valami mást, akkor csak azt mondom,
Nos, volt teljes kapacitással, ami 0-ra.
Tehát a sorban elment.
Meg kell kerületi, és olyan módon, a csomagolás körül
hogy ti tanult látomásos és egyéb psets használta mod.
Meg lehet próbálni, hogy otthon, hogy megértsük, miért tennéd q.size + q.head
mod kapacitás, de ha megnézed itt,
láthatjuk, hogy működik.
Így a legutóbbi példa, q.size volt 8
és a fej 1 volt, mert ebben a helyzetben itt a tömb.
Így lesz 8 + 1, 9. Mod kapacitás 9 lesz 0-ra.
Ez megy a mutató 0-ra. Mi lesz a megfelelő pozícióba.
És akkor próbálja ki a sorban otthon.
Néhány fontos dolog: próbáld megérteni a különbséget a verem, és a sorban.
Otthon, próbálj meg nagyon jól ismeri a végrehajtási Enqueue, dequeue, nyomja és a pop.
És azt is megérteni, ha használná mindegyiket.
>> Szóval pihenni 10 másodpercig egy csomó Pokemons.
És most térjünk vissza az adatszerkezeteket.
Hash táblák. Sokan voltak, félek hash táblák.
A probléma meg a 6., helyesírás-ellenőrző.
Hash táblák és próbálkozás, egy csomó ember, hogy félek tőlük.
Azt hiszik, hogy annyira nehéz megérteni. Igen?
[Rob Bowden] Probléma készlet 5. >> Probléma készlet 5, igen. Köszönöm, Rob.
Igen. Hat volt Huff n 'Puff, igen.
Probléma meg az 5. helyesírás-ellenőrző, és ha kellett, hogy vagy a hash tábla, vagy egy próbát.
Sokan gondolták, hogy ők szuper nehéz megérteni, de ők valójában nagyon egyszerű.
Mi az a hash tábla, gyakorlatilag? A hash tábla egy tömb, láncolt listák.
Az egyetlen különbség a tömb és a hash tábla
az, hogy a hash tábla van egy úgynevezett hash függvényt.
Mi az a hash függvény?
Nem tudom, hogy ti is itt olvasható.
Ez egy példa egy hash tábla.
Tehát látható, hogy van egy sor 31 elemekkel.
És mit csinálunk a hash tábla egy hash függvény
hogy fog fordítani a kulcsot, minden int egy index.
Ha például, ha azt szeretné, hogy válasszon a B. Harrison,
Azt tegye B. Harrison én hash függvények,
és a hash függvény visszatér 24.
Szóval tudom, hogy szeretnék tárolni B. Harrison 24.
Szóval ez a különbség csak úgy, egy tömböt, és miután egy hash tábla.
A hash tábla akkor van olyan funkció, amely fogja mondani,
hol tárolja az adatokat, hogy a tárolni kívánt.
A hash függvény, meg akarom nézni a hash függvény
hogy a determinisztikus és jól elosztott.
Mint látható itt, akkor láthatjuk, hogy sok az adat, hogy szerettem volna tárolni valójában 19
ahelyett, hogy a 31. és a 30. és 29., melyek minden szabad.
Így a hash függvényt, amit használtam nem volt túl jól elosztott.
Amikor azt mondjuk, jól elosztott, azt jelenti, hogy azt akarjuk, hogy,
durván, legalább 1 vagy 2 az egyes -
mint például, a különbség 1 vagy 2 az egyes indexek a tömbök.
Azt akarjuk, hogy nagyjából az azonos számú elemet az egyes láncolt lista a tömbben.
És ez könnyen ellenőrizhető, ha ez érvényes a hash tábla, nézet, mint hash táblákat.
>> Majd fák. Ez egy fa.
Fák számítástechnika fejjel lefelé valamilyen okból.
Tehát itt van a gyökere a fa, majd a levelek.
Akkor csak azt tudom, a nómenklatúra a szülők és a gyermek.
Mindegyik csomópontnak megvan a gyermekek számára, melyek a csomópontok, amelyek alatt a szülő.
Így például a 2 lesz a szülő és a 3, a többi gyermek ott,
míg a 3. lesz a szülő 1 és a többi gyerek, hogy ott vannak.
És 1 lesz 3 gyermeke, és így tovább.
Van valami sokkal érdekesebb, úgynevezett bináris kereső fa,
ahol minden érték a jobb oldalon egy csomópont
lesz a jobb, itt - a jobb oldalon,
lesz nagyobb, mint az elemet a gyökér.
Tehát, ha van az 5-ös szám itt, minden eleme a jobb oldalon
lesz nagyobb, mint 5, és a bal oldalon
minden eleme lesz kevesebb, mint 5.
Miért van ez hasznos?
Nos, ha azt akarom, hogy ellenőrizze, hogy a 7-es szám van itt, például,
Én csak az 5-ös az első, és én fogom látni, 7 nagyobb vagy kisebb, mint 5?
Ez nagyobb, ezért tudom, hogy lesz, hogy legyen jobb a fa.
Így sokkal kevesebb dolgot nézni.
A megvalósítása egy bináris keresést fa, a csomópont, én csak megy, hogy az adatok,
így int n, akkor is van egy sor
vagy bármit, amit akart.
Csak meg kell legyen óvatos meghatározzák, hogy mi a nagyobb, ami kevésbé.
Tehát, ha már húrok, például, definiálhatunk
hogy ezeket a dolgokat a jobb oldalon megy, hogy a nagyobb hosszúságú,
A bal oldali megy, hogy a kisebb hosszúságú, így tényleg rajtad múlik.
>> Hogyan végrehajtani keressünk BST?
Az első dolog, amit meg kell tennie, hogy ellenőrizze, hogy a gyökér NULL.
Ha ez NULL, az azt jelenti, hogy a dolog nem létezik
mert nem is egy fa, nem igaz?
Szóval vissza hamis.
Egyébként, én fogom ellenőrizni, ha a szám nagyobb,
értéknél a gyökér.
Fogom, hogy megpróbálja megtalálni az elem a jobb oldalon
a fa.
Azt látom, hogy én vagyok a rekurzió itt.
És aztán, ha ez kevesebb, fogom nézni a bal oldalon.
És végül, ellenkező esetben, ha ez nem kevésbé, vagy nem nagyobb,
ez azt jelenti, hogy ez az érték is.
Szóval én csak vissza igaz.
Láthatjuk, hogy itt voltam, ha, ha, ha.
És ne feledd, a kvíz 0, mi volt a probléma, hogy még, ha, ha, ha,
és meg kellett volna találni a hatékonyság,
és a hatékonyság volt, hogy használható, ha.
Meg kellett volna használni, ha else if, else if és más.
Így kell használni else if és az else if és az else itt?
Tudja valaki - Igen?
[Student beszéd, nem hallható]
Ez tökéletes. Tehát azt mondja, hogy nem számít,
csak azért, mert a hatékonyság, hogy mi volt korábban
az volt, hogy azért, mert, talán ha néhány feltétel teljesül,
így csináltak valamit, de akkor is lesz, hogy ellenőrizze az összes egyéb feltétel.
De ebben az esetben, akkor vissza azonnal, így nem számít.
Szóval nem kell használni else if.
>> És végül, beszéljünk próbálkozás,
amely mindenki kedvence.
A próbát egy fa a tömbök.
Ez nagyon gyorsan keresni értékeket, de használ sok memóriát.
És ez általában Szűrés szavak, így amikor
szeretnénk végrehajtani, például, nem is tudom, mint egy telefonkönyv a telefon
és azt szeretné, hogy képes legyen B típusú
és csak nevét, akik B.
Ez nagyon könnyen megvalósítható, hogy egy próbát, pl.
Hogyan határozná meg a csomópont egy próbát?
Csak ki kell, hogy egy bool, hogy lesz is_word.
Ez jelzi, hogy használja az összes karakter előtt csomópont,
voltál képes, hogy egy szót,
és akkor lesz egy sor mutató a csomópontok.
Látod, hogy van egy sor szülő csomópont, így a node * tömb? Igen?
Nézzük, hogy ez hogyan fog működni. A helyesírás-ellenőrzés,
van egy sor 27-elemek,
azért van, mert a betűk és az idézőjel.
Mielőtt itt én csak fogja használni 2, mert azt akarom, hogy képes írni a fórumon.
Oké. Tehát ez egy példa egy próbát.
Ha csak meg az első csomópont, én is egy sor 2 elem
hogy a 2 mutatókat NULL, úgyhogy csak fel "a" és "b".
És én fogom, hogy egy bool, amely azt mondja is_word.
Ez lesz, hogy hamis az az első,
csak azért, mert előtte meg nincs karaktereket.
Tehát egy üres szó, nem egy szó. Tehát hamis.
Ha szeretne hozzáadni "a" a szótár, mit kell tennem?
Én csak malloc új csomópontot az "A",
, majd adjunk hozzá a szó igaz.
Tehát ez csak jelzi, hogy miután "a" lesz igaz. Értelme?
Akkor, ha azt akarom, hogy add 'ba', én is, hogy malloc 1. 'b',
aztán megyek, hogy hozzanak létre a logikai hamis,
mert a "b" önmagában nem egy szó.
Aztán megyek malloc másik az "A", így a "ba"
aztán megyek, hogy hozzanak létre ez egy szó igaz.
Mivel a "ba" egy szó.
És ha azt akarom, hogy ha a "b" ebben a szótárban,
Én is csak megy az első, "b". Lemegyek, és nézd meg a szó, és azt mondja, hamis.
Tehát ez nem egy szó. Ha azt szeretné, hogy ellenőrizze "ba"
Megyek az első, "b", aztán megy a 'a', és látom, igaz, így ez a szó. Értelme?
Sokan összezavarodnak a próbálkozás. Nem?
>> Végül Huffman kódolás. Huffman-kódolás nagyon hasznos
A helytakarékosság és tömöríteni szöveges fájlok,
csak azért, mert sokszor használja az "a" és "e", például,
a dokumentumokat, de nem tudom, ha ti a 'q' vagy 'z' annyi.
Ha csak 1 bájt minden egyes karakter,
minden egyes - a 256 karakter, hogy van az ASCII táblázat nem túl optimális,
csak azért, mert vannak olyan karakterek használata sokkal több,
ezért valószínűleg kevesebb memóriát számára.
Hogyan használhatom Huffman kódolást?
Meg kell csinálni a Huffman fa.
A Huffman fának csomópont
amelyek egy szimbólum, amely olyan lesz, mint "a", "b", "c", a levél,
bármilyen betű van, a frekvencia, az a frekvencia, hogy a szó jelenik meg a szövegben,
hogy te is megteremti a Huffman fa,
majd a csomópontot, hogy fog mutatni, hogy a bal oldalon a Huffman fa
és egy másik csomópont, hogy fog mutatni a jobb. Tehát, mint egy fa.
Hogyan épít a Huffman fa?
Fogsz felvenni a 2. csomópontok a legalacsonyabb frekvenciákat.
Ha van egy döntetlen fogsz felvenni a 2. csomópont
hogy a legalacsonyabb ASCII értékeket is.
Akkor fogsz egy új fát ki azokat a 2. csomópont
hogy megy, hogy a kombinált frekvenciát a szülő csomópont.
És akkor fogsz, hogy távolítsa el a 2 gyermek az erdőből
és cseréld ki a szülő.
És fogsz megismételni, hogy addig, amíg már csak 1 fa az erdőben.
Nézzük, hogyan tennéd a Huffman fa ZAMYLA.
Itt látható, hogy a leveleket már frekvencia 1, kivéve az "A", amely a frekvencia 2.
Ezért hoztam létre csomópontok minden betű tettem, hogy az ASCII értékét és gyakoriságát.
Tehát, ha azt akarom, hogy létrehozza az első fát, akkor az "L" és "M".
Szóval itt van. A frekvencia a pár lesz 2
mert ez 1 + 1, akkor a következő 2 a legalacsonyabb frekvenciák "Y" és "Z".
És akkor már az összes közülük - a frekvencia 2.
Tehát melyek azok, amelyek a legalacsonyabb ASCII értéket a következő?
"A" és "L". Így hozza létre az új csomópont,
és végül, ez 4 és 2, így a 2 lesz a bal oldalon.
És ez a Huffman fa.
Akkor, ha azt akarom, hogy írjon egy szöveget,
mint bináris átalakítani a szöveget, a Huffman fa nagyon egyszerű.
Például, ha azt mondom, hogy mozog, hogy a bal oldalon van egy 0 és mozog jobbra egy 1,
Mi az, hogy fogja képviselni?
Szóval, mint 1, 1, ezért jobb, jobb,
majd 0, tehát balra lenne L, majd 1, 0, 0-ra.
Tehát 1, 0, így csak 1, 0, 'A'.
És akkor 0, 1, így a "Z".
És akkor 1, 0, 0 - nincs.
0, 0 lesz, "Y", így lusta.
Szóval ez mind nekem, Rob fogja átvenni.
>> [Rob Bowden] Tehát, a hét 7 dolog.
Már van egy csomó, hogy menjen át nagyon gyorsan.
Bitenkénti operátorok, puffer túlcsordulás,
CS50 könyvtár, akkor a HTML, HTTP, CSS.
Mindent mint a 15 és 20 perc.
Bitenkénti operátorok. Jelenleg 6 nekik, hogy meg kell tudni.
Bitenkénti és bitenkénti vagy, XOR, bal shift jobb shift, és nem.
JOBB SHIFT és nem alig látott előadás egyáltalán.
Majd megy át gyorsan, de akkor jó tudni, hogy ezek a 6., hogy létezik.
Ne feledje, hogy bitenkénti operátorok, mint ha nem 3 + 4.
Nem foglalkozik a bináris a 3. és 4..
A bitenkénti operátorok akkor tulajdonképpen foglalkozik az egyes bitek a számok a 3. és 4..
>> Tehát az első, hogy azt mondjuk a bitenkénti nem,
és mindent meg tesz, fordítsa a bit.
Tehát itt, ha írsz ezt a C-ben, akkor nem írja
a ~ 11.011, vagy bármi, akkor írja meg, mint a ~ 4,
és akkor ez megfordítja a bináris 4.
Tehát itt, ~ néhány bináris szám 1101101 lesz pontosan a flip csupa 1-0-ra és a mind a 0-1-es.
Mint mondják, a gyakori használata ezt,
és majd meglátjuk, hogy egy kicsit olyan, mint szeretnénk, hogy dolgozzon ki egy számot
ahol az összes bit értéke 1, kivéve az egyiket.
Szóval, ez általában könnyebb kifejezni a számot
ahol csak, hogy egyetlen bit be van állítva,
majd vegye a ~ a, tehát minden bit be van állítva, kivéve, hogy az egyik.
Szóval ez az, amit mi fogunk használni, inkább egy kicsit.
>> Bitorientált vagy. Itt van 2 bináris számokat, és ezek a 2 szám
elég reprezentatív, hiszen ők képviselik minden lehetséges
kombinációs bitek, amire szüksége lehet, hogy működik.
Itt, amikor or'd minden bit, mi csak lesz összehasonlítani egyenesen lefelé.
Tehát a bal oldalon van egy 1-es és a 1.
Amikor bitenkénti | azok, mit fogok kapni? Egy.
Ezután bitenkénti | 0 és 1 fog adni nekem? Egy.
Bitenkénti 1 és 0 lesz ugyanaz a dolog, egy.
Bitenkénti 0 | 0 fog adni nekem 0-ra.
Tehát az egyetlen eset, amikor kapok 0 van a 0 | 0 eset.
És azt hiszem, hogy csakúgy, mint a logikai ors.
Tehát, ha úgy gondolja, 1 igaz 0 hamis, ugyanez érvényes itt.
Így igaz, vagy igaz, igaz, igaz vagy hamis igaz.
Hamis vagy igaz, igaz, hamis, vagy hamis az egyetlen dolog, ami valójában hamis.
Itt a példa, amit tudnia kell
mint egy nagyon jó példa arra, amikor a bitenkénti operátorok használnak.
Itt, ha mi, vagy tőkét "A" OX20,
és akkor nézd meg ezeket a második, akkor kap valamit.
És ha mi, vagy kisbetűs "a"-val OX20, kapunk valamit.
Szóval húzza fel ASCII tábla.
Oké. Itt azt látjuk, hogy "A" -
itt van "A" decimális 65.
De én megyek hexadecimális, ami Ox41.
Biztos vagyok benne láttuk az osztályban. Azt hiszem, láttam az osztályban
hogy ez elég könnyű átalakítani a hexadecimális bináris.
Tehát itt, ha azt szeretnénk, hogy 4 bináris,
ez csak lesz 0100.
Ez az 1-es sor, 2. helyét, 4-es szinten, így ez 4.
Aztán lehet rész 1 bináris, ami lesz 0001.
És ez lesz a képviselete "A" bináris.
A kezelés ideje alatt kisbetűs "a", ez most lesz Ox61,
ahol felosztása e fel a saját bináris, így a 6 -
Nézzük ténylegesen csinálni - nem látható a radír? Radír.
Ox61. Tehát felosztása 6. bináris lesz 0 + 4 + 2 + 0.
És felosztása 1 lesz 0001.
Ami a különbség a 2,
azt látjuk, hogy az egyetlen különbség a kisbetűs és a tőke 'A' ez egyetlen bit.
Így jön vissza ide - rendben van.
Visszatérve ide, ha megnézzük, hogy mi a bit OX20 van,
így felosztása OX20 bele bináris,
a 0010, a 0000.
OX20, az egyetlen bit van beállítva ez a kicsit, hogy arról van szó,,
A váltás a tőke és a kisbetűs "a".
Ha én, vagy "A", ami ez, az "A",
ha én, vagy "A" OX20,
mit fogok kapni?
[Student, nem hallható] >> kisbetűs "a", mert ez lesz a flip ezt a kicsit, hogy az 1.
És ha én, vagy "a"-val OX20, mit fogok kapni?
Kisbetűs egy, mert csak fejekhez, "a"-val OX20,
Én csak lesz fejekhez, ez az egyetlen bit az 1, ez már egy 1, így nem számít.
Tehát, hogy az "a" és "a".
>> Bitorientált és. Ismét el tudunk képzelni ezt a logikus és párja.
A bal oldalon van, igaz és igaz.
Ez lesz, hogy igaz legyen, és minden esetben,
hamis és igaz vagy igaz-hamis, vagy téves és hamis,
egyik sem ezek a dolgok igazak.
Tehát mi a végén kezd 1000.
Tehát most, itt, itt, ahol én is használtam a megbízható bitenkénti nem,
ahol volt OX20.
Tehát ez OX20.
Most már, hogy mit akarok csinálni, bitenkénti ~ az OX20.
Hogy fog fordítsa a bit.
Szóval 1101, 1111.
És így "A" kapcsolatba kerülnek a ~ OX20 fog adni, hogy mit?
Az egyetlen bit valóban meg kell gondolni ezt,
mivel ha az összes ilyen bit értéke 1,
akkor mi lesz, hogy pontosan mi az "A" volt,
kivéve, talán, hogy mi ez a kicsit.
Mert ha ez a 1, most lesz állítva a 0,
mert akármi is ez, kapcsolatba kerülnek ezzel lesz 0-ra.
Tehát mi az 'A' & ~ OX20 fog adni nekem?
[A diákok választ, nem hallható] >> És mi az "a" és - ez az "A".
És mi az "a" és ~ OX20 fog adni nekem?
"A." Mivel ez jelenleg a 1.
Anding ezzel 0 lesz, hogy ez a 0,
és most mi lesz, hogy egy "A".
>> Mindkettő "A", és végül, de nem utolsó sorban az ilyen típusú,
van XOR. Ez nagyon hasonlít, vagy
kivéve azt jelenti, hogy kizárólag vagy.
Ez olyan, mint amit általában gondolnak, mint vagy a valós világban.
Szóval, te vagy a "x" vagy "y", de nem mindkettő.
Itt 1 ^ 1 lesz 0-ra.
Mert igaz, ez - ez nem működik olyan jól a logikai igaz és hamis
mint bitenkénti és és vagy nem,
de igaz ^ igaz, hamis.
Mert mi csak azt akarjuk, hogy visszatérjen igaz, ha csak az egyik igaz.
Tehát 1 ^ 1 0. Mi a helyzet a 0 ^ 1?
1 lehet. 1 ^ 0 1, 0 ^ 0 0..
Szóval, minden körülmények között, 0 bitenkénti valami 0 lesz 0-ra.
1 bitenkénti valami 0 vagy 0 bitenkénti 1
ha ez | vagy ^, akkor lesz 1, és ha ez és ez lesz 0-ra.
És az egyetlen eset, amikor 1 bitenkénti 1 nem 1 kizárólagos vagy.
Az 0110.
Tehát itt most a XOR - tehát újra itt vagyunk 20.
'A' ^ OX20 ezek a 2 bit vagyunk képest.
Tehát egy 1 ^ 0 fog adni nekem, mi? Az egy.
'A' ^ OX20 fog adni nekem? Kisbetű a.
'A' ^ OX20 fog adni nekem? Capital A.
Mert bármit ezt csinálja, ez XOR logikai és OX20
hatékonyan essek bármit ez a kicsit.
Ha ez 0, ez most fog válni 1..
Mivel ez egy 1, 1 ^ 1 0.
Tehát "a" lett "A" és a "A" lett "a".
Tehát XOR egy igazán kényelmes módja csak essek az ügy.
Azt akarod, hogy végighaladni egy sor betű
és alternatív esetében minden egyes karakter,
csak XOR mindent OX20.
>> Most már bal shift. Bal Shift csak megy, hogy alapvetően,
nyomja az összes számokat, vagy balra, és helyezze be a 0-mögöttük.
Tehát itt van 00.001.101.
Fogunk álljon 3 0 által a jobb,
és megkapjuk 01.101.000.
A nonbináris szempontból,
azt látjuk, hogy ez tényleg foglalkozó 13 bal eltolt 3, ami nekünk a 104.
Tehát a bal változó, amit itt látunk, x << y alapvetően x * 2 ^ y.
13 * 2 ^ 3, 2 ^ 3-8, így 13 * 8-104.
Ha csak gondol bináris általában, hogy az egyes szám,
ha elkezdjük a jobb, ez az 1-es helyen, majd a 2. helyét, akkor a 4-es helyére.
Tehát nyomva a 0-k a jobb
mi csak nyomja a dolgokat, amelyek a 4-es hely a 8-as helyen,
és a dolgok, amelyek a 8-as hely, hogy a 16. helyét.
Minden műszakban csak megsokszorozza 2. Igen?
[Diák] Mi történik, ha tolódott 5?
[Bowden] Ha tolódott 5 akkor csak veszíteni számjegy.
Elkerülhetetlen, hogy ez ugyanaz a dolog. Mint egész csak 32 bit,
Tehát, ha hozzá 2 igazán nagy egész, csak nem fér el egy egész szám.
Szóval ez ugyanaz a dolog itt. Ha tolódott 5,
mi lenne most elveszíti azt.
És ez az a fajta, amit gondolok a "durván"
ahol, ha váltás túl messze, akkor elveszíti bit.
>> JOBB SHIFT lesz az ellenkezőjét,
, hova megyünk, hogy dugjon 0-k ki a végét,
és céljainknak, töltse ki a 0-balról.
Tehát ezt, mi alapvetően megfordult, amit már megtette.
És azt látjuk, hogy a három 0-k jobb most esett le,
és már tolta a 1101 egészen jobbra.
Ez tesz 104 >> 3, amely hatékonyan, x / 2 ^ y.
Tehát most, itt, ez egy hasonló ötlet.
Miért van az, csak nagyjából x / 2 ^ y, és valójában nem x / 2 ^ y?
Mert ha én tolódott 4, elvesztettem volna 1.
Alapvetően, mit gondol, gondoljunk csak az egész osztás általában.
Tehát, mint 5/2 2 lehet. Ez nem 2.5.
Ez ugyanaz a gondolat itt. Ha elosztjuk 2-vel,
mi is elveszítjük páratlan bit az út mentén.
Tehát most - ennyi bitenkénti. Ez minden, amit tudnod kell.
Ne feledje, a használati esetek láttunk az osztályban,
mint egy kis maszk hasznos bitenkénti operátorok,
vagy használja őket kicsit maszkok.
Nagybetűk és kisbetűk, konverziók egy nagyon prototipikus példa.
>> Oké, buffer overflow támadások.
Bárki, aki emlékszik, mi volt a baj ezzel a funkcióval?
Figyeljük meg, hogy kijelentette, egy sor 12 byte, 12 karakter,
majd másoljuk be a puffer 12 karakter az egész szöveget bárban.
Akkor mi a probléma?
A bűvös 12-es szám meg eléggé, azonnal kiugrik az - miért 12?
Mi van, ha bár történetesen több, mint 12 karakter?
Mi van, ha bár több millió karaktereket?
Itt a kérdés memcpy. Ha bár elég hosszú,
akkor csak teljesen - a "c", "c" nem érdekli, hogy ez csak 12 karakter;
A "c" nem érdekli, hogy nem fér, hogy hány bájt.
Ez csak teljesen felülírja char, a 12 bájt már kiosztott rá,
és minden múltban a memóriában, hogy valójában nem tartozik a tárolóba
, bármilyen a húr bár.
Tehát ez volt az a kép láttunk az osztályban
ahol megvan a verem felnőni.
Meg kell használni ezeket a képeket, vagy megismerkedhet velük újra.
Megvan a stack nőnek fel, a memória címek 0-val kezdődnek, a felső
és a nő le, mint 4 milliárd az alján.
Megvan array "c" valahol a memóriában,
akkor mi van a mutató, bár jobb alatta,
és akkor mi van ez mentette frame mutatóra, a feladó címét, és a szülő rutin verem.
Ne feledje, mi a visszatérési cím?
Ez az, amikor fő meghív egy függvényt ize, meghív egy függvényt bár,
elkerülhetetlen, bár visszatér.
Tehát, amikor bár visszatér, tudniuk kell, hogy ez megy vissza az ize, hogy hívták.
Tehát a visszatérési címet a címe a funkció, hogy vissza kell térnie, amikor a függvény.
Ennek az az oka, hogy ez fontos a buffer overflow támadások, mert kényelmesen,
hackerek szeretné változtatni, hogy feladó címét.
Ahelyett, hogy megy vissza az ize, én megyek vissza oda a hacker akarja, hogy menjek vissza.
És, kényelmesen, ahol a hacker gyakran akar visszamenni
a kezdete a puffer, amit eredetileg.
Tehát észre, megint Little Indian.
A készülék egy példa egy kis indiai rendszer,
így az egész, vagy a mutató tárolja a bájt fordított.
Tehát itt látjuk - ez? Igen.
Látjuk Ox80, OxC0, Ox35, OxO8.
Ne feledje, a hexadecimális számjegy?
Nem fordított hexadecimális számjegyek Little Indian,
mert 2 hexadecimális számjegy teszik ki egyetlen byte, és fordított a bájt.
Ezért nem tárolja, mint 80530CO8.
Tároljuk helyett, egy pár 2 számjegy, kezdve a jobb oldalon.
Ez a cím utal a címre a start
a mi buffer, amit valójában akartam másolni be az első helyen.
Ennek az az oka, hogy ez hasznos, mert mi van, ha a támadó
történt, ahelyett, hogy egy sor, amely csak
egy ártalmatlan sor, mint a nevüket, vagy valami,
mi lenne, ha ahelyett, hogy a szöveg is csak néhány tetszőleges kód
hogy volt, amit akartak vele csinálni?
Így tudták - Nem tudok mondani olyan jó kódot.
Ez lehet bármi, mégis. Minden katasztrofális kódot.
Ha azt akarták, tudták csak tenni valamit szegmens hibák, de ez értelmetlen lenne.
Ők általában nem azt feltörni a rendszert.
>> Oké. CS50 könyvtár.
Ez alapvetően getInt, getString, mindazokat a funkciókat, amit biztosított az Ön számára.
Tehát char * karakterláncot, és ez az absztrakció, hogy elsöpörte
valamikor a félév során.
Ne feledje, hogy a szöveg csak egy sor karakter.
Tehát itt látunk egy rövidített változata getString.
Akkor nézd vissza, hogy ne feledje, hogy ez is megvalósul.
A legfontosabb részletek, észre kapunk egy-egy karaktert egy időben
A standard, amely olyan, mint mi adjuk ki a billentyűzetet.
Tehát egy karakter egy időben, és ha túl sok karaktert,
így ha n + 1-nél nagyobb kapacitású,
akkor meg kell növelni a kapacitását a puffer.
Tehát itt vagyunk megduplázza a méretét a puffer.
És ez megy tovább, mi be a karaktert a puffer
amíg nem kap egy új vonal vagy fájl vége, vagy bármi,
ebben az esetben, mi történik a húr, és akkor az igazi getString
zsugorodik a memóriát, mint ha mi juttatott túl sok memóriát megyek vissza, és csökken egy kicsit.
Tehát nem azt mutatják, hogy, de a fő gondolata az,
azt, hogy olvasni egy karaktert egy időben.
Nem csak olvasni egy egészet egyszerre,
mert a puffer csak egy bizonyos méretet.
Tehát, ha a húr, amely megpróbálja beilleszteni puffer túl nagy, akkor ez túlcsordul.
Tehát itt megakadályozza, hogy csak olvasott egyetlen karaktert
egy időben, és egyre nagyobb, amikor szükségünk van rá.
Így getInt a másik CS50 könyvtári funkciókat hajlanak arra, hogy getString
azok megvalósítása.
Szóval kiemelte a fontos dolgokat.
Felszólítja getString, hogy egy húr.
Ha getString nem tért vissza a memória,
ne feledjük, hogy getString mallocs valami, így ha hívja getString
akkor nem (érthetetlen), szabad, hogy a húr, amit kapott.
Tehát itt, ha nem malloc valamit, amit vissza INT_MAX, mint csak egy zászló, amely,
Hé, valójában nem voltak képesek, hogy egy egész szám.
Meg kell figyelmen kívül hagyni, amit én vissza hozzád, vagy
akkor nem kell kezelni ezt, mint egy érvényes bemenet.
Végül, feltételezve, hogy nem sikerült, az általunk használt sscanf, hogy a különleges zászló,
ami azt jelenti, hogy első meccsen az egész,
akkor illik egyik karakter után egész.
Így észre, azt akarjuk, hogy egyenlő 1.
Tehát sscanf vissza, hogy hány mérkőzés, ha sikeresen tette?
Vissza fog térni 1, ha sikeresen illeszkedik egy egész szám,
majd vissza 0, ha nem egyezik egész szám, és vissza fog térni 2
ha ez egy egész párosított majd néhány karakter.
Így észre, hogy újra, ha egyezik valami, de 1.
Tehát, ha léptünk 1, 2, 3, a C, vagy 1, 2, 3, X,
majd az 1, 2, 3 kapnánk tárolt egész szám,
X kapnánk tárolt a karakter,
sscanf visszatér 2, és mi újra, mert csak szeretne egy egész.
>> Gyorsan fúj a HTML, HTTP, CSS.
HyperText Markup Language szerkezetét és szemantikáját az interneten.
Itt a példa előadás, ahol már a HTML-címkéket.
Van fejét címkéket, test címke,
van példa az üres címkéket, ahol valójában nincs kezdő és záró tag,
már csak linket, és a kép.
Nincs záró kép tag, ott csak egy tag, amely megvalósítja mindazt, amit a címke kell tennie.
A link egy példa, majd nézze meg, hogyan hivatkoznak CSS,
A script egy példa arra, hogy hogyan hivatkoznak külső JavaScript.
Ez nagyon egyszerű, és ne feledd, a HTML nem programozási nyelv.
Itt emlékszem, hogyan határozná meg egy űrlapot, vagy legalábbis, hogy ez mit fog csinálni?
Ez a forma olyan cselekvés és a módszer.
A módszerek, akkor mindig csak látni a GET és a POST.
Úgyhogy az a változat, ahol a dolog kerül fel az URL-ben.
POST, ahol ez nem hozott a URL.
Ehelyett minden adatot a nyomtatvány egészül több rejtett a HTTP kérés.
Tehát itt, intézkedéseket határozza meg, ahol a HTTP kérés megy.
Ha megy a google.com / search.
Módszer. Ne feledje, a különbség a GET és a POST,
, és csak azt mondom példaként, ha azt szeretnénk, hogy könyvjelző valamit.
Ön soha nem lesz képes a kedvencei a POST URL
mivel az adatok nem szerepel az URL.
>> HTTP, most a HyperText Transfer Protocol.
A HyperText Transfer Protocol, akkor elvárják, hogy át
HyperText Markup Language, és ez.
De ez is át olyan képeket talál az interneten,
mindenféle letöltés csinál indul, mint egy HTTP kérés.
Tehát HTTP csak a nyelv a World Wide Web.
És itt meg kell ismerni ezt a fajta egy HTTP kérés.
Itt HTTP/1.1 az oldalon, csak azt mondja, hogy ez a verzió
A protokoll én használ.
Ez nagyjából mindig lesz HTTP/1.1, ahogy látni fogod.
Ekkor azt látjuk, hogy ez volt a GET, a másik, hogy POST, hogy lehet látni.
És az URL-t, hogy akartam látogatás www.google.com/search?q = bla, bla, bla.
Úgy emlékszem, hogy ez, a kérdőjel q = bla-bla-bla,
az a fajta dolog, hogy nyújtja be a formában.
A válasz talán visszatér hozzám fog kinézni.
Ismét, kezdve a protokoll, ami lesz, hogy a
majd az állapot kódot. Itt van 200 OK.
És végül, az internetes oldalt, hogy én valóban kértem követi.
A lehetséges állapot kódot lehet látni, és tudnia kell, többen.
200 OK akkor valószínűleg látott.
403 Forbidden, 404 Not Found, 500 Internal Server Error
általában, ha elmész egy honlapon, és valami elromlott vagy PHP kódot összeomlik,
míg a készülék van, hogy a nagy narancssárga doboz
hogy jön, és azt mondja, mint valami rossz, ez a kód nem működik
vagy ez a funkció rossz.
Általában honlap nem akarom, hogy tudja, milyen funkciókat valóban rossz,
Tehát ahelyett, hogy ők majd csak kapsz 500 Internal Server hibák.
>> TCP / IP 1 réteg alatt HTTP.
Ne feledje, hogy az interneten kívül a World Wide Web.
Mint ha játszani egy online játék, amely nem megy át HTTP,
ez megy keresztül a másik -, hogy még mindig az internet,
de nem használ HTTP.
HTTP csak egy példa a protokoll épülő TCP / IP.
IP szó szerint azt jelenti Internet Protocol.
Minden számítógépnek van IP-címe, ezek a 4 számjegyű dolgokat
mint a 192.168.2.1, vagy bármi más, hogy inkább legyen egy helyi.
De ez a minta az IP-cím.
Tehát a DNS, Domain Name Service,
ez az, ami lefordítja a dolgokat, mint a google.com a tényleges IP-címet.
Tehát, ha azt írja, hogy az IP-címet egy URL-t,
hogy hozna, hogy a Google, de inkább nem emlékszem ezeket a dolgokat.
Meg inkább emlékezni google.com helyett.
Az utolsó dolog, amit meg a port, ahol ez a TCP része az IP.
TCP nem több. Gondolj, mondjuk, akkor a böngésző fut.
Lehet, hogy néhány e-mail alkalmazás fut;
lehet, hogy egy másik program, amely az interneten fut.
Mindannyian kell az internet-hozzáférést,
, de a számítógép csak 1 WiFi kártya vagy bármi.
Tehát port az is, hogy képesek vagyunk, hogy osszuk el
hogy ezek az alkalmazások képesek használni az internetet.
Minden alkalmazás kap 1 speciális port, hogy képes hallgatni,
és alapértelmezés szerint a HTTP-as portot használja a 80.
Egyes e-mail szolgáltatások használata 25.
Az alacsony sorszámú is hajlamosak fenntartva.
Ön általában tudja, hogy a magasabb számozású is magad.
>> CSS, Cascading Style Sheets.
Mi stílus weboldalak CSS, nem HTML.
Jelenleg 3 helyen akkor tegye a CSS.
Ez lehet egyenes, a stílus címkéket, vagy egy teljesen különálló fájlt, majd kapcsolódik be
És itt csak egy példa a CSS.
Meg kell ismerni ezt a mintát,
ahol az első példa a mi felel a body tag,
és itt mi központosító a body tag.
A második példa, mi az a dolog illő
azonosító lábléc, és mi alkalmazása néhány stílusok, hogy.
Figyeljük meg, hogy ID lábléc szöveg igazodik a bal oldalon,
míg a szövegtörzs-igazítja központ.
Lábléc a testben.
Ez helyett, text-align maradt, annak ellenére, hogy a test szerint text-align center.
Ez az egész kaszkád része.
Akkor lehet - megadhatja stílusok a test,
majd a dolgok a szervezetben megadhatja konkrétabb stílus,
és működnek a dolgok, mint ahogy várnánk.
Konkrétabb CSS specifikációk az elsőbbséget.
Azt hiszem, ez az.
>> [Ali Nahm] Szia mindenkinek. Ha tudtam csak, hogy a figyelmet.
Én vagyok, Ali és én megyek keresztül, PHP és SQL nagyon gyors.
Így el tudjuk kezdeni. PHP rövid a PHP: Hypertext Preprocessor.
És mint minden tudnia kell, hogy ez egy szerver-oldali programozási nyelv,
és használja a hátsó weboldalak,
és hogyan csinál sok a számítások, a mögött színfalak rész.
Syntax. Ez nem olyan, mint a C, micsoda meglepetés.
Mindig meg kell kezdeni az, ha látod, a - nem tudok előrehaladni.
Láthatjuk, hogy szükség van az új típusú fogszabályozó és akkor is szükség van az? Php.
Ez mindig, hogy hogyan kell a keret a PHP szöveget, a PHP kódot.
Így nem csak, mint a C, ahol ilyen tedd az első.
Meg kell, hogy mindig körül azt.
És most, a fő szintaxis hogy minden változót kell kezdeni a $ karaktert.
Meg kell csinálni, ha éppen meghatározásakor őket, meg kell csinálni
ha utalsz, hogy őket később.
Mindig kell, hogy a $. Ez az új legjobb barátja, elég sok.
Nem - ellentétben a C, akkor nem kell, hogy milyen típusú változót is.
Tehát amíg szükséged van a $, akkor nem kell tenni, mint a,
int x vagy string y, satöbbi, satöbbi.
Tehát egy kis különbség.
Ennek eredményeként a, az azt jelenti, hogy a PHP egy gyengén típusát.
A PHP egy gyengén típusú nyelv, és ez gyengén gépelt változókat.
Más szavakkal ez azt jelenti, hogy meg lehet váltani a különböző változó típusok.
Tárolhatja az 1, mint egy int,
lehet tárolni, mint egy húr, és akkor tárolja, mint a float,
és ez mind az, hogy 1-es szám.
Annak ellenére, hogy te tárolja a különböző formák,
még mindig - a változó típusok még mindig tartja a végén.
Tehát, ha meg itt, ha emlékszel a Pset 7,
Sokan talán már kérdés ezzel.
Két azonos jelek, 3 egyenlő jelek, 4 egyenlő jeleket.
Jól van, de nincsenek 4 egyenlő jelek, de vannak a 2. és 3..
Használja 2. azonos jeleket, hogy ellenőrizze az értékeket.
Meg tudja nézni az egész típusok.
Tehát, ha látod az első példa,
Van num_int == num_string.
Tehát az int, és a húr egyaránt, technikailag, 1,
de ők különböző típusú. De a két egyenlő, akkor az még át.
Ahhoz azonban, hogy a hármas egyenlők, ellenőrzi érték, valamint a különböző típusú.
Ez azt jelenti, hogy ez nem fog múlni, hogy a második esetben is,
hová a 3 egyenlő jelek helyett.
Szóval ez egy nagy különbség, hogy érdemes minden kimutatták már.
>> Karakterlánc összefűzés egy másik hatékony dolog, amit lehet használni a PHP.
Ez alapvetően csak a praktikus dot jelöléssel,
és ez hogyan lehet kötni húrok együtt.
Tehát ha Cat és van kutya, és azt szeretné, hogy a 2. húrok együtt,
akkor az idő, és ez a fajta, hogyan működik.
Akkor is csak tegyük őket egymás mellé,
mint látható itt az alsó példában,
ahol már echo karakterlánc 1, hely húr 2..
PHP tudni fogja helyettesíteni ezeket.
Tömbök. Most, PHP, van 2 különböző tömbök.
Lehet rendszeres tömbök, és akkor is asszociatív tömbök,
és fogunk menni rajtuk keresztül most.
A rendszeres tömbök csak ez a C-ben
és így van indexek meg vannak számlálva.
Most mi csak létre fog hozni egy és fel -
Szóval így hozunk létre egy üres tömböt, aztán megyünk
helyezni a indexszám 0-ra.
Megyünk, hogy a 6-os szám, az érték 6.
Láthatjuk, hogy az alján van.
Where's - az index 1-es szám fogunk tenni érték 4-es számú,
és így láthatja, van egy 6, van egy 4,
aztán ahogy mi nyomtatás dolgokat,
amikor megpróbálja kinyomtatni a tárolt érték az index 0,
aztán majd meglátjuk az értéket 6 kinyomtatását. Cool?
Szóval ez a rendszeres tömbök neked.
Egy másik módja, akkor is hozzá dolgokat rendszeres tömbök már
az, ha csak akkor fűzze őket a végén.
Ez azt jelenti, hogy nem kell megadni az adott index.
Láthatjuk számot, majd a szögletes zárójelben nincs index megadva.
És akkor tudni fogja, hogy - PHP tudni fogja, hogy csak hozzá, hogy a végén a lista, a következő szabad helyet.
Így láthatjuk a 1. ott azon a 0 helyen,
2 ment ott az első helyen.
A 3 megy - egészül ki ott is.
Tehát ez a fajta van értelme. Te csak mindig hozzátéve, hogy,
és amikor mi visszhangzó indexe 1-es szám,
kiírja az érték 2.
>> Aztán ott van a tömbök, amelyek asszociatív tömbök.
Az asszociatív tömbök, ahelyett, hogy a numerikus indexek
mit csinálnak az, hogy vannak indexek, amelyek a húr.
Láthatjuk, ahelyett, hogy - megszabadultam az összes ilyen szám indexek
és most ez kulcs1, key2, KEY3, és ők idézőjelek, jelezve, hogy ők mind szálakat.
Tehát mi is van egy példa erre.
A példa erre az, hogy mi van a tf, és ez az index nevét.
Megyünk, hogy "Ali", mint a neve, az index, kalória evett,
tudunk rakni egy int ezúttal helyett egy string,
, majd az index embernek tetszik, tudunk rakni egy egész sor belsejébe.
Tehát ez a fajta - ez egy hasonló fogalom, hogy hogyan kellett
indexek számokat, de most már meg tudjuk változtatni az indexek körül
hogy azokat húrok helyett.
Megteheti ezt, emellett csak csinálja külön-külön,
meg tudod csinálni mindezt egy darab. Így láthatjuk, hogy a TF az, hogy tömb,
aztán mi meg őket egy hatalmas szögletes zárójel készlet.
Annak érdekében, hogy képes gyorsítsák fel a dolgokat.
Ez inkább stilisztikai választás, mint nem.
Mi is hurkok.
A C-ben van hurkok, hogy a munka, mint ez.
Mi volt a sor, és mentünk a mutató 0 és a végén a lista,
és nyomtassa ki az egészet, igaz?
Kivéve, hogy a probléma az, hogy az asszociatív tömbök,
nem feltétlenül ismeri azokat a számszerű mutatók
mert most már a string indexeket.
Most használd foreach hurok, ami megint, akkor remélhetőleg használt Pset 7.
Foreach hurok is csak azt tudom, minden egyes része a lista.
És nem kell tudni, hogy pontosan a numerikus index, hogy van.
Szóval a foreach szintaxis, így foreach, akkor tegye a tömb.
Szóval a tömb neve Pset, majd ahogy a szót,
és akkor, hogy ezt a helyi ideiglenes változó, hogy fogsz használni
csak az adott dolog, ami fog tartani az adott -
egy példányát vagy egy szakasz a tömb.
Pset num tart 1, és akkor talán tartalmazza majd a 6-os szám,
és akkor tartsa a 2-es szám.
De ez biztos, hogy menjen át minden egyes értéket, ami a tömbben.
Hasznos funkció, amit tudnia kell a PHP az szükséges,
így gondoskodik arról, hogy te, beleértve bizonyos fájlokat, echo, kilépés, üres.
Azt ajánlom, nézd meg Pset 7, és nézd meg ezeket a funkciókat.
Lehet, hogy ismeri azokat,
úgyhogy biztosan tudni, hogy mi, pontosan, ezek mind csinálnak.
>> Most fogunk átmenni köre nagyon gyorsan.
A kör, PHP egyfajta funky dolog, ellentétben a C,
és így mi csak menni rajta gyorsan.
Mondjuk kezdjük abban nyíllal, hogy mi van ott.
És meg fogjuk kezdeni $ i. Tehát a változó "i" lesz 0,
és mi csak fog tartani nyomtatást azt, hogy a nagy fehér doboz ott.
Fogunk kezdeni I0, aztán megyünk echo azt.
Tehát ott van a 0-ra.
És akkor mi lesz, hogy megnöveljük a for ciklus,
és akkor lesz 1 értéket.
Az egyik kisebb, mint 3, így fog át, hogy a hurok,
majd fogjuk látni, hogy a nyomtatott újra.
Fogunk megnöveljük ismét 2
és 2 kisebb, mint 3, így kihagyom a for ciklus, és akkor nyomtassa ki a 2..
Akkor vegye figyelembe, hogy 3 nem kevesebb, mint 3, így fogunk törni a for ciklus.
Tehát most már kilépett, majd fogunk menni aFunction.
Oké. Így kell megjegyezni, hogy ez a változó, amit létrehoztunk,
Az "i" változó, nem helyi távcsöves.
Ez azt jelenti, hogy nem a helyi hurok,
és a változó még ma is hozzáférhet és módosíthatja utána, és akkor is hatékony legyen.
Tehát, ha bemegy a funkciót most, látni fogja, hogy mi is használjuk az "i" változó,
és mi lesz növekmény 'i' + +.
Azt hiszem, az első, amely a C, hogy ez egy példányt a "i" változó.
Ez egy teljesen más dolog, ami helyes.
Tehát, ha nyomtatni fogunk nyomtatni 'i' + +, ami megy, hogy nyomtassa ki, hogy a 4,
aztán megyünk - sajnálom.
Aztán mi lesz a vége, ki ezt a funkciót,
és mi lesz, ha ez a nyíl van most.
Ez azt jelenti, hogy akkor, ugyanakkor, bár a funkció megváltoztatta az értéke "i",
ez nem változott a függvényen kívülre,
mert a funkció egy külön köre.
Ez azt jelenti, hogy ha echo "i", nem változott a funkció hatáskörének,
így aztán megyünk nyomtatni 3. újra.
A különböző dolog köre a PHP, mint a C-
>> Most a PHP és a HTML.
PHP használják, hogy a weboldalak dinamikus.
Ez a fajta teszi a dolgokat más.
Van különbözik a HTML.
A HTML, mindig csak ugyanaz a statikus dolog, mint például, hogy Rob azt mutatták,
míg a PHP, meg tudod változtatni a dolgokat alapján, hogy ki a felhasználó.
Tehát, ha én ezt, én, "Te néven jelentkezett be -", majd a nevét,
és meg tudom változtatni a nevet. Tehát most a neve Joseph,
és ez a "rólam", de akkor én is megváltoztathatja a nevét, hogy Tommy.
És lenne egy másik dolog.
Így akkor is megváltoztathatja a különböző dolgokat róla,
és megmutatja a különböző tartalmak neve alapján.
Így PHP fajta változás, mi folyik a honlapon.
Ugyanaz itt. Mégis, vegye figyelembe, hogy a különböző tartalmak,
még ha technikailag még hozzáférését, hogy ugyanaz a weboldal a felszínen.
Generálása HTML. Vannak 2 különböző módon lehet csinálni.
Akkor megyünk át, hogy most. Az első módszer, akkor - igen, sajnálom.
Szóval csak a szokásos for ciklus a PHP-ben,
és akkor visszhang a PHP és visszhang ki a HTML.
A mi Rob mutattam a HTML script
és akkor használja a PHP print, hogy csak nyomtassa ki a weboldal.
A másik út az, hogy nem, mint ha külön ki a PHP és a HTML.
Szóval lehet, hogy egy sor PHP, amely elindítja a for ciklus,
akkor lehet, hogy a vonal a HTML egy külön dolog,
és akkor a végén a hurok, ismét, a PHP.
Szóval ez a fajta elválasztó ki.
A bal oldalon, lehet, hogy már az összes -
ez csak 1 darab PHP.
A jobb oldalon látható, hogy van egy sor PHP,
van egy sor HTML, és van egy sor PHP újra.
Így elkülönítve azt ki, mit csinálnak.
És akkor vegye figyelembe, hogy akár így, akár őket,
még mindig nyomtassa ki a képet, a kép, a kép,
úgy, hogy még mindig van nyomtatva a HTML ugyanúgy.
És akkor még mindig látni a 3 kép jelenik meg a honlapon.
Tehát 2 különböző módon ugyanazt a dolgot.
>> Most formák és kéréseket. Ahogy Rob mutattam,
Vannak formák HTML, és mi csak szellő ezen.
Van egy akció, és van egy módszer, és a műveletet
fajta megmutatja, hol fogsz küldeni, és a módszer az, hogy
ez lesz a GET vagy POST.
És egy GET kérést, mint Rob azt mondta, azt jelenti, hogy fogsz, hogy azt olyan formában
és akkor látni, mint egy URL-t, míg a POST kérést nem jelenik meg egy URL-t.
Tehát egy kis különbség.
Azonban egy dolog, hogy egy hasonló dolog
az, hogy a POST és GET egyaránt bizonytalan.
Szóval, azt gondolhatja, hogy csak azért, mert nem látja, hogy az URL-ben,
azt jelenti, hogy a POST biztonságosabb,
de még mindig látni a cookie-kat, hogy milyen adatokat küldünk.
Tehát nem hiszem, hogy az egyik vagy a másik.
A másik figyelemre méltó dolog az, hogy te is részt változókat.
Ti használta ezt a Pset 7, hogy a felhasználói azonosítóját.
Az történt, hogy akkor használja ezt asszociatív tömb,
A $ _SESSION, és akkor vagyunk képesek elérni a különböző dolgokat
és tárolja a különböző dolgokat az egész oldalt.
>> Utolsó dolog, hogy van SQL Structured Query Language,
és ez a programozási nyelv kezelni adatbázisokat.
Pontosan mit, van adatbázis? Ők gyűjtemények asztalok,
és az egyes táblák esetében is hasonló jellegű tárgyakat.
Tehát volt egy tábla a felhasználók a pénzügyi Pset.
És miért vannak hasznos? Mert ez egy módja annak, tartósan tárolja az adatokat.
Ez egy módja nyomon dolgok és kezelése a dolgokat
és valóban látta, hogy a különböző oldalak és nyomon követése.
Míg ha csak tárolja azt, hogy az ember közvetlen pillanatban
majd később, akkor nem fogja tudni elérni semmit, mentette.
Jelenleg 4 legfontosabb dolog, hogy használjuk az SQL parancsokat.
Van SELECT, INSERT, törlése és frissítése.
Ezek nagyon fontos, ha tudnátok, a kvíz.
>> Majd gyorsan átvesszük válassza most.
Alapvetően, akkor kiválasztja sorokat egy adatbázisban.
Tehát, ha van, itt -
van a 2 különböző dolgokat, és azt akarjuk, hogy válasszon az osztályok táblázat
ahol félelmetes - ahol a félelmetes oszlop az érték 1.
Tehát itt is látszik, van ezeket a 2 dolog az osztály nevét,
CS50 és Stat110, és mi van az osztály azonosítók és a szlogen.
Tehát szeretnénk válassza ki az összes információt.
Akkor láthatod itt, hogy ez a fajta szedés ki, hogy a félelmetes oszlop,
ahol minden dolog 1, majd azt a class azonosító, osztály nevét és a szlogen, hogy vedd ki.
Pontosan hogyan csinálod ezt a kódot? Ki kell használni a PHP.
Tehát ez a fajta, hogy a PHP és SQL kapcsolódnak egymáshoz.
Most a kódot, és fogjuk használni a lekérdezés funkció
ahogy tettük Pset 7, és mi fog futni az SQL lekérdezést.
Aztán mi lesz, hogy -
mindig kell ellenőrizni, ha sor hármas egyenlő, ha hamis.
Tehát még egyszer, azt szeretné, hogy ellenőrizze a típusát és értékét,
és ha ez nem működik, akkor azt szeretné, hogy bocsánatot kérjen, mint mindig, mint mi a Pset 7.
Ellenkező esetben azt szeretnénk, hogy hurok segítségével mindent azokkal praktikus
foreach hurok, hogy most ment át.
Most, hogy a ciklusok keresztül, és már tette korábban,
tegyük fel, hogy a lekérdezési eltelt, most már a foreach ciklus.
És az első sorban van, így itt a sorban, itt van, ez dobozos.
Ez lesz, hogy nyomtassa ki az összes információt, hogy ütött.
Ezért van, hogy nyomtassa ki az alján "Wanna Learn HTML-t?"
Akkor fog menni a következő sorban, mert elkészült az első for ciklus,
és így aztán ez megy, hogy nyomtassa ki a második sorban is,
ami lesz STAT110, megtalálja a pillanatokat.
>> Még egy utolsó dolog, SQL sérülékenység.
Tudom, hogy David érintette ezt egy kicsit az előadás.
Elolvashatja később. Ez tényleg vicces.
SQL Injection egyfajta trükkös dolog.
Tegyük fel, hogy csak tartsa azokat a változókat jobbra a lekérdezés,
ahogy látható, hogy az első sorban.
Tehát úgy tűnik rendben van, igaz? Te csak egy olyan, a felhasználó nevét
és jelszót az SQL lekérdezést, és azt szeretné, hogy a hajó ki és kap mindent ami az adatok táblázatban.
Úgy tűnik, elég egyszerű. Tehát mondjuk valaki tesz be,
a jelszót, ezt vagy szöveg itt -
kell ténylegesen a piros doboz.
Tehát mondjuk, hogy tegye, hogy a jelszót - ez az, amit meg.
Így ők üzembe vagy "1" = 1.
Egyfajta ostoba jelszó van.
Most csak cserélje ki az, és akkor vegye figyelembe, hogy az adott SQL lekérdezést most,
értékeli, hogy mindig igaz, mert akkor vegye figyelembe, hogy
tudod SQL query jelölje mindezt az információt
vagy ha csak 1 = 1.
Annak érdekében, hogy mindig lesz, hogy értékelje az igazi.
Ez nem fog igazán működni, mert ez azt jelenti, hogy a hacker betörni a rendszerbe.
A megoldás erre az, hogy van, hogy az OEM-rendszer,
ami azt jelenti, hogy kell használni kérdőjelek,
melyik az, amit a srácok használnak Pset 7,
hol akarsz használni egy kérdőjel helyett, ahol el kívánja helyezni valamit,
és akkor fogsz, hogy egy vesszőt, és akkor lesz utána,
után a húr, a különböző változók kívánt cserélni be a kérdőjel.
Tehát akkor itt megjegyezni, hogy most ezeket a piros kérdőjel.
Aztán fel a változókat, miután a húrok, így tudom, hogy cserélje ki ebben a sorrendben utána.
Ez biztosítja, hogy ha valaki nem úgy, mint ez,
és nekik van a vagy 1 = 1 a helyzet, hogy győződjön meg róla,
a hátsó végén, győződjön meg róla, hogy ez valójában nem törik az SQL lekérdezést.
Oké, szóval nagyjából azt, a forgószél a PHP és SQL.
Sok szerencsét mindenkinek, és most, hogy Oregon
>> [Oreoluwatomiwa Babarinsa] Oké mindenkinek. Ideje menni át néhány JavaScript
és néhány más dolog, nagyon gyorsan, így nem tartja fel ma este.
JavaScript. Igen. JavaScript egyfajta klassz dolog, állítólag.
A dolog, amit igazán tudni kell JavaScript, ez a fajta, mint
a kliens-oldali végén, amit a web app fog csinálni.
Van néhány dolog, amit csak nem akarom, hogy vigyázzon az egész idő alatt a szerver oldalon.
Minden kis kölcsönhatások, kiemelve egy dolog, hogy valami eltűnik.
Tényleg nem akarom, hogy beszélni, hogy a szerver minden ideje.
És bizonyos, hogy ez nem is lehetséges, hogy a szerver oldalon.
Ezért kell valami, mint a JavaScript.
Cool dolog JavaScript: A dinamikusan típusos.
Ez azt jelenti, hogy a program nem kell tudni
mit, pontosan, a változók, ha írsz ki.
Ez lesz csak egyfajta kitalálni, mint fut.
Más dolog, hogy jó róla: Ez egy zárójel nyelv,
ami azt jelenti, a szintaxis hasonló a C és a PHP.
Nem kell sokat utómunka, ha tanulunk a JavaScript.
Itt van egy kis JavaScript.
Érdekes dolog itt az, hogy ha megnézzük azt,
van egy kis JavaScript ott a head tag.
Mi ez alapvetően csak magában a JavaScript fájlt.
Ez az egyik módja, akkor is a JavaScriptet a programba.
Aztán a második kicsit valóban néhány inline JavaScript,
nagyon hasonlít egy inline stílus CSS,
és te csak írásban egy kódot nagyon gyorsan ott.
JavaScript tömbök.
Csak egy újabb módja annak, hogy az adatok körül, nagyon hasznos.
Nagyon szép és egyszerű szintaxis.
A szögletes zárójelek eléréséhez mindent, és folyamatosan mindent együtt.
Semmi sem túl bonyolult.
A hűvös dolog JavaScript és script nyelvek általában
az, hogy nem kell aggódnia, array méretben.
Lehet csak használni array.length és nyomon követi azt,
valamint a tömb növekszik vagy csökken, ahogy szükség van rá.
Szóval nem is kell aggódnod a fajta,
Ó, nem, azt kell, hogy fordítsanak több dolgot, vagy ilyesmi.
>> A jó dolog az, hogy a javascript úgynevezett tárgyakat.
Ez egy objektum-orientált nyelv, akkor mi azt is, lényegében,
a módját, hogy csoportos adatokat együtt, némileg hasonló a struktúra,
de lehet hozzáférni, mint egy struct vagy egy asszociatív tömb szintaxist.
Elég egyszerű, és mit lehet csinálni ezzel az csoportadatokat együtt
ha van egy csomó adat, ami kapcsolódik.
Mert ez a dolog, amit szükséges egy olyan autót,
akkor nem kell, hogy ez egy csomó különböző helyeken.
Lehet csak kibír be 1 objektum JavaScript.
Mint azt bizonyára tudják, iterációjával egyike azoknak unalmas feladatokat.
Csak csináld több mint egy újra. Meg kell beszélni, hogy minden tárgy az autóban,
vagy meg kell, hogy menjen át minden elem egy listában, vagy valami ilyesmi.
Tehát JavaScript is, hasonlóan a PHP, a foreach szintaxis.
Ebben az esetben ez egy a hurok.
Ha szeretné használni ezt csak a tárgyakat.
Vannak problémák fordulhatnak elő, ha ezt a tömböt.
Ez általában az egyik olyan dolog, mégis, ez nagyon hasznos,
mert megszünteti a sok felső
mert nem kell, hogy húzza fel mindent az objektumot egyedül.
Nem kell emlékezni az összes kulcsfontosságú neveket.
Csak valami, hogy vissza ebben a szintaxis.
Ebben, és az, csak azt, hogy emlékezni
hogy kapsz vissza a kulcsokat, egy nagyon hasonló módon hash tábla.
Ha emlékszel attól, ha hozna egy string is kaphat valamit
volna, hogy a társult értéket vele.
Mit lehet tenni ez akkor azt mondják, rendben,
Tettem egy autó, és hívtam, hogy egy Ferrari.
Így tesz a karakterlánc Ferrari később újra, és lehet kapni, hogy ki.
És meg tudod csinálni, hogy a hurok, az a hurok.
Tehát csak többet tárgyakat. A legfontosabb dolog e, meg kell emlékezni
az, hogy tudod használni az objektumot struct hasonló szintaxist, amikor csak akar ezekkel,
kivéve, ha az fog használni, mint a karakterlánc nem érvényes változó neve.
Tehát, ha megnézzük, hogy van, hogy van kulcs terek.
Nos, ha úgy döntesz, hogy tegye object.key, a tér, és, tér, terek,
hogy csak nem lenne értelme szintaktikailag.
Szóval csak lehet csinálni, hogy ez a fajta zárójeles formával.
>> Szintén JavaScript nagyon hatály-bölcs a PHP.
Van 2 módon kezelésének hatálya alá.
Nem lehet, hogy a var előtt egy változó,
és ez csak azt jelenti, hogy ez a globális.
Láthatjuk, hogy bárhonnan. Akkor is, ha úgy döntesz, hogy ezt egy if,
bárhol máshol a kódot, miután ezen a ponton lehetett látni, hogy a változó.
A másik dolog, mégis, a var, akkor korlátozott, amit a funkció éppen be
Ha nem a funkció, nos, ez a globális.
De ha van egy funkció, hogy ez csak akkor látható, ezen belül a funkciót.
Én nem egy példa, de igen. Ez az egyik olyan dolog, ahol
tudja kezelni, amit változókat akarsz lenni a globális,
milyen változókat akarsz lenni a helyi, de nem kell, hogy legyen óvatos erről,
mert nem az a fajta finomszemcsés szabályozás csinálsz C,
ahol, ha valami bejelentett egy for ciklus, ez meg fog maradni, hogy a hurok.
A dolog, amit valóban törődnek a JavaScript-et manipulálni weboldalakat, ugye?
Úgy értem, hogy ez miért csináljuk ezt.
>> Ehhez használjuk úgynevezett a DOM.
A Document Object Model.
Alapvetően, mit csinál ez mindent visz a HTML
és modellek ki egy csomó objektumok egymásba ágyazott.
Ha elindul valami ilyesmi.
Van, a jó nekem, egy csomó kód arra nézve, hogy ez a fajta -
Azt gondolom, hogy lenne nagyon nehéz manipulálni,
mert akkor lenne elemzés egy csomó szöveget
és miután a darab egymástól a dolgokat. És mi van, ha nem megfelelően formázott?
Rossz dolgok történnek.
Tehát JavaScript gondoskodik ezt neked, és kapsz egy szép adatstruktúra,
mint az egy a bal oldalamon, ahol csak egy dokumentumot,
és benne, hogy van valami úgynevezett HTML,
és belül, hogy van a fej és a test,
és belül, hogy a fejét már egy címet, satöbbi, satöbbi, satöbbi.
Ez leegyszerűsíti manipulálni egy internetes oldalt, hogy ez csak,
Ó, én csak azt szeretném, hogy beszélni ezt az objektumot.
Valahogy nagyon hasonló módon szeretnél beszélni egy másik objektumot te készítetted.
Mint mondtam, a DOM van a document objektum.
Vagy ez csak egy helyen, és akkor mehet benne, hogy a dolgok,
és meg tudod csinálni - ez a régi stílusú csinálja, ott,
ahol te document.getElementById, majd a nevét,
és akkor talán mondani, ez mindig nagyon nehézkes egy idő után.
Szóval, akkor valószínűleg nem akarom. Ezért van
A következő dolog, fogunk beszélni után.
A legfontosabb dolog az, hogy minden rendben, akkor ezek az elemek, nem igaz?
Így talán meg tudom változtatni a színét a valamit, amikor az oldal betöltődik.
Akkor mi? Mi történik, ha a felhasználó rákattint valamit?
Azt akarom, hogy valami érdekes, ha rákattintanak valamit.
Ezért van eseményeket.
Ön alapvetően talál eleme a DOM,
majd azt mondják, hé. Amikor ez betölti vagy valaki rákattint,
vagy akkor, amikor az egér fölé, vele valamit.
És mi van az, hogy olyan funkciók, amelyek kezelik ezt neked.
Ezek a funkciók eseménykezelőt.
Mi tetlen - ez csak egy divatos szóval,
Ez a funkció csak akkor hajtódik végre, ha az esemény megtörténik.
Így kezeli az esetre, ha bekövetkezik.
Így akkor feküdt ki egy eseménykezelő.
Van néhány gomb, és ha rákattint, akkor felrobban.
Tehát ne kattintson a gombra.
Ez az egyik módja a közeledő, igaz?
Van egy gomb tag, és kattintásra van egy sor, amely azt mondja,
Ja, mellesleg én ezt robbanó dolog számomra.
Egyébként, ez csak, mint egy hagyományos gomb csak sor.
Megteheti ezt egy másik módja,
a rángatás a DOM elem, de majd menteni, hogy miután beszélünk jQuery.
>> JQuery: Ez egy olyan könyvtár, amely cross-browser.
Használhatja a nagyjából semmit.
És ez csak ad egy csomó eszköz dolgozni.
Mivel a JavaScript, míg erős, nem rendelkezik az összes szükséges eszközöket
ki a dobozt, hogy valóban kezelni a web app érdemes csinálni.
Tehát ez leegyszerűsíti egy csomó dolgot, ad egy csomó funkció
ki a dobozból, amit egyébként meg kell írni magát, újra és újra és újra.
És csak teszi a dolgokat nagyon egyszerű.
Arra is van szelektor, amelyek segítségével vegye ki az összes olyan elemet,
az Ön DOM sokkal egyszerűbben, ahelyett, hogy ezeket a nagyon hosszú függvényhívás.
Bővebben ezekről a választók. Van, ott akkor, mondjuk
Azt szeretnénk, hogy egy elem az ID "rock".
Nos, jQuery, ez csak $, majd egy string, amely egy font, majd a "rock".
Ez nagyon egyszerű, és sokkal gyorsabb, mint a hagyományos JavaScript módja a probléma megoldásában.
És hasonló dolgokat osztályok és elemek típusok.
jQuery - az egyik nagyszerű tulajdonsága az, akkor valami tömöríteni
le a lekérdezéseket a DOM nagyon, nagyon gyors.
Most már vissza eseménykezelés, és ez az, hogy hogyan kellene kezelni egy esemény jQuery.
Szóval, mit fogunk itt azt mondjuk, rendben. Van egy script tag, nem igaz?
Szóval van ez a inline JavaScript.
Mit fogunk tenni az fogjuk mondani, minden rendben.
Ha a dokumentum elkészült, ami azt jelenti, a dokumentum betöltődött,
fogunk menni, hogy ezt a funkciót, és meg fogjuk mondani, rendben,
Ez a funkció valójában valami mást csinál.
Ez alapvetően azt mondja, rendben van, hogy nekem az elemet az ID "MyID."
És akkor, hogy ez egy funkciót kezelőt, amely végrehajtja ha rákattint.
Alapvetően Mi ez, azt mondja, minden rendben.
Az oldal betöltésekor, úgyhogy megyek az, meg ez az elem,
hogy ez az esemény kezelő, és alapvetően beállítja az oldal az Ön számára.
És ez hogyan akarok gondolni eseménykezelés.
Csak azt akarom gondolni, minden rendben, ha valami történik, amit akarok, hogy megtörténjen?
Nem akarok gondolni, oké, azt kell, hogy győződjön meg róla, ez a dolog beszél ez a dolog,
ez a dolog, bla-bla-bla, mert csak azt, hogy beszélni dolog, tekintve az események.
Amikor ez megtörténik, ez történik. Amikor ez történik, ami történik.
És ha a dolgok kiváltó más dolog, ez nagyszerű.
De te nem akarod próbálni, és nem bonyolult kód
hová kiváltó több dolgot egyszerre,
mert csak most fog adni magadnak a fejem.
>> Rendben. Most már tudjuk, hogy a lap kezelni az eseményeket,
de mondjuk a felhasználó egy gombra kattint.
Mit tegyek, ha szeretné küldeni a kérelmet vissza a szerver,
de nem akarom, hogy újra az oldalt, mert miután újratölteni egy új oldalt
minden egyes alkalommal kap elég fárasztó, és miért van szükség
, hogy húzza le a fejléc újra, és a lábléc újra
és minden eleme az oldal újra
csak azért, hogy frissíteni kell az üdvözlés vagy az idő?
Tehát ezért van valami hasonló Ajax.
Mit tehetünk itt Ajax mondhatjuk, rendben,
Szeretném küldeni néhány adatot a szerverre,
és azt szeretné, hogy egy választ, így tudom frissíteni az oldalam,
vagy talán csak némi algoritmikus számítás nem feltétlenül mutat semmit a felhasználónak.
Mit kell tenni? Nos, meg kell egy URL-t meg kell beszélni.
A szerver nem csak varázsütésre hallgatni a semmiből.
Be kell, hogy egy adott hely, akkor küldjük az adatokat.
És akkor is kell néhány adatot küldeni, vagy talán ez egy dataless lekérdezést.
Azt akarod, hogy ping vissza a szerverre, és azt mondják, hé, én élek, vagy valami ilyesmi.
És akkor azt szeretné, hogy a funkció alapvetően kezeli sikerrel.
Tegyük fel, hogy vissza bizonyos információkat a szerver,
és meg akarja változtatni a felhasználó címét a saját oldalon.
Így kap az adatokat vissza,
és akkor nyomja meg, hogy a képernyőre.
Mi történik, ha az oldal készen áll,
létrehoz egy kattintásra funkció ezt a gombot az úgynevezett üdvözlő.
Mi ez, akkor nem az, ha ez a gomb megnyomása
beszélsz greetings.php, csinál egy POST kérést,
és azt mondod, hé, hozz nekem valamit az oldalon.
Nem igazán kell leírni, de greetings.php,
mondjuk, adja vissza "hello world".
Így vissza ez a "hello world", és a sikere ez,
feltételezve, hogy semmi baj, akkor megyünk erre a cél helyre
hogy meghatározott, és mi csak kibír a válasz ott.
És ez egy nagyon egyszerű módja felállítása Ajax lekérdezést.
>> Nagyon gyorsan, Rob egyfajta említette már,
dolgok rosszra, rossz dolgok történnek,
ezért azt szeretné, hogy megismerkedjen ezekkel a HTTP válasz kódokat.
Mik ezek csak, mint a 200, minden ment rendben.
Valami más, rossz dolgok történtek.
Ez általában a dolog, amit akarok emlékezni.
De jó tudni, hogy az összes ilyen.
És végül, ha egyszer már ment keresztül, hogy minden,
beszélnünk kell nagyon gyorsan a design,
és akkor hagyom, hogy minden távozzon.
Design. Dolog, amit akar emlékezni.
Kérdezd meg magadtól ezeket a kérdéseket: Ki lesz ezzel?
Mit fognak használni azt? Mit a felhasználók érdekel?
Mit sem törődnek?
Csak nem akarja, hogy egy app, és hagyja, hogy ez csak nőni
és legyen ez a hatalmas, mindent felemésztő dolog, amit nem is befejezni.
Azt akarod, hogy diszkrét célok és tervek, és a dolgok szeretne foglalkozni.
Legyen könnyű. Mindez azt mondja, alapvetően,
megkönnyítik a felhasználó számára, hogy, ne, hogy ez egy hatalmas folt a szöveg, mint ez a dia, valóban.
Csak azt akarom, hogy legyen valami, ahol nagyon könnyű valakit, hogy menjen a
és amit akarnak.
Nem akarom, hogy navigálni 5 oldal
hogy az elsődleges funkciója a webhelyen.
Ha a Google már 5 oldal előtt akkor is keres valamit,
senki sem használja.
És végül, a papír prototípus, fókuszcsoportos.
Legyen jó tervezés és tesztelési gyakorlattal.
Csak azért, mert úgy gondolod, hogy működik az Ön számára,
nem azt jelenti, bárki más azt hiszi, hogy működik-e.
De igen, ez az.
[CS50.TV]