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
अब तक, हम कार्यों का उपयोग कर रहा है की तरह printf

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
उपयोगकर्ता से इनपुट और फिर यह outputs.

9
00:00:25,960 --> 00:00:28,990
>> 7 लाइन पर, हम एक स्ट्रिंग के लिए उपयोगकर्ता उत्साह रहे हैं, और

10
00:00:28,990 --> 00:00:31,680
फिर 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
धारा मानक बाहर कहा जाता है, या एस - टी - घ बाहर.

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
एक दृष्टिकोण के लिए हमारे सी कार्यक्रम में ऐसा करते हैं, का उपयोग किया जाएगा

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 अनुप्रेषित.

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
ठीक है.

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
सी कार्यक्रम.

41
00:01:52,040 --> 00:01:56,090
चलो अब रास के साथ इस निर्देशिका की सामग्री की जांच.

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
ठीक है.

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
/ dev / 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
या एस - टी - घ में -

73
00:03:31,250 --> 00:03:33,550
stdout के अनुरूप.

74
00:03:33,550 --> 00:03:36,010
हालांकि कार्यों की तरह 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
फिर, हम अपने सी कार्यक्रम में नहीं संशोधित किया है.

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
तो यहाँ एक साधारण सी कार्यक्रम मैं

103
00:04:56,650 --> 00:05:00,190
यहाँ hello.c कहा जाता है.

104
00:05:00,190 --> 00:05:02,617
जैसा कि आप देख सकते हैं, यह सिर्फ outputs "हाय

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 अनुप्रेषित सकता

109
00:05:13,920 --> 00:05:18,960
input.txt, तो है कि एक ही अनुप्रेषित की stdin अनुप्रेषित

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
तो हम एक सेमीकोलन के साथ यह थोड़ा कम कर सकते हैं, जो की अनुमति देता है

116
00:05:38,290 --> 00:05:41,360
हमें एक ही लाइन पर दो या दो से अधिक कमांड चलाने के लिए.

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
>> तो यह काम करता है, लेकिन यह अभी भी सुंदर असजीला लगता है.

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

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
के लिए मानक इनपुट के रूप में इस्तेमाल किया जाएगा

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
आज्ञाओं एक साथ 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
पाइप का उपयोग करना है, हम को ज़रूरत के बिना कुछ अच्छा सामान कर सकते हैं

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
एक पाइप का उपयोग करना, हम 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
रास के लिए 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
wc-l झंडा की आपूर्ति करने के लिए यह बताने के लिए पंक्तियों की गणना

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
हम, ज़ाहिर है, हमारे लिए यह करने के लिए एक सी कार्यक्रम लिख सकता है.

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
बिल्ली आदेश सिर्फ इतना है कि क्या करेंगे.

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
क्रमबद्ध करें stdout के लिए stdin के माध्यम से आपूर्ति की लाइन उत्पादन होगा

169
00:08:16,830 --> 00:08:19,310
क्रमबद्ध क्रम में.

170
00:08:19,310 --> 00:08:23,450
आदेश में students.txt की सामग्री की आपूर्ति करने के लिए

171
00:08:23,450 --> 00:08:29,600
stdin तरह है, हम एक पाइप का उपयोग करने के लिए बिल्ली और तरह का गठबंधन सकता है.

172
00:08:29,600 --> 00:08:34,440
सॉर्ट और | तो मैं बिल्ली students.txt पर अमल कर सकते हैं

173
00:08:34,440 --> 00:08:35,640
प्रेस दर्ज करें.

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
तो अब हम बिल्ली students.txt

182
00:08:56,910 --> 00:09:00,040
तरह | | uniq.

183
00:09:00,040 --> 00:09:03,330
अंत में, हम एक पाइपलाइन के उत्पादन को बचाने कर सकते हैं

184
00:09:03,330 --> 00:09:09,090
तरह | | uniq बिल्ली students.txt माध्यम से फाइल

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 है.