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。