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]