[Powered by Google Translate] [Secció 8 - Més Còmode]
[Rob Bowden - Harvard University]
[Aquesta és CS50. - CS50.TV]
>> Aquestes notes de la secció setmanes seran molt breu,
així que només vaig a seguir parlant, vostès seguiran fent preguntes,
i intentarem omplir el temps tant com sigui possible.
Molta gent pensa que aquest conjunt de processadors no és necessàriament difícil, però és molt llarg.
L'especificació conjunt de processadors es pren una hora per llegir.
Li donem una gran part d'SQL que pugui necessitar per al seu ús.
Explica el procés d'una gran quantitat d'aquesta, pel que no ha de ser massa dolent.
Algú ha començat o acabat?
És el conjunt de processadors passat. Oh, Déu meu.
En general, hi ha un JavaScript, un després d'això, però les coses canvien calendari
fa que tot sigui una setmana més curta, i ja no tenim un conjunt de processadors JavaScript.
No sé com això afecta si JavaScript apareixerà en l'examen
o Qüestionari 1.
M'imagino que serà una cosa semblant al que necessita saber coses d'alt nivell sobre JavaScript,
però dubto que acabava de donar-li directament el codi JavaScript
ja que no han tingut un conjunt de processadors al mateix.
Però això serà matèria per a l'examen pregunta de la setmana que ve.
>> Secció de preguntes.
Moltes d'aquestes coses són una mica mal redactat, però anem a discutir per què.
A diferència de C, PHP és un "tipus dinàmic" del llenguatge. Què vol dir això, et preguntaràs?
Bé, dir adéu a tots aquells flotador char, int, i les paraules clau que vostè necessita utilitzar
en declarar variables i funcions en C.
En PHP, el tipus d'una variable es determina pel valor que s'està duent a terme actualment.
Així que abans d'escriure el codi en un arxiu anomenat dynamic.php,
PHP és tipus dinàmics. Això és cert.
Estic en desacord amb el fet que això vol dir que estem dient adéu a char, float, int,
i altres paraules clau.
La diferència exacta entre els tipus dinàmics i l'alternativa,
que és estàtic de tipus, és que el tipus dinàmics, tota la comprovació de tipus i altres coses
ocorre en temps d'execució, mentre estàtic de tipus ocorre en temps de compilació.
La paraula estàtica en general sembla tenir significats temps de compilació.
Suposo que hi ha altres usos per a ella, però al carrer quan es declara una variable estàtica,
seu emmagatzematge s'assigna en temps de compilació.
Aquí, tipus dinàmics només vol dir que -
En C si intenta afegir una cadena i un enter, quan es compila,
es queixarà perquè dirà que no es pot afegir un enter i un punter.
No és només una operació vàlida.
Aquesta és una altra cosa que arribarem a en un segon.
Però aquest tipus de control, el fet que es queixa en temps de compilació,
és la comprovació de tipus estàtics.
Hi ha llengües en què no necessito dir flotador char, int, i totes aquestes coses,
però el llenguatge pot dir del context del que tipus se suposa que ha de ser,
però segueix sent estàtic de tipus.
Així que si vostè pren 51, Ocaml, no cal utilitzar cap d'aquests tipus,
però seguirà en temps de compilació diu que no pot fer-ho perquè va a barrejar un enter i una cadena.
Tipus dinàmics només significa que en algun moment durant el temps d'execució que en tindrà una queixa.
Si heu utilitzat Java abans, en general, gairebé qualsevol llenguatge de tipus C
serà estàtic de tipus, de manera que C, C + +, Java, tots els que són generalment estàtic de tipus.
En Java en compilar alguna cosa i dius
cadena s és igual a una cosa nova que no és una cadena,
això va a queixar perquè aquests tipus simplement no coincideixen.
Això va a queixar en temps de compilació.
Però també té una mica de temps dinàmic coses com si tracta de llançar alguna cosa
a un tipus que és més específic que el tipus actual,
no hi ha res pot fer en temps de compilació per comprovar si aquest repartiment tindrà èxit.
Java també té algun tipus dinàmic comprovar que tan aviat com es posa a la línia de codi
quan en realitat està executant, que farà el repartiment,
de comprovar si eixa repartiment era vàlid, en primer lloc,
i si no ho era, llavors va a queixar-se que vostè té un tipus no vàlid.
Tipus dinàmic de xecs.
Escriu això en un arxiu anomenat dynamic.php.
Dynamic.php.
Vaig a descomprimir aquest format.
Tenim una variable, que estableix l'sencer 7,
llavors anem a imprimir i% s -
Oh, estem imprimint el tipus de la mateixa, de manera que gettype tornarà el tipus de la variable.
Només estem imprimint el tipus una i altra vegada.
Acabem de php.dynamic.php.
Veurem que canvia de nombre sencer a cadena a Boolean com els que passem.
En C no hi ha cap tipus de dades Boolean, no hi ha cap tipus de dades de cadena.
Hi ha char * i booleans només tendeix a ser int o char o alguna cosa així.
En PHP aquests tipus existeixen, i aquesta és una de les grans avantatges de PHP més de C -
que les operacions de cadenes són infinitament més fàcil en PHP que C. Només treballen.
>> Així que tornar aquí.
Vam córrer dynamic.php.
Això li diu a l'intèrpret de PHP, anomenat php, per executar el codi PHP en dynamic.php.
Si vostè té qualsevol error en l'arxiu, l'intèrpret li dirà!
L'intèrpret, aquesta és una altra gran diferència entre PHP i C.
En C cal compilar alguna cosa i després executar aquest arxiu compilat.
En PHP no compila res.
Així que l'intèrpret PHP és bàsicament llegint aquesta línia per línia.
Es realitza var = 7 llavors es realitza printf llavors es realitza var llavors es realitza printf i així successivament.
Hi ha una mica de compilar ho fa, i l'emmagatzema en memòria cau els resultats
pel que si s'executa l'script més tard que pot fer alguna cosa,
però bàsicament es tracta d'una línia per línia espècie de cosa.
Això vol dir que moltes de les optimitzacions que obtenim en C,
com la compilació, és només en general el compilador pot fer un munt de trucs per a tu.
Pot dur a terme les variables utilitzades, es pot fer tot aquest tipus de coses,
que pot fer la recursió de cua.
En PHP no aconseguiràs aquest avantatge
perquè només començarà a executar línia per línia per línia,
i que en realitat no reconèixer aquestes coses tan fàcilment
ja que no és un pas de gran compilació sobre la cosa i l'execució;
és només línia per línia.
Així que aquest és l'intèrpret.
>> De tornada al nostre tipus dinàmics: molt bé, eh?
Definitivament no podia fer això en C!
Ara, a veure si es pot esbrinar el tipus de cada un dels següents valors.
Veure la referència.
Així 3,50. Quin tipus creus que serà?
Aquests són els tipus que tenim.
Tenim Bools, sencers, punts flotants, cadenes, matrius, objectes,
i recursos, a continuació, que és una espècie de vague.
Crec que en realitat és un exemple aquí.
Després hi NULL. NULL és un tipus especial.
A diferència de C, on NULL és un punter amb l'adreça 0,
en PHP, NULL és el seu propi tipus on l'única vàlid d'aquest tipus és NULL.
Això és molt més útil per a la comprovació d'errors.
En C, on vam tenir aquest problema en el qual si torna NULL,
Vol dir que vostè està tornant un punter NULL o utilitzant NULL per indicar error
o tota la confusió que hi havia en un punt.
En aquest cas, torni NULL significa generalment error.
Un munt de coses també tornarà false per l'error.
Però el punt és el tipus NULL, l'única del tipus NULL és NULL.
Després de devolució de trucada és com es pot definir algunes funcions anònimes.
No ha de proveir la funció d'un nom, però vostè no haurà de bregar amb això aquí.
Quant als tipus que no esperis que sapiguem,
Què et sembla el tipus de 3,50 és? >> [Estudiant] Float.
Si.
Així que aquí, què et sembla el tipus que és això? >> [Estudiant] Array.
Si. La primera va ser flotador, el segon és una matriu.
Tingueu en compte que aquesta sèrie no és com una matriu C
on vostè té l'índex 0 té algun valor, índex 1 té algun valor.
Aquí, els índexs són a, b, i c, i els valors són 1, 2, i 3.
En PHP no hi ha diferència entre una matriu associativa i només una matriu regular
com es podria pensar d'ell en C.
No només això, i sota la caputxa d'una matriu regular és una matriu associativa
on 0 mapes a algun valor de la mateixa manera s'assigna a un cert valor.
Per això, PHP pot ser molt dolent per realment ràpids codi / avaluació comparativa de les coses
ja que en C quan s'utilitza una matriu de saber que l'accés a un membre és la constant de temps.
En PHP per accedir a un membre és qui sap quant de temps?
És probable que sigui constant si hashes correctament.
Qui sap el que està fent en realitat per sota de la caputxa?
Segur que necessitat d'examinar l'aplicació per veure com va a lluitar amb això.
Llavors fopen.
Crec que aquí fopen Instruccions de PHP només per mirar el tipus de retorn.
Veiem aquí pots consultar gairebé qualsevol funció en el manual de PHP
i això és una espècie de la pàgina del manual de PHP.
El tipus de canvi es requerirà molts recursos.
És per això que el vaig buscar, perquè en realitat no definir els recursos.
La idea dels recursos, al carrer que té un tipus de FILE * o el que sigui;
PHP en el recurs és seu arxiu *.
És el que llegirem, que és el que estarem escrivint.
En general és externa, pel que és un recurs que pot tirar coses des i llençar coses a.
I finalment, quin és el tipus de NULL? >> [Estudiant] NULL.
Si. Així que l'única cosa que és NULL és NULL.
NULL és NULL.
>> Una característica del sistema de tipus de PHP (per bé o per mal) és la seva capacitat de fer malabars amb els tipus.
En escriure una línia de codi PHP que combina els valors de diferents tipus,
PHP intentarà fer el més sensat.
Proveu cadascuna de les següents línies de codi PHP. Què està imprès?
És el que esperaves? Per què o per què no?
Aquest fet sobre PHP és el que el fa ser el que anomenem tipus febles.
Tipus febles i fortament tipat,
existeixen diferents aplicacions d'aquests termes,
però la majoria de la gent fa servir tipus febles i fortament tipat en el sentit d'aquest tipus de coses
on ("1" + 2), que funciona.
En C que no anava a funcionar.
Vostè pot imaginar això no funciona.
Moltes persones barregen tipus dinàmics i tipificació feble i tipus estàtics i tipat fort.
Python és un exemple més d'un idioma que s'escriu de forma dinàmica.
Vostè pot llançar al voltant dels tipus de les variables i que determinarà en temps d'execució
les comprovacions d'error.
En Python s'executarà això i veurà ("1" + 2);
i es produirà un error, ja que diu que no es pot afegir una cadena i un enter.
En PHP, que és igual de tipus dinàmics, això no fallarà.
Tipificació feble té a veure amb el fet que fa coses amb tipus
que en realitat no té sentit necessàriament.
Així ("1" + 2), puc imaginar que sent la cadena 12, m'imagino que és la cadena 3,
M'imagino que és el nombre enter 3.
No és necessàriament ben definida, i probablement anem a veure aquí
que en imprimir ("1" + 2), que probablement acabarà sent diferent
d'impressió (1 + "2").
I això tendeix a ser, al meu entendre, per pitjor.
Aquí podem tractar aquests.
Un altre petit truc sobre PHP és que no cal escriure realment l'arxiu.
Sense haver corregut aquesta manera de comandament.
Així php-r, llavors podem llençar l'ordre aquí:
"Print ('1 '+ 2)," i vaig a llançar una nova línia.
Aquest imprès 3.
Sembla que imprimeix 3 i és el nombre enter 3.
Així que ara anem a tractar a l'inrevés:
"Lletra (1 + '2 ');
Tenim 3, i ho està també serà un nombre enter 3? Honestament, no tinc idea.
Sembla que és consistent.
Mai hi ha alguna possibilitat que sigui el 12 cordes ni res d'això
PHP perquè, a diferència de JavaScript i Java també,
té un operador independent per a la concatenació.
Concatenació en PHP és punt.
Així impressió (1 '2 '.), Ens donarà 12.
Això tendeix a crear confusió on la gent tracta de fer alguna cosa com str + =
altra cosa que vulgueu afegir a la final de la cadena, i això va a fracassar.
Que ha de fer str. =
Així que no t'oblidis de concatenació en PHP és un punt.
Altres coses per intentar: print ("CS" + 50);
Ja t'he dit que no hi ha esperança que això impliqui CS50
des concatenació no és +.
Què et sembla que això acabarà sent?
Sincerament, no tenen absolutament cap idea.
Sembla que és només 50.
Ves a la corda, i jo aposto a que si posem 123CS -
Vés a la primera cadena, es tracta de llegir un nombre enter d'ella o d'un codi d 'aquesta.
En aquest cas es veu 123CS.
"Això no té sentit com un enter, així que només vaig a pensar en 123".
Així 123 + 50 serà 173.
I aquí comença a llegir això com un sencer.
No es veu res, de manera que només el tracta com a 0. Llavors, 0 +50 serà 50.
Això que estic assumint que farà alguna cosa semblant.
Estic pensant en 99.
Sí, perquè va a prendre la primera -
Així 99.
Aquí (10/7), si això fos C, quin seria tornar?
[Estudiant] 1. >> Sí, seria una causa 10/7 està dividint dos nombres enters.
Sencer dividit per un enter tornarà un enter.
No es pot tornar un punt qualsevol que sigui, de manera que només tornarà 1.
Aquí impressió (10/7), que interpretarà en realitat això.
I això vol dir que si vostè realment vol fer arrodoniment sencer i coses per l'estil,
que ha de fer print (pis (10/7));
En C és probablement estrany que vostè pot confiar en el truncament sencer amb regularitat,
però en PHP no es pot perquè automàticament es convertirà en un flotador.
I llavors (7 + true); què et sembla que serà?
Suposo 8 si es va a interpretar com una veritat.
Sembla que són les 8.
>> Així que tot el que hem fet en els últims 10 minuts no ha absolutament fer.
Veurà el codi que fa això.
No cal que sigui tan senzill com aquest.
Vostè podria tenir dues variables, i 1 variable passa a ser una cadena
i l'altra variable passa a ser un int, i després s'afegeixen aquestes variables.
A partir de PHP és tipus dinàmics i no farà cap comprovació de tipus per a vostè
I ja que és tipus febles i com s'acaba de llançar automàticament aquestes coses juntes
i tot es va a treballar, és difícil saber fins que aquesta variable ha de ser una cadena ara,
pel que no ha de afegir a aquesta variable, que és un enter.
La millor pràctica és si una variable és una cadena, es mantindrà com una cadena per sempre.
Si una variable és un enter, mantenir com un int per sempre.
Si vostè vol tractar amb nombres enters i cadenes,
pot utilitzar varsint - això és JavaScript.
Intval. Ho faig tot el temps. PHP i JavaScript barrejo tot.
Així intval tornarà el valor sencer d'una variable.
Si passem a "print (intval ('123 ')), s'obté 123.
Intval si mateix no farà el xec per a nosaltres que és exclusivament un enter.
El manual de PHP, hi ha funcions només disponibles per a molts,
asique crec que el que jo faria servir és is_numeric primer.
Suposo que retorna false.
Aquesta és una altra cosa que hem d'anar més és. ===
Així is_numeric ('123df '), no se li ocorreria que a mesura que is_numeric.
En C hauries de iterar sobre tots els caràcters
i comprovar per veure si cada caràcter és el dígit o el que sigui.
Aquí is_numeric farà això per nosaltres,
i es retorna false.
Així que quan em impresa, s'imprimirà res, així que aquí estic comparant a veure,
se t'ha acudit que és falsa? I pel que ara s'està imprimint 1.
Pel que sembla, s'imprimeix 1 com veritable lloc d'imprimir veritable com a veritable.
Em pregunto si ho faig print_r. No, encara ho fa 1.
>> Tornant a ===, == encara existeix,
i si vostè parla amb Tommy dirà == està perfectament bé.
Vaig a dir que == és terrible i mai s'ha d'utilitzar. ==
La diferència és que == compara coses
on pot ser cert fins i tot si no són del mateix tipus,
mentre === compara les coses i primer es comprova que són del mateix tipus?
Sí Bé, ara vaig a veure si realment comparar a ser igual.
Vostè aconsegueix coses rares com 10 és igual a - anem a veure el que diu.
Així que ('10 '== '1 e1');
Retorna true.
Algú té alguna idea per què això torna true?
No es tracta només d'això. Potser això és una indirecta.
Però si puc canviar això a un f - és maleït! Segueixo utilitzant cometes dobles.
La raó de les cometes dobles estan cridant a mi és perquè m'he posat aquesta entre cometes dobles.
Així que podria escapar de les cometes dobles a aquí, però cometes simples fan que sigui més fàcil.
Així que ('10 '== '1 f1'), no s'imprimeix cert. ('10 '== '1 E1'); imprimeix cert.
[Estudiant] És hexadecimal? >> No és hexagonal, però gairebé que és com -
Notació 1E1, científic.
Es reconeix com un 1E1 * 10 ^ 1 o el que sigui.
Aquests són nombres enters iguals.
Si ho fem === llavors serà falsa.
En realitat tinc ni idea de si ho fem == què passa amb (10 i'' 10abc); Està bé. Així que això és cert.
Així com quan ho va fer (10 + '10abc »), i que seria 20,
aquí (10 '10abc == '), és veritat.
Pitjor encara són coses com (fals == NULL); és cert
o (false == 0), és cert, (false == []);
Hi ha casos rars de - Aquest és un d'aquests casos rars.
Observeu que (false == []), és veritat.
('0 '== False), és veritat.
('0 '== []); És fals.
Així == és de cap manera transitiva.
una pot ser igual a B i A pot ser igual a c,
però b pot no ser igual a c.
Això és una abominació per a mi, i sempre s'ha d'utilitzar. ===
[Estudiant] Podem fer-ho! == També? >> [Bowden] Sí
L'equivalent seria! = I! ==.
Això és realment educat en l'especificació de conjunt de processadors
on una gran quantitat de funcions retornen -
El manual de PHP és bo sobre això.
Es posa en una caixa vermella gran "Això retornarà false si hi ha un error."
Però tornant 0 és una cosa perfectament raonable per tornar.
Penseu en qualsevol funció que s'espera que torni un nombre enter.
Suposem que aquesta funció ha de comptar el nombre de línies en un arxiu o alguna cosa.
En circumstàncies normals, es passa a aquesta funció un arxiu
i que va a tornar un nombre sencer que representa el nombre de línies.
Així que 0 és un nombre perfectament raonable si l'arxiu és només buit.
Però el que si se li passa un arxiu no vàlid i la funció passa a retornar false
si se li passa un arxiu no vàlid?
Si vostè acaba de fer == no està diferenciant així entre l'arxiu invàlid i arxiu buit.
Utilitzeu sempre. ===
Això és tot d'ells.
>> En PHP, el tipus de matriu és diferent del que estem acostumats a C.
De fet, és possible que ja han donat compte d'això anteriorment, quan es va adonar que això és de tipus array.
La sintaxi de suport és nou a partir de PHP 5.4, que és la nova versió de PHP.
Abans d'això, sempre havia d'escriure array ('a' -> 1, 'b' -> 2.
Aquest va ser el constructor d'una matriu.
Ara PHP per fi es va decidir a la sintaxi agradable de tot just entre claudàtors,
que és simplement molt millor que la matriu.
Però tenint en compte PHP 5/4 és la versió més recent,
pot trobar llocs que no tenen ni tan sols PHP 5.3.
Durant l'estiu ens trobem amb aquest problema al PHP 5.3 era el que teníem en l'aparell,
però el servidor que despleguem tota la nostra llibreta de qualificacions i presentar i totes aquestes coses a
PHP va ser 5,4.
Sense saber això, es va desenvolupar en el 5,3, empènyer a 5,4,
i ara, de sobte res del nostre codi funciona
perquè allí va passar a haver estat els canvis entre 5,3 i 5,4
que no són compatibles,
i hem d'anar a arreglar totes les nostres coses que no funcionen per PHP 5.4.
Per aquesta classe, ja que l'aparell té PHP 5.4,
és perfectament possible utilitzar claudàtors.
Però si vostè està mirant les coses a Internet,
si vostè està buscant algun tipus de material de matriu, més probable és que vostè va a veure
l'encanteri fora sintaxi array constructor des que ha existit des de PHP va néixer
i la sintaxi de claudàtors ha estat durant els últims dos mesos
o quan es va acostar 5,4.
Aquesta és la forma d'índex.
Igual que en C com ho faria amb índex entre claudàtors com $ array [0], $ array [1], $ array [2],
que l'índex de la mateixa manera si li passa que té els seus índexs ser cadenes.
Així que $ array ['a'] i $ array ['b'].
$ Array [b]. Per què seria dolent?
Probablement va a generar una advertència, però encara funcionen. PHP tendeix a fer això.
Tendeix a poc: "Jo et vaig a advertir sobre això, però jo només vaig a seguir endavant
"I fer tot el que pugui".
És probable que traduir això a una cadena,
però és possible que en algun moment en el passat algú va dir
b definir com 'Hola Món'.
Així que ara b podria ser una constant de matriu i $ [b] en realitat farà 'hola món'.
Crec que en aquest punt, o si més no la nostra configuració de PHP,
si tractes d'índex en una matriu i que la clau no existeix, es produirà un error.
Jo no crec que sigui només un advertiment.
O almenys vostè pot configurar perquè no només t'adverteixo que no només cap amunt.
>> La forma de comprovar si realment existeix aquest índex és isset.
Així isset ($ array ['hola món']) retorna fals.
isset ($ array ['b']) retorna veritable.
Vostè pot barrejar aquestes sintaxi.
Estic bastant segur del que aquesta matriu acabaria sent és - Podem provar-ho.
Oh, necessito PHPWord.
Això és barrejar la sintaxi on s'especifica quina és la clau
i no s'especifica quina és la clau.
Així que aquí 3 és un valor.
No ha dit explícitament quina és la seva clau serà.
Què et sembla la clau serà?
[Estudiant] 0. >> Suposo 0 només perquè és la primera que no s'ha especificat.
De fet, podem fer un parell d'aquests casos.
Així és print_r imprimir recursiva. S'imprimirà tota la matriu.
Seria imprimir submatrius de la matriu si n'hi ha.
Així print_r ($ array); php.test.php.
S'assembla a ella li donava 0.
De fet, hi ha alguna cosa a tenir en compte aquí, però ens posarem en contacte amb ell en un segon.
Però el que si se m'acut fer aquest índex 1?
PHP no fa diferència entre els índexs de cadenes i índexs sencers,
el que en aquest moment m'acaba de definir un índex 1 i puc fer les dues coses array $ [1] i $ array [1 "]
i serà el mateix índex i la mateixa clau.
I ara què creu vostè que 3 serà? >> [Estudiant] 2. >> [Bowden] Estic endevinant 2.
Si. Són les 2.
Què passaria si féssim això és 10, això és 4? Què et sembla l'índex de 3 serà?
Estic pensant en 11.
La meva conjectura pel que fa al que fa PHP - i crec que ho he vist abans -
es tracta simplement d'un seguiment del que el major índex numèric que ha utilitzat fins ara és.
Mai va a assignar un índex de la cadena a 3. Sempre serà un índex numèric.
Per tant, segueix la pista de la més alta està assignada fins ara, que passa a ser 10,
i que donarà 11 a 3.
El que vaig dir abans, observi la manera com s'està imprimint aquesta matriu.
Imprimeix clau 10, clau 4, clau 11, tecla d.
Ni tan sols farem -
Suposo que no va posar un 0, però és la impressió 1, 2, 3, 4.
Què passa si em canvi aquí? O anem a canviar realment aquests 2.
Ara s'imprimeix 2, 1, 3, 4.
Arrays de PHP no són com tu taula hash regular.
És perfectament raonable pensar-hi com taules hash 99% de les vegades.
Però en les taules de hash no té sentit de l'ordre en què les coses es van inserir.
Així que tan aviat com s'insereix en la taula hash,
assumir que no hi ha llista enllaçada i es podia jutjar dins d'una llista enllaçada
que es va inserir primer.
Però aquí inserim 2 primer i sap quan està imprimint aquesta matriu que 2 és el primer.
No imprimir en qualsevol ordre.
L'estructura de dades tècniques que s'està utilitzant és un mapa ordenat,
pel que mapeja claus als valors i recorda l'ordre en què les claus s'insereixen.
Bàsicament es tracta que algunes de les complicacions en què és realment molest -
Diguem que vostè té una matriu 0, 1, 2, 3, 4, 5
i vol treure índex 2.
Una forma de fer-ho, anem a veure el que sembla.
0, 2, 1, 3, 4.
Desactivar passa a desarmar les dues variables i índexs de matriu.
Així unset ($ array [2]);
Ara, què és això semblarà? 2 és només passat, de manera que està perfectament bé.
Més molest és que si vols que les coses siguin realment com una matriu.
Vaig a posar nombres a l'atzar.
Ara fixeu-vos en els meus índexs.
Jo vull que sigui com una matriu C, on es passa de 0 a length - 1
i puc iterar sobre ella com a tal.
Però tan bon punt desarmar el segon índex, el que havia en l'índex 3 no convertit índex 2.
En el seu lloc, només elimina aquest índex i ara te'n vas 0, 1, 3, 4.
Això és perfectament raonable.
És només una molèstia i cal fer coses com entroncament matriu. Si.
>> [Estudiant] Què passaria si tinguessis un bucle for
i que volia revisar tots els elements?
Quan va colpejar dos, seria cedir mai?
Iteració sobre una matriu. Hi ha dues maneres en què pot fer-ho.
Podeu utilitzar un bucle for normal.
Aquesta és una altra complexitat de PHP.
La majoria dels idiomes, jo diria, tenir algun tipus de longitud o llengua o alguna cosa
indica la longitud d'una matriu.
En PHP és comte.
Així count ($ array) $ i +) +
Anem a print ($ array [$ i]);
Notice: Undefined offset: 2.
És només fallarà.
Aquesta és la raó per la qual, en la seva major part, no és necessari per iterar sobre una matriu d'aquesta manera.
Pot ser que sigui una exageració, però que mai necessitat d'iterar sobre un arranjament com aquest
pel fet que PHP ofereix una sintaxi foreach on foreach ($ array com $ item).
Ara bé, si imprimir ($ item); - ens tornarem parlar-ne en un segon - que funciona perfectament bé.
La manera com està treballant foreach és el primer argument és la matriu que s'està interactuant sobre.
I el segon argument, tema, a través de cada pas del bucle for
que prendrà el següent pas en la matriu. Així que recorda que la matriu té una ordre.
La primera vegada que el bucle for, el punt serà 123
llavors serà 12 llavors serà 13 llavors serà 23 llavors serà 213.
Les coses es posen realment estrany quan fas alguna cosa com foreach.
Anem a veure què passa, perquè vostè mai ha de fer això.
Què passaria si unset ($ array [1]);
Això probablement s'esperava.
Ets iterar sobre aquesta matriu, i cada vegada que estiguis desarmat el primer índex.
Així que per l'índex 0, el primer element, pren el valor 0, així que serà 123.
Però dins del bucle for ens unset índex 1, el que significa que 12 s'han anat.
Així imprimir. PHP_EOL.
PHP_EOL és sol salt de línia, però és tècnicament més fàcils de transportar
des salts de línia en Windows és diferent de salts de línia en Mac i UNIX.
En Windows nova línia és \ r \ n, mentre que a tot arreu es tendeix per estar \ n.
PHP_EOL està configurat per utilitzar qualsevol que sigui la nova línia del seu sistema.
Així que imprimir. No cal print_r ($ array) al final.
No tenia ni idea que aquest seria el comportament.
Article encara pren el valor 12 a pesar que desarmar 12 abans que alguna vegada va arribar-hi des de la matriu.
No prengui la meva paraula en això, però sembla que foreach crea una còpia de la matriu
i article assumeix tots els valors d'aquesta còpia.
Així que fins i tot si es modifica la matriu dins del bucle for,
no li importarà. L'article serà enfrontar-se als valors originals.
Tractarem de desarmar aquesta.
I si això és $ array [1] = "hola";
Tot i que posar "hola" a la matriu, mai tema es té en aquest valor.
Hi ha una altra sintaxi per foreach bucles
on poses 2 variables separades per una fletxa.
Aquesta primera variable serà la clau d'aquest valor,
i aquesta segona variable serà el article exacte mateix.
Això no és interessant aquí, però si tornem al nostre cas original de 'a' - 1>,
'B' -> 1,
aquí si simplement iterar per a cada matriu com element, element que serà una cada vegada.
Però si a més volem que coneguin la clau associada a aquest tema
llavors fem com $ key -> $ item.
Així que ara podem fer print ($ key. ':'.
Ara s'està iterant sobre i imprimir cada clau i el seu valor associat.
>> Una cosa addicional que podem fer en bucles foreach és que veu aquesta sintaxi.
Ampersands abans dels noms de variables tendeixen a ser com PHP fa referències.
On les referències són molt similars als punters,
vostè no té punters, de manera que mai ocupar-se de memòria directament.
Però tenim referències on 1 variable es refereix a la mateixa cosa com una altra variable.
Dins d'aquí que farem $ item. Tornem a 1, 10.
Fem $ item + +; Que encara existeix en PHP. Vostè encara pot fer + +.
php.test.php. He de imprimir. print_r ($ array);
S'imprimeixen 2, 11.
Si jo acabava de fer foreach ($ array com $ item) llavors ítem serà el valor 1
la primera vegada a través del bucle. S'incrementarà 1 a 2 i després ja està.
Així que llavors passarà a través de la segona passada del bucle i que el tema és de 10.
S'incrementa l'article a la 11, i després que acaba de llençar.
Després print_r ($ array), i els veurem que això és només una de 10.
Així, l'increment que vam fer va ser perdut.
Però foreach ($ array com & $ item)
ara aquest article és el mateix article com aquest aquí. És la mateixa cosa.
Llavors, $ item + + és la modificació de matriu 0.
Bàsicament, vostè també pot fer $ k -> array $ item i vostè pot fer $ [$ k] + +;
>> Així que una altra manera de fer això, tenim la llibertat de modificar el punt,
però això no modificarà la nostra matriu original.
Però si utilitzem k, que és la clau, llavors podem simplement índex al nostre array usant aquesta clau
i d'incrementar.
Això més directament modifica la nostra matriu original.
Vostè pot fins i tot fer que si per alguna raó vostè volia que la capacitat de modificar -
En realitat, això és perfectament raonable.
No vol haver d'escriure $ array [$ k] + +,
que només volia escriure $ item + + però encara volia dir if ($ k === 'a')
després incrementar article i després imprimir la nostra matriu.
I ara què és el que esperem print_r fer? Quins valors s'han d'imprimir?
[Estudiant] 2 i 10. >> [Bowden] Només si la clau era 'a' és el que realment imprimir això.
>> És probable que molt poques vegades, o mai, cal definir funcions en PHP,
però potser veureu alguna cosa similar en el qual es defineix una funció com qualsevol funció.
En general, vostè diria ($ foo, $ bar) i després definir que sigui el que sigui.
Però si faig això, llavors això vol dir que tot el que demana el que sigui,
l'anomena baz, de manera que el primer argument passat al baz es pot canviar.
Fem $ foo + +;
ia l'interior d'aquí farem baz ($ item);
Ara estem cridant a una funció.
L'argument es pren com a referència, el que significa que si ho modificar
estem modificant el que s'ha passat polz
I aquesta impressió s'espera - si no vaig ficar la pota sintaxi - ens van donar 2, 11,
de manera que s'incrementa realment.
Notificació necessitem referències en 2 llocs.
Què passa si ho va fer? Què vol dir això?
[Estudiant] Es canviarà. Sí >>.
L'article és simplement una còpia del valor de la matriu.
Així element canvia a 2, però la matriu ['a'] encara serà 1.
O què si ho faig?
Ara element s'envia una còpia a baz.
Així que la còpia de l'argument s'incrementa a 2,
però el tema en si mateix mai va ser incrementat a 2.
I el tema és el mateix que la matriu de suport que sigui,
de manera que mai matriu es va incrementar.
Així que aquests dos llocs que necessiti.
>> PHP és en general bastant intel · ligent sobre això.
Es podria pensar que vull passar per referència -
Això era realment una pregunta d'un dels conjunts de processadors.
Era una cosa Questions.txt on diu:
Per què voldria passar aquesta estructura per referència?
Quina va ser la resposta?
[Estudiant] Així que vostè no ha de copiar alguna cosa gran. Sí >>.
Una estructura pot ser arbitràriament gran, i quan es passa l'estructura com a argument
ha de copiar aquesta estructura sencera per passar a la funció,
mentre que si vostè només ha de passar l'estructura per referència
a continuació, només ha de copiar una adreça de 4 bytes a l'argument de la funció.
PHP és una mica més intel · ligent que això.
Si tinc alguna funció i pas a un conjunt de 1.000 les coses,
¿Això vol dir que haurà de copiar tots 1.000 de aquestes coses
per passar a la funció? No ha de fer-ho immediatament.
Si dins d'aquesta funció en realitat mai modifica foo,
així if ($ foo === 'hola') retornarà true.;
Tingueu en compte que en realitat mai va modificar l'interior argument d'aquesta funció,
el que significa que tot el que s'usa per a mai foo ha de copiar
perquè no ho està modificant.
Així que la forma PHP obres són els arguments es passen sempre per referència
fins que realment tractar de modificar-lo.
Ara bé, si per exemple $ foo + + i passarà a fer una còpia de l'original foo i modificar la còpia.
Això estalvia algun temps.
Si mai estàs tocant aquest arsenal massiu, mai en realitat el modifica,
no és necessari per fer la còpia,
mentre que si només cal posar aquest signe que significa que ni tan sols copiar
fins i tot si vostè el modifica.
Aquest comportament s'anomena copy-on-write.
El veurà en altres llocs, sobretot si vostè pren un curs del sistema operatiu.
Copy-on-write és un patró bastant usual en què no cal fer una còpia d'alguna cosa
llevat que s'hagi canviat realment. Si.
[Estudiant] Què passa si vostè tenia l'increment dins de la prova,
tan sols 1 element de 1.000 hauria de ser canviat?
No estic segur.
Crec que seria copiar tota la cosa, però és possible que és prou intel · ligent com això -
En realitat, el que estic pensant és imaginar que tenia una sèrie que són aquestes: $ matriz2 = [
Llavors 'a' índex és una matriu de [1 2 3 4], i l'índex de 'b' és una matriu del que sigui.
Necessito comes entre tots ells. Imagina que no hi ha comes.
Llavors 'c' és el valor 3.
Bé.
Ara diguem que fem $ baz ($ matriz2);
on baz no considera aquesta per referència.
Així que $ foo ['c'] + +;
Aquest és un exemple en el qual s'usa per al'argument matriz2
i després s'està modificant un índex específic de la matriu incrementant.
Honestament no tinc idea del que PHP farà.
Es pot fer fàcilment una còpia de tota la cosa, però si és intel · ligent,
es farà una còpia d'aquestes claus on aquesta tindrà el seu valor diferent
però això encara pot apuntar a la mateixa matriu 1,2,3,4
i això encara pot apuntar a aquesta matriu.
Vaig iPad ella.
Passem en aquesta matriu on aquest noi a 3 punts, això apunta a guy [1,2,3,4],
aquest noi apunta [34, ...]
Ara que ho estem passant a baz, estem modificant això.
Si PHP és intel · ligent, només pot fer -
Encara havia de copiar una mica de memòria, però si no hagués aquests subconjunts niats enormes
no necessitem fer-ne les.
No sé si això és el que fa, però m'imagino fent això.
Això també és un avantatge molt gran de C sobre PHP.
>> PHP fa la vida molt més fàcil per a un munt de coses,
però quin tipus de tenir la més mínima idea de com es durà a terme
perquè no tinc ni idea de per sota de la caputxa quan es tracta de fer aquestes còpies de les coses,
oh, és que serà una còpia constant de temps,
és només canviarà un punter, és que serà una còpia lineal ridículament difícil?
I si no pot trobar l'espai?
Té llavors d'executar la recollida d'escombraries per obtenir espai una mica més?
I la recollida d'escombraries pot prendre arbitràriament llarg.
En C no ha de preocupar per aquestes coses.
Cada línia que s'escriu pot raonar més o menys sobre com es va a realitzar.
>> Anem a mirar cap enrere en aquests.
Que bo és que no has de lluitar amb les funcions hash,
llistes enllaçades, ni res d'això?
Des que treballem amb taules hash és tan fàcil ara, heus aquí un trencaclosques divertit per treballar.
Obriu un arxiu anomenat unique.php i hi escriu un programa PHP
(També conegut com un "script").
Tendim a cridar els scripts si són coses curtes que s'executen en la línia d'ordres.
Bàsicament, qualsevol llenguatge que no compila però vas a executar l'arxiu executable
en la línia de comandes, pot trucar a aquest script executable.
Jo podria molt bé escriure un programa en C que fa això,
però jo no en dic un script des de la primera vegada que compili i executeu el fitxer binari.
Però aquest programa PHP que anomenarem a un script.
O si ho escrivim en Python o Perl o Node.js o qualsevol d'aquestes coses,
ens diem tots els scripts perquè s'executen en la línia d'ordres
però no Debian.
Podem fer això amb bastant rapidesa.
No utilitzarem argv. Anem a volar a través d'això.
Llámelo únic, escriure un programa.
Es pot suposar que l'entrada contindrà una paraula per línia.
En realitat, argv serà bastant trivial d'usar.
unique.php.
Primer el primer, volem comprovar si se'ns ha passat un argument de línia d'ordres.
Tal com era d'esperar argc i argv al carrer, tenim encara els de PHP.
Així que si ($ argc! == 2) llavors no tractaré d'imprimir un missatge o alguna cosa així.
Vaig a sortir, el codi d'error de 1.
També vaig poder tornar 1.
Poques vegades en PHP que es troben en aquest estat on estem -
En general, vostè està en una funció anomenada per una funció anomenada per una funció anomenada per una funció.
I si alguna cosa surt malament i el que desitja és sortir tot del tot,
sortida just acaba el programa.
Això també existeix en C.
Si estàs en una funció en una funció en una funció en una funció
i vol matar només el programa, pot trucar a la sortida i sortirà sol.
Però en PHP és encara més estrany que ens trobem en aquest nivell superior.
En general, estem dins d'algun tipus de funció, pel que anomenem sortida
perquè no hagi de tornar a una cosa que s'adona que hi ha un error
de manera que si torna fins que reconeix que va ser un error.
No volem de lidiar amb això, així que sortir (1);
retorn (1), en aquest cas seria equivalent.
>> Llavors, què volem obrir volem fopen.
Els arguments que es van a veure bastant similar.
Volem fopen ($ argv [1], i volem obrir per a llegir.
Retorna un recurs que anomenarem a f.
Això es veu molt semblant a com ho fa C excepte que no has de dir * FILE.
En el seu lloc, només dir $ f. Bé.
En realitat, crec que fins i tot ens dóna una pista pel que fa a la funció de PHP anomenada arxiu. PHP File.
El que això farà és llegir un arxiu sencer en una matriu.
No tens necessitat de fopen ella. Es farà això per vostè.
Així que $ línies = arxiu ($ argv [1]);
Ara totes les línies de l'arxiu són a les línies. Ara volem ordenar les línies.
Com podem classificar les línies?
Ens ordenar les línies.
I ara podem imprimir-les o el que sigui.
Probablement la forma més fàcil és foreach ($ lines com $ line) echo $ line;
[Estudiant] No ens fins i tot creuar les línies fent referència a alguna cosa a classe?
Aquí és on l'espècie es definiria com una mena de funció (& $ array).
Quan es crida a la funció que no passi per referència.
És la funció que es defineix com a prenent com a referència.
Això és en realitat exactament el que va sortir malament
quan posem tot als nostres servidors quan vam anar 5,3-5,4.
Fins 5,4, això era perfectament raonable.
Una funció no té previst prendre com a referència, però es pot passar per referència
així que si la funció es dóna a modificar, segueix sent modificat.
A partir de 5,4, que no has de fer això.
Així que ara l'única forma de passar per referència és si la funció explícita que fa.
Si vostè no vol que el modifiqui, llavors vostè necessita per fer còpia $ = $ pass línies i còpia.
Així que ara les línies es conservarà còpia i serà canviada.
php.unique.php. Jo podria haver ficat alguna cosa.
Inesperat 'espècie'.
Serà alguna cosa que ho fa per nosaltres.
Ni tan sols hi.
Avís quan vostè llegeix el manual que el primer argument s'espera que sigui una matriu
i es pren com a referència.
Per què es queixen a mi? Perquè tinc aquesta espècie en funció encara aquí que no vull.
Bé, php.unique.php. No em passa un argument perquè no tinc un arxiu.
És php.unique.php a test.php.
Aquí està test.php tots impresos en un ordre ben ordenats.
Tingueu en compte que l'ordre establert és una mica estrany per a un arxiu de codi
perquè totes les nostres línies en blanc serà el primer
llavors vindran tots els nostres osques de nivell 1
després vénen tots els nostres osques no.
Si. >> [Estudiant] Així que el codi font no es passa per referència?
És que generalment passa per valor?
[Bowden] Quan es crida a una funció, mai es determina si es passen per referència.
És la definició de la funció que determina si es passen per referència.
I mirant a la definició de la funció de l'espècie, o simplement buscant en això,
pren l'argument per referència.
Així que, independentment de si desitja que es prengui com a referència, ho fa prendre com a referència.
Es modifica la matriu en el seu lloc.
Això no és només permesa. No té permís per fer-ho. >> [Estudiant] Oh, està bé.
[Bowden] Això, més o menys es prendrà com a referència les línies i modificar-lo.
I de nou, si vostè no vol que faci això, vostè pot fer una còpia de gènere.
Fins i tot en aquest cas, la còpia no és realment una còpia de les línies.
És només apunta al mateix fins que primer és modificat,
on els primers van a modificar en la funció de classificació,
on, perquè és copy-on-write, ara una còpia de l'exemplar que realitzarà.
També pot fer això. Aquest és el lloc que vostè pot veure i comercial.
Ho veus en els bucles foreach, el veus a la declaració de funcions,
i ho veus quan l'assignació a variables.
I nosaltres no hem fet res en fer això
perquè la còpia i les línies són literalment la mateixa cosa.
Vostè pot utilitzar les línies i copiar de manera intercanviable.
Vostè pot fer unset ($ còpia), i que no les línies no definides,
que acaba de perdre la seva referència al mateix.
Així que a partir d'aquest punt, ara línies és l'única manera d'accedir a línies.
>> Preguntes?
Si.
[Estudiant] completament fora de tema, però vostè no ha de tancar PHP amb la opció - >> No ho saps.
Bé.
[Bowden] Jo aniria tan lluny com per dir que és una mala pràctica per tancar.
Això és probablement una exageració, sobretot en un script,
però ja veurem què passa si faig això.
Això no va fer res. Què passa si jo volia - [Sospira]
He de passar un argument.
Dispara. Vaig trucar malament.
Així php.unique.php amb un argument.
Ara ja no tens necessitat d'això.
Vaig a passar un argument vàlid.
Aquest imprès el que és la impressió.
Estic imprimint còpia i la còpia no existeix. Així línies.
S'imprimirà tot, i després es dóna compte tota aquesta brossa aquí baix,
perquè en res PHP que es troba fora de les etiquetes PHP
només voleu imprimir literalment.
És per això que HTML, és tan bonic que puc fer div bla, bla, bla, classe o el que sigui,
bla, bla, bla, i després fer una mica de codi PHP i llavors fer div fi.
I ara això em fa l'efecte de la meva div bonic sobre de la tapa, tot el que PHP imprès, div a la part inferior.
Desastrós quan passa alguna cosa com això, que és bastant comú,
només una nova línia paràsita a la part inferior d'arxiu.
No pensaria que seria tan gran d'un acord
fins que es té en compte el fet que amb els navegadors -
>> Com redirigir el treball o bàsicament qualsevol treball encapçalats,
en realitzar la connexió amb un lloc web i l'envia de tornada totes aquestes capçaleres i coses
com a resposta o la resposta de redirecció 200 o el que sigui,
encapçalats només són vàlids fins al primer byte de dades s'envien.
Pot redirigir milers de vegades, però tan aviat com el primer byte de dades s'envia
que no suposa per redirigir de nou.
>> Si té una pèrdua de nova línia a la part inferior d'un arxiu
i diguem que utilitzi aquesta funció i llavors vostè vol -
Diguem que és un altre arxiu que és index.php i require_once alguna cosa -
No puc pensar en un bon exemple.
El problema ocorre quan aquesta línia a la part inferior es va fer ressò.
No vol que res s'ha fet ressò encara.
Tot i que no tenia la intenció d'aconseguir qualsevol cosa es va fer ressò, cosa que sí aconseguim ressò
i el que ara se suposa que no has de fer arribar les capçaleres de cap altra
i vostè rebrà queixes.
Un no necessita aquestes etiquetes de tancament.
Si tens pensat fer alguna cosa amb HTML -
i és perfectament raonable per fer-ho aquí div qualsevol
i en aquest punt es pot o no es poden incloure.
En realitat no importa.
Però en scripts PHP és estrany per tancar-la.
Quan tot és PHP, absolutament tot,
vostè realment no necessita per tancar / no has tancar-lo.
>> Tractar amb cadenes és molt més agradable que en C.
En PHP es pot especificar una cadena amb cometes simples o dobles.
Amb cometes simples no es pot utilitzar "escapament" seqüències.
Constantment escapar, blah, blah, blah.
Així que printf és molt rar en PHP.
Suposo que m'agradaria utilitzar printf si volia fer una mena de cosa - en el conjunt de processadors que utilitza sprintf 5 o el que sigui.
Però que vols fer 001.jpg 002.jpg i.
Així que per a aquest tipus de coses en què realment vol formatar el text m'agradaria utilitzar printf.
Però d'altra banda m'acaba d'utilitzar la concatenació de cadenes.
Realment mai utilitzar printf.
Només estem diferenciant els detalls entre cometes simples i cometes dobles.
La major diferència és que les cometes simples, s'imprimirà literalment.
No hi ha cap tipus de dades char en PHP, a diferència de C, així que això és equivalent a això.
Els dos són cadenes.
I el bo sobre les cadenes de cometes simples es podria dir 'hola món! " bla, bla, bla,
$ $ Wooo.
Què passa quan es tracta d'imprimir el voleu imprimir literalment.
Anem a desfer de totes les nostres coses.
Així que trobo $ cadena1;
És, literalment, imprès totes aquestes coses: signes de dòlar,
backslash n, que un pensaria que seria salts de línia -
totes aquestes coses que s'imprimeix la lletra.
L'única cosa que es necessita per escapar cometes simples són
perquè si no podria pensar que tancarà les cometes simples.
Les cometes dobles, completament diferents.
Ja veiem el ressaltat de sintaxi se'ns cluing al que anirà molt malament.
php.unique. Undefined variable: Wooo perquè això s'interpreta com una variable anomenada Wooo.
Les cometes dobles permeten inserir variables en -
Diguem que $ name = "Rob";
Així que trobo "Hola, em dic $ nom!";
Es reconeix això com una variable.
Quan executo això - i vaig a inserir un salt de línia - Hola, em dic Rob! i hola món!
Això és perquè mai li vaig treure la impressió de Wooo dalt.
Hi ha un pas més que pot fer.
$ Array = [1, 2, 3];
Què passa si vull imprimir el primer índex de la matriu?
Vostè fa $ array [0].
El ressaltat de sintaxi és una pista. Què és això farà?
php.unique.
Hola, em dic 1! que no és el que jo volia.
El ressaltat de sintaxi em va mentir.
Anem a provar 'a' -> 1, 'b' -> 2.
Així és com jo hauria d'escriure.
Cita inesperada únic (T_ENCAPSED blah, blah, blah, blah, blah).
La idea és que no es reconeix això com a part de la matriu.
No està reconeixent això com matriu indexada per una lletra.
Vols fer que entre claus,
i ara el que hi ha en aquesta clau de tancament seran interpolats,
que és la paraula que fem servir per màgicament la inserció d'aquestes variables en els llocs correctes.
Ara fer això, php.unique i Hola, em dic 1! com s'esperava
o Hola, em dic Rob!
Una cosa que és una mica agradable sobre cometes simples és que -
Hi ha algun cost per a la interpolació.
Si utilitzeu cometes, l'intèrpret ha d'anar a través d'aquesta cadena,
assegurant que, "Oh, aquí hi ha una variable. Ara he d'anar a buscar aquesta variable i inserir aquí."
Encara que no utilitza cap variable,
res dins d'aquestes cometes necessita ser interpolats,
però encara serà més lent perquè ha d'anar a través de les cometes dobles
a la recerca de coses que necessiten ser interpolats.
Així cites individuals pot ser una mica més ràpid si res necessita ser interpolats,
i tendeixo a fins i tot utilitzar cometes simples per a: 'Hola, em dic'. $ Array ['a'] de totes maneres.
Això serà equivalent al que teníem abans.
Però és una qüestió de preferència.
Si utilitzeu PHP, és probable que no els importa la diferència de velocitat.
No és suficient per raonar, per començar.
>> Una pregunta final?
>> En realitat, ni tan sols passar per tot això, però això era avorrit.
L'última cosa que una espècie d'agradable en PHP és quan vostè està tractant amb HTML,
ho vas a utilitzar una mica, així que la sintaxi bon drecera per imprimir una variable.
Sense posar PHP aquí, això es diu etiquetes curtes.
Oficialment a partir de PHP 5.4, aquesta no s'utilitza.
Es recomana posar php.
Això és tot suportada, etiqueta curtes amb el <? = Són encara perfectament bé.
És recolzada per defecte, així que vostè pot utilitzar aquests com vulgui, i són bastant convenients.
>> Alguna pregunta?
Està bé.
>> Mantingues la classe, San Diego.
[Rialles]
Bye. [Rialles]
[Aplaudiments] [riu]
>> [CS50.TV]