[Powered by Google Translate] [Одељак 8 - Више Удобан]
[Роб Бовден - Универзитет Харвард]
[Ово је ЦС50. - ЦС50.ТВ]
>> Ове недеље секција белешке ће бити прилично кратак,
па ћу само да говоримо, ви идете да поставља питања,
а ми ћемо покушати да попуни онолико времена колико је то могуће.
Многи људи мисле да је ово псет није нужно тешко, али то је веома дуго.
Псет спец сама траје сат да чита.
Дајемо вам пуно на СКЛ можете евентуално треба да користите.
Ми вас провести кроз много тога, тако да не би требало да буде лоше.
Да ли је неко почео или завршио?
То је последња псет. Ох, мој Боже.
Обично постоји једна ЈаваСкрипт након овога, али промена календара ствари
чини све 1 седмица краћи, а ми више не поседујете ЈаваСцрипт псет.
Ја не знам како то утиче да ли је ЈаваСцрипт ће се појавити на испиту
или Квиз 1.
Претпостављам да ће бити нешто као што треба да знате високом нивоу ствари о ЈаваСцрипт-а,
али сумњам да бих само да вам дам праву ЈаваСцрипт кода
јер нисте имали псет у њему.
Али то ће бити ствар за квиз преглед следеће недеље.
>> Секција питања.
Многе од ових ствари је нешто лоше формулисана, али ћемо разговарати зашто.
За разлику од Ц, ПХП је "динамички откуцали" језик. Шта то значи, питате се?
Па, рецимо збогом свима онима цхар, флоат, инт, и друге кључне речи треба да користите
када декларисање променљивих и функција у Ц
У ПХП, променљива је типа одређује вредност која се тренутно држи.
Дакле, пре него што упишете ову шифру у фајлу под називом динамиц.пхп,
ПХП је динамички откуца. То је истина.
Не слажем се са чињеницом да то значи да смо поздрављали цхар, флоат, инт,
и друге кључне речи.
Тачан Разлика између динамички куцани и алтернативно,
која је статички откуцан, да је динамички откуцао, све ваше типа провера и ствари
дешава у време извршавања, док статички откуцан се дешава на компајлирања.
Реч статичка уопште изгледа да значи нешто компајлирања.
Претпостављам да постоје и други користи за њега, али у Ц када прогласимо статичку променљиву,
његова складиштење додељено компајлирања.
Ево, динамички откуцао само значи да -
У Ц ако покушате да додате ниску и цео број, када га саставити,
то ће да се жале, јер је хтео да кажем да не можете да додате инт и показивач.
То једноставно није валидан операција.
То је још једна ствар која ми ћемо доћи до у секунд.
Али та врста провере, чињеница да се жали на компајлирања,
је статичан тип провера.
Постоје језици којима не треба да кажем цхар, флоат, инт, и све те ствари,
али језик може рећи из контекста ствари које врсте је то требало да буде,
али је и даље статично откуца.
Дакле, ако узмете 51, ОЦамл, никада нећете морати да користите било који од ових типова,
али ипак ће у време компајлирања кажу да не можете да урадите, јер сте мешање инт и стринг.
Динамички откуцали само значи да је негде током Рун Тиме ћете добити жалбу.
Ако сте и ви користили Јава раније, у принципу, скоро свака Ц-тип језика
ће бити статички откуцао, па Ц, Ц + +, Јава, сви они су углавном статицки откуца.
У Јави кад састави нешто и кажеш
стринг с једнако нову нешто што није ниска,
који ће да се жале, јер те врсте једноставно не подударају.
То ће да се жале на компајлирања.
Али такође има неку динамичку време ствари се допада ако покушате да баци нешто
на типу који је прецизнији од свог тренутног типа,
не постоји ништа што може да уради на време компајлирања да провери да ли је цаст ће успети.
Јава има неку врсту провере динамичан да чим се стигне до те линије кода
када се она извршава, то ће да уради баци,
проверите да ли је био валидан цаст на првом месту,
а ако није, онда ће да се жале да имате неважећи тип.
Динамички тип провере.
Укуцајте ово у фајл под називом динамиц.пхп.
Динамиц.пхп.
Ја ћу распакујте ту обликовање.
Имамо променљиву, ми смо га поставили на цео 7,
онда ћемо одштампати и% с -
Ох, ми смо штампање тип, па геттипе ће да врати тип променљиве.
Ми само штампањем тип изнова и изнова.
Ми само пхп.динамиц.пхп.
Ми ћемо видети да се она мења из цео у низу на Боолеан као што смо проћи.
У Ц постоји Булова тип података, не постоји низ података типа.
Има цхар * и Булова само тежи да буде инт или цхар или тако нешто.
У ПХП ове врсте не постоје, и то је једна од великих предности над ПХП Ц -
да стринг операције су бескрајно лакше него у ПХП Ц. Они само раде.
>> Тако смо дошли овамо.
Трчали смо динамиц.пхп.
То говори ПХП преводилац, назван пхп, за покретање ПХП кода у динамиц.пхп.
Ако имате било какве грешке у датотеци, преводилац ће вам рећи!
Тумач, ово је још једна велика разлика између ПХП и Ц.
У Ц морате да састави нешто и онда покренути тај саставио датотеку.
У ПХП никад саставити ништа.
Дакле, ПХП преводилац основи само читају ову линију по линију.
Он удари вар = 7 онда удари иф онда удари вар онда удари принтф и тако даље.
Постоји мало састављања то ради, и то кешира резултате
па ако покренете скрипту касније можете да урадите неке,
али у суштини то је то ред по ред ствари.
То значи да многи од оптимизацијама које смо добили у Ц,
као прикупљање, то је само генерално компајлер може да уради много трикова за вас.
То може да потраје од неискоришћених променљиве, то може да уради све оваквим стварима,
може да уради рекурзија рампа.
У ПХП нећеш добити ту предност
само зато што ће почети извршење линију по линију по линију,
и то није заиста препознају ове ствари тако лако
јер није 1 велика компилација пролаз преко ствари и онда извршење;
то је само по линији.
Тако да је преводилац.
>> Вратимо се нашем динамичном куцања: кул, а?
Ти дефинитивно не могу да урадим у Ц!
Дакле, видите да ли можете да схватим тип сваког од следећих вредности.
Погледајте ово за референцу.
Тако 3,50. Који тип мислите да ће то бити?
Овде су типови имамо.
Имамо боолс, целих бројева, плутајући поена, жице, низови, објекти,
и онда ресурси, који је некако нејасан.
Мислим да заправо постоји овде пример.
Затим, ту је НУЛЛ. НУЛЛ је посебан тип.
За разлику од Ц где НУЛЛ је само показивач на адреси 0,
у ПХП, НУЛЛ је сопствени тип, где једина валидна ствар тог типа је НУЛЛ.
Ово је много више користан за проверавање грешака.
У Ц где смо имали овај проблем где ако се врати НУЛЛ
да ли то значи да се враћамо на НУЛЛ показивач или коришћење НУЛЛ да означи грешку
или све те конфузије смо имали у једном тренутку.
Ево, враћа НУЛЛ обично значи грешку.
Много ствари се такође вратити фалсе за грешке.
Али поента је НУЛЛ типа, једина ствар НУЛЛ типа је НУЛЛ.
Тада је као повратни можете дефинисати неке анонимне функције.
Ви не морате да дате функцији име, али нећете морати да се позабавимо овде.
Гледајући типова који они очекују од нас да зна,
Шта мислите тип 3,50 је? >> [Ученик] Пливајући.
Да.
Дакле овде, шта мислите тип је ово? >> [Ученик] Арраи.
Да. Први је био пловак, други је низ.
Обратите пажњу да је ово низ није као Ц низу
где имате индекс 0 има неку вредност, индекс 1 има неку вредност.
Овде су индекси су, б, и ц и вредности су 1, 2 и 3.
У ПХП постоји разлика између асоцијативног низа и само редован низу
као што би било да томе у Ц.
Постоји само ово, а испод хаубе редовна низ је само асоцијативна низа
где 0 мапе за неке вредности исти начин мапе на неку вредност.
Из тог разлога, ПХП може бити прилично лоша за стварно брзе кода / бенчмаркинг ствари
јер у Ц када користите низ знате да приступе члана је константна времена.
У ПХП приступа члана је ко зна колико времена?
То је вероватно константна, ако га исправно хасхови.
Ко зна шта је то стварно ради испод хаубе?
Ви заиста треба погледати на имплементацију да видимо како ће да се позабави тиме.
Дакле фопен.
Ја сам овде мислим да само ПХП мануал фопен да погледате повратног типа.
Ми овде видимо можете погледати прилично било коју функцију у ПХП приручнику
и то је нека врста човека страни ПХП.
Повратни тип ће бити ресурс.
Зато сам га погледао, јер ми није стварно дефинише ресурс.
Идеја добра, у Ц ли некако добио ФИЛЕ * или било шта друго;
у ПХП ресурс је ваша ФИЛЕ *.
То је оно што ће се читајући, то је оно што ће бити писмено.
То је обично спољна, тако да је ресурс можете повући ствари од и бацају ствари.
И на крају, шта је тип НУЛЛ? >> [Ученик] НУЛЛ.
Да. Дакле, једина ствар која је НУЛЛ НУЛЛ је.
НУЛЛ је НУЛЛ.
>> Једна од особина система типа ПХП (за боље или горе) је његова способност да жонглира типова.
Када пишете линију ПХП кода који комбинује вредности различитих типова,
ПХП ће покушати да уради разумна ствар.
Испробајте сваки од следећих линија ПХП кода. Шта је одштампан?
Да ли је то оно што сте очекивали? Зашто или зашто не?
Ова чињеница о ПХП је шта га чини оно што зовемо слабо откуцан.
Слабо откуцана и снажно откуцао,
постоје различити користи за тим терминима,
али већина људи користи слабо откуцано и снажно откуцао да значи овакве ствари
где ("1" + 2), да ради.
У Ц то не би функционисало.
Можете замислити то не ради.
Многи људи мешају динамичан куцање и слабу куцање и статичку куцање и јаку куцање.
Питон је још један пример језика који се динамично унели.
Можете да баци око типова у варијабли и да ће то утврдити у време извршавања
Свака грешка цхецкингс.
У Питхон да ће да изврши ово и да ће видети ("1" + 2);
и то неће успети, јер каже да не можете да додате ниску и цео број.
У ПХП, која је баш као динамички откуцао, ово неће успети.
Слаба куцање има везе са чињеницом да је чини ствари са типовима
да стварно не смисла нужно.
Дакле, ("1" + 2), ја могу да замислим да буде ниска 12, могу да замислим да то не буде ниска 3,
Могу да замислим да то не буде цео 3.
То није нужно добро дефинисан, а ми вероватно ћемо видети овде
када смо одштампали ("1" + 2); вероватно ће завршити као другачији
од штампања (1 + "2").
А ово тежи да буде, по мом мишљењу, за горе.
Овде можемо пробати ово.
Још један мали трик у вези ПХП је да не треба да се заиста пише датотеку.
Нема се покренете ову команду режим.
Дакле, пхп-р, онда можемо бацити у команди овде:
"Принт ('1 '+ 2)," а ја ћу бацити нову линију.
Овај штампани 3.
Изгледа као да штампа 3 и то је цео 3.
Дакле, хајде да пробамо обрнуто:
"Принт (1 + '2 ');
Ми смо добили 3, а такође ће бити цео 3? Ја искрено немам појма.
Изгледа да је доследна.
Не постоји било каква шанса да се она ниска 12 или нешто слично
јер ПХП, за разлику од Јава и Јава такође,
има посебан оператор за спајање.
Спајање у ПХП је тачка.
Дакле, штампа (1 '2 '.) Ће нам дати 12.
Ово има тенденцију да доведе до забуне где људи покушавају да ураде нешто ул + =
нека друга ствар коју желите да додате на крају свог ниске, и да ће успети.
Потребно је да урадите ул =.
Зато не заборавите спајање у ПХП је тачка.
Друге ствари које треба да испробате: принт ("ЦС" + 50);
Рекао сам ти да не постоји нада за ово резултира ЦС50
јер спајање није +.
Шта мислите да ће ово завршити као?
Ја искрено немам појма.
Изгледа као да је само 50.
Она види стринг, а кладим се да ако ставимо 123ЦС -
Она види прву жицу, он покушава да прочитате цео из ње или број из њега.
У овом случају то види 123ЦС.
"То нема никаквог смисла као цео број, па ћу само да мислим на 123".
Дакле, 123 + 50 ће бити 173.
И овде почиње читањем ово као цео број.
Он не види ништа, па то је само третира га као 0. Дакле 0 + 50 ће бити 50.
Ово Претпостављам ће да уради нешто слично.
Размишљам 99.
Да, зато што ће узети први -
Тако 99.
Овде (10/7), ако је ово Ц, шта би то вратити?
[Ученик] 1. >> Да, то би било 1, јер 10/7 дели 2 цела броја.
Целобројна подељен цео број ће се вратити цео број.
То не може да се врати било шта 1 тачке које ће бити, па то је само ће да се врате 1.
Овде штампање (10/7), то ће заправо тумаче то.
А то значи да, ако сте заиста желите да урадите цео заокруживање и слично,
морате да урадите принт (спрат (10/7));
У Ц вероватно је чудно да се можете ослонити на цео скраћења редовно,
али у ПХП не можете јер аутоматски ће га претворити у флоат.
А онда (7 + истина), шта мислите да ће то бити?
Претпостављам 8 Ако ће то протумачити као тачно 1.
Изгледа као да је 8.
>> Тако нешто смо урадили у протеклих 10 минута да апсолутно не треба никада учинити.
Видећете кода који чини ово.
То не мора да буде тако једноставан као овај.
Могли сте 2 променљиве и 1 променљива се дешава да се стринг
и друге променљиве деси да буде инт, а онда додати заједно ових променљивих.
Пошто ПХП динамички откуцан и то неће учинити никакву проверу типа за вас
а пошто је слабо откуцано и пошто ће само бацити заједно аутоматски ове ствари
и све ће само радити, тешко је чак и знају да то мора да буде променљива сада ниска,
тако да не би требало да га додате ове променљиве, што је цео број.
Најбоља пракса је ако променљива стринг, држите га као стринг заувек.
Ако променљива инт га задржи као инт заувек.
Ако желите да се баве целих и гудаче,
можете да користите варсинт - то је ЈаваСцрипт.
Интвал. Ја ово све време. ПХП и Јава сам помешати све.
Дакле, интвал ће вратити цео вредност променљиве.
Ако прођемо у "штампе (интвал ('123 ')); добијате 123.
Интвал сама неће да уради проверу за нас да то искључиво је цео број.
ПХП мануал, постоји само толико функција доступна,
ево ја мислим да оно што бих ја користим је ис_нумериц први.
Нагађам да врати фалсе.
То је још једна ствар коју морамо да пређемо јесте. ===
Дакле ис_нумериц ('123дф '), не би пало на памет да као ис_нумериц.
У Ц да би требало да прелазили преко свих знакова
и проверите да ли сваки знак је цифра или шта год.
Овде ис_нумериц ће то за нас,
и то се враћа фалсе.
Дакле, када сам штампани тога штампани ништа, па ево ја сам у односу да види,
да ли вам се деси да буде нетачно? И тако сада је штампа 1.
Изгледа да штампа 1 као истинито, уместо штампања истина као истина.
Питам се да ли ја принт_р. Не, још увек не 1.
>> Враћајући се ===, == још увек постоји,
и ако разговарате са Томијем ће рећи == је савршено у реду.
Ја ћу да кажем да == је ужасан и да никада не треба користити. ==
Разлика је у томе што == пореди ствари
где може да буде истина, чак и ако они нису исти тип,
док === пореди ствари и прво проверава да су исти тип?
Да. Ок, сад ћу да видим да ли они заправо упореди да буду једнаки.
Добићете чудне ствари као што је једнако 10 - Да видимо шта ту пише.
Дакле, ('10 '== '1 Е1');
То враћа истина.
Да ли неко има било нагађања зашто се враћа истина?
Није реч само о томе. Можда је ово наговештај.
Али ако бих да променим на ф - то Дарн! Ја га користим дупле наводнике.
Разлог су наводници су викали на мене зато што сам ставио ово у наводницима.
Тако да сам могао да побегне дупле наводнике овде, али апострофе лакше.
Дакле, ('10 '== '1 Ф1'); не штампа истина. ('10 '== '1 Е1'); штампа истина.
[Ученик] Да ли је хексадецимални? >> Није хексадецимално, али је близу да то изгледа -
1е1, научни нотација.
Она признаје 1е1 као 1 * 10 ^ 1 или било шта друго.
Они су равноправни бројеви.
Ако радимо === онда ће то бити лажна.
Ја стварно немам појма, ако радимо == шта (10 и '10абц '); У реду. Дакле, то је истина.
Дакле, баш као када сте радили (10 + '10абц '), и то би било 20,
Овде (10 == '10абц '), је истина.
Још горе су ствари као што су (лажни == НУЛЛ); је истина
или (лажни == 0); је истина, (лажно == []);
Постоје чудни случајеви - То је једна од оних чудних случајева.
Приметимо да је (лажно == []), је истина.
('0 '== Фалсе); је истина.
('0 '== []), Је лажна.
Дакле, == никако прелазној.
може бити једнако Б и може бити једнак ц,
али је б можда неће бити једнака ц.
То је одвратно за мене, и увек треба користити. ===
[Ученик] Можемо ли == као добро!? >> [Боуден] Да.
Еквивалент би било! = И ==.
То је заправо одрастао у псет спец
где много повратка функције -
ПХП упутство је добро о томе.
Она ставља у великом црвеном пољу, "Ово ће вратити фалсе ако постоји грешка."
Али повратку 0 је сасвим разумна ствар да се врате.
Размислите о било коју функцију коју се очекује да ће вратити цео број.
Рецимо ова функција треба да пребројите број линија у датотеци или тако нешто.
Под нормалним околностима, прођете ове функције датотеку
и то ће вратити цео број који представља број линија.
Дакле, 0 је сасвим разуман број ако датотека је само празна.
Али шта ако му прође неважећи фајл и функција дешава да се врати фалсе
ако му прође неважећи фајл?
Ако само не == нисте разликовање случај између неважеће датотеке и празан фајл.
Увек користите. ===
То је све од њих.
>> У ПХП-у, низ врста се разликује од онога што сте навикли у Ц.
Заиста, можда сте већ приметили ово горе када сте видели да је ово типа низа.
Носач синтакса је ново као ПХП 5,4, што је најновија верзија ПХП-а.
Пре тога си увек морао да напише низ ('' -> 1, 'б' -> 2.
То је конструктор за низа.
Сада ПХП коначно дошао око на лепу синтаксом само угластим заградама,
који је тако много боље него низа.
Али с обзиром на ПХП 5,4 је најновија верзија,
можете наићи места која немају ни ПХП 5.3.
Током лета смо наишли на овај проблем, где ПХП 5,3 је оно што смо имали на апарату,
али сервер који смо применили све наше разред књигу и достави и све те ствари да
био ПХП 5.4.
Не знајући то, развили смо у 5,3, гурнути на 5,4,
и сад одједном нико нашег кода ради
јер се десило да су промене између 5.3 и 5.4
који нису компатибилни уназад,
и морамо да идемо и поправити све наше ствари које не раде за ПХП 5.4.
За ову класу, пошто апарат има ПХП 5.4,
то је сасвим у реду да користите угласте заграде.
Али, ако сте у потрази горе ствари око интернета,
ако тражиш неку врсту низа ствари, највероватније ћете видети
срицати синтаксе низа конструктора, јер то је било још од ПХП рођен
и заграда синтакса је око већ последњих неколико месеци
или када је дошао око 5,4.
Ово је начин да индекс.
Баш као у Ц како би Индекс угластим заградама, као што $ низ [0], $ арраи [1], $ арраи [2],
Ви индекс на исти начин уколико се догоди да ваша индекси бити ниске.
Тако $ низ [''] и $ арраи ['б'].
$ Низ [б]. Зашто би то било у реду?
Вероватно ће генерисати упозорење, али и даље ради. ПХП тежи да се то уради.
Она тежи да само: "Ја ћу да вас упозорим, али само ћу да наставим
"И учинити све што могу."
Вероватно ће превести ово на ниске,
али је могуће да ће у неком тренутку у прошлости неко рекао
дефинисати б да буду "ХЕЛЛО ВОРЛД '.
Дакле, сада б може бити константна и $ низ [б] ће заиста бити рад "ХЕЛЛО ВОРЛД '.
Мислим да у овом тренутку, или бар наше ПХП подешавања,
ако покушате да индекс у низу и да кључ не постоји, она ће успети.
Ја не мислим да је то само ће вас упозорити.
Или барем можете да подесите тако да не само да вас упозорим, то право само до успе.
>> Начин да проверите да ли постоји заиста таква индекс иссет.
Дакле иссет ($ низ ['ЗДРАВО СВЕТ']) ће вратити фалсе.
иссет ($ низ ['б']) ће вратити тачно.
Можете да комбинујете ове синтаксе.
Прилично сам сигуран шта је то низ завршити као ис - Можемо га испробате.
Ох, морам ПХПВорд.
То је мешање синтаксу где сте навели шта је кључ
и не прецизира шта је кључ.
Дакле 3 овде је вредност.
Ви нисте експлицитно рекао оно што њен кључ ће бити.
Шта мислите њен кључ ће бити?
[Ученик] 0. >> Нагађам 0 само зато што је то први нисмо навели.
Ми смо заправо може да уради пар ових случајева.
Дакле принт_р је штампање рекурзивна. То ће одштампати цео низ.
То би одштампали субарраис низа ако их је било.
Дакле принт_р ($ низ); пхп.тест.пхп.
То изгледа као да је дао 0.
Постоји заправо нешто имати на уму овде, али ћемо се вратити на то у секунди.
Али шта ако се деси да овај индекс 1?
ПХП не прави разлику између индекса и гудачке целобројних индекса,
тако да у овом тренутку управо сам дефинисали индекс 1 и ја могу да урадим како $ низ [1] и $ арраи ['1 ']
и то ће бити исти индекс и исти кључ.
Па сад шта мислиш 3 ће бити? >> [Ученик] 2. >> [Бовден] Предпостављам 2.
Да. То је 2.
Шта ако смо урадили ово је 10, то је 4? Шта мислите индекс 3 ће бити?
Размишљам 11.
Моја претпоставка о томе шта ради ПХП - и мислим да сам видео ово раније -
је то само води евиденцију о томе шта највише нумерички индекс се он користи до сада је.
То никада неће доделити индекс ниске до 3. Увек ће бити нумерички индекс.
Тако да води евиденцију о највишем једне то је додељен до сада, што се дешава да буде 10,
и то ће дати 11 до 3.
Оно што сам рекао раније, приметите како се штампа овај низ.
Он штампа кључну 10, тастер 4, кључ 11, тастер д.
Или чак да урадимо -
Претпостављам да нисам ставио 0, али је штампање 1, 2, 3, 4.
Шта ако ја овде пребацити? Или хајде да ствари пребацити ове 2.
Сада штампа 2, 1, 3, 4.
ПХП низови су не само као ваш редовни хеш табели.
То је сасвим разумно да мислимо о њима као хасх табела 99% времена.
Али у вашим хасх табеле нема смисла за ред у коме су убачене ствари.
Дакле, чим га убаците у свој хасх табели,
Претпостављам да нема повезан листа и можете да процените у повезану листу
који је први пут постављена.
Али овде убацили смо 2 прва и зна када је штампање овај низ да 2 долази прво.
Она га не штампа у било ком редоследу.
Техничка структура података да се то користи је наредио карта,
тако да мапира кључеве на вредности и памти редослед којим су убачени ти кључеви.
У суштини то је до неких компликација где је досадно да се заправо -
Рецимо да имате низ 0, 1, 2, 3, 4, 5
и желите да се индекс 2.
Један од начина да се то ради, хајде да видимо шта то личи.
0, 2, 1, 3, 4.
Невезаног дешава ресетовање обе променљиве и низа индекса.
Тако постављена ($ низ [2]);
Сада шта ће то изгледати? 2 је управо отишао, тако да је то сасвим у реду.
Више досадно је ако желите да се ствари заиста буде као низа.
Ставићу случајних бројева.
Сада приметите моје индексе.
Желим само да буде као Ц низа где иде од 0 до дужине - 1
и ја могу прелазили преко тога, као што су.
Али, чим сам ресетовање други индекс, шта је било у индексу 3 сада не постане индекс 2.
Уместо тога, само уклања тај индекс и сада идете 0, 1, 3, 4.
Ово је савршено разумно.
То је само досадни и ви морате да урадите ствари као низа Сплице. Да.
>> [Ученик] Шта ће се десити ако је за петљу
а ви хтели да иду преко свих елемената?
Када је ударио 2, да ли би икада донети?
Итератинг преко низа. Постоје 2 начина да се то уради.
Можете користити редовно за петљу.
Ово је још један сложеност ПХП.
Већина језика, ја бих рекао, имају неку врсту дужине или ЛЕН или нешто
указује на дужину низа.
У ПХП је гроф.
Дакле, цоунт ($ низ); $ и + +)
Хајде само да штампа ($ низ [$ и]);
Нотице: Ундефинед оффсет: 2.
То ће да пропадне.
То је разлог да, у највећем делу, никада нећете морати да вршите итерацију кроз низ овако.
То може бити претеривање, али никада нећете морати да вршите итерацију кроз низ овако
јер ПХП обезбеђује његову фореацх синтаксу где фореацх ($ $ арраи као ставка).
Сада, ако се штампају ($ ставка) - ве'лл томе разговарати у секунди - који ради савршено добро.
Начин на који фореацх ради је први аргумент је низ које сте итератинг преко.
А други аргумент ставка, кроз сваку од пролаза за петље
то ће да се на следећем ствар у низу. Дакле, запамтите низ има налог.
Први пут кроз фор петљи, ставка ће бити 123
онда ће бити 12 онда ће бити 13 онда ће бити 23 онда ће бити 213.
Ствари се заиста чудно кад радиш нешто фореацх.
Хајде да видимо шта се дешава, јер никада не би требало да урадите.
Шта ако невезаног ($ арраи [1]);
То је вероватно очекивао.
Ти итератинг у овом низу, и сваки пут када се унсеттинг први индекс.
Дакле, за индекс 0, прва ствар, ставка узима вредност 0, тако да ће бити 123.
Али унутар петље за нас невезаног индекс 1, па то значи да 12 је нестало.
Тако штампа. ПХП_ЕОЛ.
ПХП_ЕОЛ је само нови ред, али је техницки преносив
јер редовима у Виндовс разликује од редовима на Мац и Уник.
На Виндовс нови ред је \ р \ н, а свуда има тенденцију само да се \ н.
ПХП_ЕОЛ је конфигурисан тако да користи, без обзира на нови ред вашег система.
Тако принт то. Немојмо принт_р ($ низ) на крају.
Нисам имао појма да ће то бити понашање.
Ставка и даље траје на вредности 12 иако смо ресетовање 12 пре него што смо икада добили на њега из низа.
Не узимам реч о томе, али изгледа као да фореацх креира копију низа
и онда ставка узима све вредности те копије.
Дакле, чак и ако измените низ унутар фор петљи,
то није брига. Ставка ће се на првобитне вредности.
Хајде да покушамо унсеттинг га.
Шта ако је ово $ арраи [1] = "здраво";
Иако смо ставили "здраво" у низу, тачка никада не одузима на тој вредности.
Постоји још једна синтакса за фореацх петље
где сте ставили 2 променљиве раздвојене стрелом.
Овај први променљива ће бити кључ те вредности,
а ова друга варијабла ће бити исти тачан ставка.
То се овде незанимљива, али ако се вратимо на наш првобитни случај 'А' -> 1,
'Б' -> 1,
овде ако смо само прелазили за сваку низа као ставке, ставка ће бити 1 сваки пут.
Али ако ми такође желимо да знамо кључ повезан са том ставком
онда ми као $ тастер -> $ итем.
Тако сада можемо да урадимо за штампање ($ кеи ':'..
Сада је итератинг изнова и штампа сваки тастер и њену повезану вредност.
>> Додатни ствар коју можете да урадите у фореацх петљи је можда видети ову синтаксу.
Амперсандс пре променљивих имена имају тенденцију да буде како ПХП ради референце.
Где референце су врло сличне показивачима,
немате тројки, тако да никада баве меморије директно.
Али ви немате референце где 1 променљива се односи на исту ствар као и друге променљиве.
Унутар овде урадимо $ ставка. Хајде да се вратимо на 1, 10.
Урадимо $ ставка + +; То још увек постоји у ПХП-у. Још увек можете да урадите + +.
пхп.тест.пхп. Морам да га одштампате. принт_р ($ низ);
Штампамо 2, 11.
Ако само учинио фореацх ($ низ ас $ итем), онда ставка ће бити вредност 1
Први пут кроз петљу. То ће увећати 1 до 2 и онда смо готови.
Онда ће ићи кроз друге пролазе од петље и да ставка 10.
То повећава тачка на 11, а онда је само бацити.
Онда смо принт_р ($ арраи), и хајде да видимо да је то само 1, 10.
Дакле, прираст смо је изгубили.
Али фореацх ($ низ као & $ ставка)
Сада ова ставка је иста ставка као ово овде. То је иста ствар.
Тако $ ставка + + је низ измена 0.
У суштини, можете да урадите $ К -> $ ставку и можете да урадите $ низ [$ к] + +;
>> Дакле, још један начин да ради, ми смо слободни да мењате ставке,
али да неће мењати своју оригиналну низ.
Али ако користимо К, који је наш кључни, онда можемо само индекс у нашем низу користећи тај кључ
и инкрементирање то.
Ово више директно мења наш оригинални низ.
Можете чак и да то ако из неког разлога желели могућност да промени -
Заправо, ово је савршено разумно.
Ниси хтела да напише $ низ [$ к] + +,
само хтео да напише $ ставка + +, али још увек желели да кажу да ли ($ к === '')
онда инкрементирање ставку, а затим одштампате наш низ.
Па сад шта очекујемо принт_р да радимо? Које вредности треба да се штампа?
[Ученик] 2 и 10. >> [Бовден] Само ако кључ је "" ми заправо одштампате то.
>> Ви вероватно веома ретко, ако икада, потребно је дефинисати функције у ПХП-у,
али можда ћете видети нешто слично где дефинисати функцију као функцију вхатевер.
Обично би рекли ($ фоо, бар $), а затим га дефинишу бити свеједно.
Али ако то урадим, онда то значи да без обзира шта год позива,
год зове Баз, па први аргумент прослеђен Баз може бити промењена.
Урадимо $ фоо + +;
и унутар овде урадимо Баз ($ ставка);
Сада позивамо функцију.
Аргумент се узима позивањем, што значи да ако га измени
ми допунама ствар која је прошла ин
А штампање ове очекујемо - осим ако сам забрљао синтаксу - имамо 2, 11,
тако да је заправо повећава.
ОБАВЕШТЕЊЕ морамо референце у 2 места.
Шта ако сам урадио ово? Шта ово значи?
[Ученик] То ће се променити. >> Да.
Ставка је само копија вредности у низу.
Дакле, ставка ће се променити у 2, али низ [''] ће и даље бити 1.
Или, шта ако урадим ово?
Сада ставка послата као копију Баз.
Дакле, копија аргумента ће бити увећан до 2,
али ставка сама никада није увећан за 2.
А ставка је иста ствар као низа носач шта год,
тако да низ никада није увећан.
Дакле, оба та места треба.
>> ПХП је обично прилично паметно о томе.
Можда мислиш да желим да прође по референци -
То је, заправо, питање о једном од псетс.
То је била ствар куестионс.ткт где је рекао,
Зашто би желите да проследите ову струцт позивањем?
Шта је одговор на то?
[Ученик] Тако да не морате да копирате нешто велико. >> Да.
Струцт могу бити произвољно велики, а када прође струцт се као аргумент
потребно је да копирате тај цео струцт да га усвоји до функције,
а ако само прође струцт позивањем
онда само треба да копирате 4-бајта адресу као аргумент функције.
ПХП је мало паметнији од тога.
Ако имам неку функцију и прећи на њега низ од 1.000 ствари,
да ли то значи да ће морати да копирате све 1.000 тих ствари
да прође га у функцију? То не мора да то уради одмах.
Ако унутар ове функције она заправо никада није модификује фоо,
па ако ($ фоо === 'здраво') ретурн.;
Обавештење ми заправо никада модификован аргумента унутар ове функције,
што значи да све што је усвојен као трла не мора да буде копирана
јер није то то мењање.
Дакле, начин на који ПХП дела је да су аргументи су увек прошли по референци
док ви у ствари покушавају да га мењају.
Сада, ако кажем $ фоо + +, то ће сада направити копију оригиналне фоо и мењати копију.
То штеди време.
Ако никад не додирујете овај масиван низ, заправо никада не мења,
да не треба да направи копију,
а ако смо само ставили ову амперсанд То значи да чак и не да га копирате
чак и ако могу да измените.
Ово понашање се зове копија-на-писања.
Ви ћете га видети у другим местима, посебно ако се узме оперативног система курс.
Цопи-он-врите је прилично уобичајена образац где не треба да направи копију нешто
уколико се заиста мења. Да.
[Ученик] Шта ако сте имали пораст унутар теста,
па само 1 елемент од 1.000 би требало да се промени?
Нисам сигуран.
Мислим да би копирали целу ствар, али је могуће да је довољно паметан да -
Заправо, оно што ја мислим је замислити да смо имали низ који изгледа овако: $ низ2 = [
Онда ИНДЕКС '' је низ [1 2 3 4], а индекс 'Б' је низ вхатевер.
Морам зарезе између свих њих. Замислите постоје зарези.
Затим 'ц' је вредност 3.
Ок.
Сада рецимо радимо $ баз ($ низ2);
где баз не узме ово референце.
Тако $ фоо ['ц'] + +;
То је такав пример где смо пролази арраи2 као аргумент
и онда се измене посебан индекс низа тако да увецава.
Ја искрено немам појма шта ПХП ће да уради.
Лако може да направи копију целог ствар, али ако је паметан,
то ће направити копију ових тастера, где ће имати своју посебну вредност
али то и даље може указати на истом низу 1,2,3,4
а то даље може указати на истом низу.
Ја ћу га иПад.
Пролазимо у овом низу, где је овај момак бодова до 3, овај момак поена [1,2,3,4],
Овај момак указује на [...] 34,
Сада када смо то пролази на Баз, ми смо мењање ово.
Ако ПХП је паметан, само може да уради -
Ми смо увек морали да копирате неку меморију, али ако је било огромне угнежђене субарраис
нисмо морали да копирате њих.
Ја не знам да ли је то оно што ради, али могу да замислим да то раде.
Ово је такође прилично велика предност над Ц ПХП.
>> ПХП чини живот много лакши за много ствари,
али некако немам појма колико добро ће обављати
јер ја немам појма испод хаубе када је прављење ових копија ствари,
Ох, јесте да ће бити константа време копија,
је то само ће се променити 1 показивач, да ли ће бити смешно тешко линеарно копија?
Шта ако не можемо да нађемо простор?
Да ли је онда потребно да покренете колекцију смеће добити мало више простора?
А смеће може да произвољно дуго.
У Ц не морате да бринете о тим стварима.
Сваки ред можете да ти пишем можеш прилично разлога о томе како ће то обављати.
>> Да се ​​осврнем на ово.
Како је лепо да не морате да се баве хеш функција,
повезане листе, или тако нешто?
Пошто рад са табелама хасх је тако лако сада, ево забавно слагалица за рад.
Отворите фајл под називом уникуе.пхп иу њему написати ПХП програм
(Такође познат као "сценарио").
Ми смо склони да их назовем скрипте ако су кратке ствари да раде у командној линији.
У суштини, сваки језик који се не компајлира али ћеш да покренете извршни
у командној линији, можете назвати скрипту извршну.
Могао баш као и написати Ц програм који ради ово,
али ја не зовем сценарио, јер сам први пут га састави, а затим покрените бинарни.
Али ово ПХП програм ћемо позвати сценарио.
Или, ако га је писао у Питхон или Перл или Ноде.јс или било тих ствари,
ми бисмо их зову сви скриптови јер сте их покрене на командној линији
али ми их не саставити.
Могли би ово прилично брзо.
Нећемо користити аргв. Хајде да експлодира кроз ово.
Назовите то јединствена, написати програм.
Можете претпоставити да ће улаз садржати једну реч по линији.
Заправо, аргв ће бити прилично тривијалне за употребу.
уникуе.пхп.
Прва ствар прво, желимо да провери да ли смо прошли 1 командне линије аргумент.
Баш као што бисте очекивали аргц и аргв у Ц, и даље имамо оне у ПХП-у.
Дакле, ако ($ аргц == 2!), Онда нећу бавити штампањем поруку или нешто слично.
Ја ћу изаћи, код грешке од 1.
Такође сам могао да се врати 1.
Ретко у ПХП сте у том стању где смо -
Обично сте у функцији расписао функцију зове по функцији позван од функције.
А ако нешто крене наопако, а ви само желите да изађете све у потпуности,
излаз само завршава програм.
То такође постоји у Ц.
Ако сте у функцији у функцији у функцији у функцији
и желите да само убити програм, можете позвати екит и то ће само изаћи.
Али у ПХП је још реткост да смо на овом врхунском нивоу.
Обично смо у некаквом функције, тако зовемо излаз
тако да не морамо да се врате за 1 ствар која онда схвата да је грешка
тако да се враћа ако препозна било грешка.
Ми не желимо да се бавимо тиме, тако да излазак (1);
повратак (1), у овом случају би била еквивалент.
>> Онда оно што желите да отворите желимо да фопен.
Аргументи ће изгледају прилично слично.
Желимо да фопен ($ аргв [1], а ми желимо да га отвори за читање.
То даје ресурс који идемо звати ф.
Ово изгледа прилично слично како то ради, осим Ц не морамо да кажемо * Филе.
Уместо тога, само реци $ ф. Ок.
Заправо, мислим да је то чак нам даје наговештај о томе да ПХП функцију зове фајл. ПХП Филе.
Шта ће се то уради је да прочитате целу датотеку у низу.
Не морате чак ни да фопен га. То ће учинити то за вас.
Дакле, $ линија = филе ($ аргв [1]);
Сада све линије датотеке су у редовима. Сада желимо да сортирате редове.
Како можемо разврстати линије?
Ми смо сортирали линије.
А сада можемо да штампамо их или било шта друго.
Вероватно најлакши начин је фореацх ($ $ линије као линија) ецхо $ линија;
[Ученик] не би ми чак прелазе линије које референцирање нешто у врсте?
Ово је место где би некако да се дефинише као функција сорт ($ & низ).
Када позовете функцију да не прође референцу.
То је функција која дефинише га као да је узимајући као референцу.
То је заправо оно што је пошло наопако
када смо ставили све да нашим серверима, када смо отишли ​​из 5,3 до 5,4.
До 5,4, ово је било сасвим разумно.
Функција не очекује да га узме као референца, али можете да га проћи као референцу
па ако функција не деси да га модификује, она је и даље мењати.
Као од 5,4, ви не би требало да урадите.
Тако сада једини начин да прође позивајући је да ако функција изричито ради.
Ако не желите да га модификује, онда морате да урадите $ $ = примерак линије и пасс копија.
Дакле, сада линије ће бити очувана и копија ће бити промењена.
пхп.уникуе.пхп. Можда сам забрљао нешто.
Неочекивани 'врста'.
Ту ће бити нешто што то ради за нас.
Није ни тамо.
Обратите пажњу када читате приручник који први аргумент се очекује да буде низ
и то узети по референци.
Зашто је ова жале на мене? Зато што имам ту функцију какву још увек овде да ја не желим.
Ок, пхп.уникуе.пхп. Нисам га положе аргумент, јер ја немам датотеку.
То је пхп.уникуе.пхп на тест.пхп.
Овде је све тест.пхп штампан у лепој сортираном редоследу.
Приметимо да сортирају како би је некако чудно кода датотеке
јер сви наши празних линија ће доћи прво
онда ће доћи сви наши 1 степен удубљења
онда долазе сви наши без удубљења.
Да. >> [Ученик] Дакле, за изворни код није прошао по референци?
Да ли је то уопште прошао вредности?
[Бовден] Када позовете функцију, никада се утврђује да ли је прошао по референци.
То је функција дефиниција која одређује да ли је прошао по референци.
И гледа функцији дефинисања врсте или само гледа ово,
потребно аргумент по референци.
Дакле, без обзира на то да ли желите да га узме по референци, ипак узми по референци.
Она мења низ на месту.
Ово једноставно није дозвољено. Не смете да урадите. >> [Ученик] Ох, у реду.
[Бовден] То се, некако ће да се линије по референци и мењати га.
А опет, ако нисте хтели да урадите, можете да направите копију врсте.
Чак иу том случају, копија није заправо копија линија.
То само указује на исту ствар све док се први пут добија модификовани,
где је први пут ће се мењати у функцији сортирања,
где, јер је копија-на-писати, сад копија копије ће бити направљен.
Такође можете да урадите ово. То је друго место можете видети амперсанд.
Видиш у фореацх петље, можете га видети у функцији декларацијама,
а ви га видите када је само додељивања варијабли.
Сада смо постигли ништа на овај начин
јер копирање и линије су буквално иста ствар.
Можете користити линије и копирање синоними.
То можете да урадите унсет ($ копију), и да не унсет линије,
само изгубити референцу на исту ствар.
Дакле, од овог тренутка, сада линије је једини начин да приступите линије.
>> Питања?
Да.
[Ученик] Потпуно офф топиц, али не морате да затворите ПХП са - >> ти не.
Ок.
[Бовден] Ја бих ишао тако далеко да кажем да је лоша пракса да их затвори.
То је вероватно претеривање, посебно у сценарију,
али хајде да видимо шта ће се десити ако то урадим.
То није ништа. Шта ако сам желео - [уздаси]
Морам да прође аргумент.
Пуцај. Звала сам је погрешно.
Тако пхп.уникуе.пхп свађом.
Сада не морате чак ни то.
Ја ћу га донети исправну аргумент.
Ова штампа шта год да је штампа.
Ја штампање копија и копија не постоји. Тако линије.
Он штампа све, а онда примети све ово смеће овде доле,
јер у ПХП све што је изван ПХП тагова
је само ће бити буквално штампа.
Зато ХТМЛ, то је тако лепо да могу да урадим див бла, бла, бла класу или шта год,
бла, бла, бла, а онда неки ПХП код и онда див завршетка.
И сада штампа ово ћу добити леп див до врха, све да ПХП штампани, див на дну.
Катастрофалан када се нешто овако деси, што је прилично уобичајено,
само залутали нови ред на дну фајла.
Ти не би помислио да би било да је велик посао
док не узме у обзир чињеница да је са претраживача -
>> Како преусмерава рад или практично било заглавља рад,
када правите своју везу на веб сајту и поново шаље све ове заглавља и ствари
као одговор 200 или одговора преусмеравање или шта год,
Заглавља су важеће само док први бајт података је послат.
Можете преусмерити на хиљаде пута, али чим први бајт података је послат
Ниси ти требао поново да преусмери.
>> Ако имате залутали нови ред на дну датотеке
и рецимо да користите ову функцију, а затим желите да -
Рецимо да је то још један фајл који је индек.пхп и рекуире_онце нешто -
Ја не могу да смислим добар пример тога.
Питање се дешава када се та линија на дну добија одјек.
Не желим ништа да још није одјекивао.
Иако нисте намеравали на шта добијање одјекнула, нешто није се поновио
па сад ти не би требало да пошаље било још заглавља
и ти ћеш добити жалбе.
Ви једноставно не треба те ознаке ријеч.
Ако планирате да радиш нешто са ХТМЛ -
и то је сасвим разумно да се уради овде див год
и онда у овом тренутку можете или не можете да их укључите.
То није ни битно.
Али у ПХП скрипти је ретко да га затворили.
Када је све ПХП, апсолутно све,
ти стварно не треба га затворити / не треба га затворити.
>> Суочавање са стринговима је много лепше него у Ц.
У ПХП можете да наведете стринг са једним или двоструким наводницима.
Са апострофа не можете да користите "Бекство" секвенце.
Стално побегне, бла, бла, бла.
Дакле принтф је веома ретка у ПХП.
Претпостављам да бих принтф употребити ако сам желео да урадим овакве ствари - у псет 5 сте користили спринтф или шта год.
Али ви желите да урадите 001.јпг 002.јпг и.
Дакле, за такве ствари где сам заправо желе да обликујете текст бих принтф користи.
Али иначе сам користио би спајање жица.
Ја заиста никада не користим принтф.
Ми само диференцирање детаља између апострофа и двоструких наводника.
Највећа разлика је у томе што апострофе, то ће бити буквално штампа.
Нема инт тип података у ПХП, за разлику од Ц, тако да је ово еквивалентно томе.
Они су обе жице.
И лепа ствар о појединачним наводницима жицама је да сам могао да кажем 'хелло свет!' бла, бла, бла,
$ $ Вооо.
Шта се дешава када одштампате је да ће га штампати буквално.
Идемо ослободити све наше ствари.
Дакле ецхо $ стр1;
Буквално штампан све те ствари: Долар знакова,
бацксласх н, коју би помислио би неулинес -
све те ствари које су буквално штампа.
Једина ствар коју треба да побегне су самохране цитати
јер у супротном би било да је то затварања апострофе.
Двоструки наводници, потпуно различити.
Ми смо већ видели истицање синтаксе нас цлуинг на оно што је о томе да иде страшно лоше.
пхп.уникуе. Ундефинед вариабле: Вооо јер се тумачи као променљиву зове Вооо.
Двоструки наводници омогућавају да убаците променљиве у -
Рецимо $ име = "Роб";
Дакле ецхо "Здраво, моје име је $ име!";
Он препознаје као променљиву.
Када трчим да - и ја ћу убацити нови ред - Здраво, моје име је Роб! и здраво свет!
То је зато што никада нисам уклонио штампање Вооо горе.
Ту је 1 корак даље можете да урадите.
$ Низ = [1, 2, 3];
Шта ако желим да одштампате прву индекс низа?
Знаш $ низ [0].
На истицање синтаксе је траг. Шта ће ово да урадим?
пхп.уникуе.
Здраво, моје име је 1! што није оно што сам желео.
Истицање синтаксе лагали мене.
Хајде да покушамо '"-> 1,' б '-> 2.
Тако сам морао да га напишем.
Неочекивана један цитат (Т_ЕНЦАПСЕД бла, бла, бла, бла, бла).
Идеја је да то није признавање ово као део низа.
Није признајући то као низ индексирана писмом а.
Желите да урадите окружен заграда,
а сада оно што је у овом коврџавом браце биће интерполирано,
што је реч коју користимо за магично убацивање ове променљиве у правим местима.
Сада радим ово, пхп.уникуе и Здраво, моје име је 1! као што се очекује
или Здраво, моје име је Роб!
Једна ствар која је некако лепо о апострофа је да -
Има неки трошак за интерполацијом.
Ако користите дупле наводнике, преводилац мора да иде преко ове ниске,
уверивши се да: "О, ево променљива Сада морам да одем ту променљиву и убаците га овде.".
Чак и ако не користите никакве променљиве
Ништа унутар ове наводнике треба интерполирано,
али ће ипак бити спорији јер је потребно да се иде преко дупле наводнике
у потрази за ствари које треба да се интерполира.
Дакле, апострофе може бити мало брже ако ништа треба да се интерполирано,
и ја имају тенденцију да користе чак и апострофе за "Здраво, моје име је '. $ Низ [''] свеједно.
То ће бити еквивалентна ономе што смо раније имали.
Али то је ствар личног опредељења.
Ако користите ПХП, вероватно вам није стало до брзине разлике.
Нема довољно да их размишљају до почетка.
>> Свака коначна питања?
>> Ми заправо нису ни добили кроз све то, али ова ствар је досадно.
Последња ствар која је врста лепо у ПХП је када имате посла са ХТМЛ,
ћете га користити мало, тако да је лепо приручни синтаксу за штампање променљиву.
Без стављања ПХП овде, ово се зове кратке цртице.
Званично од ПХП 5,4, ово је застарела.
Препоручује се да ставите пхп.
Ово је још подржава, тако кратке ознаке са <= још увек савршено у реду.
То је по дефаулту подржан, тако да можете да користите као желите, и они су прилично згодно.
>> Има ли питања?
У реду.
>> Останите отмено, Сан Дијего.
[Цхуцклес]
Ћао. [Смех]
[Аплауз] [смех]
>> [ЦС50.ТВ]