1
00:00:07,060 --> 00:00:08,420
[Powered by Google Translate] Tommy: Neste vídeo, imos aprender sobre

2
00:00:08,420 --> 00:00:10,140
redirixido e canos.

3
00:00:10,140 --> 00:00:12,780
Ata agora, estamos usando funcións como printf para

4
00:00:12,780 --> 00:00:15,590
datos de saída para o terminal e funcións como GetString

5
00:00:15,590 --> 00:00:17,520
para permitir ao usuario a contribuír ao noso

6
00:00:17,520 --> 00:00:19,490
programa usando o teclado.

7
00:00:19,490 --> 00:00:21,880
Imos axiña dar un ollo a un programa que recibe unha liña de

8
00:00:21,880 --> 00:00:25,960
entrada do usuario e, a continuación, xera-lo.

9
00:00:25,960 --> 00:00:28,990
>> Na liña 7, estamos alertando o usuario a unha cadea, e

10
00:00:28,990 --> 00:00:31,680
a continuación, na liña 8, estamos imprimindo-lo de volta.

11
00:00:31,680 --> 00:00:35,220
Imos compilar e executar o noso programa.

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

13
00:00:35,900 --> 00:00:37,620
A secuencia de nós desde eco de volta

14
00:00:37,620 --> 00:00:39,170
para nós no terminal.

15
00:00:39,170 --> 00:00:42,110
Iso aconteceu porque a función printf escribiu un

16
00:00:42,110 --> 00:00:46,220
fluxo chamado estándar ou s-t-d-out.

17
00:00:46,220 --> 00:00:49,230
Cando algo está escrito na saída estándar, e por defecto

18
00:00:49,230 --> 00:00:51,110
exhibida polo terminal.

19
00:00:51,110 --> 00:00:53,720
>> Entón, iso é todo moi ben, pero o que si, en vez de simplemente

20
00:00:53,720 --> 00:00:57,700
mostrando a cadea, quería salvalo nun arquivo?

21
00:00:57,700 --> 00:01:00,470
Por exemplo, pode querer lembrar exactamente o que o noso

22
00:01:00,470 --> 00:01:04,450
programa fixo cando deu unha entrada en particular máis tarde.

23
00:01:04,450 --> 00:01:07,270
Unha visión sería facelo no noso programa de C, utilizando

24
00:01:07,270 --> 00:01:09,680
algunhas funcións especiais para a gravación de ficheiros que imos

25
00:01:09,680 --> 00:01:11,270
ver noutro vídeo.

26
00:01:11,270 --> 00:01:13,260
Aínda máis fácil, con todo, sería de algunha maneira

27
00:01:13,260 --> 00:01:16,090
redireccionar saída estándar para un arquivo.

28
00:01:16,090 --> 00:01:19,780
Desta forma, cando printf escribe á saída, o contido será

29
00:01:19,780 --> 00:01:21,720
escribir nun ficheiro, en vez de

30
00:01:21,720 --> 00:01:23,410
exhibida polo terminal.

31
00:01:23,410 --> 00:01:26,690
Podemos facelo engadindo un sinal de maior-que, seguido

32
00:01:26,690 --> 00:01:30,820
por un nome de ficheiro para o comando que usamos para executar o noso programa.

33
00:01:30,820 --> 00:01:34,730
>> Entón, en vez de simplemente executar. / Redirección, podemos

34
00:01:34,730 --> 00:01:38,880
realice. / redirección, seguido por un sinal de maior, seguida pola

35
00:01:38,880 --> 00:01:41,530
nome do ficheiro, como file.txt.

36
00:01:41,530 --> 00:01:44,290
Imos ver o que acontece.

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

38
00:01:45,130 --> 00:01:48,470
Teña en conta que, esta vez, nada foi exhibida no terminal,

39
00:01:48,470 --> 00:01:50,290
pero non modificaron o contido da nosa

40
00:01:50,290 --> 00:01:52,040
C programa en todo.

41
00:01:52,040 --> 00:01:56,090
Imos agora examinar o contido deste directorio con ls.

42
00:01:56,090 --> 00:01:56,630
>> Todo ben.

43
00:01:56,630 --> 00:02:00,840
Temos, agora, un novo arquivo no noso directorio chamado file.txt,

44
00:02:00,840 --> 00:02:03,640
que é o nome do ficheiro que proporcionou cando rodamos noso

45
00:02:03,640 --> 00:02:05,050
Redireccionar programa.

46
00:02:05,050 --> 00:02:08,020
Imos abrir file.txt.

47
00:02:08,020 --> 00:02:11,840
E aquí, podemos ver que o saída estándar de redireccionar foi

48
00:02:11,840 --> 00:02:15,550
escrito para o arquivo chamado arquivo.txt.

49
00:02:15,550 --> 00:02:18,470
Entón, imos facer de novo o mando anterior, pero introducindo unha

50
00:02:18,470 --> 00:02:20,075
entrada diferente desta vez.

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

52
00:02:25,900 --> 00:02:28,205
Imos dar un ollo a file.txt agora.

53
00:02:31,070 --> 00:02:34,580
>> Podemos ver aquí que o arquivo foi substituído, polo que a nosa

54
00:02:34,580 --> 00:02:37,120
entrada orixinal non está alí.

55
00:02:37,120 --> 00:02:40,280
Se en vez quero engadir a este ficheiro, colocar o novo

56
00:02:40,280 --> 00:02:43,600
entrada de abaixo os contidos existentes no arquivo, podemos

57
00:02:43,600 --> 00:02:46,800
usar dous sinais de maior, en vez de só un.

58
00:02:46,800 --> 00:02:48,050
Imos tentar iso.

59
00:02:52,160 --> 00:02:57,910
Agora, se abrirmos file.txt novo, podemos ver tanto da nosa

60
00:02:57,910 --> 00:02:59,580
liñas de entrada.

61
00:02:59,580 --> 00:03:02,180
Nalgúns casos, pode-se o desexa descartar calquera

62
00:03:02,180 --> 00:03:03,850
saída do noso programa.

63
00:03:03,850 --> 00:03:06,450
En vez de escribir a saída a un ficheiro e despois borrar

64
00:03:06,450 --> 00:03:09,310
o ficheiro cando estamos a facer con ela, podemos escribir unha especial

65
00:03:09,310 --> 00:03:12,360
arquivo chamado / dev / null.

66
00:03:12,360 --> 00:03:15,160
Cando algo é escrita / dev/null--

67
00:03:15,160 --> 00:03:16,960
ou só devnull para breve -

68
00:03:16,960 --> 00:03:18,950
el automaticamente descartado.

69
00:03:18,950 --> 00:03:23,290
Entón pense devnull como un burato negro para os seus datos.

70
00:03:23,290 --> 00:03:26,070
>> Entón, agora temos visto como o sinal máis grande que pode redireccionar

71
00:03:26,070 --> 00:03:29,610
saída estándar, imos ver como podemos redireccionar estándar en -

72
00:03:29,610 --> 00:03:31,250
ou s-t-d-in -

73
00:03:31,250 --> 00:03:33,550
o análogo da saída estándar.

74
00:03:33,550 --> 00:03:36,010
Mentres funcións como printf gravar o fluxo de chamadas

75
00:03:36,010 --> 00:03:40,500
GetString saída estándar, e funcións similares lidos do fluxo

76
00:03:40,500 --> 00:03:43,770
chamado stdin, que, por defecto, é o fluxo de

77
00:03:43,770 --> 00:03:46,290
caracteres tecleados no teclado.

78
00:03:46,290 --> 00:03:50,010
Podemos redireccionar stdin usando a menos de sinal, seguido

79
00:03:50,010 --> 00:03:51,370
por un nome de ficheiro.

80
00:03:51,370 --> 00:03:54,000
Agora, en vez de avisar o usuario para a entrada no

81
00:03:54,000 --> 00:03:57,870
terminal, un programa ha abrir o ficheiro que especificamos e utilizar

82
00:03:57,870 --> 00:03:59,790
súas liñas como entrada.

83
00:03:59,790 --> 00:04:02,620
>> Imos ver o que acontece.

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

85
00:04:03,280 --> 00:04:07,590
A primeira liña de file.txt foi exhibida no terminal

86
00:04:07,590 --> 00:04:10,160
porque estamos chamando GetString unha vez.

87
00:04:10,160 --> 00:04:13,170
Se tivésemos outra chamada para GetString no noso programa, o

88
00:04:13,170 --> 00:04:16,149
seguinte liña de file.txt sería utilizada como

89
00:04:16,149 --> 00:04:17,990
entrada para a chamada.

90
00:04:17,990 --> 00:04:21,050
Unha vez máis, non modificaron o noso programa C en todo.

91
00:04:21,050 --> 00:04:23,620
Estamos só cambiando o xeito no que executa-lo.

92
00:04:23,620 --> 00:04:27,080
E lembre tamén, non temos redirixido saída estándar este tempo,

93
00:04:27,080 --> 00:04:28,970
de xeito que o resultado do programa foi aínda

94
00:04:28,970 --> 00:04:31,040
exhibida no terminal.

95
00:04:31,040 --> 00:04:33,500
Podemos, por suposto, tanto redirixir stdin

96
00:04:33,500 --> 00:04:37,320
e saída estándar coma este.

97
00:04:37,320 --> 00:04:43,550
Agora, file2.txt contén a primeira liña de file.txt.

98
00:04:43,550 --> 00:04:46,140
>> Así, usando estes operadores, temos sido capaces de ler e

99
00:04:46,140 --> 00:04:48,130
escribir a partir de arquivos de texto.

100
00:04:48,130 --> 00:04:51,890
Agora, imos ver como podemos utilizar a saída dun programa

101
00:04:51,890 --> 00:04:54,710
a entrada a outro programa.

102
00:04:54,710 --> 00:04:56,650
Entón aquí está outro programa C simple eu

103
00:04:56,650 --> 00:05:00,190
ter aquí chamado hello.c.

104
00:05:00,190 --> 00:05:02,617
Como podes ver, este simplemente exhibe "Ola

105
00:05:02,617 --> 00:05:04,430
alí "para o usuario.

106
00:05:04,430 --> 00:05:08,890
Se eu queira redireccionar para usar como entrada a saída de Ola -

107
00:05:08,890 --> 00:05:10,190
outro programa -

108
00:05:10,190 --> 00:05:13,920
Eu podería redireccionar o saída estándar primeiro Ola a un arquivo chamado

109
00:05:13,920 --> 00:05:18,960
input.txt, entón redireccionar a stdin de redireccionar para o mesmo

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

111
00:05:21,190 --> 00:05:26,730
Para que eu poida facer. / Ola input.txt>.

112
00:05:26,730 --> 00:05:28,810
Prema Intro para executar isto.

113
00:05:28,810 --> 00:05:31,910
Seguido por. / Redireccionar <

114
00:05:31,910 --> 00:05:35,270
input.txt e realizar iso.

115
00:05:35,270 --> 00:05:38,290
Así, podemos reducir iso un pouco con un punto e coma, o que permite

116
00:05:38,290 --> 00:05:41,360
nós para realizar dous ou máis comandos na mesma liña.

117
00:05:41,360 --> 00:05:47,920
Entón eu podo dicir,. / Ola> input.txt, punto e coma,

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

119
00:05:53,850 --> 00:05:56,740
>> Entón, isto funciona, pero aínda se sente moi deselegante.

120
00:05:56,740 --> 00:05:59,530
Quero dicir, nós realmente necesitamos deste arquivo de texto intermediario que é

121
00:05:59,530 --> 00:06:02,520
non é máis necesario tras redireccionar carreiras?

122
00:06:02,520 --> 00:06:05,780
Afortunadamente, podemos evitar ese arquivo de texto extra usando o que hai de

123
00:06:05,780 --> 00:06:07,220
chamado un tubo.

124
00:06:07,220 --> 00:06:13,740
Se eu digo, / Ola | .. / Redireccionar, entón o saída estándar

125
00:06:13,740 --> 00:06:15,310
o programa da esquerda -

126
00:06:15,310 --> 00:06:16,740
neste caso, Ola -

127
00:06:16,740 --> 00:06:18,970
será usada como a entrada para o estándar

128
00:06:18,970 --> 00:06:20,370
programa, á dereita.

129
00:06:20,370 --> 00:06:24,850
Neste caso, o redireccionamento. Entón, imos realizar este.

130
00:06:24,850 --> 00:06:25,930
>> Alí imos nós.

131
00:06:25,930 --> 00:06:30,080
Podemos ver que a saída da Ola foi usada como entrada

132
00:06:30,080 --> 00:06:31,520
para redireccionar.

133
00:06:31,520 --> 00:06:34,890
Amarre comandos en conxunto, utilizando tubos, que forman o que é

134
00:06:34,890 --> 00:06:38,120
chamado dun gasoduto, unha vez que a nosa produción é principalmente movendo

135
00:06:38,120 --> 00:06:40,590
a través dunha secuencia de comandos.

136
00:06:40,590 --> 00:06:43,570
Usando tubos, podemos facer algunhas cousas legais sen necesidade de

137
00:06:43,570 --> 00:06:45,870
escribir calquera código en todo.

138
00:06:45,870 --> 00:06:48,760
Por exemplo, imos dicir que queremos saber cantos arquivos

139
00:06:48,760 --> 00:06:50,630
dentro deste directorio.

140
00:06:50,630 --> 00:06:55,200
Empregando un tubo, podemos combinar o comando ls con baño -

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

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

143
00:06:57,850 --> 00:07:02,230
Ls saída de cada ficheiro no directorio á saída,

144
00:07:02,230 --> 00:07:08,040
baño vai dicir cantas liñas foron dadas a el a través de stdin.

145
00:07:08,040 --> 00:07:12,440
Entón, se nós dicimos ls | WC-l -

146
00:07:12,440 --> 00:07:16,800
facilitar o L-bandeira para baño dicir a el para contar liñas -

147
00:07:16,800 --> 00:07:19,260
podemos ver exactamente cantos arquivos

148
00:07:19,260 --> 00:07:21,940
no directorio actual.

149
00:07:21,940 --> 00:07:24,570
>> Entón, imos dar un ollo a un exemplo.

150
00:07:24,570 --> 00:07:27,740
Eu teño aquí un arquivo chamado students.txt,

151
00:07:27,740 --> 00:07:29,600
cunha lista de nomes.

152
00:07:29,600 --> 00:07:32,730
Con todo, eses nomes non están en ningunha orde de todo isto, e parece

153
00:07:32,730 --> 00:07:34,850
como algúns nomes repítense.

154
00:07:34,850 --> 00:07:38,510
O que queremos é unha lista de nomes exclusivos en alfabética

155
00:07:38,510 --> 00:07:42,550
orde, salvo nun arquivo chamado final.txt.

156
00:07:42,550 --> 00:07:45,210
Poderiamos, por suposto, escribir un programa en C para facelo por nós.

157
00:07:45,210 --> 00:07:46,560
Pero vai estar innecesariamente

158
00:07:46,560 --> 00:07:48,560
complexo moi rapidamente.

159
00:07:48,560 --> 00:07:51,740
Imos, en vez usar tubos e algúns built-in-ferramentas para resolver

160
00:07:51,740 --> 00:07:53,300
este problema.

161
00:07:53,300 --> 00:07:57,760
>> A primeira cousa que cómpre facer é ler o students.txt arquivo.

162
00:07:57,760 --> 00:08:00,530
O comando cat vai facer exactamente isto.

163
00:08:00,530 --> 00:08:03,230
El vai ler o ficheiro especificado e escribir

164
00:08:03,230 --> 00:08:05,750
seu contido á saída.

165
00:08:05,750 --> 00:08:07,570
Despois que lin o arquivo de texto, imos

166
00:08:07,570 --> 00:08:09,490
quere clasificar os nomes.

167
00:08:09,490 --> 00:08:12,510
O comando sort pode tratar con isto para nós.

168
00:08:12,510 --> 00:08:16,830
Ordenar saída será a liña fornecida a través de stdin saída estándar

169
00:08:16,830 --> 00:08:19,310
en orde de clasificación.

170
00:08:19,310 --> 00:08:23,450
Fin de achegar o contido do students.txt para

171
00:08:23,450 --> 00:08:29,600
stdin tipo, poderiamos usar un tubo para combinar gato e tipo.

172
00:08:29,600 --> 00:08:34,440
Para que eu poida executar gato students.txt | sort e

173
00:08:34,440 --> 00:08:35,640
prema Intro.

174
00:08:35,640 --> 00:08:39,309
E agora vemos o contido da students.txt en

175
00:08:39,309 --> 00:08:40,909
orde alfabética.

176
00:08:40,909 --> 00:08:42,860
>> Entón, imos engadir outro comando -

177
00:08:42,860 --> 00:08:44,730
uniq, ou única -

178
00:08:44,730 --> 00:08:46,230
ao noso pipeline.

179
00:08:46,230 --> 00:08:49,810
Como podes imaxinar, uniq, cando proporcionada unha secuencia ordenada de

180
00:08:49,810 --> 00:08:53,650
liñas a través de stdin, pode imprimir as liñas orixinais.

181
00:08:53,650 --> 00:08:56,910
Polo tanto, agora temos students.txt gato

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

183
00:09:00,040 --> 00:09:03,330
Finalmente, podemos salvar a saída do gasoduto a un

184
00:09:03,330 --> 00:09:09,090
arquivo vía gato students.txt | sort | uniq

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

186
00:09:12,440 --> 00:09:16,260
Entón, se abrirmos final.txt, temos exactamente o que nós

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

188
00:09:17,270 --> 00:09:20,180
unha lista de nomes exclusivos en orde alfabética,

189
00:09:20,180 --> 00:09:22,150
gardados nun arquivo de texto.

190
00:09:22,150 --> 00:09:26,020
A propósito, tamén podería ter dito tipo <

191
00:09:26,020 --> 00:09:32,290
students.txt | uniq> final.txt facer exactamente

192
00:09:32,290 --> 00:09:35,400
o mesmo, utilizando cada un dos operadores que xa vimos en

193
00:09:35,400 --> 00:09:36,580
este vídeo.

194
00:09:36,580 --> 00:09:39,540
>> O meu nome é Tommy, e este é o CS50.