1
00:00:00,210 --> 00:00:00,810
大丈夫。

2
00:00:00,810 --> 00:00:03,900
だから、これらの3つの問題の解決策を見てみましょう。

3
00:00:03,930 --> 00:00:10,100
最初のものから始めてみましょう。ここで始めることさえあります。私は前進して供給を開くつもりです。

4
00:00:10,740 --> 00:00:18,530
私は彼を老化させる指標を持っています。ファイルを作成し、スクリプトタグを追加して、この解決策を呼び出すだけです。

5
00:00:18,750 --> 00:00:19,110
 

6
00:00:19,230 --> 00:00:21,410
はい。

7
00:00:21,420 --> 00:00:28,410
だから次は、この解決策をJファイルにする必要があり、その解決策を保存するつもりです。

8
00:00:28,640 --> 00:00:32,130
はい、同じ場所でかなり安全です。

9
00:00:32,700 --> 00:00:35,340
だから私達は偶数で始まっています。

10
00:00:35,610 --> 00:00:38,430
だから私は関数が偶数であることを宣言するつもりで、それは単一の引数をとる必要があります。

11
00:00:41,340 --> 00:00:43,100
 

12
00:00:43,200 --> 00:00:47,640
 

13
00:00:50,580 --> 00:00:56,990
それを麻痺と呼びましょう。さもなければ偽を返す場合はtrueを返したいとします。

14
00:00:57,030 --> 00:00:59,040
したがって、これを行うにはいくつかの方法があります。

15
00:00:59,100 --> 00:01:01,880
最初の方法はできるだけ明示的に行うことです。

16
00:01:02,070 --> 00:01:10,830
だから、麻痺モード2がゼロであるかどうかは、剰余がなければ2をその数に分割する残りの部分がゼロであっても何かがあるかどうかをどう思い出すのかを覚えておいてください。

17
00:01:10,830 --> 00:01:15,430
 

18
00:01:15,480 --> 00:01:16,680
それはそれが均等であることを意味します。

19
00:01:16,770 --> 00:01:25,600
したがって、TRUEを返すことができれば、それ以外の場合はfalseを返します。

20
00:01:25,830 --> 00:01:27,230
ちょうどそれのように。

21
00:01:27,870 --> 00:01:29,520
 

22
00:01:32,820 --> 00:01:37,240
そして、私はこれを上に移動して、何に対応するのかを明確にするつもりです。

23
00:01:37,470 --> 00:01:39,610
ちょうどそれのように。

24
00:01:40,080 --> 00:01:41,260
だから我々はこれを行うことができます。

25
00:01:41,580 --> 00:01:44,480
そして、私は実際に私の機能をまだ呼び出すつもりはありません。

26
00:01:44,490 --> 00:01:49,430
私はあなたに若干新しいことを示すためにブラウザでそれを開くつもりです。

27
00:01:49,860 --> 00:01:57,500
だから私が私のコンソールを開くと、実際に私のコンソールにもアクセスできます。

28
00:01:57,870 --> 00:02:04,170
だから、たとえ括弧がついていなくても、私が知っていることは偶然であることを私に伝えます。ここにコードがあります。そして、かっこを追加すると、その番号を5のように渡す必要があります。

29
00:02:04,170 --> 00:02:09,880
 

30
00:02:10,440 --> 00:02:19,120
そして、私は4人で、1人で、あるいは90人でもう一度やり直すことができます。

31
00:02:19,530 --> 00:02:21,860
だから、そこには二つのことがあります。

32
00:02:21,900 --> 00:02:22,910
それは素晴らしいです。

33
00:02:22,950 --> 00:02:28,590
しかし、もっと重要なのは、関数とコードをファイルに定義できることを示したいと思います。

34
00:02:28,800 --> 00:02:31,420
そして、それらのファイルをブラウザで開くと、

35
00:02:31,620 --> 00:02:35,510
このケースでは、私たちの老化した彼は私たちのJavaScriptファイルに接続しているL5です。

36
00:02:35,580 --> 00:02:40,140
私はそれらの機能にアクセスすることができます。

37
00:02:40,140 --> 00:02:42,500
そこでここで作ることができる小さなリファクタがあります。

38
00:02:42,750 --> 00:02:49,650
 

39
00:02:49,650 --> 00:02:57,470
私はこのコードをすべてコメントしたものをコピーして、これを短くするつもりですので、まずはソリューションを最初に示してから、それがどのように機能するかを見て行きます。

40
00:02:57,480 --> 00:03:00,670
これは実質的により短い復帰です。

41
00:03:00,800 --> 00:03:04,260
2番は等号= 0です。

42
00:03:04,260 --> 00:03:05,610
では、ページを更新しましょう。

43
00:03:05,640 --> 00:03:12,980
3が偽であっても4が真であっても動作することを確認してください。

44
00:03:12,990 --> 00:03:15,060
それでも同じように動作します。

45
00:03:16,260 --> 00:03:19,660
それで実際にこの行が実際にここで動作する方法です。

46
00:03:19,710 --> 00:03:22,920
リターンナームはトリプルにしてゼロに等しい。

47
00:03:23,130 --> 00:03:28,750
最初にこれを評価するつもりです。それは真偽のステートメントです。ブールステートメントです。

48
00:03:29,040 --> 00:03:33,180
トリポリがゼロに麻痺するのは真か偽かのどちらかです。

49
00:03:33,270 --> 00:03:35,840
そして、私たちはただ真実か偽かを戻しています。

50
00:03:36,120 --> 00:03:43,800
真であるかどうかを調べるのではなく、真偽を返し、偽であればfalseを返します。

51
00:03:43,800 --> 00:03:44,970
 

52
00:03:44,970 --> 00:03:48,170
だからそこには素敵なショートカットがあります。

53
00:03:49,860 --> 00:03:52,100
だから次は階乗がある。

54
00:03:52,320 --> 00:04:00,510
だから私は先に進んで、階乗階乗階乗という私の関数を定義することから始め、数を取る必要があることを知っています。

55
00:04:00,510 --> 00:04:03,070
 

56
00:04:04,110 --> 00:04:05,780
ここで私はメモを書くつもりです。

57
00:04:05,880 --> 00:04:14,430
だから私が4の階乗をした場合、それは私に4回3回2回1回与えるべきで、私はそれを持って来るつもりです。

58
00:04:14,430 --> 00:04:17,340
 

59
00:04:17,340 --> 00:04:20,820
私たちの関数の中で、私は擬似コードをいくつか書くつもりです。

60
00:04:20,850 --> 00:04:26,730
私たちが最初にやりたいことは、結果変数を定義することです。関数の最後のものは結果変数を返します。

61
00:04:26,730 --> 00:04:30,050
 

62
00:04:30,480 --> 00:04:34,230
 

63
00:04:36,960 --> 00:04:42,770
間には重要なことがあり、それが結果の階乗と値を計算するところです。

64
00:04:44,060 --> 00:04:47,740
そこで、階乗をどのように計算できるかについて、いくつかのアプローチがあります。

65
00:04:47,880 --> 00:04:54,290
最初の結果を1に設定してから2を掛け、次に3を掛けて4を掛けるか、ここにあるように別の方法で行くことができます。

66
00:04:54,620 --> 00:04:59,910
 

67
00:05:00,390 --> 00:05:08,140
そして、私はこのようにして始めます。その結果、変数varの結果は1に等しくなります。

68
00:05:08,730 --> 00:05:15,710
そして、私たちがしなければならないことは、結果を1とその数の間のあらゆる数で掛けることです。

69
00:05:15,750 --> 00:05:20,110
だから何とか4番か1番か10番に入るのですか？

70
00:05:20,670 --> 00:05:25,840
そのためには、forループまたはwhileループのいずれかを使用できるループを使用する必要があります。

71
00:05:26,040 --> 00:05:28,800
ここではforループを使用するつもりですが、少し短くなっています。

72
00:05:28,920 --> 00:05:32,750
それでは遠くに、それを私と呼んでみましょう。

73
00:05:33,300 --> 00:05:35,060
そして私は私を1人として始めました。

74
00:05:35,160 --> 00:05:37,030
だから私はまずそれをやるでしょう。

75
00:05:37,410 --> 00:05:45,330
そして、私が麻痺以下である間に逓増を続けようとするたびに、私は毎回1を加えるつもりです。

76
00:05:45,480 --> 00:05:47,380
 

77
00:05:47,880 --> 00:05:54,950
そして私たちがしたいことはすべて私が結果を倍増させることです。

78
00:05:55,250 --> 00:06:04,080
だから私たちがこれを踏んだ場合、4つの結果の4つの階級のためにそれを開始すると、ここに1つの結果が始まります。私は始まりを1にし、結果を掛けます。

79
00:06:04,120 --> 00:06:09,250
 

80
00:06:09,450 --> 00:06:13,350
だから私は気づいたのはちょうど1回1です。

81
00:06:13,350 --> 00:06:16,410
だから我々はこれを2で始めることができます。

82
00:06:16,440 --> 00:06:20,350
だから初めて、私たちは時間の結果を掛けます。

83
00:06:20,400 --> 00:06:22,560
だから我々は1回2を得る。

84
00:06:22,680 --> 00:06:27,710
次回は私が追加したので私は3つになりました。

85
00:06:27,990 --> 00:06:30,920
それはまだ4つの数よりも少ないです。

86
00:06:30,930 --> 00:06:38,040
だから私たちは再び結果を現在の値と同じにします。結果はこの時3です。

87
00:06:39,090 --> 00:06:43,990
だから私たちは6を持っていますし、次の時は今は4です。

88
00:06:44,000 --> 00:06:46,250
したがって、4は4以下です。

89
00:06:46,250 --> 00:06:47,230
それは本当です。

90
00:06:47,580 --> 00:06:53,790
私たちは最後の時間に4を掛けて、私たちの4つのループで1つを加えて、今度は終了します。

91
00:06:53,790 --> 00:06:54,500
 

92
00:06:55,250 --> 00:06:57,260
今私たちは5時ですから5。

93
00:06:57,250 --> 00:06:59,380
それは4以下ではありません。

94
00:07:00,120 --> 00:07:02,000
それだけで私たちはそこでやるべきことがあります。

95
00:07:02,000 --> 00:07:04,000
私たちができる小さな変化があります。

96
00:07:04,050 --> 00:07:06,940
我々は結果が結果の時間と等しいと言う必要はありません。

97
00:07:06,950 --> 00:07:14,340
私は、私たちが今持っていたものとまったく同じもののためのちょうどショートカットであるstar equalsを使ってこれを短縮することができます。

98
00:07:14,340 --> 00:07:15,240
 

99
00:07:15,690 --> 00:07:19,770
そして最後に、結果を返すしかありません。

100
00:07:20,280 --> 00:07:27,130
だから、ブラウザのリフレッシュでそれを開いて保存し、私たちの階乗関数にアクセスする必要があります。

101
00:07:27,960 --> 00:07:31,480
3の階乗を試してみましょう。

102
00:07:31,530 --> 00:07:41,340
私たちが10の階乗の解としてここで得たものである、360または2000の3階乗の階乗はどうですか？

103
00:07:41,390 --> 00:07:46,940
 

104
00:07:47,370 --> 00:07:48,860
そしてそれを試してみましょう。

105
00:07:49,110 --> 00:07:52,060
ゼロの因数。

106
00:07:53,250 --> 00:07:54,630
そして、私たちは1つを得る。

107
00:07:54,660 --> 00:07:56,230
それで完璧に動作します。

108
00:07:56,670 --> 00:07:58,510
それだけで階乗をする必要があります。

109
00:07:58,710 --> 00:08:05,090
私が言及したように、あなたは数字と等しい結果で始まる別の方向にこれを行うことができます。

110
00:08:05,160 --> 00:08:06,420
そして私たちは後ろ向きに働きます。

111
00:08:06,540 --> 00:08:08,450
そして、それは非常に簡単な変更です。

112
00:08:08,670 --> 00:08:17,930
基本的に私たちはこれを麻痺させるように変更し、私たちはここで私が麻痺していない状態で開始します。

113
00:08:17,930 --> 00:08:24,220
1以上である。

114
00:08:24,260 --> 00:08:25,780
マイナスマイナス。

115
00:08:26,190 --> 00:08:31,980
だから我々は4つの結果を開始しているので、3より結果が1少ない数を掛けて3を引いてから1を引いてみよう。

116
00:08:31,980 --> 00:08:34,140
 

117
00:08:34,160 --> 00:08:38,110
2を掛けて1を掛けて、それで終わりです。

118
00:08:38,550 --> 00:08:40,430
だから確実にうまくいくように。

119
00:08:40,440 --> 00:08:43,870
私たちがリフレッシュした場合に遭遇する唯一の問題です。

120
00:08:43,950 --> 00:08:45,800
この3つの階乗を試してみましょう。

121
00:08:45,840 --> 00:08:51,640
それは私たちに6を与え、5は私たちに120を与え、0はゼロを与える。

122
00:08:51,870 --> 00:08:56,030
ですから、私たちがこのように始めたときに問題があります。

123
00:08:56,040 --> 00:08:57,760
結果は麻痺に等しい。

124
00:08:57,920 --> 00:09:01,740
ゼロを渡すと、結果はゼロになります。

125
00:09:02,120 --> 00:09:03,250
そして、私たちは終わりました。

126
00:09:03,300 --> 00:09:05,190
私たちは0に何も乗算していません。

127
00:09:05,180 --> 00:09:07,630
私たちがそれをしても、それはまだゼロになるでしょう。

128
00:09:07,910 --> 00:09:12,900
 

129
00:09:12,960 --> 00:09:18,790
ですから、それに対する解決策は、ここでの麻痺スコアが0の場合のようなものである可能性がある場合は、単純にすることができます。

130
00:09:18,990 --> 00:09:22,760
私たちがすべてを短絡させる返品陳述書を持っているかどうか覚えておいてください

131
00:09:23,000 --> 00:09:24,840
だから、今はそれが良いことになるはずです。

132
00:09:25,470 --> 00:09:30,540
 

133
00:09:30,780 --> 00:09:36,110
 

134
00:09:36,120 --> 00:09:36,820
しかし、私は最初の解決法が好きです。短くて特別なケースを持つ必要がない、または最初に結果を1に設定して、すべてのことを処理しなければならないことです。

135
00:09:38,860 --> 00:09:42,830
さて、ハバブの最後のものにヘビに取り組んでみましょう。

136
00:09:43,330 --> 00:09:49,080
だから、これは単一の文字列を取り、すべてのダッシュを下線で置き換えることになっていることに注意してください。

137
00:09:49,270 --> 00:09:52,720
それで、それはハバブのケースをスネークのケースに変えます。

138
00:09:52,720 --> 00:09:57,490
だから私は最初にその関数を定義して行くつもりです。

139
00:09:57,550 --> 00:10:01,000
関数ここでいくつかのスペースを作ってみましょう。

140
00:10:01,000 --> 00:10:05,720
機能Khababが1つの文字列を取ります。

141
00:10:05,740 --> 00:10:10,350
私たちはそれをTRと呼ぶだけで、そこに論理を入れます。

142
00:10:10,420 --> 00:10:13,530
しかし、まず擬似コードをもう一度書きます。

143
00:10:13,540 --> 00:10:22,630
私たちがやりたいことは、すべてのダッシュをアンダースコアに置き換え、最後にTRとして返すことです。

144
00:10:25,510 --> 00:10:30,000
 

145
00:10:30,760 --> 00:10:34,640
だから、この問題の要点は、実際にそれをどうやって行うのかわからないということです。

146
00:10:34,660 --> 00:10:38,000
文字列内の1文字すべてをどのように置き換えるか

147
00:10:38,530 --> 00:10:40,000
もう一度それは慎重だった。

148
00:10:40,030 --> 00:10:43,920
私はこれをオンラインで見つけなければならないように、これを試して見なければならないと思っていました。

149
00:10:43,930 --> 00:10:46,000
それは本当に重要なスキルです。

150
00:10:46,510 --> 00:10:51,290
だから私がやる最初のことは、私がGoogleで私の検索をどのように言いたいかを理解することです。

151
00:10:51,370 --> 00:10:55,810
 

152
00:10:55,810 --> 00:11:00,790
それはかなり明白なもののように聞こえるが、実際に私が生きるルールで得られる結果のタイプに大きな影響を及ぼすだろうということは、あなたがあなたの検索をできるだけ一般的にして、ダッシュやアンダースコア、またはスネークケースやハバブケースについての情報を含めたい。

153
00:11:00,970 --> 00:11:07,430
 

154
00:11:07,450 --> 00:11:08,870
 

155
00:11:08,950 --> 00:11:14,290
その代わりに、ダッシュかアンダースコアかドル記号かどうかにかかわらず、文字列内の文字をどのように置き換えるか検索しようとするかもしれません。

156
00:11:14,740 --> 00:11:17,620
 

157
00:11:18,040 --> 00:11:19,660
さあ、それを試してみましょう。

158
00:11:19,690 --> 00:11:26,240
私はjavascriptの置換文字列を検索するつもりです。

159
00:11:26,940 --> 00:11:29,120
そして、私たちが何を得るのか見てみましょう。

160
00:11:29,350 --> 00:11:31,010
ここでいくつかの結果を得る。

161
00:11:31,090 --> 00:11:35,020
私はW3の学校を避けたいので、この2つを試してみましょう。

162
00:11:35,140 --> 00:11:37,740
特定のインデックスの文字を置き換えるにはどうすればいいですか？

163
00:11:37,750 --> 00:11:40,560
だから私たちが探しているものではありません。

164
00:11:40,600 --> 00:11:42,010
これは良い見えます。

165
00:11:42,010 --> 00:11:44,610
すべてのカンマを文字列に置き換えます。

166
00:11:45,280 --> 00:11:51,310
だから私たちはダッシュやアンダースコアをラクダやkababを含めなかったので、うまくいくこの結果が得られました。

167
00:11:51,310 --> 00:11:52,840
 

168
00:11:52,870 --> 00:11:54,820
これはすべてのカンマを置き換えることです。

169
00:11:54,880 --> 00:11:59,890
コンマを置き換えるのではなく、ソリューション内の小さな文字を変更するだけで済みます。

170
00:11:59,890 --> 00:12:02,230
ダッシュを置き換える必要があります。

171
00:12:02,230 --> 00:12:07,830
スタックオーバーフローの仕方は、あなたが上のトップが質問者の質問であることを一度も見たことがない場合に機能します。

172
00:12:07,840 --> 00:12:10,230
だから、私たちが解決策を読んでいるところではありません。

173
00:12:10,450 --> 00:12:15,220
これは質問の回答であり、回答は返事です。

174
00:12:15,220 --> 00:12:19,840
だから、この答えのセクションとここで私たちは答えに行く。

175
00:12:19,840 --> 00:12:25,600
この人は、Gフラグ付きの正規表現を使うことができると言っています。あなたはそれが何であるかを知る必要はありません。

176
00:12:25,600 --> 00:12:27,250
 

177
00:12:27,250 --> 00:12:29,540
正規表現について詳しく説明します。

178
00:12:29,590 --> 00:12:32,250
さあ、これをコピーしてみましょう。

179
00:12:33,340 --> 00:12:38,080
だから最初にやるべきことは、このコードを私たちの特定の状況に合わせて適応させることです。

180
00:12:38,380 --> 00:12:44,260
したがって、最初に変数宣言を行う必要はありません。なぜなら、実際には文字列をTRとして受け取るからです。

181
00:12:44,260 --> 00:12:45,130
 

182
00:12:45,460 --> 00:12:52,540
しかし、私は最初にTRとして交換を行う必要がありますし、我々は交換するものと交換するものを交換したいと思うでしょう。

183
00:12:52,540 --> 00:12:55,590
 

184
00:12:55,600 --> 00:13:01,330
ですから、ダッシュを置き換えたいと思います。この構文については、これを正規表現と呼びます。

185
00:13:01,330 --> 00:13:02,100
 

186
00:13:02,230 --> 00:13:07,810
スラッシュの中に入れたものは、それが置き換えられるパターンです。

187
00:13:07,810 --> 00:13:13,280
だから二重ダッシュのようなものを置くと、2つのダッシュが連続して検索されます。

188
00:13:13,480 --> 00:13:14,470
そうです。

189
00:13:14,500 --> 00:13:20,530
正規表現は、非常に長く複雑なパターンを定義することができます。

190
00:13:20,710 --> 00:13:23,230
そして、私はここで何かに置き換えることができます。

191
00:13:23,230 --> 00:13:29,390
したがって、ダッシュを置き換えるものをアンダースコアだけで更新する必要があります。

192
00:13:30,070 --> 00:13:38,500
ですから、これを新しい文字列newという変数に保存します。TRは置換しない文字列を実行した結果です。

193
00:13:38,500 --> 00:13:40,350
 

194
00:13:40,450 --> 00:13:46,900
私がそれをした理由は、置き換えられたドットは、最初の文字列自体のTR内のものを実際に置き換えないということです。

195
00:13:46,900 --> 00:13:47,790
 

196
00:13:47,920 --> 00:13:51,520
置き換えられたデータを含む新しいコピーを返します。

197
00:13:51,520 --> 00:13:57,850
だから私は、新しい文字列変数で返された新しいコピーをキャプチャして、TRとしてnewを返すだけです。

198
00:13:58,150 --> 00:13:59,520
 

199
00:14:00,190 --> 00:14:02,230
では、ブラウザでこれを試してみましょう。

200
00:14:02,230 --> 00:14:11,710
私はそのページの問題をリフレッシュして、ハバッブにハローデッチの世界のヘビを挑戦しようとしています。そして、私たちはアンダースコアの世界を得ます。

201
00:14:11,740 --> 00:14:13,430
 

202
00:14:13,630 --> 00:14:18,620
こんにちは世界でもう一度試してみましょう。

203
00:14:20,420 --> 00:14:23,140
そして、あなたはそれがすべてのダッシュを置き換えるのを見ることができます。

204
00:14:23,200 --> 00:14:24,170
それがそこにあります。

205
00:14:24,310 --> 00:14:29,430
だから、この練習の焦点は、実際にグーグルで情報を見つけようとしていた