>> [MUSIC nagpe-play]
>> DAN AMRMENDARIZ: Ang bawat tao, maligayang pagdating sa CS50 seminar,
iOS App Development sa Swift.
Ako Dan Armendariz, at ako preceptor ng computer science dito sa Harvard.
>> At sa susunod na oras ay magiging isang ipoipo tour ng mas maraming mga bagay-bagay
tungkol sa paksang ito na maaari naming magkasya.
Ako mag-post ng lahat ng mga source code na makikita mo sa araw na ito online.
Maaaring hindi namin magagawang aktwal na pumunta sa paglipas ng lahat ng bagay
na ako na ako Ipinapakita sa iyo sa oras na ito.
Ngunit hindi bababa sa inaasahan namin na sa pamamagitan ng mga komento ng source code,
Makikita mo na subukan upang malaman kung ano ang eksakto ang nangyayari para sa mga bagay-bagay
na hindi pa namin makuha sa.
>> Sa pangkalahatan, ang mga istraktura ng talk ngayon ay ang mga sumusunod.
Makikita simulan namin ang paggawa ng ilang mga pangunahing syntax sa mga wika Swift,
pagpunta sa ilan sa mga mas advance na mga syntax ng Swift wika.
Dahil ang mga wika ay talagang moderno at ito
ay may maraming mga mataas na antas mga tampok, ang mga bagay na mayroon kaming hindi
makikita sa C buong CS50, o kahit ilang iba pang mga wika
na sinimulan namin sa gamit sa CS50 tulad ng PHP,
kaya ako pagpunta sa may upang subukan upang ipakilala ang ilan din na mga paksa na
ay may kaugnayan sa mas mataas na antas ng mga wika na maaaring hindi mo makita sa lalim sa CS50,
ngunit makikita mo sa ibang pagkakataon aaral ng computer science.
Kaya ito ay magiging isang mahigpit nakaimpake oras.
At huwag mag-atubiling ipaalam sa akin malaman kung ikaw ay may anumang mga katanungan.
Kaya kung interesado ka sa paggawa ng pag-unlad
may Swift, o talagang anumang pag-unlad iOS app,
may isang pares ng mga kinakailangan.
Una sa lahat, kailangan mo na gamitin ang Mac, na tumatakbo sa mga halimbawa
na kami ay pagpunta sa maging gamit ang araw na ito, isang relatibong bagong bersyon ng OS
X. Sa kasong ito, ako tumatakbo X 10.5.
Maaari mong patakbuhin ang 10.11 kung gusto mo.
Ngunit lahat ng bagay na kayo ay pagpunta sa makita ay kinasasangkutan Xcode 7 at sa ibang pagkakataon,
na kung saan ay ang pinakabagong bersyon ng Swift, na kung saan ay Swift 2.0.
Ito ay talagang isang pretty mahalagang pagkakaiba.
Ang isang pulutong ng mga syntax ay may nagbago pretty makabuluhang
sa ilang mga kaso mula sa Swift 1.0, na kung saan ay inilabas noong nakaraang taon,
sa Swift 2.0, na kung saan lamang ay dumating out na ito mahulog.
Kaya kami ay pagpunta upang ipakita Swift 2.0.
Ang isang pulutong ng mga bagay na naghanap ka para sa mga online
kapag sinusubukan mong makakuha ng mga karagdagang impormasyon tungkol sa iba't-ibang mga bagay-bagay,
baka gusto mong malinaw maghanap para sa Swift 2
sa halip na lamang plain lumang Swift upang gumawa ng Siguraduhin na makuha mo ang syntax tama.
>> Sa katunayan, ito ay totoo.
May isang mabilis na halaga ng pag-unlad nangyayari sa Swift wika
mula pa nang inilabas ito Apple, sa palagay ko kung ano, ito ay naging isang maliit na higit sa isang taon
ngayon.
At bagay ay nagbago kapansin-pansing sa oras na iyon.
At upang hindi maging bigo kung, kapag kayo ay naghahanap sa paligid
para sa mga paksa sa Swift o kung paano ganapin isang bagay gamit ang ilang halimbawa ng code
o isang bagay na ito ay hindi tunay na gawain sa Swift 2.0.
Tiyakin na ikaw ay naghahanap partikular para sa bersyon na iyon
upang subukan upang i-minimize epekto ng iba't ibang mga bersyon at mga uri ng mga bagay.
>> Kukunin ko ang subukan upang ituro ang ilang mga bagay lamang na iba sa mga mas lumang mga bersyon.
Ngunit ito ay isang bagay upang panoorin ang para sa.
Iyan ay malamang na magiging isa sa pinakamalaking sakit ng ulo
na ikaw ay may sa Swift ay paghahanap Halimbawa code na mas matanda, kahit na lamang
sa pamamagitan ng ilang buwan, sinusubukan mong gamitin ang mga ito sa iyong mas modernong proyekto.
At ito lamang lamang ay hindi gumagana.
Nakakakuha ka ng mga error compiler, syntax mga error, ang lahat ng mga uri ng mga nakatutuwang bagay.
Kaya maging matiyaga sa pamamagitan lamang na, at ikaw sana
magkaroon ng isang medyo magandang karanasan may Swift pangkalahatang.
>> Ngayon ay maaari mo talagang join-- at Umaasa ako ang tunay na kami ay magkakaroon pa rin ito year-- ito
Apple app CS 50 ng pag-unlad ng koponan, na
ay magbibigay-daan sa iyo upang i-install ang anumang apps na kung saan nilikha mo sa iyong iOS device.
Kaya maglaan ng hitsura sa URL na ito kung ikaw ay interesado sa paggawa na.
>> Kaya lang ng ilang mga mga bagay-bagay tungkol sa Swift mismo.
Ito ay isang pinagsama-sama wika.
Ngunit makikita mo na ang ilang mga sa mga tampok na ginagamit namin
payagan ito upang magamit din sa isang bit tulad ng isang naisalin paraan rin.
>> Ang isang pulutong ng mga syntax ay hiram mula sa C. Ito ay batay at nakasulat sa C.
At sa gayon ay makikita natin na may isang pulutong ng mga takeaways
mula sa iyong mga umiiral na kaalaman mula sa C na aming makakaya port sa Swift.
>> Ngunit may mga bagay na gawin itong tunay na naiiba mula sa C.
Ito ay napaka-Matindi-type.
May automatic memory management.
Hindi ka pagpunta sa may sa gamitin ang malloc o libre kahit saan.
Ito ay dinisenyo para sa mga pahayag.
Kaya sa ibang salita, maaari mong gamitin ito sa lahat ng uri ng konteksto, mula sa Apple Watch
sa iPhone ang lahat ng mga paraan ng hanggang sa OS X, at kahit ilang mga server, kahit na ang ilang scripting.
Ngunit kami ay makita na ang mga suporta para sa scripting
ay hindi pa lubos na may bilang ito ay sa iba pang mga wika.
Kaya malamang makikita mo ang gamit ito eksklusibo para sa pag-unlad
sa iyong Mac o sa iyong iPhone.
>> At ito ay may maraming mga modernong mga tampok.
At ng maraming mga bagay na ito ay mga bagay-bagay na kami ay pagpunta sa subukan sa address na ngayon,
kundi pati na rin ang aming mga paksa na lantaran, maaari naming italaga ang buong kurso.
Sa katunayan, ang CS 51, na kung saan ay inaalok sa susunod na semestre,
naka-focus sa isang pulutong sa mga paksang ito na inilarawan sa ibaba.
Kaya maaari mong gastusin sa isang buong semester pag-unawa sa mga bagay na ito.
Ngunit kami ay pagpunta sa subukan upang makuha sa pamamagitan ng mga ito
hindi bababa sa sapat na iyong maaaring maunawaan kung ano ang
nangyayari kapag ikaw ay tumingin sa isang Swift program
at ma-hack ang iyong paraan sa pamamagitan ng ito para sa pangwakas na proyekto.
>> Ngayon ay isa sa mga pinakamahusay na paraan na maaari mong makakuha ng karagdagang impormasyon tungkol sa mga ito
ay lantaran sa pamamagitan lamang ng Apple ibinigay na dokumentasyon para sa Swift.
May isang pulutong ng mga API na magagamit.
At ito ay isang mahusay na home base para sa iyo ang hahanapin, tiyak na mga bagay na iyong
nais na gawin na may API na kinasasangkutan ng iOS.
Kung nais mong gamitin ang camera para sa Halimbawa, maaari mong simulan ang hinahanap dito,
at gamitin din ang Google at stack Umaapaw na gagawin mo sa normal.
>> Ang anumang mga katanungan sa mga ito bago namin tumalon sa kanan?
Lahat tama.
Ni ilipat sa.
>> Kaya una, mayroon akong isang bilang ng mga halimbawa ng mga file.
At ako pagpunta sa subukan sa hakbang pamamagitan ng mga ito relatibong mabilis.
Ito ang Hello World file para sa Swift.
Ito ay napaka-simple.
May paraan higit pang mga komento kaysa sa may mga aktwal na code.
Pansinin ang aktwal na code ay pinakailalim sa 14 linya.
Ito sabi print.
At pagkatapos ay ito ay isang function na tawag.
Kami ay pagpasa sa mga ito ng isang string na tinatawag Kamusta cs50.
Pansinin na walang semicolon.
Pansinin na walang int main.
May wala sa mga cruft na namin ay may C.
Kapag kami ay gumagamit Swift sa ganitong paraan, na kung saan ay lamang na nakasulat sa isang file ng teksto
at naka-imbak sa aking computer, at pagkatapos ay Maaari ko ba itong itala at patakbuhin ito.
>> Pansinin na dito ako hindi gamit ang CS50 IDE.
Ipinapalagay na ako tumatakbo at na ako sa OS X,
at na ako na naka-install Xcode na ito sa machine sa order para sa
upang aktwal na function.
Ngunit ito ay lamang ng isang normal na text file na maaari naming pagkatapos ay sumulat ng libro at i-edit.
Kaya sabihin makita kung paano talaga gumagana ito.
Paano kung gusto kong sumulat ng libro ito?
swiftc 1.swift.
Pagkatapos ng isang sandali o dalawa, ito ay makikita na mayroon kami ngayon
pinagsama-sama na ito sa isang file na tinatawag na 1.
At ngayon ay naka-print na namin ang aming CS50, aming Hello World application sa halip.
>> Pansinin ang isa sa iba pang mga bagay tulad ng well ay na sa pamamagitan ng default,
hindi namin ay may sa input a / n-print ng isang bagong linya.
Sa pamamagitan ng default, ang function print in Swift ay i-print ang isang bagong linya para sa iyo.
Maaari mong ipasa ang isang opsyonal na dagdag na parameter upang sabihin dito na hindi na gawin ito.
Ngunit ang Google para sa karagdagang impormasyon tungkol sa mga iyon.
Sa pamamagitan ng default, ito ay gawin ang mga linya print.
>> Sabihin ilipat sa Lahat ng karapatan, kaya hayaan pagkatapos ay sa ilang iba pang mga bagay.
Kaya kung paano namin aktwal na matukoy ang mga variable?
Maaari naming gawin na gamit isa sa dalawang paraan.
At ang isa na gusto kong sabihin sa iyo tungkol sa una ay ang kahulugan let.
At ito ay mahalaga dahil epektibo
kung ano ang aming ginagawa ay pagtukoy sa isang pare-pareho.
Kami ay pagpunta upang lumikha ng isang variable, o sa halip ng isang pare-pareho na tinatawag na pangalan,
magbigay sa mga ito ang ilang mga data-- in kasong ito, ang string Dan.
Ngunit sa pamamagitan ng paggamit na ito ay hahayaan keyword, kami ay sinasabi
na ito variable-- o muli constant-- tinatawag
pangalan ay hindi pagpunta sa mabago.
Ito ay pagpunta sa maging walang pagbabago sa kabuuan ng ang tagal ng programa na ito
o sa buong tagal ng konteksto
na variable na ito ay magagamit.
>> Ito ay talagang mahalaga na kapag mayroon kang ilang mga data na ito ay hindi
pagpunta sa pagbabago sa iyong programa, at makikita mo ang isang iba't ibang mga halimbawa
tungkol sa kapag gusto naming gamitin hayaan kumpara sa iba pang mga syntax,
ito ay mahalaga na gamitin mo hayaan hangga't maaari dahil ito Inaabisuhan
ang wika na ito ay hindi pagpunta sa ay nagbago,
at ang tunay na ito ay maaaring gumanap isang pulutong ng mga pag-optimize
upang mapabuti ang bilis at ang kaligtasan ng inyong programa.
At sa pamamagitan ng kaligtasan, hindi ko ibig sabihin ng ipaalam ito crash sa mga nakatutuwang mga error
upang tayo'y maging bihasa sa nakikita sa C.
>> Pagkatapos ay maaari naming gamitin ang string agaw sa encapsulate ito sa loob ng isang string.
Kaya maaari naming makita na ito sa print linya, i-print hello,
at pagkatapos ay gumagamit ng backslash open parens, at pagkatapos ay ang pangalan ng aking variable,
sa kasong ito pare-pareho, isara ang panaklong.
Mahalagang ako pagkatapos ay inilagay ang mga nilalaman ng pangalan ng variable na tinatawag na ito
sa loob ng string at pagkatapos ay pag-print ang resulta doon.
>> May isa pang pagbabago sa file na ito na kung saan ay na mayroon ako, sa pinakadulo itaas,
ilagay sa isang shebang line, kung saan talaga lang tumutukoy
na gusto kong gamitin ang Swift interpreter, na
Nangangahulugan ito na hindi ko na kailangang sumulat ng libro na ito partikular na programa.
Maaari ko bang patakbuhin lamang ito tulad ng kanyang sariling script.
Ngunit ito ay, sa kasong ito, sa likod ng mga eksena na naipon at pagkatapos ay
tumakbo.
Ito ay hindi nakikita lamang sa amin.
>> Sabihin ilipat sa Lahat ng karapatan, kaya hayaan.
Kaya mayroong isang bit ng panlilinlang na lamang ang nangyari noon.
Ipinakita ko sa inyo na ako maaaring tukuyin ang isang pare-pareho.
At ako ay maaaring magbigay ng ilang mga data na gawin ito.
Ngunit sa kasong ito, ang paunawa na ako ay hindi talagang tukuyin ang uri ng data
na ito ay.
At iyon ay dahil sa tagatala, Swift Maaari
magpakilala ang mga uri ng data na batay lamang sa data na ako ilagay sa ito.
Dahil alam ng mga ito na sa pamamagitan ng pagsusuri na ito variable dito mismo, ang data na ito right
dito, alam na ito ay isang string.
At kaya ito pare-pareho ang pangalan ay samakatuwid magiging pati isang string.
>> Ngunit maaari din naming maging tahasan tungkol sa mga uri na
kami ay pagpunta upang gamitin para sa constants o mga variable
sa pamamagitan ng paggamit na ito syntax instead-- hayaan name colon String katumbas
Dan, na sa kasong ito ay nangangahulugan hindi namin pagpunta upang tukuyin ang isang pare-pareho na tinatawag na pangalan.
Ito ay pagpunta sa maging ng uri String.
At ang halaga ay magiging Dan.
Ngayon ang iba pang mga paraan na maaari naming lumikha variables--
at ang mga ito ay maaaring mabago ng mga variable, kung saan ay nangangahulugan na tayo, sa katunayan, pagpunta
na baguhin ang kanilang mga nilalaman sa ibang araw sa tagal ng konteksto
na variable na defined-- namin sa halip ng paggamit ng var keyword ipaalam.
Ngunit muli, sa pamamagitan ng default, maliban kung alam mo na kailangan mo upang manipulahin ang data na iyon,
subukang gamitin ipaalam para pagpapabuti ng pagganap.
>> Sa kasong ito, pagkatapos ay maaari ko tukuyin ang uri ng data
na inaasahan namin na maging sa loob ng ito ng mga bagong variable na tinatawag na label.
Ito ay pagpunta sa maging isang string.
At kami ay pagpunta sa pagkatapos ay pagdugtungin dalawang string magkasama, ang string hello,
at ang string na kinakatawan ng mga variable, o sa halip ang constant name.
>> Kaya ito ay dahil sa ganda ito ay medyo PHP tulad ng sa na namin
Mayroon napakadaling string pagdudugtong.
Kami ay hindi awtomatikong kung gumamit ng anumang uri ng memory management
upang dagdagan ang laki at gawin anumang uri ng mga nakakatawang bagay doon.
Ito ay gumagana bilang ang tunay na kami ay inaasahan.
>> Lahat ng karapatan, anumang mga katanungan sa mga ito?
>> Ngayon ang iba pang mga dahilan na kailangan naming mayroon kang kakayahan
para ma-define kung ano uri ng variable data ay
ay dahil sa kung minsan ay hindi kami Gusto upang magpasimula variable
kasama ang ilang mga data sa punto ng kahulugan.
Kaya sa kasong ito, sabihin natin na gusto kong simulan inputting
sa ilang mga grado sa isang grade book.
Well alam ko na ang isa sa mga variable na gusto kong maging
ay magiging isang nagbabago grade.
At alam din natin na tayo gusto mo itong maging isang integer.
Pero siguro hindi namin pa may magagamit grade na iyon.
>> Sa Swift, kailangan mong tukuyin ang uri ng data
na nauugnay sa isang variable o isang ipaalam sa pare-pareho ang
bago maaari mong aktwal na gamitin ang variable na iyon.
Dahil ito ay malakas na nag-type, mayroon kang mag-ugnay ng uri
may mga variable na ito.
>> Kaya sa kasong ito, kung hindi ko na hindi maayos initialize ang unang na may ilang mga halaga,
pagkatapos ay kailangan ko upang sabihin sa Swift ano Inaasahan ko ang uri ng data na.
At ito ay pagpunta sa mananatiling na parehong uri ng data
sa buong kasaysayan ng programang ito.
>> Ngayon maaari mong matukso sa lalong madaling Ako ay may ginawa ito variable grade
at ibinigay ito ng isang integer ng 100, ngayon kung ako
nais na subukan upang pagdugtungin isang string na may na integer,
maaaring matukso upang pa ring gamitin na string pagdudugtong operator
tulad ng ginawa namin lamang ng ilang linya ng bago.
Ngunit sa kasamaang palad, tunay na ito ay hindi
magtrabaho, dahil ikaw ay mahalagang gumaganap
isang operasyon sa dalawang iba't ibang uri.
>> Ngayon na ito ay ibang-iba mula sa iba pang wika tulad ng PHP na kung saan ay tunay na
loosey gusi sa kanilang mga uri ng mga uri.
Sila ay tulad lamang, oo, kahit na ano, Wala akong pakialam.
Lang bigyan ako ng isang uri, at siguro kailangan kong gawin ang mga tamang bagay.
>> Sa kasong ito, Swift ay lubhang mahigpit tungkol sa mga uri
na ikaw ay may pakikisama.
Ito kabuuan operator o pagdudugtong operator
may mahalagang isang pares ng mga iba't ibang posibleng mga opsyon.
Maaari mong gawin ang kabuuan may integer, o mo
maaaring gawin string pagdudugtong, at marahil ilang iba pang mga bagay pati na rin.
Pero kung na operator ay hindi kinikilala kung ano ang nasa magkabilang panig ng mga ito,
o sa halip ang mga kumbinasyon ng mga dalawang uri, ay hindi kung ano ito ay umaasa,
pagkatapos ito ay pagpunta sa maging sanhi ng isang pagkabigo.
>> Kaya sa kasong ito, kung ano ang ibig sabihin ng na magkaroon ng isang string plus isang integer?
Well sa konteksto ng na ito, malamang na gusto namin
upang gawin ang isang operasyon string pagdudugtong.
Ngunit ng mga kurso sa computer ay hindi na uri ng konteksto.
At kaya kailangan namin upang magbigay ng na ang karagdagang impormasyon
upang ipaalam ito alam kung ano ito ay na gusto naming gawin.
>> Kaya sa ibang salita, ang katunayan na Swift ay malakas na nag-type
ay nangangahulugan na ikaw ay may sa gawin ang isang maliit na piraso ng karagdagang trabaho
upang makakuha ng mga ito upang patakbuhin ang paraan na gusto mo.
Ngunit bilang isang resulta, ito ay mas ligtas.
At sa sandaling ikaw ay kumuha ng sa account ang mga uri,
mga bagay na lantaran simulan lamang upang gumana nang mahusay.
>> Kaya sa kasong ito, at pagkatapos namin na gagawin gumanap string pagdudugtong
sa pamamagitan ng tahasang paghahagis ang integer sa isang string
sa pamamagitan ng pambalot na ito sa kategoryang ito capital S String function,
at pagkatapos gamit ang string pagdudugtong operator upang baguhin ang aming mga variable label,
at pagkatapos ay i-print ito.
>> Sa ngayon, kaya mabuti?
Lahat ng mga karapatan, sabihin ilipat sa ipaalam.
>> Ngayon may mga iba't-ibang uri ng data uri na maaari naming gamitin sa Swift.
Habang ikaw ay naging bihasa sa, maaari naming lumikha ng isang nagbabago array.
At na array ay maaari lamang naglalaman ng isang solong uri.
>> Kaya sa kasong ito, kami ay pagpunta upang lumikha ng maaaring mabago ng isang array ng mga integer, na
tatawagan namin marka, at kami ay maaaring upang mag-imbak na sa square bracket
format tulad mo na lumaki sanay sa sa iba't-ibang mga wika.
Ngunit mapansin na dito hindi namin pagtukoy ng isang pares ng mga bagay-bagay.
marka ay maaaring mabago ng isang variable-- hindi namin gamitin ang let keyword.
Kaya ito ay nangangahulugan na maaari naming pagkatapos ay baguhin ang mga nilalaman ng array.
Ito ay uri ng Array int, at maaari naming sabihin na ang
batay sa mga square bracket dito.
>> Ngayon ay isa sa mga bagay na maganda tungkol dito ay na namin
magkaroon ng access sa isang pulutong ng mga karagdagang impormasyon
tungkol sa mga array lamang gamit ang ilang mga simpleng dot notation.
Kaya halimbawa, nagbibigay grades.count sa amin
ang bilang ng mga item na umiiral sa na array, na kung saan namin pagkatapos ma-access pretty
madali lang gamit na notation tuldok.
>> Kung nais mong magdagdag ng mga karagdagang item sa array na ito,
hindi mo maaaring gawin ang mga estilo PHP kung saan mo lamang malinaw na tukuyin,
sa isang ibinigay na index, ang ilang mga halaga na gusto mong ipasok.
Sa halip, gamitin ang ikakabit Ang pamamaraan sa uri ng array
upang maidagdag ang item na iyon, 95, sa listahan na ito.
>> Kaya ngayon ito array ay ang mga sumusunod contents-- 100, 0, 90, 85.
At ngayon ko na nakadugtong namin 95 pati na rin sa mga iyon.
>> May iba pang paraan maaari naming ikabit ang mga bagay-bagay.
Maaari mong aktwal na gamitin ang isang kabuuan operator,
na kung saan ay kahulugan bilang isang array na Magkabit operasyon.
At maaari mong pagkatapos ay idagdag ang isa pang array, na ang mga nilalaman ay 70 at 80,
sa na array.
Kaya ngayon kami ay may mga mga nilalaman sa mga variable na ito
grades-- 100, 0, 90, 85, 95, 70, at 80.
Ito ay lamang ng isang magandang maliit na syntactic asukal na nagbibigay Swift sa amin.
>> Kaya kung gusto naming sabihin sa ilang mga marka, hindi namin marahil
pagpunta sa nais na umulit sa paglipas ng bawat item na ito sa loop.
At tayong, sa Swift, ang paniwala ng isang para sa loop tulad ng iyong inaasahan.
Ngunit ang paraan na nagpapahiwatig ng namin isang hanay ay bahagyang naiiba.
Kaya sa kasong ito, upang sabihin sa ilang ang lahat ng bagay, bibigyan namin ng
pagpunta upang lumikha ng isang pansamantalang variable na tinatawag na sum sa order para sa amin
upang mapanatili ang bilang na ito.
>> At mapansin ang aming para sa loop construction dito.
Para sa index sa 0 .. <grade.count.
Kaya ito konstruksiyon, 0 .. <grades.count ay isang operasyon na hanay kung saan tayo
sinasabi na kami ay pagpunta upang lumikha ng isang hanay ng mga integer mula up 0
ngunit hindi kasama grades.count.
Kaya ito ay 0, 1, 2, 3, 4, 5, hanggang gayunpaman maraming isa
bago grades.count.
>> Kaya ito ay iba kaysa sa kung paano namin Gusto karaniwang ginagamit para sa mga loop
kung saan nais mong magkaroon ng ilang mga index variable, itakda ito katumbas ng 0 sa una,
at pagkatapos ay isama ang hanggang sa ilang mga halaga na mas mababa kaysa sa bilang ng mga ite
sa na array.
>> Kaya doon ay isang pagbabago sa ito, talaga,
na kung saan ay nagbibigay-daan sa amin upang tunay madali magtakda ng iba't ibang mga uri ng mga saklaw.
Kung babaguhin mo ang hanay na ito sa tatlong tuldok, 0 ... grade.count,
ito ay kumakatawan sa hanay na 0 upang grades.count inklusibo,
ibig sabihin na ang number na din pagkatapos ay kasama sa saklaw na iyon.
>> Ngunit ito ay lubhang madaling gamitin para sa mga eksaktong mga bagay,
kapag kami ay may upang magsagawa ng iteration sa paglipas ng loop
dahil sa mga ini-index ay zero-index, tulad ng nakita natin sa ibang wika
din.
Ang anumang mga katanungan sa mga ito para sa loop?
>> Kaya may implicit kahulugan ng index variable na ito,
halaga na nagsisimula sa 0, at patuloy sa bawat loop na pag-ulit
upang dagdagan ng 1 hanggang isang punto na katumbas ng grades.count,
at sa puntong, loop aborts.
>> Pansinin na sa aming string agaw dito,
maaari naming talagang gawin ang ilang mga simpleng manipulations sa mga halagang iyon.
Kaya index plus 1 ay talagang gumanap ng isang kabuuan ng halaga na
dahil index ay, sa kasong ito, isang integer.
At sa puntong iyon, ito ay pagkatapos ay i-convert sa isang string
at interpolated sa ang string na ito dito, at naka-print out tulad ng gagawin namin inaasahan. .
>> At ang ganda ng bagay tungkol sa mga array dito ay
na hindi namin din maaaring magkaroon ng fetching halaga at pagtatakda ng mga halaga
gamit ang square bracket pagtatanda bilang nasaksihan namin sa iba pang mga wika pati na rin.
>> Lahat ng karapatan, kaya mula dito, kami ngayon compute aming kabuuan ng lahat ng aming mga grado.
Ngayon uri ng mga susunod na lohikal na hakbang ay
upang gawin ang isang operasyon division upang mahanap ang average ng mga marka.
Ngunit isang bagay na mahalaga dito ang nangyayari kung saan
ay na sum na ito ay marahil isang integer.
Ngunit kailangan namin upang magsagawa ng ilang mga uri ng double division.
At ito ay magiging lubhang mahalaga kapag
gusto naming gawin ang operasyon, dahil kung ano ang sinasabi ng mga kami
ay na kailangan namin upang aktwal na gumanap ng division sa dalawang doubles.
At muli, dahil Swift ay napaka-Matindi nai-type,
kami ay dapat na malinaw na itakda ang lahat ng mga item upang doubles bago namin talagang
gawin ang operasyon na iyon.
>> Kaya sa order para sa amin upang gumanap ng double division,
ito ay hindi sapat para sa isa lamang sa mga bagay na maging isang double.
Pareho sa mga ito ay may na maging isang double sa order para sa matulin
upang siguraduhin na ito ay kung ano ang gusto naming gawin.
Kaya pagkatapos namin malinaw na pumili ng aktor ang kabuuan na kung saan namin nakalkula sa itaas
at ang bilang ng mga grado sa doubles, at pagkatapos ay gawin na operasyon at store
na ito sa bagong variable, o sa halip ang bagong constant tinatawag average,
na kung saan ay magkakaroon ng kung ano ang uri, mo isipin?
Double, oo.
Kaya sa kasong ito, kami Hindi mo na kailangang tukuyin ito
dahil ito ay maaaring natukoy na mula sa operasyon kung anong uri ng average na data
magiging.
At Swift ay karaniwang medyo magandang tungkol sa pagiging magagawang upang ipahiwatig ang mga uri.
>> Gusto mo bang makita ang mga ito tumakbo, o maaari ko bang ilipat sa?
Gusto kong panatilihin ang pagpunta.
Ang anumang mga katanungan sa anumang ng mga ito?
Great.
>> Ngayon kami ay pagpunta upang simulan upang makakuha ng sa ang mabuting stuff-- function pagtukoy,
at ng ilang iba pang mga uri na natatangi sa Swift na hindi mo pa
makikita sa ibang wika hanggang sa puntong ito,
ngunit sila ay naroroon sa iba pang mga ito ay wika na maaring mahanap sa susunod.
Kaya unang kung nais mong upang tukuyin ang isang function,
mong tukuyin ang mga ito sa funky salita function, at pagkatapos ay ang pangalan ng function,
at pagkatapos ay sa mga panaklong, ang argumento na nais mo na ang pag-andar upang tanggapin.
Ang argumento ay dapat ding specify-- generally--
ay dapat ding tukuyin ang uri ng data na ang mga ito, maliban kung maaari nilang i-natukoy.
At kami na makita na ang maliit caveat sa loob lamang ng ilang sandali.
>> Kaya sa kasong ito kami ay may isang function na tinatawag printGradeCount.
Kami ay pagpunta sa tanggapin ang isang variable-- o sa halip na sa kasong ito,
isang constant-- tinatawag gradebook.
At ito ay pagpunta sa maging ng type array ng mga integer.
Ngayon ay mayroong isang bagay na talagang mahalaga dito
na gusto ko sa iyo upang maunawaan.
Iyon ay na sa pamamagitan ng default, ang mga argumento na input sa function na ito ay
tinukoy na may isang implicit let keyword, na nangangahulugan na hindi ko maaaring baguhin ito
gradebook variable dito.
At na uri ng mga may katuturan, dahil kayo ay dumadaan data in.
At ikaw ay marahil hindi gusto upang maging nagbago mula sa ilalim mo.
Ito ay posible na malinaw na banggitin na ito ay isang variable sa pamamagitan ng paglalagay
ang var keyword dito.
Ngunit iyon ay isang gotcha na kami Napansin tao ay tapos na sa nakaraan
ay na ipinapalagay nila na ito ay pagpunta upang maging isang variable kapag, sa katunayan, ito
ay isang pare-pareho.
>> Lahat ng karapatan, kaya dito pagkatapos, sa kasong ito, kami ay hindi tumutukoy sa anumang uri return.
Ipapakita namin sa iyo kung paano gawin na sa ilang sandali lamang.
Ngunit mapansin na dito kami isang simpleng lamang kung ang condition.
Kung ang gradebook ay walang laman, na sa kasong ito
ay lamang ang mga ari-arian ng mga ito integer array, pagkatapos ay i-print namin ang isang bagay.
Kung hindi man ang ginagawa namin sa ibang bagay.
>> Medyo prangka sa ngayon ang tingin ko.
Ngunit huminto sa akin kung mayroon kang anumang mga katanungan.
>> Ngayon na ito function, average, tumatagal din ang ilang mga argumento, o sa halip ng isang argument,
kung saan ay ang gradebook, at oras na ito ay pagpunta upang bumalik sa isang double type.
Dahil ito ay computing ang average na at ito ay
pagpunta sa aktwal na bumalik na computed average sa linya pagtawag.
>> Sa kasong ito, kami tukuyin ang bumalik type pagkatapos ng isang arrow.
At ito nga ang pakiramdam uri ng kakaiba sa unang.
Ikaw na lumago bihasa sa pagtatakda ng mga return
nagta-type sa harap ng mga pangalan ng function.
Pero kung sa tingin mo ng mga ito sa mga tuntunin ng matematika,
tulad ng kapag mayroon kang matematika na tukuyin ang isang function,
Mayroon ka ng isang function na may ilang input, at ito ay gumagawa ng isang output.
At na eksakto kung ano ang ito ay dapat na gayahin.
At may isang pares ng mga iba pang mga wika na may katulad na syntax na rin,
ngunit malamang na wala na mo na makikita sa CS50.
Ngunit pa rin hindi malito sa pamamagitan ng mga ito.
Arrow Ang ibig sabihin nito ay kung ano ang nangyayari na ibabalik sa kasong ito.
OK, kaya kung paano tayo pupunta upang makalkula ang average?
Well, kung ang gradebook Walang laman, kung sa gayon hindi namin
pagpunta sa bumalik 0, na marahil isang makatwirang paraan upang matrato ito.
Hindi ko alam, ay dumating ipaalam bumalik sa na sa ilang sandali.
Ito ay maaaring hindi tunay maging isang makatwirang paraan
mag-compute ng isang average kung kami ay may isang walang laman na markahan.
>> Pagkatapos ay magpapadala kami lamang maisagawa ang aming kabuuan.
Pansinin na dito kami talaga may isang kahaliling bersyon ng isang
para sa loop, na nagpapahintulot sa amin upang umulit paglipas ng bawat isang item sa isang array
at ilagay sa bawat elemento sa kanyang sariling variable.
Sa pamamagitan ng pagtukoy ng grado sa gradebook, kung ano ang sinasabi ng mga kami
ay na kami ay pagpunta sa kataon lamang lumikha ng isang bagong constant tinatawag
grade na pagpunta sa kumakatawan bawat natatanging item sa gradebook
sa bawat oras na ang para sa loop iterates.
Kaya ang unang pagkakataon na ito ay tumakbo, grade ay
ay ang unang item sa markahan.
Ang ikalawang oras na ito ay ang ikalawang bagay, kaya sa at iba pa
hanggang gradebook ay naubos mismo ng mga elemento.
Pagkatapos namin ma-sum na grade sa ating kabuuan variable
at bumalik sa aming average bilang namin nakita bago.
OK, anumang mga katanungan?
Oo?
Madla: Mayroon akong dalawang katanungan.
Bilang isa, saka-sakali, maaari patakbuhin mo integer sa isang ito?
Hindi kailangang maging isang double, ay ang tama?
DAN AMRMENDARIZ: Maaari mo ulitin ang tanong na iyan?
Madla: Maaari ko bang gawin integer bilang ang average?
DAN AMRMENDARIZ: Maaari mo gawin integer bilang isang average?
Kaya bumalik ang isang integer average sa halip ng isang double?
>> Madla: Return-- mo Mayroon na ngayon sa ibaba.
DAN AMRMENDARIZ: Kanan dito, bumalik 0.0?
Madla: Oo, bumalik 0 lamang.
Kaya ito ay alinman sa 80 o 85, ngunit hindi 85.2.
>> DAN AMRMENDARIZ: Kaya sa kasong iyon, kaya may isang pares ng iba't ibang mga paraan
upang sagutin na.
Hayaan akong sagutin ang mga ito sa pagkakasunud-sunod.
Kaya kapag gumawa ako lamang ang return ito 0, isang 0 ay isang integer value.
At kaya na magiging sanhi ng isang error type para sa kasong ito
dahil ito ay umaasa sa isang double ngunit pagkatapos ay bumabalik isang integer.
Kung gusto ko upang bumalik sa isang integer, kaya ko.
Maaari ko bang itakda ang uri ng return sa int, bumalik 0 dito,
at hindi gumaganap double division.
Ngunit pagkatapos kami ay magiging paggawa ng integer division.
At kaya pagkatapos namin ay hindi makuha ang average na marahil namin inaasahan.
Ngunit yes maaari naming baguhin ang mga uri sa na paraan.
>> Madla: At pangalawa, ikaw may isa Double sa itaas.
Ngunit pababa sa ibaba, kapag kayo gawin bumalik Double Double,
na na awtomatikong bumabalik Double format.
Bakit kailangan mo pa rin upang tukuyin ang mga ito sa arrow sa itaas na may isang double?
>> DAN AMRMENDARIZ: So sa kaso, ito ay bahagi
ng the-- kaya upang ulitin ang tanong, dahil sa ito ay implicit mula sa return
uri dito, kung ano ang uri na ito ang tunay ay, kailangan namin upang maging malinaw sa Swift
tungkol sa kung ano ang gusto naming bumalik sa labas ng function na ito
kaya na kapag ito ay gumaganap type suri, maaari itong tiyakin
na kung ano ang tunay na kami ay may nakasulat down sa ibaba ang tunay na umaayon sa mga iyon.
Kaya ito ay uri ng tulad ng isang tseke sa iyong sarili uri ng mga sitwasyon.
Ngunit may are--
>> Madla: [hindi marinig] palaso?
>> DAN AMRMENDARIZ: May mga kaso kapag maaari naming tukuyin na namin maaari nang kataon lamang
itakda ang uri ng return.
Ngunit sa kasong ito, hindi ako isipin na gumana.
May ilang iba pang mga syntax na namin makita sa ibang pagkakataon.
>> Lahat ng karapatan, kaya ito ang pinagmulan code ay Medyo naiiba
dahil ito Pina-parse ng argumento mula sa ang pag-andar na kami ay pagtawag.
Hayaan akong ipakita sa iyo kung paano ito gumagana bago namin ilipat talagang sa
sa ilang mga kagiliw-giliw na mga bagay-bagay na nangyayari sa Swift.
>> Kaya sa kasong ito, kung ako ay tatakbo lamang ito code, mapapansin na kung ano ang ginagawa nito
is-- habang, ito uri ng ay nagbibigay sa akin ng isang kakaibang error.
Kailangan ko upang pumasa ito sa isang pares ng mga integer bilang argument command line.
Kaya tingnan natin, 150 at 80, at pindutin ang Enter upang malaman kung ano ang tunay na ito ay ginagawa.
Ito ay tumatanggap ng bawat isa sa ang mga halagang ito bilang integer.
Ito ay inputting ito sa isang markahan.
At pagkatapos ay gumaganap ito na average ng pagkalkula
at outputting na tulad ng gagawin namin inaasahan.
>> Ngunit malinaw naman ay mayroong isang bagay na nangyayari sa may ito ang pagtanggi ng isang bagay
isang bagay bilang isang integer.
Bilang maaari mong isipin ang mula noong tayo ay pagharap sa mga argumento command line
sa C at iba pang mga wika, ang unang Ika-0 item sa na argumento command line
listahan ay ang pangalan ng utos na namin ang tunay na pinaandar.
Kaya sa kasong ito, tingin lang ako looping higit sa lahat ng mga argumento command line.
Ngunit hindi ako paggawa ng anumang uri ng pag-iisip suriin upang laktawan ang higit na nauna.
Ako tahasan lamang o nang kataon lamang ako pagsuri kung alin sa mga uri
ay integers bago ko talaga gumanap pagtutuos na ito.
>> At iyan ay mahalagang Anong nangyayari dito.
Para sa bawat argument in argumento sa proseso, ang
Pupunta ako upang isagawa ang ilang check.
At sa kasong ito, pupuntahan ko upang subukang unang convert
na argument sa isang integer sa pamamagitan ng gumaganap ng isang tahasang pumili ng aktor,
dahil ito ay, sa input, ang isang string at hindi sa katunayan ng isang integer.
>> Ngunit ito ay uri ng isang kakaiba syntax, kung ipaalam grade katumbas int (argument).
Ano ang tunay na nangyayari dito ay lubhang
Mahalaga na ang iyong mga gamit Swift.
Ito ay gumagamit ng kung ano ang tinatawag na isang opsyonal na uri.
>> Kaya ito function, int (argument), nagbalik hindi lamang isang integer, ngunit nagbalik
ano ang tinatawag na isang opsyonal na integer.
At kaya ito ay ang uri ng mga isang uri sa tuktok ng isang uri.
Maaari mong uri ng isipin ito tulad ng ito ay bumabalik tulad ng isang pakete.
At kapag binuksan mo na package, ito ay alinman sa
may isang integer, na kung saan ay ang resulta, o ito ay may ganap na walang wala sa mga ito sa lahat.
At ito ay kapaki-pakinabang bilang isang error checking mekanismo, dahil sa kasong ito
maaari naming malaman, ay ito matagumpay na uri ng conversion?
Kung ito ay, pagkatapos ito ay sa katunayan pagpunta sa may isang integer sa loob.
Kung hindi ito ay pagpunta sa may ilang mga halaga na namin ang tawag kawalan, kung saan
ay kinatawan ng walang integer sa lahat.
Ito ay tunay na kinatawan ng wala.
>> At kaya ito kung construction ay nagbibigay-daan sa amin upang mabuksan package na,
na opsyonal na umiiral.
At kung hindi namin magagawang ng balot na package at makahanap ng isang integer sa loob,
pagkatapos ay kung ano ang sinasabi ng mga kami dito ay na pagkatapos ay namin
payagan halaga na na-set sa ito palagian tinatawag grade.
At ang bahaging ito ng kung pahayag, ang itaas na bahagi ng pahayag kung
ay tatakbo, dahil na alisan ng balot ay matagumpay.
>> Kung nangyari kaya lang ito na nagkaroon ng error marahil
sa ganitong tahasang uri ng conversion mula sa isang string sa isang integer, marahil
ito ay ang halaga ng ABC halimbawa.
At iyan ay talagang hindi pagpunta ang pag-convert sa isang integer.
Pagkatapos ay ibalik ito kawalan, na kung saan ay hindi isang integer.
At ito kung ang pahayag na rin pagkatapos ay mabibigo.
hindi umiiral dahil grade ito ay walang nilalaman na integer.
At ito ay tatakbo ito ng ibang block sa halip.
Oo?
>> Madla: Nil ay N-I-L?
DAN AMRMENDARIZ: kawalan ay N-I-L, yes.
>> Kaya ito ay marahil ang isa sa mga hardest bagay tungkol sa Swift,
lalo na kapag ikaw ay nasa ang mga damo sa isang iOS app
at ang tunay na ikaw ay sinusubukan gawin ang ilang mga pag-unlad doon.
Ito ay pagpunta sa maging sumisigaw sa iyo ang tungkol sa opsyonal.
Ito ay pagpunta sa ay humihingi sa inyo para sa tanong marks at exclamation points.
Ngunit sa sandaling malaman mo out-- kung ikaw maglaan ng ilang oras upang ang pag-uunawa
kung ano ang nangyayari sa mga opsyonal na mga uri, mo i-save ang iyong sarili ng isang pulutong ng mga sakit ng ulo
pati na iyong sinusubukan na magsulat ng isang app sa Swift.
>> Ito ay talagang isang napakalakas na tampok.
At makikita mo na lang kung kunin ang aking mga salita para dito sa ngayon.
Ngunit kami ay makita ito konstruksiyon at ilang iba gusto ito
sa ilan sa mga iba pang mga source code na ipapakita namin sa iyo sa loob lamang ng ilang sandali.
>> Mayroon bang anumang mga paunang mga tanong dito?
Kaya ang mahalagang takeaway ay na ang isang opsyonal na uri ay uri ng isang metatype.
Ito ay alinman sa isang halaga, at kung ito ay, pagkatapos ito
ay marahil mayroon na halaga na kaugnay sa mga ito, o kung ano pa man ay walang halaga ito,
at ito ay kinakatawan ng wala.
Ang natitirang bahagi ng mga ito ay marahil tulad ng iyong inaasahan.
>> Kaya sabihin ramp up ang nahihirapan pa muli.
At oras na ito, sabihin kumuha ng isang pagtingin sa ilan iba pang mga uri na aktwal na umiiral na data.
Isa sa mga ito ay mga diksyunaryo, na kung saan ay halos kapareho sa Python diksyunaryo.
Ito ay halos katulad sa isang hash table sa C. Ito ay mahalagang isang pagmamapa ng key
kung saan ang mga pindutan ay maaaring maging string.
At kapag hanapin mo ang mga susi, mga key ay magkakaroon ng isang halaga.
Kaya ito ay hindi pa isang array, ngunit sa halip, mas malapit na kaugnay
sa isang hash mapa o isang hash table.
>> Tingnan natin kung paano ito ay dapat ipaalam sa sa trabaho bago namin talagang
pumunta sa source code mismo.
Kung nagpapatakbo ko lang ito, talaga ang mangyayari wala.
Ito ay nagsasabi sa akin na ako umaasa ang ilang mga parameter ng ang mga sumusunod na uri.
Kaya ako pagpunta upang magbigay sa ito ang ilang mga pangalan ng hanay ng problema,
kaya pset0, siguro nakuha ko 100.
At pset1, isang 5 ang nakuha ko.
At pagkatapos ay sa pagsusulit, ako ay tunay mabuti at nakuha 30.
At Oops, ako hit ng isang puwang dito.
>> Kapag ako pindutin ang Enter, maaari mong makita ito ay gumaganap ng ilang mga pagtutuos.
Sinasabi nito gradebook ay tatlong grado, pset1, pset0, exam.
At ang gradebook ay ito tiyak na average.
Kaya muli, kami ay nagtatrabaho may ideya gradebook ito,
ngunit kami ay pagpunta upang magpatuloy iterating sa pagiging kumplikado ng aming mga function.
>> Kaya sa pagsisimula, hindi namin lamang pagpunta upang lumikha ng isang function na
ay responsable para sa pag-print ang paggamit.
At may exit na ito function na kung saan ay lamang
puwersahang isara ang application.
Ito ay hindi isang bagay na gagamitin mo sa iOS app.
Ito ay para lamang, sa kasong ito, may isang argument command line.
Susunod na kami ay simulan ang paglipat patungo sa Xcode.
Ngunit ito ay tiyak sa isang utos style program line sa Swift.
>> Tingnan natin ang isang pagtingin sa ilan sa ang mga kagiliw-giliw na bagay dito.
Makita, lamang ng ilang Hayaan kagiliw-giliw na mga bagay-bagay sa banggitin marahil
ay na sa aking pag-andar ng imprenta ang bilang ng marka,
maaari mong isipin ang na ako ay listahan na ng items-- pset1, pset0, at exam.
Maaari mong aktwal na mabilis at madaling gawin ito
sa pamamagitan ng pagkuha ang gradebook, na isang diksyunaryo na may susi at halaga.
Hanapin ang lahat ng mga key ay sa pamamagitan ng ang paraan dot keys dito,
at pagkatapos ay gamitin ito joinWithSeparator, na kung saan ay pagkatapos ay gawin ang lahat ng mga susi
na kami ay nag-type sa, pset1-- o Paumanhin, pset0, pset1, at exam--
at pagdugtungin ang mga ito nang sama-sama gamit ang isang kuwit at isang puwang
upang lumikha ng isa pang string.
Ito sumali operasyon ay phenomenally lamang kapaki-pakinabang sa isang iba't ibang mga konteksto.
At kaya ito ay na ito joinWithSeparator.
>> At ito ay isang bagay na nagbago mula Swift 1 hanggang Swift 2.
May ginamit upang maging isang Python style-- kung ikaw ay
pamilyar sa Python-- isang sawa sumali style na paraan sa mga string.
Ngunit iyon ay hindi na ang kaso sa Swift 2.
Gusto mong gamitin ito kung nais mong pagdugtungin ng isang hanay ng mga bagay-bagay
kasama ang isang string.
>> Kaya marahil pagkatapos ay sa aming talakayan ng average ng dati,
ito ay gumagawa ng isang maliit na piraso ng higit pang kahulugan para sa amin upang i-set ang average na function
upang maging isang opsyonal na double sa halip pa sa isang tahasang double.
Dahil kami ay nagkaroon na hindi pangkaraniwang kalagayan kung saan,
paano kung gradebook talaga Wala halaga sa loob ng mga ito?
Ano dapat ang average return?
>> Well siguro sa C mo sana ay tapos na ang isang bagay
tulad ng ibinigay ang halaga ng isang nagbabantay, tulad ng 0.0, o marahil ng isang negatibong bilang,
o isang bagay na kumakatawan lamang ang katotohanan na nagkaroon ng ilang kondisyon na error
at ikaw ay marahil hindi talaga magkaroon ng kakayahan sa compute na average.
Well ang kagandahan ng pagtukoy ng isang opsyonal na uri ay upang gawin iyon.
At ako ngayon sinasabi ng lahat ng mga salitang ito, ngunit ito ang tunay na hindi gumagamit optionals.
Ngunit kami ay makita na sa loob lamang minuto kung saan maaari naming i-set average
upang maging isang opsyonal na uri ng data upang ang kung ito aktwal na nagbabalik ng ilang data, pagkatapos ay
kami ay babalik na data.
Kung hindi man kami ay babalik kawalan, na nagsasabi na ito
Wala makabuluhan pagtutuos.
>> Sabihin ilipat sa ibang bagay Hayaan.
Kaya mula dito, kami ay naghahanap sa lahat ng mga halimbawang ito sa linya ng command.
Ngunit ang tunay ano ang iyong pagpunta sa pagharap sa ay Xcode.
At ang isa sa mga magagandang bagay tungkol sa Xcode ay, at partikular na sa Swift,
ay mayroon kaming na ito bagay na tinatawag na isang Playground.
At isang Playground ay hindi sa lahat ng iOS app.
Ngunit ito ay nagbibigay-daan sa iyo upang mag-eksperimento may Swift sa isang napaka-madaling paraan.
Maaari ninyong ilagay ang lahat ng iyong code.
Ito ay mabuti syntax highlight dito.
Kapag lumikha ka ng isang bagong file, ito ay hihilingin sa iyo kung nais mong lumikha ng isang Playground.
Ngunit ang magandang bagay tungkol sa palaruan ay nasa kanan ng iyong window,
ay ito ang tunay na ipakita sa iyo output mula sa iyong code.
Kaya kung mag-scroll ko pababa, maaari naming makita kung ano ang ang output ng iba't-ibang linya ng code
talagang mangyayari na.
>> Kaya sa kasong ito, kami ay pagpunta sa baguhin ang mga direksyon ng kaunti lamang
at makipag-usap tungkol sa isang bagay na talagang Mahalaga na ito mataas na antas na paraan
na Swift nagpapatakbo, at ito ay ito ideya ng pagsasara.
At makikita mo marahil ito Medyo sa JavaScript.
Para sa inyo na ay sa CS50, pagsasara
ay napaka-tanyag, magaling na paraan ng paggawa mga bagay mataas na antas sa modernong wika.
Ngunit ito ay uri ng mahirap na ring balutin ang inyong ulo sa paligid sa unang pagkakataon.
Kaya't kung ikaw ay naghahanap sa ito unang pagkakataon, na ang OK.
Hanapin lamang sa mga source code at tingnan kung maaari mong malaman kung ito sa bahay.
>> Kaya sa kasong ito, sabihin natin na tayo nais na lumikha ng isang pulutong ng mga exponents
kasama ang ilang mga nakapirming halaga.
Kaya sa kasong ito ang maaari kong lumikha ng isang function.
Pupunta ako sa mga tawag na ito ng kapangyarihan ng 2 na ang tanging layunin sa buhay
ay tumagal ng ilang mga input at double ito, at ibalik ang halaga.
Pansinin na dito ako pagtanggap sa isang uri ng data.
Ito ay pagpunta sa maging isang variable na tinatawag na x.
Ito ay ganitong uri Double.
At ako pagpunta upang bumalik sa isang Double dito.
At lamang ako ng pagpunta sa gawin isang napaka, lantaran, pretty
walang muwang na paraan ng pagdodoble ang halaga na ito.
At ipapakita ko sa iyo kung bakit ito ay kapaki-pakinabang sa isang segundo lang.
>> Pansinin na dito kami hanay na ito muli. para sa isang bagay sa 1, tuldok
tuldok tuldok, 2, na nangangahulugan na ang loop na ito ay tatakbo nang dalawang beses.
Ngunit ito ay kumakatawan sa isang dummy variable.
Ito ay nangangahulugan na hindi ako tunay na pagpunta sa ay gumagamit ng variable na kahit saan
sa loob ng loop na ito.
Gusto ko lang ang linyang ito ng code na tumakbo nang dalawang beses,
hindi nangangailangan na alam ang halaga ng mga saklaw na iyon.
>> Kaya sa kasong ito ako nagpapatakbo resulta ulit x dalawang beses, na mahalagang
ay nangangahulugan na ako ng squaring ang halagang ito.
At ito ang mangyayari sa mga gumana tulad ng gagawin namin inaasahan.
Power of 2, pagpasa ng isang halaga ng 2.0 ay nagbibigay sa amin ng isang output ng 4.
3.2 gawa para sa 10.24.
>> Ngayon ay maaari naming gawin ng isang katulad bagay para sa kapangyarihan ng 3.
Ngunit ngayon lamang baguhin range ang.
Para dummy variable in 1 sa pamamagitan ng 3, i-multiply ng 3 beses,
at gawin ang parehong bagay.
>> Kaya ito ay maaaring makaramdam ng kaunti contrived.
Subalit mayroong isang mahalagang bagay dito na
na ang pagtingin sa mga dalawang pag-andar, may
lamang ng isang bagay na naiiba, na kung saan ay ang halaga na ito sa saklaw.
Lahat ng iba pa tungkol sa mga dalawang function, kapangyarihan ng 3 at kapangyarihan ng 2,
ay, sa katunayan, magkapareho dahil gumagana ang mga ito sa parehong paraan.
>> Kaya sa puntong ito, ang isang maliit alarma kampanilya ay dapat na pagpunta off.
Sana kung ano ang iyong sinasabi, alam mo, ito nararamdaman ng isang maliit na piraso
tulad ng pagkopya ng mga pagsisikap.
Marahil mayroong isang paraan na gusto ko ma-encapsulate ang lahat ng ito
at magbigay ng isang function o lumikha ng isang function na
ay kung ano mismo ang gusto ko nang walang nangangailangan na i-type ito sa labas tahasang.
At ito ay kung ano ang kapangyarihan ng isang pagsasara ay nagbibigay-daan sa amin upang gawin.
Kaya sabihin kumuha ng isang pagtingin sa ito.
At kukunin ko na gumastos ng ilang mga minuto na ito, dahil ito
ay medyo mahalaga para sa Swift.
Nakita namin ito sa lahat ng oras.
Kami ay pagpunta upang tukuyin ang isang function.
Ito ay pagpunta sa ay tinatawag na powerOf.
Ito ay pagpunta upang tanggapin ang isang parameter na tinatawag na y ng uri int.
Ngunit ang isang tumingin sa ang uri ng return.
Ang uri ng return ay, sa panaklong, Double palaso Double.
Na nangangahulugan na ang function na ito, mga function na ito powerOf,
ay nagbabalik ng isang function.
Iyon ay ang pagtanggap ng isang Double at pagbabalik ng isang Double.
Kaya na maaaring tunog uri ng mga loko, ngunit ni-scroll pababa ng kaunti ipaalam
at tumingin upang makita kung ano ang mangyayari.
Humihingi kami sa loob ng function na ito powerOf.
Kami ay ang paglikha ng isang bagong function tinatawag exponentiator,
ngunit ito ay hindi mahalaga kung ano ito.
>> Paunawa na ito ay may isang input na halaga ng x.
At ito ay ang pagkuha sa isang Double at pagbabalik ng isang Double.
At ito ay ang parehong code na aming Nakita sa itaas, maliban na ang mga halaga ng 2
o ang halaga ng 3, na itaas na nakatali sa hanay na iyon,
ay pinalitan ng ang halaga na ito ng y, na
ay ang unang parameter ng ating powerOf function.
At sa puntong ito, kami bumalik exponentiator.
Kami ay bumabalik na ang function.
>> Ito ay uri ng tulad ng isang maliit na isip pamumulaklak.
Ngunit ni isipin kung ano ang mangyayari ipaalam kapag tumawag ako ang function na ito powerOf
at pumasa sa mga ito sa ilang mga halaga tulad ng 2.
Ano ang ibig sabihin nito ay na Ngayon ko ang halaga
2 para sa y, na nangangahulugan na ang halaga na ito y sa exponentiator function na
ay magiging na halaga 2.
Ngunit ako bumabalik na ito exponentiator function.
>> Kaya mapansin ko kung ano Swift sabi may ginawa sa kasong ito.
hayaan square ay isang kahulugan, ito ay isang function na tumatanggap ng isang Double
at nagbalik ng isang Double.
Ako ay may ginawa ng isang function na mga parisukat ng isang bagay
gamit ang mekanismo na ito dito mismo.
At talagang kung ano ang nangyayari ay na ito ay bumabalik ang function na ito
exponentiator, ngunit ang halaga na ito y ay nakabalot sa loob ng mga ito.
At sa bawat oras kaya ngayon ito ang ginagamit ko variable o tapat na ito ng tinatawag na
square, ito ito ay pagpunta upang kumilos bilang isang function.
At kaya ko maaaring pagkatapos ay tumawag sa variable na tulad Gusto kong tumawag sa isang function,
at pumasa sa mga ito ng isang numero, tulad ng sa kasong ito 3.
At ako ay pagkatapos ay parisukat ang halagang ito.
Kaya 3 nakalapat ay pagkatapos maging 9, bilang maaari naming makita dito.
>> Talagang mabaliw, ngunit ito ngayon ay nagbibigay-daan sa akin ng pagkakataon
upang lumikha ng iba pang mga function powerOf.
Tulad ng maaari kong sabihin, OK, na rin ngayon ay nais ko upang lumikha ng isang bagong pag-andar, powerOf (3),
at mag-store na iyon sa isang pare-pareho na tinatawag na kubo.
At ngayon kubo ay magiging isang hiwalay na function na ay pagkatapos
tumagal ng ilang mga halaga ng input at kubo na halaga na maaari naming makita sa ilalim na linya
dito.
kubo ng 2 ay pagpunta sa resulta sa 8.
>> Sana medyo kapong baka bagay-bagay.
Hindi ka pa nakakakita nito bago.
Hinihikayat ko kayo na tumingin sa mga pagsasara at siyasatin ito nang kaunti pa.
Talaga ang malakas na mga bagay-bagay ito nakita namin ang isang pulutong sa JavaScript at ilang iba pang mga wika.
Ito ay talagang mahalaga sa pag-unawa sa mga API pati
na kami ay kumuha sa isang segundo lang.
Oo?
>> Madla: Kapag ginawa mo powerOf (2), panaklong, at pagkatapos ay
isa pang parenthesis, isa pang input-- karaniwang kayo ay pinapalitan ang square.
DAN AMRMENDARIZ: Kaya tingnan sa pinakadulo huling linya dito.
Ito ay talagang lubos na posible na gawin na pagdudugtong bilang iminungkahing sa iyo.
Kaya powerOf (5) ay nangangahulugan na kami ay pagpunta na magkaroon ng isang exponentiator 5 up dito.
Kaya ito ay mahalagang pagpunta sa maging ang parehong bagay tulad ng 4 hanggang ikalimang kapangyarihan,
dahil lumikha kami ng isang exponentiating gumana sa ikalimang kapangyarihan,
at kami ay pagpasa sa na function ng halaga 4.
At kami makakuha ng halaga na na inaasahan namin, 1024.
Madla: At ito ay hindi isang pangalan, kaya ito ay mas madali
basahin, ang mga parisukat na kahit na ano.
>> DAN AMRMENDARIZ: Kanan, eksakto.
Kaya bago ko bang ilagay ito lamang sa isang pare-pareho dito kaya
na ito na ginawa ito madaling gamitin na pangalan.
Oo?
>> Madla: Sa kontekstong ito powerOf, ito ay bahagi
ng mga programming language bilang laban sa mga paraan kung paano ka
tingin ng powerOf sa [hindi marinig]?
DAN AMRMENDARIZ: So sa kasong ito, powerOf
ay para lang sa pangalan ng function na akong tinukoy up dito.
Kaya ito ay hindi likas sa ang wika mismo,
ngunit sa halip, ito lamang isang function na ay may
na pangalan dahil ako bigyan ito ng pangalan na.
Anumang iba pang mga katanungan?
Lahat tama.
>> Ngayon na ito ay malaki.
Ngunit hindi ka pagpunta upang makita ang isang pulutong ng pagsasara function na
ay tulad na ito kung saan mo tukuyin, sa loob ng isang function, ang isa pang pag-andar.
At maaari mong gawin ito.
Ngunit ito ay uri ng hindi talagang kinakailangan, right?
Tulad ng kung bakit ko tukuyin ang mga ito function na tinatawag exponentiator
at pagkatapos ay agad na bumalik ito.
Bakit hindi na lang ako agad bumalik sa function na ito?
>> At sa katunayan, ito ay tiyak ang ideya sa likod ng isang konsepto na tinatawag na
anonymous pag-andar, kung saan hindi kilalang function ay hindi tunay
magkaroon ng isang pangalan dahil sila hindi na kailangan upang magkaroon ng isa.
At kaya sa kasong ito, sa 7B, maaari naming mahanap ang tiyak na.
Lahat ng ito ay ang parehong code, gumagana nang eksakto ang parehong bagay,
ngunit ngayon binago namin ito nang bahagya kaya na ito powerOf function na agad
nagbabalik ng isang function.
Pansinin na pagkatapos ng pagbabalik, may isang bukas na curly bracket.
Ito ay umaasa na ito input Double.
Ito ay umaasa na ang output Double.
At pagkatapos ay ang sa keyword naghihiwalay sa code mismo.
Kaya ito ay isang hindi nakikilalang function.
Ito ay hindi tunay na magkaroon ng isang pangalan, kung saan ang bago ito ay tinatawag exponentiator.
Ngunit tulad ng nakita natin, talagang lamang ay hindi sumangguni sa exponentiator
sa labas ng na function.
Kaya hindi ito mahalaga.
Kaya hindi kilalang function na ito ay tinatawag na ito sapagkat ito ay walang pangalan,
ngunit ito ay ginagamit pa rin sa konteksto ng code na ito.
>> Ang susunod na ilang mga Ako pagpunta sa patuloy sana
pamumulaklak ng iyong isip nang kaunti.
Maaari naming gawing simple ito ng mas maraming.
Dahil bilang ay astutely tulis mas maaga,
marahil aktwal na namin alam, sa pamamagitan ng inferring ito mula sa code, kung ano
ang output ng code na ito ay magiging.
At sa katunayan, sa hindi kilalang function na ito, maaaring sa katunayan naming ipahiwatig ang mga uri ng data.
>> Kaya sa isang ito, walang kami na kailangang tahasang tukuyin
ang uri ng data na pagiging input at output mula sa function na ito
para sa isang pares ng mga dahilan.
Ang isa ay na iyong tinukoy namin, hanggang sa prototype ng nasasakupang function,
ano ang uri ng data na ito anonymous function na ay dapat na input at output.
At mula sa iba pang, kami ay maaaring magpahiwatig mula sa code
down na dito na kami ay tumatanggap ng mga input na ng uri Double
at pagbabalik ng isang Double.
>> Pansinin na dito kami hindi malinaw tinukoy ang mga pangalan ng mga argumento
na ang function na ito ay tumatanggap.
At kaya namin makita ang maaari naming sumangguni sa mga parameter gamit $ 0, $ 1,
kaya sa at iba pa, depende sa ang bilang ng mga na parameter na ginamit
sa function na ito.
>> Ito ay isang bagay na ikaw ay pagpunta upang makita ang marami ay ito open curly bracket
definition na sinusundan ng isang $ 0, at pagkatapos ng ilang operasyon,
at pagkatapos ng isang closed kulot bracket.
Iyon ay isang hindi nakikilalang function na gumaganap ng operation na ito.
Ito ay may parameter na ito kung saan ito ay ang uri ay natukoy.
Na unang parameter ay $ 0.
At ilang operasyon ay nangyayari sa na $ 0.
>> Madla: Kaya ang dollar sign nangangahulugan parameter talaga,
at 0 ay nangangahulugan na ang unang isa?
DAN Armendariz: Iyan ay tama.
Kaya karaniwang ay nangangahulugan na ang dollar sign parameter, at 0 ay nangangahulugan na ang unang isa.
Ngunit ito partikular na gumagana sa kasong ito kung saan hindi ako pinangalanan
ang mga argumento sa aking mga function anonymous.
>> Madla: Perl o isang bagay na mayroon ba ito dollar sign, dollar 0 in doon?
DAN Armendariz: ba na, Sorry?
Madla: Mayroon Perl ba ito dollar 0, dollar 1--
DAN Armendariz: Hindi ako masyadong pamilyar sa Perl,
ngunit PHP kung ano ang tumutukoy na mga variable batay sa mga palatandaan dollar.
At maaaring may ilang mga wika na magkaroon ng mga tampok tulad nito.
Sa katunayan, Swift borrows isang pulutong ng mga tampok tulad ng isang ito
mula sa isang pulutong ng iba pang mga wika.
Nakakakita kami ng mga pahiwatig ng Python sa loob nito.
Ito kahulugan ng uri parang nanggaling mula OCaml.
At kami ay may lamang ng isang buong grupo ng mga mga bagay-bagay mula sa maraming iba't-ibang mga wika.
Iyon ang isa sa mga magaling mga bagay-bagay tungkol sa Swift
na ito ay tumatagal ng isang pulutong ng mga pinakamahusay na mga ideya mula sa isang grupo ng mga wika
at shoehorns mga ito ang lahat ng sama-sama sa isa super wika.
Sa katunayan, kung papayagan mo ako sa patuloy pamumulaklak ng iyong isip,
kaya kami ay ginagawa ang lahat ng ito.
Maaari naming marahil gawing simple ito ng isang maliit na unti realizing na, siyempre,
Swift ay may isang exponentiating function na built in.
Kung import ko Darwin, kung saan ay lamang ang library na
Nagtatampok ang function na tinatawag na pow, ngayon Maaari ko bang gawing simple ang aking kapangyarihan ng pag-andar
na ang mga sumusunod.
Ito ay pagpunta sa ay bumabalik anonymous function na ito.
>> Ngunit tumingin sa kung paano simple ito ay ngayon.
Ito ay isang hindi kilalang function na ay tumatanggap ng ilang mga uri ng data,
at ito ay magiging isa argument na partikular,
isinangguni sa $ 0 na ng uri Double.
Ito ay pagpunta upang bumalik sa isang uri Double.
Ngunit ang return statement ay implicit ngayon.
>> At ito ay ang eksaktong estilo na ay tunay, tunay na laganap sa Swift,
lahat ng dako ng lugar.
Kami ay pagpunta upang makita ito lahat ng oras sa Swift.
Kaya ako na nagpapakita ng lahat ng mga ito sa iyo dahil sa ang syntax na ito.
Ito ay napaka-pangkaraniwan upang makita, na nangangahulugan na ito
ay isang hindi kilalang function na gumaganap
ang ilang mga operasyon sa mga argumento.
At doon ay isang implicit return.
Kaya ito ay ganap na ang parehong bagay para sa amin upang sabihin na ito, dito mismo.
>> Dahil ito kulot bracket ay isang function,
hindi namin maisagawa ang operasyon sa unang argumento.
Kami ay pagpunta sa bumalik na.
Ngunit ito outer return ay bumabalik na ang buong pag-andar,
na ang buong pag-andar anonymous na lamang na nilikha namin.
Anumang iba pang mga katanungan?
Sige, hindi ko alam kung ka guys ay handa na para sa mga ito,
ngunit kami ay maaaring pumunta kahit crazier sa Swift.
Handa ka na?
OK, ito ay mahusay.
>> Ngayon ang tunay na kami ay may kakayahan upang, sa Swift, dahil sa kung paano modular
at kung paano batay protocol na ito ay, sa tukuyin ang aming sariling freaking operator.
Tulad ng sa kasong ito, kami ay walang operator para exponentiation-- rin,
para sa pagganap ng kapangyarihan ng isang bagay.
Ngunit maaari ko, sa Swift, tukuyin ang isang bagong operator na ang tiyak na.
Kaya sa kasong ito ay mayroong ng grupo ng mga syntax dito.
At kukunin ko na magbibigay-daan sa iyo upang tingnan ang mga ito sa bahay kapag tiningnan mo ito.
Ngunit kami ay pagtukoy ito itanim operator, **, na pagkatapos ay magbibigay-daan sa amin,
sa pamamagitan ng pagtukoy kung ano na ang function na ** talaga
ay, upang tanggapin ang isang kaliwang kamay panig at isang kanang bahagi,
at pagkatapos ay ibalik ang exponent ng na kaliwang bahagi sa kanang bahagi.
>> At kaya ngayon lahat ng isang biglaang ko ay lumikha ng isang bagong tagabilang.
Kaya 2 ** 3 nangangahulugan 2 sa ikatlong kapangyarihan.
[Isip Pagbugso ng tunog] na ito sa pamamagitan dapat mismo gumawa ka na tulad ng,
OK, tornilyo C. Pupunta ako Swift lahat ng mga paraan.
Ito ay kahanga-hanga.
Ito ay medyo hindi kapani-paniwala.
>> Kahit na ito ay isang magandang halimbawa.
Ngunit mayroon akong hindi kailanman isang beses sa labas ng halimbawa na ito ang tunay na
tinukoy ang aking sariling mga operator.
Ngunit pa rin, ito ay nagpapakita ng isang pulutong ng kapangyarihan ng Swift
at kung bakit ito ay talagang talagang napaka-cool.
OK, yes?
Madla: Kung ikaw ay pagtukoy ng iyong sariling operator,
kung paano ang kilala mo kung hindi mo sinasadyang subukan at lumikha ng isang operator na
sa tabi-tabi sa C, tulad ng nakatago sa isang lugar sa Swift,
tulad ng isang isa ikukubli na kayo Maaaring hindi nakita bago.
>> DAN Armendariz: Kaya kung sinusubukan upang tukuyin ang iyong sariling mga operator,
diyan ay ang panganib ng pagtukoy isa sa paglipas ng isang umiiral na operator.
Iyon ay pumunta sa isang antas ng detalye na Hindi sa tingin ko kami ay may oras upang pumunta sa ibabaw.
Ngunit iyon ay isang panganib.
At iyon ay sa katunayan ang tunay na dahilan kung bakit Hindi ko gamitin ang simbolo caret, na
kapag kami ay pag-type ang kapangyarihan, kami ay karaniwang gamitin ang 4 maliit caret 5 o isang bagay
tulad na, lamang kapag kami ay Gchatting buddies o anuman.
Ngunit sa kasong iyon, na talagang ay may dulot ng isang banggaan.
At kaya ako iwasan ito dahil lang Nangyari kong malaman na sa kasong ito
na na magiging dahilan na banggaan.
>> Lahat tama.
Ngayon sa kasamaang-palad, para sa sa huling pitong minuto,
Kailangan ko bang panatilihin ang pamumulaklak inyong mga isipan nang kaunti.
Kaya payagan ako upang ipakita sa iyo ilang iba pang mga bagay-bagay pati na rin.
>> Kami ay ipinapakita ang ideya na ito ng sa iyo pagkakaroon ng mga anonymous na function,
mga closures na magpapahintulot sa inyo na uri ng pumasa function sa paligid.
Maaari mong ibalik ang mga ito.
Maaari mong manipulahin ang mga ito.
Maaari mong gawin ang lahat ng mga uri ng mga nakatutuwang bagay-bagay.
>> Ngunit ang isa pang bagay na ang mangyayari sa maging kapaki-pakinabang
ay ang kakayahang, bilang kabaligtaran sa pagbabalik ng mga function
sa isang function, upang pumasa sa isang function bilang isang parameter sa ibang gamit.
Maaaring nag-iisip na rin kung bakit sa Earth Gusto ko nais na gawin ang isang bagay tulad na?
>> Well, sabihin natin na gusto ko kunin ang operator na ako
nagtrabaho nang husto upang lumikha at mag-aplay ito sa isang grupo ng mga iba't ibang mga numero
sa isang array.
Kaya sa kasong ito Mayroon akong isang hanay ng mga integers-- 1, 4, 7, 2, 5, 10, 56.
At gusto ko upang i-double ito lahat.
Ang paraan na gusto namin karaniwang gawin ito ay upang magsulat lamang
isang simpleng para sa loop na iterates higit sa lahat ng mga ito
at magsagawa ng mga ilang uri ng mga square operasyon sa loob ng mga ito,
inputting mga bagong halaga sa isang bagong variable, o sa halip, ang isang bagong array dito.
At ang halaga ng output ng pagkatapos resulta ay ang lahat ng mga array,
o sa halip ng lahat ng mga elemento ngayon nakalapat.
>> At maaari naming gawin ang parehong bagay para sa cubing ito,
ngunit ang isang maliit na kampanilya alarma dapat maging pagpunta off
sinasabi na baka may ang ilang mga paraan na gusto namin
maaaring gawing simple na ito nang kaunti.
At sa katunayan ay may.
Paano kung maaari naming lumikha isang function na nagpapahintulot sa amin
upang tanggapin, bilang isang mandaragit, isang function?
Kaya sa kasong ito, kumuha ng isang tingnan ang mga argumento.
Kami ay pagpunta sa tanggapin ang isang listahan ng mga doubles.
At pagkatapos kami ay pagpunta upang tanggapin ang isang function
sa isang variable na tinatawag na f na pagpunta upang kumuha ng Double at ibalik ang isang Double.
At ang buong output ng buong pag-andar
tinatawag mapper ay pagpunta sa bumalik sa isang array na tinatawag na double.
>> Ano ang gusto ito at pagkatapos ay payagan ako sa gawin ay upang umulit sa listahan na
at gawin ang parehong bagay, ngunit ngayon mag-apply na function sa bawat
ng mga indibidwal na mga halaga sa listahang iyon.
Kaya hindi ko talaga alam kung ano ang f ay.
Hindi mahalaga sa akin.
Subalit kaya hangga't ito ay tumatagal sa isang Double, ang pagganap ng ilang mga operasyon sa mga ito,
at pagkatapos ay nagbabalik ng isang Double, pagkatapos Gusto ko ay
able sa mapa na function sa kabuuan bawat solong elemento sa listahan.
>> At sa ganitong uri ng programa ay tinatawag na mas mataas na pag-andar order,
kung saan kami ay pagpasa function sa paligid ng bilang ng mga parameter
at paggawa ng mga bagay na may pag-andar.
Ito ay uri ng tulad ng pagkuha ng lahat ng mga mga ideya na iyong natutunan namin sa CS50
at pagkuha ng mga ito-uri-uriin ng sa susunod na antas.
At ito ay ang lahat ng mga bagay-bagay style CS51.
At kaya kami ay pumunta sa malalim higit pa sa klase na tulad ng.
>> Ngunit ito ay din mahalaga dito dahil tayo
makita ang marami ng mga pag-andar na ginagamit sa Swift
na mahalagang ginagawa na ito, kung saan mayroon kaming
ang ilang mga numero, ang ilang mga hanay ng mga numero.
Kami ay pagpunta sa pumasa na array sa aming mapper.
At kami ay din ng pagpunta sa pumasa ang ilang mga function, kung saan
na tinukoy namin ang up dito.
Ito ay pagpunta sa maging square.
At kami ay pagpunta sa pagkatapos ay parisukat ang lahat ng mga numero
at mag-store na ito sa mga resulta dito.
>> Kaya kasong ito na tinukoy namin ang aming sariling function na tinatawag na mapper.
Ngunit ito eksaktong bagay ay, sa katunayan, na binuo sa Swift.
May mga iba't-ibang mga tinatawag na function na mapa.
May isang function na mapa, mayroong isang mabawasan function,
at mayroong isang filter na function, na mahalagang ilapat function
sa bawat solong elemento sa isang ilista na baguhin ang mga ito sa ilang mga paraan.
>> Madla: Kaya dahil ikaw ay pagbabago ang data sa ibang format
sa pamamagitan ng isang function
DAN Armendariz: Kanan.
Oo, kaya ang pag-andar na kami ay tumatanggap ng mga
ay pagbabago sa data sa ilang mga paraan.
Sa kasong ito, kami ay mag squaring ito, o kami ay cubing ito,
o talagang, maaari naming magsagawa ng walang operasyon sa mga ito sa lahat.
>> Ngunit hayaan mo akong ipakita sa iyo pagkatapos ay kung paano ito ay pagpunta sa tumingin sa pagsasanay.
At muli, ako nagpapatakbo ng isang piraso ng oras. kaya hindi ako
pagpunta sa magagawang upang pumunta sa lahat ng source code dito sa detalye.
Ngunit Hinihikayat ko kayo na gawin iyon.
Magpo-post kami ng ito sa lalong madaling panahon pagkatapos na ito talk.
>> Ngunit kung ikaw ay kumuha ng isang pagtingin sa mga ito, ipagpalagay na kami ay may isang listahan ng mga numero,
isang hanay ng mga numero sa mga ito variable na tinatawag na numero.
At gusto namin upang maisagawa ito filter na operasyon sa mga numero.
Kaya filter ay isang mas mataas order function na
tumatanggap ng isang array at isang function din.
At sa bawat sangkap sa mga array, ito ay gumaganap na function.
>> Kung na function ay nagbabalik totoo, iniingatan nito ang item na iyon.
Kung na function ay nagbabalik ng hindi totoo, ito ay nagtatapon ng item na iyon.
At pagkatapos ay nagbabalik ng isang listahan na pagkatapos ay binubuo ng lahat
sa mga bagay na na-filter.
>> Kaya sa ibang salita, ito ay ang parehong ideya, markahan.
Maaari naming magkaroon ng isang iba't ibang mga marka sa halaga na ito na tinatawag na numero.
Puwede na 100, at 70, at 40, para sa at iba pa.
Ano ang filter na ito ay ay notice na ito ay na ang sintaktik asukal
para sa isang hindi nakikilalang function.
Ito ay isang hindi kilalang function na sinasabi na ang mga parameter na ako tumatanggap ng mga
ay magiging, kung ito ay mas malaki kaysa sa 70,
pagkatapos na ito ay nagbabalik ng tunay, ibig sabihin na na item ay dapat manatili sa filter na ito.
Kaya maging ang isang maliit na bit ipaalam mas kongkreto tungkol dito.
Kung may ganito akong array ng mga numero at ito ay binubuo ng 100, 70, at 40,
Gawin ko ang filter na ito operasyon sa bawat isa sa mga iyon.
Kaya na una ay ang halaga na ito ng 100.
100 mas mataas o katumbas hanggang 70 ay totoo, na
ay nangangahulugan na ang 100 ay nag-iingat sa ito ng mga bagong kopya ng array.
70 din pumasa.
Ngunit 40 ay hindi.
Kaya kung ano ay ibinalik sa passingCount ay ang dami ng mga elemento ng 100 at 70--
100, kuwit, 70.
Yaong ay ang dalawang lamang mga item na nag-iingat.
At upang ang mga dahilan ko mabilis nagpunta sa pamamagitan ng isang pulutong ng mga uri ng mga mataas na order
bagay na ito ay dahil ito ay na karaniwang bagay na makikita mo sa Swift pretty
madalas, ay gumagawa ng ilang mga operasyon gamit na ito anonymous syntax function.
>> May ilang mga cool na bagay.
Lilipat ay tunay na makapangyarihan sa Swift, Ibig sabihin ko tulad ng mabaliw, mabaliw makapangyarihan.
Maaari mong gamitin ang switch, at Maaari mong aktwal na mag-aplay ang mga ito
na mga saklaw, na kung saan ay uri ng mabaliw, at gawin magarbong bagay-bagay na tulad ng.
>> Ngunit sa huling ilang mga minuto, Gusto ko na maunang lumaktaw Medyo malayo
at magpapakita sa iyo ng isang tiyak na halimbawa ng kung paano maaari naming lumikha sa iOS app gamit Swift.
Kaya kapag ikaw ay gumagawa ng na ito, magkakaroon ka upang kumuha ng
isang tumingin at-- sa Apple dokumentasyon, sila
magkaroon ng maraming talagang magandang mga tutorial para sa paglikha ng iyong unang application.
At hinihikayat ka kong gawin na dahil sila magdadala sa iyo
sa pamamagitan ng lahat ng mga hakbang ng kung ano ang eksaktong sa mag-click sa upang lumikha ng isang iOS application.
>> Ngunit dito kami ay may ito iOS app.
At ito ay isang medyo simple app talaga.
Kung nagpapatakbo ko ito, sabihin sa akin sa iyo kung ano ang mukhang.
Lahat ng ito ay mahalagang ay ito kinukuha mula sa internet sa isang JSON file
na ako ay may naka-imbak sa isang server.
At na JSON file Tinutukoy ng mga imahe na payagan
sa akin na pagkatapos cycle sa pamamagitan ng, sa aking app, imahe mula sa aking web server.
>> Kaya ko dito getNextImage.
Naglo-load Ito ang isang imahe mula sa internet, at pagkatapos ay ipinapakita ang mga ito sa screen.
>> Kaya ito ay medyo simple.
Ngunit ang layunin dito ay upang ipakita ang sa iyo kung paano maaari naming pagsamahin ang mga bagay
mula sa ilang huling linggo ng CS50 sa isang aktwal na iOS application.
Sa ibang salita, marahil ang isa sa mga mga bagay na gusto mong gawin
ay ang pagkakaroon ng iOS application na maaaring hilahin ang data mula sa internet
at ipakita ng user ang ilang impormasyon.
Iyon ay ganap na punto ng source code dito.
>> Kaya mayroong isang pulutong na sinabi tungkol sa kung paano gawin ang mga aktwal na iOS-unlad.
May ay isang pulutong ng mga loko syntax na hindi masyadong pa namin nakikita
tulad ng isang klase, kung ano ang isang klase ay talagang.
Maaaring higit sa lahat naming huwag pansinin na para sa pansamantala.
>> Ngunit mapansin na may nakapaloob namin sa loob ito ng iba't-ibang mga bagay-bagay
na kami ay nakita ko na tulad ng mga function na may tiyak na pangalan.
At kapag binigyan kami ng mga mga function na ang tamang mga pangalan
na inaasahan sa pamamagitan ng iOS, sa katunayan ito nararamdaman ng isang maliit na piraso nakapagtataka.
Ngunit kapag lumikha ka ng isang iOS application, may
mga tiyak na mga pangalan ng function na tinatawag sa pamamagitan ng telepono mismo
bilang ang application ay naglo-load na subukan upang lumikha ng mga proseso na aktwal
tumatakbo ang iyong application.
Kaya muli, may isang pulutong ng mga bagay na ako kung pagtakpan dito sa order para sa amin
upang makipag-usap tungkol sa mga partikular na ito.
Ngunit Hinihikayat ko kayo na tingnan marahil ang iba pang iOS seminar, kundi pati na rin ang ilang mga
ng tutorial online na gawin isang mas mas mahusay na trabaho ng naglalarawan
ang tiyak na impormasyon.
>> Ngunit maaari naming makita ang isang pares ng mga bagay na mga kagiliw-giliw na mula sa mga code dito.
Pansinin na kami kung ang mga pahayag.
Sa pamamagitan ng paraan, ang isang mahalagang bagay tungkol sa kung ang mga pahayag
ay na ang mga panaklong sa paligid ng Boolean expression ay opsyonal.
Ngunit ang curly braces ay hindi opsyonal, kahit gaano kaunti o maraming mga linya ng code
mayroon ka sa isang pahayag kung.
Hindi ka maaaring magkaroon ng isang kung pahayag walang curly braces sa Swift.
>> At ito ay, well, uri ng mga uto.
Ngunit mayroong mga makasaysayang dahilan para sa na.
Ito ay dapat na i-save mo mula sa iyong sarili.
Tulad nito, halimbawa, hindi mo maaaring maalis ang curly braces sa paligid na
kung pahayag.
Yaong ay sa katunayan kinakailangan.
Kaya Hinihikayat ko kayo na tingnan ang mga ito.
Ngunit may isa pang tayuan na gusto ko
upang ipakita sa iyo ang tungkol sa Swift na ay bago sa Swift 2.0 kung ihahambing
sa mga mas lumang mga bersyon ng Swift, na kung saan ay ang mga sumusunod.
Sabihin makita kung saan ito ilalagay ko dito?
>> Kaya sa function na tinatawag na fetchJSON, function na ito
ay responsable para sa paghila na JSON maghain mula sa isang URL, na lang kaya ang mangyayari
na tumatakbo sa aking CS50 IDE.
Ko lamang na nagsimula Apache, ilagay ang aking JSON file doon,
at ako makapag-pagkatapos ay hilahin na data mula sa internet gamit
mga function na ito at ang URL na ito, na kung saan ay ibinigay sa pamamagitan ng telepono.
Ito ay ibinigay sa pamamagitan ng isang library na gamitin mo kapag
ikaw ay gumagawa ng ilang mga pag-unlad iOS app.
>> Pansinin dito na ito sa hindi pangkaraniwang syntactical tayuan tinatawag bantay.
At talagang lahat ng ito ay nasa Swift ay isang paraan ng pag-verify
na ang ilang mga bagay na kailangan ito ay natutugunan bago ka
magpatuloy sa ang magpahinga ng ang function.
Kaya ako ay maaaring magkaroon, gamit ang opsyonal na uri,
Maaari ko nakita ang mga URL sa pamamagitan ng tumatakbo na ito NSURL function na
at pagtatago na sa isang URL pare-pareho, at pagkatapos ay suri
upang makita kung ang URL ay wala, dahil ito ay pagpunta upang bumalik ang isang opsyonal na uri.
At kung ito ay wala, pagkatapos ay gagawin ko i-print out ng isang error at pagkatapos ay bumalik.
>> Ngunit sa halip, kung ano ang nagbibigay-daan sa guard amin gawin ay tunay na bagay,
ngunit tiyakin na ito ay tunay na ang kaso na ang url
ito ay maayos na naka-set sa pamamagitan NSURL.
At kung ito ay, pagkatapos ito skips higit na ito, at ito
ay magpapahintulot sa inyo na magpatuloy sa url pagiging maayos na tinukoy.
Ngunit kung ito ay ang kaso na ang url ay hindi maayos na tinukoy,
kung ang function ay nagbabalik ng isang error o ilang iba pang hindi inaasahang bagay
tunay na nangyayari, ang guard tayuan ay nagbibigay-daan sa amin upang pagkatapos ay output na error
at bumalik agad.
Oo?
>> Madla: Kaya ito ay uri ng mga tulad ng isang kung pagkatapos ng iba pa?
DAN Armendariz: Ito ay uri ng tulad ng isang kung pagkatapos ng ibang tao, oo,
maliban na ang url na ito ay pagkatapos tinukoy para sa lahat ng bagay na ito sa ibaba.
Kung ito pumasa sa guard na ito, at pagkatapos na ito ay tunay na puno ng data
at kapaki-pakinabang sa mga natitirang source code sa iyong function.
Kaya ako maghinala na ikaw ay pagpunta sa simulan na makita ang guard na ito pati na rin.
At alintanahin na.
>> Kaya lamang ng pagtingin sa isang pares ng mga iba pang bagay na ito, ang karapatan na ito dito ay kung ano ang,
sa tingin ninyo, batay lamang sa kung ano ang bago namin ay pakikipag-usap tungkol sa?
>> Madla: Mag-isip ito ay tumakbo sa listahan?
>> DAN Armendariz: Kaya na close.
Ito ay isang function na tayo ay pagtukoy.
At kami ay inputting na function bilang isang argument sa function na ito dito.
>> Madla: [hindi marinig] kung hindi wala.
Kaya ito ay sa listahan, i-right?
>> DAN Armendariz: Kung error ay hindi kawalan, upang ang is-- kaya ko bang mag-scroll.
Well, tingnan natin, hindi talaga ko mag-scroll sa kanan dito.
error ay isang argument na ang pagiging lumipas na hindi kilalang function na ito.
Ito ay isang hindi nakikilalang function.
Ito ay walang pangalan.
Ngunit kami ay tumatanggap ng mga tatlong arguments, data, tugon, at error.
At ito ay pagpunta sa bumalik walang bisa, kaya hindi ito ay pagpunta upang bumalik sa anumang bagay.
At ito ay ang mga nilalaman ng na function.
At pagkatapos kami ay may access sa loob na function na sa bawat isa sa mga argumento.
>> Kaya ito ay isang whirlwind tour ng wika.
Ngunit Umaasa ako sa mga ito, sana habang kinukuha mo
tingnan ang ilan sa mga tutorial tiyak sa iOS-unlad sa Swift,
lalo na kung ikaw ay pupunta sa Web page-- developer Apple
sila ay may isang pulutong ng mga tunay mabuti tutorial upang makapagsimula ka.
Ngunit sana lang sa oras na ito ng pakikipag-usap tungkol sa syntax mismo ay nagbigay sa
ikaw ay sapat na upang makapagsimula na.
>> Magpo-post kami ng lahat ng mga ito ang pinagmulan code sa seminar website
sa lalong madaling panahon, at din ang mga slide kaya mayroon kang isang reference para sa lahat ng mga iyon.
Ngunit good luck sa iyong proyekto.
At salamat sa iyo ang lahat ng napaka para sa pagdating.
>> [Palakpakan]