1
00:00:07,060 --> 00:00:08,420
[Powered by Google Translate] Tommy: W tym filmie dowiemy się o

2
00:00:08,420 --> 00:00:10,140
przekierowanie i rur.

3
00:00:10,140 --> 00:00:12,780
Do tej pory używaliśmy funkcji, takich jak printf

4
00:00:12,780 --> 00:00:15,590
dane wyjściowe do terminalu i funkcje, takie jak getString

5
00:00:15,590 --> 00:00:17,520
, aby umożliwić użytkownikowi wkład do naszej

6
00:00:17,520 --> 00:00:19,490
Program za pomocą klawiatury.

7
00:00:19,490 --> 00:00:21,880
Niech szybko zapoznać się z programem, który pobiera linię

8
00:00:21,880 --> 00:00:25,960
Wejście od użytkownika, a następnie wysyła go.

9
00:00:25,960 --> 00:00:28,990
>> W linii 7, jesteśmy monitowania użytkownika ciąg znaków, a

10
00:00:28,990 --> 00:00:31,680
następnie na linii 8, mamy drukowanie z powrotem.

11
00:00:31,680 --> 00:00:35,220
Załóżmy, skompilować i uruchomić nasz program.

12
00:00:35,220 --> 00:00:35,900
Great.

13
00:00:35,900 --> 00:00:37,620
Ciąg dostarczyliśmy poparło powrotem

14
00:00:37,620 --> 00:00:39,170
do nas na terminalu.

15
00:00:39,170 --> 00:00:42,110
Stało się tak, ponieważ funkcja printf napisał

16
00:00:42,110 --> 00:00:46,220
Strumień z nazywa standardowa lub S-t-d-z.

17
00:00:46,220 --> 00:00:49,230
Kiedy coś jest napisane na stdout, to domyślnie

18
00:00:49,230 --> 00:00:51,110
wyświetlana przez terminal.

19
00:00:51,110 --> 00:00:53,720
>> Więc to jest wszystko dobrze, ale co, jeśli zamiast po prostu

20
00:00:53,720 --> 00:00:57,700
wyświetlania ciąg, chcieliśmy go zapisać do pliku?

21
00:00:57,700 --> 00:01:00,470
Na przykład, chcemy pamiętać właśnie nasz

22
00:01:00,470 --> 00:01:04,450
program zrobił gdy daliśmy mu szczególny wkład później.

23
00:01:04,450 --> 00:01:07,270
Pierwsze podejście do tego w naszym programie C, stosując

24
00:01:07,270 --> 00:01:09,680
pewne specjalne funkcje do pisania do plików, które będziesz

25
00:01:09,680 --> 00:01:11,270
zobaczyć w innym filmie.

26
00:01:11,270 --> 00:01:13,260
Jeszcze łatwiej, choć będzie jakoś

27
00:01:13,260 --> 00:01:16,090
przekierować stdout do pliku.

28
00:01:16,090 --> 00:01:19,780
W ten sposób, kiedy printf pisze do stdout, zawartość będzie

29
00:01:19,780 --> 00:01:21,720
być zapisywane w pliku, a nie

30
00:01:21,720 --> 00:01:23,410
wyświetlana przez terminal.

31
00:01:23,410 --> 00:01:26,690
Można zrobić tak, że przez dodanie znak większości, a następnie

32
00:01:26,690 --> 00:01:30,820
przez nazwę pliku, do polecenia używamy do realizacji naszego programu.

33
00:01:30,820 --> 00:01:34,730
>> Tak więc, zamiast po prostu wykonywać. / Redirect, możemy

34
00:01:34,730 --> 00:01:38,880
uruchom. / przekierowanie, a następnie znak większości, a następnie

35
00:01:38,880 --> 00:01:41,530
filename, jak plik.txt.

36
00:01:41,530 --> 00:01:44,290
Zobaczmy, co się dzieje.

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

38
00:01:45,130 --> 00:01:48,470
Należy zauważyć, że w tym czasie, nic nie wyświetlany w terminalu,

39
00:01:48,470 --> 00:01:50,290
ale nie zostały one zmodyfikowane zawartości naszych

40
00:01:50,290 --> 00:01:52,040
Program C w ogóle.

41
00:01:52,040 --> 00:01:56,090
Przyjrzyjmy się teraz, zawartość tego katalogu z ls.

42
00:01:56,090 --> 00:01:56,630
>> Dobrze.

43
00:01:56,630 --> 00:02:00,840
Mamy teraz nowy plik w naszym katalogu o nazwie plik.txt,

44
00:02:00,840 --> 00:02:03,640
która to nazwa pliku dostarczyliśmy gdy biegaliśmy do naszego

45
00:02:03,640 --> 00:02:05,050
Przekierowanie program.

46
00:02:05,050 --> 00:02:08,020
Otwórzmy się plik.txt.

47
00:02:08,020 --> 00:02:11,840
I tu widać, że stdout z przekierowanie było

48
00:02:11,840 --> 00:02:15,550
zapisywane w pliku o nazwie plik.txt.

49
00:02:15,550 --> 00:02:18,470
Więc uruchomieniu polecenia ponownie, ale dostarczanie

50
00:02:18,470 --> 00:02:20,075
inaczej wejście tym razem.

51
00:02:25,140 --> 00:02:25,900
Okay.

52
00:02:25,900 --> 00:02:28,205
Rzućmy okiem na file.txt teraz.

53
00:02:31,070 --> 00:02:34,580
>> Widzimy tutaj, że plik został nadpisany, więc nasze

54
00:02:34,580 --> 00:02:37,120
Oryginalny wejściowy nie jest już tam.

55
00:02:37,120 --> 00:02:40,280
Jeśli natomiast chcesz dołączyć do tego pliku, stawiając nowy

56
00:02:40,280 --> 00:02:43,600
wejście poniżej istniejących zawartości pliku, możemy

57
00:02:43,600 --> 00:02:46,800
zastosować dwie większe niż znaki zamiast jednego.

58
00:02:46,800 --> 00:02:48,050
Spróbujmy tego.

59
00:02:52,160 --> 00:02:57,910
Teraz, jeśli otworzymy file.txt kolejny możemy zobaczyć zarówno naszych

60
00:02:57,910 --> 00:02:59,580
linie wejściowe.

61
00:02:59,580 --> 00:03:02,180
W niektórych przypadkach, może chcemy, aby odrzucić

62
00:03:02,180 --> 00:03:03,850
Wyjście naszego programu.

63
00:03:03,850 --> 00:03:06,450
Zamiast pisać wyjście do pliku, a następnie usunąć

64
00:03:06,450 --> 00:03:09,310
Plik kiedy skończymy z tym, możemy napisać do specjalnych

65
00:03:09,310 --> 00:03:12,360
Plik o nazwie / dev / null.

66
00:03:12,360 --> 00:03:15,160
Kiedy coś jest napisane w / dev/null--

67
00:03:15,160 --> 00:03:16,960
lub po prostu devnull na krótkie -

68
00:03:16,960 --> 00:03:18,950
jest automatycznie odrzucane.

69
00:03:18,950 --> 00:03:23,290
Więc myślę o devnull jako czarna dziura dla Twoich danych.

70
00:03:23,290 --> 00:03:26,070
>> Więc teraz widzieliśmy jak znak większości można przekierować

71
00:03:26,070 --> 00:03:29,610
stdout, zobaczmy, w jaki sposób możemy przekierować standard -

72
00:03:29,610 --> 00:03:31,250
lub S-t-d-w -

73
00:03:31,250 --> 00:03:33,550
analogiem stdout.

74
00:03:33,550 --> 00:03:36,010
Chociaż funkcje jak printf pisać do strumienia zwanego

75
00:03:36,010 --> 00:03:40,500
stdout, GetString i podobne funkcje odczytu ze strumienia

76
00:03:40,500 --> 00:03:43,770
nazywane stdin które domyślnie jest strumień

77
00:03:43,770 --> 00:03:46,290
znaki wpisywane z klawiatury.

78
00:03:46,290 --> 00:03:50,010
Możemy przekierować stdin przy użyciu mniej niż znak, a następnie

79
00:03:50,010 --> 00:03:51,370
według nazwy pliku.

80
00:03:51,370 --> 00:03:54,000
Teraz, zamiast monitowania użytkownika o wejściu na

81
00:03:54,000 --> 00:03:57,870
terminal, program otworzy plik, możemy określić i wykorzystać

82
00:03:57,870 --> 00:03:59,790
jego linie jako wejście.

83
00:03:59,790 --> 00:04:02,620
>> Zobaczmy, co się dzieje.

84
00:04:02,620 --> 00:04:03,280
Great.

85
00:04:03,280 --> 00:04:07,590
Pierwsza linia plik.txt został wydrukowany na terminal

86
00:04:07,590 --> 00:04:10,160
bo dzwonisz getString raz.

87
00:04:10,160 --> 00:04:13,170
Jeśli mieliśmy innego połączenia do getString w naszym programie,

88
00:04:13,170 --> 00:04:16,149
Następny wiersz plik.txt została wykorzystana jako

89
00:04:16,149 --> 00:04:17,990
Wejście do tej rozmowy.

90
00:04:17,990 --> 00:04:21,050
Ponownie, nie zmieniły nasz program C w ogóle.

91
00:04:21,050 --> 00:04:23,620
Jesteśmy tylko zmiany, jak go uruchomić.

92
00:04:23,620 --> 00:04:27,080
I pamiętać, nie mamy przekierowanie stdout ten czas,

93
00:04:27,080 --> 00:04:28,970
Wyjście to program nadal

94
00:04:28,970 --> 00:04:31,040
wyświetlany na terminalu.

95
00:04:31,040 --> 00:04:33,500
Możemy, oczywiście, przekierowanie zarówno stdin

96
00:04:33,500 --> 00:04:37,320
i stdout tak.

97
00:04:37,320 --> 00:04:43,550
Teraz plik2.txt zawiera pierwszą linię plik.txt.

98
00:04:43,550 --> 00:04:46,140
>> Tak więc, za pomocą tych operatorów, byliśmy w stanie przeczytać i

99
00:04:46,140 --> 00:04:48,130
pisać z plików tekstowych.

100
00:04:48,130 --> 00:04:51,890
Teraz zobaczmy jak możemy użyć wyjścia jednego programu

101
00:04:51,890 --> 00:04:54,710
Wejście do innego programu.

102
00:04:54,710 --> 00:04:56,650
Tak tu jest kolejny prosty program w C I

103
00:04:56,650 --> 00:05:00,190
które tutaj nazywa hello.c.

104
00:05:00,190 --> 00:05:02,617
Jak widać, to po prostu wysyła "Hi

105
00:05:02,617 --> 00:05:04,430
tam "dla użytkownika.

106
00:05:04,430 --> 00:05:08,890
Jeśli chcę przekierować używany jako wejście wyjście hello -

107
00:05:08,890 --> 00:05:10,190
inny program -

108
00:05:10,190 --> 00:05:13,920
Może pierwszy raz przekierować stdout cześć pliku o nazwie

109
00:05:13,920 --> 00:05:18,960
input.txt, a następnie przekierować stdin przekierować do tego samego

110
00:05:18,960 --> 00:05:21,190
file - input.txt.

111
00:05:21,190 --> 00:05:26,730
Więc nie mogę zrobić. / Hello> input.txt.

112
00:05:26,730 --> 00:05:28,810
Naciśnij Enter, aby wykonać to.

113
00:05:28,810 --> 00:05:31,910
Następnie. / Redirect <

114
00:05:31,910 --> 00:05:35,270
input.txt i wykonać to.

115
00:05:35,270 --> 00:05:38,290
Tak więc możemy skrócić ten trochę z średnikiem, który pozwala

116
00:05:38,290 --> 00:05:41,360
nas do uruchomienia dwóch lub więcej poleceń na tej samej linii.

117
00:05:41,360 --> 00:05:47,920
Więc mogę powiedzieć,. / Hello> input.txt, średnik,

118
00:05:47,920 --> 00:05:50,580
. / Redirect input.txt <.

119
00:05:53,850 --> 00:05:56,740
>> Tak to działa, ale nadal czuje się całkiem nieeleganckie.

120
00:05:56,740 --> 00:05:59,530
To znaczy, czy naprawdę musimy ten plik tekstowy pośrednika, który jest

121
00:05:59,530 --> 00:06:02,520
nie jest już konieczne, po przekierowanie działa?

122
00:06:02,520 --> 00:06:05,780
Na szczęście, możemy uniknąć tego dodatkowego pliku tekstowego, co jest

123
00:06:05,780 --> 00:06:07,220
zwane rury.

124
00:06:07,220 --> 00:06:13,740
Jeśli powiem, / hello |.. / Przekierowania, wtedy stdout

125
00:06:13,740 --> 00:06:15,310
Program po lewej -

126
00:06:15,310 --> 00:06:16,740
w tym przypadku, hello -

127
00:06:16,740 --> 00:06:18,970
będzie jako standardowe wejście dla

128
00:06:18,970 --> 00:06:20,370
Program na prawo.

129
00:06:20,370 --> 00:06:24,850
W tym przypadku, przekierowanie. Więc uruchom to.

130
00:06:24,850 --> 00:06:25,930
>> Proszę bardzo.

131
00:06:25,930 --> 00:06:30,080
Można zauważyć, że sygnał wyjściowy zastosowano HELLO jako wejścia

132
00:06:30,080 --> 00:06:31,520
za przekierowanie.

133
00:06:31,520 --> 00:06:34,890
, Spinając ze sobą za pomocą polecenia Rury, tworzymy to, co znajduje się

134
00:06:34,890 --> 00:06:38,120
zwany gazociąg, gdyż nasza produkcja jest przede wszystkim przeniesienie

135
00:06:38,120 --> 00:06:40,590
przez sekwencję poleceń.

136
00:06:40,590 --> 00:06:43,570
Korzystanie z rur, możemy zrobić kilka fajnych rzeczy, bez konieczności

137
00:06:43,570 --> 00:06:45,870
pisania kodu w ogóle.

138
00:06:45,870 --> 00:06:48,760
Na przykład, powiedzmy, że chcemy wiedzieć, jak wiele plików są

139
00:06:48,760 --> 00:06:50,630
wewnątrz tego katalogu.

140
00:06:50,630 --> 00:06:55,200
Korzystanie z rury, możemy połączyć polecenia ls z wc -

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

142
00:06:56,460 --> 00:06:57,850
polecenia.

143
00:06:57,850 --> 00:07:02,230
Ls wyświetli wszystkie pliki w katalogu do stdout, oraz

144
00:07:02,230 --> 00:07:08,040
wc powie nam, ile wierszy zostało nadane mu przez stdin.

145
00:07:08,040 --> 00:07:12,440
Tak więc, jeśli mówimy ls | wc-l -

146
00:07:12,440 --> 00:07:16,800
dostarczanie flagę-l do WC, aby poinformować go policzyć wiersze -

147
00:07:16,800 --> 00:07:19,260
możemy zobaczyć, ile dokładnie pliki są

148
00:07:19,260 --> 00:07:21,940
w bieżącym katalogu.

149
00:07:21,940 --> 00:07:24,570
>> Warto więc spojrzeć na jeszcze jeden przykład.

150
00:07:24,570 --> 00:07:27,740
Mam tu plik o nazwie students.txt,

151
00:07:27,740 --> 00:07:29,600
z listą nazwisk.

152
00:07:29,600 --> 00:07:32,730
Jednak te nazwy nie są w dowolnej kolejności, to wszystko, i wygląda

153
00:07:32,730 --> 00:07:34,850
jak kilka nazwisk są powtarzane.

154
00:07:34,850 --> 00:07:38,510
Chcemy lista unikatowych nazw w kolejności alfabetycznej

155
00:07:38,510 --> 00:07:42,550
porządek, zapisany w pliku o nazwie final.txt.

156
00:07:42,550 --> 00:07:45,210
Możemy, oczywiście, napisać program w C to zrobić za nas.

157
00:07:45,210 --> 00:07:46,560
Ale dostanie niepotrzebnie

158
00:07:46,560 --> 00:07:48,560
Kompleks dość szybko.

159
00:07:48,560 --> 00:07:51,740
Załóżmy, zamiast używać rur i kilka wbudowanych narzędzi do rozwiązania-

160
00:07:51,740 --> 00:07:53,300
ten problem.

161
00:07:53,300 --> 00:07:57,760
>> Pierwszą rzeczą, którą musisz zrobić, to przeczytać students.txt pliku.

162
00:07:57,760 --> 00:08:00,530
Polecenie cat będzie nie tylko to.

163
00:08:00,530 --> 00:08:03,230
Będzie on odczytywany w określonym pliku i zapisu

164
00:08:03,230 --> 00:08:05,750
jego zawartość na standardowe wyjście.

165
00:08:05,750 --> 00:08:07,570
Po skopiowaniu pliku tekstowego, dowiemy

166
00:08:07,570 --> 00:08:09,490
Aby posortować nazwy.

167
00:08:09,490 --> 00:08:12,510
Polecenie sort może obsłużyć to dla nas.

168
00:08:12,510 --> 00:08:16,830
Sortuj wyświetli linię dostarczonego przez stdin na stdout

169
00:08:16,830 --> 00:08:19,310
w uporządkowanej kolejności.

170
00:08:19,310 --> 00:08:23,450
W celu dostarczenia zawartości students.txt do

171
00:08:23,450 --> 00:08:29,600
Sortuj w stdin, możemy użyć rury połączyć kota i sortowania.

172
00:08:29,600 --> 00:08:34,440
Więc mogę wykonaj cat students.txt | sort i

173
00:08:34,440 --> 00:08:35,640
naciśnij klawisz Enter.

174
00:08:35,640 --> 00:08:39,309
A teraz widzimy zawartość students.txt w

175
00:08:39,309 --> 00:08:40,909
w porządku alfabetycznym.

176
00:08:40,909 --> 00:08:42,860
>> Dodajmy kolejne polecenia -

177
00:08:42,860 --> 00:08:44,730
uniq lub wyjątkowy -

178
00:08:44,730 --> 00:08:46,230
do naszego rurociągu.

179
00:08:46,230 --> 00:08:49,810
Jak można się domyślać, Uniq, gdy dostarczane posortowanej sekwencji

180
00:08:49,810 --> 00:08:53,650
linie poprzez stdin wyświetli unikalne linie.

181
00:08:53,650 --> 00:08:56,910
Więc teraz mamy students.txt kota

182
00:08:56,910 --> 00:09:00,040
| Sort | uniq.

183
00:09:00,040 --> 00:09:03,330
Wreszcie, możemy zapisać wyjście rurociągu

184
00:09:03,330 --> 00:09:09,090
plików przez kota students.txt | sort | uniq

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

186
00:09:12,440 --> 00:09:16,260
Tak więc, jeśli otwieramy final.txt, mamy dokładnie to, co my

187
00:09:16,260 --> 00:09:17,270
szukam:

188
00:09:17,270 --> 00:09:20,180
lista unikatowych nazw w kolejności alfabetycznej,

189
00:09:20,180 --> 00:09:22,150
zapisane w pliku tekstowym.

190
00:09:22,150 --> 00:09:26,020
Nawiasem mówiąc, również mógł powiedzieć sort <

191
00:09:26,020 --> 00:09:32,290
students.txt | uniq> final.txt zrobić dokładnie

192
00:09:32,290 --> 00:09:35,400
samo, wykorzystując każdy z podmiotów, które widzieliśmy w

193
00:09:35,400 --> 00:09:36,580
ten film.

194
00:09:36,580 --> 00:09:39,540
>> Nazywam się Tommy, i to jest CS50.