1
00:00:00,000 --> 00:00:02,610
[Powered by Google Translate] [Раздел 8 - по-комфортно]

2
00:00:02,610 --> 00:00:04,910
[Роб Боудън - Харвардския университет]

3
00:00:04,910 --> 00:00:07,070
[Това е CS50. - CS50.TV]

4
00:00:11,520 --> 00:00:14,160
>> Тези бележки седмица раздел ще бъде доста кратък,

5
00:00:14,160 --> 00:00:19,070
така че аз съм просто ще продължим да говорим, вие ще продължат да задават въпроси,

6
00:00:19,070 --> 00:00:22,720
и ние ще се опитаме да запълнят толкова време, колкото е възможно.

7
00:00:22,720 --> 00:00:31,950
Много хора смятат, че, че това pset не е непременно трудно, но това е много дълго.

8
00:00:31,950 --> 00:00:37,070
Самата pset спец. отнема един час, за да се чете.

9
00:00:40,530 --> 00:00:45,730
Ние ви даваме много на SQL, което би могло да се наложи да използвате.

10
00:00:45,730 --> 00:00:50,520
Ние ви преведе през много от него, така че не трябва да бъде прекалено лошо.

11
00:00:50,520 --> 00:00:54,560
Има ли някой е започнало или завършен?

12
00:00:55,380 --> 00:00:59,710
Това е последната pset. О, Боже мой.

13
00:00:59,710 --> 00:01:05,400
Обикновено там е JavaScript един след това, но нещата календарни на климата

14
00:01:05,400 --> 00:01:09,560
прави всичко 1 седмица по-кратък, а ние вече няма pset JavaScript.

15
00:01:09,560 --> 00:01:12,310
Не знам как това влияе на това дали JavaScript ще се появи на изпита

16
00:01:12,310 --> 00:01:15,510
или викторина 1.

17
00:01:15,510 --> 00:01:22,260
Предполагам, че това ще бъде нещо като теб трябва да знае неща от високо ниво за JavaScript,

18
00:01:22,260 --> 00:01:26,460
но аз се съмнявам, че току-що ви дам направо JavaScript код

19
00:01:26,460 --> 00:01:28,720
тъй като не са имали pset в него.

20
00:01:28,720 --> 00:01:33,000
Но това ще бъде неща за преглед тест следващата седмица.

21
00:01:33,000 --> 00:01:36,320
>> Раздел въпроси.

22
00:01:36,320 --> 00:01:43,870
А много от тези неща е малко по-зле формулиран, но ние ще обсъдим защо.

23
00:01:43,870 --> 00:01:50,220
За разлика от C, PHP е език "динамично пишеща машина". Какво означава това, ще попитате вие?

24
00:01:50,220 --> 00:01:53,830
Е, да кажем сбогом на всички тези Чар, флоат, вътр и други ключови думи, които трябва да използвате

25
00:01:53,830 --> 00:01:56,190
при деклариране на променливи и функции в C.

26
00:01:56,190 --> 00:02:00,420
В PHP, типът на променливата се определя от стойност, която в момента държи.

27
00:02:00,420 --> 00:02:04,990
Така че преди да въведете този код във файл, наречен dynamic.php,

28
00:02:04,990 --> 00:02:12,670
PHP е динамично написали. Това е вярно.

29
00:02:12,670 --> 00:02:17,590
Не съм съгласен с факта, че това означава, че ние сме се сбогува с Чар, флоат, вътр,

30
00:02:17,590 --> 00:02:20,620
и други ключови думи.

31
00:02:20,620 --> 00:02:25,510
Точната разлика между динамично на пишеща машина и алтернативата,

32
00:02:25,510 --> 00:02:32,010
което е статично въвели, е, че динамично въвели, всички проверки на типа и неща

33
00:02:32,010 --> 00:02:37,350
се случва по време на изпълнение, като има предвид, че статично написали това се случва по време на компилация.

34
00:02:37,350 --> 00:02:43,030
Думата статична като цяло изглежда предвид неща, времето на съставяне.

35
00:02:43,030 --> 00:02:48,170
Предполагам, че има и други начини за използване, но в C, когато декларирам статична променлива,

36
00:02:48,170 --> 00:02:52,650
нейното съхранение се разпределят по време на компилация.

37
00:02:52,650 --> 00:02:59,260
Тук динамично написали просто означава, че

38
00:02:59,260 --> 00:03:04,350
В C, ако се опитате да добавите низ и число, когато го съставят,

39
00:03:04,350 --> 00:03:11,000
че ще ходи да се оплаче, защото тя ще каже, че не можете да добавяте вътр и показалеца.

40
00:03:11,000 --> 00:03:14,710
Това просто не е валиден операция.

41
00:03:14,710 --> 00:03:21,170
Това е друго нещо, че ние ще стигнем до в секунда.

42
00:03:21,170 --> 00:03:24,860
Но този вид проверка, фактът, че той се оплаква по време на компилация,

43
00:03:24,860 --> 00:03:29,220
е статичен тип проверка.

44
00:03:29,220 --> 00:03:35,220
Има езици, където не трябва да се каже, Чар, плувка, вътр., Както и всички тези неща,

45
00:03:35,220 --> 00:03:40,940
но езикът може да каже от контекста на това нещо, какъв тип е трябвало да бъде,

46
00:03:40,940 --> 00:03:43,980
но тя все още е статично написали.

47
00:03:43,980 --> 00:03:49,000
Така че, ако сте приели 51, OCaml, никога не трябва да използвате някоя от тези видове,

48
00:03:49,000 --> 00:03:58,700
но все още по време на компилация ще кажа, че не може да направи това, защото сте смесването на вътр и низ.

49
00:03:58,700 --> 00:04:05,650
Динамично написали просто означава, че по някое време тече времето ти започваш да се получи жалба.

50
00:04:05,650 --> 00:04:13,430
Ако сте също се използва Java и преди, като цяло, почти всеки тип C-език

51
00:04:13,430 --> 00:04:20,070
ще бъде статично написали, C, C + +, Java, всички тези обикновено статично написали.

52
00:04:20,070 --> 00:04:22,910
В Java, когато съставят нещо и казва

53
00:04:22,910 --> 00:04:26,670
низ и се равнява на нещо ново, което не е низ,

54
00:04:26,670 --> 00:04:28,950
че ще ходи да се оплаче, защото тези типове просто не съвпадат.

55
00:04:28,950 --> 00:04:31,180
Това ще да се оплакват по време на компилация.

56
00:04:31,180 --> 00:04:36,750
Но той също има някои динамично време, такива неща, ако се опитате да хвърли нещо

57
00:04:36,750 --> 00:04:40,500
тип, който е по-специфична от сегашния си вид,

58
00:04:40,500 --> 00:04:45,610
няма нищо, той може да направи по време на компилация, за да се провери дали тези гласове ще успее.

59
00:04:45,610 --> 00:04:51,130
Java също има някои динамичен тип проверка, че веднага след като тя стане на тази линия на код

60
00:04:51,130 --> 00:04:54,130
когато тя всъщност изпълнява, той ще направи на гласове,

61
00:04:54,130 --> 00:04:56,260
проверите дали това гласове на първо място е валидно,

62
00:04:56,260 --> 00:04:59,890
и ако не беше, то тогава ще да се оплакват, че имате невалиден тип.

63
00:04:59,890 --> 00:05:03,200
Динамичен тип проверка.

64
00:05:03,200 --> 00:05:07,010
Въведете това в един файл, наречен dynamic.php.

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

66
00:05:14,580 --> 00:05:17,190
Ще разархивирайте, че форматирането.

67
00:05:18,750 --> 00:05:21,880
Ние имаме променлива, ние го до цяло число 7,

68
00:05:21,880 --> 00:05:27,930
след това отиваме да го отпечатате и% S -

69
00:05:27,930 --> 00:05:32,830
О, ние сме отпечатване на вид, така че gettype ще се върне типа на променливата.

70
00:05:32,830 --> 00:05:35,720
Ние сме просто печат вида отново и отново.

71
00:05:35,720 --> 00:05:39,440
Ние просто php.dynamic.php.

72
00:05:39,440 --> 00:05:45,920
Ще видим, че тя се променя от цяло число в низ до булевата както ние мине през.

73
00:05:45,920 --> 00:05:54,590
В C не е Булев тип данни, не е низ тип данни.

74
00:05:54,590 --> 00:06:00,500
Има Чар * и Булева тенденция да бъде INT или овъгляване или нещо.

75
00:06:00,500 --> 00:06:05,690
В PHP тези видове не съществуват, и това е едно от големите предимства на PHP над C

76
00:06:05,690 --> 00:06:13,290
низови операции са безкрайно по-лесно в PHP от C. Те просто работят.

77
00:06:13,290 --> 00:06:18,290
>> Така че ние се върна тук.

78
00:06:18,290 --> 00:06:21,260
Избягахме dynamic.php.

79
00:06:21,260 --> 00:06:26,710
Това казва на PHP преводач, PHP, да стартирате PHP код в dynamic.php.

80
00:06:26,710 --> 00:06:30,250
Ако имате някакви грешки във файла, преводачът ще ти кажа!

81
00:06:30,250 --> 00:06:39,110
Преводачът, това е още една голяма разлика между PHP и C.

82
00:06:39,110 --> 00:06:48,200
В C ще трябва да компилирате нещо и след това да тичам, че компилиран файл.

83
00:06:48,200 --> 00:06:50,490
В PHP никога не съставят нищо.

84
00:06:50,490 --> 00:06:57,200
PHP интерпретатора е просто четат тази линия по ред.

85
00:06:57,200 --> 00:07:02,900
Той удари VaR = 7 след това го удари ФОРМАТ след това го удари VaR след това го удари ФОРМАТ и така нататък.

86
00:07:02,900 --> 00:07:10,910
Има малко на съставянето го прави и го кешира резултатите

87
00:07:10,910 --> 00:07:15,510
така че ако стартирате скрипта по-късно можете да направите някои,

88
00:07:15,510 --> 00:07:19,280
но основно това е ред по ред подобно нещо.

89
00:07:19,280 --> 00:07:25,280
Това означава, че много оптимизации, които получаваме в C,

90
00:07:25,280 --> 00:07:31,920
като събиране, това е просто обикновено компилаторът може да направи много трикове за вас.

91
00:07:31,920 --> 00:07:36,110
Това може да отнеме неизползвани променливи, той може да направи всички тези видове неща,

92
00:07:36,110 --> 00:07:38,660
той може да направи рекурсия опашката.

93
00:07:38,660 --> 00:07:42,550
В PHP вие няма да получите това предимство

94
00:07:42,550 --> 00:07:45,690
защото това е просто ще започне изпълнение на ред по ред по ред,

95
00:07:45,690 --> 00:07:49,950
и не наистина да признае тези неща толкова лесно

96
00:07:49,950 --> 00:07:54,440
тъй като не е една голяма компилация пас над нещо и след това изпълнение;

97
00:07:54,440 --> 00:07:56,860
това е просто ред по ред.

98
00:08:00,730 --> 00:08:02,750
Така че това е преводач.

99
00:08:02,750 --> 00:08:06,840
>> Обратно към динамичното ни пишете: много готино, нали?

100
00:08:06,840 --> 00:08:08,640
Ти определено не може да направи това в C!

101
00:08:08,640 --> 00:08:11,860
Сега, вижте, ако можете да разберете вида на всяка от следните стойности.

102
00:08:11,860 --> 00:08:14,760
Виж за справка.

103
00:08:14,760 --> 00:08:19,420
Така 3.50. Какъв тип смятате ли, че ще бъде?

104
00:08:24,480 --> 00:08:26,370
Това са видове, които имаме.

105
00:08:26,370 --> 00:08:30,430
Имаме bools, цели числа, плаващи точки, низове, масиви, обекти,

106
00:08:30,430 --> 00:08:38,370
и ресурси, което е един вид на неясни.

107
00:08:38,370 --> 00:08:41,010
Мисля, че всъщност е пример тук.

108
00:08:41,010 --> 00:08:43,740
Тогава там е NULL. NULL е специален вид.

109
00:08:43,740 --> 00:08:47,140
За разлика от C, където NULL е само указател с адрес 0,

110
00:08:47,140 --> 00:08:54,930
в PHP, NULL своя тип, когато валидни само нещо от този тип е NULL.

111
00:08:57,560 --> 00:09:00,670
Това е много по-полезен за проверка за грешки.

112
00:09:00,670 --> 00:09:04,310
В C, където сме имали този проблем, при който ако се върнете NULL,

113
00:09:04,310 --> 00:09:08,660
не означава, че връща нулев указател или използване NULL да означава грешка

114
00:09:08,660 --> 00:09:12,380
или всичко това объркване имахме в един момент.

115
00:09:12,380 --> 00:09:18,440
Ето, връщайки NULL обикновено означава грешка.

116
00:09:20,860 --> 00:09:27,300
Много неща се върне невярно за грешка.

117
00:09:27,300 --> 00:09:33,140
Но въпросът е NULL тип, единственото нещо, на NULL тип е NULL.

118
00:09:33,140 --> 00:09:40,090
След това обаждане е като можете да определите някои анонимни функции.

119
00:09:40,090 --> 00:09:46,420
Не е нужно да се даде функцията име, но няма да се налага да се справят с това тук.

120
00:09:46,420 --> 00:09:53,940
Видове, които те очакват от нас да знаете,

121
00:09:53,940 --> 00:09:59,000
какво мислите вида на 3.50? >> [Ученик] Float.

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

123
00:10:00,370 --> 00:10:06,290
Значи тук, какво мислите за това е? >> Студент масив.

124
00:10:06,290 --> 00:10:09,890
Да. Първият е поплавък, вторият е масив.

125
00:10:09,890 --> 00:10:14,500
Забележете, че този масив не е като масив C

126
00:10:14,500 --> 00:10:19,610
където имате индекс 0 има някаква стойност, индекс 1 има някаква стойност.

127
00:10:19,610 --> 00:10:26,320
Тук индекси са А, Б, В и С и стойностите са 1, 2 и 3.

128
00:10:26,320 --> 00:10:33,980
В PHP няма разлика между асоциативен масив, а просто обикновен масив

129
00:10:33,980 --> 00:10:36,740
, както бихте си помислили за него в C.

130
00:10:36,740 --> 00:10:43,040
Има само това, а под предния капак редовно масив е само асоциативен масив

131
00:10:43,040 --> 00:10:50,000
където 0 карти до някаква стойност по същия начин, карти някаква стойност.

132
00:10:50,000 --> 00:11:00,410
Поради тази причина, PHP може да бъде доста лошо за много по-бързо нещата код / ​​бенчмаркинг

133
00:11:00,410 --> 00:11:07,930
тъй като в C, когато използвате масив знаете, че достъпът до потребител е константно време.

134
00:11:07,930 --> 00:11:11,860
В PHP достъп до член е кой знае колко време?

135
00:11:11,860 --> 00:11:18,970
Вероятно това е постоянна, ако правилно го хешове.

136
00:11:18,970 --> 00:11:21,620
Кой знае какво наистина прави под предния капак?

137
00:11:21,620 --> 00:11:25,600
Вие наистина трябва да погледнем изпълнението, за да се види как ще се справим с това.

138
00:11:25,600 --> 00:11:28,550
Тогава fopen.

139
00:11:28,550 --> 00:11:36,420
Мисля, че тук нека просто PHP ръчно fopen да погледнете типът на връщане.

140
00:11:36,420 --> 00:11:41,260
Ние виждаме тук можете да погледнете нагоре почти всяка функция в PHP употреба

141
00:11:41,260 --> 00:11:47,540
и това е нещо на човека страница на PHP.

142
00:11:47,540 --> 00:11:51,060
Връщания тип ще бъде ресурс.

143
00:11:51,060 --> 00:11:56,050
Ето защо аз го погледна, защото ние наистина не определят ресурс.

144
00:11:56,050 --> 00:12:04,110
Идеята на ресурсите, C вид има FILE * или каквото

145
00:12:04,110 --> 00:12:07,200
в PHP ресурс е FILE *.

146
00:12:07,200 --> 00:12:10,360
Това е това, което ще трябва да се чете от, това е, което ти започваш да се пише.

147
00:12:10,360 --> 00:12:20,710
Това е обикновено външни, така че това е ресурс, който може да тегли нещата и хвърлят неща, които трябва да.

148
00:12:20,710 --> 00:12:26,520
И накрая, какъв е типът на NULL? >> Студент NULL.

149
00:12:26,520 --> 00:12:30,650
Да. Е NULL Така че единственото нещо, което е NULL.

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

151
00:12:35,490 --> 00:12:41,170
>> Една от характеристиките на тип система PHP (за добро или за лошо) е способността му да жонглирам видове.

152
00:12:41,170 --> 00:12:44,390
Когато пишете линия на PHP код, която съчетава ценностите на различни видове

153
00:12:44,390 --> 00:12:46,670
PHP ще се опита да се направи разумно нещо.

154
00:12:46,670 --> 00:12:48,920
Опитайте всеки от следните линии на PHP код. Какво отпечатани?

155
00:12:48,920 --> 00:12:51,000
Това, което сте очаквали? Защо или защо не?

156
00:12:51,000 --> 00:12:58,600
Този факт за PHP е това, което прави това, което ние наричаме слабо пишеща машина.

157
00:12:58,600 --> 00:13:04,610
Слабо написали и силно типизирани

158
00:13:04,610 --> 00:13:06,840
има различни начини за използване на тези условия,

159
00:13:06,840 --> 00:13:12,020
но повечето хора използват слабо написали и силно типизирани означава този вид на нещо

160
00:13:12,020 --> 00:13:15,920
където ("1" + 2), която работи.

161
00:13:15,920 --> 00:13:18,290
В C, че няма да работи.

162
00:13:18,290 --> 00:13:22,490
Можете да си представите, това не работи.

163
00:13:22,490 --> 00:13:29,200
Много хора се смесват динамично типизиране и слаби пишете и статични пишете и силно типизиране.

164
00:13:29,200 --> 00:13:34,050
Python е друг пример за език, който е динамично написали.

165
00:13:34,050 --> 00:13:41,770
Можете да хвърлите около видове в променливи и ще се определи по време на изпълнение

166
00:13:41,770 --> 00:13:44,680
грешки checkings.

167
00:13:44,680 --> 00:13:50,740
В Python, че ще изпълни това и ще видите ("1" + 2);

168
00:13:50,740 --> 00:13:55,920
и това ще се провалят, защото тя казва, че не можете да добавяте низ и число.

169
00:13:55,920 --> 00:14:00,860
В PHP, който е също толкова динамично написали, това няма да се провали.

170
00:14:00,860 --> 00:14:04,220
Слаба пишете трябва да се направи с факта, че тя прави неща с типове

171
00:14:04,220 --> 00:14:07,800
, които наистина не смисъл е задължително.

172
00:14:07,800 --> 00:14:17,420
Така ("1" + 2), мога да си представя, че е низ 12, мога да си представя, че е низ 3,

173
00:14:17,420 --> 00:14:20,710
Мога да си представя да е цяло число 3.

174
00:14:20,710 --> 00:14:24,530
Това не е непременно добре дефинирани, и ние вероятно сме да видите тук

175
00:14:24,530 --> 00:14:29,140
че когато се печата ("1" + 2); е вероятно в крайна сметка ще е различен

176
00:14:29,140 --> 00:14:32,320
от печат (1 + "2").

177
00:14:32,320 --> 00:14:39,700
И тази тенденция да бъде, по мое мнение, по-лошо.

178
00:14:39,700 --> 00:14:44,240
Тук можем да се опитаме.

179
00:14:44,240 --> 00:14:48,740
Друг малък трик за PHP е, че не е нужно да се запише файла.

180
00:14:48,740 --> 00:14:52,790
Тя не изпълните тази команда режим.

181
00:14:52,790 --> 00:14:57,710
Така PHP-R, тогава можем да хвърли в командния тук:

182
00:14:57,710 --> 00:15:06,610
"Печат (1 + 2);" и аз ще направя нов ред.

183
00:15:19,550 --> 00:15:23,970
Това отпечатани 3.

184
00:15:31,100 --> 00:15:35,330
Изглежда, че отпечатва 3, и е цяло число 3.

185
00:15:35,330 --> 00:15:38,420
Така че сега, нека се опитаме по друг начин:

186
00:15:38,420 --> 00:15:42,970
"Печат (1 + 2");

187
00:15:45,560 --> 00:15:50,490
Ставаме 3, и също ще бъде цяло число 3? Честно казано, нямам идея.

188
00:15:50,490 --> 00:15:54,030
Това изглежда, че е в съответствие.

189
00:15:54,030 --> 00:15:59,550
Там никога няма шанс да е низ 12 или нещо подобно, че

190
00:15:59,550 --> 00:16:08,080
защото PHP, за разлика от JavaScript и Java,

191
00:16:08,080 --> 00:16:11,670
има отделен оператор за конкатенация.

192
00:16:11,670 --> 00:16:14,930
Concatenation в PHP е точка.

193
00:16:14,930 --> 00:16:22,950
Така печат (1 '2 ').; Ще ни даде 12.

194
00:16:25,790 --> 00:16:32,420
Тази тенденция да доведе до объркване, когато хората се опитват да направят нещо подобно ул. + =

195
00:16:32,420 --> 00:16:37,840
някои други неща, че искате да добавите към края на низ им, както и че ще се провалят.

196
00:16:37,840 --> 00:16:40,770
Вие трябва да направите ул. =

197
00:16:42,000 --> 00:16:46,240
Така че не забравяйте конкатенация в PHP е точка.

198
00:16:46,240 --> 00:16:52,100
Други неща, които можете да опитате: печат ("CS" + 50);

199
00:16:55,750 --> 00:17:03,610
Казах ти, че няма надежда за това, в резултат на CS50

200
00:17:03,610 --> 00:17:06,119
тъй като конкатенация не е +.

201
00:17:06,119 --> 00:17:08,440
Какво мислиш, че това е в крайна сметка ще е?

202
00:17:10,359 --> 00:17:13,460
Аз честно казано нямам абсолютно никаква идея.

203
00:17:14,250 --> 00:17:16,460
Тя изглежда като че ли е само на 50.

204
00:17:16,460 --> 00:17:21,490
Тя вижда низ, и Обзалагам се, че ако сложим 123CS -

205
00:17:21,490 --> 00:17:29,640
Тя вижда първия низ, тя се опитва да чете цяло число от него или от нея.

206
00:17:29,640 --> 00:17:31,710
В този случай той вижда 123CS.

207
00:17:31,710 --> 00:17:35,190
"Това не се връзва като цяло число, така че аз съм просто ще мисля за 123".

208
00:17:35,190 --> 00:17:38,580
Така че 123 + 50 ще бъде 173.

209
00:17:38,580 --> 00:17:40,740
И тук започва да чете това като цяло число.

210
00:17:40,740 --> 00:17:45,690
Той не вижда нищо, така че просто се третира като 0. Така 0 + 50 ще бъде 50.

211
00:17:45,690 --> 00:17:51,600
Това аз съм се предположи, че ще направи нещо подобно.

212
00:17:51,600 --> 00:17:54,310
Мисля 99.

213
00:17:54,310 --> 00:17:57,580
Да, защото ще вземе първото -

214
00:18:12,880 --> 00:18:15,730
Така 99.

215
00:18:15,730 --> 00:18:21,970
Тук (10/7), ако това е C, какво би било това се върнете?

216
00:18:23,700 --> 00:18:29,630
[Ученик] 1. >> Да, ще бъде 1, защото 10/7 се раздели на две числа.

217
00:18:29,630 --> 00:18:32,910
Цяло число, разделени от цяло число ще се върне цяло число.

218
00:18:32,910 --> 00:18:37,750
Тя не може да се върне една каквото и точка, която ще бъде, така че просто ще се върне 1.

219
00:18:37,750 --> 00:18:46,120
Тук печат (10/7), това ще се тълкува тази.

220
00:18:46,120 --> 00:18:53,760
А това означава, че ако искате да направите цяло число, закръгляване и подобни неща,

221
00:18:53,760 --> 00:18:59,950
което трябва да направите печат (етаж (10/7));

222
00:18:59,950 --> 00:19:08,460
В C, това е може би странно, че можете да разчитате на редовно цяло число отрязване,

223
00:19:08,460 --> 00:19:12,260
но в PHP не може, защото тя автоматично ще го превърне в поплавъка.

224
00:19:13,430 --> 00:19:17,610
И тогава (7 + вярно); какво мислите, че ще бъде?

225
00:19:18,550 --> 00:19:23,640
Аз съм се познае осем, ако то се случва да се тълкува вярно, тъй като 1.

226
00:19:23,640 --> 00:19:25,740
Тя изглежда като че ли е 8.

227
00:19:25,740 --> 00:19:31,710
>> Така че всичко, което сме правили през последните 10 минути абсолютно никога не трябва да правите.

228
00:19:31,710 --> 00:19:39,870
Вие ще видите код, който прави това.

229
00:19:39,870 --> 00:19:42,700
То не трябва да бъде толкова лесно, тъй като това.

230
00:19:42,700 --> 00:19:47,240
Може да има две променливи, както и едно променлива се случва да бъде низ

231
00:19:47,240 --> 00:19:51,310
и друга променлива се случва да бъде едно цяло число, и след това да добавите тези променливи.

232
00:19:51,310 --> 00:20:00,120
Тъй като PHP е динамично написали и не ще направи проверка на типа за вас

233
00:20:00,120 --> 00:20:03,640
и тъй като това е слабо написали и тъй като тя просто ще автоматично хвърлят тези неща заедно

234
00:20:03,640 --> 00:20:11,490
и всичко ще работи, че е трудно дори да се знае, че тази променлива трябва да бъде низ сега,

235
00:20:11,490 --> 00:20:14,930
така че аз не трябва да го добавите към тази променлива, която е цяло число.

236
00:20:18,780 --> 00:20:24,560
Най-добрата практика е, ако дадена променлива е низ, дръжте го като низ завинаги.

237
00:20:24,560 --> 00:20:26,980
Ако дадена променлива е едно цяло число, като вътр завинаги.

238
00:20:26,980 --> 00:20:30,770
Ако искате да се справят с числа и низове,

239
00:20:30,770 --> 00:20:36,970
можете да използвате varsint - това е JavaScript.

240
00:20:36,970 --> 00:20:42,520
Intval. Аз правя това през цялото време. PHP и JavaScript смесват всичко.

241
00:20:42,520 --> 00:20:47,600
Така intval ще се върне числовата стойност на дадена променлива.

242
00:20:47,600 --> 00:20:56,550
Ако премине в "печат (intval ('123 ')), можете да получите 123.

243
00:21:06,820 --> 00:21:15,850
Intval сама по себе си не ще да направи проверка за нас, че това е изключително цяло число.

244
00:21:15,850 --> 00:21:20,460
Ръководството на PHP, има само толкова много функции,

245
00:21:20,460 --> 00:21:26,560
така че тук мисля, че това, което бих използвал е функция is_numeric първото.

246
00:21:26,560 --> 00:21:32,590
Аз съм се познае, че се връща фалшиви.

247
00:21:32,590 --> 00:21:35,780
Това е друго нещо, което трябва да е ===.

248
00:21:37,850 --> 00:21:44,020
Така функция is_numeric ('123df "), не би си помислил, на тази функция is_numeric.

249
00:21:44,020 --> 00:21:46,720
В C вие ще трябва да обхождане на всички символи

250
00:21:46,720 --> 00:21:50,410
и да се провери, ако всеки от героите е цифра или каквото.

251
00:21:50,410 --> 00:21:53,850
Тук функцията is_numeric ще направи това за нас,

252
00:21:53,850 --> 00:21:56,520
и това е връщане фалшиви.

253
00:21:56,520 --> 00:22:02,120
Така че, когато аз отпечатан, отпечатани нищо, така че аз съм тук сравняват, за да видите,

254
00:22:02,120 --> 00:22:05,490
се случи да е фалшива? И така, сега е печат 1.

255
00:22:05,490 --> 00:22:10,060
Очевидно го отпечатва едно като истински вместо на отпечатване вярно, тъй като вярно.

256
00:22:10,060 --> 00:22:15,790
Чудя се, ако го направя print_r. Не, все още една.

257
00:22:15,790 --> 00:22:26,760
>> Връщайки се към === == все още съществува,

258
00:22:26,760 --> 00:22:32,260
и ако искаш да говориш с Томи той ще каже == е съвършено глоба.

259
00:22:32,260 --> 00:22:37,700
Отивам да се каже, че == е ужасно и никога не трябва да се използва ==.

260
00:22:37,700 --> 00:22:44,870
Разликата е, че == сравнява неща

261
00:22:44,870 --> 00:22:48,450
, където тя може да бъде вярно, дори ако те не са един и същи тип,

262
00:22:48,450 --> 00:22:53,810
като има предвид, че === сравнява неща и за първи път го проверки, които са едни и същи тип?

263
00:22:53,810 --> 00:22:58,010
Да. Добре, сега отивам да се види дали те действително сравни да бъде равен.

264
00:22:58,010 --> 00:23:08,890
Можете да получите странни неща, като 10 се равнява - нека да видим какво казва.

265
00:23:08,890 --> 00:23:15,570
Така че ('10 '== '1 e1 ");

266
00:23:15,570 --> 00:23:17,980
Това връща вярно.

267
00:23:17,980 --> 00:23:21,420
Някой има ли предположения защо това се връща вярно?

268
00:23:25,180 --> 00:23:27,120
Това не е само за това. Може би това е намек.

269
00:23:27,120 --> 00:23:33,170
Но ако сменя на е - по дяволите! Продължите да използвате двойни кавички.

270
00:23:33,170 --> 00:23:38,780
Причината двойни кавички са ми крещи е така, защото съм сложил това в кавички.

271
00:23:38,780 --> 00:23:43,850
Така че бих могъл да избяга от двойни кавички тук, но единични кавички го правят по-лесно.

272
00:23:43,850 --> 00:23:49,120
Така че ('10 '== "1 f1); не се отпечатва вярно. ('10 '== "1 e1); отпечатва вярно.

273
00:23:49,120 --> 00:23:56,330
[Ученик] шестнадесетичен? >> Това не е шестнадесетичен, но е близо, че това е като -

274
00:23:56,330 --> 00:24:01,060
1E1, научна нотация.

275
00:24:01,060 --> 00:24:07,950
Тя признава 1E1 като 1 * 10 ^ 1 или нещо такова.

276
00:24:07,950 --> 00:24:11,510
Това са равни числа.

277
00:24:11,510 --> 00:24:15,930
Ако правим === то тогава ще е невярна.

278
00:24:15,930 --> 00:24:28,490
Аз всъщност нямам идея, ако правим == какво да кажем за (10 и '10abc "); Добре. Така че това е вярно.

279
00:24:28,490 --> 00:24:35,940
Така че просто искал когато си направил (10 + '10abc "); и тя ще бъде 20,

280
00:24:35,940 --> 00:24:38,800
(10 == '10abc "); е вярно.

281
00:24:38,800 --> 00:24:45,350
Дори по-лошо са неща, като (FALSE == NULL); е вярно

282
00:24:45,350 --> 00:24:52,210
или (фалшиво == 0); е вярно, (фалшиво == []);

283
00:24:52,210 --> 00:25:00,970
Има странни случаи на - Това е една от тези странни случаи.

284
00:25:00,970 --> 00:25:08,110
Забележете, че (фалшиво == []); е вярно.

285
00:25:08,110 --> 00:25:11,950
('0 '== Фалшиви); е вярно.

286
00:25:11,950 --> 00:25:16,090
('0 '== []), Е лъжа.

287
00:25:16,090 --> 00:25:19,090
Така == е по никакъв начин не преходен.

288
00:25:19,090 --> 00:25:26,830
може да бъде равна на В и може да бъде равна на в

289
00:25:26,830 --> 00:25:29,340
но б не може да бъде равна на в.

290
00:25:29,340 --> 00:25:35,580
Това е отвратително с мен, и винаги трябва да използвате ===.

291
00:25:35,580 --> 00:25:38,590
[Ученик] Може да направим! == Както добре? >> Bowden Да.

292
00:25:38,590 --> 00:25:44,600
Равностойността ще бъде! = И! ==.

293
00:25:44,600 --> 00:25:48,230
Това всъщност е израснал в pset спец.

294
00:25:48,230 --> 00:25:52,000
когато много функции връщат -

295
00:25:52,000 --> 00:25:53,890
Ръководството на PHP е добре за това.

296
00:25:53,890 --> 00:25:59,140
Тя поставя в голяма червена кутия "Това ще върне невярно, ако има грешка."

297
00:25:59,140 --> 00:26:03,940
Но връщането на 0 е напълно разумно нещо, което трябва да се върне.

298
00:26:03,940 --> 00:26:08,250
Помислете за всяка функция, която се очаква да се върне цяло число.

299
00:26:11,250 --> 00:26:17,880
Да кажем, че тази функция е трябвало да брои броя на редовете във файл или нещо такова.

300
00:26:17,880 --> 00:26:23,490
При нормални обстоятелства, се преминава тази функция файл

301
00:26:23,490 --> 00:26:27,120
и тя ще се върне цяло число, което представлява броя на редовете.

302
00:26:27,120 --> 00:26:30,820
Така че 0 е напълно разумен брой, ако файлът е празно.

303
00:26:30,820 --> 00:26:36,810
Но какво, ако го давате невалиден файл и функцията се случва да се върне фалшиви

304
00:26:36,810 --> 00:26:38,860
ако го премине невалиден файл?

305
00:26:38,860 --> 00:26:46,500
Ако просто правим == не сте диференциране на делото между невалиден файл и празен файл.

306
00:26:48,870 --> 00:26:51,350
Винаги използвайте ===.

307
00:26:55,690 --> 00:26:58,000
Това е всичко, от тези.

308
00:26:58,000 --> 00:27:01,660
>> Типът масив PHP, е различно от това, което сте свикнали в C.

309
00:27:01,660 --> 00:27:06,650
Всъщност, може да са забелязали това по-горе, когато видя, че това е от тип масив.

310
00:27:06,650 --> 00:27:15,640
Скоба синтаксис е ново от PHP 5.4, което е най-новата версия на PHP.

311
00:27:15,640 --> 00:27:36,960
Преди това винаги трябваше да се напише масив ("А" -> 1, "б" -> 2.

312
00:27:36,960 --> 00:27:41,160
Това беше конструктор за масив.

313
00:27:41,160 --> 00:27:45,950
PHP е най-накрая дойде около хубаво синтаксис само квадратните скоби,

314
00:27:45,950 --> 00:27:50,900
, която е толкова много по-добре от масив.

315
00:27:50,900 --> 00:27:54,480
Но като се има предвид PHP 5.4 е най-новата версия,

316
00:27:54,480 --> 00:27:59,090
може да срещнете места, които дори нямат PHP 5.3.

317
00:27:59,090 --> 00:28:08,220
През лятото ние се блъсна в този въпрос, където PHP 5.3 е това, което имахме на уреда,

318
00:28:08,220 --> 00:28:14,480
но сървърът, че ние разгърнати нашия клас книга и да представят и всички тези неща да

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

320
00:28:16,750 --> 00:28:23,060
Не знаейки това, ние разработихме в 5.3, избута до 5,4,

321
00:28:23,060 --> 00:28:25,660
и сега всички изведнъж никой от нашия код работи

322
00:28:25,660 --> 00:28:28,680
защото там се случи да има промени между 5,3 и 5,4

323
00:28:28,680 --> 00:28:31,030
, които не са обратно съвместими,

324
00:28:31,030 --> 00:28:35,770
и ние трябва да отида и да определи всички наши неща, които не работят за PHP 5.4.

325
00:28:39,210 --> 00:28:42,320
За този клас, тъй като уредът има PHP 5.4,

326
00:28:42,320 --> 00:28:45,490
това е съвършено глоба да използвате квадратни скоби.

327
00:28:47,240 --> 00:28:50,440
Но ако търсите неща из интернет,

328
00:28:50,440 --> 00:28:54,880
ако търсите някакъв вид на масива неща, най-вероятно ти започваш да се види

329
00:28:54,880 --> 00:29:02,020
магията от масив конструктор синтаксис, тъй като това е бил около тъй като PHP е роден

330
00:29:02,020 --> 00:29:07,340
и квадратни скоби е около продължение на последните няколко месеца

331
00:29:07,340 --> 00:29:10,020
или когато 5,4 се наоколо.

332
00:29:10,020 --> 00:29:12,710
Това е начина, по който индекс.

333
00:29:12,710 --> 00:29:30,610
Точно както в C как бихте индекс от квадратните скоби като масива $ [0], масива $ [1], масива $ [2],

334
00:29:30,610 --> 00:29:36,320
индекс на същия начин, ако се случи да има индекси се струни.

335
00:29:36,320 --> 00:29:40,440
Така че масива $ ["'] и $ масив [" б ".

336
00:29:40,440 --> 00:29:47,410
Масива $ [B]. Защо това да е грешно?

337
00:29:52,490 --> 00:29:59,870
Тя вероятно ще генерира предупреждение, но все още работи. PHP има тенденция да го направя.

338
00:29:59,870 --> 00:30:04,890
Тя има тенденция да само: "Отивам да ви предупреди за това, но аз съм просто ще продължа

339
00:30:04,890 --> 00:30:07,550
"И направя каквото мога."

340
00:30:07,550 --> 00:30:11,500
Тя вероятно ще се преведе това в низ,

341
00:30:11,500 --> 00:30:15,000
но е възможно, че в някакъв момент в миналото някой каза

342
00:30:15,000 --> 00:30:20,180
определят б, за да бъде "Здравей, свят".

343
00:30:20,180 --> 00:30:28,740
Така че сега б може да бъде постоянен и масива $ [B] всъщност ще се прави "Здравей, свят".

344
00:30:28,740 --> 00:30:32,380
Мисля, че в този момент, или поне нашите PHP настройки,

345
00:30:32,380 --> 00:30:37,870
ако се опитате да индекс в масив и този ключ не съществува, тя ще се провали.

346
00:30:37,870 --> 00:30:40,150
Аз не мисля, че просто ще ви предупредя.

347
00:30:40,150 --> 00:30:44,560
Или най-малкото можете да го настроите така, че да не само да ви предупредя, просто нагоре се провали.

348
00:30:44,560 --> 00:30:49,290
>> Начин да проверите, за да видите, ако има действително е такъв индекс е isset.

349
00:30:49,290 --> 00:30:54,690
Така isset ($ масив ['Hello World ") ще се върне фалшиви.

350
00:30:54,690 --> 00:30:59,160
isset ($ масив ['б']) ще се върне вярно.

351
00:31:06,830 --> 00:31:09,880
Можете да смесвате тези синтаксиса.

352
00:31:15,060 --> 00:31:22,440
Аз съм сигурен, че това, което ще сложи край на този масив е - Можем да го тестваме.

353
00:31:43,290 --> 00:31:45,700
О, имам нужда от PHPWord.

354
00:31:53,960 --> 00:32:00,260
Това е смесване на синтаксиса, където можете да уточни каква ключът е

355
00:32:00,260 --> 00:32:03,330
и не уточни какво е ключът.

356
00:32:03,330 --> 00:32:05,520
Така 3 тук е стойност.

357
00:32:05,520 --> 00:32:08,080
Не сте изрично подчерта ключовата му ще бъде.

358
00:32:08,080 --> 00:32:11,670
Какво мислите ключа му ще бъде?

359
00:32:11,670 --> 00:32:21,410
[Ученик] 0. >> Аз съм се познае 0 само защото е първият, който не са уточнени.

360
00:32:21,410 --> 00:32:23,500
Ние действително можем да направим няколко от тези случаи.

361
00:32:23,500 --> 00:32:28,030
Така print_r е да изписва рекурсивна. Тя ще отпечатате целия масив.

362
00:32:28,030 --> 00:32:32,700
Той ще отпечата подмасива на масива, ако имаше такива.

363
00:32:32,700 --> 00:32:36,630
Така print_r ($ масив); php.test.php.

364
00:32:36,630 --> 00:32:38,810
Тя не изглежда като тя го е дал 0.

365
00:32:38,810 --> 00:32:43,530
Всъщност е нещо, което трябва да имате предвид тук, но ние ще се върнем към него в секунда.

366
00:32:43,530 --> 00:32:45,850
Но какво ще стане, ако се случи да направи този индекс 1?

367
00:32:45,850 --> 00:32:51,170
PHP не прави разлика между струнни индекси и целочислените индекси,

368
00:32:51,170 --> 00:33:00,280
така че в този момент аз току-що определи индекс 1 и мога да направя както масива $ [1] и масива $ [1]

369
00:33:00,280 --> 00:33:06,250
и това ще бъде един и същ индекс и същ ключ.

370
00:33:06,250 --> 00:33:13,000
И сега какво мислиш, че 3 ще бъде? >> Студент [2]. >> Bowden] Аз съм се познае 2.

371
00:33:16,000 --> 00:33:18,690
Да. Това е 2.

372
00:33:18,690 --> 00:33:24,790
Какво ще стане, ако го е направил е 10, това е 4? Какво мислиш, че индексът на 3 ще бъде?

373
00:33:27,360 --> 00:33:29,110
Мисля 11.

374
00:33:29,110 --> 00:33:33,060
Моето предположение какво PHP - и аз мисля, че съм виждал това и преди -

375
00:33:33,060 --> 00:33:39,760
е просто следи от числов индекс, е използван досега.

376
00:33:39,760 --> 00:33:44,230
Той никога няма да се присвоява индекс на низ до 3. Тя винаги ще бъде числов индекс.

377
00:33:44,230 --> 00:33:47,690
Така че следи от най-високата е зададена досега, което се случва да бъде 10,

378
00:33:47,690 --> 00:33:52,540
и тя ще даде 11-3.

379
00:33:52,540 --> 00:34:02,110
Това, което казах преди, обърнете внимание на начина, по който тя се отпечатва този масив.

380
00:34:02,110 --> 00:34:06,850
Той отпечатва ключ 10, ключ 4, ключ 11, ключ г.

381
00:34:06,850 --> 00:34:09,790
Или дори да го направим -

382
00:34:15,760 --> 00:34:22,489
Предполагам, че не съм се на 0, но това е печат 1, 2, 3, 4.

383
00:34:22,489 --> 00:34:29,330
Какво ще стане, ако премина тук? Или нека включите тези две.

384
00:34:29,330 --> 00:34:31,940
Сега го отпечатва 2, 1, 3, 4.

385
00:34:31,940 --> 00:34:41,270
Масиви на PHP не са точно като редовен хеш таблица.

386
00:34:41,270 --> 00:34:45,570
Това е напълно разумно да се мисли за тях като хеш таблици 99% от времето.

387
00:34:45,570 --> 00:34:53,790
В хеш таблици на реда, в който са били вкарани неща няма смисъл.

388
00:34:53,790 --> 00:34:56,639
Така че веднага щом я поставете в хеш таблицата

389
00:34:56,639 --> 00:35:00,590
Предполагам, че няма свързан списък и може да се съди в свързан списък

390
00:35:00,590 --> 00:35:03,980
която е поставена на първо място.

391
00:35:03,980 --> 00:35:10,060
Но тук сме поставили 2 първото и го знае, когато това е печат на този масив, че 2 е на първо място.

392
00:35:10,060 --> 00:35:13,090
Тя не го отпечатате само в произволен ред.

393
00:35:13,090 --> 00:35:17,550
Техническа структура на данните, които тя използва, е подредена карта,

394
00:35:17,550 --> 00:35:24,690
така че карти ключовете за ценности и помни реда, в който бяха включени тези ключове.

395
00:35:24,690 --> 00:35:31,600
По същество това е някои усложнения, когато това е досадно действително -

396
00:35:31,600 --> 00:35:34,510
Да кажем, че имате масив 0, 1, 2, 3, 4, 5

397
00:35:34,510 --> 00:35:37,700
и искате да се индекс 2.

398
00:35:37,700 --> 00:35:47,750
Един от начините да го прави, нека да видим какво прилича.

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

400
00:35:50,410 --> 00:35:54,880
Отмяна на зададените случва с недефинирани променливи, така и индексите на масиви.

401
00:35:54,880 --> 00:35:58,630
Така че унищожен (масива $ [2]);

402
00:35:58,630 --> 00:36:03,430
Сега какво ще прилича? 2 е просто отиде, така че това е съвършено глоба.

403
00:36:03,430 --> 00:36:11,670
По-досадно е, ако искате неща, за да бъде като масив.

404
00:36:11,670 --> 00:36:14,910
Ще сложа случайни числа.

405
00:36:14,910 --> 00:36:20,400
Сега забележите индекси.

406
00:36:20,400 --> 00:36:26,860
Искам тя да бъде само като масив C, където той отива от 0 до дължина - 1

407
00:36:26,860 --> 00:36:30,810
и мога да превъртате над него като такъв.

408
00:36:30,810 --> 00:36:38,520
Но веднага след като унищожите втория индекс, това, което е в индекса 3 не се превърна в индекс 2.

409
00:36:38,520 --> 00:36:44,790
Вместо това, той просто премахва този индекс и сега да отидете 0, 1, 3, 4.

410
00:36:44,790 --> 00:36:48,740
Това е напълно разумно.

411
00:36:48,740 --> 00:36:53,950
Това е просто досадно и което трябва да направите неща като масив снаждане. Да.

412
00:36:53,950 --> 00:36:57,200
>> [Ученик] Какво ще се случи, ако сте имали за контур

413
00:36:57,200 --> 00:36:59,630
и искаш да отидеш над всички елементи?

414
00:36:59,630 --> 00:37:02,290
Когато го удари два, ще я отстъпиш някога?

415
00:37:02,290 --> 00:37:10,150
Итерации над масив. Има два начина, по които можете да го направите.

416
00:37:10,150 --> 00:37:12,770
Можете да използвате редовно за контур.

417
00:37:12,770 --> 00:37:22,000
Това е още една сложност на PHP.

418
00:37:22,000 --> 00:37:27,420
Повечето езици, бих казал, че има някаква дължина или лен или нещо

419
00:37:27,420 --> 00:37:30,470
посочва дължината на масива.

420
00:37:30,470 --> 00:37:32,820
В PHP брой.

421
00:37:32,820 --> 00:37:36,160
Така броят ($ масив); $ I + +)

422
00:37:36,160 --> 00:37:42,950
Нека просто печат ($ масив [I]);

423
00:37:45,920 --> 00:37:48,820
Notice: Undefined компенсира: 2.

424
00:37:48,820 --> 00:37:51,610
Това е просто ще се провалят.

425
00:37:51,610 --> 00:38:03,020
Това е причината, че за по-голямата си част, няма да е необходимо за обхождане на масив като този.

426
00:38:03,020 --> 00:38:07,110
То може да бъде преувеличено, но никога не трябва да обхождане на масив като това

427
00:38:07,110 --> 00:38:19,410
защото PHP предоставя foreach синтаксис, където foreach ($ масив $ елемент).

428
00:38:19,410 --> 00:38:31,830
Сега, ако се печата ($ позиция); - Ще го обсъдим а през втората - че работи перфектно глоба.

429
00:38:31,830 --> 00:38:38,960
Начинът, по който foreach работи е първият аргумент е масив, който сте итерации над.

430
00:38:38,960 --> 00:38:44,060
И вторият аргумент, т. чрез всяко преминаване на линия за

431
00:38:44,060 --> 00:38:52,690
ще поеме следващото нещо, което в масива. Така че не забравяйте масив има заповед.

432
00:38:52,690 --> 00:38:55,690
Първи път през за цикъла, т. ще бъде 123

433
00:38:55,690 --> 00:38:59,540
след това ще бъде 12 след това ще бъде 13 след това ще бъде 23 тогава той ще бъде 213.

434
00:38:59,540 --> 00:39:04,670
Нещата стават наистина странно, когато правиш нещо като foreach.

435
00:39:04,670 --> 00:39:07,480
Нека видим какво се случва, защото никога не трябва да направите това.

436
00:39:07,480 --> 00:39:13,320
Какво ще стане, ако ние унищожен (масива $ [1]);

437
00:39:20,410 --> 00:39:26,030
Това вероятно се очаква.

438
00:39:26,030 --> 00:39:30,950
Вие итерации през този масив, и всеки път, когато сте изключване на първия индекс.

439
00:39:30,950 --> 00:39:39,720
Така индекс 0, първото нещо, т. приема стойност 0, така че ще бъде 123.

440
00:39:39,720 --> 00:39:44,630
Но вътре за цикъл ние унищожен индекс 1, така че това означава, че 12 е отишъл.

441
00:39:44,630 --> 00:39:57,480
Така отпечатате. PHP_EOL.

442
00:39:57,480 --> 00:40:03,580
PHP_EOL е само нов ред, но това е технически по-преносим

443
00:40:03,580 --> 00:40:08,890
тъй като нови редове в Windows е различен от нови редове на Mac и UNIX.

444
00:40:08,890 --> 00:40:18,040
На Windows нов ред \ R \ N, докато навсякъде другаде тя е склонна само за да бъде \ N.

445
00:40:18,040 --> 00:40:25,150
PHP_EOL е конфигуриран така, че да използва, независимо от нов ред на вашата система е.

446
00:40:25,150 --> 00:40:29,310
Така отпечатате. Нека не print_r ($ масив) в края.

447
00:40:32,830 --> 00:40:37,390
Нямах представа, че това ще бъде поведението.

448
00:40:41,740 --> 00:40:48,960
Точка все още заема на стойност 12, макар и да унищожите 12, преди да сме някога трябва да го от масива.

449
00:40:52,770 --> 00:40:58,840
Не вземайте думата ми за това, но тя изглежда като foreach създава копие на масива

450
00:40:58,840 --> 00:41:02,160
и след това т. поема всички стойности на това копие.

451
00:41:02,160 --> 00:41:07,760
Така че, дори ако промените масиви в линия за

452
00:41:07,760 --> 00:41:17,240
това не им пука. Позиция ще поеме първоначалните стойности.

453
00:41:17,240 --> 00:41:19,240
Нека се опитаме изключване.

454
00:41:19,240 --> 00:41:24,460
Какво ще стане, ако това е масива $ [1] = "Здравей";

455
00:41:24,460 --> 00:41:31,770
Въпреки, че ние поставяме "здравей" в масива, никога т. поема тази стойност.

456
00:41:31,770 --> 00:41:37,430
Има и друг синтаксис, за да foreach вериги

457
00:41:37,430 --> 00:41:45,900
, където да поставите две променливи, разделени със стрелка.

458
00:41:45,900 --> 00:41:49,680
Тази първа променлива ще бъде ключа на тази стойност,

459
00:41:49,680 --> 00:41:53,050
и това втората променлива ще бъде точно същата позиция.

460
00:41:53,050 --> 00:42:01,610
Това е безинтересно тук, но ако се върнем към нашия случай "а" -> 1,

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

462
00:42:06,090 --> 00:42:14,470
тук, ако ние просто за всеки масив като точка превъртите, т. ще бъде едно всеки един момент.

463
00:42:14,470 --> 00:42:18,170
Но ако искате да знаете ключ, свързан с тази позиция

464
00:42:18,170 --> 00:42:25,230
след това правим като ключ - Над точка.

465
00:42:25,230 --> 00:42:31,980
Така че сега можем да направим печат ($ ключ. ":".

466
00:42:31,980 --> 00:42:39,380
Сега е итерации и отпечатване на всеки клавиш и свързаните с нея стойност.

467
00:42:39,380 --> 00:42:47,030
>> Допълнителен нещо, което можем да направим в foreach вериги, можете да видите този синтаксис.

468
00:42:47,030 --> 00:42:54,770
Амперсанди пред имената на променливите са склонни да бъдат, как PHP прави препратки.

469
00:42:54,770 --> 00:43:00,460
Когато препратките са много подобни на указатели,

470
00:43:00,460 --> 00:43:04,820
не сте указатели, така че никога не се справят с памет директно.

471
00:43:04,820 --> 00:43:12,620
Но имате препратки, където 1 променливата се отнася до същото като друга променлива.

472
00:43:12,620 --> 00:43:21,450
Вътре тук, нека да направим $ елемент. Нека се върнем към 1, 10.

473
00:43:21,450 --> 00:43:28,800
Нека да направим $ т. + +, че все още съществува в PHP. Можете да го направите + +.

474
00:43:28,800 --> 00:43:38,260
php.test.php. Аз трябва да го отпечатате. print_r ($ масив);

475
00:43:38,260 --> 00:43:42,730
Ние печат 2, 11.

476
00:43:42,730 --> 00:43:49,560
Ако току-що бях направил foreach ($ масив $ позиция) елемент ще бъде на стойност 1

477
00:43:49,560 --> 00:43:54,190
първи път през примката. Тя ще увеличите 1 до 2 и след това сме готови.

478
00:43:54,190 --> 00:43:57,260
Тогава той ще мине през второто преминаване на цикъла и тази позиция е 10.

479
00:43:57,260 --> 00:44:01,570
Тя стъпки т. 11, и това е просто изхвърля.

480
00:44:01,570 --> 00:44:06,670
Тогава ние print_r ($ масив), и да видим, че това е само 1, 10.

481
00:44:06,670 --> 00:44:09,070
Така че увеличение, което направихме, е загубен.

482
00:44:09,070 --> 00:44:13,410
Но foreach ($ масив, както и $ т.)

483
00:44:13,410 --> 00:44:21,910
сега тази позиция е една и съща позиция, тъй като това тук. Това е едно и също нещо.

484
00:44:21,910 --> 00:44:26,820
Значи $ т. + + променя масив 0.

485
00:44:29,330 --> 00:44:41,850
Принцип, можете да направите $ к -> $ позиция и можете да направите $ масив [к] + +;

486
00:44:41,850 --> 00:44:48,650
>> Така че друг начин за това, ние сме свободни да променят т.,

487
00:44:48,650 --> 00:44:54,070
но това няма да промени нашата оригинална масив.

488
00:44:54,070 --> 00:44:59,720
Но ако използваме к, което е нашата основна, тогава можем просто индекс в нашия масив използвате този клавиш

489
00:44:59,720 --> 00:45:01,530
и нарастване.

490
00:45:01,530 --> 00:45:05,410
Това по-пряко променя нашата оригинална масив.

491
00:45:05,410 --> 00:45:10,690
Можете дори да направите това, ако по някаква причина искаш възможност за промяна -

492
00:45:10,690 --> 00:45:13,510
Всъщност, това е напълно разумен.

493
00:45:13,510 --> 00:45:16,020
Вие не искате да трябва да напишете масива $ [$ к] + +,

494
00:45:16,020 --> 00:45:27,890
просто исках да напиша $ т. + + но все пак исках да кажа, ако ($ к === "а")

495
00:45:27,890 --> 00:45:30,620
след това нарастване позиция и след това да отпечатате нашия масив.

496
00:45:30,620 --> 00:45:36,290
И сега какво да очакваме print_r да направя? Какви ценности трябва да бъдат отпечатани?

497
00:45:36,290 --> 00:45:43,770
[Ученик] 2 и 10. >> [Bowden] Само ако ключът е "да ние всъщност отпечатате.

498
00:45:51,940 --> 00:45:55,670
>> Може би много рядко, ако изобщо някога, ще трябва да се определи функции в PHP,

499
00:45:55,670 --> 00:46:03,370
но вие може да видите нещо подобно, можете да зададете функция като функция това, което.

500
00:46:03,370 --> 00:46:09,900
Обикновено бих казал ($ Foo, бар) и след това го определят, за да бъде каквото.

501
00:46:09,900 --> 00:46:17,580
Но ако направя това, то това означава, че каквото и призовава каквото,

502
00:46:17,580 --> 00:46:25,110
каквото и призовава Баз, така че първият аргумент на Баз може да бъде променена.

503
00:46:25,110 --> 00:46:38,100
Нека да направим $ Foo + +;

504
00:46:38,100 --> 00:46:48,020
и отвътре от тук нека да направим Баз ($ позиция);

505
00:46:48,020 --> 00:46:52,250
Сега ние призоваваме функция.

506
00:46:52,250 --> 00:46:56,780
Аргументът е взето чрез препратка, което означава, че ако ние го променят

507
00:46:56,780 --> 00:47:00,390
промяна на нещо, което е приет.

508
00:47:00,390 --> 00:47:04,420
И отпечатване на това, което очакваме - освен ако аз се обърках синтаксис - имаме 2, 11,

509
00:47:04,420 --> 00:47:06,300
така че всъщност се увеличава.

510
00:47:06,300 --> 00:47:08,790
Забележите, че се нуждаят от препратки в две места.

511
00:47:08,790 --> 00:47:13,050
Какво ще стане, ако го направя това? Какво означава това?

512
00:47:13,050 --> 00:47:15,810
[Ученик] ще се промени. >> Да.

513
00:47:15,810 --> 00:47:18,290
Позиция е просто копие на стойност в масива.

514
00:47:18,290 --> 00:47:26,670
Така че позиция ще се промени на 2, но масива "а"] все още ще бъде 1.

515
00:47:26,670 --> 00:47:32,560
Или какво, ако направя това?

516
00:47:32,560 --> 00:47:39,260
Сега е изпратен като копие на Баз.

517
00:47:39,260 --> 00:47:46,330
Така че копие на аргумента ще се увеличи на 2,

518
00:47:46,330 --> 00:47:49,240
но самия елемент никога не е бил увеличен до 2.

519
00:47:49,240 --> 00:47:52,880
И т. е същото като масив скоба каквото

520
00:47:52,880 --> 00:47:55,380
така че масив никога не се увеличава.

521
00:47:55,380 --> 00:47:57,960
Така че и двете тези места, които се нуждаят от нея.

522
00:47:57,960 --> 00:48:03,830
>> PHP обикновено е доста умен за това.

523
00:48:03,830 --> 00:48:06,570
Може би си мислите, Искам да премине чрез позоваване

524
00:48:06,570 --> 00:48:09,560
Това всъщност е въпрос на един от psets.

525
00:48:09,560 --> 00:48:14,480
Това беше questions.txt нещо, където се казва,

526
00:48:14,480 --> 00:48:19,280
Защо може да искате да премине тази структура чрез препратка?

527
00:48:19,280 --> 00:48:21,250
Какъв беше отговорът на този въпрос?

528
00:48:21,250 --> 00:48:25,100
[Ученик] Така че не е нужно да копирате нещо голямо. >> Да.

529
00:48:25,100 --> 00:48:32,920
Структура може да бъде произволно голям и, когато преминат структура като аргумент

530
00:48:32,920 --> 00:48:36,800
тя трябва да копира цялата тази структура, за да го предаде на функцията,

531
00:48:36,800 --> 00:48:40,410
докато ако просто минават структура чрез позоваване

532
00:48:40,410 --> 00:48:46,530
след това просто трябва да копира 4-байтов адрес като аргумент на функцията.

533
00:48:48,520 --> 00:48:52,320
PHP е малко по-умен от това.

534
00:48:52,320 --> 00:49:00,650
Ако имам някои функции и предам масив от 1000 неща,

535
00:49:00,650 --> 00:49:03,990
това означава, че ще трябва да копирате всички 1000 от тези неща

536
00:49:03,990 --> 00:49:10,450
да премине в функцията? То не трябва да направи това незабавно.

537
00:49:10,450 --> 00:49:15,940
Ако вътрешността на тази функция никога всъщност променя Foo,

538
00:49:15,940 --> 00:49:22,660
така че ако ($ Foo === "здравей") връщане вярно;

539
00:49:22,660 --> 00:49:26,460
Забележете, ние всъщност никога не се е променил аргумент вътрешността на тази функция,

540
00:49:26,460 --> 00:49:30,010
което означава, че каквото и да е приет, тъй като никога не Foo трябва да бъдат копирани

541
00:49:30,010 --> 00:49:32,100
, защото не е изменение.

542
00:49:32,100 --> 00:49:39,240
Така че PHP работи е аргументи винаги се предават по референция

543
00:49:39,240 --> 00:49:42,170
докато всъщност се опитват да го променят.

544
00:49:42,170 --> 00:49:51,160
Сега, ако кажа, $ Foo + +; сега ще направи копие на оригиналната Foo и промяна на копие.

545
00:49:51,160 --> 00:49:53,090
Това спестява доста време.

546
00:49:53,090 --> 00:49:58,210
Ако никога не сте докосването на тази масивна решетка, никога няма да го променят,

547
00:49:58,210 --> 00:50:02,360
че не е необходимо да се направи копие,

548
00:50:02,360 --> 00:50:06,640
като има предвид, че, ако ние просто сложи този символ, това означава, че дори не го копирате

549
00:50:06,640 --> 00:50:08,640
Дори и да го променят.

550
00:50:08,640 --> 00:50:10,680
Това поведение се нарича копие на запис.

551
00:50:10,680 --> 00:50:17,380
Ще го видите и на други места, особено ако сте се разбира операционната система.

552
00:50:17,380 --> 00:50:23,880
Копиране на запис е доста обичайната схема, при която не е нужно да се направи копие на нещо

553
00:50:23,880 --> 00:50:26,650
освен ако не е действително се променя. Да.

554
00:50:26,650 --> 00:50:29,520
[Ученик] Какво ще стане, ако сте имали увеличение вътре в теста,

555
00:50:29,520 --> 00:50:33,700
така че само 1 елемент от 1000 ще трябва да се промени?

556
00:50:33,700 --> 00:50:38,770
Не съм сигурен.

557
00:50:38,770 --> 00:50:51,250
Мисля, че ще копира цялото нещо, но това е възможно, то е достатъчно умен, че -

558
00:50:51,250 --> 00:51:00,020
Всъщност, това, което си мисля, е, представете си, че е масив, който изглежда така: $ array2 = [

559
00:51:00,020 --> 00:51:11,000
Тогава индекс "а" е масив от [1 2 3 4], а индексът "б" е набор от каквото.

560
00:51:11,000 --> 00:51:15,380
Имам нужда от запетаи между всички тези. Представете си, има запетаи.

561
00:51:15,380 --> 00:51:21,210
Тогава "С" е на стойност 3.

562
00:51:24,210 --> 00:51:26,290
Добре.

563
00:51:26,290 --> 00:51:33,440
Сега нека да кажем, че правим Баз ($ array2);

564
00:51:33,440 --> 00:51:36,540
където Баз не вземе това по референция.

565
00:51:43,510 --> 00:51:47,370
Значи $ Foo ['в'] + +;

566
00:51:47,370 --> 00:51:52,340
Това е такъв пример, където преминава array2 като аргумент

567
00:51:52,340 --> 00:51:57,010
и след това го променя конкретен индекс на масива от него увеличаване.

568
00:51:57,010 --> 00:52:01,090
Аз честно казано нямам представа какво PHP ще направи.

569
00:52:01,090 --> 00:52:07,200
Тя може лесно да се направи копие на цялото нещо, но ако тя е умна,

570
00:52:07,200 --> 00:52:15,030
, че ще направи копие на тези клавиши, когато това ще има различния си стойност

571
00:52:15,030 --> 00:52:20,620
но това все още може да сочат към един и същ масив 1,2,3,4

572
00:52:20,620 --> 00:52:22,320
и това все още може да сочат към един и същ масив.

573
00:52:22,320 --> 00:52:24,170
Ще го IPAD.

574
00:52:28,900 --> 00:52:45,950
Минаваме в този масив, където този човек точки 3, този човек [1,2,3,4],

575
00:52:45,950 --> 00:52:51,350
Този човек пункта до [34] ...

576
00:52:51,350 --> 00:52:58,590
Сега, когато сме я предава в Баз, ние сме промяна.

577
00:52:58,590 --> 00:53:03,550
Ако PHP е интелигентен, той може просто да направя -

578
00:53:11,850 --> 00:53:18,230
Ние все още трябва да копирате някакъв спомен, но ако не бяха тези огромни вложени подмасива

579
00:53:18,230 --> 00:53:21,560
ние не трябва да копирате тези.

580
00:53:21,560 --> 00:53:27,530
Аз не знам дали това е, което го прави, но мога да си представя да го прави, че.

581
00:53:29,050 --> 00:53:36,690
Това също е доста голямо предимство на C PHP.

582
00:53:36,690 --> 00:53:40,320
>> PHP прави живота много по-лесно за много неща,

583
00:53:40,320 --> 00:53:45,060
но някак си нямат абсолютно никаква представа колко добре ще изпълнява

584
00:53:45,060 --> 00:53:52,530
защото нямам идея под капака, когато прави тези копия на неща,

585
00:53:52,530 --> 00:53:55,170
о, е, че ще бъде постоянно копие от време,

586
00:53:55,170 --> 00:54:01,140
просто няма да се промени едно показалеца, ще бъде абсурдно трудно линеен копие?

587
00:54:01,140 --> 00:54:03,000
Какво ще стане, ако не може да намери пространство?

588
00:54:03,000 --> 00:54:06,760
Ли трябва да тече събиране на отпадъци, за да получите повече пространство?

589
00:54:06,760 --> 00:54:11,210
Събиране на боклука може да взема произволно дълго.

590
00:54:11,210 --> 00:54:13,600
В C не е нужно да се притеснявате за тези неща.

591
00:54:13,600 --> 00:54:19,780
Всеки един ред пишете в голяма степен причината за това как тя ще изпълнява.

592
00:54:26,800 --> 00:54:29,150
>> Нека да погледнем назад към тези.

593
00:54:35,400 --> 00:54:37,520
Колко хубаво е, че не е нужно да се справят с хеш функции,

594
00:54:37,520 --> 00:54:39,010
свързани списъци, или нещо подобно?

595
00:54:39,010 --> 00:54:41,980
Тъй като работата с хеш таблици е толкова лесно сега, тук е забавно пъзел да работят.

596
00:54:41,980 --> 00:54:45,920
Отворете файл, наречен unique.php и в него се напише програма PHP

597
00:54:45,920 --> 00:54:48,330
(Известен също като "скрипт").

598
00:54:48,330 --> 00:54:55,700
Ние сме склонни да ги наричат ​​скриптове, ако те са кратки неща, които се движат в командния ред.

599
00:54:55,700 --> 00:55:02,950
По принцип, всеки език, който не се съставят, а ти започваш да стартирате изпълнимия

600
00:55:02,950 --> 00:55:05,920
в командния ред, можете да се обадите на този скрипт изпълним.

601
00:55:05,920 --> 00:55:08,510
Също толкова добре мога да се напише програма на C, която прави това,

602
00:55:08,510 --> 00:55:12,300
но аз не го наричат ​​скрипт, тъй като за първи път го компилирате и след това пуснете на двоичен.

603
00:55:12,300 --> 00:55:15,480
Но тази програма PHP отиваме да се обадя на сценария.

604
00:55:15,480 --> 00:55:23,830
Или ако го е написал в Python или Perl или Node.js или някое от тези неща,

605
00:55:23,830 --> 00:55:26,500
ние ще ги наричаме всички скриптове, защото ги стартирате командния ред

606
00:55:26,500 --> 00:55:30,040
но ние не ги компилирате.

607
00:55:30,860 --> 00:55:33,400
Можем да го направим доста бързо.

608
00:55:36,960 --> 00:55:41,480
Ние няма да използвате argv. Нека просто се взриви през тази.

609
00:55:41,480 --> 00:55:45,730
Наречете го уникален, напишете програма.

610
00:55:45,730 --> 00:55:49,400
Може да се предположи, че на входа ще съдържа по една дума на ред.

611
00:55:49,400 --> 00:55:52,020
Всъщност, argv ще бъде доста тривиално да използвате.

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

613
00:56:08,550 --> 00:56:13,750
Първото нещо, което за първи път, ние искаме да проверим дали са преминали един от командния ред аргумент.

614
00:56:13,750 --> 00:56:20,900
Точно както бихте очаквали argc и argv в C, ние все още имаме тези в PHP.

615
00:56:20,900 --> 00:56:33,900
Така че, ако ($ argc! == 2), тогава няма да се занимава с печатането на съобщение или нещо.

616
00:56:33,900 --> 00:56:37,340
Аз просто ще излезете, код на грешка 1.

617
00:56:37,340 --> 00:56:41,340
Аз също може да се върне 1.

618
00:56:41,340 --> 00:56:53,180
Рядко в PHP са в това състояние, къде сме ние -

619
00:56:53,180 --> 00:56:57,820
Обикновено сте функция, наречена от функция, наречена от функция, наречена от функция.

620
00:56:57,820 --> 00:57:02,070
И ако нещо се обърка и просто искате да излезете от всичко изцяло,

621
00:57:02,070 --> 00:57:05,680
изход просто приключва програмата.

622
00:57:05,680 --> 00:57:08,160
Това съществува и в C.

623
00:57:08,160 --> 00:57:10,700
Ако сте във функция във функция във функция във функция

624
00:57:10,700 --> 00:57:17,540
и искате просто да убие програмата, можете да се обадите на излизане и тя просто ще излезете.

625
00:57:17,540 --> 00:57:23,120
Но в PHP е още по-рядък, че ние сме в това най-високо ниво.

626
00:57:23,120 --> 00:57:26,090
Обикновено сме вътре някаква функция, така че ние наричаме излизане

627
00:57:26,090 --> 00:57:29,650
, така че ние не трябва да се върне до 1 нещо, което след това осъзнава, има грешка

628
00:57:29,650 --> 00:57:32,270
така че се връща, ако, която признава, че е грешка.

629
00:57:32,270 --> 00:57:35,270
Ние не искаме да се справим с това, така че EXIT (1);

630
00:57:35,270 --> 00:57:38,240
възвръщаемост (1), в този случай би било равносилно.

631
00:57:38,240 --> 00:57:44,000
>> Тогава това, което искате да отворите искаме да fopen.

632
00:57:44,000 --> 00:57:46,760
Аргументите ще изглеждат доста сходни.

633
00:57:46,760 --> 00:57:51,600
Ние искаме да fopen ($ argv [1], и ние искаме да го отворите за четене.

634
00:57:51,600 --> 00:57:55,720
Това връща ресурс, който отива да се обадя е.

635
00:57:55,720 --> 00:58:02,180
Това изглежда доста сходен как C го прави, освен ние не трябва да се каже * FILE.

636
00:58:02,180 --> 00:58:06,170
Вместо това, ние просто да кажем $ е. Добре.

637
00:58:06,170 --> 00:58:17,190
Всъщност мисля, че това дори ни подсказва да функционира PHP файл, наречен. PHP файл.

638
00:58:17,190 --> 00:58:23,990
Това ще направи, е да прочетете целия файл в масив.

639
00:58:23,990 --> 00:58:29,770
Ти дори не трябва да го fopen. Това ще направи това за вас.

640
00:58:37,450 --> 00:58:43,700
Значи $ линии = файл ($ argv [1]);

641
00:58:43,700 --> 00:58:49,680
Сега всички редове от файла са в линии. Сега искаме да сортирате линии.

642
00:58:49,680 --> 00:58:52,180
Как можем да сортирате редове?

643
00:58:52,180 --> 00:58:54,920
Ние да сортирате линии.

644
00:58:54,920 --> 00:58:58,080
И сега можем да ги отпечатате или каквото.

645
00:58:58,080 --> 00:59:05,580
Вероятно най-лесният начин е foreach ($ линии, като $ ред) ехо $ ред;

646
00:59:05,580 --> 00:59:10,960
[Ученик] не бихме дори пресичат линии чрез съотнасяне нещо в вид?

647
00:59:10,960 --> 00:59:28,850
Това е мястото, където вид да бъдат определени като функция сортиране (& $ масив).

648
00:59:28,850 --> 00:59:32,650
Когато се обадите функцията, която не се предава по референция.

649
00:59:32,650 --> 00:59:36,900
Това е функция, която се определя като като препратка.

650
00:59:36,900 --> 00:59:40,900
Това всъщност е точно какво се е объркало

651
00:59:40,900 --> 00:59:46,220
когато ние поставяме всичко за нашите сървъри, когато отидохме от 05.03-05.04.

652
00:59:46,220 --> 00:59:53,800
До 5,4, това е напълно разумен.

653
00:59:53,800 --> 00:59:58,740
Функция не се очаква да го вземе като отправна точка, но можете да го предадете като позоваването

654
00:59:58,740 --> 01:00:02,860
така че ако функцията се случи да го променят, тя все още е модифициран.

655
01:00:02,860 --> 01:00:05,850
Считано от 5.4, не би трябвало да направите това.

656
01:00:05,850 --> 01:00:11,740
Така че сега само начина, по който преминават чрез позоваване е, ако функцията изрично го прави.

657
01:00:11,740 --> 01:00:19,840
Ако не искате да го промените, тогава вие трябва да направите $ копие = $ линии и копиране на прохода.

658
01:00:19,840 --> 01:00:24,820
Така че сега линии ще бъдат запазени и копие ще се промени.

659
01:00:27,670 --> 01:00:31,460
php.unique.php. Може би щях да побъркани нещо.

660
01:00:31,460 --> 01:00:33,190
Неочаквано "вид".

661
01:00:38,320 --> 01:00:43,850
Ще бъде нещо, което прави това за нас.

662
01:00:43,850 --> 01:00:45,820
Тя дори не е там.

663
01:00:45,820 --> 01:00:52,140
Забележете, когато четете ръководството, че първият аргумент се очаква да бъде масив

664
01:00:52,140 --> 01:00:56,490
и е взето по референция.

665
01:00:58,160 --> 01:01:03,540
Защо това се оплакват с мен? Защото имам тази функция вид все още тук, че аз не искам.

666
01:01:03,540 --> 01:01:09,210
Добре, php.unique.php. Не съм го давате аргумент, защото не е нужно файл.

667
01:01:09,210 --> 01:01:13,560
Това е php.unique.php на test.php.

668
01:01:13,560 --> 01:01:19,080
Ето test.php всички отпечатани в хубаво подредени за.

669
01:01:19,080 --> 01:01:24,600
Забележете, че подредени ред е малко странно за код на файла

670
01:01:24,600 --> 01:01:27,460
защото всички от нашите празни редове ще дойдат първо

671
01:01:27,460 --> 01:01:30,190
след това ще дойде на едно ниво вдлъбнатини

672
01:01:30,190 --> 01:01:33,360
след това идват на нашите не вдлъбнатини.

673
01:01:33,360 --> 01:01:38,620
Да. >> [Ученик] Така за изходния код не е приет чрез препратка?

674
01:01:38,620 --> 01:01:42,240
Е, че обикновено се предават по стойност?

675
01:01:42,240 --> 01:01:50,240
Bowden] Когато се обадите функция, тя никога не определя дали се предават по референция.

676
01:01:50,240 --> 01:01:53,960
Това е дефиницията на функцията, който определя дали се предават по референция.

677
01:01:53,960 --> 01:01:59,450
И гледам в дефиницията на функцията на сортиране или просто търсите това,

678
01:01:59,450 --> 01:02:02,820
е необходимо аргумент по референция.

679
01:02:02,820 --> 01:02:07,160
Така че, независимо от това дали искате да го вземе чрез препратка, тя не е по референция.

680
01:02:07,160 --> 01:02:10,200
Той променя масива на място.

681
01:02:10,200 --> 01:02:17,400
Това просто не е позволено. Не ти е позволено да направят това. >> [Ученик] О, добре.

682
01:02:17,400 --> 01:02:22,410
[Bowden] Това, нещо ще отнеме линии чрез препратка и го променете.

683
01:02:22,410 --> 01:02:26,850
И отново, ако не искате да направите това, можете да направите копие на сортиране.

684
01:02:26,850 --> 01:02:35,850
Дори и в този случай, копие всъщност не е копие на линиите.

685
01:02:35,850 --> 01:02:40,620
Тя просто се насочва към едно и също нещо, докато не стане промяна,

686
01:02:40,620 --> 01:02:44,430
където първият ще се промени в нещо функция,

687
01:02:44,430 --> 01:02:50,940
, защото това е копие при запис, сега се случва да се направи копие на копие.

688
01:02:57,500 --> 01:03:04,250
Можете да направите това. Това е другото място, където можете да видите амперсанд.

689
01:03:04,250 --> 01:03:07,190
Можете да я видите в примки foreach, можете да го видите в декларации на функциите,

690
01:03:07,190 --> 01:03:10,040
и вие я виждате, когато просто възлагане променливи.

691
01:03:10,040 --> 01:03:12,350
Сега сме постигнали нищо по този начин

692
01:03:12,350 --> 01:03:15,600
защото копиране и линии са буквално едно и също нещо.

693
01:03:15,600 --> 01:03:19,940
Можете да използвате линии и да копирате взаимозаменяеми.

694
01:03:19,940 --> 01:03:25,430
Можете да направите унищожен ($ копие); и че не се премахват линии,

695
01:03:25,430 --> 01:03:29,120
просто губите препратка към едно и също нещо.

696
01:03:29,120 --> 01:03:33,440
Така че от тази гледна точка, сега линии е единственият начин, по който можете да получите достъп линии.

697
01:03:36,450 --> 01:03:38,770
>> Въпроси?

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

699
01:03:42,460 --> 01:03:45,880
[Ученик] Напълно извън темата, но вие не трябва да затворите PHP - >> не.

700
01:03:45,880 --> 01:03:47,730
Добре.

701
01:03:47,730 --> 01:03:53,790
[Bowden аз ще отида толкова далеч, че да кажа, че е лоша практика да ги затвори.

702
01:03:53,790 --> 01:03:57,580
Това вероятно е преувеличено, особено в скрипт,

703
01:03:57,580 --> 01:04:03,740
но нека видим какво ще стане, ако направя това.

704
01:04:03,740 --> 01:04:08,890
Това не е направил нищо. Какво става, ако исках - [въздишки]

705
01:04:13,870 --> 01:04:16,960
Трябва да премине аргумент.

706
01:04:19,000 --> 01:04:22,050
Застреляй. Обадих се правилно.

707
01:04:24,340 --> 01:04:28,310
Така php.unique.php с аргумент.

708
01:04:28,310 --> 01:04:30,980
Сега дори не е необходимо това.

709
01:04:34,520 --> 01:04:37,740
Ще предам валиден аргумент.

710
01:04:37,740 --> 01:04:42,050
Това отпечатан каквото и да е печат.

711
01:04:45,260 --> 01:04:50,080
Аз печат копие и копие не съществува. Така линии.

712
01:04:53,650 --> 01:04:58,270
Отпечатва всичко, и след това да забележите, всички тези боклуци тук,

713
01:04:58,270 --> 01:05:06,690
защото в PHP нещо, което е извън PHP тагове

714
01:05:06,690 --> 01:05:09,520
е просто ще бъдат отпечатани буквално.

715
01:05:09,520 --> 01:05:18,050
Ето защо HTML, това е толкова хубаво, че мога да направя дивизия дрън, дрън, дрън клас или каквото,

716
01:05:18,050 --> 01:05:25,140
дрън, дрън, дрън и след това да се направят някои PHP код, а след направим DIV края.

717
01:05:25,140 --> 01:05:36,460
И сега отпечатване на това аз да си взема хубаво дивизия до върха, всичко, което PHP печатни, DIV в дъното.

718
01:05:36,460 --> 01:05:43,510
Катастрофални, когато нещо подобно се случи, което е доста често срещано,

719
01:05:43,510 --> 01:05:47,930
само едно бездомно нов ред в долната част на файла.

720
01:05:47,930 --> 01:05:50,940
Може би не мисля, че това ще бъде, че голяма сделка

721
01:05:50,940 --> 01:05:58,660
докато не отчетем факта, че с браузъри -

722
01:05:58,660 --> 01:06:03,880
>> Как пренасочва работа или по принцип какъвто и заглавията работа,

723
01:06:03,880 --> 01:06:07,980
когато правите връзка към уеб сайт и го изпраща обратно всички тези горни и неща

724
01:06:07,980 --> 01:06:12,020
като отговор 200 или отговор, за пренасочване или каквото,

725
01:06:12,020 --> 01:06:18,230
заглавията са валидни само до първия байт данни се изпраща.

726
01:06:18,230 --> 01:06:23,140
Можете да пренасочите хиляди пъти, но веднага след като първи байт данни се изпраща

727
01:06:23,140 --> 01:06:26,120
не би трябвало да се пренасочат отново.

728
01:06:26,120 --> 01:06:31,860
>> Ако имате бездомно ред в долната част на файла

729
01:06:31,860 --> 01:06:37,260
и нека кажем, че и след това искате да използвате тази функция -

730
01:06:41,580 --> 01:06:52,870
Да кажем, че това е друг файл, който е index.php и require_once нещо -

731
01:06:52,870 --> 01:06:56,920
Не мога да мисля за добър пример за това.

732
01:06:56,920 --> 01:07:04,740
Въпросът се случва, когато получава отекна тази линия в долната част.

733
01:07:04,740 --> 01:07:08,660
Не искам нищо да са отекна още.

734
01:07:10,820 --> 01:07:15,700
Въпреки, че не е имал намерение нещо да се отекна, нещо, което се отекна

735
01:07:15,700 --> 01:07:17,990
И така, сега не би трябвало да изпрати повече заглавията

736
01:07:17,990 --> 01:07:20,030
и ти започваш да получавам оплаквания.

737
01:07:22,170 --> 01:07:24,420
Ти просто не се нуждаят от тези затварящи тагове.

738
01:07:24,420 --> 01:07:27,420
Ако имате намерение да правите нещо с HTML -

739
01:07:27,420 --> 01:07:30,490
и това е напълно разумно да се направи тук DIV

740
01:07:30,490 --> 01:07:39,450
и след това в този момент може или не може да ги включи.

741
01:07:39,450 --> 01:07:41,590
Всъщност няма значение.

742
01:07:41,590 --> 01:07:45,450
Но в PHP скриптове е рядкост да го затворите.

743
01:07:45,450 --> 01:07:50,400
Когато всичко е PHP, абсолютно всичко,

744
01:07:50,400 --> 01:07:55,460
наистина не трябва да го затворите / не трябва да го затворите.

745
01:08:02,030 --> 01:08:05,720
>> Справяне със струни е много по-хубав, отколкото в C.

746
01:08:05,720 --> 01:08:09,470
В PHP можете да зададете низ с единични или двойни кавички.

747
01:08:09,470 --> 01:08:12,820
С единични кавички не можете да използвате "бягство" последователности.

748
01:08:12,820 --> 01:08:17,640
Постоянно избяга, дрън, дрън, дрън.

749
01:08:19,920 --> 01:08:24,010
Така ФОРМАТ е много рядко в PHP.

750
01:08:24,010 --> 01:08:32,290
Предполагам, че ще използва ФОРМАТ ако исках да направя подобно нещо - в pset 5 sprintf или каквото сте използвали.

751
01:08:32,290 --> 01:08:36,060
Но вие искате да направите 001.jpg и 002.jpg.

752
01:08:36,060 --> 01:08:40,300
Така че за такова нещо, където аз всъщност искам да форматирате текста, бих използвал ФОРМАТ.

753
01:08:40,300 --> 01:08:44,689
Но иначе бих просто използвайте конкатенация на низ.

754
01:08:44,689 --> 01:08:47,000
Аз никога не използва ФОРМАТ.

755
01:08:49,229 --> 01:09:00,170
Ние сме просто диференциране на информация между единични кавички и двойни кавички.

756
01:09:00,170 --> 01:09:07,490
Най-голямата разлика е, че единични кавички, то ще бъдат отпечатани буквално.

757
01:09:07,490 --> 01:09:15,390
Не е Чар тип данни в PHP, за разлика от C, така че това е еквивалентно на това.

758
01:09:15,390 --> 01:09:17,970
И двамата са струни.

759
01:09:17,970 --> 01:09:29,180
И хубавото единични струни цитат е, че може да се каже "Здравей, свят!" дрън, дрън, дрън,

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

761
01:09:33,340 --> 01:09:38,260
Какво се случва, когато отпечатате това е, че ще го отпечатате буквално.

762
01:09:38,260 --> 01:09:40,680
Да се ​​отървете от всички на нашите неща.

763
01:09:40,680 --> 01:09:44,700
Така ехо $ str1;

764
01:09:48,569 --> 01:09:56,570
Той буквално отпечатан всички тези неща: доларови знаци,

765
01:09:56,570 --> 01:09:58,770
наклонена черта N, който бихте мисля, че би било знак за нов ред -

766
01:09:58,770 --> 01:10:01,500
всички тези неща го отпечатва буквално.

767
01:10:01,500 --> 01:10:05,650
Единственото нещо, което трябва да избягат са единични кавички

768
01:10:05,650 --> 01:10:09,470
защото в противен случай би помислил, че ще затвори единични кавички.

769
01:10:09,470 --> 01:10:15,050
Двойни кавички, съвсем различно.

770
01:10:20,300 --> 01:10:25,870
Вече виждаме оцветяване на синтаксиса ни cluing на това, което е на път да отиде ужасно погрешно.

771
01:10:25,870 --> 01:10:36,190
php.unique. Undefined променлива: Wooo, защото това се тълкува като променлива наречена Wooo.

772
01:10:36,190 --> 01:10:42,400
Двойни кавички ви позволи да вмъкнете променливи в

773
01:10:42,400 --> 01:10:52,730
Да речем, $ име = "Роб";

774
01:10:52,730 --> 01:10:58,020
Така ехо "Здравейте, моето име е $ име!";

775
01:10:58,020 --> 01:11:09,260
Тя признава това като променлива.

776
01:11:09,260 --> 01:11:21,210
Когато аз тичам, че и аз ще вмъкнете нов ред - Здравей, името ми е Роб! и здравей свят!

777
01:11:21,210 --> 01:11:24,910
Това е така, защото никога не съм се отстраняват отпечатването на Wooo по-горе.

778
01:11:24,910 --> 01:11:30,020
Има 1-нататъшна стъпка можете да направите.

779
01:11:30,020 --> 01:11:39,250
Масива $ = [1, 2, 3];

780
01:11:39,250 --> 01:11:43,270
Какво ще стане, ако желаете да отпечатате първия индекс на масива?

781
01:11:43,270 --> 01:11:45,150
Можете да направите масива $ [0].

782
01:11:45,150 --> 01:11:49,280
Оцветяване на синтаксиса е представа. Каква е тази смяташ да правиш?

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

784
01:11:54,510 --> 01:11:59,860
Здравейте, моето име е една! който не е това, което исках.

785
01:11:59,860 --> 01:12:05,050
Оцветяване на синтаксиса ме излъга.

786
01:12:05,050 --> 01:12:13,020
Нека се опитаме "-> 1," б "-> 2.

787
01:12:18,450 --> 01:12:21,440
Ето как аз ще трябва да го напиша.

788
01:12:26,350 --> 01:12:32,160
Неочаквана апостроф (T_ENCAPSED дрън, дрън, дрън, дрън, дрън).

789
01:12:32,160 --> 01:12:41,780
Идеята е, че тя не признава това като част от масива.

790
01:12:41,780 --> 01:12:46,620
Това не е признаването на този масив, индексирани с писмо на.

791
01:12:46,620 --> 01:12:49,870
Вие искате да направите това, заобиколен от фигурни скоби,

792
01:12:49,870 --> 01:12:54,730
и сега каквото и да е в тази презрамки къдрава ще се интерполират

793
01:12:54,730 --> 01:13:00,340
което е дума, която използваме за магически поставяне на тези променливи в правилните места.

794
01:13:00,340 --> 01:13:04,280
Сега правя това, php.unique и Здравейте, моето име е 1! както се очаква

795
01:13:04,280 --> 01:13:07,720
Здравейте, моето име е Роб!

796
01:13:14,110 --> 01:13:23,130
Едно нещо, което е нещо хубаво за единични кавички е, че

797
01:13:23,130 --> 01:13:28,480
Има някои разходи за интерполиране.

798
01:13:30,520 --> 01:13:35,100
Ако използвате двойни кавички, преводачът трябва да мине през този низ,

799
01:13:35,100 --> 01:13:41,500
като се уверите, че: "О, тук е променлива. Сега трябва да отида на тази променлива и я поставете тук."

800
01:13:41,500 --> 01:13:48,930
Дори ако не използвате променливи,

801
01:13:48,930 --> 01:13:52,220
нищо вътре в тези двойни кавички трябва да се интерполира,

802
01:13:52,220 --> 01:13:56,800
но все пак ще бъде по-бавно, защото трябва да отидем на двойни кавички

803
01:13:56,800 --> 01:14:00,130
търси неща, които трябва да се интерполира.

804
01:14:00,130 --> 01:14:05,360
Така единични кавички може да бъде малко по-бързо, ако нищо не трябва да се интерполира,

805
01:14:05,360 --> 01:14:15,650
и са склонни да използвате дори единични кавички, "Здравейте, моето име е". Масива $ ['а'] така или иначе.

806
01:14:15,650 --> 01:14:20,430
Това ще бъде еквивалентно на това, което сме имали преди.

807
01:14:24,840 --> 01:14:28,440
Но това е въпрос на предпочитание.

808
01:14:28,440 --> 01:14:34,750
Ако използвате PHP, най-вероятно не ми пука за разлика в скоростта.

809
01:14:34,750 --> 01:14:39,480
Не е достатъчно, за да разсъждаваме, да започнем с това.

810
01:14:39,480 --> 01:14:43,030
>> Някакви последни въпроси?

811
01:14:47,430 --> 01:14:51,710
>> Ние всъщност не дори да получите чрез всичко това, но тези неща е скучно.

812
01:14:51,710 --> 01:14:59,080
Последното нещо, което е нещо хубаво в PHP е, когато имаш работа с HTML,

813
01:14:59,080 --> 01:15:06,450
ще го използвате малко, така хубаво синтаксис пряк път за печат на променлива.

814
01:15:32,400 --> 01:15:36,730
Без пускането на PHP тук, това се нарича къси тагове.

815
01:15:36,730 --> 01:15:44,330
Официално от PHP 5.4, това е нежелателно.

816
01:15:44,330 --> 01:15:48,640
Се препоръчва да се сложи PHP.

817
01:15:48,640 --> 01:15:55,770
Това е все още поддържа, толкова кратки тагове с <= все още са съвършено глоба.

818
01:15:55,770 --> 01:16:02,480
Поддържа по подразбиране, така че можете да ги използвате, както желаете, и те са доста удобен.

819
01:16:02,480 --> 01:16:05,700
>> Някакви въпроси?

820
01:16:07,780 --> 01:16:09,270
Добре.

821
01:16:10,840 --> 01:16:13,800
>> Останете класа, Сан Диего.

822
01:16:13,800 --> 01:16:16,070
[Подсмихва]

823
01:16:18,620 --> 01:16:22,660
Чао. [Смее се]

824
01:16:24,350 --> 01:16:28,470
[Аплодисменти] [смее се]

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