>> [Review: Quiz 1]
[Ali Nahm, Oreoluwa Barbarinsa, Lucas Freitas, Rob Bowden] [Harvard University]
[Dit is CS50.] [CS50.TV]
[Lucas Freitas] Welkom iedereen. Dit is beoordeling voor quiz 1.
Net zoals een disclaimer, deze is - ik bedoel, we gaan proberen te dekken
zoveel mogelijk materiaal, maar dat betekent niet dat
we gaan alles van de dingen die kunnen worden in quiz 1 dekken.
Dus zorg ervoor dat u ook een kijkje nemen op college, secties, alles wat je kunt nemen.
Quiz 1 gaat worden op woensdag, volgende week woensdag.
Dus zorg ervoor om te studeren. Het zal zijn, vrij veel, net als de eerste quiz
met betrekking tot het formaat, maar het gaat waarschijnlijk veel moeilijker zijn.
Tenminste, vorig jaar toen ik 50, ik dacht dat het veel moeilijker.
Dus bestuderen veel.
>> Ik ga datastructuren dekken en Huffman codering.
Dit is iets dat veel mensen denken is complex,
maar ik ga proberen om het zo makkelijk mogelijk te maken.
Allereerst, wat we willen dat jullie weten quiz 1 is
inzicht in de conceptuele beschrijvingen van elk van de data structuren die ik ga presenteren.
Dat betekent dat je niet hoeft om daadwerkelijk
implementeren van een hash-tabel in uw quiz 1.
We willen niet dat je een hele hash table voeren; misschien zullen we proberen
te zorgen dat u bepaalde functies uit te voeren,
de meest voorkomende operaties, maar we gaan niet om je alles uit te voeren.
Dus het is belangrijk dat je het concept achter elke datastructuur begrijpen
en ook dat u in staat om code in C zijn,
alleen de meest voorkomende activiteiten die zij hebben voor elke datastructuur.
En ook in staat om pointers en structs beoordelen,
omdat ze blijkbaar veel in deze datastructuren.
>> Eerste gekoppelde lijsten. Geschakelde lijsten zijn eigenlijk zeer vergelijkbaar met arrays
maar het verschil tussen een gekoppelde lijst en een array,
allereerst dat een gekoppelde lijst een flexibel formaat,
terwijl in arrays moet je kiezen voor een zeer grote omvang van de array,
zodat je weet dat je gaat om te kunnen al uw gegevens in die array op te slaan,
of je moet malloc gebruiken om een ​​flexibele lengte van de array.
In gelinkte lijsten het is heel makkelijk om gewoon meer elementen,
zet meer elementen in de gelinkte lijst of elementen te verwijderen.
En eigenlijk, als je niet wilt dat de gelinkte lijst te sorteren,
U kunt zoeken en elementen in constante tijd te verwijderen,
dus O (1) tijd, dus het is erg handig.
Je moet gewoon voorzichtig zijn om altijd onthouden om malloc en gratis de knooppunten,
gewoon omdat als je dat niet, dan moet je memory leaks.
Dus gelinkte lijsten - de definitie van een knooppunt is net als wat we hebben daar.
Ik zet int n, maar u kunt alle gegevens die u wilt opslaan.
Dus als je wilt een string op te slaan, het is prima.
Wilt u een structuur op te slaan, het is prima, een dubbele, wat je wilt.
Ik heb net int n voor de voorbeelden hier.
En je moet een pointer naar het volgende knooppunt.
Dus, in principe, een gekoppelde lijst heeft een aantal data, en dan wijst naar de volgende node.
Als het het laatste element in de gelinkte lijst, gaat het te wijzen op NULL.
Dit is dus een voorbeeld van een gekoppelde lijst.
>> Oke, dus nu laten we zien wat we moeten doen als ik een element in een gelinkte lijst invoegen.
Ten eerste zal een functie insert van het type ongeldig
want ik wil niet terugkeert niets.
En ik ga naar een int nemen als argument,
omdat ik wil weten wat ik wil invoegen.
Dus wat is het eerste wat ik moet doen? Nou, ik moet malloc op newnode,
dus dat is de eerste regel.
Ik ben gewoon het creëren van een nieuw knooppunt in een gelinkte lijst te zetten.
Dus wat kan ik doen? Nou, we weten dat in onze implementaties van gelinkte lijsten
in de klas, we altijd op het hoofd als een globale variabele.
Dus wat we kunnen doen is de kop.
Ik kan deze nieuwe node het nieuwe hoofd,
en het gaat om te wijzen op het vorige hoofd.
Hoe kunnen we dat doen? Het eerste wat ik moet doen
is verandering de 'n' in het nieuwe knooppunt naar waarde,
die werd doorgegeven aan de functie.
Dan is newnode naast gaat het hoofd zijn.
Het hoofd zal worden newnode. Dus het is vrij simpel.
Voor het verwijderen van een knooppunt, kunnen we het doen zoals -
Enkel we dat konden doen wil zeggen,
oke, als ik wilde verwijderen, bijvoorbeeld, 3,
wat ik kon doen is gewoon wijzen de vorige knooppunt
naar de volgende knoop van 3.
Dus ik zou net zoiets doen.
Maar wat is het probleem met dat te doen?
Ik heb een geheugen lek, dus ik heb geen toegang tot de nummer 3 niet meer.
Het probleem met dat is dat ik niet van plan om te kunnen bevrijden dat knooppunt.
Ik ga moeten geheugenlek en (onverstaanbaar) gaat me haten.
Dus in plaats van dat te doen, zou ik waarschijnlijk een tijdelijke pointer.
Dus ik zet temp. Het zal wijzen op het knooppunt dat ik wil verwijderen.
En dan kan ik de vorige nodes verplaatsen naar punt naar het volgende knooppunt
van de knoop die ik wil verwijderen.
En tot slot, kan ik gratis de aanwijzer.
Moet ik de pointer die ik heb gemaakt daar te bevrijden?
Ik hoef niet naar, gewoon omdat -
het verschil is dat deze node is gemaakt met behulp van malloc,
dus het is in de hoop, terwijl deze net werd verklaard als een NULL schakelaar in de stapel.
Dus ik hoef het niet te bevrijden.
>> Oke. Dus nu laten we praten over stacks.
Stapels zijn vrij eenvoudig.
We hebben stapels en rijen in de klas alleen met behulp van arrays,
maar je moet vertrouwd zijn - net bewust
dat u ook stapels kunt doen in de rij met behulp van gelinkte lijsten ook.
Dus als je een array, wat zou een stapel zijn?
Een stapel, eerste, zal een grootte hebben.
Je moet slaan wat is de grootte van de stack die je nu hebt.
En ook zou u een array, in dit geval getallen,
maar als je wilt, kan het een array zijn
snaren, een array van structuur, iets dat u wilt opslaan.
Over de stapel: Het verschil tussen een stapel en een gekoppelde lijst
is dat de stapel u toegang tot het laatste element dat in de stapel is gebracht alleen.
Het laatste heet, first out.
Net alsof je een stapel trays,
als je een dienblad op de bovenkant van de stapel,
moet je die lade eerst verwijderen om toegang tot de andere laden hebben.
Het is hetzelfde met stapels.
Dus als ik wil, bijvoorbeeld, voegen een element aan een stapel, wat moet ik doen?
Het heet push, en het is vrij eenvoudig.
Het eerste wat je hoeft te doen is controleren of de grootte van de stack
niet groter of gelijk aan de capaciteit van de stapel.
Want als je al op volle capaciteit, kun je niets anders toevoegen.
En als niet, je hoeft alleen het element toe te voegen aan de stapel.
En tenslotte, verhoog de grootte. Dus het is vrij eenvoudig.
Dus ik voeg gewoon de nummer 2.
En als ik wil knallen, wat betekent dat ik wil verwijderen
de laatste element dat toegevoegd en terugkeer de waarde van het element,
het eerste wat ik heb om te controleren is dat de stack niet leeg is.
Want als het leeg is, kan ik niets terug.
In dat geval ben ik terug -1.
Anders ga ik de grootte van de spec verlagen,
en terug te keren nummers (s.size).
Waarom heb ik verlagen van de grootte en dan terug s.size?
Het is omdat, in dit geval, de spec heeft maat 4,
en ik wil het vierde element terug, toch?
Maar wat is de index van het vierde element? Drie.
Omdat ik de grootte - gaat worden 3, kan ik gewoon s.numbers terug (s.size)
omdat het 3. Dus het is gewoon de index.
>> Nu wachtrijen. Wachtrijen zijn vrijwel hetzelfde.
Het enige verschil is dat in plaats van last in, first out,
je eerst in, first out.
Waarschijnlijk als je zit te wachten om naar een concert,
je zou niet blij zijn als je een stapel in plaats van een wachtrij gehad.
Omdat dit de laatste persoon te komen zou de eerste persoon om het concert te betreden.
Je zou waarschijnlijk niet gelukkig zijn.
In de rij, de eerste persoon in te krijgen is ook de eerste persoon om eruit te komen.
Dus in de definitie van een rij, naast het hebben van de grootte van de array
heb je ook aan het hoofd, die de index aan het hoofd van de stapel hebben.
Dus het eerste element op dit moment.
Enqueue is hetzelfde als push voor stacks.
Als je erg naïef, zou je gewoon zeggen,
goed, ik kan het gewoon doen precies hetzelfde als ik deed voor push.
Ik kan alleen maar controleren of het niet verder dan de capaciteit.
Als het is, ik return false, anders kan ik gewoon exporteren de nieuwe waarde
en dan verhoog de grootte.
Maar waarom is dit verkeerd?
Laten we eens kijken dit voorbeeld.
Ik ben op zoek naar een heleboel dingen enqueue,
en dan ga ik dequeue en enqueue.
Er is een hoop commando's, maar het is heel simpel.
Ik ga enqueue 5, dus het is aan 5, en dan op 7,
1, 4, 6, en dan wil ik iets dequeue,
wat betekent dat ik ga naar het eerste element te verwijderen.
Dus ik ga naar het nummer 3 te verwijderen, toch?
Het eerste element. Oke.
Nu als ik probeer om iets anders enqueue, wat er gaat gebeuren?
Volgens mijn implementatie,
Ik was van plan om het volgende nummer in de index q.size zetten.
In dit geval is de grootte 8,
dus de index 8 zal hier in de laatste positie.
Als ik probeer om hier enqueue 1, zou ik de laatste positie worden overschreven
om het nummer 1, dat is het helemaal mis.
Wat ik wil doen is wikkel rond en ga naar de eerste positie.
Misschien wil je gewoon zeggen, nou, ik moet enkel vertrekken
als ik daadwerkelijk iets daar zetten.
Zo niet, zeg ik gewoon, oh, de nieuwe volledige capaciteit
is eigenlijk capaciteit - 1, en je niet kunt een element daar.
Maar wat is het probleem? Het probleem is dat als ik alles dequeue precies goed hier
en dan probeer ik iets anders toe te voegen, zou het gewoon zeggen,
goed, je was op volle capaciteit, dat is 0.
Dus je wachtrij is verdwenen.
Je moet wikkelen, en een manier van wikkelen rond
dat jullie geleerd in visionaire en andere psets werd met behulp van mod.
U kunt proberen thuis te begrijpen waarom je q.size + q.head zou doen
mod capaciteit, maar als je hier direct bekijken,
kunnen we zien dat het werkt.
Dus in het laatste voorbeeld, was q.size 8
en het hoofd was 1, want het was deze positie hier van de array.
Zo zal 8 + 1, 9. Mod capaciteit 9 zou zijn 0.
Het zou gaan om de index 0. We zullen in de juiste positie.
En dan proberen de wachtrij thuis.
Enkele belangrijke dingen: proberen om het verschil tussen een stapel en een wachtrij te begrijpen.
Thuis, proberen om zeer vertrouwd met de uitvoering enqueue, dequeue, push en pop te krijgen.
En ook begrijpen als je elk van hen zou gebruiken.
>> Dus laten we ontspannen gedurende 10 seconden met een bos van Pokemons.
En nu laten we terugkeren naar datastructuren gaan.
Hash tabellen. Veel mensen waren bang van hash tables.
in probleem set 6, Spell Checker.
Hash tabellen en probeert, veel mensen bang van hen.
Ze denken dat ze zo moeilijk te begrijpen. Yeah?
[Rob Bowden] Probleem set 5. >> Probleem set 5, ja. Bedankt Rob.
Yeah. Zes was Huff n 'Puff, ja.
Probleem set 5 werd Spell Checker, en je moest ofwel een hash table of proberen te gebruiken.
Veel mensen dachten dat ze waren super moeilijk te begrijpen, maar ze zijn eigenlijk vrij eenvoudig.
Wat is een hash table, eigenlijk? Een hash table is een array van gelinkte lijsten.
Het enige verschil tussen een array en een hash tabel
is dat in de hash tabel je zoiets als een hash-functie hebben.
Wat is een hash-functie?
Ik weet niet of jullie hier kunt lezen.
Dit is een voorbeeld van een hash-tabel.
Zodat je kunt zien dat je een array met 31 elementen.
En wat we doen in een hash tabel wordt een hash-functie
dat gaat om een ​​sleutel te vertalen, elk int aan een index.
Als, bijvoorbeeld, als ik wil kiezen voor B. Harrison,
Ik zou B. Harrison in mijn hash functies,
en de hash-functie zou 24 terugkeren.
Dus ik weet dat ik wil B. Harrison op te slaan in 24.
Dus dat is het verschil tussen gewoon een array en een hash table.
In de hash tabel vindt u een functie die zal u vertellen
waar de gegevens die u wilt opslaan op te slaan.
Voor de hash-functie, u wilt op zoek naar een hash-functie
dat is deterministische en goed gespreid.
Zoals je hier kunt zien, zie je dat een groot deel van de gegevens die ik wilde winkel was eigenlijk 19
in plaats van 31 en 30 en 29, die allemaal vrij waren.
Dus de hash-functie die ik gebruikte was niet erg goed gespreid.
Wanneer we zeggen dat goed gespreid, het betekent dat we willen hebben,
ongeveer ten minste 1 of 2 voor elk van de -
als een verschil van 1 of 2 voor elk van de indexen van de matrices.
Je wilt hebben, ruwweg, hetzelfde aantal elementen in elke gelinkte lijst in de array.
En het is gemakkelijk om te controleren of deze geldig is in de hash tabel, zien als hash tables.
>> Dan bomen. Dit is een boom.
Bomen in de informatica zijn kop voor een of andere reden.
Dus hier heb je de wortel van de boom en vervolgens de bladeren.
Je moet gewoon weten de nomenclatuur voor ouders en kind.
Elk knooppunt heeft een kind, waarbij de knooppunten die onder de moederverbinding.
Dus, bijvoorbeeld, 2 zal de ouder 3 en het andere kind daar,
terwijl 3 gaat de ouder 1 en de andere kinderen die er zijn.
En 1 zal 3 kind zijn, enzovoort.
Wij hebben iets veel interessanter, een zogenaamde binaire zoekboom,
waarbij alle waarden rechts van een knooppunt
zullen worden aan de rechterkant, hier - aan de rechterkant,
zullen groter dan het element in de root.
Dus als ik het nummer 5 hier, alle elementen op de juiste
zullen groter dan 5, en aan de linkerkant
alle elementen zullen minder dan 5 is.
Waarom is dit nuttig?
Nou, als ik wil controleren of het getal 7 is hier, bijvoorbeeld,
Ik ga gewoon naar 5 eerste en ik ga kijken, is 7 meer of minder dan 5?
Het is groter, dus ik weet dat het zal moeten worden aan de rechterkant van de boom.
Dus ik heb veel minder dingen te kijken.
Ter uitvoering van een binaire zoekboom, de knoop, ik gewoon te hebben tot de gegevens,
dus int n, je kon ook een string
of alles wat je wilde.
Je moet gewoon voorzichtig zijn op het definiëren van wat groter is om, wat minder is.
Dus als je snaren had, bijvoorbeeld, kun je definiëren
dat al die dingen op de juiste zullen grotere lengte hebben,
links zullen lagere lengtes hebben, dus het is echt aan jou.
>> Hoe implementeer ik vind voor BST?
Het eerste wat we moeten doen, is controleren of de wortel is NULL.
Als het NULL, betekent dit dat de zaak er niet
want je hoeft niet eens een boom, toch?
Dus ik return false.
Anders, ik ga om te controleren of het getal groter
dan de bij de wortel.
Ik ga proberen om het element aan de rechterzijde
van de boom.
Je ziet dat ik gebruik recursie hier.
En als het dan minder, ga ik naar links kijkt.
En tot slot, anders, als het niet minder of niet meer,
betekent dat het de waarde zelf.
Dus ik return true.
U kunt hier zien dat ik gebruikte als, als, als.
En vergeet niet, in quiz 0, hadden we een probleem dat had als, als, als,
en je moest de inefficiëntie te vinden,
en de inefficiëntie was dat je gebruikt wanneer.
U zou hebben gebruikt indien, anders als, anders als, en anders.
Dus, moet ik gebruiken else if en else if en anders hier?
Heeft iemand - ja?
[Student spreken, onhoorbaar]
Dat is perfect. Dus ze zegt dat het niet uitmaakt,
alleen omdat de inefficiëntie die we eerder hadden
was dat, omdat, misschien als enige voorwaarde werd voldaan,
zodat u een actie hebt uitgevoerd, maar dan ging je alle andere voorwaarden te controleren.
Maar in dit geval is het terug meteen, dus het maakt niet uit.
Dus je hoeft niet anders te gebruiken als.
>> En tot slot, laten we praten over pogingen,
dat is ieders favoriet.
Een try is een boom van arrays.
Het is zeer snel op te zoeken waarden, maar het maakt gebruik van een veel geheugen.
En het is meestal om woorden te filteren, dus als je
wilt implementeren, bijvoorbeeld, weet ik niet, als een telefoonboek in uw telefoon
en u wilt kunnen typen B
en gewoon namen van mensen die hebben B.
Het is zeer eenvoudig te implementeren dat het gebruik van een proberen, bijvoorbeeld.
Hoe maak je een knoop definiëren in een keer te proberen?
Je hoeft alleen een bool dat gaat worden is_word hebben.
Dat betekent dat het gebruik van alle personages voor dat knooppunt,
je was in staat om een ​​woord te vormen,
en dan zul je een array van pointers naar knooppunten.
Kun je zien dat we een array van ouder knooppunten, dus knoop * array? Yeah?
Dus laten we zien hoe dat zal werken. Voor de spellingcontrole,
We hebben een reeks elementen 27,
want we hebben alle letters plus de apostrof.
Voordat hier Ik ben gewoon gaan gebruiken 2 want ik wil in staat zijn om te schrijven op het bord.
Oke. Dus dit is een voorbeeld van een try.
Als ik alleen het eerste knooppunt definiëren, zal ik een serie van 2 elementen
dat zijn 2 verwijzingen naar NULL, dus ik zet 'a' en 'b'.
En ik ga een bool dat is_word zegt te hebben.
Het gaat vals voor de eerste te zijn,
alleen maar omdat, voordat dat je geen karakters.
Dus een leeg woord is niet een woord. Dus het is vals.
Als ik wil 'een' toe te voegen aan dit woordenboek, wat zou ik moeten doen?
Ik zou gewoon een nieuw knooppunt voor 'a' malloc,
en voeg dan het woord om waar.
Zodat het net vertegenwoordigt dat het hebben van 'een' gaat om waar te zijn. Zinvol?
Dan als ik wil 'ba' toe te voegen, zal ik moeten malloc 1 voor 'b',
en dan ga ik het opzetten van de boolean op false,
want 'b' op zichzelf is niet een woord.
Dan ga ik naar een ander voor 'a', dus 'ba' malloc,
en dan ga ik voor het opzetten van het is een woord op true.
Omdat 'ba' is een woord.
En dan als ik wil zien of 'b' is in dit woordenboek,
Ik kan gewoon naar de eerste, 'b'. Ik ga naar beneden, en ik kijk naar is woord, en het valse zegt.
Dus het is niet een woord. Als ik wil 'ba' check,
Ik ga naar de eerste, 'b', en ga dan naar 'een', en ik zie waar, dus het is een woord. Zinvol?
Veel mensen raken in de war door pogingen. Nee?
>> Tenslotte Huffman codering. Huffman codering is zeer nuttig
om geheugen te besparen en comprimeren van tekstbestanden,
alleen maar omdat een heleboel keer je 'a' en 'e' te gebruiken, bijvoorbeeld,
in uw documenten, maar ik weet niet of jullie gebruiken 'q' of 'z' zo veel.
Na slechts 1 byte voor elk karakter,
elk - de 256 tekens die we hebben in de ASCII-tabel is niet erg optimaal,
alleen maar omdat er een aantal tekens dat je veel meer gebruiken,
dus moet je waarschijnlijk minder geheugen gebruiken voor die.
Hoe gebruik ik Huffman codering?
We moeten een Huffman boom doen.
Een Huffman boom heeft knooppunten
dat een symbool dat zal zijn als, 'a', 'b', 'c', de brief hebben,
welke letter je hebt, een frequentie die de frequentie dat het woord in de tekst voorkomt,
dat je het maken van de Huffman boom voor,
en een knooppunt dat gaat naar links wijzen van de Huffman boom
en een ander knooppunt dat gaat naar rechts wijzen. Dus net als een boom.
Hoe maak je een Huffman boom te bouwen?
Je gaat naar de 2 knooppunten die de laagste frequenties halen.
Als u een stropdas moet je naar de 2 knopen halen
dat de laagste ASCII-waarden hebben.
Dan zul je een nieuwe boom te maken uit deze 2 knopen
dat gaat de gecombineerde frequentie in het bovenliggende node hebben.
En dan ga je naar de 2 kinderen uit het bos te verwijderen
en ze te vervangen door de ouder.
En je gaat herhalen totdat u slechts 1 boom in het bos.
Dus laten we zien hoe je een Huffman boom zou doen voor ZAMYLA.
U kunt hier zien dat alle letters hebben frequentie 1, behalve voor 'A', die frequentie 2 heeft.
Dus heb ik knooppunten voor alle brieven die ik op basis van hun ASCII-waarde en frequentie.
Dus als ik wil de eerste boom te maken, zal het met 'L' en 'M'.
Dus het is hier. De frequentie van het paar zal 2
want het is 1 + 1, dan is de volgende 2 met de laagste frequenties zijn 'Y' en 'Z'.
En dan heb ik ze allemaal zijn - hebben een frequentie van 2.
Ja welke degenen die de laagste ASCII-waarde voor de volgende kunnen hebben?
'A' en 'L'. Dus ik maak het nieuwe knooppunt,
en tot slot, het is 4 en 2, dus 2 gaat worden aan de linkerkant.
En dit is de Huffman boom.
Dan als ik wat tekst wilt schrijven,
zoals in binair om te zetten naar tekst met de Huffman boom is zeer eenvoudig.
Bijvoorbeeld, als ik zeg dat u naar links is een 0 en verhuizen naar de rechterkant is een 1,
Wat gaat dat voor?
Dus als 1, 1, dus rechts, rechts,
en dan 0, dus links zou L zijn, en dan 1, 0, 0.
Dus 1, 0, dus gewoon 1, 0, 'A'.
En dan 0, 1, dus 'Z'.
En dan 1, 0, 0 - geen.
0, 0 zal zijn 'Y', zo lui.
Dus dat is allemaal voor mij, Rob's gaan over te nemen.
>> [Rob Bowden] Dus, week 7 spul.
We hebben veel werd erg snel over te gaan.
Logische operatoren op, buffer overflow,
CS50 bibliotheek, dan HTML, HTTP, CSS.
Alle in zoals 15 tot 20 minuten.
Logische operatoren op. Er zijn 6 van hen die je moet weten.
Bitwise en bitwise of, XOR, left shift, rechter shift, en niet.
Rechts verschuiven en niet je nauwelijks zag in collegezaal helemaal.
Gaan we over het snel hier, maar het is goed om te weten dat dit de 6 die er bestaan.
Vergeet niet dat bitwise operators zijn net als je 3 + 4.
U bent niet te maken met de binaire van 3 en 4.
Met logische operatoren op u eigenlijk te maken met de individuele bits van de nummers 3 en 4.
>> Dus het eerste dat we zullen zeggen is bitwise niet,
en alles wat het doet is flip alle bits.
Dus hier, als je het schrijven dit in C, zou je niet schrijven
als ~ 11011 of wat dan ook, zou je schrijft het leuk ~ 4,
en dan zou het de binaire representatie van 4 flip.
Dus hier, ~ van een aantal binaire getal 1101101 gaat precies flip alle 1 tot 0 en alle 0 tot 1's.
Zoals ik daar zeg, het veelvuldig gebruik van deze,
en we zullen het zien in een beetje, is als we willen komen met een aantal nummer
waarbij alle bits 1, behalve een van hen.
Dus het is meestal makkelijker om het aantal te drukken
waar net dat ene bit is ingesteld,
en neem dan de ~ van het, dus elke andere bit is ingesteld, behalve voor die ene.
Dus dat is wat we gaan meer gebruiken in een beetje.
>> Bitsgewijze of. Hier zijn 2 binaire getallen, en deze 2 nummers
zijn vrij representatief, aangezien ze alle mogelijke vormen
combinatie van bits die je nodig zou kunnen hebben om te werken op.
Hier, toen ik or'd elke bit, we gaan gewoon recht naar beneden te vergelijken.
Dus aan de linkerkant hebben we een 1 en een 1.
Toen ik bitsgewijs | die, wat ga ik krijgen? One.
Dan bitsgewijs | 0 en 1 gaat me geven? One.
Bitwise 1 en 0 gaat hetzelfde, een zijn.
Bitsgewijze 0 | 0 gaat me geven 0.
Dus het enige geval waarin ik 0 is in de 0 | 0 geval.
En je kunt bedenken dat net als je logisch ors.
Dus als je denkt van 1 als waar en 0 als valse, hetzelfde geldt hier.
Zo waar of waar is waar, waar of onwaar is waar.
Vals of waar is waar, vals of onwaar is het enige dat is eigenlijk vals.
Hier is het voorbeeld dat je moet weten
als een vrij goed voorbeeld van wanneer bitsgewijs operatoren worden gebruikt.
Hier zouden wij of hoofdletter 'A' met OX20,
en we zullen kijken naar deze in een tweede, we iets krijgen.
En als we of kleine letters 'a' met OX20, iets krijgen we.
Dus laten we trekken ASCII-tabel.
Oke. Hier zien we dat 'A' is -
hier hebben we 'A' is decimaal 65.
Maar ik ga met hexadecimale, dat is Ox41.
Vrij zeker dat we zagen in de klas. Ik denk dat wij het zagen in de klas
dat het is erg makkelijk om te zetten van hexadecimaal naar binair.
Dus hier, als ik wil 4 zetten in binaire,
dat gaat gewoon te zijn 0100.
Dit is 1 van de plaats, 2 de plaats, 4 de plaats, dus dit is 4.
Dan kan ik splitsen 1 in binaire, die zal worden 0001.
En dus dit gaat om de vertegenwoordiging van de 'A' in binaire zijn.
Het nemen van kleine letters 'a', het is nu van plan om Ox61 zijn,
waar, splitsen deze op in haar binaire, dus een 6 -
Laten we het eigenlijk doen - is er geen gum? Gum.
Ox61. Dus splitsen 6 in binaire gaat worden 0 + 4 + 2 + 0.
En splitsen 1 gaat worden 0001.
Kijkend naar het verschil tussen deze 2,
zien we dat het enige verschil tussen een kleine en een hoofdletter 'A' is deze enkele bit.
Dus terug te komen naar hier - oke.
Komen hier terug om, als we kijken naar wat de bit OX20 is,
dus het splitsen van OX20 in zijn binaire,
is 0010, 0000.
OX20, het enige stukje dat is ingesteld is dit beetje dat we zijn bezig met,
met het schakelen tussen hoofdletters en kleine 'a'.
Als I of A, dat deze, A,
als ik of 'A' met OX20,
wat ga ik krijgen?
[Student, onhoorbaar] >> Kleine letters 'a', omdat het gaat om dit stukje spiegelen aan een 1.
En als ik of 'een' met OX20, wat ga ik krijgen?
Kleine letters a, want net oring 'een' met OX20,
Ik ga gewoon worden oring deze enkele bit van een 1, het is al een 1, dus het maakt niet uit.
Dus krijgen we 'a' en 'a'.
>> Bitwise en. Ook hier kunnen we denken aan dit als onze logische en tegenhanger.
Aan de linkerkant hebben we true & waar.
Het gaat om waar te zijn, en voor al de gevallen,
valse en echte of ware en valse, of valse en valse,
geen van deze dingen waar zijn.
Dus wat we uiteindelijk krijgt is 1000.
Dus nu, hier, hier is waar ik de trouwe bitgewijze hebt gebruikt niet,
waar we OX20.
Dus dit is OX20.
Nu, wat ik wil doen, bitwise ~ van OX20.
Dat wordt alle bits omdraaien.
Dus ik heb 1101, 1111.
En dus 'A' ge-AND met ~ OX20 gaat me wat?
Het enige beetje we echt nodig hebben om te denken is dit een,
want als al deze bits zijn ingesteld op 1,
dan gaan we precies wat 'A' was,
behalve eventueel wat dit bit.
Want als het een 1, nu het gaat worden ingesteld op een 0,
want wat is dit, ge-AND met dit gaat worden 0.
Dus wat is 'A' & ~ OX20 me gaat geven?
[Leerlingen beantwoorden, onhoorbaar] >> En wat is 'a' en - het is 'A'.
En wat is 'een' & ~ OX20 me gaat geven?
'A.' Want dit is momenteel een 1.
Anding met deze 0 gaat om het een 0,
en nu gaan we een 'A' te krijgen.
>> Beide zijn 'A', en last but not least van dit type,
we XOR. Het is heel erg als of,
behalve dat het uitsluitend betekent of.
Dit is hetzelfde als wat je meestal denken als of in de echte wereld.
Zodat je ofwel 'x' of 'y', maar niet beide.
Hier 1 ^ 1 gaat worden 0.
Omdat de ware, dit is - het maakt niet zo goed werkt met de logische ware en valse
als bitwise & en of doen,
maar waar ^ waar is onwaar.
Omdat we willen alleen echte terugkeren als slechts een van hen is waar.
So 1 ^ 1 is 0. Hoe zit het met 0 ^ 1?
Is 1. 1 ^ 0 = 1, 0 ^ 0 is 0.
Dus onder alle omstandigheden, 0 bitwise iets 0 gaat worden 0.
1 bitwise iets 0 of 0 bitwise 1,
als het | of ^, zal het een 1 zijn, en als het is en het zal zijn 0.
En het enige geval waarin 1 bitwise 1 is niet 1 is met exclusieve of.
Dat is 0110.
Dus hier nu, met behulp van XOR - dus we zijn terug op 20.
'A' ^ OX20 is deze 2 bits we vergelijken.
Dus een 1 ^ 0 gaat me een wat? Een een.
'A' ^ OX20 gaat me geven? Kleine letters een.
'A' ^ OX20 gaat me geven? Kapitaal A.
Want wat deze doet, dit XORing met OX20
effectief flippen wat dit bit.
Als dit een 0, is het nu gaat een 1 te worden.
Aangezien dit een 1, 1 ^ 1 is 0.
Dus onze 'a' is geworden 'A' en onze 'A' is 'a'.
Dus XOR is echt een handige manier van alleen het wegknippen van de zaak.
Je wil gewoon itereren over een reeks letters
en wisselen het geval van elk karakter,
je gewoon XOR alles met OX20.
>> Nu we shift hebben verlaten. Verschuiving naar links is gewoon om, in principe,
Duw alle nummers in, of naar links en steek 0's achter hen.
Hier hebben we dus 00.001.101.
We gaan 3 0 in te duwen vanaf de rechterkant,
en we krijgen 01101000.
In nonbinary termen,
zien we dat dat werkelijk voor zich 13 links verschoven met 3, die ons 104 geeft.
Dus links verschuiven, zien we hier, x << y is eigenlijk x * 2 ^ y.
13 * 2 ^ 3, 2 ^ 3 8 is, dus 13 * 8 104.
Als je gewoon denkt over binaire in het algemeen, hoe elk cijfer,
Als we uitgaan van het recht, het is de 1 plaats, dan is de 2 de plaats, dan is de 4 de plaats.
Dus door te duwen in 0's van rechts,
we zijn gewoon duwen dingen die waren in de 4 de plaats van de 8 de plaats,
en dingen die waren in de 8 de plaats op de 16 de plaats.
Elke shift gewoon vermenigvuldigt met 2. Yeah?
[Student] Wat gebeurt er als je verschoven door 5?
[Bowden] Als je verschoven met 5 zou je gewoon verliezen cijfers.
Onvermijdelijk, het is hetzelfde. Zoals, gehele getallen zijn slechts 32 bits,
dus als je 2 echt grote getallen toe te voegen, het is gewoon niet past in een geheel getal.
Dus het is hier hetzelfde. Als u verschoven 5,
we zouden alleen verliezen die ene.
En dat is een beetje wat ik bedoel met "ongeveer"
waar als je te ver verschuiven, verlies je bits.
>> Rechts verschuiving gaat het tegenovergestelde,
waar gaan we naar 0's opduwen het einde,
en voor onze doeleinden, vul 0 vanaf links.
Dus dit te doen, we eigenlijk omkeren wat we al hadden gedaan.
En we zien dat de drie 0's aan de rechterkant net afgevallen,
en we hebben de 1101 helemaal naar rechts geduwd.
Dit doet 104 >> 3, en dat is effectief, x / 2 ^ y.
Dus nu, hier, het is een soortgelijk idee.
Waarom is het slechts ongeveer x / 2 ^ y, en niet daadwerkelijk x / 2 ^ y?
Want als ik had verschoven door 4, zou ik verloren heb een 1.
Kortom, wat je denkt van, denk maar aan integer deling in het algemeen.
Dus, zoals 5/2 2. Het is niet 2.5.
Het is hetzelfde idee hier. Als we delen door 2,
kunnen we vreemde stukjes verliezen langs de weg.
Dus nu - dat is het voor bitwise. Dat is alles wat je moet weten.
De use cases die we zagen in de klas herinneren,
als een beetje masker is handig voor bitwise operators,
of je ze kunt gebruiken voor bit maskers.
Hoofdletters en kleine letters, conversies is een vrij prototypisch voorbeeld.
>> Oke, dus buffer overflow aanvallen.
Iedereen weet wat er mis met deze functie was?
Merken we verklaarde een array van 12 bytes, 12 tekens,
en dan kopiëren we in onze buffer van 12 tekens de hele reeks bar.
Dus wat is het probleem hier?
Het magische getal 12 moet vrijwel onmiddellijk pop uit als - waarom 12?
Wat als bar gebeurt te zijn meer dan 12 tekens?
Wat als bar is miljoenen tekens?
Hier is de kwestie memcpy. Als bar is lang genoeg,
het zal gewoon helemaal - 'c', 'c' niet schelen dat het was slechts 12 tekens;
"C" geeft niet dat het niet past dat veel bytes.
Het zal gewoon helemaal overschrijven char, de 12 bytes die we voor hem hebt toegewezen,
en alles verleden in het geheugen dat niet daadwerkelijk tot die buffer
met wat de string bar is.
Dus dit was het beeld zagen we in de klas
waar we onze stack opgroeien.
U moet worden gebruikt om deze foto's of vertrouwd te raken met hen opnieuw.
We hebben onze stack opgroeien, geheugenadressen bij 0 beginnen aan de top
en groeien naar zijn 4 miljard onderaan.
We hebben ons aanbod 'c' ergens in het geheugen,
dan hebben we onze pointer naar bar rechts eronder,
en dan hebben we het gered framepointer in ons retouradres en stapel onze moedermaatschappij routine.
Herinneren wat het retouradres is?
Het is als belangrijkste noemt een functie foo, roept een functie bar,
onvermijdelijk, bar rendement.
Dus als bar terugkeert, moeten ze weten dat het gaat terug naar foo dat het genoemd.
Dus het retouradres is het adres van de functie die het heeft om terug te keren wanneer de functie terugkeert.
De reden dat is belangrijk voor buffer overflow-aanvallen is omdat, gunstig,
hackers willen dat retouradres veranderen.
In plaats van terug naar foo gaan, ga ik terug naar waar de hacker wil dat ik om terug te gaan te gaan.
En, heel handig, waar de hacker vaak wil terug naar
is het begin van de buffer die we oorspronkelijk hadden.
Zo merkt, weer, Little Indian.
Het apparaat is een voorbeeld van een Little Indian systeem,
dus een geheel getal of een pointer wordt opgeslagen met de bytes omgekeerd.
Dus hier zien we - is dit? Yeah.
We zien Ox80, OxC0, Ox35, OxO8.
Denk aan de hexadecimale cijfers?
Wij niet afdoen aan het hexadecimale cijfers in Little Indian,
omdat 2 hexadecimale cijfers vormen een byte, en we keren de bytes.
Dat is waarom we niet op te slaan, zoals, 80530CO8.
Wij slaan, in plaats daarvan, elk paar van 2 cijfers, te beginnen van rechts.
Dat adres betreft het adres van de start
van onze buffer die we eigenlijk wilden kopiëren naar in de eerste plaats.
De reden dat het nuttig is, want wat als de aanvaller
overkomen, in plaats van een string die net was
een onschuldig reeks zoals hun naam of iets,
wat als, in plaats daarvan, die string waren slechts enkele willekeurige code
die deden wat ze wilde doen?
Zodat ze konden - Ik kan niet denken van een koele code.
Het kan van alles zijn, dat wel. Elke rampzalige code.
Als ze wilden, konden ze gewoon iets bij seg fouten doen, maar dat zou zinloos zijn.
Ze doen het meestal om uw systeem te hacken.
>> Oke. CS50 bibliotheek.
Dit is, in principe, getInt, getString, al die functies die we voorzien voor u.
Dus we hebben char * string en dat is de abstractie die we blies weg
op een gegeven moment tijdens het semester.
Vergeet niet dat een string is gewoon een array van karakters.
Dus hier zien we een verkorte versie van getString.
Je moet kijken terug op het te herinneren hoe het eigenlijk is geïmplementeerd.
Belangrijke details zijn, merken we krijgen in een karakter per keer
van standaard, die net als wij het typen op het toetsenbord.
Dus een karakter per keer, en als we te veel tekens,
dus als n + 1 groter is dan de capaciteit,
dan moeten we de capaciteit van onze buffer vergroten.
Dus hier zijn we een verdubbeling van de omvang van onze buffer.
En dat blijft gaan, voegen we het personage in onze buffer
totdat we een nieuwe lijn of het einde van het bestand of wat dan ook te ontvangen,
in welk geval, we zijn klaar met de string en daarna de echte getString
krimpt het geheugen, net als we toegewezen te veel geheugen het zal terug te gaan en krimpt een beetje.
Dus we zien dat niet, maar het belangrijkste idee is
het moet lezen in een karakter per keer.
Het kan niet alleen lezen in een alles in een keer,
omdat de buffer slechts een bepaalde grootte.
Dus als de string die het probeert in te voegen in de buffer te groot is, dan zou overstromen.
Dus hier voorkomen we dat door alleen het lezen in een enkel karakter
tegelijkertijd en groeiende wanneer we moeten.
Dus getInt en de andere CS50 bibliotheek functies de neiging om getString gebruiken
in hun implementaties.
Dus heb ik gewezen op de belangrijke dingen hier.
Het roept getString om een ​​string te krijgen.
Als getString niet geheugen terug te keren,
vergeet niet dat getString mallocs iets, dus wanneer u getString bellen
moet je niet (onverstaanbaar) bevrijden die string die je hebt.
Dus hier, als het niet iets malloc, keren we terug INT_MAX als gewoon een vlag die,
hey, waren we niet echt in staat om een ​​geheel getal te krijgen.
Je moet negeren wat ik bij u terug, of
je moet dit niet behandelen als een geldige invoer.
Tot slot, in de veronderstelling dat lukte, we gebruiken sscanf met die speciale vlag,
waardoor enerzijds overeenkomen een integer,
vervolgens passende tekens na die integer.
Zo merken we willen dat het gelijk 1.
Dus sscanf rendementen hoeveel wedstrijden als succes gemaakt?
Het zal 1 als het met succes voldoen een integer terug,
het zal terugkeren 0 als het niet overeenkomt met een integer, en het zal 2 terug
als het paste een geheel getal gevolgd door een wat karakter.
Zo merken we opnieuw proberen als we iets maar 1 wedstrijd.
Als we binnenkwamen 1, 2, 3, C, of ​​1, 2, 3, X,
vervolgens 1, 2, 3 zou opgeslagen in de integer,
X zou krijgen opgeslagen in het karakter,
sscanf zou 2 terugkeren, en we zouden het opnieuw te proberen, omdat we alleen een integer willen.
>> Snel waait door HTML, HTTP, CSS.
HyperText Markup Language is de structuur en semantiek van het web.
Hier is het voorbeeld van lezing waar we HTML-tags.
We hebben hoofd-tags, body-tags,
we hebben voorbeelden van lege tags waar we eigenlijk niet een start-en nauwe tag hebben,
we moeten gewoon koppeling en imago.
Er is geen sluiting image tag, er is slechts een label dat alles de tag moet doen volbrengt.
De link is een voorbeeld, we zullen zien hoe u een koppeling naar CSS,
het script is een voorbeeld van hoe u een koppeling naar een externe webbrowser.
Het is vrij eenvoudig, en vergeet niet, HTML is geen programmeertaal.
Hier herinneren hoe u een formulier zou bepalen of tenminste wat dit zou doen?
Een dergelijke vorm heeft een actie en een methode.
De methoden die u zult alleen maar ziet zijn GET en POST.
Dus GET is de versie waar de zaak wordt gezet in de URL.
POST is waar het niet is gesteld in de URL.
In plaats daarvan, gegevens uit het formulier is verborgen in de HTTP verzoek ingevoegd.
Dus hier, actie bepaalt waar het HTTP-verzoek gaat.
Waar het heen gaat is google.com / search.
Methode. Denk aan de verschillen tussen GET en POST,
en, gewoon zeggen als voorbeeld, als u een bladwijzer wilt iets.
Je zult nooit in staat zijn om een ​​POST URL bladwijzer
omdat de gegevens niet is opgenomen in de URL.
>> HTTP, nu, is HyperText Transfer Protocol.
Het HyperText Transfer Protocol, zou je verwachten dat het overdragen
HyperText Markup Language, en het doet.
Maar maakt zij ook alle beelden die je vindt op het web,
welke downloads u beginnen als een HTTP-verzoek.
Dus HTTP is alleen de taal van het World Wide Web.
En hier moet je dit soort van een HTTP-verzoek te herkennen.
Hier HTTP/1.1 aan de kant zegt alleen dat is de versie
van het protocol ik gebruik.
Het is vrijwel altijd gaat om HTTP/1.1 zijn, zoals u zult zien.
Dan zien we dat dit GET, het alternatief dat POST, dat je zou kunnen zien.
En de URL die ik probeerde te bezoeken was www.google.com/search?q = blah, blah, blah.
Dus denk dat dit, het vraagteken q = blah blah blah,
is het soort spul dat wordt ingediend door een formulier.
De respons is het misschien terug naar mij zou er ongeveer zo uitzien.
Weer, te beginnen met het protocol, dat gaat worden dat,
gevolgd door de status code. Hier is het 200 OK.
En tenslotte, de webpagina die ik eigenlijk gevraagd zal worden gevolgd.
De mogelijke statuscode je zou kunnen zien, en je moet een aantal van hen weten.
200 OK heb je waarschijnlijk eerder gezien.
403 Forbidden, 404 Not Found, 500 Internal Server Error
is meestal als je naar een website en er iets gebroken of hun PHP code crashes,
terwijl we in het toestel hebben dat grote oranje doos
die komt op en zegt, als er iets mis is, is deze code niet werkt
of is slecht deze functie.
Meestal websites wil niet dat je te weten wat de functies zijn eigenlijk slecht,
dus in plaats daarvan zullen ze geven je gewoon 500 Internal Server Errors.
>> TCP / IP = 1 laag onder HTTP.
Vergeet niet dat er internet buiten het World Wide Web.
Net als je een online spel dat niet via HTTP af te spelen,
het gaat via een ander - het is nog steeds met behulp van het internet,
maar het maakt geen gebruik van HTTP.
HTTP is slechts een voorbeeld van de ingebouwde protocol op TCP / IP.
IP betekent letterlijk Internet Protocol.
Elke computer heeft een IP-adres, het zijn die 4-cijferige dingen
zoals 192.168.2.1, of wat, dat vaak een lokaal.
Maar dat is het patroon van een IP-adres.
Dus de DNS, Domain Name Service,
dat is wat dingen zoals google.com vertaalt zich tot een werkelijke IP-adres.
Dus als je dat IP-adres typt in een URL,
dat zou je naar Google, maar je de neiging niet om die dingen te onthouden.
Je hebt de neiging om google.com plaats herinneren.
Het laatste wat we hebben is de havens, waar dit het TCP onderdeel van IP.
TCP doet meer. Denk er eens over, als, u hebt uw webbrowser draait.
Misschien heb je een aantal e-mail-toepassing actief is;
misschien heb je een ander programma dat het internet draait gebruikt.
Ze hebben allemaal toegang tot het internet nodig hebben,
maar uw computer slechts 1 WiFi-kaart of wat dan ook.
Dus poorten zijn de manier waarop we in staat zijn op te splitsen
hoe deze toepassingen zijn in staat om het internet te gebruiken.
Elke aanvraag krijgt 1 specifieke poort die kan luisteren,
en standaard HTTP poort 80.
Sommige e-maildiensten gebruiken 25.
De lage-getelden neiging te worden gereserveerd.
Je bent meestal in staat om hoger genummerde tanden te krijgen voor jezelf.
>> CSS, Cascading Style Sheets.
We stijl webpagina's met CSS, niet met HTML.
Er zijn 3 plaatsen kun je je CSS zetten.
Het kan inline worden, tussen stijl-tags, of in een volledig apart bestand en vervolgens gekoppeld inch
En hier is slechts een voorbeeld van CSS.
U moet dit patroon herkent,
waar het eerste voorbeeld is dat we het afstemmen van de body-tag,
en hier zijn we het centreren van de body-tag.
Het tweede voorbeeld, zijn we het afstemmen van de zaak
met ID-footer, en we zijn het toepassen van een aantal stijlen die.
Merk op dat ID footer tekst uitgelijnd naar links,
terwijl hoofdtekst-uitgelijnd centrum.
Voettekst is in het lichaam.
Het zal, in plaats daarvan, text-align gelaten, hoewel lichaam zegt text-align center.
Dit is geheel trapsgewijze deel ervan.
Je kunt hebben - u kunt stijlen opgeven voor het lichaam,
en dan dingen in het lichaam kun je meer specifieke stijlen te geven,
en de dingen werken zoals je zou verwachten.
Meer specifieke CSS bestekschrijvers voorrang.
Ik denk dat is het.
>> [Ali Nahm] Hallo iedereen. Als ik kon gewoon je aandacht.
Ik ben Ali en ik ga om te gaan door middel van PHP en SQL echt snel.
Dus we kunnen beginnen. PHP staat voor PHP: Hypertext Preprocessor.
En zoals jullie allemaal zou moeten weten, het is een server-side scripting taal,
en we gebruiken het voor de back-end van websites,
en hoe het doet veel van de berekeningen, de achter-schermen deel.
Syntax. Het is niet zoals C, wat een verrassing.
Het heeft altijd te beginnen met de, als je kunt zien, de - ik kan niet vooruit te komen.
U kunt zien dat u de nieuwe soorten beugels nodig hebt en dan moet u ook de php?.
Dat is altijd hoe je je PHP tekst, PHP-code te kaderen.
Dus het kan niet gewoon zoals C, waar je soort zet het op eerste.
U moet altijd omringen.
En nu, de belangrijkste syntax is dat alle variabelen moeten beginnen met het $ teken.
Je moet het doen als je ze te definiëren, je moet om het te doen
als je bedoelt om ze later op.
Je moet altijd dat $. Het is je nieuwe beste vriend, vrij veel.
Je hoeft niet - in tegenstelling tot C, je hoeft niet te brengen wat voor soort variabele type het is.
Dus terwijl u hoeft de $, hoeft u niet om te zetten, zoals,
int x of y touw, enzovoort, enzovoort.
Zodat een klein verschil.
Als gevolg hiervan betekent dat PHP is een zwak soort.
PHP is een zwak soort taal, en het zwak heeft getypt variabelen.
Met andere woorden, dat betekent dat je kunt schakelen tussen verschillende soorten variabele types.
U kunt uw nummer 1 op te slaan als een int,
u kunt de gegevens opslaan als een string, en je kunt het opslaan als een float,
en het zal allemaal dat nummer 1.
Ook al ben je het opslaan in verschillende vormen,
het is nog steeds - de variabele types zijn nog steeds vast in het einde.
Dus als je hier kijkt, als je nog uit PSET 7,
velen van u waarschijnlijk had problemen met deze.
Twee gelijke tekens, 3 gelijke tekens, 4 gelijke borden.
Ok, er geen 4 gelijkheidstekens, maar er zijn 2 en 3.
U gebruikt 2 gelijk borden naar de waarden te controleren.
Het kan over typen controleren.
Dus als je bij het eerste voorbeeld kan zien,
Ik heb num_int == num_string.
Dus je int en uw snaar zijn beide, technisch, 1,
maar ze zijn verschillende types. Maar voor de dubbel is, zal het nog passeren.
Voor de drievoudige gelijken, controleert waarde en de verschillende types.
Dat betekent dat het niet gaat hier in dat tweede geval door te geven,
waar je met behulp van 3 gelijkheidstekens plaats.
Dus dat is een belangrijk verschil dat je moet alles nu hebben laten zien.
>> String aaneenschakeling is een ander krachtig ding dat je kunt gebruiken in PHP.
Het is eigenlijk gewoon deze handige puntnotatie,
en dat is hoe je snaren samen kunnen binden.
Dus als je kat en je hebt Hond, en u wilt de 2 strings samen te stellen,
kunt u de periode te gebruiken, en dat is een soort van hoe het werkt.
Je kunt ook gewoon leg ze naast elkaar,
zoals je hier kunt zien in de onderste voorbeeld,
waar ik echo snaar 1, ruimte touwtje 2.
PHP zal weten om ze als zodanig te vervangen.
Arrays. Nu, in PHP zijn er 2 verschillende matrices.
U kunt regelmatig arrays, en u kunt ook associatieve arrays,
en we gaan om te gaan door hen nu.
Regelmatige arrays zijn en dit in C,
en dus je hebt indices die zijn genummerd.
Op dit moment zijn we gewoon gaan er een te maken en zet -
dus dit is hoe creëren we een lege array, dan gaan we naar
steken in de index nummer 0.
We gaan om het nummer 6, de waarde 6 zetten.
U kunt het hier zien aan de onderkant.
Where's - op index nummer 1 gaan we waarde nummer 4 gezet,
en zo kun je zien dat er een 6, is er een 4,
en vervolgens als we afdrukt dingen,
als we proberen en print de waarde opgeslagen bij indexnummer 0,
dan zullen we zien de waarde 6 wordt afgedrukt. Cool?
Dus dat is regelmatige arrays voor u.
Een andere manier kun je ook dingen toevoegen aan regelmatige arrays nu
is dat je ze gewoon toevoegen aan het eind.
Dat betekent dat je niet hoeft om de specifieke index opgeven.
U kunt zien nummer, en vervolgens in de vierkante haken is er geen index opgegeven.
En het zal weten - PHP zal weten om gewoon toe te voegen aan het einde van de lijst, de volgende vrije plek.
Zo kunt u de 1 daar zie op dat 0 spot,
de 2 ging daar op de eerste plek.
De 3 gaat - is daar ook toegevoegd.
Dus dat soort zinvol. Je bent gewoon constant toe te voegen,
en toen we in navolging van de index van de nummer 1,
zal het printen van de waarde 2.
>> Dan hebben we arrays die associatieve arrays zijn.
Associatieve arrays, in plaats van numerieke waarden,
wat ze doen is, ze hebben indices die door string.
U kunt zien, in plaats van - ik verlost van al die numerieke indices,
en nu is het key1, key2, KEY3, en ze zijn tussen dubbele aanhalingstekens om aan te geven dat ze allemaal strings.
Dus we kunnen hier een voorbeeld van te hebben.
Het voorbeeld hiervan is dat we de tf, en dat is de index naam.
We gaan, zet "Ali", zoals de naam van de index, calorieën gegeten,
kunnen we een int zet dit keer in plaats van een string,
en vervolgens op de index voor leuk, we kunnen een hele array zet erin.
Dus dit is een soort van - het is een vergelijkbaar concept met hoe we hadden
indices met cijfers, maar nu kunnen we de indices rond veranderen
om hen als strings plaats.
U kunt dit ook doen, naast gewoon doen individueel,
je kunt het allemaal in een brok. Dus je kunt dat tf van die array te zien,
en dan zetten we ze allemaal in een gigantische vierkante haken set.
Zodat dingen te versnellen.
Het is meer een stilistische keuze dan niet.
We hebben ook loops.
In C hebben we lussen die werken als volgt.
We hadden ons aanbod, en we gingen uit de index 0 tot het einde van de lijst,
en wij drukken het allemaal, toch?
Behalve het probleem is, voor associatieve arrays,
we niet per se te kennen die numerieke indices
want nu hebben we de string indices.
Nu gebruiken we foreach loops, die, nogmaals, u hopelijk gebruikt in PSET 7.
Foreach loops weet gewoon elk onderdeel van de lijst.
En het hoeft niet precies de numerieke index die je hebt leren kennen.
Dus je hebt de foreach syntax, dus het is foreach, je zet de array.
Dus mijn array wordt genoemd PSET, en vervolgens als het woord als,
en dan zet je deze lokale tijdelijke variabele die je gaat gebruiken
alleen voor de specifieke ding dat gaat om de specifieke te houden -
een exemplaar of een gedeelte van de array.
Pset num zal houden 1, en dan misschien zal het nummer 6 te houden,
en dan zal het de nummer 2 te houden.
Maar het is gegarandeerd om te gaan door elke waarde die in de array.
Handige functies die u moet weten in PHP zijn de eisen,
dus dat zorgt ervoor dat je met inbegrip van bepaalde bestanden, echo, afrit, leeg.
Ik beveel je kijkt naar pset 7 en kijk naar deze functies.
Je zou kunnen hebben om die kennen,
dus ik zou zeker weten wat precies, die doen allemaal.
>> En nu gaan we om te gaan door ruimte heel snel.
Van toepassing, PHP is een soort van een funky ding, in tegenstelling tot C,
en dus zijn we gewoon gaan snel doorheen.
Dus laten we zeggen beginnen we op dat de pijl die we daar hebben.
En we gaan beginnen met $ i. Dus de variabele 'i' gaat worden 0,
en we gaan gewoon houden afgedrukt in dat grote witte doos daar.
We gaan beginnen met i0, en dan gaan we het echo.
Dus er is het 0.
En dan gaan we het verhogen van de for-lus,
en dan gaat het om de waarde van 1 zijn.
Een kleiner is dan 3, dus het gaat door dat te kunnen slagen voor lus,
en dan gaan we zien het weer gedrukt.
We gaan het weer verhogen naar 2,
en 2 minder dan 3, dus het zal passeren de lus, en het zal de 2 drukken.
Dan zul je merken dat 3 is niet minder dan 3, dus we zullen uit de pauze voor lus.
Dus nu hebben we verlaten, en dan gaan we naar aFunction te gaan.
Oke. Dus je moet er rekening mee dat deze variabele die we hebben gecreëerd,
de 'i' variabele, niet lokaal bereik.
Dat betekent dat het niet lokaal op de loop,
en die variabele we kunnen nog steeds toegang en veranderen daarna, en het zal nog steeds effectief zijn.
Dus als je in de functie nu, zult u zien dat wij de 'i' variabele te gebruiken ook,
en we gaan op te hogen 'i' + +.
Je zou denken, in eerste instantie, op basis van C, dat is een kopie van de 'i' variabele.
Het is een heel ander ding, dat is correct.
Dus toen we afdrukken, we gaan drukken 'i' + +, die gaat om uit te printen dat 4,
en dan gaan we - sorry.
Dan gaan we naar het einde van die functie,
en we gaan zijn waar die pijl op dit moment is.
Dat betekent dat dan echter, hoewel de functie verandert de waarde van 'i'
het niet buiten de functie te veranderen,
omdat de functie een aparte ruimte.
Dit betekent dat wanneer we echo 'i' is niet veranderd in de scope van de functie
en dus dan gaan we opnieuw af te drukken 3.
Verschillende dingen over reikwijdte in PHP dan in C.
>> Nu in PHP en HTML.
PHP wordt gebruikt om webpagina's dynamisch te maken.
Het maakt soort dingen anders.
We hebben het anders dan HTML.
Met HTML, we altijd gewoon hetzelfde statisch ding, zoals hoe Rob toonde,
terwijl PHP, kun je dingen veranderen op basis van wie de gebruiker is.
Dus als ik dit, ik heb, "U bent ingelogd als -" en vervolgens de naam,
en ik kan de naam veranderen. Dus nu de naam is Joseph,
en het heeft de "over mij", maar dan kan ik ook de naam te veranderen in Tommy hebben.
En dat zou een andere zaak zijn.
Dus dan kunnen we ook verschillende dingen over hem te veranderen,
en het zal verschillende inhoud tonen op basis van de naam.
Dus PHP kan soort veranderen wat er gaande is in uw website.
Same here. Toch merken dat ze verschillende inhoud,
ook al ben je technisch gesproken nog steeds toegang tot dezelfde webpagina op het oppervlak.
HTML genereren. Er zijn 2 verschillende manieren waarop u dit kunt doen.
Dus gaan we door dat moment. De eerste manier is, je hebt - ja, sorry.
Dus je hoeft alleen uw gewone lus in PHP,
en dan echo je in PHP en je echo uit HTML.
Met behulp van wat Rob liet je van HTML script
en vervolgens met behulp van de PHP druk om gewoon print het uit op de webpagina.
De alternatieve manier is om het te doen alsof je scheiden van de PHP en HTML.
Zo kunt u een lijn van PHP die begint de lus hebben,
dan kunt u de lijn van de HTML hebben in een apart ding,
en dan kom je de lus, wederom, met een PHP.
Dus het is een soort van het scheiden van het uit.
Aan de linkerkant, kunt u dat u alle -
het is gewoon 1 brok van PHP.
Aan de rechterkant kunt u zien dat u een lijn van PHP,
heb je een regel HTML, en je weer een lijn van PHP.
Dus scheiden het uit in wat ze doen.
En je zult merken dat hoe dan ook, voor een van hen,
ze nog steeds een afdruk van de afbeelding, de afbeelding, de afbeelding,
zodat HTML steeds wordt afgedrukt op dezelfde manier.
En dan zul je nog steeds de 3 beelden weergegeven op uw website.
Dus het is 2 verschillende manieren om hetzelfde te doen.
>> Nu hebben we formulieren en aanvragen. Zoals Rob liet zien,
Er zijn vormen van HTML, en we zullen alleen wind door dit.
U heeft een actie en je hebt een methode, en uw actie
soort laat u zien waar je naartoe gaat om het te verzenden, en de methode is of
het gaat om een ​​GET of POST zijn.
En een GET-verzoek, zoals Rob zegt, betekent dat je gaat om het in een vorm te gieten
en je zult het zien als een URL, terwijl een POST-aanvraag zal je niet zien in een URL.
Zodat een klein verschil.
Echter, een ding dat is een soortgelijk ding
is dat POST en GET zijn even onzeker.
Dus je zou kunnen denken dat alleen maar omdat je het niet zien in de URL,
dat betekent dat de POST is veiliger,
maar je kunt het nog steeds zien in uw cookies in de informatie die u verzendt.
Dus denk niet dat over een of het ander.
Een ander ding om op te merken is dat je ook paragraaf variabelen.
Jullie gebruikten deze in pset 7 om uw gebruikers-ID informatie te krijgen.
Wat er gebeurde was dat u deze associatieve array kan gebruiken,
de $ _SESSION, en dan ben je in staat om toegang te krijgen tot verschillende dingen bent
en opslaan verschillende dingen over de pagina's.
>> Laatste ding is dat we SQL, Structured Query Language,
en dit is een programmeertaal om databases te beheren.
Wat precies, zijn databases? Het zijn verzamelingen van tafels,
en elke tabel kunnen vergelijkbare soorten objecten hebben.
Dus we hadden een tafel van gebruikers in uw financiën PSET.
En waarom zijn ze nuttig? Omdat het een manier om permanent informatie opslaan.
Het is een manier van het bijhouden van dingen en het beheer van de dingen
en eigenlijk zien van het op verschillende pagina's en het bijhouden.
Terwijl als je gewoon op te slaan op dat een onmiddellijke ogenblik
en gebruik het dan later, zult u niet in staat zijn om toegang te krijgen tot alles wat je hebt bespaard.
We hebben 4 belangrijkste dingen die we gebruiken voor SQL-opdrachten.
We hebben selecteren, invoegen, verwijderen en bijwerken.
Die zijn echt belangrijk voor jullie om te weten voor uw quiz.
>> We zullen snel gaan dan selecteert nu.
Kortom, je bent het selecteren van rijen uit een database.
Dus als je, hier -
we hebben deze 2 verschillende dingen, en we willen selecteren uit de tabel klassen
waar awesome - waar in de ontzagwekkende kolom de waarde is 1.
Zodat je hier kunt zien, hebben we deze 2 dingen van naam van de klasse,
CS50 en Stat110, en hebben we de klasse-identificaties en de slogan.
Dus we willen al die informatie te selecteren.
Dan kunt u hier zien dat het soort van plukken uit die geweldige column,
waar alle dingen zijn 1, en dan heeft de klasse-id, class naam en slogan die het kan uitzoeken.
Hoe precies doe je dit in de code? Je moet PHP gebruiken.
Dat is een soort van hoe PHP en SQL zijn aan elkaar.
Nu hebben we onze code, en we gaan onze vraag functie te gebruiken
zoals we in PSET 7, en we gaan naar de SQL-query uit te voeren.
Dan gaan we hebben -
we hebben altijd te controleren of de rij van triple gelijk als vals.
Dus nogmaals, wil je het type en de waarde te controleren,
en dan, als het niet werkt, dan wil je verontschuldigen, zoals gewoonlijk, zoals wij deden in PSET 7.
Anders, je wilt lus door alles met die handige
foreach loops dat we gingen net over.
Nu we doorlussen en we hebben het verleden gemaakt,
laten we aannemen dat onze vraag voorbij, nu hebben we onze foreach lus.
En de eerste rij heeft, dus hier is de rij hier, het is verpakt.
Het gaat om uit te printen alle informatie die het is geworden.
Dus het gaat om uit te drukken aan de onderkant "Wil leren HTML?"
Dan is het gaan naar de volgende rij, omdat het voltooide de eerste lus,
en dus dan gaat het printen van de tweede regel van het,
die gaat STAT110 zijn, Vind alle Moments.
>> Een laatste ding is op SQL beveiligingslekken.
Ik weet dat David raakte op deze een beetje in collegezaal.
Je kunt dit later lezen. Het is echt grappig.
SQL Injection is een soort van lastig ding.
Laten we zeggen dat je gewoon vasthouden die variabelen direct in uw query,
zoals je kunt zien in die eerste lijn.
Het lijkt zo fijn, toch? Je bent gewoon de invoering van de gebruikersnaam
en wachtwoord om uw SQL-query, en je wil het schip uit en krijgen wat er in uw gegevens tafel.
Dat lijkt vrij eenvoudig. Dus laten we zeggen iemand zet in,
voor het wachtwoord, dit OR hier tekst -
eigenlijk zou moeten zijn in het rode vak.
Dus laten we zeggen dat ze zetten dat wachtwoord in - dat is wat ze in te voeren.
Dus ze zetten of "1" = 1.
Soort van een domme wachtwoord te hebben.
Laten we nu gewoon vervangen in, en je zult merken dat in dat SQL-query nu,
evalueert om altijd waar, want je zult merken dat
U kunt SQL-query selecteren al deze informatie
of je kan gewoon 1 = 1.
Dus dat gaat altijd om te evalueren op true.
Dat gaat niet echt werken, want dat betekent dat de hacker kan breken in uw systeem.
De oplossing hiervoor is dat je de BOB-systeem te gebruiken,
wat betekent dat je vraagtekens gebruiken,
dat is wat jullie gebruikt in PSET 7,
waar je naartoe gaat om een ​​vraagteken te gebruiken in plaats van waar je iets wilt zetten,
en dan zul je een komma, en dan zul je daarna hebt,
na uw snaar, de verschillende variabelen die u wilt vervangen in uw vraagteken.
Dus je zult merken dat ik nu deze rode vraagtekens.
Dan zet ik de variabelen na mijn snaren, dus ik weet dat ze achteraf te vervangen in die volgorde.
Dat zal ervoor zorgen dat als iemand het doet als dit,
en ze hebben de or 1 = 1 situatie, die zal ervoor zorgen dat,
in de back-end, zorg ervoor dat het eigenlijk niet zal breken de SQL-query.
Oke, dus dat is het zowat, een wervelwind van PHP en SQL.
Veel succes voor jullie allemaal, en nu aan Oregon
>> [Oreoluwatomiwa Babarinsa] Oke iedereen. Tijd om te gaan over een aantal JavaScript
en een aantal andere dingen heel snel, zodat we je niet houden vanavond.
JavaScript. Ja. JavaScript is een soort van een cool ding, ogenschijnlijk.
De dingen die je echt moet weten over JavaScript, het is een beetje als
de client-side einde van wat uw web app gaat doen.
Er zijn een paar dingen die je gewoon niet willen om te zorgen voor de hele tijd op de server kant.
Alle kleine interacties, aandacht voor een ding, iets laten verdwijnen.
Je echt niet willen hebben om uw server te praten de hele tijd voor dat.
En sommige van die zelfs niet mogelijk is te doen op de server kant.
Dit is waarom we iets als JavaScript nodig.
Coole dingen over JavaScript: Het is dynamisch getypeerde.
Wat dit betekent is dat je programma niet hoeft te weten
wat precies, de variabelen zijn als je het opschrijven.
Het zal gewoon soort van het uit als het draait.
Andere dingen die zijn cool aan is: Het is een accolade taal,
waardoor de syntax is vergelijkbaar met C en PHP.
Je hoeft niet te veel rework doen als je het leren JavaScript.
Hier hebben we een beetje van JavaScript.
Interessante ding hier is dat, als je er naar kijkt,
we hebben een beetje van JavaScript daar in het hoofd-tag.
Wat is doet is eigenlijk gewoon onder een JavaScript-bestand.
Dit is een manier kun je onder andere JavaScript in uw programma.
Dan is de tweede beetje eigenlijk een aantal inline JavaScript,
zeer vergelijkbaar met een inline stijl met CSS,
en je bent gewoon schrijven wat code zeer snel er.
JavaScript heeft arrays.
Gewoon een andere manier om data te houden rond, zeer nuttig.
Zeer mooie en gemakkelijke syntaxis.
U gebruikt vierkante haken om alles bij elkaar te houden en alles.
Niets te complex.
Het koele ding over JavaScript en scripting talen in het algemeen
is dat je niet hoeft te maken over matrix maten.
U kunt gewoon gebruik maken van Array.length en bijhouden van het,
en ook de array kan groeien of krimpen als je het nodig hebt.
Dus je hoeft niet eens zorgen te maken over een soort van,
oh nee, ik moet meer dingen, of iets dergelijks toe te wijzen.
>> Het leuke hier is dat JavaScript heeft iets genaamd objecten.
Het is een objectgeoriënteerde taal, dus wat het is in wezen,
een manier voor u om gegevens te groeperen samen, enigszins vergelijkbaar met een structuur,
maar je kunt openen als een struct of in een associatieve array syntax.
Het is vrij simpel en wat u kunt doen met dit is groep gegevens samen
als je een heleboel gegevens die zijn gerelateerd.
Want het is alles wat je nodig hebt om een ​​auto te beschrijven,
je hoeft niet om het in een heleboel verschillende plaatsen hebben.
Je kunt gewoon plak het in 1 object in JavaScript.
Zoals u waarschijnlijk weet, iteratie is een van die vervelende taken.
Je doet het net iets meer dan een weer. Je nodig hebt om alle objecten te praten in de auto,
of je moet gaan door elke item in een lijst of iets dergelijks.
JavaScript heeft dus, vergelijkbaar met PHP, een foreach syntax.
In dit geval is een in lus.
Wil je dit alleen gebruiken op objecten.
Er zijn een aantal problemen die zich voordoen als u dit gebruiken op arrays.
Het is over het algemeen een van die dingen, hoewel, dat is erg handig,
omdat je veel overhead elimineren
omdat je niet hoeft te trekken alles in je object zelf.
Je hoeft niet alle belangrijke namen te onthouden.
Je gewoon soort van krijgen ze terug in dit syntax.
In deze, voor, je wilt onthouden
dat je krijgt terug alle sleutels, in een zeer gelijkaardige manier om hash table.
Als je nog van dat, wanneer je in een string zou zetten kon je iets uit te krijgen
dat zou een bijbehorende waarde mee.
Wat u kunt doen met dit is dat je kan zeggen, oke,
Ik zet in een auto, en ik noemde het een Ferrari.
Zo kunt u in de string Ferrari weer later te zetten, en je kunt krijgen dat uit.
En kun je dat doen in een lus, met de in lus.
Dus gewoon meer over objecten. Het belangrijkste van deze je moet onthouden
is dat je het object struct kan gebruiken, zoals syntax wanneer u maar wilt met deze,
behalve als wat je gaat gebruiken als een string is geen geldige variabelenaam.
Dus als je kijkt naar dat er, we hebben sleutel met spaties.
Nou, als je naar object.key zetten, ruimte, met, ruimte, ruimten,
dat zou gewoon niet logisch syntactisch maken.
Dus alleen kun je dat doen met dit soort beugel syntaxis.
>> Ook JavaScript is zeer ruimte-verstandig om PHP.
Je hebt 2 manieren van aanpakken scope.
Je kunt niet de var voor een variabele,
en dat betekent gewoon dat dit is wereldwijd.
Je ziet het overal. Zelfs als je om dit in een if-statement te zetten,
ergens anders in de code na dat punt kon je die variabele zien.
Een ander ding is echter met de var, het is beperkt tot wat de functie waar je in bent
Als je niet in een functie, goed, het is mondiaal.
Maar als je in een functie is het alleen toegankelijk binnen die functie.
Ik heb geen voorbeeld hebben, maar ja. Het is een van die dingen waar
u kunt beheren welke variabelen je wilt globaal te zijn,
wat variabelen die je wilt lokaal te zijn, maar je moet voorzichtig zijn over dit,
omdat u niet beschikt over het soort fijne korrel controle die je doen in C,
waar als er iets wordt verklaard in een lus, het gaat om te verblijven in die lus.
Het ding dat we echt zorgen over het gebruik van JavaScript voor manipuleert webpagina's, toch?
Ik bedoel, dat is waarom we dit doen.
>> Om dat te doen, gebruiken we iets genaamd de DOM.
Het Document Object Model.
Kortom, wat het doet is het neemt al je HTML
en modellen het uit in een bos van objecten die zijn genest in elkaar.
Je begint met iets als dit.
Je hebt, op de juiste voor mij, een bos van code die er zijn dat is een soort -
Je zou denken dat zeer moeilijk te manipuleren zou zijn,
want je zou parsen door een bos van tekst
en hoeven stuk uit elkaar dingen. En wat als het was niet goed geformatteerd?
Slechte dingen zouden gebeuren.
JavaScript duurt zo verzorgen dit voor u, en u hebt een mooie datastructuur te krijgen,
zoals die links van mij, waar je gewoon een document,
en binnen dat je iets genaamd HTML hebben,
en binnen dat u een hoofd en een lichaam,
en binnen dat hoofd je hebt een titel, etcetera, etcetera, etcetera.
Dit vereenvoudigt het manipuleren van een webpagina, zodat het is gewoon,
oh, ik wil gewoon dit object te praten.
Soort van een zeer gelijkaardige manier om een ​​ander object dat u zelf gemaakt zou praten.
Zoals ik al zei, alle DOM is in het document object.
Ofwel het is gewoon een plek en dan kun je naar binnen te gaan om dingen te vinden,
en je kunt het doen - dit is de oude stijl van doen, daar,
waar je dat doet document.getElementById, en vervolgens de naam,
en zoals u waarschijnlijk kunt vertellen, dit wordt erg onhandig na een tijdje.
Dus u wilt waarschijnlijk niet om dat te doen. Daarom hebben wij
het volgende wat we gaan over praten na deze.
De sleutel hier is dat, oke, je hebt al deze elementen, toch?
Dus misschien kan ik de kleur van iets wanneer de pagina geladen wijzigen.
So what? Wat als mijn gebruiker iets klikt?
Ik wil dat het iets interessants doen wanneer ze op iets.
Daarom hebben we evenementen.
U kunt, in principe, vinden elk element in je DOM,
en dan zeggen, he. Wanneer deze laadt of iemand het klikt,
of wanneer ze de muis over het, doe er iets mee.
En wat je hebt is, heb je functies die dit voor u te behandelen.
Deze functies zijn event handlers.
Wat Ze zijn - het is gewoon een mooie manier om te zeggen,
Deze functie wordt alleen uitgevoerd wanneer dit evenement gebeurt.
Zo behandelt het geval voordoet.
Dit is hoe je zou lay-out een event handler.
Ik heb enkele knop, en wanneer u erop klikt, hij ontploft.
Dus niet op de knop.
Dit is een manier van benaderen, toch?
Je hebt een knop tag, en klik je een string die zegt,
oh, door de manier, ik doe dit exploderende ding voor mij.
Anders, het is net als een gewone toets die u net gemaakt.
U kunt dit ook doen op een andere manier,
door grijpen de DOM-element, maar dat bewaren we nadat we praten over jQuery.
>> JQuery: Het is een bibliotheek die is cross-browser.
Je kunt het gebruiken in vrijwel alles.
En het geeft je gewoon een hoop tools om mee te werken.
Omdat JavaScript, terwijl krachtige, niet alle tools die u nodig hebt
uit de doos om echt aan te pakken een web app die u zou willen doen.
Dus het vereenvoudigt een heleboel dingen, geeft je een heleboel functies
uit de doos die je normaal zou moeten schrijven zelf, over en over en weer.
En net maakt de dingen heel simpel.
Je hebt ook selectors, die laat je uit al die elementen
van uw DOM veel eenvoudiger, in plaats van om deze zeer lange functie-aanroepen gebruiken.
Meer informatie over deze selectors. Je hebt, daar heb je, laten we zeggen
Ik wil een element te krijgen met het ID "rock."
Nou, in jQuery, het is gewoon $ en dan een string die een pond heeft, en dan "rock."
Het is heel simpel en een stuk sneller dan de traditionele JavaScript manier om dit probleem aan te pakken.
En u soortgelijke dingen voor klassen en soorten element.
jQuery is - een van de coole features is dat je kunt een soort van comprimeren
uw vragen over uw DOM heel, heel snel.
Nu zijn we terug naar event handling, en dit is hoe je een evenement in jQuery zou behandelen.
Dus wat we hier gaan is dat we zeggen, oke. Ik heb een script-tag, toch?
Dus ik heb dit inline JavaScript.
Wat we gaan doen is dat we gaan zeggen, oke.
Wanneer het document gereed is, wat betekent dat het document is geladen,
we gaan naar binnen te gaan naar die functie, en we gaan zeggen, oke,
Deze functie is eigenlijk iets anders te doen.
Het is eigenlijk te zeggen, oke, geef me het element met het ID "myid."
En dan geven deze een functie handler die wordt uitgevoerd wanneer u erop klikt.
Eigenlijk wat dit doet is, het zegt, oke.
De pagina wordt geladen, dus ik ga in, vinden dit element,
geef het dit event handler, en het zet in principe op uw pagina voor u.
En dit is hoe je wilt denken event handling.
Wil je gewoon denken, oke, als er iets gebeurt, wat wil ik er gebeuren?
Je wilt niet te denken, oke, ik moet zorgen dat dit ding gesprekken maken om dit ding,
dit ding blah blah blah, omdat je gewoon wilt ding spreken in termen van de gebeurtenissen.
Wanneer dit gebeurt, gebeurt. Wanneer dit gebeurt, dat gebeurt.
En als de dingen teweegbrengen andere dingen, dat is geweldig.
Maar je hoeft niet te proberen en te doen ingewikkelde code
waar je triggeren meerdere dingen tegelijk,
want je gaat gewoon om jezelf een hoofdpijn.
>> Oke. Nu kunnen we onze pagina om gebeurtenissen af ​​te handelen,
maar laten we zeggen dat mijn gebruiker op een knop klikt.
Wat als ik wil dat verzoek terug naar de server te sturen,
maar ik wil niet naar de pagina opnieuw te laden, omdat het hebben van een nieuwe pagina te herladen
elke keer wordt een beetje vervelend, en waarom moet ik
weer naar beneden trekken van de header, en opnieuw de voettekst,
en alle elementen van de pagina weer
alleen maar om de begroeting of de tijd te vernieuwen?
Dus dat is de reden waarom we iets als Ajax.
Wat kunnen we hier doen met Ajax is dat we kunnen zeggen, oke,
Ik wil een aantal gegevens naar de server,
en ik wil een reactie terug te krijgen zodat ik mijn pagina bij te werken,
of misschien gewoon doen wat algoritmische berekening die niet per se iets te laten zien aan de gebruiker.
Wat heb je nodig om dit te doen? Nou, je een URL die je nodig hebt om mee te praten.
Uw server kan niet gewoon magisch luisteren uit het niets.
U moet een specifieke plaats je deze gegevens naar hebben.
En je moet ook een aantal gegevens te sturen, of misschien is het een datalozen query.
Je wil gewoon terug naar de server pingen en zeggen: hey, ik leef, of iets dergelijks.
En dan een functie die in principe handgrepen met succes wil je.
Laten we zeggen dat je krijgt terug wat informatie van uw server,
en je wilt de titel van de gebruiker op hun pagina te veranderen.
Dus zou je de informatie terug te krijgen,
en je zou duwen die aan het scherm.
Wat er gebeurt is, wanneer de pagina klaar is,
u een op Click-functie te creëren voor deze knop genaamd Greeter.
Wat dit doet dan is, wanneer deze wordt ingedrukt,
je praat met greetings.php, u een POST-aanvraag te maken,
en je zegt, he, iets van uw pagina me.
We niet echt nodig om te beschrijven dat, maar greetings.php,
laten we maar zeggen, geeft terug "hallo wereld".
Dus krijgen we weer deze "hallo wereld" en op het succes van deze,
veronderstelling niets mis gaat, dan gaan we gewoon naar deze doelgroep plaats
dat we opgegeven en we gewoon vasthouden de reactie daar.
En dit is een zeer eenvoudige manier van het opzetten van een Ajax-query.
>> Zeer snel, Rob soort noemde dit al,
dingen mis kan gaan, kan slechte dingen gebeuren,
dus je wilt om vertrouwd te raken met deze HTTP response codes.
Wat deze zijn, zijn enkel, als, 200, ging alles goed.
Iets anders, slechte dingen gebeurd.
Het is over het algemeen de wat je wilt onthouden.
Maar het is leuk om al deze weten.
En tenslotte, als we eenmaal hebt meegemaakt dat alles,
We moeten heel snel praten over design,
en dan kunnen we laten jullie allemaal vertrekken.
Design. Dingen die je wilt onthouden.
Stel jezelf de volgende vragen: Wie zal met behulp van deze?
Wat zullen ze gebruiken voor? Wat doen mijn gebruikers schelen?
Wat doen ze niet schelen?
Je wil gewoon niet om een ​​app te maken en laat het gewoon groeien
en word deze reus, alles verterende ding dat je niet eens kan afmaken.
U wilt discrete doelen en plannen en dingen die je wilt pakken hebben.
Maak het moeiteloos. Dit alles zegt, in principe,
maken het gemakkelijk voor de gebruiker om het te gebruiken, maak het niet een gigantische klodder tekst zoals deze dia is, eigenlijk.
Je wil gewoon dat het iets waar het is heel makkelijk voor iemand om in te gaan
en doen wat ze willen doen.
Je wilt niet dat ze moeten 5 pagina's navigeren
om uw primaire functie van uw site te krijgen.
Als Google had 5 pagina's voor dat je kon zelfs iets zoeken,
zou niemand het gebruiken.
En tot slot, papieren prototype, focusgroep.
Heb goede ontwerpen en testen praktijken.
Gewoon omdat je denkt dat het voor u werkt,
betekent niet dat iemand anders denkt dat het werkt.
Maar ja, dat is het.
[CS50.TV]