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

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

3
00:00:04,910 --> 00:00:07,070
[Detta är CS50. - CS50.TV]

4
00:00:11,520 --> 00:00:14,160
>> Dessa vecka avsnitt anteckningar kommer att vara ganska kort,

5
00:00:14,160 --> 00:00:19,070
så jag ska bara fortsätta prata, är ni kommer att fortsätta att ställa frågor,

6
00:00:19,070 --> 00:00:22,720
och vi ska försöka fylla så mycket tid som möjligt.

7
00:00:22,720 --> 00:00:31,950
Många tror att detta pset är inte nödvändigtvis svårt, men det är mycket lång.

8
00:00:31,950 --> 00:00:37,070
Den pset spec själv tar en timme att läsa.

9
00:00:40,530 --> 00:00:45,730
Vi ger dig en hel del av SQL kan du eventuellt behöver använda.

10
00:00:45,730 --> 00:00:50,520
Vi går igenom mycket av det, så det borde inte vara så illa.

11
00:00:50,520 --> 00:00:54,560
Har någon börjat eller färdiga?

12
00:00:55,380 --> 00:00:59,710
Det är den sista pset. Herregud.

13
00:00:59,710 --> 00:01:05,400
Vanligtvis finns det en JavaScript en efter detta, men kalender ändra saker

14
00:01:05,400 --> 00:01:09,560
gör allt 1 vecka kortare och vi inte längre har en JavaScript pset.

15
00:01:09,560 --> 00:01:12,310
Jag vet inte hur det påverkar om JavaScript kommer att visas på tentan

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

17
00:01:15,510 --> 00:01:22,260
Jag antar att det kommer att vara något som du behöver veta på hög nivå saker om JavaScript,

18
00:01:22,260 --> 00:01:26,460
men jag tvivlar på att vi bara skulle ge dig rakt JavaScript-kod

19
00:01:26,460 --> 00:01:28,720
eftersom du inte har haft en pset i den.

20
00:01:28,720 --> 00:01:33,000
Men det kommer att vara saker för frågesport översyn nästa vecka.

21
00:01:33,000 --> 00:01:36,320
>> Del av frågorna.

22
00:01:36,320 --> 00:01:43,870
En hel del av det här är något dåligt formulerad, men vi kommer att diskutera varför.

23
00:01:43,870 --> 00:01:50,220
Till skillnad från C, PHP ett "dynamiskt skrivit" språk. Vad betyder det, frågar du?

24
00:01:50,220 --> 00:01:53,830
Tja, säga adjö till alla dessa röding, flyta, int, och andra sökord som du behöver använda

25
00:01:53,830 --> 00:01:56,190
När förklara variabler och funktioner i C.

26
00:01:56,190 --> 00:02:00,420
I PHP är en variabels typ bestäms av det värde som för närvarande är innehav.

27
00:02:00,420 --> 00:02:04,990
Så innan vi skriver denna kod i en fil som heter dynamic.php,

28
00:02:04,990 --> 00:02:12,670
PHP dynamiskt skrivs. Det är sant.

29
00:02:12,670 --> 00:02:17,590
Jag håller inte med att det innebär att vi säger adjö till röding, flyta, int,

30
00:02:17,590 --> 00:02:20,620
och andra sökord.

31
00:02:20,620 --> 00:02:25,510
Den exakta skillnaden mellan dynamiskt tryckte hand,

32
00:02:25,510 --> 00:02:32,010
som är statiskt skrivs, är det dynamiskt skrivit, alla dina typkontroll och sånt

33
00:02:32,010 --> 00:02:37,350
händer vid körning, medan statiskt skrivit det händer vid kompileringen.

34
00:02:37,350 --> 00:02:43,030
Ordet static i allmänhet tycks betyda saker kompileringen.

35
00:02:43,030 --> 00:02:48,170
Jag antar att det finns andra användningsområden för det, men i C när du deklarerar en statisk variabel,

36
00:02:48,170 --> 00:02:52,650
lagring fördelas vid kompileringen.

37
00:02:52,650 --> 00:02:59,260
Här dynamiskt skrivit betyder bara att -

38
00:02:59,260 --> 00:03:04,350
I C om du försöker lägga till en sträng och ett heltal, när du kompilerar den,

39
00:03:04,350 --> 00:03:11,000
det kommer att klaga eftersom det kommer att säga att du inte kan lägga en int och en pekare.

40
00:03:11,000 --> 00:03:14,710
Det är bara inte en giltig operation.

41
00:03:14,710 --> 00:03:21,170
Det är en annan sak som vi kommer till i en sekund.

42
00:03:21,170 --> 00:03:24,860
Men den sortens kontroll, att det klagar vid kompileringen,

43
00:03:24,860 --> 00:03:29,220
är statisk typkontroll.

44
00:03:29,220 --> 00:03:35,220
Det finns språk där man inte behöver säga röding, flyta, int, och alla dessa saker,

45
00:03:35,220 --> 00:03:40,940
men språket kan berätta från ramen för något vilken typ det ska vara,

46
00:03:40,940 --> 00:03:43,980
men det är fortfarande statiskt skrivit.

47
00:03:43,980 --> 00:03:49,000
Så om du tar 51, OCaml, behöver du aldrig använda någon av dessa typer,

48
00:03:49,000 --> 00:03:58,700
men det kommer fortfarande vid kompileringen säger att du inte kan göra detta eftersom du blandar en int och en sträng.

49
00:03:58,700 --> 00:04:05,650
Dynamiskt skrivit betyder bara att någon gång under körning du kommer att få ett klagomål.

50
00:04:05,650 --> 00:04:13,430
Om du också har använt Java tidigare i allmänhet nästan alla C-typ språk

51
00:04:13,430 --> 00:04:20,070
kommer att statiskt skrivit så C, C + +, Java, alla dessa är i allmänhet statiskt skrivs.

52
00:04:20,070 --> 00:04:22,910
I Java när du kompilerar något och du säger

53
00:04:22,910 --> 00:04:26,670
string s lika ny något som inte är en sträng,

54
00:04:26,670 --> 00:04:28,950
det kommer att klaga eftersom dessa typer bara inte matchar.

55
00:04:28,950 --> 00:04:31,180
Det kommer att klaga vid kompileringen.

56
00:04:31,180 --> 00:04:36,750
Men det har också några dynamisk tid saker som om du försöker kasta något

57
00:04:36,750 --> 00:04:40,500
en typ som är mer specifik än den nuvarande typ,

58
00:04:40,500 --> 00:04:45,610
det finns inget man kan göra vid kompileringen att kontrollera om den gjutna kommer att lyckas.

59
00:04:45,610 --> 00:04:51,130
Java har också några dynamisk typkontroll att så snart det kommer till att kodrad

60
00:04:51,130 --> 00:04:54,130
när det faktiskt är köra, det kommer att göra rösterna,

61
00:04:54,130 --> 00:04:56,260
kontrollera om det gjutna gällde i första hand,

62
00:04:56,260 --> 00:04:59,890
och om det inte var så att det kommer att klaga över att du har en ogiltig typ.

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

64
00:05:03,200 --> 00:05:07,010
Skriv detta 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
Jag packa den formateringen.

67
00:05:18,750 --> 00:05:21,880
Vi har en variabel, vi satt det till heltal 7,

68
00:05:21,880 --> 00:05:27,930
då ska vi skriva ut det och s% -

69
00:05:27,930 --> 00:05:32,830
Åh, vi skriver den typ av den, så getType kommer att återvända typen av variabeln.

70
00:05:32,830 --> 00:05:35,720
Vi bara skriva ut typ om och om igen.

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

72
00:05:39,440 --> 00:05:45,920
Vi får se till att den ändras från heltal till sträng till Boolean som vi går igenom.

73
00:05:45,920 --> 00:05:54,590
I C finns ingen boolesk datatyp, finns det ingen sträng datatyp.

74
00:05:54,590 --> 00:06:00,500
Det finns char * och Boolean bara tenderar att vara int eller char eller något.

75
00:06:00,500 --> 00:06:05,690
I PHP dessa typer finns, och det är en av de stora fördelarna med PHP över C -

76
00:06:05,690 --> 00:06:13,290
att string verksamhet oändligt mycket lättare i PHP än C. De bara fungerar.

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

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

79
00:06:21,260 --> 00:06:26,710
Detta talar PHP tolken, kallad php, att köra PHP-kod i dynamic.php.

80
00:06:26,710 --> 00:06:30,250
Om du har några fel i filen kommer tolken berätta!

81
00:06:30,250 --> 00:06:39,110
Tolken är detta en annan stor skillnad mellan PHP och C

82
00:06:39,110 --> 00:06:48,200
I C måste du kompilera något och sedan kör det kompilerade filen.

83
00:06:48,200 --> 00:06:50,490
I PHP du kompilera aldrig något.

84
00:06:50,490 --> 00:06:57,200
Så PHP tolken är i princip bara läser detta rad för rad.

85
00:06:57,200 --> 00:07:02,900
Det träffar var = 7 så träffar printf då den träffar var så den träffar printf och så vidare.

86
00:07:02,900 --> 00:07:10,910
Det är lite att sammanställa det gör, och det cachar resultatet

87
00:07:10,910 --> 00:07:15,510
så om du kör skriptet senare kan du göra några,

88
00:07:15,510 --> 00:07:19,280
men i grunden är det en rad för rad saker.

89
00:07:19,280 --> 00:07:25,280
Det betyder att många av de optimeringar som vi får i C,

90
00:07:25,280 --> 00:07:31,920
Liksom sammanställa, det är bara allmänt kompilatorn kan göra en hel del trick för dig.

91
00:07:31,920 --> 00:07:36,110
Det kan ta ut oanvända variabler, kan det göra alla dessa typer av saker,

92
00:07:36,110 --> 00:07:38,660
det kan göra svansen rekursion.

93
00:07:38,660 --> 00:07:42,550
I PHP du inte kommer att få denna fördel

94
00:07:42,550 --> 00:07:45,690
eftersom det bara kommer att börja köra rad för rad för rad,

95
00:07:45,690 --> 00:07:49,950
och den inte erkänner egentligen dessa saker lika lätt

96
00:07:49,950 --> 00:07:54,440
eftersom det inte är en stor sammanställning passerar över saken och sedan utförande;

97
00:07:54,440 --> 00:07:56,860
det är bara en rad i taget.

98
00:08:00,730 --> 00:08:02,750
Så det är tolken.

99
00:08:02,750 --> 00:08:06,840
>> Tillbaka till våra dynamiska skriva: pretty cool, va?

100
00:08:06,840 --> 00:08:08,640
Du definitivt inte kunde göra det i C!

101
00:08:08,640 --> 00:08:11,860
Nu, se om du kan lista ut vilken typ av vardera av följande värden.

102
00:08:11,860 --> 00:08:14,760
Se denna som referens.

103
00:08:14,760 --> 00:08:19,420
Så 3,50. Vilken typ tror du att det kommer att bli?

104
00:08:24,480 --> 00:08:26,370
Här är de typer som vi har.

105
00:08:26,370 --> 00:08:30,430
Vi har bools, heltal, flytande punkter, strängar, arrayer, objekt,

106
00:08:30,430 --> 00:08:38,370
och sedan resurser, vilket är typ av vaga.

107
00:08:38,370 --> 00:08:41,010
Jag tror det finns faktiskt ett exempel här.

108
00:08:41,010 --> 00:08:43,740
Sedan finns NULL. NULL är en speciell typ.

109
00:08:43,740 --> 00:08:47,140
Till skillnad från C där NULL är bara en pekare med adress 0,

110
00:08:47,140 --> 00:08:54,930
i PHP, är NULL sin egen typ där det enda giltiga sak av den typen är NULL.

111
00:08:57,560 --> 00:09:00,670
Detta är mycket mer användbart för felkontroll.

112
00:09:00,670 --> 00:09:04,310
I C där vi hade den här frågan där om du återvänder NULL,

113
00:09:04,310 --> 00:09:08,660
betyder det att du återvänder en NULL-pekare eller använda NULL för att beteckna fel

114
00:09:08,660 --> 00:09:12,380
eller alla som förvirring vi hade vid ett tillfälle.

115
00:09:12,380 --> 00:09:18,440
Här, återvänder NULL allmänhet betyder fel.

116
00:09:20,860 --> 00:09:27,300
En hel del saker återkommer också falskt för fel.

117
00:09:27,300 --> 00:09:33,140
Men poängen är NULL typen är det enda av NULL typen NULL.

118
00:09:33,140 --> 00:09:40,090
Då återuppringning är som du kan definiera några anonyma funktioner.

119
00:09:40,090 --> 00:09:46,420
Du behöver inte ge funktionen ett namn, men du kommer inte behöva ta itu med det här.

120
00:09:46,420 --> 00:09:53,940
Titta på de typer som de inte förväntar sig att vi ska veta,

121
00:09:53,940 --> 00:09:59,000
vad tror du den typ av 3,50 är? >> [Elev] Float.

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

123
00:10:00,370 --> 00:10:06,290
Så då här, vad tycker du vilken typ av detta är? >> [Elev] Array.

124
00:10:06,290 --> 00:10:09,890
Ja. Den första var flottören, är den andra en grupp.

125
00:10:09,890 --> 00:10:14,500
Observera att denna array är inte som en C array

126
00:10:14,500 --> 00:10:19,610
där du har index 0 har något värde, har index 1 visst värde.

127
00:10:19,610 --> 00:10:26,320
Här indexen är a, b och c och är 1, 2, och 3.

128
00:10:26,320 --> 00:10:33,980
I PHP är det ingen skillnad mellan en associativ array och bara en vanlig array

129
00:10:33,980 --> 00:10:36,740
som du skulle tänka på det i C.

130
00:10:36,740 --> 00:10:43,040
Det är just detta, och under huven en vanlig array är bara en associativ array

131
00:10:43,040 --> 00:10:50,000
där 0 kartor till ett värde på samma sätt en kartor till något värde.

132
00:10:50,000 --> 00:11:00,410
Av denna anledning kan PHP vara ganska dåligt för riktigt snabba kod / benchmarking saker

133
00:11:00,410 --> 00:11:07,930
eftersom C när du använder en array som du vet att komma en medlem är konstant tid.

134
00:11:07,930 --> 00:11:11,860
I PHP åtkomst till en ledamot är som vet hur mycket tid?

135
00:11:11,860 --> 00:11:18,970
Det är nog konstant om det hashar korrekt.

136
00:11:18,970 --> 00:11:21,620
Vem vet vad det egentligen gör under huven?

137
00:11:21,620 --> 00:11:25,600
Du måste verkligen titta på genomförandet för att se hur det kommer att ta itu med det.

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

139
00:11:28,550 --> 00:11:36,420
Jag tror här låt oss bara PHP manuell fopen att titta på returtyp.

140
00:11:36,420 --> 00:11:41,260
Vi ser här kan du slå upp ganska mycket varje funktion i PHP manualen

141
00:11:41,260 --> 00:11:47,540
och detta är typ av mannen sidan av PHP.

142
00:11:47,540 --> 00:11:51,060
Avkastningen typ kommer att bli resurs.

143
00:11:51,060 --> 00:11:56,050
Det är därför jag såg det, eftersom vi inte riktigt definiera resurs.

144
00:11:56,050 --> 00:12:04,110
Idén om resurs i C du typ av har en fil * eller vad;

145
00:12:04,110 --> 00:12:07,200
i PHP resursen är din fil *.

146
00:12:07,200 --> 00:12:10,360
Det är vad du kommer att läsa ur, det är vad du kommer att skriva till.

147
00:12:10,360 --> 00:12:20,710
Det är oftast externa, så det är en resurs som du kan dra saker från och kasta saker.

148
00:12:20,710 --> 00:12:26,520
Och slutligen, vad är den typ av NULL? >> [Elev] NULL.

149
00:12:26,520 --> 00:12:30,650
Ja. Så det enda som är NULL NULL.

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

151
00:12:35,490 --> 00:12:41,170
>> Ett inslag i PHP typsystem (på gott och ont) är dess förmåga att jonglera typer.

152
00:12:41,170 --> 00:12:44,390
När du skriver en rad PHP-kod som kombinerar värden av olika slag,

153
00:12:44,390 --> 00:12:46,670
PHP kommer att försöka göra det enda förnuftiga.

154
00:12:46,670 --> 00:12:48,920
Prova var och en av följande rader PHP-kod. Vad skrivs ut?

155
00:12:48,920 --> 00:12:51,000
Är det vad du förväntade dig? Varför eller varför inte?

156
00:12:51,000 --> 00:12:58,600
Detta faktum om PHP är det som gör det vad vi kallar svagt skrivit.

157
00:12:58,600 --> 00:13:04,610
Svagt skrivit och starkt skrivit,

158
00:13:04,610 --> 00:13:06,840
det finns olika användningsområden för dessa villkor,

159
00:13:06,840 --> 00:13:12,020
men de flesta människor använder svagt skrivit och starkt skrivit att betyda något sådant

160
00:13:12,020 --> 00:13:15,920
där ("1" + 2), som fungerar.

161
00:13:15,920 --> 00:13:18,290
I C som inte skulle fungera.

162
00:13:18,290 --> 00:13:22,490
Ni kan föreställa er att detta inte fungerar.

163
00:13:22,490 --> 00:13:29,200
Många blandar ihop dynamisk typning och svag typning och statisk typning och stark skriva.

164
00:13:29,200 --> 00:13:34,050
Python är ett annat exempel på ett språk som dynamiskt är skrivit.

165
00:13:34,050 --> 00:13:41,770
Du kan kasta runt typer i variabler och det kommer att avgöra vid körning

166
00:13:41,770 --> 00:13:44,680
eventuella fel KONTROLLER.

167
00:13:44,680 --> 00:13:50,740
I Python det kommer att utföra detta och det kommer att se ("1" + 2);

168
00:13:50,740 --> 00:13:55,920
och detta kommer att misslyckas eftersom det står att du inte kan lägga till en sträng och ett heltal.

169
00:13:55,920 --> 00:14:00,860
I PHP, som är lika dynamiskt skrivit, kommer detta inte misslyckas.

170
00:14:00,860 --> 00:14:04,220
Svag typning har att göra med det faktum att den gör saker med olika typer

171
00:14:04,220 --> 00:14:07,800
som egentligen inte vettigt nödvändigtvis.

172
00:14:07,800 --> 00:14:17,420
Så ("1" + 2), jag kan tänka mig att vara strängen 12, kan jag tänka mig att det är strängen 3,

173
00:14:17,420 --> 00:14:20,710
Jag kan tänka mig att det är heltalet 3.

174
00:14:20,710 --> 00:14:24,530
Det är inte nödvändigtvis väl definierade, och vi förmodligen kommer att se här

175
00:14:24,530 --> 00:14:29,140
att när vi skriver ut ("1" + 2), det är förmodligen kommer att hamna olika

176
00:14:29,140 --> 00:14:32,320
än utskrift (1 + "2").

177
00:14:32,320 --> 00:14:39,700
Och detta tenderar att vara, enligt min mening, till det sämre.

178
00:14:39,700 --> 00:14:44,240
Här kan vi prova dessa.

179
00:14:44,240 --> 00:14:48,740
En annan litet trick om PHP är att du inte behöver verkligen skriva filen.

180
00:14:48,740 --> 00:14:52,790
Det har kört detta kommando läget.

181
00:14:52,790 --> 00:14:57,710
Så php-r, då kan vi kasta in kommandot här:

182
00:14:57,710 --> 00:15:06,610
"Tryck ('1 '+ 2)," och jag kastar en ny rad.

183
00:15:19,550 --> 00:15:23,970
Denna tryckta 3.

184
00:15:31,100 --> 00:15:35,330
Det ser ut som det skrivs 3 och det är heltalet 3.

185
00:15:35,330 --> 00:15:38,420
Så nu ska vi prova tvärtom:

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, och det kommer också att bli heltal 3? Jag har ärligt talat ingen aning.

188
00:15:50,490 --> 00:15:54,030
Det ser ut som det är konsekvent.

189
00:15:54,030 --> 00:15:59,550
Det finns aldrig någon chans att det är strängen 12 eller nåt sånt

190
00:15:59,550 --> 00:16:08,080
eftersom PHP, till skillnad från JavaScript och Java också,

191
00:16:08,080 --> 00:16:11,670
har en separat operatör för sammanfogning.

192
00:16:11,670 --> 00:16:14,930
Sammanlänkning i PHP är prick.

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

194
00:16:25,790 --> 00:16:32,420
Detta tenderar att leda till förvirring där människor försöker göra något liknande Str + =

195
00:16:32,420 --> 00:16:37,840
någon annan sak som de vill lägga till i slutet av sin sträng, och det kommer att misslyckas.

196
00:16:37,840 --> 00:16:40,770
Du måste göra str. =

197
00:16:42,000 --> 00:16:46,240
Så glöm inte sammanslagning i PHP är en punkt.

198
00:16:46,240 --> 00:16:52,100
Andra saker att prova: print ("CS" + 50);

199
00:16:55,750 --> 00:17:03,610
Jag har sagt att det inte finns något hopp om detta resulterar i CS50

200
00:17:03,610 --> 00:17:06,119
eftersom sammanslagning är inte +.

201
00:17:06,119 --> 00:17:08,440
Vad tror du detta kommer att hamna?

202
00:17:10,359 --> 00:17:13,460
Jag har ärligt talat ingen aning.

203
00:17:14,250 --> 00:17:16,460
Det ser ut som det är bara 50.

204
00:17:16,460 --> 00:17:21,490
Det ser strängen, och jag slår vad om vi sätter 123CS -

205
00:17:21,490 --> 00:17:29,640
Den ser den första strängen, försöker den att läsa ett heltal från den eller ett nummer från den.

206
00:17:29,640 --> 00:17:31,710
I det här fallet ser 123CS.

207
00:17:31,710 --> 00:17:35,190
"Det inte är vettigt som ett heltal, så jag ska bara tänka på 123."

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

209
00:17:38,580 --> 00:17:40,740
Och här börjar läser detta som ett heltal.

210
00:17:40,740 --> 00:17:45,690
Det behöver inte se någonting, så det bara behandlar det som 0. Så 0 + 50 kommer att bli 50.

211
00:17:45,690 --> 00:17:51,600
Detta Jag antar kommer att göra något liknande.

212
00:17:51,600 --> 00:17:54,310
Jag tänker 99.

213
00:17:54,310 --> 00:17:57,580
Ja, eftersom det kommer att ta första -

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

215
00:18:15,730 --> 00:18:21,970
Här (10/7), om detta var C, vad skulle det tillbaka?

216
00:18:23,700 --> 00:18:29,630
[Elev] 1. >> Ja, det skulle vara 1 eftersom 10/7 splittrar 2 heltal.

217
00:18:29,630 --> 00:18:32,910
Ett heltal dividerad med ett heltal kommer att returnera ett heltal.

218
00:18:32,910 --> 00:18:37,750
Det kan inte returnera 1 poäng vad det skulle vara, så det är bara att gå tillbaka 1.

219
00:18:37,750 --> 00:18:46,120
Här skriver (10/7), det kommer att faktiskt tolka det.

220
00:18:46,120 --> 00:18:53,760
Och detta innebär att om du verkligen vill göra heltal avrundning och sånt,

221
00:18:53,760 --> 00:18:59,950
du behöver göra utskrift (golv (10/7));

222
00:18:59,950 --> 00:19:08,460
I C är det nog konstigt att man kan lita på heltal trunkering regelbundet,

223
00:19:08,460 --> 00:19:12,260
men i PHP kan du inte eftersom det kommer automatiskt att förvandla det till en flottör.

224
00:19:13,430 --> 00:19:17,610
Och sedan (7 + true), vad tror du att det kommer att bli?

225
00:19:18,550 --> 00:19:23,640
Jag gissar 8 om det kommer att tolka sant som 1.

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

227
00:19:25,740 --> 00:19:31,710
>> Så allt vi har gjort under de senaste 10 minuterna ska du absolut aldrig göra.

228
00:19:31,710 --> 00:19:39,870
Du kommer att se kod som gör detta.

229
00:19:39,870 --> 00:19:42,700
Det behöver inte vara så enkelt som detta.

230
00:19:42,700 --> 00:19:47,240
Du kunde ha 2 variabler och 1 variabel råkar vara en sträng

231
00:19:47,240 --> 00:19:51,310
och den andra variabeln råkar vara en int, och sedan lägga till dessa variabler tillsammans.

232
00:19:51,310 --> 00:20:00,120
Eftersom PHP är dynamiskt skrivit och det kommer inte att göra någon typ kontroll för dig

233
00:20:00,120 --> 00:20:03,640
och eftersom det är svagt skrivit och eftersom det kommer bara automatiskt kasta dessa saker tillsammans

234
00:20:03,640 --> 00:20:11,490
och allt bara fungerar, är det svårt att ens veta att denna variabel ska vara en sträng nu,

235
00:20:11,490 --> 00:20:14,930
så jag ska inte lägga till denna variabel, vilket är ett heltal.

236
00:20:18,780 --> 00:20:24,560
Bästa praxis är om en variabel är en sträng, hålla det som en sträng för evigt.

237
00:20:24,560 --> 00:20:26,980
Om en variabel är en int, hålla den som en int evigt.

238
00:20:26,980 --> 00:20:30,770
Om du vill ta itu med heltal och strängar,

239
00:20:30,770 --> 00:20:36,970
Du kan använda varsint - det är JavaScript.

240
00:20:36,970 --> 00:20:42,520
Intval. Jag gör det hela tiden. PHP och Javascript jag blandar ihop allting.

241
00:20:42,520 --> 00:20:47,600
Så intval kommer att returnera heltalsvärdet av en variabel.

242
00:20:47,600 --> 00:20:56,550
Om vi ​​passerar i "tryck (intval ('123 ')); du får 123.

243
00:21:06,820 --> 00:21:15,850
Intval själv kommer inte att göra kontrollen för oss att det är enbart ett heltal.

244
00:21:15,850 --> 00:21:20,460
PHP manualen, det finns bara så många funktioner tillgängliga,

245
00:21:20,460 --> 00:21:26,560
så här tror jag vad jag skulle använda är is_numeric först.

246
00:21:26,560 --> 00:21:32,590
Jag gissar att returneras falskt.

247
00:21:32,590 --> 00:21:35,780
Det är en annan sak som vi måste gå över är ===.

248
00:21:37,850 --> 00:21:44,020
Så is_numeric ('123df), skulle du inte tänka på det som is_numeric.

249
00:21:44,020 --> 00:21:46,720
I C du måste iterera över alla tecken

250
00:21:46,720 --> 00:21:50,410
och kontrollera om varje karaktär är siffran eller vad som helst.

251
00:21:50,410 --> 00:21:53,850
Här is_numeric kommer att göra det åt oss,

252
00:21:53,850 --> 00:21:56,520
och det är tillbaka falsk.

253
00:21:56,520 --> 00:22:02,120
Så när jag tryckt att skrivas ingenting, så här jag jämföra det att se,

254
00:22:02,120 --> 00:22:05,490
var du råkar vara falsk? Och så nu är det utskrift 1.

255
00:22:05,490 --> 00:22:10,060
Tydligen skriver 1 som gäller i stället för att skriva ut sant som sant.

256
00:22:10,060 --> 00:22:15,790
Jag undrar om jag gör print_r. Nej, det gör det fortfarande 1.

257
00:22:15,790 --> 00:22:26,760
>> Att gå tillbaka till === finns == fortfarande,

258
00:22:26,760 --> 00:22:32,260
och om du pratar med Tommy att han ska säga == är helt bra.

259
00:22:32,260 --> 00:22:37,700
Jag ska säga att == är fruktansvärt och du bör aldrig använda ==.

260
00:22:37,700 --> 00:22:44,870
Skillnaden är att == jämför saker

261
00:22:44,870 --> 00:22:48,450
där det kan vara sant, även om de inte är av samma typ,

262
00:22:48,450 --> 00:22:53,810
medan === jämför saker och Först kontrollerar är de av samma typ?

263
00:22:53,810 --> 00:22:58,010
Ja. Okej, nu ska jag se om de faktiskt jämföra vara lika.

264
00:22:58,010 --> 00:23:08,890
Du får konstiga saker som 10 är lika med - låt oss se vad det säger.

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

266
00:23:15,570 --> 00:23:17,980
Detta returnerar true.

267
00:23:17,980 --> 00:23:21,420
Har någon några gissningar varför detta returnerar sant?

268
00:23:25,180 --> 00:23:27,120
Det handlar inte bara om det. Kanske är detta en ledtråd.

269
00:23:27,120 --> 00:23:33,170
Men om jag ändra det till en F - darn det! Jag håller med citationstecken.

270
00:23:33,170 --> 00:23:38,780
Anledningen till att citationstecken skriker på mig är att jag har lagt detta i citationstecken.

271
00:23:38,780 --> 00:23:43,850
Så jag kunde fly citattecken i här, men apostrof gör det lättare.

272
00:23:43,850 --> 00:23:49,120
Så ('10 '== 1 f1'); inte ut riktigt. ('10 '== 1 e1'); skriver sant.

273
00:23:49,120 --> 00:23:56,330
[Elev] Är det hex? >> Det är inte hex, men det är nära att det är som -

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

275
00:24:01,060 --> 00:24:07,950
Det erkänner 1E1 som en * 10 ^ 1 eller något annat.

276
00:24:07,950 --> 00:24:11,510
Det är lika heltal.

277
00:24:11,510 --> 00:24:15,930
Om vi ​​gör === då det kommer att vara falsk.

278
00:24:15,930 --> 00:24:28,490
Jag har faktiskt ingen aning om vi gör == vad om (10 och '10abc '); Okej. Så det är sant.

279
00:24:28,490 --> 00:24:35,940
Så precis som när du gjorde (10 + '10abc "), och det skulle vara 20,

280
00:24:35,940 --> 00:24:38,800
Här (10 == '10abc '); är sant.

281
00:24:38,800 --> 00:24:45,350
Ännu värre är saker som (falsk == NULL); är sant

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

283
00:24:52,210 --> 00:25:00,970
Det finns konstiga fall - Det är en av de konstiga fall.

284
00:25:00,970 --> 00:25:08,110
Observera att (falskt == []); är sant.

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

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

287
00:25:16,090 --> 00:25:19,090
Så == är på intet sätt transitiva.

288
00:25:19,090 --> 00:25:26,830
en kan vara lika med b och en kan vara lika med c,

289
00:25:26,830 --> 00:25:29,340
men B inte kan vara lika med c..

290
00:25:29,340 --> 00:25:35,580
Det är en styggelse för mig, och du bör alltid använda ===.

291
00:25:35,580 --> 00:25:38,590
[Elev] Kan vi göra! == Också? >> [Bowden] Ja.

292
00:25:38,590 --> 00:25:44,600
Motsvarande skulle vara! = Och! ==.

293
00:25:44,600 --> 00:25:48,230
Detta är faktiskt växte upp i pset spec

294
00:25:48,230 --> 00:25:52,000
där många funktioner tillbaka -

295
00:25:52,000 --> 00:25:53,890
PHP manualen är bra om det här.

296
00:25:53,890 --> 00:25:59,140
Det sätter en stor röd ruta, "Detta kommer att returnera false om det finns ett fel."

297
00:25:59,140 --> 00:26:03,940
Men återvänder 0 är en helt rimlig sak att återvända.

298
00:26:03,940 --> 00:26:08,250
Tänk om någon funktion som förväntas återgå ett heltal.

299
00:26:11,250 --> 00:26:17,880
Låt oss säga denna funktion är tänkt att räkna antalet rader i en fil eller något.

300
00:26:17,880 --> 00:26:23,490
Under normala omständigheter, passerar du den här funktionen en fil

301
00:26:23,490 --> 00:26:27,120
och det kommer att återvända ett heltal som representerar antalet rader.

302
00:26:27,120 --> 00:26:30,820
Så 0 är en helt rimligt antal om filen är bara tomt.

303
00:26:30,820 --> 00:26:36,810
Men om du passerar det en ogiltig fil och funktionen råkar returnera false

304
00:26:36,810 --> 00:26:38,860
om du klarar det en ogiltig fil?

305
00:26:38,860 --> 00:26:46,500
Om du bara gör == du inte skilja fallet mellan ogiltig fil och tom fil.

306
00:26:48,870 --> 00:26:51,350
Använd alltid ===.

307
00:26:55,690 --> 00:26:58,000
Det är alla dessa.

308
00:26:58,000 --> 00:27:01,660
>> I PHP är arrayen typ annorlunda än vad du är van vid i C.

309
00:27:01,660 --> 00:27:06,650
I själva verket kanske du redan har märkt detta ovan när du såg att det är av typen array.

310
00:27:06,650 --> 00:27:15,640
Fästet Syntaxen är nytt från och med PHP 5,4, som är den senaste versionen av PHP.

311
00:27:15,640 --> 00:27:36,960
Innan detta kan du alltid haft att skriva array ('a' -> 1, 'b' -> 2.

312
00:27:36,960 --> 00:27:41,160
Det var konstruktören för en matris.

313
00:27:41,160 --> 00:27:45,950
Nu PHP har äntligen kommit runt till trevliga syntax bara hakparenteser,

314
00:27:45,950 --> 00:27:50,900
vilket är bara så mycket bättre än matris.

315
00:27:50,900 --> 00:27:54,480
Men med tanke på PHP 5,4 är den nyaste versionen,

316
00:27:54,480 --> 00:27:59,090
du kan stöta platser som inte ens har PHP 5.3.

317
00:27:59,090 --> 00:28:08,220
Under sommaren körde vi i denna fråga där PHP 5,3 var vad vi hade på apparaten,

318
00:28:08,220 --> 00:28:14,480
men den server som vi utplacerade alla våra klass bok och lämna in och allt det där till

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

320
00:28:16,750 --> 00:28:23,060
Att inte veta detta har vi utvecklat under 5,3, knuffade till 5,4,

321
00:28:23,060 --> 00:28:25,660
och nu helt plötsligt ingen av vår kod fungerar

322
00:28:25,660 --> 00:28:28,680
eftersom det råkade ha skett förändringar mellan 5,3 och 5,4

323
00:28:28,680 --> 00:28:31,030
som inte är bakåtkompatibelt,

324
00:28:31,030 --> 00:28:35,770
och vi måste gå och fixa alla våra saker som inte fungerar för PHP 5,4.

325
00:28:39,210 --> 00:28:42,320
För denna klass, eftersom apparaten inte har PHP 5,4,

326
00:28:42,320 --> 00:28:45,490
Det är väl bra att använda hakparenteser.

327
00:28:47,240 --> 00:28:50,440
Men om du letar upp saker runt på Internet,

328
00:28:50,440 --> 00:28:54,880
om du letar upp någon form av matris saker, mest troligt att du kommer att se

329
00:28:54,880 --> 00:29:02,020
förtrollningen ut Array-konstruktorn syntax eftersom det har funnits sedan PHP föddes

330
00:29:02,020 --> 00:29:07,340
och offentlig fäste syntax har funnits under de senaste par månader

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

332
00:29:10,020 --> 00:29:12,710
Så här gör du index.

333
00:29:12,710 --> 00:29:30,610
Precis som i C hur du skulle index med hakparenteser som $ array [0], $ array [1], $ array [2],

334
00:29:30,610 --> 00:29:36,320
du indexerar på samma sätt om du råkar ha din index är strängar.

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

336
00:29:40,440 --> 00:29:47,410
$ Array [b]. Varför skulle detta vara fel?

337
00:29:52,490 --> 00:29:59,870
Det kommer förmodligen generera en varning men fortfarande fungerar. PHP tenderar att göra det.

338
00:29:59,870 --> 00:30:04,890
Det tenderar att bara, "jag ska varna dig om det här, men jag ska bara fortsätta

339
00:30:04,890 --> 00:30:07,550
"Och göra vad jag kan."

340
00:30:07,550 --> 00:30:11,500
Det kommer sannolikt att översätta detta till en sträng,

341
00:30:11,500 --> 00:30:15,000
men det är möjligt att någon gång i det förflutna någon sade

342
00:30:15,000 --> 00:30:20,180
definiera b för att vara "Hello World".

343
00:30:20,180 --> 00:30:28,740
Så nu B kan vara en konstant och $ array [b] faktiskt kommer att göra "Hello World".

344
00:30:28,740 --> 00:30:32,380
Jag tror på denna punkt, eller åtminstone våra PHP-inställningar,

345
00:30:32,380 --> 00:30:37,870
om du försöker index i en array och att nyckeln inte finns, kommer det att misslyckas.

346
00:30:37,870 --> 00:30:40,150
Jag tror inte att det bara kommer att varna dig.

347
00:30:40,150 --> 00:30:44,560
Eller åtminstone kan du ställa in den så att den inte bara varna dig, det bara rakt upp misslyckas.

348
00:30:44,560 --> 00:30:49,290
>> Sättet du kontrollera om det faktiskt är ett sådant index är isset.

349
00:30:49,290 --> 00:30:54,690
Så isset ($ array ['Hello World']) kommer att återvända falskt.

350
00:30:54,690 --> 00:30:59,160
isset ($ array ['b']) kommer att återvända sant.

351
00:31:06,830 --> 00:31:09,880
Du kan blanda dessa syntax.

352
00:31:15,060 --> 00:31:22,440
Jag är ganska säker på vad denna array skulle hamna är - Vi kan testa det.

353
00:31:43,290 --> 00:31:45,700
Åh, jag behöver PHPWord.

354
00:31:53,960 --> 00:32:00,260
Detta blandar syntax där du anger vad nyckeln är

355
00:32:00,260 --> 00:32:03,330
och du inte anger vad nyckeln är.

356
00:32:03,330 --> 00:32:05,520
Så 3 här är ett värde.

357
00:32:05,520 --> 00:32:08,080
Du har inte uttryckligen sagt vad dess nyckel kommer att bli.

358
00:32:08,080 --> 00:32:11,670
Vad tror du det nyckel kommer att bli?

359
00:32:11,670 --> 00:32:21,410
[Elev] 0. >> Jag gissar 0 bara för att det är den första vi har inte specificerats.

360
00:32:21,410 --> 00:32:23,500
Vi kan faktiskt göra ett par av dessa fall.

361
00:32:23,500 --> 00:32:28,030
Så print_r är ut rekursiv. Det kommer att skriva ut hela uppsättningen.

362
00:32:28,030 --> 00:32:32,700
Det skulle skriva ut subanordningarna i matrisen om det fanns några.

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 gav den 0.

365
00:32:38,810 --> 00:32:43,530
Det är faktiskt något att tänka på här, men vi återkommer till det i en sekund.

366
00:32:43,530 --> 00:32:45,850
Men om jag råkar göra detta index 1?

367
00:32:45,850 --> 00:32:51,170
PHP skiljer inte mellan sträng index och heltal index,

368
00:32:51,170 --> 00:33:00,280
så på denna punkt har jag bara definierat ett index 1 och jag kan göra både $ array [1] och $ array ['1 ']

369
00:33:00,280 --> 00:33:06,250
och det kommer att vara samma index och samma nyckel.

370
00:33:06,250 --> 00:33:13,000
Så nu vad tror du 3 kommer att bli? >> [Elev] 2. >> [Bowden] Jag gissar 2.

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

372
00:33:18,690 --> 00:33:24,790
Tänk om vi gjorde detta är 10, är ​​detta 4? Vad tror du index 3 kommer att bli?

373
00:33:27,360 --> 00:33:29,110
Jag tänker 11.

374
00:33:29,110 --> 00:33:33,060
Min gissning vad PHP gör - och jag tror att jag har sett det här förut -

375
00:33:33,060 --> 00:33:39,760
är det håller bara reda på vad det högsta numeriska indexet den används hittills är.

376
00:33:39,760 --> 00:33:44,230
Det kommer aldrig att tilldela en sträng index 3. Det kommer alltid att vara ett numeriskt index.

377
00:33:44,230 --> 00:33:47,690
Så det håller reda på den högsta en det tilldelade hittills, vilket råkar vara 10,

378
00:33:47,690 --> 00:33:52,540
och det kommer att ge 11 till 3.

379
00:33:52,540 --> 00:34:02,110
Vad jag sa tidigare, märker hur det skriver denna array.

380
00:34:02,110 --> 00:34:06,850
Den skriver nyckeln 10, nyckel 4, 11, nyckel d..

381
00:34:06,850 --> 00:34:09,790
Eller ens låta oss göra -

382
00:34:15,760 --> 00:34:22,489
Jag antar att jag inte satt en 0, men det är utskrift 1, 2, 3, 4.

383
00:34:22,489 --> 00:34:29,330
Vad händer om jag byter här? Eller låt oss faktiskt byta dessa 2.

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

385
00:34:31,940 --> 00:34:41,270
PHP: s arrayer är inte precis som din vanliga hashtabell.

386
00:34:41,270 --> 00:34:45,570
Det är helt rimligt att tänka på dem som hashtabeller 99% av tiden.

387
00:34:45,570 --> 00:34:53,790
Men i din hashtabeller finns det ingen känsla av ordning som saker in.

388
00:34:53,790 --> 00:34:56,639
Så snart som du sätter in i din hashtabell,

389
00:34:56,639 --> 00:35:00,590
antar det finns ingen länkad lista och du kan döma i en länkad lista

390
00:35:00,590 --> 00:35:03,980
som infördes först.

391
00:35:03,980 --> 00:35:10,060
Men här vi in ​​2 först och den vet när den skrivs ut denna array som 2 kommer först.

392
00:35:10,060 --> 00:35:13,090
Det skrivs inte ut det i bara någon ordning.

393
00:35:13,090 --> 00:35:17,550
Den tekniska datastruktur som det använder är en ordnad karta,

394
00:35:17,550 --> 00:35:24,690
så det kartlägger nycklar till värden och det minns i vilken ordning dessa nycklar infördes.

395
00:35:24,690 --> 00:35:31,600
I grunden är det vissa komplikationer där det är irriterande att faktiskt -

396
00:35:31,600 --> 00:35:34,510
Låt oss säga att du har en array 0, 1, 2, 3, 4, 5

397
00:35:34,510 --> 00:35:37,700
och du vill ta ut index 2.

398
00:35:37,700 --> 00:35:47,750
Ett sätt att göra det, låt oss se vad 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 råkar nollställa både variabler och index array.

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

402
00:35:58,630 --> 00:36:03,430
Nu vad det kommer att se ut? 2 är bara borta, så det är väl bra.

403
00:36:03,430 --> 00:36:11,670
Mer irriterande är om du vill att saker faktiskt vara som en matris.

404
00:36:11,670 --> 00:36:14,910
Jag sätter slumptal.

405
00:36:14,910 --> 00:36:20,400
Nu märker jag index.

406
00:36:20,400 --> 00:36:26,860
Jag vill att det ska bara vara som en C array där det går från 0 till längd - 1

407
00:36:26,860 --> 00:36:30,810
och jag kan iterera över den som sådan.

408
00:36:30,810 --> 00:36:38,520
Men så fort jag frånkoppla det andra indexet, vad var i index 3 inte blivit index 2.

409
00:36:38,520 --> 00:36:44,790
Istället tar bort just det indexet och nu går 0, 1, 3, 4.

410
00:36:44,790 --> 00:36:48,740
Det är helt rimligt.

411
00:36:48,740 --> 00:36:53,950
Det är bara irriterande och du måste göra saker som array skarv. Ja.

412
00:36:53,950 --> 00:36:57,200
>> [Elev] Vad skulle hända om du hade en for-slinga

413
00:36:57,200 --> 00:36:59,630
och du ville gå över alla element?

414
00:36:59,630 --> 00:37:02,290
När det slår 2, skulle det ge någonsin?

415
00:37:02,290 --> 00:37:10,150
Iterera över en array. Det finns 2 sätt att göra det.

416
00:37:10,150 --> 00:37:12,770
Du kan använda en vanlig for-slinga.

417
00:37:12,770 --> 00:37:22,000
Detta är en annan invecklade av PHP.

418
00:37:22,000 --> 00:37:27,420
De flesta språk, skulle jag säga, har någon form av längd eller len eller något

419
00:37:27,420 --> 00:37:30,470
indikerar längden på en array.

420
00:37:30,470 --> 00:37:32,820
I PHP är det räknas.

421
00:37:32,820 --> 00:37:36,160
Så räkna ($ array), $ i + +)

422
00:37:36,160 --> 00:37:42,950
Låt oss bara skriva ut ($ array [$ i]);

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

424
00:37:48,820 --> 00:37:51,610
Det kommer bara att misslyckas.

425
00:37:51,610 --> 00:38:03,020
Detta är anledningen till att, för det mesta, att du aldrig behöver iterera över en array som denna.

426
00:38:03,020 --> 00:38:07,110
Det kan vara en överdrift, men du behöver aldrig iterera över en array som denna

427
00:38:07,110 --> 00:38:19,410
eftersom PHP erbjuder sina foreach syntax där foreach ($ array som $ post).

428
00:38:19,410 --> 00:38:31,830
Nu om vi trycker ($ post), - we'll diskutera det i en andra - som fungerar alldeles utmärkt.

429
00:38:31,830 --> 00:38:38,960
Det sätt som foreach arbetar är det första argumentet är arrayen som du iteration över.

430
00:38:38,960 --> 00:38:44,060
Och det andra argumentet, objekt genom varje pass av for-slingan

431
00:38:44,060 --> 00:38:52,690
det kommer att ta på nästa sak i arrayen. Så kom ihåg matrisen har en beställning.

432
00:38:52,690 --> 00:38:55,690
Första gången genom for-slingan är posten kommer att bli 123

433
00:38:55,690 --> 00:38:59,540
då blir det 12 då blir det 13 då blir det 23 då blir det 213.

434
00:38:59,540 --> 00:39:04,670
Saker och ting blir väldigt konstigt när du gör något som foreach.

435
00:39:04,670 --> 00:39:07,480
Låt oss se vad som händer eftersom du aldrig ska göra detta.

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

437
00:39:20,410 --> 00:39:26,030
Som förmodligen var väntat.

438
00:39:26,030 --> 00:39:30,950
Du iteration över denna array, och varje gång du deaktivera det första indexet.

439
00:39:30,950 --> 00:39:39,720
Så för index 0, tar det första punkt på värde 0, så det kommer att bli 123.

440
00:39:39,720 --> 00:39:44,630
Men inuti for-slingan vi unset index 1, så det betyder 12 är borta.

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

442
00:39:57,480 --> 00:40:03,580
PHP_EOL är bara nyrad, men det är tekniskt mer portabel

443
00:40:03,580 --> 00:40:08,890
eftersom nya rader i Windows skiljer sig från radbrytningar på Mac och UNIX.

444
00:40:08,890 --> 00:40:18,040
I Windows nyrad är \ r \ n, medan överallt annars tenderar bara vara \ n.

445
00:40:18,040 --> 00:40:25,150
PHP_EOL är konfigurerad så att den använder oavsett nyrad av ditt system.

446
00:40:25,150 --> 00:40:29,310
Så ut det. Låt oss inte print_r ($ array) i slutet.

447
00:40:32,830 --> 00:40:37,390
Jag hade ingen aning om att det skulle vara beteendet.

448
00:40:41,740 --> 00:40:48,960
Punkt tar fortfarande på värdet 12 även om vi nollställa 12 innan vi någonsin fick den från matrisen.

449
00:40:52,770 --> 00:40:58,840
Ta inte mitt ord på detta, men det ser ut som foreach skapar en kopia av matrisen

450
00:40:58,840 --> 00:41:02,160
och sedan posten tar på alla värden i den kopian.

451
00:41:02,160 --> 00:41:07,760
Så även om du ändrar arrayen inne i for-slingan,

452
00:41:07,760 --> 00:41:17,240
det kommer inte bry sig. Punkt tar på de ursprungliga värdena.

453
00:41:17,240 --> 00:41:19,240
Låt oss försöka deaktivera den.

454
00:41:19,240 --> 00:41:24,460
Tänk om det är $ array [1] = "Hej";

455
00:41:24,460 --> 00:41:31,770
Även om vi sätter "Hej" i arrayen, tar posten aldrig på det värdet.

456
00:41:31,770 --> 00:41:37,430
Det finns en annan syntax för att foreach loopar

457
00:41:37,430 --> 00:41:45,900
där du sätter 2 variabler åtskilda av en pil.

458
00:41:45,900 --> 00:41:49,680
Denna första variabel kommer att vara nyckeln för detta värde,

459
00:41:49,680 --> 00:41:53,050
och denna andra variabel kommer att vara exakt samma objekt.

460
00:41:53,050 --> 00:42:01,610
Detta är ointressant här, men om vi går tillbaka till vår ursprungliga fråga om "a" -> 1,

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

462
00:42:06,090 --> 00:42:14,470
här om vi bara iterera för varje array som objekt är objektet kommer att bli 1 varje gång.

463
00:42:14,470 --> 00:42:18,170
Men om vi vill också veta nyckeln associerad med det objektet

464
00:42:18,170 --> 00:42:25,230
då vi gör som $ key -> $ objekt.

465
00:42:25,230 --> 00:42:31,980
Så nu kan vi göra utskrift ($ key. ':'.

466
00:42:31,980 --> 00:42:39,380
Nu är det iteration över och skriva varje knapp och dess tillhörande värde.

467
00:42:39,380 --> 00:42:47,030
>> En ytterligare sak vi kan göra i foreach loopar är att du kan se den här syntaxen.

468
00:42:47,030 --> 00:42:54,770
Et-tecken innan variabelnamn tenderar att vara hur PHP gör referenser.

469
00:42:54,770 --> 00:43:00,460
Där hänvisningar är mycket lika pekare,

470
00:43:00,460 --> 00:43:04,820
du inte har pekare, så att du aldrig ta itu med minnet direkt.

471
00:43:04,820 --> 00:43:12,620
Men du har referenser där 1 variabel avser samma sak som en annan variabel.

472
00:43:12,620 --> 00:43:21,450
Inuti här vi gör $ objekt. Låt oss gå tillbaka till 1, 10.

473
00:43:21,450 --> 00:43:28,800
Låt oss göra $ objekt + +, det finns fortfarande i PHP. Du kan fortfarande göra + +.

474
00:43:28,800 --> 00:43:38,260
php.test.php. Jag måste skriva ut det. print_r ($ matris);

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

476
00:43:42,730 --> 00:43:49,560
Om jag bara hade gjort foreach ($ array som $ post) då objektet blir värdet 1

477
00:43:49,560 --> 00:43:54,190
första gången genom slingan. Det kommer att öka från 1 till 2 och vi är klara.

478
00:43:54,190 --> 00:43:57,260
Så då kommer det att gå igenom det andra passet av slingan och objektet är 10.

479
00:43:57,260 --> 00:44:01,570
Det steg post till 11, och sedan som bara kastas bort.

480
00:44:01,570 --> 00:44:06,670
Då vi print_r ($ array), och låt oss se till att detta bara är 1, 10.

481
00:44:06,670 --> 00:44:09,070
Så ökningen vi gjorde var förlorat.

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

483
00:44:13,410 --> 00:44:21,910
Nu denna post är samma objekt som denna här. Det är samma sak.

484
00:44:21,910 --> 00:44:26,820
Så $ objekt + + är att ändra rad 0.

485
00:44:29,330 --> 00:44:41,850
I princip kan du också göra $ k -> $ objekt och du kan göra $ array [$ k] + +;

486
00:44:41,850 --> 00:44:48,650
>> Så ett annat sätt att göra det är vi fria att modifiera objekt,

487
00:44:48,650 --> 00:44:54,070
men det kommer inte att ändra vår ursprungliga arrayen.

488
00:44:54,070 --> 00:44:59,720
Men om vi använder k, som är vår nyckel, vi kan då bara index i vår array med denna nyckel

489
00:44:59,720 --> 00:45:01,530
och öka det.

490
00:45:01,530 --> 00:45:05,410
Denna mer direkt ändrar vår ursprungliga arrayen.

491
00:45:05,410 --> 00:45:10,690
Du kan även göra det om du av någon anledning ville möjlighet att ändra -

492
00:45:10,690 --> 00:45:13,510
Egentligen är detta helt rimligt.

493
00:45:13,510 --> 00:45:16,020
Du ville inte behöva skriva $ array [$ k] + +,

494
00:45:16,020 --> 00:45:27,890
du ville bara skriva $ objekt + + men du fortfarande ville säga if ($ k === "a")

495
00:45:27,890 --> 00:45:30,620
sedan öka objektet och sedan skriva ut vår array.

496
00:45:30,620 --> 00:45:36,290
Så nu vad vi förväntar oss print_r göra? Vilka värden ska skrivas?

497
00:45:36,290 --> 00:45:43,770
[Studerande] 2 och 10. >> [Bowden] Endast om nyckeln var "en" vi faktiskt ut som.

498
00:45:51,940 --> 00:45:55,670
>> Du har förmodligen mycket sällan, om någonsin, måste definiera funktioner i PHP,

499
00:45:55,670 --> 00:46:03,370
men du kan se något liknande där du definierar en funktion som funktion oavsett.

500
00:46:03,370 --> 00:46:09,900
Vanligtvis skulle du säga ($ foo, $ bar) och sedan definiera det vara vad som helst.

501
00:46:09,900 --> 00:46:17,580
Men om jag gör det, så betyder det att allt samtal oavsett,

502
00:46:17,580 --> 00:46:25,110
vad kallar baz, så det första argumentet som skickas till baz kan ändras.

503
00:46:25,110 --> 00:46:38,100
Låt oss göra $ foo + +;

504
00:46:38,100 --> 00:46:48,020
och insidan av här låt oss göra baz ($ post);

505
00:46:48,020 --> 00:46:52,250
Nu är vi kallar en funktion.

506
00:46:52,250 --> 00:46:56,780
Argumentet är tagen som referens, vilket innebär att om vi ändrar det

507
00:46:56,780 --> 00:47:00,390
vi ändrar det som antogs i.

508
00:47:00,390 --> 00:47:04,420
Och skriva det vi förväntar oss - om jag trasslat syntax - vi fick 2, 11,

509
00:47:04,420 --> 00:47:06,300
så det var faktiskt ökas.

510
00:47:06,300 --> 00:47:08,790
Märker vi behöver referenser i 2 platser.

511
00:47:08,790 --> 00:47:13,050
Vad händer om jag gjorde det här? Vad betyder det här?

512
00:47:13,050 --> 00:47:15,810
[Elev] Det kommer att förändras. >> Ja.

513
00:47:15,810 --> 00:47:18,290
Objektet är bara en kopia av värdet i arrayen.

514
00:47:18,290 --> 00:47:26,670
Så posten ändras till 2, men arrayen ['a'] kommer fortfarande att vara 1.

515
00:47:26,670 --> 00:47:32,560
Eller tänk om jag gör det?

516
00:47:32,560 --> 00:47:39,260
Nu objektet skickas som kopia till baz.

517
00:47:39,260 --> 00:47:46,330
Så kopian av argumentet kommer att ökas till 2,

518
00:47:46,330 --> 00:47:49,240
men själva objektet aldrig ökas till 2.

519
00:47:49,240 --> 00:47:52,880
Och punkt är samma sak som array fäste oavsett,

520
00:47:52,880 --> 00:47:55,380
så att matris aldrig ökas.

521
00:47:55,380 --> 00:47:57,960
Så båda dessa platser behöver det.

522
00:47:57,960 --> 00:48:03,830
>> PHP är oftast ganska smarta om detta.

523
00:48:03,830 --> 00:48:06,570
Du kanske tror att jag vill passera genom hänvisning -

524
00:48:06,570 --> 00:48:09,560
Detta var faktiskt en fråga om en av de psets.

525
00:48:09,560 --> 00:48:14,480
Det var en questions.txt sak där det stod,

526
00:48:14,480 --> 00:48:19,280
Varför vill du kanske passera denna struct genom hänvisning?

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

528
00:48:21,250 --> 00:48:25,100
[Eleven] Så du behöver inte kopiera något stort. >> Ja.

529
00:48:25,100 --> 00:48:32,920
En struktur kan vara godtyckligt stor, och när du passerar struct in som ett argument

530
00:48:32,920 --> 00:48:36,800
den behöver för att kopiera hela den struktur för att ge det till funktionen,

531
00:48:36,800 --> 00:48:40,410
medan om du passerar bara struct genom hänvisning

532
00:48:40,410 --> 00:48:46,530
då behöver bara kopiera en 4-byte adress som argument till funktionen.

533
00:48:48,520 --> 00:48:52,320
PHP är lite smartare än så.

534
00:48:52,320 --> 00:49:00,650
Om jag har någon funktion, och jag övergår till det en rad 1.000 saker,

535
00:49:00,650 --> 00:49:03,990
betyder att det kommer att behöva kopiera alla 1.000 av dessa saker

536
00:49:03,990 --> 00:49:10,450
att passera den i funktion? Det behöver inte göra det omedelbart.

537
00:49:10,450 --> 00:49:15,940
Om insidan av denna funktion aldrig ändrar foo,

538
00:49:15,940 --> 00:49:22,660
så om ($ foo === "Hej") return true.;

539
00:49:22,660 --> 00:49:26,460
Märker vi aldrig ändrat argumentet insidan av denna funktion,

540
00:49:26,460 --> 00:49:30,010
vilket innebär att allt antogs i så foo aldrig behöver kopieras

541
00:49:30,010 --> 00:49:32,100
eftersom det inte är att ändra den.

542
00:49:32,100 --> 00:49:39,240
Så hur PHP fungerar är argumenten skickas alltid med referens

543
00:49:39,240 --> 00:49:42,170
tills du prova faktiskt att ändra den.

544
00:49:42,170 --> 00:49:51,160
Nu om jag säger $ foo + +, det kommer nu att göra en kopia av den ursprungliga foo och ändra kopian.

545
00:49:51,160 --> 00:49:53,090
Detta sparar tid.

546
00:49:53,090 --> 00:49:58,210
Om du aldrig vidröra denna massiva array, du aldrig ändra det,

547
00:49:58,210 --> 00:50:02,360
det behöver inte göra kopian,

548
00:50:02,360 --> 00:50:06,640
medan om vi sätter bara denna ampersand det betyder att det inte ens kopiera den

549
00:50:06,640 --> 00:50:08,640
även om du ändrar det.

550
00:50:08,640 --> 00:50:10,680
Detta beteende kallas copy-on-write.

551
00:50:10,680 --> 00:50:17,380
Du ser det på andra ställen, speciellt om du tar en kurs operativsystem.

552
00:50:17,380 --> 00:50:23,880
Copy-on-write är en ganska vanlig mönster där du inte behöver göra en kopia av något

553
00:50:23,880 --> 00:50:26,650
om det inte är faktiskt förändras. Ja.

554
00:50:26,650 --> 00:50:29,520
[Eleven] Tänk om du hade ökningen inom test,

555
00:50:29,520 --> 00:50:33,700
så bara 1 del av 1.000 skulle behöva förändras?

556
00:50:33,700 --> 00:50:38,770
Jag är inte säker.

557
00:50:38,770 --> 00:50:51,250
Jag tror att det skulle kopiera det hela, men det är möjligt att det är smart nog att -

558
00:50:51,250 --> 00:51:00,020
Egentligen, vad jag tänker är föreställa hade vi en array som ser ut så här: $ matris2 = [

559
00:51:00,020 --> 00:51:11,000
Då index "a" är en matris av [1 2 3 4], och index "b" är en matris med vad som helst.

560
00:51:11,000 --> 00:51:15,380
Jag behöver kommatecken mellan alla dessa. Föreställ finns kommatecken.

561
00:51:15,380 --> 00:51:21,210
Sedan "c" är värdet 3.

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

563
00:51:26,290 --> 00:51:33,440
Låt oss nu säga att vi gör $ Baz ($ matris2);

564
00:51:33,440 --> 00:51:36,540
där baz inte ta detta som referens.

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

566
00:51:47,370 --> 00:51:52,340
Detta är ett sådant exempel där vi passerar matris2 som ett argument

567
00:51:52,340 --> 00:51:57,010
och sedan modifierar ett specifikt index av uppsättningen genom att öka den.

568
00:51:57,010 --> 00:52:01,090
Jag har ärligt talat ingen aning om vad PHP kommer att göra.

569
00:52:01,090 --> 00:52:07,200
Det kan lätt göra en kopia av hela saken, men om det är smart,

570
00:52:07,200 --> 00:52:15,030
det kommer att göra en kopia av dessa tangenter där det kommer att ha sin distinkta värde

571
00:52:15,030 --> 00:52:20,620
men detta kan ändå peka till samma array 1,2,3,4

572
00:52:20,620 --> 00:52:22,320
och detta kan fortfarande peka till samma array.

573
00:52:22,320 --> 00:52:24,170
Jag ska iPad den.

574
00:52:28,900 --> 00:52:45,950
Vi passerar i denna array där denna kille pekar på 3, den här killen pekar på [1,2,3,4],

575
00:52:45,950 --> 00:52:51,350
denna killen pekar på [34, ...]

576
00:52:51,350 --> 00:52:58,590
Nu när vi passerar den till baz, vi ändrar det.

577
00:52:58,590 --> 00:53:03,550
Om PHP är smart, det kan bara göra -

578
00:53:11,850 --> 00:53:18,230
Vi hade fortfarande att kopiera något minne, men om det var dessa enorma kapslade subsystem

579
00:53:18,230 --> 00:53:21,560
Vi behövde inte kopiera dem.

580
00:53:21,560 --> 00:53:27,530
Jag vet inte om det är vad den gör, men jag kan tänka mig att det gör det.

581
00:53:29,050 --> 00:53:36,690
Detta är också en ganska stor fördel av C över PHP.

582
00:53:36,690 --> 00:53:40,320
>> PHP gör livet så mycket lättare för en massa saker,

583
00:53:40,320 --> 00:53:45,060
men du typ av har absolut ingen aning om hur bra det kommer att fungera

584
00:53:45,060 --> 00:53:52,530
eftersom jag har ingen aning under huven när det gör dessa kopior av saker,

585
00:53:52,530 --> 00:53:55,170
Oh, är det kommer att bli en konstant tid kopia,

586
00:53:55,170 --> 00:54:01,140
det bara att byta 1 pekare, det kommer att bli en löjligt svår linjär kopia?

587
00:54:01,140 --> 00:54:03,000
Tänk om det inte kan hitta utrymme?

588
00:54:03,000 --> 00:54:06,760
Behöver den då att köra skräpsamling för att få lite mer utrymme?

589
00:54:06,760 --> 00:54:11,210
Och sophämtning kan ta godtyckligt lång.

590
00:54:11,210 --> 00:54:13,600
I C behöver du inte oroa dig för dessa saker.

591
00:54:13,600 --> 00:54:19,780
Varenda linje du skriver kan du ganska mycket resonera kring hur det kommer att utföra.

592
00:54:26,800 --> 00:54:29,150
>> Låt oss se tillbaka på dessa.

593
00:54:35,400 --> 00:54:37,520
Hur trevligt är det att du inte behöver ta itu med hash funktioner,

594
00:54:37,520 --> 00:54:39,010
länkade listor, eller något sånt?

595
00:54:39,010 --> 00:54:41,980
Sedan arbeta med hashtabeller är så lätt nu, här en rolig pussel att arbeta med.

596
00:54:41,980 --> 00:54:45,920
Öppna en fil som heter unique.php och i den skriver en PHP-program

597
00:54:45,920 --> 00:54:48,330
(Även känd som en "script").

598
00:54:48,330 --> 00:54:55,700
Vi tenderar att kalla dem skript om de är korta saker som du kör på kommandoraden.

599
00:54:55,700 --> 00:55:02,950
I grund och botten, vilket språk som helst som du inte kompilera men du kommer att köra den körbara

600
00:55:02,950 --> 00:55:05,920
på kommandoraden, kan du kalla det körbara skript.

601
00:55:05,920 --> 00:55:08,510
Jag kunde lika gärna skriva en C-program som gör detta,

602
00:55:08,510 --> 00:55:12,300
men jag kallar det inte ett manus sedan jag först kompilera och kör den binära.

603
00:55:12,300 --> 00:55:15,480
Men denna PHP-program ska vi kalla ett skript.

604
00:55:15,480 --> 00:55:23,830
Eller om vi skrev det i Python eller Perl eller Node.js eller någon av dessa saker,

605
00:55:23,830 --> 00:55:26,500
vi skulle kalla dem alla skript eftersom du kör dem på kommandoraden

606
00:55:26,500 --> 00:55:30,040
men vi sammanställa dem inte.

607
00:55:30,860 --> 00:55:33,400
Vi kan göra det här ganska snabbt.

608
00:55:36,960 --> 00:55:41,480
Vi kommer inte att använda argv. Låt oss bara blåsa igenom det här.

609
00:55:41,480 --> 00:55:45,730
Kalla det unika, skriva ett program.

610
00:55:45,730 --> 00:55:49,400
Du kan anta att ingången kommer att innehålla ett ord per rad.

611
00:55:49,400 --> 00:55:52,020
Egentligen kommer argv vara ganska trivialt att använda.

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

613
00:56:08,550 --> 00:56:13,750
Första sak först, vill vi att kontrollera om vi har passerat 1 kommandoraden argument.

614
00:56:13,750 --> 00:56:20,900
Precis som du förväntar argc och argv i C, har vi fortfarande de i PHP.

615
00:56:20,900 --> 00:56:33,900
Så om ($ argc! == 2) då jag inte kommer att behandla skriva ett meddelande eller något.

616
00:56:33,900 --> 00:56:37,340
Jag ska bara avsluta, felkod av 1.

617
00:56:37,340 --> 00:56:41,340
Jag kunde också återvända 1.

618
00:56:41,340 --> 00:56:53,180
Sällan i PHP är du på detta tillstånd där vi är på -

619
00:56:53,180 --> 00:56:57,820
Vanligtvis du är i en funktion som kallas en funktion som kallas en funktion som kallas en funktion.

620
00:56:57,820 --> 00:57:02,070
Och om något går fel och du bara vill lämna allt helt,

621
00:57:02,070 --> 00:57:05,680
utgång slutar strax programmet.

622
00:57:05,680 --> 00:57:08,160
Detta finns också i C.

623
00:57:08,160 --> 00:57:10,700
Om du är i en funktion i en funktion i en funktion i en funktion

624
00:57:10,700 --> 00:57:17,540
och du vill bara döda programmet kan du ringa avsluta och det kommer bara avsluta.

625
00:57:17,540 --> 00:57:23,120
Men i PHP är det ännu mer sällsynt att vi är på denna toppnivå.

626
00:57:23,120 --> 00:57:26,090
Vanligtvis är vi inne någon form av funktion, så vi kallar exit

627
00:57:26,090 --> 00:57:29,650
så att vi inte behöver återvända upp 1 sak som sedan inser att det finns ett fel

628
00:57:29,650 --> 00:57:32,270
så som returnerar upp om som erkänner det fanns ett fel.

629
00:57:32,270 --> 00:57:35,270
Vi vill inte ta itu med det, så avsluta (1);

630
00:57:35,270 --> 00:57:38,240
retur (1), i detta fall skulle vara likvärdiga.

631
00:57:38,240 --> 00:57:44,000
>> Vad vi vill öppna vi vill fopen.

632
00:57:44,000 --> 00:57:46,760
Argumenten kommer att se ganska lika.

633
00:57:46,760 --> 00:57:51,600
Vi vill fopen ($ argv [1], och vi vill öppna den för läsning.

634
00:57:51,600 --> 00:57:55,720
Som returnerar en resurs som vi ska ringa f..

635
00:57:55,720 --> 00:58:02,180
Detta ser ganska lik hur C gör det utom vi inte har att säga FIL *.

636
00:58:02,180 --> 00:58:06,170
Istället säger vi bara $ f. Okej.

637
00:58:06,170 --> 00:58:17,190
Egentligen tror jag att detta även ger oss en vink om PHP-funktion som kallas fil. PHP-fil.

638
00:58:17,190 --> 00:58:23,990
Vad detta kommer att göra är att läsa en hel fil i en matris.

639
00:58:23,990 --> 00:58:29,770
Du behöver inte ens behöver fopen det. Det kommer att göra det åt dig.

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

641
00:58:43,700 --> 00:58:49,680
Nu alla rader i filen är i rader. Nu vill vi sortera raderna.

642
00:58:49,680 --> 00:58:52,180
Hur kan vi sortera raderna?

643
00:58:52,180 --> 00:58:54,920
Vi sorterar raderna.

644
00:58:54,920 --> 00:58:58,080
Och nu kan vi skriva ut dem eller vad som helst.

645
00:58:58,080 --> 00:59:05,580
Förmodligen det enklaste sättet är foreach ($ linjer som $ rad) echo $ linje;

646
00:59:05,580 --> 00:59:10,960
[Elev] Skulle vi korsar ens linjer genom att referera något i slag?

647
00:59:10,960 --> 00:59:28,850
Det är där slaget skulle definieras som funktion sort (& $ array).

648
00:59:28,850 --> 00:59:32,650
När du ringer den funktion du inte passera genom referens.

649
00:59:32,650 --> 00:59:36,900
Det är den funktion som definierar det som att ta det som referens.

650
00:59:36,900 --> 00:59:40,900
Detta är faktiskt precis vad som gick fel

651
00:59:40,900 --> 00:59:46,220
när vi sätter allt till våra servrar när vi gick från 5,3 till 5,4.

652
00:59:46,220 --> 00:59:53,800
Fram till 5,4, detta var helt rimligt.

653
00:59:53,800 --> 00:59:58,740
En funktion förväntar sig inte att ta det som referens, men du kan skicka den som referens

654
00:59:58,740 --> 01:00:02,860
så om funktionen inte råkar ändra det, det är fortfarande ändras.

655
01:00:02,860 --> 01:00:05,850
Från och med 5,4, du är inte meningen att göra detta.

656
01:00:05,850 --> 01:00:11,740
Så nu är det enda sättet du passera genom hänvisning är om funktionen uttryckligen gör det.

657
01:00:11,740 --> 01:00:19,840
Om du inte vill att den ska ändra det, så måste du göra $ kopia = $ linjer och passera kopia.

658
01:00:19,840 --> 01:00:24,820
Så nu linjer kommer att bevaras och kopiera ändras.

659
01:00:27,670 --> 01:00:31,460
php.unique.php. Jag kanske har trasslat upp något.

660
01:00:31,460 --> 01:00:33,190
Oväntat "Sortera".

661
01:00:38,320 --> 01:00:43,850
Det kommer att vara något som gör detta åt oss.

662
01:00:43,850 --> 01:00:45,820
Det är inte ens där.

663
01:00:45,820 --> 01:00:52,140
Lägg märke till när man läser den manual som det första argumentet förväntas vara en array

664
01:00:52,140 --> 01:00:56,490
och det har tagit genom hänvisning.

665
01:00:58,160 --> 01:01:03,540
Varför är detta klagar till mig? Eftersom jag har denna funktion Sortera fortfarande här som jag inte vill.

666
01:01:03,540 --> 01:01:09,210
Okej, php.unique.php. Jag klarade inte det ett argument för att jag inte har en fil.

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

668
01:01:13,560 --> 01:01:19,080
Här är test.php alla skrivas ut i en sorterad fin ordning.

669
01:01:19,080 --> 01:01:24,600
Observera att sorterad ordning är lite konstigt för en kod fil

670
01:01:24,600 --> 01:01:27,460
eftersom alla våra tomma rader kommer att komma först

671
01:01:27,460 --> 01:01:30,190
sedan kommer att komma alla våra 1 nivå fördjupningar

672
01:01:30,190 --> 01:01:33,360
sedan kommer alla våra några försänkningar.

673
01:01:33,360 --> 01:01:38,620
Ja. >> [Elev] Så för källkoden inte antogs av referens?

674
01:01:38,620 --> 01:01:42,240
Är det gick allmänt värde?

675
01:01:42,240 --> 01:01:50,240
[Bowden] När du ringer en funktion, aldrig avgör om det antogs genom hänvisning.

676
01:01:50,240 --> 01:01:53,960
Det är funktionsdefinitionen som avgör om den antogs genom hänvisning.

677
01:01:53,960 --> 01:01:59,450
Och titta på funktionen definition av slag eller bara tittar på detta,

678
01:01:59,450 --> 01:02:02,820
det tar argument som referens.

679
01:02:02,820 --> 01:02:07,160
Så oavsett om du vill att den ska ta det med hänvisning tar det den som referens.

680
01:02:07,160 --> 01:02:10,200
Det ändrar arrayen på plats.

681
01:02:10,200 --> 01:02:17,400
Detta är helt enkelt inte tillåtet. Du är inte tillåtet att göra detta. >> [Elev] Åh, okej.

682
01:02:17,400 --> 01:02:22,410
[Bowden] Detta är typ kommer att ta linjer genom hänvisning och ändra det.

683
01:02:22,410 --> 01:02:26,850
Och återigen, om du inte vill att det ska göra det, kan du göra en kopia av slag.

684
01:02:26,850 --> 01:02:35,850
Även i detta fall, är kopia inte faktiskt en kopia av linjer.

685
01:02:35,850 --> 01:02:40,620
Den pekar bara samma sak tills det först blir modifierad,

686
01:02:40,620 --> 01:02:44,430
där det först gå att få ändras i sorteringsfunktionen,

687
01:02:44,430 --> 01:02:50,940
där, eftersom det är copy-on-write, nu en kopia av kopia kommer att göras.

688
01:02:57,500 --> 01:03:04,250
Du kan också göra detta. Det är den andra plats som du kan se ampersand.

689
01:03:04,250 --> 01:03:07,190
Du ser det i foreach loopar, ser du det i funktionsdeklarationer,

690
01:03:07,190 --> 01:03:10,040
och du ser det när bara tilldela variabler.

691
01:03:10,040 --> 01:03:12,350
Nu har vi åstadkommit något genom att göra detta

692
01:03:12,350 --> 01:03:15,600
eftersom kopiering och linjer är bokstavligen samma sak.

693
01:03:15,600 --> 01:03:19,940
Du kan använda linjer och kopiera omväxlande.

694
01:03:19,940 --> 01:03:25,430
Du kan göra unset ($ kopia), och som inte unset linjer,

695
01:03:25,430 --> 01:03:29,120
du förlorar bara din hänvisning till samma sak.

696
01:03:29,120 --> 01:03:33,440
Så från och med denna punkt, nu linjer är det enda sättet du kan komma rader.

697
01:03:36,450 --> 01:03:38,770
>> Frågor?

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

699
01:03:42,460 --> 01:03:45,880
[Elev] Helt off topic, men du behöver inte stänga PHP med - >> Du gör det inte.

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

701
01:03:47,730 --> 01:03:53,790
[Bowden] Jag skulle gå så långt som att säga att det är dålig praxis att stänga dem.

702
01:03:53,790 --> 01:03:57,580
Det är förmodligen en överdrift, speciellt i ett manus,

703
01:03:57,580 --> 01:04:03,740
men låt oss se vad som händer om jag gör detta.

704
01:04:03,740 --> 01:04:08,890
Det gjorde ingenting. Vad händer om jag ville - [suckar]

705
01:04:13,870 --> 01:04:16,960
Jag behöver skicka ett argument.

706
01:04:19,000 --> 01:04:22,050
Skjuta. Jag kallade det fel.

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

708
01:04:28,310 --> 01:04:30,980
Nu har jag inte ens behöver det här.

709
01:04:34,520 --> 01:04:37,740
Jag ska förmedla det ett giltigt argument.

710
01:04:37,740 --> 01:04:42,050
Denna tryckta vad det är utskrift.

711
01:04:45,260 --> 01:04:50,080
Jag skriver kopiera och kopiera finns inte. Så linjer.

712
01:04:53,650 --> 01:04:58,270
Det tryckta allt, och sedan märker allt detta skräp här nere,

713
01:04:58,270 --> 01:05:06,690
eftersom PHP allt som är utanför PHP-taggar

714
01:05:06,690 --> 01:05:09,520
är bara att skrivas ut ordagrant.

715
01:05:09,520 --> 01:05:18,050
Det är därför HTML, det är så skönt att jag kan göra div bla, bla, bla klass eller vad som helst,

716
01:05:18,050 --> 01:05:25,140
bla, bla, bla och sedan göra några PHP-kod och sedan göra slut div.

717
01:05:25,140 --> 01:05:36,460
Och nu skriver detta får jag min fina div uppe, allt som PHP tryckta, div nedtill.

718
01:05:36,460 --> 01:05:43,510
Katastrofalt när något sådant här händer, vilket är ganska vanligt,

719
01:05:43,510 --> 01:05:47,930
bara en herrelös nyrad på botten av filen.

720
01:05:47,930 --> 01:05:50,940
Du skulle inte tro att det skulle vara så stor av en affär

721
01:05:50,940 --> 01:05:58,660
tills man betänker det faktum att med webbläsare -

722
01:05:58,660 --> 01:06:03,880
>> Hur omdirigerar arbete eller i princip alla rubriker arbete,

723
01:06:03,880 --> 01:06:07,980
när du gör din anslutning till en webbplats och det skickar tillbaka alla dessa rubriker och saker

724
01:06:07,980 --> 01:06:12,020
Liksom svar 200 eller svar omdirigera eller vad som helst,

725
01:06:12,020 --> 01:06:18,230
rubriker är endast giltiga fram till den första byte data skickas.

726
01:06:18,230 --> 01:06:23,140
Du kan omdirigera tusentals gånger, men så snart som den första byten av data skickas

727
01:06:23,140 --> 01:06:26,120
du är inte tänkt att omdirigera igen.

728
01:06:26,120 --> 01:06:31,860
>> Om du har en herrelös nyrad på botten av en fil

729
01:06:31,860 --> 01:06:37,260
och låt oss säga att du använder den här funktionen och sedan vill -

730
01:06:41,580 --> 01:06:52,870
Låt oss säga att det är en annan fil som är index.php och du require_once något -

731
01:06:52,870 --> 01:06:56,920
Jag kan inte tänka ett bra exempel på det.

732
01:06:56,920 --> 01:07:04,740
Frågan händer när denna linje längst ner blir ekade.

733
01:07:04,740 --> 01:07:08,660
Du vill inte något att ha ekade ännu.

734
01:07:10,820 --> 01:07:15,700
Även om du inte tänker på någonting blir ekade, gjorde något får ekade

735
01:07:15,700 --> 01:07:17,990
och så nu du inte ska skicka fler rubriker

736
01:07:17,990 --> 01:07:20,030
och du kommer att få klagomål.

737
01:07:22,170 --> 01:07:24,420
Du bara behöver inte dessa avslutande taggar.

738
01:07:24,420 --> 01:07:27,420
Om du planerar att göra något med HTML -

739
01:07:27,420 --> 01:07:30,490
och det är helt rimligt att göra här nere div helst

740
01:07:30,490 --> 01:07:39,450
och sedan på denna punkt kan du eller kan du inte inkludera dem.

741
01:07:39,450 --> 01:07:41,590
Det spelar egentligen ingen roll.

742
01:07:41,590 --> 01:07:45,450
Men i PHP-skript är det ovanligt att stänga den.

743
01:07:45,450 --> 01:07:50,400
När allt är PHP, absolut allt,

744
01:07:50,400 --> 01:07:55,460
du egentligen inte behöver stänga den / du ska inte stänga den.

745
01:08:02,030 --> 01:08:05,720
>> Att handskas med strängar är mycket trevligare än i C.

746
01:08:05,720 --> 01:08:09,470
I PHP kan du ange en sträng med enkla eller dubbla citattecken.

747
01:08:09,470 --> 01:08:12,820
Med enkla citationstecken kan du inte använda "escape"-sekvenser.

748
01:08:12,820 --> 01:08:17,640
Ständigt fly, bla, bla, bla.

749
01:08:19,920 --> 01:08:24,010
Så printf är mycket sällsynt i PHP.

750
01:08:24,010 --> 01:08:32,290
Jag antar att jag skulle använda printf om jag ville göra ett slags sak - i pset 5 du använde sprintf eller vad som helst.

751
01:08:32,290 --> 01:08:36,060
Men du vill göra 001.jpg och 002.jpg.

752
01:08:36,060 --> 01:08:40,300
Så för sånt där jag vill faktiskt att formatera texten jag skulle använda printf.

753
01:08:40,300 --> 01:08:44,689
Men annars skulle jag bara använda strängsammanfogning.

754
01:08:44,689 --> 01:08:47,000
Jag har aldrig riktigt använda printf.

755
01:08:49,229 --> 01:09:00,170
Vi bara skilja detaljerna mellan enkla citationstecken och dubbla citat.

756
01:09:00,170 --> 01:09:07,490
Den största skillnaden är att enkla citattecken, kommer det att skrivas bokstavligt.

757
01:09:07,490 --> 01:09:15,390
Det finns ingen röding datatyp i PHP, till skillnad från C, så detta är likvärdig med detta.

758
01:09:15,390 --> 01:09:17,970
De är båda strängarna.

759
01:09:17,970 --> 01:09:29,180
Och det fina med enstaka citat strängar är jag kunde säga "Hej världen!" bla, bla, bla,

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

761
01:09:33,340 --> 01:09:38,260
Vad händer när jag skriver ut det skriver ut det bokstavligen.

762
01:09:38,260 --> 01:09:40,680
Låt oss bli av med alla våra grejer.

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

764
01:09:48,569 --> 01:09:56,570
Det tryckta bokstavligen alla dessa saker: dollartecken,

765
01:09:56,570 --> 01:09:58,770
omvänt snedstreck n, som man skulle kunna tro skulle vara radbrytningar -

766
01:09:58,770 --> 01:10:01,500
alla dessa saker det skrivs bokstavligen.

767
01:10:01,500 --> 01:10:05,650
Det enda du behöver för att fly är enkla citattecken

768
01:10:05,650 --> 01:10:09,470
eftersom det annars skulle tro det stänga enkla citattecken.

769
01:10:09,470 --> 01:10:15,050
Dubbla citattecken, helt annorlunda.

770
01:10:20,300 --> 01:10:25,870
Vi ser redan syntaxmarkering är cluing oss till vad som är på väg att gå fruktansvärt fel.

771
01:10:25,870 --> 01:10:36,190
php.unique. Odefinierad variabel: Wooo eftersom detta tolkas som en variabel som heter Wooo.

772
01:10:36,190 --> 01:10:42,400
Citattecken låter dig infoga variabler i -

773
01:10:42,400 --> 01:10:52,730
Låt oss säga $ name = "Rob";

774
01:10:52,730 --> 01:10:58,020
Så echo "Hej, mitt namn är $ namn!";

775
01:10:58,020 --> 01:11:09,260
Det erkänner detta som en variabel.

776
01:11:09,260 --> 01:11:21,210
När jag kör det - och jag kommer att sätta in en ny rad - Hej, jag heter Rob! och hej världen!

777
01:11:21,210 --> 01:11:24,910
Detta beror på att jag aldrig bort tryckningen av Wooo ovan.

778
01:11:24,910 --> 01:11:30,020
Det finns 1 ytterligare steg du kan göra.

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

780
01:11:39,250 --> 01:11:43,270
Vad händer om jag vill skriva ut den första index 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 syntaxmarkering är en ledtråd. Vad kommer detta att göra?

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

784
01:11:54,510 --> 01:11:59,860
Hej, mitt namn är 1! vilket är inte vad jag ville.

785
01:11:59,860 --> 01:12:05,050
Syntaxmarkering ljög för mig.

786
01:12:05,050 --> 01:12:13,020
Låt oss försöka "a" -> 1, 'b' -> 2.

787
01:12:18,450 --> 01:12:21,440
Det är så jag skulle behöva skriva det.

788
01:12:26,350 --> 01:12:32,160
Oväntad enda citat (T_ENCAPSED bla, bla, bla, bla, bla).

789
01:12:32,160 --> 01:12:41,780
Tanken är att det inte är att erkänna detta som en del av gruppen.

790
01:12:41,780 --> 01:12:46,620
Det är inte erkänna detta som matris indexeras av bokstaven A.

791
01:12:46,620 --> 01:12:49,870
Du vill göra det omgiven av klammerparenteser,

792
01:12:49,870 --> 01:12:54,730
och nu allt som är i detta klammerparentes kommer interpoleras,

793
01:12:54,730 --> 01:13:00,340
vilket är det ord vi använder för magiskt sätta dessa variabler i de rätta ställena.

794
01:13:00,340 --> 01:13:04,280
Nu gör detta, php.unique och Hej, mitt namn 1! som väntat

795
01:13:04,280 --> 01:13:07,720
eller Hej, jag heter Rob!

796
01:13:14,110 --> 01:13:23,130
En sak som är ganska trevligt om enkla citattecken är att -

797
01:13:23,130 --> 01:13:28,480
Det finns en viss kostnad för interpolering.

798
01:13:30,520 --> 01:13:35,100
Om du använder citationstecken, måste tolken att gå över denna sträng,

799
01:13:35,100 --> 01:13:41,500
att se till att, "Åh, här är en variabel. Nu måste jag gå och hämta den variabeln och sätta in det här."

800
01:13:41,500 --> 01:13:48,930
Även om du inte använder några variabler,

801
01:13:48,930 --> 01:13:52,220
ingenting inuti dessa citationstecken måste interpoleras,

802
01:13:52,220 --> 01:13:56,800
men det kommer fortfarande att vara långsammare eftersom det måste gå över de dubbla citattecken

803
01:13:56,800 --> 01:14:00,130
letar efter saker som måste interpoleras.

804
01:14:00,130 --> 01:14:05,360
Så apostrof kan vara lite snabbare om ingenting behöver interpoleras,

805
01:14:05,360 --> 01:14:15,650
och jag brukar även använda enkla citattecken för "Hej, mitt namn är". $ Array ['a'] ändå.

806
01:14:15,650 --> 01:14:20,430
Det kommer att motsvara vad vi hade tidigare.

807
01:14:24,840 --> 01:14:28,440
Men det är en fråga om inställning.

808
01:14:28,440 --> 01:14:34,750
Om du använder PHP, du förmodligen inte bryr sig om skillnaden i hastighet.

809
01:14:34,750 --> 01:14:39,480
Det räcker inte att resonera dem till att börja med.

810
01:14:39,480 --> 01:14:43,030
>> Några definitiva frågor?

811
01:14:47,430 --> 01:14:51,710
>> Vi har faktiskt inte ens få igenom allt, men det här var tråkigt.

812
01:14:51,710 --> 01:14:59,080
Det sista som är ganska trevligt i PHP är när du arbetar med HTML,

813
01:14:59,080 --> 01:15:06,450
du kommer att använda den lite, så den fina genvägen syntaxen för att skriva ut en variabel.

814
01:15:32,400 --> 01:15:36,730
Utan att sätta PHP hit, detta kallas korta taggar.

815
01:15:36,730 --> 01:15:44,330
Officiellt som PHP 5,4, detta föråldrat.

816
01:15:44,330 --> 01:15:48,640
Du rekommenderas att sätta PHP.

817
01:15:48,640 --> 01:15:55,770
Detta stöds fortfarande, så korta taggar med <? = Fortfarande mycket bra.

818
01:15:55,770 --> 01:16:02,480
Det är genom stöd standard, så att du kan använda dessa som du vill, och de är ganska bekvämt.

819
01:16:02,480 --> 01:16:05,700
>> Några frågor?

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

821
01:16:10,840 --> 01:16:13,800
>> Håll stilrena, San Diego.

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

823
01:16:18,620 --> 01:16:22,660
Hej då. [Skrattar]

824
01:16:24,350 --> 01:16:28,470
[Applåder] [skrattar]

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