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の1つではなく、カレンダーの変更のものがあり

14
00:01:05,400 --> 00:01:09,560
すべてが1週間短くなり、私たちはもはや、JavaScriptのpsetを持っていません。

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
さて、あなたが使用する必要がある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
私は、我々はint型、char型、float型に別れを言っていることを意味しているという事実に同意しない

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
文字列sは、文字列ではない何か新しいものに等しい

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
char *とブールはちょうどintやcharか何かになる傾向があります。

75
00:06:00,500 --> 00:06:05,690
PHPでは、これらのタイプが存在しますが、それはC上のPHPの大きな利点の一つだ - 

76
00:06:05,690 --> 00:06:13,290
文字列操作は、彼らはただ働く℃よりPHPで無限に容易であること。

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
これはdynamic.phpでPHPコードを実行するために、PHPと呼ばれる、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、それはそれは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
NULLは単にアドレスが0のポインタはCとは異なり、

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
我々はあなたがNULLを返す場合、この問題を持っていたC言語では、

113
00:09:04,310 --> 00:09:08,660
あなたはNULLポインタを返すか、エラーを示すためにNULLを使用しているわけではないこと

114
00:09:08,660 --> 00:09:12,380
または我々は1の時点で持っていた混乱のすべて。

115
00:09:12,380 --> 00:09:18,440
ここでは、NULLを返すことは、一般的にエラーを意味します。

116
00:09:20,860 --> 00:09:27,300
物事の多くは、エラーの場合はfalseを返します。

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のタイプが何であるかと思いますか？ >> [生徒]フロート。

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
うん。最初のものは、floatであった、2番目の例は、配列です。

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
それでは、関数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
あまりにもJavaScriptとJavaと違っているので、PHP、

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
これは、人々は、+ = strのような何かをしようと混乱につながる傾向

195
00:16:32,420 --> 00:16:37,840
彼らは文字列の最後に追加したい、それが失敗するために起こっていることをいくつかの他の事。

196
00:16:37,840 --> 00:16:40,770
あなたは、strを行う必要があります=

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 SO + 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
これはCであった場合は、ここに（10/7）、それは何を返すでしょう？

216
00:18:23,700 --> 00:18:29,630
[学生] 1。 10月7日には2つの整数を分割しているので>>うん、それは1になります。

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では、あなたはそれが自動的にfloat型に変換しますができないためです。

224
00:19:13,430 --> 00:19:17,610
そして、（7 +真）、あなたはなるだろうことをどう思いますか？

225
00:19:18,550 --> 00:19:23,640
それは1のように真の解釈に起こっている場合、私は8を推測している。

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の場合は、永遠に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
私は、falseが返されたことを推測している。

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
そして、それはfalseを返すだ。

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
これは、trueを返します。

267
00:23:17,980 --> 00:23:21,420
なぜこれがtrueを返す誰がどんな推測を持っていますか？

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
それは1として認識1E1 * 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
、そして、それは20だろう。だから、あなたがしたときに（10 + '10abc '）が好き

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
か（false == 0）はtrueですが、（偽== []）;

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）の場合はtrueです。

286
00:25:11,950 --> 00:25:16,090
（'0 '== []）; falseです。

287
00:25:16,090 --> 00:25:19,090
だから==は他動詞では決してない。

288
00:25:19,090 --> 00:25:26,830
bに等しくすることができると、cに等しくすることができる

289
00:25:26,830 --> 00:25:29,340
しかし、bがcに等しいではないかもしれません。

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
それは、 "エラーがある場合、これはfalseを返します。"大きな赤いボックスに入れ

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
あなたはそれを不正なファイルを渡すと、関数はfalseを返すために発生しますが、どうでしょう

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の最新バージョンで、PHP 5.4のように新しく追加されました。

311
00:27:15,640 --> 00:27:36,960
> 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
どのようにあなたは$配列[0]は、$ array [1]は、$ array [2]のように角括弧でインデックスのと同じC言語のように、

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
$配列[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
'Hello World'のようにbを定義します。

343
00:30:20,180 --> 00:30:28,740
だから今、bは定数と$配列かもしれない[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
>> あなたが実際にそのようなインデックスがあるかどうかを確認する方法は、issetです。

349
00:30:49,290 --> 00:30:54,690
だからかどうかの判断（$配列['Hello World'の ']'）はfalseを返します。

350
00:30:54,690 --> 00:30:59,160
判断（$配列['B']）がtrueを返します。

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を定義していると私は両方の配列$ a [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であることを起こる、それがこれまで割り当てられている最高の1を追跡します

378
00:33:47,690 --> 00:33:52,540
そしてそれは3から11を与えるために起こっている。

379
00:33:52,540 --> 00:34:02,110
私が前に言ったこと、それはこの配列を印刷する方法がわかります。

380
00:34:02,110 --> 00:34:06,850
これは、キー10、キー4キー11、キーdを出力します。

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
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
Let 'sは、あなたが配列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
unsetは、変数や配列のインデックスの両方の設定を解除することを起こる。

401
00:35:54,880 --> 00:35:58,630
そうしますunset（$配列[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
1  - 私はそれがちょうどそれが0からな長さになりますC言語の配列のようになりたい

407
00:36:26,860 --> 00:36:30,810
そして私はそういうものとしてそれを反復処理することができます。

408
00:36:30,810 --> 00:36:38,520
しかし、すぐに私は2番目のインデックスの設定を解除すると、インデックス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
forループのレギュラーを使用することができます。

417
00:37:12,770 --> 00:37:22,000
これはPHPの別の複雑さです。

418
00:37:22,000 --> 00:37:27,420
ほとんどの言語は、私が言うと、長さはlenか何かのいくつかの並べ替えを持っている

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
注意：未定義のオフセット：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
今、私たちは、印刷する場合（$アイテム）;  -  we'll第二にそれを議論する - 完全に正常に動作している。

429
00:38:31,830 --> 00:38:38,960
foreachが動作していることの方法は、最初の引数は、繰り返して配列していることです。

430
00:38:38,960 --> 00:38:44,060
forループの各パスに通して、第二引数、項目、

431
00:38:44,060 --> 00:38:52,690
それは、配列内の次の事に取るつもりです。だから配列が秩序を持って覚えている。

432
00:38:52,690 --> 00:38:55,690
forループを介して初めて、その項目は123になるだろう

433
00:38:55,690 --> 00:38:59,540
それはそれはそれはそれは213になり23になり13になり12になります。

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
何なら、私たちますunset（$配列[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
しかし、内側のforループは我解除インデックス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
あなたは、forループ内の配列を変更するので、たとえ

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
我々は配列には "hello"を入れていても、アイテムはその値を取ることはありません。

456
00:41:31,770 --> 00:41:37,430
ループをforeachのための別の構文があります

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
'B'  - > 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
>> 我々は、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（$アイテムとして$ array）をやっていれば、その項目の値は1になります

477
00:43:49,560 --> 00:43:54,190
最初のループで。それは、我々が終わった後2から1をインクリメントします。

478
00:43:54,190 --> 00:43:57,260
だから、それはループの2回目のパスを通過しますと、その項目は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
基本的に、あなたはまた、$ 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 === 'a'）の場合、言いたいこと

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と$ bar）をし、それが何であると定義することになります。

501
00:46:09,900 --> 00:46:17,580
私はこれを行うにはしかし、もしそれが、何が何でも呼び出すことを意味します

502
00:46:17,580 --> 00:46:25,110
bazが呼び出すものは何でも、バズに渡される最初の引数を変更することができるようにします。

503
00:46:25,110 --> 00:46:38,100
$ fooを実行してみましょう+ +;

504
00:46:38,100 --> 00:46:48,020
ここの内側にbazを（$アイテム）を行うてみましょう;

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に変更されますが、配列は['A']はまだ1になります。

515
00:47:26,670 --> 00:47:32,560
または私はこれを行うにはどうすればよいでしょうか。

516
00:47:32,560 --> 00:47:39,260
今アイテムは、bazへコピーとして送信されます。

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
これは実際のpsetのいずれかに問題であった。

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
私はいくつかの機能を持っていると私はそれに千の事の配列を渡すと、

535
00:49:00,650 --> 00:49:03,990
それはそれはそれらの事のすべて千をコピーする必要があるとしているわけではない

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は=== 'こんにちは'）がtrueを返す。

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つの要素を変更する必要があるでしょうか？

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]、の配列であり、インデックス' b 'は何の配列です。

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
今すぐみましょう我々は$ bazを（$配列2）を行うと言う。

564
00:51:33,440 --> 00:51:36,540
どこbazは参照することによって、これを取ることはありません。

565
00:51:43,510 --> 00:51:47,370
つまり、$ fooは['C'] + +;

566
00:51:47,370 --> 00:51:52,340
これは、我々は引数として配列2を渡しているような例です。

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
ここで、[1,2,3,4] 3〜この男がポイント、この男を指し、我々は、この配列を渡す

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
これは、PHP上のCの非常に大きな利点です。

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
あなたは、入力が1行に1つの単語が含まれていると仮定することができます。

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
あなたがC言語でargcとargvを期待するのと同じように、我々はまだ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
そしてあなただけのプログラムを強制終了したい場合は、あなたは、exitを呼び出すことができ、それだけで終了します。

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
>> その後、我々はオープンしたい私たちは、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
それは我々がfを呼び出すつもりリソースを返します。

635
00:57:55,720 --> 00:58:02,180
これは、我々はFILE *を言わなければならない点を除き、Cはそれをしない方法にかなり似ています。

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
あなたも、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
ソートは関数sort（＆$配列）として定義されるであろうところです。

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
それはtest.phpを上php.unique.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
あなたは、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
、それが未設定の行をしません、あなたは、unset（$ copy）を行うことができます

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コードを実行してから終了のdivを行う。

717
01:05:25,140 --> 01:05:36,460
そして今、私はPHPのプリント、下部にdivを、すべて、トップアップ私の素敵な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
>> 文字列を扱うことでよりもはるかに進歩しています

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
PSET 5にはsprintfのか何使用 - 私は事のようなものをやってみたかった場合、私はprintfを使用するだろうと思います。

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にはcharデータ型がありませんが、C言語とは違って、これはこれに相当します。

758
01:09:15,390 --> 01:09:17,970
彼らは両方の文字列だ。

759
01:09:17,970 --> 01:09:29,180
と単一引用符を文字列についての素晴らしい事は、私が言うことがあるの 'Hello World！'を何とか、何とか、何とか、

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。未定義の変数：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
私はそれを実行したときに - 私は改行を挿入します - こんにちは、私の名前はロブです！とHello World！

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
と私は 'こんにちは、私の名前は'も、一重引用符を使用する傾向がある。 $配列['A']とにかく。

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]