1
00:00:00,000 --> 00:00:12,610

2
00:00:12,610 --> 00:00:12,900
>> DAVID J.マラン：すべての権利。

3
00:00:12,900 --> 00:00:16,790
初めてにとても歓迎
クイズのCS50の死後。

4
00:00:16,790 --> 00:00:18,340
私達は私達が発足しようと思いました
この伝統は今年。

5
00:00:18,340 --> 00:00:20,960
そして、これはチャンスとなります
ウォークスルーする

6
00:00:20,960 --> 00:00:22,220
クイズへのソリューションを提供しています。

7
00:00:22,220 --> 00:00:26,160
そして、我々はスピードアップやベース遅くします
ここでそれらの利益に。

8
00:00:26,160 --> 00:00:29,730
>> あなたがしているので、それで、あなたは、おそらくここにいる
あなたが持っている可能性がどのように興味を持ったり

9
00:00:29,730 --> 00:00:31,170
いくつかに答えている必要があります
これらの問題の。

10
00:00:31,170 --> 00:00:33,300
では、なぜ我々は見ていないの
最初のこのセクションでは？

11
00:00:33,300 --> 00:00:34,450
だから、文字列を取得する。

12
00:00:34,450 --> 00:00:37,600
これはあなたに3つの異なるバージョンを与えた
されたプログラムの、最終的には、

13
00:00:37,600 --> 00:00:39,650
ユーザから文字列を取得するためのもの。

14
00:00:39,650 --> 00:00:42,530
だったが、それをしたか否かは、
決定するために、あなたに残しました。

15
00:00:42,530 --> 00:00:45,150
>> そして、我々は、質問0で尋ね
バージョン1があるとし

16
00:00:45,150 --> 00:00:46,400
コンパイルして実行。

17
00:00:46,400 --> 00:00:48,860
なぜプログラムがセグメンテーション違反でしょうか？

18
00:00:48,860 --> 00:00:51,150
一見すると、何か提案
理由として？

19
00:00:51,150 --> 00:00:54,012

20
00:00:54,012 --> 00:00:54,489
うん。

21
00:00:54,489 --> 00:00:59,260
>> 観客：だから私はこれを覚えている
を見ての前の例

22
00:00:59,260 --> 00:01:05,506
CHAR * sおよびsのスキャンを見て、
それは、ポインタだから見て、どのように

23
00:01:05,506 --> 00:01:07,971
それはあなたがスキャンした内容に影響しましたか？

24
00:01:07,971 --> 00:01:10,940
それはSまたはsのアドレスですか？

25
00:01:10,940 --> 00:01:11,180
>> DAVID J.マラン：わかりました。

26
00:01:11,180 --> 00:01:11,480
グッド。

27
00:01:11,480 --> 00:01:14,830
だから最終的に、すべての問題の原因
おそらく削減しようとしている

28
00:01:14,830 --> 00:01:16,210
その変数sに。

29
00:01:16,210 --> 00:01:17,280
そして、それは確かにその変数の。

30
00:01:17,280 --> 00:01:19,900
その変数のデータ·タイプは
それがために起こっていることを意味char *を、

31
00:01:19,900 --> 00:01:22,570
文字のアドレスが含まれています。

32
00:01:22,570 --> 00:01:23,850
そしてその中の洞察力はある。

33
00:01:23,850 --> 00:01:28,330
これは、のアドレスが含まれているために起こっている
より一般的には文字または、

34
00:01:28,330 --> 00:01:32,110
の最初の文字のアドレス
文字のブロック全体。

35
00:01:32,110 --> 00:01:36,680
>> しかし、漁獲量は、スキャンSという目的です
人生は、アドレスが与えられ、与えられている

36
00:01:36,680 --> 00:01:40,960
書式コードは、％sのように、読み
のチャンクに文字列

37
00:01:40,960 --> 00:01:42,330
そのアドレスのメモリ。

38
00:01:42,330 --> 00:01:46,040
しかし、誰等号の前にありませんので、
最初にそのセミコロン

39
00:01:46,040 --> 00:01:49,310
コー​​ドの行、私たちは実際にないので、
でメモリを割り当て

40
00:01:49,310 --> 00:01:53,020
malloc関数、それが実際になかったため、
すべての、いくつかのサイズの配列を割り当て

41
00:01:53,020 --> 00:01:57,620
あなたがやっている、ユーザーのを読んでいる
いくつかの完全にキーボード入力

42
00:01:57,620 --> 00:02:00,490
ゴミ値、どの
デフォルトでは、Sである。

43
00:02:00,490 --> 00:02:04,480
だから、オッズは、あなたがあればセグメンテーション違反するつもりである
そのアドレスは、ちょうどそう発生しません

44
00:02:04,480 --> 00:02:08,009
あなたができる値になるように、
実際には、への書き込み。

45
00:02:08,009 --> 00:02:10,889
割り当てることはないので、悪い
そこにあなたの記憶。

46
00:02:10,889 --> 00:02:13,150
>> そこで質問1で、我々は尋ねた、
バージョン2があるとし

47
00:02:13,150 --> 00:02:14,230
コンパイルして実行。

48
00:02:14,230 --> 00:02:15,900
なぜ、このプログラムでは、セグメンテーション違反でしょうか？

49
00:02:15,900 --> 00:02:17,990
したがって、この1はあまりバグが。

50
00:02:17,990 --> 00:02:21,470
一つだけは本当にあります
明白な方法どこにあなたができる

51
00:02:21,470 --> 00:02:22,810
ここでセグメンテーションフォルトをトリガします。

52
00:02:22,810 --> 00:02:23,730
そして、これはテーマ別である。

53
00:02:23,730 --> 00:02:28,180
我々は、メモリにCを使っているときはいつでも、どのような
あなたがセグメンテーションフォルトを誘導するために何ができる

54
00:02:28,180 --> 00:02:30,718
バージョン2と？

55
00:02:30,718 --> 00:02:35,560
>> 読者：あなたはでその入力を使用している場合
49よりも長いです文字列

56
00:02:35,560 --> 00:02:35,975
文字。

57
00:02:35,975 --> 00:02:37,260
>> DAVID J.マラン：その通りです。

58
00:02:37,260 --> 00:02:41,420
あなたが何かを固定長を参照してくださいいつでも
それが配列になると、あなたの

59
00:02:41,420 --> 00:02:44,650
レーダーは、これは可能性があることを消灯し
問題のあるあなたがチェックしていない場合は、

60
00:02:44,650 --> 00:02:45,810
配列の境界。

61
00:02:45,810 --> 00:02:46,650
そして、それは、ここで問題です。

62
00:02:46,650 --> 00:02:47,910
我々はまだscanf関数を使用している。

63
00:02:47,910 --> 00:02:52,200
我々はまだ試しを意味し、％Sを使用している
ユーザーから文字列を読み取ります。

64
00:02:52,200 --> 00:02:56,300
それは、Sに読み込むことになるだろう、
この時点で、効果的である

65
00:02:56,300 --> 00:02:58,570
メモリチャンクのアドレス
または、同等です。

66
00:02:58,570 --> 00:03:02,080
これは、配列の名前です
メモリの文字数。

67
00:03:02,080 --> 00:03:07,610
>> しかし、正確には、文字列を読めば
つまり、49 49文字以上です

68
00:03:07,610 --> 00:03:10,440
あなたは、バックスラッシュのための部屋を必要とするので、
0は、オーバーフローするつもりだ

69
00:03:10,440 --> 00:03:11,390
そのバッファ。

70
00:03:11,390 --> 00:03:16,410
そして、あなたは幸運を得るとすることができるかもしれません
第51文字、第52回、第53回を書く。

71
00:03:16,410 --> 00:03:18,560
しかし、ある時点で、OSの
いや、言おうとしています。

72
00:03:18,560 --> 00:03:21,270
これは間違いなくメモリではありません
あなたは、タッチすることができています。

73
00:03:21,270 --> 00:03:23,380
プログラムがセグメンテーション違反しようとしている。

74
00:03:23,380 --> 00:03:26,650
>> だから、、ヒューリスティックは任意のものでなければならない
あなたは、固定長を持っている時間は、あなたが持っている

75
00:03:26,650 --> 00:03:30,150
あなたは長さをチェックしている作る
それはあなたがしようとしているが何であれの

76
00:03:30,150 --> 00:03:31,090
その中に読み取ることができます。

77
00:03:31,090 --> 00:03:35,110
>> 観客：だから、それを解決するには、可能性が
実際にチェックする声明を持っていた

78
00:03:35,110 --> 00:03:37,140
長さ以上である
以上またはより少ない？

79
00:03:37,140 --> 00:03:37,730
>> DAVID J.マラン：もちろんです。

80
00:03:37,730 --> 00:03:41,706
あなただけの条件を持っている
場合には、述べています - 

81
00:03:41,706 --> 00:03:46,080
というか、あなたは必ずしも分からない
事前に何文字

82
00:03:46,080 --> 00:03:49,060
ユーザーは、入力しようとしているので、
あなたは鶏と卵を持っている。

83
00:03:49,060 --> 00:03:51,860
あなたはscanf関数でそれを中に読んだではないまで
あなたはそれがどのくらい把握することができます。

84
00:03:51,860 --> 00:03:54,500
しかし、その時点で、それは遅すぎる、
あなたは既ににそれを読んだので、

85
00:03:54,500 --> 00:03:55,710
メモリーの一部のブロック。

86
00:03:55,710 --> 00:03:59,590
余談ですが、CS50ライブラリ回避するのでそのように
この問題を完全にリコール

87
00:03:59,590 --> 00:04:01,060
fgetc関数を使用します。

88
00:04:01,060 --> 00:04:05,390
そして、それは、一度に1つの文字を読み取り、
ことを知って、一緒に先端糞ガキなんか

89
00:04:05,390 --> 00:04:08,060
場合は、文字をオーバーフローすることはできません
一度に1をお読みください。

90
00:04:08,060 --> 00:04:11,580
>> キャッチのgetStringのリコールとされている
我々は常にサイズ直ししなければならないこと

91
00:04:11,580 --> 00:04:13,590
メモリのチャンク、その
ただ痛みです。

92
00:04:13,590 --> 00:04:15,310
これは、行の多くの
これを行うためのコード。

93
00:04:15,310 --> 00:04:18,779
だから、別のアプローチをすることであろう
実際にいとこを使用するので、

94
00:04:18,779 --> 00:04:19,790
scanf関数の、話をする。

95
00:04:19,790 --> 00:04:22,820
これらの多くの亜種があります。
実際に確認機能

96
00:04:22,820 --> 00:04:25,870
何文字の長さ
あなたが最大限に読むかもしれない。

97
00:04:25,870 --> 00:04:29,430
そして、あなたは読んでいない、指定することができます
50文字以内。

98
00:04:29,430 --> 00:04:34,110
だから、別のアプローチになりますが、
大きな入力の少ない収容。

99
00:04:34,110 --> 00:04:37,040
>> だから、そのバージョンを仮定し、尋ねる質問2
図3に示すようにコンパイルされて実行される。

100
00:04:37,040 --> 00:04:39,960
なぜそのプログラムがセグメンテーション違反でしょうか？

101
00:04:39,960 --> 00:04:42,650
したがって、この1は実際には同じです
、答えにもかかわらず、それ

102
00:04:42,650 --> 00:04:43,590
少し手の込んだ見える。

103
00:04:43,590 --> 00:04:46,440
私たちは、のように感じているのmallocを使用している
我々は自分自身をより多くのオプションを与えている。

104
00:04:46,440 --> 00:04:48,030
そして、我々はそれを解放している
最後にメモリ。

105
00:04:48,030 --> 00:04:49,580
それはまだメモリのわずか50バイトです。

106
00:04:49,580 --> 00:04:53,620
だから我々は、まだ読んでみてください
51、52、1,000バイト中。

107
00:04:53,620 --> 00:04:55,830
それがためにセグメンテーション違反になるだろう
まったく同じ理由。

108
00:04:55,830 --> 00:04:57,530
>> しかし、もう一つの理由は、あまりにもあります。

109
00:04:57,530 --> 00:05:03,890
他に何がほかにリターンをのmallocできた
メモリチャンクのアドレス？

110
00:05:03,890 --> 00:05:04,920
これはnullを返すことができます。

111
00:05:04,920 --> 00:05:07,560
そして、我々はチェックしていないので、
つまり、我々は何かをするかもしれない

112
00:05:07,560 --> 00:05:11,350
ということで、別の理由で、愚かな
私たちは読み、scanf関数を伝える可能性があります

113
00:05:11,350 --> 00:05:16,050
キーボードからのユーザ入力
0場所に、別名ヌル。

114
00:05:16,050 --> 00:05:18,890
そして、それは、あまりにも、間違いなく意志
セグメンテーションフォルトをトリガします。

115
00:05:18,890 --> 00:05:21,590
だから、クイズの目的のために、我々はだろう
として、それらのいずれかを受け入れた

116
00:05:21,590 --> 00:05:22,740
正当な理由。

117
00:05:22,740 --> 00:05:23,420
一つは同じです。

118
00:05:23,420 --> 00:05:25,720
一つは、もう少し微妙である。

119
00:05:25,720 --> 00:05:28,975
>> 最後に、プログラムのに関して
バージョン2を実行し、どのようにメモリを使用する、

120
00:05:28,975 --> 00:05:30,350
バージョン3が異なる？

121
00:05:30,350 --> 00:05:35,070
だから、何が価値があるために、我々は見た
可能性の表面上は無限の供給

122
00:05:35,070 --> 00:05:35,770
これに対する答え。

123
00:05:35,770 --> 00:05:39,300
そして、人々の答えの中で、我々はどのようなものだった
を期待して、私たちは、他の受け入れ

124
00:05:39,300 --> 00:05:42,250
物事は、いくつかの言及だった
バージョン2が使用しているという事実

125
00:05:42,250 --> 00:05:44,560
いわゆるスタック。

126
00:05:44,560 --> 00:05:46,710
バージョン3は、ヒープを使用しています。

127
00:05:46,710 --> 00:05:50,060
そして機能的には、これは本当にない
差のすべてが多くを作る。

128
00:05:50,060 --> 00:05:54,040
一日の終わりに、我々はまだだ
ただ、メモリの50バイトを取得。

129
00:05:54,040 --> 00:05:56,640
>> しかし、それは可能な答えの一つであった
我々は見ていたことを。

130
00:05:56,640 --> 00:05:59,730
あなたがクイズを得るようにはできますが、表示されます
背中のTFから、我々が行ったことを

131
00:05:59,730 --> 00:06:04,330
彼らの他の議論を受け入れる
異種のメモリの使用にも。

132
00:06:04,330 --> 00:06:08,600
しかし、スタックとヒープがあったであろう
一緒に行くための簡単​​な答え。

133
00:06:08,600 --> 00:06:11,150
ご質問？

134
00:06:11,150 --> 00:06:12,400
私はあなたにロブを与える。

135
00:06:12,400 --> 00:06:18,360

136
00:06:18,360 --> 00:06:20,210
>> ROBボーデン：だから問題4。

137
00:06:20,210 --> 00:06:21,985
これはあなたが記入しなければならなかったものです
すべてのうち、バイト数

138
00:06:21,985 --> 00:06:23,460
これらの異なるタイプを用いる。

139
00:06:23,460 --> 00:06:24,830
私たちが見るので、まず最初に。

140
00:06:24,830 --> 00:06:27,930
32ビットアーキテクチャを前提とし、
このCS50アプライアンスのような。

141
00:06:27,930 --> 00:06:33,530
についての基本的なもののため、1つの
を教えてくれる32ビットアーキテクチャ、

142
00:06:33,530 --> 00:06:37,490
ポインタが起こっている正確にどのように大きな
アーキテクチャであっする。

143
00:06:37,490 --> 00:06:43,020
>> ので、すぐに、私たちは知っている任意のポインタ
型は32ビットまたは4バイトです。

144
00:06:43,020 --> 00:06:46,010
したがって、この表を見て、A
ノード*がポインタ型である。

145
00:06:46,010 --> 00:06:47,250
つまり、4バイトになるだろう。

146
00:06:47,250 --> 00:06:51,640
構造体ノード*、それは文字通りだ
ノードのスターと同じ。

147
00:06:51,640 --> 00:06:53,590
そしてその結果は4バイトになるだろう。

148
00:06:53,590 --> 00:06:58,270
文字列なので、似ていない
まだポインタが、型定義、A

149
00:06:58,270 --> 00:07:01,590
文字列だけではchar *であり、これ
ポインタ型である。

150
00:07:01,590 --> 00:07:03,550
だから、4バイトになるだろう。

151
00:07:03,550 --> 00:07:06,150
>> したがって、これら3つはすべて4バイトです。

152
00:07:06,150 --> 00:07:09,350
今、ノードと学生は
少し複雑。

153
00:07:09,350 --> 00:07:15,160
そうノードと学生を見て、我​​々が表示さ
整数とポインタとしてノード。

154
00:07:15,160 --> 00:07:18,050
学生2つのポインタである
その中の。

155
00:07:18,050 --> 00:07:23,340
だから、少なくともここに我々の場合のために、道
我々のサイズを計算してしまうことを

156
00:07:23,340 --> 00:07:27,020
この構造体は単に、すべてを合計している
つまり、構造体の中だ。

157
00:07:27,020 --> 00:07:30,690
>> そうノードに対して、我々は整数を有する、
その4バイトです。

158
00:07:30,690 --> 00:07:32,830
我々は、4バイトのポインタを有する。

159
00:07:32,830 --> 00:07:35,820
だから1ノードが起こっている
8バイトを占有します。

160
00:07:35,820 --> 00:07:39,490
と同様に、学生のために、我々は持っている
4バイトと別のポインタ

161
00:07:39,490 --> 00:07:40,770
4バイトのポインタ。

162
00:07:40,770 --> 00:07:43,180
だから、終わりになるだろう
最大8バイトであること。

163
00:07:43,180 --> 00:07:45,480
そうノードと学生が8バイトです。

164
00:07:45,480 --> 00:07:48,950
そして、これら3つはすべて4バイトです。

165
00:07:48,950 --> 00:07:50,240
その上での質問？

166
00:07:50,240 --> 00:07:54,640

167
00:07:54,640 --> 00:07:54,990
はい。

168
00:07:54,990 --> 00:07:58,413
>> 観客：それは64ビットになりましたか
建築、それをう

169
00:07:58,413 --> 00:07:59,880
それらのすべてを倍増？

170
00:07:59,880 --> 00:08:01,790
>> ROBボーデン：それはないでしょう
それらのすべてを倍増。

171
00:08:01,790 --> 00:08:05,830
だから、64ビットアーキテクチャ、IT、再び、
変化することを基本的な事、その

172
00:08:05,830 --> 00:08:08,910
ポインタは、64ビットです。

173
00:08:08,910 --> 00:08:09,290
うん。

174
00:08:09,290 --> 00:08:10,930
だから、ポインタは8バイトです。

175
00:08:10,930 --> 00:08:15,420
したがって、これらの4バイトであったことを
8バイトになるだろうしている。

176
00:08:15,420 --> 00:08:18,617
2ポインタた学生、
まあ、今ではなるだろう

177
00:08:18,617 --> 00:08:19,800
8バイト、8バイトである。

178
00:08:19,800 --> 00:08:21,980
それは、16バイトをするつもりだ。

179
00:08:21,980 --> 00:08:25,710
>> しかし、ノードがまだ4バイトです。

180
00:08:25,710 --> 00:08:27,800
したがって、このポインタが起こっている
8バイトになります。

181
00:08:27,800 --> 00:08:28,930
これは4バイトです。

182
00:08:28,930 --> 00:08:30,870
だから、ノードは、起こっている
12バイトになります。

183
00:08:30,870 --> 00:08:36,309

184
00:08:36,309 --> 00:08:39,280
その1上の任意の他の質問？

185
00:08:39,280 --> 00:08:44,500
ので、次の1、これらは
HTTPステータスコード。

186
00:08:44,500 --> 00:08:48,000
そして、あなたは事情を説明しなければならなかった
その下で、これらのマイト

187
00:08:48,000 --> 00:08:49,810
あなたに返される。

188
00:08:49,810 --> 00:08:56,730
私は何人かの学生を聞いた一つの問題
持っている彼らが作るしようとしたことである

189
00:08:56,730 --> 00:08:58,950
エラーは、クライアントのエンドであること。

190
00:08:58,950 --> 00:09:02,320
だから我々は、要求をしようとするとき
サーバに、何かが行く

191
00:09:02,320 --> 00:09:03,820
私たちの最後の間違った。

192
00:09:03,820 --> 00:09:07,660
しかし、一般的に、これらのコードは、
サーバから返されている。

193
00:09:07,660 --> 00:09:11,720
だから我々は何が起こっているのかを把握したい
間違っていたり、そのサーバー上の権利

194
00:09:11,720 --> 00:09:14,280
これらのものが返される。

195
00:09:14,280 --> 00:09:18,670
では、なぜサーバーが返す可能性がある
ステータスコード200？

196
00:09:18,670 --> 00:09:19,920
任意の考え？

197
00:09:19,920 --> 00:09:23,360

198
00:09:23,360 --> 00:09:23,730
>> うん。

199
00:09:23,730 --> 00:09:27,850
だから、何かについて成功裏
要求が通って行きました。

200
00:09:27,850 --> 00:09:30,260
そして、彼らは返すことができるしている
あなたが求めたものは何でも。

201
00:09:30,260 --> 00:09:32,240
だから、すべてが大丈夫だった。

202
00:09:32,240 --> 00:09:35,662
302についてはどうか？

203
00:09:35,662 --> 00:09:36,618
うん。

204
00:09:36,618 --> 00:09:39,008
>> 観客：サーバが探していた
あなたが要求したもののために。

205
00:09:39,008 --> 00:09:40,442
しかし、それはそれを見つけることができませんでした。

206
00:09:40,442 --> 00:09:42,850
ように、エラーがあります。

207
00:09:42,850 --> 00:09:47,720
>> ROBボーデン：だからサーバーだった
あなたが何を望むかを探している。

208
00:09:47,720 --> 00:09:51,682
だから、ここで見て、302見つけ、
それはそれを見つけることができた。

209
00:09:51,682 --> 00:09:53,035
>> 観客：ごめんなさい。

210
00:09:53,035 --> 00:09:54,388
発見は、彼らがそれを見つけたことを意味します。

211
00:09:54,388 --> 00:09:55,638
申し訳ありません。

212
00:09:55,638 --> 00:09:58,120

213
00:09:58,120 --> 00:10:00,160
>> ROBボーデン：だから302が見つかりました。

214
00:10:00,160 --> 00:10:02,350
サーバは見つけることができ
あなたが何を望むか。

215
00:10:02,350 --> 00:10:04,640
>> 観客：しかし、それは、それを表示していないのですか？

216
00:10:04,640 --> 00:10:08,180
>> ROBボーデン：違い
この302と200、それがあることである

217
00:10:08,180 --> 00:10:09,280
あなたが欲しいものを知っている。

218
00:10:09,280 --> 00:10:12,000
しかし、それは正確にどこではありません
あなたがお聞きしたかった。

219
00:10:12,000 --> 00:10:14,580
だから、302は、一般的なリダイレクトです。

220
00:10:14,580 --> 00:10:16,510
だから、ページを要求した。

221
00:10:16,510 --> 00:10:19,590
それは私が欲しい、ああ、知っている
あなたにこの戻ります。

222
00:10:19,590 --> 00:10:21,070
しかし、これは別のURLにあります。

223
00:10:21,070 --> 00:10:23,534
そうねえ、あなたが実際にこれをしたい。

224
00:10:23,534 --> 00:10:26,950
>> DAVID J.マラン：それは言った一枚です
私たちはあなたたちのリダイレクトを与えたことを

225
00:10:26,950 --> 00:10:30,830
ヘッダー機能を使用する機能
それは、順番に、場所をプリントアウト

226
00:10:30,830 --> 00:10:34,110
コロン、その後、先のURL
あなたがユーザーを拒否したい。

227
00:10:34,110 --> 00:10:37,480
あなたは302を見ていないにもかかわらず、
明示的にそこに、それがどのようなPHPのです

228
00:10:37,480 --> 00:10:41,550
魔法のようにヘッダとして挿入します
ロブが言ったまさに言って - 

229
00:10:41,550 --> 00:10:41,930
発見した。

230
00:10:41,930 --> 00:10:43,180
その代わりに、ここに行く。

231
00:10:43,180 --> 00:10:45,960

232
00:10:45,960 --> 00:10:46,160
>> ROBボーデン：わかりました。

233
00:10:46,160 --> 00:10:47,630
だから、403について何を禁じ？

234
00:10:47,630 --> 00:10:52,240

235
00:10:52,240 --> 00:10:57,120
>> 読者：私はそれがだと思う、そのサーバー
基本的にはクライアントと言っている

236
00:10:57,120 --> 00:10:59,970
ホームページにアクセスすることはできません。

237
00:10:59,970 --> 00:11:03,260
>> ROBボーデン：そうです。

238
00:11:03,260 --> 00:11:07,670
さて、一般的な答えは、私たちはいた
期待して、ファイルのようなものです。

239
00:11:07,670 --> 00:11:08,920
適切chmoddedされていません。

240
00:11:08,920 --> 00:11:11,590
それはおそらくどのような状況の下での
あなたがそれらを見た。

241
00:11:11,590 --> 00:11:18,920
しかし、理由があることをクライアント
ここに障害が発生している可能性があります。

242
00:11:18,920 --> 00:11:20,440
別のステータスコードは実際にあります - 

243
00:11:20,440 --> 00:11:21,210
401。

244
00:11:21,210 --> 00:11:22,820
したがって、これらは非常に似ています。

245
00:11:22,820 --> 00:11:24,590
>> 401は、不正である。

246
00:11:24,590 --> 00:11:26,130
そして403は禁止されている。

247
00:11:26,130 --> 00:11:31,890
そして、あなたがそのように許可されていない独占的
あなたがログインしていない場合は、取得

248
00:11:31,890 --> 00:11:34,520
しかし、ログインすると意味するかもしれない
あなたが許可されていること。

249
00:11:34,520 --> 00:11:37,930
しかし、あなたはすでにログインしている場合
それでも、権限を持っていません

250
00:11:37,930 --> 00:11:40,140
また、禁止されている得ることができます。

251
00:11:40,140 --> 00:11:45,320
だから、ログインしているし、持っていない場合
許可、禁止さでもある

252
00:11:45,320 --> 00:11:47,164
あなたが得ることができるもの。

253
00:11:47,164 --> 00:11:48,900
>> DAVID J.マラン：機構による
これらの問題は通常、ある

254
00:11:48,900 --> 00:11:53,100
サーバー上にある解決
どのコマンドを経由して？

255
00:11:53,100 --> 00:11:57,700
chmodの、それがなら、確かに、アクセス権
ファイルまたはディレクトリに発行します。

256
00:11:57,700 --> 00:11:59,220
>> ROBボーデン：その後404が見つかりません。

257
00:11:59,220 --> 00:12:03,100

258
00:12:03,100 --> 00:12:03,470
うん。

259
00:12:03,470 --> 00:12:10,150
だから、302とは異なり、それは正確ではなかった場合、
あなたが求めているが、それは何を知っている場合、

260
00:12:10,150 --> 00:12:12,710
あなたが欲しい、これは、それだけであります
あなたが望むものは考えていません。

261
00:12:12,710 --> 00:12:15,648
そして、あなたは要求していない
有効な何か。

262
00:12:15,648 --> 00:12:18,580

263
00:12:18,580 --> 00:12:22,310
418私は、ティーポットだと
500内部サーバ。

264
00:12:22,310 --> 00:12:24,870
では、なぜあなたはそれを得るかもしれない？

265
00:12:24,870 --> 00:12:26,120
>> そうセグメンテーションフォルト - 

266
00:12:26,120 --> 00:12:28,760

267
00:12:28,760 --> 00:12:30,640
私は実際に等級を知らない
このための標準。

268
00:12:30,640 --> 00:12:34,850
しかし、あなたのPHPコードが何かを持っていた場合
それは、理論的には間違った可能性が

269
00:12:34,850 --> 00:12:39,650
実際に、この場合には、これをセグメンテーション違反
500内部サーバーエラー、何か

270
00:12:39,650 --> 00:12:41,400
サーバーのに問題がある
コンフィギュレーション。

271
00:12:41,400 --> 00:12:44,320
または構文エラーがあります
PHPコード内。

272
00:12:44,320 --> 00:12:46,095
または何か悪いことが起こっている。

273
00:12:46,095 --> 00:12:48,320
>> DAVID J.マラン：私たちは、セグメンテーションフォルトを見た
少数の人々の答えの中で。

274
00:12:48,320 --> 00:12:49,490
技術的に、それが起こる可能性があります。

275
00:12:49,490 --> 00:12:53,820
しかし、それは、PHP、プログラムになります
実際に、他の人が書いた

276
00:12:53,820 --> 00:12:57,790
segfaulted、その場合にのみ、それらの人々
めちゃくちゃとでバギーのコードを書きました

277
00:12:57,790 --> 00:13:00,680
そのインタプリタだろう
PHP自体がセグメンテーション違反。

278
00:13:00,680 --> 00:13:06,460
500は、セグメンテーションフォルトのようなものですので、にもかかわらず、
心の中で、それはほとんど常にです

279
00:13:06,460 --> 00:13:10,490
設定ファイルの問題の結果
あなたのWeb​​サーバまたは、ロブが言ったように、

280
00:13:10,490 --> 00:13:13,200
あなたのような構文エラー、
引用符を閉じませんでした。

281
00:13:13,200 --> 00:13:16,180
または、どこかでセミコロンを失った。

282
00:13:16,180 --> 00:13:23,677
>> 読者：だからシャトルPSETのために、私
私はそれをやったときに私がクリックされたらと思います

283
00:13:23,677 --> 00:13:26,300
ブラウザが、何が登場しました、
彼らは白ページと呼んだ。

284
00:13:26,300 --> 00:13:28,056
しかし、それが原因のコードであった。

285
00:13:28,056 --> 00:13:29,440
私はJavaScriptのだったと思いますよね？

286
00:13:29,440 --> 00:13:29,770
>> ROBボーデン：うん。

287
00:13:29,770 --> 00:13:31,180
>> 観客：だろうとエラー
まだ出てくる？

288
00:13:31,180 --> 00:13:34,290
>> ROBボーデン：だから得なかったであろう
このエラーのため、すべて

289
00:13:34,290 --> 00:13:36,930
Webサーバの視点から
完全に大丈夫だった。

290
00:13:36,930 --> 00:13:39,090
しかし、あなたはindex.htmlに要請した。

291
00:13:39,090 --> 00:13:42,000
あなたはshuttle.jsを要請
とservice.js。

292
00:13:42,000 --> 00:13:44,580
そして、それは成功して戻ることができた
もしそれらのもののすべてに - 

293
00:13:44,580 --> 00:13:44,980
200。

294
00:13:44,980 --> 00:13:45,680
[OK]をクリックします。

295
00:13:45,680 --> 00:13:49,330
お使いのブラウザがしようとしたときにのみです
JavaScriptコードを解釈すること

296
00:13:49,330 --> 00:13:51,370
それはようなものだ、待って、これではありません
有効なJavaScriptエラー。

297
00:13:51,370 --> 00:13:55,720

298
00:13:55,720 --> 00:13:58,210
その他のご質問は？

299
00:13:58,210 --> 00:14:00,750
わかりました。

300
00:14:00,750 --> 00:14:04,120
>> DAVID J.マラン：だから、次の
アップは数11であった。

301
00:14:04,120 --> 00:14:07,610
そして11は怖いだった
多くの人々のために。

302
00:14:07,610 --> 00:14:14,620

303
00:14:14,620 --> 00:14:18,570
だから、最も重要なことは、ここで注意すべき
これは、確かに、としていたということでした

304
00:14:18,570 --> 00:14:19,840
双方向リンクリスト。

305
00:14:19,840 --> 00:14:23,160
しかし、これは昨年のと同じではありませんでした
双方向リンクリストの問題、

306
00:14:23,160 --> 00:14:27,170
これはあなたに警告を与えていないこと
リストは、実際には、ソートされていない可能性があります。

307
00:14:27,170 --> 00:14:29,640
>> リストがソートされていないとなるように、事実
その言葉があったという事実

308
00:14:29,640 --> 00:14:32,930
伝えるためにそこに意味された下線
これは実際には単純化であること

309
00:14:32,930 --> 00:14:35,430
そうであったであろうものの
より困難な問題

310
00:14:35,430 --> 00:14:36,600
長い1。

311
00:14:36,600 --> 00:14:40,760
だからここによくある間違いは、入れていることでした
あなたの1に昨年のソリューション

312
00:14:40,760 --> 00:14:45,580
ページャ、その後やみくもにそのコピー
正しい答えとしてダウン

313
00:14:45,580 --> 00:14:48,520
別の質問に答える
精神面で似ています。

314
00:14:48,520 --> 00:14:51,340
しかし、ここでは微妙
以下のとおりであった。

315
00:14:51,340 --> 00:14:55,200
>> だから1、我々はノードを宣言しており、
ここで通常の方法で定義されている。

316
00:14:55,200 --> 00:14:59,230
その後、我々はリストにはグローバルに定義されている
ポインタはnullに初期化。

317
00:14:59,230 --> 00:15:02,150
そして、明らかに、二つの機能があります
我々はここでのプロトタイプを持って、挿入

318
00:15:02,150 --> 00:15:03,240
および削除します。

319
00:15:03,240 --> 00:15:06,600
そして、我々はここでいくつかのサンプルコードを持っている
挿入の束を行う。

320
00:15:06,600 --> 00:15:09,930
そして、我々が完了するように依頼する
このような中で、以下のインサートの実装

321
00:15:09,930 --> 00:15:14,380
それがリストにNを挿入する方法
一定の時間で、また下線、

322
00:15:14,380 --> 00:15:15,730
でも、すでに存在する場合。

323
00:15:15,730 --> 00:15:20,600
>> だから、挿入することができるという美しさ
一定の時間で、それが意味することである

324
00:15:20,600 --> 00:15:23,060
あなたが挿入する必要があること
新しいノードどこ？

325
00:15:23,060 --> 00:15:23,690
前へ。

326
00:15:23,690 --> 00:15:27,760
だから、少なくとも、ありがたいことに、排除
必要とするように使用される例の1

327
00:15:27,760 --> 00:15:30,520
コー​​ドのより一層のライン、それが行ったように
昨年とさえクラスのときに我々

328
00:15:30,520 --> 00:15:34,040
この種のものを通して話
人間とSOMEとともに

329
00:15:34,040 --> 00:15:35,250
口頭での擬似コード。

330
00:15:35,250 --> 00:15:39,190
だからここに溶液中で、のは飛ばしてみましょう
それには、Visual上を持っている

331
00:15:39,190 --> 00:15:40,480
画面。

332
00:15:40,480 --> 00:15:42,230
>> 我々は次のことをやっていることに注意してください。

333
00:15:42,230 --> 00:15:45,140
また、他の簡素化に気付く
それはだ場合でも、ということでした

334
00:15:45,140 --> 00:15:48,280
既に存在しているので、これはあっても、意味
番号は、あなたができる、そこに既にある

335
00:15:48,280 --> 00:15:50,280
ただやみくもに別のものを挿入する
そのコピー。

336
00:15:50,280 --> 00:15:52,560
そして、それは、あまりにも、であることを意図した
簡素化、あなたができるように

337
00:15:52,560 --> 00:15:54,940
本当に、より多くのいくつかに焦点を合わせる
知的興味深い部分と

338
00:15:54,940 --> 00:15:58,090
だけではなく、いくつかの追加のエラーチェック
限られた時間を与えられた。

339
00:15:58,090 --> 00:16:02,880
>> したがって、この試料溶液中に、我々は、割り当てる
左側にポインタ

340
00:16:02,880 --> 00:16:04,510
ノードへのこちら側。

341
00:16:04,510 --> 00:16:07,190
今、として、そのポインタを実現
ロブは言った、唯一の32ビットです。

342
00:16:07,190 --> 00:16:09,060
そして、それは実際には含まれていません
あなたまでのアドレス

343
00:16:09,060 --> 00:16:09,970
それにアドレスを割り当てる。

344
00:16:09,970 --> 00:16:13,220
そして、我々は右側にそれを行う
malloc関数を介してサイド。

345
00:16:13,220 --> 00:16:16,550
善良な市民と同じように、我々はそれを確認してください
ようにmalloc関数は、実際には、nullではない

346
00:16:16,550 --> 00:16:18,690
我々は誤って作成しないでください
ここにセグメンテーションフォルト。

347
00:16:18,690 --> 00:16:22,840
あなたは、生活の中であなたをmalloc関数を使用して、いつでも
ないように、NULLをチェックする必要があります

348
00:16:22,840 --> 00:16:24,090
あなたは微妙なバグがあります。

349
00:16:24,090 --> 00:16:28,460
>> その後、我々はして、そのヌルを初期化する
Nと前後の割り当て。

350
00:16:28,460 --> 00:16:32,450
そして、ここで、この場合、私は初期化さ
この新しいため、ヌル前

351
00:16:32,450 --> 00:16:34,780
ノードは、新しいことを行っている
私のリストの先頭。

352
00:16:34,780 --> 00:16:37,050
そうであるように起こって
その前に何もない。

353
00:16:37,050 --> 00:16:42,010
そして、私は、基本的に追加したい
による新しいノードに既存のリスト

354
00:16:42,010 --> 00:16:44,700
自分自身をリストの横に等しく設定する。

355
00:16:44,700 --> 00:16:47,120
しかし、私はちょうどまだいないよ。

356
00:16:47,120 --> 00:16:51,780
リスト自体はすでに存在し、その場合は
および少なくとも1つのノードが存在した

357
00:16:51,780 --> 00:16:57,070
既に配置され、これは、リストの場合は
ここに、私は私が、ここに新しいノードを挿入

358
00:16:57,070 --> 00:17:01,840
ていることを確認する必要が私の元のノード
私の新しいノードに後方を指し、

359
00:17:01,840 --> 00:17:04,260
これは、再び、であるので
双方向リンクリスト。

360
00:17:04,260 --> 00:17:05,460
>> だから我々は、健全性チェックを行う。

361
00:17:05,460 --> 00:17:10,109
既にがあるかどうリストは、NULLでない場合
そこつまたは複数のノード、

362
00:17:10,109 --> 00:17:12,470
いわばその後方参照を追加します。

363
00:17:12,470 --> 00:17:15,420
そして、我々が必要とする非常に最後の事
行うには、実際にはグローバルを更新している

364
00:17:15,420 --> 00:17:20,329
ポイントに変数リストそのもの
その新しいノードに。

365
00:17:20,329 --> 00:17:21,790
うん。

366
00:17:21,790 --> 00:17:26,579
>> 読者：ポインタアロー
[聞こえない]ことを行い、ヌルに等しい

367
00:17:26,579 --> 00:17:30,420
リストに対処するため、
リストがnullの？

368
00:17:30,420 --> 00:17:30,596
>> DAVID J.マラン：いいえ。

369
00:17:30,596 --> 00:17:34,500
それは単に私が積極的にされている
これは私の場合は、その中で、慎重に

370
00:17:34,500 --> 00:17:38,730
おそらくいくつかのノードを持つ元のリスト
こことかけて私は私のを挿入しています

371
00:17:38,730 --> 00:17:42,380
こっちに新しいノード、そこに起こっている
こっちには何もありません。

372
00:17:42,380 --> 00:17:44,720
そして、私はその考えを捕獲したい
前に設定することにより

373
00:17:44,720 --> 00:17:47,740
新しいノードではnullを返します。

374
00:17:47,740 --> 00:17:51,410
おそらく、私のコードが正しい場合
を挿入する他の方法はありません

375
00:17:51,410 --> 00:17:54,970
この関数以外のノード、
おそらく、リストが既に持っている場合でも、

376
00:17:54,970 --> 00:18:00,090
その内の1つ以上のノード、おそらく
リストは、最初のノードが有するであろう

377
00:18:00,090 --> 00:18:02,750
ヌル自体の前のポインタ。

378
00:18:02,750 --> 00:18:03,550
>> 観客：そして、ちょうどフォローアップ。

379
00:18:03,550 --> 00:18:08,139
あなたは次の等号ポインタ置く理由
リストには、ポインタを作っているされている

380
00:18:08,139 --> 00:18:13,579
リストの前にそれが指しているという点で、
次の、私は推測する - 

381
00:18:13,579 --> 00:18:14,980
私はドント - 

382
00:18:14,980 --> 00:18:15,450
ただ一覧表示されます？

383
00:18:15,450 --> 00:18:16,400
>> DAVID J.マラン：その通りです。

384
00:18:16,400 --> 00:18:19,400
そしてそれでは、実際に2例を考えてみましょう
ここでは本当に、たとえ

385
00:18:19,400 --> 00:18:22,070
我々は彼らを検討します順番はありません
コー​​ドと全く同じ。

386
00:18:22,070 --> 00:18:26,250
しかし、これが表すハイレベルで、場合に
リストは、これは32ビットである

387
00:18:26,250 --> 00:18:29,560
ポインタで、最も単純なシナリオ
これは、デフォルトではNULLであること。

388
00:18:29,560 --> 00:18:33,010
そして、私は挿入する必要があると
番号50は、最初の数字だった。

389
00:18:33,010 --> 00:18:37,640
だから私は先に行くと割り当てるつもりです
含まれているために起こっているノード、

390
00:18:37,640 --> 00:18:38,770
3フィールド - 

391
00:18:38,770 --> 00:18:42,070
N、以前、次。

392
00:18:42,070 --> 00:18:44,580
>> 私は、数50を入れるつもりです
ここで、これはNになりますので。

393
00:18:44,580 --> 00:18:46,130
これは、次となります。

394
00:18:46,130 --> 00:18:48,530
そして、これは、前になります。

395
00:18:48,530 --> 00:18:50,910
そして私は、この場合には何をしますか？

396
00:18:50,910 --> 00:18:53,900
まあ、私はちょうどここに1行目をやった。

397
00:18:53,900 --> 00:18:55,400
ポインタnは、nを取得します。

398
00:18:55,400 --> 00:18:57,740
私は、以前、言っている
ヌル取得する必要があります。

399
00:18:57,740 --> 00:18:59,470
だから、これはNULLであることを行っている。

400
00:18:59,470 --> 00:19:01,365
それから私は、次の言おうとしています
リストを取得する予定です。

401
00:19:01,365 --> 00:19:05,150
>> そして、これは単にうまく動作します。

402
00:19:05,150 --> 00:19:06,500
これはnullになります。

403
00:19:06,500 --> 00:19:10,620
だから私は、新しいノードの次の、言っている
フィールドは、これが何であれ取得する必要があります。

404
00:19:10,620 --> 00:19:12,570
だから、そこに別のヌルを置きます。

405
00:19:12,570 --> 00:19:14,510
そして、最後の事
私はここでチェックしているん。

406
00:19:14,510 --> 00:19:17,870
リストはNULLに等しくない場合、それ
ヌルに等しいので、我々はそれをスキップ

407
00:19:17,870 --> 00:19:18,470
完全に。

408
00:19:18,470 --> 00:19:23,520
だから私はすべてが次のリストを取得で
絵画的になり、ポインタ、

409
00:19:23,520 --> 00:19:25,570
そのような絵。

410
00:19:25,570 --> 00:19:26,620
だから、1のシナリオだ。

411
00:19:26,620 --> 00:19:30,490
>> そして、あなたが知っ求めていた1
特にこのような状況があり、

412
00:19:30,490 --> 00:19:33,190
我々はすでに1ノードリストを持っているところ。

413
00:19:33,190 --> 00:19:36,240
そして私は、元に戻って上がる場合は、
問題文は、我々は次のよ

414
00:19:36,240 --> 00:19:39,320
インサートはちょうどのために、34であると言う
議論のために。

415
00:19:39,320 --> 00:19:46,210
だから、僕は、便利に行くよ
こっちそれを描く。

416
00:19:46,210 --> 00:19:47,540
私はmallocさだ。

417
00:19:47,540 --> 00:19:49,310
のは、私がnullのチェックをしていたとする。

418
00:19:49,310 --> 00:19:51,870
>> 今、私は初期化す​​るつもりだ
N 34であると。

419
00:19:51,870 --> 00:19:53,040
そして、これはNになります。

420
00:19:53,040 --> 00:19:54,670
これは、次となります。

421
00:19:54,670 --> 00:19:57,100
そして、これは、前になります。

422
00:19:57,100 --> 00:19:59,370
の私はなかったことを確認してみましょう
後方これを取得。

423
00:19:59,370 --> 00:20:01,110
前回は最初に来る
定義中。

424
00:20:01,110 --> 00:20:03,070
私は、この問題を修正しましょう​​。

425
00:20:03,070 --> 00:20:04,410
これは、前のです。

426
00:20:04,410 --> 00:20:05,780
これは隣接しています。

427
00:20:05,780 --> 00:20:08,620
これらが同一であるにもかかわらず、
一貫性のないところに保管してみましょう。

428
00:20:08,620 --> 00:20:09,450
>> 前。

429
00:20:09,450 --> 00:20:11,030
これは隣接しています。

430
00:20:11,030 --> 00:20:16,310
だから、僕はチェックし、私のノートをmallocさだ
nullを、ノードに34を割り当てました。

431
00:20:16,310 --> 00:20:17,570
前回はnullを取得します。

432
00:20:17,570 --> 00:20:19,480
だから私にそれを与えます。

433
00:20:19,480 --> 00:20:21,010
次のリストを取得します。

434
00:20:21,010 --> 00:20:22,370
だから、リストはこれです。

435
00:20:22,370 --> 00:20:26,520
だから、これは今、これを図面と同じである
彼らは1を指すように、矢印

436
00:20:26,520 --> 00:20:27,940
同じ中。

437
00:20:27,940 --> 00:20:30,400
そして私はチェックしていたら、リスト
NULLと同じではありません。

438
00:20:30,400 --> 00:20:31,740
そして、それはこの時点ではありません。

439
00:20:31,740 --> 00:20:35,580
それから私は、リストをするつもりです
以前はポインターを取得します。

440
00:20:35,580 --> 00:20:39,700
>> だから、前のリストPTRを取得します。

441
00:20:39,700 --> 00:20:44,300
だから、これは置くことの効果があります
ここグラフィカル矢印。

442
00:20:44,300 --> 00:20:46,930
そして、それは少しなってきた
波状、ライン。

443
00:20:46,930 --> 00:20:50,780
そして、最後に、私が更新
ポインタを指すように一覧表示します。

444
00:20:50,780 --> 00:20:55,560
だから今これがこの男を指しています。

445
00:20:55,560 --> 00:20:57,170
そして今、のは、迅速にやらせる
健全性チェック。

446
00:20:57,170 --> 00:20:59,470
>> ここにあるリストは、です
グローバル変数。

447
00:20:59,470 --> 00:21:02,850
最初のノードは、実際に、34なぜなら
私はその矢印を次のよ。

448
00:21:02,850 --> 00:21:05,210
私がしたいので、それが正しいです
リストの先頭に挿入します

449
00:21:05,210 --> 00:21:06,070
すべての新しいノード。

450
00:21:06,070 --> 00:21:08,860
彼の次のフィールドは、この男に私をリードしています。

451
00:21:08,860 --> 00:21:10,710
私が続けるなら、私は次のヒットnullです。

452
00:21:10,710 --> 00:21:11,760
だから、これ以上のリストがありません。

453
00:21:11,760 --> 00:21:14,460
私は以前にヒットした場合、私が取得
私は期待してどこにバックアップします。

454
00:21:14,460 --> 00:21:16,435
>> だから、いくつかのポインタが残っています、
明らかに、操作する。

455
00:21:16,435 --> 00:21:19,870
しかし、あなたが何を言われたという事実
これは、一定の時間内にあなただけを意味し、

456
00:21:19,870 --> 00:21:22,910
物事の有限数を有する
あなたが行うには許可しています。

457
00:21:22,910 --> 00:21:24,290
その数は何ですか？

458
00:21:24,290 --> 00:21:25,185
それは一歩かもしれません。

459
00:21:25,185 --> 00:21:25,700
これは、2かもしれません。

460
00:21:25,700 --> 00:21:26,820
それは千のステップかもしれません。

461
00:21:26,820 --> 00:21:30,500
しかし、それはあなたができないことを意味している、有限だ
ループのいずれかの種類が起こっている

462
00:21:30,500 --> 00:21:32,010
ここでは、再帰なし、なしのループ。

463
00:21:32,010 --> 00:21:37,390
それは、単にハードコードされた行があるはずだ
我々は、このサンプルで持っているように、コードの。

464
00:21:37,390 --> 00:21:42,330
>> だから、次の問題12は、私たちを尋ねた
削除の実装を完了

465
00:21:42,330 --> 00:21:46,740
それが削除されるような方法で、以下の
線形時間のリストからN。

466
00:21:46,740 --> 00:21:48,740
だから、もう少しを持っている
余地になりました。

467
00:21:48,740 --> 00:21:52,380
存在する場合には、そのNをとることができる
リストに、存在するであろう

468
00:21:52,380 --> 00:21:53,340
一回に過ぎない。

469
00:21:53,340 --> 00:21:56,770
あまりにもクイズ系であることを意味すること
単純化した仮定なので、

470
00:21:56,770 --> 00:21:59,780
それは、番号50のどこかを発見した場合
リストで、あなたもしません

471
00:21:59,780 --> 00:22:02,890
し続けることを心配する必要はあり
あらゆる可能な探して、繰り返し処理

472
00:22:02,890 --> 00:22:06,990
ただ委譲う50のコピー、
限られた時間の中で、いくつかの特徴点に。

473
00:22:06,990 --> 00:22:10,460
>> だから削除して、この1は間違いだった
より挑戦的かつ詳細

474
00:22:10,460 --> 00:22:11,640
書き込むためのコード。

475
00:22:11,640 --> 00:22:14,990
しかし、一見すると、率直に言って、それは可能性がある
圧倒的と次のようになり

476
00:22:14,990 --> 00:22:17,060
あなたが持つことができる方法はありません
クイズに思い付く。

477
00:22:17,060 --> 00:22:22,450
しかし、我々は個々のステップに焦点を当てた場合、
うまくいけば、それは突然ます

478
00:22:22,450 --> 00:22:26,060
これらの個々のそれぞれのことを打つ
手順は、明らかな意味があります

479
00:22:26,060 --> 00:22:27,080
振り返ってみると。

480
00:22:27,080 --> 00:22:28,200
それでは見てみましょう。

481
00:22:28,200 --> 00:22:32,570
>> だからまず、ポインタを初期化
であるとすること自体を一覧表示します。

482
00:22:32,570 --> 00:22:36,040
私は線形時間をしたいので、その手段
私はいくつかのループを持っているつもりです。

483
00:22:36,040 --> 00:22:39,730
そして一般的な方法は、反復するために
リスト構造や、あらゆる種類のノード

484
00:22:39,730 --> 00:22:43,860
構造を反復取ることです
データの先頭へのポインタ

485
00:22:43,860 --> 00:22:46,990
構造と、ちょうど更新を開始
ITとあなたの道を歩く

486
00:22:46,990 --> 00:22:48,650
データ構造を通る。

487
00:22:48,650 --> 00:22:50,040
だから私はまさにそれをするつもりです。

488
00:22:50,040 --> 00:22:54,260
>> ポインタしばらく、私の一時変数、
みましょう、NULLと等しくない

489
00:22:54,260 --> 00:22:55,660
先に行くとチェックしてください。

490
00:22:55,660 --> 00:22:56,910
私は幸運でしたか？

491
00:22:56,910 --> 00:23:01,740
私は現在、私のノードでNフィールドです
に等しく見

492
00:23:01,740 --> 00:23:03,380
番号は私が探しています？

493
00:23:03,380 --> 00:23:05,410
もしそうなら、のは何かをしてみましょう。

494
00:23:05,410 --> 00:23:10,020
今、このことを気づいた場合は、条件
全体を囲んで

495
00:23:10,020 --> 00:23:11,520
次のコード行。

496
00:23:11,520 --> 00:23:14,610
これは私が気に唯一のものです - 
問題の番号を見つける。

497
00:23:14,610 --> 00:23:18,010
そう単純化する、全く他にありません
概念的に物事を少し。

498
00:23:18,010 --> 00:23:22,040
>> しかし、今、私が実現し、あなたが持っているかもしれません
だけを考えた後、これを実現

499
00:23:22,040 --> 00:23:24,720
それは少しを通して、そこ
実際にここ2例。

500
00:23:24,720 --> 00:23:28,060
ノードがであるものである
あるリストの先頭

501
00:23:28,060 --> 00:23:31,040
それだから、少し迷惑
特別な場合には、対処する必要があるため

502
00:23:31,040 --> 00:23:33,340
この事で、どの
唯一の異常である。

503
00:23:33,340 --> 00:23:35,720
他のどこでも、リスト内の、
それは同じことだ。

504
00:23:35,720 --> 00:23:38,050
前のノードと次があります
ノード、前のノード、次のノード。

505
00:23:38,050 --> 00:23:40,940
しかし、この男は少し特殊です
彼が先頭にいた場合。

506
00:23:40,940 --> 00:23:48,710
>> そう、ポインタがリストと等しい場合
それ自体、私はの先頭にいたら

507
00:23:48,710 --> 00:23:53,960
リストとI nは発見した、私が必要
物事のカップルをすることができません。

508
00:23:53,960 --> 00:23:59,230
一つは、私はにリストを変更する必要があります
次のフィールドをポイントし、50。

509
00:23:59,230 --> 00:24:01,270
だから私はしようとしていると仮定
34を削除します。

510
00:24:01,270 --> 00:24:03,560
だから、この男の行くようになった
わずか瞬間に。

511
00:24:03,560 --> 00:24:07,210
>> だから私は言うつもりは、リスト
次のポインタを取得します。

512
00:24:07,210 --> 00:24:08,570
まあ、これはポインタです。

513
00:24:08,570 --> 00:24:10,360
次のこっちを向いている。

514
00:24:10,360 --> 00:24:17,470
だから、これはこの矢印を右に変化している
今ここにこの男を指すように設定します。

515
00:24:17,470 --> 00:24:19,580
今、我々が持っている、覚えている
一時変数。

516
00:24:19,580 --> 00:24:23,520
だから我々は、あらゆるノードが孤立していないが、
私も、私の中でこの男を持っているので、

517
00:24:23,520 --> 00:24:25,010
削除の実装。

518
00:24:25,010 --> 00:24:29,600
だから今、リスト自体がnullでない場合、
私は少し何かを修正する必要があります。

519
00:24:29,600 --> 00:24:32,690
>> 私は今、必ずこの矢印ことを確認する必要があり、
以前に指している

520
00:24:32,690 --> 00:24:36,830
50から34に、これは離れて行くようになっており、
ので、私は取り除くためにしようとしている場合は、

521
00:24:36,830 --> 00:24:41,910
34、50はいずれも維持し、より良いしていなかった
としてそれを後方参照の種類

522
00:24:41,910 --> 00:24:42,820
矢印が示唆された。

523
00:24:42,820 --> 00:24:44,820
だから、僕は、この行をしました。

524
00:24:44,820 --> 00:24:46,520
だから、私は行われています。

525
00:24:46,520 --> 00:24:48,040
その場合は、実際にはかなり簡単です。

526
00:24:48,040 --> 00:24:51,010
リストの先頭を切っチョッピング
比較的簡単である。

527
00:24:51,010 --> 00:24:52,980
>> 残念ながら、これがあります
迷惑なelseブロック。

528
00:24:52,980 --> 00:24:56,170
だから今、私はケースを考慮する必要があります
途中で何かがある場所。

529
00:24:56,170 --> 00:24:59,880
しかし、それは除いて、あまりにもひどいではありません
このような構文のために。

530
00:24:59,880 --> 00:25:03,080
だから私はの先頭にいないよ場合は、
リストは、私がどこか真ん中にいるよ。

531
00:25:03,080 --> 00:25:08,160
そして、ここでこのラインは、言っているスタート
どのようなノードでは、にいる。

532
00:25:08,160 --> 00:25:11,210

533
00:25:11,210 --> 00:25:18,550
前のノードの次のフィールドに移動
ポインタでそれを指摘している。

534
00:25:18,550 --> 00:25:20,390
>> それでは絵でこれをやってみましょう。

535
00:25:20,390 --> 00:25:21,640
それは複雑になっていた。

536
00:25:21,640 --> 00:25:30,480

537
00:25:30,480 --> 00:25:37,990
だから私はここに、前のフィールドを持っている場合 - 
それでは、これをやらせる - ここに、次のフィールド。

538
00:25:37,990 --> 00:25:41,200
私はむしろ私のポインタを簡素化するつもりだ
の全体の束を描くよりも

539
00:25:41,200 --> 00:25:45,710
物事は前後に縦横に
お互い。

540
00:25:45,710 --> 00:25:50,870
そして今、ちょうどこれは、1、2であるとしましょう
でも、議論のために3、

541
00:25:50,870 --> 00:25:53,410
それはと整列しませんが
問題となっている問題。

542
00:25:53,410 --> 00:25:55,900
>> だからここに私のリンクリストです。

543
00:25:55,900 --> 00:25:59,300
私はこれで2を削除しようとしています
物語の特定のバージョン。

544
00:25:59,300 --> 00:26:01,960
だから私は、体へのポインタを更新しました
この男を指している。

545
00:26:01,960 --> 00:26:03,315
だから、これは、PTRです。

546
00:26:03,315 --> 00:26:04,530
彼はここに指している。

547
00:26:04,530 --> 00:26:07,170
これは、リストされ、存在している
世界的に前と同じように。

548
00:26:07,170 --> 00:26:09,200
そして、彼は何があって、ここで指しているんだ。

549
00:26:09,200 --> 00:26:10,800
そして今、私は2を削除しようとしている。

550
00:26:10,800 --> 00:26:13,850
>> ポインタが、ここで指しているのであれば、私は今
、明らかに、従うつもり

551
00:26:13,850 --> 00:26:17,110
1で私を置き、前のポインタ。

552
00:26:17,110 --> 00:26:22,290
私は次のことを言おうとしています
これに私をもたらし、フィールド、

553
00:26:22,290 --> 00:26:25,410
ここBOX、しようとしている
等しいポインタの横。

554
00:26:25,410 --> 00:26:28,400
このポインタのであれば、これが隣接しています。

555
00:26:28,400 --> 00:26:31,840
つまりつまり、この矢印ニーズ
この男を指すように設定します。

556
00:26:31,840 --> 00:26:35,140
>> だから、このコード行は、単に何を持っている
この少しはあるに行わ。

557
00:26:35,140 --> 00:26:37,500
そして今、これはのように探しています
正しい方向への一歩。

558
00:26:37,500 --> 00:26:41,390
私たちは、基本的に2つを切り取るたい
1および3の中央。

559
00:26:41,390 --> 00:26:44,400
だから、私たちがしたいことを理にかなっている
その周りにルートこのポインタを。

560
00:26:44,400 --> 00:26:50,400
ポインタのであれば、この次の行がチェックしている
次のnullでない、そこ

561
00:26:50,400 --> 00:26:54,200
2の右に実際に誰かが、
つまり、我々はまたしなければならないことを意味

562
00:26:54,200 --> 00:26:55,850
ここで少しスニップ。

563
00:26:55,850 --> 00:27:00,590
>> だから私は今、このポインターを実行する必要があります
そして、前のポインタを上に更新する

564
00:27:00,590 --> 00:27:05,410
の少しを行うにはこの男
回避策はここにここでのポイント。

565
00:27:05,410 --> 00:27:07,100
そして今、視覚的にこれがいいです。

566
00:27:07,100 --> 00:27:11,930
があることで、それは少し厄介なの
もう2を指して誰も。

567
00:27:11,930 --> 00:27:13,600
2は左を指している。

568
00:27:13,600 --> 00:27:14,980
そして2右を指している。

569
00:27:14,980 --> 00:27:17,480
しかし、彼は、彼が望んでいるものは何でもできますので、
彼は解放された取得することについてです。

570
00:27:17,480 --> 00:27:19,480
そして、それはどのような問題ではありません
これらの値はもうある。

571
00:27:19,480 --> 00:27:23,040
>> 重要なのは、残りのことです
男は、上のルーティングされる

572
00:27:23,040 --> 00:27:24,280
そして今、彼下記。

573
00:27:24,280 --> 00:27:25,810
そして実際、それは我々が次の仕事だ。

574
00:27:25,810 --> 00:27:29,360
私たちが知ることを意味我々フリーポインタ、
オペレーティングシステムは、あなたを歓迎します

575
00:27:29,360 --> 00:27:30,906
これを再利用する。

576
00:27:30,906 --> 00:27:34,900
した後、最後に、我々は戻って。

577
00:27:34,900 --> 00:27:37,220
我々の場合、暗黙のうちに他の
まだ戻っていない、

578
00:27:37,220 --> 00:27:38,290
私たちは探し続けるようになってきました。

579
00:27:38,290 --> 00:27:41,485
だから、ポインタは単に次のポインタに等しい
ここでこの男を動かすことを意味します。

580
00:27:41,485 --> 00:27:42,600
ここでこの男を移動します。

581
00:27:42,600 --> 00:27:45,400
ここでこの男を移動すると、実際には、
私たちは番号を見つけることができませんでした

582
00:27:45,400 --> 00:27:46,960
我々はまだ探しています。

583
00:27:46,960 --> 00:27:49,630
>> そう率直に言って、それが完全に見える
最初は、私が思うに、圧倒的

584
00:27:49,630 --> 00:27:52,180
あなたが苦労している場合は特に一見、
これでクイズ中にして参照してください。

585
00:27:52,180 --> 00:27:52,850
このようなもの。

586
00:27:52,850 --> 00:27:55,050
そして、あなたは背中に自分自身をなでる。

587
00:27:55,050 --> 00:27:57,080
さて、私が持っていることができる方法はありません
クイズでその思い付く。

588
00:27:57,080 --> 00:28:00,470
あなたが壊れている場合、私はあなたができる、と主張するだろう
これらの個々にそれダウン

589
00:28:00,470 --> 00:28:04,400
ただ例で、それを歩く
慎重に、確かに、とはいえ、下

590
00:28:04,400 --> 00:28:06,300
ストレスの多い状況。

591
00:28:06,300 --> 00:28:09,470
>> ありがたいことに、画像が作ら
幸せのすべて。

592
00:28:09,470 --> 00:28:11,050
あなたはこれを引くことができ
任意の数の方法。

593
00:28:11,050 --> 00:28:12,760
あなたが十字交差を行う必要はありません
ここの事。

594
00:28:12,760 --> 00:28:14,520
あなたはストレートでそれを行うことができます
このような行。

595
00:28:14,520 --> 00:28:18,790
しかし、この問題の要旨、
一般的には、ことを実現することでした

596
00:28:18,790 --> 00:28:22,060
最終的に画像が少しになります
なぜなら、このようなもの、

597
00:28:22,060 --> 00:28:25,030
時定数は、あなたが保持することを暗示
ジャミングや妨害と妨害

598
00:28:25,030 --> 00:28:29,900
先頭に新しいノードを
リストの。

599
00:28:29,900 --> 00:28:31,960
ご質問？

600
00:28:31,960 --> 00:28:34,565
おそらく最も挑戦
確かに、コードの質問。

601
00:28:34,565 --> 00:28:37,690
>> 観客：そうのようなリストがある
前の例でのヘッド。

602
00:28:37,690 --> 00:28:39,640
>> DAVID J.マラン：その通り、その通りです。

603
00:28:39,640 --> 00:28:43,130
のためだけに別の名前
グローバル変数。

604
00:28:43,130 --> 00:28:44,380
世界的な何？

605
00:28:44,380 --> 00:28:48,880

606
00:28:48,880 --> 00:28:49,730
>> ROBボーデン：わかりました。

607
00:28:49,730 --> 00:28:52,020
だから、これはどこに1です
段落を書かなければならなかった。

608
00:28:52,020 --> 00:28:56,060
一部の人々は、エッセイを書きました
この質問のために。

609
00:28:56,060 --> 00:29:00,230
しかし、あなたはちょうどこれらの6の用語を使用する必要があります
ときに何が起こるかを説明する

610
00:29:00,230 --> 00:29:02,440
あなたはfacebook.comに連絡してみてください。

611
00:29:02,440 --> 00:29:07,930
だから、僕はプロセスを介して話をしましょう
すべてのこれらの用語を使用して。

612
00:29:07,930 --> 00:29:11,290
だから私たちのブラウザでは、我々はfacebook.comを入力
そしてEnterキーを押します。

613
00:29:11,290 --> 00:29:17,280
だから私たちのブラウザは、構築するために起こっている
それは送信するために起こっていることを、HTTPリクエスト

614
00:29:17,280 --> 00:29:22,220
のためのFacebookへいくつかの過程を経て
との私達に応えるためにFacebook

615
00:29:22,220 --> 00:29:24,450
そのページのHTML。

616
00:29:24,450 --> 00:29:28,800
>> だから、プロセスはで何
そのHTTPリクエスト

617
00:29:28,800 --> 00:29:30,730
実際にFacebookに取得する？

618
00:29:30,730 --> 00:29:32,790
だからまず、翻訳する必要があり
Facebook.com。

619
00:29:32,790 --> 00:29:38,780
だから、名前Facebook.com与え
実際にHTTPリクエストを行う場合、

620
00:29:38,780 --> 00:29:39,940
行く必要がある？

621
00:29:39,940 --> 00:29:44,120
だから我々はFacebook.comを変換する必要があります
一意のIPアドレスに

622
00:29:44,120 --> 00:29:47,620
どのようなマシンたちが実際に識別
この要求を送信する。

623
00:29:47,620 --> 00:29:49,310
あなたのラップトップは、IPアドレスを持っています。

624
00:29:49,310 --> 00:29:52,240
インターネットに接続されているものは
IPアドレスを持っています。

625
00:29:52,240 --> 00:29:59,030
>> だからDNSは、ドメインネームシステム、すなわち、
何が翻訳を扱うために起こっている

626
00:29:59,030 --> 00:30:03,750
facebook.comからそのIPアドレスに
あなたは、実際に連絡を取りたい。

627
00:30:03,750 --> 00:30:08,075
だから我々は、DNSサーバーに問い合わせて、
たとえば、facebook.comは何ですか？

628
00:30:08,075 --> 00:30:16,560
それは、ああ、それはIPアドレス190.212だ、と言う
何か、何か、何か。

629
00:30:16,560 --> 00:30:16,900
わかりました。

630
00:30:16,900 --> 00:30:18,850
今、私は知っているマシン
私が連絡したいと思います。

631
00:30:18,850 --> 00:30:22,360
>> だから、あなたはあなたのHTTPリクエストを送信する
そのマシンにフェイルオーバ。

632
00:30:22,360 --> 00:30:24,140
それでは、どのように、そのマシンに到達するのでしょうか？

633
00:30:24,140 --> 00:30:27,200
さて、リクエストがから行く
バウンスルータにルータ。

634
00:30:27,200 --> 00:30:32,630
ここで、クラスの例を覚えている
私たちは実際にルートを見た

635
00:30:32,630 --> 00:30:35,340
私たちがしようとしたときのパケットがかかった
通信します。

636
00:30:35,340 --> 00:30:38,460
我々は、大西洋を飛び越えた
1点または任意のオーシャン。

637
00:30:38,460 --> 00:30:42,820
>> だから、最後の項ポート。

638
00:30:42,820 --> 00:30:46,520
これは、お使いのコンピュータに保存されました。

639
00:30:46,520 --> 00:30:49,970
現在、複数のものを持つことができます
インターネットとの通信。

640
00:30:49,970 --> 00:30:53,730
だから私は、言う、スカイプを実行することができます。

641
00:30:53,730 --> 00:30:55,670
私は、Webブラウザを開いている場合があります。

642
00:30:55,670 --> 00:30:59,010
私は何かを持っているかもしれません
BitTorrentにファイル。

643
00:30:59,010 --> 00:31:00,880
したがって、すべてのこれらの事である
との通信

644
00:31:00,880 --> 00:31:02,600
何らかの方法でインターネット。

645
00:31:02,600 --> 00:31:08,070
>> だからあなたのコンピュータは、いくつかのデータを受信したとき
インターネットから、どのようにそれはありません

646
00:31:08,070 --> 00:31:10,130
実際にどのようなアプリケーションを知っている
データを望んでいる？

647
00:31:10,130 --> 00:31:12,610
それはどのようにこの特定のかどうかわからない
データは、のためのものです

648
00:31:12,610 --> 00:31:16,070
対照的に、アプリケーションをBitTorrentに
Webブラウザに？

649
00:31:16,070 --> 00:31:20,980
だから、これはその中のポートの目的です
これらのアプリケーションのすべてが持っている

650
00:31:20,980 --> 00:31:22,720
お使いのコンピュータのポートを主張した。

651
00:31:22,720 --> 00:31:27,580
だからあなたのWeb​​ブラウザは、ちょっと、と言う
私は、ポート1000上聞いている。

652
00:31:27,580 --> 00:31:32,240
そして、あなたのBitTorrentにプログラムが言っている、
私は、ポート3000上で聞いている。

653
00:31:32,240 --> 00:31:34,770
とSkypeは、私は、ポート4000を使用しています、と言います。

654
00:31:34,770 --> 00:31:41,950
>> ですから、所属するいくつかのデータを取得するとき
これらの用途の一つは、データの

655
00:31:41,950 --> 00:31:45,510
どのポートが付いているので、実際に
に沿って送信する必要があります。

656
00:31:45,510 --> 00:31:47,950
だから、これはああ、私が所属し、言う
ポート1000。

657
00:31:47,950 --> 00:31:50,950
私は、私はこれを転送する必要が知っている
私のWebブラウザに沿い。

658
00:31:50,950 --> 00:31:56,440
だから、その理由は、それはここでは関係者
Webサーバがする傾向があることである

659
00:31:56,440 --> 00:31:58,240
ポート80をリッスンする。

660
00:31:58,240 --> 00:32:02,420
私はFacebook.comに連絡したとき、私はよ
いくつかのマシンと通信。

661
00:32:02,420 --> 00:32:06,390
しかし、私はそれのどのポートを言う必要がある
私が通信するマシン。

662
00:32:06,390 --> 00:32:09,160
およびWebサーバがある傾向がある
ポート80でリスニングしています。

663
00:32:09,160 --> 00:32:14,010
>> 彼らが望んした場合、彼らはそれを設定することができます
それは、ポート7000上のように一覧表示されますので、最大。

664
00:32:14,010 --> 00:32:19,090
した後、Webブラウザで、私ができた
7000：手動Facebook.comを入力

665
00:32:19,090 --> 00:32:24,600
ポート7000に要求を送信
Facebookのウェブサーバーの。

666
00:32:24,600 --> 00:32:26,820
>> DAVID J.マラン：この場合にも、
我々は人々を必要としませんでしたが

667
00:32:26,820 --> 00:32:30,000
これを言及、この場合は、どのポート
要求が実際に行くか？

668
00:32:30,000 --> 00:32:36,630

669
00:32:36,630 --> 00:32:37,880
もう一度やり直してください。

670
00:32:37,880 --> 00:32:42,810

671
00:32:42,810 --> 00:32:44,300
その通りです。

672
00:32:44,300 --> 00:32:47,960
微妙なものを探しているではなく、
つまり、最後のどれもありません。

673
00:32:47,960 --> 00:32:51,770
>> ROBボーデン：だからHTTPSが、それはですので、
のために特別に聞いて

674
00:32:51,770 --> 00:32:55,180
暗号化され、ポート4430上にある。

675
00:32:55,180 --> 00:32:57,680
>> 観客：E-メール配信は25アール、右？

676
00:32:57,680 --> 00:33:00,670
>> DAVID J.マラン：送信
電子メール、25、うん。

677
00:33:00,670 --> 00:33:03,760
>> ROBボーデン：私も、ほとんどのを知らない
 - 下のもののすべてになりがち

678
00:33:03,760 --> 00:33:06,310
物事のため​​に予約。

679
00:33:06,310 --> 00:33:09,260
私はすべての下で考える
1024は予約されています。

680
00:33:09,260 --> 00:33:13,450
>> 観客：なぜあなたは言った
3は間違った番号でしたか？

681
00:33:13,450 --> 00:33:18,820
>> ROBボーデン：のためのIPアドレス、
数字の4つのグループがあります。

682
00:33:18,820 --> 00:33:21,090
そして、彼らは0から255までだ。

683
00:33:21,090 --> 00:33:28,060
だから、192.168.2.1が一般的です
ローカルネットワークのIPアドレス。

684
00:33:28,060 --> 00:33:30,840
それらのすべてが255未満であることに注意してください。

685
00:33:30,840 --> 00:33:33,570
だから私は300で開始すると、その
おそらく持っていることができませんでした

686
00:33:33,570 --> 00:33:35,210
数字の一つとなって。

687
00:33:35,210 --> 00:33:38,170
>> DAVID J.マラン：しかし、その愚かなクリップ
から - それは彼らが持っていたCSIだった

688
00:33:38,170 --> 00:33:39,970
あまりにも大きかった回数
IPアドレスについて。

689
00:33:39,970 --> 00:33:42,940

690
00:33:42,940 --> 00:33:46,110
>> ROBボーデン：この上の任意の質問？

691
00:33:46,110 --> 00:33:51,710
次の1、で非常に完全な変更
トピックが、我々にはこのPHPの配列を持っている

692
00:33:51,710 --> 00:33:53,270
クワッド内の家々。

693
00:33:53,270 --> 00:33:56,360
そして、我々は順序なしリストを持っている。

694
00:33:56,360 --> 00:33:59,550
そして、我々は各リスト項目を印刷したい
ちょうど家の名前が入っている。

695
00:33:59,550 --> 00:34:09,090

696
00:34:09,090 --> 00:34:11,870
だから我々は、foreachループを持っている。

697
00:34:11,870 --> 00:34:17,540
だから、構文がforeachのですが、覚えている
配列内のアイテムとして配列。

698
00:34:17,540 --> 00:34:22,360
だから、ループの各反復を通じて、
家はの1を取るために起こっている

699
00:34:22,360 --> 00:34:24,060
配列の内部値。

700
00:34:24,060 --> 00:34:26,530
>> 最初の繰り返しでは、家
キャボットハウスになります。

701
00:34:26,530 --> 00:34:30,370
2回目の繰り返し、家になります
というように宅配便の家であることと。

702
00:34:30,370 --> 00:34:34,370
だから、家の各クワッドのために、我々はしている
ただ印刷しようとして - 

703
00:34:34,370 --> 00:34:37,250
また、エコーたかもしれない - 

704
00:34:37,250 --> 00:34:42,199
リスト項目、その後、家の名前
して、リスト項目を閉じます。

705
00:34:42,199 --> 00:34:45,210
中括弧は、ここで省略可能です。

706
00:34:45,210 --> 00:34:49,480
>> そして、我々はまた、問題の中で述べ
それ自体は、クローズするのを忘れないでください

707
00:34:49,480 --> 00:34:50,770
番号なしリストタグ。

708
00:34:50,770 --> 00:34:53,949
だから我々は、PHPモードを終了する必要があります
これを実行するためである。

709
00:34:53,949 --> 00:35:00,280
あるいは我々がエコーしている可能性が
番号なしリストタグを閉じます。

710
00:35:00,280 --> 00:35:02,380
>> DAVID J.マラン：ここにも罰金だろう
古い学校を使用するようになっている

711
00:35:02,380 --> 00:35:07,340
$ iは= 0 0とまでカウントを使用したループ
線の長さを把握する。

712
00:35:07,340 --> 00:35:09,240
ただ、あまりにも完全に罰金
少し冗長に。

713
00:35:09,240 --> 00:35:12,170

714
00:35:12,170 --> 00:35:14,742
>> 観客：だから、しようとしている場合は
[聞こえない]、あなたがするだろう - 

715
00:35:14,742 --> 00:35:16,734
私はループが[聞こえない]が何であるかを忘れている。

716
00:35:16,734 --> 00:35:21,380
もし$クワッドブラケット、私だろうか？

717
00:35:21,380 --> 00:35:21,850
>> DAVID J.マラン：その通りです。

718
00:35:21,850 --> 00:35:23,100
ええ、その通りです。

719
00:35:23,100 --> 00:35:26,650

720
00:35:26,650 --> 00:35:27,900
>> ROBボーデン：他には？

721
00:35:27,900 --> 00:35:31,350

722
00:35:31,350 --> 00:35:32,010
>> DAVID J.マラン：すべての権利。

723
00:35:32,010 --> 00:35:32,300
トレードオフ。

724
00:35:32,300 --> 00:35:38,290
だから、答えの束があった
これらのそれぞれの可能な。

725
00:35:38,290 --> 00:35:40,510
私たちは本当にちょうど探していた
逆さまのための説得力のあるものと

726
00:35:40,510 --> 00:35:41,100
欠点。

727
00:35:41,100 --> 00:35:44,830
と数16は、ユーザーの検証、尋ね
入力クライアント·サイドは、JavaScriptと同様に、

728
00:35:44,830 --> 00:35:47,280
代わりに、サーバー側の、PHPと同じように。

729
00:35:47,280 --> 00:35:49,450
そうの利点は何ですか
クライアントサイドをやって？

730
00:35:49,450 --> 00:35:53,780
>> まあ、我々が提案ものの一つです
あなたので、あなたが、待ち時間を減らすこと

731
00:35:53,780 --> 00:35:56,750
連絡気にする必要はありません
いくつかのかかる場合があり、サーバ、

732
00:35:56,750 --> 00:36:00,390
でも、ミリ秒または秒のカップル
それを避けることで、ちょうど

733
00:36:00,390 --> 00:36:04,670
で、ユーザーの入力クライアント·サイドの検証
オン提出ハンドラをトリガし、

734
00:36:04,670 --> 00:36:06,650
ちょうど彼らが入力したチェック
nameの中の何か？

735
00:36:06,650 --> 00:36:08,080
彼らは何かを入力しましたか
電子メールアドレスのためにある？

736
00:36:08,080 --> 00:36:10,950
彼らはから寮を選んだ
ドロップダウンメニュー？

737
00:36:10,950 --> 00:36:14,360
>> あなたは彼らに瞬時にフィードバックを与えることができます
ギガヘルツコンピュータを使用して

738
00:36:14,360 --> 00:36:16,770
または何でも彼らはそれはだている
実際に自分の机の上。

739
00:36:16,770 --> 00:36:19,310
だから、それだけで良いのユーザーの
一般的に経験する。

740
00:36:19,310 --> 00:36:24,460
しかし、クライアント側をすることのマイナス面
検証、あなたもすることなく、それを行う場合は、

741
00:36:24,460 --> 00:36:29,860
サーバー側の検証を行うと、ということです
CS50から出てくるほとんど誰もが知っている

742
00:36:29,860 --> 00:36:33,980
あなただけのあなたが望む任意のデータを送信できること
サーバへの任意の数の方法。

743
00:36:33,980 --> 00:36:37,030
率直に言って、ほとんどすべてのブラウザで、次のことが可能
設定で周りをクリックするだけ

744
00:36:37,030 --> 00:36:40,110
JavaScriptをオフにし、これだろう
従って、任意の形態をディセーブル

745
00:36:40,110 --> 00:36:41,080
検証。

746
00:36:41,080 --> 00:36:44,460
>> しかし、あなたはまたしても私はそれを思い出すかもしれません
使用して、クラスにいくつかの難解なことをした

747
00:36:44,460 --> 00:36:47,790
Telnetと実際のふり
GETを送信することで、ブラウザに

748
00:36:47,790 --> 00:36:49,240
サーバへのリクエスト。

749
00:36:49,240 --> 00:36:51,030
そして、それは確かではありません
任意のJavaScriptを使用して。

750
00:36:51,030 --> 00:36:53,290
それはちょうど私は、コマンドを入力するだ
キーボードで。

751
00:36:53,290 --> 00:36:57,410
だから本当に、十分な内の任意のプログラマ
ウェブとHTTPと快適さ

752
00:36:57,410 --> 00:37:01,690
彼または彼女が望むどのようなデータを送信することができます
検証せずに、サーバーへ。

753
00:37:01,690 --> 00:37:05,470
そして、あなたのサーバーもチェックしていない場合は、
彼らが私に名前を付けたのです

754
00:37:05,470 --> 00:37:08,930
この実際には有効な電子メールアドレス、でした
彼らは寮を選ぶ、あなたが終わるかもしれない

755
00:37:08,930 --> 00:37:12,800
偽のか、単に空白のデータを挿入するまで
おそらく、データベース内へ

756
00:37:12,800 --> 00:37:15,450
良いことになるだろうされていない場合
あなたはそれがあったと仮定した。

757
00:37:15,450 --> 00:37:16,770
>> だから、これは厄介な現実である。

758
00:37:16,770 --> 00:37:19,890
しかし、一般的には、クライアント側の
検証は素晴らしいです。

759
00:37:19,890 --> 00:37:21,810
しかし、それは二倍の仕事を意味します。

760
00:37:21,810 --> 00:37:25,970
様々存在しないが
のためのライブラリ、JavaScriptライブラリ

761
00:37:25,970 --> 00:37:28,830
例えば、これだけを行うことを
頭痛のはるかに少ない。

762
00:37:28,830 --> 00:37:31,940
そして、あなたはコードの一部を再利用することができます
サーバー側、クライアント側の。

763
00:37:31,940 --> 00:37:35,980
しかし、それは一般的であることを認識しない
追加作業。

764
00:37:35,980 --> 00:37:36,415
うん。

765
00:37:36,415 --> 00:37:37,792
>> 観客：もしそうならば、私たちだけで
安全性の低いと - 

766
00:37:37,792 --> 00:37:39,205
>> DAVID J.マラン：（笑）

767
00:37:39,205 --> 00:37:39,680
ぐふ。

768
00:37:39,680 --> 00:37:43,105
それらは常に困難です
裁定するもの。

769
00:37:43,105 --> 00:37:44,480
>> ROBボーデン：それだろう
受け入れられている。

770
00:37:44,480 --> 00:37:44,810
>> DAVID J.マラン：何？

771
00:37:44,810 --> 00:37:45,810
>> ROBボーデン：私はこの問題を作成しました。

772
00:37:45,810 --> 00:37:46,735
それが受け入れられたであろう。

773
00:37:46,735 --> 00:37:47,220
>> DAVID J.マラン：うん。

774
00:37:47,220 --> 00:37:47,830
>> 観客：クール。

775
00:37:47,830 --> 00:37:51,770
>> ROBボーデン：しかし、我々は受け入れられませんでした
最初の1のために - 

776
00:37:51,770 --> 00:37:53,630
さて、私たちが探していたことである
あなたのようなものがする必要はありません

777
00:37:53,630 --> 00:37:55,270
サーバーと通信します。

778
00:37:55,270 --> 00:37:58,355
我々だけ速く受け入れませんでした。

779
00:37:58,355 --> 00:38:00,080
>> 観客：何について
ページをリロードしてみませんか？

780
00:38:00,080 --> 00:38:00,430
>> ROBボーデン：はい。

781
00:38:00,430 --> 00:38:03,000
それは受け入れ答えた。

782
00:38:03,000 --> 00:38:06,300
>> DAVID J.マラン：我々は感じたものは
それはそうではない可能性の方が高いでした

783
00:38:06,300 --> 00:38:09,780
あなたは何であったか知っていたこと
タフである、と言って

784
00:38:09,780 --> 00:38:13,500
時々描画するライン。

785
00:38:13,500 --> 00:38:16,000
代わりに、リンクされたリストを使用して
維持するために、アレイの

786
00:38:16,000 --> 00:38:17,590
整数のリストを並べ替え。

787
00:38:17,590 --> 00:38:21,000
だから我々は、多くの場合に引用逆さまにリンクされた
彼らの全体の動機をリスト

788
00:38:21,000 --> 00:38:22,370
導入には、ダイナミズムを取得しました。

789
00:38:22,370 --> 00:38:23,030
彼らは成長することができます。

790
00:38:23,030 --> 00:38:23,950
彼らは、縮小することができます。

791
00:38:23,950 --> 00:38:27,370
だから、試練をする必要はありません
実際に多くのメモリを作成するには

792
00:38:27,370 --> 00:38:28,140
配列を持つ。

793
00:38:28,140 --> 00:38:30,310
それとも、ただする必要はありません
申し訳ありません、と言うと、ユーザ。

794
00:38:30,310 --> 00:38:31,410
アレイが充填されている。

795
00:38:31,410 --> 00:38:35,850
リストのとてもダイナミックな成長。

796
00:38:35,850 --> 00:38:37,210
リンクリストのもマイナス面？

797
00:38:37,210 --> 00:38:40,916

798
00:38:40,916 --> 00:38:43,356
>> 観客：それは線形です。

799
00:38:43,356 --> 00:38:45,800
リンクリストに検索が線形である
代わりに、あなたがログイン何の

800
00:38:45,800 --> 00:38:46,360
>> DAVID J.マラン：その通りです。

801
00:38:46,360 --> 00:38:50,160
リンクリストに検索は直線的で、
それがソートさであったとしても、あなたは可能性があるため

802
00:38:50,160 --> 00:38:53,170
これらのみパン粉に従って、これらの
ポインタは、リストの先頭から

803
00:38:53,170 --> 00:38:53,570
最後まで。

804
00:38:53,570 --> 00:38:57,970
あなたは、ランダム·アクセスを活用することはできません、
このように、二分探索は、それがであったとしても

805
00:38:57,970 --> 00:39:00,740
あなたができることを、ソートされた
配列を使用して行います。

806
00:39:00,740 --> 00:39:02,390
そしてもう一つのコストもあります。

807
00:39:02,390 --> 00:39:02,966
うん。

808
00:39:02,966 --> 00:39:03,800
>> 観客：メモリー非効率的？

809
00:39:03,800 --> 00:39:04,130
>> DAVID J.マラン：うん。

810
00:39:04,130 --> 00:39:06,940
まあ、私は必ずしもないでしょう
非効率的と言う。

811
00:39:06,940 --> 00:39:10,110
しかし、それはあなたに多くのメモリを費用がかかり、
あなたはすべてのために32ビットを必要とするので、

812
00:39:10,110 --> 00:39:13,400
追加のポインタのノード、で
シングルリンクリストのための最低。

813
00:39:13,400 --> 00:39:16,660
今、あなたが整数のみを格納している場合と
あなたは、ポインタを追加している、それはです

814
00:39:16,660 --> 00:39:17,830
実際にこの種の非自明。

815
00:39:17,830 --> 00:39:19,340
これは、メモリの量を倍増だ。

816
00:39:19,340 --> 00:39:22,330
しかし、現実には、あなたが保存している場合は、
可能性があり、構造体のリンクリスト

817
00:39:22,330 --> 00:39:25,540
8バイト、16バイト、さらにより
それよりも、多分それは少ないです

818
00:39:25,540 --> 00:39:26,500
限界費用の。

819
00:39:26,500 --> 00:39:28,320
しかし、それにもかかわらず、コストです。

820
00:39:28,320 --> 00:39:31,880
ので、これらのいずれかがきになる
マイナス面として罰金き。

821
00:39:31,880 --> 00:39:32,110
>> 18。

822
00:39:32,110 --> 00:39:36,100
書くことの代わりに、CのPHPを使用して
コマンドラインプログラム。

823
00:39:36,100 --> 00:39:41,890
だからここには、使用するために、多くの場合、高速です
PHPやRubyやPythonのような言語。

824
00:39:41,890 --> 00:39:43,700
あなただけ素早く開く
テキストエディタまで。

825
00:39:43,700 --> 00:39:45,900
あなたは多くのより多くの機能を持っている
あなたに利用できる。

826
00:39:45,900 --> 00:39:49,325
PHPは関数の台所の流しがあり、
Cでは、一方、

827
00:39:49,325 --> 00:39:50,420
非常に、非常に少ないがあります。

828
00:39:50,420 --> 00:39:53,820
実際には、人はリジェクト苦労を知っている
あなたはハッシュテーブルを持っていないこと。

829
00:39:53,820 --> 00:39:55,000
あなたがリンクリストを持っていません。

830
00:39:55,000 --> 00:39:57,470
あなたがそれらをしたい場合は、その必要はあり
自分で実装しています。

831
00:39:57,470 --> 00:40:00,950
>> だから、1のPHPの上部または実際に任意の
インタプリタ型言語は迅速である

832
00:40:00,950 --> 00:40:02,920
これを使用すると、コードを書くことができます。

833
00:40:02,920 --> 00:40:06,660
しかし、欠点は、私たちはこれを見たとき、私
迅速misspellerをホイップ

834
00:40:06,660 --> 00:40:11,780
PHPを使用して、講義での実装は、ある
インタプリタ言語を使用して、その

835
00:40:11,780 --> 00:40:13,570
通常は時間がかかります。

836
00:40:13,570 --> 00:40:18,420
そして、我々はして明らかにすることを見ました
3に0.3秒から時間の増加

837
00:40:18,420 --> 00:40:24,440
なぜなら解釈の秒、
それは実際に起こる。

838
00:40:24,440 --> 00:40:27,060
>> 別の利点は、あなたということでした
コンパイルする必要はありません。

839
00:40:27,060 --> 00:40:30,130
だから、また、開発をスピードアップ
ちなみに、あなたは持っていないため、

840
00:40:30,130 --> 00:40:31,360
プログラムの実行には、2つのステップ。

841
00:40:31,360 --> 00:40:32,140
あなただけの1を持っている。

842
00:40:32,140 --> 00:40:35,260
だからこれはかなりです
魅力的なだけでなく。

843
00:40:35,260 --> 00:40:38,450
SQLデータベースを使用する代わりに、
データを格納するためのCSVファイル。

844
00:40:38,450 --> 00:40:40,230
ように、SQLデータベースがpset7に使用されます。

845
00:40:40,230 --> 00:40:42,060
CSVファイルはあなたがあまり使用しませんでした。

846
00:40:42,060 --> 00:40:45,960
しかし、あなたのようにpset7で間接的に使用される
よくヤフーファイナンスに話すことによって。

847
00:40:45,960 --> 00:40:49,330
>> しかし、CSVは単なるExcelファイルに似ていますが、
列がどこにあるか、超簡単

848
00:40:49,330 --> 00:40:54,010
すぐ内側カンマでdemarked
そうでなければテキストフ​​ァイルの。

849
00:40:54,010 --> 00:40:56,740
SQLデータベースを使用することはあり
もう少し説得力。

850
00:40:56,740 --> 00:41:00,060
あなたは物事をので、逆さまだ
のような選択して挿入して、削除します。

851
00:41:00,060 --> 00:41:03,790
そして、あなたは、おそらく、インデックスを取得すること
MySQLとのような他のデータベース、

852
00:41:03,790 --> 00:41:07,510
オラクル、メモリ内にあなたのために構築し、その
あなたの選択はおそらくないことを意味します

853
00:41:07,510 --> 00:41:09,000
下へ直線的トップになるだろう。

854
00:41:09,000 --> 00:41:11,300
それは実際に何かになるだろう
二分探索か何かのような

855
00:41:11,300 --> 00:41:12,520
精神面で似ています。

856
00:41:12,520 --> 00:41:13,930
そこで、彼らは一般的に高速だ。

857
00:41:13,930 --> 00:41:16,040
>> しかし、欠点は、ということです
それだけでより多くの仕事だ。

858
00:41:16,040 --> 00:41:16,730
それは多くの努力です。

859
00:41:16,730 --> 00:41:18,140
あなたがデータベースを理解する必要があります。

860
00:41:18,140 --> 00:41:18,940
あなたはそれを設定する必要があります。

861
00:41:18,940 --> 00:41:20,840
あなたが実行するためのサーバが必要
上のそのデータベース。

862
00:41:20,840 --> 00:41:22,750
あなたが理解する必要があります
それを設定する方法。

863
00:41:22,750 --> 00:41:24,930
したがって、これらはちょうどこれらの
トレードオフの種類。

864
00:41:24,930 --> 00:41:27,860
CSVファイル、次のことができ、一方、
geditのでそれを作成してください。

865
00:41:27,860 --> 00:41:28,770
そして、あなたは行ってもいいです。

866
00:41:28,770 --> 00:41:31,550
それを超えていない複雑さがありません。

867
00:41:31,550 --> 00:41:34,870
>> トライの代わりにハッシュテーブルを使用して
保存するための別々の連鎖で

868
00:41:34,870 --> 00:41:37,490
連想させる単語の辞書
pset5の。

869
00:41:37,490 --> 00:41:42,480
そのように理論​​的には、上側試みる
少なくとも、何がある？

870
00:41:42,480 --> 00:41:46,380
一定の時間、少なくともあなたがしている場合
個々のそれぞれの上にハッシング

871
00:41:46,380 --> 00:41:48,990
あなたのような単語の文字、
pset5のために持っているかもしれません。

872
00:41:48,990 --> 00:41:52,720
つまり、5ハッシュ、6かもしれない
5または6があるかどうハッシュする

873
00:41:52,720 --> 00:41:53,900
単語の文字。

874
00:41:53,900 --> 00:41:54,580
そして、それはかなり良いです。

875
00:41:54,580 --> 00:41:56,910
そして、どのように上限があるかどう
長いあなたの言葉があるかもしれない、それはです

876
00:41:56,910 --> 00:41:59,320
確かに漸近的に一定の時間。

877
00:41:59,320 --> 00:42:05,180
>> 一方、別々にハッシュ·テーブル
それとそこには、問題を連鎖

878
00:42:05,180 --> 00:42:09,070
データ構造の一種であること
通常、アルゴリズムの性能

879
00:42:09,070 --> 00:42:12,700
ものの数に依存します
既にデータ構造である。

880
00:42:12,700 --> 00:42:15,660
そして、それは間違いの場合だ
チェーン、あなたが置くことにより、より多くの原料

881
00:42:15,660 --> 00:42:18,800
ハッシュテーブルに、長いもの
チェーンは最悪で意味し、行く

882
00:42:18,800 --> 00:42:21,960
場合、あなたが探している可能性があります事
1の最後にすべての方法である

883
00:42:21,960 --> 00:42:26,000
これらのチェインの、その効果的
リニア何かに委譲。

884
00:42:26,000 --> 00:42:29,450
>> さて、実際には、それは絶対にできた
ハッシュテーブルの場合の

885
00:42:29,450 --> 00:42:32,820
チェーンは、対応するよりも高速です
トライの実装。

886
00:42:32,820 --> 00:42:35,570
しかし、それはの間で、様々な理由のためだ
その試みは、全体の多くを使用している

887
00:42:35,570 --> 00:42:39,240
メモリということができ、実際には、遅いもの
ダウン、あなたが素敵な取得しないので、

888
00:42:39,240 --> 00:42:42,410
キャッシングと呼ばれるものの利点、
どこに接近しているもの

889
00:42:42,410 --> 00:42:45,420
メモリにアクセスすることができます
多くの場合、より迅速に。

890
00:42:45,420 --> 00:42:48,180
そして、時にはあなたが思い付くことができます
本当に良いハッシュ関数。

891
00:42:48,180 --> 00:42:51,060
あなたが少しを無駄にする必要があっても、
メモリには、確かに、することができるかもしれない

892
00:42:51,060 --> 00:42:54,430
高速ではないものを見つける
直線的に同じくらい悪い。

893
00:42:54,430 --> 00:42:58,410
>> そう簡単に言えば、必ずしもありませんでした
これらの1あるいは2のいずれか

894
00:42:58,410 --> 00:43:00,050
私たちが探していた特定の事柄。

895
00:43:00,050 --> 00:43:03,080
説得力のある本当に何
上側および下など

896
00:43:03,080 --> 00:43:04,800
一般的に私たちの目を引いた。

897
00:43:04,800 --> 00:43:11,840
>> ROBボーデン：だから逆に、我々はなかった
自分自身で受け入れられない "速く"あなた

898
00:43:11,840 --> 00:43:14,540
それについて何かを言っていた。

899
00:43:14,540 --> 00:43:17,910
あなたは、理論的に速く前記あっても、
我々はあなたがちょっと理解していることを知っていた

900
00:43:17,910 --> 00:43:19,470
それは1の0だと。

901
00:43:19,470 --> 00:43:22,820
理論的には、ハッシュテーブル、
1の0ではありません。

902
00:43:22,820 --> 00:43:26,550
ランタイムについて何も言及
一般的にはあなたのポイントを得た。

903
00:43:26,550 --> 00:43:32,640
しかし、「より速く、「ソリューションのほとんどに
試みであった大きなボード

904
00:43:32,640 --> 00:43:34,990
ソリューションよりも客観的にも遅い
つまり、ハッシュテーブルでした。

905
00:43:34,990 --> 00:43:37,250
とても速く、それ自体の
本当に真実ではありません。

906
00:43:37,250 --> 00:43:41,550

907
00:43:41,550 --> 00:43:44,380
>> DAVID J.マラン：ドム·デ·DOM DOM。

908
00:43:44,380 --> 00:43:46,686
私はおそらく実現だけだ
それは、そのがになっている方法です

909
00:43:46,686 --> 00:43:47,500
右、発音される？

910
00:43:47,500 --> 00:43:50,400
>> ROBボーデン：私は実際に理解していませんでした。

911
00:43:50,400 --> 00:43:51,650
>> DAVID J.マラン：それは作られ
私の頭の中で感覚。

912
00:43:51,650 --> 00:43:53,830

913
00:43:53,830 --> 00:43:57,580
>> ROBボーデン：私はこの1つをやっている。

914
00:43:57,580 --> 00:43:58,020
[OK]をクリックします。

915
00:43:58,020 --> 00:44:04,243
だから、これはあなたが描く必要があったものです
あなたと同様の図かもしれない

916
00:44:04,243 --> 00:44:06,040
過去の試験で見てきました。

917
00:44:06,040 --> 00:44:12,200
それでは、ちょうどこのを見てみましょう。

918
00:44:12,200 --> 00:44:18,170
だから、HTMLのノードから、我々は2つ​​を持っている
子ども、頭と体。

919
00:44:18,170 --> 00:44:20,570
だから我々の枝 - 頭と体。

920
00:44:20,570 --> 00:44:22,280
ヘッドはタイトルタグを持っています。

921
00:44:22,280 --> 00:44:23,710
だから我々はタイトルを持っている。

922
00:44:23,710 --> 00:44:28,450
>> 今、一つのこと、多くの人々
忘れてしまったこれらのテキストノードであるということです

923
00:44:28,450 --> 00:44:30,430
このツリー内の要素。

924
00:44:30,430 --> 00:44:36,260
そこでここでは、楕円としてそれらを描くことが起こる
これらと区別するために、

925
00:44:36,260 --> 00:44:37,380
ノードのタイプ。

926
00:44:37,380 --> 00:44:41,450
しかし、予告もここで我々はトップを持って、
途中、下がされてしまう

927
00:44:41,450 --> 00:44:42,560
テキストノード。

928
00:44:42,560 --> 00:44:46,250
だから、それらは幾分だった忘れて
よくある間違いの。

929
00:44:46,250 --> 00:44:48,770
>> ボディは3人の子供がいる - 
これらの3のdiv。

930
00:44:48,770 --> 00:44:53,340
そうDIV、DIV、DIV、テキスト
これらのdiv要素のノードの子。

931
00:44:53,340 --> 00:44:55,900
つまり、かなりそれだ
その質問のため。

932
00:44:55,900 --> 00:44:57,860
>> DAVID J.マラン：そして、それは注目に値します、
我々は、これらにこだわるしないにもかかわらず、

933
00:44:57,860 --> 00:45:01,040
私たちが過ごす時間の詳細
注文がないJavaScriptや、中

934
00:45:01,040 --> 00:45:02,290
実際、技術的には問題。

935
00:45:02,290 --> 00:45:06,330
だから、ヘッドが身体の前に来る場合
HTML、それはに表示されます

936
00:45:06,330 --> 00:45:08,860
実際のDOM内の車体左側。

937
00:45:08,860 --> 00:45:12,265
彼は、単にFYI、一般に、ある
文書順序と呼ばれるもの、どこで

938
00:45:12,265 --> 00:45:13,260
それは問題ではありません。

939
00:45:13,260 --> 00:45:17,470
そして、あなたは、パーサーを実装した場合には、
建物内のHTMLを読み込むプログラム

940
00:45:17,470 --> 00:45:20,960
メモリ内の木まで、正直に言うと、
それはおそらく直感的にどのようなあなたです

941
00:45:20,960 --> 00:45:24,720
とにかくやる - 上から下へ、
左から右へ。

942
00:45:24,720 --> 00:45:26,116
>> ROBボーデン：これについての質問？

943
00:45:26,116 --> 00:45:29,080

944
00:45:29,080 --> 00:45:30,000
私は、次のいずれかの操作を実行する必要がありますか？

945
00:45:30,000 --> 00:45:32,380
>> DAVID J.マラン：確かに。

946
00:45:32,380 --> 00:45:33,810
>> ROBボーデン：わかりました。

947
00:45:33,810 --> 00:45:39,320
だから、これはバッファオーバーランです
攻撃質問。

948
00:45:39,320 --> 00:45:43,740
ここで認識するための主なものは、ある
さて、どのように敵のトリックかもしれない

949
00:45:43,740 --> 00:45:46,170
実行中にこのプログラム
任意のコード？

950
00:45:46,170 --> 00:45:51,860
そうargv1、最初のコマンドライン
このプログラムへの引数であることができる

951
00:45:51,860 --> 00:45:53,920
任意の長さ。

952
00:45:53,920 --> 00:45:59,160
が、ここではコピーするmemcpyをを使用している
ここにバーですargv1、。

953
00:45:59,160 --> 00:46:00,165
私たちは、引数として渡している。

954
00:46:00,165 --> 00:46:02,050
そしてそれは名前バーに取っている。

955
00:46:02,050 --> 00:46:08,040
>> だから我々はバーをmemcpyingいる
このバッファCに。

956
00:46:08,040 --> 00:46:09,400
我々はどのように多くのバイトをコピーしている？

957
00:46:09,400 --> 00:46:14,040
さてしかし何バイトバーはどうなります
、その引数の長さを使用する。

958
00:46:14,040 --> 00:46:17,930
しかし、Cは12バイト幅である。

959
00:46:17,930 --> 00:46:22,280
だから我々は、コマンドライン引数を入力した場合
それが12バイトより長いですが、我々はしている

960
00:46:22,280 --> 00:46:25,470
これをオーバーフローしよう
特定のバッファ。

961
00:46:25,470 --> 00:46:31,000
今、どのように敵をだますかもしれません
任意のコードを実行させるプログラム？

962
00:46:31,000 --> 00:46:34,910
>> だから、ここで覚えている
メインはfooのを呼び出している。

963
00:46:34,910 --> 00:46:37,340
だから、メインの呼び出しは狛犬。

964
00:46:37,340 --> 00:46:40,408
それでは、これを描きましょう。

965
00:46:40,408 --> 00:46:44,720

966
00:46:44,720 --> 00:46:46,990
だから我々は我々のスタックを持っています。

967
00:46:46,990 --> 00:46:49,090
そして主は、スタックフレームを有している
一番下にある。

968
00:46:49,090 --> 00:46:51,860

969
00:46:51,860 --> 00:46:53,250
ある時点で、主コールはfooに。

970
00:46:53,250 --> 00:46:55,390
さて、すぐに、メインの呼び出しは狛犬。

971
00:46:55,390 --> 00:46:57,130
だからfooは、独自のスタックフレームを取得します。

972
00:46:57,130 --> 00:46:59,650

973
00:46:59,650 --> 00:47:02,220
>> 今、いくつかの点で、fooの
返すために起こっている。

974
00:47:02,220 --> 00:47:06,810
とfooリターンを行ってきました、我々は時に知っておく必要があります
メイン我々の内部のコードのどの行

975
00:47:06,810 --> 00:47:10,610
知るためであった
私たちは、主に再開する必要があります。

976
00:47:10,610 --> 00:47:13,100
我々は全体からのfooを呼び出すことができます
さまざまな場所の束。

977
00:47:13,100 --> 00:47:14,620
どのように我々はどこに返すことを知っていますか？

978
00:47:14,620 --> 00:47:16,460
さて、私たちはどこかに格納する必要があります。

979
00:47:16,460 --> 00:47:23,010
>> だから、どこかで右周りここでは、保存
我々は一度に戻るべき場所

980
00:47:23,010 --> 00:47:24,070
fooの戻ります。

981
00:47:24,070 --> 00:47:26,350
そして、これは、リターンアドレスです。

982
00:47:26,350 --> 00:47:30,490
それでは、どの敵は利点がかかる場合があります
これのことである

983
00:47:30,490 --> 00:47:37,550
このバッファーCが格納されている、みましょう
cはちょうどここ、と言う。

984
00:47:37,550 --> 00:47:39,690
だから我々は、Cのための12バイトを持っている。

985
00:47:39,690 --> 00:47:40,540
これはCである。

986
00:47:40,540 --> 00:47:43,030
そして、これは、fooのスタックリングです。

987
00:47:43,030 --> 00:47:49,970
だから、悪意のあるユーザーが、よりに入った場合
12バイト以上、またはそれらはコマンドを入力します。

988
00:47:49,970 --> 00:47:54,570
12よりも長いですライン引数
文字は、その後、我々はするつもりだ

989
00:47:54,570 --> 00:47:57,540
このバッファをオーバーフロー。

990
00:47:57,540 --> 00:47:59,910
>> 我々は続けることができます。

991
00:47:59,910 --> 00:48:02,220
そしてある時点で、私たちは遠くに行く
私たちは始めることを十分に

992
00:48:02,220 --> 00:48:05,120
このリターンアドレスを上書きします。

993
00:48:05,120 --> 00:48:08,310
だから我々はリターンアドレスを上書きした後、
これは、ときのfoo

994
00:48:08,310 --> 00:48:14,220
戻って、我々はどこに戻っています
悪意のあるユーザーがすることによって、それを語っている

995
00:48:14,220 --> 00:48:19,490
それはどのようなことで、入力されたどのような値
文字は、ユーザーが入力した。

996
00:48:19,490 --> 00:48:24,320
だから悪意のあるユーザーがされている場合
特に巧妙な、彼はこれを持つことができます

997
00:48:24,320 --> 00:48:29,255
printDef内のどこかに戻る
関数やmalloc関数内のどこかに

998
00:48:29,255 --> 00:48:31,830
機能、どこでも任意の。

999
00:48:31,830 --> 00:48:38,420
>> しかし、さらに巧妙な彼が持っているものであればある
ユーザーはここに戻ります。

1000
00:48:38,420 --> 00:48:41,920
そして、あなたは実行を開始
これらのコード行として。

1001
00:48:41,920 --> 00:48:46,610
だから、その時点で、ユーザーが入力することができます
彼は、この地域に望むものは何でも。

1002
00:48:46,610 --> 00:48:52,210
そして、彼は完全に制御を持っている
あなたのプログラムの上。

1003
00:48:52,210 --> 00:48:53,460
その上での質問？

1004
00:48:53,460 --> 00:48:56,380

1005
00:48:56,380 --> 00:49:00,970
だから、次の質問が完了しました
このような方法でのfooの再実装

1006
00:49:00,970 --> 00:49:02,620
それがもはや脆弱だということ。

1007
00:49:02,620 --> 00:49:03,870
>> だから、いくつかの方法があります
あなたはこれを行っている可能性があります。

1008
00:49:03,870 --> 00:49:10,900

1009
00:49:10,900 --> 00:49:13,330
我々はまだCのみ持っている
長さ12のもの。

1010
00:49:13,330 --> 00:49:16,480
あなたはこれを変更した可能性
あなたのソリューションの一部として。

1011
00:49:16,480 --> 00:49:18,930
また、確認してくださいを追加しました
必ずバーがnullではなかった。

1012
00:49:18,930 --> 00:49:24,460
あなたは必要としませんでしたが
その完全な信用のため。

1013
00:49:24,460 --> 00:49:27,690
だから我々は最初にチェックしている
バーの文字列の長さ。

1014
00:49:27,690 --> 00:49:31,650
それは12を超えます場合には、
実際にコピーをしない。

1015
00:49:31,650 --> 00:49:33,010
だから、それを固定する一つの方法です。

1016
00:49:33,010 --> 00:49:36,750
>> それを固定する別の方法は、代わりに
それだけを持って、長さが12であることを有するC

1017
00:49:36,750 --> 00:49:39,310
長さはstrlen（バー）であること。

1018
00:49:39,310 --> 00:49:43,370
それを固定する別の方法は、ある
実際には戻ります。

1019
00:49:43,370 --> 00:49:46,690
だから、あなただけのすべてを取り除く得ていた場合は、
これは、あなただけのすべて削除した場合は、

1020
00:49:46,690 --> 00:49:51,830
コー​​ドの行は、あなたが得ているだろう
この関数以来、フルクレジット、

1021
00:49:51,830 --> 00:49:54,150
実際には何も達成しない。

1022
00:49:54,150 --> 00:49:57,650
これは、コマンドラインをコピーするだ
いくつかの配列に引数

1023
00:49:57,650 --> 00:49:59,960
そのローカルスタックフレーム。

1024
00:49:59,960 --> 00:50:01,310
そして、その後のことは戻っている。

1025
00:50:01,310 --> 00:50:04,020
そして何でもそれは達成がなくなっています。

1026
00:50:04,020 --> 00:50:09,740
だから、リターンも十分であった
フルクレジットを取得する方法。

1027
00:50:09,740 --> 00:50:13,425
>> DAVID J·マラン：のない非常精神
質問が、あたりの許容

1028
00:50:13,425 --> 00:50:15,580
それにもかかわらずスペック。

1029
00:50:15,580 --> 00:50:18,260
>> ROBボーデン：それに関して質問？

1030
00:50:18,260 --> 00:50:22,270
あなたは、少なくとも一つのこと
コー​​ドをコンパイルしている必要がありました。

1031
00:50:22,270 --> 00:50:24,810
だから、技術的にはそうでないにもかかわらず、
脆弱なコードがない場合

1032
00:50:24,810 --> 00:50:29,130
コンパイル、我々はそれを受け入れませんでした。

1033
00:50:29,130 --> 00:50:31,350
noの質問？

1034
00:50:31,350 --> 00:50:33,320
[OK]をクリックします。

1035
00:50:33,320 --> 00:50:34,580
>> DAVID J.マラン：あなたがしたいですか
このタイトルを避ける？

1036
00:50:34,580 --> 00:50:37,230
>> ROBボーデン：いいえ。

1037
00:50:37,230 --> 00:50:40,470
>> DAVID J.マラン：だからこれ1において、この
良いニュースか悪いニュースのいずれかであった。

1038
00:50:40,470 --> 00:50:43,870
これは文字通り、同じ問題である
最初のクイズなど。

1039
00:50:43,870 --> 00:50:46,140
そしてそれはほとんど同じだ
PSET1として問題。

1040
00:50:46,140 --> 00:50:49,980
しかし、それは意図的であることが簡素化されました
単純なピラミッドであることができる1

1041
00:50:49,980 --> 00:50:52,330
少しで解決
単純な反復。

1042
00:50:52,330 --> 00:50:55,680
本当に、私達はで何を得ていた
ここでは、そのように多くのロジックではなかった

1043
00:50:55,680 --> 00:50:58,100
おそらく、この時点で、あなたがしているので
あなたがいたよりも快適

1044
00:50:58,100 --> 00:51:01,850
ループや、なぜforループで週1において、
しかし、実際にその離れていじめる

1045
00:51:01,850 --> 00:51:04,790
あなたは少し慣れ
PHPはまさにではありませんという考え

1046
00:51:04,790 --> 00:51:05,290
プログラミング。

1047
00:51:05,290 --> 00:51:07,820
これは、実際の言語として使用することができる
コマンドラインプログラムを書く。

1048
00:51:07,820 --> 00:51:10,060
>> そして実際、それは我々がしようとしていたものだ
に注意を描画します。

1049
00:51:10,060 --> 00:51:12,060
これは、コマンドラインPHPプログラムです。

1050
00:51:12,060 --> 00:51:16,690
そこでここでは、Cコード、しばらく正しい
C言語で、PHPを補正しない。

1051
00:51:16,690 --> 00:51:17,940
しかし、コードは実際には同じである。

1052
00:51:17,940 --> 00:51:21,720
あなたはクイズのためのソリューションを比較すると
クイズ1対0、あなたはそれを見つけることができます

1053
00:51:21,720 --> 00:51:25,630
それは除いて、ほとんど同じだ
いくつかのドル記号および用

1054
00:51:25,630 --> 00:51:27,250
データ型が存在しないこと。

1055
00:51:27,250 --> 00:51:31,720
特に、我々はここで見てみると、
この中で、我々は繰り返し処理いることがわかります

1056
00:51:31,720 --> 00:51:33,730
ケース、1から7までアップする。

1057
00:51:33,730 --> 00:51:34,910
>> 我々はそれを0のインデックスを行っている可能性があります。

1058
00:51:34,910 --> 00:51:37,320
しかし、時には、私はそれだけだと思う
精神的に簡単に物事を考えること

1059
00:51:37,320 --> 00:51:38,200
1〜7。

1060
00:51:38,200 --> 00:51:40,300
あなたは1ブロックが必要な場合は、2
次いで、ブロック、三つ、次いで

1061
00:51:40,300 --> 00:51:41,770
ドット、ドット、ドット7。

1062
00:51:41,770 --> 00:51:45,960
我々は1に初期化されてきたJ
そして私までに数える。

1063
00:51:45,960 --> 00:51:48,150
そして、ここにすべてがある
それ以外は同一。

1064
00:51:48,150 --> 00:51:49,790
しかし、注目に値するのである
物事のカップル。

1065
00:51:49,790 --> 00:51:53,230
私たちはあなたの次の2行、最初にこれを与える
ばかみたいにシバンとして名前1、

1066
00:51:53,230 --> 00:51:54,560
鋭い強打のため。

1067
00:51:54,560 --> 00:51:58,770
そして、それはただ、パスを指定します。
フォルダ、プログラムが可能な

1068
00:51:58,770 --> 00:52:02,160
使用したいことを発見
このファイルを解釈する。

1069
00:52:02,160 --> 00:52:04,710
>> とのその後、ライン、
コー​​スは、PHPモードに入ることを意味します。

1070
00:52:04,710 --> 00:52:07,740
そして一番下の行
終了PHPモードを意味します。

1071
00:52:07,740 --> 00:52:09,740
これはと、一般に、動作する
言語を解釈した。

1072
00:52:09,740 --> 00:52:14,370
あなたが書く場合にはちょっと迷惑なんだ
はFoo.phpというファイル内のプログラム。

1073
00:52:14,370 --> 00:52:17,320
そして、あなたのユーザーが持っているだけで
[OK]を、覚えて、このプログラムを実行するために、私

1074
00:52:17,320 --> 00:52:22,320
入力する必要が "PHPのスペースはFoo.phpを。"種類
何もない場合は迷惑なの。

1075
00:52:22,320 --> 00:52:25,270
そしてそれはまた、あなたのプログラムことが明らかになった
すべてではありません、PHPで書かれている

1076
00:52:25,270 --> 00:52:27,060
そのユーザ用照明。

1077
00:52:27,060 --> 00:52:30,100
>> だから、完全に。PHPを削除することができます
講義からリコール。

1078
00:52:30,100 --> 00:52:35,690
そして、あなたは実際には。/ fooを行うことができた場合
あなたはそれを作ることによってそれをchmoddedました

1079
00:52:35,690 --> 00:52:36,500
実行可​​能。

1080
00:52:36,500 --> 00:52:39,630
だからます。chmod a + xはfooがそれを行っているでしょう。

1081
00:52:39,630 --> 00:52:41,460
そして、あなたはまた、シバンをここに追加した場合。

1082
00:52:41,460 --> 00:52:45,320
しかし、実際に、問題は、なっていた
このようなものをプリントアウト。

1083
00:52:45,320 --> 00:52:51,100
ノーHTML、必ずノーCコード、
単にいくつかのPHP。

1084
00:52:51,100 --> 00:52:54,100
そうミロは、問題25で戻った。

1085
00:52:54,100 --> 00:52:58,050
そして25で、あなたは、次の与えられた
たスケルトンコード、

1086
00:52:58,050 --> 00:52:59,730
非常に単純なWebページ。

1087
00:52:59,730 --> 00:53:04,230
とHTMLワイズジューシーな部分がダウンしていた
ここで、我々は、本体の内部に有する場合

1088
00:53:04,230 --> 00:53:09,160
入力の固有のIDを持つフォーム
その内部2入力、1だった

1089
00:53:09,160 --> 00:53:11,950
名前の考えと、1
ボタンの考えと。

1090
00:53:11,950 --> 00:53:14,240
>> 最初は、text型だった
型の第提出してください。

1091
00:53:14,240 --> 00:53:16,930
そして私たちは、実際には、より多くのあなたを与えた
あなたはちょうどので、必要以上に食材

1092
00:53:16,930 --> 00:53:19,230
あなたたちは、との選択肢を持っていた
この問題を解決する。

1093
00:53:19,230 --> 00:53:21,130
あなたは厳密には必要ありません
これらのIDがすべて表示されます。

1094
00:53:21,130 --> 00:53:23,580
しかし、それはあなたが解決することができます
それさまざまな方法で。

1095
00:53:23,580 --> 00:53:27,050
最大上部に、いることに注意してください
目的は、トリガーにした

1096
00:53:27,050 --> 00:53:27,960
このようなウィンドウ - 

1097
00:53:27,960 --> 00:53:28,780
こんにちは、ミロ！ - 

1098
00:53:28,780 --> 00:53:31,270
使用してブラウザでポップアップする
もし、超簡単

1099
00:53:31,270 --> 00:53:33,190
醜いではない、アラート機能。

1100
00:53:33,190 --> 00:53:37,480
だから、最終的には、これはつまるところ
概念的には何らかの形でのリスニングをする

1101
00:53:37,480 --> 00:53:41,290
フォームのクライアント側の提出
、何とかしないサーバー側、

1102
00:53:41,290 --> 00:53:45,640
して、その提出への対応
ユーザーが入力した値をつかむ

1103
00:53:45,640 --> 00:53:50,120
[名前]フィールドにログインした後、
アラートの本体に表示する。

1104
00:53:50,120 --> 00:53:53,460
>> ですから、これを行うことができます一つの方法はである
少し見えるjQueryの、

1105
00:53:53,460 --> 00:53:56,880
最初は構文的に困惑。

1106
00:53:56,880 --> 00:54:00,760
あなたは純粋なDOMコードでこれを行うことができます - 
IDでdocument.getelement。

1107
00:54:00,760 --> 00:54:02,530
しかし、ここでは、このバージョンを見てみましょう。

1108
00:54:02,530 --> 00:54:05,110
大切なのカップルを持っている
行最初。

1109
00:54:05,110 --> 00:54:09,460
したがって、1つは、我々はある、このラインを持っている
あなたが見たかもしれないものと同じ

1110
00:54:09,460 --> 00:54:13,830
私は信じて、で、form2.html
週9クラスから。

1111
00:54:13,830 --> 00:54:16,960
そして、これは単に、実行、と言っている
次のコードとき

1112
00:54:16,960 --> 00:54:18,430
文書では、準備ができています。

1113
00:54:18,430 --> 00:54:21,770
これは重要であるためだけで
HTMLページは、トップ読み込まれる

1114
00:54:21,770 --> 00:54:23,280
左から右へ下の、。

1115
00:54:23,280 --> 00:54:27,910
>> そのため、あなたは何をしようとした場合
ここまでいくつかのDOMへのコードの中の何か

1116
00:54:27,910 --> 00:54:31,560
要素、いくつかのHTMLタグは、それがダウンだ
ここで、あなたもすぐにそれをやっている、

1117
00:54:31,560 --> 00:54:34,220
これさえしていないため、
メモリに読み込まれて。

1118
00:54:34,220 --> 00:54:37,740
したがって、このdocument.readyと言って
行は、我々は言っている、

1119
00:54:37,740 --> 00:54:39,040
ここではいくつかのコードは、ブラウザです。

1120
00:54:39,040 --> 00:54:42,440
しかし全体まで、これを実行しないでください
文書が準備ができている、即ちDOMある

1121
00:54:42,440 --> 00:54:44,320
ツリーはメモリ上に存在しています。

1122
00:54:44,320 --> 00:54:47,110
この1は、もう少しです
構文的にはAであれば、簡単な

1123
00:54:47,110 --> 00:54:51,890
少し違う、私が言っている、グラブ
そのユニークなHTML要素

1124
00:54:51,890 --> 00:54:53,560
識別子は、入力である。

1125
00:54:53,560 --> 00:54:56,220
つまり、どのようなハッシュタグの
、一意のIDを示している。

1126
00:54:56,220 --> 00:54:58,070
そして私は呼んでいる。提出する。

1127
00:54:58,070 --> 00:55:01,660
>> そう。ここに提出するには、それ以外の場合は、関数で
方法として知られている、それはです

1128
00:55:01,660 --> 00:55:05,850
左側上のオブジェクトの内部
私はハイライト表示しなかったことがある側。

1129
00:55:05,850 --> 00:55:08,990
だから、オブジェクトとして入力の思えば
メモリに - そして実際にそれがある。

1130
00:55:08,990 --> 00:55:10,440
これは、ツリー内のノードの - 

1131
00:55:10,440 --> 00:55:16,580
。手段を提出する際にこのフォームで
このIDが送信され、実行

1132
00:55:16,580 --> 00:55:17,700
次のコード。

1133
00:55:17,700 --> 00:55:20,290
私は気にしないものの名前
この関数は、私が実行していましてね。

1134
00:55:20,290 --> 00:55:23,760
だからここに私は何、以前のように、使用しています
ラムダ関数、またはと呼ばれる

1135
00:55:23,760 --> 00:55:24,720
無名関数。

1136
00:55:24,720 --> 00:55:27,640
それは、知的には全くありません
それは名前がない以外は興味深い、

1137
00:55:27,640 --> 00:55:30,220
あなただけなら罰金である
今までに一度と呼ぶつもり。

1138
00:55:30,220 --> 00:55:34,490
そして、そこの中に私が実際に扱う
フォームの送信。

1139
00:55:34,490 --> 00:55:36,810
私が最初に変数を宣言
Valueという。

1140
00:55:36,810 --> 00:55:40,610
して、この効果は何ですか
今ここの部分を強調した？

1141
00:55:40,610 --> 00:55:44,755
それはで何をするのか
私のためのハイレベル？

1142
00:55:44,755 --> 00:55:48,539
>> 観客：それは値を取得します
ユーザーは、以下のHTMLでなかった。

1143
00:55:48,539 --> 00:55:50,920
次に、そのIDを取得し、
ITの価値を発見する。

1144
00:55:50,920 --> 00:55:51,590
>> DAVID J.マラン：その通りです。

1145
00:55:51,590 --> 00:55:54,300
それは、そのユニークなノードをつかむ
識別子は名前です。

1146
00:55:54,300 --> 00:55:56,900
それは、その中の値を取得している
で、おそらく、どのような利用者

1147
00:55:56,900 --> 00:55:58,190
彼または彼女自身を入力しました。

1148
00:55:58,190 --> 00:56:01,020
そしてそれはであることを記憶する
変数は値と呼ばれる。

1149
00:56:01,020 --> 00:56:03,720
余談として、あなたも可能性があり
少し違ったこれをし。

1150
00:56:03,720 --> 00:56:09,250
何かをすることによって、完全に許容できる
嘘のVAR値を取得

1151
00:56:09,250 --> 00:56:10,500
のdocument.getElementById。

1152
00:56:10,500 --> 00:56:12,860

1153
00:56:12,860 --> 00:56:15,460
それは少しである理由、これがある
jQueryを使用しないように面倒。

1154
00:56:15,460 --> 00:56:16,710
「名前」。値。

1155
00:56:16,710 --> 00:56:18,330

1156
00:56:18,330 --> 00:56:19,620
そう完全に許容できる。

1157
00:56:19,620 --> 00:56:22,770
これを行うためのさまざまな方法。 jQueryのちょうど
もう少し簡潔になる傾向がある

1158
00:56:22,770 --> 00:56:25,230
間違いなく、より人気のある
プログラマの間。

1159
00:56:25,230 --> 00:56:27,590
>> 今、私は正気を少しやっている
なぜなら問題で、確認してください

1160
00:56:27,590 --> 00:56:30,820
文は、我々は、明示的に、言ったら
ユーザーがまだタイプされていない、自分の

1161
00:56:30,820 --> 00:56:32,580
名前、アラートが表示されません。

1162
00:56:32,580 --> 00:56:35,390
しかし、あなただけで、それをチェックすることができます
空の文字列をチェックする

1163
00:56:35,390 --> 00:56:37,850
俗に言うがあるかどう
実際にそこに何もない。

1164
00:56:37,850 --> 00:56:40,880
しかし、それは俗に言うと等しくない場合には、
私は警告を呼びたい。

1165
00:56:40,880 --> 00:56:45,610
そして、ここで興味深い部分は、ということです
我々は、プラス演算子を使用しているどの

1166
00:56:45,610 --> 00:56:48,130
JavaScriptで何をしますか？

1167
00:56:48,130 --> 00:56:48,740
連結します。

1168
00:56:48,740 --> 00:56:50,690
だから、PHP欠陥のドット演算子のようなものだ。

1169
00:56:50,690 --> 00:56:52,820
同じ考え、他とは少し違います。

1170
00:56:52,820 --> 00:56:55,280
と私は、その文字列を作成しています
あなたはスクリーンショットで見た - 

1171
00:56:55,280 --> 00:56:57,750
こんにちは、云々。

1172
00:56:57,750 --> 00:56:59,200
>> そして、最後の細部はこれです。

1173
00:56:59,200 --> 00:57:04,970
なぜ内部falseを返します
この無名関数の？

1174
00:57:04,970 --> 00:57:07,420
>> 観客：は値がありません。

1175
00:57:07,420 --> 00:57:09,380
あなたは、フォームに配置します。

1176
00:57:09,380 --> 00:57:12,320

1177
00:57:12,320 --> 00:57:16,730
値がない場合にはそれだけで、述べています
空白に等しいし、それを行う。

1178
00:57:16,730 --> 00:57:20,040

1179
00:57:20,040 --> 00:57:20,940
その申請の空白があった。

1180
00:57:20,940 --> 00:57:21,170
>> DAVID J.マラン：わかりました。

1181
00:57:21,170 --> 00:57:21,640
しかし注意。

1182
00:57:21,640 --> 00:57:22,830
ここに誰もありません。

1183
00:57:22,830 --> 00:57:25,510
そして、その戻り値のfalseが外にある
もし条件。

1184
00:57:25,510 --> 00:57:29,470
これは、falseを返し、行をハイライト表示
どんな時に実行されませ

1185
00:57:29,470 --> 00:57:32,310
フォームが送信されます。

1186
00:57:32,310 --> 00:57:36,810
何がこの虚偽の内部を返すん
メソッドが呼び出されるようにイベントハンドラ、、

1187
00:57:36,810 --> 00:57:38,450
対象のイベント
提出されて？

1188
00:57:38,450 --> 00:57:42,350

1189
00:57:42,350 --> 00:57:44,470
>> 観客：ので
一度だけ発生します。

1190
00:57:44,470 --> 00:57:45,320
>> DAVID J.マラン：一度だけ発生します。

1191
00:57:45,320 --> 00:57:46,821
はなく、かなり。

1192
00:57:46,821 --> 00:57:47,292
うん？

1193
00:57:47,292 --> 00:57:50,589
>> 観客：それはからフォームを防ぐ
デフォルトの動作に提出する、

1194
00:57:50,589 --> 00:57:52,480
ページのリロードを行うことであろう。

1195
00:57:52,480 --> 00:57:53,110
>> DAVID J.マラン：その通りです。

1196
00:57:53,110 --> 00:57:56,490
だから私は、この用語は、ここに提出する過負荷によ
私が言っているので、フォームがある

1197
00:57:56,490 --> 00:57:57,670
提出さ。

1198
00:57:57,670 --> 00:58:02,240
あなたが示唆するようにしかし、それは実際にはありません
真のHTTPの方法で提出され。

1199
00:58:02,240 --> 00:58:06,870
あなたのために、[送信]をクリックしたときに私たちの
のonSubmitハンドラは、傍受している

1200
00:58:06,870 --> 00:58:09,040
いわば、そのフォームの送信。

1201
00:58:09,040 --> 00:58:11,290
それから、私たちのことをやっている
JavaScriptコードで。

1202
00:58:11,290 --> 00:58:14,070
しかし、私は意図的に、falseを返すよ
私は起きたくないものを理由

1203
00:58:14,070 --> 00:58:18,430
分割は秒後に、フォーム全体のためである
それ自体はウェブに提出する

1204
00:58:18,430 --> 00:58:22,800
変更することで、キーと値のペアを使用してサーバー
のようなものにするためのURL

1205
00:58:22,800 --> 00:58:26,180
Q =猫または何我々が行った、
例えば、クラスで。

1206
00:58:26,180 --> 00:58:29,640
私は、それが起こるしたくないので、
このため、どのサーバのリスニングはありません

1207
00:58:29,640 --> 00:58:30,690
フォーム送信。

1208
00:58:30,690 --> 00:58:32,320
これは純粋にJavaScriptコードで行うの。

1209
00:58:32,320 --> 00:58:35,760
私も持っていなかった理由、それはだ
私ので、私のフォームのaction属性、

1210
00:58:35,760 --> 00:58:38,870
このために意図していない
これまでサーバーにアクセスしてください。

1211
00:58:38,870 --> 00:58:40,780
>> だから、提出されています。

1212
00:58:40,780 --> 00:58:44,340
しかし、我々はそのフォームを傍受している
提出し、デフォルトを防ぐ

1213
00:58:44,340 --> 00:58:47,477
に実際に行動、
すべての道のサーバーにアクセスしてください。

1214
00:58:47,477 --> 00:58:48,730
>> 観客：だから、クライアント側にそれを維持する。

1215
00:58:48,730 --> 00:58:49,780
>> DAVID J.マラン：維持
そのクライアント·サイド。

1216
00:58:49,780 --> 00:58:51,030
まったく正しい。

1217
00:58:51,030 --> 00:58:53,240

1218
00:58:53,240 --> 00:58:55,757
次はMySQLのオーマイた。

1219
00:58:55,757 --> 00:59:00,000

1220
00:59:00,000 --> 00:59:00,430
>> ROBボーデン：わかりました。

1221
00:59:00,430 --> 00:59:04,990
したがって、この最初の質問は、一般的だった
人々のためのラフ。

1222
00:59:04,990 --> 00:59:07,270
後のものは、より良い行ってきましたけど。

1223
00:59:07,270 --> 00:59:12,260
だから、正しいデータを選択しなければならなかった
これらのカラムの両方の型。

1224
00:59:12,260 --> 00:59:17,750
これらの両方は、いくつかを有する
それらについての事、その

1225
00:59:17,750 --> 00:59:20,620
選択を困難にする。

1226
00:59:20,620 --> 00:59:24,430
だから、INTは有効ではありませんでした
番号を入力します。

1227
00:59:24,430 --> 00:59:29,410
その理由は、12桁のアカウントであること
番号は、INTがするのに十分な大きさではありません

1228
00:59:29,410 --> 00:59:31,070
合計の数字を格納します。

1229
00:59:31,070 --> 00:59:36,570
だから、有効な選択肢は、ビッグだっただろう
あなたがそれを知っているために起こる場合int型。

1230
00:59:36,570 --> 00:59:42,090
別の選択があったかもしれない
長さ12のCHARフィールド。

1231
00:59:42,090 --> 00:59:44,560
ので、これらのいずれかが働いていただろう。

1232
00:59:44,560 --> 00:59:46,100
INTはないでしょう。

1233
00:59:46,100 --> 00:59:50,170
>> 今、バランス、バックpset7と思います。

1234
00:59:50,170 --> 00:59:59,540
だから我々は、具体的には、小数点を使用
株式の価値を保存したり - 

1235
00:59:59,540 --> 01:00:00,550
>> DAVID J.マラン：現金。

1236
01:00:00,550 --> 01:00:01,060
>> ROBボーデン：現金。

1237
01:00:01,060 --> 01:00:05,710
我々の量を格納するために小数を用い
ユーザーが現在持って現金。

1238
01:00:05,710 --> 01:00:10,950
だから我々はそれを行う理由は、
覚えているので、浮遊する。

1239
01:00:10,950 --> 01:00:12,480
精度の浮動小数点があります。

1240
01:00:12,480 --> 01:00:18,200
それは、正確に現金を保管することはできません
我々のような値がここに欲しい。

1241
01:00:18,200 --> 01:00:23,630
だから、小数は正確に記憶することができる
、言いたい、小数点以下。

1242
01:00:23,630 --> 01:00:27,630
バランス、我々はそれをしたい理由です
フロートは、小数点とされていないと。

1243
01:00:27,630 --> 01:00:30,230
>> DAVID J.マラン：そしてまた、あまりにも、しかし
それは他で賢いだったかもしれない

1244
01:00:30,230 --> 01:00:32,760
考えるコンテキスト、多分これ
int型のためのチャンスです。

1245
01:00:32,760 --> 01:00:34,420
私はちょうどを記録しておこう
ペニーにあるもの。

1246
01:00:34,420 --> 01:00:38,670
我々は、明示的にデフォルトを示したので、
その100.00であることの価値、

1247
01:00:38,670 --> 01:00:40,380
それだけでINT可能性を意味します。

1248
01:00:40,380 --> 01:00:45,310
あまりにも数が別の微妙
それが意味されていなかったということでした

1249
01:00:45,310 --> 01:00:46,180
トリックの質問であると。

1250
01:00:46,180 --> 01:00:49,860
しかし、MySQLで、そのINTを思い出す
少なくともにおいては、C言語のように

1251
01:00:49,860 --> 01:00:51,440
アプライアンスは、32ビットである。

1252
01:00:51,440 --> 01:00:53,960
そして、我々はすることを期待していないにもかかわらず、
正確に何桁ことを知っている

1253
01:00:53,960 --> 01:00:56,910
手段は、最も多くのことを思い出してやる
あなたは、潜在的に表すことができます

1254
01:00:56,910 --> 01:01:00,710
32ビットの数値で、ほぼ何ですか？

1255
01:01:00,710 --> 01:01:02,760
>> 私たちは常にお客様番号を言うのですか？

1256
01:01:02,760 --> 01:01:04,530
何およそ32、2？

1257
01:01:04,530 --> 01:01:07,492

1258
01:01:07,492 --> 01:01:08,780
あなたは正確に知っている必要はありません。

1259
01:01:08,780 --> 01:01:10,580
しかし、大体の生活に役立ちます。

1260
01:01:10,580 --> 01:01:12,200
これは、およそ40億だ。

1261
01:01:12,200 --> 01:01:14,430
だから我々は何度かあることを言ってきた。

1262
01:01:14,430 --> 01:01:16,360
私が知っている私は何度か述べている。

1263
01:01:16,360 --> 01:01:17,670
そして、それはおよそ40億です。

1264
01:01:17,670 --> 01:01:19,710
そして、それは良いルールだ
親指の知っている。

1265
01:01:19,710 --> 01:01:21,880
あなたが8ビット、256を持っている場合
マジックナンバーです。

1266
01:01:21,880 --> 01:01:24,160
あなたは32ビットで、4を持っている場合
億は与えるか、または取る。

1267
01:01:24,160 --> 01:01:27,140
だから、あなただけの40億を書き留めている場合、
あなたはそれがより少ない数字だということがわかります

1268
01:01:27,140 --> 01:01:30,970
それがはっきりしないということだ12、
キャプチャするための十分な表現力

1269
01:01:30,970 --> 01:01:34,220
12桁の口座番号。

1270
01:01:34,220 --> 01:01:34,940
>> ROBボーデン：わかりました。

1271
01:01:34,940 --> 01:01:38,520
だから、他のものは良く行きました。

1272
01:01:38,520 --> 01:01:40,900
だから、銀行と仮定
毎月20ドルを課し

1273
01:01:40,900 --> 01:01:42,400
すべてのアカウントでの維持費。

1274
01:01:42,400 --> 01:01:45,506
どのようなSQLクエリ可能性があり、銀行との
場合でも、すべてのカウントから20ドルを差し引く

1275
01:01:45,506 --> 01:01:47,520
それはいくつかの負の残高になり？

1276
01:01:47,520 --> 01:01:50,380
そこで、基本的に、4があります
クエリの主な種類 - 

1277
01:01:50,380 --> 01:01:52,840
挿入、選択、更新、および削除する。

1278
01:01:52,840 --> 01:01:56,080
だから我々は我々がしているものだと思いますか
ここで使用するつもり？

1279
01:01:56,080 --> 01:01:57,000
アップデート。

1280
01:01:57,000 --> 01:01:58,260
>> それでは見てみましょう。

1281
01:01:58,260 --> 01:02:04,290

1282
01:02:04,290 --> 01:02:05,870
そこでここでは、更新している。

1283
01:02:05,870 --> 01:02:09,900
どのようなテーブル、我々はアカウントを更新している？

1284
01:02:09,900 --> 01:02:11,670
だから、アカウントを更新する。

1285
01:02:11,670 --> 01:02:15,390
して、構文は、言っていること
口座に我々は更新している？

1286
01:02:15,390 --> 01:02:19,520
まあ、我々と同じバランスを設定している
バランスはマイナス20の現在の値。

1287
01:02:19,520 --> 01:02:22,860
だから、これはすべての行が更新されます
アカウントの減算

1288
01:02:22,860 --> 01:02:26,250
残高から20ドル。

1289
01:02:26,250 --> 01:02:29,260
>> DAVID J.マラン：ここによくある間違い、
我々は時々それを許したとしても、

1290
01:02:29,260 --> 01:02:32,990
実際にここPHPコードを持っていることだった
クエリ関数を呼び出すか、置く

1291
01:02:32,990 --> 01:02:35,460
そのすべてを引用符で囲む
そこにある必要はありませんでした。

1292
01:02:35,460 --> 01:02:39,780
>> ROBボーデン：MySQLがあることを忘れないでください
PHPとは別の言語。

1293
01:02:39,780 --> 01:02:42,410
私たちは、PHPでMySQLを書き込むことが起こる。

1294
01:02:42,410 --> 01:02:46,180
そしてPHPはそれからのお届けとなります
MySQLサーバにフェールオーバ。

1295
01:02:46,180 --> 01:02:51,120
しかし、あなたがするためにPHPを必要としない
MySQLサーバと通信します。

1296
01:02:51,120 --> 01:02:51,730
>> DAVID J.マラン：その通りです。

1297
01:02:51,730 --> 01:02:54,240
ドル記号を持つので、何の変数ません
このコンテキスト内にある必要があります

1298
01:02:54,240 --> 01:02:59,550
それはちょうど、数学のすべてを行うことができます
データベース自体の内部。

1299
01:02:59,550 --> 01:03:00,080
>> ROBボーデン：わかりました。

1300
01:03:00,080 --> 01:03:01,300
ので、次の1。

1301
01:03:01,300 --> 01:03:02,731
これは、次の1か？

1302
01:03:02,731 --> 01:03:03,210
うん。

1303
01:03:03,210 --> 01:03:06,570
それでは、SQLクエリを使用して銀行でし
そのの口座番号を取得

1304
01:03:06,570 --> 01:03:09,300
豊かな顧客を有するもの
千より大きい残高？

1305
01:03:09,300 --> 01:03:13,280
だから、4つの主なタイプのどの
我々はここにしたいとしていますか？

1306
01:03:13,280 --> 01:03:14,430
選択してください。

1307
01:03:14,430 --> 01:03:16,650
だから我々は選択したい。

1308
01:03:16,650 --> 01:03:17,610
我々は選択しますか？

1309
01:03:17,610 --> 01:03:19,380
我々は選択することが何列たいですか？

1310
01:03:19,380 --> 01:03:20,970
我々は、特にお勧めします
番号を選択します。

1311
01:03:20,970 --> 01:03:23,910
しかし、あなたは星を言ったならば、我々
また、それを受け入れた。

1312
01:03:23,910 --> 01:03:25,820
>> それがどうしたテーブルから番号を選択？

1313
01:03:25,820 --> 01:03:26,640
アカウント。

1314
01:03:26,640 --> 01:03:28,370
そして、我々が望む条件？

1315
01:03:28,370 --> 01:03:30,140
どこ千より大きいバランス。

1316
01:03:30,140 --> 01:03:31,720
我々はまた、より大きな受け入れ
よりか等しい。

1317
01:03:31,720 --> 01:03:35,230

1318
01:03:35,230 --> 01:03:36,190
ラスト1。

1319
01:03:36,190 --> 01:03:42,940
どのようなSQLクエリ可能性があり、銀行との
近く、すなわち、すべてのアカウントを削除するには、その

1320
01:03:42,940 --> 01:03:44,480
0ドルの残高を持っている？

1321
01:03:44,480 --> 01:03:47,620
だから、四つのどれウィーアー
使用したいとして？

1322
01:03:47,620 --> 01:03:48,320
削除します。

1323
01:03:48,320 --> 01:03:50,180
だから、そのための構文は？

1324
01:03:50,180 --> 01:03:51,890
どのテーブルから削除しますか？

1325
01:03:51,890 --> 01:03:53,550
アカウント。

1326
01:03:53,550 --> 01:03:55,790
そして、条件、その上に
我々は、削除したい - 

1327
01:03:55,790 --> 01:03:57,280
残高がゼロに等しい。

1328
01:03:57,280 --> 01:04:03,050
だから、アカウントからすべての行を削除
残高はゼロである。

1329
01:04:03,050 --> 01:04:04,300
これらのいずれかに関する質問？

1330
01:04:04,300 --> 01:04:08,840

1331
01:04:08,840 --> 01:04:10,260
キューしてみませんか？

1332
01:04:10,260 --> 01:04:11,200
>> DAVID J.マラン：キューガイド。

1333
01:04:11,200 --> 01:04:17,110
そのため、この1で、私たちはあなたにいくらかを与えた
我々は探検おなじみの構造

1334
01:04:17,110 --> 01:04:20,450
構造体と一緒にクラスのビット、
データだった

1335
01:04:20,450 --> 01:04:21,910
精神に関連する構造。

1336
01:04:21,910 --> 01:04:24,670
キューにも違いがある
我々は何とか覚えなければならなかったことを誰

1337
01:04:24,670 --> 01:04:27,900
大規模で、キューの先頭にあった
一部我々はより多くを作ることができるように、

1338
01:04:27,900 --> 01:04:30,530
少なくとも、メモリの効率的な利用、
我々は、配列を使用していた場合。

1339
01:04:30,530 --> 01:04:35,460
>> リコールするので、我々は、配列を持っている場合、もし、
例えば、これは、目の前である

1340
01:04:35,460 --> 01:04:38,470
キュー、私はここで待ち行列に入る場合には、
そして、誰かがラインに入った

1341
01:04:38,470 --> 01:04:42,710
私の後ろに、私の後ろに、私の後ろに、と
1人がラインを抜け出し、あなた

1342
01:04:42,710 --> 01:04:45,930
私たちは私たち人間のいくつかを見たように、可能性
クラス内のボランティアは、誰もが持っている

1343
01:04:45,930 --> 01:04:47,100
このようにシフトする。

1344
01:04:47,100 --> 01:04:50,880
しかし、一般的に、誰もがやるた
何かが時間を最大限に活用ではありません

1345
01:04:50,880 --> 01:04:54,600
プログラムでは、それはあなたのことを意味するからだ
アルゴリズムとは何で実行されている

1346
01:04:54,600 --> 01:04:56,520
漸近実行時間？

1347
01:04:56,520 --> 01:04:57,420
それは線形です。

1348
01:04:57,420 --> 01:04:59,600
>> それはちょっと愚かだように、私は感じています。

1349
01:04:59,600 --> 01:05:02,890
ライン内の次の人が次の場合
に入ることになっている人

1350
01:05:02,890 --> 01:05:04,660
店舗、それらはすべて持っていない
一緒に移動します。

1351
01:05:04,660 --> 01:05:08,200
ただ、その人がオフに摘み取らとする
時間は、たとえば、来るとき。

1352
01:05:08,200 --> 01:05:09,870
だから我々はそこに少しの時間を節約することができます。

1353
01:05:09,870 --> 01:05:14,840
だからその手段は、しかしそのためには
そのキューの先頭または

1354
01:05:14,840 --> 01:05:18,060
キューの先頭をしようとしている
徐々に深く深く移動

1355
01:05:18,060 --> 01:05:23,340
配列にし、最終的にかもしれない
我々は使用している場合、実際にラップアラウンド

1356
01:05:23,340 --> 01:05:25,790
人々を格納する配列
このキューにある。

1357
01:05:25,790 --> 01:05:28,390
だから、ほとんど考えることができます
円形のデータとして配列

1358
01:05:28,390 --> 01:05:29,880
その意味で構造。

1359
01:05:29,880 --> 01:05:33,970
>> だから、何とかを追跡する必要があります
実際にそれの大きさやそれの終わり

1360
01:05:33,970 --> 01:05:36,250
そして、それの始まりです。

1361
01:05:36,250 --> 01:05:39,490
だから我々はあなたが宣言することを提案する
呼び出し1、キュー、

1362
01:05:39,490 --> 01:05:41,330
それをQ、ちょうど1手紙。

1363
01:05:41,330 --> 01:05:44,570
その後、我々は前にすることを提案
ゼロに初期化し、その大きさ

1364
01:05:44,570 --> 01:05:45,470
ゼロに初期化する。

1365
01:05:45,470 --> 01:05:47,770
>> だから、今は何もありません
そのキューの内側。

1366
01:05:47,770 --> 01:05:50,910
そして、我々は、完了するかを尋ね
中下のエンキューの実装

1367
01:05:50,910 --> 01:05:55,250
関数はnに追加されますよう
その後、Qの終わりとtrueを返します。

1368
01:05:55,250 --> 01:05:58,690
しかし、qは完全であるか負である場合には、
この関数は代わりにfalseを返す必要があります。

1369
01:05:58,690 --> 01:06:01,060
そして、我々はあなたにカップルを与えた
仮定の。

1370
01:06:01,060 --> 01:06:04,320
しかし、彼らは本当に機能的じゃない
関連する、ちょうどそのBOOLは存在しますが、

1371
01:06:04,320 --> 01:06:06,690
なぜなら、技術的には、BOOLにはない
あなたが含まれていない限り、Cに存在する

1372
01:06:06,690 --> 01:06:07,310
特定のヘッダファイル。

1373
01:06:07,310 --> 01:06:09,350
だから、そこを確認してくださいました
NOこれはトリックではないし、

1374
01:06:09,350 --> 01:06:10,940
事の質問一種。

1375
01:06:10,940 --> 01:06:16,280
>> 我々は、サンプルで提案されているので、エン
解決策次のように実装する。

1376
01:06:16,280 --> 01:06:20,420
一つは、我々は最初の使いやすさをチェックし、
低ぶら下げ果物。

1377
01:06:20,420 --> 01:06:23,820
キューが満杯または番号である場合は、その
あなたが挿入しようとしている小さい

1378
01:06:23,820 --> 01:06:26,380
私たちが言っゼロ、より
問題の仕様べき

1379
01:06:26,380 --> 01:06:30,320
我々は唯一たいので、許可されない
そしてあなたはあるべきであるが、負の値、

1380
01:06:30,320 --> 01:06:31,640
ただすぐにfalseを返します。

1381
01:06:31,640 --> 01:06:33,820
ので、いくつかは比較的容易
エラーチェック。

1382
01:06:33,820 --> 01:06:38,720
あなたはその実際を追加したいかの場合
数には、少しをしなければならなかった

1383
01:06:38,720 --> 01:06:39,440
ここに考えて。

1384
01:06:39,440 --> 01:06:41,330
それはちょっと迷惑なんだどこに、これはある
精神的に、あなたがしなければならないので

1385
01:06:41,330 --> 01:06:43,000
ラップアラウンドを処理する方法を見つけ出す。

1386
01:06:43,000 --> 01:06:46,870
>> しかし、のだここでの考え方の生殖に
私たちに関心がそのラップアラウンドです

1387
01:06:46,870 --> 01:06:51,480
多くの場合、モジュラー演算を意味し、
mod演算子、パーセント側、

1388
01:06:51,480 --> 01:06:55,140
あなたは大きな値から行くことができますどこ
ゼロにして、1と2と

1389
01:06:55,140 --> 01:06:58,650
3、その後戻って周りのゼロに、
1と2など3および

1390
01:06:58,650 --> 01:06:59,380
何度も何度も。

1391
01:06:59,380 --> 01:07:02,880
だから我々はこれを行うことを提案の方法です
我々はにインデックスを作成するということ

1392
01:07:02,880 --> 01:07:05,850
数字どこと呼ばれる配列
私たちの整数は嘘。

1393
01:07:05,850 --> 01:07:10,740
しかし、そこに到達するためには、まず何をしたい
キューのサイズがあるが何であれ

1394
01:07:10,740 --> 01:07:14,080
その後、どのようなものに追加
リストの先頭です。

1395
01:07:14,080 --> 01:07:17,880
そして、それの効果はで私達を置くことです
キュー内の正しい位置と

1396
01:07:17,880 --> 01:07:20,970
行の最初の人と想定していない
先頭にあり、その彼または

1397
01:07:20,970 --> 01:07:24,130
彼女は絶対になることができれば我々
また、すべての人をシフトされた。

1398
01:07:24,130 --> 01:07:26,710
しかし、我々は単に仕事を作成している
自分のために私たちがかかった場合

1399
01:07:26,710 --> 01:07:27,800
その特定のパス。

1400
01:07:27,800 --> 01:07:29,330
>> だから我々は、比較的単純な、それを維持することができます。

1401
01:07:29,330 --> 01:07:32,180
我々はちょうどその私たちを覚えておく必要があります
キューにint型を追加しました。

1402
01:07:32,180 --> 01:07:35,850
そして、我々は単にtrueを返す。

1403
01:07:35,850 --> 01:07:38,560
一方、デキューでは、我々は尋ねた
あなたは以下を実行する。

1404
01:07:38,560 --> 01:07:42,260
このような方法でそれを実装することを、それ
デキュー、つまり、除去·リターンである、

1405
01:07:42,260 --> 01:07:44,190
キューの先頭にint型。

1406
01:07:44,190 --> 01:07:46,410
int型を削除するには、それが十分である
それを忘れている。

1407
01:07:46,410 --> 01:07:47,650
あなたは、そのビットをオーバーライドする必要はありません。

1408
01:07:47,650 --> 01:07:48,820
だから、実際にそこにまだある。

1409
01:07:48,820 --> 01:07:51,930
ただ、ハードドライブ上のデータのように、
我々だけで事実を無視している

1410
01:07:51,930 --> 01:07:52,970
それはそこになりましたということ。

1411
01:07:52,970 --> 01:07:55,520
Qが空である場合、我々はすべき
代わりに負の1を返す。

1412
01:07:55,520 --> 01:07:56,750
だから、これは任意で感じている。

1413
01:07:56,750 --> 01:08:01,640
なぜ負の戻り1
代わりに、偽？

1414
01:08:01,640 --> 01:08:02,620
うん。

1415
01:08:02,620 --> 01:08:05,070
>> 観客：Qが収納されている
正の値。

1416
01:08:05,070 --> 01:08:10,950
あなたは正の値のみを格納しているため
Qは、負はエラーになります。

1417
01:08:10,950 --> 01:08:11,510
>> DAVID J.マラン：OK、真。

1418
01:08:11,510 --> 01:08:14,850
だから我々は唯一の肯定を保存しているので、
値またはゼロは、それはにいいのよ

1419
01:08:14,850 --> 01:08:18,050
センチネルとして負の値を返す
値、特殊記号。

1420
01:08:18,050 --> 01:08:21,630
しかし、あなたは、そこに歴史を書き換えている
なぜなら我々は唯一だ理由

1421
01:08:21,630 --> 01:08:25,890
負でない値を返す
私たちがしたいからです。

1422
01:08:25,890 --> 01:08:27,670
標識値を持っている。

1423
01:08:27,670 --> 01:08:32,617
より具体的には、なぜだけではなく、
エラーの例ではfalseを返す？

1424
01:08:32,617 --> 01:08:33,099
うん。

1425
01:08:33,099 --> 01:08:35,510
>> 読者：あなたが失敗しました
整数を返す。

1426
01:08:35,510 --> 01:08:36,630
>> DAVID J.マラン：その通りです。

1427
01:08:36,630 --> 01:08:38,569
Cが取得する場所と、これはある
かなり制約。

1428
01:08:38,569 --> 01:08:40,590
あなたが行っていると言っている場合
int型を返すには、持っている

1429
01:08:40,590 --> 01:08:41,279
int型を返すことができます。

1430
01:08:41,279 --> 01:08:43,689
あなたは空想取得し、戻って起動することはできません
BOOLまたはfloatまたは

1431
01:08:43,689 --> 01:08:45,040
文字列またはそのような何か。

1432
01:08:45,040 --> 01:08:49,370
さて、一方で、JavaScriptとPHPと
いくつかの他の言語ができ、実際には、

1433
01:08:49,370 --> 01:08:51,310
あなたが異なる戻ってきた
値の型。

1434
01:08:51,310 --> 01:08:54,819
そして、それは実際にどこで、便利です
あなたは正整数、ゼロを返すことができ、

1435
01:08:54,819 --> 01:08:59,439
負の整数、またはFALSEまたはNULL
でも、エラーを示すために。

1436
01:08:59,439 --> 01:09:01,890
しかし、我々はそれを持っていない
Cの汎用性

1437
01:09:01,890 --> 01:09:04,569
>> そうデキューと、私たち
で行うことを提案する - 

1438
01:09:04,569 --> 01:09:07,350

1439
01:09:07,350 --> 01:09:09,830
>> ROBボーデン：あなたはfalseを返すことができます。

1440
01:09:09,830 --> 01:09:13,189
それは、ハッシュだけでは偽ですそれは
ゼロにfalseを定義します。

1441
01:09:13,189 --> 01:09:16,000
だから、falseを返した場合、
あなたは、ゼロを返している。

1442
01:09:16,000 --> 01:09:25,470
ゼロは、我々のキューで有効なものですが、
負の1に対した場合ではありません

1443
01:09:25,470 --> 01:09:27,000
偽は、負の1であることを起こった。

1444
01:09:27,000 --> 01:09:29,972
しかし、あなたもいけない
それを知っている必要があります。

1445
01:09:29,972 --> 01:09:32,399
>> DAVID J.マラン：それです。
なぜ私はそれを言わなかった。

1446
01:09:32,399 --> 01:09:36,450
>> ROBボーデン：しかし、それは本当ではなかった
あなたはfalseを返すことができない。

1447
01:09:36,450 --> 01:09:37,700
>> DAVID J.マラン：確かに。

1448
01:09:37,700 --> 01:09:40,920

1449
01:09:40,920 --> 01:09:44,240
我々は受け入れるので、デキュー、予告
引数として無効になる。

1450
01:09:44,240 --> 01:09:45,479
そして、我々はわからないので、それはだ
インチ何を渡す

1451
01:09:45,479 --> 01:09:48,359
我々だけで要素を削除したい
キューの先頭に。

1452
01:09:48,359 --> 01:09:49,819
では、どのように我々はこれをやって行くのでしょうか？

1453
01:09:49,819 --> 01:09:51,290
さて、まず、これをやらせる
迅速な健全性チェック。

1454
01:09:51,290 --> 01:09:53,350
キュー·サイズが0の場合、そこ
なすべき仕事ません。

1455
01:09:53,350 --> 01:09:54,210
負の1を返します。

1456
01:09:54,210 --> 01:09:54,800
行わ。

1457
01:09:54,800 --> 01:09:56,340
だから、私のプログラムの数行です。

1458
01:09:56,340 --> 01:09:58,180
だから、唯一の4行が残っている。

1459
01:09:58,180 --> 01:10:01,310
>> だからここに私はデクリメントすることにした
サイズ。

1460
01:10:01,310 --> 01:10:04,620
かつ効果的にサイズをデクリメント
私が忘れていることを意味します

1461
01:10:04,620 --> 01:10:06,010
何かがそこにある。

1462
01:10:06,010 --> 01:10:09,910
しかし、私はまた更新する必要がどこに
数字の前にある。

1463
01:10:09,910 --> 01:10:11,620
そうそのためには、私が必要とする
2つのことを行う。

1464
01:10:11,620 --> 01:10:16,390
私が最初にどのような番号を覚えておく必要があります
キューの先頭にある、

1465
01:10:16,390 --> 01:10:17,860
私はそのことを返す必要があるため。

1466
01:10:17,860 --> 01:10:20,910
だから私はうっかり忘れたくない
それについて、それを上書きします。

1467
01:10:20,910 --> 01:10:22,840
私はint型で覚えておくつもりです。

1468
01:10:22,840 --> 01:10:27,310
>> そして今、私が更新したい
1をq.frontするq.front。

1469
01:10:27,310 --> 01:10:30,070
これがの最初の人だった場合
ラインは、今、私はプラス1をやってみたい

1470
01:10:30,070 --> 01:10:31,930
ライン内の次の人を指す。

1471
01:10:31,930 --> 01:10:33,420
しかし、私はラップアラウンドを処理する必要があります。

1472
01:10:33,420 --> 01:10:37,270
容量がグローバル定数である場合、
それは私が確認するためにできるようになるだろう

1473
01:10:37,270 --> 01:10:41,140
私はで非常に最後の人を指すように
ライン、モジュロ演算がもたらす

1474
01:10:41,140 --> 01:10:43,840
でゼロに私の背中
キューの先頭。

1475
01:10:43,840 --> 01:10:46,050
そして、それはここでラップアラウンドを処理します。

1476
01:10:46,050 --> 01:10:48,950
そして私は、nを返すように進んでください。

1477
01:10:48,950 --> 01:10:51,530
>> 今、厳密に言えば、私はしませんでした
Nを宣言する必要があります。

1478
01:10:51,530 --> 01:10:53,880
私はそれを取得し、それを格納する必要はありませんでした
一時的に、値であるため

1479
01:10:53,880 --> 01:10:54,740
まだある。

1480
01:10:54,740 --> 01:10:57,490
だから私はちょうど算術を行うことができます
元ヘッドを返す

1481
01:10:57,490 --> 01:10:58,450
キューの。

1482
01:10:58,450 --> 01:11:01,850
しかし、私はちょうどこれがより明らかになったと感じていた
実際にint型をつかむために、それを置く

1483
01:11:01,850 --> 01:11:04,320
nは、その後、それを返す
明瞭化のためではなく、

1484
01:11:04,320 --> 01:11:05,735
必ずしも必要ではありません。

1485
01:11:05,735 --> 01:11:09,313

1486
01:11:09,313 --> 01:11:12,130
PSST。

1487
01:11:12,130 --> 01:11:13,410
彼らはすべての私の頭の中で発音している。

1488
01:11:13,410 --> 01:11:15,940

1489
01:11:15,940 --> 01:11:19,110
>> ROBボーデン：だから最初の質問
二分木の問題がある。

1490
01:11:19,110 --> 01:11:22,140
だから、最初の質問は、私たちがしている、ある
これらの数字与えられ。

1491
01:11:22,140 --> 01:11:27,160
そして、我々は何とかにそれらを挿入する
これらのノードは、であるような

1492
01:11:27,160 --> 01:11:30,110
有効な二分探索木。

1493
01:11:30,110 --> 01:11:36,260
だから一つのことについて覚えて
二分探索木はそうでないということです

1494
01:11:36,260 --> 01:11:39,800
ちょうどその左の事
が少ないとの事です。

1495
01:11:39,800 --> 01:11:41,120
右は大きい。

1496
01:11:41,120 --> 01:11:44,580
それがする必要があるとツリー全体へ
左が少なく、ツリー全体

1497
01:11:44,580 --> 01:11:45,740
右に大きい。

1498
01:11:45,740 --> 01:11:55,260
>> だから私がトップでここに34を入れた場合、その後、
私はここで20を置くので、それはとても有効なの

1499
01:11:55,260 --> 01:11:56,970
ここまで、34まで、ここからです。

1500
01:11:56,970 --> 01:11:57,920
20は左に行っている。

1501
01:11:57,920 --> 01:11:58,950
だから少ないです。

1502
01:11:58,950 --> 01:12:03,640
しかし、私はそれから、ここに59を置くことができないため、
59は、20の右側にあっても、

1503
01:12:03,640 --> 01:12:06,140
それは34の左側にはまだです。

1504
01:12:06,140 --> 01:12:10,760
このことを念頭に置いての制約とそう、
おそらく、これを解決する最も簡単な方法

1505
01:12:10,760 --> 01:12:14,330
問題は、単にソートすることです。
これらの数の - 

1506
01:12:14,330 --> 01:12:18,720
そのように20、34、36、52、59、106。

1507
01:12:18,720 --> 01:12:21,640
次にそれらを挿入
左から右へ。

1508
01:12:21,640 --> 01:12:23,390
>> だから20がここに入ります。

1509
01:12:23,390 --> 01:12:24,630
34がここに入ります。

1510
01:12:24,630 --> 01:12:25,830
36がここに入ります。

1511
01:12:25,830 --> 01:12:29,360
52、59、106。

1512
01:12:29,360 --> 01:12:34,730
そして、あなたはまたして考え出したかもしれない
中には、プラグインすると実現

1513
01:12:34,730 --> 01:12:38,830
ああ、私は十分な数字を持っていない、待って
こっちでこれを埋めるために。

1514
01:12:38,830 --> 01:12:42,170
だから私は何を私のreshiftする必要があります
ルート·ノートでは、になるだろう。

1515
01:12:42,170 --> 01:12:47,490
しかし、もし、最後の3つの中のことに気付く
あなたが左から右に読んで、それがである

1516
01:12:47,490 --> 01:12:48,740
昇順。

1517
01:12:48,740 --> 01:12:52,150

1518
01:12:52,150 --> 01:12:56,540
>> だから今、私たちは何を宣言したい
構造体は、ためになるだろう

1519
01:12:56,540 --> 01:12:58,300
このツリー内のノード。

1520
01:12:58,300 --> 01:13:02,720
だから我々は、二分木に何が必要ですか？

1521
01:13:02,720 --> 01:13:05,830
だから我々は、型の値を持っている
int型なので、いくつかのint型の値。

1522
01:13:05,830 --> 01:13:07,220
私は我々が呼ばれるかわからない
溶液中で - 

1523
01:13:07,220 --> 01:13:08,500
N int型。

1524
01:13:08,500 --> 01:13:13,570
我々は左の子へのポインタを必要とする
そして右の子へのポインタ。

1525
01:13:13,570 --> 01:13:17,540
だから、このように見えるようになるだろう。

1526
01:13:17,540 --> 01:13:20,510
そしてそれは実際に前に見ていきます
二重リンクなかったとき

1527
01:13:20,510 --> 01:13:25,090
リストのものなので、通知 - 

1528
01:13:25,090 --> 01:13:27,860
私はすべてにスクロールする必要がありますするつもりだ
帰りダウン問題11へ。

1529
01:13:27,860 --> 01:13:30,980

1530
01:13:30,980 --> 01:13:36,390
>> だから、これと同じに見えるに気付く、
私達はちょうどこれらを呼び出すことが起こる除く

1531
01:13:36,390 --> 01:13:38,590
別の名前。

1532
01:13:38,590 --> 01:13:41,440
我々はまだ、整数を持っている
値と二つのポインタ。

1533
01:13:41,440 --> 01:13:44,850
それ扱うのではなく、まさにそれだ
次の事を指すようポインタ

1534
01:13:44,850 --> 01:13:47,955
と前の事は、我々は治療している
ポインタは左の子を指すように

1535
01:13:47,955 --> 01:13:49,205
そして右の子。

1536
01:13:49,205 --> 01:13:57,372

1537
01:13:57,372 --> 01:13:57,860
[OK]をクリックします。

1538
01:13:57,860 --> 01:13:59,650
だから、私たちの構造ノードの。

1539
01:13:59,650 --> 01:14:03,920
そして今、唯一の機能は、私たちのことを行う必要があり
これはトラバースであるため、実装している

1540
01:14:03,920 --> 01:14:08,320
私たちは、木の上に行きたい、印刷
順にツリーの値が不足しています。

1541
01:14:08,320 --> 01:14:15,241
>> だからここを見ると、印刷したいと思う
アウト20、34、36、52、59、および106。

1542
01:14:15,241 --> 01:14:17,970
どのように我々はそれを達成するの​​ですか？

1543
01:14:17,970 --> 01:14:18,890
だから、それはかなり似ている。

1544
01:14:18,890 --> 01:14:22,910
あなたは過去の試験問題を見た場合
あなたがプリントアウトしたいと

1545
01:14:22,910 --> 01:14:25,940
その間にカンマでツリー全体
すべてのもの、それも、実際にあった

1546
01:14:25,940 --> 01:14:27,320
それよりも容易になります。

1547
01:14:27,320 --> 01:14:30,950
だからここソリューションです。

1548
01:14:30,950 --> 01:14:33,110
これはかなり簡単だった
あなたは再帰的にそれをしなかった場合には。

1549
01:14:33,110 --> 01:14:36,650
誰も試みたかどうかは知りません
反復的にそれを行うには。

1550
01:14:36,650 --> 01:14:38,340
>> しかし、最初に、我々は我々のベースケースを持っている。

1551
01:14:38,340 --> 01:14:39,660
何ルートがnullの場合は？

1552
01:14:39,660 --> 01:14:40,610
その後、我々は単に返すようになるだろう。

1553
01:14:40,610 --> 01:14:42,300
私たちは、何も印刷しない。

1554
01:14:42,300 --> 01:14:45,940
他に私たちは横断しようとしている
再帰的にダウン。

1555
01:14:45,940 --> 01:14:48,140
全体の左部分木を印刷します。

1556
01:14:48,140 --> 01:14:51,440
だから、あまり、すべてを印刷する
私の現在の値よりも。

1557
01:14:51,440 --> 01:14:53,930
そして私は自分自身を印刷するつもりです。

1558
01:14:53,930 --> 01:14:57,310
そして私は私を下に再帰的にするつもりだ
全体右部分木なので、すべてのもの

1559
01:14:57,310 --> 01:14:58,810
私の値よりも大きい。

1560
01:14:58,810 --> 01:15:03,870
そして、これは、印刷しようとしている
順番にすべてのものが不足しています。

1561
01:15:03,870 --> 01:15:05,860
どのようにこの実際に質問
それを実現する？

1562
01:15:05,860 --> 01:15:09,892

1563
01:15:09,892 --> 01:15:12,545
>> 読者：私は疑問を持っている
[聞こえない]に。

1564
01:15:12,545 --> 01:15:15,090

1565
01:15:15,090 --> 01:15:23,550
>> ROBボーデン：近づくので、一つの方法
任意の再帰的な問題だけで考えることです

1566
01:15:23,550 --> 01:15:26,275
それについてあなたが考えなければならないように
すべてのコーナーケースについて。

1567
01:15:26,275 --> 01:15:32,150

1568
01:15:32,150 --> 01:15:38,110
だから我々がしたいと考えている
このツリー全体を印刷します。

1569
01:15:38,110 --> 01:15:42,030
したがって、すべての私たちは、に焦点を当てるとしている
この特定のノードである - 

1570
01:15:42,030 --> 01:15:43,740
36。

1571
01:15:43,740 --> 01:15:47,420
再帰呼び出しは、私たちはふり
それらはただ働く。

1572
01:15:47,420 --> 01:15:54,000
だからここに、この再帰呼び出し
でも何も考えずに、私たちを通過

1573
01:15:54,000 --> 01:15:58,640
それについてだけ左をトラバース
3、すでに20を印刷していることを想像する

1574
01:15:58,640 --> 01:16:00,730
そして私たちのために34。

1575
01:16:00,730 --> 01:16:03,350
して、ときに我々最終的に再帰的に
上のトラバースを呼び出す

1576
01:16:03,350 --> 01:16:07,890
右、それが正しく印刷されます
52、59、そして私たちのために106。

1577
01:16:07,890 --> 01:16:13,620
>> だから、これは20、34を印刷することができますことを考えると、
もう一つは、52、59、108を印刷することができます

1578
01:16:13,620 --> 01:16:17,180
我々が行うことができるように必要なものはプリントです
それの真ん中に私たち自身。

1579
01:16:17,180 --> 01:16:21,250
だから私たちの前にすべてのものをプリントアウトする。

1580
01:16:21,250 --> 01:16:27,710
私たち自身を印刷するため、現在のノードを印刷
36、定期的なprintf関数、その後、

1581
01:16:27,710 --> 01:16:31,170
私たちの後にすべてを印刷します。

1582
01:16:31,170 --> 01:16:32,730
>> DAVID J.マラン：これはどこ再帰です
本当に美しい取得します。

1583
01:16:32,730 --> 01:16:36,270
それは、信仰のこの素晴らしいLEAPのWHERE
あなたは仕事の最も小さいビットを行う。

1584
01:16:36,270 --> 01:16:38,460
それから、あなたは誰かを聞かせて
他の残りの部分を行う。

1585
01:16:38,460 --> 01:16:40,180
そして、そのほかの人
あなたは、皮肉なことに、ある。

1586
01:16:40,180 --> 01:16:44,260

1587
01:16:44,260 --> 01:16:48,360
深刻なブラウニーポイントの場合、もしそうであれば
あなたが質問にスクロールアップ - 

1588
01:16:48,360 --> 01:16:50,530
>> ROBボーデン：質問か？

1589
01:16:50,530 --> 01:16:53,490
>> DAVID J.マラン：およびTo少しダウン
ここでの数字は、誰もが知っていますか

1590
01:16:53,490 --> 01:16:55,190
これらの数字から来るの？

1591
01:16:55,190 --> 01:16:56,610
>> ROBボーデン：私は、文字通りは考えている。

1592
01:16:56,610 --> 01:16:59,794
>> DAVID J.マラン：彼らが表示される
クイズを通して。

1593
01:16:59,794 --> 01:17:01,150
>> 読者：彼らは同じ番号はありますか？

1594
01:17:01,150 --> 01:17:01,910
>> DAVID J.マラン：これらの数字。

1595
01:17:01,910 --> 01:17:03,260
小さなイースターエッグ。

1596
01:17:03,260 --> 01:17:08,100
だから、オンラインで見ているあなたのそれらのために
家は、次の作業を行う電子メールによって私達に伝えることができた場合

1597
01:17:08,100 --> 01:17:12,680
heads@CS50.net何の意義
これらの定期的な6つの数字の

1598
01:17:12,680 --> 01:17:18,560
クイズ1を通じて、私たちはあなたをシャワーします
最終的に驚くほどの注意を払って

1599
01:17:18,560 --> 01:17:21,610
講義やストレスボール。

1600
01:17:21,610 --> 01:17:25,460

1601
01:17:25,460 --> 01:17:27,790
素敵な、微妙。

1602
01:17:27,790 --> 01:17:29,570
>> ROBボーデン：どれでも過去の質問
クイズには何でしょうか？

1603
01:17:29,570 --> 01:17:32,608