1
00:00:00,000 --> 00:00:02,610
[Powered by Google Translate] [Section 8 - более комфортной]

2
00:00:02,610 --> 00:00:04,910
[Rob Боуден - Гарвардский университет]

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
Обычно есть наличие одного за это, но все изменения календаря

14
00:01:05,400 --> 00:01:09,560
делает все 1 неделю короче, и у нас больше нет PSET JavaScript.

15
00:01:09,560 --> 00:01:12,310
Я не знаю, как это влияет ли наличие собирается появиться на экзамен

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
Ну, скажем до свидания всем тем, CHAR, FLOAT, INT, и другие ключевые слова необходимо использовать

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
Я не согласен с тем, что это означает, что мы прощались с CHAR, FLOAT, INT,

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
он собирается жаловаться, потому что он собирался сказать, что вы не можете добавить Int и указатель.

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
Есть языки, в которых вы не нуждаетесь сказать, CHAR, FLOAT, INT, и все эти вещи,

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
но он по-прежнему будет во время компиляции, что вы не можете сделать этого, потому что вы смешиваете Int и строки.

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
Она поражает переменная = 7, то она попадает Printf то он попадает VAR то он попадает Printf и так далее.

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
так как это не 1 большой этап компиляции над вещью, а затем исполнение;

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 указателя или с помощью 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.

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
Так то вот, как вы думаете, типа этого? >> [Студент] Array.

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
Здесь индексами A, B, и C, а значения 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
Итак Еореп.

139
00:11:28,550 --> 00:11:36,420
Я думаю, что здесь давайте просто PHP Руководство Еореп смотреть на тип возвращаемого значения.

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 ресурс файл *.

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
любая ошибка проверок.

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-г, то мы можем бросить в команду здесь:

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
Объединение в 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
Другие вещи, чтобы попробовать: Print ("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 делит 2 целых чисел.

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

218
00:18:32,910 --> 00:18:37,750
Он не может вернуть 1 очко что бы это ни было бы, таким образом, это просто будет возвращать 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
Я предполагаю, 8, если это будет интерпретировать как истинный 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
Вы можете иметь 2 переменных и 1 переменной бывает строки

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

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
Если переменная Int, сохранить его в виде целого навсегда.

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
Видимо он печатает 1, как истинный вместо печати истинное как истинное.

256
00:22:10,060 --> 00:22:15,790
Мне интересно, если я делаю print_r. Нет, он по-прежнему делает 1.

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
Но если я изменю, что F - палки! Я продолжаю использовании двойных кавычках.

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
Еще хуже такие вещи, как (ложные == 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 '== False); это правда.

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
[Студент] Можем ли мы сделать! ==, А? >> [Боуден] Да.

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
До этого вы всегда были написать массив ('A' -> 1, 'B' -> 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], $ array [1], $ array [2],

334
00:29:30,610 --> 00:29:36,320
Вы индекса Точно так же, если вам случится, чтобы ваши индексы быть строками.

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

336
00:29:40,440 --> 00:29:47,410
$ Массив [б]. Почему это было бы не так?

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
Определим б быть "Hello World".

343
00:30:20,180 --> 00:30:28,740
Так что теперь б могла быть постоянным и массив $ [B] на самом деле будет делать "Hello World".

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
>> То, как вы убедитесь в том, на самом деле есть такой индекс Исеть.

349
00:30:49,290 --> 00:30:54,690
Так Исеть ($ массив ['Hello World']) вернет ложь.

350
00:30:54,690 --> 00:30:59,160
Исеть ($ массив ['B']) вернет истину.

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. >> [Боуден] Я предполагаю, 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
Что делать, если я включаю сюда? Или давайте на самом деле эти переключения 2.

384
00:34:29,330 --> 00:34:31,940
Теперь он печатает 2, 1, 3, 4.

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

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
Когда он ударил 2, будет ли давать когда-либо?

415
00:37:02,290 --> 00:37:10,150
Перебор массива. Есть 2 способа сделать это.

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
Давайте просто печать ($ массив [$ я]);

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 предоставляет своим Еогеасп синтаксис, где Еогеасп ($ массив $ пункта).

428
00:38:19,410 --> 00:38:31,830
Теперь, если мы печатаем ($ пункта); - МЫ обсудим это во второй - что работает прекрасно.

429
00:38:31,830 --> 00:38:38,960
Таким образом, что каждому элементу работает первый аргумент является массивом, что вы итерации.

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 новая строка \ г \ п, в то время как везде он стремится только, чтобы быть \ п.

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
Не верьте мне на слово по этому вопросу, но, похоже, Еогеасп создает копию массива

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] = "Hello";

455
00:41:24,460 --> 00:41:31,770
Даже если мы ставим "привет" в массив, элемент никогда не принимает это значение.

456
00:41:31,770 --> 00:41:37,430
Там другая синтаксис для Еогеасп петли

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

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
Здесь, если мы просто итерацию для каждого массива в качестве пункта, пункта будет на 1 каждый раз.

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
>> Кроме того, еще мы можем сделать в Еогеасп петель вы можете увидеть этот синтаксис.

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
Если бы я только что сделал Еогеасп ($ массив $ пункта), то элемент будет значение 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
Но Еогеасп ($ массив, как и $ пункта)

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
В принципе, вы также можете сделать $ K -> $ пункта и вы можете сделать массив $ [$ K] + +;

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
Но если мы используем K, которая является нашим ключевым, то мы можем просто индексом в нашем массиве с использованием этого ключа

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
Вы не хотите, чтобы написать массиве $ [$ K] + +,

494
00:45:16,020 --> 00:45:27,890
Вы только хотел написать $ пункту + +, но вы все еще хотел сказать, если ($ K === '')

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. >> [Боуден] Только если ключ был "а" мы на самом деле напечатать это.

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
Заметьте, что мы нужны ссылки на 2 места.

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
Если внутри этой функции он никогда не изменяет Фу,

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
Тогда 'C' является значением 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 ['C'] + +;

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
оно только собирается изменить 1 указатель, оно будет смешно трудно линейного копия?

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
Первое, что во-первых, мы хотим проверить, если бы мы были приняты 1 аргумент командной строки.

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
Мы не хотим иметь дело с тем, чтобы выйти (1);

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

631
00:57:38,240 --> 00:57:44,000
>> Тогда то, что мы хотим открыть мы хотим Еореп.

632
00:57:44,000 --> 00:57:46,760
Аргументы будет выглядеть очень похоже.

633
00:57:46,760 --> 00:57:51,600
Мы хотим, чтобы Еореп ($ 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
Вместо этого мы просто скажем, $ F. Хорошо.

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
Вам не нужно даже Еореп его. Он будет делать это за вас.

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
Возможно, самым простым способом является Еогеасп ($ линиях в $ линия) Эхо $ линию;

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
Когда мы все расставит на наших серверах, когда мы пошли с 5,3 до 5,4.

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
Затем собираются приехать всей нашей 1 углубления уровня

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
[Боуден] Когда вы вызываете функцию, она никогда не определяет, было ли оно передается по ссылке.

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
[Боуден] Это, своего рода займет линии по ссылке и изменить его.

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
Вы видите это в петли Еогеасп, вы видите его в объявлении функции,

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
[Боуден] Я бы так далеко, чтобы сказать, что это плохая практика, чтобы закрыть их.

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, это так приятно, что я могу сделать DIV бла, бла, бла, бла класса или любой другой,

716
01:05:18,050 --> 01:05:25,140
бла, бла, бла, бла, а затем сделать некоторые PHP код, а затем делать конце дел.

717
01:05:25,140 --> 01:05:36,460
А теперь распечатать это я получу хорошее дел наверху, все, что PHP печатной, раздел внизу.

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
и это вполне разумно делать здесь все, что дел

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
Так Printf очень редко в PHP.

750
01:08:24,010 --> 01:08:32,290
Я думаю, я хотел бы использовать Printf если бы я хотел делать вещи - в 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
Таким образом, для такого рода вещи, где я действительно хочу, чтобы отформатировать текст я хотел бы использовать Printf.

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

754
01:08:44,689 --> 01:08:47,000
Я никогда не использовать Printf.

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
обратная косая черта п, которое вы могли бы подумать бы новой строки -

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. Неопределенная переменная: Wooo, потому что это интерпретируется как переменная называется Wooo.

772
01:10:36,190 --> 01:10:42,400
Двойные кавычки позволяют вставить переменные в -

773
01:10:42,400 --> 01:10:52,730
Скажем, $ Name = "Rob";

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
Привет, меня зовут 1! которые не то, что я хотел.

785
01:11:59,860 --> 01:12:05,050
Подсветка синтаксиса солгал мне.

786
01:12:05,050 --> 01:12:13,020
Давайте попробуем "а" -> 1, 'B' -> 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]