>> [Suriin: Pagsusulit 1]
[Ali Nahm, Oreoluwa Barbarinsa, Lucas Freitas, Rob Bowden] [Harvard University]
[Ito ay CS50.] [CS50.TV]
[Lucas Freitas] Maligayang pagdating sa lahat. Ito ay pagsusuri para sa pagsusulit 1.
Tulad ng disclaimer, ito ay - Ibig kong sabihin, kami ay pagpunta sa subukan upang masakop
bilang magkano ang materyal hangga't maaari, ngunit iyon ay hindi nangangahulugan na
kami ay pagpunta upang masakop ang lahat ng mga bagay na maaaring maging sa pagsusulit 1.
Kaya siguraduhin mo ring tingnan ang panayam, mga seksyon, ang lahat ng bagay na magagawa mo na.
Pagsusulit 1 ay magiging sa Miyerkules, sa susunod na Miyerkules.
Kaya siguraduhin na mag-aral. Ito ay pagpunta sa maging, halos, tulad ng una pagsusulit
patungkol sa format nito, ngunit marahil ito pupuntahan ay mas mahirap.
Hindi bababa sa, nakaraang taon noong kinuha ko 50, naisip ko na ito ay mas mahirap.
Kaya mag-aral ng maraming.
>> Pupunta ako upang masakop ang mga istraktura ng data at Huffman coding.
Ito ay isang bagay na ng maraming mga tao sa tingin ay complex,
ngunit ako pagpunta sa subukan upang gawin itong bilang madaling hangga't maaari.
Una sa lahat, kung ano ang gusto namin sa iyo guys upang malaman para sa pagsusulit 1 ay upang
maunawaan ang haka-haka mga paglalarawan ng bawat isa sa mga istraktura ng data na pupuntahan ko ipakita.
Nangangahulugan iyon na hindi mo kailangang i-aktwal
ipatupad ang hash talahanayan sa iyong pagsusulit 1.
Hindi namin gusto mong ipatupad ang isang kabuuan ng hash talahanayan; siguro susubukan naming
upang gawing mong ipatupad ng ilang mga pag-andar,
ang pinaka-karaniwang mga operasyon, ngunit kami ay hindi pagpunta sa gawin ipatupad mo ang lahat.
Kaya mahalaga na maunawaan mo ang konsepto sa likod ng bawat istraktura ng data
at din na nagagawa mong code sa C,
lamang ang mga pinaka-karaniwang mga operasyon mayroon sila para sa bawat istraktura ng data.
At magagawang upang suriin ang mga payo at structs din,
dahil lumilitaw ang mga ito ng maraming sa mga istraktura ng data.
>> Una, naka-link na mga listahan. Mga listahan ng Linked ay aktwal na halos kapareho sa array,
ngunit ang pagkakaiba sa pagitan ng isang naka-link na listahan at isang array,
una sa lahat, ay na ang isang naka-link na listahan ay may sukat napaka-kakayahang umangkop,
habang sa array kailangan mong alinman sa pumili ng isang napakalaking sukat para sa array,
sa gayon ay alam mong naka-pagpunta sa ay makakapag-imbak ang lahat ng iyong data sa na array,
o mayroon kang gamitin ang malloc upang magkaroon ng isang may kakayahang umangkop haba ng array.
Sa naka-link na listahan ay masyadong madaling makakuha lamang sa higit pang mga elemento,
ilagay sa higit pang mga elemento sa naka-link na listahan o alisin ang mga elemento.
At talagang, kung hindi mo nais ang naka-link na listahan na pinagsunod-sunod,
maaari mong hanapin at alisin ang mga sangkap sa pare-pareho ang oras,
kaya O (1) oras, sa gayon ay masyadong maginhawa.
Mayroon kang lamang upang mag-ingat na laging tandaan na malloc at libreng mga nodes,
dahil lang kung wala ka, magkakaroon ka ng memory paglabas.
Kaya naka-link na listahan - ang kahulugan ng isang node ay tulad lamang ng kung ano ang mayroon kami doon.
Naglagay ako int n, ngunit maaari kang mag-imbak ng anumang data na gusto mo.
Kaya kung nais mong i-imbak ang isang string, ito ay pinong.
Kung nais mong i-imbak ang isang struct, ito ay pinong, isang double, kahit anong gusto mo.
Ilagay ko lang ang int n para sa mga halimbawa dito.
At mayroon kang isang pointer sa susunod na node.
Kaya, talaga, naka-link na listahan ay may ilang mga data, at pagkatapos ay tumuturo ito sa susunod na node.
Kung ito ay ang huling elemento sa naka-link na listahan, ito ay pagpunta upang tumuro sa null.
Kaya ito ay isang halimbawa ng isang naka-link na listahan.
>> Okay, kaya hayaan na ngayon ni makita kung ano ang dapat naming gawin kung gusto kong ipasok ang isang elemento sa isang naka-link na listahan.
Una, isang insert function na ay magiging walang bisa ng uri
dahil hindi ko nais upang bumalik kahit ano.
At ako pagpunta sa tumagal ng isang int bilang isang argument,
dahil gusto kong malaman kung ano ang gusto ko ipapasok.
Kaya ano ang unang bagay na dapat kong gawin? Well, ang dapat kong malloc sa newnode,
nang sa gayon ay ang unang linya.
Lang ako sa paglikha ng isang bagong node ang ilalagay sa isang naka-link na listahan.
Kaya kung ano ang maaari kong gawin? Well, alam namin na sa aming mga pagpapatupad ng naka-link na mga listahan
sa klase, palagi naming ilagay ang ulo bilang isang global variable.
Kaya kung ano ang maaari naming gawin ay baguhin ang ulo.
Maaari ba akong gumawa ng bagong node maging ang bagong ulo,
at ito ay pagpunta sa ituro sa nakaraang ulo.
Paano namin maaaring gawin iyon? Ang unang bagay na kailangan kong gawin
ay baguhin ang 'n' sa bagong node sa halaga,
kung saan ito ay pumasa sa sa pagpapaandar.
Pagkatapos ay newnode susunod ay magiging ang ulo.
Ang ulo ay pagpunta sa ma-newnode. Kaya ito ay medyo simple.
Para sa pagtanggal ng isang node, maaari naming gawin ito tulad ng -
Ang isang paraan na maaari kaming gawin iyon ay upang sabihin,
okay, kung gusto kong tanggalin ang, halimbawa, 3,
ano ang maaari kong gawin ay ituro lang ang mga nakaraang node
sa susunod na node ng 3.
Kaya gusto kong gawin lamang ng isang bagay tulad na.
Ngunit ano ang problema sa paggawa na?
Mayroon akong isang tumagas memory, kaya hindi ko ay may access sa ang bilang 3 na ngayon.
Ang problema sa na ay hindi na pupuntahan ko magagawang palayain na node.
Pupunta ako sa may memory tumagas at (hindi maintindihan) ay pagpunta sa pagkamuhi sa akin.
Kaya sa halip ng paggawa na, ang dapat kong marahil ay may isang pansamantalang pointer.
Kaya ko bang ilagay ang Temp. Ito ay pagpunta sa ay tumuturo sa node na gusto kong tanggalin.
At pagkatapos ay maaari kong ilipat ang nakaraang mga node sa punto sa susunod na node
ng node na gusto kong tanggalin.
At sa wakas, ang maaari kong palayain ang pointer.
Dapat ko bang palayain ang pointer na aking nilikha doon?
Hindi ko na kailangang, dahil lamang -
ang pagkakaiba ay na ito node ay nilikha gamit ang malloc,
kaya sa magbunton, habang ang isang ito ay ipinahayag lamang bilang isang null lumipat sa stack.
Kaya hindi ko na kailangang palayain ito.
>> Okay. Kaya-usapan natin ang tungkol sa mga stack ipaalam sa ngayon.
Mga stack ay medyo prangka.
Ginawa namin stack at queues sa klase lamang gamit ang array,
ngunit dapat mong maging pamilyar - magkaroon ng kamalayan lamang
na maaari mo ring gawin stack sa queues gamit ang naka-link na mga listahan pati na rin.
Kaya kung mayroon kang isang array, ano ang magiging isang stack?
Ang isang stack, una, ay magkakaroon na magkaroon ng laki.
Mayroon kang mag-imbak ng kung ano ay ang laki ng stack na mayroon ka ngayon.
At din magkakaroon ka ng isang array, sa ganitong kaso ng mga numero,
ngunit kung gusto mo, maaari itong maging isang array
ng mga string, isang array ng struct, ang anumang bagay na nais mong iimbak.
Tungkol sa stack: Ang pagkakaiba sa pagitan ng isang stack at isang naka-link na listahan
ay na sa stack na may access sa huling elemento na ilalagay sa stack mo lamang.
Ito ay tinatawag na huling in, unang out.
Tulad lamang mayroon kang isang stack ng trays,
kung ilalagay mo ang isang tray sa tuktok ng stack,
mayroon kang upang alisin muna na tray upang magkaroon ng access sa iba pang mga trays.
Ito ay ang parehong bagay sa stack.
Kaya kapag gusto kong, halimbawa, magdagdag ng isang sangkap sa isang stack, ano ang dapat kong gawin?
Ito ay tinatawag na push, at ito ay medyo prangka.
Ang unang bagay na kailangan mong gawin ay check kung ang laki ng stack
ay hindi mas malaki sa o katumbas ng kapasidad ng stack.
Dahil kung mayroon ka ay sa buong kapasidad, hindi ka maaaring magdagdag ng ano pa man.
At pagkatapos kung hindi, mayroon na lamang kayong upang idagdag ang elemento sa stack.
At sa wakas, dagdagan ang laki. Kaya ito ay medyo prangka.
Kaya idagdag ko lang ang numero 2.
At kung gusto kong mag-pop, na nangangahulugan na gusto kong alisin
huling elemento na ay naidagdag at ibalik ang halaga ng elemento,
ang unang bagay na kailangan kong suriin ay ang stack ay hindi walang laman.
Dahil kung ito ay walang laman, hindi ko maibabalik ang anumang bagay.
Sa kasong iyon, ako bumabalik -1.
Kung hindi man, ako pagpunta sa pagbawas sa laki ng spec,
at ibalik numero (s.size).
Bakit ang pagbawas ko ang laki at pagkatapos ay bumalik s.size?
Ito ay dahil, sa kasong ito, ang spec ay may sukat 4,
at gusto kong ibalik ang ika-apat na elemento, tama?
Ngunit ano ay ang index ng ika-apat na elemento? Tatlong.
Dahil ko laki - ay magiging 3, maaari ba akong bumalik lamang s.numbers (s.size)
dahil ito ay 3. Kaya lang ang index.
>> Ngayon queues. Queues ay medyo magkano ang parehong bagay.
Ang pagkakaiba lamang ay na sa halip ng pagkakaroon ng huling in, unang out,
Mayroon una kang in, unang out.
Marahil kung ikaw ay naghihintay upang pumunta sa isang konsiyerto,
Hindi ka magiging masaya kung mayroon kang isang stack sa halip ng isang queue.
Ang pagiging ang huling tao na dumating ay magiging ang unang taong pumasok sa konsiyerto.
Hindi mo marahil ay magiging masaya.
Sa pila, ang unang tao upang makakuha ng sa ding ang unang taong upang makakuha ng out.
Kaya sa ang kahulugan ng isang pila, bukod sa pagkakaroon sa laki sa array,
mayroon ka ring magkaroon ng ulo, kung saan ay ang index sa ulo ng stack.
Kaya sa unang elemento sa ngayon.
Enqueue ay ang parehong bagay bilang push para sa mga stack.
Kung ikaw ay napaka-simple, gusto mong sabihin lamang,
well, lamang ang maaari kong gawin nang eksakto ang parehong bagay tulad ng ginawa ko para sa push.
Maaari ko pa lang suriin kung ito ay hindi na lagpas sa kapasidad.
Kung ito ay, bumalik ako ng hindi totoo, kung hindi, maaari ko lang i-export ang mga bagong halaga
at pagkatapos ay dagdagan ang laki.
Ngunit kung bakit ito ay mali?
Tingnan ang halimbawang ito Hayaan.
Sinusubukan ko upang enqueue ng grupo ng mga bagay-bagay,
at pagkatapos ay pupuntahan ko dequeue at enqueue.
Marami ng mga utos, subalit ito ay napaka-simpleng.
Pupunta ako sa enqueue 5, kaya magdagdag 5, at pagkatapos ay i-7,
1, 4, 6, at pagkatapos ay gusto kong dequeue isang bagay,
na nangangahulugan na pupuntahan ko alisin ang unang elemento.
Kaya pupuntahan ko alisin ang bilang 3, tama?
Ang unang elemento. Okay.
Ngayon kung sinusubukan kong i-enqueue ibang bagay, kung ano ang mangyayari?
Ayon sa aking pagpapatupad,
Ako ay pagpunta sa ilagay ang susunod na numero sa index q.size.
Sa kasong ito, ang laki ay 8,
kaya ang index 8 ay magiging dito mismo sa huling posisyon.
Kung sinusubukan kong i-enqueue 1 dito mismo, Gusto ko ma-Sasapawan nito ang huling posisyon
sa numero 1, na kung saan ay ganap na mali.
Ano Gusto kong gawin ay balutin sa paligid at pumunta sa unang posisyon.
Siguro gusto mong sabihin lamang, mahusay, mayroon akong lamang upang suriin
kung ang maaari kong talagang ilagay ang isang bagay doon.
Kung hindi, lamang ko sabihin, oh, ang mga bagong ganap na kapasidad
ay ang tunay na kapasidad - 1, at hindi ka maaaring maglagay ng isang elemento doon.
Ngunit ano ang problema? Ang problema ay kung dequeue ko lang ang lahat ng bagay dito mismo
at pagkatapos ay subukan ko upang magdagdag ng iba pa, ay sabihin lamang,
rin, ikaw ay sa buong kapasidad, na kung saan ay 0.
Kaya iyong queue ay nawala.
Kailangan mong balutin sa paligid, at isang paraan ng pambalot sa paligid
na guys natutunan sa taong nagkakaroon ng mga pangitain at iba pang mga psets ay gumagamit ng mod.
Maaari mo itong subukan sa bahay upang maunawaan kung bakit nais mong gawin q.size + q.head
mod kapasidad, ngunit kung suriin mo dito mismo,
maaari naming makita na ito ay gumagana.
Kaya't sa nakaraang halimbawa, q.size ay 8
at ang ulo ay 1, dahil ito ay ang posisyon ng ito dito ng array.
Kaya ito ang magiging 8 + 1, 9. Mod kapasidad 9 ay magiging 0.
Ito pumunta sa index 0. Babalik kami sa kanang posisyon.
At pagkatapos ay subukan ang queue sa bahay.
Ang ilang mahalagang bagay: subukan upang maunawaan ang pagkakaiba sa pagitan ng isang stack at isang queue.
Sa tahanan, subukan upang makakuha ng napaka-pamilyar sa pagpapatupad ng enqueue, dequeue, push at pop.
At din maunawaan kapag gusto mong gamitin ang bawat isa sa kanila.
>> Ng magrelaks para sa 10 segundo sa isang bungkos ng Pokemons Kaya ipaalam.
At ngayon sabihin bumalik sa mga istraktura ng data.
Hash talahanayan. Ang isang pulutong ng mga tao ay natakot ng hash talahanayan.
sa set problema 6, Spell Checker.
Hash talahanayan at pagsusubok, ng maraming mga tao makakuha ng natakot ng mga ito.
Iniisip nila na ang mga ito kaya mahirap maunawaan. Oo?
[Rob Bowden] Problema set 5. >> Problema set 5, oo. Salamat Rob.
Oo. Anim na noon ay tampo n 'espongha, oo.
Problema set 5 ay Spell Checker, at kayo ay nagkaroon na gamitin ang alinman sa isang hash talahanayan o isang try.
Ang isang pulutong ng mga tao naisip na sila ay sobrang mahirap na maunawaan, ngunit ang mga ito ay aktwal na medyo simple.
Ano ang isang hash talahanayan, talaga? Ang isang hash talahanayan ay isang hilera ng mga naka-link na mga listahan.
Ang tanging pagkakaiba sa pagitan ng isang array at isang hash talahanayan
ay na sa hash talahanayan mayroon kang isang bagay na tinatawag na isang hash.
Ano ang isang hash?
Hindi ko alam kung ka guys ay maaaring magbasa dito.
Ito ay isang halimbawa ng isang hash table.
Kaya maaari mong makita na mayroon kang isang array na may 31 mga elemento.
At ano ang ginagawa namin sa isang hash talahanayan ay magkaroon ng hash
na ay pagpunta upang isalin ang isang susi, ang bawat int sa isang index.
Kung, halimbawa, kung gusto kong piliin para sa B. Harrison,
Gusto ko ilagay B. Harrison sa aking mga pag-andar ng hash,
at ang hash ay magbabalik 24.
Kaya alam ko na gusto kong i-store B. Harrison sa 24.
Kaya na ang pagkakaiba sa pagitan lamang pagkakaroon ng isang array at pagkakaroon ng hash table.
Sa hash talahanayan magkakaroon ka ng isang function na ay pagpunta sa sabihin sa iyo
kung saan upang i-imbak ang data na nais mong iimbak.
Para sa hash, na nais mong maghanap ng isang hash
na deterministic at well-distributed.
Tulad ng iyong nakikita dito, nakikita mo na maraming mga data na Nais kong tindahan ay talagang 19
sa halip ng paggamit 31 at 30 at 29, na kung saan ay libre lahat.
Kaya ang hash na aking ginagamit ay hindi masyadong mahusay na ipinamamahagi.
Kapag sinasabi namin well-distributed, nangangahulugan ito na gusto naming magkaroon,
halos, hindi bababa sa 1 o 2 para sa bawat isa sa mga -
tulad ng, ang isang pagkakaiba ng 1 o 2 para sa bawat isa ang mga indeks sa array.
Gusto mong magkaroon, humigit-kumulang, ang parehong numero ng mga elemento sa bawat naka-link na listahan sa array.
At ito'y madali upang suriin kung ito ay wastong sa hash talahanayan, tingnan ang bilang ng hash talahanayan.
>> Pagkatapos ay puno. Ito ay isang tree.
Puno sa computer science ay baligtad para sa ilang kadahilanan.
Kaya dito mismo mayroon kang root ng tree at pagkatapos ay ang mga dahon.
Dapat mong malaman lamang ang mga katawagan para sa mga magulang at anak.
Ang bawat node ay may mga anak nito, na mga nodes na ay mababa sa magulang.
Kaya, halimbawa, 2 ay magiging mga magulang para sa 3 at para sa iba pang mga bata doon,
habang 3 ay magiging mga magulang para sa 1 at ang ibang mga bata na ang naroon.
At 1 ay magiging anak 3, at iba pa.
Mayroon kaming isang bagay na mas kawili-wiling, na tinatawag na isang binary paghahanap tree,
kung saan ang lahat ng mga halaga sa kanan ng isang node
ay pagpunta sa maging sa kanan, dito mismo - sa kanan,
ay magiging mas mataas kaysa sa elemento sa root.
Kaya kung mayroon akong mga numero 5 dito mismo, ang lahat ng mga elemento sa kanan
ay magiging mas mataas kaysa sa 5, at sa kaliwa
lahat ng mga elemento ay pagpunta sa maging mas mababa sa 5.
Bakit ito kapaki-pakinabang ay?
Well, kung gusto kong i-check kung ang numero 7 ay dito, halimbawa,
Pumunta ko lang sa 5 muna at pupuntahan ko makita, ay 7 mas malaki o mas mababa sa 5?
Ito ay mas malaki, upang malaman ko ito pupuntahan kailangang maging sa kanan ng tree.
Kaya Mayroon akong higit na mas mababa bagay-bagay upang tumingin sa.
Sa pagpapatupad ng isang binary puno ng paghahanap, ang node, tingin lang ako sa pagpunta sa mayroon na magkaroon ng data,
kaya int n; maaari ka ring magkaroon ng isang string
o anumang bagay na gusto mo.
Mayroon kang lamang maging maingat sa paglalarawan ng kung ano ay mas malaki, kung ano ay mas mababa.
Kaya kung kayo ay nagkaroon ng mga string, halimbawa, na maaari mong tukuyin ang
na ang lahat ng mga bagay sa kanan ay pagpunta sa may mas malaking haba,
sa kaliwa ay pagpunta sa may mas mababang mga haba, kaya talagang nakasalalay sa iyo.
>> Paano ko maaaring ipatupad mahanap para sa BST?
Ang unang bagay na kakailanganin naming gawin ay suriin kung ang ugat ay walang bisa.
Kung ito ay walang bisa, nangangahulugan ito na ang bagay ay hindi doon
dahil hindi mo kahit na may isang puno, tama?
Kaya bumalik ako ng hindi totoo.
Kung hindi man, ako pagpunta upang suriin kung ang mga numero ay mas malaki
kaysa sa halaga sa root.
Pupunta ako sa subukang maghanap ng mga elemento sa kanan
mula sa puno.
Ang makikita mo na gumagamit ako ng recursion dito.
At pagkatapos ay kung ito ay mas kaunti, Pupunta ako sa tumingin sa kaliwa.
At sa wakas, kung hindi man, kung hindi mas o hindi mas malaki,
ibig sabihin nito na ito ang halaga mismo.
Kaya bumalik ko lang ang totoo.
Maaari mong makita dito na ginamit ko kung, kung, kung.
At tandaan, sa pagsusulit 0, nagkaroon kami ng problema na nagkaroon kung, kung, kung,
at na ipagpalagay upang mahanap ang kawalan ng kaalaman,
at ang kawalan ng kaalaman ay na iyong ginamit kung.
Dapat na ginamit mo kung, iba kung, iba kung, at iba pa.
Kaya, ang dapat kong gamitin pang tao kung at iba kung at iba pa dito?
Sinusuportahan ba ng sinuman - oo?
[Pagsasalita ng Mag-aaral, hindi marinig]
Iyan ay perpekto. Kaya ang sinasabi niya na ito ay hindi mahalaga,
dahil lang sa kawalan ng kaalaman na namin ay may bago
ay na dahil, siguro kung ilang mga kundisyon ay nasisiyahan na dito,
kaya mo gumanap ang isang aksyon, ngunit pagkatapos ikaw ay pagpunta upang suriin ang lahat ng mga iba pang mga kondisyon.
Ngunit sa kasong ito, nagbalik ito agad-agad, kaya hindi mahalaga.
Kaya hindi mo na kailangang gumamit ng ibang tao kung.
>> At sa wakas, makipag-usap tungkol sa pagsusubok na ipaalam,
na kung saan ay paborito ng lahat.
Isang try ay isang puno ng array.
Ito ay napakabilis upang maghanap ng mga halaga, ngunit ito ay gumagamit ng maraming memorya.
At ito ay karaniwang upang i-filter ng mga salita, kaya kapag ka
nais ipatupad, halimbawa, hindi ko alam, tulad ng isang libro ng telepono sa iyong telepono
at nais mong magagawang i-type B
at mayroon lamang mga pangalan ng mga tao na may B.
Ito ay napakadaling ipatupad na ang paggamit ng isang try, halimbawa.
Paano ko tutukuyin mo ang isang node sa isang try?
Mayroon kang lamang upang magkaroon ng isang bool na pagpunta sa ma-is_word.
Iyon ay kumakatawan na ang paggamit ng lahat ang mga character na bago na node,
nagawa mong bumuo ng isang salita,
at pagkatapos ay magkakaroon ka ng isang array ng mga payo sa mga node.
Maaari mong makita na mayroon kami ng isang hanay ng mga magulang nodes, kaya node * array? Oo?
Kaya sabihin makita kung paano na gagana. Para sa spell check,
mayroon kaming isang array ng 27 mga elemento,
dahil mayroon kaming lahat ang mga titik plus ang kudlit.
Bago dito lang ako sa pagpunta sa gamitin ang 2 dahil gusto kong maging magagawang magsulat sa board.
Okay. Kaya ito ay isang halimbawa ng isang try.
Kung tukuyin ko lang ang unang node, kukunin ko na magkaroon ng isang hanay ng mga 2 elemento
na 2 pointer sa null, upang ilagay ko lang ang 'isang' at 'b'.
At ako pupunta upang magkaroon ng isang bool na nagsasabing is_word.
Ito ay pagpunta sa maging hindi totoo para sa unang isa,
dahil lang, bago na wala kang anumang mga character.
Kaya isang walang laman na salita ay hindi isang salita. Kaya ito ay hindi totoo.
Kung gusto kong idagdag ang 'isang' sa diksyunaryo ito, ano ang magiging kailangan kong gawin?
Gusto ko magkaroon lang sa malloc isang bagong node para sa 'isang',
at pagkatapos ay idagdag ang salita nito sa true.
Kaya lamang ay kumakatawan ito na nagki 'ang isang' ay magiging totoo. Magkaroon ng kahulugan?
Pagkatapos ay kapag gusto kong idagdag ang 'BA', ang kukunin ko upang malloc 1 para sa 'b',
at pagkatapos ay pupuntahan ko i-set up ang boolean sa hindi totoo,
dahil 'b' sa pamamagitan ng kanyang sarili ay hindi isang salita.
Pagkatapos Pupunta ako sa malloc ng isa pa para sa 'isang', kaya 'BA',
at pagkatapos ay pupuntahan ko i-set up ito ay isang salita sa true.
Dahil 'BA' ay isang salita.
At pagkatapos ay kapag gusto kong makita kung 'b' ay nasa diksiyonaryo ito,
Maaari kong pumunta lamang sa unang isa, 'b'. Pumunta ako pababa, at hanapin ko sa ay salita, at sinasabi nito na hindi totoo.
Kaya ito ay hindi isang salita. Kung gusto kong i-check ang 'BA',
Pumunta ako sa unang isa, 'b', at pagkatapos ay pumunta sa 'isang', at nakikita ko totoo, kaya ito ay isang salita. Magkaroon ng kahulugan?
Ang isang pulutong ng mga tao makakuha ng malito sa pamamagitan ng pagsusubok. Walang?
>> Sa wakas, Huffman coding. Huffman coding ay lubhang kapaki-pakinabang
i-save ang memorya at i-compress na mga tekstong file,
dahil lang ng maraming beses gamitin mo ang 'isang' at 'e', ​​halimbawa,
sa iyong mga dokumento, ngunit hindi ko alam kung ikaw guys gamitin ang 'q' o 'z' bilang magkano.
Ang pagkakaroon byte 1 lamang para sa bawat solong character,
bawat solong - ang 256 na character na mayroon kami sa table ASCII ay hindi masyadong pinakamainam,
dahil lang mayroong ilang mga character na gamitin mo ang marami pang iba,
kaya dapat mong marahil gamitin mas mababa memory para sa mga.
Paano ko gagamitin ang Huffman coding?
Mayroon kaming na gawin ang isang Huffman tree.
Isang Huffman puno ay may mga node
na magkaroon ng isang simbolo na ay magiging tulad ng, 'isang', 'b', 'c', ang titik,
kahit anong sulat na mayroon ka, ang isang dalas na ay ang dalas na lumilitaw ang salita sa teksto,
na ikaw ay lumilikha ng Huffman puno para sa,
at pagkatapos ay isang node na ay pagpunta upang tumuro sa kaliwa ng Huffman puno
at isa pa na node na ay pagpunta upang tumuro sa kanan. Kaya gusto lamang ng isang tree.
Paano bumuo ka ng isang Huffman puno?
Ikaw ay pagpunta sa pumili ng 2 nodes na mayroong pinakamababang frequency.
Kung mayroon kang ang kurbatang ka ng pagpunta sa pumili ng 2 nodes
na mayroon pati na rin ang pinakamababang halaga na ASCII.
Pagkatapos ay ikaw ay pagpunta upang lumikha ng bagong puno out ng mga 2 nodes
na ay pagpunta sa may pinagsamang dalas sa magulang na node.
At pagkatapos ka ng pagpunta sa alisin ang 2 bata mula sa gubat
at palitan ang mga ito sa magulang.
At ka ng pagpunta sa ulitin na hanggang sa magkaroon ka lamang ng 1 puno sa kagubatan.
Kaya sabihin makita kung paano mo gawin ang isang Huffman puno para ZAMYLA.
Maaari mong makita dito na ang lahat ang mga titik na mayroon dalas 1 maliban para sa 'A'; na may dalas 2.
Kaya Lumikha ako node para sa lahat ang mga titik Naglagay ako sa pagkakasunud-sunod ng halaga ASCII at dalas.
Kaya kung nais kong lumikha ng unang puno, ito ay may 'L' at 'M'.
Kaya dito. Ang dalas ng mga pares ay magiging 2
dahil ito ay 1 + 1, pagkatapos ay ang susunod na 2 na may pinakamababang frequency ay 'Y' at 'Z'.
At pagkatapos Mayroon akong lahat ng mga ito sa pagiging - magkaroon ng isang dalas ng 2.
Kaya kung alin ang sana ang mga iyon ay may pinakamababang halaga na ASCII para sa susunod na isa?
'A' at 'L'. Kaya lumikha ako ng bagong node,
at sa wakas, ito ay 4 at 2, kaya 2 ay magiging sa kaliwa.
At ito ang Huffman tree.
Pagkatapos ay kapag gusto kong magsulat ng ilang teksto,
tulad ng sa binary ma-convert sa text, gamit ang Huffman puno Napakadaling.
Halimbawa, kung sabihin ko na gumagalaw sa kaliwa ay isang 0 at paglipat sa kanan ay isang 1,
Ano na pagpunta sa kumakatawan?
Kaya tulad ng 1, 1, kaya karapatan, karapatan,
at pagkatapos ay 0, kaya ang natitira ay magiging L, at pagkatapos 1, 0, 0.
Kaya 1, 0, kaya 1 lamang, 0, 'A'.
At pagkatapos ay 0, 1, kaya 'Z'.
At pagkatapos 1, 0, 0 - walang.
0, 0 ay magiging 'Y', kaya Lazy.
Kaya na ang lahat para sa akin, Rob ng pagpunta upang sakupin.
>> [Rob Bowden] Kaya, linggo 7 mga bagay-bagay.
Nakakuha kami ng maraming upang pumunta sa paglipas ng talagang mabilis.
Bitwise operator, buffer overflow,
CS50 library, pagkatapos ng HTML, HTTP, CSS.
Lahat ng sa tulad ng 15-20 minuto.
Bitwise operator. Mayroong 6 na sa kanila na ang kailangan mong malaman.
Bitwise at, bitwise o, XOR, pakaliwa shift, i-right shift, at hindi.
Mag-right shift at hindi mo halos nakita sa lecture sa lahat.
Susubukan naming pumunta sa paglipas ng ito mabilis dito, subalit ito ay handa na upang malaman na ang mga ito ay ang 6 na umiiral.
Tandaan na ang bitwise operator ay tulad ng kapag gumawa ka 3 + 4.
Hindi ka naka pagharap sa mga binary ng 3 at 4.
Gamit ang bitwise operator ikaw ay talagang pagharap sa mga indibidwal na mga piraso ng ang mga numero 3 at 4.
>> Kaya ang unang isa na aming sinasabi ay bitwise hindi,
at ang lahat ng ginagawa nito ay i-flip ang lahat ng mga piraso.
Kaya dito, kung ikaw ay sumusulat ito sa C, ikaw ay hindi sumulat ito
bilang ~ 11,011 o kahit ano, gusto mong isulat ito i ~ 4,
at pagkatapos ay i-flip ito ang binary na representasyon ng 4.
Kaya dito, ~ ng ilang mga binary numero 1101101 ay pagpunta sa eksaktong i-flip ang lahat ng 1 sa 0 at ang lahat ng 0 upang 1 ni.
Tulad ng sinasabi ko doon, ang madalas na paggamit ng mga ito,
at kami na makita ito sa isang bit, ay tulad ng gusto naming makabuo ng ilang mga numero
kung saan ang lahat ng mga bits ay 1, maliban para sa isa sa mga ito.
Kaya ito ay kadalasang mas madali upang ipahayag ang bilang
kung saan lang na single bit ay nakatakda,
at pagkatapos ay dadalhin ang ~ ng ito, kaya ang bawat iba pang mga bit ay nakatakda maliban para sa isa na.
Kaya na kung ano ang pagpunta naming gumamit ng higit sa isang bit.
>> Bitwise o. Narito ang 2 binary numero, at mga 2 numero
ay medyo kinatawan, dahil kinakatawan nila ang bawat posibleng
kumbinasyon ng mga piraso maaari mong kailangan upang gumana sa.
Dito, kapag or'd ko bawat bit, kami ay lamang ng pagpunta sa ihambing diretso pababa.
Kaya sa kaliwang bahagi mayroon kaming 1 at 1.
Kapag bitwise ako | mga, kung ano ako ng pagpunta upang makakuha? One.
Pagkatapos bitwise | 0 at 1 ay pagpunta sa magbibigay sa akin? One.
Bitwise 1 at 0 ay magiging ang parehong bagay, isa.
Bitwise 0 | 0 ay pagpunta sa akong bigyan 0.
Kaya ang tanging kaso kung saan nakukuha ko 0 ay nasa 0 | 0 kaso.
At maaari mong isipin na tulad ng ginagawa ng iyong mga lohikal na ors.
Kaya kung sa tingin mo ng 1 bilang totoo at 0 bilang huwad, ang parehong bagay ay nalalapat dito.
Kaya totoo o totoo ay totoo; totoo o hindi totoo.
Hindi totoo o totoo ay totoo; mali o hindi totoo ay ang tanging bagay na talagang hindi totoo.
Narito ang halimbawa na dapat mong malaman
bilang isang magandang magandang halimbawa ng kung kailan bitwise operator ay ginamit.
Narito kung kami o kabisera 'A' sa Ox20,
at titingnan namin ito sa isang segundo, makakakuha tayo ng isang bagay.
At kung namin o maliliit na 'ang isang' na may Ox20, makakakuha tayo ng isang bagay.
Kaya ni-pull up ASCII talahanayan ipaalam.
Okay. Narito makita namin na 'A' ay may -
dito mayroon kaming 'A' ay desimal 65.
Ngunit masisiyahan pumunta ako sa hexadecimal, na kung saan ay Ox41.
Pretty bang Nakita namin ito sa klase. Sa tingin ko Nakita namin ito sa klase
na ito ay medyo madaling i-convert mula sa hexadecimal sa binary.
Kaya dito, kapag gusto kong ilagay 4 sa binary,
na lamang ang pagpunta sa maging 0100.
Ito ay 1 ng lugar, ang lugar na 2, ang lugar 4, kaya ito ay 4.
Pagkatapos ay maaari kong hatiin 1 sa binary, na kung saan ay magiging 0001.
At kaya ito ay magiging ang representasyon ng 'A' sa binary.
Pagkuha ng lowercase na 'isang', ito ay ngayon pagpunta sa maging Ox61,
kung saan, paghahati mga up sa binary nito, kaya isang 6 -
Ni aktwal na gawin ito Hayaan - ay walang pambura? Pambura.
Ox61. Kaya paghahati 6 sa binary ay magiging 0 + 4 + 2 + 0.
At paghahati ng 1 ay magiging 0001.
Sa pagtingin sa mga pagkakaiba sa pagitan ng mga 2,
nakita namin na ang tanging pagkakaiba sa pagitan ng isang maliit na titik at may malaking titik 'A' ay ang nag-iisang bit.
Kaya babalik sa dito - okay.
Babalik sa dito, kung tinitingnan namin kung ano ang bit Ox20 ay,
kaya paghahati ng Ox20 sa binary nito,
ay 0010, 0000.
Ox20, ang tanging bit na itakda ay bit na ito na kami ay nababahala sa,
may lumilipat sa pagitan ng capital at lowercase na 'ang isang'.
Kung ako o 'A', na kung saan ay ang isang ito, 'A',
kung ako o 'A' sa Ox20,
kung ano ako ng pagpunta upang makakuha?
[Mag-aaral, hindi marinig] >> Maliit na titik 'ng', sapagkat ito ang nangyayari upang i-flip ito bit sa isang 1.
At kung ako o 'ang isang' na may Ox20, kung ano ako ng pagpunta upang makakuha?
Maliit na titik a, dahil oring lamang 'ang isang' na may Ox20,
Lamang ako pupunta na oring ito solong bit sa isang 1; ito nang 1, kaya hindi mahalaga.
Kaya makuha namin 'ang isang' at 'isang'.
>> Bitwise at. Muli, maaari naming isipin na ito bilang aming mga lohikal at kamukhang-mukha.
Sa kaliwang bahagi mayroon kami totoo at tunay.
Ito ay pagpunta sa maging totoo, at para sa lahat ng mga kaso,
hindi totoo at tama o totoo at hindi totoo, o hindi totoo at hindi totoo,
wala sa mga bagay na totoo.
Kaya kung ano ang napupunta namin na maging ay 1000.
Kaya ngayon, narito, narito kung saan ginamit ko na ang mga mapagkakatiwalaan bitwise hindi,
kung saan namin ay may Ox20.
Kaya ito ay Ox20.
Ngayon kung ano ang gusto kong gawin, bitwise ~ ng Ox20.
Iyon ay pagpunta upang i-flip ang lahat ng mga piraso.
Kaya Mayroon akong 1101, 1111.
At kaya 'A' anded may ~ Ox20 ay pagpunta sa magbibigay sa akin kung ano?
Ang tanging bit talagang kailangan naming isipin ang tungkol ay ang isang ito,
dahil, kung ang lahat ng mga bits ay nakatakda sa 1,
pagkatapos kami ay pagpunta upang makakuha ng kung ano mismo ang 'A' ay,
maliban sa, marahil, kung ano ito ay bit.
Dahil kung ito ay isang 1, ngayon ito ay pagpunta sa itakda sa isang 0,
dahil kahit anong ito ay, anded may ito ay magiging 0.
Kaya kung ano ang 'A' & ~ Ox20 pagpunta sa magbibigay sa akin?
[Mga mag-aaral sagutin, hindi marinig] >> At kung ano ay 'isang' at - ito ay 'A'.
At kung ano ay 'isang' & ~ Ox20 pagpunta sa magbibigay sa akin?
'A.' Dahil ito ay kasalukuyang isang 1.
Anding na may ganitong 0 ay pagpunta sa gawin itong isang 0,
at ngayon kami ay pagpunta upang makakuha ng isang 'A'.
>> Ang parehong ay 'A,' at huling ngunit hindi bababa sa na may ganitong uri,
mayroon kaming XOR. Ito ay napaka magkano katulad o,
maliban ito ay nangangahulugan lang o.
Ito ay tulad ng kung ano ang iyong karaniwang sa tingin ng bilang o sa tunay na mundo.
Kaya gawin mo ang alinman sa 'x' o 'y', ngunit hindi pareho.
Narito 1 ^ 1 ay magiging 0.
Dahil ang totoo, ito ay - hindi ito gumana pati na rin sa mga lohikal na totoo at hindi totoo
bilang bitwise & at o gawin,
pero totoo ^ true false.
Dahil nais lamang naming nagbabalik ng tunay na kung ang isa lamang sa mga ito ay totoo.
Kaya 1 ^ 1 ay 0. Paano ang tungkol sa 0 ^ 1?
Ay 1. 1 ^ 0 ay 1, 0 0 ^ ay 0.
Kaya sa ilalim ng lahat ng mga pangyayari, 0 bitwise isang bagay 0 ay magiging 0.
1 bitwise isang bagay 0 o 0 bitwise 1,
kung ito ay | o ^, ito ay maging isang 1, at kung ito ay & magkakaroon ito ay 0.
At ang tanging kaso kung saan 1 bitwise 1 ay hindi 1 ay may eksklusibong o.
Iyan 0110.
Kaya dito ngayon, gamit XOR - kaya hindi namin pabalik sa 20.
'A' ^ Ox20 ay mga 2 piraso kami ng paghahambing.
Kaya isang 1 ^ 0 ay pagpunta sa ninyo ako ng kung ano? Isang isa.
'A' ^ Ox20 ay pagpunta sa magbibigay sa akin? Maliit na titik a.
'Ang isang' ^ Ox20 ay pagpunta sa magbibigay sa akin? Capital A.
Dahil kahit anong ito ay ginagawa, ito XORing may Ox20
ay epektibo flipping kahit anong ito ay bit.
Kung ito ay isang 0, ito ay ngayon pagpunta sa maging isang 1.
Dahil ito ay isang 1, 1 ^ 1 ay 0.
Kaya aming 'ang isang' ay naging 'A', at ang aming 'A' ay naging 'ang isang'.
Kaya XOR ay isang tunay na maginhawang paraan ng flipping lamang ang kaso.
Gusto mo lang na umulit sa isang string ng mga titik
at pagsalitin kaso ng bawat solong character,
ikaw lang XOR lahat ng bagay na may Ox20.
>> Ngayon na iniwanan namin shift. Kaliwa shift ay pagpunta lamang sa, talaga,
itulak ang lahat ng mga numero sa, o sa kaliwa, at ipasok 0 ni sa likod ng mga ito.
Kaya dito mayroon kaming 00,001,101.
Kami ay pagpunta sa itulak 3 sa 0 mula sa kanan,
at makakakuha tayo ng 01,101,000.
Sa nonbinary termino,
nakita namin na iyon talaga ang pagharap 13-kaliwa-Paglipat sa 3, na nagbibigay sa amin ng 104.
Kaya kaliwang paglilipat, makikita natin dito, x << y ay isa lamang x * 2 ^ y.
13 * 2 ^ 3, 2 ^ 3 ay 8, kaya 13 * 8 ay 104.
Kung sa tingin mo lamang tungkol sa binary sa pangkalahatan, gaano bawat digit,
kung simulan namin mula sa kanan, ito ang 1 lugar, pagkatapos ay i-lugar ang 2, at pagkatapos lugar ang 4 na.
Kaya sa pamamagitan ng pagtulak sa 0 mula sa kanan,
naka pagtulak lang namin ang mga bagay na nasa lugar ang 4 na lugar ang 8 ni,
at mga bagay na nasa lugar ang 8 upang lugar ang 16 ni.
Ang bawat shift multiply sa pamamagitan lamang ng 2. Oo?
[Mag-aaral] Ano ang mangyayari kung ikaw Paglipat sa pamamagitan ng 5?
[Bowden] Kung Paglipat sa pamamagitan ng 5 gusto mo mawala lamang digit.
Hindi maaaring hindi, ito ay ang parehong bagay. Tulad ng, integer ay bit sa 32 lamang,
kaya kung idagdag mo ang 2 talagang malaki integer, ito lamang ay hindi magkasya sa isang integer.
Kaya ito ang parehong bagay dito. Kung ikaw Paglipat sa pamamagitan ng 5,
Gusto naming mawala lamang isa na.
At iyon ang uri ng kung ano ang ibig sabihin ko sa pamamagitan ng "halos,"
kung saan kung lilipat ka masyadong malayo, nawalan ka ng bits.
>> Right shift ay magiging ng kabaligtaran,
kung saan kami ay pagpunta sa tulak 0 ng off sa dulo,
at para sa aming mga layunin, punan 0 mula sa kaliwa.
Kaya ginagawa ito, talaga kami pagtaliwas kung ano na kami ay tapos na.
At nakita namin na ang tatlong 0 sa kanan ay bumagsak lamang off,
at na-hunhon namin ang 1101 ang lahat ng mga paraan sa kanan.
Ito ay ginagawa 104 >> 3, na kung saan ay, mabisa, x / 2 ^ y.
Kaya ngayon, dito, ito ay isang katulad na ideya.
Bakit ito halos lamang ay x / 2 ^ y, at hindi talagang x / 2 ^ y?
Dahil kung ako ay Paglipat sa pamamagitan ng 4, sana ako nawala isang 1.
Talaga, ano sa tingin mo ng, sa tingin lamang ng integer division sa pangkalahatan.
Kaya, tulad ng 5/2 ay 2. Ito ay hindi 2.5.
Ito ay ang parehong mga ideya dito. Kapag hinati namin sa pamamagitan ng 2,
maaari naming mawala ang mga kakaibang mga piraso sa kahabaan ng paraan.
Kaya ngayon - iyon ito para sa bitwise. Iyon lang ang kailangan mong malaman.
Tandaan ang mga kaso na paggamit nakita natin sa klase,
tulad ng isang bit mask ay kapaki-pakinabang para sa bitwise operator,
o gamitin mo ang mga ito para sa bit mask.
Malalaking titik at maliliit na mga titik, mga conversion ay isang kaakit-akit na prototypical halimbawa.
>> Okay, sa gayon buffer overflow na pag-atake.
Sinuman matandaan kung ano ang mali sa function na ito?
Abisuhan ang ipinahayag kami ng isang hanay ng mga 12 bytes, 12 na karakter,
at pagkatapos ay kokopyahin namin sa aming buffer ng 12 char ang buong string bar.
Kaya ano ang problema dito?
Ang magic number 12 dapat halos agad-pop out bilang - kung bakit 12?
Paano kung bar ang mangyayari na maging mas mababa sa 12 mga character?
Paano kung bar ay milyon-milyong mga character?
Narito ang isyu ay memcpy. Kung bar ay mahaba sapat,
ito ay ganap lamang - 'c', 'c' ay hindi na mahalaga na ito ay character 12 lamang;
'C' ay hindi na mahalaga na hindi ito maaaring magkasya na maraming bytes.
Ito ay ganap lamang patungan pansamantalang trabaho, ang 12 bytes na inilalaan namin para rito,
at ang lahat ng nakalipas na ito sa memorya na hindi talaga nabibilang sa na nagpapahina ng lakas
may anuman ang string bar.
Kaya ito ay ang larawan nakita natin sa klase
kung saan mayroon kaming ang aming stack na lumalagong up.
Dapat mong magamit upang ilan sa mga larawang o maging pamilyar sa mga ito muli.
Na aming stack na lumalagong namin up, memory address magsisimula sa 0 sa tuktok
at palaguin pababa upang i 4000000000 sa ibaba.
Mayroon kaming ang aming array 'c' sa isang lugar sa memorya,
pagkatapos ay mayroon kaming ang aming pointer sa bar karapatan sa ilalim nito,
at pagkatapos ay mayroon kaming ito save frame pointer sa aming return address at stack ang aming mga magulang routine ni.
Tandaan kung ano ang return address ay?
Ito ay kapag ang pangunahing tawag ng isang function foo, tawag ng isang function bar,
hindi maaaring hindi, bar babalik.
Kaya kapag ang pagbalik ng bar, kailangan nila upang malaman na ito ang nangyayari pabalik sa foo na tinatawag na ito.
Kaya ang return address ay ang address ng pag-andar na ito ay may upang bumalik sa kapag ang pag-andar babalik.
Ang dahilan na mahalaga para sa pag-atake ng buffer overflow ay dahil, maginhawa,
i hacker na baguhin na return address.
Sa halip ng pagpunta pabalik sa foo, Pupunta ako upang bumalik sa kung saan man nais ni ang Hacker sa akin upang bumalik sa.
At, Maginhawa, kung saan madalas Nais ni ang Hacker upang bumalik sa
ay ang simula ng buffer na orihinal na namin ay may.
Kaya't mapapansin, muli, Little India.
Ang appliance ay isang halimbawa ng isang Little Indian sistema,
kaya isang integer o isang pointer ay naka-imbak sa bytes reverse.
Kaya dito makita namin - ay ito? Oo.
Nakakakita kami ng Ox80, OxC0, Ox35, OxO8.
Tandaan ang mga digit hexadecimal?
Hindi namin baligtarin ang hexadecimal digit sa Little India,
dahil 2 digit hexadecimal bumubuo ng isang solong byte, at baligtarin namin ang bytes.
Iyon ang dahilan kung bakit hindi kami nag-iimbak, tulad ng, 80530CO8.
Iniimbak namin, sa halip, ang bawat pares ng 2 digit, na nagsisimula mula sa kanan.
Ang address na iyon ay tumutukoy sa address ng pagsisimula
sa aming mga buffer na namin nais na aktwal na upang kopyahin papunta sa unang lugar.
Ang dahilan na kapaki-pakinabang ay dahil, paano kung ang pag-atake
nangyari sa, sa halip ng pagkakaroon ng isang string lamang
isang hindi nakakapinsala string ng mga katulad, ang kanilang pangalan o isang bagay,
ano kung, sa halip, na string ay lamang ng ilang di-makatwirang code
na ginawa kahit anong nais nila itong gawin?
Kaya nila - ako maaaring hindi tingin ng anumang mga cool na code.
Ito ay maaaring maging anumang bagay, bagaman. Ang anumang mapaminsalang code.
Kung nais nila, maaari nilang gawin lamang ng isang bagay sa seg faults, ngunit iyon ay magiging walang bisa.
Karaniwan nilang gawin ito sa tadtarin sa iyong system.
>> Okay. CS50 library.
Ito ay, talaga, getInt, getString, ang lahat ng mga function na ibinigay namin para sa iyo.
Kaya mayroon kaming pansamantalang trabaho * string, at iyon ang abstraction na namin blew ang layo
sa isang punto sa panahon ng semestre.
Alalahanin na ang isang string ay lamang ng isang hanay ng mga character.
Kaya dito makita natin ang isang abridged bersyon ng getString.
Dapat mong lingunin ito upang matandaan kung paano talaga ito ay ipinatupad.
Key mga detalye ay, mapansin makuha namin sa isang solong character sa isang pagkakataon
mula sa standard sa, na kung saan ay tulad lang sa amin ang pagta-type sa keyboard.
Kaya isang solong character sa isang pagkakataon, at kung makuha namin masyadong maraming mga character,
kaya kung n + 1 ay mas malaki sa kapasidad,
pagkatapos ay kailangan namin upang madagdagan ang kapasidad ng aming buffer.
Kaya dito kami pagdodoble sa laki ng aming buffer.
At iyon ay nagpapanatili ng pagpunta; isingit namin ang mga character na sa aming buffer
hanggang sa matanggap namin ang isang bagong linya o pagtatapos ng file o kahit anong,
sa kasong ito, tapos na kami sa string at pagkatapos ay ang tunay na getString
Pinaliliit ang memorya, tulad ng kung inilalaan namin ng masyadong maraming memorya magkakaroon ito bumalik at pag-urong ng kaunti.
Kaya hindi namin ipakita na, ngunit ang pangunahing ideya ay
ito ay upang basahin sa isang solong character sa isang pagkakataon.
Hindi ito maaaring basahin lamang sa isang buong bagay nang sabay-sabay,
sapagkat ang kanilang buffer ay lamang ng isang tiyak na laki.
Kaya kung ang string na ito sinusubukan upang ipasok sa buffer ay masyadong malaki, pagkatapos ay magdudulot ito apaw.
Kaya dito pigilan namin na sa pamamagitan lamang ng pagbabasa sa isang solong character
sa isang pagkakataon at lumalaki sa tuwing kailangan naming.
Kaya getInt at ang iba pang mga pag-andar CS50 library ay may posibilidad na gamitin getString
sa kanilang mga pagpapatupad.
Kaya naka-highlight ko ang mga mahahalagang bagay dito.
Tawag Nag getString upang makakuha ng isang string.
Kung nabigo getString upang bumalik memorya,
tandaan na getString mallocs isang bagay, kaya kahit kailan mo tawagan getString
dapat mong hindi (hindi maintindihan) palayain na string na iyong nakuha.
Kaya dito, kung nabigo ito sa malloc isang bagay, bumalik kami INT_MAX bilang isang flag lang iyon,
hey, kami ay hindi talagang magagawang upang makakuha ng isang integer.
Dapat mong huwag pansinin ang anumang bumalik ako sa iyo, o
hindi mo dapat ituring ito bilang isang wastong input.
Sa wakas, sa pag-aakala na ang magtagumpay, ginagamit namin sscanf may espesyal na flag,
na nangangahulugan, tumugma sa unang isang integer,
pagkatapos ay tumugma sa anumang mga character pagkatapos na integer.
Kaya't mapapansin gusto namin ito upang pumatas 1.
Kaya sscanf babalik ang kung gaano karaming mga tugma kung Matagumpay na nagawa?
Ito ay bumalik 1 kung matagumpay ito tumugma sa isang integer,
ito ay bumalik 0 kung hindi ito tumugma sa isang integer, at ito ay bumalik 2
kung tumugma ito isang integer na sinusundan ng ilang mga character.
Kaya't mapapansin muling subukan namin kung tumutugma namin ang anumang bagay ngunit 1.
Kaya kung ipinasok namin 1, 2, 3, C, o 1, 2, 3, X,
pagkatapos 1, 2, 3 gusto makakuha ng naka-imbak sa integer,
X nais makakuha ng naka-imbak sa mga karakter,
Gusto sscanf bumalik 2, at gusto naming subukang gamitin ulit, dahil gusto lang namin ang isang integer.
>> Mabilis na pamumulaklak sa pamamagitan ng HTML, HTTP, CSS.
Hypertext Markup Language ay ang istraktura at semantika ng web.
Narito ang halimbawa mula sa panayam kung saan mayroon kaming mga tag na HTML.
Mayroon kaming head tag, katawan tag,
mayroon kaming mga halimbawa ng mga walang laman na mga tag kung saan kami talaga ay walang isang panimula at malapit na tag,
mayroon lang namin link at imahe.
Walang dulong tag ng imahe; mayroong lamang isang solong tag na accomplishes ang lahat ng bagay kailangan ng tag na gawin.
Ang link ay isang halimbawa; makikita namin kung paano ka mag-link sa CSS,
ang script ay isang halimbawa ng kung paano mo i-link sa isang panlabas na JavaScript.
Ito ay medyo prangka, at tandaan, HTML ay hindi isang programming language.
Dito, tandaan kung paano mo tukuyin ang isang form o hindi bababa sa kung ano ang gagawin?
Ang ganitong mga form sa isang May isang pagkilos at isang paraan.
Ang pamamaraan na ito ay mo man lamang makita ang mga GET at POST.
Kaya GET ay ang bersyon kung saan ang bagay ay makakakuha ng ilalagay sa URL.
POST ay kung saan ito ay hindi ilalagay sa URL.
Sa halip, ang anumang data mula sa form na ito ay naipasok sa higit pang nakatagong sa kahilingan ng HTTP.
Kaya dito, ang pagkilos ay tumutukoy kung saan napupunta ang mga kahilingan ng HTTP.
Saan ito ang nangyayari ay google.com / search.
Pamamaraan. Tandaan ang mga pagkakaiba sa pagitan ng GET at POST,
at, sabihin lamang bilang isang halimbawa, kung nais mong i-bookmark ang isang bagay.
Hindi mo magagawang i-bookmark ang isang POST URL
dahil ang data ay hindi kasama sa URL.
>> HTTP, ngayon, ay Hypertext Transfer Protocol.
Ang Hypertext Transfer Protocol, gusto mong asahan ito upang maglipat ng mga
Hypertext Markup Language, at ginagawa nito.
Ngunit mayroon din transfer ng anumang mga imahe na mahanap ka sa Web,
anumang mga pag-download na gagawin mo simulan bilang isang kahilingang HTTP.
Kaya HTTP lamang ang wika ng World Wide Web.
At dito kailangan mong nakikilala ang uri ng isang HTTP kahilingan.
Narito HTTP/1.1 sa gilid lamang sabi iyon ang bersyon
ng protocol gumagamit ako.
Ito ay halos palaging magiging HTTP/1.1, bilang makikita mo ito.
Pagkatapos nakita namin na ito ay GET, ang alternatibong pagiging POST, na maaari mong makita.
At ang URL na ako ay sinusubukan mong bisitahin ay www.google.com/search?q = blah, blah, blah.
Kaya tandaan na ito, ang mga tandang pananong q = blah blah blah,
ay ang uri ng mga bagay-bagay na ay isinumite sa pamamagitan ng isang form.
Ang tugon maaari itong bumalik sa akin magmumukhang ito.
Muli, na nagsisimula sa protocol, na kung saan ay pagpunta sa maging iyon,
kasunod ang code ng katayuan. Narito ito ay 200 OK.
At sa wakas, ang web page na talaga ko tinanong para sa ay sinundan.
Ang mga posibleng code ng katayuan na maaari mong makita, at dapat mong malaman ang ilan sa mga ito.
200 OK marahil mo nakita bago.
403 Forbidden, 404 Not Found, Error 500 Internal Server
ay karaniwang kung pupunta ka sa isang website at isang bagay ay nasira o ang kanilang mga pag-crash code na PHP,
samantalang sa appliance na mayroon kami na malaki orange na kahon
na ay lumalabas at sabi, tulad ng, ang isang bagay ay mali, ang code na ito ay hindi gumagana
o ito pagpapaandar ng masama.
Karaniwan mga website ay hindi gusto mong pag-alam kung ano ang function ay aktwal na masama,
kaya sa halip makikita lang nila magbibigay sa iyo ng 500 Panloob na error sa server.
>> TCP / IP ay 1 layer sa ilalim ng HTTP.
Tandaan na mayroong Internet sa labas ng World Wide Web.
Tulad ng kung i-play ka ng isang online game na hindi pumunta sa pamamagitan ng HTTP,
itong ibang mapupuntahan sa pamamagitan ng isang iba't ibang - ito ay gumagamit pa rin ng Internet,
ngunit hindi ito ang ginagamit ng HTTP.
HTTP ay isa lamang halimbawa ng mga protocol na binuo sa TCP / IP.
IP Literal na nangangahulugan ng Internet Protocol.
Ang bawat computer na may IP address; ang mga ito ay mga 4-digit na mga bagay
tulad ng 192.168.2.1, o kahit ano; na may gawi na maging isang lokal na isa.
Ngunit iyon ay ang pattern ng isang IP address.
Kaya ang DNS, Pangalan ng Serbisyo ng Domain,
na kung ano ang tina-translate bagay tulad ng google.com sa isang aktwal na mga IP address.
Kaya kung nagta-type ka na IP address sa isang URL,
na magdadala sa iyo sa Google, ngunit ikaw ay may posibilidad hindi upang alalahanin ang mga bagay.
Ikaw ay may posibilidad sa halip na tandaan google.com.
Ang huling bagay na mayroon kami ay port, kung saan ito ay ang TCP bahagi ng IP.
TCP gumagana ang higit pa. Mag-isip tungkol sa, tulad ng, mayroon kang ang pagpapatakbo ng iyong browser ng web.
Siguro ay may ilang mga running email application iyo;
siguro mayroon kang ilang mga iba pang mga program na gumagamit ng running Internet.
Ang lahat ng mga kailangan ng access sa Internet,
ngunit ang iyong computer ay may lamang 1 WiFi card o kahit anong.
Kaya port ay ang paraan na magagawa naming maghiwalay
paano mga application na ito ay magagawang gamitin ang Internet.
Ang bawat application ay makakakuha ng 1 tukoy na port ay maaari na itong makinig sa,
at sa pamamagitan ng default, ang HTTP ay gumagamit ng port 80.
Ang ilang mga serbisyo ng email na ginagamit 25.
Ang mga mababang-numero ay may posibilidad na ma-reserbado.
Ikaw ay karaniwang magagawang upang makakuha ng mas mataas na bilang na mga bago para sa iyong sarili.
>> CSS, Cascading Style Sheet.
Style kami ng mga pahina ng web na may CSS, hindi sa HTML.
May 3 lugar na maaari mong ilagay ang iyong mga CSS.
Maaari itong maging inline, sa pagitan ng estilo ng mga tag, o sa isang ganap na hiwalay na file at pagkatapos ay naka-link in
At dito ay isa lamang halimbawa ng CSS.
Dapat mong kilalanin ang pattern na ito,
kung saan ang unang halimbawa ay kami ay tumutugma sa tag katawan,
at dito kami pagsasentro ang tag katawan.
Ang ikalawang halimbawa, kami ay tumutugma sa bagay
may ID footer, at ipinapadala namin sa paglalapat ng ilang mga estilo upang iyon.
Pansinin na ID footer text-aligns sa kaliwa,
samantalang ang katawan ng teksto-aligns center.
Footer ay nasa loob ng katawan.
Ito ay, sa halip,-Ihanay ang teksto na kaliwa, kahit na-Ihanay teksto center katawan sabi.
Ito ang buong cascading bahagi nito.
Maaari kang magkaroon ng - maaari mong tukuyin ang mga estilo para sa katawan,
at pagkatapos bagay sa katawan maaari mong tukuyin ang mas tiyak na mga estilo,
at mga bagay na gumana tulad ng inaasahan.
Mas tiyak na CSS specifiers ang mangunguna.
Sa tingin ko na ito.
>> [Ali Nahm] Hi sa lahat. Kung lamang ako maaaring makakuha ng iyong pansin.
Ako Ali at pupuntahan ko pumunta sa pamamagitan ng PHP at SQL talagang mabilis.
Kaya maaari naming magsimula. PHP ay maikli para sa PHP: Hypertext Preprocessor.
At bilang dapat mo ang lahat ng alam, ito ay isang wika na server-side scripting,
at ginagamit namin ito para sa likod ng pagtatapos ng mga website,
at kung paano ito gumagana ng maraming mga computations, ang bahagi sa likod ng mga eksena-.
Syntax. Hindi ito i C, sorpresa, sorpresa.
Palaging Ito ay upang magsimula sa, kung maaari mong makita, ang - ko maaaring hindi ilipat nang mas maaga.
Maaari mong makita ang kailangan mo sa bagong uri ng mga tirante at pagkatapos ay kailangan mo rin ang? Php.
Iyon ay palaging kung paano mayroon kang mag-frame ang iyong teksto ng PHP, ang iyong code na PHP.
Kaya hindi ito lamang ay maaaring maging tulad ng C, kung saan mo uri ng unang ilagay ito sa.
Kailangan mong palaging palibutan ito.
At ngayon, ang mga pangunahing syntax ay na kailangan ang lahat ng mga variable na magsimula sa $ character.
Kailangan mong gawin ito kapag naka-pagtukoy sa mga ito; kailangan mong gawin ito
kapag tapos ka nagre-refer na sa kanila sa susunod.
Palagi kang kailangan na $. Ito ay ang iyong bagong pinakamatalik na kaibigan, halos.
Wala ka - hindi tulad ng C, hindi mo na kailangang ilagay kung anong uri ng uri ng variable na ito ay.
Kaya habang ginagawa mo kailangan ang $, hindi mo na kailangang ilagay, tulad ng,
int x o string y, at iba pa, at iba pa.
Kaya ang isang bahagyang pagkakaiba.
Bilang resulta ng na ito, nangangahulugan ito na PHP ay isang mahina uri.
PHP ay isang mahina wika uri, at ito ay mahina-type na mga variable.
Sa ibang salita, na nangangahulugan na maaari kang lumipat sa pagitan ng iba't ibang mga uri ng variable na uri.
Maaari kang mag-imbak ang iyong numero ng 1 bilang isang int,
Maaari kang mag-imbak ito bilang isang string, at maaari kang mag-imbak ito bilang isang float,
at ito ay maging lahat na numero 1.
Kahit na naka-imbak nito sa iba't-ibang mga form,
pa rin ito - hinahawakan pa rin ang uri ng variable sa dulo.
Kaya't kung tiningnan mo dito, kung iyong naaalala mula pset 7,
marami sa inyo marahil ay nagkaroon ng mga isyu sa ito.
Dalawang katumbas karatula, 3 pantay na mga karatula, 4 pantay na mga karatula.
Okay, walang mga 4 pantay na mga palatandaan, ngunit may mga 2 at 3.
Gamitin mo 2 katumbas senyales upang suriin ang mga halaga.
Maaari itong tingnan sa kabuuan ng mga uri.
Kaya kung maaari mong makita sa unang halimbawa,
Mayroon akong num_int == num_string.
Kaya ang iyong mga int at ang iyong mga string Parehong, technically, 1,
ngunit ang mga ito ay iba't ibang uri. Ngunit para sa double Kapantay, ito ay pa rin pumasa.
Gayunpaman, para sa mga triple Kapantay, sinusuri ito halaga pati na rin ang iba't-ibang uri.
Iyon ay nangangahulugan na ito ay hindi pagpunta sa pumasa sa na pangalawang kaso dito,
kung saan gumagamit ka ng 3 pantay na mga karatula sa halip.
Kaya na ang isang pangunahing pagkakaiba na dapat mong lahat ang nagpakita sa ngayon.
>> String pagdudugtong ay isa pang mahusay na bagay na maaari mong gamitin sa PHP.
Ito ay isa lamang lang ito na madaling gamitin pagtatanda na tuldok,
at iyon ang kung paano mo maaaring isailalim mga string ng sama-sama.
Kaya kung mayroon kang Cat at mayroon kang Aso, at nais mong ilagay ang 2 string magkasama,
maaari mong gamitin ang panahon, at iyon ang uri ng kung paano ito gumagana.
Maaari mo ring lamang ilagay ang mga ito sa tabi ng bawat isa,
bilang maaari mong makita dito sa ibabang halimbawa,
kung saan ako echo string 1, space string 2.
PHP ay malaman upang palitan ang mga ito bilang tulad.
Ang mga array. Ngayon, sa PHP, may mga 2 iba't ibang mga uri ng array.
Maaari kang magkaroon ng regular na array, at maaari mo ring magkaroon nag-uugnay array,
at kami ay pagpunta sa pumunta sa pamamagitan ng mga ito sa ngayon.
Regular na array lamang ito sa C,
at sa gayon mayroon kang mga indeks na may bilang.
Sa ngayon lang kami ng pagpunta upang lumikha ng isa at ilagay -
kaya ito ay kung paano namin lumikha ng isang walang laman na array, pagkatapos kami ay pagpunta sa
ilagay sa index ng numero ng 0.
Kami ay pagpunta sa ilagay ang bilang 6, ang halaga 6.
Maaari mong makita ito sa ilalim dito.
Where's - sa index ng numero 1 kami ng pagpunta sa ilagay halaga bilang 4,
at sa gayon maaari mong makita mayroong 6, may 4,
at pagkatapos ay bilang ka sa pag-print namin ang mga bagay,
kapag sinubukan namin at i-print ang halaga na naka-imbak sa index bilang 0,
pagkatapos ay gagamitin namin makita ang halaga 6 ini-print mo. Cool?
Kaya na regular na array para sa iyo.
Ang isa pang paraan maaari mo ring idagdag ang mga bagay na regular na array ngayon
ay maaari mo lamang isama ang mga ito sa dulo.
Nangangahulugan iyon na hindi mo na kailangang tukuyin ang partikular na index.
Maaari mong makita ang numero, at pagkatapos ay sa square bracket walang tinukoy na index.
At ito ay alam - PHP ay malaman upang idagdag lamang ito sa dulo ng listahan, ang susunod na libreng lugar.
Kaya maaari mong makita ang 1 doon sa na 0 lugar,
ang 2 nagpunta doon sa unang puwesto.
Ang 3 pumupunta - ay idinagdag din doon.
Kaya na uri ng saysay. Lamang ka patuloy na pagdagdag nito,
at pagkatapos ay kapag kami ay echoing sa index ng numero 1,
ito ay i-print ang halaga 2.
>> Pagkatapos mayroon kaming array na nag-uugnay array.
Nag-uugnay array, sa halip ng pagkakaroon ng numerical mga indeks,
kung ano ang ginagawa nila ay, mayroon silang mga indeks na sa pamamagitan ng string.
Maaari mong makita, sa halip na - Nakatanggap ako mapupuksa ang lahat ng mga numero ng mga indeks,
at ngayon ito ay key1, key2, key3, at ang mga ito ay sa double quote upang magpahiwatig na ang mga ito ay ang lahat ng mga string.
Kaya maaari kaming magkaroon ng isang halimbawa ng mga ito.
Ang halimbawa nito ay mayroon kaming ang tf, at iyon ang pangalan index.
Kami ay pagpunta sa ilagay "Ali" bilang pangalan, sa index, calories kinakain,
Maaari naming ilagay sa isang int oras na ito sa halip ng isang string,
at pagkatapos ay sa index ng mga gusto, maaari naming ilagay ang isang buong array sa loob nito.
Kaya ito ay uri ng - ito ay isang katulad na konsepto sa kung paano namin ay may
mga indeks na may mga numero, ngunit ngayon ay maaari naming baguhin ang mga indeks sa paligid
upang magkaroon ng mga ito bilang mga string sa halip.
Maaari mo ring gawin ito, bukod sa lamang gawin ito nang paisa-isa,
Maaari mo ang lahat ng ito gawin sa isang tipak. Kaya maaari mong makita na tf ng na array,
at pagkatapos ay itakda namin ang mga ito lahat sa isang higanteng square bracket set.
Kaya maaari na mapabilis ang mga bagay up.
Ito ay higit pa sa isang pangkakanyahan choice kaysa hindi.
Mayroon din kaming mga loop.
Sa C mayroon kaming mga loop na gumagana tulad nito.
Nagkaroon kami ng aming mga array, at kami ay nagpunta mula sa index ng 0 sa dulo ng listahan,
at i-print namin ang lahat ng ito, tama?
Maliban ang problema ay, para sa nag-uugnay array,
hindi namin kinakailangang alam ang mga numerikal na indeks ng
dahil ngayon ay mayroon kaming ang mga indeks ng string.
Ngayon ginagamit namin foreach loop, kung saan, muli, mo sana ay ginamit sa pset 7.
Foreach loop malalaman lamang bawat solong bahagi ng listahan.
At ito ay hindi na kailangang eksaktong alam ang index ng numerical na mayroon ka.
Kaya mayroon kang foreach syntax, kaya foreach, ilagay mo ang array.
Kaya ang aking mga array ay tinatawag na pset, at pagkatapos ay bilang, ang salita bilang,
at pagkatapos mong ilagay ito lokal na pansamantalang variable na kayo ay pagpunta sa gamitin
para lamang sa mga partikular na bagay na pupuntahan matagal ang tiyak -
Halimbawa isa o ang isa na seksyon ng array.
Pset num ay humawak 1, at pagkatapos ay marahil ito ay pindutin nang matagal ang numero 6,
at pagkatapos ay ito pindutin nang matagal ang numero 2.
Ngunit ito ay garantisadong upang pumunta sa pamamagitan ng bawat solong halaga na sa array.
Kapaki-pakinabang na mga pag-andar na dapat mong malaman sa PHP ay ang mga nangangailangan,
nang sa gayon ay tinitiyak na kayo ay kabilang ang ilang mga file, echo, lumabas, walang laman.
Masidhing kong inirerekumendang kang tumingin sa pset 7 at tumingin sa mga function.
Maaaring mayroon kang malaman iyon,
kaya talagang ko malalaman kung ano, eksakto, iyon ay paggawa ng lahat.
>> At ngayon kami ay pagpunta sa pumunta sa pamamagitan ng saklaw talaga mabilis.
Sa saklaw, PHP ay uri ng isang funky bagay, hindi tulad ng C,
at kaya lang kami ng pagpunta sa pumunta sa pamamagitan ng ito mabilis.
Kaya sabihin nating simulan namin sa na arrow na mayroon kami doon.
At kami ay pagpunta sa magsimula sa $ i. Kaya ang variable ang 'i' ay magiging 0,
at kami ay lamang ng pagpunta sa panatilihin ang pag-print ito sa na malaki puting kahon banda roon.
Kami ay pagpunta sa magsimula sa i0, at pagkatapos kami ay pagpunta sa echo ito.
Kaya naroon ang 0.
At pagkatapos ay kami ay pagpunta sa dagdagan ito sa pamamagitan ng para sa loop,
at pagkatapos ito ay magiging halaga ng 1.
Ang isa ay mas mababa sa 3, kaya pagpunta sa pumasa sa pamamagitan ng na para sa loop,
at pagkatapos kami ay pagpunta upang makita muli itong naka-print.
Kami ay pagpunta sa dagdagan itong muli sa 2,
at 2 ay mas mababa sa 3, kaya makikita ito pumasa ang para sa loop, at makikita ito i-print ang 2.
Pagkatapos ay makikita mo tandaan na 3 ay hindi mas mababa sa 3, kaya ipapakita namin masira out ng para sa loop.
Kaya ngayon na lumabas kami, at pagkatapos kami ay pagpunta sa pumunta sa aFunction.
Okay. Kaya kailangan mong tandaan na ito variable na aming nilikha,
ang 'i' na variable, ay hindi lokal scoped.
Iyon ay nangangahulugan na ito ay hindi lokal sa loop,
at variable na maaari pa rin namin ma-access at baguhin pagkatapos, at ito ay magiging epektibo pa rin.
Kaya kung pumunta ka sa ang pag-andar ngayon, makikita mo na ring gamitin namin ang 'i' na variable,
at kami ay pagpunta sa dagdagan ang 'i' + +.
Gusto mong isipin, sa una, batay sa C, na na ang isang kopya ng 'i' variable.
Ito ay isang ganap na kakaiba bagay, na kung saan ay tama.
Kaya kapag i-print namin ito, kami ay pagpunta sa i-print ang 'i' + +, na kung saan ay pagpunta sa i-print out na 4,
at pagkatapos kami ay pagpunta sa - paumanhin.
Pagkatapos kami ay pagpunta sa magtapos out sa na function,
at kami ay pagpunta sa maging kung saan arrow na ngayon.
Iyon ay nangangahulugan na pagkatapos, gayunpaman, kahit na ang function ay nagbago ang halaga ng 'i',
hindi ito baguhin sa labas ng pag-andar,
dahil ang function ay may nakahiwalay na saklaw.
Nangangahulugan iyon na kapag Echo namin ang 'i', hindi ito ang nagbago sa ang saklaw ng pag-andar,
at kaya pagkatapos kami ay pagpunta sa i-print muli 3.
Iba't ibang bagay tungkol sa saklaw sa PHP kaysa sa C.
>> Ngayon sa PHP at HTML.
PHP ay ginagamit upang gumawa ng mga web page dynamic.
Ito uri ng gumagawa ng mga bagay na naiiba.
Mayroon kaming ito naiiba mula sa HTML.
Sa HTML, palagi lang namin magkaroon ng parehong static na bagay, tulad ng kung paano ito ay nagpakita ng Rob,
samantalang ang PHP, maaari mong baguhin ang mga bagay batay sa kung sino ang gumagamit ay.
Kaya kung mayroon akong ito, ko, "Ikaw ay naka-log in bilang -" at pagkatapos ay ang pangalan,
at ang maaari kong baguhin ang pangalan. Kaya ngayon ang pangalan ay Joseph,
at ito ay may "tungkol sa akin," ngunit pagkatapos ay maaari kong ring baguhin ang pangalan upang magkaroon Tommy.
At iyon ay magiging isang iba't ibang mga bagay.
Kaya pagkatapos ay maaari naming ring baguhin ang iba't ibang mga bagay tungkol sa kanya,
at ito ay nagpapakita ng iba't ibang nilalaman batay sa pangalan.
Kaya PHP Maaari uri ng baguhin kung ano ang nagaganap sa iyong website.
Parehong dito. Still, tandaan na mayroon sila ng ibang nilalaman,
kahit na technically-access mo pa rin na parehong web pahina sa ibabaw.
Bumubuo ng HTML. May 2 iba't ibang mga paraan na maaari mong gawin ito.
Kaya ipagpapatuloy namin sa pamamagitan ng na ngayon. Ang unang paraan ay, mayroon kang - oo, paumanhin.
Kaya mayroon lamang sa iyo ang iyong regular para sa loop sa PHP,
at pagkatapos ay echo mo sa PHP at echo mo out HTML.
Paggamit ng kung ano ang ipinakita sa iyo Rob ng HTML script
at pagkatapos ay ang paggamit ng naka-print na PHP upang mag-print lang ito sa web page.
Ang alternatibong paraan ay ang gawin ito bilang kung ihiwalay mo ang PHP at HTML.
Kaya maaari kang magkaroon ng isang linya ng PHP na magsisimula ang para sa loop,
pagkatapos ay maaari kang magkaroon ng mga linya ng HTML sa isang hiwalay na bagay,
at pagkatapos ay magtapos ka sa loop, muli, na may PHP.
Kaya ito ay uri ng naghihiwalay ito.
Sa kaliwang bahagi, maaari mong mayroon ka ng lahat ng -
ito ay tipak 1 lang ng PHP.
Sa kanan na maaari mong makita na ikaw ay may isang linya ng PHP,
mayroon kang isang linya ng HTML, at mayroon kang muli ng isang linya ng PHP.
Kaya na naghihiwalay sa ito sa kung anong ginagawa nila.
At makikita mo tandaan na alinman paraan, para sa alinman sa mga ito,
i-print pa rin nila ang mga imahe, mga larawan, mga imahe,
kaya na HTML pa rin ay naka-print sa parehong paraan.
At pagkatapos ay makakakita ka pa rin ng 3 mga larawan lalabas sa inyong website.
Kaya ito ay 2 iba't ibang mga paraan ng paggawa ng parehong bagay.
>> Ngayon mayroon kaming mga form at mga kahilingan. Tulad ng ipinakita sa iyo Rob,
mayroong mga paraan ng HTML, at aming lamang Breeze sa pamamagitan ng ito.
Mayroon kang isang aksyon at mayroon kang isang pamamaraan, at ang iyong mga aksyon
uri ng nagpapakita sa iyo kung saan ka ng pagpunta sa ipadala ito, at ang mga pamamaraan ay kung
ito ay pagpunta sa maging GET o isang POST.
At isang kahilingan GET, tulad ng sinabi Rob, nangangahulugan na kayo ay pagpunta sa ilagay ito sa isang form
at makikita mo ito bilang isang URL, samantalang ang isang POST kahilingan mo ay hindi makakakita sa isang URL.
Kaya ang isang bahagyang pagkakaiba.
Gayunpaman, isang bagay na ang isang katulad na bagay
ay na POST at GET ay pantay hindi secure.
Kaya maaari mong isipin na dahil lamang hindi mo makita ito sa URL,
na nangangahulugang ang POST ay mas ligtas,
ngunit maaari mo pa ring makita ito sa iyong mga cookies sa impormasyon na ipapadala mo.
Kaya huwag isipin na ang tungkol sa isa o ang iba.
Isa pang bagay upang tandaan ay na mayroon ka ring mga variable na seksyon.
Ikaw guys ginamit ito sa pset 7 upang makuha ang iyong impormasyon ng user ID.
Ano ang nangyari noon ay na maaari mong gamitin ito nag-uugnay array,
ang $ _SESSION, at pagkatapos ikaw ay makakapag-access sa iba't ibang bagay
at mag-store ng iba't ibang mga bagay sa kabuuan ng mga pahina.
>> Huling bagay ay mayroon kaming SQL, Naka-istrakturang Wika Query,
at ito ay isang programming language upang pamahalaan ang mga database.
Ano, eksakto, ay mga database? Ang mga ito ay mga koleksyon ng mga talahanayan,
at ang bawat talahanayan ay maaaring magkaroon ng katulad na uri ng mga bagay.
Kaya nagkaroon kami ng isang talaan ng mga gumagamit sa iyong pset pananalapi.
At bakit kapaki-pakinabang ang mga ito? Dahil ito ay isang paraan ng permanenteng pag-iimbak ng impormasyon.
Ito ay isang paraan ng pagsubaybay sa mga bagay at pamamahala ng mga bagay
at aktwal na makita ito sa iba't ibang mga pahina at nag-iingat ng track.
Sapagkat kung ini-imbak mo lang ito sa na ang isa agarang sandali
at pagkatapos ay gamitin ito sa ibang pagkakataon, hindi mo magagawang i-access ang anumang bagay na iyong na-save.
Mayroon kaming 4 mga pangunahing bagay na ginagamit namin para sa SQL command.
Mayroon kaming select, insert, tanggalin, at i-update.
Iyon ang talagang mahalaga para sa iyo guys upang malaman para sa iyong pagsusulit.
>> Kaming makikita mabilis na pumunta sa paglipas ng piliin ngayon.
Talaga, ka ng pagpili sa mga hilera mula sa database.
Kaya kung mayroon kang, dito mismo -
mayroon kaming mga 2 iba't-ibang mga bagay, at gusto naming pumili mula sa talahanayan ng mga klase
kung saan kahanga-hangang - kung saan sa kahanga-hangang hanay na ang halaga ay 1.
Kaya maaari mong makita dito, mayroon kaming mga 2 mga bagay ng pangalan ng klase,
CS50 at Stat110, at mayroon kaming mga klase at mga ID ng slogan.
Kaya gusto namin upang piliin ang lahat ng impormasyon na iyon.
Pagkatapos ay maaari mong makita dito mismo na ito uri ng pagpili out sa na kahanga-hangang hanay,
kung saan lahat ng bagay ay 1, at pagkatapos nito ay ang klase ID, pangalan ng klase at slogan na maaari itong mamili.
Paano eksaktong gagawin mo ito sa code? Mayroon kang upang gamitin ang PHP.
Kaya na uri ng kung paano PHP at SQL ay may kaugnayan sa isa't isa.
Ngayon na mayroon kami sa aming code, at kami ay pagpunta sa gamitin ang aming mga query
tulad ng ginawa namin sa pset 7, at kami ay pagpunta upang patakbuhin ang SQL query.
Pagkatapos kami ay pagpunta sa may -
palagi naming mayroon upang suriin kung triple katumbas hilera kung hindi totoo.
Kaya muli, nais mong suriin ang mga uri at ang halaga,
at pagkatapos ay kung ito ay hindi gumana, pagkatapos ay gusto mong Humihingi, gaya ng dati, tulad ng ginawa namin sa pset 7.
Kung hindi man, gusto mong i-loop sa pamamagitan ng lahat ng bagay na may mga madaling-gamiting
foreach loop na nagpunta kami sa ibabaw lamang.
Ngayon na kami ay sa pamamagitan ng looping at gumawa kami ng nakalipas na ito,
Ipagpalagay nating na ang aming query pumasa sa ipaalam, na ngayon ay mayroon kaming ang aming foreach loop.
At ang unang hilera ito ay may, kaya narito ang hilera, dito mismo; ito ay boxed.
Ito ay pagpunta sa i-print out ang lahat ng mga impormasyon na ito ay nakuha.
Kaya ito ay pagpunta sa i-print out sa ilalim "Nais mong Dagdagan ang HTML?"
Pagkatapos ito ay pagpunta sa pumunta sa susunod na hilera, dahil ito ay nakumpleto ang unang para sa loop,
at kaya pagkatapos ito ay pagpunta sa i-print ang pangalawang linya ng ito,
na kung saan ay pagpunta sa maging STAT110, Hanapin ang lahat ng mga sandali.
>> Isang huling bagay ay sa SQL mga kahinaan.
Alam ko hinawakan David sa ito nang kaunti sa panayam.
Maaari mong basahin ito sa ibang pagkakataon. Ito ay talagang nakakatawa.
SQL Injection ay isang uri ng mapaglalang bagay.
Sabihin natin na ilagay mo lamang ang mga variable pakanan papunta sa iyong query,
bilang maaari mong makita sa na unang linya.
Kaya ito ay tila fine, tama? Lamang naglalagay ka ng sa user name
at password sa iyong SQL query, at nais mong ipadala ang mga ito off at makakuha ng kahit ano ang nasa iyong mga talahanayan ng data.
Iyon ay tila medyo simple. Kaya nagbibigay-daan sa sabihin ng isang tao ay nilalagay sa,
para sa mga password, ito O teksto dito mismo -
Dapat talagang nasa pulang kahon.
Kaya sabihin nating na sila ilagay na password sa - na kung ano ang ipinasok nila.
Kaya ito ay naka-putting O "1" = 1.
Kind ng isang ulok password upang magkaroon.
Makikita mo tandaan na sa na SQL query ngayon palitan lamang sa mga ito Ngayon ipaalam, at,
ito sinusuri upang palaging totoo, dahil makikita mo tandaan na
maaari mong SQL query piliin ang lahat ng impormasyon na ito
o maaari mong lamang magkaroon ng 1 = 1.
Kaya na palaging pagpunta upang suriin sa true.
Iyon hindi pagpunta ay upang talagang gumagana, dahil ibig sabihin nito ay na ang Hacker maaaring masira sa iyong system.
Ang solusyon dito ay na mayroon ka upang gamitin ang PDO system,
na nangangahulugan na mayroon kang upang gamitin ang mga tandang pananong,
na kung saan ay kung ano ang iyong guys ginamit sa pset 7,
kung saan ka ng pagpunta sa gumamit ng isang tandang pananong sa halip na kung saan mo nais na ilagay ang isang bagay,
at pagkatapos ay ka pagpunta sa magkaroon ng isang kuwit, at pagkatapos ay magkakaroon ka pagkatapos,
pagkatapos ng iyong string, ang iba't ibang mga variable na gusto mong palitan sa iyong tandang pananong.
Kaya makikita mo tandaan dito na ngayon Mayroon akong mga pulang tandang pananong.
Pagkatapos ko bang ilagay ang mga variable pagkatapos ng aking mga string ng sa gayon ay alam kong palitan ang mga ito sa ganoong pagkakasunod-sunod pagkatapos.
Iyon ay siguraduhin na kapag ang isang tao gagawin nito na tulad nito,
at mayroon silang o 1 = 1 sitwasyon, na tiyakin,
sa dulo pabalik, tiyakin na hindi ito aktwal na masira ang SQL query.
Okay, kaya na medyo magkano ito, isang ipuipo ng PHP at SQL.
Suwertehin ka sana sa lahat ng sa iyo, at ngayon upang Ore.
>> [Oreoluwatomiwa Babarinsa] Okay lahat. Oras upang pumunta sa paglipas ng ilang JavaScript
at ilang iba pang mga bagay masyadong mabilis kaya hindi kami hawak mo up ngayong gabi.
JavaScript. Oo. JavaScript ay uri ng isang astig na bagay, purportedly.
Ang mga bagay na kailangan mo ba talagang malaman tungkol sa JavaScript, ito ay isang uri ng tulad ng
ang client-side dulo ng kung ano ang iyong web app ay pagpunta sa ginagawa.
Mayroong ilang mga bagay na mo lamang ayaw mong mag-ingat ng lahat ng oras sa gilid ng server.
Ang lahat ng mga maliit na mga pakikipag-ugnayan, pag-highlight ang isang bagay, paggawa ng isang bagay mawala.
Ikaw talaga ayaw mong magkaroon upang makipag-usap sa iyong server sa lahat ng oras para doon.
At ang ilan sa mga iyon ay hindi kahit posible na gawin sa gilid server.
Ito ay kung bakit kailangan namin ng isang bagay tulad ng JavaScript.
Cool bagay tungkol sa JavaScript: Ito ay dynamic na-type.
Ano ang ibig sabihin nito ay na ang iyong programa ay hindi kailangang malaman
ano, eksakto, ang mga variable ay kapag isulat mo ito out.
Makikita lamang ito ng isang uri ng malaman ito bilang pinapagana nito.
Iba pang mga bagay na cool na tungkol dito: Ito ay isang kulot wika suhay,
na nangangahulugan na ang syntax ay katulad ng C at PHP.
Hindi mo kailangang gawin magkano rework kapag naka-aaral ng JavaScript.
Narito mayroon kami ng kaunting JavaScript.
Kawili-wiling bagay dito mismo ay na, kung ang pagtingin mo dito,
magkaroon kami ng kaunting JavaScript doon sa head tag.
Ano ang ibig ay isa lamang isama lamang ng isang JavaScript na file.
Ito ay isang paraan maaari mong isama ang JavaScript sa iyong programa.
Pagkatapos ng ikalawang kaunti ay talagang ilang mga inline na JavaScript,
na halos kapareho sa isang estilo naaayon sa CSS,
at lamang sumusulat ka ng ilang mga code masyadong mabilis doon.
JavaScript ay array.
Isa pang paraan lamang upang panatilihin sa paligid ng data, napaka kapaki-pakinabang.
Napakabuti at madaling syntax.
Gumamit ka ng mga square bracket upang ma-access ang lahat at panatilihin ang lahat ng bagay nang magkakasama.
Wala masyadong kumplikado.
Ang mga cool na bagay tungkol sa JavaScript at mga wika scripting sa pangkalahatan
ay hindi mo na kailangang mag-alala tungkol sa laki ng array.
Maaari mo lamang gamitin array.length at subaybayan ang mga ito,
at din ang array ay maaaring lumaki o pag-urong bilang kailangan mo ito sa.
Kaya hindi mo kahit na kailangang mag-alala tungkol sa anumang uri ng,
oh hindi, kailangan ko upang magtalaga ng higit pang mga bagay, o anumang bagay tulad na.
>> Ang mga cool na bagay dito ay na ang JavaScript ay may isang bagay na tinatawag na mga bagay.
Ito ay isang object-oriented wika, kaya kung ano ito ay ay, mahalagang,
isang paraan para sa iyo na data ng pangkat magkasama, medyo katulad ng isang struct,
ngunit maaari mong i-access ito tulad ng isang struct o sa isang nag-uugnay array syntax.
Ito ay medyo simple at ano ang maaari mong gawin sa mga ito ang data ng pangkat magkasama
kung mayroon kang isang bungkos ng mga data na may kaugnayan.
Dahil ang lahat ng mga bagay na kailangan mong upang ilarawan ang isang kotse,
Hindi mo kailangang magkaroon ng ito sa isang bungkos ng iba't ibang mga lugar.
Maaari mong ilagay lang ito sa 1 bagay sa JavaScript.
Habang ikaw ay marahil alam, iterating ay isa sa mga nakakapagod na gawain.
Gawin mo lang ito sa isang paulit-ulit. Kailangan mong makipag-usap sa bawat bagay sa kotse,
o kailangan mo upang pumunta sa pamamagitan ng bawat item sa isang listahan o isang bagay tulad na.
Kaya JavaScript ay, katulad ng PHP, isang foreach syntax.
Sa kasong ito, ito ay isang para sa loop.
Gusto mong gamitin ito lamang sa mga bagay.
May ilang mga problema na nagaganap kung gagamitin mo ito sa array.
Ito sa pangkalahatan ay isa sa mga bagay-bagay, bagaman, ito ay isang kapaki-pakinabang,
dahil puksain ang marami kang mga overhead
dahil hindi mo na kailangang mag-pull up ang lahat sa iyong bagay sa pamamagitan ng iyong sarili.
Hindi mo kailangang tandaan ang lahat ng mga mahahalagang pangalan.
Ikaw lamang ang uri ng mga ito pabalik sa ang syntax na ito.
Sa ito, may para sa, gusto mo lamang na tandaan
na nakakakuha ka pabalik lahat ang mga key, sa isang halos katulad na paraan upang hash table.
Kung naaalala mula sa na, kapag nais mong ilagay sa isang string na maaari mong makuha ang isang bagay out
na may isang nauugnay na halaga sa mga ito.
Ano ang maaari mong gawin sa mga ito ay maaari mong sabihin, ang lahat ng karapatan,
Naglagay ako sa isang kotse, at tinatawag ko itong isang Ferrari.
Kaya maaari mong ilalagay sa string Ferrari muli sa ibang pagkakataon, at maaari kang makakuha ng na-out.
At maaari mong gawin iyon sa isang loop, na may para sa loop.
Kaya lamang ang nalalaman tungkol sa bagay. Ang pangunahing bagay mula ito kailangan mong matandaan
ay na maaari mong gamitin ang bagay struct tulad ng syntax kahit kailan mo gusto sa mga ito,
maliban kung ano ang iyong pagpunta upang magamit bilang isang string ay hindi isang wastong pangalan ng variable.
Kaya't kung tiningnan mo ang na doon, mayroon kaming key na may mga puwang.
Well, kung ikaw ay upang ilagay object.key, espasyo, may, puwang, puwang,
na lamang ay hindi magkaroon ng kahulugan syntactically.
Kaya mo lamang maaaring gawin na may ganitong uri ng bracket syntax.
>> Gayundin, ang JavaScript ay napaka-saklaw-matalino sa PHP.
Mayroon kang 2 paraan ng pagtugon sa saklaw.
Hindi ka maaaring magkaroon ng var sa harap ng isang variable,
at iyon lamang ang ibig sabihin nito ay global.
Maaari mong tingnan ito mula sa kahit saan. Kahit na kung ikaw ay upang ilagay ito sa isang kung pahayag,
saan pa man sa iyong code pagkatapos ng puntong iyon na maaari mong makita na variable na iyon.
Isa pang bagay, bagaman, ay sa pamamagitan ng var, ito ay limitado sa kahit anong function na ikaw ay in
Kung ikaw ay hindi sa isang function, na rin, ito ay global.
Ngunit kung ikaw ay nasa isang function ito ay nakikita lamang ng loob na function.
Wala akong isang halimbawa, ngunit, oo. Isa ito sa mga bagay na kung saan ang
maaari mong pamahalaan kung ano ang mga variable nais mong maging global,
ano variable nais mong maging lokal, ngunit mo kailangang maging maingat tungkol dito,
dahil hindi mo na kailangang ang uri ng mga masasarap na butil na kontrol ginagawa mo sa C,
kung saan kung ang isang bagay ay ipinahayag sa isang para sa loop, ito ay pagpunta upang manatili sa na para sa loop.
Ang bagay na talagang pinahahalagahan namin tungkol sa paggamit ng JavaScript para ay pagmamanipula ng mga web page, i-right?
Ibig kong sabihin, na ang dahilan kung bakit namin ginagawa ito.
>> Upang magawa iyon, gumagamit kami ng isang bagay na tinatawag na DOM.
Ang Dokumento Bagay Model.
Talaga, ano ang ginagawa nito ay tumatagal ng lahat ng iyong HTML
at mga modelo out ito sa isang bungkos ng mga bagay na nested sa loob ng bawat isa.
Mong simulan out na may isang bagay na katulad nito.
Mayroon kang, sa kanan para sa akin, isang bungkos ng code out doon na uri ng -
Gusto mong isipin na nais maging napakahirap upang manipulahin,
dahil gusto mo ay pag-parse sa pamamagitan ng grupo ng mga teksto
at pagkakaroon upang piraso hiwalayin bagay. At kung ano kung ito ay hindi wastong nai-format?
Masamang bagay ang mangyayari.
Kaya JavaScript tumatagal ng pag-aalaga ng mga ito para sa iyo, at makakakuha ka ng isang magandang istraktura ng data,
tulad ng isa sa aking kaliwa, kung saan mayroon na lamang kayong isang dokumento,
at sa loob na mayroon kang isang bagay na tinatawag na HTML,
at sa loob na mayroon kang isang ulo at isang katawan,
at sa loob na ulo mayroon kang isang pamagat, at iba pa, at iba pa, at iba pa.
Pinapasimple ito pagmamanipula ng isang web page upang ito ay para lamang,
oh, gusto ko lang makipag-usap sa bagay na ito.
Pagsunud-sunurin ayon ng isang halos katulad na paraan na gusto mong makipag-usap sa isa pang bagay na ginawa mo sa iyong sarili.
Tulad ng sinabi ko, ang lahat ng mga DOM ay nasa sa bagay na dokumento.
Alinman ito lamang ay isang lugar at pagkatapos ay maaari kang pumunta sa loob nito upang mahanap ang mga bagay,
at maaari mong gawin ito - ito ay ang lumang estilo ng paggawa nito, hanggang doon,
kung saan gagawin mo document.getElementById, at pagkatapos ay ang pangalan,
at bilang maaari mong marahil sabihin, ito ay nagiging sobrang mahirap gamitin matapos ang ilang panahon.
Kaya marahil hindi nais upang gawin iyon. Iyon ay kung bakit mayroon kaming
ang susunod na bagay kami ay pagpunta sa makipag-usap tungkol sa pagkatapos na ito.
Ang pangunahing bagay dito ay na, ang lahat ng karapatan, mayroon ka ng lahat ang mga elementong ito, tama?
Kaya siguro ang maaari kong palitan ang kulay ng isang bagay kapag nag-load ang pahina.
Kaya kung ano? Paano kung ang aking user ay nag-click ng isang bagay?
Gusto ko ito upang gawin ang isang bagay kawili-wiling kapag nag-click sila ng isang bagay.
Iyon ay kung bakit mayroon kaming mga kaganapan.
Maaari mong, talaga, makahanap ng anumang mga sangkap sa iyong DOM,
at pagkatapos ay sabihin, hey. Kapag ito naglo-load o may nag-click ito,
o kapag sila mouse sa ibabaw ng ito, gawin ang isang bagay na may ito.
At kung ano ang mayroon ka ay, mayroon kang mga pag-andar na pangasiwaan ito para sa iyo.
Ang mga pag-andar ng mga handler ng kaganapan.
Ano they're - ito ay lamang ng isang magarbong paraan ng sinasabi,
ito function ay ipinatupad lamang kapag nangyari ang kaganapan na ito.
Kaya nito pinangangasiwaan ang kaganapan na nangyayari.
Ito ay kung paano mo gustong mag-ipon out ng handler ng kaganapan.
Mayroon akong ilang mga pindutan, at kapag nag-click mo ito, explodes ito.
Kaya huwag i-click ang pindutan.
Ito ay isang paraan ng papalapit na ito, i-right?
Mayroon kang isang tag na pindutan, at sa pag-click mayroon kang isang string na nagsasabing,
oh, sa pamamagitan ng ang paraan, gawin ko ito sumasabog na bagay para sa akin.
Kung hindi man, ito ay katulad lamang ng isang regular na pindutan na iyong ginawa.
Maaari mo ring gawin ito ng isa pang paraan,
sa pamamagitan ng daklot ang DOM element, ngunit magkakaroon save namin na matapos naming makipag-usap tungkol sa jQuery.
>> JQuery: Ito ay isang library na cross-browser.
Maaari mo itong gamitin sa halos kahit ano.
At nagbibigay sa iyo ito lamang ng maraming mga tool upang gumana sa.
Dahil ang JavaScript, habang malakas, ay walang lahat ng mga kasangkapang kinakailangan mo
sa labas ng kahon upang talagang matugunan ang isang web app na maaaring gusto mong gawin.
Kaya pinapasimple ito ng maraming mga bagay, ay nagbibigay sa iyo ng maraming mga pag-andar
sa labas ng kahon na nais mong normal na kailangang isulat ang iyong sarili, paulit-ulit.
At lamang Ginagawang napaka-simple ang mga bagay.
Mayroon ka ring tagapili, na ipaalam magdadala sa iyo ang lahat ng mga elemento
mula sa iyong DOM higit pa lamang, sa halip ng pagkakaroon upang magamit ang mga napakatagal pinaandar na mga tawag.
Higit sa mga tagapili. Mayroon kang, hanggang doon ka pa, sabihin nating
Gusto kong makakuha ng isang elemento na may ID "bato."
Well, sa jQuery, ito ay $ lamang at pagkatapos ay isang string na may kalahating kilong, at pagkatapos ay "rock."
Ito ay napaka-simple at marami mas mabilis kaysa sa tradisyunal na JavaScript paraan ng tackling ang problemang ito.
At mayroon kang katulad na bagay para sa mga klase at mga uri ng elemento.
jQuery ay - isa sa mga cool na tampok ay maaari mong uri ng compress ang
down na ang iyong mga query sa iyong DOM napaka, napakabilis.
Ngayon kami ay pabalik sa handling kaganapan, at ito ay kung paano mo gustong pangasiwaan ang isang kaganapan sa jQuery.
Kaya kung ano kami ay pagpunta dito ay sinasabi na namin, ang lahat ng karapatan. Mayroon akong script tag, i-right?
Kaya Mayroon akong na ito ng mga inline na JavaScript.
Ano kami ay pagpunta sa gawin ay kami ay pagpunta sa sabihin, ang lahat ng karapatan.
Kapag ang dokumento ay handa na, na nangangahulugan na ang dokumento ay nai-load,
pupunta kami upang pumunta sa sa na function, at kami ay pagpunta sa sabihin, ang lahat ng karapatan,
ang pagpapaganang ito ay aktwal na paggawa ng isang bagay iba.
Ay isa lamang na sinasabi nito, lahat ng karapatan, kumuha sa akin ang elemento na may ID "myid."
At pagkatapos ay bigyan ito ng isang humahawak ng function na executes kapag nag-click mo ito.
Talaga kung ano ang ginagawa ito ay, sinasabi nito, ang lahat ng karapatan.
Ang pahina ay malo-load, kaya pupuntahan ko sa, hanapin ang elementong ito,
bigyan ito ng handler ng kaganapan na ito, at ito ay nagtatakda talaga up ang iyong pahina para sa iyo.
At ito ay kung paano mo nais na isipin ang tungkol sa pangangasiwa ng kaganapan.
Gusto mo lang mag-isip tungkol sa, lahat ng karapatan, kapag ang isang bagay ay nangyayari, ano ang gusto kong mangyari?
Hindi mo nais na isipin ang tungkol, okay, kailangan ko upang matiyak na bagay na ito uusap sa bagay na ito,
bagay na ito blah blah blah, dahil gusto mo lamang na makipag-usap bagay sa mga tuntunin ng kaganapan.
Kapag nangyari ito, nangyari ito. Kapag nangyari ito, na mangyayari.
At kung ang mga bagay-trigger sa iba pang mga bagay, mabuti iyan.
Ngunit hindi mo nais na subukan at gawin kumplikado code
kung saan ka nagti-trigger ng maramihang mga bagay nang sabay-sabay,
dahil lamang ka ng pagpunta sa bigyan ang iyong sarili ng isang sakit ng ulo.
>> Lahat ng karapatan. Ngayon ay maaari naming makuha ang aming pahina upang mahawakan ang mga kaganapan,
ngunit sabihin nating ang aking mga user ay nag-click ng isang pindutan.
Paano kung gusto kong magpadala na kahilingan pabalik sa server,
ngunit hindi ko nais upang i-reload ang pahina, dahil hindi na kinakailangang i-reload ang isang bagong pahina
bawat solong oras ang nakukuha ng uri ng nakakainip, at kung bakit kailangan ko
upang hilahin pababa ang header muli, at muli ang footer,
at ang lahat ng mga elemento ng pahina ng muli
lamang upang i-refresh ang pagbati o ang oras?
Kaya na ang dahilan kung bakit mayroon kaming isang bagay tulad ng Ajax.
Ano ang maaari naming gawin dito sa Ajax ay maaari naming sabihin, ang lahat ng karapatan,
Gusto kong ipadala ang ilang mga data sa server,
at gusto ko upang makakuha ng isang tugon pabalik sa gayon maaari kong i-update ang aking pahina,
o siguro gawin lamang ng ilang mga algorithmic kalkulasyon na ay hindi kinakailangang magpakita ng kahit ano sa user.
Ano ang kailangan mong gawin ito? Well, kailangan mo ng URL kailangan mong makipag-usap sa.
Maaari hindi lamang magically makinig sa iyong server mula sa walang pinanggalingan.
Kailangan mong magkaroon ng isang tukoy na lugar ipapadala mo ang data na ito sa.
At kailangan mo rin ang ilang mga data upang magpadala, o marahil ito ay isang dataless query.
Gusto mo lang upang i-ping pabalik sa server at sabihin, hey, ako buhay, o isang bagay tulad na.
At pagkatapos ay nais mo ang isang function na talaga humahawak sa tagumpay.
Sabihin nating makabalik ng ilang impormasyon mula sa iyong server,
at gusto mong baguhin ang pamagat ng gumagamit sa kanilang pahina.
Kaya nais mong makakuha ng impormasyon pabalik,
at gusto mo itulak na sa screen.
Ano ang mangyayari ay, kapag ang pahina ay handa na,
kang lumikha ng on-click ang function para sa pindutan na tinatawag na greeter.
Ano pagkatapos ay gumagana ito ay, kapag pindutan na ay hunhon,
mong makipag-usap sa greetings.php, gumawa ka ng POST kahilingan,
at sabihin mo, hey, kumuha ako ng isang bagay mula sa iyong pahina.
Hindi kami talaga kailangan upang ilarawan iyon, ngunit greetings.php,
sabihin nating lang, nagbibigay sa likod "kumusta mundo."
Kaya kami makababalik ito "kumusta mundo," at sa tagumpay ng ito,
sa pag-aakala walang napupunta mali, pagkatapos ay pumunta lang namin sa na-target na lugar
na tinukoy namin at ilagay lang namin ang pagtugon sa doon.
At ito ay isang napaka-simpleng paraan ng pagse-set up ng isang Ajax query.
>> Tunay mabilis, uri ng mga nabanggit na ito Rob na,
mga bagay na maaari magkamali, masamang bagay ay maaaring mangyari,
kaya gusto mong maging pamilyar sa mga code na tugon ng HTTP.
Ano ang mga ito ay lamang, tulad ng, 200, ang lahat ng bagay nagpunta okay.
Ibang bagay, masamang bagay ang nangyari.
Ito ay sa pangkalahatan ang mga bagay na gusto mong matandaan.
Ngunit ito ay magaling na malaman ang lahat ng mga ito.
At sa wakas, sa sandaling na nawala namin ang lahat ng iyon,
kailangan namin upang makipag-usap nang napakabilis tungkol sa disenyo,
at pagkatapos ay maaari naming ipaalam sa iyo ang lahat ng mga umalis.
Disenyo. Mga bagay na nais mong matandaan.
Tanungin ang iyong sarili ang mga katanungang ito: Sino ang mag-i-gamit na ito?
Ano ang mga ito ay gamitin ito para sa? Ano ang aking mga user na nagmamalasakit sa?
Ano ang hindi nila asikasuhin?
Ikaw lamang ang ayaw na gumawa ng isang app at hayaan ito lumalaki lamang
at maging ang higanteng, lahat gugulin bagay na hindi mo kahit na maaaring matapos.
Gusto mong magkaroon ng hiwalay mga layunin at mga plano at mga bagay na nais mong tugunan.
Gawin itong walang hirap. Ang lahat ng ito sabi, talaga,
gawin itong madali para sa gumagamit na gamitin ito; huwag gawin itong isang higanteng patak ng teksto tulad ng slide na ito ay, talaga.
Gusto mo lamang ito upang maging isang bagay na kung saan ay masyadong madali para sa isang tao upang pumunta sa
at gawin kung ano ang gusto nilang gawin.
Hindi mo na nais ang mga ito upang magkaroon ng upang mag-navigate 5 mga pahina
upang makapunta sa iyong de-kalidad na pag-andar ng iyong site.
Kung nagkaroon ng Google 5 mga pahina bago maaari mong kahit na maghanap ng isang bagay na,
walang sinuman ang maaaring gamitin ito.
At bilang wakas, papel prototype, focus group.
Magkaroon ng magandang disenyo at mga kasanayan sa pagsubok.
Dahil lamang sa tingin mo ito gumagana para sa iyo,
ay hindi nangangahulugan na ang sinuman sa palagay nito ay gumagana.
Ngunit oo, na ito.
[CS50.TV]