1
00:00:07,060 --> 00:00:08,420
[Powered by Google Translate] ტომი: ამ ვიდეო, ჩვენ გაეცნობიან

2
00:00:08,420 --> 00:00:10,140
გადამისამართება და მილები.

3
00:00:10,140 --> 00:00:12,780
ჯერჯერობით, ჩვენ იყენებს ფუნქციებს like printf to

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
>> On line 7, ჩვენ რითაც მომხმარებლის ამისთვის სიმებიანი და

10
00:00:28,990 --> 00:00:31,680
მაშინ on line 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
როდესაც რაღაც იწერება stdout, ეს იყოს

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
გადამისამართება stdout to ფაილი.

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
და აქ ჩვენ ვხედავთ, რომ stdout გარეთ გადამისამართება იყო

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

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
ფაილი სახელად / განვითარება / 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
stdout, ვნახოთ როგორ შეგვიძლია გადამისამართება სტანდარტი -

72
00:03:29,610 --> 00:03:31,250
ან s-t-D-ში -

73
00:03:31,250 --> 00:03:33,550
იუმორისტული stdout.

74
00:03:33,550 --> 00:03:36,010
მიუხედავად იმისა, ფუნქციების like printf ჩაწერის ნაკადი მოუწოდა

75
00:03:36,010 --> 00:03:40,500
stdout, 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
ჩვენ შეგვიძლია გადამისამართება stdin გამოყენებით ნაკლები ნიშანი, რასაც მოჰყვება

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
და ასევე გახსოვთ, ჩვენ არ გადამისამართებულ stdout ამ დროს,

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
ჩვენ შეგვიძლია, რა თქმა უნდა, გადამისამართება ორივე stdin

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 I

103
00:04:56,650 --> 00:05:00,190
არ აქ მოუწოდა hello.c.

104
00:05:00,190 --> 00:05:02,617
როგორც ხედავთ, ამ უბრალოდ შედეგები "Hi

105
00:05:02,617 --> 00:05:04,430
იქ! ", რათა მომხმარებელს.

106
00:05:04,430 --> 00:05:08,890
თუკი მინდა გადამისამართება გამოიყენოთ როგორც შეყვანის გამოშვება მიესალმები -

107
00:05:08,890 --> 00:05:10,190
კიდევ ერთი პროგრამა -

108
00:05:10,190 --> 00:05:13,920
შემეძლო პირველი გადამისამართება stdout of მოკითხვა ფაილი სახელად

109
00:05:13,920 --> 00:05:18,960
input.txt, მაშინ გადამისამართება stdin of გადამისამართება იმავე

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
ასე რომ ჩვენ შეგვიძლია შემცირება ამ bit ერთად მძიმით, რომელიც საშუალებას იძლევა

116
00:05:38,290 --> 00:05:41,360
us გასაშვებად ორი ან მეტი ბრძანებები იმავე ხაზის.

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
>> ასე რომ, ეს სამუშაოები, მაგრამ ეს ჯერ კიდევ გრძნობს საკმაოდ inelegant.

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
თუ მე ვიტყვი,. / მიესალმები |. / გადამისამართება, მაშინ stdout of

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
გამოყენებული იქნება როგორც სტანდარტული input for

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
ჩვენ ვხედავთ, რომ გამოშვებულ მიესალმები იქნა გამოყენებული როგორც შეყვანის

132
00:06:30,080 --> 00:06:31,520
ამისთვის გადამისამართება.

133
00:06:31,520 --> 00:06:34,890
By stringing ბრძანებები ერთად გამოყენებით მილები, ჩვენ ქმნიან რა

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
გამოყენება მილები, ჩვენ შეგვიძლია გავაკეთოთ ზოგიერთი cool პერსონალის გარეშე სჭირდება, რათა

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 დაბეჭდავს თითოეული ფაილის დირექტორიის stdout, და

144
00:07:02,230 --> 00:07:08,040
WC გვეტყვის რამდენი ხაზები გადაეცათ ის მეშვეობით stdin.

145
00:07:08,040 --> 00:07:12,440
ასე რომ, თუ ვიტყვით ls | WC-L -

146
00:07:12,440 --> 00:07:16,800
ამარაგებს-L დროშა WC ვუთხრა მას ითვლიან ხაზები -

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
დალაგების ბრძანება შეუძლია ამ ჩვენთვის.

168
00:08:12,510 --> 00:08:16,830
დალაგების დაბეჭდავს ხაზის მეშვეობით მიწოდებული stdin to stdout

169
00:08:16,830 --> 00:08:19,310
წელს დახარისხებული მიზნით.

170
00:08:19,310 --> 00:08:23,450
იმისათვის, რომ მიაწოდოს შინაარსი students.txt to

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
ხაზების მეშვეობით stdin, დაბეჭდავს უნიკალური ხაზები.

181
00:08:53,650 --> 00:08:56,910
ახლა ჩვენ გვაქვს cat students.txt

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

183
00:09:00,040 --> 00:09:03,330
და ბოლოს, ჩვენ შეგვიძლია გადარჩენა გამოშვება მილსადენის

184
00:09:03,330 --> 00:09:09,090
ფაილის მეშვეობით cat students.txt | sort | 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.