1
00:00:00,000 --> 00:00:02,610
[Powered by Google Translate] [Afsnit 8 - Mere behagelig]

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

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

4
00:00:11,520 --> 00:00:14,160
>> Disse uger afsnit noter vil være temmelig korte,

5
00:00:14,160 --> 00:00:19,070
så jeg bare har tænkt mig at holde taler, er du fyre kommer til at holde stille spørgsmål,

6
00:00:19,070 --> 00:00:22,720
og vi vil forsøge at fylde så meget tid som muligt.

7
00:00:22,720 --> 00:00:31,950
En masse mennesker tror, ​​at denne Pset ikke nødvendigvis er svært, men det er meget lang.

8
00:00:31,950 --> 00:00:37,070
Den Pset spec selv tager en time at læse.

9
00:00:40,530 --> 00:00:45,730
Vi giver dig en masse SQL du kunne muligvis behov for at bruge.

10
00:00:45,730 --> 00:00:50,520
Vi går du gennem en masse af det, så det burde ikke være alt for dårlig.

11
00:00:50,520 --> 00:00:54,560
Har nogen startet eller færdig?

12
00:00:55,380 --> 00:00:59,710
Det er den sidste Pset. Åh, min Gud.

13
00:00:59,710 --> 00:01:05,400
Normalt er der en JavaScript ene efter dette, men kalender ændre tingene

14
00:01:05,400 --> 00:01:09,560
gør alt 1 uge kortere, og vi ikke længere har en JavaScript Pset.

15
00:01:09,560 --> 00:01:12,310
Jeg ved ikke, hvordan det påvirker, om JavaScript vil blive vist på eksamen

16
00:01:12,310 --> 00:01:15,510
eller Quiz 1.

17
00:01:15,510 --> 00:01:22,260
Jeg forestiller mig, det vil være noget som du behøver at vide på højt niveau ting om JavaScript,

18
00:01:22,260 --> 00:01:26,460
men jeg tvivler på, vi ville bare give dig straight JavaScript-kode

19
00:01:26,460 --> 00:01:28,720
da du ikke har haft en Pset i det.

20
00:01:28,720 --> 00:01:33,000
Men det vil være ting for quiz revision i næste uge.

21
00:01:33,000 --> 00:01:36,320
>> Afsnit med spørgsmål.

22
00:01:36,320 --> 00:01:43,870
En masse af disse ting er noget dårligt formuleret, men vi vil diskutere hvorfor.

23
00:01:43,870 --> 00:01:50,220
I modsætning til C, er PHP en "dynamisk-skrevet" sprog. Hvad betyder det, spørger du?

24
00:01:50,220 --> 00:01:53,830
Nå, siger farvel til alle dem char, float, int, og andre søgeord du skal bruge

25
00:01:53,830 --> 00:01:56,190
når erklære variable og funktioner i C.

26
00:01:56,190 --> 00:02:00,420
I PHP, er en variabels type, bestemt af den værdi, den i øjeblikket bedrift.

27
00:02:00,420 --> 00:02:04,990
Så før vi skriver denne kode i en fil kaldet dynamic.php,

28
00:02:04,990 --> 00:02:12,670
PHP er dynamisk skrives. Det er rigtigt.

29
00:02:12,670 --> 00:02:17,590
Jeg er uenig med, at det betyder, at vi siger farvel til char, float, int,

30
00:02:17,590 --> 00:02:20,620
og andre søgeord.

31
00:02:20,620 --> 00:02:25,510
Den nøjagtige forskel mellem dynamisk maskinskrevet og subsidiært,

32
00:02:25,510 --> 00:02:32,010
der er statisk skrevet, er der dynamisk skrevet, er alle dine typekontrol og kram

33
00:02:32,010 --> 00:02:37,350
sker under kørslen, mens statisk skrevet det sker ved oversættelsen.

34
00:02:37,350 --> 00:02:43,030
Ordet statiske generelt synes at betyde kompilere tid ting.

35
00:02:43,030 --> 00:02:48,170
Jeg tror der er andre anvendelser for det, men i C, når du erklærer en statisk variabel,

36
00:02:48,170 --> 00:02:52,650
opbevaringen heraf fordeles påkompileringstidspunktet.

37
00:02:52,650 --> 00:02:59,260
Her dynamisk skrevet betyder blot, at -

38
00:02:59,260 --> 00:03:04,350
I C, hvis du forsøger at tilføje en streng og et heltal, når du kompilere det,

39
00:03:04,350 --> 00:03:11,000
det kommer til at klage fordi det kommer til at sige, at du ikke kan tilføje en int og en pegepind.

40
00:03:11,000 --> 00:03:14,710
Det er bare ikke en gyldig operation.

41
00:03:14,710 --> 00:03:21,170
Det er en anden ting, som vi vil komme til i et sekund.

42
00:03:21,170 --> 00:03:24,860
Men den slags kontrol, at det klager påkompileringstidspunktet,

43
00:03:24,860 --> 00:03:29,220
er statisk typekontrol.

44
00:03:29,220 --> 00:03:35,220
Der er sprog, hvor man ikke behøver at sige char, float, int, og alle disse ting,

45
00:03:35,220 --> 00:03:40,940
men sproget kan fortælle fra rammerne af ting, hvad type det er meningen at være,

46
00:03:40,940 --> 00:03:43,980
men det er stadig statisk indtastet.

47
00:03:43,980 --> 00:03:49,000
Så hvis du tager 51, OCaml, du aldrig behøver at bruge nogen af ​​disse typer,

48
00:03:49,000 --> 00:03:58,700
men det vil stadig påkompileringstidspunktet siger, du kan ikke gøre dette, fordi du blander en int og en streng.

49
00:03:58,700 --> 00:04:05,650
Dynamisk skrevet betyder bare, at engang i løbet køres tid du vil få en klage.

50
00:04:05,650 --> 00:04:13,430
Hvis du også har brugt Java før i almindelighed næsten enhver C-type sprog

51
00:04:13,430 --> 00:04:20,070
vil blive statisk skrives, så C, C + +, Java, alle af dem er generelt statisk indtastes.

52
00:04:20,070 --> 00:04:22,910
I Java når du kompilerer noget, og du siger

53
00:04:22,910 --> 00:04:26,670
string s lig ny noget, der ikke er en streng,

54
00:04:26,670 --> 00:04:28,950
der kommer til at klage fordi disse typer bare ikke passer sammen.

55
00:04:28,950 --> 00:04:31,180
Det kommer til at klage ved oversættelsen.

56
00:04:31,180 --> 00:04:36,750
Men det har også noget dynamisk tid ting som hvis du forsøger at kaste noget

57
00:04:36,750 --> 00:04:40,500
til en type, der er mere specifik end den nuværende type,

58
00:04:40,500 --> 00:04:45,610
der er ikke noget den kan gøre påkompileringstidspunktet at kontrollere, om der stemmer kommer til at lykkes.

59
00:04:45,610 --> 00:04:51,130
Java har også nogle dynamiske type kontrol af, at så snart det bliver til denne linje kode

60
00:04:51,130 --> 00:04:54,130
når det er faktisk bliver kørt, det kommer til at gøre de medvirkende,

61
00:04:54,130 --> 00:04:56,260
tjekke om dette stemmer var gyldig i første omgang,

62
00:04:56,260 --> 00:04:59,890
og hvis det ikke var, så det kommer til at klage over, at du har en ugyldig type.

63
00:04:59,890 --> 00:05:03,200
Dynamisk type, kontrol.

64
00:05:03,200 --> 00:05:07,010
Skriv dette i en fil kaldet dynamic.php.

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

66
00:05:14,580 --> 00:05:17,190
Vil jeg pakke det formatering.

67
00:05:18,750 --> 00:05:21,880
Vi har en variabel, vi har sat det til det hele tal 7,

68
00:05:21,880 --> 00:05:27,930
så vil vi udskrive den og% s -

69
00:05:27,930 --> 00:05:32,830
Oh, vi udskriver typen af ​​det, er så getType vil vende tilbage til typen af ​​den variable.

70
00:05:32,830 --> 00:05:35,720
Vi er bare udskriver den type igen og igen.

71
00:05:35,720 --> 00:05:39,440
Vi har lige php.dynamic.php.

72
00:05:39,440 --> 00:05:45,920
Vi vil se, at den ændres fra heltal til streng til Boolean som vi går igennem.

73
00:05:45,920 --> 00:05:54,590
I C er der ingen Boolean datatype, er der ingen streng datatype.

74
00:05:54,590 --> 00:06:00,500
Der er char * og Boolesk bare tendens til at være int eller char eller noget.

75
00:06:00,500 --> 00:06:05,690
I PHP disse typer, der findes, og det er en af ​​de store fordele ved PHP end C -

76
00:06:05,690 --> 00:06:13,290
at strengoperationer er uendeligt lettere i PHP end C. De bare arbejde.

77
00:06:13,290 --> 00:06:18,290
>> Så vi kommer tilbage her.

78
00:06:18,290 --> 00:06:21,260
Vi kørte dynamic.php.

79
00:06:21,260 --> 00:06:26,710
Dette fortæller PHP tolk, kaldet php, til at køre PHP-kode i dynamic.php.

80
00:06:26,710 --> 00:06:30,250
Hvis du har nogle fejl i filen, vil tolk fortælle dig!

81
00:06:30,250 --> 00:06:39,110
Tolken, dette er en anden stor forskel mellem PHP og C.

82
00:06:39,110 --> 00:06:48,200
I C du nødt til at oversætte noget, og derefter kører det kompileret fil.

83
00:06:48,200 --> 00:06:50,490
I PHP du aldrig kompilere noget.

84
00:06:50,490 --> 00:06:57,200
Så PHP fortolkeren er dybest set bare at læse denne linje for linje.

85
00:06:57,200 --> 00:07:02,900
Det rammer var = 7 så det rammer printf så det rammer var så det rammer printf og så videre.

86
00:07:02,900 --> 00:07:10,910
Der er en smule for at udarbejde det gør, og det cacher resultatet

87
00:07:10,910 --> 00:07:15,510
så hvis du kører scriptet senere du kan gøre nogle,

88
00:07:15,510 --> 00:07:19,280
men dybest set er det en linje for linje slags ting.

89
00:07:19,280 --> 00:07:25,280
Det betyder, at mange af de optimeringer, vi får i C,

90
00:07:25,280 --> 00:07:31,920
ligesom kompilering, er det bare generelt compileren kan gøre en masse tricks for dig.

91
00:07:31,920 --> 00:07:36,110
Det kan tage ud ubrugte variabler, kan det gøre alle disse slags ting,

92
00:07:36,110 --> 00:07:38,660
det kan gøre hale rekursion.

93
00:07:38,660 --> 00:07:42,550
I PHP, du ikke vil få denne fordel

94
00:07:42,550 --> 00:07:45,690
fordi det bare kommer til at starte fuldbyrdende linje for linje for linje,

95
00:07:45,690 --> 00:07:49,950
og det gør ikke rigtig genkende disse ting så let

96
00:07:49,950 --> 00:07:54,440
da det ikke er 1 stor samling pass over ting og derefter udførelse;

97
00:07:54,440 --> 00:07:56,860
det er bare linje for linje.

98
00:08:00,730 --> 00:08:02,750
Så det er tolk.

99
00:08:02,750 --> 00:08:06,840
>> Tilbage til vores dynamiske skrive: pretty cool, eh?

100
00:08:06,840 --> 00:08:08,640
Du absolut ikke kunne gøre det i C!

101
00:08:08,640 --> 00:08:11,860
Nu, se om du kan finde ud af, hvilken type af hver af de følgende værdier.

102
00:08:11,860 --> 00:08:14,760
Se dette som reference.

103
00:08:14,760 --> 00:08:19,420
Så 3,50. Hvilken type tror du der kommer til at være?

104
00:08:24,480 --> 00:08:26,370
Her er de typer, vi har.

105
00:08:26,370 --> 00:08:30,430
Vi har bools, heltal, flydende punkter, strygere, arrays, objekter,

106
00:08:30,430 --> 00:08:38,370
og derefter ressourcer, som er form for vag.

107
00:08:38,370 --> 00:08:41,010
Jeg tror, ​​der er faktisk et eksempel her.

108
00:08:41,010 --> 00:08:43,740
Så er der NULL. NULL er en speciel type.

109
00:08:43,740 --> 00:08:47,140
I modsætning til C hvor NULL er blot en pointer med adresse 0,

110
00:08:47,140 --> 00:08:54,930
i PHP, er NULL sin egen type, hvor det eneste gyldige ting af denne type er NULL.

111
00:08:57,560 --> 00:09:00,670
Dette er meget mere nyttigt for fejlkontrol.

112
00:09:00,670 --> 00:09:04,310
I C hvor vi havde dette problem hvor Hvis du returnere NULL,

113
00:09:04,310 --> 00:09:08,660
betyder det, at du returnerer en NULL pointer eller bruge NULL til at betyde fejl

114
00:09:08,660 --> 00:09:12,380
af eller hele denne forvirring, vi havde på et tidspunkt.

115
00:09:12,380 --> 00:09:18,440
Her vender NULL betyder generelt fejl.

116
00:09:20,860 --> 00:09:27,300
En masse ting også returnere false for fejl.

117
00:09:27,300 --> 00:09:33,140
Men pointen er den NULL type, det eneste af den NULL type er NULL.

118
00:09:33,140 --> 00:09:40,090
Så tilbagekald er ligesom du kan definere nogle anonyme funktioner.

119
00:09:40,090 --> 00:09:46,420
Du behøver ikke at give funktionen et navn, men du vil ikke have at beskæftige sig med det her.

120
00:09:46,420 --> 00:09:53,940
Ser man på de typer, som de ikke forventer os at vide,

121
00:09:53,940 --> 00:09:59,000
hvad tror du, hvilken type 3,50 er? >> [Studerende] Float.

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

123
00:10:00,370 --> 00:10:06,290
Altsaa her, hvad tror du, hvilken type af denne er? >> [Studerende] Array.

124
00:10:06,290 --> 00:10:09,890
Yeah. Det første var float, den anden er et array.

125
00:10:09,890 --> 00:10:14,500
Bemærk, at dette array ikke er som et C-array

126
00:10:14,500 --> 00:10:19,610
hvor du har index 0 har en vis værdi, index 1 har en vis værdi.

127
00:10:19,610 --> 00:10:26,320
Her indeks er a, b og c og værdierne er 1, 2, og 3..

128
00:10:26,320 --> 00:10:33,980
I PHP er der ingen forskel mellem en associativ array og bare en almindelig opstilling

129
00:10:33,980 --> 00:10:36,740
som du ville tænke på det i C.

130
00:10:36,740 --> 00:10:43,040
Der er blot dette, og under hætten en regelmæssig række er bare et associativt array

131
00:10:43,040 --> 00:10:50,000
hvor 0 kort til en vis værdi på samme måde en kort til en vis værdi.

132
00:10:50,000 --> 00:11:00,410
Af denne grund, kan PHP være temmelig dårligt for virkelig hurtig kode / benchmarking ting

133
00:11:00,410 --> 00:11:07,930
da der i C, når du bruger et array du ved, at adgang til et medlem er konstant tid.

134
00:11:07,930 --> 00:11:11,860
I PHP adgang til en medlem er der ved hvor meget tid?

135
00:11:11,860 --> 00:11:18,970
Det er sandsynligvis konstant, hvis det hashes korrekt.

136
00:11:18,970 --> 00:11:21,620
Hvem ved, hvad det virkelig gør under kølerhjelmen?

137
00:11:21,620 --> 00:11:25,600
Du har virkelig brug for at se på gennemførelsen for at se, hvordan det kommer til at beskæftige sig med det.

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

139
00:11:28,550 --> 00:11:36,420
Jeg tror her lad os bare PHP manual fopen til at se på returtype.

140
00:11:36,420 --> 00:11:41,260
Vi ser her kan du slå op stort set enhver funktion i PHP manualen

141
00:11:41,260 --> 00:11:47,540
og dette er en slags manden side af PHP.

142
00:11:47,540 --> 00:11:51,060
Afkastet typen vil være ressource.

143
00:11:51,060 --> 00:11:56,050
Det er derfor, jeg slog det op, fordi vi ikke rigtig definere ressource.

144
00:11:56,050 --> 00:12:04,110
Ideen om ressource i C du slags fik en FIL * eller hvad;

145
00:12:04,110 --> 00:12:07,200
i PHP ressourcen er din FILE *.

146
00:12:07,200 --> 00:12:10,360
Det er, hvad du kommer til at læse fra, det er hvad du vil skrive til.

147
00:12:10,360 --> 00:12:20,710
Det er som regel eksterne, så det er en ressource, du kan trække ting fra og kaste ting til.

148
00:12:20,710 --> 00:12:26,520
Og endelig, hvad er den type NUL? >> [Studerende] NULL.

149
00:12:26,520 --> 00:12:30,650
Yeah. Så det eneste, der er NULL er NULL.

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

151
00:12:35,490 --> 00:12:41,170
>> Et træk af PHP-typen system (for bedre eller værre) er dens evne til at jonglere typer.

152
00:12:41,170 --> 00:12:44,390
Når du skriver en linje af PHP kode, der kombinerer værdier af forskellige typer,

153
00:12:44,390 --> 00:12:46,670
PHP vil forsøge at gøre det fornuftige.

154
00:12:46,670 --> 00:12:48,920
Prøv hver af de følgende linjer af PHP kode. Hvad er udskrevet?

155
00:12:48,920 --> 00:12:51,000
Er det hvad du forventede? Hvorfor eller hvorfor ikke?

156
00:12:51,000 --> 00:12:58,600
Dette faktum om PHP er hvad gør det, hvad vi kalder svagt indtastet.

157
00:12:58,600 --> 00:13:04,610
Svagt skrevet og stærkt skrevet,

158
00:13:04,610 --> 00:13:06,840
der er forskellige anvendelser for disse begreber,

159
00:13:06,840 --> 00:13:12,020
men de fleste mennesker bruger svagt skrevet og stærkt skrevet at betyde den slags ting

160
00:13:12,020 --> 00:13:15,920
hvor ("1" + 2), der virker.

161
00:13:15,920 --> 00:13:18,290
I C, der ikke ville arbejde.

162
00:13:18,290 --> 00:13:22,490
Du kan forestille dig dette ikke fungerer.

163
00:13:22,490 --> 00:13:29,200
En masse mennesker blandes op dynamisk skrive og svag skrive og statisk skrive og stærk skrive.

164
00:13:29,200 --> 00:13:34,050
Python er et andet eksempel på et sprog, der er dynamisk skrevet.

165
00:13:34,050 --> 00:13:41,770
Du kan smide rundt typer i variabler og det kommer til at afgøre på kørselstidspunktet

166
00:13:41,770 --> 00:13:44,680
eventuelle fejl kontroller,.

167
00:13:44,680 --> 00:13:50,740
I Python det kommer til at udføre dette, og det vil se ("1" + 2);

168
00:13:50,740 --> 00:13:55,920
og dette vil mislykkes, fordi det siger du kan ikke tilføje en streng og et heltal.

169
00:13:55,920 --> 00:14:00,860
I PHP, som er lige så dynamisk skrevet, vil dette ikke mislykkes.

170
00:14:00,860 --> 00:14:04,220
Svag typebestemmelse har at gøre med det faktum, at det gør tingene med typer

171
00:14:04,220 --> 00:14:07,800
som ikke rigtig mening nødvendigvis.

172
00:14:07,800 --> 00:14:17,420
Så ("1" + 2), og jeg kan forestille mig, at det at være strengen 12, kan jeg forestille mig, det er den streng 3,

173
00:14:17,420 --> 00:14:20,710
Jeg kan forestille mig, det er det hele tal 3.

174
00:14:20,710 --> 00:14:24,530
Det er ikke nødvendigvis godt defineret, og vi sandsynligvis kommer til at se her

175
00:14:24,530 --> 00:14:29,140
at når vi udskriver ("1" + 2), det er nok kommer til at ende med at blive anderledes

176
00:14:29,140 --> 00:14:32,320
end udskrivning (1 + "2").

177
00:14:32,320 --> 00:14:39,700
Og det plejer at være, efter min mening, til det værre.

178
00:14:39,700 --> 00:14:44,240
Her kan vi prøve disse.

179
00:14:44,240 --> 00:14:48,740
Et andet lille trick om PHP er du ikke behøver at faktisk skrive filen.

180
00:14:48,740 --> 00:14:52,790
Det har kørt denne kommando mode.

181
00:14:52,790 --> 00:14:57,710
Så php-r, så vi kan smide i kommandoen her:

182
00:14:57,710 --> 00:15:06,610
"Print ('1 '+ 2)," og jeg smider en ny linje.

183
00:15:19,550 --> 00:15:23,970
Dette trykte 3.

184
00:15:31,100 --> 00:15:35,330
Det ser ud som det udskrives 3, og det er det hele tal 3.

185
00:15:35,330 --> 00:15:38,420
Så lad os nu prøve den anden vej rundt:

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

187
00:15:45,560 --> 00:15:50,490
Vi får 3, og er det også kommer til at være heltal 3? Jeg ærligt har ingen idé.

188
00:15:50,490 --> 00:15:54,030
Det ligner, der er konsistent.

189
00:15:54,030 --> 00:15:59,550
Der er aldrig nogen chance for at det er strengen 12 eller sådan noget

190
00:15:59,550 --> 00:16:08,080
fordi PHP, i modsætning til JavaScript og Java også,

191
00:16:08,080 --> 00:16:11,670
har en separat operatør for sammenkædning.

192
00:16:11,670 --> 00:16:14,930
Sammenkædning i PHP er prik.

193
00:16:14,930 --> 00:16:22,950
Så udskrivning (1 '2 '.) Vil give os 12.

194
00:16:25,790 --> 00:16:32,420
Denne tendens til at føre til forvirring, hvor folk forsøger at gøre noget som str + =

195
00:16:32,420 --> 00:16:37,840
nogle andre ting, som de ønsker at tilføje til slutningen af ​​deres streng, og det kommer til at mislykkes.

196
00:16:37,840 --> 00:16:40,770
Du er nødt til at gøre str. =

197
00:16:42,000 --> 00:16:46,240
Så glem ikke sammenkædning i PHP er en prik.

198
00:16:46,240 --> 00:16:52,100
Andre ting, du kan prøve: Print ("CS" + 50);

199
00:16:55,750 --> 00:17:03,610
Jeg har fortalt dig, at der ikke er noget håb for denne resulterer i CS50

200
00:17:03,610 --> 00:17:06,119
idet sammenkædning ikke +.

201
00:17:06,119 --> 00:17:08,440
Hvad tror du, det kommer til at ende med at blive?

202
00:17:10,359 --> 00:17:13,460
Jeg ærligt har absolut ingen idé.

203
00:17:14,250 --> 00:17:16,460
Det ser ud til det er bare 50.

204
00:17:16,460 --> 00:17:21,490
Det ser strengen, og jeg vædde på, hvis vi sætter 123CS -

205
00:17:21,490 --> 00:17:29,640
Det ser den første streng, det forsøger at læse et helt tal fra det eller et nummer fra det.

206
00:17:29,640 --> 00:17:31,710
I dette tilfælde er det ser 123CS.

207
00:17:31,710 --> 00:17:35,190
"Det giver ingen mening som et heltal, så jeg bare at tænke på 123".

208
00:17:35,190 --> 00:17:38,580
Så 123 + 50 vil være 173.

209
00:17:38,580 --> 00:17:40,740
Og her begynder det at læse dette som et heltal.

210
00:17:40,740 --> 00:17:45,690
Det ser ikke noget, så det bare behandler det som 0. Så 0 + 50 vil være 50.

211
00:17:45,690 --> 00:17:51,600
Dette Jeg antager kommer til at gøre noget lignende.

212
00:17:51,600 --> 00:17:54,310
Jeg tænker 99.

213
00:17:54,310 --> 00:17:57,580
Ja, fordi det kommer til at tage det første -

214
00:18:12,880 --> 00:18:15,730
So 99.

215
00:18:15,730 --> 00:18:21,970
Her (10/7), hvis dette var C, hvad ville det vende tilbage?

216
00:18:23,700 --> 00:18:29,630
[Studerende] 1. >> Ja, det ville være 1, fordi 10/7 er at dividere 2 heltal.

217
00:18:29,630 --> 00:18:32,910
Et heltal divideret med et heltal vil returnere et heltal.

218
00:18:32,910 --> 00:18:37,750
Det kan ikke returnere 1 point hvad det så end ville være, så det er bare at vende tilbage 1.

219
00:18:37,750 --> 00:18:46,120
Her udskrivning (10/7); det kommer til rent faktisk at fortolke det.

220
00:18:46,120 --> 00:18:53,760
Og det betyder, at hvis du rent faktisk ønsker at gøre heltal afrunding og den slags,

221
00:18:53,760 --> 00:18:59,950
du behøver at gøre print (gulv (10/7));

222
00:18:59,950 --> 00:19:08,460
I C er det nok underligt, at du kan stole på afkortede heltal regelmæssigt,

223
00:19:08,460 --> 00:19:12,260
men i PHP, kan du ikke fordi det automatisk vil gøre det til en float.

224
00:19:13,430 --> 00:19:17,610
Og så (7 + true); hvad tror du der kommer til at være?

225
00:19:18,550 --> 00:19:23,640
Jeg kan gætte 8, hvis det kommer til at fortolke sandt som 1.

226
00:19:23,640 --> 00:19:25,740
Det ser ud til det er 8.

227
00:19:25,740 --> 00:19:31,710
>> Så alt vi har gjort i de sidste 10 minutter, du bør absolut aldrig gøre.

228
00:19:31,710 --> 00:19:39,870
Du vil se kode, der gør dette.

229
00:19:39,870 --> 00:19:42,700
Det behøver ikke at være så enkel som dette.

230
00:19:42,700 --> 00:19:47,240
Du kunne have 2 variabler, og 1 variabel sker for at være en streng

231
00:19:47,240 --> 00:19:51,310
og den anden variabel sker for at være en int, og derefter tilføjer du disse variabler sammen.

232
00:19:51,310 --> 00:20:00,120
Da PHP dynamisk der skrives, og det vil ikke gøre nogen typekontrol for dig

233
00:20:00,120 --> 00:20:03,640
og da det svagt er skrevet, og da det bare vil automatisk smide disse ting sammen

234
00:20:03,640 --> 00:20:11,490
og alt vil bare arbejde, er det svært at selv vide, at denne variabel skal være en streng nu,

235
00:20:11,490 --> 00:20:14,930
så jeg skal ikke tilføje det til denne variabel, som er et heltal.

236
00:20:18,780 --> 00:20:24,560
Bedste praksis er, hvis en variabel er en streng, holde det som en streng for evigt.

237
00:20:24,560 --> 00:20:26,980
Hvis en variabel er en int, holde det som en int evigt.

238
00:20:26,980 --> 00:20:30,770
Hvis du ønsker at beskæftige sig med tal og strygere,

239
00:20:30,770 --> 00:20:36,970
du kan bruge varsint - det er JavaScript.

240
00:20:36,970 --> 00:20:42,520
Intval. Jeg gør det hele tiden. PHP og JavaScript jeg blander alt.

241
00:20:42,520 --> 00:20:47,600
Så intval vil returnere heltal værdien af ​​en variabel.

242
00:20:47,600 --> 00:20:56,550
Hvis vi passerer i "print (intval ('123 ')); får du 123.

243
00:21:06,820 --> 00:21:15,850
Intval ikke selv tænkt sig at gøre kontrollen for os, at det er udelukkende et heltal.

244
00:21:15,850 --> 00:21:20,460
PHP manual, der er bare så mange funktioner til rådighed,

245
00:21:20,460 --> 00:21:26,560
så her jeg mener, hvad jeg ville bruge er is_numeric først.

246
00:21:26,560 --> 00:21:32,590
Jeg kan gætte, at returnerede falsk.

247
00:21:32,590 --> 00:21:35,780
Det er en anden ting, vi er nødt til at gå over er ===.

248
00:21:37,850 --> 00:21:44,020
Så is_numeric ('123df «), ville du ikke tænke på, at så is_numeric.

249
00:21:44,020 --> 00:21:46,720
I C ville du nødt til at gentage over alle tegn

250
00:21:46,720 --> 00:21:50,410
og kontrollere, om hver karakter er ciffer eller hvad.

251
00:21:50,410 --> 00:21:53,850
Her is_numeric vil gøre det for os,

252
00:21:53,850 --> 00:21:56,520
og det er tilbage falsk.

253
00:21:56,520 --> 00:22:02,120
Så da jeg udskrevet det, det trykte ingenting, så her er jeg sammenligne det at se,

254
00:22:02,120 --> 00:22:05,490
har du tilfældigvis er falsk? Og så nu er det udskrivning 1.

255
00:22:05,490 --> 00:22:10,060
Tilsyneladende udskriver den 1 som sand i stedet for at printe sandt som sandt.

256
00:22:10,060 --> 00:22:15,790
Jeg spekulerer på, om jeg gør print_r. Nej, det stadig gør 1.

257
00:22:15,790 --> 00:22:26,760
>> Går tilbage til ===, == stadig eksisterer,

258
00:22:26,760 --> 00:22:32,260
og hvis du taler med Tommy han vil sige == er helt fint.

259
00:22:32,260 --> 00:22:37,700
Jeg har tænkt mig at sige, at == er forfærdeligt, og du bør aldrig bruge ==.

260
00:22:37,700 --> 00:22:44,870
Forskellen er, at == sammenligner tingene

261
00:22:44,870 --> 00:22:48,450
hvor det kan være tilfældet, selvom de ikke er af samme type,

262
00:22:48,450 --> 00:22:53,810
hvorimod === sammenligner ting og først kontrollerer er de samme type?

263
00:22:53,810 --> 00:22:58,010
Ja. Okay, nu vil jeg se, om de rent faktisk sammenligne at være lige.

264
00:22:58,010 --> 00:23:08,890
Du får underlige ting som 10 lig - Lad os se, hvad det siger.

265
00:23:08,890 --> 00:23:15,570
Så ('10 '== '1 e1');

266
00:23:15,570 --> 00:23:17,980
Det returnerer sandt.

267
00:23:17,980 --> 00:23:21,420
Er der nogen der har nogen gæt hvorfor dette returnerer sandt?

268
00:23:25,180 --> 00:23:27,120
Det handler ikke kun om det. Måske dette er et hint.

269
00:23:27,120 --> 00:23:33,170
Men hvis jeg ændre det til en f - darn det! Jeg holder ved hjælp anførselstegn.

270
00:23:33,170 --> 00:23:38,780
Grunden de dobbelte citater råben på mig, er fordi jeg har sat dette i anførselstegn.

271
00:23:38,780 --> 00:23:43,850
Så jeg kunne undslippe de dobbelte anførselstegn i her, men enkelte anførselstegn gøre det lettere.

272
00:23:43,850 --> 00:23:49,120
Så ('10 '== '1 f1'); udskriver ikke sandt. ('10 '== '1 E1'); udskriver sandt.

273
00:23:49,120 --> 00:23:56,330
[Studerende] Er det hex? >> Det er ikke hex, men det er tæt på, at det er ligesom -

274
00:23:56,330 --> 00:24:01,060
1E1, videnskabelig notation.

275
00:24:01,060 --> 00:24:07,950
Det erkender 1E1 som 1 * 10 ^ 1 eller whatever.

276
00:24:07,950 --> 00:24:11,510
Det er lige heltal.

277
00:24:11,510 --> 00:24:15,930
Hvis vi gør === så det kommer til at være falsk.

278
00:24:15,930 --> 00:24:28,490
Jeg har faktisk ingen idé, hvis vi gør == hvad (10 og '10abc ');? Ok. Så det er sandt.

279
00:24:28,490 --> 00:24:35,940
Så ligesom når du gjorde (10 + '10abc «), og det ville være 20,

280
00:24:35,940 --> 00:24:38,800
her (10 == '10abc '); er sandt.

281
00:24:38,800 --> 00:24:45,350
Endnu værre er ting som (falsk == NULL); er sandt

282
00:24:45,350 --> 00:24:52,210
eller (false == 0), er sandt, (false == []);

283
00:24:52,210 --> 00:25:00,970
Der er underlige tilfælde - Det er en af ​​de mærkelige sager.

284
00:25:00,970 --> 00:25:08,110
Bemærk, at (falsk == []) er sandt.

285
00:25:08,110 --> 00:25:11,950
('0 '== False), er sandt.

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

287
00:25:16,090 --> 00:25:19,090
Så == er på ingen måde transitiv.

288
00:25:19,090 --> 00:25:26,830
a kan være lig med b og a kan være lig med c,

289
00:25:26,830 --> 00:25:29,340
men b måske ikke være lig med ca.

290
00:25:29,340 --> 00:25:35,580
Det er en vederstyggelighed for mig, og du bør altid bruge ===.

291
00:25:35,580 --> 00:25:38,590
[Studerende] Kan vi gøre! == Så godt? >> [Bowden] Ja.

292
00:25:38,590 --> 00:25:44,600
Den tilsvarende ville være! = Og! ==.

293
00:25:44,600 --> 00:25:48,230
Dette er faktisk opdraget i Pset spec

294
00:25:48,230 --> 00:25:52,000
hvor en masse funktioner afkast -

295
00:25:52,000 --> 00:25:53,890
PHP manual er godt om dette.

296
00:25:53,890 --> 00:25:59,140
Det lægger en stor rød boks, "Dette vil returnere falsk, hvis der er en fejl."

297
00:25:59,140 --> 00:26:03,940
Men tilbage 0 er en helt rimelig ting at vende tilbage.

298
00:26:03,940 --> 00:26:08,250
Tænk enhver funktion, som forventes at vende tilbage et heltal.

299
00:26:11,250 --> 00:26:17,880
Lad os sige, denne funktion er meningen at tælle antallet af linier i en fil eller noget.

300
00:26:17,880 --> 00:26:23,490
Under normale omstændigheder passerer man denne funktion en fil

301
00:26:23,490 --> 00:26:27,120
og det kommer til at returnere et heltal, der repræsenterer antallet af linjer.

302
00:26:27,120 --> 00:26:30,820
Så 0 er et helt rimeligt antal, hvis filen er bare tom.

303
00:26:30,820 --> 00:26:36,810
Men hvad nu hvis du passerer det en ugyldig fil og funktionen sker for at returnere falsk

304
00:26:36,810 --> 00:26:38,860
hvis du passerer det en ugyldig fil?

305
00:26:38,860 --> 00:26:46,500
Hvis du bare gør == du ikke differentiere tilfældet mellem ugyldig fil og tom fil.

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

307
00:26:55,690 --> 00:26:58,000
Det er alt af dem.

308
00:26:58,000 --> 00:27:01,660
>> I PHP, er det tabeltype anderledes, end du er vant til i C.

309
00:27:01,660 --> 00:27:06,650
Faktisk har du måske allerede bemærket dette ovenfor, når du så, at det er af typen array.

310
00:27:06,650 --> 00:27:15,640
Konsollen syntaks er ny som i PHP 5,4, som er den nyeste version af PHP.

311
00:27:15,640 --> 00:27:36,960
Før dette kan du altid nødt til at skrive array ('a' -> 1, 'b' -> 2.

312
00:27:36,960 --> 00:27:41,160
Det var constructoren for et array.

313
00:27:41,160 --> 00:27:45,950
Nu PHP er endelig kommet rundt til nice syntaks af blot kantede parenteser,

314
00:27:45,950 --> 00:27:50,900
der er bare så meget bedre end array.

315
00:27:50,900 --> 00:27:54,480
Men i betragtning af PHP 5,4 er den nyeste version,

316
00:27:54,480 --> 00:27:59,090
kan du støde på steder, der ikke engang har PHP 5.3.

317
00:27:59,090 --> 00:28:08,220
I løbet af sommeren vi løb ind i dette spørgsmål, hvor PHP 5,3 var, hvad vi havde på apparatet,

318
00:28:08,220 --> 00:28:14,480
men den server, vi indsatte alle vores karakterbog og indsende og alt det der til

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

320
00:28:16,750 --> 00:28:23,060
Ikke kender dette, vi udviklede i 5,3, skubbede til 5,4,

321
00:28:23,060 --> 00:28:25,660
og nu pludselig ingen af ​​vores kode virker

322
00:28:25,660 --> 00:28:28,680
fordi der tilfældigvis har været ændringer mellem 5,3 og 5,4

323
00:28:28,680 --> 00:28:31,030
som ikke er bagud kompatible,

324
00:28:31,030 --> 00:28:35,770
og vi er nødt til at gå og ordne alle vores ting, der ikke fungerer for PHP 5,4.

325
00:28:39,210 --> 00:28:42,320
For denne klasse, har siden apparatet gør PHP 5,4,

326
00:28:42,320 --> 00:28:45,490
det er helt fint at bruge kantede parenteser.

327
00:28:47,240 --> 00:28:50,440
Men hvis du søger ting op omkring Internettet,

328
00:28:50,440 --> 00:28:54,880
hvis du søger op eller anden form for array-ting, mest sandsynligt du vil se

329
00:28:54,880 --> 00:29:02,020
magien ud arrayet konstruktionsfunktionsyntaks siden, der har eksisteret siden PHP blev født

330
00:29:02,020 --> 00:29:07,340
og firkantede beslag syntaks har eksisteret i de sidste par måneder

331
00:29:07,340 --> 00:29:10,020
eller når 5,4 kom rundt.

332
00:29:10,020 --> 00:29:12,710
Dette er, hvordan du indeks.

333
00:29:12,710 --> 00:29:30,610
Ligesom i C hvordan du ville indekset med firkantede parenteser som $ array [0], $ array [1], $ array [2],

334
00:29:30,610 --> 00:29:36,320
du index på samme måde, hvis du tilfældigvis har dine indeks er strenge.

335
00:29:36,320 --> 00:29:40,440
Så $ array ['a'] og $ array ['b'].

336
00:29:40,440 --> 00:29:47,410
$ Array [b]. Hvorfor skulle det være forkert?

337
00:29:52,490 --> 00:29:59,870
Det vil sandsynligvis generere en advarsel, men stadig arbejde. PHP har tendens til at gøre det.

338
00:29:59,870 --> 00:30:04,890
Det har tendens til bare, "Jeg har tænkt mig at advare dig om dette, men jeg vil bare at holde i gang

339
00:30:04,890 --> 00:30:07,550
"Og gøre, hvad jeg kan."

340
00:30:07,550 --> 00:30:11,500
Det vil sandsynligvis oversætte dette til en streng,

341
00:30:11,500 --> 00:30:15,000
men det er muligt at på et tidspunkt i fortiden nogen sagde

342
00:30:15,000 --> 00:30:20,180
definere b for at være "Hello World".

343
00:30:20,180 --> 00:30:28,740
Så nu B kunne være en konstant og $ array [b] rent faktisk vil gøre "Hello World".

344
00:30:28,740 --> 00:30:32,380
Jeg tror på dette punkt, eller i det mindste vores PHP-indstillinger,

345
00:30:32,380 --> 00:30:37,870
hvis du forsøger at indeksere i et array, og at nøglen ikke eksisterer, vil det mislykkes.

346
00:30:37,870 --> 00:30:40,150
Jeg tror ikke, det vil bare advare dig.

347
00:30:40,150 --> 00:30:44,560
Eller i det mindste du kan indstille den, så den ikke bare advare dig, det bare lige op mislykkes.

348
00:30:44,560 --> 00:30:49,290
>> Den måde, du kontrollere, om der rent faktisk er sådan et indeks er isset.

349
00:30:49,290 --> 00:30:54,690
Så isset ($ array ['Hello World']) vil returnere falsk.

350
00:30:54,690 --> 00:30:59,160
isset ($ array ['b']) vil returnere sandt.

351
00:31:06,830 --> 00:31:09,880
Du kan blande disse syntakser.

352
00:31:15,060 --> 00:31:22,440
Jeg er temmelig sikker på, hvad dette array ville ende med at blive, er - Vi kan teste det ud.

353
00:31:43,290 --> 00:31:45,700
Åh, jeg har brug PHPWord.

354
00:31:53,960 --> 00:32:00,260
Dette er at blande den syntaks, hvor du angiver, hvad nøglen er

355
00:32:00,260 --> 00:32:03,330
og du behøver ikke angive, hvad nøglen er.

356
00:32:03,330 --> 00:32:05,520
Så 3 højre her er en værdi.

357
00:32:05,520 --> 00:32:08,080
Du har ikke udtrykkeligt sagt, hvad dens nøgle bliver.

358
00:32:08,080 --> 00:32:11,670
Hvad tror du sit nøgle kommer til at være?

359
00:32:11,670 --> 00:32:21,410
[Studerende] 0. >> Jeg gætte 0 kun fordi det er det første vi har ikke specificeret.

360
00:32:21,410 --> 00:32:23,500
Vi kan faktisk gøre et par af disse sager.

361
00:32:23,500 --> 00:32:28,030
Så print_r er udskrive rekursiv. Det vil udskrive hele array.

362
00:32:28,030 --> 00:32:32,700
Det ville udskrive subarrays af arrayet hvis der var nogen.

363
00:32:32,700 --> 00:32:36,630
Så print_r ($ array); php.test.php.

364
00:32:36,630 --> 00:32:38,810
Det ser ud, som den gav det 0.

365
00:32:38,810 --> 00:32:43,530
Der er faktisk noget at huske på her, men vi vil komme tilbage til det i en anden.

366
00:32:43,530 --> 00:32:45,850
Men hvad nu hvis jeg kommer til at lave dette indeks 1?

367
00:32:45,850 --> 00:32:51,170
PHP skelner ikke mellem streng indekser og integer indekser,

368
00:32:51,170 --> 00:33:00,280
så på dette punkt Jeg har netop defineret et indeks 1 og jeg kan gøre begge dele $ array [1] og $ array ['1 ']

369
00:33:00,280 --> 00:33:06,250
og det vil være det samme indeks og samme nøgle.

370
00:33:06,250 --> 00:33:13,000
Så hvad nu tror du 3 kommer til at være? >> [Studerende] 2. >> [Bowden] Jeg kan gætte 2.

371
00:33:16,000 --> 00:33:18,690
Yeah. Det er 2.

372
00:33:18,690 --> 00:33:24,790
Hvad hvis vi gjorde dette er 10, det er 4? Hvad tror du indekset på 3 bliver?

373
00:33:27,360 --> 00:33:29,110
Jeg tænker 11.

374
00:33:29,110 --> 00:33:33,060
Mit gæt på hvad PHP gør - og jeg tror, ​​jeg har set det før -

375
00:33:33,060 --> 00:33:39,760
er det blot holder styr på, hvad det højeste numeriske indeks det bruges hidtil er.

376
00:33:39,760 --> 00:33:44,230
Det er aldrig kommer til at tildele en streng indeks til 3. Det vil altid være et numerisk indeks.

377
00:33:44,230 --> 00:33:47,690
Så det holder styr på det højeste det er tildelt hidtil, hvilket sker for at være 10,

378
00:33:47,690 --> 00:33:52,540
og det kommer til dannelse af 11 til 3.

379
00:33:52,540 --> 00:34:02,110
Hvad jeg sagde før, bemærk den måde, det er ved at udskrive denne array.

380
00:34:02,110 --> 00:34:06,850
Den udskriver tast 10, tast 4, tast 11, tasten d.

381
00:34:06,850 --> 00:34:09,790
Eller endda lade os gøre -

382
00:34:15,760 --> 00:34:22,489
Jeg gætter jeg ikke sætte et 0, men det er udskrivning 1, 2, 3, 4.

383
00:34:22,489 --> 00:34:29,330
Hvad hvis jeg skifter her? Eller lad os faktisk skifte disse 2.

384
00:34:29,330 --> 00:34:31,940
Nu udskriver 2, 1, 3, 4.

385
00:34:31,940 --> 00:34:41,270
PHP er arrays er ikke ligesom din almindelige hash tabellen.

386
00:34:41,270 --> 00:34:45,570
Det er helt rimeligt at tænke på dem som hash tabeller 99% af tiden.

387
00:34:45,570 --> 00:34:53,790
Men i dine hash tabeller er der ingen fornemmelse af, i hvilken rækkefølge tingene blev indsat.

388
00:34:53,790 --> 00:34:56,639
Så så snart du indsætter det i din hash tabel,

389
00:34:56,639 --> 00:35:00,590
antage, at der er ingen linkede liste, og du kan dømme i en sammenkædet liste

390
00:35:00,590 --> 00:35:03,980
som blev indsat først.

391
00:35:03,980 --> 00:35:10,060
Men her har vi indsat 2 første, og det ved, hvornår det er at udskrive dette array, at 2 kommer først.

392
00:35:10,060 --> 00:35:13,090
Det betyder ikke printe det ud i en hvilken som helst rækkefølge.

393
00:35:13,090 --> 00:35:17,550
De tekniske data struktur, at det er ved hjælp af en ordnet kort,

394
00:35:17,550 --> 00:35:24,690
så den rummer nøglerne til værdier og den husker den rækkefølge, hvori disse nøgler blev indsat.

395
00:35:24,690 --> 00:35:31,600
Dybest set er det til nogle komplikationer, hvor det er irriterende at der faktisk -

396
00:35:31,600 --> 00:35:34,510
Lad os sige du har et array 0, 1, 2, 3, 4, 5

397
00:35:34,510 --> 00:35:37,700
og du ønsker at tage ud index 2.

398
00:35:37,700 --> 00:35:47,750
En måde at gøre det på, lad os se hvad der ligner.

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

400
00:35:50,410 --> 00:35:54,880
Unset sker for at nulstille både variable og array-indeks.

401
00:35:54,880 --> 00:35:58,630
Så frakoblet ($ array [2]);

402
00:35:58,630 --> 00:36:03,430
Nu hvad dette kommer til at se ud? 2 er lige gået, så det er helt fint.

403
00:36:03,430 --> 00:36:11,670
Mere irriterende er, hvis du vil have tingene til rent faktisk at være som et array.

404
00:36:11,670 --> 00:36:14,910
Jeg vil sætte tilfældige tal.

405
00:36:14,910 --> 00:36:20,400
Læg nu mærke mine indeks.

406
00:36:20,400 --> 00:36:26,860
Jeg vil have det til bare være ligesom en C-array, hvor den går fra 0 til længde - 1

407
00:36:26,860 --> 00:36:30,810
og jeg kan gentage over det som sådan.

408
00:36:30,810 --> 00:36:38,520
Men så snart jeg frakoble det andet indeks, hvad der var i indeks 3 ikke nu blevet indeks 2.

409
00:36:38,520 --> 00:36:44,790
I stedet er det bare fjerner nævnte indeks, og nu du gå 0, 1, 3, 4.

410
00:36:44,790 --> 00:36:48,740
Det er helt rimeligt.

411
00:36:48,740 --> 00:36:53,950
Det er bare irriterende, og du er nødt til at gøre ting som array-splejsning. Yeah.

412
00:36:53,950 --> 00:36:57,200
>> [Studerende] Hvad ville der ske, hvis du havde en for-løkke

413
00:36:57,200 --> 00:36:59,630
og du ønskede at gå over alle elementer?

414
00:36:59,630 --> 00:37:02,290
Når det ramte 2, ville det give nogensinde?

415
00:37:02,290 --> 00:37:10,150
Iteration over et array. Der er 2 måder, du kan gøre det.

416
00:37:10,150 --> 00:37:12,770
Du kan bruge en almindelig for-løkke.

417
00:37:12,770 --> 00:37:22,000
Dette er en anden forviklinger af PHP.

418
00:37:22,000 --> 00:37:27,420
De fleste sprog, jeg ville sige, har en form for længde eller len eller noget

419
00:37:27,420 --> 00:37:30,470
angiver længden af ​​et array.

420
00:37:30,470 --> 00:37:32,820
I PHP er det tæller.

421
00:37:32,820 --> 00:37:36,160
Så count ($ array); $ i + +)

422
00:37:36,160 --> 00:37:42,950
Lad os bare 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
Det er bare kommer til at mislykkes.

425
00:37:51,610 --> 00:38:03,020
Dette er grunden til at, for det meste, du aldrig behøver at gentage over et array som denne.

426
00:38:03,020 --> 00:38:07,110
Det kunne være en overdrivelse, men du aldrig behøver at gentage over et array som dette

427
00:38:07,110 --> 00:38:19,410
fordi PHP giver sin foreach syntaks hvor foreach ($ array som $ emne).

428
00:38:19,410 --> 00:38:31,830
Nu, hvis vi udskriver ($ emne) - we'll diskutere det i en anden - det virker helt fint.

429
00:38:31,830 --> 00:38:38,960
Den måde, foreach arbejder er den første argument er det array, du iteration over.

430
00:38:38,960 --> 00:38:44,060
Og det andet argument, post, gennem hver passage af for-løkken

431
00:38:44,060 --> 00:38:52,690
det kommer til at tage den næste ting i array. Så husk array har en ordre.

432
00:38:52,690 --> 00:38:55,690
Første gang gennem for-løkken, er post vil være 123

433
00:38:55,690 --> 00:38:59,540
så vil det være 12, så vil det være 13, så vil det være 23, så vil det være 213.

434
00:38:59,540 --> 00:39:04,670
Tingene bliver virkelig underligt, når du gør noget som foreach.

435
00:39:04,670 --> 00:39:07,480
Lad os se hvad der sker, fordi du aldrig bør gøre dette.

436
00:39:07,480 --> 00:39:13,320
Hvad hvis vi frakoblet ($ array [1]);

437
00:39:20,410 --> 00:39:26,030
Det var sandsynligvis forventet.

438
00:39:26,030 --> 00:39:30,950
Du iteration over dette array, og hver gang du frakoble den første indeks.

439
00:39:30,950 --> 00:39:39,720
Så for indeks 0, tager den første ting, punkt på værdien 0, så det kommer til at være 123.

440
00:39:39,720 --> 00:39:44,630
Men inde i for-løkken vi frakoblet indeks 1, så betyder 12 er væk.

441
00:39:44,630 --> 00:39:57,480
Så udskrive. PHP_EOL.

442
00:39:57,480 --> 00:40:03,580
PHP_EOL er bare linjeskift, men det er teknisk set mere bærbar

443
00:40:03,580 --> 00:40:08,890
da newlines i Windows er forskellig fra newlines på Mac og UNIX.

444
00:40:08,890 --> 00:40:18,040
På Windows linjeskift er \ r \ n, hvorimod alle andre steder det har en tendens blot at være \ n.

445
00:40:18,040 --> 00:40:25,150
PHP_EOL er konfigureret således, at den bruger uanset newline af dit system er.

446
00:40:25,150 --> 00:40:29,310
Så udskrive denne. Lad os ikke print_r ($ array) i slutningen.

447
00:40:32,830 --> 00:40:37,390
Jeg havde ingen idé om, at det ville være adfærd.

448
00:40:41,740 --> 00:40:48,960
Vare stadig tager på værdien 12, selvom vi frakoble 12 før vi nogensinde fik det fra arrayet.

449
00:40:52,770 --> 00:40:58,840
Tag ikke mit ord på dette, men det ligner foreach opretter en kopi af array

450
00:40:58,840 --> 00:41:02,160
og derefter punkt tager på alle værdier af denne kopi.

451
00:41:02,160 --> 00:41:07,760
Så selvom du ændrer array inde i for-løkken,

452
00:41:07,760 --> 00:41:17,240
det vil ikke pleje. Item vil tage på de oprindelige værdier.

453
00:41:17,240 --> 00:41:19,240
Lad os prøve frakobling det.

454
00:41:19,240 --> 00:41:24,460
Hvad hvis det er $ array [1] = "hej";

455
00:41:24,460 --> 00:41:31,770
Selvom vi sætter "hello" i array, punkt aldrig tager på denne værdi.

456
00:41:31,770 --> 00:41:37,430
Der er en anden syntaks til foreach løkker

457
00:41:37,430 --> 00:41:45,900
hvor du lægger 2 variabler adskilt af en pil.

458
00:41:45,900 --> 00:41:49,680
Denne første variabel vil være nøglen til denne værdi,

459
00:41:49,680 --> 00:41:53,050
og denne anden variabel bliver nøjagtig de samme element.

460
00:41:53,050 --> 00:42:01,610
Dette er uinteressant her, men hvis vi går tilbage til vores oprindelige tilfælde af 'a' -> 1,

461
00:42:01,610 --> 00:42:06,090
'B' -> 1,

462
00:42:06,090 --> 00:42:14,470
her, hvis vi bare gentage for hver array som elementtype, emne vil være 1 hver eneste gang.

463
00:42:14,470 --> 00:42:18,170
Men hvis vi vil også gerne vide nøglen tilknyttet dette punkt

464
00:42:18,170 --> 00:42:25,230
så gør vi som $ key -> $ element.

465
00:42:25,230 --> 00:42:31,980
Så nu kan vi gøre print ($ key. ':'.

466
00:42:31,980 --> 00:42:39,380
Nu er det iteration over og udskrivning af hver nøgle og dens tilhørende værdi.

467
00:42:39,380 --> 00:42:47,030
>> En ekstra ting, vi kan gøre i foreach loops er du måske se denne syntaks.

468
00:42:47,030 --> 00:42:54,770
-Tegn før variabelnavne tendens til at være, hvordan PHP gør referencer.

469
00:42:54,770 --> 00:43:00,460
Hvor referencer er meget lig pegepinde,

470
00:43:00,460 --> 00:43:04,820
du ikke har pegepinde, så du aldrig beskæftige sig med hukommelse direkte.

471
00:43:04,820 --> 00:43:12,620
Men du har referencer hvor 1 variabel dækker det samme som en anden variabel.

472
00:43:12,620 --> 00:43:21,450
Inde i her lad os gøre $ element. Lad os gå tilbage til 1, 10.

473
00:43:21,450 --> 00:43:28,800
Lad os gøre $ element + +; Det eksisterer stadig i PHP. Du kan stadig gøre + +.

474
00:43:28,800 --> 00:43:38,260
php.test.php. Jeg er nødt til at udskrive det. print_r ($ array);

475
00:43:38,260 --> 00:43:42,730
Vi udskriver 2, 11.

476
00:43:42,730 --> 00:43:49,560
Hvis jeg bare havde gjort foreach ($ array som $ emne), så item vil være værdien 1

477
00:43:49,560 --> 00:43:54,190
første gennemløb af løkken. Det vil forøge 1 til 2 og derefter er vi færdige.

478
00:43:54,190 --> 00:43:57,260
Så det vil gå igennem det andet gennemløb af løkken, og denne post er 10.

479
00:43:57,260 --> 00:44:01,570
Det spring emne til 11, og så det er bare smidt væk.

480
00:44:01,570 --> 00:44:06,670
Så vi print_r ($ array), og lad os se, at dette er kun 1, 10.

481
00:44:06,670 --> 00:44:09,070
Så tilvækst vi gjorde var tabt.

482
00:44:09,070 --> 00:44:13,410
Men foreach ($ array som & $ emne)

483
00:44:13,410 --> 00:44:21,910
nu denne post er den samme post som denne her. Det er det samme.

484
00:44:21,910 --> 00:44:26,820
Så $ element + + er at ændre opstilling 0.

485
00:44:29,330 --> 00:44:41,850
Dybest set, kan du også gøre $ k -> $ emne, og du kan gøre $ array [$ k] + +;

486
00:44:41,850 --> 00:44:48,650
>> Så en anden måde at gøre det, er vi frie til at ændre punkt,

487
00:44:48,650 --> 00:44:54,070
men det vil ikke ændre vores oprindelige array.

488
00:44:54,070 --> 00:44:59,720
Men hvis vi bruger k, som er vores nøgle, kan vi så bare indekset i vores array ved hjælp af denne nøgle

489
00:44:59,720 --> 00:45:01,530
og øg det.

490
00:45:01,530 --> 00:45:05,410
Denne mere direkte ændrer vores oprindelige array.

491
00:45:05,410 --> 00:45:10,690
Du kan endda gøre det, hvis en eller anden grund du ville evnen til at modificere -

492
00:45:10,690 --> 00:45:13,510
Faktisk, det er helt rimeligt.

493
00:45:13,510 --> 00:45:16,020
Du havde ikke ønsker at skulle skrive $ array [$ k] + +,

494
00:45:16,020 --> 00:45:27,890
De ville bare skrive $ element + + men du stadig ønskede at sige if ($ k === 'a')

495
00:45:27,890 --> 00:45:30,620
derefter tilvækst emne og derefter udskrive vores array.

496
00:45:30,620 --> 00:45:36,290
Så nu hvad forventer vi print_r at gøre? Hvilke værdier skal udskrives?

497
00:45:36,290 --> 00:45:43,770
[Studerende] 2 og 10. >> [Bowden] Kun hvis nøglen var 'a' har vi faktisk udskrive det.

498
00:45:51,940 --> 00:45:55,670
>> Du har sandsynligvis meget sjældent, om nogensinde, bliver nødt til at definere funktioner i PHP,

499
00:45:55,670 --> 00:46:03,370
men du kan se noget lignende, hvor du definerer en funktion som funktion uanset.

500
00:46:03,370 --> 00:46:09,900
Normalt ville du sige ($ foo, $ bar), og derefter definere det at være hvad som helst.

501
00:46:09,900 --> 00:46:17,580
Men hvis jeg gør dette, så det betyder, at uanset hvad kalder uanset hvad,

502
00:46:17,580 --> 00:46:25,110
uanset kalder baz, så den første argument sendt til baz kan ændres.

503
00:46:25,110 --> 00:46:38,100
Lad os gøre $ foo + +;

504
00:46:38,100 --> 00:46:48,020
og indersiden af ​​her lad os gøre baz ($ emne);

505
00:46:48,020 --> 00:46:52,250
Nu er vi kalder en funktion.

506
00:46:52,250 --> 00:46:56,780
Argumentet er taget som reference, hvilket betyder, at hvis man ændre det

507
00:46:56,780 --> 00:47:00,390
vi ændre de ting, der blev vedtaget i.

508
00:47:00,390 --> 00:47:04,420
Og udskrivning dette forventer vi - med mindre jeg rodet op syntaks - vi fik 2, 11,

509
00:47:04,420 --> 00:47:06,300
så det var faktisk øges.

510
00:47:06,300 --> 00:47:08,790
Varsel vi har brug for referencer i 2 steder.

511
00:47:08,790 --> 00:47:13,050
Hvad hvis jeg gjorde det? Hvad betyder dette?

512
00:47:13,050 --> 00:47:15,810
[Student] Det vil ændre sig. >> Yeah.

513
00:47:15,810 --> 00:47:18,290
Varen er blot en kopi af værdien i array.

514
00:47:18,290 --> 00:47:26,670
Så emne vil skifte til 2, men det array ['a'] vil stadig være 1.

515
00:47:26,670 --> 00:47:32,560
Eller hvad hvis jeg gør dette?

516
00:47:32,560 --> 00:47:39,260
Nu vare sendes som en kopi til baz.

517
00:47:39,260 --> 00:47:46,330
Så kopi af argumentet vil blive forøget til 2,

518
00:47:46,330 --> 00:47:49,240
men selve elementet blev aldrig inkrementeret til 2.

519
00:47:49,240 --> 00:47:52,880
Og punkt på dagsordenen er det samme som array-beslag uanset hvad,

520
00:47:52,880 --> 00:47:55,380
således at arrayet er aldrig blevet inkrementeret.

521
00:47:55,380 --> 00:47:57,960
Så begge disse steder har brug for det.

522
00:47:57,960 --> 00:48:03,830
>> PHP er normalt temmelig smart om dette.

523
00:48:03,830 --> 00:48:06,570
Du tror måske, jeg ønsker at videregive ved henvisning -

524
00:48:06,570 --> 00:48:09,560
Dette var faktisk et spørgsmål på en af ​​psets.

525
00:48:09,560 --> 00:48:14,480
Det var en questions.txt ting, hvor det siges,

526
00:48:14,480 --> 00:48:19,280
Hvorfor har du måske lyst til at passere denne struct som reference?

527
00:48:19,280 --> 00:48:21,250
Hvad var svaret på det?

528
00:48:21,250 --> 00:48:25,100
[Studerende] Så du ikke behøver at kopiere noget stort. >> Yeah.

529
00:48:25,100 --> 00:48:32,920
En struct kan være vilkårligt stor, og når du passerer struct ind som et argument

530
00:48:32,920 --> 00:48:36,800
er det nødvendigt at kopiere, at hele struct at videregive det til den funktion,

531
00:48:36,800 --> 00:48:40,410
hvorimod hvis du bare forbi struct ved henvisning

532
00:48:40,410 --> 00:48:46,530
så det skal bare kopiere en 4-byte-adresse som argument til funktionen.

533
00:48:48,520 --> 00:48:52,320
PHP er en lille smule klogere end det.

534
00:48:52,320 --> 00:49:00,650
Hvis jeg har nogle funktion og jeg passerer den et array på 1.000 ting,

535
00:49:00,650 --> 00:49:03,990
betyder det det er nødt til at kopiere alt 1.000 af disse ting

536
00:49:03,990 --> 00:49:10,450
at passere den i funktion? Det behøver ikke at gøre det samme.

537
00:49:10,450 --> 00:49:15,940
Hvis indersiden af ​​denne funktion aldrig det faktisk ændrer foo,

538
00:49:15,940 --> 00:49:22,660
så hvis ($ foo === 'hello') returnere sandt.;

539
00:49:22,660 --> 00:49:26,460
Bemærk at vi faktisk aldrig ændret argumentet indersiden af ​​denne funktion,

540
00:49:26,460 --> 00:49:30,010
hvilket betyder, at hvad der var passeret ind som Foo aldrig skal kopieres

541
00:49:30,010 --> 00:49:32,100
fordi det ikke er at ændre det.

542
00:49:32,100 --> 00:49:39,240
Så den måde PHP værker er argumenterne er altid sendes som reference

543
00:49:39,240 --> 00:49:42,170
indtil du rent faktisk forsøge at ændre det.

544
00:49:42,170 --> 00:49:51,160
Nu hvis jeg sige $ foo + +, og det vil nu lave en kopi af den originale foo og ændre kopien.

545
00:49:51,160 --> 00:49:53,090
Det sparer tid.

546
00:49:53,090 --> 00:49:58,210
Hvis du aldrig røre denne massive array, du faktisk aldrig ændre det,

547
00:49:58,210 --> 00:50:02,360
det behøver ikke at gøre kopien,

548
00:50:02,360 --> 00:50:06,640
hvorimod hvis vi bare sætte denne tegnet betyder det ikke engang kopiere det

549
00:50:06,640 --> 00:50:08,640
selv hvis du ændre det.

550
00:50:08,640 --> 00:50:10,680
Denne adfærd kaldes copy-on-write.

551
00:50:10,680 --> 00:50:17,380
Du vil se det andre steder, især hvis du tager et operativsystem kursus.

552
00:50:17,380 --> 00:50:23,880
Copy-on-write er en temmelig sædvanlige mønster, hvor du ikke behøver at lave en kopi af noget

553
00:50:23,880 --> 00:50:26,650
medmindre det rent faktisk er under forandring. Yeah.

554
00:50:26,650 --> 00:50:29,520
[Studerende] Hvad hvis du havde tilvækst inde i testen,

555
00:50:29,520 --> 00:50:33,700
så kun 1 element ud af 1.000 vil skulle ændres?

556
00:50:33,700 --> 00:50:38,770
Jeg er ikke sikker.

557
00:50:38,770 --> 00:50:51,250
Jeg tror, ​​det ville kopiere hele ting, men det er muligt, det er smart nok at -

558
00:50:51,250 --> 00:51:00,020
Faktisk, hvad jeg tænker, er forestille vi havde et array, der ser sådan ud: $ matrix2 = [

559
00:51:00,020 --> 00:51:11,000
Så indeks »a« er en vifte af [1 2 3 4], og indeks 'b' er en vifte af hvad som helst.

560
00:51:11,000 --> 00:51:15,380
Jeg har brug komma mellem alle dem. Forestille der er komma.

561
00:51:15,380 --> 00:51:21,210
Så 'c' er værdien 3.

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

563
00:51:26,290 --> 00:51:33,440
Lad os nu sige, vi gør $ baz ($ matrix2);

564
00:51:33,440 --> 00:51:36,540
hvor baz ikke tager dette som reference.

565
00:51:43,510 --> 00:51:47,370
Så $ foo ['c'] + +;

566
00:51:47,370 --> 00:51:52,340
Det er sådan et eksempel, hvor vi passerer matrix2 som et argument

567
00:51:52,340 --> 00:51:57,010
og så er det at modificere et specifikt indeks af arrayet ved at forøge den.

568
00:51:57,010 --> 00:52:01,090
Jeg ærligt har ingen idé om, hvad PHP vil gøre.

569
00:52:01,090 --> 00:52:07,200
Det kan nemt lave en kopi af hele ting, men hvis det er smart,

570
00:52:07,200 --> 00:52:15,030
det vil gøre en kopi af disse taster, hvor det vil have sin særegne værdi

571
00:52:15,030 --> 00:52:20,620
men dette kan stadig pege på den samme array 1,2,3,4

572
00:52:20,620 --> 00:52:22,320
og dette kan stadig pege på den samme array.

573
00:52:22,320 --> 00:52:24,170
Jeg vil iPad det.

574
00:52:28,900 --> 00:52:45,950
Vi passerer i dette array, hvor denne fyr point til 3, denne fyr point til [1,2,3,4],

575
00:52:45,950 --> 00:52:51,350
denne fyr peger på [34, ...]

576
00:52:51,350 --> 00:52:58,590
Nu, hvor vi passerer den til baz, vi ændre denne.

577
00:52:58,590 --> 00:53:03,550
Hvis PHP er smart, kan det bare gøre -

578
00:53:11,850 --> 00:53:18,230
Vi havde stadig at kopiere noget hukommelse, men hvis der var disse enorme indlejrede subarrays

579
00:53:18,230 --> 00:53:21,560
vi ikke brug for at kopiere dem.

580
00:53:21,560 --> 00:53:27,530
Jeg ved ikke, om det er, hvad det gør, men jeg kan forestille mig, det gør det.

581
00:53:29,050 --> 00:53:36,690
Dette er også en temmelig stor fordel af C over PHP.

582
00:53:36,690 --> 00:53:40,320
>> PHP gør livet så meget lettere for en masse ting,

583
00:53:40,320 --> 00:53:45,060
men du slags har absolut ingen idé om, hvor godt det vil udføre

584
00:53:45,060 --> 00:53:52,530
fordi jeg har ingen idé under kalechen, når det gør disse kopier af ting,

585
00:53:52,530 --> 00:53:55,170
Åh, er, at vil være en konstant tid kopi,

586
00:53:55,170 --> 00:54:01,140
er det bare at ændre 1 pegepind, er det vil være et latterligt svært lineær kopi?

587
00:54:01,140 --> 00:54:03,000
Hvad hvis den ikke kan finde plads?

588
00:54:03,000 --> 00:54:06,760
Er det så nødvendigt at køre garbage collection for at få nogle mere plads?

589
00:54:06,760 --> 00:54:11,210
Og garbage collection kan tage vilkårligt lang.

590
00:54:11,210 --> 00:54:13,600
I C du ikke behøver at bekymre sig om disse ting.

591
00:54:13,600 --> 00:54:19,780
Hver eneste linje, du skriver du kan temmelig meget grund om, hvordan det kommer til at udføre.

592
00:54:26,800 --> 00:54:29,150
>> Lad os se tilbage på disse.

593
00:54:35,400 --> 00:54:37,520
Hvor dejligt er det, at du ikke behøver at beskæftige sig med hash-funktioner,

594
00:54:37,520 --> 00:54:39,010
hægtede lister, eller noget?

595
00:54:39,010 --> 00:54:41,980
Da arbejdet med hash tabeller er så let nu, her er en sjov puzzle at arbejde på.

596
00:54:41,980 --> 00:54:45,920
Åbn en fil kaldet unique.php og i den skriver et PHP-program

597
00:54:45,920 --> 00:54:48,330
(Også kendt som et "script").

598
00:54:48,330 --> 00:54:55,700
Vi er tilbøjelige til at kalde dem scripts, hvis de er korte ting, som du kører på kommandolinjen.

599
00:54:55,700 --> 00:55:02,950
Dybest set, alle sprog, som du ikke kompilere, men du kommer til at køre den eksekverbare

600
00:55:02,950 --> 00:55:05,920
på kommandolinjen, kan du kalde det eksekverbart script.

601
00:55:05,920 --> 00:55:08,510
Jeg kunne lige så godt skrive et C-program, der gør dette,

602
00:55:08,510 --> 00:55:12,300
men jeg kan ikke kalde det et script siden jeg første kompilere det og derefter køre den binære.

603
00:55:12,300 --> 00:55:15,480
Men denne PHP program vil vi kalde et script.

604
00:55:15,480 --> 00:55:23,830
Eller hvis vi skrev det i Python eller Perl eller Node.js eller nogen af ​​disse ting,

605
00:55:23,830 --> 00:55:26,500
vi ville kalde dem alle scripts fordi du kører dem på kommandolinjen

606
00:55:26,500 --> 00:55:30,040
men vi har ikke kompilere dem.

607
00:55:30,860 --> 00:55:33,400
Vi kunne gøre det temmelig hurtigt.

608
00:55:36,960 --> 00:55:41,480
Vi vil ikke bruge argv. Lad os bare blæse gennem denne.

609
00:55:41,480 --> 00:55:45,730
Kald det unikke, skrive et program.

610
00:55:45,730 --> 00:55:49,400
Du kan antage, at input vil indeholde et ord pr linje.

611
00:55:49,400 --> 00:55:52,020
Faktisk vil argv være temmelig trivielt at bruge.

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

613
00:56:08,550 --> 00:56:13,750
Første ting først, vi ønsker at se, om vi er blevet passeret 1 kommando-line argument.

614
00:56:13,750 --> 00:56:20,900
Ligesom du ville forvente argc og argv i C, har vi stadig har dem i PHP.

615
00:56:20,900 --> 00:56:33,900
Så if ($ argc! == 2) så vil jeg ikke beskæftige sig med at udskrive en besked eller noget.

616
00:56:33,900 --> 00:56:37,340
Jeg vil bare afslutte, fejlkode af 1.

617
00:56:37,340 --> 00:56:41,340
Jeg kunne også returnere 1.

618
00:56:41,340 --> 00:56:53,180
Sjældent i PHP er du til denne tilstand, hvor vi er på -

619
00:56:53,180 --> 00:56:57,820
Normalt er du i en funktion kaldt af en funktion kaldes af en funktion kaldes af en funktion.

620
00:56:57,820 --> 00:57:02,070
Og hvis noget går galt, og du blot ønsker at afslutte alting helt,

621
00:57:02,070 --> 00:57:05,680
exit bare afslutter programmet.

622
00:57:05,680 --> 00:57:08,160
Det findes også i C.

623
00:57:08,160 --> 00:57:10,700
Hvis du er i en funktion i en funktion i en funktion i en funktion

624
00:57:10,700 --> 00:57:17,540
og du bare ønsker at dræbe programmet, kan du ringe exit, og det vil bare afslutte.

625
00:57:17,540 --> 00:57:23,120
Men i PHP er det endnu mere sjældent, at vi er på dette topniveau.

626
00:57:23,120 --> 00:57:26,090
Normalt er vi inde i en slags funktion, så vi kalder exit

627
00:57:26,090 --> 00:57:29,650
så vi ikke behøver at vende tilbage op 1 ting som derefter indser at der er en fejl

628
00:57:29,650 --> 00:57:32,270
så der returnerer op, hvis det erkender, at der var en fejl.

629
00:57:32,270 --> 00:57:35,270
Vi ønsker ikke at beskæftige sig med det, så afslut (1);

630
00:57:35,270 --> 00:57:38,240
afkast (1), i dette tilfælde ville svare.

631
00:57:38,240 --> 00:57:44,000
>> Så hvad vi ønsker at åbne vi ønsker at fopen.

632
00:57:44,000 --> 00:57:46,760
Argumenterne kommer til at se temmelig ens.

633
00:57:46,760 --> 00:57:51,600
Vi ønsker at fopen ($ argv [1], og vi ønsker at åbne det for læsning.

634
00:57:51,600 --> 00:57:55,720
Der returnerer en ressource, som vi vil kalde f..

635
00:57:55,720 --> 00:58:02,180
Det ser temmelig svarende til, hvordan C gør det undtagen vi ikke behøver at sige FILE *.

636
00:58:02,180 --> 00:58:06,170
I stedet siger vi bare $ f. Okay.

637
00:58:06,170 --> 00:58:17,190
Faktisk, jeg tror, ​​det selv giver os et vink om PHP funktion kaldet fil. PHP-fil.

638
00:58:17,190 --> 00:58:23,990
Hvad dette vil gøre, er at læse en hel fil ind i et array.

639
00:58:23,990 --> 00:58:29,770
Du behøver ikke engang behøver at fopen det. Det kommer til at gøre det for dig.

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

641
00:58:43,700 --> 00:58:49,680
Nu er alle de linjer i filen er i linjer. Nu ønsker vi at sortere linierne.

642
00:58:49,680 --> 00:58:52,180
Hvordan kan vi sortere de linjer?

643
00:58:52,180 --> 00:58:54,920
Vi sorterer linjerne.

644
00:58:54,920 --> 00:58:58,080
Og nu kan vi udskrive dem eller hvad.

645
00:58:58,080 --> 00:59:05,580
Sandsynligvis den nemmeste måde er foreach ($ linjer som $ line) echo $ linje;

646
00:59:05,580 --> 00:59:10,960
[Studerende] Vil vi ikke engang krydse linjer ved at referere noget i sort?

647
00:59:10,960 --> 00:59:28,850
Det er her slags ville blive defineret som funktion sort (& $ array).

648
00:59:28,850 --> 00:59:32,650
Når du kalder den funktion, du ikke kan passere det som reference.

649
00:59:32,650 --> 00:59:36,900
Det er den funktion, der definerer det som at tage det som reference.

650
00:59:36,900 --> 00:59:40,900
Det er faktisk præcis, hvad der gik galt

651
00:59:40,900 --> 00:59:46,220
når vi sætter alt til vores servere, når vi gik fra 5,3 til 5,4.

652
00:59:46,220 --> 00:59:53,800
Indtil 5,4, var dette helt rimeligt.

653
00:59:53,800 --> 00:59:58,740
En funktion forventer ikke at tage det som reference, men du kan passere det som reference

654
00:59:58,740 --> 01:00:02,860
så hvis funktionen sker at ændre det, er det stadig modificeret.

655
01:00:02,860 --> 01:00:05,850
Som på 5,4, du er ikke meningen at gøre dette.

656
01:00:05,850 --> 01:00:11,740
Så nu er den eneste måde, du passerer ved henvisning er, hvis funktionen udtrykkeligt gør det.

657
01:00:11,740 --> 01:00:19,840
Hvis du ikke ønsker, at ændre det, så er du nødt til at gøre $ kopi = $ linjer og pass kopi.

658
01:00:19,840 --> 01:00:24,820
Så nu linjer vil blive bevaret og kopi vil blive ændret.

659
01:00:27,670 --> 01:00:31,460
php.unique.php. Jeg kunne have rodet noget op.

660
01:00:31,460 --> 01:00:33,190
Uventet 'sort'.

661
01:00:38,320 --> 01:00:43,850
Der kommer til at være noget, der gør dette for os.

662
01:00:43,850 --> 01:00:45,820
Det er ikke engang dér.

663
01:00:45,820 --> 01:00:52,140
Bemærk, når du læser manualen, at det første argument forventes at være et array

664
01:00:52,140 --> 01:00:56,490
og det har taget som reference.

665
01:00:58,160 --> 01:01:03,540
Hvorfor er dette klager til mig? Fordi jeg har denne funktion slags stadig her, at jeg ikke ønsker.

666
01:01:03,540 --> 01:01:09,210
Okay, php.unique.php. Jeg har ikke videregive det et argument, fordi jeg ikke har en fil.

667
01:01:09,210 --> 01:01:13,560
Det er php.unique.php på test.php.

668
01:01:13,560 --> 01:01:19,080
Her er test.php alle printes ud i en nice sorteret orden.

669
01:01:19,080 --> 01:01:24,600
Bemærk, at sorteret orden er lidt underligt for en kode-fil

670
01:01:24,600 --> 01:01:27,460
fordi alle vores tomme linjer vil komme først

671
01:01:27,460 --> 01:01:30,190
derefter vil komme alle vores 1 niveau fordybninger

672
01:01:30,190 --> 01:01:33,360
derefter kommer alle vores ingen fordybninger.

673
01:01:33,360 --> 01:01:38,620
Yeah. >> [Studerende] Så for kildekoden ikke blev vedtaget som reference?

674
01:01:38,620 --> 01:01:42,240
Er der generelt forbi værdi?

675
01:01:42,240 --> 01:01:50,240
[Bowden] Når du kalder en funktion, er det aldrig afgør, om det blev vedtaget som reference.

676
01:01:50,240 --> 01:01:53,960
Det er den funktion definition, der bestemmer, om det blev vedtaget som reference.

677
01:01:53,960 --> 01:01:59,450
Og hvis man ser på den funktion definition af sort eller bare kigge på dette,

678
01:01:59,450 --> 01:02:02,820
det tager argumentet som reference.

679
01:02:02,820 --> 01:02:07,160
Så uanset om du vil have det til at tage det som reference, det tager det som reference.

680
01:02:07,160 --> 01:02:10,200
Det ændrer opstillingen på plads.

681
01:02:10,200 --> 01:02:17,400
Det er bare ikke tilladt. Du har ikke tilladelse til at gøre dette. >> [Studerende] Åh, okay.

682
01:02:17,400 --> 01:02:22,410
[Bowden] Dette er slags kommer til at tage linjer ved henvisning og ændre den.

683
01:02:22,410 --> 01:02:26,850
Og igen, hvis du ikke vil have det til at gøre det, kan du lave en kopi af slags.

684
01:02:26,850 --> 01:02:35,850
Selv i dette tilfælde, er kopien faktisk ikke en kopi af linjer.

685
01:02:35,850 --> 01:02:40,620
Det bare henvist til den samme ting, indtil det først bliver ændret,

686
01:02:40,620 --> 01:02:44,430
hvor det første kommer til at få ændret i den slags funktion,

687
01:02:44,430 --> 01:02:50,940
hvor, fordi det er copy-on-write, nu en kopi af kopi vil finde sted.

688
01:02:57,500 --> 01:03:04,250
Du kan også gøre dette. Det er det andet sted du kan se tegnet.

689
01:03:04,250 --> 01:03:07,190
Du ser det i foreach loops, kan du se det i funktion erklæringer,

690
01:03:07,190 --> 01:03:10,040
og du kan se det, når bare tildele variabler.

691
01:03:10,040 --> 01:03:12,350
Nu vi har udrettet noget ved at gøre dette

692
01:03:12,350 --> 01:03:15,600
fordi kopi og linjer er bogstaveligt talt det samme.

693
01:03:15,600 --> 01:03:19,940
Man kan bruge linjer og kopiere flæng.

694
01:03:19,940 --> 01:03:25,430
Du kan gøre frakoblet ($ kopi), og som ikke forsatte linier,

695
01:03:25,430 --> 01:03:29,120
du bare miste din reference til det samme.

696
01:03:29,120 --> 01:03:33,440
Så som i dette punkt, nu linjer er den eneste måde du kan få adgang linjer.

697
01:03:36,450 --> 01:03:38,770
>> Spørgsmål?

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

699
01:03:42,460 --> 01:03:45,880
[Studerende] Helt off topic, men du behøver ikke at lukke PHP med - >> Du gør ikke.

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

701
01:03:47,730 --> 01:03:53,790
[Bowden] Jeg vil gå så langt som til at sige, at det er dårlig praksis at lukke dem.

702
01:03:53,790 --> 01:03:57,580
Det er nok en overdrivelse, især i et script,

703
01:03:57,580 --> 01:04:03,740
men lad os se hvad der sker, hvis jeg gør dette.

704
01:04:03,740 --> 01:04:08,890
Det gjorde intet. Hvad hvis jeg ønskede - [suk]

705
01:04:13,870 --> 01:04:16,960
Jeg er nødt til at passere et argument.

706
01:04:19,000 --> 01:04:22,050
Optag. Jeg kaldte det forkert.

707
01:04:24,340 --> 01:04:28,310
Så php.unique.php med et argument.

708
01:04:28,310 --> 01:04:30,980
Nu ved jeg ikke engang brug for dette.

709
01:04:34,520 --> 01:04:37,740
Jeg vil videregive det et gyldigt argument.

710
01:04:37,740 --> 01:04:42,050
Dette trykt hvad det er udskrivning.

711
01:04:45,260 --> 01:04:50,080
Jeg udskriver kopi og kopi findes ikke. Så linjer.

712
01:04:53,650 --> 01:04:58,270
Det trykte alt, og derefter mærke alt dette junk ned her,

713
01:04:58,270 --> 01:05:06,690
fordi i PHP noget, der er uden for PHP tags

714
01:05:06,690 --> 01:05:09,520
bare skal udskrives bogstaveligt.

715
01:05:09,520 --> 01:05:18,050
Det er derfor, HTML, det er så rart, at jeg kan gøre div blah, blah, blah klasse eller hvad ved jeg,

716
01:05:18,050 --> 01:05:25,140
blah, blah, blah, og derefter gøre nogle PHP-kode og derefter gøre ende div.

717
01:05:25,140 --> 01:05:36,460
Og nu udskriver dette får jeg min nice div op øverst, alt det PHP trykte, div nederst.

718
01:05:36,460 --> 01:05:43,510
Disastrous når sådan noget sker, som er temmelig almindelig,

719
01:05:43,510 --> 01:05:47,930
blot en vildfaren linjeskift i bunden af ​​filen.

720
01:05:47,930 --> 01:05:50,940
Man skulle ikke tro, det ville være så stor en deal

721
01:05:50,940 --> 01:05:58,660
indtil du tænker på, at med browsere -

722
01:05:58,660 --> 01:06:03,880
>> Hvordan omdirigerer arbejde eller dybest set noget headers arbejde,

723
01:06:03,880 --> 01:06:07,980
når du laver din forbindelse til en hjemmeside og sender det tilbage alle disse overskrifter og ting

724
01:06:07,980 --> 01:06:12,020
lignende reaktion 200 eller respons omdirigere eller hvad,

725
01:06:12,020 --> 01:06:18,230
overskrifter er kun gyldige indtil den første byte af data bliver sendt.

726
01:06:18,230 --> 01:06:23,140
Kan omdirigere tusindvis af gange, men så snart den første byte af data sendes

727
01:06:23,140 --> 01:06:26,120
du er ikke meningen at omdirigere igen.

728
01:06:26,120 --> 01:06:31,860
>> Hvis du har en vildfaren linjeskift i bunden af ​​en fil

729
01:06:31,860 --> 01:06:37,260
og lad os sige, at du bruger denne funktion og derefter du vil -

730
01:06:41,580 --> 01:06:52,870
Lad os sige, det er en anden fil, der er index.php og du require_once noget -

731
01:06:52,870 --> 01:06:56,920
Jeg kan ikke tænke på et godt eksempel på det.

732
01:06:56,920 --> 01:07:04,740
Spørgsmålet sker, når denne linje i bunden bliver gentaget.

733
01:07:04,740 --> 01:07:08,660
Du ønsker ikke noget at være blevet gentaget endnu.

734
01:07:10,820 --> 01:07:15,700
Selvom du ikke har til hensigt på noget at blive gentaget, noget bliver gentaget

735
01:07:15,700 --> 01:07:17,990
og så nu er du ikke meningen at sende flere headers

736
01:07:17,990 --> 01:07:20,030
og du kommer til at få klager.

737
01:07:22,170 --> 01:07:24,420
Du skal bare ikke brug for disse afsluttende tags.

738
01:07:24,420 --> 01:07:27,420
Hvis du har planer om at gøre noget med HTML -

739
01:07:27,420 --> 01:07:30,490
og det er helt rimeligt at gøre hernede div uanset

740
01:07:30,490 --> 01:07:39,450
og derefter ved dette punkt kan du eller du kan ikke inkludere dem.

741
01:07:39,450 --> 01:07:41,590
Det er faktisk ligegyldigt.

742
01:07:41,590 --> 01:07:45,450
Men i PHP-scripts det er sjældent at lukke den.

743
01:07:45,450 --> 01:07:50,400
Når alt er PHP, absolut alt,

744
01:07:50,400 --> 01:07:55,460
du ikke virkelig nødt til at lukke det / du bør ikke lukke den.

745
01:08:02,030 --> 01:08:05,720
>> Beskæftiger sig med strygere er meget pænere end i C.

746
01:08:05,720 --> 01:08:09,470
I PHP kan du angive en streng med enkelt eller dobbelt citationstegn.

747
01:08:09,470 --> 01:08:12,820
Med apostroffer du kan ikke bruge "Escape"-sekvenser.

748
01:08:12,820 --> 01:08:17,640
Konstant flygte, blah, blah, blah.

749
01:08:19,920 --> 01:08:24,010
Så printf er meget sjælden i PHP.

750
01:08:24,010 --> 01:08:32,290
Jeg tror jeg ville bruge printf, hvis jeg ønskede at gøre en slags ting - i Pset 5 du brugt sprintf eller whatever.

751
01:08:32,290 --> 01:08:36,060
Men du ønsker at gøre 001.jpg og 002.jpg.

752
01:08:36,060 --> 01:08:40,300
Så for den slags ting, hvor jeg rent faktisk ønsker at formatere den tekst, jeg ville bruge printf.

753
01:08:40,300 --> 01:08:44,689
Men ellers ville jeg bare bruge strengsammensætning.

754
01:08:44,689 --> 01:08:47,000
Jeg har aldrig rigtig bruge printf.

755
01:08:49,229 --> 01:09:00,170
Vi er bare differentiere detaljerne mellem enkelte anførselstegn og dobbelte anførselstegn.

756
01:09:00,170 --> 01:09:07,490
Den største forskel er, at enkelte anførselstegn, vil det blive udskrevet bogstaveligt.

757
01:09:07,490 --> 01:09:15,390
Der er ingen tegndatatype i PHP, i modsætning til C, så det svarer til det.

758
01:09:15,390 --> 01:09:17,970
De er begge strenge.

759
01:09:17,970 --> 01:09:29,180
Og det gode ved ét tilbud strings er jeg kunne sige "hej verden!" blah, blah, blah,

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

761
01:09:33,340 --> 01:09:38,260
Hvad sker der, når jeg udskriver det er det vil udskrive det bogstaveligt.

762
01:09:38,260 --> 01:09:40,680
Lad os slippe af med alle vores stuff.

763
01:09:40,680 --> 01:09:44,700
Så echo $ str1;

764
01:09:48,569 --> 01:09:56,570
Det bogstaveligt udskrevet alle disse ting: dollartegn,

765
01:09:56,570 --> 01:09:58,770
backslash n, som man skulle tro ville være linjeskift -

766
01:09:58,770 --> 01:10:01,500
alle disse ting det udskrives bogstaveligt.

767
01:10:01,500 --> 01:10:05,650
Det eneste du behøver at flygte, er enkelte anførselstegn

768
01:10:05,650 --> 01:10:09,470
fordi det ellers ville synes det er at lukke enkelte anførselstegn.

769
01:10:09,470 --> 01:10:15,050
Anførselstegn, helt anderledes.

770
01:10:20,300 --> 01:10:25,870
Vi har allerede se syntaksfremhævning er cluing os til, hvad der er ved at gå grueligt galt.

771
01:10:25,870 --> 01:10:36,190
php.unique. Undefined variable: wooo fordi det tolkes som en variabel kaldet wooo.

772
01:10:36,190 --> 01:10:42,400
Anførselstegn kan du indsætte variabler i -

773
01:10:42,400 --> 01:10:52,730
Lad os sige $ name = "Rob";

774
01:10:52,730 --> 01:10:58,020
Så echo "Hej, mit navn er $ navn!"

775
01:10:58,020 --> 01:11:09,260
Det anerkender dette som en variabel.

776
01:11:09,260 --> 01:11:21,210
Når jeg kører det - og jeg vil indsætte en ny linje - Hej, mit navn er Rob! og goddag verden!

777
01:11:21,210 --> 01:11:24,910
Det er fordi jeg aldrig fjernet trykning af wooo ovenfor.

778
01:11:24,910 --> 01:11:30,020
Der er 1 skridt du kan gøre.

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

780
01:11:39,250 --> 01:11:43,270
Hvad hvis jeg ønsker at udskrive den første indeks for array?

781
01:11:43,270 --> 01:11:45,150
Du gør $ array [0].

782
01:11:45,150 --> 01:11:49,280
De syntaksfremhævning er et fingerpeg. Hvad er dette vil gøre?

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

784
01:11:54,510 --> 01:11:59,860
Hej, mit navn er 1! der er ikke, hvad jeg ønskede.

785
01:11:59,860 --> 01:12:05,050
Syntaksfremhævning løj for mig.

786
01:12:05,050 --> 01:12:13,020
Lad os prøve 'a' -> 1, 'b' -> 2.

787
01:12:18,450 --> 01:12:21,440
Det er, hvordan jeg ville have til at skrive det.

788
01:12:26,350 --> 01:12:32,160
Uventet ét tilbud (T_ENCAPSED blah, blah, blah, blah, blah).

789
01:12:32,160 --> 01:12:41,780
Ideen er, at det ikke er at anerkende dette som en del af array'et.

790
01:12:41,780 --> 01:12:46,620
Det er ikke anerkender dette som en tabel indekseres ved brev en.

791
01:12:46,620 --> 01:12:49,870
Du ønsker at gøre det omgivet af krøllede parenteser,

792
01:12:49,870 --> 01:12:54,730
og nu, hvad der er i denne klammeparentes vil blive interpoleret,

793
01:12:54,730 --> 01:13:00,340
hvilket er det ord, vi bruger til magisk indsætte disse variabler ind de rigtige steder.

794
01:13:00,340 --> 01:13:04,280
Nu gør dette, php.unique, og Hej, mit navn er 1! som forventet

795
01:13:04,280 --> 01:13:07,720
eller Hej, mit navn er Rob!

796
01:13:14,110 --> 01:13:23,130
En ting, der er lidt rart, om enkelte citater er, at -

797
01:13:23,130 --> 01:13:28,480
Der er nogle omkostninger at interpolere.

798
01:13:30,520 --> 01:13:35,100
Hvis du bruger anførselstegn, tolken har til at gå over denne streng,

799
01:13:35,100 --> 01:13:41,500
at sikre, at, "Åh, her er en variabel. Nu har jeg brug for at gå få denne variabel og indsætte det her."

800
01:13:41,500 --> 01:13:48,930
Selv hvis du ikke bruger nogen variabler,

801
01:13:48,930 --> 01:13:52,220
intet indersiden af ​​disse dobbelte anførselstegn skal interpoleres,

802
01:13:52,220 --> 01:13:56,800
men det vil stadig være langsommere, fordi det skal gå over de dobbelte anførselstegn

803
01:13:56,800 --> 01:14:00,130
leder efter ting, der skal interpoleres.

804
01:14:00,130 --> 01:14:05,360
Så enkelt anførselstegn kan være en smule hurtigere, hvis intet skal interpoleres,

805
01:14:05,360 --> 01:14:15,650
og jeg har en tendens til selv bruge enkelte anførselstegn for, "Hej, mit navn er '. $ Array ['a'] alligevel.

806
01:14:15,650 --> 01:14:20,430
Det kommer til at svare til, hvad vi havde før.

807
01:14:24,840 --> 01:14:28,440
Men det er et spørgsmål om præference.

808
01:14:28,440 --> 01:14:34,750
Hvis du bruger PHP, har du sandsynligvis ligeglad den hastighed forskel.

809
01:14:34,750 --> 01:14:39,480
Der er ikke nok til at ræsonnere dem ud til at begynde med.

810
01:14:39,480 --> 01:14:43,030
>> Eventuelle sidste spørgsmål?

811
01:14:47,430 --> 01:14:51,710
>> Vi faktisk ikke engang komme igennem det hele, men denne ting var kedeligt.

812
01:14:51,710 --> 01:14:59,080
Den sidste ting, der er lidt rart i PHP er, når du beskæftiger sig med HTML,

813
01:14:59,080 --> 01:15:06,450
du vil bruge det en smule, så den pæne genvej syntaksen for udskrivning af en variabel.

814
01:15:32,400 --> 01:15:36,730
Uden at sætte PHP her, kaldes det korte tags.

815
01:15:36,730 --> 01:15:44,330
Officielt fra PHP 5,4, er dette frarådes.

816
01:15:44,330 --> 01:15:48,640
Du anbefales at sætte php.

817
01:15:48,640 --> 01:15:55,770
Dette understøttes stadig, så korte tags med <? = Er stadig helt fint.

818
01:15:55,770 --> 01:16:02,480
Det er ved understøttet standard, så du kan bruge disse som du ønsker, og de er temmelig praktisk.

819
01:16:02,480 --> 01:16:05,700
>> Eventuelle spørgsmål?

820
01:16:07,780 --> 01:16:09,270
Ok.

821
01:16:10,840 --> 01:16:13,800
>> Ophold klassiske, San Diego.

822
01:16:13,800 --> 01:16:16,070
[Griner]

823
01:16:18,620 --> 01:16:22,660
Bye. [Griner]

824
01:16:24,350 --> 01:16:28,470
[Bifald] [griner]

825
01:22:46,460 --> 01:22:49,460
>> [CS50.TV]