1
00:00:07,060 --> 00:00:08,420
[Powered by Google Translate] TOMMY：在這個視頻中，我們將了解

2
00:00:08,420 --> 00:00:10,140
重定向和管道。

3
00:00:10,140 --> 00:00:12,780
到目前為止，我們一直在使用的功能，如printf來

4
00:00:12,780 --> 00:00:15,590
輸出到終端的數據和功能類似的GetString

5
00:00:15,590 --> 00:00:17,520
以允許用戶提供輸入到我們的

6
00:00:17,520 --> 00:00:19,490
程序中使用的鍵盤。

7
00:00:19,490 --> 00:00:21,880
讓我們趕緊來看看一個程序，得到了行

8
00:00:21,880 --> 00:00:25,960
來自用戶的輸入，然後將其輸出。

9
00:00:25,960 --> 00:00:28,990
>> 在第7行，我們提示用戶輸入一個字符串，並

10
00:00:28,990 --> 00:00:31,680
然後在第8行，我們要打印退了出去。

11
00:00:31,680 --> 00:00:35,220
讓編譯和運行我們的程序。

12
00:00:35,220 --> 00:00:35,900
大。

13
00:00:35,900 --> 00:00:37,620
我們所提供的字符串被回

14
00:00:37,620 --> 00:00:39,170
我們在終端。

15
00:00:39,170 --> 00:00:42,110
這是因為printf函數寫信給

16
00:00:42,110 --> 00:00:46,220
流稱為標準輸出，S-T-D-OUT。

17
00:00:46,220 --> 00:00:49,230
當事情寫入到標準輸出，默認情況下，

18
00:00:49,230 --> 00:00:51,110
顯示由該終端。

19
00:00:51,110 --> 00:00:53,720
>> 所以，這一切都很好，但如果，而不是簡單地

20
00:00:53,720 --> 00:00:57,700
顯示字符串，我們希望將它保存到一個文件？

21
00:00:57,700 --> 00:01:00,470
例如，我們可能要記得正是我們的

22
00:01:00,470 --> 00:01:04,450
程序的時候，我們給了它一個特定的輸入後。

23
00:01:04,450 --> 00:01:07,270
有一種方法可以做到這一點在我們的C程序中，使用

24
00:01:07,270 --> 00:01:09,680
寫入文件的一些特殊功能，我們將

25
00:01:09,680 --> 00:01:11,270
看到在另一個視頻。

26
00:01:11,270 --> 00:01:13,260
雖然，更容易，以某種方式將

27
00:01:13,260 --> 00:01:16,090
重定向標準輸出到一個文件中。

28
00:01:16,090 --> 00:01:19,780
這樣一來，當printf寫入到stdout，其內容將

29
00:01:19,780 --> 00:01:21,720
被寫入文件，而不是

30
00:01:21,720 --> 00:01:23,410
顯示由該終端。

31
00:01:23,410 --> 00:01:26,690
我們可以做到這一點，添加一個大於號，

32
00:01:26,690 --> 00:01:30,820
一個文件名，命令，我們執行我們的程序。

33
00:01:30,820 --> 00:01:34,730
>> 因此，而不是簡單地執行。/重定向，我們可以

34
00:01:34,730 --> 00:01:38,880
運行。/重定向，一個大於號，

35
00:01:38,880 --> 00:01:41,530
名，例如file.txt的。

36
00:01:41,530 --> 00:01:44,290
讓我們看看會發生什麼。

37
00:01:44,290 --> 00:01:45,130
OK。

38
00:01:45,130 --> 00:01:48,470
請注意，這時候，什麼也沒有顯示在終端上，

39
00:01:48,470 --> 00:01:50,290
但我們並沒有修改的內容，我們

40
00:01:50,290 --> 00:01:52,040
在所有的C程序。

41
00:01:52,040 --> 00:01:56,090
現在，讓我們來檢查使用ls這個目錄的內容。

42
00:01:56,090 --> 00:01:56,630
>> 好的。

43
00:01:56,630 --> 00:02:00,840
我們現在有一個新的名為file.txt的文件，在我們的目錄，

44
00:02:00,840 --> 00:02:03,640
這是我們提供的文件名，當我們運行我們的

45
00:02:03,640 --> 00:02:05,050
重定向程序。

46
00:02:05,050 --> 00:02:08,020
讓我們打開file.txt的。

47
00:02:08,020 --> 00:02:11,840
在這裡，我們可以看到，標準輸出重定向

48
00:02:11,840 --> 00:02:15,550
寫入文件名為file.txt的。

49
00:02:15,550 --> 00:02:18,470
因此，讓我們再次運行前面的命令，但提供一個

50
00:02:18,470 --> 00:02:20,075
不同的輸入時間。

51
00:02:25,140 --> 00:02:25,900
好吧。

52
00:02:25,900 --> 00:02:28,205
讓我們來看看在file.txt的。

53
00:02:31,070 --> 00:02:34,580
>> 在這裡，我們可以看到該文件已被覆蓋，所以我們

54
00:02:34,580 --> 00:02:37,120
原來的輸入是不存在了。

55
00:02:37,120 --> 00:02:40,280
如果我們不是要追加到這個文件，把新的

56
00:02:40,280 --> 00:02:43,600
輸入下面的現有文件的內容，我們可以

57
00:02:43,600 --> 00:02:46,800
使用兩個大於符號，而不是只有一個。

58
00:02:46,800 --> 00:02:48,050
讓我們試試吧。

59
00:02:52,160 --> 00:02:57,910
現在，如果我們再次打開file.txt的，我們可以看到我們的

60
00:02:57,910 --> 00:02:59,580
輸入線。

61
00:02:59,580 --> 00:03:02,180
在某些情況下，我們可能要放棄任何

62
00:03:02,180 --> 00:03:03,850
輸出我們的計劃。

63
00:03:03,850 --> 00:03:06,450
而不是寫輸出到一個文件，然後刪除

64
00:03:06,450 --> 00:03:09,310
我們已經完成了它的文件時，我們可以寫一個特殊的

65
00:03:09,310 --> 00:03:12,360
文件名為/ dev / null的。

66
00:03:12,360 --> 00:03:15,160
什麼是寫入/ dev/null--

67
00:03:15,160 --> 00:03:16,960
或只是devnull短 - 

68
00:03:16,960 --> 00:03:18,950
它被自動丟棄。

69
00:03:18,950 --> 00:03:23,290
因此，認為devnull的黑洞，為您的數據。

70
00:03:23,290 --> 00:03:26,070
>> 所以，現在我們已經看到了如何用大於號可以重定向

71
00:03:26,070 --> 00:03:29,610
標準輸出，讓我們看看如何可以重定向標準 - 

72
00:03:29,610 --> 00:03:31,250
或s-叔的d  - 

73
00:03:31,250 --> 00:03:33,550
標準輸出的模擬。

74
00:03:33,550 --> 00:03:36,010
雖然功能同於printf寫的流稱為

75
00:03:36,010 --> 00:03:40,500
從流中讀取標準輸出，的GetString和類似功能

76
00:03:40,500 --> 00:03:43,770
稱為stdin，默認情況下，是流

77
00:03:43,770 --> 00:03:46,290
在鍵盤上輸入的字符。

78
00:03:46,290 --> 00:03:50,010
使用小於號，我們可以重定向標準輸入，

79
00:03:50,010 --> 00:03:51,370
一個文件名。

80
00:03:51,370 --> 00:03:54,000
現在，而不是在提示用戶輸入

81
00:03:54,000 --> 00:03:57,870
終端，程序將打開我們指定的文件，並使用

82
00:03:57,870 --> 00:03:59,790
它的線條作為輸入。

83
00:03:59,790 --> 00:04:02,620
>> 讓我們看看會發生什麼。

84
00:04:02,620 --> 00:04:03,280
大。

85
00:04:03,280 --> 00:04:07,590
的第一行file.txt的已印到終端

86
00:04:07,590 --> 00:04:10,160
因為我們調用GetString的一次。

87
00:04:10,160 --> 00:04:13,170
如果我們有另一個在我們的程序中調用GetString的，

88
00:04:13,170 --> 00:04:16,149
file.txt的下一行已被用來作為

89
00:04:16,149 --> 00:04:17,990
輸入到該呼叫。

90
00:04:17,990 --> 00:04:21,050
同樣，我們沒有改變我們的C程序在所有。

91
00:04:21,050 --> 00:04:23,620
我們只是改變了我們運行它。

92
00:04:23,620 --> 00:04:27,080
還記得，我們​​沒有重定向標準輸出時間，

93
00:04:27,080 --> 00:04:28,970
所以輸出的程序的時間是仍

94
00:04:28,970 --> 00:04:31,040
顯示在終端上。

95
00:04:31,040 --> 00:04:33,500
當然，我們可以都重定向標準輸入

96
00:04:33,500 --> 00:04:37,320
和stdout是這樣的。

97
00:04:37,320 --> 00:04:43,550
現在，file2.txt包含file.txt的的第一行。

98
00:04:43,550 --> 00:04:46,140
>> 因此，使用這些運營商，我們已經能夠閱讀和

99
00:04:46,140 --> 00:04:48,130
寫文本文件。

100
00:04:48,130 --> 00:04:51,890
現在，讓我們來看看如何，我們可以使用一個程序的輸出

101
00:04:51,890 --> 00:04:54,710
另一個程序的輸入。

102
00:04:54,710 --> 00:04:56,650
因此，這裡是另一個簡單的C程序，我

103
00:04:56,650 --> 00:05:00,190
這裡有名為hello.c。

104
00:05:00,190 --> 00:05:02,617
正如你可以看到，這只是輸出“嗨，

105
00:05:02,617 --> 00:05:04,430
那裡！“給用戶。

106
00:05:04,430 --> 00:05:08,890
如果我想重定向到使用作為輸入輸出的Hello  - 

107
00:05:08,890 --> 00:05:10,190
另一種方案 - 

108
00:05:10,190 --> 00:05:13,920
我可以先輸出重定向到一個文件名為hello的

109
00:05:13,920 --> 00:05:18,960
INPUT.TXT，然後重定向標準輸入重定向到相同的

110
00:05:18,960 --> 00:05:21,190
文件 -  INPUT.TXT。

111
00:05:21,190 --> 00:05:26,730
所以我可以做。/你好INPUT.TXT。

112
00:05:26,730 --> 00:05:28,810
按Enter鍵執行。

113
00:05:28,810 --> 00:05:31,910
其次/重定向<

114
00:05:31,910 --> 00:05:35,270
INPUT.TXT，並執行它。

115
00:05:35,270 --> 00:05:38,290
因此，我們可以縮短這個有點用分號，這使得

116
00:05:38,290 --> 00:05:41,360
我們在同一行上運行兩個或多個命令。

117
00:05:41,360 --> 00:05:47,920
所以我可以說，。/你好INPUT.TXT，分號，

118
00:05:47,920 --> 00:05:50,580
/重定向<INPUT.TXT。

119
00:05:53,850 --> 00:05:56,740
>> 所以這個作品，但它仍然感覺非常不雅。

120
00:05:56,740 --> 00:05:59,530
我的意思是，我們真的需要這種中介的文本文件，該文件

121
00:05:59,530 --> 00:06:02,520
重定向運行後，不再需要嗎？

122
00:06:02,520 --> 00:06:05,780
幸運的是，我們可以避免這種額外的文本文件，使用的是什麼

123
00:06:05,780 --> 00:06:07,220
稱為管道。

124
00:06:07,220 --> 00:06:13,740
如果我說/你好| /重定向，然後在標準輸出

125
00:06:13,740 --> 00:06:15,310
在左邊的程序 - 

126
00:06:15,310 --> 00:06:16,740
在這種情況下，你好 - 

127
00:06:16,740 --> 00:06:18,970
將被用作標準輸入

128
00:06:18,970 --> 00:06:20,370
程序上的權利。

129
00:06:20,370 --> 00:06:24,850
在這種情況下，重定向。因此，讓我們運行這個。

130
00:06:24,850 --> 00:06:25,930
>> 我們走吧。

131
00:06:25,930 --> 00:06:30,080
我們可以看到，作為輸入輸出的Hello

132
00:06:30,080 --> 00:06:31,520
為重定向。

133
00:06:31,520 --> 00:06:34,890
拉絲命令一起使用管道，我們形成什麼

134
00:06:34,890 --> 00:06:38,120
所謂的管道，因為我們的產量基本上是移動

135
00:06:38,120 --> 00:06:40,590
通過一個命令序列。

136
00:06:40,590 --> 00:06:43,570
使用管道，我們可以做一些很酷的東西，而不需要

137
00:06:43,570 --> 00:06:45,870
寫任何代碼。

138
00:06:45,870 --> 00:06:48,760
例如，讓我們說，我們想知道有多少文件

139
00:06:48,760 --> 00:06:50,630
這個目錄裡面。

140
00:06:50,630 --> 00:06:55,200
使用管道，我們可以將ls命令與WC  - 

141
00:06:55,200 --> 00:06:56,460
或wordcount的 - 

142
00:06:56,460 --> 00:06:57,850
命令。

143
00:06:57,850 --> 00:07:02,230
ls將輸出到標準輸出的目錄中的每個文件，並

144
00:07:02,230 --> 00:07:08,040
廁所會告訴我們有多少行，它通過標準輸入。

145
00:07:08,040 --> 00:07:12,440
所以，如果我們說LS WC-L  - 

146
00:07:12,440 --> 00:07:16,800
到wc-l標誌，告訴它計算行數 - 

147
00:07:16,800 --> 00:07:19,260
我們可以看到到底有多少文件

148
00:07:19,260 --> 00:07:21,940
在當前目錄中。

149
00:07:21,940 --> 00:07:24,570
>> 因此，讓我們來看看一個例子。

150
00:07:24,570 --> 00:07:27,740
我這裡有一個名為students.txt，

151
00:07:27,740 --> 00:07:29,600
的名稱的列表。

152
00:07:29,600 --> 00:07:32,730
但是，這些名稱都沒有任何順序，它的外觀

153
00:07:32,730 --> 00:07:34,850
像幾個名字是重複的。

154
00:07:34,850 --> 00:07:38,510
我們要的是一個唯一的名稱列表按字母

155
00:07:38,510 --> 00:07:42,550
為了保存到一個名為final.txt。

156
00:07:42,550 --> 00:07:45,210
當然，我們可以寫一個C程序來為我們做這。

157
00:07:45,210 --> 00:07:46,560
但它會得到不必要的

158
00:07:46,560 --> 00:07:48,560
複雜的很快。

159
00:07:48,560 --> 00:07:51,740
讓我們，而不是使用管道和一些內置的工具來解決

160
00:07:51,740 --> 00:07:53,300
這個問題。

161
00:07:53,300 --> 00:07:57,760
>> 我們需要做的第一件事情是讀取該文件students.txt。

162
00:07:57,760 --> 00:08:00,530
cat命令將做到這一點。

163
00:08:00,530 --> 00:08:03,230
這將在指定的文件中讀取和寫入

164
00:08:03,230 --> 00:08:05,750
其內容輸出到stdout。

165
00:08:05,750 --> 00:08:07,570
我們已經閱讀過的文本文件後，我們會

166
00:08:07,570 --> 00:08:09,490
要排序的名稱。

167
00:08:09,490 --> 00:08:12,510
sort命令可以處理給我們看。

168
00:08:12,510 --> 00:08:16,830
的排序將輸出線通過提供標準輸入到標準輸出（stdout）

169
00:08:16,830 --> 00:08:19,310
在排序順序。

170
00:08:19,310 --> 00:08:23,450
為了提供內容students.txt

171
00:08:23,450 --> 00:08:29,600
排序的stdin，我們可以使用一個管結合貓和排序。

172
00:08:29,600 --> 00:08:34,440
所以，我可以執行cat students.txt的排序|和

173
00:08:34,440 --> 00:08:35,640
然後按Enter鍵。

174
00:08:35,640 --> 00:08:39,309
而現在，我們看到的內容students.txt

175
00:08:39,309 --> 00:08:40,909
按字母順序排列。

176
00:08:40,909 --> 00:08:42,860
>> 所以，讓我們添加另一個命令 - 

177
00:08:42,860 --> 00:08:44,730
uniq的，或獨特的 - 

178
00:08:44,730 --> 00:08:46,230
我們的管道。

179
00:08:46,230 --> 00:08:49,810
正如你可能已經猜到，uniq中，提供了一個排序序列

180
00:08:49,810 --> 00:08:53,650
線通過標準輸入，輸出的獨特線條。

181
00:08:53,650 --> 00:08:56,910
所以現在我們有貓students.txt

182
00:08:56,910 --> 00:09:00,040
|排序| uniq的。

183
00:09:00,040 --> 00:09:03,330
最後，我們可以節省的管道輸出到

184
00:09:03,330 --> 00:09:09,090
貓students.txt |排序| uniq的文件通過

185
00:09:09,090 --> 00:09:12,440
> final.txt。

186
00:09:12,440 --> 00:09:16,260
所以，如果我們打開了final.txt的，我們有什麼，我們

187
00:09:16,260 --> 00:09:17,270
尋找：

188
00:09:17,270 --> 00:09:20,180
唯一的名稱按字母順序排列的列表，

189
00:09:20,180 --> 00:09:22,150
保存到一個文本文件中。

190
00:09:22,150 --> 00:09:26,020
順便說一下，我們也可以說排序<

191
00:09:26,020 --> 00:09:32,290
students.txt | uniq的final.txt做到底

192
00:09:32,290 --> 00:09:35,400
同樣的事情，我們已經看到在使用每個運營商

193
00:09:35,400 --> 00:09:36,580
這部影片。

194
00:09:36,580 --> 00:09:39,540
>> 我的名字是湯米，這是CS50。