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

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

3
00:00:10,140 --> 00:00:12,780
Até agora, estamos usando funções como printf para

4
00:00:12,780 --> 00:00:15,590
dados de saída para o terminal e funções como GetString

5
00:00:15,590 --> 00:00:17,520
para permitir ao usuário a contribuir para o nosso

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

7
00:00:19,490 --> 00:00:21,880
Vamos rapidamente dar uma olhada em um programa que recebe uma linha de

8
00:00:21,880 --> 00:00:25,960
entrada do usuário e, em seguida, gera-lo.

9
00:00:25,960 --> 00:00:28,990
>> Na linha 7, estamos alertando o usuário para uma string, e

10
00:00:28,990 --> 00:00:31,680
em seguida, na linha 8, estamos imprimindo-lo de volta.

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

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

13
00:00:35,900 --> 00:00:37,620
A seqüência de nós desde ecoou 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
Isso aconteceu porque a função printf escreveu a um

16
00:00:42,110 --> 00:00:46,220
fluxo chamado padrão, ou s-t-d-out.

17
00:00:46,220 --> 00:00:49,230
Quando algo está escrito na saída padrão, é por padrão

18
00:00:49,230 --> 00:00:51,110
exibida pelo terminal.

19
00:00:51,110 --> 00:00:53,720
>> Então, isso é tudo muito bem, mas o que se, em vez de simplesmente

20
00:00:53,720 --> 00:00:57,700
exibindo a string, queria salvá-lo em um arquivo?

21
00:00:57,700 --> 00:01:00,470
Por exemplo, pode querer se lembrar exatamente o que o nosso

22
00:01:00,470 --> 00:01:04,450
programa fez quando deu uma entrada em particular mais tarde.

23
00:01:04,450 --> 00:01:07,270
Uma abordagem seria fazer isso em nosso programa de C, utilizando

24
00:01:07,270 --> 00:01:09,680
algumas funções especiais para a gravação de arquivos que vamos

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

26
00:01:11,270 --> 00:01:13,260
Ainda mais fácil, no entanto, seria de alguma forma

27
00:01:13,260 --> 00:01:16,090
redirecionar stdout para um arquivo.

28
00:01:16,090 --> 00:01:19,780
Dessa forma, quando printf escreve para stdout, o conteúdo será

29
00:01:19,780 --> 00:01:21,720
ser escrito em um arquivo, em vez de

30
00:01:21,720 --> 00:01:23,410
exibida pelo terminal.

31
00:01:23,410 --> 00:01:26,690
Nós podemos fazer isso adicionando um sinal de maior-que, seguido

32
00:01:26,690 --> 00:01:30,820
por um nome de arquivo, para o comando que usamos para executar o nosso programa.

33
00:01:30,820 --> 00:01:34,730
>> Então, ao invés de simplesmente executar. / Redirecionamento, podemos

34
00:01:34,730 --> 00:01:38,880
execute. / redirecionamento, seguido por um sinal de maior, seguida pela

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

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

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

38
00:01:45,130 --> 00:01:48,470
Observe que, desta vez, nada foi exibida no terminal,

39
00:01:48,470 --> 00:01:50,290
mas nós não têm modificado o conteúdo de nossa

40
00:01:50,290 --> 00:01:52,040
C programa em tudo.

41
00:01:52,040 --> 00:01:56,090
Vamos agora examinar o conteúdo desse diretório com ls.

42
00:01:56,090 --> 00:01:56,630
>> Tudo bem.

43
00:01:56,630 --> 00:02:00,840
Temos, agora, um novo arquivo no nosso diretório chamado file.txt,

44
00:02:00,840 --> 00:02:03,640
que é o nome do arquivo que forneceu quando rodamos nosso

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

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

47
00:02:08,020 --> 00:02:11,840
E aqui, nós podemos ver que o stdout de redirecionar 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ão, vamos executar novamente o comando anterior, mas fornecendo uma

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
Vamos dar uma olhada em file.txt agora.

53
00:02:31,070 --> 00:02:34,580
>> Podemos ver aqui que o arquivo foi substituído, por isso a nossa

54
00:02:34,580 --> 00:02:37,120
entrada original não está mais lá.

55
00:02:37,120 --> 00:02:40,280
Se em vez quero acrescentar a este arquivo, colocando o novo

56
00:02:40,280 --> 00:02:43,600
entrada abaixo os conteúdos existentes no arquivo, podemos

57
00:02:43,600 --> 00:02:46,800
usar dois sinais de maior, em vez de apenas um.

58
00:02:46,800 --> 00:02:48,050
Vamos tentar isso.

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

60
00:02:57,910 --> 00:02:59,580
linhas de entrada.

61
00:02:59,580 --> 00:03:02,180
Em alguns casos, pode-se desejar descartar qualquer

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

63
00:03:03,850 --> 00:03:06,450
Ao invés de escrever a saída para um arquivo e depois apagar

64
00:03:06,450 --> 00:03:09,310
o arquivo quando estamos a fazer com ela, podemos escrever uma especial para

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

66
00:03:12,360 --> 00:03:15,160
Quando alguma coisa é escrita / dev/null--

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

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

69
00:03:18,950 --> 00:03:23,290
Então pense devnull como um buraco negro para os seus dados.

70
00:03:23,290 --> 00:03:26,070
>> Então, agora temos visto como o sinal maior do que pode redirecionar

71
00:03:26,070 --> 00:03:29,610
stdout, vamos ver como podemos redirecionar padrão em -

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 stdout.

74
00:03:33,550 --> 00:03:36,010
Enquanto funções como printf gravar o fluxo de chamadas

75
00:03:36,010 --> 00:03:40,500
GetString stdout, e funções similares lidos do fluxo

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

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

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

79
00:03:50,010 --> 00:03:51,370
por um nome de arquivo.

80
00:03:51,370 --> 00:03:54,000
Agora, em vez de avisar o usuário para a entrada no

81
00:03:54,000 --> 00:03:57,870
terminal, um programa irá abrir o arquivo que nós especificamos e usar

82
00:03:57,870 --> 00:03:59,790
suas linhas como entrada.

83
00:03:59,790 --> 00:04:02,620
>> Vamos 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 linha de file.txt foi exibida no terminal

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

87
00:04:10,160 --> 00:04:13,170
Se tivéssemos outra chamada para GetString em nosso programa, o

88
00:04:13,170 --> 00:04:16,149
próxima linha de file.txt teria sido utilizada como

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

90
00:04:17,990 --> 00:04:21,050
Mais uma vez, nós não têm modificado o nosso programa C em tudo.

91
00:04:21,050 --> 00:04:23,620
Estamos apenas mudando o modo como executá-lo.

92
00:04:23,620 --> 00:04:27,080
E lembre-se também, não temos redirecionado stdout este tempo,

93
00:04:27,080 --> 00:04:28,970
de modo que o resultado do programa foi ainda

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

95
00:04:31,040 --> 00:04:33,500
Podemos, evidentemente, tanto redireccionar stdin

96
00:04:33,500 --> 00:04:37,320
e stdout como este.

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

98
00:04:43,550 --> 00:04:46,140
>> Assim, usando esses operadores, temos sido capazes de ler e

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

100
00:04:48,130 --> 00:04:51,890
Agora, vamos ver como podemos usar a saída de um programa como

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

102
00:04:54,710 --> 00:04:56,650
Então aqui está um outro programa C simples eu

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

104
00:05:00,190 --> 00:05:02,617
Como você pode ver, este simplesmente exibe "Oi

105
00:05:02,617 --> 00:05:04,430
lá "para o utilizador.

106
00:05:04,430 --> 00:05:08,890
Se eu quiser redirecionar para usar como entrada a saída de Olá -

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

108
00:05:10,190 --> 00:05:13,920
Eu poderia redirecionar o stdout primeiro de Olá para um arquivo chamado

109
00:05:13,920 --> 00:05:18,960
input.txt, então redirecionar a stdin de redirecionar 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 possa fazer. / Olá input.txt>.

112
00:05:26,730 --> 00:05:28,810
Pressione Enter para executar isso.

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

114
00:05:31,910 --> 00:05:35,270
input.txt e executar isso.

115
00:05:35,270 --> 00:05:38,290
Assim, podemos encurtar isso um pouco com um ponto e vírgula, o que permite

116
00:05:38,290 --> 00:05:41,360
nós para executar dois ou mais comandos na mesma linha.

117
00:05:41,360 --> 00:05:47,920
Então eu posso dizer,. / Olá> input.txt, ponto e vírgula,

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

119
00:05:53,850 --> 00:05:56,740
>> Então, isso funciona, mas ele ainda se sente muito deselegante.

120
00:05:56,740 --> 00:05:59,530
Quero dizer, nós realmente precisamos desse arquivo de texto intermediário que é

121
00:05:59,530 --> 00:06:02,520
não é mais necessário depois de redirecionar corridas?

122
00:06:02,520 --> 00:06:05,780
Felizmente, podemos evitar esse arquivo de texto extra usando o que há de

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

124
00:06:07,220 --> 00:06:13,740
Se eu digo, / Olá |.. / Redirecionar, então o stdout

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

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

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

128
00:06:18,970 --> 00:06:20,370
programa, à direita.

129
00:06:20,370 --> 00:06:24,850
Neste caso, o redireccionamento. Então, vamos executar este.

130
00:06:24,850 --> 00:06:25,930
>> Lá vamos nós.

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

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

133
00:06:31,520 --> 00:06:34,890
Amarrando comandos em conjunto, utilizando tubos, que formam o que é

134
00:06:34,890 --> 00:06:38,120
chamado de um gasoduto, uma vez que nossa produção é essencialmente movendo

135
00:06:38,120 --> 00:06:40,590
através de uma seqüência de comandos.

136
00:06:40,590 --> 00:06:43,570
Usando tubos, podemos fazer algumas coisas legais sem a necessidade de

137
00:06:43,570 --> 00:06:45,870
escrever qualquer código em tudo.

138
00:06:45,870 --> 00:06:48,760
Por exemplo, vamos dizer que queremos saber quantos arquivos são

139
00:06:48,760 --> 00:06:50,630
dentro deste diretório.

140
00:06:50,630 --> 00:06:55,200
Usando um tubo, podemos combinar o comando ls com o wc -

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

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

143
00:06:57,850 --> 00:07:02,230
Ls saída de cada arquivo no diretório para stdout, e

144
00:07:02,230 --> 00:07:08,040
wc vai nos dizer quantas linhas foram dadas a ele através de stdin.

145
00:07:08,040 --> 00:07:12,440
Então, se nós dizemos ls | wc-l -

146
00:07:12,440 --> 00:07:16,800
fornecer o L-bandeira para wc dizer a ele para contar linhas -

147
00:07:16,800 --> 00:07:19,260
podemos ver exatamente quantos arquivos são

148
00:07:19,260 --> 00:07:21,940
no diretório atual.

149
00:07:21,940 --> 00:07:24,570
>> Então, vamos dar uma olhada em mais um exemplo.

150
00:07:24,570 --> 00:07:27,740
Eu tenho aqui um arquivo chamado students.txt,

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

152
00:07:29,600 --> 00:07:32,730
No entanto, esses nomes não estão em nenhuma ordem de tudo isso, e parece

153
00:07:32,730 --> 00:07:34,850
como alguns nomes se repetem.

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

155
00:07:38,510 --> 00:07:42,550
ordem, salvo em um arquivo chamado final.txt.

156
00:07:42,550 --> 00:07:45,210
Poderíamos, é claro, escrever um programa em C para fazer isso por nós.

157
00:07:45,210 --> 00:07:46,560
Mas vai ficar desnecessariamente

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

159
00:07:48,560 --> 00:07:51,740
Vamos, em vez usar tubos e alguns 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 coisa que precisamos fazer é ler o students.txt arquivo.

162
00:07:57,760 --> 00:08:00,530
O comando cat vai fazer exatamente isso.

163
00:08:00,530 --> 00:08:03,230
Ele vai ler o arquivo especificado e escrever

164
00:08:03,230 --> 00:08:05,750
seu conteúdo para stdout.

165
00:08:05,750 --> 00:08:07,570
Depois que li o arquivo de texto, vamos

166
00:08:07,570 --> 00:08:09,490
deseja classificar os nomes.

167
00:08:09,490 --> 00:08:12,510
O comando sort pode lidar com isso para nós.

168
00:08:12,510 --> 00:08:16,830
Ordenar saída será a linha fornecida através de stdin stdout

169
00:08:16,830 --> 00:08:19,310
em ordem de classificação.

170
00:08:19,310 --> 00:08:23,450
De modo a fornecer o conteúdo do students.txt para

171
00:08:23,450 --> 00:08:29,600
stdin tipo, poderíamos usar um tubo para combinar gato e tipo.

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

173
00:08:34,440 --> 00:08:35,640
pressione Enter.

174
00:08:35,640 --> 00:08:39,309
E agora, vemos o conteúdo da students.txt em

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

176
00:08:40,909 --> 00:08:42,860
>> Então, vamos adicionar outro comando -

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

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

179
00:08:46,230 --> 00:08:49,810
Como você pode imaginar, uniq, quando fornecida uma seqüência ordenada de

180
00:08:49,810 --> 00:08:53,650
linhas através de stdin, irá imprimir as linhas originais.

181
00:08:53,650 --> 00:08:56,910
Portanto, 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 um

184
00:09:03,330 --> 00:09:09,090
arquivo via 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ão, se abrirmos final.txt, temos exatamente o que nós

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

188
00:09:17,270 --> 00:09:20,180
uma lista de nomes exclusivos em ordem alfabética,

189
00:09:20,180 --> 00:09:22,150
salvos em um arquivo de texto.

190
00:09:22,150 --> 00:09:26,020
A propósito, também poderia ter dito tipo <

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

192
00:09:32,290 --> 00:09:35,400
a mesma coisa, usando cada um dos operadores que já vimos em

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

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