[Powered by Google Translate] [8. § - Több Kényelmes]
[Rob Bowden - Harvard University]
[Ez CS50. - CS50.TV]
>> E hét pont jegyzetek lesz elég rövid,
úgyhogy csak megy, hogy tartsa beszél, srácok megy folyamatosan kérdéseket,
és mi megpróbáljuk töltse ki annyi időt, amennyire csak lehetséges.
Sok ember úgy gondolja, hogy ez a Pset nem feltétlenül nehéz, de nagyon hosszú.
A Pset spec maga vesz egy órát olvasni.
Adunk egy csomó SQL amit esetleg kell használni.
Mi végigvezeti Önt egy csomó, így ez nem lehet túl rossz.
Valaki indításakor vagy kész?
Ez az utolsó Pset. Ó, Istenem.
Általában van egy JavaScript egymás után, de naptári változás a dolgok
tesz mindent 1 hét rövidebb, és már nincs egy JavaScript Pset.
Nem tudom, hogy ez hogyan befolyásolja, hogy a JavaScript fog megjelenni a vizsgán
vagy Kvíz 1.
El tudom képzelni, hogy valami olyasmi lesz, amit tudnod kell a magas szintű dolgokat JavaScript,
de nem hiszem, hogy épp neked egyenesen JavaScript-kód
mert nem volt Pset benne.
De ez lesz a cucc a kvíz az értékelést a jövő héten.
>> Szakasz kérdésekre.
Sok ez a cucc kissé rosszul hangzik, de megbeszéljük miért.
Ellentétben a C, PHP egy "dinamikusan-típusú" nyelv. Mit jelent ez, kérdezed?
Nos, búcsút mindazok char, float, int, és sok más kulcsszavakat kell használni
amikor kijelenti változók és függvények C.
PHP-ben egy változó típusát határozza meg az értéket, amelyet ez jelenleg betöltő.
Szóval mielőtt írja be ezt a kódot egy fájlba nevű dynamic.php,
PHP dinamikusan gépelt. Ez igaz.
Nem értek egyet azzal, hogy ez azt jelenti, hogy mondod búcsút char, float, int,
és egyéb kulcsszavakkal.
A pontos különbség dinamikusan tipizált, valamint az alternatív,
amely statikusan gépelt, hogy dinamikusan beírt, az összes típusú ellenőrzés és a cucc
történik futási időben, mivel statikusan gépelt történik fordítási időben.
A szó statikus úgy tűnik, általában azt jelenti, fordításkor dolgokat.
Azt hiszem, vannak más célokra szánt, de C-ben, amikor kijelenti egy statikus változó,
tárolása osztottak ki fordítási időben.
Itt dinamikusan gépelt csak azt jelenti, hogy -
A C-ben ha megpróbál hozzáadni egy karakterlánc és egy egész, amikor fordítani,
ez fog panaszkodni, mert ez fogja mondani, hogy nem lehet hozzáadni int, és a mutató.
Ez csak nem egy érvényes művelet.
Ez egy másik dolog, hogy mi lesz, hogy egy másodperc alatt.
De ez a fajta ellenőrzés, a tény, hogy kifogásolja fordítási időben,
statikus típusú ellenőrzés.
Vannak olyan nyelvek, ahol nem kell mondani, char, float, int, és minden olyan dolog,
de a nyelv meg tudja mondani az összefüggésben a dolog, milyen típusú kellene lennie,
de ez még mindig statikusan beírt.
Tehát, ha veszel 51, OCaml, soha nem kell használni minden ilyen típusú,
de még mindig lesz fordítási időben mondani, ezt nem teheted, mert te összekeverjük egy int és string.
Dinamikusan gépelt csak azt jelenti, hogy valamikor futási időben fogsz kapni a panaszt.
Ha az is használt Java előtt, általában, csaknem bármilyen C-típusú nyelv
lesz statikusan beírni, így a C, C + +, Java, az összes ilyen általában statikusan beírt.
A Java amikor fordítod valamit, és azt mondod,
s karakterlánc megegyezik az új valamit, ami nem egy string,
hogy fog panaszkodni, mert az ilyen típusú, csak nem egyeznek meg.
Ez fog panaszkodni fordítási időben.
De ez is van néhány dinamikus idő dolgot, mint ha megpróbálod leadott valamit
olyan típusú, ami pontosabb, mint a jelenlegi típus
semmit sem tehet fordítási időben, hogy ellenőrizze, hogy a leadott fog sikerülni.
Java is van néhány dinamikus típusú ellenőrzése, hogy amint lesz e kódsort
amikor ez ténylegesen végrehajtó, ez fog csinálni a leadott
ellenőrizze, hogy leadott érvényes volt az első helyen,
és ha nem volt, akkor ez fog panaszkodni, hogy van egy érvénytelen típus.
Dinamikus típusú ellenőrzés.
Írja be ezt egy fájlba nevű dynamic.php.
Dynamic.php.
Én csomagolja, hogy a formázás.
Van egy változó, akkor meg azt, hogy az egész 7,
akkor fogunk nyomtatni, és% s -
Oh, mi nyomtatás típusát, így gettype megy vissza típusa változó.
Mi csak a nyomtatás típusát újra és újra.
Csak php.dynamic.php.
Majd meglátjuk, hogy a változások az integer string Boolean ahogy haladunk keresztül.
A C-ben nincs logikai adat típus is van, nincs karaktersorozat adat típus.
Van char * és logikai csak általában a int vagy char vagy ilyesmi.
PHP-ben ilyen típusú léteznek, és ez az egyik nagy előnye a PHP feletti C -
hogy a string műveletek végtelenül könnyebb PHP-ben, mint a C. Csak dolgozni.
>> Szóval gyere vissza.
Mi futott dynamic.php.
Ez azt mondja a PHP interpreter nevű php, futtatni a PHP kódot dynamic.php.
Ha bármilyen hiba a fájlban, a tolmács fogja mondani!
A tolmács, ez is egy nagy különbség a PHP és a C.
A C-ben meg kell fordítani valamit, majd futtatja azt lefordított fájlt.
A PHP sosem összeállításához semmit.
Tehát a PHP interpreter alapvetően csak olvassa ezt a sorról sorra.
Az üt var = 7, akkor eléri printf akkor üt var majd eltalálja printf és így tovább.
Van egy kis összeállításának csinál, és ez gyorsítja az eredmények
így ha futtatod a szkriptet később meg tudod csinálni néhány,
de alapvetően ez egy soronként ilyesmit.
Ez azt jelenti, hogy sok az optimalizáció, hogy megkapjuk a C,
mint a fordítás, csak általában a fordító tehet egy csomó trükköt az Ön számára.
Ez vegye ki a fel nem használt változók, meg tudja csinálni az összes ilyen dolgot,
meg tudja csinálni farok rekurziót.
A PHP nem fogod, hogy ez az előny
mert ez csak fog kezdeni végrehajtó sorról soronként,
és ez nem igazán ismeri ezeket a dolgokat, mint egyszerűen
mivel ez nem 1 big válogatás át át a dolog, és akkor a végrehajtás;
ez csak soronként.
Szóval ez a tolmács.
>> Vissza a dinamikus gépelési: elég jó, mi?
Te biztosan nem tehette, hogy a C!
Most nézd meg, hogy kitaláljuk, milyen típusú az egyes következő értékek.
Lásd ezt a referencia.
Tehát 3.50. Milyen nem úgy gondolja, hogy ez lesz?
Itt vannak a típusok, amink van.
Van bools, egészek, úszó pontok, vonósok, tömbök, objektumok,
majd a források, ami elég homályos.
Azt hiszem, valójában egy példa itt.
Aztán ott van a NULL. NULL egy speciális típusa.
Ellentétben C ahol NULL csak egy mutató a cím 0,
PHP, NULL saját magát írja, ahol az egyetlen érvényes dolog, az ilyen típusú NULL.
Ez sokkal több hasznos hibaellenőrzés.
A C-ben, ahol volt ez a kérdés, ahol, ha visszatér NULL,
ez azt jelenti, hogy te vissza a NULL pointer vagy használja NULL, jelezve hiba
vagy az összes, hogy zavar volt egy ponton.
Itt vissza NULL általában azt jelenti, hiba.
Egy csomó dolgot is visszatér hamis hiba.
De a lényeg a NULL típus, az egyetlen dolog, amit a NULL típus NULL.
Akkor visszahívási olyan, mint megadhatjuk néhány anonim függvények.
Nem kell, hogy a függvény nevét, de akkor nem kell foglalkozni, hogy itt.
Keresi a típusokat, hogy azok várják tőlünk, hogy tudjuk,
Mit gondolsz, hogy milyen típusú 3,50 van? >> [Hallgató] Float.
Igen.
Tehát itt, mit gondolsz milyen ez? >> [Hallgató] Array.
Igen. Az első volt az úszó, a második egy tömb.
Vegyük észre, hogy ez a tömb nem olyan, mint a C tömb
ahol van index 0-nak valamilyen érték, index 1-nek némi értéke.
Itt az indexek a, b, és c és az értékeket az 1., 2., és 3.
PHP-ben nincs különbség egy asszociatív tömböt, és csak a rendszeres array
ahogy azt gondolni, hogy a C
Már csak ez, és a motorháztető alatt a rendszeres tömb csak egy asszociatív tömbben
ahol 0 térképeket valamilyen érték azonos módon a térképek bizonyos értéket.
Emiatt a PHP elég rossz nagyon gyorsan kód / benchmarking dolgok
mivel a C, ha a 'használ egy tömböt tudja, hogy elérésekor tag konstans idő.
A PHP elérése egy tag, aki tudja, mennyi idő?
Ez valószínűleg állandó, ha kivonatok helyesen.
Ki tudja, mi ez valójában csinál a motorháztető alatt?
Tényleg meg kell nézni a végrehajtás, hogy hogyan is fog foglalkozni.
Akkor fopen.
Azt hiszem, itt most csak a PHP kézikönyv fopen hogy nézd meg a visszatérési típus.
Látunk itt lehet keresni elég sok minden funkciót a PHP kézikönyv
és ez a fajta a man oldalt a PHP.
A visszatérési típus lesz forrás.
Ezért kerestem fel, mert nem igazán határozza erőforrás.
Az ötlet, hogy erőforrás a C akkor milyen van egy FILE * vagy bármi;
A PHP az erőforrás a FILE *.
Ez az, amit akarsz, hogy olvasása, ez az, amit akarsz, hogy írásban.
Ez általában a külső, így ez az erőforrás tudja húzni a dolgokat, és dobja a dolgokat.
És végül, mi a típusa NULL? >> [Hallgató] NULL.
Igen. Így az egyetlen dolog, ami NULL NULL.
NULL NULL.
>> Egyik jellemzője a PHP-féle rendszer (jobb vagy rosszabb), hogy képes zsonglőrködik típusok.
Ha írsz egy sor PHP kód, amely egyesíti értékeket különböző típusú,
PHP megpróbálja csinálni a értelmes dolog.
Próbálja ki mindegyik az alábbi sorokat a PHP kódot. Mi kinyomtatják?
Van-e, amit várt? Miért vagy miért nem?
Ez a tény a PHP-ről az, ami hívjuk gyengén típusos.
Gyengén beírt és határozottan gépelt,
vannak különböző felhasználások esetében ezeket a kifejezéseket,
de a legtöbb ember használja gyengén gépelt és határozottan gépelt jelenti ilyesmit
ahol ("1" + 2), ami működik.
A C-ben, hogy nem fog működni.
El lehet képzelni, ez nem működik.
Egy csomó ember keveredik dinamikus tipizálást és gyenge tipizálása és statikus tipizálása és erős gépelni.
Python egy másik példa egy nyelvet, ami dinamikusan gépelt.
Akkor dobja körül típus változók, és ez fogja meghatározni, futási időben
bármilyen hiba checkings.
A Python ez fog végrehajtani ezt, és azt fogja látni ("1" + 2);
és ez nem fog sikerülni, mert azt mondja, nem adhat hozzá egy karakterlánc és egy egész.
A PHP-ben, ami ugyanolyan dinamikusan gépelt, ez nem sikerül.
Gyenge gépelés köze van a tény, hogy ez a dolgok típusai
hogy nem igazán értelme feltétlenül.
Tehát ("1" + 2), el tudom képzelni, hogy mivel a húr 12, el tudom képzelni azt, hogy a húr 3,
El tudom képzelni azt, hogy az egész 3.
Ez nem feltétlenül jól meghatározott, és mi valószínűleg fog itt látni
hogy amikor nyomtatni ("1" + 2), ez valószínűleg a végén, hogy a különböző
mint a nyomtatás (1 + "2").
És ez általában lenni, véleményem szerint, az még rosszabb.
Itt lehet próbálni ezeket.
Egy másik kis trükk a PHP-ről van akkor nem kell, hogy ténylegesen írni a fájlt.
Ez nem volna futtatni ezt a parancs módba.
Tehát php-r, akkor mi is dobja a parancsban itt:
"Print ('1 '+ 2)," és én dobja az új vonal.
A nyomtatott 3.
Úgy néz ki, hogy kinyomtatja 3 és ez az egész 3.
És most nézzük meg a másik fordítva:
"Print (1 + '2 ');
Kapunk 3, és az is lesz egész 3? Őszintén szólva fogalmam sincs.
Úgy néz ki, hogy az összhangban.
Soha nincs semmi esély rá, hogy a húr 12 vagy ilyesmi
mert a PHP ellentétben JavaScript és a Java is,
külön üzemeltető összefűzésben.
Összefűzése a PHP-ben dot.
Szóval nyomtatás (1. '2 '); Fog adni nekünk 12.
Ez általában zavart okozhat, ahol az emberek megpróbálják ilyet str + =
néhány más dolog, hogy szeretnénk hozzáadni a végéig a string, és ez nem megy.
Annyit kell tennie, str. =
Tehát ne felejtsd el összefűzése a PHP egy pont.
Más dolog, hogy megpróbálja: print ("CS" + 50);
Mondtam már, hogy nincs remény e eredményező CS50
mivel összefűzése nem +.
Mit gondolsz, ez lesz a végén, hogy?
Őszintén szólva fogalmam sincs.
Úgy néz ki, hogy csak 50.
Úgy látja, a húr, és fogadok, ha teszünk 123CS -
Úgy látja, az első string, megpróbálja elolvasni egy egész szám, vagy egy számot is.
Ebben az esetben ez látja 123CS.
"Ez nincs értelme, mint egy egész, úgyhogy csak fog gondolni 123."
Tehát 123 + 50 lesz 173.
És itt kezdődik olvasod ezt, mint egy egész.
Nem látok semmit, úgyhogy ez csak úgy kezeli, mint 0-ra. Szóval 0 + 50 lesz 50.
Ez én vagyok, feltéve fog csinálni valami hasonlót.
Gondolkodom 99.
Igen, mert ez fog tartani az első -
Tehát 99.
Itt (10/7), ha ez a C, mi lenne, hogy vissza?
[Hallgató] 1. >> Igen, lenne, mert 10 1/7 elosztják 2 egész számok.
Egy egész osztva egy egész megy vissza egy egész szám.
Ez nem térhet vissza 1 pont bármi lenne, szóval ez csak megy vissza 1.
Itt nyomtatás (10/7), ez lesz a ténylegesen értelmezni azt.
És ez azt jelenti, hogy ha valóban szeretne csinálni egész kerekítés és ilyesmi,
annyit kell tennie, print (padló (10/7));
A C-ben ez talán furcsa, hogy tud támaszkodni egész csonkolási rendszeresen,
de a PHP nem tudja, mert akkor automatikusan kapcsolja be a float.
És akkor (7 + true); mit gondolsz, hogy lesz?
Azt hiszem 8 ha ez fog értelmezni igaz már 1.
Úgy néz ki, ez 8.
>> Tehát bármit tettünk az elmúlt 10 perc alatt kell teljesen sohasem.
Látni fogja, kód, amely nem ezt.
Nem kell, hogy mivel egyszerű, mint ez.
Lehet, hogy 2 változó, és 1 változó előfordul, hogy egy string
és a többi változó történik, hogy egy int, majd adja hozzá ezeket a változókat együtt.
Mivel a PHP dinamikusan gépelt és ez nem fog semmiféle ellenőrzés az Ön számára
és mivel ez gyengén begépelt, és mivel akkor csak automatikusan dobja ezeket a dolgokat együtt
és minden menni fog, nehéz is tudja, hogy ezt a változót kell lennie húr most,
így nem kell hozzá, hogy ezt a változót, amely egy egész szám.
A legjobb gyakorlat, ha a változó egy string, tartsa, mint egy húr örökre.
Ha egy változó int, tartsa meg, mint egy int örökre.
Ha szeretne foglalkozni egész és vonósok,
tudod használni varsint - ez a JavaScript programot.
Intval. Én ezt minden alkalommal. PHP és JavaScript én keverjük össze mindent.
Szóval intval megy vissza integer értéke változó.
Ha átmegyünk a "print (intval ('123 ')); kapsz 123.
Intval önmagában nem fog csinálni az ellenőrzés számunkra, hogy ez kizárólag az egész.
A PHP kézikönyv, már csak annyi funkciók,
ezért itt azt hiszem, amit én használni az is_numeric először.
Azt hiszem, hogy a visszaadott hamis.
Ez a másik dolog, amit meg kell, hogy menjen át a ===.
Szóval is_numeric ('123df "), akkor nem hiszem, hogy mivel is_numeric.
A C-ben meg kellett volna navigálhat az összes karaktert
, és ellenőrizze, hogy minden egyes karakter számjegy, vagy bármi.
Itt is_numeric fog tenni, hogy nekünk,
és ez visszatérő hamis.
Szóval mikor nyomtatva, hogy nem nyomtatott semmit, úgyhogy itt vagyok összehasonlítva látni,
tudtad történetesen hamis? És így most már nyomtatás 1.
Úgy látszik, hogy kiírja az 1. tényleges nyomtatás helyett igaz, igaz.
Kíváncsi vagyok, ha én print_r. Nem, még mindig nem 1.
>> Visszatérve ===, == továbbra is fennáll,
és ha beszélni Tommy fog mondani == tökéletesen rendben van.
Fogom mondani, hogy == rettenetes, és soha ne használjon ==.
A különbség az, hogy a == hasonlítja dolgok
ahol lehet igaz, ha ők nem ugyanolyan típusúak,
mivel === összehasonlítja a dolgokat, és az első, hogy az ellenőrzések, hogy az azonos típusú?
Igen. Oké, most megyek, hogy ha ténylegesen összehasonlítani egyenlő.
Kapsz furcsa dolgokat, mint 10 megfelel - Lássuk, hogy mit mond.
Tehát ('10 '== '1 e1');
Ezzel visszatér igaz.
Van valakinek találgatások, hogy ez miért ad vissza igaz?
Ez nem csak arról. Talán ez a tipp.
De ha tudom megváltoztatni, hogy az egy f - a fenébe is! Folyton dupla idézőjeleket.
Az ok a dupla idézőjel kiabál velem, mert én már be ezt idézőjelek.
Így tudtam menekülni a dupla idézőjel itt, de aposztrófot könnyebb.
Tehát ('10 '== '1 f1'); nem nyomtat igaz. ('10 '== '1 E1'); kinyomtatja igaz.
[Hallgató] Ez hex? >> Ez nem hex, de közel van, hogy ez olyan, mint -
1E1, tudományos jelöléssel.
Elismeri 1E1 már 1 * 10 ^ 1 vagy bármi.
Azok egyenlő egészek.
Ha így teszünk === akkor lesz hamis.
Igazából fogalmam sincs, ha nem teszünk == mi a helyzet (10 és '10abc ');? Rendben van. Szóval ez igaz.
Szóval, mint amikor te (10 + '10abc '), és lenne 20,
itt (10 == '10abc '); igaz.
Még rosszabb a dolgok, mint a (hamis == NULL); igaz
vagy (false == 0); igaz, (false == []);
Vannak furcsa esetek - Ez egyike azoknak a furcsa eseteket.
Figyeljük meg, hogy (false == []); igaz.
(0 "== false); igaz.
('0 '== []); Hamis.
So == egyáltalán nem tranzitív.
egy koncentráció megegyezhet a b és egy lehet egyenlő a C,
de b nem feltétlenül egyenlő a c.
Ez egy utálatos nekem, és akkor mindig ===.
[Hallgató] Meg tudjuk csinálni! == Is? >> [Bowden] Igen.
Az egyenértékű lenne! = És! ==.
Ez tulajdonképpen hozta fel a Pset spec
ahol sok a funkciók return -
A PHP kézikönyv jó erről.
Ez hoz egy nagy piros négyzet, "Ez lesz return false, ha van egy hiba."
De visszatérve 0 egy tökéletesen ésszerű dolog, hogy visszatérjen.
Gondolj olyan függvény, amely várhatóan visszatér egész.
Tegyük fel, hogy ezt a funkciót kellene számolni a sorok száma a fájl, vagy ilyesmi.
Normális körülmények között, ha át ezt a funkciót egy fájl
és ez megy vissza integer amely a sorok száma.
Szóval 0 egy tökéletesen elfogadható számot, ha a fájl csak üres.
De mi van, ha át is érvénytelen fájlt, és a függvény történik return false
ha át is érvénytelen fájlt?
Ha csak ezt == te nem különbséget az ügy között érvénytelen fájl és üres fájlt.
Mindig ===.
Ez az összes ilyen.
>> A PHP, a tömb típus eltér amit használt a C
Sőt, lehet, hogy már észre ezt a fent említett, amikor látta, hogy ez a típusú tömb.
A konzol szintaxisa új, a PHP 5.4, amely a legújabb verziója PHP.
Mielőtt ez mindig kellett írni array ("a" -> 1, 'b' -> 2.
Ez volt a kivitelező egy tömb.
Most PHP végre magához tér a szép szintaxisa csak szögletes zárójelben
ami csak sokkal jobb, mint tömb.
De figyelembe véve PHP 5,4 a legújabb verzió,
akkor találkozhat helyeket, még csak nem is a PHP 5.3.
Az elmúlt nyár folyamán futott be ezt a kérdést, ha PHP-ben 5,3 volt, mi volt a készülék,
de a szerver, hogy mi telepített minden fokozat könyvet, és küldje el, és minden ilyesmi, hogy
volt a PHP 5.4.
Nem tudta ezt, kifejlesztett 5,3, tolt 5,4,
és most hirtelen egyetlen kódunkat munkák
mert ott történt volna változás között 5,3 és 5,4
amelyek nem kompatibilisek,
és mi kell menni és erősít minden kedves dolog, hogy nem működik a PHP 5.4.
Mert ez az osztály, mert a készülék rendelkezik PHP 5,4,
ez tökéletesen használható szögletes zárójelben.
De ha keresi fel a dolgokat az interneten,
ha keres valamiféle array cucc, valószínűleg fogsz látni
a varázslat out tömb kivitelező szintaxis ettől ez már körül, mivel a PHP-ben született
és szögletes zárójeles formával már körül az elmúlt pár hónapban
vagy amikor 5,4 jött körül.
Ez hogyan index.
Csakúgy, mint a C, hogyan lenne index szögletes zárójelek $ array [0], $ array [1], $ array [2],
Ön index ugyanúgy, ha véletlenül az indexek, hogy szálakat.
Tehát $ array ['a'] és a $ array ['b'].
$ Array [b]. Miért lenne ez baj?
Ez valószínűleg létrehoz egy figyelmeztetést, de még mindig működik. PHP hajlamos erre.
Úgy látszik, hogy csak a "fogok figyelmezteti Önt erről, de én csak megy, hogy megy
", És tegyenek meg mindent tudok."
Ez valószínűleg lefordítani, hogy ez egy string,
de az is lehetséges, hogy egy bizonyos ponton a múltban valaki említett
define b, hogy "Hello World".
Tehát most b lehet állandó és $ array [b] ténylegesen csinál "Hello World".
Azt hiszem, ezen a ponton, vagy legalábbis a PHP beállításait,
ha megpróbál index egy tömb, és hogy a kulcs nem létezik, akkor nem fog sikerülni.
Nem hiszem, hogy ez csak figyelmezteti Önt.
Vagy legalábbis lehet beállítani úgy, hogy nem csak figyelmezteti Önt, csak egyenesen felfelé sikertelen.
>> Az út, hogy ellenőrizze, hogy van valójában egy ilyen index isset.
Szóval isset ($ array ['Hello World']) visszatér hamis.
isset ($ array ['b']) tér vissza igaz.
Akkor keverjük ezeket a szintaxist.
Biztos vagyok benne, hogy ez mit tömb lenne a végén, hogy van - tudjuk tesztelni azt.
Ó, szükségem van PHPWord.
Ezt összekeverjük a szintaxist, ahol megadhatja, mi a kulcs
és nem határozza meg, mi a kulcs.
So 3 itt van egy érték.
Nem kifejezetten azt mondta, hogy mi a legfontosabb lesz.
Mit gondolsz, a legfontosabb lesz?
[Hallgató] 0. >> Gondolom 0 csak azért, mert ez az első, amit nem meghatározott.
Mi lehet ténylegesen egy pár ilyen esetekben.
Szóval print_r a nyomtatás rekurzív. Ez kiírja a teljes tömb.
Ez kinyomtatni subarrays a tömb ha voltak ilyenek.
Szóval print_r ($ array); php.test.php.
Úgy néz ki, mint azt adta 0.
Van valóban valami, hogy tartsa szem előtt van, de mi lesz vissza, hogy a második.
De mi van, ha történik, hogy ez a mutató 1?
PHP nem tesz különbséget a string indexeket és egész indexek,
így ezen a ponton én már csak egy meghatározott index 1 és meg tudom csinálni mind $ array [1] és $ array ['1 ']
és ez lesz az azonos index és ugyanazt a kulcsot.
Tehát most mit gondolsz 3 lesz? >> [Hallgató] 2. >> [Bowden] Gondolom 2.
Igen. Ez 2.
Mi lenne, ha ezt tette a 10, ez a 4? Mit gondolsz az index a 3 lesz?
Gondolkodom 11.
Az a gyanúm, hogy milyen PHP csinál -, és azt hiszem, már láttam ilyet -
Ez csak számon tartja, hogy mi a legnagyobb numerikus index ez eddig alkalmazott van.
Ez soha nem fog rendelni egy string index 3-ra. Ez mindig egy numerikus index.
Így nyomon követi a legmagasabb ez rendelt eddig, ami történetesen 10,
és ez megy, hogy 11-3.
Amit korábban mondtam, észre így is nyomtat ezt a tömböt.
Ez nyomtat gomb 10, gombot 4, 11 billentyű, gombot d.
Vagy még csináljuk -
Azt hiszem, nem terjesztett a 0, de ez Nyomtatásra 1, 2, 3, 4.
Mit tegyek, ha váltani itt? Vagy nézzük valóban váltani ezeket a 2.
Most a nyomtatás 2, 1, 3, 4.
PHP tömbök nem csak, mint a szokásos hash táblát.
Ez teljesen ésszerű azt gondolni rájuk, mint hash táblák 99%-át az időt.
De a hash táblák nincs értelme a sorrendet, amelyben a dolgok behelyezve.
Tehát amint helyezze be a hash tábla,
vállalnak nincs csatolt listán, és meg tudná ítélni egy láncolt lista
amelyet be először.
De itt már ki 2 első és tudja, ha ez kinyomtatott ezt a tömböt, hogy a 2 az első.
Nem nyomtassa ki akármilyen sorrendben.
A műszaki adatok szerkezete, hogy ez használ egy rendezett térkép,
így térképezi kulcsok értékeit, és emlékszik a sorrendet, amely ezeket a kulcsokat is beilleszteni.
Alapvetően ez bizonyos szövődmények, ahol ez bosszantó, hogy valóban -
Tegyük fel, hogy van egy tömb 0, 1, 2, 3, 4, 5
és szeretné kivenni index 2.
Az egyik módja, hogy lássuk, hogy mi néz ki.
0, 2, 1, 3, 4.
Unset történik hatástalanítására egyaránt változók és tömb indexei.
Szóval unset ($ array [2]);
Most mi fog ez kinézni? 2 csak eltűnt, úgy, hogy tökéletesen rendben van.
További bosszantó, ha azt szeretné, hogy a dolgok valójában, mint egy tömb.
Teszek véletlen számokat.
Most már észre a mutatók.
Azt akarom, hogy csak olyan, mint egy C tömb hova megy 0-ról hossza - 1
és én iterációkhoz rajta, mint olyat.
De amint azt hatástalanítsa a második index, mi volt az index 3 nem váltak index 2.
Ehelyett csak eltávolítja említett index, és most megy 0, 1, 3, 4.
Ez teljesen ésszerű.
Ez csak bosszantó, és meg kell csinálni a dolgokat, mint a tömb splice. Igen.
>> [Hallgató] Mi történne, ha volt egy for ciklus
és meg akart menni az összes elemet?
Amikor a hit 2, lenne így valaha?
Iterációjával több mint egy tömb. Van 2 módon lehet csinálni.
Használhatja a rendszeres for ciklus.
Ez egy másik bonyolultságát PHP.
A legtöbb nyelven, azt mondanám, van valamilyen hosszúságú vagy len vagy valami
jelezve a hosszát egy tömb.
PHP-ben ez a szám.
Szóval count ($ array); $ i + +)
Nézzük csak print ($ array [$ i]);
Notice: Undefined offset: 2.
Ez csak megy, hogy nem.
Ez az oka annak, hogy a legtöbb esetben, akkor soha nem kell megismételni több mint egy tömböt, mint ez.
Lehet, hogy túlzás, de soha nem kell megismételni több mint egy tömböt, mint ez
mert a PHP a foreach szintaxist adott foreach ($ array as $ elem).
Most, ha kiírjuk ($ tétel) - we'll beszélje meg a második -, hogy tökéletesen működik jól.
Az út, hogy a foreach dolgozik, az első érv a tömböt, hogy te iterációjával át.
És a második érv, elem segítségével minden lépésben a for ciklus
ez fog tartani a következő dolog, amit a tömbben. Úgy emlékszem, a tömb egy rendelésre.
Az első alkalommal, a for ciklus, elem lesz 123
akkor lesz 12, akkor lesz 13, akkor lesz 23 akkor lesz 213.
A dolgok igazán furcsa, ha valami ilyesmit foreach.
Lássuk, mi történik, mert soha nem csinálni.
Mi lenne, ha unset ($ array [1]);
Ez valószínűleg várható.
Te iterációjával át ezt a tömböt, és minden egyes alkalommal, amikor hatástalanítás az első index.
Így az index értéke 0, az első dolog, elem felveszi értéke 0, így lesz 123.
De belül a for ciklus akkor unset index 1, tehát azt jelenti, hogy a 12 eltűnt.
Tehát nyomtatni. PHP_EOL.
PHP_EOL csak új sor, de ez technikailag könnyebben hordozható
mivel újsor Windows különbözik újsor Mac és UNIX.
A Windows új sor a \ r \ n, mivel mindenhol máshol is inkább csak azért, hogy legyen \ n.
PHP_EOL úgy van kialakítva, hogy az általa használt bármilyen újsor a rendszer.
Tehát, hogy a nyomtatás. Ne print_r ($ array) a végén.
Fogalmam sem volt, hogy ez lenne a viselkedést.
Jogcím még mindig tart az érték 12 még akkor is hatástalanítani 12 előtt, amit valaha kapott, hogy azt a tömböt.
Ne fogd meg a szót, de úgy néz ki foreach másolatot készít a tömbben
majd a tétel veszi az összes értéket adott példány.
Tehát akkor is, ha módosítja a tömb belsejében a hurok,
akkor nem érdekel. Jogcím lesz az eredeti értékeket.
Próbáljuk hatástalanításakor meg.
Mi van, ha ez a $ array [1] = "hello";
Annak ellenére, hogy tegye "hello" a tömb, elem nem veszi fel ezt az értéket.
Van egy másik szintaxis foreach hurok
ahová 2 változó elválasztva egy nyíl.
Ez az első változó lesz a kulcsa az érték,
és ez a második változó lesz pontosan ugyanolyan elemet.
Ez itt érdektelen, de ha megyünk vissza az eredeti esetben az "a" -> 1,
A "b" -> 1,
Itt már csak navigálhat az egyes tömb elem elem lesz 1 minden egyes alkalommal.
De ha azt is szeretnénk tudni, hogy a kulcsot társított tétel
akkor mi as $ kulcs -> $ elemet.
Így most tehetünk print ($ kulcs. ':'.
Most ez iterációjával át, és nyomtatás minden kulcs és a hozzá kapcsolódó értékét.
>> Egy további dolog, amit tehetünk foreach ciklushoz képest lehet látni ezt a szintaxist.
Ampersands mielőtt változó nevek általában hogyan működik PHP hivatkozásokat.
Amennyiben a hivatkozások nagyon hasonló mutató,
nincs mutató, így nem foglalkozik a memória közvetlenül.
De vannak bizonyos hivatkozásokat, ahol az 1 a változó tartalmazza az ugyanaz, mint a másik változó.
Belül itt csináljuk $-tétel. Menjünk vissza az 1-10-ig.
Csináljuk $ tétel + +; Ez még mindig létezik a PHP. Továbbra is csinálni + +.
php.test.php. Meg kell kinyomtatni. print_r ($ array);
Mi nyomtatni 2, 11.
Ha az imént tett foreach ($ array as $ elem), akkor a tétel lesz az 1-es érték
az első alkalommal a hurkon. Ez növekmény 1-2, és akkor kész.
Akkor fog átmenni a második lépés a hurok, és hogy elem 10.
Ez lépésekben elem 11 programot, majd ez csak kidobni.
Aztán print_r ($ array), és nézzük meg, hogy ez csak 1, 10.
Tehát a növekmény tettük elveszett.
De foreach ($ array as & $ elem)
most ez a napirendi pont ugyanazt a tételt, mint ez itt. Ez ugyanaz a dolog.
Tehát $ elem + + a módosító array 0.
Alapvetően, akkor is csinálni $ k -> $ tételt, és meg tudod csinálni $ array [$ k] + +;
>> Tehát egy másik módja az, hogy szabadok vagyunk módosítani elem,
de ez nem módosítja az eredeti tömb.
De ha használja k, ami a legfontosabb, akkor is csak a mi tömb index segítségével, hogy a legfontosabb
és növelni azt.
Ez több közvetlenül módosítja az eredeti tömb.
Akár azt is csinálni, hogy ha valamilyen okból úgy akarta, hogy a képesség, hogy módosítsa -
Valójában ez teljesen ésszerű.
Nem akarjuk, hogy írni $ array [$ k] + +,
Ön csak azt akartam írni, $ elem + +, de még mindig azt akartam mondani, if ($ k === 'a')
akkor növelni elemet, majd nyomtassa ki a tömb.
Akkor most mit várunk print_r csinálni? Milyen értékeket kell nyomtatni?
[Hallgató] 2 és 10. >> [Bowden] Csak akkor, ha a kulcs az volt "a" nem mi valójában, hogy nyomtatni.
>> Valószínűleg nagyon ritkán, ha valaha, meg kell határozni függvények PHP-ben,
de lehet, hogy valami hasonló, ahol meg egy függvényt, mint a funkció bármi.
Általában azt mondanám ($ foo $ bar), majd meghatározza, hogy legyen bármi.
De ha ezt, akkor ez azt jelenti, hogy bármi is felhívja bármi,
függetlenül felhívja BAZ, így az első érv át baz lehet változtatni.
Csináljuk $ foo + +;
és belül itt csináljuk baz ($ elem);
Most hív egy függvényt.
Az érvet hozott hivatkozás, ami azt jelenti, hogy ha módosítja azt
mi módosítja a dolog, hogy vezetünk be
És ez a nyomtatás várunk - ha elrontottam szintaxis - kaptunk 2, 11,
így ténylegesen növekszik.
Figyeljük meg kell utalások 2 helyen.
Mi van, ha én tettem ezt? Mit jelent ez?
[Hallgató] Ez meg fog változni. >> Igen.
Jogcím csak egy másolata az értéket a tömbben.
Szóval elem változik 2, de a tömb ['a'] továbbra is 1.
Vagy mi van, ha tudom ezt megtenni?
Most tétel küldött egy példányt a BAZ.
Tehát a másolat az érvelés lesz eggyel 2,
de a tétel önmagában soha nem növekszik 2-re.
És napirendi pont ugyanaz, mint array konzol bármi,
hogy a tömb soha nem növekszik.
Szóval mindkét helyen szükség van rá.
>> PHP általában elég okos erről.
Azt hihetnénk, hogy azt akarom, hogy adja át a referencia -
Ez volt tulajdonképpen a kérdést az egyik psets.
Ez volt a questions.txt dolog, ha azt mondta,
Miért is szeretnénk átadni ezt a struct hivatkozva?
Mi volt a válasz, hogy az?
[Hallgató] Szóval nem kell másolni valami nagy. >> Igen.
A struct lehet tetszőlegesen nagy, és amikor át a struct az argumentumként
szükséges másolni, hogy egész struct átadni azt a funkciót,
mivel ha csak át a struct hivatkozással
akkor csak meg kell másolni egy 4 byte-os cím az érvet, hogy a funkciót.
PHP egy kicsit okosabb ennél.
Ha van valami funkciója, és átadom neki egy sor 1.000 dolgokat,
ez azt jelenti, hogy ez lesz, hogy másolni 1.000 azokat a dolgokat
átadni azt a funkciót? Nem kell tennie, hogy azonnal.
Ha belül ez a funkció akkor soha nem módosítja foo,
így if ($ foo === 'hello') return true.;
Figyeljük meg mi sosem módosították azt az érvet belül ezt a funkciót,
ami azt jelenti, hogy bármilyen fogadták el a foo nem kell másolni
mert ez nem módosítja azt.
Tehát az út PHP művek az érvek mindig által elfogadott referencia
amíg ténylegesen megpróbálja módosítani azt.
Most, ha azt mondom, $ foo + +, akkor most egy másolatot az eredeti foo és módosítsa a másolatot.
Ez ment egy ideig.
Ha soha nem érinti ez a hatalmas tömb, akkor soha nem módosíthatja,
nem kell, hogy a másolatot,
mivel ha csak hogy ezt a jelet, amely azt jelenti, hogy nem is másolni
akkor is, ha nem módosítja.
Ez a jelenség az úgynevezett copy-on-write.
Látni fogod, hogy más helyen, különösen, ha veszel egy operációs rendszer tanfolyamot.
Copy-on-write egy nagyon megszokott mintát, ahol nem kell másolatot készíteni valamit
kivéve, ha ez nem változik. Igen.
[Hallgató] Mi lenne, ha a növekmény belsejében a vizsgálat,
így csak 1 elem 1000-ből kellene változtatni?
Nem vagyok benne biztos.
Azt hiszem, ez másolja az egész dolog, de lehetséges, hogy ez elég okos ahhoz, hogy -
Igazából, mit gondolok az képzelje el, hogy volt egy tömb, amely így néz ki: $ tomb2 = [
Aztán index 'a' egy tömb [1 2 3 4] és index 'b' egy tömb bármi.
Szükségem van vesszők között, az összes ilyen. Képzeld el vannak elválasztva.
Aztán a "c" az értéke 3.
Oké.
Most mondjuk mi $ baz ($ tomb2);
ha BAZ nem veszi ezt a hivatkozást.
Tehát $ ize ['c'] + +;
Ez olyan példa, ahol mi haladnak tömb2 argumentumként
és akkor azt módosítja egy sajátos indexre mutató növelésével azt.
Őszintén szólva fogalmam sincs, mi a PHP fog tenni.
Könnyen készíthet másolatot az egész dolog, de ha ez az intelligens,
meg fog tenni egy másolatot ezekről a kulcs, ha ez lesz az elkülönült értéke
de ez még mindig mutatnak azonos tömb 1,2,3,4
és ez továbbra is pont ugyanarra a tömb.
Én majd iPad is.
Átmegyünk ezen a tömb, ha ez a fickó pont 3, ez a fickó pontok [1,2,3,4]
ez a fickó pontok [34, ...]
Most, hogy mi vezetjük be a BAZ, mi módosításokra.
Ha a PHP okos, akkor csak csináld -
Még mindig kellett másolni némi memóriát, de ha volt ilyen hatalmas beágyazott subarrays
mi nem kell másolni azokat.
Nem tudom, hogy ez az, amit csinál, de el tudom képzelni, hogy csinálja.
Ez is egy nagyon nagy előnye a C-PHP.
>> PHP teszi az életet, így sokkal könnyebb a sok dolgot,
de ilyen egyáltalán nincs ötlete, hogyan is fog végezni
mert fogalmam sincs, a motorháztető alatt, ha ez, hogy ezeket a másolatokat a dolgokat,
oh, az, hogy lesz egy állandó idő példányt,
Ez csak fog változni 1 mutató, igaz lesz egy nevetségesen nehéz lineáris másolat?
Mi van, ha nem talál helyet?
Vajon akkor kell futtatni szemétgyűjtő, hogy még egy kis hely?
És szemétgyűjtő vehet önkényesen hosszú.
A C-ben nem kell aggódnia, ezeket a dolgokat.
Minden egyes sort írsz akkor elég sok oka arról, hogyan fog végrehajtani.
>> Nézzünk vissza ezeket.
Milyen szép az, hogy nem kell foglalkozni a hash függvények,
kapcsolódó listák, vagy ilyesmi?
Mivel a munka hash táblák olyan könnyű most itt egy szórakoztató puzzle dolgozni.
Nyisd ki nevű fájlt unique.php és benne levelet PHP program
(Más néven a "script").
Hajlamosak vagyunk arra, hogy hívja őket, parancsfájlok, ha ők rövid dolgokat futtatni a parancssorban.
Alapvetően bármilyen nyelven, hogy nem állítanak össze, de mész a futtatáshoz
a parancssorban, akkor hívja, hogy végrehajtható script.
Tudtam éppúgy levelet C program, amely nem ezt,
de én nem nevezném egy forgatókönyvet, mivel először fordítsuk le, majd futtassa a bináris.
De ez a PHP program fogunk hívni a script.
Vagy ha azt írta a Python vagy a Perl vagy Node.js vagy azoknak a dolgoknak,
mi lenne nevezzük őket, mert az összes szkriptet futtatni őket a parancssorból
de nem fordítani őket.
Megtehetjük ezt elég gyorsan.
Nem fogunk használni argv. Nézzük csak fúj keresztül.
Nevezzük egyedi, írni egy programot.
Lehet feltételezni, hogy a bemenet tartalmaz egy szót soronként.
Valójában, argv lesz elég triviális használni.
unique.php.
Az első dolog az első, azt akarjuk, hogy ellenőrizze, mi már eltelt 1 parancssori argumentum.
Ahogy elvárható argc és argv C, még mindig azok, PHP nyelven.
Tehát, ha ($ argc! == 2), akkor nem fogok foglalkozni nyomtat egy üzenetet, vagy ilyesmi.
Én csak kilépéshez, hibakód: 1 db.
Én is return 1.
Ritkán a PHP Önnek ezt az állapotot, ha már itt tartunk -
Általában te egy függvényt hívja a függvény által hívott függvény által hívott függvény.
És ha valami balul sül el, és ön csak akar lépni mindent teljesen,
kilépés csak véget ér a program.
Ez is létezik C.
Ha egy függvény egy funkciót a funkció egy funkció
és azt szeretné, hogy csak ölni a programot, akkor hívja kiléptető és akkor csak kilép.
De PHP ez még ritka, hogy mi vagyunk ezen a legfelső szinten.
Általában bent vagyunk valamilyen funkciót, így nevezzük kilépési
azért, hogy ne kelljen visszatérni up 1 dolog, ami aztán rájön, hogy van egy hiba
annak érdekében, hogy vissza, fel, ha felismeri, hogy hiba történt.
Nem akarjuk, hogy foglalkozzanak ezzel, így a kilépés (1);
visszatérés (1), ebben az esetben az lenne egyenértékű.
>> Akkor mit akarunk nyitni akarunk fopen.
Az érvek fognak csinos hasonló.
Azt akarjuk, hogy fopen ($ argv [1], és azt akarjuk, hogy nyissa meg olvasásra.
Ez visszaadja a forrás, amely fogunk hívni f.
Ez úgy néz ki nagyon hasonlít, hogy hogyan C csinálja csak nem kell mondani FILE *.
Ehelyett mondjuk $ f. Oké.
Igazából, azt hiszem, ez is ad nekünk egy tipp, hogy PHP nevezett funkció fájlt. PHP fájl.
Mi ez fog tenni az olvasni egy egész fájlt egy tömb.
Nem is kell, hogy fopen rá. Úgy fog tenni az Ön számára.
Tehát $ lines = file ($ argv [1]);
Most minden a vonalak a fájl vannak vonalak. Most szeretnénk rendezni a sorokat.
Hogyan tudjuk rendezni a sorokat?
Mi rendezni a sorokat.
És most lehet nyomtatni, vagy bármi.
Talán a legegyszerűbb foreach ($ sor as $ line) echo $ line;
[Hallgató] Nem lenne még azt is át vonalak hivatkozás valamit a sort?
Ez az, ahol sort lehetne meghatározni függvény sort (& $ array).
Ha hívja a funkció nem adja át hivatkozunk.
Ez az a funkció, amely meghatározza azt a szedését, mint referencia.
Ez valójában pontosan mi volt a baj
amikor mindent a mi szerverrel amikor mentünk 5,3-5,4.
Egészen 5,4, ez teljesen ésszerű.
A funkció nem számíthat arra, hogy vegye referenciaként, de akkor add a referencia
így ha a funkció nem történik, hogy módosítsa, ez még mindig módosítani.
Mivel a 5,4, nem kéne ezt tenni.
Tehát most csak úgy át történő hivatkozással, ha a funkció kifejezetten csinálja.
Ha nem akarjuk, hogy módosítsa azt, akkor meg kell tennie $ copy = $ vonalak és jelszó másolatot.
Tehát most irányvonal mentén kell őrizni, és másolatot kell változtatni.
php.unique.php. Én lehet, hogy elrontottam valamit.
Váratlan "sort".
Ott lesz valami, hogy működik ez a számunkra.
Ez még csak nem is ott.
Értesítés, ha elolvassa a kézikönyvet, hogy az első érvet várhatóan egy tömb
és ez által referenciaként.
Miért van ez panaszkodik nekem? Mert van ez a funkció fajta még mindig itt van, hogy nem akarok.
Oké, php.unique.php. Én nem adja át az érvet, mert nekem nincs egy fájlt.
Ez php.unique.php a test.php.
Itt test.php összes kinyomtatott egy szép rendezett sorrendben.
Figyeljük meg, hogy rendezetten egyfajta furcsa egy kódot fájl
mert minden a mi üres sor fog jönni 1.
ezután fog jönni minden kedves 1 szint bemélyedések
akkor gyere minden kedves nincs bemélyedések.
Igen. >> [Hallgató] Tehát a forráskód, hogy nem fogad el referencia?
Van, hogy általában elfogadott érték szerint?
[Bowden] Ha hív egy függvényt, soha nem határozza meg, hogy azt át hivatkozunk.
Ez a függvény definíciójában, amely meghatározza, hogy azt át hivatkozunk.
És nézte a függvény definíciójában a sort, vagy csak nézi most ezt,
veszi az érvet hivatkozunk.
Tehát függetlenül attól, hogy azt akarja, hogy vegye hivatkozással, hogy nem fog rá hivatkozni.
Ez módosítja a tömböt a helyére.
Ez egyszerűen nem lehetséges. Te nem szabad ezt tenni. >> [Hallgató] Ó, oké.
[Bowden] Ez, sort fog tartani vonalakat referencia és módosítja.
Továbbá, ha nem akarja, hogy erre, akkor készítsen egy másolatot a sort.
Még ebben az esetben, másolás nem valójában másolata vonalak.
Csak mutat ugyanaz a dolog, amíg meg nem lesz átalakítva,
ahol az első lesz, hogy módosították a rendezési funkció
ahol, mert a copy-on-levelet, most egy példányát példány fog tenni.
Azt is megteheti ezt. Ez a másik hely látható jelet.
Látod azt a foreach hurok, látod, hogy a funkció a nyilatkozatokat,
és látod, amikor éppen kiosztása változókat.
Most elértünk semmit ezt
mivel a másolás és a vonalak szó szerint ugyanaz a dolog.
Használhatja a sorokat és másolja szinonimaként.
Meg tudod csinálni unset ($ másolat), és hogy nem unset vonalak,
csak elveszíti a hivatkozás az ugyanaz a dolog.
Szóval, ezen a ponton, most vonalak csak így érheti vonalak.
>> Kérdései vannak?
Igen.
[Hallgató] Teljesen off topic, de nem kell, hogy lezárja a PHP-t a - >> Te nem.
Oké.
[Bowden] mennék, amennyire azt mondani, hogy rossz gyakorlat, hogy zárja be őket.
Ez talán túlzás, különösen egy olyan script,
de lássuk, mi történik, ha ezt csinálom.
Ez nem tett semmit. Mi van, ha akarok - [sóhajok]
Azt kell tennie egy érvet.
Lődd le. Hívtam, hogy tévedtem.
Így php.unique.php egy érvet.
Most már nem is kell ezt.
Majd add meg egy érvényes érv.
Ez a nyomtatott függetlenül, hogy ez a nyomtatást.
Én nyomtatás másolás és a másolás nem létezik. Szóval vonalak.
A nyomtatott mindent, és akkor veszi észre ezt a sok kacatot itt lenn,
mert PHP bármit, ami kívül esik a PHP címkék
csak megy a nyomtatandó szó.
Ezért HTML, ez annyira jó, hogy meg tudom csinálni div bla, bla, bla osztály vagy bármi,
bla, bla, bla, majd némi PHP kódot, majd tegye vége div.
És most ez a nyomtatás kapok egy szép div up top, mindent, ami a PHP nyomtatott div alján.
Katasztrofális amikor ilyesmi történik, ami elég gyakori,
Csak egy kóbor újsor alján a fájlt.
Ugye, nem hiszem, hogy lenne olyan nagy ügy
amíg Ön szerint a tény, hogy a böngészők -
>> Hogyan átirányítások munka vagy lényegében bármilyen fejlécet munka,
amikor, hogy a kapcsolat a weboldalt, és küld vissza az összes ezeket a fejléceket és a dolgok
mint a válasz 200 vagy válasz átirányítás, vagy bármi,
fejlécek csak akkor érvényesek, amíg az első byte adat kerül elküldésre.
Átirányíthatod ezerszer, de amint az első bájt az adatok elküldött
nem kéne átirányítani újra.
>> Ha van egy kóbor újsor alján egy fájl
és mondjuk, hogy használja ezt a funkciót, majd a kívánt -
Tegyük fel, hogy ez egy másik fájlt, ami index.php és require_once valamit -
Én nem hiszem, jó példa rá.
A probléma történik, ha ezt a sort az alján lesz visszhangzott.
Nem akarom, hogy bármi is visszhangzott még.
Annak ellenére, hogy nem állt szándékában a semmit egyre visszhangozta, amit nem kap visszhangzott
és így most már nem kéne, hogy küldjön többé fejlécet
és fogsz kapni panaszok.
Csak nem kell a záró tag.
Ha azt tervezi csinál valamit HTML -
és ez tökéletesen elfogadható tenni idelent div függetlenül
majd ezen a ponton lehet, vagy nem tudja magában azokat.
Ez nem igazán számít.
De a PHP szkriptek ez ritka, hogy lezárja azt.
Mikor minden PHP, abszolút mindent,
nem igazán kell, hogy zárja be / ne zárja be.
>> Kezelése húrok sokkal szebb, mint a C
A PHP megadható egy string szimpla vagy dupla idézőjelek közé.
Az aposztrófot ezért nem használhatja a "menekülés" szekvenciák.
Folyamatosan menekülni, bla, bla, bla.
Szóval printf nagyon ritka PHP.
Azt hiszem, akkor használja printf, ha akartam csinálni a fajta dolog - az Pset 5 használt sprintf vagy bármi.
De akarod 001.jpg 002.jpg és.
Tehát ez a fajta dolog, ha én tényleg akarom formázni a szöveget szeretném használni printf.
De különben én csak használni karakterlánc összefűzés.
Én soha nem használja printf.
Mi csak a különbséget az adatok között egységes idézetek és idézőjelek.
A legnagyobb különbség az, hogy szimpla idézőjelet, akkor nyomtatott szó.
Nincs char adattípus a PHP, ellentétben a C, így ez megegyezik e.
Mindketten szálakat.
És a szép dolog aposztróf stringek mondhatnám "hello world!" bla, bla, bla,
$ $ Wooo.
Mi történik, amikor nyomtatni ez kiírja a szó szoros értelmében.
Menjünk megszabadulni az összes cuccot.
Szóval echo $ STR1;
Szó nyomtatott mindezen dolgok: dollár jelek,
backslash n, amit azt hiszem, lenne Újsorok -
az összes ilyen dolgot nyomtat szó.
Az egyetlen dolog, amire szükséged van, hogy elkerülje aposztrófot
mert különben azt hiszem, ez az egyetlen záró idézőjelek.
Idézőjel, teljesen más.
Már látni a szintaxis kiemelés cluing bennünket, hogy mi fog menni borzasztóan rossz.
php.unique. Undefined variable: wooo mert ez értelmezi a változó nevű wooo.
Dupla idézetek segítségével helyezze változók -
Tegyük fel, hogy $ name = "Rob";
Szóval echo "Hi, my name is $ name!";
Elismeri ezt a változót.
Amikor elindítom, hogy - és én helyezzen be egy újsor - Hi, my name is Rob! és hello world!
Ez azért van, mert soha nem eltávolítani a nyomtatás wooo felett.
Van 1 további lépés, amit tehetünk.
$ Array = [1, 2, 3];
Mit tegyek, ha szeretné kinyomtatni az első index a tömb?
Ugye $ array [0].
A szintaxis kiemelés egy nyom. Mit fog ez csinálni?
php.unique.
Hi, my name is 1! ami nem az, amit akartam.
Szintaxiskiemelés hazudott nekem.
Próbáljuk meg az "a" -> 1, 'b' -> 2.
Így szerettem volna megírni.
Váratlan aposztróf (T_ENCAPSED bla, bla, bla, bla, bla.)
Az elképzelés az, hogy ez nem ismeri ezt a részeként a tömbben.
Ez nem ismeri ezt indexelt tömb levélben a.
Azt akarom, hogy a kapcsos zárójelek,
és most mindent, ami ebben a kapcsos zárójel kerül interpolált
amely a szó általunk használt varázslatosan beilleszteni ezeket a változókat a jobb helyeken.
Most ezt, php.unique és Hi, my name is 1! a várt
vagy Hi, my name is Rob!
Egy dolog, hogy ez a fajta szép körülbelül aposztrófot, hogy -
Van néhány költség interpolációs.
Ha az idézőjelek, a tolmács is, hogy menjen át a húr,
ügyelve arra, hogy: "Ó, itt van egy változót. Most mennem kell kap, hogy a változó és helyezze be ide."
Még ha nem használ változókat,
benne semmi ilyen idézőjelek közé kell interpolálni,
de ez még mindig lassabb, mert szüksége van, hogy menjen át az idézőjelek
keresem a dolgokat, amelyeket meg kell interpolálni.
Így aposztrófot lehet egy kicsit gyorsabb, ha semmit sem kell interpolálni,
és én inkább még egyszerű idézőjeleket, a "Hi, my name is." $ Array ['a'] egyébként.
Ez lesz egyenértékű, amit korábban.
De ez egy kérdés preferencia.
Ha a PHP, akkor valószínűleg nem érdekel a sebesség különbség.
Nincs elég értelem őket kezdeni.
>> Bármely végleges még kérdése?
>> Igazából nem is átvészelni az egészet, de ez a cucc volt unalmas.
Az utolsó dolog, hogy ez a fajta jó a PHP-ben, ha dolgunk HTML,
akkor használja egy kicsit, így a szép helyi szintaxis nyomtatásához változó.
Anélkül, hogy PHP itt, ezt nevezzük rövid tag.
Hivatalosan a PHP 5.4, ez elavult.
Javasoljuk, hogy helyezze php.
Ezt továbbra is támogatott, így a rövid tag a <? = Még mindig tökéletesen megfelel.
Ez alapértelmezés szerint támogatott, így ezeket, ahogy szeretné, és ők nagyon kényelmes.
>> Van még kérdése?
Rendben van.
>> Maradj klassz, San Diego.
[Kuncog]
Szia. [Nevet]
[Taps] [nevet]
>> [CS50.TV]