[Powered by Google Translate] [Sectie 8 - Meer Comfortabele]
[Rob Bowden - Harvard University]
[Dit is CS50. - CS50.TV]
>> Deze week deel notities zullen zijn vrij kort,
dus ik ga gewoon blijven praten, gaan jullie heen om te vragen blijven stellen,
en we zullen proberen op te vullen zo veel mogelijk tijd.
Veel mensen denken dat dit PSET niet per se moeilijk, maar het is erg lang.
De PSET spec zelf duurt een uur te lezen.
Wij geven u een groot deel van de SQL-je nodig zou kunnen hebben om te gebruiken.
We lopen u door er veel van, dus het moet niet al te slecht.
Heeft iemand gestart of beëindigd?
Het is de laatste PSET. Oh, mijn God.
Meestal is er een JavaScript-na dit, maar kalender dingen veranderen
maakt alles 1 week korter, en we niet langer een JavaScript-PSET.
Ik weet niet hoe dat van invloed is of JavaScript zal verschijnen op het examen
of Quiz 1.
Ik kan me voorstellen zal het iets als je nodig hebt om op hoog niveau dingen te weten over JavaScript,
maar ik betwijfel of we zouden alleen maar geven u recht JavaScript-code
omdat je nog niet had een PSET in.
Maar dat zal dingen voor quiz beoordeling zijn volgende week.
>> Sectie van vragen.
Veel van deze dingen is enigszins slecht geformuleerde, maar we zullen bespreken waarom.
In tegenstelling tot C, PHP is een "dynamisch getypeerde" taal. Wat betekent dit, vraag je?
Nou ja, afscheid te nemen van al die char, float, int, en andere zoekwoorden die u moet gebruiken
Bij de aangifte variabelen en functies in C.
In PHP is een variabele van het type wordt bepaald door de waarde die het op dit moment is houdt.
Dus voordat we typ deze code in een bestand genaamd dynamic.php,
PHP wordt dynamisch getypt. Dat geldt.
Ik ben het oneens met het feit dat dat betekent dat we afscheid zeggen aan char, float, int,
en andere zoekwoorden.
Het precieze verschil tussen dynamisch getypeerde en subsidiair,
die statisch wordt getypt, is dat dynamisch getypt, al uw type checking en dat soort dingen
gebeurt tijdens de uitvoering, terwijl statisch getypt het gebeurt tijdens het compileren.
Het woord statische in het algemeen lijkt te betekenen compileren dingen.
Ik denk dat er andere toepassingen voor, maar in C als je een statische variabele declareren,
de opslag wordt toegewezen tijdens het compileren.
Hier, dynamisch getypt betekent gewoon dat -
In C als u probeert om een ​​string en een integer toe te voegen, als je het compileren,
het gaat om te klagen omdat het gaat om te zeggen dat je niet kunt een int en een pointer toe te voegen.
Het is gewoon niet een geldige operatie.
Dat is een ander ding dat we om in een seconde.
Maar dat soort controle, het feit dat het klaagt tijdens het compileren,
is statisch type checking.
Er zijn talen waar je niet hoeft te char, float, int zeggen, en al die dingen,
maar de taal kan vertellen uit de context van de zaak welk type het zou moeten zijn,
maar het is nog steeds statisch getypt.
Dus als je 51, OCaml te nemen, hoeft u nooit een van deze soorten te gebruiken,
maar het nog steeds tijdens het compileren zeggen dat je kunt dit niet doen omdat je het mengen van een int en een string.
Dynamisch getypt betekent gewoon dat ergens tijdens runtime je gaat om een ​​klacht in te krijgen.
Als u ook Java eerder gebruikt, in het algemeen, bijna elke C-type taal
gaat statisch worden getypt, dus C, C + +, Java, al die zijn over het algemeen statisch getypt.
Op Java als je compileren iets en je zegt
snaar s is gelijk aan nieuwe iets dat niet is een string,
dat gaat om te klagen omdat die types die gewoon niet met elkaar overeenkomen.
Dat zal wel zijn ongenoegen tijdens het compileren.
Maar het heeft ook een aantal dynamische tijd dingen zoals als je probeert om iets te werpen
naar een type dat is meer specifiek dan de huidige type,
er is niets dat kan doen tijdens het compileren tijd om te controleren of dat gegoten gaat lukken.
Java heeft ook een dynamische typecontrole dat zodra het wordt dat coderegel
wanneer het eigenlijk is uitgevoerd, gaat het om de cast te doen,
controleren of dat gegoten geldig was in de eerste plaats,
en als het niet was, dan dat het gaat om te klagen dat je een ongeldig type hebben.
Dynamisch type checking.
Typ deze in een bestand genaamd dynamic.php.
Dynamic.php.
Ik zal unzip dat bij het formatteren.
We hebben een variabele, zetten we het aan de integer 7,
dan gaan we het en% s af te drukken -
Oh, we de aard van het afdrukken, zo gettype zal het type van de variabele terug.
We zijn net het afdrukken van de soort over en weer.
We hebben net php.dynamic.php.
We zullen zien dat het verandert van integer naar string naar Booleaanse als we door.
In C is er geen Boolean data type, er geen string data type.
Er is char * en Booleaanse gewoon de neiging om int of char of iets dergelijks.
In PHP deze soorten bestaan, en dat is een van de grote voordelen van PHP over C -
die string operaties oneindig veel gemakkelijker in PHP dan C. Ze werken.
>> Zo komen we hier terug.
We renden dynamic.php.
Dit vertelt de PHP-interpreter, genaamd php, aan de PHP code uitvoeren in dynamic.php.
Als u fouten in het bestand, zal de tolk vertellen!
De tolk, dit is een ander groot verschil tussen PHP en C.
In C moet je iets samen te stellen en dan loop je dat gecompileerde bestand.
In PHP je nooit compileren iets.
Dus de PHP-interpreter is eigenlijk gewoon het lezen van deze regel voor regel.
Het raakt var = 7 dan raakt printf dan raakt var dan raakt printf enzovoort.
Er is een beetje van de samenstelling van het doet, en het slaat de resultaten
dus als je het script later kunt u doen wat,
maar in principe is het een regel voor regel soort dingen.
Dat betekent dat veel van de optimalisaties die we in C,
zoals het opstellen van, het is gewoon in het algemeen de compiler kan veel trucs voor u doen.
Het kan nemen ongebruikte variabelen, kan het allemaal van dit soort dingen,
het kan doen staart recursie.
In PHP je niet van plan om dat voordeel te krijgen
omdat het slechts gaat om het uitvoeren van lijn beginnen met het regel voor regel,
en het niet echt herkent deze dingen zo gemakkelijk
omdat het niet 1 grote compilatie pas over de zaak en dan uitvoering;
het is gewoon regel voor regel.
Dus dat is de tolk.
>> Terug naar onze dynamische typen: pretty cool, he?
U zeker niet kon doen dat in C!
Nu, kijk of je kunt achterhalen van de aard van elk van de volgende waarden.
Zie deze als referentie.
Dus 3,50. Wat soort denk je dat gaat worden?
Hier zijn de soorten die we hebben.
We hebben bools, integers, floating points, strings, arrays, objecten,
en dan middelen, die is een soort van vaag.
Ik denk dat er hier eigenlijk een voorbeeld.
Dan is er nog NULL. NULL is een speciaal type.
In tegenstelling tot de C waar NULL is slechts een wijzer met het adres 0,
in PHP, NULL is zijn eigen soort, waar de enige geldige ding van dat type is NULL.
Dit is veel nuttiger voor foutcontrole.
In C waar we dit probleem waar als u terugkeert NULL,
betekent dat je een NULL pointer terug te keren of het gebruik van NULL aan een fout betekenen
of dat alles verwarring hadden we op een gegeven moment.
Hier, terug NULL betekent over het algemeen fout.
Een heleboel dingen ook return false voor fouten.
Maar het punt is de NULL-type, het enige wat van de NULL-type is NULL.
Dan terugbellen is als kun je enkele anonieme functies.
Je hoeft niet de functie een naam te geven, maar je hoeft niet hier te gaan met dat.
Kijkend naar de types die ze verwachten dat we weten,
wat denk je van het type van 3,50 is? >> [Student] Float.
Ja.
Dus dan hier, wat denk je het van dit type is? >> [Student] Array.
Ja. De eerste was float, de tweede is een array.
Merk op dat deze array niet als een C-array
waar je index heeft 0 enige waarde heeft, index 1 heeft een bepaalde waarde.
Hier de indices a, b en c en de waarden 1, 2 en 3.
In PHP is er geen verschil tussen een associatieve array en op slechts een regelmatige reeks
als je zou denken in C.
Er is alleen dit, en onder de motorkap een regelmatige array is gewoon een associatieve array
waarbij 0 kaarten om een ​​waarde op dezelfde manier een kaarten om een ​​bepaalde waarde.
Om deze reden, kan PHP behoorlijk slecht zijn voor echt snel code / benchmarking dingen
omdat in C wanneer u gebruik maakt van een array je weet dat het openen van een lid is constante tijd.
In PHP toegang tot een lid is die weet hoeveel tijd?
Het is waarschijnlijk constant als het hashes correct.
Wie weet wat het werkelijk doet onder de motorkap?
Je moet echt kijken naar de implementatie om te zien hoe het gaat om te gaan met dat.
Dus dan fopen.
Ik denk dat hier laten we gewoon PHP handleiding fopen te kijken naar de return type.
We zien hier dat u kunt kijken op vrijwel elke functie in de PHP handleiding
en dit is een soort van de man-pagina van PHP.
De return type gaat worden bron.
Dat is waarom ik heb het opgezocht, omdat we niet echt te definiëren bron.
Het idee van hulpbronnen, in C je soort hebt een FILE * of wat dan ook;
in PHP de resource is uw FILE *.
Het is wat je gaat worden het lezen van, het is wat je gaat worden schriftelijk aan.
Het is meestal extern, dus het is een bron die u dingen kunt trekken uit en gooi dingen te.
En tot slot, wat is de aard van de NULL? >> [Student] NULL.
Ja. Dus het enige dat is NULL NULL is.
NULL NULL is.
>> Een kenmerk van het type PHP-systeem (ten goede of ten kwade) is de mogelijkheid om soorten jongleren.
Wanneer u een lijn van PHP-code die waarden van verschillende types combineert schrijven,
PHP zal proberen om de verstandige ding te doen.
Probeer elk van de volgende regels PHP code. Wat is afgedrukt?
Is het wat je verwacht? Waarom wel of waarom niet?
Dit feit over PHP is wat maakt het wat wij noemen zwak getypt.
Zwak getypt en sterk getypt,
Er zijn verschillende toepassingen voor deze termen,
maar de meeste mensen gebruiken zwak getypt en strongly typed om dit soort dingen betekenen
waarbij ("1" + 2), dat werkt.
In C, dat niet zou werken.
Je kunt je voorstellen dat niet werkt.
Veel mensen verwarren dynamische typen en zwakke typering en statische typen en sterke typering.
Python is een ander voorbeeld van een taal die dynamisch is getypt.
U kunt gooien soorten in de variabelen en het gaat om te bepalen tijdens runtime
een fout gecontroleerd te worden.
In Python het gaat om deze uit te voeren en het zal zien ("1" + 2);
en dit zal mislukken, omdat het zegt dat je niet toevoegen van een string en een integer.
In PHP, dat is net zo dynamisch getypt, zal dit niet nalaten.
Zwak typen heeft te maken met het feit dat dingen doet met types
die niet echt noodzakelijk zinvol.
Dus ("1" + 2), ik kan me voorstellen dat dat de string 12, ik kan me voorstellen dat de string 3,
Ik kan me voorstellen dat het gehele getal 3.
Het is niet per se goed gedefinieerd, en we waarschijnlijk gaan hier te zien
dat wanneer we af te drukken ("1" + 2), het gaat waarschijnlijk om uiteindelijk op een verschillende
dan afdrukken (1 + "2").
En dit heeft de neiging om, in mijn mening, voor het erger.
Hier kunnen we proberen deze.
Een ander trucje over PHP is dat je niet hoeft om daadwerkelijk in het bestand schrijven.
Het maakt zijn voer je dit commando mode.
Dus php-r, dan kunnen we gooien in het commando hier:
"Print ('1 '+ 2)," en ik zal een nieuwe lijn te gooien.
Deze gedrukte 3.
Het lijkt erop dat deze wordt afgedrukt 3 en het is het gehele getal 3.
Dus laten we nu de andere kant op proberen rond:
"Print (1 + '2 ');
We krijgen 3, en wordt het ook gaat worden geheel getal 3? Ik heb eerlijk gezegd geen idee.
Het lijkt erop dat dat consistent is.
Er is nooit enige kans van het feit dat het de string 12 of iets dergelijks
omdat PHP, in tegenstelling tot JavaScript en Java ook,
heeft een aparte operator voor concatenatie.
Aaneenschakeling in PHP is dot.
Dus afdrukken (1 '2 '.); Gaat om ons 12.
Dit leidt meestal tot verwarring waar mensen proberen iets te doen, zoals str + =
iets anders dat ze willen op voeg toe aan het einde van hun string, en dat gaat mislukken.
Je moet str doen. =
Dus vergeet niet concatenatie in PHP is een punt.
Andere dingen om te proberen: drukken ("CS" + 50);
Ik heb u verteld dat er geen hoop dat dit leidt tot CS50
aangezien aaneenschakeling niet +.
Wat denk je dat dit gaat om uiteindelijk op een?
Ik ben eerlijk gezegd heb absoluut geen idee.
Het lijkt erop dat het is gewoon 50.
Het ziet de string, en ik wed dat als we 123CS -
Het ziet de eerste reeks, probeert te lezen een geheel getal van het of een nummer uit het.
In dit geval ziet 123CS.
"Dat niet zinvol als een geheel getal, dus ik ga gewoon te denken aan 123."
Dus 123 + 50 gaat worden 173.
En hier begint het lezen van deze als een geheel getal.
Het doet er niet iets te zien, dus het gewoon als 0 behandeld. Dus 0 + 50 gaat worden 50.
Dit Ik neem aan dat gaat om iets dergelijks te doen.
Ik denk 99.
Ja, omdat het gaat om de eerste te nemen -
Zo 99.
Hier (10/7), als dit C, wat zou dat terug?
[Student] 1. >> Ja, zou het 1 omdat 10/7 verdeelt 2 gehele getallen.
Een geheel getal gedeeld door een geheel getal gaat een integer terug.
Het kan niet terugkeren 1 punt wat dat ook zou zijn, dus het is gewoon op 1 terug te keren.
Hier afdrukken (10/7), het gaat om daadwerkelijk te interpreteren dat.
En dat betekent dat als je echt wilt integer afronding en dat soort dingen doen, zoals dat,
u de afdrukken (vloer (10/7)) doen;
In C is het waarschijnlijk raar dat je regelmatig kunt vertrouwen op integer truncatie,
maar in PHP kun je niet want het zal automatisch veranderen in een vlotter.
En dan (7 + true); wat denk je dat gaat worden?
Ik gok 8 als het gaat om echte interpreteren als 1.
Het lijkt erop dat het is 8.
>> Dus alles wat we hebben gedaan in de laatste 10 minuten moet je absoluut nooit doen.
U ziet code die dit doet.
Het hoeft niet zo eenvoudig als deze.
Je zou kunnen hebben 2 variabelen, en 1 variabele toevallig een string
en de andere variabele toevallig een int, en dan moet je bij elkaar optellen van deze variabelen.
Omdat PHP wordt dynamisch getypt en zal elk type controle niet voor u doen
en omdat het zwak getypt en omdat het gewoon automatisch samen te gooien deze dingen
en alles zal gewoon werken, is het moeilijk om zelfs weten dat deze variabele moet een string nu,
dus ik niet toevoegen aan deze variabele, een integer.
Best practice is als een variabele is een string, het voor altijd bewaren als een string.
Als een variabele is een int, het voor altijd bewaren als een int.
Als je wilt om te gaan met gehele getallen en strings,
kunt u gebruik maken varsint - dat is JavaScript nodig.
Intval. Ik doe dit de hele tijd. PHP en JavaScript ik meng alles.
Dus intval gaat de integer waarde van een variabele terug.
Als we passeren in "print (intval ('123 ')), je krijgt 123.
Intval zelf is niet van plan om de cheque voor ons dat het uitsluitend is een geheel getal te doen.
De PHP handleiding, er zijn net zo veel functies die beschikbaar zijn,
dus even ik denk dat wat ik zou gebruiken is in de eerste is_numeric.
Ik gok dat valse geretourneerd.
Dat is een ander ding dat we moeten gaan dan is. ===
Dus is_numeric ('123df '), zou je niet denken dat als is_numeric.
In C zou u itereren over alle tekens
en controleer om te zien of elk teken is het cijfer of wat dan ook.
Hier is_numeric gaat dat voor ons doen,
en het is terug te keren vals.
Dus toen ik dat afgedrukt, afgedrukt niets, dus hier ben ik te vergelijken om te zien,
heb je toevallig niet waar? En dus nu is het af te drukken 1.
Blijkbaar print programma 1 als ware in plaats van af te drukken waar als waar.
Ik vraag me af als ik dat doe print_r. Nee, dat is nog steeds 1.
>> Terug te gaan naar ===, == bestaat nog steeds,
en als je praat met Tommy hij zal zeggen == is perfect in orde.
Ik ga om te zeggen dat == is verschrikkelijk en moet je nooit gebruiken. ==
Het verschil is dat == dingen vergelijkt
waar het kan waar zijn, zelfs als ze niet van hetzelfde type,
terwijl === vergelijkt dingen en eerst controles zijn ze van hetzelfde type?
Ja. Oke, nu ga ik om te zien of ze eigenlijk te vergelijken met gelijk.
Je krijgt rare dingen als 10 is gelijk aan - laten we eens kijken wat dat zegt.
So ('10 '== '1 e1');
Dit geeft true.
Heeft iemand enig gissingen waarom dit geeft true?
Het gaat niet alleen over dat. Misschien is dit een hint.
Maar als ik dat veranderen in een f - verdorie! Ik blijf met dubbele aanhalingstekens.
De reden dat de dubbele aanhalingstekens zijn schreeuwen tegen mij is, want ik heb dit in dubbele aanhalingstekens.
Dus ik kon ontsnappen aan de dubbele aanhalingstekens in hier, maar enkele aanhalingstekens maken het makkelijker.
Dus ('10 '== '1 f1'); wordt niet afgedrukt waar. ('10 '== '1 E1'); print waar.
[Student] Is het hex? >> Het is niet hex, maar het is dichtbij dat het is alsof -
1E1, wetenschappelijke notatie.
Het erkent 1E1 als 1 * 10 ^ 1 of wat dan ook.
Deze getallen zijn gelijk.
Als we dat doen === dan dat het gaat om vals te zijn.
Ik heb eigenlijk geen idee of we doen == hoe zit het met (10 en '10abc ');? Oke. Dus dat is waar.
Dus net als wanneer je (10 + '10abc ') deed, en het zou 20,
here (10 == '10abc); waar.
Nog erger zijn dingen als (valse == NULL); waar is
of (valse == 0); waar is, (valse == []);
Er zijn rare gevallen van - Dat is een van die rare gevallen.
Merk op dat (valse == []); is waar.
('0 '== False); is waar.
('0 '== []); Is vals.
Dus == is op geen enkele wijze transitieve.
een gelijk kan zijn aan b en kan gelijk zijn aan c,
b maar misschien niet gelijk aan c.
Dat is een gruwel voor mij, en je moet altijd gebruik maken. ===
[Student] Kunnen we doen! == Ook? >> [Bowden] Ja.
Het equivalent zou zijn! = En! ==.
Dit is eigenlijk opgevoed in de PSET spec
waar veel functies terugkeer -
De PHP handleiding is goed over.
Het zet in een grote rode doos, "Dit zal valse terugkeren als er een fout opgetreden."
Maar terug 0 is een volkomen redelijke zaak om terug te keren.
Denken aan een functie die naar verwachting een integer terug.
Laten we zeggen dat deze functie wordt verondersteld het aantal regels tellen in een bestand of zoiets.
Onder normale omstandigheden passeert u deze functie een bestand
en het gaat naar een integer die het aantal lijnen vertegenwoordigt terug te keren.
Dus 0 is een volkomen redelijk aantal als het bestand is gewoon leeg.
Maar wat als je passeert het een ongeldig bestand en de functie gebeurt er met return false
als je langs het een ongeldig bestand?
Als je gewoon doen == je niet het differentiëren van de zaak tussen ongeldig bestand en leeg bestand.
Gebruik altijd. ===
Dat is alles wat van.
>> In PHP, de array type is anders dan wat je gewend bent in C.
Inderdaad, kan je al gemerkt hebben dat dit boven toen je zag dat dit van het type array.
De beugel syntax is nieuw met ingang van PHP 5.4, dat is de nieuwste versie van PHP.
Voordat deze moest je altijd scala schrijven ('a' -> 1, 'b' -> 2.
Dat was de constructor voor een array.
Nu PHP is eindelijk gekomen om naar het mooie syntaxis van slechts vierkante haakjes,
dat is gewoon zo veel beter dan array.
Maar gezien PHP 5.4 is de nieuwste versie,
u kunt tegenkomen plaatsen die niet eens PHP 5.3.
In de zomer kwamen we deze kwestie waar PHP 5.3 was wat we hadden op het apparaat,
maar de server dat we allemaal onze klasboek ingezet en legt en al dat spul te
PHP was 5,4.
Niet wetend dat dit, ontwikkelden wij in 5.3, duwde tot 5,4,
en nu ineens geen van onze code werkt
want er is er gebeurd met zijn veranderingen tussen 5.3 en 5.4
die niet backwards compatible,
en we hebben om te gaan en al onze spullen die niet werken voor PHP 5.4 vast te stellen.
Voor deze klasse, omdat het apparaat heeft wel PHP 5.4,
het is prima te gebruiken tussen vierkante haken.
Maar als je op zoek bent naar dingen op op het internet,
als u op zoek bent naar omhoog een soort van array dingen, waarschijnlijk zul je zien
de spreuk uit constructor Array-syntaxis want dat is al sinds PHP is geboren
en vierkante haken syntax is al voor de afgelopen paar maanden
of wanneer 5,4 kwam rond.
Dit is hoe je index.
Net als in C hoe je dat zou doen index tussen vierkante haken als $ array [0], $ array [1], $ array [2],
u index op dezelfde manier als je toevallig om uw indexen zijn snaren.
Dus $ array ['a'] en $ array ['b'].
$ Array [b]. Waarom zou dit verkeerd zijn?
Het zal waarschijnlijk een waarschuwing, maar nog steeds werken. PHP heeft de neiging om dat te doen.
Het heeft de neiging om gewoon, "Ik ga om u te waarschuwen over dit, maar ik ga gewoon om door te gaan
"En doen wat ik kan."
Het zal waarschijnlijk vertalen naar een string,
maar het is mogelijk dat op een bepaald punt in het verleden zei iemand
definiëren b om zijn 'hello world'.
Dus nu b kan een constante en $ array [b] ook daadwerkelijk moeten doen 'hello world'.
Ik denk dat op dit punt, of op zijn minst onze PHP-instellingen,
als u probeert index in een array en die sleutel niet bestaat, zal het mislukken.
Ik denk niet dat het zal je gewoon te waarschuwen.
Of op zijn minst je kunt het zo instellen dat het niet alleen waarschuwen, het is gewoon recht omhoog mislukt.
>> De manier waarop je controleren om te zien of er daadwerkelijk zo'n index is isset.
Dus isset ($ array ['hello world']) zal terugkeren vals.
isset ($ array ['b']) zal terugkeren waar.
U kunt de mix van deze syntaxis.
Ik ben er vrij zeker van wat deze array zou uiteindelijk op een is - We kunnen testen het uit.
Oh, ik heb PHPWord.
Dit is het mengen van de syntaxis waar u specificeren wat de sleutel is
en u niet aangeven wat de sleutel is.
Dus 3 hier is een waarde.
U heeft niet expliciet gezegd wat de belangrijkste zal zijn.
Wat denk je dat de belangrijkste zal zijn?
[Student] 0. >> Ik gok 0 alleen omdat het de eerste die we niet hebben opgegeven.
We kunnen eigenlijk doen een paar van deze gevallen.
Dus print_r is recursief af te drukken. Het drukt het hele array.
Het zou afdrukken subarrays van de matrix of er nog.
Dus print_r ($ array); php.test.php.
Het maakt lijkt het gaf het 0.
Er is eigenlijk iets om hier in gedachten te houden, maar we zullen ze terug te vinden in een tweede.
Maar wat als ik toevallig deze index 1 te maken?
PHP maakt geen onderscheid tussen snaar indices en integer indices,
dus op dit punt dat ik heb zojuist gedefinieerd een index 1 en ik kan zowel $ array [1] en $ array ['1 '] doen
en wordt dezelfde index en dezelfde sleutel.
Dus nu wat denk je dat 3 gaat worden? >> [Student] 2. >> [Bowden] Ik gok 2.
Ja. Het is 2.
Wat als we dit deden is 10, dit is 4? Wat denk je dat de index van 3 gaat worden?
Ik denk 11.
Mijn gok over wat PHP doet - en ik denk dat ik dit eerder gezien -
wordt het blijft gewoon bij wat de hoogste numerieke index het is tot nu toe gebruikt is.
Het zal nooit een string-index toe te wijzen aan 3. Het zal altijd een numerieke index.
Dus het houdt bij de hoogste een het is tot nu toe toegewezen, die toevallig ook 10,
en het gaat tot 11 te geven aan 3.
Wat ik al eerder zei, let op de manier waarop het wordt afgedrukt deze array.
Hij drukt toets 10, toets 4, toets 11, toets d.
Of zelfs laten we het doen -
Ik denk dat ik niet een 0 te zetten, maar het is druk 1, 2, 3, 4.
Wat als ik hier wisselen? Of laten we eigenlijk deze 2 te schakelen.
Nu wordt afgedrukt 2, 1, 3, 4.
PHP arrays zijn niet net als uw gewone hash-tabel.
Het is volkomen redelijk om te denken dat ze hash tabellen 99% van de tijd.
Maar in uw hash tabellen is er geen gevoel van de volgorde waarin dingen werden geplaatst.
Dus zodra je plaats deze in uw hash-tabel,
aannemen dat er geen gelinkte lijst en je kon beoordelen binnen een gekoppelde lijst
die eerst werd ingebracht.
Maar hier zijn we geplaatst 2 eerste en het weet wanneer het printen van de array die 2 eerste komt.
Het maakt niet uitprinten in slechts een willekeurige volgorde.
De technische gegevens structuur die het is gebruikt, is een geordende kaart,
dus het in kaart toetsen om waarden en onthoudt de volgorde waarin deze toetsen werden ingebracht.
Eigenlijk is het om een ​​aantal complicaties waar het is vervelend om daadwerkelijk -
Laten we zeggen dat je een array 0, 1, 2, 3, 4, 5
en je wilt tot het afsluiten van index 2.
Een manier van doen, laten we eens kijken hoe dat eruit ziet.
0, 2, 1, 3, 4.
Unset gebeurt er met unset beide variabelen en array-indices.
Dus unset ($ array [2]);
Nu, wat is dit eruit komt te zien? 2 is gewoon weg, dus dat is prima.
Meer vervelend is als je wilt dingen om daadwerkelijk als een array.
Ik zet willekeurige getallen.
Let nu op mijn indices.
Ik wil dat het gewoon als een C-array waar het naartoe gaat van 0 tot lengte - 1
en ik kan itereren over het als zodanig.
Maar zodra ik de tweede index, wat er in index 3 uitschakelen niet geworden index 2.
In plaats daarvan haalt alleen maar die index en nu ga je 0, 1, 3, 4.
Dit is volkomen redelijk.
Het is gewoon vervelend en je moet dingen als serie splice doen. Ja.
>> [Student] Wat zou er gebeuren als je een for-lus
en je wilde gaan over alle elementen?
Als het 2 hit, zou het ooit op?
Itereren over een array. Er zijn 2 manieren waarop je kunt doen.
U kunt gebruik maken van een gewone for-lus.
Dit is een andere complexiteit van PHP.
De meeste talen, zou ik zeggen, hebben een soort van lengte of len of iets
dat de lengte van een array.
In PHP is het tellen.
Dus count ($ array); $ i + +)
Laten we gewoon print ($ array [$ i]);
Notice: Undefined offset: 2.
Het zal alleen maar mislukken.
Dit is de reden dat, voor het grootste deel, moet u nooit itereren over een array als deze.
Het is misschien overdreven, maar je hoeft nooit itereren over een array als deze
omdat PHP biedt haar foreach syntax waar foreach ($ array als $ item).
Als we nu af te drukken ($ item), - we zullen bespreken in een tweede - dat werkt prima.
De manier waarop foreach werkt is het eerste argument is de array die u itereren over.
En het tweede argument, item, door middel van elke passage van de for-lus
het gaat om op de volgende ding in de array. Dus onthoud de array heeft een order.
De eerste keer door de lus, wordt punt gaat worden 123
dan zal 12 dan zal 13 dan zal 23 dan zal 213.
Dingen krijgen echt raar als je zoiets doen foreach.
Laten we eens kijken wat er gebeurt, want je moet nooit doen.
Wat als we unset ($ array [1]);
Dat is waarschijnlijk werd verwacht.
Je itereren over deze array, en elke keer dat je het uitschakelen van het eerste index.
Dus voor index 0, het eerste wat, item krijgt waarde 0, dus het gaat worden 123.
Maar de binnenkant van de for-lus we uitgeschakeld index 1, dus dat betekent dat 12 is verdwenen.
Zo af te drukken. PHP_EOL.
PHP_EOL is gewoon newline, maar het is technisch gezien meer draagbare
omdat nieuwe regels in Windows verschilt van nieuwe regels op de Mac en UNIX.
Op Windows newline is \ r \ n, terwijl overal elders heeft het de neiging alleen maar om \ n.
PHP_EOL is zodanig geconfigureerd dat het gebruik maakt van wat de nieuwe regel van uw systeem.
Zo af te drukken dat. Laten we niet print_r ($ array) aan het eind.
Ik had geen idee dat dit het gedrag.
Item neemt nog steeds op de waarde 12 ook al hebben we uitschakelen 12 voordat we ooit moet het uit de array.
Niet op mijn woord te nemen op deze, maar het lijkt erop dat foreach maakt een kopie van de array
en dan wordt in punt neemt alle waarden van die kopie.
Dus zelfs als je wijzigt de array in de for-lus,
zal het niet schelen. Het punt zal nemen op de oorspronkelijke waarden.
Laten we het proberen uitschakelen het.
Wat als dit $ array [1] = "hello";
Hoewel we "hallo" put in de array, punt neemt nooit op die waarde.
Er is nog een syntax om loops foreach
waar je 2 variabelen gescheiden door een pijl.
Deze eerste variabele zal de sleutel van die waarde,
en deze tweede variabele gaat exact dezelfde item.
Dit wordt hier oninteressant, maar als we terug gaan naar onze oorspronkelijke geval van "a" -> 1,
'B' -> 1,
hier als we alleen maar herhalen voor elke array als item, wordt punt zal op 1 elke keer.
Maar als we willen ook de toets met het item weten
dan doen we als $ key -> $ item.
Dus nu kunnen we print ($ key. ':'.
Nu is het itereren over en afdrukken van elke sleutel en de bijbehorende waarde.
>> Een extra ding dat we kunnen doen in foreach loops is dat je zou kunnen zien deze syntax.
Ampersands voor namen van variabelen hebben de neiging om hoe PHP referenties doet.
Waar referenties zijn zeer vergelijkbaar met pointers,
u niet beschikt over pointers, zodat u nooit rechtstreeks te maken hebben met het geheugen.
Maar je hoeft referenties waarbij 1 variabele verwijst naar hetzelfde als een andere variabele.
Binnenkant van hier laten we het doen $ item. Laten we terug gaan naar 1, 10.
Laten we $ item + +; Dat bestaat nog steeds in PHP. U kunt nog steeds doen + +.
php.test.php. Ik moet het af te drukken. print_r ($ array);
Wij printen 2, 11.
Als ik had net gedaan foreach ($ array als $ item) dan wordt in punt zal de waarde 1 te zijn
de eerste keer door de lus. Het zal verhoogd 1 naar 2 en dan zijn we klaar.
Dus dan zal het gaan door de tweede passage van de lus en dat item is 10.
Het stappen van punt tot 11, en dan dat is gewoon weggegooid.
Dan hebben we print_r ($ array), en laten we zien dat dit slechts 1, 10.
Dus de stap die we deden was verloren.
Maar foreach ($ array als & $ item)
nu dit artikel is hetzelfde item als dit hier. Het is hetzelfde ding.
Dus $ item + + wordt het wijzigen serie 0.
In principe kun je ook doen $ k -> $ item en je kunt doen $ array [$ k] + +;
>> Dus een andere manier om dat te doen, zijn we vrij om item te wijzigen,
maar dat zal niet veranderen onze oorspronkelijke array.
Maar als we k, dat is onze belangrijkste, kunnen we dan gewoon index in ons aanbod met behulp van die toets
en verhoog dat.
Dit meer rechtstreeks wijzigt onze oorspronkelijke array.
U kunt zelfs doen als een of andere reden je wilde de mogelijkheid om te wijzigen -
Eigenlijk is dit heel redelijk.
Je hebt niet willen hebben om $ schrijven array [$ k] + +,
je wilde ik gewoon te schrijven $ post + +, maar je nog steeds wilde zeggen if ($ k === 'a')
dan verhogen item en vervolgens afdrukken ons aanbod.
Dus nu wat verwachten wij print_r te doen? Welke waarden moet worden afgedrukt?
[Student] 2 en 10. >> [Bowden] Alleen als de sleutel was 'een' weten we eigenlijk af te drukken dat.
>> Je hebt waarschijnlijk zeer zelden of nooit nodig hebt om functies te definiëren in PHP,
maar je zou kunnen zien iets dergelijks waar u een functie definiëren als functie wat dan ook.
Meestal zou je zeggen ($ foo, $ bar) en vervolgens te definiëren dat het wat dan ook.
Maar als ik dit doe, dan betekent dat wat er ook noemt wat dan ook,
wat noemt baz, dus het eerste argument doorgegeven aan baz kan worden gewijzigd.
Laten we $ foo + +;
en de binnenkant van hier laten we het doen Baz ($ item);
Nu zijn we het aanroepen van een functie.
Het argument wordt door verwijzing, wat betekent dat als we wijzigen
we wijzigen het ding dat is doorgegeven inch
En het afdrukken van dit verwachten we dat - tenzij ik messed up syntax - kregen we 2, 11,
dus het was eigenlijk opgehoogd.
Merk op dat we nodig hebben referenties in 2 plaatsen.
Wat als ik dit deed? Wat betekent dit?
[Student] Het zal veranderen. >> Ja.
Item is gewoon een kopie van de waarde in de array.
Dus item verandert op 2, maar de array ['a'] nog steeds 1.
Of wat als ik dit doe?
Nu item wordt verzonden als een kopie naar BaZ.
Dus de kopie van het argument zal worden verhoogd naar 2,
maar item zelf is nooit verhoogd naar 2.
En item is hetzelfde als array beugel wat dan ook,
zodat array werd nooit verhoogd.
Dus zowel die plaatsen nodig hebben.
>> PHP is meestal behoorlijk slim over.
U denkt misschien dat ik wil gaan aan de hand -
Dit was eigenlijk een vraag aan een van de psets.
Het was een Questions.txt ding waar het zei,
Waarom zou u deze struct voorbij aan de hand?
Wat was het antwoord op die?
[Student] Dus je hoeft niet iets groots te kopiëren. >> Ja.
Een struct kan willekeurig groot, en als je langs de struct in als argument
het moet dat hele struct kopiëren door te geven aan de functie,
terwijl als je gewoon langs de struct door middel van verwijzing
dan moet er maar een 4-byte-adres te kopiëren als het argument voor de functie.
PHP is een beetje slimmer dan dat.
Als ik wat functie en ik langs om het een reeks van 1.000 dingen,
betekent dat het gaat te hebben om alle 1.000 van die dingen te kopiëren
door te geven in de functie? Het hoeft niet onmiddellijk doen.
Als de binnenkant van deze functie eigenlijk nooit wijzigt foo,
dus if ($ foo === 'hallo') return true.;
Merk op dat we nooit het argument binnenkant van deze functie gewijzigd,
Dit betekent dat wat werd doorgegeven als foo niet moet worden gekopieerd
omdat het niet modificeren.
Dus de manier waarop PHP werkt is de argumenten worden altijd doorgegeven aan de hand
totdat u daadwerkelijk probeert om het te wijzigen.
Nu als ik zeg $ foo + +, het zal nu een kopie van de originele foo en wijzigen van de kopie.
Dit bespaart tijd.
Als je nooit aanraken deze enorme array, je nooit echt te wijzigen,
het niet nodig om een ​​kopie te maken,
terwijl als we alleen maar zet deze ampersand dat betekent dat het niet eens te kopiëren
zelfs als je wijzigen.
Dit gedrag wordt copy-on-write.
Je zult zien dat op andere plaatsen, vooral als u een besturingssysteem cursus.
Copy-on-write is een vrij gebruikelijke patroon waar je niet nodig om een ​​kopie van iets te maken
tenzij het is eigenlijk aan het veranderen. Ja.
[Student] Wat als je had de toename in de test,
dus slechts 1 element uit 1000 zou moeten worden gewijzigd?
Ik weet het niet zeker.
Ik denk dat het het hele ding te kopiëren, maar het is mogelijk dat het slim genoeg dat -
Eigenlijk, wat ik denk is stel dat we hadden een array die er zo uitziet: $ matrix2 = [
Vervolgens index "a" een array van [1 2 3 4] en index 'b' is een array van wat.
Ik moet komma's tussen al die. Stel je voor er zijn komma's.
Dan 'c' is de waarde 3.
Oke.
Laten we nu zeggen dat we doen $ Baz ($ matrix2);
waar baz niet nemen deze door middel van verwijzing.
Dus $ foo ["c"] + +;
Dit is zo'n voorbeeld waar we matrix2 passeren als argument
en dan is het modificeren van een specifieke index van de array verhogen het.
Ik heb eerlijk gezegd geen idee wat PHP gaat doen.
Het kan gemakkelijk een kopie maken van het hele ding, maar als het is slim,
het zal een kopie maken van deze toetsen waar dit zal zijn aparte waarde hebben
maar dit kan nog steeds naar dezelfde array 1,2,3,4
en dit kan nog naar dezelfde array.
Ik zal iPad het.
We passeren in deze array waar deze man wijst naar 3, deze man wijst naar [1,2,3,4],
deze man wijst naar [34, ...]
Nu dat we het passeren in om baz, zijn we het wijzigen van deze.
Als PHP is slim, kan het gewoon doen -
We moesten nog wat geheugen te kopiëren, maar als er deze enorme geneste subarrays
we hebben geen behoefte aan deze te kopiëren.
Ik weet niet of dat is wat het doet, maar ik kan me voorstellen dat dat te doen.
Dit is ook een vrij grote voordeel van C over PHP.
>> PHP maakt het leven zo veel makkelijker voor een heleboel dingen,
maar je soort heb absoluut geen idee hoe goed het zal presteren
want ik heb geen idee onder de kap als het maken van deze kopieën van de dingen,
oh, is dat gaat om een ​​constante tijd kopie te zijn,
is het gewoon gaat om een ​​aanwijzer te veranderen, gaat het om een ​​belachelijk moeilijke lineaire kopie zijn?
Wat als het niet kan plaats te vinden?
Is het dan nodig om het ophalen van vuilnis lopen om wat meer ruimte te krijgen?
En garbage collection kan willekeurig lang duren.
In C u geen zorgen te maken over deze dingen.
Elke lijn die je schrijft kun je vrij veel verstand over hoe het gaat uitvoeren.
>> Laten we terug kijken naar deze.
Hoe mooi is het dat je niet hoeft om te gaan met hash-functies,
gelinkte lijsten, of iets dergelijks?
Omdat het werken met hash tabellen is zo makkelijk nu, hier is een leuke puzzel om te werken aan.
Open een bestand met de naam unique.php en in te schrijven een PHP-programma
(Ook wel "script").
We hebben de neiging om noemen ze de scripts als ze korte dingen die je draaien op de opdrachtregel.
In principe elke taal die u niet compileren, maar je gaat het programma te starten
op de opdrachtregel, kunt u dat uitvoerbaar script.
Ik kon net zo goed schrijf een C programma dat dit doet,
maar ik noem het niet een script, omdat ik voor het eerst compileren en voer vervolgens de binaire.
Maar dit PHP-programma gaan we een script te bellen.
Of als we schreven het in Python of Perl of Node.js of een van die dingen,
we noemen ze alle scripts, omdat je ze uit te voeren op de opdrachtregel
maar we weten niet compileren.
We kunnen dit doen vrij snel.
We zijn niet van plan om argv gebruiken. Net Laten we blazen doorheen.
Noem het een unieke, een programma schrijven.
U kunt ervan uitgaan dat de ingang een woord per regel bevatten.
In feite zal argv behoorlijk triviaal te gebruiken.
unique.php.
Beginnen bij het begin willen we kijken of we zijn doorgegeven een command-line argument.
Net zoals je zou verwachten argc en argv in C, we hebben nog steeds die in PHP.
Dus if ($ argc! == 2) dan zal ik niet zal gaan over het afdrukken van een bericht of wat dan ook.
Ik zal gewoon af te sluiten, foutcode van 1.
Ik zou ook terug 1.
Zelden in PHP ben je in deze staat, waar we aan toe -
Meestal ben je in een functie genaamd door een functie aangeroepen door een functie genaamd door een functie.
En als er iets mis gaat en je wil gewoon volledig af te sluiten alles,
afslag eindigt net het programma.
Dit bestaat ook in C.
Als je in een functie in een functie in een functie in een functie
en je wilt gewoon vermoorden van het programma, kunt u bellen met exit en het zal gewoon af te sluiten.
Maar in PHP is het nog zelden dat we op dit hoogste niveau.
Meestal zijn we binnen een soort van functie, dus noemen we exit
zodat we niet hoeven terug te keren tot 1 ding die vervolgens realiseert er een fout
zodat weer op als dat erkent dat was een fout.
We willen niet om te gaan met dat, dus af te sluiten (1);
return (1), in dit geval gelijk.
>> Dan wat we willen openen we willen fopen.
De argumenten gaan kijken redelijk vergelijkbaar.
We willen fopen ($ argv [1], en we willen om het te openen om te lezen.
Dat geeft een hulpbron die we gaan f bellen.
Dit lijkt redelijk vergelijkbaar met hoe C doet het behalve dat we niet hoeven te FILE * zeggen.
In plaats daarvan hebben we gewoon zeggen dat $ f. Oke.
Eigenlijk denk ik dat dit zelfs geeft ons een hint over PHP functie genaamd bestand. PHP bestand.
Wat dit gaat doen is lezen een volledig bestand in een array.
Je hoeft niet eens nodig om fopen het. Het gaat om dat te doen voor je.
Dus $ lines = file ($ argv [1]);
Nu alle lijnen van het bestand in lijnen. Nu willen we de lijnen te sorteren.
Hoe kunnen we sorteren de lijnen?
We sorteren de lijnen.
En nu kunnen we afdrukken of wat dan ook.
Waarschijnlijk is de makkelijkste manier is foreach ($ lines als $ line) echo $ lijn;
[Student] Zouden we niet eens kruisen lijnen door te verwijzen naar iets in soort?
Dit is waar soort moeten worden gedefinieerd als functie sort (& $ array).
Wanneer u de functie bel je niet doorgeven door verwijzing.
Het is de functie die zij definieert als het nemen van het als referentie.
Dit is eigenlijk precies wat er mis ging
wanneer we alles naar onze servers toen we gingen 5,3 tot 5,4.
Tot 5,4, dit was heel redelijk.
Een functie heeft niet verwachten dat het als referentie, maar u kunt doorgeven als referentie
dus als de functie gebeurt om het te wijzigen, is het nog gewijzigd.
Met ingang van 5,4, je bent niet de bedoeling om dit te doen.
Dus nu de enige manier waarop je voorbij aan de hand is als de functie expliciet doet.
Als u niet wilt dat om het te wijzigen, dan moet je $ copy = $ lijnen en pas kopie doen.
Dus nu lijnen zullen worden bewaard en een kopie zal worden gewijzigd.
php.unique.php. Ik zou kunnen hebben iets gesloopt.
Onverwachte 'soort'.
Er gaat iets dat dit doet voor ons.
Het is er niet eens.
Let op wanneer u de handleiding die het eerste argument wordt verwacht dat een array zijn gelezen
en het is genomen aan de hand.
Waarom is dit klagen bij mij? Want ik heb deze functie soort nog steeds hier, dat ik niet wil.
Oke, php.unique.php. Ik heb het niet door een argument, want ik heb geen bestand.
Het is php.unique.php op test.php.
Hier is test.php alle afgedrukt in een mooi gesorteerde volgorde.
Merk op dat gesorteerde volgorde is een beetje vreemd voor een code-bestand
omdat al onze lege regels zullen eerst komt
dan zullen al onze 1 niveau inkepingen komen
dan komen al onze geen inkepingen.
Ja. >> [Student] Dus voor de broncode werd niet doorgegeven aan de hand?
Is dat over het algemeen als waarde doorgegeven?
[Bowden] Wanneer u een functie noemen, het is nooit bepaalt of het werd doorgegeven door middel van verwijzing.
Het is de functie-definitie die bepaalt of het werd doorgegeven door middel van verwijzing.
En kijken naar de functie-definitie van soort of gewoon op zoek naar deze,
het duurt het argument door middel van verwijzing.
Dus ongeacht of u het wilt om het te nemen door middel van verwijzing, het doet nemen door middel van verwijzing.
Het wijzigt de array om.
Dit is gewoon niet toegestaan. Het is niet toegestaan ​​om dit te doen. >> [Student] Oh, oke.
[Bowden] Dit is soort gaat lijnen te nemen door middel van verwijzing en het te wijzigen.
En nogmaals, als je niet wilt dat om dat te doen, kunt u een kopie maken van soort.
Zelfs in dit geval, exemplaar is niet echt een kopie van lijnen.
Het wijst alleen maar om het zelfde ding tot het voor het eerst wordt gewijzigd,
waar het eerst naar te aangepast in de sorteerfunctie,
waar, omdat het kopiëren bij schrijven nu een kopie van exemplaar zal worden.
U kunt dit ook doen. Dat is de andere plek waar je kunt zien ampersand.
Je ziet het in foreach loops, zie je het in functie verklaringen,
en je ziet het als gewoon toewijzen van variabelen.
Nu hebben we bereikt niets door dit te doen
omdat kopiëren en lijnen zijn letterlijk hetzelfde.
U kunt gebruik maken van lijnen en kopiëren door elkaar.
U kunt dit doen unset ($ kopie), en dat niet uitgeschakeld lijnen,
je gewoon verliest uw verwijzing naar het zelfde ding.
Dus vanaf dit punt, nu lijnen is de enige manier u toegang tot lijnen.
>> Vragen?
Ja.
[Student] Volledig off topic, maar je hoeft niet te PHP te sluiten met de - >> Dat doe je niet.
Oke.
[Bowden] Ik zou zo ver gaan als te zeggen dat het een slechte gewoonte om ze te sluiten.
Dat is waarschijnlijk een overdrijving, vooral in een script,
maar laten we eens kijken wat er gebeurt als ik dit doe.
Dat deed niets. Wat als ik wilde - [zucht]
Ik moet een argument passeren.
Maak de opname. Ik noemde het verkeerd.
Dus php.unique.php met een argument.
Nu heb ik niet eens nodig.
Ik zal het doorgeven van een geldig argument.
Deze gedrukt wat het ook is afgedrukt.
Ik ben printen kopiëren en kopiëren bestaat niet. De lijnen.
Het gedrukte alles, en dan merk al die rommel hier beneden,
omdat in PHP alles wat zich buiten PHP tags
is gewoon te letterlijk worden afgedrukt.
Daarom HTML, het is zo leuk dat ik kan doen div bla, bla, bla klasse of wat dan ook,
bla, bla, bla en vervolgens doen wat PHP-code en doe dan het einde div.
En nu het afdrukken van dit krijg ik mijn mooie div tot boven, alles wat PHP gedrukt, div onderaan.
Rampzalig als zoiets gebeurt, dat is vrij normaal,
gewoon een verdwaalde nieuwe regel aan de onderkant van het bestand.
Je zou niet denken dat het zou kunnen zijn dat groot van een deal
totdat je bedenkt dat met browsers -
>> Hoe doorverwijzingen werk of eigenlijk elke headers werk,
wanneer u uw verbinding met een website en stuurt het terug al deze headers en dingen die er
achtige respons 200 of reactie sturen of wat dan ook,
headers zijn slechts geldig tot en met de eerste byte van gegevens worden verzonden.
Worden doorgeleid duizenden keren, maar zodra de eerste byte van data verzonden
je bent niet de bedoeling om opnieuw te sturen.
>> Als u een verdwaalde newline onderaan een bestand
en laten we zeggen dat u deze functie gebruikt en dan wil je -
Laten we zeggen dat het een ander bestand dat is index.php en je require_once iets -
Ik kan niet denken aan een goed voorbeeld van.
Het probleem gebeurt wanneer deze lijn aan de onderkant wordt herhaald.
Je wilt niet iets om nog zijn herhaald.
Ook al heb je niet van plan was op iets krijgen echo, is er iets te krijgen echo
en dus nu ben je niet de bedoeling om nog meer headers te versturen
en je gaat om klachten te krijgen.
Je gewoon niet hebben die sluiten tags.
Als u van plan bent om iets te doen met HTML -
en het is heel redelijk te doen hier beneden div wat
en dan op dit punt kun je of je kunt ze niet op.
Het maakt eigenlijk niet uit.
Maar in PHP scripts is het zeldzaam om te sluiten.
Als alles is PHP, absoluut alles,
je niet echt nodig hebt om te sluiten / moet je niet sluiten.
>> Omgaan met strijkers is nog veel leuker dan in C.
In PHP kunt u een string met enkele of dubbele aanhalingstekens.
Met enkele aanhalingstekens kunt u geen gebruik maken van "escape"-sequenties.
Voortdurend ontsnappen, blah, blah, blah.
Dus printf is zeer zeldzaam in PHP.
Ik denk dat ik zou printf gebruiken als ik wilde een soort dingen te doen - in PSET 5 u gebruikt sprintf of wat dan ook.
Maar u wilt 001.jpg 002.jpg en doen.
Dus voor dat soort dingen waar ik eigenlijk de tekst wilt zou ik printf gebruik te formatteren.
Maar anders zou ik gewoon gebruik maken van het aaneenschakelen van tekenreeksen.
Ik heb nooit echt printf te gebruiken.
We zijn net differentiatie van de gegevens tussen enkele aanhalingstekens en dubbele aanhalingstekens.
Het grootste verschil is dat enkele aanhalingstekens, het zal letterlijk worden afgedrukt.
Er is geen char gegevenstype in PHP anders dan C, dus gelijkwaardig is aan deze.
Ze zijn allebei snaren.
En het mooie van een enkel aanhalingsteken strings is dat ik kon zeggen 'hello world!' bla, bla, bla,
$ $ Wooo.
Wat gebeurt er als ik print deze is het zal het letterlijk af te drukken.
Laten zich te ontdoen van al onze spullen.
Dus echo $ str1;
Het letterlijk afgedrukt al die dingen: dollartekens,
backslash n, dat je zou denken zou zijn newlines -
al die dingen het afdrukken letterlijk.
Het enige wat je nodig hebt om te ontsnappen zijn enkele aanhalingstekens
want anders zou denken dat het de enkele aanhalingstekens sluiten.
Dubbele aanhalingstekens, heel anders.
We hebben al zien de syntax highlighting is cluing ons op om wat over te gaan vreselijk mis.
php.unique. Undefined variable: wooo, omdat dit wordt geïnterpreteerd als een variabele genaamd wooo.
Dubbele aanhalingstekens kunt u variabelen in te voegen in -
Laten we zeggen $ naam = "Rob";
Dus echo "Hallo, mijn naam is $ naam!";
Het herkent dit als een variabele.
Toen ik die draaien - en ik zal plaatst u een nieuwe regel - Hallo, mijn naam is Rob! en hello world!
Dit komt omdat ik nooit verwijderd het afdrukken van wooo hierboven.
Er is 1 stap verder je kunt doen.
$ Array = [1, 2, 3];
Wat als ik wil de eerste index van de array af te drukken?
Je doet $ array [0].
De syntax highlighting is een aanwijzing. Wat gaat dit doen?
php.unique.
Hallo, mijn naam is 1! dat is niet wat ik wilde.
Syntax highlighting tegen me gelogen.
Laten we proberen 'een' -> 1, 'b' -> 2.
Dat is hoe ik zou moeten schrijven.
Onverwachte enkele aanhalingstekens (T_ENCAPSED bla, bla, bla, bla, bla).
Het idee is dat het niet dit herkennen als onderdeel van de array.
Het is niet het herkennen dit als array geïndexeerd per brief een.
U wilt dat wordt omgeven door accolades te doen,
en nu wat er in deze accolade worden geïnterpoleerd,
dat is het woord dat we gebruiken voor magische wijze het invoegen van deze variabelen in de juiste plaatsen.
Nu om dit te doen, php.unique, en Hi, mijn naam is 1! zoals verwacht
of Hi, mijn naam is Rob!
Een ding dat is een soort van mooi over enkele aanhalingstekens is dat -
Er is wat kosten voor het interpoleren.
Als u dubbele aanhalingstekens, de tolk moet gaan over deze string,
ervoor te zorgen dat: "O, hier is een variabele. Nu moet ik gaan die variabele te krijgen en hier in te vullen."
Zelfs als u geen gebruik van variabelen,
niets binnenkant van deze dubbele aanhalingstekens moet worden geïnterpoleerd,
maar het zal nog langzamer zijn, want het moet gaan over de dubbele aanhalingstekens
op zoek naar dingen die moeten worden geïnterpoleerd.
Dus enkele aanhalingstekens kan een beetje sneller als er niets moet worden geïnterpoleerd,
en ik de neiging om zelfs enkele aanhalingstekens te gebruiken voor, 'Hallo, mijn naam is'. $ Array ['a'] toch.
Dat zal gelijk zijn aan wat we hebben gehad.
Maar het is een kwestie van voorkeur.
Als u PHP, heb je waarschijnlijk niet de zorg over het verschil in snelheid.
Er is niet genoeg om ze beredeneren te beginnen.
>> Nog een laatste vraag?
>> We eigenlijk niet eens door dit alles heen, maar dit spul was saai.
Het laatste wat wel leuk is in PHP is wanneer je te maken hebt met HTML,
je zult gebruiken het een beetje, zodat de mooie snelkoppeling syntaxis voor het afdrukken van een variabele.
Zonder dat PHP hier, dit heet korte tags.
Officieel vanaf PHP 5.4 wordt dit afgeraden.
Wij raden u aan php te zetten.
Dit wordt nog wel ondersteund, zo kort tags met de <? = Zijn nog steeds perfect in orde.
Het is door ondersteunde standaard, dus u kunt deze gebruiken als je wilt, en ze zijn erg handig.
>> Nog vragen?
Oke.
>> Blijf classy, ​​San Diego.
[Grinnikt]
Bye. [Lacht]
[Applaus] [lacht]
>> [CS50.TV]