1
00:00:07,060 --> 00:00:08,420
[Powered by Google Translate] TOMMY: Dans cette vidéo, nous allons en apprendre davantage sur

2
00:00:08,420 --> 00:00:10,140
réorienter et de tuyaux.

3
00:00:10,140 --> 00:00:12,780
Jusqu'à présent, nous avons utilisé des fonctions comme printf pour

4
00:00:12,780 --> 00:00:15,590
sortie de données vers le terminal et fonctionne comme GetString

5
00:00:15,590 --> 00:00:17,520
pour permettre à l'utilisateur d'apporter une contribution à notre

6
00:00:17,520 --> 00:00:19,490
programme à l'aide du clavier.

7
00:00:19,490 --> 00:00:21,880
Jetons rapidement un coup d'oeil à un programme qui obtient une ligne de

8
00:00:21,880 --> 00:00:25,960
entrée de l'utilisateur, puis il sort.

9
00:00:25,960 --> 00:00:28,990
>> Sur la ligne 7, nous invitant l'utilisateur à une chaîne, et

10
00:00:28,990 --> 00:00:31,680
puis sur la ligne 8, nous l'imprimer arrière.

11
00:00:31,680 --> 00:00:35,220
Nous allons compiler et exécuter notre programme.

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

13
00:00:35,900 --> 00:00:37,620
La chaîne nous avons fourni a été renvoyée en écho

14
00:00:37,620 --> 00:00:39,170
nous à la borne.

15
00:00:39,170 --> 00:00:42,110
Cela s'est produit parce que la fonction printf écrit à un

16
00:00:42,110 --> 00:00:46,220
ruisseau appelé la sortie standard, ou s-t-d-out.

17
00:00:46,220 --> 00:00:49,230
Quand quelque chose est écrit sur la sortie standard, il est par défaut

18
00:00:49,230 --> 00:00:51,110
affichée par le terminal.

19
00:00:51,110 --> 00:00:53,720
>> Donc, c'est bien beau, mais si, au lieu de simplement

20
00:00:53,720 --> 00:00:57,700
affichage de la chaîne, nous avons voulu l'enregistrer dans un fichier?

21
00:00:57,700 --> 00:01:00,470
Par exemple, nous pourrions vouloir me souviens pas exactement ce que notre

22
00:01:00,470 --> 00:01:04,450
programme a fait quand nous lui avons donné une entrée particulière tard.

23
00:01:04,450 --> 00:01:07,270
Une approche possible serait de le faire dans notre programme en C, à l'aide

24
00:01:07,270 --> 00:01:09,680
certaines fonctions spéciales pour l'écriture des fichiers que nous allons

25
00:01:09,680 --> 00:01:11,270
voir dans une autre vidéo.

26
00:01:11,270 --> 00:01:13,260
Encore plus facile, cependant, serait en quelque sorte

27
00:01:13,260 --> 00:01:16,090
rediriger stdout vers un fichier.

28
00:01:16,090 --> 00:01:19,780
Ainsi, lorsque printf écrit sur la sortie standard, le contenu sera

29
00:01:19,780 --> 00:01:21,720
être écrites dans un fichier plutôt que

30
00:01:21,720 --> 00:01:23,410
affichée par le terminal.

31
00:01:23,410 --> 00:01:26,690
Nous pouvons faire cela en ajoutant un signe supérieur à, suivi

32
00:01:26,690 --> 00:01:30,820
par un nom de fichier, la commande que nous utilisons pour exécuter notre programme.

33
00:01:30,820 --> 00:01:34,730
>> Donc, plutôt que de simplement exécuter. / Redirection, nous pouvons

34
00:01:34,730 --> 00:01:38,880
exécuter. / redirection, suivi d'un signe supérieur, suivie par

35
00:01:38,880 --> 00:01:41,530
nom de fichier, comme fichier.txt.

36
00:01:41,530 --> 00:01:44,290
Voyons voir ce qui se passe.

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

38
00:01:45,130 --> 00:01:48,470
Remarquez que cette fois, rien n'est affiché sur le terminal,

39
00:01:48,470 --> 00:01:50,290
mais nous n'avons pas modifié le contenu de notre

40
00:01:50,290 --> 00:01:52,040
Programme C du tout.

41
00:01:52,040 --> 00:01:56,090
Examinons maintenant le contenu de ce répertoire avec ls.

42
00:01:56,090 --> 00:01:56,630
>> Très bien.

43
00:01:56,630 --> 00:02:00,840
Nous avons maintenant un nouveau fichier dans notre répertoire appelé file.txt,

44
00:02:00,840 --> 00:02:03,640
qui est le nom du fichier, nous avons fourni quand nous avons eu notre

45
00:02:03,640 --> 00:02:05,050
Rediriger programme.

46
00:02:05,050 --> 00:02:08,020
Ouvrons fichier.txt.

47
00:02:08,020 --> 00:02:11,840
Et ici, nous pouvons voir que la sortie standard de redirection était

48
00:02:11,840 --> 00:02:15,550
écrit dans le fichier appelé fichier.txt.

49
00:02:15,550 --> 00:02:18,470
Donc, nous allons exécuter la commande précédente à nouveau, mais fournir un

50
00:02:18,470 --> 00:02:20,075
d'entrée différent cette fois.

51
00:02:25,140 --> 00:02:25,900
D'accord.

52
00:02:25,900 --> 00:02:28,205
Jetons un coup d'oeil à file.txt maintenant.

53
00:02:31,070 --> 00:02:34,580
>> Nous pouvons voir ici que le fichier a été écrasé, donc notre

54
00:02:34,580 --> 00:02:37,120
d'entrée d'origine n'est plus là.

55
00:02:37,120 --> 00:02:40,280
Si nous voulons au lieu de joindre à ce dossier, mettre le nouveau

56
00:02:40,280 --> 00:02:43,600
entrée ci-dessous le contenu existant du fichier, nous pouvons

57
00:02:43,600 --> 00:02:46,800
utiliser deux signes supérieur au lieu d'un seul.

58
00:02:46,800 --> 00:02:48,050
Essayons.

59
00:02:52,160 --> 00:02:57,910
Maintenant, si nous ouvrons à nouveau fichier.txt, on peut voir à la fois de notre

60
00:02:57,910 --> 00:02:59,580
des lignes d'entrée.

61
00:02:59,580 --> 00:03:02,180
Dans certains cas, on peut vouloir jeter tout

62
00:03:02,180 --> 00:03:03,850
sortie de notre programme.

63
00:03:03,850 --> 00:03:06,450
Plutôt que d'écrire la sortie dans un fichier, puis supprimer

64
00:03:06,450 --> 00:03:09,310
le fichier quand nous aurons fini avec elle, nous pouvons écrire une tâche particulière

65
00:03:09,310 --> 00:03:12,360
fichier appelé / dev / null.

66
00:03:12,360 --> 00:03:15,160
Quand quelque chose est écrit dans / dev/null--

67
00:03:15,160 --> 00:03:16,960
ou tout simplement pour faire court devnull -

68
00:03:16,960 --> 00:03:18,950
il est automatiquement éliminé.

69
00:03:18,950 --> 00:03:23,290
Alors, pensez à devnull comme un trou noir pour vos données.

70
00:03:23,290 --> 00:03:26,070
>> Alors maintenant, nous avons vu comment le signe supérieur peut rediriger

71
00:03:26,070 --> 00:03:29,610
stdout, nous allons voir comment nous pouvons rediriger standard -

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

73
00:03:31,250 --> 00:03:33,550
l'analogue de stdout.

74
00:03:33,550 --> 00:03:36,010
Alors que les fonctions comme printf écrire dans le flux appelé

75
00:03:36,010 --> 00:03:40,500
stdout, GetString et des fonctions similaires lue dans le flux

76
00:03:40,500 --> 00:03:43,770
appelé stdin, qui, par défaut, est le flux de

77
00:03:43,770 --> 00:03:46,290
caractères tapés au clavier.

78
00:03:46,290 --> 00:03:50,010
Nous pouvons rediriger stdin en utilisant le signe inférieur, suivie

79
00:03:50,010 --> 00:03:51,370
par un nom de fichier.

80
00:03:51,370 --> 00:03:54,000
Maintenant, plutôt que de demander à l'utilisateur pour l'entrée à l'

81
00:03:54,000 --> 00:03:57,870
terminal, un programme pour ouvrir le fichier que nous avons spécifié et l'utilisation

82
00:03:57,870 --> 00:03:59,790
les lignes en entrée.

83
00:03:59,790 --> 00:04:02,620
>> Voyons voir ce qui se passe.

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

85
00:04:03,280 --> 00:04:07,590
La première ligne de file.txt a été imprimée à la borne

86
00:04:07,590 --> 00:04:10,160
parce que nous faisons appel GetString fois.

87
00:04:10,160 --> 00:04:13,170
Si nous avions un autre appel à GetString dans notre programme, le

88
00:04:13,170 --> 00:04:16,149
prochaine ligne de file.txt aurait été utilisé comme

89
00:04:16,149 --> 00:04:17,990
d'entrée pour cet appel.

90
00:04:17,990 --> 00:04:21,050
Encore une fois, nous n'avons pas modifié notre programme C du tout.

91
00:04:21,050 --> 00:04:23,620
Nous ne faisons que changer la façon dont nous l'exécutons.

92
00:04:23,620 --> 00:04:27,080
Et souvenez vous aussi, nous n'avons pas redirigé stdout cette fois,

93
00:04:27,080 --> 00:04:28,970
de sorte que la sortie du programme a été encore

94
00:04:28,970 --> 00:04:31,040
affichées sur le terminal.

95
00:04:31,040 --> 00:04:33,500
Nous pouvons, bien sûr, rediriger à la fois stdin

96
00:04:33,500 --> 00:04:37,320
et stdout comme ça.

97
00:04:37,320 --> 00:04:43,550
Maintenant, file2.txt contient la première ligne de file.txt.

98
00:04:43,550 --> 00:04:46,140
>> Ainsi, en utilisant ces opérateurs, nous avons été en mesure de lire et d'

99
00:04:46,140 --> 00:04:48,130
écrire à partir de fichiers texte.

100
00:04:48,130 --> 00:04:51,890
Maintenant, nous allons voir comment nous pouvons utiliser la sortie d'un programme

101
00:04:51,890 --> 00:04:54,710
l'entrée d'un autre programme.

102
00:04:54,710 --> 00:04:56,650
Alors, voici un autre programme simple C I

103
00:04:56,650 --> 00:05:00,190
ont appelé ici hello.c.

104
00:05:00,190 --> 00:05:02,617
Comme vous pouvez le voir, cette affiche simplement "Salut

105
00:05:02,617 --> 00:05:04,430
il "à l'utilisateur.

106
00:05:04,430 --> 00:05:08,890
Si je veux rediriger à utiliser comme entrée la sortie de bonjour -

107
00:05:08,890 --> 00:05:10,190
un autre programme -

108
00:05:10,190 --> 00:05:13,920
Je pourrait tout d'abord rediriger stdout bonjour à un fichier appelé

109
00:05:13,920 --> 00:05:18,960
input.txt, puis rediriger le stdin d'rediriger vers ce même

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

111
00:05:21,190 --> 00:05:26,730
Donc je peux faire. / Bonjour> input.txt.

112
00:05:26,730 --> 00:05:28,810
Appuyez sur Entrée pour exécuter cette.

113
00:05:28,810 --> 00:05:31,910
Suivie d'. / Redirect <

114
00:05:31,910 --> 00:05:35,270
input.txt, et d'exécuter cela.

115
00:05:35,270 --> 00:05:38,290
Donc, nous pouvons raccourcir un peu ceci avec un point-virgule, ce qui permet

116
00:05:38,290 --> 00:05:41,360
nous d'exécuter deux ou plusieurs commandes sur la même ligne.

117
00:05:41,360 --> 00:05:47,920
Donc je peux dire,. / Bonjour> input.txt, point-virgule,

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

119
00:05:53,850 --> 00:05:56,740
>> Donc, cela fonctionne, mais il se sent encore assez inélégant.

120
00:05:56,740 --> 00:05:59,530
Je veux dire, nous avons vraiment besoin de ce fichier texte intermédiaire qui est

121
00:05:59,530 --> 00:06:02,520
n'est plus nécessaire après redirection fonctionne?

122
00:06:02,520 --> 00:06:05,780
Heureusement, nous pouvons éviter ce fichier texte en utilisant ce qui est

123
00:06:05,780 --> 00:06:07,220
appelée pipe.

124
00:06:07,220 --> 00:06:13,740
Si je dis: / bonjour |.. / Rediriger, puis la sortie standard d'

125
00:06:13,740 --> 00:06:15,310
le programme sur la gauche -

126
00:06:15,310 --> 00:06:16,740
dans ce cas, bonjour -

127
00:06:16,740 --> 00:06:18,970
sera utilisée comme entrée pour la norme

128
00:06:18,970 --> 00:06:20,370
programme sur la droite.

129
00:06:20,370 --> 00:06:24,850
Dans ce cas, rediriger. Donc, nous allons lancer ça.

130
00:06:24,850 --> 00:06:25,930
>> Nous y voilà.

131
00:06:25,930 --> 00:06:30,080
Nous pouvons voir que la sortie de bonjour a été utilisé comme entrée

132
00:06:30,080 --> 00:06:31,520
pour rediriger.

133
00:06:31,520 --> 00:06:34,890
En enfilant commandes de concert avec les tuyaux, nous formons ce qui est

134
00:06:34,890 --> 00:06:38,120
appelé pipe-line, depuis notre sortie est essentiellement le déplacement

135
00:06:38,120 --> 00:06:40,590
à travers une séquence de commandes.

136
00:06:40,590 --> 00:06:43,570
Utilisant des tuyaux, on peut faire des trucs cool sans avoir besoin de

137
00:06:43,570 --> 00:06:45,870
écrire de code du tout.

138
00:06:45,870 --> 00:06:48,760
Par exemple, disons que nous voulons savoir combien de fichiers sont

139
00:06:48,760 --> 00:06:50,630
l'intérieur de ce répertoire.

140
00:06:50,630 --> 00:06:55,200
L'utilisation d'un tuyau, on peut combiner la commande ls avec le wc -

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

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

143
00:06:57,850 --> 00:07:02,230
Ls affichera tous les fichiers dans le répertoire de sortie standard, et

144
00:07:02,230 --> 00:07:08,040
wc nous dira combien de lignes ont été donnés à lui via stdin.

145
00:07:08,040 --> 00:07:12,440
Donc, si nous disons ls | wc-l -

146
00:07:12,440 --> 00:07:16,800
fournissant l'option-l pour wc pour lui dire de compter les lignes -

147
00:07:16,800 --> 00:07:19,260
nous pouvons voir exactement combien de fichiers sont

148
00:07:19,260 --> 00:07:21,940
dans le répertoire courant.

149
00:07:21,940 --> 00:07:24,570
>> Donc, nous allons jeter un coup d'oeil à un exemple de plus.

150
00:07:24,570 --> 00:07:27,740
J'ai ici un fichier appelé students.txt,

151
00:07:27,740 --> 00:07:29,600
avec une liste de noms.

152
00:07:29,600 --> 00:07:32,730
Toutefois, ces noms ne sont pas dans n'importe quel ordre tout cela, et il semble

153
00:07:32,730 --> 00:07:34,850
comme quelques noms sont répétés.

154
00:07:34,850 --> 00:07:38,510
Ce que nous voulons est une liste de noms uniques dans l'ordre alphabétique

155
00:07:38,510 --> 00:07:42,550
commande, enregistrée dans un fichier appelé final.txt.

156
00:07:42,550 --> 00:07:45,210
Nous pourrions, bien sûr, écrire un programme en C pour faire cela pour nous.

157
00:07:45,210 --> 00:07:46,560
Mais il va devenir inutilement

158
00:07:46,560 --> 00:07:48,560
complexe assez rapidement.

159
00:07:48,560 --> 00:07:51,740
Disons plutôt que d'utiliser des tuyaux et des built-in-outils pour résoudre

160
00:07:51,740 --> 00:07:53,300
ce problème.

161
00:07:53,300 --> 00:07:57,760
>> La première chose que nous devons faire est de lire le fichier students.txt.

162
00:07:57,760 --> 00:08:00,530
La commande cat va faire exactement cela.

163
00:08:00,530 --> 00:08:03,230
Il sera lu dans le fichier spécifié et écrire

164
00:08:03,230 --> 00:08:05,750
son contenu vers stdout.

165
00:08:05,750 --> 00:08:07,570
Après que nous avons lu le fichier texte, nous allons

166
00:08:07,570 --> 00:08:09,490
Pour trier les noms.

167
00:08:09,490 --> 00:08:12,510
La commande sort peut gérer cela pour nous.

168
00:08:12,510 --> 00:08:16,830
Trier va afficher la ligne alimenté par stdin vers stdout

169
00:08:16,830 --> 00:08:19,310
dans l'ordre.

170
00:08:19,310 --> 00:08:23,450
Afin de fournir le contenu de students.txt à

171
00:08:23,450 --> 00:08:29,600
stdin sorte, nous pourrions utiliser un tuyau de combiner chat et de tri.

172
00:08:29,600 --> 00:08:34,440
Donc, je peux exécuter chat students.txt | trier et

173
00:08:34,440 --> 00:08:35,640
appuyez sur Entrée.

174
00:08:35,640 --> 00:08:39,309
Et maintenant, nous voyons le contenu de students.txt dans

175
00:08:39,309 --> 00:08:40,909
ordre alphabétique.

176
00:08:40,909 --> 00:08:42,860
>> Donc, nous allons ajouter une autre commande -

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

178
00:08:44,730 --> 00:08:46,230
à notre portefeuille.

179
00:08:46,230 --> 00:08:49,810
Comme vous pouvez le deviner, uniq, lorsqu'il est fourni une séquence ordonnée d'

180
00:08:49,810 --> 00:08:53,650
lignes via stdin, va afficher les lignes uniques.

181
00:08:53,650 --> 00:08:56,910
Nous avons donc maintenant students.txt chat

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

183
00:09:00,040 --> 00:09:03,330
Enfin, on peut enregistrer la sortie de la canalisation à une

184
00:09:03,330 --> 00:09:09,090
fichier via chat students.txt | sort | uniq

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

186
00:09:12,440 --> 00:09:16,260
Donc, si nous ouvrons final.txt, nous avons exactement ce que nous étions

187
00:09:16,260 --> 00:09:17,270
à la recherche de:

188
00:09:17,270 --> 00:09:20,180
une liste de noms uniques dans l'ordre alphabétique,

189
00:09:20,180 --> 00:09:22,150
enregistrées dans un fichier texte.

190
00:09:22,150 --> 00:09:26,020
Par ailleurs, nous avons également pu dire sort <

191
00:09:26,020 --> 00:09:32,290
students.txt | uniq> final.txt de faire exactement

192
00:09:32,290 --> 00:09:35,400
la même chose, en utilisant chacun des opérateurs que nous avons vu dans

193
00:09:35,400 --> 00:09:36,580
cette vidéo.

194
00:09:36,580 --> 00:09:39,540
>> Mon nom est Tommy, et c'est CS50.