1
00:00:00,000 --> 00:00:02,320
>> [研讨会 -  Unix shell中，环境]

2
00:00:02,320 --> 00:00:04,180
[道格拉斯·克莱恩 - 哈佛大学]

3
00:00:04,180 --> 00:00:07,160
[这是CS50。 -  CS50.TV]

4
00:00:07,160 --> 00:00:12,770
>>今天的话题是Unix的外壳。

5
00:00:12,770 --> 00:00:20,600
我是道格拉斯·克莱恩，专家，或至少有能力的用户的shell。

6
00:00:20,600 --> 00:00:25,280
shell是为用户的计算机的操作系统的接口。

7
00:00:25,280 --> 00:00:29,580
这个名字是误导，因为，不同于动物的壳，

8
00:00:29,580 --> 00:00:34,890
这是硬和保护性的，在计算机外壳允许进行通信。

9
00:00:34,890 --> 00:00:39,120
所以多孔膜可能会是一个更好的比喻。

10
00:00:39,120 --> 00:00:44,500
>>原壳对于Unix是Bourne shell的。

11
00:00:44,500 --> 00:00:46,450
伯恩的拼写B-0-U-R-N-E。

12
00:00:46,450 --> 00:00:49,770
伯恩是unix下的原作者之一，

13
00:00:49,770 --> 00:00:51,700
所以外壳以他命名。

14
00:00:51,700 --> 00:00:54,850
该shell作为命令的名字只是简单的sh。

15
00:00:54,850 --> 00:00:57,400
这是可以执行的命令。

16
00:00:57,400 --> 00:01:00,810
壳开始登录。

17
00:01:00,810 --> 00:01:04,459
当您登录到计算机时，shell只是开始运行你，

18
00:01:04,459 --> 00:01:06,820
而这正是需要你的命令。

19
00:01:06,820 --> 00:01:09,790
它可以在其他时间开始也。

20
00:01:09,790 --> 00:01:16,780
如果弹出一个窗口，没有其他指示，它会启动一个shell你。

21
00:01:16,780 --> 00:01:20,450
这是怎么回事，你可以去到一个窗口，并开始键入命令

22
00:01:20,450 --> 00:01:23,960
等等还有，即使你没有在该窗口中登录。

23
00:01:23,960 --> 00:01:26,670
此外，如果你做一个远程登录，

24
00:01:26,670 --> 00:01:30,250
然后它会启动远程计算机上的shell。

25
00:01:30,250 --> 00:01:44,310
并有可能在没有交互式shell中运行命令。

26
00:01:44,310 --> 00:01:48,990
这可以将当前操作中的意思，

27
00:01:48,990 --> 00:01:50,700
它也可以指远程操作。

28
00:01:50,700 --> 00:01:52,900
你可以发送一个命令到另一台计算机，

29
00:01:52,900 --> 00:01:55,460
其中包括启动一个shell那里。

30
00:01:55,460 --> 00:01:57,760
事实上，它有包括启动一个shell有

31
00:01:57,760 --> 00:02:01,740
即使这是不是你的最终目的。

32
00:02:05,310 --> 00:02:12,350
当事情开始，像这样，它并不一定启动一个新的shell。

33
00:02:12,350 --> 00:02:17,430
如果你打开​​一个新的窗口，它可以告诉它带来了一个编辑器

34
00:02:17,430 --> 00:02:18,940
或一些其它命令。

35
00:02:18,940 --> 00:02:20,560
在这种情况下，编辑器会从头开始。

36
00:02:20,560 --> 00:02:22,930
当编辑结束时，窗口结束。

37
00:02:22,930 --> 00:02:24,620
这是一个有点不寻常，但它可以做到的。

38
00:02:24,620 --> 00:02:27,140
在这些情况下，它不会是一个外壳。

39
00:02:27,140 --> 00:02:31,890
因此，它不一定是一个窗口或一些这样的应用程序将弹出一个shell的情况。

40
00:02:31,890 --> 00:02:34,030
>>贝壳解析命令。

41
00:02:34,030 --> 00:02:40,900
解析装置识别所述各元素，并将它们分类。

42
00:02:40,900 --> 00:02:43,470
在一个命令，你键入完整的字符串，

43
00:02:43,470 --> 00:02:47,310
将有1个或多个要执行的单个命令。

44
00:02:47,310 --> 00:02:50,050
其他元素可以是参数。

45
00:02:50,050 --> 00:02:55,020
还有，也可以影响一个命令的执行的特殊字符。

46
00:02:55,020 --> 00:02:59,710
他们可以将输出比屏幕其他地方

47
00:02:59,710 --> 00:03:01,750
如果该命令将通常将其发送到屏幕上。

48
00:03:01,750 --> 00:03:04,390
它可以重定向输入，它可以做其他事情也。

49
00:03:04,390 --> 00:03:08,120
还有各种其他符号，字符，等等。

50
00:03:08,120 --> 00:03:13,600
解析涉及检测和解释这些事情。

51
00:03:13,600 --> 00:03:19,560
>>现在，如果没有其他问题了，这是相当可能的，因为没有更多的人，

52
00:03:19,560 --> 00:03:24,620
我们会继续我的下一个页面在这里。

53
00:03:24,620 --> 00:03:29,170
>>我刚才说的Bourne shell是初始的shell。

54
00:03:29,170 --> 00:03:31,550
还有其他的。

55
00:03:31,550 --> 00:03:34,520
一个是C壳。该命令是csh。

56
00:03:34,520 --> 00:03:36,830
该名称为C壳只是一个文字游戏。

57
00:03:36,830 --> 00:03:41,260
这个shell介绍了与伯克利的Unix在70年代中期。

58
00:03:41,260 --> 00:03:44,830
伯克利的Unix在Unix的发展的一个开创性的事件。

59
00:03:44,830 --> 00:03:48,770
这是一个巨大的革命，包括引入这个shell。

60
00:03:48,770 --> 00:03:50,790
究其原因，对词游戏，C壳，

61
00:03:50,790 --> 00:03:56,490
是，C-shell都有它的一些特性这类似于C语言，

62
00:03:56,490 --> 00:03:59,740
这是Bourne shell没有 - 

63
00:03:59,740 --> 00:04:02,140
或者它没有在那个时候。

64
00:04:02,140 --> 00:04:05,190
另外还有TC壳。

65
00:04:05,190 --> 00:04:07,360
这是C壳的超集。

66
00:04:07,360 --> 00:04:11,470
它有更多的功能，其中有许多是交互使用有用的，

67
00:04:11,470 --> 00:04:16,050
如在历史机制回顾命令

68
00:04:16,050 --> 00:04:18,459
我将描述有点迟 - 

69
00:04:18,459 --> 00:04:23,120
以简单的方式，编辑为蓝本。

70
00:04:23,120 --> 00:04:29,170
它也有绑定，让你可以很短的密钥字符串绑定到一个较长的命令。

71
00:04:29,170 --> 00:04:31,440
我们不打算今天要进入的。

72
00:04:31,440 --> 00:04:33,650
它有一些功能是对编程有用。

73
00:04:33,650 --> 00:04:37,020
然而，C-shell不是通常用于shell编程。

74
00:04:37,020 --> 00:04:39,080
shell程序，如果你还不知道，

75
00:04:39,080 --> 00:04:41,690
是程序，包括外壳采用特质。

76
00:04:41,690 --> 00:04:43,220
你可以为程序运行它们。

77
00:04:43,220 --> 00:04:46,760
你写了一堆shell命令到一个文件并执行该文件。

78
00:04:46,760 --> 00:04:49,760
你并不需要编译它。这是一种解释性语言。

79
00:04:49,760 --> 00:04:57,320
这句话的C-shell是现在暧昧，因为它可能仅仅指原来的C壳，CSH，

80
00:04:57,320 --> 00:05:01,200
或将所有的C壳，包括tcsh的。这是一个有点暧昧。

81
00:05:01,200 --> 00:05:08,250
>>后来的shell是Korn外壳程序，KSH，程序员而得名，科恩。

82
00:05:08,250 --> 00:05:14,160
这个壳试图将其纳入1壳

83
00:05:14,160 --> 00:05:16,960
在C-外壳交互使用的优势

84
00:05:16,960 --> 00:05:19,230
和Bourne shell编程。

85
00:05:19,230 --> 00:05:25,440
它已被用来作为一个交互式shell的一些人 - 少数。

86
00:05:25,440 --> 00:05:32,050
后来虽然，还有一个介绍，在Bash shell中，BASH，

87
00:05:32,050 --> 00:05:35,290
再一个文字游戏，伯恩 - 再次壳。

88
00:05:35,290 --> 00:05:43,830
这是Bourne shell中的延伸。 Korn外壳是也。他们两人都是。

89
00:05:43,830 --> 00:05:48,100
它具有Korn外壳程序的合并的目标一致的C shell的

90
00:05:48,100 --> 00:05:50,980
和Bourne shell中的优势1外壳。

91
00:05:50,980 --> 00:05:56,810
许多Korn shell中的增强功能还包括在Bash中。

92
00:05:56,810 --> 00:06:00,710
击，但是，有更多，因此是优选的。

93
00:06:00,710 --> 00:06:05,180
伯恩 - 再次壳和Korn外壳程序被称为Bourne类型的炮弹

94
00:06:05,180 --> 00:06:07,730
因为它们包含了Bourne shell的特性，

95
00:06:07,730 --> 00:06:11,180
这是不兼容的，在某些方面与C壳。

96
00:06:11,180 --> 00:06:15,520
除了有这些，一些打算限制使用其他shell，

97
00:06:15,520 --> 00:06:20,670
也许仅限于某些命令，也许专业的参考，不宜经常使用。

98
00:06:20,670 --> 00:06:24,240
>>好吧。这里下一个项目。

99
00:06:31,300 --> 00:06:38,970
在Bash shell中已经成为各种形式的Linux相关。

100
00:06:38,970 --> 00:06:41,550
我不知道如果这是每一种真实。

101
00:06:41,550 --> 00:06:43,280
有很多形式存在，并且我没有使用过他们，

102
00:06:43,280 --> 00:06:46,870
但在那些我用它已经成为与它相关联。

103
00:06:46,870 --> 00:06:49,670
所以，据我所知，没有什么关于Bash

104
00:06:49,670 --> 00:06:52,210
这使得它的任何更多的Linux兼容

105
00:06:52,210 --> 00:06:55,020
比外壳与操作系统的任何其他组合。

106
00:06:55,020 --> 00:06:59,690
我想这可能只是反映了程序员的倾向。

107
00:06:59,690 --> 00:07:07,500
它已经成为Linux的相关的另一个原因更喜欢bash来的ksh

108
00:07:07,500 --> 00:07:11,820
因为事情很可能被写在它和它的可能扩散。

109
00:07:11,820 --> 00:07:15,410
我给你以后的其他原因。

110
00:07:15,410 --> 00:07:21,330
的Bourne shell脚本应该在了Korn Shell或bash运行。

111
00:07:21,330 --> 00:07:22,650
如果你写的东西了Bourne shell的，

112
00:07:22,650 --> 00:07:26,180
你或许可以在ksh下或bash执行它。

113
00:07:26,180 --> 00:07:30,610
Korn外壳脚本可能会猛砸下运行，但我不能保证。

114
00:07:30,610 --> 00:07:36,040
后来就到这里，C-shell脚本应该根据TC-shell运行。

115
00:07:38,850 --> 00:07:41,690
在C壳竟是从未广泛用于脚本

116
00:07:41,690 --> 00:07:48,110
因为Bourne shell的和后来的Bourne类型的炮弹是最好用于这一目的。

117
00:07:48,110 --> 00:07:50,620
所以这真的不是那么重要。

118
00:07:50,620 --> 00:07:53,480
有相当多的，其中书面不久前的Bourne shell脚本，

119
00:07:53,480 --> 00:07:56,860
Korn shell中或者是Bourne-Again Shell的面前进行了介绍。

120
00:07:56,860 --> 00:07:59,300
那些仍然在使用中，操作系统的一部分，

121
00:07:59,300 --> 00:08:01,590
所以你会发现他们，如果你到操作系统

122
00:08:01,590 --> 00:08:03,760
或一些老节目包。

123
00:08:03,760 --> 00:08:12,840
>> Bash是在一定程度上成为一种通用语言的操作系统。

124
00:08:12,840 --> 00:08:17,580
它已经被延伸到Windows和VMS。

125
00:08:17,580 --> 00:08:20,440
VMS，如果你不知道，是一个专有操作系统

126
00:08:20,440 --> 00:08:25,480
数字设备公司，该公司仍然在使用，主要是在幕后的。

127
00:08:25,480 --> 00:08:29,250
如果它的将是在几个不同的操作系统上运行，

128
00:08:29,250 --> 00:08:31,110
可能是人们往往转向它。

129
00:08:31,110 --> 00:08:33,840
但这种发展也比较近。

130
00:08:33,840 --> 00:08:39,490
这是刚刚开始，所以我无法预测这是否会变成真正那种用得上。

131
00:08:39,490 --> 00:08:43,539
同时，由于文件路径名和库的不同

132
00:08:43,539 --> 00:08:46,210
这些不同的操作系统之间，

133
00:08:46,210 --> 00:08:50,250
你可能不能够在一个操作系统上编写一个Bash脚本

134
00:08:50,250 --> 00:08:51,840
然后在另一个上运行它。

135
00:08:51,840 --> 00:08:54,440
你应该能够将其移动不同的Unix，Linux之间

136
00:08:54,440 --> 00:08:59,020
的Mac OS操作系统，但不一定Windows或VMS。

137
00:08:59,020 --> 00:09:01,390
你可能需要更改文件路径名的描述，

138
00:09:01,390 --> 00:09:03,180
而一些图书馆可能会有所不同，

139
00:09:03,180 --> 00:09:05,230
这可能会影响的方式，一些命令的工作

140
00:09:05,230 --> 00:09:09,730
或者他们如何处理参数等。

141
00:09:09,730 --> 00:09:19,230
除此之外，这里的另一个注意事项是难保

142
00:09:19,230 --> 00:09:23,570
所有我提到的不同弹 - 的Bourne shell，C壳，

143
00:09:23,570 --> 00:09:29,880
TC-外壳，Korn shell中，伯恩 - 再次壳 - 将在任何Unix可用

144
00:09:29,880 --> 00:09:33,750
或Linux或Mac OS的计算机。

145
00:09:33,750 --> 00:09:35,620
他们可能根本不存在。

146
00:09:35,620 --> 00:09:38,300
这是这里的注意事项之一。

147
00:09:38,300 --> 00:09:41,490
这是一个不幸的限制，在这里，因为你想要的东西的工作无处不在，

148
00:09:41,490 --> 00:09:44,380
但不幸的是，你不能依靠这一点。

149
00:09:44,380 --> 00:09:47,230
>>好吧。这里下一个。

150
00:09:50,280 --> 00:09:54,370
比方说，你想编写一个shell脚本，

151
00:09:54,370 --> 00:09:57,170
一个方案，包括shell命令。

152
00:09:57,170 --> 00:10:01,200
你写你的命令，将它们放在一个文件，执行该文件。

153
00:10:01,200 --> 00:10:04,230
如果您要包含的参数？

154
00:10:04,230 --> 00:10:09,650
在shell操作的情况下，参数被称为参数或位置参数

155
00:10:09,650 --> 00:10:15,940
他们会用一个美元符号和数字，$ 1，$ 2中可以调用。

156
00:10:15,940 --> 00:10:27,000
因此，如果脚本有这个名字，我的第一个参数可能是说法1

157
00:10:27,000 --> 00:10:30,540
而我的第二个可能是参数2，

158
00:10:30,540 --> 00:10:34,110
和我的脚本里面，如果我要引用这些东西 - 

159
00:10:34,110 --> 00:10:36,810
让我们抹去这一点，因为我不是真的要运行它 - 

160
00:10:36,810 --> 00:10:42,160
我的剧本里我可能有1美元是指ARG1，

161
00:10:42,160 --> 00:10:45,890
$ 2中，会出来这样一来，ARG2。

162
00:10:45,890 --> 00:10:50,080
因此，那些符号可供参考的参数，

163
00:10:50,080 --> 00:10:52,390
和那些适用于所有的炮弹。

164
00:10:52,390 --> 00:10:56,520
此外，还有一些其他字符。

165
00:10:56,520 --> 00:11:01,700
$ *是指整个参数列表，所有的人。

166
00:11:01,700 --> 00:11:05,390
$＃代表参数的个数。

167
00:11:05,390 --> 00:11:07,910
再次，这适用于所有的炮弹。

168
00:11:07,910 --> 00:11:15,540
这些符号，*和＃，可以与在其他地方还有那些含义。

169
00:11:15,540 --> 00:11:17,940
我们不会进入的。

170
00:11:17,940 --> 00:11:20,460
>>贝壳符线。那是什么呢？

171
00:11:20,460 --> 00:11:27,760
比方说，你已经写了一个脚本，它是一个特定的shell，你要运行它。

172
00:11:27,760 --> 00:11:33,500
你怎么知道哪个shell操作系统将使用运行你的脚本？

173
00:11:33,500 --> 00:11:37,230
在一个点上，你可以认为它会运行在Bourne shell中

174
00:11:37,230 --> 00:11:39,440
如果你不说，否则，

175
00:11:39,440 --> 00:11:41,730
但人不是写在了Bourne外壳脚本那么多了

176
00:11:41,730 --> 00:11:43,750
而且你甚至不能依靠这样了。

177
00:11:43,750 --> 00:11:48,740
所以在这里，我们有一个shell符线就在这里。

178
00:11:48,740 --> 00:11:52,450
指定猛砸。

179
00:11:52,450 --> 00:11:56,750
请注意，它指定它的路径名，/斌/庆典。

180
00:11:56,750 --> 00:12:02,870
如果一台计算机有在Bash shell中，但不是在bin目录下，/ bin中，这是不行的。

181
00:12:02,870 --> 00:12:06,870
这是另一个预选赛，另一个小心这里。

182
00:12:06,870 --> 00:12:09,500
英镑符号是注释行字符。

183
00:12:09,500 --> 00:12:12,300
这适用于所有的shell。

184
00:12:12,300 --> 00:12:18,610
这里的特殊情况下，＃！在脚本的开始，是一种特殊情况。

185
00:12:18,610 --> 00:12:23,410
指定要在其中运行脚本的外壳。

186
00:12:23,410 --> 00:12:30,230
正如我说的，它可能不是同一个地方/ bin中。

187
00:12:30,230 --> 00:12:34,880
此外，还有这里另外一件事。

188
00:12:34,880 --> 00:12:41,250
如果你只是用井号，没有感叹号和路径名，

189
00:12:41,250 --> 00:12:44,640
应该指出一个C壳。

190
00:12:44,640 --> 00:12:48,300
但是，我不建议这样做，因为我不能保证

191
00:12:48,300 --> 00:12:49,750
这将始终工作。

192
00:12:49,750 --> 00:12:52,220
如果你想一个C壳，倒不如说出来。

193
00:12:52,220 --> 00:12:58,450
再有就是这里的东西相当混乱。

194
00:12:58,450 --> 00:13:03,940
如果您使用的shell符线例如/ bin / bash的

195
00:13:03,940 --> 00:13:07,070
而且外壳是不可有，

196
00:13:07,070 --> 00:13:10,680
有没有这样的东西作为该特定计算机上的/斌/ bash中，

197
00:13:10,680 --> 00:13:14,330
可能是因为它不具有击或者因为它在不同的位置，

198
00:13:14,330 --> 00:13:17,450
你会得到一个错误，告诉你，你运行该脚本不存在。

199
00:13:17,450 --> 00:13:21,510
当然还有你的脚本存在，使错误信息是混乱的。

200
00:13:21,510 --> 00:13:24,810
操作系统为您提供了错误的原因

201
00:13:24,810 --> 00:13:28,370
或者更准确地说，你在其中运行此交互式shell给出了错误，

202
00:13:28,370 --> 00:13:33,510
是，它会报告你使用的命令，这是脚本的名称。

203
00:13:33,510 --> 00:13:36,920
该命令实际上是由脚本的名称被叫做shell。

204
00:13:36,920 --> 00:13:39,330
这就是你得到令人困惑的错误消息。

205
00:13:39,330 --> 00:13:42,980
另一种方法来调用shell脚本

206
00:13:42,980 --> 00:13:45,910
是通过指定的shell命令行上，如下。

207
00:13:45,910 --> 00:13:52,510
这是一个命令。这是说运行猛砸，然后在Bash中运行我的脚本。

208
00:13:52,510 --> 00:13:55,680
这将优先于符线，

209
00:13:55,680 --> 00:14:02,090
这有让您为不同的路径名的功能。

210
00:14:02,090 --> 00:14:04,840
如果你只是给一个命令时，操作系统将查找命令

211
00:14:04,840 --> 00:14:06,410
在不同的地方。

212
00:14:06,410 --> 00:14:08,820
如果有的话，就应该找到它。

213
00:14:08,820 --> 00:14:12,290
电脑会发现猛砸无论它在哪里，并运行它，

214
00:14:12,290 --> 00:14:15,470
所以你不需要再被关注的地方找到它。

215
00:14:15,470 --> 00:14:17,360
还有潜在的其他问题在这里，

216
00:14:17,360 --> 00:14:20,830
因为如果有超过1版本的Bash，这是可能的，虽然不太可能的。

217
00:14:20,830 --> 00:14:23,540
所以这是另一种方式来处理这些事情。

218
00:14:23,540 --> 00:14:30,480
说明行可以调用任何shell。

219
00:14:30,480 --> 00:14:34,480
他们也可以拨打事情比其他炮弹。

220
00:14:34,480 --> 00:14:37,940
例子我这里是用sed，这是流编辑器;

221
00:14:37,940 --> 00:14:39,900
awk中，这是一个模式处理语言;

222
00:14:39,900 --> 00:14:43,680
和perl，一个非常高度发达的脚本语言。

223
00:14:43,680 --> 00:14:47,570
如果你把一个符线，表示这些方案之初之一，

224
00:14:47,570 --> 00:14:51,270
它会直接进入该程序，而不是启动一个shell。

225
00:14:51,270 --> 00:14:54,030
这些程序必须限制自己的能力。

226
00:14:54,030 --> 00:14:58,790
Perl是很能干。 sed是一个编辑器。它可以做超越简单的编辑东西。

227
00:14:58,790 --> 00:15:03,300
但它可能很难编程这一点。

228
00:15:03,300 --> 00:15:09,670
此外，传递参数和东西向的脚本是不可能或混乱。

229
00:15:09,670 --> 00:15:15,030
因此，在这种情况下，使用awk或sed的，它是，至少在我的经验，

230
00:15:15,030 --> 00:15:18,910
最好写一个shell脚本和呼叫笨拙或从shell脚本sed的

231
00:15:18,910 --> 00:15:24,660
而不是调用的awk或sed的作为脚本说明符线。

232
00:15:24,660 --> 00:15:26,980
Perl是一个高度多元化的语言，如我所说。

233
00:15:26,980 --> 00:15:30,050
您不能运行交互式命令在perl中，

234
00:15:30,050 --> 00:15:32,660
这意味着你不能测试的脚本，你正在开发的部分

235
00:15:32,660 --> 00:15:33,970
通过交互方式运行它们。

236
00:15:33,970 --> 00:15:36,160
然而，这是一个非常有能力的语言

237
00:15:36,160 --> 00:15:40,960
并已经发展成为一个非常广泛使用的工具。

238
00:15:40,960 --> 00:15:45,720
这只是说明符线的括号备注一点点。

239
00:15:45,720 --> 00:15:50,610
>>在所有或大多数形式的Linux  - 再一次，我不能肯定这一切 - 

240
00:15:50,610 --> 00:15:57,900
而在Mac OS上，如果你输入你的csh tcsh的获得，

241
00:15:57,900 --> 00:16:00,570
如果你输入sh你得到的是bash。

242
00:16:00,570 --> 00:16:05,020
他们试图在那里给你这些炮弹更先进的版本，

243
00:16:05,020 --> 00:16:07,940
但是这可能会造成混淆。

244
00:16:07,940 --> 00:16:16,720
如果你写使用的tcsh脚本或Bash特性，同时呼吁csh或sh的

245
00:16:16,720 --> 00:16:22,230
然后尝试不具有的tcsh或bash的计算机上运行它，

246
00:16:22,230 --> 00:16:25,050
你可能会得到一些错误，如果有命令在那里

247
00:16:25,050 --> 00:16:27,970
而那些炮弹不承认。

248
00:16:27,970 --> 00:16:34,120
此外，你可能已经召集了在本地计算机上你的shell

249
00:16:34,120 --> 00:16:37,700
称其为sh或csh的，然后得到更高级的壳。

250
00:16:37,700 --> 00:16:41,440
你甚至可能不会想到的，你使用更高级的壳的事实。

251
00:16:41,440 --> 00:16:45,670
因此，这是一个潜在的缺陷。

252
00:16:45,670 --> 00:16:50,290
它是如何建立的，如果你输入sh你猛砸，

253
00:16:50,290 --> 00:16:55,580
如果你输入的csh你TSCH？

254
00:16:55,580 --> 00:16:59,940
有些事情在这些计算机被称为链接

255
00:16:59,940 --> 00:17:06,460
它可以连接到文件的名称来引用同样的事情。

256
00:17:06,460 --> 00:17:12,180
它可以是2的名称相同的文件或一个文件，其目的是指向另一个文件。

257
00:17:12,180 --> 00:17:17,550
他们被称为硬链接和符号链接。我们今天不会进入这样了。

258
00:17:17,550 --> 00:17:21,619
也可能有单独的文件 -  1文件SH，1档巴什 - 

259
00:17:21,619 --> 00:17:23,880
但它们都运行猛砸。

260
00:17:23,880 --> 00:17:29,350
然后还有一个限定词在这里。

261
00:17:29,350 --> 00:17:42,640
如果你调用这些炮弹的一个名字之一，

262
00:17:42,640 --> 00:17:46,640
你可能会认为你会得到相同的功能由另一名调用它。

263
00:17:46,640 --> 00:17:49,700
嗯，这其实未必是真实的。

264
00:17:49,700 --> 00:17:55,020
这些命令可以检查它们被称为名

265
00:17:55,020 --> 00:18:00,020
他们可以，那名的基础上，有不同的行为。

266
00:18:00,020 --> 00:18:02,740
有可能是试图符合标准的问题。

267
00:18:02,740 --> 00:18:06,060
你们有些人可能已经听说POSIX标准或其他的，

268
00:18:06,060 --> 00:18:08,730
也许其他功能。

269
00:18:08,730 --> 00:18:14,520
这有时可以通过命令行参数来选择

270
00:18:14,520 --> 00:18:17,310
或通过设置shell变量。

271
00:18:17,310 --> 00:18:22,170
调用它的sh或bash中实际上可能导致不同的执行

272
00:18:22,170 --> 00:18:25,300
即使是你正在执行相同的文件。

273
00:18:25,300 --> 00:18:31,800
另一个要考虑的是，即使另一台计算机的tcsh或bash，

274
00:18:31,800 --> 00:18:35,310
如果他们没有链接，因为它们是在本地计算机上

275
00:18:35,310 --> 00:18:37,990
如果你有一个Linux或Mac OS本地计算机，

276
00:18:37,990 --> 00:18:45,630
话又说回来，你会得到你调用sh或csh的外壳，而不是你可能更喜欢的之一。

277
00:18:50,430 --> 00:19:01,130
当前的Bourne shell有小的改进比那些在Bash中

278
00:19:01,130 --> 00:19:06,100
但过去那些在原来的Bourne shell。

279
00:19:06,100 --> 00:19:09,690
作为其结果，即使在当前的Bourne shell，SH，

280
00:19:09,690 --> 00:19:14,560
即使它不是猛砸，类似于C语言超过了C壳一样。

281
00:19:14,560 --> 00:19:20,460
这不是第一次建立了C壳时真实的，但它已经开发出的方式。

282
00:19:20,460 --> 00:19:26,560
您可能会注意到这里，除了Bourne shell的所有这些壳的名字

283
00:19:26,560 --> 00:19:30,640
有东西来表示他们是哪个shell  - 长山壕时，bash  - 

284
00:19:30,640 --> 00:19:32,550
但Bourne shell的仅仅是SH。

285
00:19:32,550 --> 00:19:34,910
为什么呢？这是原来的外壳。

286
00:19:34,910 --> 00:19:37,770
它是贝壳的话，不是一个shell，

287
00:19:37,770 --> 00:19:41,090
而且由于它是外壳，没有理由从另一个shell区别。

288
00:19:41,090 --> 00:19:45,030
所以这就是为什么它有这个名字，仍然一样。

289
00:19:50,630 --> 00:19:58,990
>>这里这上面是从一个密码数据库中的行账户我有有

290
00:19:58,990 --> 00:20:01,680
在另一台计算机。

291
00:20:01,680 --> 00:20:08,300
我要设法让这个名字所以你可以看到，部分在年底，外壳。

292
00:20:09,720 --> 00:20:15,450
密码数据库保存了所有用户的登录特性。

293
00:20:15,450 --> 00:20:20,330
在开始的时候是用户名，你现在可以看到的最后2个字母的我。

294
00:20:20,330 --> 00:20:23,970
这里的字段以冒号分隔。

295
00:20:23,970 --> 00:20:28,210
最后一个字段，如你所见，是斌/ tcsh中，外壳。

296
00:20:28,210 --> 00:20:30,230
这就是壳说明。

297
00:20:30,230 --> 00:20:33,240
还有这里一些有趣的事情。

298
00:20:33,240 --> 00:20:36,950
如果是首次开发的Unix，也仅有1外壳，

299
00:20:36,950 --> 00:20:38,350
所以在那里别无选择。

300
00:20:38,350 --> 00:20:45,570
那么，为什么他们允许在密码数据库中的字段指定一个shell？

301
00:20:45,570 --> 00:20:47,920
我不知道，但它是幸运的，他们做到了。

302
00:20:47,920 --> 00:20:52,030
这是相当困难的修改在密码数据库格式

303
00:20:52,030 --> 00:20:54,420
因为很多程序是指它的格式

304
00:20:54,420 --> 00:20:57,720
并且将不得不被重写。

305
00:20:57,720 --> 00:21:04,130
那就是他们包括该字段的恰当的或偶然的发展。

306
00:21:04,130 --> 00:21:12,780
那种一个密码文件中的行都是用在所有的Unix和Linux电脑，所以据我所知。

307
00:21:12,780 --> 00:21:14,650
在Mac都有自己的系统。

308
00:21:14,650 --> 00:21:17,810
它实际上与该格式的行的密码文件，

309
00:21:17,810 --> 00:21:21,060
但是这不是在用户特征被定义。

310
00:21:21,060 --> 00:21:24,200
另一个括号备注那里。

311
00:21:36,470 --> 00:21:46,020
>>如果你调用一个shell，你可以把它作为一个子shell现有的炮弹。

312
00:21:46,020 --> 00:21:50,480
所以，如果我去这里，让我们摆脱这些东西。

313
00:21:50,480 --> 00:21:53,350
在这里，我在C壳。

314
00:21:56,830 --> 00:22:01,200
该变量，从而准确地确定了我的壳，

315
00:22:01,200 --> 00:22:04,300
其实并不总是确定你正在运行哪个shell的一个可靠的方法，

316
00:22:04,300 --> 00:22:06,220
但在这种情况下，它是。

317
00:22:06,220 --> 00:22:08,040
如果刚才的输入 - 

318
00:22:09,970 --> 00:22:12,470
现在我在Bash中。

319
00:22:12,470 --> 00:22:19,540
有些事情会是相同的。 LS告诉我，我的命令。

320
00:22:19,540 --> 00:22:24,500
如果我做了一个暂停回我的C壳，LS，一样的。对不对？

321
00:22:24,500 --> 00:22:28,890
FG，前景，回到我的Bash shell。

322
00:22:28,890 --> 00:22:38,290
PWD，当前目录，返回到了C壳。

323
00:22:38,290 --> 00:22:43,180
PWD，不同的目录 - 其实不是在这种情况下，不同的目录。

324
00:22:43,180 --> 00:22:45,110
这是相同的目录中。

325
00:22:45,110 --> 00:22:50,000
比方说，我想在这里调用一个命令：其中LS。

326
00:22:50,000 --> 00:22:52,140
那是什么呢？

327
00:22:52,140 --> 00:22:53,670
它告诉我那里的ls命令，

328
00:22:53,670 --> 00:22:56,670
一个，让我一个目录列表，位于LS。

329
00:22:56,670 --> 00:23:01,460
让我们回去的Bash shell。让我们尝试同样的事情。

330
00:23:01,460 --> 00:23:05,830
嗯，有趣的那里，在那里：找不到​​命令。

331
00:23:05,830 --> 00:23:07,400
这是为什么？

332
00:23:07,400 --> 00:23:11,570
where命令是建立在与C壳。

333
00:23:11,570 --> 00:23:15,630
这不是必须从其它地方读入到存储器中并执行的命令。

334
00:23:15,630 --> 00:23:20,310
在C-shell中执行存储在它自己的代码的一部分运行它

335
00:23:20,310 --> 00:23:22,790
它不是在bash shell。

336
00:23:22,790 --> 00:23:25,710
所以猛砸，没有这样的内置命令，查找它，没有找到它，

337
00:23:25,710 --> 00:23:27,720
我们得到一个错误。

338
00:23:27,720 --> 00:23:32,290
因此，我们有一个Bash shell中下一个C-shell中运行，我们称之为一个子shell。

339
00:23:32,290 --> 00:23:38,480
而万一你很好奇，Bash shell中有它自己的定位命令的方式。

340
00:23:38,480 --> 00:23:42,590
散列是指它可以更迅速地执行的事实，

341
00:23:42,590 --> 00:23:44,960
被发现更迅速。

342
00:23:44,960 --> 00:23:48,610
这是建在一些炮弹的增强功能之一。

343
00:23:50,220 --> 00:23:54,200
>> Bourne类型的炮弹是首选的编程。

344
00:23:54,200 --> 00:23:57,300
他们有像循环，条件语句控制结构，

345
00:23:57,300 --> 00:24:00,240
您可能会在编程语言使用像C的排序命令

346
00:24:00,240 --> 00:24:04,190
或任何一种语言。也许你正在编写Java或别的什么东西。

347
00:24:04,190 --> 00:24:06,460
shell有这些呢。

348
00:24:06,460 --> 00:24:11,790
伯恩的型壳，尤其是Bash有更多的

349
00:24:11,790 --> 00:24:15,730
和它们的设计具有更大的灵活性。

350
00:24:15,730 --> 00:24:20,700
在Bash shell中有数组。原来的Bourne shell没有。

351
00:24:20,700 --> 00:24:26,130
所以，可以进行编程相当合算。

352
00:24:26,130 --> 00:24:29,810
在C壳实际上确实有数组，但并没有很多的这些其他功能。

353
00:24:29,810 --> 00:24:33,450
伯恩的型壳会执行得更快

354
00:24:33,450 --> 00:24:36,520
如果它们不具有用于交互使用的功能。

355
00:24:36,520 --> 00:24:39,340
你加载下来的东西只有一个目的，这将加载下来用于其他用途。

356
00:24:39,340 --> 00:24:41,520
有这么权衡那里。

357
00:24:41,520 --> 00:24:44,510
这是用于交互使用这些功能

358
00:24:44,510 --> 00:24:46,920
真的是很少或根本没有使用的脚本。

359
00:24:46,920 --> 00:24:52,160
它可以使用一个交互式子shell就像一个我在那里开始

360
00:24:52,160 --> 00:24:57,780
测试一下，你打算在脚本中使用的命令。

361
00:24:57,780 --> 00:25:01,180
这就是你不能用Perl做什么。你可以用贝壳做。

362
00:25:01,180 --> 00:25:04,850
即使是像for循环等等的结构可以交互方式运行。

363
00:25:04,850 --> 00:25:07,000
他们以交互方式运行偶尔有用，

364
00:25:07,000 --> 00:25:10,180
但更可能你使用他们开发的脚本。

365
00:25:15,690 --> 00:25:17,400
>>别名。

366
00:25:17,400 --> 00:25:21,630
这将是有关C壳。

367
00:25:23,270 --> 00:25:27,570
在那里，你会回到前面的命令历史机制

368
00:25:27,570 --> 00:25:30,340
或其中某些部分，你已经运行。

369
00:25:30,340 --> 00:25:33,680
再次，有关C壳，Bourne shell的和Korn外壳程序有这些东西，

370
00:25:33,680 --> 00:25:35,620
但我不打算进入他们。

371
00:25:35,620 --> 00:25:40,340
因此，这里有我有一些有用的别名。

372
00:25:43,100 --> 00:25:44,880
而不是输入ls  - 这是一个共同的命令 - 

373
00:25:44,880 --> 00:25:47,620
只要输入L和保存自己1个字符。

374
00:25:47,620 --> 00:25:50,600
LS提供了各种选项，所有这些工作。

375
00:25:50,600 --> 00:25:54,460
请注意，这些定义都有他们周围的报价。

376
00:25:54,460 --> 00:25:57,520
在这些情况下，引号是没有必要的。

377
00:25:57,520 --> 00:26:00,100
如果你可以定义这些别名不带引号，它仍然工作。

378
00:26:00,100 --> 00:26:02,910
他们建议。

379
00:26:02,910 --> 00:26:04,900
有在其中您不能使用的情况下报价

380
00:26:04,900 --> 00:26:08,050
因为你想要的东西发生该报价将阻止。

381
00:26:08,050 --> 00:26:11,210
有时候，你可以引述的定义的一部分，但不是全部。

382
00:26:11,210 --> 00:26:17,010
这也是一般建议使用单引号而不是双引号。

383
00:26:17,010 --> 00:26:19,750
双引号对变量定义的影响，

384
00:26:19,750 --> 00:26:22,950
特别是使它们进行评估，而不是停止它。

385
00:26:22,950 --> 00:26:25,910
为什么我们要停止的评价？

386
00:26:25,910 --> 00:26:28,710
以及如何报价替我们？

387
00:26:28,710 --> 00:26:32,600
>>这里是你可能会发现有趣的命令。

388
00:26:32,600 --> 00:26:35,470
“LS G *'

389
00:26:35,470 --> 00:26:37,640
G *，你可能知道，是一个通配符表达式

390
00:26:37,640 --> 00:26:40,290
所有的文件名相克的开始。

391
00:26:40,290 --> 00:26:46,410
如果我只是写在一个ls命令G *，我会在我的当前目录下的所有这些名字的列表。

392
00:26:46,410 --> 00:26:50,870
如果我定义了别名，因为它是这里的引号，

393
00:26:50,870 --> 00:26:56,990
它会在你运行它当前目录运行该命令。

394
00:26:56,990 --> 00:27:01,250
但是，如果你不带引号运行别名定义，

395
00:27:01,250 --> 00:27:09,620
它会评估通配符G *当运行定义命令。

396
00:27:09,620 --> 00:27:14,400
所以别名的定义将被LS接着文件在目录列表

397
00:27:14,400 --> 00:27:16,310
在其上执行命令的别名，

398
00:27:16,310 --> 00:27:19,180
无论在哪里，你确实要运行的命令。

399
00:27:19,180 --> 00:27:26,360
这是没有多大用处，而单引号防止星号的评价。

400
00:27:26,360 --> 00:27:30,780
所以，你刚刚得到的定义之中LS G *。

401
00:27:30,780 --> 00:27:35,510
然后，当你运行的别名，LGS，它进而提出了这一点。

402
00:27:35,510 --> 00:27:40,490
现在有没有引号，并且在运行alias命令，将评估星号。

403
00:27:40,490 --> 00:27:43,900
所以这是一件事。

404
00:27:43,900 --> 00:27:46,590
双引号将有同样的效果在这里，

405
00:27:46,590 --> 00:27:50,580
但也有其他案件中，双引号是行不通的这么好。

406
00:27:50,580 --> 00:27:52,450
>>这里是另外一个。

407
00:27:52,450 --> 00:27:54,270
你可能知道grep命令。

408
00:27:54,270 --> 00:28:02,110
grep命令可以被用来扫描具有一定的字符串的行的文件。

409
00:28:02,110 --> 00:28:10,350
所以，让我们在这里，我会退出从我的Bourne shell。

410
00:28:23,570 --> 00:28:25,450
好吧。这里有一个文件。

411
00:28:25,450 --> 00:28:31,490
比方说，它的grep ABC字符串。在那里，它是。

412
00:28:31,490 --> 00:28:37,930
如果我做的grep zddd，我什么也得不到。好吧。

413
00:28:37,930 --> 00:28:40,960
所以找到一个字符串，它会报告它没有找到，它不报告。

414
00:28:40,960 --> 00:28:44,930
它输出一个具有该字符串就可以了任意行。

415
00:28:44,930 --> 00:28:49,080
有各种各样的选择这里，你可以在文档中找到。

416
00:28:49,080 --> 00:28:52,160
下面就来做到这一点的方法之一。

417
00:28:52,160 --> 00:29:03,290
这个怎么样，别名grabc的'grep ABC'？

418
00:29:03,290 --> 00:29:09,000
那将包括1参数的别名定义时。

419
00:29:09,000 --> 00:29:26,300
所以，如果我这样做，在这里，现在如果我做grabc，

420
00:29:26,300 --> 00:29:30,620
现在的别名包括超过简单的命令。它也有争论。

421
00:29:30,620 --> 00:29:32,190
到目前为止的作品。

422
00:29:32,190 --> 00:29:38,590
我这里有另一个命令，这一个，所以这些都是不同的字符串在那里

423
00:29:38,590 --> 00:29:46,790
并且表明，该未发现任何存在，因为它不匹配。

424
00:29:46,790 --> 00:29:56,180
>>如果我想在别名定义，以包括我将要搜索的文件

425
00:29:56,180 --> 00:30:02,970
我想给作为参数传递给该别名，我要找的字符串？

426
00:30:02,970 --> 00:30:08,040
我可能要说ABC作为参数传递给我的别名，

427
00:30:08,040 --> 00:30:10,870
但该别名已经确定的文件。

428
00:30:10,870 --> 00:30:15,710
而这也正是这个表达式的用武之地。

429
00:30:20,430 --> 00:30:25,270
注意这里我们使用grep像以前一样。

430
00:30:25,270 --> 00:30:28,130
我们有文件在这里，字符串。

431
00:30:28,130 --> 00:30:35,610
\！^，有种奇怪的表情，我想，如果你还没有见过这个。

432
00:30:35,610 --> 00:30:39,920
感叹号是C shell的历史记录机制的一部分。

433
00:30:39,920 --> 00:30:45,220
它可以回忆较早的命令，它可以调用的参数的那些命令等等。

434
00:30:46,760 --> 00:31:01,570
历史机制被用作混叠的一部分。

435
00:31:01,570 --> 00:31:07,390
如果指定了感叹号后一条线，它会参考该行历史记录列表，

436
00:31:07,390 --> 00:31:11,910
我们不会陷入现在，因为它是一个整体的其他话题。

437
00:31:11,910 --> 00:31:16,280
它可以指定一个线路的一部分。

438
00:31:16,280 --> 00:31:22,950
所以！3:2将指挥3号的第二个参数。

439
00:31:22,950 --> 00:31:30,430
这里在这个表达式中插入符号代表第一个参数。

440
00:31:30,430 --> 00:31:34,410
如果你不给它一个迹象，其中的命令你指的是，

441
00:31:34,410 --> 00:31:37,300
它是指紧接前面的命令，

442
00:31:37,300 --> 00:31:41,990
和插入符号是第一个参数的象征。

443
00:31:41,990 --> 00:31:46,820
因为它是插入符号，而不是数量，你不需要使用冒号，

444
00:31:46,820 --> 00:31:52,660
所以！^指的第一个参数前面的命令。

445
00:31:52,660 --> 00:31:55,020
这里有点混淆。

446
00:31:55,020 --> 00:31:58,450
在这种情况下，当你使用这个作为别名的定义，

447
00:31:58,450 --> 00:32:04,650
历史上的参考指回在其中别名使用的命令。

448
00:32:04,650 --> 00:32:08,470
因此，这是要回1命令作为历史操作，

449
00:32:08,470 --> 00:32:11,810
但作为一个别名操作它指的是你会在其中键入命令，

450
00:32:11,810 --> 00:32:14,780
说，grstrings_file。

451
00:32:17,440 --> 00:32:20,240
我们这里有它的报价。什么是反斜杠呢？

452
00:32:20,240 --> 00:32:30,810
在这种情况下，与其他地方一样，我们并不想执行的历史记录机制

453
00:32:30,810 --> 00:32:33,680
在定义别名。

454
00:32:33,680 --> 00:32:37,900
如果我们没有足够的反斜线出现，外壳会拉在第一个参数

455
00:32:37,900 --> 00:32:41,870
右才跑了这个alias命令，这是我们不希望的命令。

456
00:32:41,870 --> 00:32:47,520
我们希望这是内置在alias命令中的参数后调用。

457
00:32:47,520 --> 00:32:53,550
单引号不要逃避感叹号，历史参考。

458
00:32:53,550 --> 00:32:57,450
也许你知道的表情逃生手段来改变某事的意义。

459
00:32:57,450 --> 00:33:00,260
在这种情况下，这意味着停止的东西从具有特殊的意义。

460
00:33:00,260 --> 00:33:03,030
感叹号的特殊意义是历史。

461
00:33:03,030 --> 00:33:05,790
逃跑，它不具有意义。

462
00:33:05,790 --> 00:33:08,080
报价不这样做;反斜线一样。

463
00:33:08,080 --> 00:33:11,900
所以，我们实际上正在使用2级逃逸这里。

464
00:33:23,500 --> 00:33:29,620
我要提出这个命令到另一个窗口，而无需键入它

465
00:33:29,620 --> 00:33:35,210
通过使用这些编辑操作，这可能对你有用。

466
00:33:40,620 --> 00:33:42,460
别的东西在这里我会告诉你。

467
00:33:42,460 --> 00:33:46,730
如果你只需要输入别名，不带任何参数，它会告诉你所有你的论点。

468
00:33:46,730 --> 00:33:48,640
这是一堆的别名，我已经在这里了

469
00:33:48,640 --> 00:33:53,400
除了那些我一直在使用今天已经。

470
00:33:53,400 --> 00:34:00,220
但是，如果我只需要输入与别名的名称，它告诉我这是什么意思。

471
00:34:00,220 --> 00:34:03,390
请注意，引号都走了，反斜杠也没有了。

472
00:34:03,390 --> 00:34:08,620
这里这个字符串是别名定义的结果，

473
00:34:08,620 --> 00:34:12,199
现在它刚刚！^在里面。

474
00:34:12,199 --> 00:34:19,150
这要看看在文件字符串东西。

475
00:34:19,150 --> 00:34:34,900
所以，如果我做grstrings_file字符串，我没有给它任何东西去寻找那里，

476
00:34:34,900 --> 00:34:37,429
但它在寻找字符串。

477
00:34:37,429 --> 00:34:42,330
它没有找到这个词的字符串在文件中的字符串，但它确实找到ABC。

478
00:34:42,330 --> 00:34:46,770
它不觉得。

479
00:34:46,770 --> 00:34:52,330
所以在这里我们给击中到别名的定义参数，

480
00:34:52,330 --> 00:34:55,530
被插入到它。

481
00:34:55,530 --> 00:34:58,540
这就是这个表情从何而来。

482
00:34:58,540 --> 00:35:00,240
您可以使用超过1。

483
00:35:00,240 --> 00:35:03,170
插入符号是第一个参数的象征。

484
00:35:03,170 --> 00:35:07,510
如果你想使用第二个参数，你会然后说：2。

485
00:35:07,510 --> 00:35:11,250
还有第二个参数没有特殊符号。

486
00:35:11,250 --> 00:35:14,790
而且由于你使用的是数字，你将不得不使用冒号。

487
00:35:14,790 --> 00:35:17,220
然而，还有就是，这里的另一种选择。

488
00:35:17,220 --> 00:35:21,220
美元符号表示最后一个参数。

489
00:35:21,220 --> 00:35:23,320
而且由于这是一个符号，你可以省略冒号。

490
00:35:23,320 --> 00:35:25,870
所以它会在列表中的最后一个参数。

491
00:35:25,870 --> 00:35:27,900
还有还有那一个。

492
00:35:27,900 --> 00:35:31,380
星号意味着一切，所以这是完整的参数列表，

493
00:35:31,380 --> 00:35:35,150
又一次，你可以省略冒号，因为它不是一个数字。

494
00:35:36,970 --> 00:35:39,950
我希望你们都遵守了这一切。

495
00:35:39,950 --> 00:35:54,100
>>历史机制可以回到更早线在历史列表中。

496
00:35:54,100 --> 00:36:01,370
你可以在一个别名定义做到这一点。

497
00:36:01,370 --> 00:36:02,950
我从来没有见过这样做。

498
00:36:02,950 --> 00:36:05,840
那就得从历史列表中拉出前面命令的效果

499
00:36:05,840 --> 00:36:08,130
当您执行的别名，这可能是不同的命令

500
00:36:08,130 --> 00:36:11,240
这取决于你执行它的时间和地点。

501
00:36:11,240 --> 00:36:14,020
可以想象你可能想拉出这样的引用

502
00:36:14,020 --> 00:36:15,900
只知道一个较早的命令了。

503
00:36:15,900 --> 00:36:17,280
我从来没有见过这种情况发生。

504
00:36:17,280 --> 00:36:19,970
我想有人可能会想，但这是不太可能。

505
00:36:19,970 --> 00:36:26,480
这里有另外​​一件事。

506
00:36:26,480 --> 00:36:33,060
如果您使用的历史类型的引用，

507
00:36:33,060 --> 00:36:38,190
那么只有参数其中有这样一个参考使用。

508
00:36:38,190 --> 00:36:42,180
如果您有不使用的历史型参考别名定义，

509
00:36:42,180 --> 00:36:44,060
如果它仅仅成为命令的开始

510
00:36:44,060 --> 00:36:46,520
和你有进一步的论据，那么任何你之后键入

511
00:36:46,520 --> 00:36:48,450
将被添加到该命令。

512
00:36:48,450 --> 00:36:52,040
在这种情况下，我只是给了那里的例子中，我们使用的第一个参数;

513
00:36:52,040 --> 00:36:54,610
我们没有使用任何其他人。

514
00:36:54,610 --> 00:36:57,960
如果其他参数已经在命令行上被赋予，他们就不会被使用。

515
00:36:57,960 --> 00:37:04,630
所以，如果你使用历史参考的话，那么你必须使用它来得到任何说法。

516
00:37:04,630 --> 00:37:11,310
>>还有这里另外一件事我只想说，部分插入语，

517
00:37:11,310 --> 00:37:15,250
即用感叹号这段历史机制

518
00:37:15,250 --> 00:37:18,010
又回到了原来的C壳。

519
00:37:18,010 --> 00:37:27,060
在tcsh的介绍历史操作

520
00:37:27,060 --> 00:37:30,910
其中使用了各种各样的编辑命令和字符串，

521
00:37:30,910 --> 00:37:33,650
无论是Emacs或VI。

522
00:37:33,650 --> 00:37:36,430
我个人的意见是Emacs是非常容易使用用于此目的

523
00:37:36,430 --> 00:37:39,390
即使你用vi进行常规的编辑。

524
00:37:39,390 --> 00:37:43,900
有些是现在适用于各种历史Emacs的命令。

525
00:37:43,900 --> 00:37:46,410
对照组p得到在历史列表中的前行。

526
00:37:46,410 --> 00:37:48,840
另一个控制普将得到你之前的那个。

527
00:37:48,840 --> 00:37:50,540
上箭头做同样的事情。

528
00:37:50,540 --> 00:37:54,190
控制无获取下一个命令，如果你已经回滚动的一些方法。

529
00:37:54,190 --> 00:37:55,880
向下箭头不太多。

530
00:37:55,880 --> 00:38:00,480
您可以将左到右的箭头和其他各种东西。

531
00:38:00,480 --> 00:38:02,390
这可以使历史机制的用途

532
00:38:02,390 --> 00:38:05,070
比使用感叹号语法更容易，

533
00:38:05,070 --> 00:38:07,930
但你不会使用，在一个别名定义。

534
00:38:17,780 --> 00:38:20,020
我们就去了其他一些时间。

535
00:38:24,300 --> 00:38:25,810
>>变数。

536
00:38:26,880 --> 00:38:29,510
你知道哪些变量是编程语言。

537
00:38:29,510 --> 00:38:31,680
炮弹让他们也。

538
00:38:31,680 --> 00:38:37,350
在C-shell使用设置为变量赋值的命令，

539
00:38:37,350 --> 00:38:41,360
因此，设置变量a为b的值 - 

540
00:38:41,360 --> 00:38:46,390
正如我所说，一个无用的定义，但它是如何使用的说明。

541
00:38:48,790 --> 00:38:52,410
set命令将创建一个变量，如果它不存在。

542
00:38:55,270 --> 00:39:02,490
对于shell脚本的位置参数可以被认为是变量，

543
00:39:02,490 --> 00:39:10,750
但使用它们以及它们的规则有所不同。

544
00:39:10,750 --> 00:39:14,320
您可以在脚本的过程中价值不分配到1美元。

545
00:39:14,320 --> 00:39:18,340
你必须定义一个新的变量，为此目的，如果你们当中有些人想要。

546
00:39:23,000 --> 00:39:28,470
输入设置不带参数，你会得到所有当前定义的变量的列表。

547
00:39:28,470 --> 00:39:34,220
并让我们到我其他的shell这里，看看我们得到了什么，如果我们做到这一点。

548
00:39:34,220 --> 00:39:37,110
相当长的清单中有，对不对？

549
00:39:37,110 --> 00:39:40,990
向上滚动一点点。看着这一切。

550
00:39:40,990 --> 00:39:44,330
有些事情是由shell自动定义的。

551
00:39:44,330 --> 00:39:49,320
在shell创建变量并给它一个值。

552
00:39:49,320 --> 00:39:52,730
其中有些是由shell定义，但随后由用户重新定义

553
00:39:52,730 --> 00:39:54,820
根据他的喜好。

554
00:39:54,820 --> 00:39:59,110
其中一些是由用户根据自己在做什么的那一天创建的。

555
00:39:59,110 --> 00:40:01,880
这只是设置不带任何参数。

556
00:40:06,920 --> 00:40:10,050
还有这里的这个东西一个奇怪的特点。

557
00:40:10,050 --> 00:40:17,980
有要么没有等号和变量名之间的空格

558
00:40:17,980 --> 00:40:23,700
并在等号两边的值或空格符号，

559
00:40:23,700 --> 00:40:28,940
在这一个。

560
00:40:35,620 --> 00:40:41,340
这可不行，这实际上是一个有效的命令

561
00:40:41,340 --> 00:40:43,390
但它不会做什么，你打算。

562
00:40:43,390 --> 00:40:50,070
该命令将工作，因为如果你只是说集和变量名

563
00:40:50,070 --> 00:40:54,890
不带等号或集和变量名与一个等号和没有价值，

564
00:40:54,890 --> 00:40:57,770
将变量设置为空值。

565
00:40:57,770 --> 00:41:00,120
所以设置一个=是一个有效的命令。

566
00:41:00,120 --> 00:41:04,370
该组指令可以在相同的行中定义多于1个变量。

567
00:41:04,370 --> 00:41:11,240
所以这里这个命令定义a和b为null值的效果。

568
00:41:11,240 --> 00:41:13,470
可能不是你想要的。

569
00:41:13,470 --> 00:41:17,940
这一个在这里，前面所提到的，会导致一个错误

570
00:41:17,940 --> 00:41:21,270
因为= b不合法的表达式。

571
00:41:21,270 --> 00:41:23,680
变量名不能以等号。

572
00:41:26,760 --> 00:41:29,080
并有在这里这些进一步的东西。

573
00:41:29,080 --> 00:41:36,820
冒号是用来选择从历史行参数，

574
00:41:36,820 --> 00:41:41,210
它们可以被用来 - 我没去成前 - 修改这些东西。

575
00:41:41,210 --> 00:41:44,480
它们也可以被用于修改shell变量。

576
00:41:44,480 --> 00:41:49,050
这一个在这里，$ A，有一个值。

577
00:41:49,050 --> 00:41:55,040
：R将起飞的延伸。

578
00:41:55,040 --> 00:41:57,200
一个扩展将是什么，下面的一个点，

579
00:41:57,200 --> 00:41:59,200
一个点和任何在文件的末尾跟随它，

580
00:41:59,200 --> 00:42:03,230
仅在该列表的最后一个斜线后结束。

581
00:42:03,230 --> 00:42:05,480
所以，我有在这里。

582
00:42:05,480 --> 00:42:10,730
一个是。它会下降的。Ö。

583
00:42:10,730 --> 00:42:16,510
如果没有扩展名，只有最后的斜杠后的路径名，它不会有任何效果。

584
00:42:16,510 --> 00:42:27,480
一：小时，该变量表达式，将脱下的目录列表的最后一个元素，

585
00:42:27,480 --> 00:42:29,660
再次，只有在最后的斜线。

586
00:42:29,660 --> 00:42:33,160
所以，/ A / B / C变为/ A / B，

587
00:42:33,160 --> 00:42:38,870
但是这一次被改变，因为列表后的元素为null。

588
00:42:38,870 --> 00:42:43,070
在这里有这也是我想强调某事。

589
00:42:43,070 --> 00:42:46,770
这些限定符不搜索这些文件的存在。

590
00:42:46,770 --> 00:42:48,910
他们只是寻找字符串。

591
00:42:48,910 --> 00:42:54,520
这些都是为了操纵文件名，路径名，

592
00:42:54,520 --> 00:42:57,520
但他们可以在任何字符串被使用，即使它不是一个文件名。

593
00:42:57,520 --> 00:42:58,920
他们不找的存在，

594
00:42:58,920 --> 00:43:03,550
因此，如果没有这样的文件，/ A / B / C，这仍然可以工作。

595
00:43:03,550 --> 00:43:06,930
无论是任何使用的是另外一个问题，但它仍然可以工作。

596
00:43:06,930 --> 00:43:12,850
变量是不同的的Bourne shell。我们将在稍后。

597
00:43:12,850 --> 00:43:18,240
美元符号可以像感叹号和星号进行转义。

598
00:43:18,240 --> 00:43:21,760
美元符号可以用反斜杠转义或单引号。

599
00:43:21,760 --> 00:43:24,790
双引号在所有的炮弹效果奇

600
00:43:24,790 --> 00:43:28,690
迫使一元钱的评价标志变量表达式。

601
00:43:28,690 --> 00:43:31,960
所以，如果它被转义单程，双引号可以有效果

602
00:43:31,960 --> 00:43:34,380
的导致它无论如何评价。

603
00:43:34,380 --> 00:43:37,090
这是一个有点混乱。

604
00:43:37,090 --> 00:43:43,740
如果有多个层次逃避，如在双引号单引号

605
00:43:43,740 --> 00:43:46,770
或在单引号双引号，你应该测试一下，看看会发生什么

606
00:43:46,770 --> 00:43:49,520
给一个变量，如果你正在使用一个。

607
00:43:49,520 --> 00:43:53,410
那些2的情况下 - 的双单，单双层内内 - 

608
00:43:53,410 --> 00:43:55,980
不一定给你相同的结果。

609
00:44:02,520 --> 00:44:05,600
环境变量，绑定C-shell变量。

610
00:44:05,600 --> 00:44:08,340
环境变量也是在C-shell变量，

611
00:44:08,340 --> 00:44:11,250
他们也是变量在其他炮弹了。

612
00:44:11,250 --> 00:44:15,230
在C-壳，它们是有区别的。

613
00:44:15,230 --> 00:44:18,130
的事情，我是说之前是关于shell变量。

614
00:44:18,130 --> 00:44:21,300
环境变量是一组变量不同的

615
00:44:21,300 --> 00:44:28,650
除了我们称之为绑定变量的几个变量，

616
00:44:28,650 --> 00:44:30,640
这是非常重要的，我们将进入那些后。

617
00:44:30,640 --> 00:44:34,950
环境变量被自动传递

618
00:44:34,950 --> 00:44:41,800
以贝壳或从你的shell中运行的命令。

619
00:44:41,800 --> 00:44:46,220
其他的东西都没有。在shell变量，别名都没有。环境变量。

620
00:44:46,220 --> 00:44:48,630
这就是为什么我们称他们为环境变量，

621
00:44:48,630 --> 00:44:55,030
的想法是，环境的延伸过去只是你当前的shell。

622
00:44:55,030 --> 00:45:00,510
它们可以被用来定义活动为命令。

623
00:45:00,510 --> 00:45:05,470
下面是一个例子。打印机，LPDEST。

624
00:45:05,470 --> 00:45:12,270
这两个变量可以定义一个命令将用于打印的东西的打印机。

625
00:45:12,270 --> 00:45:16,500
如果你身边有多个打印机，你可能想要把你喜欢的人。

626
00:45:16,500 --> 00:45:21,320
我们有2个变量的原因是不同的命令集写

627
00:45:21,320 --> 00:45:23,870
使用这些不同的变量。

628
00:45:23,870 --> 00:45:25,910
你可能会给予他们不同的值。

629
00:45:25,910 --> 00:45:28,860
最有可能你会给他们两个相同的值。

630
00:45:28,860 --> 00:45:35,840
这些东西的工作，因为做印刷的命令

631
00:45:35,840 --> 00:45:40,740
被编程来检查这些变量的值。

632
00:45:42,200 --> 00:45:46,150
如果一个程序没有写这样一来，如果它被写做别的事情，

633
00:45:46,150 --> 00:45:48,280
该变量是不相关的。

634
00:45:48,280 --> 00:45:52,530
所以操作系统是不是找这些变量

635
00:45:52,530 --> 00:45:55,210
每次你指的是打印机的时间。

636
00:45:55,210 --> 00:45:59,090
，做印刷的命令是寻找这些变量，如果它是编程的方式。

637
00:46:11,030 --> 00:46:15,240
这些变量通常在初始化文件中定义

638
00:46:15,240 --> 00:46:19,440
但不一定。

639
00:46:19,440 --> 00:46:21,050
你可以在命令行中定义它们。

640
00:46:21,050 --> 00:46:24,090
它们可以在一个命令来定义。

641
00:46:24,090 --> 00:46:28,740
运行一些命令可以有自己的选择的变量 - 

642
00:46:28,740 --> 00:46:32,390
变量所特有的特定软件包，例如。

643
00:46:32,390 --> 00:46:36,740
当您运行该程序包，他们将被定义。

644
00:46:39,690 --> 00:46:42,680
如何这些变量传递给子shell？

645
00:46:42,680 --> 00:46:48,210
当一个子shell写，不写进入该地区。

646
00:46:48,210 --> 00:46:53,260
子外壳，致力于环境变量的区域

647
00:46:53,260 --> 00:46:56,450
不写入由子壳;它是由复制。

648
00:46:56,450 --> 00:47:00,530
当你运行一个普通的命令，如这些命令来打印或什么的，

649
00:47:00,530 --> 00:47:03,840
他们通过创建一个新的shell开始。

650
00:47:03,840 --> 00:47:06,190
壳创建一个shell，然后重写它的一部分

651
00:47:06,190 --> 00:47:08,800
与你正在运行的命令，这是一个有点混乱，

652
00:47:08,800 --> 00:47:10,740
但是这是这些命令怎么弄的环境变量

653
00:47:10,740 --> 00:47:14,890
他们然后参照后面。

654
00:47:21,920 --> 00:47:28,010
该命令在这里定义的变量SETENV。

655
00:47:28,010 --> 00:47:36,470
这就是你如何定义它。这3个元素：SETENV，变量的值。

656
00:47:36,470 --> 00:47:44,710
如果你只是用的setenv没有参数，你会得到什么？

657
00:47:47,220 --> 00:47:48,810
所有这些变量的列表。

658
00:47:48,810 --> 00:47:53,190
再次，这是一个不错的长长的名单，并在这种情况下，在别人，

659
00:47:53,190 --> 00:47:57,320
这些变量在很大程度上定义了我的登录操作由shell本身

660
00:47:57,320 --> 00:47:59,740
而不是由任何我做到了。

661
00:47:59,740 --> 00:48:03,580
还有这里的另一个命令，printenv的。

662
00:48:07,520 --> 00:48:10,340
这也打印出了环境。

663
00:48:10,340 --> 00:48:15,240
请注意这最后的东西在这里，编辑= VI。

664
00:48:15,240 --> 00:48:21,120
那说，如果我使用的东西，调用一个编辑器

665
00:48:21,120 --> 00:48:25,530
我没有指定一个编辑器，它可以让我选择，它可以给我六。

666
00:48:25,530 --> 00:48:37,280
如果我做printenv的编辑器？它告诉我它是什么。

667
00:48:37,280 --> 00:48:41,340
右之前，有一个变量，减。

668
00:48:41,340 --> 00:48:46,040
这些是你的默认选项，当我运行less命令，

669
00:48:46,040 --> 00:48:49,360
其中显示文件。

670
00:48:49,360 --> 00:48:55,910
所以，如果我这样做，printenv将可能需要1或0自变量参数，

671
00:48:55,910 --> 00:48:58,070
不超过1。

672
00:49:01,800 --> 00:49:05,690
还有其他一些命令还可以，但我们不打算进入所有今天。

673
00:49:05,690 --> 00:49:11,010
记得有修饰符的shell变量，如：H，

674
00:49:11,010 --> 00:49:14,350
它会掉落一个路径名的最后一个元素，

675
00:49:14,350 --> 00:49:17,950
或：R，这将下降的延伸。

676
00:49:17,950 --> 00:49:23,110
现在，那些适用于环境变量了。他们没有用。

677
00:49:23,110 --> 00:49:24,960
它曾经是他们不能被修改。现在，他们都可以。

678
00:49:24,960 --> 00:49:29,190
它与炮弹多年来的发展的进步之一。

679
00:49:29,190 --> 00:49:35,620
我是说，炮弹作为环境的一部分

680
00:49:35,620 --> 00:49:43,040
而在C-壳壳变数，但有一些例外，不同的集合。

681
00:49:43,040 --> 00:49:46,790
你可以建立一个环境变量和shell变量具有相同的名称。

682
00:49:46,790 --> 00:49:49,220
他们将不同的变量，它们可以有不同的值。

683
00:49:49,220 --> 00:49:53,090
改变一个变量的值不会改变另一个的值。

684
00:49:53,090 --> 00:49:58,070
这些变量都是评估与美元符号 - 美元，$不管。

685
00:49:58,070 --> 00:50:02,340
所以，如果你有这是什么？你知不知道你是哪一个？

686
00:50:02,340 --> 00:50:04,520
在我的测试中，我得到了shell变量，

687
00:50:04,520 --> 00:50:07,240
但这不是记录并不能依靠这一点。

688
00:50:07,240 --> 00:50:10,270
所以我问你，是创造的shell和环境变量

689
00:50:10,270 --> 00:50:13,490
具有相同名称的一个好主意？第好吧。

690
00:50:13,490 --> 00:50:17,460
什么是那些主要的例外所处的环境和shell变量

691
00:50:17,460 --> 00:50:19,860
被彼此连接？

692
00:50:19,860 --> 00:50:27,470
有这些4。

693
00:50:32,030 --> 00:50:35,510
大写字母TERM环境变量，

694
00:50:35,510 --> 00:50:41,540
shell变量术语小写字母，终端仿真类型。

695
00:50:41,540 --> 00:50:47,430
我只是要去在这里，我打算做的回声，一个有用的命令在这里，

696
00:50:47,430 --> 00:50:52,560
$ $ TERM任期。和那里。

697
00:50:52,560 --> 00:51:00,570
是的xterm终端类型为X Window系统显示的窗口。

698
00:51:00,570 --> 00:51:04,330
xterm的颜色就是一个变化，它允许不同的颜色。

699
00:51:04,330 --> 00:51:06,580
为什么我们定义这些？这是什么好处？

700
00:51:06,580 --> 00:51:09,740
这就像重新编辑器屏幕的命令

701
00:51:09,740 --> 00:51:13,680
发送特定序列，称为转义序列，

702
00:51:13,680 --> 00:51:18,160
到一个终端或窗口来重新排列，并且依此类推。

703
00:51:18,160 --> 00:51:20,990
这些序列是不同的不同类型的终端。

704
00:51:20,990 --> 00:51:23,100
这告诉它使用哪个。

705
00:51:23,100 --> 00:51:25,900
有时也有问题存在。

706
00:51:25,900 --> 00:51:28,600
你可能想改变这种状况。

707
00:51:28,600 --> 00:51:30,780
如果事情不工作，有时终端类型设置错误，

708
00:51:30,780 --> 00:51:36,440
您可以通过重新定义术语变量来解决它。

709
00:51:36,440 --> 00:51:43,420
在这种情况下，改变一个变量，环境变量或shell变量，

710
00:51:43,420 --> 00:51:45,970
应改变另一个。

711
00:51:45,970 --> 00:51:50,970
我通过经验发现，改变长期以大写字母

712
00:51:50,970 --> 00:51:54,060
不经常变化的shell变量术语小写字母。

713
00:51:54,060 --> 00:51:55,550
这是一个错误。

714
00:51:55,550 --> 00:51:59,400
我不知道这是永远正确的。大多数时候它是不正确的，但它可以是。

715
00:51:59,400 --> 00:52:02,490
所以，如果你做出改变，只是检查了这一点。

716
00:52:02,490 --> 00:52:05,830
这不是经常，你需要更改该值，但一旦你这样做了一段时间。

717
00:52:05,830 --> 00:52:08,260
环境变量USER。

718
00:52:08,260 --> 00:52:12,070
再次，在大写字母的环境变量，在小字母shell变量。

719
00:52:12,070 --> 00:52:13,710
这是您的用户名。

720
00:52:13,710 --> 00:52:16,730
这是只有在非常特殊的情况下

721
00:52:16,730 --> 00:52:18,420
你会想改变这种状况。

722
00:52:18,420 --> 00:52:22,350
如果您的用户名是别人，它可以引发各种各样的事情了。

723
00:52:22,350 --> 00:52:26,040
主目录，用户的主目录。

724
00:52:26,040 --> 00:52:28,060
同样，你不会想改变这种状况。

725
00:52:28,060 --> 00:52:32,260
在所有这些情况下和一个我们将要覆盖，路径变量注意，

726
00:52:32,260 --> 00:52:37,070
环境变量是大写字母，被绑定的shell变量是小写字母。

727
00:52:37,070 --> 00:52:39,240
如果你换一个，你应该改变对方。

728
00:52:39,240 --> 00:52:45,960
这种结合不能成立，因为你不能绑定2个变量，

729
00:52:45,960 --> 00:52:50,570
除了这4个，并在这些变量的绑定无法挽回，

730
00:52:50,570 --> 00:52:52,090
你不能把它们分开。

731
00:52:52,090 --> 00:52:55,820
因此，这4个变量对被绑定。

732
00:52:55,820 --> 00:52:59,020
他们总是会。没有人会。

733
00:52:59,020 --> 00:53:05,720
此外，这将有可能创造具有相同名称的变量

734
00:53:05,720 --> 00:53:07,780
相反的类型。

735
00:53:07,780 --> 00:53:11,600
你可以做一个shell变量术语小写字母

736
00:53:11,600 --> 00:53:14,990
或环境变量TERM大写字母。

737
00:53:14,990 --> 00:53:19,040
这些变量是独立于这些成对变量

738
00:53:19,040 --> 00:53:20,780
并且他们将是相互独立的。

739
00:53:20,780 --> 00:53:23,780
我无法想象，你为什么会这么做，除非你想迷惑人。

740
00:53:24,600 --> 00:53:29,730
这一个在这里，path变量，这是一个非常重要的问题。

741
00:53:29,730 --> 00:53:35,550
这里的另一件事是，有可能是个案

742
00:53:35,550 --> 00:53:40,430
与未结合到彼此相似的成对的名称的变量。

743
00:53:40,430 --> 00:53:45,000
可以有变量，壳和贝壳，在资本和小写字母。

744
00:53:45,000 --> 00:53:48,300
基于这个名字，你不知道，如果该变量是一个shell变量

745
00:53:48,300 --> 00:53:51,580
或一个环境变量，并且它们不彼此结合。

746
00:53:51,580 --> 00:53:55,300
所以那种成对的名字并不意味着绑定变量。

747
00:53:55,300 --> 00:53:58,830
路径变量，这是我之前展示，

748
00:53:58,830 --> 00:54:01,880
是路径名的列表，其中的shell查找命令。

749
00:54:01,880 --> 00:54:12,320
让我们在这个窗口在这里，我们会尽回声$ PATH中，大写字母 - 

750
00:54:12,320 --> 00:54:20,230
环境变量 - 回声$路径，小写字母 -  shell变量。

751
00:54:20,230 --> 00:54:24,980
注意，目录列表是相同的。这些约束。

752
00:54:24,980 --> 00:54:26,590
改变一个人，你改变了其他。

753
00:54:26,590 --> 00:54:32,970
在环境变量中的元素用冒号隔开。请注意。

754
00:54:32,970 --> 00:54:35,130
在shell变量之间用空格分隔。

755
00:54:35,130 --> 00:54:38,760
此环境变量是一个字符串。

756
00:54:38,760 --> 00:54:41,480
shell变量是一个数组。

757
00:54:41,480 --> 00:54:43,490
是Bourne shell没有数组。

758
00:54:43,490 --> 00:54:46,600
bash的操作类似，但是这已经是外壳的固定部分。

759
00:54:46,600 --> 00:54:48,660
这是一个字符串，而不是一个数组。

760
00:54:48,660 --> 00:54:50,420
在C壳总是有数组。

761
00:54:50,420 --> 00:54:52,630
该数组是非常容易的工作。

762
00:54:52,630 --> 00:54:54,400
您可以参考它的一部分。

763
00:54:54,400 --> 00:55:02,350
所以回声$ PATH [1]和我的/ usr / bin中，第一个元素。

764
00:55:02,350 --> 00:55:09,950
再次，记得美元符号代表的历史列表的最后一个元素。

765
00:55:09,950 --> 00:55:16,850
会发生什么呢？它试图寻找美元符号作为变量符号。

766
00:55:16,850 --> 00:55:20,850
我逃避它。哎呀。它不会采取，要么。

767
00:55:20,850 --> 00:55:23,690
有些事情不工作这么好。

768
00:55:23,690 --> 00:55:28,140
也许我们就离开了这一点。

769
00:55:28,140 --> 00:55:36,980
星号指的是整个事情，但是这就是你得到的，如果你不指定一个元素。

770
00:55:36,980 --> 00:55:46,170
另一种方式，数组变量可以被操纵，

771
00:55:46,170 --> 00:55:49,500
元素存在，7元素的数量。

772
00:55:49,500 --> 00:55:53,410
在这里，我们把英镑符号变量名之前。

773
00:55:53,410 --> 00:55:58,280
这里是另外一个。打上问号存在。

774
00:55:58,280 --> 00:56:03,170
这是一个逻辑值。指示该变量是否存在。

775
00:56:03,170 --> 00:56:05,160
这是使用变量的另一种方法。

776
00:56:05,160 --> 00:56:06,660
这，顺便说一下，不一定是一个数组变量。

777
00:56:06,660 --> 00:56:08,210
这可以是任何可变的。

778
00:56:08,210 --> 00:56:11,840
如果我这样做，有没有这样的变量，我得到一个0。

779
00:56:11,840 --> 00:56:14,990
有关变量的评价另一个小东西在那里。

780
00:56:23,670 --> 00:56:32,950
回到这一个在这里，如果你想用这个来工作的一些原因

781
00:56:32,950 --> 00:56:37,990
而不是与阵列工作，外壳变量

782
00:56:37,990 --> 00:56:41,470
有一些命令可以基于冒号分开这些事情。

783
00:56:41,470 --> 00:56:44,080
事实上，如果你将要在Bash shell中有可能这样做，

784
00:56:44,080 --> 00:56:47,110
某种类型的脚本，那将是很可能你会怎么做。

785
00:56:47,110 --> 00:56:50,350
但在C壳它更容易使用数组。

786
00:56:50,350 --> 00:56:58,250
在Bourne shell中，变量是通过这样一个表达式赋值，

787
00:56:58,250 --> 00:57:01,760
就像你可能会在一个编程语言赋给一个变量的方式，

788
00:57:01,760 --> 00:57:05,110
这里必须没有空格。

789
00:57:05,110 --> 00:57:09,110
这是必要的，它只是1串。

790
00:57:09,110 --> 00:57:14,980
在Bourne类型的炮弹，所有的变量都是shell变量。

791
00:57:14,980 --> 00:57:19,250
环境变量是shell变量的子集。

792
00:57:19,250 --> 00:57:24,060
它们从非环境变量由出口区分开来。

793
00:57:24,060 --> 00:57:28,860
要做到这一点的命令是出口，出口像打印机。

794
00:57:28,860 --> 00:57:34,930
如果我们定义这样的变量，

795
00:57:34,930 --> 00:57:38,480
如果我们想打印命令来找到它，它必须是一个环境变量，

796
00:57:38,480 --> 00:57:40,730
这就是我们如何使它之一。

797
00:57:40,730 --> 00:57:42,090
这里有什么东西那种混乱。

798
00:57:42,090 --> 00:57:50,430
这表情，出口环境，源于这个Bourne shell的概念，

799
00:57:50,430 --> 00:57:54,520
可是该表达式用于在C-壳的描述，

800
00:57:54,520 --> 00:57:57,920
哪里有没有这样的命令出口。

801
00:57:57,920 --> 00:58:06,200
如果你刚刚说出口本身，你得到的出口列表 - 

802
00:58:06,200 --> 00:58:10,620
所以，如果我只是做外销这里，没有这回事。

803
00:58:13,620 --> 00:58:15,200
好了，我们走吧。

804
00:58:15,200 --> 00:58:17,010
这些东西，顺便说一下，也由shell定义。

805
00:58:17,010 --> 00:58:19,400
我没有我自己定义任何的这些。

806
00:58:19,400 --> 00:58:23,550
外壳本身并各种各样的东西。

807
00:58:23,550 --> 00:58:26,650
它应该会自动做的事情。

808
00:58:30,240 --> 00:58:36,880
在bash或Korn shell，可以运行像这样的命令，

809
00:58:36,880 --> 00:58:42,000
这都将给出一个变量的值，并在1命令导出。

810
00:58:42,000 --> 00:58:46,150
在Bourne shell的命令，他们必须像出口的单独命令。

811
00:58:46,150 --> 00:58:48,410
这里是另一个方面，这是令人困惑的。

812
00:58:48,410 --> 00:58:52,220
在C-shell中set命令定义变量

813
00:58:52,220 --> 00:58:55,550
和不带参数告诉你的变量的值是什么。

814
00:58:55,550 --> 00:59:01,140
在bash shell，不带参数的set命令做同样的事情，

815
00:59:01,140 --> 00:59:03,580
但随着争论它确实完全不同的东西。

816
00:59:03,580 --> 00:59:06,200
因此，这些都是这里的各种参数。

817
00:59:06,200 --> 00:59:10,460
其中也不乏一些环境变量，其中有些变量是shell变量。

818
00:59:10,460 --> 00:59:13,200
他们都是shell变量真的。他们有些是环境变量。

819
00:59:15,690 --> 00:59:23,920
带参数的set命令可以用来操作

820
00:59:23,920 --> 00:59:28,220
对位置参数的脚本，

821
00:59:28,220 --> 00:59:33,910
这是越来越一次全部的方法。

822
00:59:33,910 --> 00:59:36,150
我们不能真正进入了今天。

823
00:59:36,150 --> 00:59:39,580
它也可以用来改变壳的行为。

824
00:59:39,580 --> 00:59:46,700
特别是在Bash中还存在变数，这将决定如何在shell的行为。

825
00:59:46,700 --> 00:59:51,310
那么也只有这一个命令，你可能会看到，这个命令。

826
00:59:51,310 --> 00:59:59,050
排版后跟变量和变量类型是用在Korn和击炮弹。

827
00:59:59,050 --> 01:00:04,970
这不是强制性的，但它可以被用于限制变量的值，

828
01:00:04,970 --> 01:00:08,400
这可能是有用的，以防止错误，而且它是相当常见的。

829
01:00:08,400 --> 01:00:11,640
所以，我只是提的是，如果你在某处看到它。

830
01:00:17,290 --> 01:00:19,160
where命令。

831
01:00:19,160 --> 01:00:22,490
还记得我前面提到的where命令在C壳，

832
01:00:22,490 --> 01:00:28,750
它可以告诉你一个命令路径名的位置。

833
01:00:28,750 --> 01:00:32,580
下面是命令替换。

834
01:00:32,580 --> 01:00:41,900
你应该找到你的键盘某处的字符，看起来像这样的。

835
01:00:41,900 --> 01:00:44,910
在键盘上的位置会发生变化。

836
01:00:44,910 --> 01:00:47,050
我们已经把它称为反引号。这是关于一个报价的大小。

837
01:00:47,050 --> 01:00:48,720
它从左上角到右下角。

838
01:00:48,720 --> 01:00:52,690
在这里，我的Mac键盘上它在左上角的角落。

839
01:00:52,690 --> 01:00:58,150
该字符可以用来在命令中执行命令。

840
01:00:58,150 --> 01:01:03,400
如果你有反引号里面的表达式，

841
01:01:03,400 --> 01:01:07,080
该表达式是一个命令，它的运行。

842
01:01:07,080 --> 01:01:09,010
该命令的输出

843
01:01:09,010 --> 01:01:11,980
然后，替换为全反引号表达

844
01:01:11,980 --> 01:01:16,110
然后与输出运行一个较长的命令里面

845
01:01:16,110 --> 01:01:22,010
作为论据等等的字符串的一部分。

846
01:01:22,010 --> 01:01:28,640
这里是它使用了一个命令。

847
01:01:28,640 --> 01:01:32,340
让我们来演示操作在这里。

848
01:01:44,980 --> 01:01:49,090
让我们在这里，取出后引号。

849
01:01:49,090 --> 01:01:54,410
控制一个得到我与Emacs编辑语法行的开头。

850
01:01:54,410 --> 01:02:00,380
到目前为止，路径名是什么地方呢，

851
01:02:00,380 --> 01:02:05,040
但是当我做了这个样子，它的路径名的名单，然后塞

852
01:02:05,040 --> 01:02:08,750
在这个地方整个反引号表达和运行ls-l的对他们。

853
01:02:08,750 --> 01:02:11,120
一种方便的，对吧？

854
01:02:11,120 --> 01:02:14,860
所以这是一个绝妙的事情。这就是反引号工作。

855
01:02:14,860 --> 01:02:17,560
现在，让我们再稍微往下走。

856
01:02:17,560 --> 01:02:22,050
这些都是别名。实际上我用这些。

857
01:02:22,050 --> 01:02:26,410
我会尽力让这个与1的编辑操作。

858
01:02:34,900 --> 01:02:36,900
好吧。

859
01:02:36,900 --> 01:02:39,630
现在让我们看看这些定义是怎么来的。

860
01:02:39,630 --> 01:02:44,930
别名长宽高告诉我它是如何定义的。

861
01:02:44,930 --> 01:02:51,210
请注意，这只是这一点，但外报价已采取关闭

862
01:02:51,210 --> 01:02:53,750
和感叹号被取下。

863
01:02:53,750 --> 01:02:58,940
！*，所有参数的完整列表。

864
01:02:58,940 --> 01:03:03,580
在别名定义，它会回到应用到哪里我用这个。

865
01:03:03,580 --> 01:03:10,620
长宽高KSH是bash。好吧。

866
01:03:10,620 --> 01:03:13,960
看到是如何工作的？它为我节省一些打字。

867
01:03:13,960 --> 01:03:16,440
我们去了一点点只是提别的东西在这里。

868
01:03:19,150 --> 01:03:23,120
注意这里这些不同的炮弹。我以前也说过这一点。

869
01:03:23,120 --> 01:03:36,060
长山壕有一个2过这里，所以没有/ bin中/ tcsh的。

870
01:03:36,060 --> 01:03:39,870
我们可以通过其他方式证明这些其实都是同一个文件。

871
01:03:39,870 --> 01:03:43,150
记住我，如果你输入sh你让bash在说什么。

872
01:03:43,150 --> 01:03:47,390
键入此，你会得到这个。

873
01:03:47,390 --> 01:03:51,730
但这些都没有联系。那些具有单一的人那里。

874
01:03:51,730 --> 01:03:54,910
这是不是一种文件，可以调用另一个。

875
01:03:54,910 --> 01:03:59,460
因此，这些都是单独的文件，在C-壳的是同一个文件。

876
01:03:59,460 --> 01:04:03,640
返回到这里，这里的另外一个，这个别名，

877
01:04:03,640 --> 01:04:09,090
注意，正在运行此命令，文件。

878
01:04:09,090 --> 01:04:13,810
该别名运行的。文件告诉你的文件的类型。

879
01:04:13,810 --> 01:04:20,330
所以FWH KSH是bash。好吧。

880
01:04:20,330 --> 01:04:23,230
这是该文件命令的输出。

881
01:04:23,230 --> 01:04:24,630
我不知道，如果你知道这意味着什么在这里，

882
01:04:24,630 --> 01:04:26,750
Mach-O的通用二进制与2架构。

883
01:04:26,750 --> 01:04:30,470
有在Mac的2个可能的处理器类型，

884
01:04:30,470 --> 01:04:34,780
有的也编写程序能够与这两种运行，

885
01:04:34,780 --> 01:04:37,950
和文件命令可以确定，所以这就是这个意思。

886
01:04:37,950 --> 01:04:40,660
这两个文件被写入的方式。

887
01:04:40,660 --> 01:04:43,760
于是我们看到了别名的作品中，我们看到了反引号的作品，

888
01:04:43,760 --> 01:04:48,640
我们看到的实际文件ls或者文件的工作。

889
01:04:52,050 --> 01:04:57,000
这可能无法正常工作。试试“哪里哪里”和“长宽高其中”。好吧，让我们来试试。

890
01:04:57,000 --> 01:05:01,040
哪里哪里。

891
01:05:01,040 --> 01:05:03,500
那里是一个shell内置的。

892
01:05:03,500 --> 01:05:06,970
记得早些时候我们发现，猛砸没有在那里。

893
01:05:06,970 --> 01:05:10,080
如果您在Bash shell中键入，你会得到一个错误信息。

894
01:05:10,080 --> 01:05:12,540
它的外壳只是一部分，而不是作为一个单独的命令。

895
01:05:12,540 --> 01:05:20,000
会发生什么，如果我键入长宽高找哪里？看看会发生什么存在。

896
01:05:20,000 --> 01:05:22,850
跑到哪里哪里，得到这个输出，然后试着运行ls

897
01:05:22,850 --> 01:05:25,600
作为升在哪里是一个shell内置的。

898
01:05:25,600 --> 01:05:28,790
其中是存在的，但其他的人不存在。

899
01:05:28,790 --> 01:05:32,090
这些都不存在，其实。

900
01:05:32,090 --> 01:05:35,560
所以这并不总是有效，而且还说明了如何一些事情

901
01:05:35,560 --> 01:05:39,580
不这样做挺你可能认为。

902
01:05:40,930 --> 01:05:43,010
让我们往下走远一点这里。

903
01:05:44,890 --> 01:05:54,760
这这里是在Bash中。这也是像反引号命令替换。

904
01:05:54,760 --> 01:06:05,280
但是，与反引号，它使用这个变量的风格。

905
01:06:05,280 --> 01:06:09,860
有许多的以一个美元符号表达式，

906
01:06:09,860 --> 01:06:16,070
虽然这些都不是变量，他们借来使用美元符号

907
01:06:16,070 --> 01:06:19,570
提示某种形式的表达。

908
01:06:19,570 --> 01:06:23,550
可以用括号或方括号或双括号括起来，

909
01:06:23,550 --> 01:06:26,320
它有不同的目的。

910
01:06:26,320 --> 01:06:29,500
这里单括号是一个命令替换就像反引号。

911
01:06:29,500 --> 01:06:32,720
双括号实际上是一个算术运算。

912
01:06:32,720 --> 01:06:35,380
还有其他的语法，以及其他操作。

913
01:06:35,380 --> 01:06:41,520
反引号语法可在Bash中。

914
01:06:41,520 --> 01:06:46,780
然而，这一次是优选的。它更容易阅读和它允许嵌套。

915
01:06:46,780 --> 01:06:51,300
您可以在$（命令）另一个命令，

916
01:06:51,300 --> 01:06:54,590
类似的东西 - 

917
01:07:14,560 --> 01:07:18,210
我到那里列表。

918
01:07:18,210 --> 01:07:21,670
这将工作，如果我有反引号也。

919
01:07:32,050 --> 01:07:38,470
如果我想要做这样的事情 - 

920
01:08:03,390 --> 01:08:06,430
你可能不会真正使用这个命令，

921
01:08:06,430 --> 01:08:14,160
但这个内部命令替换呼应了开头的所有文件的名称，

922
01:08:14,160 --> 01:08:18,229
那么这一个运行ls-l的这些文件，

923
01:08:18,229 --> 01:08:20,500
然后这个刚相呼应的输出。

924
01:08:21,729 --> 01:08:24,479
你可能不会做到这一点，你只会做回声或LS，

925
01:08:24,479 --> 01:08:29,450
但是这说明了命令的嵌套工作。

926
01:08:29,450 --> 01:08:34,380
所以，只是一个在这里的功能。

927
01:08:34,380 --> 01:08:37,450
 我提到这早些时候，当你有地方在C壳，

928
01:08:37,450 --> 01:08:42,770
请在Bourne类型的炮弹作品定位的命令。

929
01:08:48,939 --> 01:08:52,270
内置命令，正是我说有。

930
01:08:52,270 --> 01:08:54,640
命令是外壳，像其中的一部分。

931
01:08:54,640 --> 01:08:59,880
当shell执行命令ls之类，它找到它穿过的路径，

932
01:08:59,880 --> 01:09:03,029
发现它在某些目录中的某个地方，

933
01:09:03,029 --> 01:09:05,800
读取到内存中，创建一个新的shell，

934
01:09:05,800 --> 01:09:08,960
读取命令ls或任何入壳

935
01:09:08,960 --> 01:09:11,450
那里的环境变量已经位于，

936
01:09:11,450 --> 01:09:14,000
然后将执行转移到它。

937
01:09:14,000 --> 01:09:18,319
内置的命令，该命令的代码是壳体内，

938
01:09:18,319 --> 01:09:21,460
因此外壳刚开始执行它自己的代码的一部分。

939
01:09:21,460 --> 01:09:24,569
其中这样的命令。它实际上变得更快。

940
01:09:24,569 --> 01:09:28,380
它不具有读取在存储器中的任何事情;它已经在存储器中。

941
01:09:28,380 --> 01:09:32,460
内置的命令总是优先于命令同名。

942
01:09:32,460 --> 01:09:36,050
命令是在目录中的路径可能具有相同的名称，

943
01:09:36,050 --> 01:09:39,090
在不同的目录命令，文件在不同的目录。

944
01:09:39,090 --> 01:09:41,740
早在路径中发生的一个是一个，你会得到。

945
01:09:41,740 --> 01:09:43,770
如果有一个内置的命令，你总是能得到它。

946
01:09:43,770 --> 01:09:47,890
有没有办法给它的优先级低于路径的命令。

947
01:09:47,890 --> 01:09:54,140
如果您想获得该路径的命令，你可以输入完整的路径名。

948
01:09:54,140 --> 01:09:55,850
如果在那里的路径是一个命令的地方，

949
01:09:55,850 --> 01:09:58,440
您可以键入/ bin中/在那里，你会得到它。

950
01:09:58,440 --> 01:10:01,800
如果您不想输入完整的路径名，你可以定义一个别名。

951
01:10:01,800 --> 01:10:06,310
事实上，如果你给的别名名称相同的内置命令，它会工作

952
01:10:06,310 --> 01:10:08,790
因为别名定义进行评估

953
01:10:08,790 --> 01:10:13,220
前壳确定它是应执行的内置命令。

954
01:10:18,810 --> 01:10:23,440
那么这个就有点更复杂一些的命令在这里。

955
01:10:23,440 --> 01:10:29,880
一些命令的情况下，实际上是内置的命令和路径。

956
01:10:29,880 --> 01:10:34,140
其中之一是回声，命令我只是用了一小会儿前的那些例子。

957
01:10:34,140 --> 01:10:37,410
回声路径中的一个命令，它在每个shell。

958
01:10:37,410 --> 01:10:40,580
他们不一定所有的行为相同的方式。

959
01:10:40,580 --> 01:10:42,970
它最初是一个命令只在路径中。

960
01:10:42,970 --> 01:10:45,280
它后来被内置在外壳。

961
01:10:45,280 --> 01:10:48,080
因为有依赖于环境的选择

962
01:10:48,080 --> 01:10:52,970
和命令行选项，内置的命令

963
01:10:52,970 --> 01:10:57,030
写的功能相同，已经在路径中的命令，

964
01:10:57,030 --> 01:10:59,670
这是不可能的，他们将被写入的方式

965
01:10:59,670 --> 01:11:01,720
如果该命令不是已经被写入的路径。

966
01:11:01,720 --> 01:11:06,180
因此，这有副作用。它的历史在这里有效果。

967
01:11:06,180 --> 01:11:08,380
有选择在那里。

968
01:11:14,280 --> 01:11:23,060
还有一个变量名为echo_style的tcsh中定义的选项。

969
01:11:23,060 --> 01:11:27,700
这就是这些变量，可以改变回声的工作方式之一。

970
01:11:27,700 --> 01:11:30,910
还有其他一些情况下，您可以指定一个变量

971
01:11:30,910 --> 01:11:36,290
改变的方式，外壳操作，包括一个内置的命令，有效。

972
01:11:36,290 --> 01:11:38,130
它不会影响任何东西

973
01:11:38,130 --> 01:11:40,640
因为其他的命令都不能访问的shell变量，

974
01:11:40,640 --> 01:11:42,090
只有环境变量。

975
01:11:42,090 --> 01:11:45,360
但shell操作可以读取shell变量。

976
01:11:45,360 --> 01:11:50,710
这不会csh的工作。这是唯一的tcsh。这就是增强功能之一。

977
01:11:58,540 --> 01:12:04,620
解析具有序列时，其评估的元字符，

978
01:12:04,620 --> 01:12:08,140
当它评估的变量，别名，历史文献。

979
01:12:08,140 --> 01:12:11,830
有这些东西一个特定的序列。

980
01:12:11,830 --> 01:12:13,730
如果这样做的事情中的特定序列

981
01:12:13,730 --> 01:12:16,080
并得到的东西，这是一个排序的表达式

982
01:12:16,080 --> 01:12:20,650
它已经被评估，就不会再对其进行评估。

983
01:12:20,650 --> 01:12:24,520
如果它得到它，那么它只会传递的字符。

984
01:12:24,520 --> 01:12:29,920
所以，如果像命令替换一些表达式的求

985
01:12:29,920 --> 01:12:36,850
或变量或任何会引起表达式

986
01:12:36,850 --> 01:12:39,240
您希望进行评估，

987
01:12:39,240 --> 01:12:42,510
将工作只有在评估后的序列中出现。

988
01:12:42,510 --> 01:12:45,010
我希望我是清楚的在那里。

989
01:12:45,010 --> 01:12:50,460
也就是说解析序列，在C壳的操作，

990
01:12:50,460 --> 01:12:56,490
是不一样的内置命令，因为它是对非内置命令。

991
01:12:56,490 --> 01:12:58,890
我不知道关于Bash那里。

992
01:12:58,890 --> 01:13:02,450
例如，如果一个shell变量产生的历史参考，

993
01:13:02,450 --> 01:13:04,230
它可能不会回到过去的历史。

994
01:13:04,230 --> 01:13:06,010
这将刚才得到的感叹号。

995
01:13:06,010 --> 01:13:08,840
其实，我们只要尝试了，现在。

996
01:13:09,720 --> 01:13:18,240
设置=，我们将不得不把这个在那里。

997
01:13:30,690 --> 01:13:34,580
哦，等等。抱歉。我在Bash这样做。我想在这里做。

998
01:13:53,470 --> 01:13:56,080
见，所以也没评价，历史参考

999
01:13:56,080 --> 01:14:00,520
因为它已经过去的历史评价表达的点

1000
01:14:00,520 --> 01:14:02,720
当计算的变量。

1001
01:14:02,720 --> 01:14:05,550
所以这是解析1日起生效。

1002
01:14:05,550 --> 01:14:08,760
再次，内置命令没有执行同样的方式。

1003
01:14:08,760 --> 01:14:11,230
好的。让我们去到下一个位置。

1004
01:14:11,230 --> 01:14:16,060
这旨在是1行，但它更容易阅读。

1005
01:14:19,130 --> 01:14:21,530
那是什么呢？

1006
01:14:21,530 --> 01:14:28,640
你可能还记得，我们可以评估为星号通配符的文件名，

1007
01:14:28,640 --> 01:14:33,890
还有其他的文件名通配符，如问号和括号表达式。

1008
01:14:33,890 --> 01:14:39,000
这样的评价被称为通配。

1009
01:14:39,000 --> 01:14:46,290
设置noglob在这个命令的开头说，不这样做。

1010
01:14:46,290 --> 01:14:53,370
未设置noglob说回去做。

1011
01:14:53,370 --> 01:14:56,440
需要注意的是一套水珠不会有这种效果。

1012
01:14:56,440 --> 01:15:00,800
在日常语言中，设置水珠或取消noglob似乎是相等的，

1013
01:15:00,800 --> 01:15:03,290
但在这里它不是。这是未设置noglob。

1014
01:15:05,120 --> 01:15:07,910
现在TSET。 TSET站为终端集。

1015
01:15:07,910 --> 01:15:11,840
它不使用，往往现在，但窗口系统面世之前，

1016
01:15:11,840 --> 01:15:15,760
和你有一个单一的终端，您可能需要确定类型。

1017
01:15:15,760 --> 01:15:18,700
如果什么东西过来以太网或从网络，

1018
01:15:18,700 --> 01:15:21,120
你可能要说这是一个VT100。

1019
01:15:21,120 --> 01:15:26,630
VT100是一种在终端业务的一个标准。它来自DEC终端。

1020
01:15:26,630 --> 01:15:35,270
如果你只是做拨号 - 注意到了吗？这又回到一个办法，是吧？

1021
01:15:35,270 --> 01:15:39,520
所以，如果我们只是做TSET在这里，

1022
01:15:39,520 --> 01:15:45,250
如果我只是做TSET，它重置我的终端，但你什么也没看见。

1023
01:15:45,250 --> 01:15:47,340
它并没有真正改变什么。

1024
01:15:47,340 --> 01:15:48,620
-S

1025
01:15:49,900 --> 01:15:51,480
好吧。

1026
01:15:51,480 --> 01:15:53,350
的setenv TERM xterm的颜色。

1027
01:15:53,350 --> 01:15:57,080
我们已经知道，这个词所设定的方式，所以这并没有改变。

1028
01:15:57,080 --> 01:15:58,860
这就是我们会想这样做的方式。

1029
01:15:58,860 --> 01:16:07,080
但是请注意，这个命令，TSET-S，只输出这些命令。它没有运行它们。

1030
01:16:07,080 --> 01:16:09,770
它没有运行这些命令，它输出它们。

1031
01:16:09,770 --> 01:16:13,650
所以这是为了以产生将被执行的命令。

1032
01:16:13,650 --> 01:16:16,360
你还记得该文件中的命令，我刚才给你什么也问答。

1033
01:16:16,360 --> 01:16:18,910
因此，让我们做到这一点。

1034
01:16:18,910 --> 01:16:23,750
在Q抑制一些输出，但是这不要紧这里，你可以看到。

1035
01:16:23,750 --> 01:16:27,980
我只是这样做，告诉你，这并不重要。

1036
01:16:27,980 --> 01:16:31,870
这是在反引用语法。

1037
01:16:31,870 --> 01:16:35,340
注意反引号在这里，反引号在这里。

1038
01:16:35,340 --> 01:16:37,680
我省略这些东西在这里。

1039
01:16:37,680 --> 01:16:39,570
这是告诉它要做什么案件

1040
01:16:39,570 --> 01:16:42,050
特别类型的终端的情况下 - 

1041
01:16:42,050 --> 01:16:45,400
以太网，网络，拨号，你有什么。

1042
01:16:45,400 --> 01:16:48,050
不要紧，在这里，因为我们实际上没有做任何这些东西。

1043
01:16:48,050 --> 01:16:49,720
我只是说明了命令。

1044
01:16:49,720 --> 01:16:55,170
如果我做这个反引号，我该怎么走？

1045
01:16:55,170 --> 01:17:00,210
还要注意这里，这包括了一套noglob和取消设置noglob，

1046
01:17:00,210 --> 01:17:02,630
所以那些现在多余的定义。

1047
01:17:02,630 --> 01:17:05,380
这并不总是正确的，但现在他们包含在该命令。

1048
01:17:05,380 --> 01:17:08,890
但是让我们看看如果我这样做会发生什么

1049
01:17:08,890 --> 01:17:12,570
和我一起去参加一个控制该行的开头，我这样做。

1050
01:17:14,380 --> 01:17:18,040
好了，设置：命令未找到。种奇怪的，不是吗？

1051
01:17:18,040 --> 01:17:20,570
集是一个众所周知的命令。它的外壳的一部分。

1052
01:17:20,570 --> 01:17:24,040
设置：命令没有发现呢？这是为什么？

1053
01:17:24,040 --> 01:17:26,790
嗯。好吧，让我们来想一想。

1054
01:17:26,790 --> 01:17:31,100
它运行一个反引号命令替换，

1055
01:17:31,100 --> 01:17:37,430
和发生在解析命令的序列的某一部分。

1056
01:17:37,430 --> 01:17:40,360
集是一个内置的命令。

1057
01:17:40,360 --> 01:17:43,900
因此，通过它的命令替换的时候，

1058
01:17:43,900 --> 01:17:48,280
它已经得到了过去识别的内置命令的地步。

1059
01:17:48,280 --> 01:17:51,900
所以它把设置，就像它是在路径的命令。

1060
01:17:51,900 --> 01:17:55,440
不用说，它没有找到它，你会得到一个错误。

1061
01:17:55,440 --> 01:17:59,300
好吧。有解析顺序的一个例子。

1062
01:17:59,300 --> 01:18:01,460
和我们做对什么？

1063
01:18:01,460 --> 01:18:04,800
这里请注意，这非常有趣的命令，EVAL。

1064
01:18:04,800 --> 01:18:06,530
我不知道是什么一样。

1065
01:18:06,530 --> 01:18:08,760
如果你看看手册 - ，让我们就这样做

1066
01:18:08,760 --> 01:18:12,000
显示这些手册是如何混乱是 - 

1067
01:18:12,000 --> 01:18:19,400
男人的tcsh，迷茫说明书，发现这里的东西是不容易。

1068
01:18:19,400 --> 01:18:31,850
在这里，我们走了，EVAL精氨酸，所以我们可以有1个或多个参数

1069
01:18:31,850 --> 01:18:34,090
而且也没有的事情的清单。

1070
01:18:34,090 --> 01:18:37,730
把参数作为输入到shell

1071
01:18:37,730 --> 01:18:43,600
而在当前shell的上下文中执行产生的命令。

1072
01:18:43,600 --> 01:18:46,900
这通常是用来作为执行命令的结果生成的命令

1073
01:18:46,900 --> 01:18:51,310
或变量替换，因为这些替代之前的解析发生。

1074
01:18:51,310 --> 01:18:52,580
很不错的。

1075
01:18:52,580 --> 01:18:54,740
在这里，他们甚至提到了tset命令的使用示例

1076
01:18:54,740 --> 01:18:57,700
就像我刚才给你看。

1077
01:18:57,700 --> 01:19:00,440
现在我已经拿到窗口返回到一个有用的地方。

1078
01:19:03,150 --> 01:19:07,800
让我们在这里，我们将看到的eval只是在这之前使用。

1079
01:19:07,800 --> 01:19:14,010
因此，让我们看看如果我们把会发生什么 - 在这里，我们去了箭头的命令

1080
01:19:14,010 --> 01:19:20,940
并控制一个开头，EVAL。

1081
01:19:20,940 --> 01:19:22,850
好了，所以它的工作原理。

1082
01:19:22,850 --> 01:19:26,440
当你这样做的eval，它需要什么来后，它并使它的命令。

1083
01:19:26,440 --> 01:19:29,460
这使您能够基本上解析它的两倍。

1084
01:19:29,460 --> 01:19:33,710
这里的部分​​运行此命令的反引号里面，

1085
01:19:33,710 --> 01:19:36,210
得到的输出。

1086
01:19:36,210 --> 01:19:42,850
输出应该是因为这些命令在这里运行这样的

1087
01:19:42,850 --> 01:19:45,890
在这一个，这一个。

1088
01:19:45,890 --> 01:19:50,100
因此这些命令现在这里在这个序列，

1089
01:19:50,100 --> 01:19:58,950
但这些内置的命令，它不能让他们的时候了。

1090
01:19:58,950 --> 01:20:06,440
所以，我们去评估，EVAL挑选一个了，全部重新开始整个事情，和它的作品。

1091
01:20:06,440 --> 01:20:18,460
一个例子既backquoting的，EVAL，解析，解析的后果，

1092
01:20:18,460 --> 01:20:21,910
并命令这可能是非常小的使用，以你现在的。

1093
01:20:21,910 --> 01:20:25,540
好吧。好吧，umask的。

1094
01:20:25,540 --> 01:20:32,160
让我们来看看这个命令在这里，使用umask 022。我不知道是什么一样。

1095
01:20:32,160 --> 01:20:38,420
让我们只输入umask一无所有之后。 22。好吧。

1096
01:20:38,420 --> 01:20:44,350
022，做一遍。

1097
01:20:44,350 --> 01:20:48,580
正如你可能已经猜到了，umask的不带参数将告诉您当前的面具;

1098
01:20:48,580 --> 01:20:51,760
umask命令与参数使得它，但是这是一个我已经有了。

1099
01:20:51,760 --> 01:20:53,800
什么是022意思？

1100
01:21:01,650 --> 01:21:07,080
这是这里的规定保障的文件。

1101
01:21:07,080 --> 01:21:11,440
他们确定谁可以读取或写入或执行文件。

1102
01:21:11,440 --> 01:21:16,560
保护也称为权限。

1103
01:21:16,560 --> 01:21:21,390
r代表读，在W写入，

1104
01:21:21,390 --> 01:21:25,500
和x，它不存在在那里，代表执行。

1105
01:21:25,500 --> 01:21:27,260
有3个类别，有。

1106
01:21:27,260 --> 01:21:33,540
在过去3个元素是用户的类别。那些适用于我，则用户。

1107
01:21:33,540 --> 01:21:36,870
这3个在这里适用于组。

1108
01:21:36,870 --> 01:21:41,590
该文件属于1组，用户可以属于多个组，

1109
01:21:41,590 --> 01:21:47,150
但是，如果用户是其中此文件所属于的组中，

1110
01:21:47,150 --> 01:21:51,090
那么这些保护措施将适用于他，如果他不是用户。

1111
01:21:51,090 --> 01:21:54,230
而这一次是所有的人。

1112
01:21:55,540 --> 01:21:57,690
这些类别是互斥的。

1113
01:21:57,690 --> 01:21:59,750
用户的保护适用于他，

1114
01:21:59,750 --> 01:22:03,780
该组保护应用到组的成员以外的用户，

1115
01:22:03,780 --> 01:22:08,110
和其他保护只适用于人比用户与该组成员的其他。

1116
01:22:08,110 --> 01:22:12,320
如果有一个r或AW或一个x，这意味着保护是理所当然的。

1117
01:22:12,320 --> 01:22:13,950
如果有一个连字符，这意味着它不是。

1118
01:22:13,950 --> 01:22:16,690
有实际上是可以放置在这里，除了这些其它的东西，

1119
01:22:16,690 --> 01:22:18,350
我不会进入现在。

1120
01:22:18,350 --> 01:22:24,450
umask的定义了一个默认为您创建的文件。

1121
01:22:24,450 --> 01:22:28,580
而作为一个面具，基本上它说，你不设置的位。

1122
01:22:28,580 --> 01:22:30,450
这是如何成为位？

1123
01:22:30,450 --> 01:22:33,240
如果您认为所有这些作为一个八进制数，

1124
01:22:33,240 --> 01:22:42,120
这是1秒位，这是2秒，这是4秒。

1125
01:22:42,120 --> 01:22:45,840
所以0到7

1126
01:22:45,840 --> 01:22:51,770
将描述什么样的组合存在的R，W的，而x的你有这些3

1127
01:22:51,770 --> 01:22:53,710
然后同样数量的这些，然后对这些。

1128
01:22:53,710 --> 01:23:12,030
因此，022表示为0外，2组，2为用户。

1129
01:23:12,030 --> 01:23:15,870
但是，这是一个面具。面具是你没有的东西。

1130
01:23:19,380 --> 01:23:20,610
对不起。我只是给你的东西在错误的顺序。

1131
01:23:20,610 --> 01:23:25,620
这是第3。这3个是用户，这3个都是群，这3个是其他。

1132
01:23:25,620 --> 01:23:27,970
对不起，我错了顺序给你这些。

1133
01:23:27,970 --> 01:23:31,910
的0，这是第一个的那些，不显示该值，

1134
01:23:31,910 --> 01:23:35,430
但如果一个数字是不存在的，它是一个0。

1135
01:23:35,430 --> 01:23:38,370
这意味着所有3这些将被允许。

1136
01:23:38,370 --> 01:23:41,550
注意，在这个特定的一个的X是不允许的。

1137
01:23:41,550 --> 01:23:44,090
其原因是，外​​壳是能够确定的

1138
01:23:44,090 --> 01:23:46,260
文件是否应执行与否。

1139
01:23:46,260 --> 01:23:49,800
因为这不是一个可执行文件，它没有设置x。

1140
01:23:49,800 --> 01:23:54,000
2方法，在这里写权限，第二类，

1141
01:23:54,000 --> 01:23:56,500
一个在中间，被拒绝。

1142
01:23:56,500 --> 01:23:58,500
所以，再一次，这些都是东西，它否认。

1143
01:23:58,500 --> 01:24:02,080
那么，x被允许的，但它不是在这里，因为它不是可执行

1144
01:24:02,080 --> 01:24:04,260
并且类似的其他人。

1145
01:24:04,260 --> 01:24:08,880
所以这是一个常见的​​umask。

1146
01:24:08,880 --> 01:24:14,630
另一个常见的​​一种是700  - 给自己的一切，没有人任何东西。

1147
01:24:14,630 --> 01:24:17,040
而且还有其他的可能性。

1148
01:24:21,340 --> 01:24:27,110
我会回去的。使用历史，我可以搜索回来的，长宽高到那里。

1149
01:24:27,110 --> 01:24:30,210
好吧。所以在这里，这些都是炮弹。

1150
01:24:30,210 --> 01:24:36,020
猛砸，车主是谁的系统帐户，可以做任何事情。

1151
01:24:36,020 --> 01:24:41,210
集团和其他人可以做读或执行，但不能写入。

1152
01:24:41,210 --> 01:24:44,570
这其中甚至没有让主人来写它。

1153
01:24:44,570 --> 01:24:46,460
如果业主想写它，系统帐户，

1154
01:24:46,460 --> 01:24:48,020
他必须首先改变的保护。

1155
01:24:48,020 --> 01:24:53,940
但同样，umask的通过屏蔽它设置默认值，

1156
01:24:53,940 --> 01:24:57,160
通过指示将不会被设置的位。

1157
01:24:57,160 --> 01:25:04,380
这通常是在你的初始化文件之一，它是的。cshrc为C壳

1158
01:25:04,380 --> 01:25:07,500
或者，天寒Bourne类型的炮弹。

1159
01:25:07,500 --> 01:25:12,520
它可以是别处也如果有系统上的其他初始化文件。

1160
01:25:12,520 --> 01:25:14,610
无论如何，这是的umask。

1161
01:25:14,610 --> 01:25:18,180
还有一些那种奇怪在这里，

1162
01:25:18,180 --> 01:25:22,800
那就是，为什么有一个单一的命令呢？

1163
01:25:22,800 --> 01:25:28,690
如果我写这个，我想使它成为一个变量来说，umask =一定的价值。

1164
01:25:28,690 --> 01:25:31,100
为什么有一个整体的命令只是为了这个目的？

1165
01:25:31,100 --> 01:25:34,560
原因是这只是又回到了Unix的起源。

1166
01:25:34,560 --> 01:25:41,050
Unix的只是一些编程项目在贝尔实验室在70年代初期。

1167
01:25:41,050 --> 01:25:42,610
人们只是聚在一起的程序。

1168
01:25:42,610 --> 01:25:45,290
他们从来没有打算让它成为一个世界性的操作系统。

1169
01:25:45,290 --> 01:25:47,250
不同的人写不同部分不假思索非常

1170
01:25:47,250 --> 01:25:49,790
如何自己将要被使用 - 比较简略。

1171
01:25:49,790 --> 01:25:53,290
它走到了一起这样，它仍然像在某些方面。

1172
01:25:53,290 --> 01:25:57,930
因此，反映了历史，并且仍然有这些矛盾和它的奇怪的元素。

1173
01:25:57,930 --> 01:26:00,750
好吧。这里下一个。

1174
01:26:08,170 --> 01:26:11,000
正如我前面写的C壳是不是真的用得非常多的编程，

1175
01:26:11,000 --> 01:26:12,420
虽然它可以是。

1176
01:26:12,420 --> 01:26:15,080
它执行更慢，再交互使用之间的权衡，

1177
01:26:15,080 --> 01:26:17,820
其中有涉及比速度更多的处理，

1178
01:26:17,820 --> 01:26:20,710
它可以不用处理。

1179
01:26:20,710 --> 01:26:28,320
由Korn和伯恩 - 弹再次加入到Bourne shell中的额外功能

1180
01:26:28,320 --> 01:26:32,120
似乎并没有慢下来，我不知道这是为什么。

1181
01:26:32,120 --> 01:26:36,310
它可能只是更好的编程，但我不是在一个位置就知道了。

1182
01:26:36,310 --> 01:26:40,420
这里的速度其实并不是什么大不了的，虽然它被提及。

1183
01:26:40,420 --> 01:26:43,690
其原因是shell脚本实际上得到较快。

1184
01:26:43,690 --> 01:26:46,450
如果有很多像命令的程序量的计算，

1185
01:26:46,450 --> 01:26:49,110
你可能不会在shell脚本做到这一点。

1186
01:26:49,110 --> 01:26:51,450
该操作还有相当简单明了。

1187
01:26:51,450 --> 01:26:53,960
我已经经历过的那些是太慢

1188
01:26:53,960 --> 01:26:57,110
涉及缓慢命令的重复应用。

1189
01:26:57,110 --> 01:27:00,480
刚才我提到的sed流编辑器。该命令是缓慢的。

1190
01:27:00,480 --> 01:27:03,760
如果你执行的sed很多次了，你会得到一个缓慢的脚本，但它不是shell，它是缓慢的。

1191
01:27:03,760 --> 01:27:07,920
在Bourne shell中运行它不会比在C-shell中运行它要快得多，

1192
01:27:07,920 --> 01:27:10,070
虽然有可能一些优势在那里。

1193
01:27:10,070 --> 01:27:12,760
额外的编程能力，另一方面，

1194
01:27:12,760 --> 01:27:17,920
有显著的原因，你会使用Bourne类型的炮弹。

1195
01:27:17,920 --> 01:27:21,390
C-shell有奇怪的特性，它 - 

1196
01:27:21,390 --> 01:27:25,250
事实上，你不知道，如果一个变量是一个shell变量或环境变量。

1197
01:27:25,250 --> 01:27:27,440
它可以是非常混乱。

1198
01:27:27,440 --> 01:27:32,170
这不是那么容易写

1199
01:27:32,170 --> 01:27:35,930
只是根据你在其他语言的编程经验。

1200
01:27:35,930 --> 01:27:41,350
我想你可能会发现Bourne类型的炮弹与您体验更加一致。

1201
01:27:43,730 --> 01:27:49,270
一些脚本，不过，可以在成千上万行的长度的。

1202
01:27:49,270 --> 01:27:52,450
那些我见过的用于修补操作系统。

1203
01:27:52,450 --> 01:27:55,450
那些可以执行很慢，但是你不运行这些非常频繁。

1204
01:27:55,450 --> 01:27:57,180
只有当你在做修补，

1205
01:27:57,180 --> 01:27:59,450
而且只有系统管理员谁做的那些事，

1206
01:27:59,450 --> 01:28:01,840
所以它不是一个真正大问题。

1207
01:28:01,840 --> 01:28:06,980
那些数百行的长期实际执行相当迅速。

1208
01:28:06,980 --> 01:28:10,540
这里提到这一点，那些是什么改进？

1209
01:28:10,540 --> 01:28:13,170
我已经提到其中的几个 - 阵列，计算，

1210
01:28:13,170 --> 01:28:20,540
在$（）表达式的计算在Bash shell中，

1211
01:28:20,540 --> 01:28:23,050
另一种命令替换的。

1212
01:28:23,050 --> 01:28:25,360
有不同类型的测试命令

1213
01:28:25,360 --> 01:28:29,350
通过它可以对文件或其他东西的存在做条件测试。

1214
01:28:29,350 --> 01:28:34,790
最后在这里，在这里此命令。

1215
01:28:34,790 --> 01:28:38,480
这是什么做的，为什么会有人用吗？

1216
01:28:51,170 --> 01:28:52,990
printenv的变量名。

1217
01:28:52,990 --> 01:28:56,130
我们知道printenv的一样。它告诉我们一个变量的值。

1218
01:28:56,130 --> 01:29:00,850
和printenv的变量名不会告诉我们很多，因为没有这样的变量。

1219
01:29:03,550 --> 01:29:05,120
空白。

1220
01:29:05,120 --> 01:29:08,440
但是，让我们给它一些有意义的事情。

1221
01:29:13,420 --> 01:29:16,800
那是不是有两种。好吧。我想我从来没有定义的。

1222
01:29:16,800 --> 01:29:18,020
让我们只检查我的环境。

1223
01:29:18,020 --> 01:29:20,900
这是另一个命令，通过它可以检查你的环境。

1224
01:29:20,900 --> 01:29:24,470
有很好的老编辑，我们之前看到的那个。

1225
01:29:42,360 --> 01:29:44,120
那是什么呢？

1226
01:29:44,120 --> 01:29:48,050
在这里，我们有一个反引号表达。

1227
01:29:48,050 --> 01:29:50,370
请记住这是C壳。

1228
01:29:50,370 --> 01:29:54,850
所以printenv的编辑器会给我们EDITOR的值。这是六。

1229
01:29:54,850 --> 01:29:59,790
然后它会将该值设置为变量a，set命令。

1230
01:29:59,790 --> 01:30:02,860
所以，现在如果我做回声美元，我得到六。

1231
01:30:02,860 --> 01:30:05,850
这似乎并不十分有用。

1232
01:30:05,850 --> 01:30:08,080
然而，它实际上有一个目的。

1233
01:30:08,080 --> 01:30:12,260
由于我们不知道一个变量是否是一个shell变量或环境变量

1234
01:30:12,260 --> 01:30:16,280
通过使用美元符号评价语法，我们可以使用printenv的

1235
01:30:16,280 --> 01:30:19,460
以确保它是一个环境变量。

1236
01:30:19,460 --> 01:30:22,550
所以，如果有一个shell变量编辑器，这会不会得到它。

1237
01:30:22,550 --> 01:30:25,640
这仅适用于环境变量。

1238
01:30:25,640 --> 01:30:28,370
如果有一个shell变量，我想它的价值，

1239
01:30:28,370 --> 01:30:29,980
我必须找到一些其他的方法来做到这一点。

1240
01:30:29,980 --> 01:30:33,530
要做到这一点的一种方法是通过做套和管道。

1241
01:30:33,530 --> 01:30:36,130
这是元字符，特殊字符中的一个。

1242
01:30:36,130 --> 01:30:38,370
它发送组的输出到别的东西。

1243
01:30:38,370 --> 01:30:40,650
让我们来看看我们可能会发现在那里。

1244
01:30:40,650 --> 01:30:49,340
什么都没有。好吧。就让我们看看有什么在那里都在一起。

1245
01:30:49,340 --> 01:30:53,580
这是echo_style，就是我前面提到的。好吧，让我们做到这一点。

1246
01:31:02,460 --> 01:31:06,230
还记得我前面提到的，echo_style

1247
01:31:06,230 --> 01:31:08,410
决定的方式，echo命令将运行。

1248
01:31:08,410 --> 01:31:10,940
BSD代表伯克利标准分布。

1249
01:31:10,940 --> 01:31:13,200
这是伯克利的Unix从20世纪70年代。

1250
01:31:13,200 --> 01:31:16,630
这是呼应可以运行的方式之一。

1251
01:31:16,630 --> 01:31:22,310
在TC壳设置echo_style该值将导致回波的行为是那样。

1252
01:31:22,310 --> 01:31:27,670
这样设置确实如此，但设置只得到shell变量。

1253
01:31:27,670 --> 01:31:35,430
它不会找到的编辑器，这是不是一个shell变量。

1254
01:31:36,870 --> 01:31:38,050
什么都没有。

1255
01:31:38,050 --> 01:31:39,660
所以这是区分它们的一种方法。

1256
01:31:39,660 --> 01:31:42,000
但是，你有一个事实要经过一些奇怪的命令一样，

1257
01:31:42,000 --> 01:31:45,500
shell变量或环境变量来区分

1258
01:31:45,500 --> 01:31:49,970
显示了一种在C-外壳为了某种目的的不切实际的性质。

1259
01:31:52,290 --> 01:31:57,960
而现在，最后，也许至少，这是手册页。

1260
01:31:57,960 --> 01:32:03,190
那些你可能知道是谁的，男人是命令缩写手册。

1261
01:32:03,190 --> 01:32:08,610
该手册页的炮弹是难以阅读。他们是很长的。

1262
01:32:08,610 --> 01:32:14,060
他们是有组织的方式，可能使其很难找到你要找的内容。

1263
01:32:14,060 --> 01:32:15,980
所以，如果你正在寻找一些有目的的，

1264
01:32:15,980 --> 01:32:20,050
你可能不知道，如果这个目的是一个shell变量或别的东西，

1265
01:32:20,050 --> 01:32:21,630
所以你可能不知道到哪里寻找它。

1266
01:32:21,630 --> 01:32:25,030
你可以找不同的字符串，但字符串经常重复。

1267
01:32:25,030 --> 01:32:27,640
所以它一般难以阅读。

1268
01:32:27,640 --> 01:32:33,810
我们只是看着有点过了TC壳手册页找到eval命令。

1269
01:32:33,810 --> 01:32:36,610
有些事情走得更快。

1270
01:32:36,610 --> 01:32:38,860
一种方法是将搜索字符串。

1271
01:32:38,860 --> 01:32:40,360
您可以使用寻呼机。

1272
01:32:40,360 --> 01:32:49,080
寻呼机有斜线寻找一个命令或一个字符串寻呼机操作里面。

1273
01:32:49,080 --> 01:32:52,830
男人在默认情况下会使用传呼机，或者是更多或更少。

1274
01:32:52,830 --> 01:32:56,560
我不知道你是否熟悉这些，但这些可以通过位显示文件位。

1275
01:32:56,560 --> 01:33:00,550
我一直在使用较少，显示现在我们得到的这些特定的文件。

1276
01:33:00,550 --> 01:33:03,300
你可以在里面搜索那里。

1277
01:33:03,300 --> 01:33:04,880
您可以尝试使用不同的搜索字符串。

1278
01:33:04,880 --> 01:33:08,420
还man页在不同的操作系统可能不一样。

1279
01:33:08,420 --> 01:33:11,130
它们可以是对于csh和tcsh单独的页面。

1280
01:33:11,130 --> 01:33:14,500
他们是不是在Mac上，但他们可能是，如果那些是独立的命令。

1281
01:33:14,500 --> 01:33:19,000
如果SH并没有真正叫击，有可能是一个单独的手册页。

1282
01:33:19,000 --> 01:33:25,820
有些系统有单独的手册页只用于C-shell内置命令。

1283
01:33:25,820 --> 01:33:30,250
有时，如果你想读一个内置的命令的说明

1284
01:33:30,250 --> 01:33:35,350
这也是在路径中，如回声，你需要阅读的手册页上的回声命令的

1285
01:33:35,350 --> 01:33:37,610
以确定它将如何工作作为一个内置的命令

1286
01:33:37,610 --> 01:33:39,760
即使你不调用内置的命令。

1287
01:33:41,630 --> 01:33:46,090
这是操作系统的一个缺点在一般情况下，不仅为壳，

1288
01:33:46,090 --> 01:33:50,710
虽然供弹特别的手册页很长，

1289
01:33:50,710 --> 01:33:56,180
部分原因是他们已经增加实用的功能对他们来说，这可能是一个利好。

1290
01:33:56,180 --> 01:34:00,290
好吧。有没有问题？你想提出什么议题？

1291
01:34:00,290 --> 01:34:03,390
与此有关什么？

1292
01:34:04,540 --> 01:34:07,100
好吧，它已经很高兴与你交谈的所有。

1293
01:34:07,100 --> 01:34:09,690
我希望你有东西出来这个研讨会

1294
01:34:09,690 --> 01:34:13,080
这将在你未来的事业对您有用。

1295
01:34:17,330 --> 01:34:19,000
[CS50.TV]