1
00:00:00,000 --> 00:00:02,320
[Powered by Google Translate] [研討會 -  Unix的砲彈，環境]

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
我是道格拉斯·克萊恩，專家，或者至少是合理的主管用戶的外殼。

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原來的shell是Bourne shell的。

11
00:00:44,500 --> 00:00:46,450
伯恩拼寫B-O-U-R-N-ê。

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
當您登錄到計算機時，外殼為你剛開始運行，

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
當事情開始像這樣，它不會啟動新的外殼。

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
在這種情況下，它不會是一個shell。

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是初始殼。

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
在20世紀70年代中期引入這個shell的Berkeley Unix。

58
00:03:41,260 --> 00:03:44,830
伯克利的Unix在Unix的發展是一個開創性的事件。

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

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編程。

74
00:04:37,020 --> 00:04:39,080
殼牌計劃，如果你還不知道，

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-外殼是曖昧的，因為它可能只是指原來的C殼，長山壕，

80
00:04:57,320 --> 00:05:01,200
或將所有的C-砲彈，包括tcsh在內。這是一個有點曖昧。

81
00:05:01,200 --> 00:05:08,250
>> 後殼是Korn shell，請ksh的，程序員而得名，光輝。

82
00:05:08,250 --> 00:05:14,160
這個shell試圖納入1殼

83
00:05:14,160 --> 00:05:16,960
的優點為C shell交互使用

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 shell的也是。他們兩人都是。

89
00:05:43,830 --> 00:05:48,100
它具有相同的目標Korn shell的合併的C殼

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
bash中，但是，有更多的，因此是優選的。

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
除了這些還有其他的砲彈，一些旨在限制使用，

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相關的另一個原因是與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外殼或猛砸。

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 shell的腳本可能會運行bash下，但我不能保證。

114
00:07:30,610 --> 00:07:36,040
後來就到這裡，C-shell腳本應該運行下TC殼。

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的或伯恩再次殼之前進行了介紹。

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
比方說，你已經寫了一個腳本，它是一個特定的殼，你要運行它。

172
00:11:27,760 --> 00:11:33,500
你怎麼知道你的操作系統將使用什麼殼運行腳本？

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 shell中，多了

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
指定的shell中運行腳本。

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
與/ bin / bash的特定的計算機上有沒有這樣的事情，

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

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
是通過在命令行上指定的殼一樣，這裡。

207
00:13:45,910 --> 00:13:52,510
這是一個命令。這說運行B​​ash和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
符線可以調用任何外殼。

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
笨拙，這是一個模式處理語言;

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腳本調用的awk或sed shell腳本

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
它可以是同一個文件或一個文件，其目的是指到另一個文件名稱。

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或猛砸，

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
即使它不是bash，類似於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
擁有的東西，以表明他們是哪個殼 -  CSH時，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
最後一個字段，你可以看到的，是bin / 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
實際上並不總是可靠的方法來確定你正在運行什麼殼，

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-殼運行將執行其自己的代碼的一部分

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。

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
殼。

348
00:24:06,460 --> 00:24:11,790
Bourne類型的砲彈，尤其是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
Bourne類型的砲彈會執行得更快

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 shell的這些東​​西，

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克*'

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克*，我會得到我的當前目錄下的所有這些名字的列表。

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
它會評估通配符克*當運行定義命令。

396
00:27:09,620 --> 00:27:14,400
因此，定義的別名將是ls目錄中的文件列表

397
00:27:14,400 --> 00:27:16,310
alias命令被執行時，

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
另一個控制P，將讓你在這之前的一個。

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
讓我們到這裡，看看我的其他外殼，我們得到了什麼，如果我們做到這一點。

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
這些東西有些是自動定義的殼。

551
00:39:44,330 --> 00:39:49,320
外殼創建變量，並賦予它一個值。

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
因此，設置A =是一個有效的命令。

566
00:41:00,120 --> 00:41:04,370
set命令可以超過1個變量定義在同一行上。

567
00:41:04,370 --> 00:41:11,240
所以這個命令在這裡有定義a和b都為空值的效果。

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
在這裡，這其中一個，有一個值。

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
一個是。它會下降的。o。

583
00:42:10,730 --> 00:42:16,510
如果沒有擴展，只有最後的斜線後的路徑名，將沒有任何影響。

584
00:42:16,510 --> 00:42:27,480
答：h時，該變量的表達式，將起飛目錄列表的最後一個元素，

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

586
00:42:29,660 --> 00:42:33,160
SO / A / B / C成為/ A / B，

587
00:42:33,160 --> 00:42:38,870
但是這一次更改後的名單，因為該元素是空的。

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
這些情況 - 單，雙單裡面的雙內側 - 

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殼的變量，

611
00:44:08,340 --> 00:44:11,250
而且他們也是其他shell中的變量太多。

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
其他的東西都沒有。殼變數，別名都沒有。環境變量。

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
子shell的面積是專門的環境變量

647
00:46:53,260 --> 00:46:56,450
不寫子shell，它通過複製的書面。

648
00:46:56,450 --> 00:47:00,530
當你運行一個普通的命令，這些命令，如打印或什麼的，

649
00:47:00,530 --> 00:47:03,840
他們開始通過創建一個新的外殼。

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參數或參數，

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
記得有修飾符殼變數，如：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殼和shell變量，也有一些例外，不同的集合。

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
這些變量都與美元符號 -  $ A，$任何評價。

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
所以我問你，是創建殼和環境變量

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
長期任期。和那裡。

697
00:50:52,560 --> 00:51:00,570
xterm的終端類型，在X窗口系統顯示的窗口。

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
環境變量用戶。

718
00:52:08,260 --> 00:52:12,070
同樣，環境變量以大寫字母，小寫字母的sh​​ell變量。

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
在這裡，這一個路徑變量，這是一個非常重要的一個。

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
是一個列表的外殼看起來命令的路徑名。

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外殼沒有陣列。

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
所以迴聲路徑[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
而非工作與陣列，shell變量，

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
順便說一下，這些東西，還定義了殼。

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，不帶參數的設置命令做同樣的事情，

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
參數設置命令可以用來操作

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有殼的行為，這將決定的變量。

825
00:59:46,700 --> 00:59:51,310
然後也只是你可能會看到一個命令，這個命令。

826
00:59:51,310 --> 00:59:59,050
排版Korn和Bash的殼中使用的變量和變量類型。

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
其中命令。

831
01:00:19,160 --> 01:00:22,490
還記得我前面提到的命令在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
控制A得到我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
有2種可能在Mac的處理器類型，

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
L是一個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
讀取到內存中，創建一個新的外殼，

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
還有一個變量tcsh的echo_style中定義的一個選項。

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。 t將站在終端集。

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
你還記得我只是表明你有一個Q值在該文件中的命令。

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
去與控制A開頭的行，我該怎麼做。

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
在這裡，我們去評估精氨酸，所以我們可以有1個或多個參數

1069
01:18:31,850 --> 01:18:34,090
那裡的東西，有一個列表。

1070
01:18:34,090 --> 01:18:37,730
黃柏作為輸入參數外殼

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
所以，我們去評估，評估選秀權，開始一遍整個事情，它的工作原理。

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或一個W或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組，為用戶。

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
這意味著所有這些都將被允許。

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
這通常是在一個初始化文件，這是為C殼的。cshrc

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是貝爾實驗室在20世紀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
添加額外的功能是Bourne shell，Korn和伯恩再次彈

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的許多倍，你會得到一個緩慢的腳本，但是它不是貝殼，是緩慢的。

1191
01:27:03,760 --> 01:27:07,920
在Bourne shell中運行它不會有太大的速度比運行在C殼，

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編輯會給我們的編輯器的值。它的VI。

1229
01:29:54,850 --> 01:29:59,790
然後將它設置該變量的值，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
這是從20世紀70年代的Berkeley Unix。

1250
01:31:13,200 --> 01:31:16,630
這是一個呼應的方式，可以運行。

1251
01:31:16,630 --> 01:31:22,310
設置echo_style該值TC殼將導致迴聲的行為是那樣。

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
同樣的人在不同的操作系統中的頁面可能是不一樣的。

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殼內置命令。

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
雖然特別man頁面相當長的供彈，

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]