WEBVTT

1
00:00:00.240 --> 00:00:02.190
您好，欢迎来到艺术家脚本。

2
00:00:02.200 --> 00:00:05.730
我的名字是Sybren，今天我们将再次烘焙我的添加。

3
00:00:05.730 --> 00:00:08.119
这只是一个名为「自然答题器」的附加元件。

4
00:00:08.130 --> 00:00:12.570
我正在稍微改变一下格式，当时我只会烤一个成年人。

5
00:00:12.580 --> 00:00:14.840
这使得视频有点短并且使得

6
00:00:14.840 --> 00:00:16.760
对我来说，生产工作少了一点，

7
00:00:16.770 --> 00:00:18.990
这意味著我将能够继续更长时间

8
00:00:18.990 --> 00:00:22.560
时间，因为它不会占用我太多的搅拌机开发时间

9
00:00:22.740 --> 00:00:26.230
在推特上，所有贴文都写道。我喜欢最后一个视频。

10
00:00:26.240 --> 00:00:28.960
非常感谢您的旧帖子，因为我只是

11
00:00:28.960 --> 00:00:31.890
最近开始编码，我真的可以使用良好的烘焙。

12
00:00:31.890 --> 00:00:33.360
好吧，没关系。

13
00:00:33.360 --> 00:00:37.330
然后我上周发布了这个免费岛屿，它取代了随机自然资产。

14
00:00:37.340 --> 00:00:41.360
每次点击听起来都很有用，让我们来看看程式码。

15
00:00:41.440 --> 00:00:43.650
我们希望有一个很好的描述

16
00:00:43.650 --> 00:00:46.260
免费的搅拌机插件用于随机放置对象，

17
00:00:46.340 --> 00:00:48.960
您选择您想要放置的资产，并且每次点击期间

18
00:00:48.960 --> 00:00:53.010
模型中放置的随机物件还具有更多功能。

19
00:00:53.010 --> 00:00:57.030
请参阅一分钟的 YouTube 影片。所以这很好。有一个关于此的精彩视频。

20
00:00:57.030 --> 00:00:59.660
我将在描述中链接它基本上是如何的

21
00:00:59.660 --> 00:01:02.090
工作原理是您进行点击选择，

22
00:01:02.090 --> 00:01:03.890
开始点击然后你点击周围然后

23
00:01:03.890 --> 00:01:06.350
它将随机资产放置在地平面上

24
00:01:06.620 --> 00:01:08.880
在一个影片中。我们来看一下程式码。

25
00:01:09.240 --> 00:01:11.930
这只是一个文件。这样事情就变简单了。

26
00:01:12.010 --> 00:01:14.460
这真的很好，但是请确保您的

27
00:01:14.460 --> 00:01:17.100
行不会太长以至于你无法再阅读它们。

28
00:01:17.110 --> 00:01:22.060
为了方便阅读，我总是建议在常用符号后键入一个空格。

29
00:01:22.540 --> 00:01:25.930
同样在英语中，我们的句子以大写字母开头。

30
00:01:25.940 --> 00:01:29.870
另外，如果您对程式码有任何建议，请告诉我。

31
00:01:29.880 --> 00:01:35.240
严格来说我不能，因为帐单资讯中没有联络资讯。

32
00:01:35.250 --> 00:01:36.250
这有点奇怪。

33
00:01:36.260 --> 00:01:40.060
有很多东西很重要，但尤其是向量被导入了两次。

34
00:01:42.540 --> 00:01:48.560
呃，这里有一个面板，当你像这样放大时很难阅读。

35
00:01:49.040 --> 00:01:53.660
然后我们的函数又很难阅读，除非你缩小很多。

36
00:01:55.040 --> 00:01:58.960
然后还有课程和

37
00:01:59.740 --> 00:02:00.360
你也是，

38
00:02:00.840 --> 00:02:03.930
如果将一个 python 档案分成多个部分。

39
00:02:03.930 --> 00:02:07.610
这通常意味著您实际上想要拥有多个 python 档案。

40
00:02:07.620 --> 00:02:09.300
我知道我们已经很久没有讨论过这个铭文了

41
00:02:09.300 --> 00:02:11.550
成年人所以我真的不能为此烤。

42
00:02:11.560 --> 00:02:12.330
然而，

43
00:02:12.330 --> 00:02:17.660
我建议永远不要使用「故事助手」之类的名字。

44
00:02:17.840 --> 00:02:20.080
我的意思是 UTIL 和 UTIL 之间有什么区别

45
00:02:20.080 --> 00:02:22.440
一个函数，其中的东西可以命名某些东西

46
00:02:22.440 --> 00:02:24.790
通常使用一个指示，表明您还没有真正

47
00:02:24.790 --> 00:02:27.350
想了想，然后就一起做事

48
00:02:27.640 --> 00:02:30.310
在本例中，它只是一个名为「设定」的类别。

49
00:02:30.310 --> 00:02:33.000
那么为什么不将其命名为“settings”呢？

50
00:02:33.000 --> 00:02:36.030
其余只是用于注册和取消注册的常规搅拌机内容

51
00:02:36.260 --> 00:02:40.790
是的，我知道还需要引导你的尾巴，不，我对此也不满意。

52
00:02:40.800 --> 00:02:42.710
让我们回到最上面的决赛是否

53
00:02:42.710 --> 00:02:45.550
面板已经找到了，而且命名有点奇怪。

54
00:02:45.640 --> 00:02:48.520
它叫做 Clicker pT 面板，我猜是 Clicker

55
00:02:48.520 --> 00:02:51.460
是类别，然后是 pT 中心面板类型

56
00:02:51.640 --> 00:02:55.850
然后再次识别他的面板，看起来有点双重

57
00:02:55.850 --> 00:02:59.310
其他面板上的名字前面到处都有一个场景。

58
00:02:59.320 --> 00:03:03.920
所以我想这听起来像是点击器，但这意味著该类别突然变成了

59
00:03:03.920 --> 00:03:06.390
不再属于这个类别，它们仍然令人印象深刻

60
00:03:06.390 --> 00:03:09.570
这个名字所以我会说将它们命名为唱首歌。

61
00:03:09.570 --> 00:03:13.560
Pt 然后无论在这种情况下面板的增长情况如何

62
00:03:13.740 --> 00:03:17.780
开始按钮，因为它只需要开始点击您可以在此处使用的按钮

63
00:03:17.790 --> 00:03:21.970
Petey 和得分场地，因为它具有地面等设置。

64
00:03:21.980 --> 00:03:24.030
我在这里注意到的另一件事是

65
00:03:24.030 --> 00:03:26.310
程式码的布局并不是真正一致。

66
00:03:26.430 --> 00:03:28.190
有时空间是相等的。

67
00:03:28.190 --> 00:03:30.860
有时等号前面没有空格

68
00:03:31.040 --> 00:03:33.810
所以我建议你建立态度

69
00:03:33.810 --> 00:03:35.870
储存时使用自动格式化。

70
00:03:35.880 --> 00:03:37.360
我将展示它是什么样子的。

71
00:03:38.140 --> 00:03:42.150
这里我们是我的编辑器、Visual Studio 程式码并且设定了不安全的格式。

72
00:03:42.150 --> 00:03:47.290
您只需按控制逗号并选取此核取方块格式不安全即可。

73
00:03:47.300 --> 00:03:50.460
我们来看一下。我保存了文件，你可以看看它在做什么

74
00:03:51.140 --> 00:03:54.810
正如你所看到的，它移动了一点。它有各种各样的小变化。

75
00:03:54.820 --> 00:03:57.140
评论后面有一个空格，

76
00:03:57.150 --> 00:03:59.770
该列前面没有空格，而且

77
00:03:59.770 --> 00:04:01.940
这里的作业都是以同样的方式完成的，

78
00:04:01.950 --> 00:04:02.440
自动化。

79
00:04:02.440 --> 00:04:04.710
这意味著你不必考虑它然后

80
00:04:04.720 --> 00:04:07.060
它确实有效，而且会让你忘记它。

81
00:04:07.440 --> 00:04:09.960
干净的程式码总是好的，因为你绝对

82
00:04:09.960 --> 00:04:12.150
阅读程式码的次数多于编写程式码的次数。

83
00:04:12.150 --> 00:04:15.910
所以，照顾好你打电话的内容是干净的，而且读起来很舒服，这是非常、

84
00:04:15.910 --> 00:04:18.860
对于任何级别的开发人员都非常重要。

85
00:04:19.440 --> 00:04:21.100
无论如何，既然我们是我的编辑，

86
00:04:21.100 --> 00:04:24.700
让我们来看看我肯定会在这里做的改进。

87
00:04:24.710 --> 00:04:27.880
正如您所看到的，这段程式码有很多重复之处。

88
00:04:27.940 --> 00:04:32.870
这部分也在此处、下一个面板和下一个面板中重复

89
00:04:32.880 --> 00:04:36.890
将所有这些程式码放入一个位置，然后在所有其他面板中使用它。

90
00:04:36.890 --> 00:04:40.760
我们可以创建所谓的混合类别。我会告诉你那是什么样子的。

91
00:04:43.340 --> 00:04:45.650
所以我只是创建一个名为答题器面板的类

92
00:04:45.650 --> 00:04:47.670
这将包含所有共同资讯。

93
00:04:50.140 --> 00:04:50.340
是的。

94
00:04:51.140 --> 00:04:53.940
然后我们可以将其用作混合类别。

95
00:04:54.840 --> 00:04:55.160
是的。

96
00:04:56.040 --> 00:05:00.270
所以这里发生的情况是，如果搅拌机试图找到点击器的帐单类别。

97
00:05:00.270 --> 00:05:03.660
Pt面板，它无法在面板本身上找到它。

98
00:05:03.670 --> 00:05:07.400
然后 python 将开始按顺序询问父级，这样它就会

99
00:05:07.400 --> 00:05:10.950
转到答题器面板，它会询问他们是否知道帐单类别

100
00:05:11.340 --> 00:05:12.470
在这种情况下确实如此。

101
00:05:12.470 --> 00:05:17.160
搜寻到此结束，然后找到 Clicker 作为该属性的值。

102
00:05:17.260 --> 00:05:19.260
我们现在可以在每个面板上执行此操作。

103
00:05:20.740 --> 00:05:20.940
是的，

104
00:05:22.440 --> 00:05:22.650
好的。

105
00:05:23.240 --> 00:05:24.560
并删除那些，

106
00:05:25.540 --> 00:05:27.360
把混合类放在那里

107
00:05:27.940 --> 00:05:28.960
关于那些

108
00:05:29.540 --> 00:05:30.110
mixing

109
00:05:30.300 --> 00:05:31.250
现在我们就到了。

110
00:05:31.740 --> 00:05:34.210
所以这已经减少了相当多的程式码。

111
00:05:34.220 --> 00:05:36.800
如果我们想更改该类别类型，

112
00:05:36.810 --> 00:05:38.830
没有一个地方对此进行了定义。

113
00:05:38.840 --> 00:05:40.770
这是干净程式码的另一个方面。

114
00:05:40.780 --> 00:05:44.620
应该只有一小段程式码负责一件事。

115
00:05:44.630 --> 00:05:47.310
关于面板就这么多了。让我们来看看这些函数。

116
00:05:47.320 --> 00:05:49.970
有一个函数加入集合，移动对象，

117
00:05:49.980 --> 00:05:52.690
这已经很奇怪了，因为它被添加到

118
00:05:52.690 --> 00:05:54.990
一个集合或它被移动到一个集合？

119
00:05:54.990 --> 00:05:58.460
函数名称是一回事。参数名称有不同的东西。

120
00:05:58.640 --> 00:06:01.430
这有点奇怪，检查一下答题器集合。

121
00:06:01.430 --> 00:06:01.900
出色地，

122
00:06:01.910 --> 00:06:05.050
Capitals 检查答题器集合是否存在

123
00:06:05.060 --> 00:06:07.130
并将物件移到该集合中。

124
00:06:07.140 --> 00:06:09.400
所以这是做两件事，

125
00:06:09.400 --> 00:06:13.300
对于仅在程式码中使用函数的情况来说，这通常不是一个好主意。

126
00:06:13.300 --> 00:06:13.630
当你

127
00:06:13.740 --> 00:06:16.280
检查复选框 FB 部分联络人说好，

128
00:06:16.290 --> 00:06:18.450
我必须阻止你，这是以前从未有过的

129
00:06:18.450 --> 00:06:21.170
除非你真的必须这样做，否则它是上下文的一部分。

130
00:06:21.180 --> 00:06:23.620
我猜这个函数会被调用

131
00:06:23.620 --> 00:06:27.210
一个运算符，该运算符从搅拌机获取上下文。

132
00:06:27.280 --> 00:06:29.900
所有后续代码都应该使用它

133
00:06:29.900 --> 00:06:32.730
上下文而不是在这里使用全域上下文。

134
00:06:32.730 --> 00:06:35.250
我将向您展示一个例子来说明为什么会这样

135
00:06:35.530 --> 00:06:38.520
每个操作员都可以有自己的上下文，但事实并非如此

136
00:06:38.520 --> 00:06:40.610
必须与全局上下文相同。

137
00:06:40.620 --> 00:06:41.640
例如，

138
00:06:41.640 --> 00:06:45.190
这里有一个引脚可以让我在这个物件中

139
00:06:45.190 --> 00:06:49.180
属性标签将选项卡固定到 Suzanne 目前活动物件。

140
00:06:49.190 --> 00:06:51.720
现在如果我将活动物件更改为立方体，

141
00:06:51.730 --> 00:06:54.260
您可以看到该面板仍然显示 Suzanne。

142
00:06:54.290 --> 00:06:58.880
这也是上下文物件和活动物件上下文之间的区别。

143
00:06:58.890 --> 00:07:02.200
这里的这个按钮是一个操作符，对于这个操作符

144
00:07:02.220 --> 00:07:05.140
物件的上下文将是固定物件的 Suzanne。

145
00:07:05.150 --> 00:07:08.060
而对于从此处的选单调用的操作员，

146
00:07:08.140 --> 00:07:09.680
它没有那个对象引脚。

147
00:07:09.680 --> 00:07:14.540
所以他们的上下文物件其实是立方体。注意两种情况下的接触。

148
00:07:14.550 --> 00:07:17.890
活动对象仍然是活动对象，它是一个立方体。

149
00:07:17.900 --> 00:07:19.580
这是营运商的方式之一

150
00:07:19.580 --> 00:07:22.260
可以获得与全域上下文不同的上下文。

151
00:07:22.270 --> 00:07:26.160
因此，只需使用给定的上下文即可，不要总是使用全局上下文。

152
00:07:26.340 --> 00:07:28.360
这一行还有更多内容

153
00:07:28.540 --> 00:07:31.490
在 if 语句中与 True 进行比较是不必要的

154
00:07:31.490 --> 00:07:34.060
因为 if 语句已经与 True 进行了比较。

155
00:07:34.070 --> 00:07:36.660
所以你只是有效地加倍了它的工作。

156
00:07:37.140 --> 00:07:40.530
只有当美国选中该复选框时，下议院才会运行该程式码。

157
00:07:40.530 --> 00:07:44.360
这意味著如果它不返回这里，一定有其他的，对吗？

158
00:07:45.340 --> 00:07:45.850
哦

159
00:07:46.340 --> 00:07:47.560
不，没有

160
00:07:48.440 --> 00:07:49.250
早点回来，

161
00:07:49.640 --> 00:07:52.900
如果没有的话，翻转你的条件早点回来。

162
00:07:53.000 --> 00:07:54.950
是的。是的 yada 确实点击收藏

163
00:07:55.340 --> 00:07:56.120
返回。

164
00:07:56.310 --> 00:07:59.860
这意味著所有这些程式码都可以一步取消缩排

165
00:08:00.240 --> 00:08:01.990
这意味著你可以解放你的大脑。

166
00:08:01.990 --> 00:08:04.750
不用看最后有没有else

167
00:08:04.760 --> 00:08:08.900
该函数或在未选取该复选框时它是否不执行任何操作。

168
00:08:08.970 --> 00:08:12.830
我认为释放你的大脑是编码中最重要的部分。

169
00:08:13.040 --> 00:08:14.370
别再让自己困惑了。

170
00:08:14.370 --> 00:08:17.690
函数名称说明了一件事，参数名称说明了另一件事。

171
00:08:18.000 --> 00:08:23.260
这里的评论说的是不同的事情，然后有一个如果你想的话

172
00:08:23.260 --> 00:08:27.360
明白了，你必须一直滚动到底部才能看到没有其他的

173
00:08:27.640 --> 00:08:30.060
现在在下一行中将名为名称的集合设定为

174
00:08:30.060 --> 00:08:32.710
如果集合尚不存在，则将建立该集合。

175
00:08:32.720 --> 00:08:35.580
我认为将此名称放入变数中是个好主意。

176
00:08:35.580 --> 00:08:37.480
但这不是这样做的地方。

177
00:08:37.490 --> 00:08:40.980
这个函数将一个物件移动到集合中，所以我不期望

178
00:08:40.980 --> 00:08:45.750
此函数是负责命名该集合的程式码位

179
00:08:45.790 --> 00:08:49.030
只需将其移至全域变数下一步就是尝试 except

180
00:08:49.040 --> 00:08:52.460
如果集合尚不存在或已创建，则取得该集合，

181
00:08:52.630 --> 00:08:53.420
这是一个很大的不，

182
00:08:53.420 --> 00:08:56.400
永远不要使用裸露，除了捕捉任何异常

183
00:08:56.400 --> 00:08:58.450
想要在这种情况下捕获它是一个关键错误

184
00:08:58.840 --> 00:08:59.930
无一例外。

185
00:08:59.930 --> 00:09:01.090
except类别的后面，

186
00:09:01.090 --> 00:09:04.040
你会捕捉到每一个异常

187
00:09:04.040 --> 00:09:06.500
不仅仅是从技术角度来看。

188
00:09:06.500 --> 00:09:10.040
此处给出异常的实际名称是错误的

189
00:09:10.040 --> 00:09:14.090
当你稍后阅读它时，你期望她再次释放你的大脑。

190
00:09:14.090 --> 00:09:17.860
你清楚知道你当时在想什么，无论你期待什么

191
00:09:18.240 --> 00:09:19.830
然后继续下一段程式码。

192
00:09:19.830 --> 00:09:23.260
这是一个循环，从它所在的所有集合中删除该对象

193
00:09:23.270 --> 00:09:27.530
然后新增到一个特定的集合，即刚刚建立的集合。

194
00:09:27.540 --> 00:09:33.420
然而，它是以一种非常间接、奇怪的方式完成的：O b J 被分配了要移动的物件。

195
00:09:33.430 --> 00:09:35.880
嗯，所以我猜你的队伍太长了。

196
00:09:35.890 --> 00:09:37.560
有一种不同的处理方法。

197
00:09:37.840 --> 00:09:41.000
那么旧的集合就是一个空列表，永远不会再使用。

198
00:09:41.140 --> 00:09:44.300
然后使用 for 回圈遍历物件用户

199
00:09:44.300 --> 00:09:48.220
集合，同时它也操作其中的物件集合。

200
00:09:48.220 --> 00:09:51.820
所以你处于循环之中，你正在操纵你正在查看的任何东西，

201
00:09:51.820 --> 00:09:53.560
这也是一个坏主意。

202
00:09:54.040 --> 00:09:56.460
那么让我们看看如何改进这一点。

203
00:09:57.340 --> 00:10:00.360
让我们快速浏览一下这段程式码，看看我们可以改进什么。

204
00:10:00.840 --> 00:10:03.240
我从内在开始，然后向外移动。

205
00:10:03.250 --> 00:10:06.940
部分资料集合集合点名称非常间接

206
00:10:06.940 --> 00:10:10.170
取得集合的方式集合已经是集合了。

207
00:10:10.180 --> 00:10:15.690
因此，要获取它的名称，然后找到我的名字来获取该集合，这有点奇怪。

208
00:10:15.700 --> 00:10:19.050
而且它可能不会按照您想像的方式工作

209
00:10:19.640 --> 00:10:20.180
也.

210
00:10:20.180 --> 00:10:25.540
现在，不必这样做，然后再联系所见的集合。

211
00:10:25.540 --> 00:10:29.670
如果它可能在那里，我们都可以将其删除，因为我们已经拥有了该集合。

212
00:10:29.670 --> 00:10:31.590
所以没有什么好失败的。

213
00:10:31.600 --> 00:10:35.120
我们循环遍历集合的第二个问题

214
00:10:35.120 --> 00:10:37.360
并同时更改集合。

215
00:10:37.440 --> 00:10:39.750
您只需建立此清单的副本即可。

216
00:10:39.940 --> 00:10:42.890
所以你可以用这种表示法来这样做。

217
00:10:42.890 --> 00:10:47.690
我可以做类似从两个到但不包括索引号五的事情。

218
00:10:47.700 --> 00:10:51.440
您可以删除第一个索引以指示从清单的开头开始，然后

219
00:10:51.440 --> 00:10:54.450
您可以删除最后一个索引，直到清单末端。

220
00:10:54.460 --> 00:10:56.990
所以这需要整个清单的副本。

221
00:10:57.000 --> 00:10:59.220
所以现在我们保存了副本，我们可以删除

222
00:10:59.230 --> 00:11:01.280
现在我们的队伍短得多。

223
00:11:01.280 --> 00:11:04.350
我们可以使用物体再次移动。

224
00:11:04.350 --> 00:11:08.250
我们有一个奇怪的事情，就是取集合名称

225
00:11:08.340 --> 00:11:11.930
然后寻找属于该名称的集合。

226
00:11:11.940 --> 00:11:14.560
而我们已经在这里收集了。

227
00:11:15.440 --> 00:11:18.180
现在我们在这里获取集合有一个问题，

228
00:11:18.180 --> 00:11:20.100
然后我们再次使用集合名称。

229
00:11:20.110 --> 00:11:23.590
然后当然我们就不再拥有原来的了

230
00:11:23.590 --> 00:11:26.260
集合，因为今天变数的名称相同。

231
00:11:26.270 --> 00:11:29.260
所以我们在这里可以做的就是，例如，命名它

232
00:11:29.640 --> 00:11:33.160
点击或呼叫以表明这是答题器集合，

233
00:11:33.940 --> 00:11:36.200
这里也这样做，在这里也这样做。

234
00:11:36.200 --> 00:11:38.790
然后你可以只说点击器呼叫来代替这个

235
00:11:38.790 --> 00:11:42.400
对象点链接，这对个人来说要简单得多，

236
00:11:42.400 --> 00:11:48.630
我会更进一步，将这个和那个程式码移到两个单独的函数中。

237
00:11:48.640 --> 00:11:50.370
第一段程式码就得到了

238
00:11:50.370 --> 00:11:53.650
该特定集合确保其现有

239
00:11:53.840 --> 00:11:57.290
这段程式码取消了物件与它所在的所有集合的连结。

240
00:11:57.300 --> 00:12:00.560
所以这与上面的程式码完全分开。

241
00:12:00.720 --> 00:12:03.220
这意味著它可能具有不同的功能。

242
00:12:03.230 --> 00:12:07.120
下一个函数称为选择物件并取得 self 作为参数。

243
00:12:07.150 --> 00:12:10.110
我对此非常怀疑，因为这基本上

244
00:12:10.110 --> 00:12:12.810
意味著它只得到 self 并且它

245
00:12:12.810 --> 00:12:17.660
这很可能应该是 self 所指向的类别的一部分。

246
00:12:18.640 --> 00:12:20.350
那我们就来看看它用在什么地方。

247
00:12:21.040 --> 00:12:21.960
是的，

248
00:12:22.440 --> 00:12:22.990
是的，

249
00:12:22.990 --> 00:12:26.390
这是点击操作符模型函数

250
00:12:26.400 --> 00:12:30.370
规模庞大，造成选择对象和受害

251
00:12:30.470 --> 00:12:35.470
并传递自我。这意味著它确实应该是操作员的一部分。

252
00:12:35.470 --> 00:12:40.460
所以只是由课堂上的一层毯子发明的

253
00:12:40.640 --> 00:12:44.360
你可以呼叫 self 点选择物件和 selfhood 随机化

254
00:12:44.540 --> 00:12:47.060
然后程式码所属的内容就更清楚了。

255
00:12:47.640 --> 00:12:50.660
除了我已经说过的之外，我认为这段程式码很好。

256
00:12:50.670 --> 00:12:55.160
嗯，随机化函数又有点奇怪了。嗯

257
00:12:55.740 --> 00:12:57.690
获得随机的正值或负值。

258
00:12:57.700 --> 00:13:01.930
好吧，你已经表明你知道随机选择，这基本上是随机的。

259
00:13:01.930 --> 00:13:04.560
选择一或-1。

260
00:13:05.340 --> 00:13:05.960
但

261
00:13:06.840 --> 00:13:11.160
这个公式以及它的使用地点有点奇怪。

262
00:13:11.540 --> 00:13:16.120
另外，我会避免重复，嘟嘟的眼神接触，一直看到答题器。

263
00:13:16.120 --> 00:13:19.070
正确的答题器是嘟嘟的眼神接触看到的答题器，甚至更好。

264
00:13:19.070 --> 00:13:23.450
您传递给此函数的上下文似乎不是点击器。嗯

265
00:13:23.940 --> 00:13:28.360
但除此之外，你随机取一个，然后将其转换为加号或减号。

266
00:13:28.360 --> 00:13:32.590
但这里有一个 0 到 10 之间的随机整数。

267
00:13:32.600 --> 00:13:38.660
将其除以 10，得到一个介于 0 和 1 之间的 0

268
00:13:39.140 --> 00:13:44.940
但只能以 1/10 为步长。然后将其乘以正数或负数。

269
00:13:44.950 --> 00:13:47.090
但你也可以添加一个。

270
00:13:47.100 --> 00:13:53.360
所以现在突然之间就是一加减一乘以随机数。

271
00:13:53.440 --> 00:13:56.130
对于你到底需要什么，它变得非常狡猾。

272
00:13:56.130 --> 00:14:00.400
我认为更合适的是使用随机的黑色制服，然后就可以了

273
00:14:00.400 --> 00:14:03.770
给出您想要得到的随机数的最小值和最大值。

274
00:14:03.770 --> 00:14:07.350
例如随机均匀减去一个逗号一将

275
00:14:07.350 --> 00:14:09.360
只要给你一个该范围内的随机数

276
00:14:09.740 --> 00:14:14.620
在这里，您使用运算符来调整大小和旋转，我永远不会这样做。

277
00:14:14.620 --> 00:14:19.800
只需将比例或旋转与给定值相乘即可

278
00:14:19.800 --> 00:14:23.660
而且更容易阅读，执行起来也更快。

279
00:14:24.440 --> 00:14:26.580
最后一件事我觉得有点奇怪

280
00:14:26.590 --> 00:14:30.310
是它对选取的单数物件进行操作。

281
00:14:30.320 --> 00:14:35.840
如果我没记错你的视频，每次你点击该物件都是随机的。

282
00:14:35.850 --> 00:14:39.050
所以这其实随机化了一个非常具体的物件。

283
00:14:39.050 --> 00:14:41.360
所以将那个物件传递给这个函数

284
00:14:41.540 --> 00:14:44.260
然后操纵其点的缩放或位置。

285
00:14:44.260 --> 00:14:45.090
那个旋转，

286
00:14:45.090 --> 00:14:47.220
无论你想操纵它

287
00:14:47.220 --> 00:14:49.240
编码的立场也让事情变得更容易，因为

288
00:14:49.240 --> 00:14:51.390
很明显，这个函数运行在

289
00:14:51.390 --> 00:14:53.450
它从颜色接收的物件。

290
00:14:54.140 --> 00:14:56.920
让我们快速浏览一下答题器操作符，因为

291
00:14:56.920 --> 00:14:59.630
基本上是附加元件的核心之一。

292
00:14:59.630 --> 00:15:01.230
该模型函数太长了。

293
00:15:01.240 --> 00:15:04.400
我认为所有帖子都同意我的观点，因为这里有一些文档

294
00:15:04.400 --> 00:15:07.270
与函数顶部的样式相同

295
00:15:07.380 --> 00:15:09.350
只不过这里不在函数里。

296
00:15:09.470 --> 00:15:12.260
所以把它放在一个函数中，分割你的程式码

297
00:15:12.440 --> 00:15:16.060
因为它让一切变得更容易理解

298
00:15:16.240 --> 00:15:16.460
是的，

299
00:15:17.040 --> 00:15:20.660
否则你就会得到这种东西。看看有没有飞机

300
00:15:21.240 --> 00:15:21.960
如果它

301
00:15:22.540 --> 00:15:24.360
如果答题器线为真。

302
00:15:24.840 --> 00:15:25.460
所以

303
00:15:26.240 --> 00:15:30.370
何时执行将程式码精确地放入单独的函数中。

304
00:15:30.370 --> 00:15:32.970
不仅让大家更容易理解，

305
00:15:32.980 --> 00:15:36.110
而且它也迫使你为该函数命名，

306
00:15:36.110 --> 00:15:39.240
它迫使您为该功能编写一些文件。

307
00:15:39.250 --> 00:15:41.450
好吧，这不会强迫你，但他无论如何都应该这样做。

308
00:15:41.740 --> 00:15:44.510
嗯，一旦你开始做某件事

309
00:15:44.510 --> 00:15:47.050
该函数并不真正遵循该名称。

310
00:15:47.270 --> 00:15:49.980
这表明您可能在那里做错了事情。

311
00:15:49.980 --> 00:15:52.240
也许这应该放在单独的程式码中

312
00:15:52.550 --> 00:15:55.250
它也确实可以帮助你理顺你的想法。

313
00:15:55.260 --> 00:15:59.360
例如，您可以将其放入一个名为 line 的函数中

314
00:15:59.360 --> 00:16:03.490
与地平面或放置在地平面上或任何它正在做的事情。

315
00:16:03.570 --> 00:16:07.450
当然，如果不是直接返回，您也可以立即返回那里

316
00:16:07.640 --> 00:16:12.760
然后其他一切都将成为发明。你明白我的意思

317
00:16:13.340 --> 00:16:14.320
在接下来的引用中，

318
00:16:14.320 --> 00:16:18.460
我们可以处理输入函数来选择另一个随机物件。

319
00:16:18.470 --> 00:16:20.340
这跳过了一堆圈子。

320
00:16:20.350 --> 00:16:23.360
最重要的是要尝试并确保

321
00:16:23.360 --> 00:16:26.090
它实际上选择了一个不同的随机物件。

322
00:16:26.100 --> 00:16:30.410
那么这里发生的情况是程式码试图删除任何主题吗？

323
00:16:30.410 --> 00:16:32.660
我以为01点太早或太

324
00:16:33.040 --> 00:16:35.560
尝试从名称中删除它，然后进行比较

325
00:16:35.560 --> 00:16:38.250
到新选择的物件以查看它们是否不同。

326
00:16:38.260 --> 00:16:44.240
好吧，但是如果我已经选择了名为 3.1 等的物件怎么办？

327
00:16:44.250 --> 00:16:46.530
然后突然就出了问题。

328
00:16:46.540 --> 00:16:51.850
相反，我在这里要做的不是使用随机选择来选择随机对象

329
00:16:52.140 --> 00:16:56.300
但随机点租金范围来选择随机物件索引。

330
00:16:56.310 --> 00:16:59.150
然后，如果您还记得您使用的最后一个索引

331
00:16:59.160 --> 00:17:01.440
您可以将各个行业进行相互比较

332
00:17:01.440 --> 00:17:04.010
然后继续选择一个随机索引，直到你有

333
00:17:04.010 --> 00:17:06.460
与之前使用的索引不同。

334
00:17:06.470 --> 00:17:07.470
这可以让你免于很多

335
00:17:07.470 --> 00:17:10.460
比较字串和操作字串的头痛

336
00:17:10.460 --> 00:17:12.849
使比较有效，因为

337
00:17:12.849 --> 00:17:15.270
在概念上符合您想做的事情。

338
00:17:15.740 --> 00:17:19.410
然后，如果上下文区域类型为三个，我们就有呼叫函数

339
00:17:19.410 --> 00:17:23.450
D 做某事然后一直在底部有 CLS

340
00:17:24.440 --> 00:17:26.800
只要翻转条件，翻转你的条件，

341
00:17:26.810 --> 00:17:29.810
将所有这些和那个一直移动到顶部。

342
00:17:29.810 --> 00:17:33.560
然后你就可以取消其余的程式码了。这又是为什么呢？

343
00:17:33.560 --> 00:17:36.770
当你在这里获得上下文时，为什么要使用上下文的部分，

344
00:17:37.440 --> 00:17:40.200
恰到好处的上下文选择的对像是同一件事

345
00:17:40.200 --> 00:17:42.590
但这样就正确了，而且打字也少了。

346
00:17:42.600 --> 00:17:46.870
现在看看我们剩下的程式码的结构，如果我们还有另一个程式码

347
00:17:46.870 --> 00:17:49.350
有另一个块来测试一些东西然后在这里

348
00:17:49.350 --> 00:17:52.050
我们再次有一个测试一些东西的块。

349
00:17:52.060 --> 00:17:58.940
因此，如果感觉上下文区域类型不合适，只需翻转您的喜欢即可翻转您的条件

350
00:17:58.940 --> 00:18:06.770
真正知道是否否如果不是部分选定物件返回如果出错返回如果

351
00:18:07.140 --> 00:18:12.860
len 选取的物件是一个且该物件是一个清晰的表面返回

352
00:18:12.870 --> 00:18:16.650
它们都可以放在同一水平线上。

353
00:18:16.660 --> 00:18:20.930
现在你拥有的是一个向三个不同方向增长的程式码。

354
00:18:20.940 --> 00:18:24.860
让我告诉你我的意思，假设你有一些功能

355
00:18:25.040 --> 00:18:27.770
这需要一些参数

356
00:18:28.040 --> 00:18:32.360
然后它做它的主要事情，就像它必须做的事情一样，

357
00:18:33.140 --> 00:18:35.470
让我们用 A B M. C 来称呼它。

358
00:18:35.480 --> 00:18:38.120
就像我们刚刚看到的这段程式码的制作方式一样

359
00:18:38.130 --> 00:18:40.840
如果我们想对 A 和 B 进行一些错误检查。

360
00:18:40.840 --> 00:18:43.780
N.C. 观察事情会发生什么事。

361
00:18:43.790 --> 00:18:49.200
因此，如果呃 A 适合 a，那么事情就会转移。

362
00:18:49.200 --> 00:18:51.670
现在我们上面已经有一些程式码了。

363
00:18:51.840 --> 00:18:53.670
它移到了右边

364
00:18:53.840 --> 00:18:54.770
进而

365
00:18:55.440 --> 00:19:00.620
和/或错误 A。 所以现在我们得到的是我们在上面有一些程式码。

366
00:19:00.630 --> 00:19:05.540
我们在它下面有一些程式码。而主程式码实际上发明了一层。

367
00:19:05.550 --> 00:19:08.880
现在，如果您在 B 上添加另一张支票，那么我们再次

368
00:19:08.880 --> 00:19:11.510
必须再次把东西移到那个方向，我们有一些错误

369
00:19:11.510 --> 00:19:15.200
在这里处理程式码，如果你想这样做的话

370
00:19:15.210 --> 00:19:19.050
它再次同时向三个方向移动。

371
00:19:19.340 --> 00:19:22.470
而如果你翻转你的条件，当你得到的是这样的

372
00:19:22.790 --> 00:19:29.210
如果不是 A. 可以处理退货吗，现在我可以复制贴上这个

373
00:19:30.420 --> 00:19:33.050
我说如果不是也没关系，处理永远

374
00:19:33.740 --> 00:19:39.710
然后回来，如果没有，她就可以预见，你会看到

375
00:19:39.870 --> 00:19:42.670
那东西现在去哪了？出色地

376
00:19:43.040 --> 00:19:47.590
事情仍然在原处，就像刚刚推送的每个错误检查一样

377
00:19:47.590 --> 00:19:51.610
它向下，但你只能向一个方向生长，而不是三个方向。

378
00:19:51.620 --> 00:19:54.490
这就是本集艺术家脚本的内容，

379
00:19:54.500 --> 00:19:56.360
我尝试保留该视频，但一定要

380
00:19:56.360 --> 00:19:59.640
虽然失败了，但我认为这仍然很有趣。

381
00:19:59.650 --> 00:20:01.570
我希望您学到了一些关于如何

382
00:20:01.570 --> 00:20:04.200
改进你的程式码，这样你就可以解放你的大脑

383
00:20:04.200 --> 00:20:07.160
如果您有任何问题或意见，请避免过度油炸

384
00:20:07.160 --> 00:20:09.460
把它们留在下面，我很快就会见到你。