[Powered by Google Translate] ტომი: ამ ვიდეო, ჩვენ გაეცნობიან
გადამისამართება და მილები.
ჯერჯერობით, ჩვენ იყენებს ფუნქციებს like printf to
გამომავალი მონაცემების ტერმინალში და ფუნქციები, როგორიცაა GetString
დაუშვას მომხმარებლის უზრუნველყოს შეყვანის ჩვენი
პროგრამის გამოყენებით კლავიატურაზე.
მოდით სწრაფად შევხედოთ პროგრამა, რომელიც იღებს ხაზი
შეიტანენ მომხმარებლის და შემდეგ შედეგები იგი.
>> On line 7, ჩვენ რითაც მომხმარებლის ამისთვის სიმებიანი და
მაშინ on line 8, ჩვენ დაბეჭდვის უკან გარეთ.
მოდით კომპილირდება და აწარმოებს ჩვენი პროგრამა.
დიდი.
სიმებიანი ჩვენ გათვალისწინებული იყო გაიმეორა უკან
ჩვენთვის გამართულ ტერმინალში.
ეს მოხდა იმის გამო printf ფუნქცია მისწერა
ნაკადი მოუწოდა სტანდარტული მათგანი, ან s-t-D-out.
როდესაც რაღაც იწერება stdout, ეს იყოს
ნაჩვენები მიერ ტერმინალში.
>> ასე რომ ყველა კარგად და კარგი, მაგრამ რა, თუ, ნაცვლად უბრალოდ
ჩვენებისას სიმებიანი, გვინდოდა შეინახავთ მას ფაილი?
მაგალითად, ჩვენ დაგვჭირდება გახსოვთ ზუსტად რა ჩვენი
პროგრამა გააკეთეს, როდესაც ჩვენ მისცა კერძოდ შეყვანის მოგვიანებით.
ერთი მიდგომა იქნებოდა ამის გაკეთება ჩვენს C პროგრამის გამოყენებით
ზოგიერთი სპეციალური ფუნქციები წერილობით ფაილი რომ ჩვენ
იხილეთ სხვა ვიდეო.
მაშინაც კი, ადვილია, თუმცა, იქნება, რათა როგორმე
გადამისამართება stdout to ფაილი.
რომ გზა, როდესაც printf წერს stdout, შინაარსი იქნება
უნდა ჩაიწეროს ფაილის ვიდრე
ნაჩვენები მიერ ტერმინალში.
ჩვენ შეგვიძლია გავაკეთოთ მხოლოდ, რომ დამატებით მეტ-ზე ნიშანი, რასაც მოჰყვება
მიერ ფაილის სახელი, რომ ბრძანება ვიყენებთ, რათა შესრულდეს ჩვენი პროგრამა.
>> ასე რომ, ვიდრე უბრალოდ შესრულებაში. / გადამისამართება, ჩვენ შეგვიძლია
აწარმოებს. / გადამისამართება, მოჰყვა მეტი ნიშანი, რასაც მოჰყვება
ფაილის სახელი, ისევე როგორც file.txt.
ვნახოთ, რა მოხდება.
OK.
გაითვალისწინეთ, რომ ამ დროს, არაფერი ნაჩვენებია ტერმინალი,
მაგრამ ჩვენ არ შეცვლილია შინაარსი ჩვენი
C პროგრამის ყველა.
მოდით ახლა შეამოწმოს შინაარსი ამ დირექტორიაში ერთად ls.
>> ყველა უფლება.
ჩვენ ახლა აქვს ახალი ფაილი ჩვენს დირექტორია მოუწოდა file.txt,
რაც ფაილის სახელი ჩვენ მიწოდებული როდესაც ჩვენ გაიქცა ჩვენი
გადამისამართება პროგრამა.
მოდით გახსენით file.txt.
და აქ ჩვენ ვხედავთ, რომ stdout გარეთ გადამისამართება იყო
იწერება ფაილი მოუწოდა file.txt.
მოდით აწარმოებს წინა ბრძანება, მაგრამ ამარაგებს
სხვადასხვა შეყვანის ამ დროს.
Okay.
მოდით შევხედოთ file.txt არის.
>> ჩვენ ვხედავთ, რომ ფაილი უკვე ინსტალერის, ამიტომ ჩვენი
ორიგინალური შეყვანის იქ არ არის უქმნით.
თუ ჩვენ ნაცვლად გვინდა დამატება ამ ფაილს, აყენებს ახალ
შეყვანის ქვემოთ არსებული შინაარსი ფაილი, ჩვენ შეგვიძლია
გამოიყენოთ ორი მეტ-ზე ნიშნების ნაცვლად მხოლოდ ერთი.
მოდით ვეცადოთ, რომ.
ახლა, თუ ჩვენ გახსნა file.txt ერთხელ, ვხედავთ ორივე ჩვენი
შეყვანის ხაზები.
ზოგიერთ შემთხვევაში, ჩვენ დაგვჭირდება გაუქმება ნებისმიერი
გამომავალი ჩვენი პროგრამის.
იმის ნაცვლად, რომ წერა გასასვლელი ფაილი და შემდეგ წაშლა
ფაილი როდესაც ჩვენ გავაკეთეთ, ჩვენ შეგიძლიათ დაწეროთ სპეციალურ
ფაილი სახელად / განვითარება / null.
როდესაც არაფერი წერია, რათა / dev/null--
ან უბრალოდ devnull მოკლე -
ის ავტომატურად უგულვებელყოფილია.
ამიტომ ვფიქრობ devnull როგორც შავი ხვრელი თქვენი მონაცემები.
>> ახლა ჩვენ ვხედავთ, თუ როგორ მეტია ნიშანი შეიძლება გადამისამართება
stdout, ვნახოთ როგორ შეგვიძლია გადამისამართება სტანდარტი -
ან s-t-D-ში -
იუმორისტული stdout.
მიუხედავად იმისა, ფუნქციების like printf ჩაწერის ნაკადი მოუწოდა
stdout, GetString და ანალოგიური ფუნქციების წაკითხვის ნაკადი
მოუწოდა stdin, რომელიც, ჩვეულებრივ, არის ნაკადი
გმირები აკრეფილი დროს კლავიატურაზე.
ჩვენ შეგვიძლია გადამისამართება stdin გამოყენებით ნაკლები ნიშანი, რასაც მოჰყვება
მიერ ფაილის სახელი.
ახლა, ვიდრე რამაც მომხმარებლის ამისთვის შეყვანის დროს
ტერმინალი, პროგრამის გახსნის ფაილის ჩვენ მითითებული და გამოყენება
მისი ხაზები როგორც დასტური.
>> ვნახოთ, რა მოხდება.
დიდი.
პირველი ხაზი file.txt უკვე დაბეჭდილი, რათა ტერმინალი
რადგან ჩვენ მოუწოდებდა GetString ერთხელ.
თუ ჩვენ გვქონდა მეორე ზარი GetString ჩვენს პროგრამას,
შემდეგი ხაზი file.txt გამოყენებული იქნებოდა, როგორც
შეყვანის რომ ზარი.
ისევ და ისევ, ჩვენ არ შეცვლილია ჩვენი C პროგრამის ყველა.
ჩვენ მხოლოდ იცვლება თუ როგორ გაუშვით.
და ასევე გახსოვთ, ჩვენ არ გადამისამართებულ stdout ამ დროს,
ასე გამომავალი პროგრამის ჯერ კიდევ
ნაჩვენებია ტერმინალში.
ჩვენ შეგვიძლია, რა თქმა უნდა, გადამისამართება ორივე stdin
და stdout მოსწონს ეს.
ახლა, file2.txt შეიცავს პირველი რიგის file.txt.
>> ამიტომ მათი გამოყენებით ოპერატორები, ჩვენ შევძელით წაიკითხა და
წერენ საწყისი ტექსტი ფაილი.
ახლა ვნახოთ, თუ როგორ შეგვიძლია გამოვიყენოთ გამომავალი ერთი პროგრამა
შეყვანის სხვა პროგრამა.
ასე რომ აქ კიდევ ერთი მარტივი პროგრამა C I
არ აქ მოუწოდა hello.c.
როგორც ხედავთ, ამ უბრალოდ შედეგები "Hi
იქ! ", რათა მომხმარებელს.
თუკი მინდა გადამისამართება გამოიყენოთ როგორც შეყვანის გამოშვება მიესალმები -
კიდევ ერთი პროგრამა -
შემეძლო პირველი გადამისამართება stdout of მოკითხვა ფაილი სახელად
input.txt, მაშინ გადამისამართება stdin of გადამისამართება იმავე
ფაილი - input.txt.
ასე, რომ არ შეუძლია გააკეთოს. / მიესალმები> input.txt.
დააჭირეთ Enter შეასრულოს ამ.
მოჰყვა. / გადამისამართება <
input.txt, და შეასრულოს რომ.
ასე რომ ჩვენ შეგვიძლია შემცირება ამ bit ერთად მძიმით, რომელიც საშუალებას იძლევა
us გასაშვებად ორი ან მეტი ბრძანებები იმავე ხაზის.
ამიტომ შემიძლია ვთქვა, რომ. / მიესალმები> input.txt, მძიმით,
. / გადამისამართება <input.txt.
>> ასე რომ, ეს სამუშაოები, მაგრამ ეს ჯერ კიდევ გრძნობს საკმაოდ inelegant.
ვგულისხმობ, ჩვენ ნამდვილად გვჭირდება ამ შუამავალი ტექსტური ფაილი რომ
აღარ საჭირო შემდეგ გადამისამართება ეშვება?
საბედნიეროდ, ჩვენ შეგვიძლია თავიდან ავიცილოთ ამ დამატებითი ტექსტური ფაილი გამოყენებით რა
მოუწოდა მილის.
თუ მე ვიტყვი,. / მიესალმები |. / გადამისამართება, მაშინ stdout of
პროგრამის მარცხენა -
ამ შემთხვევაში, მიესალმები -
გამოყენებული იქნება როგორც სტანდარტული input for
პროგრამის უფლება.
ამ შემთხვევაში გადამისამართება. მოდით აწარმოებს ამ.
>> იქ ჩვენ წავიდეთ.
ჩვენ ვხედავთ, რომ გამოშვებულ მიესალმები იქნა გამოყენებული როგორც შეყვანის
ამისთვის გადამისამართება.
By stringing ბრძანებები ერთად გამოყენებით მილები, ჩვენ ქმნიან რა
მოუწოდა მილსადენი, რადგან ჩვენი გამომავალი არსებითად მოძრავი
მეშვეობით თანმიმდევრობა ბრძანებები.
გამოყენება მილები, ჩვენ შეგვიძლია გავაკეთოთ ზოგიერთი cool პერსონალის გარეშე სჭირდება, რათა
დაწერეთ ნებისმიერი კოდი ყველა.
მაგალითად, ვთქვათ ჩვენ გვინდა ვიცოდეთ, რამდენი ფაილი
შიგნით ამ დირექტორიაში.
გამოყენება მილსადენი, შეგვიძლია დააკავშიროთ ls ბრძანება ერთად WC -
ან wordcount -
ბრძანება.
LS დაბეჭდავს თითოეული ფაილის დირექტორიის stdout, და
WC გვეტყვის რამდენი ხაზები გადაეცათ ის მეშვეობით stdin.
ასე რომ, თუ ვიტყვით ls | WC-L -
ამარაგებს-L დროშა WC ვუთხრა მას ითვლიან ხაზები -
ვხედავთ ზუსტად რამდენი ფაილი
მიმდინარე დირექტორია.
>> მოდით შევხედოთ კიდევ ერთი ნათელი მაგალითია.
მაქვს აქ ფაილი სახელად students.txt,
ერთად სიაში სახელები.
თუმცა, ეს სახელები არ არიან ნებისმიერი თანმიმდევრობით ეს ყველაფერი, და ეს გამოიყურება
მოსწონს რამდენიმე სახელები განმეორდეს.
რაც გვინდა არის სიაში უნიკალური სახელები ანბანის
იმისათვის, შეინახება ფაილი სახელად final.txt.
ჩვენ შეგვეძლო, რა თქმა უნდა, დაწეროს C პროგრამის ამის გაკეთება ჩვენთვის.
მაგრამ აპირებს მიიღოს ზედმეტად
კომპლექსი საკმაოდ სწრაფად.
მოდით ნაცვლად გამოიყენოთ მილები და ზოგიერთი ჩამონტაჟებული დაზგები მოსაგვარებლად
ეს პრობლემა.
>> პირველი, რაც უნდა გავაკეთოთ არის წაკითხულად ფაილი students.txt.
Cat ბრძანება გავაკეთებ მხოლოდ, რომ.
ეს იქნება წაიკითხონ მითითებული ფაილი და დაწეროთ
მისი შინაარსი, რათა stdout.
შემდეგ ჩვენ წაიკითხა ტექსტური ფაილი, ჩვენ
გსურთ დასალაგებლად სახელები.
დალაგების ბრძანება შეუძლია ამ ჩვენთვის.
დალაგების დაბეჭდავს ხაზის მეშვეობით მიწოდებული stdin to stdout
წელს დახარისხებული მიზნით.
იმისათვის, რომ მიაწოდოს შინაარსი students.txt to
დალაგების ს stdin, შეიძლება გამოიყენოთ მილის დააკავშიროთ კატა და დალაგება.
ასე, რომ შეიძლება შეასრულოს cat students.txt | დალაგება და
დააჭირეთ Enter-ს.
და ახლა, ჩვენ ვხედავთ შინაარსის students.txt წელს
ანბანური თანმიმდევრობით.
>> მოდით დავამატოთ ახალი ბრძანება -
uniq, ან უნიკალური -
ჩვენი მილსადენი.
როგორც თქვენ ალბათ მიხვდები, uniq, როდესაც მიწოდებული დახარისხებული თანმიმდევრობა
ხაზების მეშვეობით stdin, დაბეჭდავს უნიკალური ხაზები.
ახლა ჩვენ გვაქვს cat students.txt
| Sort | uniq.
და ბოლოს, ჩვენ შეგვიძლია გადარჩენა გამოშვება მილსადენის
ფაილის მეშვეობით cat students.txt | sort | uniq
> Final.txt.
ასე რომ, თუ ჩვენ გახსენით final.txt, ჩვენ გვაქვს ზუსტად რა ვიყავით
ეძებს:
სიაში უნიკალური სახელები ანბანის მიხედვით,
შეინახება ტექსტური ფაილი.
სხვათა შორის, ჩვენ ასევე შეეძლო განაცხადა დალაგების <
students.txt | uniq> final.txt გავაკეთოთ ზუსტად
იგივე გამოყენებით თითოეული ოპერატორების ჩვენ ვნახეთ წელს
ამ ვიდეო.
>> ჩემი სახელი არის ტომი, და ეს არის CS50.