1
00:00:00,000 --> 00:00:02,610
[Powered by Google Translate] [8. § - Több Kényelmes]

2
00:00:02,610 --> 00:00:04,910
[Rob Bowden - Harvard University]

3
00:00:04,910 --> 00:00:07,070
[Ez CS50. - CS50.TV]

4
00:00:11,520 --> 00:00:14,160
>> E hét pont jegyzetek lesz elég rövid,

5
00:00:14,160 --> 00:00:19,070
úgyhogy csak megy, hogy tartsa beszél, srácok megy folyamatosan kérdéseket,

6
00:00:19,070 --> 00:00:22,720
és mi megpróbáljuk töltse ki annyi időt, amennyire csak lehetséges.

7
00:00:22,720 --> 00:00:31,950
Sok ember úgy gondolja, hogy ez a Pset nem feltétlenül nehéz, de nagyon hosszú.

8
00:00:31,950 --> 00:00:37,070
A Pset spec maga vesz egy órát olvasni.

9
00:00:40,530 --> 00:00:45,730
Adunk egy csomó SQL amit esetleg kell használni.

10
00:00:45,730 --> 00:00:50,520
Mi végigvezeti Önt egy csomó, így ez nem lehet túl rossz.

11
00:00:50,520 --> 00:00:54,560
Valaki indításakor vagy kész?

12
00:00:55,380 --> 00:00:59,710
Ez az utolsó Pset. Ó, Istenem.

13
00:00:59,710 --> 00:01:05,400
Általában van egy JavaScript egymás után, de naptári változás a dolgok

14
00:01:05,400 --> 00:01:09,560
tesz mindent 1 hét rövidebb, és már nincs egy JavaScript Pset.

15
00:01:09,560 --> 00:01:12,310
Nem tudom, hogy ez hogyan befolyásolja, hogy a JavaScript fog megjelenni a vizsgán

16
00:01:12,310 --> 00:01:15,510
vagy Kvíz 1.

17
00:01:15,510 --> 00:01:22,260
El tudom képzelni, hogy valami olyasmi lesz, amit tudnod kell a magas szintű dolgokat JavaScript,

18
00:01:22,260 --> 00:01:26,460
de nem hiszem, hogy épp neked egyenesen JavaScript-kód

19
00:01:26,460 --> 00:01:28,720
mert nem volt Pset benne.

20
00:01:28,720 --> 00:01:33,000
De ez lesz a cucc a kvíz az értékelést a jövő héten.

21
00:01:33,000 --> 00:01:36,320
>> Szakasz kérdésekre.

22
00:01:36,320 --> 00:01:43,870
Sok ez a cucc kissé rosszul hangzik, de megbeszéljük miért.

23
00:01:43,870 --> 00:01:50,220
Ellentétben a C, PHP egy "dinamikusan-típusú" nyelv. Mit jelent ez, kérdezed?

24
00:01:50,220 --> 00:01:53,830
Nos, búcsút mindazok char, float, int, és sok más kulcsszavakat kell használni

25
00:01:53,830 --> 00:01:56,190
amikor kijelenti változók és függvények C.

26
00:01:56,190 --> 00:02:00,420
PHP-ben egy változó típusát határozza meg az értéket, amelyet ez jelenleg betöltő.

27
00:02:00,420 --> 00:02:04,990
Szóval mielőtt írja be ezt a kódot egy fájlba nevű dynamic.php,

28
00:02:04,990 --> 00:02:12,670
PHP dinamikusan gépelt. Ez igaz.

29
00:02:12,670 --> 00:02:17,590
Nem értek egyet azzal, hogy ez azt jelenti, hogy mondod búcsút char, float, int,

30
00:02:17,590 --> 00:02:20,620
és egyéb kulcsszavakkal.

31
00:02:20,620 --> 00:02:25,510
A pontos különbség dinamikusan tipizált, valamint az alternatív,

32
00:02:25,510 --> 00:02:32,010
amely statikusan gépelt, hogy dinamikusan beírt, az összes típusú ellenőrzés és a cucc

33
00:02:32,010 --> 00:02:37,350
történik futási időben, mivel statikusan gépelt történik fordítási időben.

34
00:02:37,350 --> 00:02:43,030
A szó statikus úgy tűnik, általában azt jelenti, fordításkor dolgokat.

35
00:02:43,030 --> 00:02:48,170
Azt hiszem, vannak más célokra szánt, de C-ben, amikor kijelenti egy statikus változó,

36
00:02:48,170 --> 00:02:52,650
tárolása osztottak ki fordítási időben.

37
00:02:52,650 --> 00:02:59,260
Itt dinamikusan gépelt csak azt jelenti, hogy -

38
00:02:59,260 --> 00:03:04,350
A C-ben ha megpróbál hozzáadni egy karakterlánc és egy egész, amikor fordítani,

39
00:03:04,350 --> 00:03:11,000
ez fog panaszkodni, mert ez fogja mondani, hogy nem lehet hozzáadni int, és a mutató.

40
00:03:11,000 --> 00:03:14,710
Ez csak nem egy érvényes művelet.

41
00:03:14,710 --> 00:03:21,170
Ez egy másik dolog, hogy mi lesz, hogy egy másodperc alatt.

42
00:03:21,170 --> 00:03:24,860
De ez a fajta ellenőrzés, a tény, hogy kifogásolja fordítási időben,

43
00:03:24,860 --> 00:03:29,220
statikus típusú ellenőrzés.

44
00:03:29,220 --> 00:03:35,220
Vannak olyan nyelvek, ahol nem kell mondani, char, float, int, és minden olyan dolog,

45
00:03:35,220 --> 00:03:40,940
de a nyelv meg tudja mondani az összefüggésben a dolog, milyen típusú kellene lennie,

46
00:03:40,940 --> 00:03:43,980
de ez még mindig statikusan beírt.

47
00:03:43,980 --> 00:03:49,000
Tehát, ha veszel 51, OCaml, soha nem kell használni minden ilyen típusú,

48
00:03:49,000 --> 00:03:58,700
de még mindig lesz fordítási időben mondani, ezt nem teheted, mert te összekeverjük egy int és string.

49
00:03:58,700 --> 00:04:05,650
Dinamikusan gépelt csak azt jelenti, hogy valamikor futási időben fogsz kapni a panaszt.

50
00:04:05,650 --> 00:04:13,430
Ha az is használt Java előtt, általában, csaknem bármilyen C-típusú nyelv

51
00:04:13,430 --> 00:04:20,070
lesz statikusan beírni, így a C, C + +, Java, az összes ilyen általában statikusan beírt.

52
00:04:20,070 --> 00:04:22,910
A Java amikor fordítod valamit, és azt mondod,

53
00:04:22,910 --> 00:04:26,670
s karakterlánc megegyezik az új valamit, ami nem egy string,

54
00:04:26,670 --> 00:04:28,950
hogy fog panaszkodni, mert az ilyen típusú, csak nem egyeznek meg.

55
00:04:28,950 --> 00:04:31,180
Ez fog panaszkodni fordítási időben.

56
00:04:31,180 --> 00:04:36,750
De ez is van néhány dinamikus idő dolgot, mint ha megpróbálod leadott valamit

57
00:04:36,750 --> 00:04:40,500
olyan típusú, ami pontosabb, mint a jelenlegi típus

58
00:04:40,500 --> 00:04:45,610
semmit sem tehet fordítási időben, hogy ellenőrizze, hogy a leadott fog sikerülni.

59
00:04:45,610 --> 00:04:51,130
Java is van néhány dinamikus típusú ellenőrzése, hogy amint lesz e kódsort

60
00:04:51,130 --> 00:04:54,130
amikor ez ténylegesen végrehajtó, ez fog csinálni a leadott

61
00:04:54,130 --> 00:04:56,260
ellenőrizze, hogy leadott érvényes volt az első helyen,

62
00:04:56,260 --> 00:04:59,890
és ha nem volt, akkor ez fog panaszkodni, hogy van egy érvénytelen típus.

63
00:04:59,890 --> 00:05:03,200
Dinamikus típusú ellenőrzés.

64
00:05:03,200 --> 00:05:07,010
Írja be ezt egy fájlba nevű dynamic.php.

65
00:05:10,130 --> 00:05:12,380
Dynamic.php.

66
00:05:14,580 --> 00:05:17,190
Én csomagolja, hogy a formázás.

67
00:05:18,750 --> 00:05:21,880
Van egy változó, akkor meg azt, hogy az egész 7,

68
00:05:21,880 --> 00:05:27,930
akkor fogunk nyomtatni, és% s -

69
00:05:27,930 --> 00:05:32,830
Oh, mi nyomtatás típusát, így gettype megy vissza típusa változó.

70
00:05:32,830 --> 00:05:35,720
Mi csak a nyomtatás típusát újra és újra.

71
00:05:35,720 --> 00:05:39,440
Csak php.dynamic.php.

72
00:05:39,440 --> 00:05:45,920
Majd meglátjuk, hogy a változások az integer string Boolean ahogy haladunk keresztül.

73
00:05:45,920 --> 00:05:54,590
A C-ben nincs logikai adat típus is van, nincs karaktersorozat adat típus.

74
00:05:54,590 --> 00:06:00,500
Van char * és logikai csak általában a int vagy char vagy ilyesmi.

75
00:06:00,500 --> 00:06:05,690
PHP-ben ilyen típusú léteznek, és ez az egyik nagy előnye a PHP feletti C -

76
00:06:05,690 --> 00:06:13,290
hogy a string műveletek végtelenül könnyebb PHP-ben, mint a C. Csak dolgozni.

77
00:06:13,290 --> 00:06:18,290
>> Szóval gyere vissza.

78
00:06:18,290 --> 00:06:21,260
Mi futott dynamic.php.

79
00:06:21,260 --> 00:06:26,710
Ez azt mondja a PHP interpreter nevű php, futtatni a PHP kódot dynamic.php.

80
00:06:26,710 --> 00:06:30,250
Ha bármilyen hiba a fájlban, a tolmács fogja mondani!

81
00:06:30,250 --> 00:06:39,110
A tolmács, ez is egy nagy különbség a PHP és a C.

82
00:06:39,110 --> 00:06:48,200
A C-ben meg kell fordítani valamit, majd futtatja azt lefordított fájlt.

83
00:06:48,200 --> 00:06:50,490
A PHP sosem összeállításához semmit.

84
00:06:50,490 --> 00:06:57,200
Tehát a PHP interpreter alapvetően csak olvassa ezt a sorról sorra.

85
00:06:57,200 --> 00:07:02,900
Az üt var = 7, akkor eléri printf akkor üt var majd eltalálja printf és így tovább.

86
00:07:02,900 --> 00:07:10,910
Van egy kis összeállításának csinál, és ez gyorsítja az eredmények

87
00:07:10,910 --> 00:07:15,510
így ha futtatod a szkriptet később meg tudod csinálni néhány,

88
00:07:15,510 --> 00:07:19,280
de alapvetően ez egy soronként ilyesmit.

89
00:07:19,280 --> 00:07:25,280
Ez azt jelenti, hogy sok az optimalizáció, hogy megkapjuk a C,

90
00:07:25,280 --> 00:07:31,920
mint a fordítás, csak általában a fordító tehet egy csomó trükköt az Ön számára.

91
00:07:31,920 --> 00:07:36,110
Ez vegye ki a fel nem használt változók, meg tudja csinálni az összes ilyen dolgot,

92
00:07:36,110 --> 00:07:38,660
meg tudja csinálni farok rekurziót.

93
00:07:38,660 --> 00:07:42,550
A PHP nem fogod, hogy ez az előny

94
00:07:42,550 --> 00:07:45,690
mert ez csak fog kezdeni végrehajtó sorról soronként,

95
00:07:45,690 --> 00:07:49,950
és ez nem igazán ismeri ezeket a dolgokat, mint egyszerűen

96
00:07:49,950 --> 00:07:54,440
mivel ez nem 1 big válogatás át át a dolog, és akkor a végrehajtás;

97
00:07:54,440 --> 00:07:56,860
ez csak soronként.

98
00:08:00,730 --> 00:08:02,750
Szóval ez a tolmács.

99
00:08:02,750 --> 00:08:06,840
>> Vissza a dinamikus gépelési: elég jó, mi?

100
00:08:06,840 --> 00:08:08,640
Te biztosan nem tehette, hogy a C!

101
00:08:08,640 --> 00:08:11,860
Most nézd meg, hogy kitaláljuk, milyen típusú az egyes következő értékek.

102
00:08:11,860 --> 00:08:14,760
Lásd ezt a referencia.

103
00:08:14,760 --> 00:08:19,420
Tehát 3.50. Milyen nem úgy gondolja, hogy ez lesz?

104
00:08:24,480 --> 00:08:26,370
Itt vannak a típusok, amink van.

105
00:08:26,370 --> 00:08:30,430
Van bools, egészek, úszó pontok, vonósok, tömbök, objektumok,

106
00:08:30,430 --> 00:08:38,370
majd a források, ami elég homályos.

107
00:08:38,370 --> 00:08:41,010
Azt hiszem, valójában egy példa itt.

108
00:08:41,010 --> 00:08:43,740
Aztán ott van a NULL. NULL egy speciális típusa.

109
00:08:43,740 --> 00:08:47,140
Ellentétben C ahol NULL csak egy mutató a cím 0,

110
00:08:47,140 --> 00:08:54,930
PHP, NULL saját magát írja, ahol az egyetlen érvényes dolog, az ilyen típusú NULL.

111
00:08:57,560 --> 00:09:00,670
Ez sokkal több hasznos hibaellenőrzés.

112
00:09:00,670 --> 00:09:04,310
A C-ben, ahol volt ez a kérdés, ahol, ha visszatér NULL,

113
00:09:04,310 --> 00:09:08,660
ez azt jelenti, hogy te vissza a NULL pointer vagy használja NULL, jelezve hiba

114
00:09:08,660 --> 00:09:12,380
vagy az összes, hogy zavar volt egy ponton.

115
00:09:12,380 --> 00:09:18,440
Itt vissza NULL általában azt jelenti, hiba.

116
00:09:20,860 --> 00:09:27,300
Egy csomó dolgot is visszatér hamis hiba.

117
00:09:27,300 --> 00:09:33,140
De a lényeg a NULL típus, az egyetlen dolog, amit a NULL típus NULL.

118
00:09:33,140 --> 00:09:40,090
Akkor visszahívási olyan, mint megadhatjuk néhány anonim függvények.

119
00:09:40,090 --> 00:09:46,420
Nem kell, hogy a függvény nevét, de akkor nem kell foglalkozni, hogy itt.

120
00:09:46,420 --> 00:09:53,940
Keresi a típusokat, hogy azok várják tőlünk, hogy tudjuk,

121
00:09:53,940 --> 00:09:59,000
Mit gondolsz, hogy milyen típusú 3,50 van? >> [Hallgató] Float.

122
00:09:59,000 --> 00:10:00,370
Igen.

123
00:10:00,370 --> 00:10:06,290
Tehát itt, mit gondolsz milyen ez? >> [Hallgató] Array.

124
00:10:06,290 --> 00:10:09,890
Igen. Az első volt az úszó, a második egy tömb.

125
00:10:09,890 --> 00:10:14,500
Vegyük észre, hogy ez a tömb nem olyan, mint a C tömb

126
00:10:14,500 --> 00:10:19,610
ahol van index 0-nak valamilyen érték, index 1-nek némi értéke.

127
00:10:19,610 --> 00:10:26,320
Itt az indexek a, b, és c és az értékeket az 1., 2., és 3.

128
00:10:26,320 --> 00:10:33,980
PHP-ben nincs különbség egy asszociatív tömböt, és csak a rendszeres array

129
00:10:33,980 --> 00:10:36,740
ahogy azt gondolni, hogy a C

130
00:10:36,740 --> 00:10:43,040
Már csak ez, és a motorháztető alatt a rendszeres tömb csak egy asszociatív tömbben

131
00:10:43,040 --> 00:10:50,000
ahol 0 térképeket valamilyen érték azonos módon a térképek bizonyos értéket.

132
00:10:50,000 --> 00:11:00,410
Emiatt a PHP elég rossz nagyon gyorsan kód / benchmarking dolgok

133
00:11:00,410 --> 00:11:07,930
mivel a C, ha a 'használ egy tömböt tudja, hogy elérésekor tag konstans idő.

134
00:11:07,930 --> 00:11:11,860
A PHP elérése egy tag, aki tudja, mennyi idő?

135
00:11:11,860 --> 00:11:18,970
Ez valószínűleg állandó, ha kivonatok helyesen.

136
00:11:18,970 --> 00:11:21,620
Ki tudja, mi ez valójában csinál a motorháztető alatt?

137
00:11:21,620 --> 00:11:25,600
Tényleg meg kell nézni a végrehajtás, hogy hogyan is fog foglalkozni.

138
00:11:25,600 --> 00:11:28,550
Akkor fopen.

139
00:11:28,550 --> 00:11:36,420
Azt hiszem, itt most csak a PHP kézikönyv fopen hogy nézd meg a visszatérési típus.

140
00:11:36,420 --> 00:11:41,260
Látunk itt lehet keresni elég sok minden funkciót a PHP kézikönyv

141
00:11:41,260 --> 00:11:47,540
és ez a fajta a man oldalt a PHP.

142
00:11:47,540 --> 00:11:51,060
A visszatérési típus lesz forrás.

143
00:11:51,060 --> 00:11:56,050
Ezért kerestem fel, mert nem igazán határozza erőforrás.

144
00:11:56,050 --> 00:12:04,110
Az ötlet, hogy erőforrás a C akkor milyen van egy FILE * vagy bármi;

145
00:12:04,110 --> 00:12:07,200
A PHP az erőforrás a FILE *.

146
00:12:07,200 --> 00:12:10,360
Ez az, amit akarsz, hogy olvasása, ez az, amit akarsz, hogy írásban.

147
00:12:10,360 --> 00:12:20,710
Ez általában a külső, így ez az erőforrás tudja húzni a dolgokat, és dobja a dolgokat.

148
00:12:20,710 --> 00:12:26,520
És végül, mi a típusa NULL? >> [Hallgató] NULL.

149
00:12:26,520 --> 00:12:30,650
Igen. Így az egyetlen dolog, ami NULL NULL.

150
00:12:30,650 --> 00:12:33,480
NULL NULL.

151
00:12:35,490 --> 00:12:41,170
>> Egyik jellemzője a PHP-féle rendszer (jobb vagy rosszabb), hogy képes zsonglőrködik típusok.

152
00:12:41,170 --> 00:12:44,390
Ha írsz egy sor PHP kód, amely egyesíti értékeket különböző típusú,

153
00:12:44,390 --> 00:12:46,670
PHP megpróbálja csinálni a értelmes dolog.

154
00:12:46,670 --> 00:12:48,920
Próbálja ki mindegyik az alábbi sorokat a PHP kódot. Mi kinyomtatják?

155
00:12:48,920 --> 00:12:51,000
Van-e, amit várt? Miért vagy miért nem?

156
00:12:51,000 --> 00:12:58,600
Ez a tény a PHP-ről az, ami hívjuk gyengén típusos.

157
00:12:58,600 --> 00:13:04,610
Gyengén beírt és határozottan gépelt,

158
00:13:04,610 --> 00:13:06,840
vannak különböző felhasználások esetében ezeket a kifejezéseket,

159
00:13:06,840 --> 00:13:12,020
de a legtöbb ember használja gyengén gépelt és határozottan gépelt jelenti ilyesmit

160
00:13:12,020 --> 00:13:15,920
ahol ("1" + 2), ami működik.

161
00:13:15,920 --> 00:13:18,290
A C-ben, hogy nem fog működni.

162
00:13:18,290 --> 00:13:22,490
El lehet képzelni, ez nem működik.

163
00:13:22,490 --> 00:13:29,200
Egy csomó ember keveredik dinamikus tipizálást és gyenge tipizálása és statikus tipizálása és erős gépelni.

164
00:13:29,200 --> 00:13:34,050
Python egy másik példa egy nyelvet, ami dinamikusan gépelt.

165
00:13:34,050 --> 00:13:41,770
Akkor dobja körül típus változók, és ez fogja meghatározni, futási időben

166
00:13:41,770 --> 00:13:44,680
bármilyen hiba checkings.

167
00:13:44,680 --> 00:13:50,740
A Python ez fog végrehajtani ezt, és azt fogja látni ("1" + 2);

168
00:13:50,740 --> 00:13:55,920
és ez nem fog sikerülni, mert azt mondja, nem adhat hozzá egy karakterlánc és egy egész.

169
00:13:55,920 --> 00:14:00,860
A PHP-ben, ami ugyanolyan dinamikusan gépelt, ez nem sikerül.

170
00:14:00,860 --> 00:14:04,220
Gyenge gépelés köze van a tény, hogy ez a dolgok típusai

171
00:14:04,220 --> 00:14:07,800
hogy nem igazán értelme feltétlenül.

172
00:14:07,800 --> 00:14:17,420
Tehát ("1" + 2), el tudom képzelni, hogy mivel a húr 12, el tudom képzelni azt, hogy a húr 3,

173
00:14:17,420 --> 00:14:20,710
El tudom képzelni azt, hogy az egész 3.

174
00:14:20,710 --> 00:14:24,530
Ez nem feltétlenül jól meghatározott, és mi valószínűleg fog itt látni

175
00:14:24,530 --> 00:14:29,140
hogy amikor nyomtatni ("1" + 2), ez valószínűleg a végén, hogy a különböző

176
00:14:29,140 --> 00:14:32,320
mint a nyomtatás (1 + "2").

177
00:14:32,320 --> 00:14:39,700
És ez általában lenni, véleményem szerint, az még rosszabb.

178
00:14:39,700 --> 00:14:44,240
Itt lehet próbálni ezeket.

179
00:14:44,240 --> 00:14:48,740
Egy másik kis trükk a PHP-ről van akkor nem kell, hogy ténylegesen írni a fájlt.

180
00:14:48,740 --> 00:14:52,790
Ez nem volna futtatni ezt a parancs módba.

181
00:14:52,790 --> 00:14:57,710
Tehát php-r, akkor mi is dobja a parancsban itt:

182
00:14:57,710 --> 00:15:06,610
"Print ('1 '+ 2)," és én dobja az új vonal.

183
00:15:19,550 --> 00:15:23,970
A nyomtatott 3.

184
00:15:31,100 --> 00:15:35,330
Úgy néz ki, hogy kinyomtatja 3 és ez az egész 3.

185
00:15:35,330 --> 00:15:38,420
És most nézzük meg a másik fordítva:

186
00:15:38,420 --> 00:15:42,970
"Print (1 + '2 ');

187
00:15:45,560 --> 00:15:50,490
Kapunk 3, és az is lesz egész 3? Őszintén szólva fogalmam sincs.

188
00:15:50,490 --> 00:15:54,030
Úgy néz ki, hogy az összhangban.

189
00:15:54,030 --> 00:15:59,550
Soha nincs semmi esély rá, hogy a húr 12 vagy ilyesmi

190
00:15:59,550 --> 00:16:08,080
mert a PHP ellentétben JavaScript és a Java is,

191
00:16:08,080 --> 00:16:11,670
külön üzemeltető összefűzésben.

192
00:16:11,670 --> 00:16:14,930
Összefűzése a PHP-ben dot.

193
00:16:14,930 --> 00:16:22,950
Szóval nyomtatás (1. '2 '); Fog adni nekünk 12.

194
00:16:25,790 --> 00:16:32,420
Ez általában zavart okozhat, ahol az emberek megpróbálják ilyet str + =

195
00:16:32,420 --> 00:16:37,840
néhány más dolog, hogy szeretnénk hozzáadni a végéig a string, és ez nem megy.

196
00:16:37,840 --> 00:16:40,770
Annyit kell tennie, str. =

197
00:16:42,000 --> 00:16:46,240
Tehát ne felejtsd el összefűzése a PHP egy pont.

198
00:16:46,240 --> 00:16:52,100
Más dolog, hogy megpróbálja: print ("CS" + 50);

199
00:16:55,750 --> 00:17:03,610
Mondtam már, hogy nincs remény e eredményező CS50

200
00:17:03,610 --> 00:17:06,119
mivel összefűzése nem +.

201
00:17:06,119 --> 00:17:08,440
Mit gondolsz, ez lesz a végén, hogy?

202
00:17:10,359 --> 00:17:13,460
Őszintén szólva fogalmam sincs.

203
00:17:14,250 --> 00:17:16,460
Úgy néz ki, hogy csak 50.

204
00:17:16,460 --> 00:17:21,490
Úgy látja, a húr, és fogadok, ha teszünk 123CS -

205
00:17:21,490 --> 00:17:29,640
Úgy látja, az első string, megpróbálja elolvasni egy egész szám, vagy egy számot is.

206
00:17:29,640 --> 00:17:31,710
Ebben az esetben ez látja 123CS.

207
00:17:31,710 --> 00:17:35,190
"Ez nincs értelme, mint egy egész, úgyhogy csak fog gondolni 123."

208
00:17:35,190 --> 00:17:38,580
Tehát 123 + 50 lesz 173.

209
00:17:38,580 --> 00:17:40,740
És itt kezdődik olvasod ezt, mint egy egész.

210
00:17:40,740 --> 00:17:45,690
Nem látok semmit, úgyhogy ez csak úgy kezeli, mint 0-ra. Szóval 0 + 50 lesz 50.

211
00:17:45,690 --> 00:17:51,600
Ez én vagyok, feltéve fog csinálni valami hasonlót.

212
00:17:51,600 --> 00:17:54,310
Gondolkodom 99.

213
00:17:54,310 --> 00:17:57,580
Igen, mert ez fog tartani az első -

214
00:18:12,880 --> 00:18:15,730
Tehát 99.

215
00:18:15,730 --> 00:18:21,970
Itt (10/7), ha ez a C, mi lenne, hogy vissza?

216
00:18:23,700 --> 00:18:29,630
[Hallgató] 1. >> Igen, lenne, mert 10 1/7 elosztják 2 egész számok.

217
00:18:29,630 --> 00:18:32,910
Egy egész osztva egy egész megy vissza egy egész szám.

218
00:18:32,910 --> 00:18:37,750
Ez nem térhet vissza 1 pont bármi lenne, szóval ez csak megy vissza 1.

219
00:18:37,750 --> 00:18:46,120
Itt nyomtatás (10/7), ez lesz a ténylegesen értelmezni azt.

220
00:18:46,120 --> 00:18:53,760
És ez azt jelenti, hogy ha valóban szeretne csinálni egész kerekítés és ilyesmi,

221
00:18:53,760 --> 00:18:59,950
annyit kell tennie, print (padló (10/7));

222
00:18:59,950 --> 00:19:08,460
A C-ben ez talán furcsa, hogy tud támaszkodni egész csonkolási rendszeresen,

223
00:19:08,460 --> 00:19:12,260
de a PHP nem tudja, mert akkor automatikusan kapcsolja be a float.

224
00:19:13,430 --> 00:19:17,610
És akkor (7 + true); mit gondolsz, hogy lesz?

225
00:19:18,550 --> 00:19:23,640
Azt hiszem 8 ha ez fog értelmezni igaz már 1.

226
00:19:23,640 --> 00:19:25,740
Úgy néz ki, ez 8.

227
00:19:25,740 --> 00:19:31,710
>> Tehát bármit tettünk az elmúlt 10 perc alatt kell teljesen sohasem.

228
00:19:31,710 --> 00:19:39,870
Látni fogja, kód, amely nem ezt.

229
00:19:39,870 --> 00:19:42,700
Nem kell, hogy mivel egyszerű, mint ez.

230
00:19:42,700 --> 00:19:47,240
Lehet, hogy 2 változó, és 1 változó előfordul, hogy egy string

231
00:19:47,240 --> 00:19:51,310
és a többi változó történik, hogy egy int, majd adja hozzá ezeket a változókat együtt.

232
00:19:51,310 --> 00:20:00,120
Mivel a PHP dinamikusan gépelt és ez nem fog semmiféle ellenőrzés az Ön számára

233
00:20:00,120 --> 00:20:03,640
és mivel ez gyengén begépelt, és mivel akkor csak automatikusan dobja ezeket a dolgokat együtt

234
00:20:03,640 --> 00:20:11,490
és minden menni fog, nehéz is tudja, hogy ezt a változót kell lennie húr most,

235
00:20:11,490 --> 00:20:14,930
így nem kell hozzá, hogy ezt a változót, amely egy egész szám.

236
00:20:18,780 --> 00:20:24,560
A legjobb gyakorlat, ha a változó egy string, tartsa, mint egy húr örökre.

237
00:20:24,560 --> 00:20:26,980
Ha egy változó int, tartsa meg, mint egy int örökre.

238
00:20:26,980 --> 00:20:30,770
Ha szeretne foglalkozni egész és vonósok,

239
00:20:30,770 --> 00:20:36,970
tudod használni varsint - ez a JavaScript programot.

240
00:20:36,970 --> 00:20:42,520
Intval. Én ezt minden alkalommal. PHP és JavaScript én keverjük össze mindent.

241
00:20:42,520 --> 00:20:47,600
Szóval intval megy vissza integer értéke változó.

242
00:20:47,600 --> 00:20:56,550
Ha átmegyünk a "print (intval ('123 ')); kapsz 123.

243
00:21:06,820 --> 00:21:15,850
Intval önmagában nem fog csinálni az ellenőrzés számunkra, hogy ez kizárólag az egész.

244
00:21:15,850 --> 00:21:20,460
A PHP kézikönyv, már csak annyi funkciók,

245
00:21:20,460 --> 00:21:26,560
ezért itt azt hiszem, amit én használni az is_numeric először.

246
00:21:26,560 --> 00:21:32,590
Azt hiszem, hogy a visszaadott hamis.

247
00:21:32,590 --> 00:21:35,780
Ez a másik dolog, amit meg kell, hogy menjen át a ===.

248
00:21:37,850 --> 00:21:44,020
Szóval is_numeric ('123df "), akkor nem hiszem, hogy mivel is_numeric.

249
00:21:44,020 --> 00:21:46,720
A C-ben meg kellett volna navigálhat az összes karaktert

250
00:21:46,720 --> 00:21:50,410
, és ellenőrizze, hogy minden egyes karakter számjegy, vagy bármi.

251
00:21:50,410 --> 00:21:53,850
Itt is_numeric fog tenni, hogy nekünk,

252
00:21:53,850 --> 00:21:56,520
és ez visszatérő hamis.

253
00:21:56,520 --> 00:22:02,120
Szóval mikor nyomtatva, hogy nem nyomtatott semmit, úgyhogy itt vagyok összehasonlítva látni,

254
00:22:02,120 --> 00:22:05,490
tudtad történetesen hamis? És így most már nyomtatás 1.

255
00:22:05,490 --> 00:22:10,060
Úgy látszik, hogy kiírja az 1. tényleges nyomtatás helyett igaz, igaz.

256
00:22:10,060 --> 00:22:15,790
Kíváncsi vagyok, ha én print_r. Nem, még mindig nem 1.

257
00:22:15,790 --> 00:22:26,760
>> Visszatérve ===, == továbbra is fennáll,

258
00:22:26,760 --> 00:22:32,260
és ha beszélni Tommy fog mondani == tökéletesen rendben van.

259
00:22:32,260 --> 00:22:37,700
Fogom mondani, hogy == rettenetes, és soha ne használjon ==.

260
00:22:37,700 --> 00:22:44,870
A különbség az, hogy a == hasonlítja dolgok

261
00:22:44,870 --> 00:22:48,450
ahol lehet igaz, ha ők nem ugyanolyan típusúak,

262
00:22:48,450 --> 00:22:53,810
mivel === összehasonlítja a dolgokat, és az első, hogy az ellenőrzések, hogy az azonos típusú?

263
00:22:53,810 --> 00:22:58,010
Igen. Oké, most megyek, hogy ha ténylegesen összehasonlítani egyenlő.

264
00:22:58,010 --> 00:23:08,890
Kapsz furcsa dolgokat, mint 10 megfelel - Lássuk, hogy mit mond.

265
00:23:08,890 --> 00:23:15,570
Tehát ('10 '== '1 e1');

266
00:23:15,570 --> 00:23:17,980
Ezzel visszatér igaz.

267
00:23:17,980 --> 00:23:21,420
Van valakinek találgatások, hogy ez miért ad vissza igaz?

268
00:23:25,180 --> 00:23:27,120
Ez nem csak arról. Talán ez a tipp.

269
00:23:27,120 --> 00:23:33,170
De ha tudom megváltoztatni, hogy az egy f - a fenébe is! Folyton dupla idézőjeleket.

270
00:23:33,170 --> 00:23:38,780
Az ok a dupla idézőjel kiabál velem, mert én már be ezt idézőjelek.

271
00:23:38,780 --> 00:23:43,850
Így tudtam menekülni a dupla idézőjel itt, de aposztrófot könnyebb.

272
00:23:43,850 --> 00:23:49,120
Tehát ('10 '== '1 f1'); nem nyomtat igaz. ('10 '== '1 E1'); kinyomtatja igaz.

273
00:23:49,120 --> 00:23:56,330
[Hallgató] Ez hex? >> Ez nem hex, de közel van, hogy ez olyan, mint -

274
00:23:56,330 --> 00:24:01,060
1E1, tudományos jelöléssel.

275
00:24:01,060 --> 00:24:07,950
Elismeri 1E1 már 1 * 10 ^ 1 vagy bármi.

276
00:24:07,950 --> 00:24:11,510
Azok egyenlő egészek.

277
00:24:11,510 --> 00:24:15,930
Ha így teszünk === akkor lesz hamis.

278
00:24:15,930 --> 00:24:28,490
Igazából fogalmam sincs, ha nem teszünk == mi a helyzet (10 és '10abc ');? Rendben van. Szóval ez igaz.

279
00:24:28,490 --> 00:24:35,940
Szóval, mint amikor te (10 + '10abc '), és lenne 20,

280
00:24:35,940 --> 00:24:38,800
itt (10 == '10abc '); igaz.

281
00:24:38,800 --> 00:24:45,350
Még rosszabb a dolgok, mint a (hamis == NULL); igaz

282
00:24:45,350 --> 00:24:52,210
vagy (false == 0); igaz, (false == []);

283
00:24:52,210 --> 00:25:00,970
Vannak furcsa esetek - Ez egyike azoknak a furcsa eseteket.

284
00:25:00,970 --> 00:25:08,110
Figyeljük meg, hogy (false == []); igaz.

285
00:25:08,110 --> 00:25:11,950
(0 "== false); igaz.

286
00:25:11,950 --> 00:25:16,090
('0 '== []); Hamis.

287
00:25:16,090 --> 00:25:19,090
So == egyáltalán nem tranzitív.

288
00:25:19,090 --> 00:25:26,830
egy koncentráció megegyezhet a b és egy lehet egyenlő a C,

289
00:25:26,830 --> 00:25:29,340
de b nem feltétlenül egyenlő a c.

290
00:25:29,340 --> 00:25:35,580
Ez egy utálatos nekem, és akkor mindig ===.

291
00:25:35,580 --> 00:25:38,590
[Hallgató] Meg tudjuk csinálni! == Is? >> [Bowden] Igen.

292
00:25:38,590 --> 00:25:44,600
Az egyenértékű lenne! = És! ==.

293
00:25:44,600 --> 00:25:48,230
Ez tulajdonképpen hozta fel a Pset spec

294
00:25:48,230 --> 00:25:52,000
ahol sok a funkciók return -

295
00:25:52,000 --> 00:25:53,890
A PHP kézikönyv jó erről.

296
00:25:53,890 --> 00:25:59,140
Ez hoz egy nagy piros négyzet, "Ez lesz return false, ha van egy hiba."

297
00:25:59,140 --> 00:26:03,940
De visszatérve 0 egy tökéletesen ésszerű dolog, hogy visszatérjen.

298
00:26:03,940 --> 00:26:08,250
Gondolj olyan függvény, amely várhatóan visszatér egész.

299
00:26:11,250 --> 00:26:17,880
Tegyük fel, hogy ezt a funkciót kellene számolni a sorok száma a fájl, vagy ilyesmi.

300
00:26:17,880 --> 00:26:23,490
Normális körülmények között, ha át ezt a funkciót egy fájl

301
00:26:23,490 --> 00:26:27,120
és ez megy vissza integer amely a sorok száma.

302
00:26:27,120 --> 00:26:30,820
Szóval 0 egy tökéletesen elfogadható számot, ha a fájl csak üres.

303
00:26:30,820 --> 00:26:36,810
De mi van, ha át is érvénytelen fájlt, és a függvény történik return false

304
00:26:36,810 --> 00:26:38,860
ha át is érvénytelen fájlt?

305
00:26:38,860 --> 00:26:46,500
Ha csak ezt == te nem különbséget az ügy között érvénytelen fájl és üres fájlt.

306
00:26:48,870 --> 00:26:51,350
Mindig ===.

307
00:26:55,690 --> 00:26:58,000
Ez az összes ilyen.

308
00:26:58,000 --> 00:27:01,660
>> A PHP, a tömb típus eltér amit használt a C

309
00:27:01,660 --> 00:27:06,650
Sőt, lehet, hogy már észre ezt a fent említett, amikor látta, hogy ez a típusú tömb.

310
00:27:06,650 --> 00:27:15,640
A konzol szintaxisa új, a PHP 5.4, amely a legújabb verziója PHP.

311
00:27:15,640 --> 00:27:36,960
Mielőtt ez mindig kellett írni array ("a" -> 1, 'b' -> 2.

312
00:27:36,960 --> 00:27:41,160
Ez volt a kivitelező egy tömb.

313
00:27:41,160 --> 00:27:45,950
Most PHP végre magához tér a szép szintaxisa csak szögletes zárójelben

314
00:27:45,950 --> 00:27:50,900
ami csak sokkal jobb, mint tömb.

315
00:27:50,900 --> 00:27:54,480
De figyelembe véve PHP 5,4 a legújabb verzió,

316
00:27:54,480 --> 00:27:59,090
akkor találkozhat helyeket, még csak nem is a PHP 5.3.

317
00:27:59,090 --> 00:28:08,220
Az elmúlt nyár folyamán futott be ezt a kérdést, ha PHP-ben 5,3 volt, mi volt a készülék,

318
00:28:08,220 --> 00:28:14,480
de a szerver, hogy mi telepített minden fokozat könyvet, és küldje el, és minden ilyesmi, hogy

319
00:28:14,480 --> 00:28:16,750
volt a PHP 5.4.

320
00:28:16,750 --> 00:28:23,060
Nem tudta ezt, kifejlesztett 5,3, tolt 5,4,

321
00:28:23,060 --> 00:28:25,660
és most hirtelen egyetlen kódunkat munkák

322
00:28:25,660 --> 00:28:28,680
mert ott történt volna változás között 5,3 és 5,4

323
00:28:28,680 --> 00:28:31,030
amelyek nem kompatibilisek,

324
00:28:31,030 --> 00:28:35,770
és mi kell menni és erősít minden kedves dolog, hogy nem működik a PHP 5.4.

325
00:28:39,210 --> 00:28:42,320
Mert ez az osztály, mert a készülék rendelkezik PHP 5,4,

326
00:28:42,320 --> 00:28:45,490
ez tökéletesen használható szögletes zárójelben.

327
00:28:47,240 --> 00:28:50,440
De ha keresi fel a dolgokat az interneten,

328
00:28:50,440 --> 00:28:54,880
ha keres valamiféle array cucc, valószínűleg fogsz látni

329
00:28:54,880 --> 00:29:02,020
a varázslat out tömb kivitelező szintaxis ettől ez már körül, mivel a PHP-ben született

330
00:29:02,020 --> 00:29:07,340
és szögletes zárójeles formával már körül az elmúlt pár hónapban

331
00:29:07,340 --> 00:29:10,020
vagy amikor 5,4 jött körül.

332
00:29:10,020 --> 00:29:12,710
Ez hogyan index.

333
00:29:12,710 --> 00:29:30,610
Csakúgy, mint a C, hogyan lenne index szögletes zárójelek $ array [0], $ array [1], $ array [2],

334
00:29:30,610 --> 00:29:36,320
Ön index ugyanúgy, ha véletlenül az indexek, hogy szálakat.

335
00:29:36,320 --> 00:29:40,440
Tehát $ array ['a'] és a $ array ['b'].

336
00:29:40,440 --> 00:29:47,410
$ Array [b]. Miért lenne ez baj?

337
00:29:52,490 --> 00:29:59,870
Ez valószínűleg létrehoz egy figyelmeztetést, de még mindig működik. PHP hajlamos erre.

338
00:29:59,870 --> 00:30:04,890
Úgy látszik, hogy csak a "fogok figyelmezteti Önt erről, de én csak megy, hogy megy

339
00:30:04,890 --> 00:30:07,550
", És tegyenek meg mindent tudok."

340
00:30:07,550 --> 00:30:11,500
Ez valószínűleg lefordítani, hogy ez egy string,

341
00:30:11,500 --> 00:30:15,000
de az is lehetséges, hogy egy bizonyos ponton a múltban valaki említett

342
00:30:15,000 --> 00:30:20,180
define b, hogy "Hello World".

343
00:30:20,180 --> 00:30:28,740
Tehát most b lehet állandó és $ array [b] ténylegesen csinál "Hello World".

344
00:30:28,740 --> 00:30:32,380
Azt hiszem, ezen a ponton, vagy legalábbis a PHP beállításait,

345
00:30:32,380 --> 00:30:37,870
ha megpróbál index egy tömb, és hogy a kulcs nem létezik, akkor nem fog sikerülni.

346
00:30:37,870 --> 00:30:40,150
Nem hiszem, hogy ez csak figyelmezteti Önt.

347
00:30:40,150 --> 00:30:44,560
Vagy legalábbis lehet beállítani úgy, hogy nem csak figyelmezteti Önt, csak egyenesen felfelé sikertelen.

348
00:30:44,560 --> 00:30:49,290
>> Az út, hogy ellenőrizze, hogy van valójában egy ilyen index isset.

349
00:30:49,290 --> 00:30:54,690
Szóval isset ($ array ['Hello World']) visszatér hamis.

350
00:30:54,690 --> 00:30:59,160
isset ($ array ['b']) tér vissza igaz.

351
00:31:06,830 --> 00:31:09,880
Akkor keverjük ezeket a szintaxist.

352
00:31:15,060 --> 00:31:22,440
Biztos vagyok benne, hogy ez mit tömb lenne a végén, hogy van - tudjuk tesztelni azt.

353
00:31:43,290 --> 00:31:45,700
Ó, szükségem van PHPWord.

354
00:31:53,960 --> 00:32:00,260
Ezt összekeverjük a szintaxist, ahol megadhatja, mi a kulcs

355
00:32:00,260 --> 00:32:03,330
és nem határozza meg, mi a kulcs.

356
00:32:03,330 --> 00:32:05,520
So 3 itt van egy érték.

357
00:32:05,520 --> 00:32:08,080
Nem kifejezetten azt mondta, hogy mi a legfontosabb lesz.

358
00:32:08,080 --> 00:32:11,670
Mit gondolsz, a legfontosabb lesz?

359
00:32:11,670 --> 00:32:21,410
[Hallgató] 0. >> Gondolom 0 csak azért, mert ez az első, amit nem meghatározott.

360
00:32:21,410 --> 00:32:23,500
Mi lehet ténylegesen egy pár ilyen esetekben.

361
00:32:23,500 --> 00:32:28,030
Szóval print_r a nyomtatás rekurzív. Ez kiírja a teljes tömb.

362
00:32:28,030 --> 00:32:32,700
Ez kinyomtatni subarrays a tömb ha voltak ilyenek.

363
00:32:32,700 --> 00:32:36,630
Szóval print_r ($ array); php.test.php.

364
00:32:36,630 --> 00:32:38,810
Úgy néz ki, mint azt adta 0.

365
00:32:38,810 --> 00:32:43,530
Van valóban valami, hogy tartsa szem előtt van, de mi lesz vissza, hogy a második.

366
00:32:43,530 --> 00:32:45,850
De mi van, ha történik, hogy ez a mutató 1?

367
00:32:45,850 --> 00:32:51,170
PHP nem tesz különbséget a string indexeket és egész indexek,

368
00:32:51,170 --> 00:33:00,280
így ezen a ponton én már csak egy meghatározott index 1 és meg tudom csinálni mind $ array [1] és $ array ['1 ']

369
00:33:00,280 --> 00:33:06,250
és ez lesz az azonos index és ugyanazt a kulcsot.

370
00:33:06,250 --> 00:33:13,000
Tehát most mit gondolsz 3 lesz? >> [Hallgató] 2. >> [Bowden] Gondolom 2.

371
00:33:16,000 --> 00:33:18,690
Igen. Ez 2.

372
00:33:18,690 --> 00:33:24,790
Mi lenne, ha ezt tette a 10, ez a 4? Mit gondolsz az index a 3 lesz?

373
00:33:27,360 --> 00:33:29,110
Gondolkodom 11.

374
00:33:29,110 --> 00:33:33,060
Az a gyanúm, hogy milyen PHP csinál -, és azt hiszem, már láttam ilyet -

375
00:33:33,060 --> 00:33:39,760
Ez csak számon tartja, hogy mi a legnagyobb numerikus index ez eddig alkalmazott van.

376
00:33:39,760 --> 00:33:44,230
Ez soha nem fog rendelni egy string index 3-ra. Ez mindig egy numerikus index.

377
00:33:44,230 --> 00:33:47,690
Így nyomon követi a legmagasabb ez rendelt eddig, ami történetesen 10,

378
00:33:47,690 --> 00:33:52,540
és ez megy, hogy 11-3.

379
00:33:52,540 --> 00:34:02,110
Amit korábban mondtam, észre így is nyomtat ezt a tömböt.

380
00:34:02,110 --> 00:34:06,850
Ez nyomtat gomb 10, gombot 4, 11 billentyű, gombot d.

381
00:34:06,850 --> 00:34:09,790
Vagy még csináljuk -

382
00:34:15,760 --> 00:34:22,489
Azt hiszem, nem terjesztett a 0, de ez Nyomtatásra 1, 2, 3, 4.

383
00:34:22,489 --> 00:34:29,330
Mit tegyek, ha váltani itt? Vagy nézzük valóban váltani ezeket a 2.

384
00:34:29,330 --> 00:34:31,940
Most a nyomtatás 2, 1, 3, 4.

385
00:34:31,940 --> 00:34:41,270
PHP tömbök nem csak, mint a szokásos hash táblát.

386
00:34:41,270 --> 00:34:45,570
Ez teljesen ésszerű azt gondolni rájuk, mint hash táblák 99%-át az időt.

387
00:34:45,570 --> 00:34:53,790
De a hash táblák nincs értelme a sorrendet, amelyben a dolgok behelyezve.

388
00:34:53,790 --> 00:34:56,639
Tehát amint helyezze be a hash tábla,

389
00:34:56,639 --> 00:35:00,590
vállalnak nincs csatolt listán, és meg tudná ítélni egy láncolt lista

390
00:35:00,590 --> 00:35:03,980
amelyet be először.

391
00:35:03,980 --> 00:35:10,060
De itt már ki 2 első és tudja, ha ez kinyomtatott ezt a tömböt, hogy a 2 az első.

392
00:35:10,060 --> 00:35:13,090
Nem nyomtassa ki akármilyen sorrendben.

393
00:35:13,090 --> 00:35:17,550
A műszaki adatok szerkezete, hogy ez használ egy rendezett térkép,

394
00:35:17,550 --> 00:35:24,690
így térképezi kulcsok értékeit, és emlékszik a sorrendet, amely ezeket a kulcsokat is beilleszteni.

395
00:35:24,690 --> 00:35:31,600
Alapvetően ez bizonyos szövődmények, ahol ez bosszantó, hogy valóban -

396
00:35:31,600 --> 00:35:34,510
Tegyük fel, hogy van egy tömb 0, 1, 2, 3, 4, 5

397
00:35:34,510 --> 00:35:37,700
és szeretné kivenni index 2.

398
00:35:37,700 --> 00:35:47,750
Az egyik módja, hogy lássuk, hogy mi néz ki.

399
00:35:47,750 --> 00:35:50,410
0, 2, 1, 3, 4.

400
00:35:50,410 --> 00:35:54,880
Unset történik hatástalanítására egyaránt változók és tömb indexei.

401
00:35:54,880 --> 00:35:58,630
Szóval unset ($ array [2]);

402
00:35:58,630 --> 00:36:03,430
Most mi fog ez kinézni? 2 csak eltűnt, úgy, hogy tökéletesen rendben van.

403
00:36:03,430 --> 00:36:11,670
További bosszantó, ha azt szeretné, hogy a dolgok valójában, mint egy tömb.

404
00:36:11,670 --> 00:36:14,910
Teszek véletlen számokat.

405
00:36:14,910 --> 00:36:20,400
Most már észre a mutatók.

406
00:36:20,400 --> 00:36:26,860
Azt akarom, hogy csak olyan, mint egy C tömb hova megy 0-ról hossza - 1

407
00:36:26,860 --> 00:36:30,810
és én iterációkhoz rajta, mint olyat.

408
00:36:30,810 --> 00:36:38,520
De amint azt hatástalanítsa a második index, mi volt az index 3 nem váltak index 2.

409
00:36:38,520 --> 00:36:44,790
Ehelyett csak eltávolítja említett index, és most megy 0, 1, 3, 4.

410
00:36:44,790 --> 00:36:48,740
Ez teljesen ésszerű.

411
00:36:48,740 --> 00:36:53,950
Ez csak bosszantó, és meg kell csinálni a dolgokat, mint a tömb splice. Igen.

412
00:36:53,950 --> 00:36:57,200
>> [Hallgató] Mi történne, ha volt egy for ciklus

413
00:36:57,200 --> 00:36:59,630
és meg akart menni az összes elemet?

414
00:36:59,630 --> 00:37:02,290
Amikor a hit 2, lenne így valaha?

415
00:37:02,290 --> 00:37:10,150
Iterációjával több mint egy tömb. Van 2 módon lehet csinálni.

416
00:37:10,150 --> 00:37:12,770
Használhatja a rendszeres for ciklus.

417
00:37:12,770 --> 00:37:22,000
Ez egy másik bonyolultságát PHP.

418
00:37:22,000 --> 00:37:27,420
A legtöbb nyelven, azt mondanám, van valamilyen hosszúságú vagy len vagy valami

419
00:37:27,420 --> 00:37:30,470
jelezve a hosszát egy tömb.

420
00:37:30,470 --> 00:37:32,820
PHP-ben ez a szám.

421
00:37:32,820 --> 00:37:36,160
Szóval count ($ array); $ i + +)

422
00:37:36,160 --> 00:37:42,950
Nézzük csak print ($ array [$ i]);

423
00:37:45,920 --> 00:37:48,820
Notice: Undefined offset: 2.

424
00:37:48,820 --> 00:37:51,610
Ez csak megy, hogy nem.

425
00:37:51,610 --> 00:38:03,020
Ez az oka annak, hogy a legtöbb esetben, akkor soha nem kell megismételni több mint egy tömböt, mint ez.

426
00:38:03,020 --> 00:38:07,110
Lehet, hogy túlzás, de soha nem kell megismételni több mint egy tömböt, mint ez

427
00:38:07,110 --> 00:38:19,410
mert a PHP a foreach szintaxist adott foreach ($ array as $ elem).

428
00:38:19,410 --> 00:38:31,830
Most, ha kiírjuk ($ tétel) - we'll beszélje meg a második -, hogy tökéletesen működik jól.

429
00:38:31,830 --> 00:38:38,960
Az út, hogy a foreach dolgozik, az első érv a tömböt, hogy te iterációjával át.

430
00:38:38,960 --> 00:38:44,060
És a második érv, elem segítségével minden lépésben a for ciklus

431
00:38:44,060 --> 00:38:52,690
ez fog tartani a következő dolog, amit a tömbben. Úgy emlékszem, a tömb egy rendelésre.

432
00:38:52,690 --> 00:38:55,690
Az első alkalommal, a for ciklus, elem lesz 123

433
00:38:55,690 --> 00:38:59,540
akkor lesz 12, akkor lesz 13, akkor lesz 23 akkor lesz 213.

434
00:38:59,540 --> 00:39:04,670
A dolgok igazán furcsa, ha valami ilyesmit foreach.

435
00:39:04,670 --> 00:39:07,480
Lássuk, mi történik, mert soha nem csinálni.

436
00:39:07,480 --> 00:39:13,320
Mi lenne, ha unset ($ array [1]);

437
00:39:20,410 --> 00:39:26,030
Ez valószínűleg várható.

438
00:39:26,030 --> 00:39:30,950
Te iterációjával át ezt a tömböt, és minden egyes alkalommal, amikor hatástalanítás az első index.

439
00:39:30,950 --> 00:39:39,720
Így az index értéke 0, az első dolog, elem felveszi értéke 0, így lesz 123.

440
00:39:39,720 --> 00:39:44,630
De belül a for ciklus akkor unset index 1, tehát azt jelenti, hogy a 12 eltűnt.

441
00:39:44,630 --> 00:39:57,480
Tehát nyomtatni. PHP_EOL.

442
00:39:57,480 --> 00:40:03,580
PHP_EOL csak új sor, de ez technikailag könnyebben hordozható

443
00:40:03,580 --> 00:40:08,890
mivel újsor Windows különbözik újsor Mac és UNIX.

444
00:40:08,890 --> 00:40:18,040
A Windows új sor a \ r \ n, mivel mindenhol máshol is inkább csak azért, hogy legyen \ n.

445
00:40:18,040 --> 00:40:25,150
PHP_EOL úgy van kialakítva, hogy az általa használt bármilyen újsor a rendszer.

446
00:40:25,150 --> 00:40:29,310
Tehát, hogy a nyomtatás. Ne print_r ($ array) a végén.

447
00:40:32,830 --> 00:40:37,390
Fogalmam sem volt, hogy ez lenne a viselkedést.

448
00:40:41,740 --> 00:40:48,960
Jogcím még mindig tart az érték 12 még akkor is hatástalanítani 12 előtt, amit valaha kapott, hogy azt a tömböt.

449
00:40:52,770 --> 00:40:58,840
Ne fogd meg a szót, de úgy néz ki foreach másolatot készít a tömbben

450
00:40:58,840 --> 00:41:02,160
majd a tétel veszi az összes értéket adott példány.

451
00:41:02,160 --> 00:41:07,760
Tehát akkor is, ha módosítja a tömb belsejében a hurok,

452
00:41:07,760 --> 00:41:17,240
akkor nem érdekel. Jogcím lesz az eredeti értékeket.

453
00:41:17,240 --> 00:41:19,240
Próbáljuk hatástalanításakor meg.

454
00:41:19,240 --> 00:41:24,460
Mi van, ha ez a $ array [1] = "hello";

455
00:41:24,460 --> 00:41:31,770
Annak ellenére, hogy tegye "hello" a tömb, elem nem veszi fel ezt az értéket.

456
00:41:31,770 --> 00:41:37,430
Van egy másik szintaxis foreach hurok

457
00:41:37,430 --> 00:41:45,900
ahová 2 változó elválasztva egy nyíl.

458
00:41:45,900 --> 00:41:49,680
Ez az első változó lesz a kulcsa az érték,

459
00:41:49,680 --> 00:41:53,050
és ez a második változó lesz pontosan ugyanolyan elemet.

460
00:41:53,050 --> 00:42:01,610
Ez itt érdektelen, de ha megyünk vissza az eredeti esetben az "a" -> 1,

461
00:42:01,610 --> 00:42:06,090
A "b" -> 1,

462
00:42:06,090 --> 00:42:14,470
Itt már csak navigálhat az egyes tömb elem elem lesz 1 minden egyes alkalommal.

463
00:42:14,470 --> 00:42:18,170
De ha azt is szeretnénk tudni, hogy a kulcsot társított tétel

464
00:42:18,170 --> 00:42:25,230
akkor mi as $ kulcs -> $ elemet.

465
00:42:25,230 --> 00:42:31,980
Így most tehetünk print ($ kulcs. ':'.

466
00:42:31,980 --> 00:42:39,380
Most ez iterációjával át, és nyomtatás minden kulcs és a hozzá kapcsolódó értékét.

467
00:42:39,380 --> 00:42:47,030
>> Egy további dolog, amit tehetünk foreach ciklushoz képest lehet látni ezt a szintaxist.

468
00:42:47,030 --> 00:42:54,770
Ampersands mielőtt változó nevek általában hogyan működik PHP hivatkozásokat.

469
00:42:54,770 --> 00:43:00,460
Amennyiben a hivatkozások nagyon hasonló mutató,

470
00:43:00,460 --> 00:43:04,820
nincs mutató, így nem foglalkozik a memória közvetlenül.

471
00:43:04,820 --> 00:43:12,620
De vannak bizonyos hivatkozásokat, ahol az 1 a változó tartalmazza az ugyanaz, mint a másik változó.

472
00:43:12,620 --> 00:43:21,450
Belül itt csináljuk $-tétel. Menjünk vissza az 1-10-ig.

473
00:43:21,450 --> 00:43:28,800
Csináljuk $ tétel + +; Ez még mindig létezik a PHP. Továbbra is csinálni + +.

474
00:43:28,800 --> 00:43:38,260
php.test.php. Meg kell kinyomtatni. print_r ($ array);

475
00:43:38,260 --> 00:43:42,730
Mi nyomtatni 2, 11.

476
00:43:42,730 --> 00:43:49,560
Ha az imént tett foreach ($ array as $ elem), akkor a tétel lesz az 1-es érték

477
00:43:49,560 --> 00:43:54,190
az első alkalommal a hurkon. Ez növekmény 1-2, és akkor kész.

478
00:43:54,190 --> 00:43:57,260
Akkor fog átmenni a második lépés a hurok, és hogy elem 10.

479
00:43:57,260 --> 00:44:01,570
Ez lépésekben elem 11 programot, majd ez csak kidobni.

480
00:44:01,570 --> 00:44:06,670
Aztán print_r ($ array), és nézzük meg, hogy ez csak 1, 10.

481
00:44:06,670 --> 00:44:09,070
Tehát a növekmény tettük elveszett.

482
00:44:09,070 --> 00:44:13,410
De foreach ($ array as & $ elem)

483
00:44:13,410 --> 00:44:21,910
most ez a napirendi pont ugyanazt a tételt, mint ez itt. Ez ugyanaz a dolog.

484
00:44:21,910 --> 00:44:26,820
Tehát $ elem + + a módosító array 0.

485
00:44:29,330 --> 00:44:41,850
Alapvetően, akkor is csinálni $ k -> $ tételt, és meg tudod csinálni $ array [$ k] + +;

486
00:44:41,850 --> 00:44:48,650
>> Tehát egy másik módja az, hogy szabadok vagyunk módosítani elem,

487
00:44:48,650 --> 00:44:54,070
de ez nem módosítja az eredeti tömb.

488
00:44:54,070 --> 00:44:59,720
De ha használja k, ami a legfontosabb, akkor is csak a mi tömb index segítségével, hogy a legfontosabb

489
00:44:59,720 --> 00:45:01,530
és növelni azt.

490
00:45:01,530 --> 00:45:05,410
Ez több közvetlenül módosítja az eredeti tömb.

491
00:45:05,410 --> 00:45:10,690
Akár azt is csinálni, hogy ha valamilyen okból úgy akarta, hogy a képesség, hogy módosítsa -

492
00:45:10,690 --> 00:45:13,510
Valójában ez teljesen ésszerű.

493
00:45:13,510 --> 00:45:16,020
Nem akarjuk, hogy írni $ array [$ k] + +,

494
00:45:16,020 --> 00:45:27,890
Ön csak azt akartam írni, $ elem + +, de még mindig azt akartam mondani, if ($ k === 'a')

495
00:45:27,890 --> 00:45:30,620
akkor növelni elemet, majd nyomtassa ki a tömb.

496
00:45:30,620 --> 00:45:36,290
Akkor most mit várunk print_r csinálni? Milyen értékeket kell nyomtatni?

497
00:45:36,290 --> 00:45:43,770
[Hallgató] 2 és 10. >> [Bowden] Csak akkor, ha a kulcs az volt "a" nem mi valójában, hogy nyomtatni.

498
00:45:51,940 --> 00:45:55,670
>> Valószínűleg nagyon ritkán, ha valaha, meg kell határozni függvények PHP-ben,

499
00:45:55,670 --> 00:46:03,370
de lehet, hogy valami hasonló, ahol meg egy függvényt, mint a funkció bármi.

500
00:46:03,370 --> 00:46:09,900
Általában azt mondanám ($ foo $ bar), majd meghatározza, hogy legyen bármi.

501
00:46:09,900 --> 00:46:17,580
De ha ezt, akkor ez azt jelenti, hogy bármi is felhívja bármi,

502
00:46:17,580 --> 00:46:25,110
függetlenül felhívja BAZ, így az első érv át baz lehet változtatni.

503
00:46:25,110 --> 00:46:38,100
Csináljuk $ foo + +;

504
00:46:38,100 --> 00:46:48,020
és belül itt csináljuk baz ($ elem);

505
00:46:48,020 --> 00:46:52,250
Most hív egy függvényt.

506
00:46:52,250 --> 00:46:56,780
Az érvet hozott hivatkozás, ami azt jelenti, hogy ha módosítja azt

507
00:46:56,780 --> 00:47:00,390
mi módosítja a dolog, hogy vezetünk be

508
00:47:00,390 --> 00:47:04,420
És ez a nyomtatás várunk - ha elrontottam szintaxis - kaptunk 2, 11,

509
00:47:04,420 --> 00:47:06,300
így ténylegesen növekszik.

510
00:47:06,300 --> 00:47:08,790
Figyeljük meg kell utalások 2 helyen.

511
00:47:08,790 --> 00:47:13,050
Mi van, ha én tettem ezt? Mit jelent ez?

512
00:47:13,050 --> 00:47:15,810
[Hallgató] Ez meg fog változni. >> Igen.

513
00:47:15,810 --> 00:47:18,290
Jogcím csak egy másolata az értéket a tömbben.

514
00:47:18,290 --> 00:47:26,670
Szóval elem változik 2, de a tömb ['a'] továbbra is 1.

515
00:47:26,670 --> 00:47:32,560
Vagy mi van, ha tudom ezt megtenni?

516
00:47:32,560 --> 00:47:39,260
Most tétel küldött egy példányt a BAZ.

517
00:47:39,260 --> 00:47:46,330
Tehát a másolat az érvelés lesz eggyel 2,

518
00:47:46,330 --> 00:47:49,240
de a tétel önmagában soha nem növekszik 2-re.

519
00:47:49,240 --> 00:47:52,880
És napirendi pont ugyanaz, mint array konzol bármi,

520
00:47:52,880 --> 00:47:55,380
hogy a tömb soha nem növekszik.

521
00:47:55,380 --> 00:47:57,960
Szóval mindkét helyen szükség van rá.

522
00:47:57,960 --> 00:48:03,830
>> PHP általában elég okos erről.

523
00:48:03,830 --> 00:48:06,570
Azt hihetnénk, hogy azt akarom, hogy adja át a referencia -

524
00:48:06,570 --> 00:48:09,560
Ez volt tulajdonképpen a kérdést az egyik psets.

525
00:48:09,560 --> 00:48:14,480
Ez volt a questions.txt dolog, ha azt mondta,

526
00:48:14,480 --> 00:48:19,280
Miért is szeretnénk átadni ezt a struct hivatkozva?

527
00:48:19,280 --> 00:48:21,250
Mi volt a válasz, hogy az?

528
00:48:21,250 --> 00:48:25,100
[Hallgató] Szóval nem kell másolni valami nagy. >> Igen.

529
00:48:25,100 --> 00:48:32,920
A struct lehet tetszőlegesen nagy, és amikor át a struct az argumentumként

530
00:48:32,920 --> 00:48:36,800
szükséges másolni, hogy egész struct átadni azt a funkciót,

531
00:48:36,800 --> 00:48:40,410
mivel ha csak át a struct hivatkozással

532
00:48:40,410 --> 00:48:46,530
akkor csak meg kell másolni egy 4 byte-os cím az érvet, hogy a funkciót.

533
00:48:48,520 --> 00:48:52,320
PHP egy kicsit okosabb ennél.

534
00:48:52,320 --> 00:49:00,650
Ha van valami funkciója, és átadom neki egy sor 1.000 dolgokat,

535
00:49:00,650 --> 00:49:03,990
ez azt jelenti, hogy ez lesz, hogy másolni 1.000 azokat a dolgokat

536
00:49:03,990 --> 00:49:10,450
átadni azt a funkciót? Nem kell tennie, hogy azonnal.

537
00:49:10,450 --> 00:49:15,940
Ha belül ez a funkció akkor soha nem módosítja foo,

538
00:49:15,940 --> 00:49:22,660
így if ($ foo === 'hello') return true.;

539
00:49:22,660 --> 00:49:26,460
Figyeljük meg mi sosem módosították azt az érvet belül ezt a funkciót,

540
00:49:26,460 --> 00:49:30,010
ami azt jelenti, hogy bármilyen fogadták el a foo nem kell másolni

541
00:49:30,010 --> 00:49:32,100
mert ez nem módosítja azt.

542
00:49:32,100 --> 00:49:39,240
Tehát az út PHP művek az érvek mindig által elfogadott referencia

543
00:49:39,240 --> 00:49:42,170
amíg ténylegesen megpróbálja módosítani azt.

544
00:49:42,170 --> 00:49:51,160
Most, ha azt mondom, $ foo + +, akkor most egy másolatot az eredeti foo és módosítsa a másolatot.

545
00:49:51,160 --> 00:49:53,090
Ez ment egy ideig.

546
00:49:53,090 --> 00:49:58,210
Ha soha nem érinti ez a hatalmas tömb, akkor soha nem módosíthatja,

547
00:49:58,210 --> 00:50:02,360
nem kell, hogy a másolatot,

548
00:50:02,360 --> 00:50:06,640
mivel ha csak hogy ezt a jelet, amely azt jelenti, hogy nem is másolni

549
00:50:06,640 --> 00:50:08,640
akkor is, ha nem módosítja.

550
00:50:08,640 --> 00:50:10,680
Ez a jelenség az úgynevezett copy-on-write.

551
00:50:10,680 --> 00:50:17,380
Látni fogod, hogy más helyen, különösen, ha veszel egy operációs rendszer tanfolyamot.

552
00:50:17,380 --> 00:50:23,880
Copy-on-write egy nagyon megszokott mintát, ahol nem kell másolatot készíteni valamit

553
00:50:23,880 --> 00:50:26,650
kivéve, ha ez nem változik. Igen.

554
00:50:26,650 --> 00:50:29,520
[Hallgató] Mi lenne, ha a növekmény belsejében a vizsgálat,

555
00:50:29,520 --> 00:50:33,700
így csak 1 elem 1000-ből kellene változtatni?

556
00:50:33,700 --> 00:50:38,770
Nem vagyok benne biztos.

557
00:50:38,770 --> 00:50:51,250
Azt hiszem, ez másolja az egész dolog, de lehetséges, hogy ez elég okos ahhoz, hogy -

558
00:50:51,250 --> 00:51:00,020
Igazából, mit gondolok az képzelje el, hogy volt egy tömb, amely így néz ki: $ tomb2 = [

559
00:51:00,020 --> 00:51:11,000
Aztán index 'a' egy tömb [1 2 3 4] és index 'b' egy tömb bármi.

560
00:51:11,000 --> 00:51:15,380
Szükségem van vesszők között, az összes ilyen. Képzeld el vannak elválasztva.

561
00:51:15,380 --> 00:51:21,210
Aztán a "c" az értéke 3.

562
00:51:24,210 --> 00:51:26,290
Oké.

563
00:51:26,290 --> 00:51:33,440
Most mondjuk mi $ baz ($ tomb2);

564
00:51:33,440 --> 00:51:36,540
ha BAZ nem veszi ezt a hivatkozást.

565
00:51:43,510 --> 00:51:47,370
Tehát $ ize ['c'] + +;

566
00:51:47,370 --> 00:51:52,340
Ez olyan példa, ahol mi haladnak tömb2 argumentumként

567
00:51:52,340 --> 00:51:57,010
és akkor azt módosítja egy sajátos indexre mutató növelésével azt.

568
00:51:57,010 --> 00:52:01,090
Őszintén szólva fogalmam sincs, mi a PHP fog tenni.

569
00:52:01,090 --> 00:52:07,200
Könnyen készíthet másolatot az egész dolog, de ha ez az intelligens,

570
00:52:07,200 --> 00:52:15,030
meg fog tenni egy másolatot ezekről a kulcs, ha ez lesz az elkülönült értéke

571
00:52:15,030 --> 00:52:20,620
de ez még mindig mutatnak azonos tömb 1,2,3,4

572
00:52:20,620 --> 00:52:22,320
és ez továbbra is pont ugyanarra a tömb.

573
00:52:22,320 --> 00:52:24,170
Én majd iPad is.

574
00:52:28,900 --> 00:52:45,950
Átmegyünk ezen a tömb, ha ez a fickó pont 3, ez a fickó pontok [1,2,3,4]

575
00:52:45,950 --> 00:52:51,350
ez a fickó pontok [34, ...]

576
00:52:51,350 --> 00:52:58,590
Most, hogy mi vezetjük be a BAZ, mi módosításokra.

577
00:52:58,590 --> 00:53:03,550
Ha a PHP okos, akkor csak csináld -

578
00:53:11,850 --> 00:53:18,230
Még mindig kellett másolni némi memóriát, de ha volt ilyen hatalmas beágyazott subarrays

579
00:53:18,230 --> 00:53:21,560
mi nem kell másolni azokat.

580
00:53:21,560 --> 00:53:27,530
Nem tudom, hogy ez az, amit csinál, de el tudom képzelni, hogy csinálja.

581
00:53:29,050 --> 00:53:36,690
Ez is egy nagyon nagy előnye a C-PHP.

582
00:53:36,690 --> 00:53:40,320
>> PHP teszi az életet, így sokkal könnyebb a sok dolgot,

583
00:53:40,320 --> 00:53:45,060
de ilyen egyáltalán nincs ötlete, hogyan is fog végezni

584
00:53:45,060 --> 00:53:52,530
mert fogalmam sincs, a motorháztető alatt, ha ez, hogy ezeket a másolatokat a dolgokat,

585
00:53:52,530 --> 00:53:55,170
oh, az, hogy lesz egy állandó idő példányt,

586
00:53:55,170 --> 00:54:01,140
Ez csak fog változni 1 mutató, igaz lesz egy nevetségesen nehéz lineáris másolat?

587
00:54:01,140 --> 00:54:03,000
Mi van, ha nem talál helyet?

588
00:54:03,000 --> 00:54:06,760
Vajon akkor kell futtatni szemétgyűjtő, hogy még egy kis hely?

589
00:54:06,760 --> 00:54:11,210
És szemétgyűjtő vehet önkényesen hosszú.

590
00:54:11,210 --> 00:54:13,600
A C-ben nem kell aggódnia, ezeket a dolgokat.

591
00:54:13,600 --> 00:54:19,780
Minden egyes sort írsz akkor elég sok oka arról, hogyan fog végrehajtani.

592
00:54:26,800 --> 00:54:29,150
>> Nézzünk vissza ezeket.

593
00:54:35,400 --> 00:54:37,520
Milyen szép az, hogy nem kell foglalkozni a hash függvények,

594
00:54:37,520 --> 00:54:39,010
kapcsolódó listák, vagy ilyesmi?

595
00:54:39,010 --> 00:54:41,980
Mivel a munka hash táblák olyan könnyű most itt egy szórakoztató puzzle dolgozni.

596
00:54:41,980 --> 00:54:45,920
Nyisd ki nevű fájlt unique.php és benne levelet PHP program

597
00:54:45,920 --> 00:54:48,330
(Más néven a "script").

598
00:54:48,330 --> 00:54:55,700
Hajlamosak vagyunk arra, hogy hívja őket, parancsfájlok, ha ők rövid dolgokat futtatni a parancssorban.

599
00:54:55,700 --> 00:55:02,950
Alapvetően bármilyen nyelven, hogy nem állítanak össze, de mész a futtatáshoz

600
00:55:02,950 --> 00:55:05,920
a parancssorban, akkor hívja, hogy végrehajtható script.

601
00:55:05,920 --> 00:55:08,510
Tudtam éppúgy levelet C program, amely nem ezt,

602
00:55:08,510 --> 00:55:12,300
de én nem nevezném egy forgatókönyvet, mivel először fordítsuk le, majd futtassa a bináris.

603
00:55:12,300 --> 00:55:15,480
De ez a PHP program fogunk hívni a script.

604
00:55:15,480 --> 00:55:23,830
Vagy ha azt írta a Python vagy a Perl vagy Node.js vagy azoknak a dolgoknak,

605
00:55:23,830 --> 00:55:26,500
mi lenne nevezzük őket, mert az összes szkriptet futtatni őket a parancssorból

606
00:55:26,500 --> 00:55:30,040
de nem fordítani őket.

607
00:55:30,860 --> 00:55:33,400
Megtehetjük ezt elég gyorsan.

608
00:55:36,960 --> 00:55:41,480
Nem fogunk használni argv. Nézzük csak fúj keresztül.

609
00:55:41,480 --> 00:55:45,730
Nevezzük egyedi, írni egy programot.

610
00:55:45,730 --> 00:55:49,400
Lehet feltételezni, hogy a bemenet tartalmaz egy szót soronként.

611
00:55:49,400 --> 00:55:52,020
Valójában, argv lesz elég triviális használni.

612
00:56:03,730 --> 00:56:06,720
unique.php.

613
00:56:08,550 --> 00:56:13,750
Az első dolog az első, azt akarjuk, hogy ellenőrizze, mi már eltelt 1 parancssori argumentum.

614
00:56:13,750 --> 00:56:20,900
Ahogy elvárható argc és argv C, még mindig azok, PHP nyelven.

615
00:56:20,900 --> 00:56:33,900
Tehát, ha ($ argc! == 2), akkor nem fogok foglalkozni nyomtat egy üzenetet, vagy ilyesmi.

616
00:56:33,900 --> 00:56:37,340
Én csak kilépéshez, hibakód: 1 db.

617
00:56:37,340 --> 00:56:41,340
Én is return 1.

618
00:56:41,340 --> 00:56:53,180
Ritkán a PHP Önnek ezt az állapotot, ha már itt tartunk -

619
00:56:53,180 --> 00:56:57,820
Általában te egy függvényt hívja a függvény által hívott függvény által hívott függvény.

620
00:56:57,820 --> 00:57:02,070
És ha valami balul sül el, és ön csak akar lépni mindent teljesen,

621
00:57:02,070 --> 00:57:05,680
kilépés csak véget ér a program.

622
00:57:05,680 --> 00:57:08,160
Ez is létezik C.

623
00:57:08,160 --> 00:57:10,700
Ha egy függvény egy funkciót a funkció egy funkció

624
00:57:10,700 --> 00:57:17,540
és azt szeretné, hogy csak ölni a programot, akkor hívja kiléptető és akkor csak kilép.

625
00:57:17,540 --> 00:57:23,120
De PHP ez még ritka, hogy mi vagyunk ezen a legfelső szinten.

626
00:57:23,120 --> 00:57:26,090
Általában bent vagyunk valamilyen funkciót, így nevezzük kilépési

627
00:57:26,090 --> 00:57:29,650
azért, hogy ne kelljen visszatérni up 1 dolog, ami aztán rájön, hogy van egy hiba

628
00:57:29,650 --> 00:57:32,270
annak érdekében, hogy vissza, fel, ha felismeri, hogy hiba történt.

629
00:57:32,270 --> 00:57:35,270
Nem akarjuk, hogy foglalkozzanak ezzel, így a kilépés (1);

630
00:57:35,270 --> 00:57:38,240
visszatérés (1), ebben az esetben az lenne egyenértékű.

631
00:57:38,240 --> 00:57:44,000
>> Akkor mit akarunk nyitni akarunk fopen.

632
00:57:44,000 --> 00:57:46,760
Az érvek fognak csinos hasonló.

633
00:57:46,760 --> 00:57:51,600
Azt akarjuk, hogy fopen ($ argv [1], és azt akarjuk, hogy nyissa meg olvasásra.

634
00:57:51,600 --> 00:57:55,720
Ez visszaadja a forrás, amely fogunk hívni f.

635
00:57:55,720 --> 00:58:02,180
Ez úgy néz ki nagyon hasonlít, hogy hogyan C csinálja csak nem kell mondani FILE *.

636
00:58:02,180 --> 00:58:06,170
Ehelyett mondjuk $ f. Oké.

637
00:58:06,170 --> 00:58:17,190
Igazából, azt hiszem, ez is ad nekünk egy tipp, hogy PHP nevezett funkció fájlt. PHP fájl.

638
00:58:17,190 --> 00:58:23,990
Mi ez fog tenni az olvasni egy egész fájlt egy tömb.

639
00:58:23,990 --> 00:58:29,770
Nem is kell, hogy fopen rá. Úgy fog tenni az Ön számára.

640
00:58:37,450 --> 00:58:43,700
Tehát $ lines = file ($ argv [1]);

641
00:58:43,700 --> 00:58:49,680
Most minden a vonalak a fájl vannak vonalak. Most szeretnénk rendezni a sorokat.

642
00:58:49,680 --> 00:58:52,180
Hogyan tudjuk rendezni a sorokat?

643
00:58:52,180 --> 00:58:54,920
Mi rendezni a sorokat.

644
00:58:54,920 --> 00:58:58,080
És most lehet nyomtatni, vagy bármi.

645
00:58:58,080 --> 00:59:05,580
Talán a legegyszerűbb foreach ($ sor as $ line) echo $ line;

646
00:59:05,580 --> 00:59:10,960
[Hallgató] Nem lenne még azt is át vonalak hivatkozás valamit a sort?

647
00:59:10,960 --> 00:59:28,850
Ez az, ahol sort lehetne meghatározni függvény sort (& $ array).

648
00:59:28,850 --> 00:59:32,650
Ha hívja a funkció nem adja át hivatkozunk.

649
00:59:32,650 --> 00:59:36,900
Ez az a funkció, amely meghatározza azt a szedését, mint referencia.

650
00:59:36,900 --> 00:59:40,900
Ez valójában pontosan mi volt a baj

651
00:59:40,900 --> 00:59:46,220
amikor mindent a mi szerverrel amikor mentünk 5,3-5,4.

652
00:59:46,220 --> 00:59:53,800
Egészen 5,4, ez teljesen ésszerű.

653
00:59:53,800 --> 00:59:58,740
A funkció nem számíthat arra, hogy vegye referenciaként, de akkor add a referencia

654
00:59:58,740 --> 01:00:02,860
így ha a funkció nem történik, hogy módosítsa, ez még mindig módosítani.

655
01:00:02,860 --> 01:00:05,850
Mivel a 5,4, nem kéne ezt tenni.

656
01:00:05,850 --> 01:00:11,740
Tehát most csak úgy át történő hivatkozással, ha a funkció kifejezetten csinálja.

657
01:00:11,740 --> 01:00:19,840
Ha nem akarjuk, hogy módosítsa azt, akkor meg kell tennie $ copy = $ vonalak és jelszó másolatot.

658
01:00:19,840 --> 01:00:24,820
Tehát most irányvonal mentén kell őrizni, és másolatot kell változtatni.

659
01:00:27,670 --> 01:00:31,460
php.unique.php. Én lehet, hogy elrontottam valamit.

660
01:00:31,460 --> 01:00:33,190
Váratlan "sort".

661
01:00:38,320 --> 01:00:43,850
Ott lesz valami, hogy működik ez a számunkra.

662
01:00:43,850 --> 01:00:45,820
Ez még csak nem is ott.

663
01:00:45,820 --> 01:00:52,140
Értesítés, ha elolvassa a kézikönyvet, hogy az első érvet várhatóan egy tömb

664
01:00:52,140 --> 01:00:56,490
és ez által referenciaként.

665
01:00:58,160 --> 01:01:03,540
Miért van ez panaszkodik nekem? Mert van ez a funkció fajta még mindig itt van, hogy nem akarok.

666
01:01:03,540 --> 01:01:09,210
Oké, php.unique.php. Én nem adja át az érvet, mert nekem nincs egy fájlt.

667
01:01:09,210 --> 01:01:13,560
Ez php.unique.php a test.php.

668
01:01:13,560 --> 01:01:19,080
Itt test.php összes kinyomtatott egy szép rendezett sorrendben.

669
01:01:19,080 --> 01:01:24,600
Figyeljük meg, hogy rendezetten egyfajta furcsa egy kódot fájl

670
01:01:24,600 --> 01:01:27,460
mert minden a mi üres sor fog jönni 1.

671
01:01:27,460 --> 01:01:30,190
ezután fog jönni minden kedves 1 szint bemélyedések

672
01:01:30,190 --> 01:01:33,360
akkor gyere minden kedves nincs bemélyedések.

673
01:01:33,360 --> 01:01:38,620
Igen. >> [Hallgató] Tehát a forráskód, hogy nem fogad el referencia?

674
01:01:38,620 --> 01:01:42,240
Van, hogy általában elfogadott érték szerint?

675
01:01:42,240 --> 01:01:50,240
[Bowden] Ha hív egy függvényt, soha nem határozza meg, hogy azt át hivatkozunk.

676
01:01:50,240 --> 01:01:53,960
Ez a függvény definíciójában, amely meghatározza, hogy azt át hivatkozunk.

677
01:01:53,960 --> 01:01:59,450
És nézte a függvény definíciójában a sort, vagy csak nézi most ezt,

678
01:01:59,450 --> 01:02:02,820
veszi az érvet hivatkozunk.

679
01:02:02,820 --> 01:02:07,160
Tehát függetlenül attól, hogy azt akarja, hogy vegye hivatkozással, hogy nem fog rá hivatkozni.

680
01:02:07,160 --> 01:02:10,200
Ez módosítja a tömböt a helyére.

681
01:02:10,200 --> 01:02:17,400
Ez egyszerűen nem lehetséges. Te nem szabad ezt tenni. >> [Hallgató] Ó, oké.

682
01:02:17,400 --> 01:02:22,410
[Bowden] Ez, sort fog tartani vonalakat referencia és módosítja.

683
01:02:22,410 --> 01:02:26,850
Továbbá, ha nem akarja, hogy erre, akkor készítsen egy másolatot a sort.

684
01:02:26,850 --> 01:02:35,850
Még ebben az esetben, másolás nem valójában másolata vonalak.

685
01:02:35,850 --> 01:02:40,620
Csak mutat ugyanaz a dolog, amíg meg nem lesz átalakítva,

686
01:02:40,620 --> 01:02:44,430
ahol az első lesz, hogy módosították a rendezési funkció

687
01:02:44,430 --> 01:02:50,940
ahol, mert a copy-on-levelet, most egy példányát példány fog tenni.

688
01:02:57,500 --> 01:03:04,250
Azt is megteheti ezt. Ez a másik hely látható jelet.

689
01:03:04,250 --> 01:03:07,190
Látod azt a foreach hurok, látod, hogy a funkció a nyilatkozatokat,

690
01:03:07,190 --> 01:03:10,040
és látod, amikor éppen kiosztása változókat.

691
01:03:10,040 --> 01:03:12,350
Most elértünk semmit ezt

692
01:03:12,350 --> 01:03:15,600
mivel a másolás és a vonalak szó szerint ugyanaz a dolog.

693
01:03:15,600 --> 01:03:19,940
Használhatja a sorokat és másolja szinonimaként.

694
01:03:19,940 --> 01:03:25,430
Meg tudod csinálni unset ($ másolat), és hogy nem unset vonalak,

695
01:03:25,430 --> 01:03:29,120
csak elveszíti a hivatkozás az ugyanaz a dolog.

696
01:03:29,120 --> 01:03:33,440
Szóval, ezen a ponton, most vonalak csak így érheti vonalak.

697
01:03:36,450 --> 01:03:38,770
>> Kérdései vannak?

698
01:03:41,000 --> 01:03:42,460
Igen.

699
01:03:42,460 --> 01:03:45,880
[Hallgató] Teljesen off topic, de nem kell, hogy lezárja a PHP-t a - >> Te nem.

700
01:03:45,880 --> 01:03:47,730
Oké.

701
01:03:47,730 --> 01:03:53,790
[Bowden] mennék, amennyire azt mondani, hogy rossz gyakorlat, hogy zárja be őket.

702
01:03:53,790 --> 01:03:57,580
Ez talán túlzás, különösen egy olyan script,

703
01:03:57,580 --> 01:04:03,740
de lássuk, mi történik, ha ezt csinálom.

704
01:04:03,740 --> 01:04:08,890
Ez nem tett semmit. Mi van, ha akarok - [sóhajok]

705
01:04:13,870 --> 01:04:16,960
Azt kell tennie egy érvet.

706
01:04:19,000 --> 01:04:22,050
Lődd le. Hívtam, hogy tévedtem.

707
01:04:24,340 --> 01:04:28,310
Így php.unique.php egy érvet.

708
01:04:28,310 --> 01:04:30,980
Most már nem is kell ezt.

709
01:04:34,520 --> 01:04:37,740
Majd add meg egy érvényes érv.

710
01:04:37,740 --> 01:04:42,050
Ez a nyomtatott függetlenül, hogy ez a nyomtatást.

711
01:04:45,260 --> 01:04:50,080
Én nyomtatás másolás és a másolás nem létezik. Szóval vonalak.

712
01:04:53,650 --> 01:04:58,270
A nyomtatott mindent, és akkor veszi észre ezt a sok kacatot itt lenn,

713
01:04:58,270 --> 01:05:06,690
mert PHP bármit, ami kívül esik a PHP címkék

714
01:05:06,690 --> 01:05:09,520
csak megy a nyomtatandó szó.

715
01:05:09,520 --> 01:05:18,050
Ezért HTML, ez annyira jó, hogy meg tudom csinálni div bla, bla, bla osztály vagy bármi,

716
01:05:18,050 --> 01:05:25,140
bla, bla, bla, majd némi PHP kódot, majd tegye vége div.

717
01:05:25,140 --> 01:05:36,460
És most ez a nyomtatás kapok egy szép div up top, mindent, ami a PHP nyomtatott div alján.

718
01:05:36,460 --> 01:05:43,510
Katasztrofális amikor ilyesmi történik, ami elég gyakori,

719
01:05:43,510 --> 01:05:47,930
Csak egy kóbor újsor alján a fájlt.

720
01:05:47,930 --> 01:05:50,940
Ugye, nem hiszem, hogy lenne olyan nagy ügy

721
01:05:50,940 --> 01:05:58,660
amíg Ön szerint a tény, hogy a böngészők -

722
01:05:58,660 --> 01:06:03,880
>> Hogyan átirányítások munka vagy lényegében bármilyen fejlécet munka,

723
01:06:03,880 --> 01:06:07,980
amikor, hogy a kapcsolat a weboldalt, és küld vissza az összes ezeket a fejléceket és a dolgok

724
01:06:07,980 --> 01:06:12,020
mint a válasz 200 vagy válasz átirányítás, vagy bármi,

725
01:06:12,020 --> 01:06:18,230
fejlécek csak akkor érvényesek, amíg az első byte adat kerül elküldésre.

726
01:06:18,230 --> 01:06:23,140
Átirányíthatod ezerszer, de amint az első bájt az adatok elküldött

727
01:06:23,140 --> 01:06:26,120
nem kéne átirányítani újra.

728
01:06:26,120 --> 01:06:31,860
>> Ha van egy kóbor újsor alján egy fájl

729
01:06:31,860 --> 01:06:37,260
és mondjuk, hogy használja ezt a funkciót, majd a kívánt -

730
01:06:41,580 --> 01:06:52,870
Tegyük fel, hogy ez egy másik fájlt, ami index.php és require_once valamit -

731
01:06:52,870 --> 01:06:56,920
Én nem hiszem, jó példa rá.

732
01:06:56,920 --> 01:07:04,740
A probléma történik, ha ezt a sort az alján lesz visszhangzott.

733
01:07:04,740 --> 01:07:08,660
Nem akarom, hogy bármi is visszhangzott még.

734
01:07:10,820 --> 01:07:15,700
Annak ellenére, hogy nem állt szándékában a semmit egyre visszhangozta, amit nem kap visszhangzott

735
01:07:15,700 --> 01:07:17,990
és így most már nem kéne, hogy küldjön többé fejlécet

736
01:07:17,990 --> 01:07:20,030
és fogsz kapni panaszok.

737
01:07:22,170 --> 01:07:24,420
Csak nem kell a záró tag.

738
01:07:24,420 --> 01:07:27,420
Ha azt tervezi csinál valamit HTML -

739
01:07:27,420 --> 01:07:30,490
és ez tökéletesen elfogadható tenni idelent div függetlenül

740
01:07:30,490 --> 01:07:39,450
majd ezen a ponton lehet, vagy nem tudja magában azokat.

741
01:07:39,450 --> 01:07:41,590
Ez nem igazán számít.

742
01:07:41,590 --> 01:07:45,450
De a PHP szkriptek ez ritka, hogy lezárja azt.

743
01:07:45,450 --> 01:07:50,400
Mikor minden PHP, abszolút mindent,

744
01:07:50,400 --> 01:07:55,460
nem igazán kell, hogy zárja be / ne zárja be.

745
01:08:02,030 --> 01:08:05,720
>> Kezelése húrok sokkal szebb, mint a C

746
01:08:05,720 --> 01:08:09,470
A PHP megadható egy string szimpla vagy dupla idézőjelek közé.

747
01:08:09,470 --> 01:08:12,820
Az aposztrófot ezért nem használhatja a "menekülés" szekvenciák.

748
01:08:12,820 --> 01:08:17,640
Folyamatosan menekülni, bla, bla, bla.

749
01:08:19,920 --> 01:08:24,010
Szóval printf nagyon ritka PHP.

750
01:08:24,010 --> 01:08:32,290
Azt hiszem, akkor használja printf, ha akartam csinálni a fajta dolog - az Pset 5 használt sprintf vagy bármi.

751
01:08:32,290 --> 01:08:36,060
De akarod 001.jpg 002.jpg és.

752
01:08:36,060 --> 01:08:40,300
Tehát ez a fajta dolog, ha én tényleg akarom formázni a szöveget szeretném használni printf.

753
01:08:40,300 --> 01:08:44,689
De különben én csak használni karakterlánc összefűzés.

754
01:08:44,689 --> 01:08:47,000
Én soha nem használja printf.

755
01:08:49,229 --> 01:09:00,170
Mi csak a különbséget az adatok között egységes idézetek és idézőjelek.

756
01:09:00,170 --> 01:09:07,490
A legnagyobb különbség az, hogy szimpla idézőjelet, akkor nyomtatott szó.

757
01:09:07,490 --> 01:09:15,390
Nincs char adattípus a PHP, ellentétben a C, így ez megegyezik e.

758
01:09:15,390 --> 01:09:17,970
Mindketten szálakat.

759
01:09:17,970 --> 01:09:29,180
És a szép dolog aposztróf stringek mondhatnám "hello world!" bla, bla, bla,

760
01:09:29,180 --> 01:09:33,340
$ $ Wooo.

761
01:09:33,340 --> 01:09:38,260
Mi történik, amikor nyomtatni ez kiírja a szó szoros értelmében.

762
01:09:38,260 --> 01:09:40,680
Menjünk megszabadulni az összes cuccot.

763
01:09:40,680 --> 01:09:44,700
Szóval echo $ STR1;

764
01:09:48,569 --> 01:09:56,570
Szó nyomtatott mindezen dolgok: dollár jelek,

765
01:09:56,570 --> 01:09:58,770
backslash n, amit azt hiszem, lenne Újsorok -

766
01:09:58,770 --> 01:10:01,500
az összes ilyen dolgot nyomtat szó.

767
01:10:01,500 --> 01:10:05,650
Az egyetlen dolog, amire szükséged van, hogy elkerülje aposztrófot

768
01:10:05,650 --> 01:10:09,470
mert különben azt hiszem, ez az egyetlen záró idézőjelek.

769
01:10:09,470 --> 01:10:15,050
Idézőjel, teljesen más.

770
01:10:20,300 --> 01:10:25,870
Már látni a szintaxis kiemelés cluing bennünket, hogy mi fog menni borzasztóan rossz.

771
01:10:25,870 --> 01:10:36,190
php.unique. Undefined variable: wooo mert ez értelmezi a változó nevű wooo.

772
01:10:36,190 --> 01:10:42,400
Dupla idézetek segítségével helyezze változók -

773
01:10:42,400 --> 01:10:52,730
Tegyük fel, hogy $ name = "Rob";

774
01:10:52,730 --> 01:10:58,020
Szóval echo "Hi, my name is $ name!";

775
01:10:58,020 --> 01:11:09,260
Elismeri ezt a változót.

776
01:11:09,260 --> 01:11:21,210
Amikor elindítom, hogy - és én helyezzen be egy újsor - Hi, my name is Rob! és hello world!

777
01:11:21,210 --> 01:11:24,910
Ez azért van, mert soha nem eltávolítani a nyomtatás wooo felett.

778
01:11:24,910 --> 01:11:30,020
Van 1 további lépés, amit tehetünk.

779
01:11:30,020 --> 01:11:39,250
$ Array = [1, 2, 3];

780
01:11:39,250 --> 01:11:43,270
Mit tegyek, ha szeretné kinyomtatni az első index a tömb?

781
01:11:43,270 --> 01:11:45,150
Ugye $ array [0].

782
01:11:45,150 --> 01:11:49,280
A szintaxis kiemelés egy nyom. Mit fog ez csinálni?

783
01:11:52,320 --> 01:11:54,510
php.unique.

784
01:11:54,510 --> 01:11:59,860
Hi, my name is 1! ami nem az, amit akartam.

785
01:11:59,860 --> 01:12:05,050
Szintaxiskiemelés hazudott nekem.

786
01:12:05,050 --> 01:12:13,020
Próbáljuk meg az "a" -> 1, 'b' -> 2.

787
01:12:18,450 --> 01:12:21,440
Így szerettem volna megírni.

788
01:12:26,350 --> 01:12:32,160
Váratlan aposztróf (T_ENCAPSED bla, bla, bla, bla, bla.)

789
01:12:32,160 --> 01:12:41,780
Az elképzelés az, hogy ez nem ismeri ezt a részeként a tömbben.

790
01:12:41,780 --> 01:12:46,620
Ez nem ismeri ezt indexelt tömb levélben a.

791
01:12:46,620 --> 01:12:49,870
Azt akarom, hogy a kapcsos zárójelek,

792
01:12:49,870 --> 01:12:54,730
és most mindent, ami ebben a kapcsos zárójel kerül interpolált

793
01:12:54,730 --> 01:13:00,340
amely a szó általunk használt varázslatosan beilleszteni ezeket a változókat a jobb helyeken.

794
01:13:00,340 --> 01:13:04,280
Most ezt, php.unique és Hi, my name is 1! a várt

795
01:13:04,280 --> 01:13:07,720
vagy Hi, my name is Rob!

796
01:13:14,110 --> 01:13:23,130
Egy dolog, hogy ez a fajta szép körülbelül aposztrófot, hogy -

797
01:13:23,130 --> 01:13:28,480
Van néhány költség interpolációs.

798
01:13:30,520 --> 01:13:35,100
Ha az idézőjelek, a tolmács is, hogy menjen át a húr,

799
01:13:35,100 --> 01:13:41,500
ügyelve arra, hogy: "Ó, itt van egy változót. Most mennem kell kap, hogy a változó és helyezze be ide."

800
01:13:41,500 --> 01:13:48,930
Még ha nem használ változókat,

801
01:13:48,930 --> 01:13:52,220
benne semmi ilyen idézőjelek közé kell interpolálni,

802
01:13:52,220 --> 01:13:56,800
de ez még mindig lassabb, mert szüksége van, hogy menjen át az idézőjelek

803
01:13:56,800 --> 01:14:00,130
keresem a dolgokat, amelyeket meg kell interpolálni.

804
01:14:00,130 --> 01:14:05,360
Így aposztrófot lehet egy kicsit gyorsabb, ha semmit sem kell interpolálni,

805
01:14:05,360 --> 01:14:15,650
és én inkább még egyszerű idézőjeleket, a "Hi, my name is." $ Array ['a'] egyébként.

806
01:14:15,650 --> 01:14:20,430
Ez lesz egyenértékű, amit korábban.

807
01:14:24,840 --> 01:14:28,440
De ez egy kérdés preferencia.

808
01:14:28,440 --> 01:14:34,750
Ha a PHP, akkor valószínűleg nem érdekel a sebesség különbség.

809
01:14:34,750 --> 01:14:39,480
Nincs elég értelem őket kezdeni.

810
01:14:39,480 --> 01:14:43,030
>> Bármely végleges még kérdése?

811
01:14:47,430 --> 01:14:51,710
>> Igazából nem is átvészelni az egészet, de ez a cucc volt unalmas.

812
01:14:51,710 --> 01:14:59,080
Az utolsó dolog, hogy ez a fajta jó a PHP-ben, ha dolgunk HTML,

813
01:14:59,080 --> 01:15:06,450
akkor használja egy kicsit, így a szép helyi szintaxis nyomtatásához változó.

814
01:15:32,400 --> 01:15:36,730
Anélkül, hogy PHP itt, ezt nevezzük rövid tag.

815
01:15:36,730 --> 01:15:44,330
Hivatalosan a PHP 5.4, ez elavult.

816
01:15:44,330 --> 01:15:48,640
Javasoljuk, hogy helyezze php.

817
01:15:48,640 --> 01:15:55,770
Ezt továbbra is támogatott, így a rövid tag a <? = Még mindig tökéletesen megfelel.

818
01:15:55,770 --> 01:16:02,480
Ez alapértelmezés szerint támogatott, így ezeket, ahogy szeretné, és ők nagyon kényelmes.

819
01:16:02,480 --> 01:16:05,700
>> Van még kérdése?

820
01:16:07,780 --> 01:16:09,270
Rendben van.

821
01:16:10,840 --> 01:16:13,800
>> Maradj klassz, San Diego.

822
01:16:13,800 --> 01:16:16,070
[Kuncog]

823
01:16:18,620 --> 01:16:22,660
Szia. [Nevet]

824
01:16:24,350 --> 01:16:28,470
[Taps] [nevet]

825
01:22:46,460 --> 01:22:49,460
>> [CS50.TV]