1
00:00:00,000 --> 00:00:02,610
[Powered by Google Translate] [§ 8 - Mer komfortabelt]

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 uken avsnittsnoter kommer til å være ganske kort,

5
00:00:14,160 --> 00:00:19,070
så jeg bare kommer til å fortsette å snakke, er dere kommer til å fortsette å stille spørsmål,

6
00:00:19,070 --> 00:00:22,720
og vi vil prøve å fylle opp så mye tid som mulig.

7
00:00:22,720 --> 00:00:31,950
Mange tror at dette pset er ikke nødvendigvis vanskelig, men det er veldig lenge.

8
00:00:31,950 --> 00:00:37,070
Den pset spec selv tar en time å lese.

9
00:00:40,530 --> 00:00:45,730
Vi gir deg en rekke SQL kan du muligens trenger å bruke.

10
00:00:45,730 --> 00:00:50,520
Vi går gjennom mye av det, så det bør ikke være så ille.

11
00:00:50,520 --> 00:00:54,560
Har noen gang eller ferdig?

12
00:00:55,380 --> 00:00:59,710
Det er den siste pset. Herregud.

13
00:00:59,710 --> 00:01:05,400
Vanligvis er det en JavaScript ene etter dette, men kalender endre ting

14
00:01:05,400 --> 00:01:09,560
gjør alt en uke kortere, og vi ikke lenger har en JavaScript pset.

15
00:01:09,560 --> 00:01:12,310
Jeg vet ikke hvordan det påvirker om JavaScript kommer til å vises på eksamen

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

17
00:01:15,510 --> 00:01:22,260
Jeg antar det vil være noe som du trenger å vite høyt nivå ting om JavaScript,

18
00:01:22,260 --> 00:01:26,460
men jeg tviler på at vi ville bare gi deg rett JavaScript-kode

19
00:01:26,460 --> 00:01:28,720
siden du ikke har hatt en pset i den.

20
00:01:28,720 --> 00:01:33,000
Men det vil være ting for quiz vurdering neste uke.

21
00:01:33,000 --> 00:01:36,320
>> Seksjon for spørsmål.

22
00:01:36,320 --> 00:01:43,870
Mye av dette er ting litt dårlig formulert, men vi vil diskutere hvorfor.

23
00:01:43,870 --> 00:01:50,220
I motsetning til C, er PHP et "dynamisk skrevet" språk. Hva betyr dette, spør du?

24
00:01:50,220 --> 00:01:53,830
Vel, si farvel til alle de røye, float, int, og andre søkeord du må bruke

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

26
00:01:56,190 --> 00:02:00,420
I PHP er en variabel typen bestemmes av verdien som det er for tiden holder.

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

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

29
00:02:12,670 --> 00:02:17,590
Jeg er uenig med det faktum at det betyr at vi sier farvel til røye, float, int,

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

31
00:02:20,620 --> 00:02:25,510
Den eksakte forskjellen mellom dynamisk skrevet og alternativ,

32
00:02:25,510 --> 00:02:32,010
som er statisk skrevet, er at dynamisk skrevet, alle av type kontroll og ting

33
00:02:32,010 --> 00:02:37,350
skjer under kjøring, mens statisk skrev det skjer ved kompilering.

34
00:02:37,350 --> 00:02:43,030
Ordet statisk generelt synes å bety kompilering ting.

35
00:02:43,030 --> 00:02:48,170
Jeg antar det er andre bruksområder for det, men i C når du deklarerer en statisk variabel,

36
00:02:48,170 --> 00:02:52,650
sin bagasje fordeles på kompilering.

37
00:02:52,650 --> 00:02:59,260
Her dynamisk skrevet betyr nettopp det -

38
00:02:59,260 --> 00:03:04,350
I C hvis du prøver å legge en streng og et heltall, når du kompilere den,

39
00:03:04,350 --> 00:03:11,000
det kommer til å klage fordi det kommer til å si at du ikke kan legge en int og en peker.

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

41
00:03:14,710 --> 00:03:21,170
Det er en annen ting som vi får til i et sekund.

42
00:03:21,170 --> 00:03:24,860
Men den slags kontroll, det faktum at det klager på kompilering,

43
00:03:24,860 --> 00:03:29,220
er statiske typen sjekking.

44
00:03:29,220 --> 00:03:35,220
Det er språk der du ikke trenger å si røye, float, int, og alle disse tingene,

45
00:03:35,220 --> 00:03:40,940
men språket kan fortelle fra sammenheng med ting hvilken type det er ment å være,

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

47
00:03:43,980 --> 00:03:49,000
Så hvis du tar 51, OCaml, du aldri trenger å bruke noen av disse typene,

48
00:03:49,000 --> 00:03:58,700
men det fortsatt vil på kompilering sier du ikke kan gjøre dette fordi du mikser en int og en streng.

49
00:03:58,700 --> 00:04:05,650
Dynamisk skrevet betyr bare at en gang i løpet av kjøre tid du kommer til å få en klage.

50
00:04:05,650 --> 00:04:13,430
Hvis du også har brukt Java før, generelt, nesten alle C-type språk

51
00:04:13,430 --> 00:04:20,070
kommer til å bli statisk skrevet, så C, C + +, Java, alle av dem er generelt statisk skrevet.

52
00:04:20,070 --> 00:04:22,910
I Java når du kompilere noe og du sier

53
00:04:22,910 --> 00:04:26,670
string s tilsvarer nye noe som ikke er en streng,

54
00:04:26,670 --> 00:04:28,950
som kommer til å klage fordi disse typene bare ikke samsvarer.

55
00:04:28,950 --> 00:04:31,180
Det kommer til å klage på kompilering.

56
00:04:31,180 --> 00:04:36,750
Men det har også noen dynamisk tid ting som hvis du prøver å kaste noe

57
00:04:36,750 --> 00:04:40,500
til en type som er mer spesifikk enn sin nåværende type,

58
00:04:40,500 --> 00:04:45,610
det er ingenting de kan gjøre ved kompilering for å sjekke om det kastet kommer til å lykkes.

59
00:04:45,610 --> 00:04:51,130
Java har også noen dynamisk typen sjekker at så snart det kommer til det kodelinje

60
00:04:51,130 --> 00:04:54,130
når det faktisk utfører, det kommer til å gjøre det kastet,

61
00:04:54,130 --> 00:04:56,260
sjekke om det kastet var gyldig i første omgang,

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

63
00:04:59,890 --> 00:05:03,200
Dynamisk typen kontroll.

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

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

66
00:05:14,580 --> 00:05:17,190
Jeg skal pakke det formatering.

67
00:05:18,750 --> 00:05:21,880
Vi har en variabel, vi setter den til heltall 7,

68
00:05:21,880 --> 00:05:27,930
så vi kommer til å skrive den ut og% s -

69
00:05:27,930 --> 00:05:32,830
Åh, vi skriver den type det er så getType kommer til å returnere den type variabelen.

70
00:05:32,830 --> 00:05:35,720
Vi bare skriver av type og om igjen.

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

72
00:05:39,440 --> 00:05:45,920
Vi vil se at det skifter fra heltall til strengen til Boolean som vi går gjennom.

73
00:05:45,920 --> 00:05:54,590
In C er det ingen boolsk datatype, er det ingen streng datatype.

74
00:05:54,590 --> 00:06:00,500
Det er char * og boolske bare har en tendens til å være int eller røye eller noe.

75
00:06:00,500 --> 00:06:05,690
I PHP disse finnes, og det er en av de store fordelene med PHP over C -

76
00:06:05,690 --> 00:06:13,290
at strengoperasjoner er uendelig lettere i PHP enn C. De bare fungere.

77
00:06:13,290 --> 00:06:18,290
>> Så kommer vi tilbake hit.

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

79
00:06:21,260 --> 00:06:26,710
Dette forteller PHP tolk, kalt php, å kjøre PHP-kode i dynamic.php.

80
00:06:26,710 --> 00:06:30,250
Hvis du har noen feil i filen, vil tolken fortelle deg!

81
00:06:30,250 --> 00:06:39,110
Tolken, er dette en annen stor forskjell mellom PHP og C.

82
00:06:39,110 --> 00:06:48,200
I C må du kompilere noe og deretter kjøre den kompilert fil.

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

84
00:06:50,490 --> 00:06:57,200
Så PHP tolk er i utgangspunktet bare å lese denne linje for linje.

85
00:06:57,200 --> 00:07:02,900
Den treffer var = 7 så den treffer printf da den treffer Var så den treffer printf og så videre.

86
00:07:02,900 --> 00:07:10,910
Det er litt av kompilering den gjør det, og det bufrer resultatene

87
00:07:10,910 --> 00:07:15,510
så hvis du kjører skriptet senere kan du gjøre noen,

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

89
00:07:19,280 --> 00:07:25,280
Det betyr at mange av de optimaliseringer som vi får i C,

90
00:07:25,280 --> 00:07:31,920
som kompilering, er det bare generelt kompilatoren kan gjøre mye av triks for deg.

91
00:07:31,920 --> 00:07:36,110
Det kan ta ut ubrukte variabler, kan det gjøre alle disse slags ting,

92
00:07:36,110 --> 00:07:38,660
det kan gjøre halen rekursjon.

93
00:07:38,660 --> 00:07:42,550
I PHP ikke du kommer til å få denne fordelen

94
00:07:42,550 --> 00:07:45,690
fordi det bare kommer til å begynne å utføre linje for linje for linje,

95
00:07:45,690 --> 00:07:49,950
og den ikke gjenkjenner virkelig disse tingene som lett

96
00:07:49,950 --> 00:07:54,440
siden det ikke er en stor samling passerer over ting og så kjøring;

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
>> Tilbake til vår dynamiske skrive: ganske kult, eh?

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

101
00:08:08,640 --> 00:08:11,860
Nå, se om du kan finne ut hvilken type hver av følgende verdier.

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

103
00:08:14,760 --> 00:08:19,420
Så 3,50. Hvilken type tror du det kommer til å bli?

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

105
00:08:26,370 --> 00:08:30,430
Vi har bools, heltall, flytende punkter, strenger, arrayer, gjenstander,

106
00:08:30,430 --> 00:08:38,370
og deretter ressurser, som er slags vag.

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

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

109
00:08:43,740 --> 00:08:47,140
I motsetning til C hvor NULL er bare en peker med adresse 0,

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

111
00:08:57,560 --> 00:09:00,670
Dette er mye mer nyttig for feilsjekking.

112
00:09:00,670 --> 00:09:04,310
I C der vi hadde dette problemet der hvis du går tilbake NULL,

113
00:09:04,310 --> 00:09:08,660
betyr det at du returnerer en NULL-peker eller bruke NULL å betegne feil

114
00:09:08,660 --> 00:09:12,380
eller alle at forvirring vi hadde på ett punkt.

115
00:09:12,380 --> 00:09:18,440
Her retur NULL betyr vanligvis feil.

116
00:09:20,860 --> 00:09:27,300
Mange ting også return false for feil.

117
00:09:27,300 --> 00:09:33,140
Men poenget er NULL type, er det eneste av NULL attraksjon NULL.

118
00:09:33,140 --> 00:09:40,090
Da tilbakeringing er som du kan definere noen anonyme funksjoner.

119
00:09:40,090 --> 00:09:46,420
Du trenger ikke å gi funksjonen et navn, men du trenger ikke å forholde seg til det her.

120
00:09:46,420 --> 00:09:53,940
Ser vi på de typene som de forventer oss å vite,

121
00:09:53,940 --> 00:09:59,000
hva tror du den type 3,50 er? >> [Student] Float.

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

123
00:10:00,370 --> 00:10:06,290
Så da her, hva tror du den typen dette er? >> [Student] Array.

124
00:10:06,290 --> 00:10:09,890
Ja. Den første var flyte, er det andre en en matrise.

125
00:10:09,890 --> 00:10:14,500
Legg merke til at denne matrisen er ikke som en C matrise

126
00:10:14,500 --> 00:10:19,610
der du har indeks 0 har noen verdi, har indeks 1 noen verdi.

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

128
00:10:26,320 --> 00:10:33,980
I PHP er det ingen forskjell mellom en assosiativ matrise og bare en vanlig matrise

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

130
00:10:36,740 --> 00:10:43,040
Det er nettopp dette, og under panseret en vanlig matrise er bare en assosiativ array

131
00:10:43,040 --> 00:10:50,000
hvor 0 kart til noen verdi på samme måte som en kart til noen verdi.

132
00:10:50,000 --> 00:11:00,410
Av denne grunn, kan PHP være ganske dårlig for virkelig rask kode / benchmarking ting

133
00:11:00,410 --> 00:11:07,930
siden i C når du bruker en rekke vet du at tilgang til et medlem er konstant tid.

134
00:11:07,930 --> 00:11:11,860
I PHP tilgang medlem er hvem vet hvor mye tid?

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

136
00:11:18,970 --> 00:11:21,620
Hvem vet hva det egentlig gjør under panseret?

137
00:11:21,620 --> 00:11:25,600
Du virkelig trenger å se på gjennomføringen for å se hvordan det kommer til å beskjeftige seg med.

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

139
00:11:28,550 --> 00:11:36,420
Jeg tror her la oss bare PHP manuell fopen å se på avkastningen type.

140
00:11:36,420 --> 00:11:41,260
Vi ser her at du kan slå opp ganske mye noen funksjon i PHP manualen

141
00:11:41,260 --> 00:11:47,540
og dette er liksom mannen til PHP.

142
00:11:47,540 --> 00:11:51,060
Returtypen kommer til å være ressurskrevende.

143
00:11:51,060 --> 00:11:56,050
Det er derfor jeg kikket opp, fordi vi ikke egentlig definere ressurs.

144
00:11:56,050 --> 00:12:04,110
Ideen om ressurs, i C snilt av deg fikk en FIL * eller hva;

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

146
00:12:07,200 --> 00:12:10,360
Det er hva du kommer til å lese fra, det er hva du kommer til å skrive til.

147
00:12:10,360 --> 00:12:20,710
Det er vanligvis ekstern, så det er en ressurs du kan trekke ting fra og kaste ting til.

148
00:12:20,710 --> 00:12:26,520
Og til slutt, hva er type NULL? >> [Student] NULL.

149
00:12:26,520 --> 00:12:30,650
Ja. Så det eneste som 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
>> En funksjon av PHP type system (for bedre eller verre) er dens evne til å sjonglere typer.

152
00:12:41,170 --> 00:12:44,390
Når du skriver en linje av PHP-kode som kombinerer verdier av forskjellige typer,

153
00:12:44,390 --> 00:12:46,670
PHP vil prøve å gjøre fornuftige ting.

154
00:12:46,670 --> 00:12:48,920
Prøv ut hver av de følgende linjer med PHP-kode. Hva er skrevet ut?

155
00:12:48,920 --> 00:12:51,000
Det er hva du forventet? Hvorfor eller hvorfor ikke?

156
00:12:51,000 --> 00:12:58,600
Dette faktum om PHP er det som gjør det det vi kaller svakt skrevet.

157
00:12:58,600 --> 00:13:04,610
Svakt skrevet og sterkt skrevet,

158
00:13:04,610 --> 00:13:06,840
det er forskjellige bruksområder for disse vilkårene,

159
00:13:06,840 --> 00:13:12,020
men de fleste bruker svakt skrevet og sterkt skrevet til å bety denne typen ting

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

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

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

163
00:13:22,490 --> 00:13:29,200
Mange blander dynamisk typing og svak typing og statisk skrive og sterk skrive.

164
00:13:29,200 --> 00:13:34,050
Python er et annet eksempel på et språk som er dynamisk skrevet.

165
00:13:34,050 --> 00:13:41,770
Du kan kaste rundt typer i variabler og det kommer til å avgjøre under kjøring

166
00:13:41,770 --> 00:13:44,680
noen feil checkings.

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

168
00:13:50,740 --> 00:13:55,920
og dette vil mislykkes fordi den sier at du kan ikke legge en streng og et heltall.

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

170
00:14:00,860 --> 00:14:04,220
Svak skrive har å gjøre med det faktum at det gjør ting med typer

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

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

173
00:14:17,420 --> 00:14:20,710
Jeg kan tenke det er heltallet 3.

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

175
00:14:24,530 --> 00:14:29,140
at når vi skriver ut ("1" + 2), det er sannsynligvis kommer til å ende opp med å være annerledes

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

177
00:14:32,320 --> 00:14:39,700
Og dette har en tendens til å være, etter min mening, til det verre.

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

179
00:14:44,240 --> 00:14:48,740
En annen lite triks om PHP er at du ikke trenger å faktisk skrive filen.

180
00:14:48,740 --> 00:14:52,790
Det gjør har kjørt denne kommandoen modus.

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

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

183
00:15:19,550 --> 00:15:23,970
Dette skrives tre.

184
00:15:31,100 --> 00:15:35,330
Det ser ut som det er skrevet ut 3 og det er heltall 3.

185
00:15:35,330 --> 00:15:38,420
Så la oss nå prøve det andre veien 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 det er også tenkt å være heltall 3? Jeg ærlig har ingen anelse.

188
00:15:50,490 --> 00:15:54,030
Det ser ut som det er konsistent.

189
00:15:54,030 --> 00:15:59,550
Det er aldri noen sjanse for at det er strengen 12 eller noe sånt

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

191
00:16:08,080 --> 00:16:11,670
har en egen operatør for sammenkjeding.

192
00:16:11,670 --> 00:16:14,930
Sammenkobling i PHP er prikk.

193
00:16:14,930 --> 00:16:22,950
Så utskrift (1 '2 '.); Kommer til å gi oss 12.

194
00:16:25,790 --> 00:16:32,420
Dette har en tendens til å føre til forvirring der folk prøver å gjøre noe som str + =

195
00:16:32,420 --> 00:16:37,840
noen andre ting som de ønsker å legge på til slutten av strengen sin, og det kommer til å mislykkes.

196
00:16:37,840 --> 00:16:40,770
Du trenger å gjøre str. =

197
00:16:42,000 --> 00:16:46,240
Så ikke glem sammensetning i PHP er en prikk.

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 deg at det ikke er noe håp for denne resulterer i CS50

200
00:17:03,610 --> 00:17:06,119
siden sammensetning er ikke +.

201
00:17:06,119 --> 00:17:08,440
Hva tror du dette kommer til å ende opp med å bli?

202
00:17:10,359 --> 00:17:13,460
Jeg ærlig har absolutt ingen anelse om.

203
00:17:14,250 --> 00:17:16,460
Det ser ut som det er bare 50 år.

204
00:17:16,460 --> 00:17:21,490
Det ser strengen, og jeg vedder på at hvis vi setter 123CS -

205
00:17:21,490 --> 00:17:29,640
Det ser den første strengen, prøver den å lese et heltall fra den eller et nummer fra den.

206
00:17:29,640 --> 00:17:31,710
I dette tilfellet ser det 123CS.

207
00:17:31,710 --> 00:17:35,190
"Det gir ikke mening som et heltall, så jeg skal bare tenke på 123".

208
00:17:35,190 --> 00:17:38,580
Så 123 + 50 kommer til å bli 173.

209
00:17:38,580 --> 00:17:40,740
Og her begynner det å lese dette som et heltall.

210
00:17:40,740 --> 00:17:45,690
Det ser ikke noe, slik at det bare behandler det som 0. Så 0 + 50 kommer til å bli 50 år.

211
00:17:45,690 --> 00:17:51,600
Dette jeg antar kommer til å gjøre noe lignende.

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

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

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

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

216
00:18:23,700 --> 00:18:29,630
[Student] 1. >> Ja, det ville være en fordi 10/7 er å dele to heltall.

217
00:18:29,630 --> 00:18:32,910
Et heltall delt av et heltall kommer til å returnere et heltall.

218
00:18:32,910 --> 00:18:37,750
Det kan ikke returnere 1 poeng uansett det ville være, så det er bare kommer til å returnere en.

219
00:18:37,750 --> 00:18:46,120
Her skriver (10/7), det kommer til å faktisk tolke det.

220
00:18:46,120 --> 00:18:53,760
Og dette betyr at hvis du faktisk ønsker å gjøre heltall avrunding og sånt,

221
00:18:53,760 --> 00:18:59,950
du trenger å gjøre print (etasje (10/7));

222
00:18:59,950 --> 00:19:08,460
I C er det sannsynligvis rart at du kan stole på heltall trunkering regelmessig,

223
00:19:08,460 --> 00:19:12,260
men i PHP ikke kan fordi det vil automatisk slå den inn i en flåte.

224
00:19:13,430 --> 00:19:17,610
Og så (7 + true); hva tror du det kommer til å bli?

225
00:19:18,550 --> 00:19:23,640
Jeg gjetter 8 hvis det kommer til å tolke sant som en.

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

227
00:19:25,740 --> 00:19:31,710
>> Så noe vi har gjort i de siste 10 minuttene du bør absolutt aldri gjøre.

228
00:19:31,710 --> 00:19:39,870
Du vil se koden som gjør dette.

229
00:19:39,870 --> 00:19:42,700
Det trenger ikke å være så enkelt som dette.

230
00:19:42,700 --> 00:19:47,240
Du kunne ha to variabler, og en variabel skjer for å være en streng

231
00:19:47,240 --> 00:19:51,310
og den andre variable skjer for å være en int, og deretter legger du til disse variablene sammen.

232
00:19:51,310 --> 00:20:00,120
Siden PHP er dynamisk skrevet, og det vil ikke gjøre noen typesjekking for deg

233
00:20:00,120 --> 00:20:03,640
og siden det er svakt skrevet, og siden det vil bare automatisk kaste disse tingene sammen

234
00:20:03,640 --> 00:20:11,490
og alt vil bare fungere, er det vanskelig å selv vite at denne variabelen må være en streng nå,

235
00:20:11,490 --> 00:20:14,930
så jeg ikke skal legge det til denne variabelen, som er et heltall.

236
00:20:18,780 --> 00:20:24,560
Best practice er hvis en variabel er en streng, holde det som en streng alltid.

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

238
00:20:26,980 --> 00:20:30,770
Hvis du ønsker å håndtere heltall og strenger,

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

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

241
00:20:42,520 --> 00:20:47,600
Så intval skal returnere heltallsverdien en variabel.

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

243
00:21:06,820 --> 00:21:15,850
Intval selv ikke kommer til å gjøre sjekken for oss at det er utelukkende et heltall.

244
00:21:15,850 --> 00:21:20,460
PHP manualen, det er bare så mange funksjoner tilgjengelig,

245
00:21:20,460 --> 00:21:26,560
så her tror jeg det jeg vil bruke er is_numeric først.

246
00:21:26,560 --> 00:21:32,590
Jeg gjetter at returneres falsk.

247
00:21:32,590 --> 00:21:35,780
Det er en annen ting vi har å gå over er ===.

248
00:21:37,850 --> 00:21:44,020
Så is_numeric ('123df '), ville du ikke tenke på det som is_numeric.

249
00:21:44,020 --> 00:21:46,720
I C ville du må iterere over alle tegnene

250
00:21:46,720 --> 00:21:50,410
og sjekk for å se om hver karakter er tall eller hva.

251
00:21:50,410 --> 00:21:53,850
Her is_numeric kommer til å gjøre det for oss,

252
00:21:53,850 --> 00:21:56,520
og den returnerer false.

253
00:21:56,520 --> 00:22:02,120
Så når jeg trykket at trykket det ingenting, så her jeg sammenlikne det å se,

254
00:22:02,120 --> 00:22:05,490
har du tilfeldigvis være falsk? Og så nå er det utskrift 1.

255
00:22:05,490 --> 00:22:10,060
Angivelig det skrives en som sant stedet for å skrive sant så sant.

256
00:22:10,060 --> 00:22:15,790
Jeg lurer på om jeg gjør print_r. Nei, det gjør det fortsatt en.

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

258
00:22:26,760 --> 00:22:32,260
og hvis du snakker til Tommy at han vil si == er helt greit.

259
00:22:32,260 --> 00:22:37,700
Jeg kommer til å si at == er forferdelig, og du bør aldri bruke ==.

260
00:22:37,700 --> 00:22:44,870
Forskjellen er at == sammenligner ting

261
00:22:44,870 --> 00:22:48,450
der det kan være tilfelle selv om de ikke er av samme type,

262
00:22:48,450 --> 00:22:53,810
mens === sammenligner ting og først det sjekker de samme type?

263
00:22:53,810 --> 00:22:58,010
Ja. Ok, nå skal jeg se om de faktisk sammenligne å være like.

264
00:22:58,010 --> 00:23:08,890
Du får rare ting som 10 lik - la oss se hva som sier.

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

266
00:23:15,570 --> 00:23:17,980
Dette returnerer sant.

267
00:23:17,980 --> 00:23:21,420
Har noen noen gjetninger hvorfor dette returnerer sant?

268
00:23:25,180 --> 00:23:27,120
Det handler ikke bare om det. Kanskje dette er et hint.

269
00:23:27,120 --> 00:23:33,170
Men hvis jeg endre det til en f - darn it! Jeg fortsette å bruke anførselstegn.

270
00:23:33,170 --> 00:23:38,780
Grunnen anførselstegn er roping på meg fordi jeg har satt dette i anførselstegn.

271
00:23:38,780 --> 00:23:43,850
Så jeg kunne unnslippe doble anførselstegn i her, men enkle anførselstegn gjøre det lettere.

272
00:23:43,850 --> 00:23:49,120
So ('10 '== '1 f1'); ikke ut sant. ('10 '== '1 E1'); skriver sant.

273
00:23:49,120 --> 00:23:56,330
[Student] Er det hex? >> Det er ikke hex, men det er tett at det er som -

274
00:23:56,330 --> 00:24:01,060
1E1, vitenskapelig notasjon.

275
00:24:01,060 --> 00:24:07,950
Den gjenkjenner 1E1 som 1 * 10 ^ 1 eller hva som helst.

276
00:24:07,950 --> 00:24:11,510
De er likeverdige heltall.

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

278
00:24:15,930 --> 00:24:28,490
Jeg har faktisk ingen anelse om vi gjør == hva (10 og '10abc '); OK. Så det er sant.

279
00:24:28,490 --> 00:24:35,940
Så akkurat som 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 sant.

281
00:24:38,800 --> 00:24:45,350
Enda verre er ting som (falske == NULL); er sant

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

283
00:24:52,210 --> 00:25:00,970
Det er rare tilfeller av - Det er en av de rare saker.

284
00:25:00,970 --> 00:25:08,110
Legg merke til at (falske == []); er sant.

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

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åte transitive.

288
00:25:19,090 --> 00:25:26,830
en kan være lik b og en kan være lik c,

289
00:25:26,830 --> 00:25:29,340
men b kan ikke være lik C.

290
00:25:29,340 --> 00:25:35,580
Det er en vederstyggelighet for meg, og du bør alltid bruke ===.

291
00:25:35,580 --> 00:25:38,590
[Student] Kan vi gjøre! == Også? >> [Bowden] Ja.

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

293
00:25:44,600 --> 00:25:48,230
Dette er faktisk brakt opp i pset spec

294
00:25:48,230 --> 00:25:52,000
hvor mange funksjoner avkastning -

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

296
00:25:53,890 --> 00:25:59,140
Det setter i en stor rød boks, "Dette vil returnere false hvis det er en feil."

297
00:25:59,140 --> 00:26:03,940
Men tilbake 0 er en helt rimelig ting å gå tilbake.

298
00:26:03,940 --> 00:26:08,250
Tenk om noen funksjon som er ventet å returnere et heltall.

299
00:26:11,250 --> 00:26:17,880
La oss si denne funksjonen er ment å telle antall linjer i en fil eller noe.

300
00:26:17,880 --> 00:26:23,490
Under normale omstendigheter, passerer du denne funksjonen en fil

301
00:26:23,490 --> 00:26:27,120
og det kommer til å returnere et heltall som representerer antall linjer.

302
00:26:27,120 --> 00:26:30,820
Så 0 er en helt rimelig antall hvis filen er bare tomt.

303
00:26:30,820 --> 00:26:36,810
Men hva hvis du passerer det en ugyldig fil og funksjonen skjer for å 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 gjøre == du ikke skille saken mellom ugyldig fil og tom fil.

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

307
00:26:55,690 --> 00:26:58,000
Det er alle disse.

308
00:26:58,000 --> 00:27:01,660
>> I PHP, er matrisen typen forskjellig fra det du er vant til i C.

309
00:27:01,660 --> 00:27:06,650
Faktisk har du kanskje allerede lagt merke til dette ovenfor når du så at dette er av typen array.

310
00:27:06,650 --> 00:27:15,640
Braketten syntaks er ny som på 5,4 PHP, som er den nyeste versjonen av PHP.

311
00:27:15,640 --> 00:27:36,960
Før dette alltid måtte du skrive array ('a' -> 1, 'b' -> 2.

312
00:27:36,960 --> 00:27:41,160
Det var konstruktøren for en matrise.

313
00:27:41,160 --> 00:27:45,950
Nå PHP har endelig kommet rundt til gode syntaks av bare hakeparenteser,

314
00:27:45,950 --> 00:27:50,900
som er bare så mye bedre enn array.

315
00:27:50,900 --> 00:27:54,480
Men vurderer PHP 5.4 er den nyeste versjonen,

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

317
00:27:59,090 --> 00:28:08,220
I løpet av sommeren kjørte vi inn i denne saken hvor PHP 5.3 var det vi hadde på apparatet,

318
00:28:08,220 --> 00:28:14,480
men serveren som vi utplassert alle våre karakterbok og sende 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 vite dette, har vi utviklet i 5.3, presset til 5,4,

321
00:28:23,060 --> 00:28:25,660
og nå plutselig ingen av koden vår fungerer

322
00:28:25,660 --> 00:28:28,680
fordi det har skjedd å ha vært endringer mellom 5,3 og 5,4

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

324
00:28:31,030 --> 00:28:35,770
og vi må gå og fikse alle våre ting som ikke fungerer for PHP 5.4.

325
00:28:39,210 --> 00:28:42,320
For denne klassen, da apparatet ikke har PHP 5.4,

326
00:28:42,320 --> 00:28:45,490
det er helt greit å bruke hakeparenteser.

327
00:28:47,240 --> 00:28:50,440
Men hvis du leter opp ting rundt på Internett,

328
00:28:50,440 --> 00:28:54,880
Hvis du leter opp en slags matrise ting, mest sannsynlig at du kommer til å se

329
00:28:54,880 --> 00:29:02,020
spell ut utvalg konstruktør syntaks siden det har eksistert siden PHP ble født

330
00:29:02,020 --> 00:29:07,340
og hakeparentes syntaks har eksistert i de siste par månedene

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 indeksen.

333
00:29:12,710 --> 00:29:30,610
Akkurat som i C hvordan du ville indeksen med hakeparenteser som $ array [0], $ array [1], $ array [2],

334
00:29:30,610 --> 00:29:36,320
du indekserer på samme måte hvis du tilfeldigvis har dine indekser blir strenger.

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

336
00:29:40,440 --> 00:29:47,410
$ Matrise [b]. Hvorfor skulle dette være galt?

337
00:29:52,490 --> 00:29:59,870
Det vil trolig generere en advarsel, men fortsatt arbeid. PHP har en tendens til å gjøre det.

338
00:29:59,870 --> 00:30:04,890
Det har en tendens til å bare: "Jeg kommer til å advare deg om dette, men jeg skal bare holde det gående

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

340
00:30:07,550 --> 00:30:11,500
Det vil trolig oversette dette til en streng,

341
00:30:11,500 --> 00:30:15,000
men det er mulig at på et tidspunkt i fortiden noen sa

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

343
00:30:20,180 --> 00:30:28,740
Så nå b kan være en konstant og $ array [b] vil faktisk være å gjøre 'Hello World'.

344
00:30:28,740 --> 00:30:32,380
Jeg tror på dette punktet, eller i det minste våre PHP-innstillinger,

345
00:30:32,380 --> 00:30:37,870
hvis du prøver å indeksere inn i en matrise, og at nøkkelen ikke eksisterer, vil det mislykkes.

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

347
00:30:40,150 --> 00:30:44,560
Eller i det minste du kan sette den slik at den ikke advare bare deg, det bare rett mislykkes opp.

348
00:30:44,560 --> 00:30:49,290
>> Måten du sjekke for å se om det faktisk er slik indeks er isset.

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

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

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

352
00:31:15,060 --> 00:31:22,440
Jeg er ganske sikker på hva denne tabellen ville ende opp med å bli er - Vi kan teste det ut.

353
00:31:43,290 --> 00:31:45,700
Oh, jeg trenger PHPWord.

354
00:31:53,960 --> 00:32:00,260
Dette er å blande syntaksen der du angir hva nøkkelen er

355
00:32:00,260 --> 00:32:03,330
og du ikke spesifisere hva nøkkelen er.

356
00:32:03,330 --> 00:32:05,520
Så 3 her er en verdi.

357
00:32:05,520 --> 00:32:08,080
Du har ikke eksplisitt sagt hva styringsrenten skal være.

358
00:32:08,080 --> 00:32:11,670
Hva tror du det nøkkel kommer til å bli?

359
00:32:11,670 --> 00:32:21,410
[Student] 0. >> Jeg gjetter 0 bare fordi det er den første vi har ikke spesifisert.

360
00:32:21,410 --> 00:32:23,500
Vi kan faktisk gjøre et par av disse tilfellene.

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

362
00:32:28,030 --> 00:32:32,700
Det ville skrive subarrays i matrisen hvis det var noen.

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 ut som det ga det 0.

365
00:32:38,810 --> 00:32:43,530
Det er faktisk noe å huske på her, men vi vil komme tilbake til det i et sekund.

366
00:32:43,530 --> 00:32:45,850
Men hva hvis jeg måtte gjøre denne indeksen 1?

367
00:32:45,850 --> 00:32:51,170
PHP skiller ikke mellom streng indekser og heltall indekser,

368
00:32:51,170 --> 00:33:00,280
Så på dette punktet har jeg bare definert en indeks 1, og jeg kan gjøre begge $ array [1] og $ array ['1 ']

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

370
00:33:06,250 --> 00:33:13,000
Så nå hva tror du 3 kommer til å bli? >> [Student] 2. >> [Bowden] Jeg gjetter 2.

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

372
00:33:18,690 --> 00:33:24,790
Hva om vi gjorde dette er 10, er dette 4? Hva tror du indeksen på 3 kommer til å bli?

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

374
00:33:29,110 --> 00:33:33,060
Min gjetning på hva PHP gjør - og jeg tror jeg har sett dette før -

375
00:33:33,060 --> 00:33:39,760
er det bare holder styr på hva den høyeste numerisk indeks det er brukt så langt er.

376
00:33:39,760 --> 00:33:44,230
Det kommer aldri til å tildele en streng indeksen til 3. Det vil alltid være en numerisk indeks.

377
00:33:44,230 --> 00:33:47,690
Så det holder styr på det høyeste en det er tildelt så langt, noe som skjer for å være 10,

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

379
00:33:52,540 --> 00:34:02,110
Det jeg sa tidligere, merke slik det er utskrift av denne matrisen.

380
00:34:02,110 --> 00:34:06,850
Det skriver tast 10, 4 nøkkel, 11 tast, tast d..

381
00:34:06,850 --> 00:34:09,790
Eller la oss gjøre -

382
00:34:15,760 --> 00:34:22,489
Jeg antar jeg ikke sette en 0, men det er utskrift 1, 2, 3, 4.

383
00:34:22,489 --> 00:34:29,330
Hva hvis jeg bytter her? Eller la oss faktisk slå disse to.

384
00:34:29,330 --> 00:34:31,940
Nå det skrives 2, 1, 3, 4.

385
00:34:31,940 --> 00:34:41,270
PHP er arrays er ikke akkurat som din vanlige hash table.

386
00:34:41,270 --> 00:34:45,570
Det er helt naturlig å tenke på dem som hash tabeller 99% av tiden.

387
00:34:45,570 --> 00:34:53,790
Men i dine hash tabeller er det ingen følelse av rekkefølgen ting ble satt inn.

388
00:34:53,790 --> 00:34:56,639
Så så snart du setter det inn i hash table,

389
00:34:56,639 --> 00:35:00,590
anta det er ingen lenket liste, og du kan dømme i en lenket liste

390
00:35:00,590 --> 00:35:03,980
som ble satt inn først.

391
00:35:03,980 --> 00:35:10,060
Men her har vi satt to første, og det vet når det er skrive ut denne tabellen at 2 kommer først.

392
00:35:10,060 --> 00:35:13,090
Det skrives ikke ut i bare hvilken som helst rekkefølge.

393
00:35:13,090 --> 00:35:17,550
Den tekniske data struktur som den bruker er et ordnet kart,

394
00:35:17,550 --> 00:35:24,690
så det kartlegger nøkler til verdier og det husker rekkefølgen disse nøklene ble satt inn.

395
00:35:24,690 --> 00:35:31,600
I utgangspunktet er det noen komplikasjoner der det er irriterende å faktisk -

396
00:35:31,600 --> 00:35:34,510
La oss si du har en rekke 0, 1, 2, 3, 4, 5

397
00:35:34,510 --> 00:35:37,700
og du ønsker å ta ut indeks 2.

398
00:35:37,700 --> 00:35:47,750
En måte å gjøre det på, la oss se hva som ser ut som.

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

400
00:35:50,410 --> 00:35:54,880
Unset skjer for å slette informasjonen både variabler og utvalg indekser.

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

402
00:35:58,630 --> 00:36:03,430
Nå hva dette kommer til å se ut? 2 er bare borte, så det er helt greit.

403
00:36:03,430 --> 00:36:11,670
Mer irriterende er hvis du vil at ting skal faktisk være som en matrise.

404
00:36:11,670 --> 00:36:14,910
Jeg skal sette tilfeldige tall.

405
00:36:14,910 --> 00:36:20,400
Nå merker jeg indekser.

406
00:36:20,400 --> 00:36:26,860
Jeg vil at det skal bare være som en C array hvor den går fra 0 til lengde - 1

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

408
00:36:30,810 --> 00:36:38,520
Men så snart jeg slette informasjonen den andre indeksen, hva som var i indeksen 3 ikke nå blitt indeks 2.

409
00:36:38,520 --> 00:36:44,790
I stedet er det fjerner bare at indeksen og nå du går 0, 1, 3, 4.

410
00:36:44,790 --> 00:36:48,740
Dette er helt rimelig.

411
00:36:48,740 --> 00:36:53,950
Det er bare irriterende, og du trenger å gjøre ting som matrise skjøt. Ja.

412
00:36:53,950 --> 00:36:57,200
>> [Student] Hva ville skje hvis du hadde en for loop

413
00:36:57,200 --> 00:36:59,630
og du ønsket å gå over alle elementene?

414
00:36:59,630 --> 00:37:02,290
Når den treffer to, ville det gi noensinne?

415
00:37:02,290 --> 00:37:10,150
Iterating over en matrise. Det er 2 måter du kan gjøre det.

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

417
00:37:12,770 --> 00:37:22,000
Dette er en annen intricacy av PHP.

418
00:37:22,000 --> 00:37:27,420
De fleste språk, vil jeg si, har noen form for lengde eller len eller noe

419
00:37:27,420 --> 00:37:30,470
indikerer lengden av en matrise.

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

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

422
00:37:36,160 --> 00:37:42,950
La oss 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 å mislykkes.

425
00:37:51,610 --> 00:38:03,020
Dette er grunnen til at, for det meste, du aldri trenger å iterere over en rekke som dette.

426
00:38:03,020 --> 00:38:07,110
Det kan være en overdrivelse, men du aldri trenger å iterere over en rekke som dette

427
00:38:07,110 --> 00:38:19,410
fordi PHP gir sin foreach syntaks der foreach ($ array som $ element).

428
00:38:19,410 --> 00:38:31,830
Hvis vi nå ut ($ element), - vi vil diskutere det i et sekund - som fungerer helt greit.

429
00:38:31,830 --> 00:38:38,960
Måten at foreach arbeider er det første argumentet er tabellen som du gjentar over.

430
00:38:38,960 --> 00:38:44,060
Og det andre argumentet, et element gjennom hver passering av for loop

431
00:38:44,060 --> 00:38:52,690
det kommer til å ta på den neste tingen i matrisen. Så husk tabellen har en ordre.

432
00:38:52,690 --> 00:38:55,690
Første gang gjennom for loop, er element kommer til å 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
Ting blir veldig rart når du gjør noe som foreach.

435
00:39:04,670 --> 00:39:07,480
La oss se hva som skjer fordi du aldri bør gjøre dette.

436
00:39:07,480 --> 00:39:13,320
Hva om vi unset ($ array [1]);

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

438
00:39:26,030 --> 00:39:30,950
Du gjentar i denne matrisen, og hver gang du deaktivering den første indeksen.

439
00:39:30,950 --> 00:39:39,720
Så for indeks 0, tar det første, element på verdien 0, så det kommer til å bli 123.

440
00:39:39,720 --> 00:39:44,630
Men innsiden av for-løkken vi unset en indeks, så det betyr 12 er borte.

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

442
00:39:57,480 --> 00:40:03,580
PHP_EOL er bare linjeskift, men det er teknisk mer portable

443
00:40:03,580 --> 00:40:08,890
siden linjeskift i Windows er forskjellig fra linjeskift på Mac og UNIX.

444
00:40:08,890 --> 00:40:18,040
På Windows linjeskift er \ r \ n, mens overalt ellers pleier det bare å være \ n.

445
00:40:18,040 --> 00:40:25,150
PHP_EOL er konfigurert slik at den bruker uansett linjeskift i systemet ditt er.

446
00:40:25,150 --> 00:40:29,310
Så ut som. La oss ikke print_r ($ array) på slutten.

447
00:40:32,830 --> 00:40:37,390
Jeg hadde ingen anelse om at det ville være atferd.

448
00:40:41,740 --> 00:40:48,960
Elementet tar fortsatt på verdien 12, selv om vi slette informasjonen 12 før vi noen gang kom til det fra tabellen.

449
00:40:52,770 --> 00:40:58,840
Ikke ta mitt ord på dette, men det ser ut som foreach oppretter en kopi av tabellen

450
00:40:58,840 --> 00:41:02,160
og deretter elementet tar på alle verdier av denne kopien.

451
00:41:02,160 --> 00:41:07,760
Så selv om du endrer matrisen inne i for loop,

452
00:41:07,760 --> 00:41:17,240
det vil ikke vare. Elementet vil ta på de opprinnelige verdiene.

453
00:41:17,240 --> 00:41:19,240
La oss prøve deaktivering det.

454
00:41:19,240 --> 00:41:24,460
Hva om dette er $ array [1] = "Hei";

455
00:41:24,460 --> 00:41:31,770
Selv om vi setter "hallo" i tabellen, tar vare aldri på denne verdien.

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

457
00:41:37,430 --> 00:41:45,900
hvor du setter to variabler atskilt med en pil.

458
00:41:45,900 --> 00:41:49,680
Denne første variabelen kommer til å være nøkkelen til den verdien,

459
00:41:49,680 --> 00:41:53,050
og denne andre variabelen er kommer til å være den samme nøyaktige element.

460
00:41:53,050 --> 00:42:01,610
Dette er uinteressant her, men hvis vi går tilbake til vår opprinnelige tilfelle av '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 iterate for hver matrise som element, element kommer til å være en hver eneste gang.

463
00:42:14,470 --> 00:42:18,170
Men hvis vi ønsker også å vite nøkkelen forbundet med dette elementet

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

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

466
00:42:31,980 --> 00:42:39,380
Nå er det gjentar om og om utskrift hver tast og dens tilhørende verdi.

467
00:42:39,380 --> 00:42:47,030
>> En ekstra ting vi kan gjøre i foreach løkker er kan du se denne syntaksen.

468
00:42:47,030 --> 00:42:54,770
Ampersand før variabelnavn tendens til å være hvordan PHP gjør referanser.

469
00:42:54,770 --> 00:43:00,460
Hvor referanser er svært lik pekere,

470
00:43:00,460 --> 00:43:04,820
du har ikke pekere, slik at du aldri avtale med minne direkte.

471
00:43:04,820 --> 00:43:12,620
Men du har referanser der en variabel refererer til det samme som en annen variabel.

472
00:43:12,620 --> 00:43:21,450
Innsiden av her la oss gjøre $ element. La oss gå tilbake til 1, 10.

473
00:43:21,450 --> 00:43:28,800
La oss gjøre $ element + +; Det finnes fortsatt på PHP. Du kan fortsatt gjøre + +.

474
00:43:28,800 --> 00:43:38,260
php.test.php. Jeg må skrive den ut. print_r ($ array);

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

476
00:43:42,730 --> 00:43:49,560
Hvis jeg bare hadde gjort foreach ($ array som $ element) da elementet vil være verdien 1

477
00:43:49,560 --> 00:43:54,190
første gang gjennom løkken. Det vil øke 1 til 2 og da er vi ferdig.

478
00:43:54,190 --> 00:43:57,260
Så da vil det gå gjennom en ny omgang med sløyfen og at elementet er 10.

479
00:43:57,260 --> 00:44:01,570
Det trinn element til 11, og deretter det er bare kastes.

480
00:44:01,570 --> 00:44:06,670
Da vi print_r ($ array), og la oss se at dette er bare 1, 10.

481
00:44:06,670 --> 00:44:09,070
Så tilveksten vi gjorde var tapt.

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

483
00:44:13,410 --> 00:44:21,910
nå dette elementet er det samme elementet som dette her. Det er det samme.

484
00:44:21,910 --> 00:44:26,820
Så $ element + + er å endre matrise 0.

485
00:44:29,330 --> 00:44:41,850
I utgangspunktet kan du også gjøre $ k -> $ element, og du kan gjøre $ array [$ k] + +;

486
00:44:41,850 --> 00:44:48,650
>> Så en annen måte å gjøre det, står vi fritt til å endre element,

487
00:44:48,650 --> 00:44:54,070
men det vil ikke endre vår opprinnelige array.

488
00:44:54,070 --> 00:44:59,720
Men hvis vi bruker k, som er vår nøkkel, kan vi da bare indeksen inn matrise vår bruker det nøkkelen

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

490
00:45:01,530 --> 00:45:05,410
Dette mer direkte endrer vår opprinnelige array.

491
00:45:05,410 --> 00:45:10,690
Du kan selv gjøre det hvis noen grunn ville du mulighet til å endre -

492
00:45:10,690 --> 00:45:13,510
Egentlig er dette helt rimelig.

493
00:45:13,510 --> 00:45:16,020
Du har ikke lyst til å skrive $ array [$ k] + +,

494
00:45:16,020 --> 00:45:27,890
du ville bare skrive $ element + +, men du fortsatt ønsket å si if ($ k === 'a')

495
00:45:27,890 --> 00:45:30,620
Deretter øke elementet og deretter skrive vår array.

496
00:45:30,620 --> 00:45:36,290
Så nå hva forventer vi print_r å gjøre? Hvilke verdier skal skrives?

497
00:45:36,290 --> 00:45:43,770
[Student] 2 og 10. >> [Bowden] Bare hvis nøkkelen var 'a' gjør vi faktisk ut som.

498
00:45:51,940 --> 00:45:55,670
>> Du har sannsynligvis svært sjelden, om noensinne, må definere funksjoner i PHP,

499
00:45:55,670 --> 00:46:03,370
men du kan se noe lignende der du definerer en funksjon som funksjon uansett.

500
00:46:03,370 --> 00:46:09,900
Vanligvis ville du si ($ foo, $ bar) og deretter definerer det å være uansett.

501
00:46:09,900 --> 00:46:17,580
Men hvis jeg gjør dette, så det betyr at det kaller uansett,

502
00:46:17,580 --> 00:46:25,110
hva kaller baz, så det første argument til baz kan endres.

503
00:46:25,110 --> 00:46:38,100
La oss gjøre $ foo + +;

504
00:46:38,100 --> 00:46:48,020
og innsiden av her la oss gjøre baz ($ element);

505
00:46:48,020 --> 00:46:52,250
Nå er vi ringer en funksjon.

506
00:46:52,250 --> 00:46:56,780
Argumentet er tatt ved henvisning, noe som betyr at hvis vi endrer det

507
00:46:56,780 --> 00:47:00,390
vi endrer ting som ble vedtatt i.

508
00:47:00,390 --> 00:47:04,420
Og utskrift av denne vi forventer - med mindre jeg rotet syntaks - vi fikk 2, 11,

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

510
00:47:06,300 --> 00:47:08,790
Merker vi trenger referanser i to steder.

511
00:47:08,790 --> 00:47:13,050
Hva hvis jeg gjorde dette? Hva betyr dette?

512
00:47:13,050 --> 00:47:15,810
[Student] Det vil forandre. >> Ja.

513
00:47:15,810 --> 00:47:18,290
Elementet er bare en kopi av verdien i matrisen.

514
00:47:18,290 --> 00:47:26,670
Så vil bytte til 2, men array ['a'] vil fortsatt være en.

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

516
00:47:32,560 --> 00:47:39,260
Nå elementet er sendt som en kopi til baz.

517
00:47:39,260 --> 00:47:46,330
Slik at kopien av argumentet vil økes til 2,

518
00:47:46,330 --> 00:47:49,240
men selve elementet ble aldri økes til 2.

519
00:47:49,240 --> 00:47:52,880
Og elementet er det samme som rekke brakett uansett,

520
00:47:52,880 --> 00:47:55,380
slik at matrisen ble aldri økes.

521
00:47:55,380 --> 00:47:57,960
Så begge disse stedene trenger det.

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

523
00:48:03,830 --> 00:48:06,570
Du tenker kanskje jeg ønsker å passere ved henvisning -

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

525
00:48:09,560 --> 00:48:14,480
Det var en questions.txt ting der det er sagt,

526
00:48:14,480 --> 00:48:19,280
Hvorfor kan det være lurt å passere denne struct ved henvisning?

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

528
00:48:21,250 --> 00:48:25,100
[Student] Så du trenger ikke å kopiere noe stort. >> Ja.

529
00:48:25,100 --> 00:48:32,920
En struct kan være tilfeldig stort, og når du passerer struct inn som et argument

530
00:48:32,920 --> 00:48:36,800
det er behov for å kopiere at hele struct å passere den til funksjon,

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

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

533
00:48:48,520 --> 00:48:52,320
PHP er litt smartere enn som så.

534
00:48:52,320 --> 00:49:00,650
Hvis jeg har noen funksjon, og passerer jeg det en rekke 1000 ting,

535
00:49:00,650 --> 00:49:03,990
betyr at det er nødt til å kopiere alle 1000 av disse tingene

536
00:49:03,990 --> 00:49:10,450
å passere den inn i funksjonen? Det behøver ikke å gjøre det umiddelbart.

537
00:49:10,450 --> 00:49:15,940
Hvis innsiden av denne funksjonen er det aldri endrer faktisk foo,

538
00:49:15,940 --> 00:49:22,660
så hvis ($ foo === 'Hei') return true.;

539
00:49:22,660 --> 00:49:26,460
Legg merke til at vi aldri faktisk endret argumentet innsiden av denne funksjonen,

540
00:49:26,460 --> 00:49:30,010
noe som betyr at det ble vedtatt i så Foo aldri trenger å bli kopiert

541
00:49:30,010 --> 00:49:32,100
fordi det ikke endre det.

542
00:49:32,100 --> 00:49:39,240
Så måten PHP fungerer er argumentene er alltid gått med referanse

543
00:49:39,240 --> 00:49:42,170
før du faktisk prøver å endre det.

544
00:49:42,170 --> 00:49:51,160
Nå hvis jeg si $ foo + +, det vil nå lage en kopi av den opprinnelige foo og endre kopien.

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

546
00:49:53,090 --> 00:49:58,210
Hvis du aldri berøre dette enormt utvalg, du aldri endre den,

547
00:49:58,210 --> 00:50:02,360
det er ikke nødvendig å gjøre kopien,

548
00:50:02,360 --> 00:50:06,640
mens hvis vi bare sette dette tegnet som betyr at den ikke engang kopiere den

549
00:50:06,640 --> 00:50:08,640
selv om du endrer det.

550
00:50:08,640 --> 00:50:10,680
Denne oppførselen kalles kopi-on-write.

551
00:50:10,680 --> 00:50:17,380
Du vil se det andre steder, spesielt hvis du tar et operativsystem kurset.

552
00:50:17,380 --> 00:50:23,880
Kopier-on-write er en ganske vanlig mønster der du ikke trenger å lage en kopi av noe

553
00:50:23,880 --> 00:50:26,650
med mindre det er faktisk endring. Ja.

554
00:50:26,650 --> 00:50:29,520
[Student] Hva om du hadde tilvekst inne i testen,

555
00:50:29,520 --> 00:50:33,700
så bare en del av 1000 måtte endres?

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 greia, men det er mulig det er smart nok til at -

558
00:50:51,250 --> 00:51:00,020
Egentlig hva jeg tenker er forestille vi hadde en matrise som ser slik ut: $ matrise2 = [

559
00:51:00,020 --> 00:51:11,000
Deretter indeksere 'a' er en rekke [1 2 3 4], og indeksen 'b' er en rekke uansett.

560
00:51:11,000 --> 00:51:15,380
Jeg trenger komma mellom alle disse. Forestille det er komma.

561
00:51:15,380 --> 00:51:21,210
Deretter 'c' er verdien 3.

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

563
00:51:26,290 --> 00:51:33,440
Nå la oss si at vi $ baz ($ matrise2);

564
00:51:33,440 --> 00:51:36,540
der baz ikke ta dette ved referanse.

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

566
00:51:47,370 --> 00:51:52,340
Dette er et slikt eksempel der vi passerer matrise2 som et argument

567
00:51:52,340 --> 00:51:57,010
og da er det å endre en spesifikk indeks i matrisen ved å inkrementere den.

568
00:51:57,010 --> 00:52:01,090
Jeg ærlig har ingen anelse om hva PHP kommer til å gjøre.

569
00:52:01,090 --> 00:52:07,200
Det kan lett lage en kopi av hele greia, men hvis det er smart,

570
00:52:07,200 --> 00:52:15,030
det vil lage en kopi av disse tastene hvor dette vil ha sin distinkte verdi

571
00:52:15,030 --> 00:52:20,620
men dette kan likevel peker til samme matrisen 1,2,3,4

572
00:52:20,620 --> 00:52:22,320
og dette kan fremdeles peker til samme rekke.

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

574
00:52:28,900 --> 00:52:45,950
Vi passerer i denne matrisen hvor denne fyren poeng til 3, denne fyren poeng til [1,2,3,4],

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

576
00:52:51,350 --> 00:52:58,590
Nå som vi passerer den til baz, vi endrer dette.

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

578
00:53:11,850 --> 00:53:18,230
Vi hadde fortsatt å kopiere noe minne, men hvis det var disse enorme nestede subarrays

579
00:53:18,230 --> 00:53:21,560
vi trenger ikke å kopiere dem.

580
00:53:21,560 --> 00:53:27,530
Jeg vet ikke om det er det det gjør, men jeg kan forestille meg det gjør det.

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

582
00:53:36,690 --> 00:53:40,320
>> PHP gjør livet så mye enklere for mange ting,

583
00:53:40,320 --> 00:53:45,060
men du typen har absolutt ingen anelse om hvor godt det vil fungere

584
00:53:45,060 --> 00:53:52,530
fordi jeg har ingen anelse under panseret når det gjør disse kopier av ting,

585
00:53:52,530 --> 00:53:55,170
oh, kommer det til å være en konstant tid kopi,

586
00:53:55,170 --> 00:54:01,140
er det bare kommer til å endre en peker, det kommer til å bli en latterlig vanskelig lineær kopi?

587
00:54:01,140 --> 00:54:03,000
Hva om det ikke kan finne plass?

588
00:54:03,000 --> 00:54:06,760
Betyr det da nødvendig å kjøre søppelrydding å få litt mer plass?

589
00:54:06,760 --> 00:54:11,210
Og søppelrydding kan ta vilkårlig lang.

590
00:54:11,210 --> 00:54:13,600
I C trenger du ikke å bekymre deg for disse tingene.

591
00:54:13,600 --> 00:54:19,780
Hver enkelt linje du skriver du kan ganske mye grunn om hvordan det kommer til å utføre.

592
00:54:26,800 --> 00:54:29,150
>> La oss se tilbake på disse.

593
00:54:35,400 --> 00:54:37,520
Hvor fint er det at du ikke trenger å forholde seg til hash funksjoner,

594
00:54:37,520 --> 00:54:39,010
knyttet lister, eller noe sånt?

595
00:54:39,010 --> 00:54:41,980
Siden arbeidet med hash tabeller er så lett nå, her er en morsom oppgave å jobbe med.

596
00:54:41,980 --> 00:54:45,920
Åpne opp en fil kalt unique.php og i det skrive et PHP-program

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

598
00:54:48,330 --> 00:54:55,700
Vi har en tendens til å kalle dem skript hvis de er korte ting som du kjører på kommandolinjen.

599
00:54:55,700 --> 00:55:02,950
I utgangspunktet, alle språk som du ikke kompilere, men du kommer til å kjøre den kjørbare

600
00:55:02,950 --> 00:55:05,920
på kommandolinjen, kan du kalle det kjørbart skript.

601
00:55:05,920 --> 00:55:08,510
Jeg kunne like godt skrive et C-program som gjør dette,

602
00:55:08,510 --> 00:55:12,300
men jeg kan ikke kalle det et script siden jeg først kompilere den og deretter kjøre den binære.

603
00:55:12,300 --> 00:55:15,480
Men dette PHP program skal vi kalle et skript.

604
00:55:15,480 --> 00:55:23,830
Eller hvis vi skrev det i Python eller Perl eller Node.js eller noen av disse tingene,

605
00:55:23,830 --> 00:55:26,500
vi vil kalle dem alle skript fordi du kjører dem på kommandolinjen

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

607
00:55:30,860 --> 00:55:33,400
Vi kunne gjøre dette ganske raskt.

608
00:55:36,960 --> 00:55:41,480
Vi kommer ikke til å bruke argv. La oss bare blåse gjennom dette.

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

610
00:55:45,730 --> 00:55:49,400
Du kan anta at input vil inneholde ett ord per linje.

611
00:55:49,400 --> 00:55:52,020
Egentlig vil argv være ganske trivielt å bruke.

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, ønsker vi å sjekke om vi har gått en kommandolinje-argument.

614
00:56:13,750 --> 00:56:20,900
Akkurat som du ville forvente argc og argv i C, vi har fortsatt de i PHP.

615
00:56:20,900 --> 00:56:33,900
Så hvis ($ argc! == 2) så jeg vil ikke forholde seg til å skrive ut en melding eller noe.

616
00:56:33,900 --> 00:56:37,340
Jeg vil bare avslutte, feilkode av en.

617
00:56:37,340 --> 00:56:41,340
Jeg kunne også tilbake en.

618
00:56:41,340 --> 00:56:53,180
Sjelden i PHP er du på denne tilstanden hvor vi er på -

619
00:56:53,180 --> 00:56:57,820
Vanligvis er du i en funksjon kalt av en funksjon kalt av en funksjon kalt av en funksjon.

620
00:56:57,820 --> 00:57:02,070
Og hvis noe går galt og du bare ønsker å avslutte alt helt,

621
00:57:02,070 --> 00:57:05,680
exit ender like programmet.

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

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

624
00:57:10,700 --> 00:57:17,540
og du vil bare drepe programmet, kan du ringe exit, og det vil bare avslutte.

625
00:57:17,540 --> 00:57:23,120
Men i PHP er det enda mer sjelden at vi er på dette øverste nivå.

626
00:57:23,120 --> 00:57:26,090
Vanligvis vi er inne en slags funksjon, så kaller vi exit

627
00:57:26,090 --> 00:57:29,650
slik at vi ikke trenger å gå tilbake opp en ting som deretter innser det er en feil

628
00:57:29,650 --> 00:57:32,270
så som returnerer opp hvis det gjenkjenner det var en feil.

629
00:57:32,270 --> 00:57:35,270
Vi ønsker ikke å forholde seg til det, så gå ut (1);

630
00:57:35,270 --> 00:57:38,240
Avkastningen (1), i dette tilfellet ville være tilsvarende.

631
00:57:38,240 --> 00:57:44,000
>> Så det vi ønsker å åpne vi ønsker å fopen.

632
00:57:44,000 --> 00:57:46,760
Argumentene kommer til å se ganske lik.

633
00:57:46,760 --> 00:57:51,600
Vi ønsker å fopen ($ argv [1], og vi ønsker å åpne den for å lese.

634
00:57:51,600 --> 00:57:55,720
Som returnerer en ressurs som vi kommer til å kalle f.

635
00:57:55,720 --> 00:58:02,180
Dette ser ganske lik hvordan C gjør det bortsett fra vi ikke trenger å si FIL *.

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

637
00:58:06,170 --> 00:58:17,190
Egentlig tror jeg dette selv gir oss et hint om PHP funksjon som heter fil. PHP File.

638
00:58:17,190 --> 00:58:23,990
Hva dette kommer til å gjøre er å lese en hel fil inn i en matrise.

639
00:58:23,990 --> 00:58:29,770
Du trenger ikke engang å fopen det. Det kommer til å gjøre det for deg.

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

641
00:58:43,700 --> 00:58:49,680
Nå har alle de linjene i filen er i linjer. Nå ønsker vi å sortere linjene.

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

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

644
00:58:54,920 --> 00:58:58,080
Og nå kan vi skrive dem eller hva.

645
00:58:58,080 --> 00:59:05,580
Sannsynligvis den enkleste måten er foreach ($ linjer som $ linje) echo $ linje;

646
00:59:05,580 --> 00:59:10,960
[Student] Ville ikke vi selv krysse linjene ved å referere noe inn sort?

647
00:59:10,960 --> 00:59:28,850
Det er der slag ville bli definert som funksjon sorter (& $ array).

648
00:59:28,850 --> 00:59:32,650
Når du kaller funksjonen du ikke forbi den som referanse.

649
00:59:32,650 --> 00:59:36,900
Det er funksjonen som definerer det som å ta det som referanse.

650
00:59:36,900 --> 00:59:40,900
Dette er faktisk akkurat hva som gikk galt

651
00:59:40,900 --> 00:59:46,220
når vi legger alt til våre servere når vi gikk 5,3 til 5,4.

652
00:59:46,220 --> 00:59:53,800
Frem til 5.4, var dette helt rimelig.

653
00:59:53,800 --> 00:59:58,740
En funksjon forventer ikke å ta det som referanse, men du kan sende den som referanse

654
00:59:58,740 --> 01:00:02,860
så hvis funksjonen ikke skje til å endre det, er det fortsatt endret.

655
01:00:02,860 --> 01:00:05,850
Som på 5,4, er du ikke lov til å gjøre dette.

656
01:00:05,850 --> 01:00:11,740
Så nå den eneste måten du passerer referanse er hvis funksjonen eksplisitt gjør det.

657
01:00:11,740 --> 01:00:19,840
Hvis du ikke vil at den skal endre det, så må du gjøre $ copy = $ linjer og pass kopi.

658
01:00:19,840 --> 01:00:24,820
Så nå linjene vil bli bevart og kopi vil bli endret.

659
01:00:27,670 --> 01:00:31,460
php.unique.php. Jeg kan ha rotet noe opp.

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

661
01:00:38,320 --> 01:00:43,850
Det kommer til å være noe som gjør dette for oss.

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

663
01:00:45,820 --> 01:00:52,140
Legger merke til når du lese bruksanvisningen som det første argumentet er forventet å være en matrise

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

665
01:00:58,160 --> 01:01:03,540
Hvorfor er dette klager til meg? Fordi jeg har denne funksjonen sorter fortsatt i her at jeg ikke vil ha.

666
01:01:03,540 --> 01:01:09,210
Ok, php.unique.php. Jeg bestod ikke 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 skrives ut i en fin sortert rekkefølge.

669
01:01:19,080 --> 01:01:24,600
Legg merke til at sortert rekkefølge er slags merkelig for en kode fil

670
01:01:24,600 --> 01:01:27,460
fordi alle våre tomme linjer skal komme først

671
01:01:27,460 --> 01:01:30,190
deretter kommer til å komme alle våre 1 nivå fordypninger

672
01:01:30,190 --> 01:01:33,360
så kommer alle våre ingen fordypninger.

673
01:01:33,360 --> 01:01:38,620
Ja. >> [Student] Så for kildekoden det ikke ble vedtatt av referanse?

674
01:01:38,620 --> 01:01:42,240
Er det generelt vedtatt av verdi?

675
01:01:42,240 --> 01:01:50,240
[Bowden] Når du ringer en funksjon, det har aldri avgjør om det ble vedtatt som referanse.

676
01:01:50,240 --> 01:01:53,960
Det er funksjonen definisjonen som avgjør om det ble vedtatt som referanse.

677
01:01:53,960 --> 01:01:59,450
Og ser på funksjonen definisjonen av slag eller bare ser på dette,

678
01:01:59,450 --> 01:02:02,820
det tar argumentet ved referanse.

679
01:02:02,820 --> 01:02:07,160
Så uansett om du vil at den skal ta det med referanse, det tar det som referanse.

680
01:02:07,160 --> 01:02:10,200
Det endrer tabellen på plass.

681
01:02:10,200 --> 01:02:17,400
Dette er bare ikke tillatt. Du har ikke lov til å gjøre dette. >> [Student] Oh, okay.

682
01:02:17,400 --> 01:02:22,410
[Bowden] Dette er slags kommer til å ta linjer ved henvisning og endre det.

683
01:02:22,410 --> 01:02:26,850
Og igjen, hvis du ikke vil at den skal gjøre det, kan du lage en kopi av slag.

684
01:02:26,850 --> 01:02:35,850
Selv i dette tilfellet, er kopien ikke faktisk en kopi av linjer.

685
01:02:35,850 --> 01:02:40,620
Det peker bare til det samme til den første blir endret,

686
01:02:40,620 --> 01:02:44,430
hvor det første kommer til å få endret på den slags funksjon,

687
01:02:44,430 --> 01:02:50,940
hvor, fordi det er kopi-on-skrive, nå en kopi av kopi kommer til å bli gjort.

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

689
01:03:04,250 --> 01:03:07,190
Du ser det i foreach løkker, ser du det i funksjon erklæringer,

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

691
01:03:10,040 --> 01:03:12,350
Nå har vi oppnådd noe ved å gjøre dette

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

693
01:03:15,600 --> 01:03:19,940
Du kan bruke linjer og kopiere hverandre.

694
01:03:19,940 --> 01:03:25,430
Du kan gjøre unset ($ kopi), og som ikke unset linjer,

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

696
01:03:29,120 --> 01:03:33,440
Så som i dette punktet, nå linjer er den eneste måten du kan få tilgang til linjer.

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

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

699
01:03:42,460 --> 01:03:45,880
[Student] Helt off topic, men du trenger ikke å lukke PHP med - >> Du gjør ikke det.

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 å si at det er dårlig praksis å lukke dem.

702
01:03:53,790 --> 01:03:57,580
Det er nok en overdrivelse, spesielt i et skript,

703
01:03:57,580 --> 01:04:03,740
men la oss se hva som skjer hvis jeg gjør dette.

704
01:04:03,740 --> 01:04:08,890
Det gjorde ingenting. Hva om jeg ønsket - [sukk]

705
01:04:13,870 --> 01:04:16,960
Jeg trenger å passere et argument.

706
01:04:19,000 --> 01:04:22,050
Skyt. Jeg kalte det galt.

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
Nå er jeg ikke engang trenger dette.

709
01:04:34,520 --> 01:04:37,740
Jeg skal gi det et gyldig argument.

710
01:04:37,740 --> 01:04:42,050
Dette skrives hva det er utskrift.

711
01:04:45,260 --> 01:04:50,080
Jeg skriver kopi og kopiere finnes ikke. Så linjer.

712
01:04:53,650 --> 01:04:58,270
Det skrives alt, og deretter merke alt dette søppelet her nede,

713
01:04:58,270 --> 01:05:06,690
fordi i PHP noe som er utenfor PHP koder

714
01:05:06,690 --> 01:05:09,520
er bare kommer til å bli skrevet ut bokstavelig.

715
01:05:09,520 --> 01:05:18,050
Det er derfor HTML, det er så hyggelig at jeg kan gjøre div blah, blah, blah klasse eller hva,

716
01:05:18,050 --> 01:05:25,140
blah, blah, blah, og deretter gjøre noen PHP-koden og gjør deretter ende div.

717
01:05:25,140 --> 01:05:36,460
Og nå skriver dette får jeg min hyggelig div opp toppen, alt som PHP trykt, div nederst.

718
01:05:36,460 --> 01:05:43,510
Katastrofal når noe som dette skjer, er som ganske vanlig,

719
01:05:43,510 --> 01:05:47,930
bare en bortkommen linjeskift nederst filen.

720
01:05:47,930 --> 01:05:50,940
Du ville ikke tro det ville være så stor av en avtale

721
01:05:50,940 --> 01:05:58,660
før du vurdere det faktum at med nettlesere -

722
01:05:58,660 --> 01:06:03,880
>> Hvordan viderekobler arbeid eller utgangspunktet enhver overskrifter arbeid,

723
01:06:03,880 --> 01:06:07,980
når du gjør tilkoblingen til en nettside og det sender tilbake alle disse overskriftene og ting

724
01:06:07,980 --> 01:06:12,020
som respons 200 eller respons omdirigere eller hva,

725
01:06:12,020 --> 01:06:18,230
hodene er bare gyldig til første byte data blir sendt.

726
01:06:18,230 --> 01:06:23,140
Du kan omadressere tusenvis av ganger, men så snart den første byte data sendes

727
01:06:23,140 --> 01:06:26,120
du er ikke ment å omdirigere igjen.

728
01:06:26,120 --> 01:06:31,860
>> Hvis du har en bortkommen linjeskift ved bunnen av en fil

729
01:06:31,860 --> 01:06:37,260
og la oss si at du bruker denne funksjonen, og deretter du vil -

730
01:06:41,580 --> 01:06:52,870
La oss si det er en annen fil som er index.php og require_once deg noe -

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

732
01:06:56,920 --> 01:07:04,740
Spørsmålet som skjer når denne linjen nederst blir ekko.

733
01:07:04,740 --> 01:07:08,660
Du ønsker ikke noe å ha blitt lest opp ennå.

734
01:07:10,820 --> 01:07:15,700
Selv om du ikke hadde tenkt på noe få ekko, gjorde noe få ekko

735
01:07:15,700 --> 01:07:17,990
og så nå du ikke skal sende flere hoder

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

737
01:07:22,170 --> 01:07:24,420
Du trenger bare ikke disse avsluttende kodene.

738
01:07:24,420 --> 01:07:27,420
Hvis du har tenkt på å gjøre noe med HTML -

739
01:07:27,420 --> 01:07:30,490
og det er helt rimelig å gjøre her nede div uansett

740
01:07:30,490 --> 01:07:39,450
og deretter på dette punktet kan du eller du ikke kan ta dem.

741
01:07:39,450 --> 01:07:41,590
Det spiller egentlig ingen rolle.

742
01:07:41,590 --> 01:07:45,450
Men i PHP-skript er det sjelden å lukke det.

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

744
01:07:50,400 --> 01:07:55,460
du egentlig ikke trenger å lukke det / du bør ikke lukke den.

745
01:08:02,030 --> 01:08:05,720
>> Håndteringen av strenger er mye hyggeligere enn i C.

746
01:08:05,720 --> 01:08:09,470
I PHP kan du angi en streng med enkle eller doble anførselstegn.

747
01:08:09,470 --> 01:08:12,820
Med enkle anførselstegn kan du ikke bruke "Escape" sekvenser.

748
01:08:12,820 --> 01:08:17,640
Stadig unnslippe, blah, blah, blah.

749
01:08:19,920 --> 01:08:24,010
Så printf er svært sjelden i PHP.

750
01:08:24,010 --> 01:08:32,290
Jeg antar jeg ville bruke printf hvis jeg ønsket å gjøre en slags ting - i pset 5 brukte du sprintf eller hva.

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

752
01:08:36,060 --> 01:08:40,300
Så for den slags ting der jeg faktisk ønsker å formatere teksten jeg ville bruke printf.

753
01:08:40,300 --> 01:08:44,689
Men ellers ville jeg bare bruke streng sammensetning.

754
01:08:44,689 --> 01:08:47,000
Jeg har aldri virkelig bruke printf.

755
01:08:49,229 --> 01:09:00,170
Vi bare skille detaljer mellom apostrof og doble hermetegn.

756
01:09:00,170 --> 01:09:07,490
Den største forskjellen er at enkle anførselstegn, vil det bli skrevet bokstavelig.

757
01:09:07,490 --> 01:09:15,390
Det er ingen char datatype i PHP, i motsetning C, så dette tilsvarer dette.

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

759
01:09:17,970 --> 01:09:29,180
Og det fine med enkle sitat strenger er jeg kunne si 'Hei verden!' blah, blah, blah,

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

761
01:09:33,340 --> 01:09:38,260
Hva skjer når jeg skriver ut dette er det vil skrive det bokstavelig talt.

762
01:09:38,260 --> 01:09:40,680
La oss bli kvitt alle våre ting.

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

764
01:09:48,569 --> 01:09:56,570
Det bokstavelig talt trykket alle disse tingene: dollartegn,

765
01:09:56,570 --> 01:09:58,770
backslash n, som du tror vil være linjeskift -

766
01:09:58,770 --> 01:10:01,500
alle disse tingene det skrives bokstavelig.

767
01:10:01,500 --> 01:10:05,650
Det eneste du trenger å flykte er apostrof

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

769
01:10:09,470 --> 01:10:15,050
Doble anførselstegn, helt annerledes.

770
01:10:20,300 --> 01:10:25,870
Vi ser allerede at syntaksutheving er cluing oss på til hva som er i ferd med å gå fryktelig galt.

771
01:10:25,870 --> 01:10:36,190
php.unique. Undefined variable: wooo fordi dette blir tolket som en variabel kalt wooo.

772
01:10:36,190 --> 01:10:42,400
Anførselstegn lar deg sette variabler inn -

773
01:10:42,400 --> 01:10:52,730
La oss si $ name = "Rob";

774
01:10:52,730 --> 01:10:58,020
Så echo "Hei, mitt navn er $ name!";

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

776
01:11:09,260 --> 01:11:21,210
Når jeg kjører det - og jeg vil legge inn et linjeskift - Hei, mitt navn er Rob! og hallo verden!

777
01:11:21,210 --> 01:11:24,910
Dette er fordi jeg aldri fjernet utskrift av wooo ovenfor.

778
01:11:24,910 --> 01:11:30,020
Det er en ytterligere skritt du kan gjøre.

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

780
01:11:39,250 --> 01:11:43,270
Hva om jeg ønsker å skrive ut den første indeksen array?

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

782
01:11:45,150 --> 01:11:49,280
De syntaksutheving er en anelse. Hva dette kommer til å gjøre?

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

784
01:11:54,510 --> 01:11:59,860
Hei, mitt navn er 1! som er ikke hva jeg ville.

785
01:11:59,860 --> 01:12:05,050
Syntaksutheving løy for meg.

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

787
01:12:18,450 --> 01:12:21,440
Det er slik jeg ville ha til å skrive det.

788
01:12:26,350 --> 01:12:32,160
Uventet enkelt anførselstegn (T_ENCAPSED blah, blah, blah, blah, blah).

789
01:12:32,160 --> 01:12:41,780
Tanken er at det ikke er å gjenkjenne dette som en del av matrisen.

790
01:12:41,780 --> 01:12:46,620
Det er ikke anerkjenne dette som matrise indeksert av bokstav a..

791
01:12:46,620 --> 01:12:49,870
Du ønsker å gjøre det i klammeparentes,

792
01:12:49,870 --> 01:12:54,730
og nå alt som er i denne krøllete brace vil bli interpolert,

793
01:12:54,730 --> 01:13:00,340
som er ordet vi bruker for magisk sette disse variablene i de riktige stedene.

794
01:13:00,340 --> 01:13:04,280
Nå gjør dette, php.unique, og Hei, mitt navn er 1! som forventet

795
01:13:04,280 --> 01:13:07,720
eller Hei, mitt navn Rob!

796
01:13:14,110 --> 01:13:23,130
En ting som er slags fint om apostrof er at -

797
01:13:23,130 --> 01:13:28,480
Det er noen kostnader til interpolere.

798
01:13:30,520 --> 01:13:35,100
Hvis du bruker doble anførselstegn, har tolken til å gå over denne strengen,

799
01:13:35,100 --> 01:13:41,500
å sørge for at "Å, her er en variabel. nå jeg trenger å gå få den variabelen og sett den her."

800
01:13:41,500 --> 01:13:48,930
Selv om du ikke bruker noen variabler,

801
01:13:48,930 --> 01:13:52,220
ingenting innsiden av disse anførselstegn må interpolert,

802
01:13:52,220 --> 01:13:56,800
men det vil fortsatt være tregere fordi den trenger å gå over de doble anførselstegn

803
01:13:56,800 --> 01:14:00,130
på jakt etter ting som må bli interpolert.

804
01:14:00,130 --> 01:14:05,360
Så apostrof kan være litt raskere hvis ikke noe behov for å bli interpolert,

805
01:14:05,360 --> 01:14:15,650
og jeg pleier å selv bruke enkle hermetegn for: "Hei, mitt navn er '. $ Array ['a'] uansett.

806
01:14:15,650 --> 01:14:20,430
Det kommer til å være tilsvarende det vi hadde før.

807
01:14:24,840 --> 01:14:28,440
Men det er et spørsmål om preferanser.

808
01:14:28,440 --> 01:14:34,750
Hvis du bruker PHP, har du sannsynligvis ikke bryr seg om hastigheten forskjellen.

809
01:14:34,750 --> 01:14:39,480
Det er ikke nok å resonnere dem ut til å begynne med.

810
01:14:39,480 --> 01:14:43,030
>> Noen endelige spørsmål?

811
01:14:47,430 --> 01:14:51,710
>> Vi har faktisk ikke engang komme gjennom det hele, men dette ting var kjedelig.

812
01:14:51,710 --> 01:14:59,080
Den siste tingen som er slags fint i PHP er når du arbeider med HTML,

813
01:14:59,080 --> 01:15:06,450
du kommer til å bruke det litt, så fin snarvei syntaksen for å skrive ut en variabel.

814
01:15:32,400 --> 01:15:36,730
Uten å sette PHP her, dette kalles korte koder.

815
01:15:36,730 --> 01:15:44,330
Offisielt som av PHP 5.4, er dette frarådet.

816
01:15:44,330 --> 01:15:48,640
Det anbefales å sette php.

817
01:15:48,640 --> 01:15:55,770
Dette er fortsatt støttes, så korte koder med <? = Er fortsatt helt fine.

818
01:15:55,770 --> 01:16:02,480
Det er som standard støttes, slik at du kan bruke disse som du ønsker, og de er ganske praktisk.

819
01:16:02,480 --> 01:16:05,700
>> Eventuelle spørsmål?

820
01:16:07,780 --> 01:16:09,270
OK.

821
01:16:10,840 --> 01:16:13,800
>> Hold deg stilig, San Diego.

822
01:16:13,800 --> 01:16:16,070
[Humrer]

823
01:16:18,620 --> 01:16:22,660
Bye. [Ler]

824
01:16:24,350 --> 01:16:28,470
[Applaus] [ler]

825
01:22:46,460 --> 01:22:49,460
>> [CS50.TV]