[Powered by Google Translate] Tommy: I den här videon kommer vi att lära om
omdirigera och rör.
Hittills har vi använt funktioner som printf till
utdata till terminalen och funktioner som GetString
att låta användaren att bidra till vår
program med tangentbordet.
Låt oss ta snabbt en titt på ett program som får en rad
inmatning från användaren och matar sedan ut den.
>> På rad 7, vi uppmanar användaren efter en sträng, och
sedan på rad 8, vi skriver den ut igen.
Låt oss kompilera och köra vårt program.
Jättebra.
Strängen vi som upprepades tillbaka
till oss på terminalen.
Detta skedde på grund av printf funktionen skrev till en
ström kallas standard ut eller s-t-d-ut.
När något skrivs till stdout, det som standard
visas av terminalen.
>> Så det är allt gott och väl, men vad händer om, istället för att bara
visa strängen, ville vi spara den till en fil?
Till exempel kan vi vill minnas exakt vad vi
Programmet gjorde när vi gav det en viss ingång senare.
Ett sätt skulle vara att göra det i vår C-program med hjälp av
några speciella funktioner för att skriva till filer som vi kommer
se i en annan video.
Ännu enklare, men skulle vara att på något sätt
omdirigera stdout till en fil.
På så sätt, när printf skriver till stdout, innehållet kommer
skrivas till en fil i stället
visas av terminalen.
Vi kan göra just detta genom att lägga till en större-än-tecken följt
av ett filnamn, till kommandot vi använder för att köra vårt program.
>> Så snarare än att bara köra. / Redirect kan vi
kör. / redirect, följt av en större än-tecken, följt av
filnamn, som file.txt.
Låt oss se vad som händer.
OK.
Observera att denna tid ingenting visas på terminalen,
men vi har inte ändrat innehållet i vår
C-program alls.
Låt oss nu undersöka innehållet i den här katalogen med ls.
>> Okej.
Vi har nu en ny fil i vår katalog som heter file.txt,
vilket är filnamnet levererade vi när vi körde vår
Redirect programmet.
Vi öppnar upp file.txt.
Och här kan vi se att stdout ur omdirigera var
skrivs till filen som heter file.txt.
Så låt oss köra föregående kommando igen, men levererar en
olika in denna gång.
Okej.
Låt oss ta en titt på file.txt nu.
>> Vi kan här se att filen har skrivits över, så vår
ursprungliga ingången finns inte längre.
Om vi ​​istället vill lägga till den här filen, sätta nya
ingång under de befintliga innehållet i filen kan vi
Använd två större-än-tecken istället för bara en.
Låt oss prova det.
Nu, om vi öppnar file.txt igen, kan vi se både vår
ingångsledningar.
I vissa fall kan vi vill kasta något
utgång vårt program.
I stället för att skriva utdata till en fil och sedan ta bort
filen när vi är klara med det, kan vi skriva en särskild
fil som heter / dev / null.
När allt är skrivet till / dev/null--
eller bara devnull för kort -
den automatiskt kasseras.
Så tänk på devnull som ett svart hål för dina data.
>> Så nu har vi sett hur större än skylten kan omdirigera
stdout, låt oss se hur vi kan omdirigera standard -
eller s-t-d-in -
den analog standard ut.
Medan funktioner som printf skriva till kallas strömmen
stdout, GetString och liknande funktioner läses från strömmen
kallas stdin, som som standard är strömmen av
tecken skrivs på tangentbordet.
Vi kan omdirigera stdin med mindre än-tecken följt
av ett filnamn.
Nu, i stället för att användaren för inmatning på
terminalen kommer ett program att öppna filen vi specificerade och använder
dess linjer som indata.
>> Låt oss se vad som händer.
Jättebra.
Den första raden i file.txt har skrivits till terminalen
eftersom vi kallar GetString gång.
Om vi ​​hade en annan uppmaning till GetString i vårt program, det
nästa rad av fil.txt skulle ha använts som
ingång till det samtalet.
Återigen har vi ändrat inte vår C-program alls.
Vi bara ändra hur vi kör den.
Och även komma ihåg att vi inte har omdirigerats stdout den här gången,
så att utsignalen från systemet fortfarande var
visas på terminalen.
Vi kan naturligtvis omdirigera både stdin
och stdout så här.
Nu innehåller file2.txt första raden fil.txt.
>> Så med hjälp av dessa operatörer har vi kunnat läsa och
skriva från textfiler.
Nu ska vi se hur vi kan använda utdata från ett program som
ingången till ett annat program.
Så här är en annan enkel C-program som jag
har här kallat hej.c.
Som ni kan se, matar detta helt enkelt "Hej
där! "för användaren.
Om jag vill omdirigera använda som indata utgången av Hello -
annat program -
Jag kunde först omdirigera stdout av hej till en fil som heter
input.txt sedan omdirigera stdin om omdirigering till samma
fil - input.txt.
Så jag kan göra. / Hej> input.txt.
Tryck på Enter för att utföra detta.
Följt av. / Redirect <
input.txt och köra det.
Så vi kan förkorta det lite med ett semikolon, som tillåter
oss att köra två eller flera kommandon på samma linje.
Så jag kan säga,. / Hej> input.txt, semikolon,
. / Redirect <input.txt.
>> Så här fungerar, men det känns ändå ganska klumpiga.
Jag menar, vi behöver verkligen den här filen mellanhand text som är
inte längre nödvändigt efter omdirigera körningar?
Lyckligtvis kan vi undvika denna extra textfil med vad
kallas ett rör.
Om jag säger, / hej |.. / Redirect, då stdout av
programmet på vänster -
i detta fall, hej -
kommer att användas som standard ingång för
programmet till höger.
I det här fallet, omdirigera. Så låt oss köra.
>> Där kör vi.
Vi kan se att utsignalen från hello användes som indata
för omdirigering.
Genom stringing kommandon tillsammans med rör, bildar vi vad
kallas en rörledning, eftersom vår produktion är i huvudsak rör
genom en sekvens av kommandon.
Med hjälp av rör, kan vi göra en del coola saker utan att behöva
skriva någon kod alls.
Till exempel, låt oss säga att vi vill veta hur många filer
insidan av denna katalog.
Med hjälp av ett rör, kan vi kombinera ls-kommandot med wc -
eller wordcount -
kommando.
Ls kommer mata varje fil i katalogen till stdout och
wc berättar hur många rader gavs till den via stdin.
Så om vi säger ls | wc-l -
levererar-l flaggan till wc för att berätta det att räkna rader -
Vi kan se exakt hur många filer
i den aktuella katalogen.
>> Så låt oss ta en titt på ett exempel.
Jag har här en fil som heter students.txt,
med en lista med namn.
Men dessa namn är inte i vilken ordning allt, och det ser
Liksom några namn upprepas.
Vad vi vill ha är en lista med unika namn i alfabetisk
ordning, sparas i en fil som heter final.txt.
Vi kunde naturligtvis skriva en C-program för att göra detta för oss.
Men det kommer att bli onödigt
komplex ganska snabbt.
Låt oss istället använda rör och några inbyggd-verktyg för att lösa
detta problem.
>> Det första vi behöver göra är att läsa filen students.txt.
Kommandot cat kommer att göra just det.
Den kommer att läsa i den angivna filen och skriva
dess innehåll till stdout.
Efter att vi har läst textfilen, vi
vill sortera namnen.
Kommandot Sortera kan hantera detta för oss.
Sortera matar ut linan matas via stdin till stdout
i sorterad ordning.
För att leverera innehållet i students.txt till
Sortera: s standard in, kan vi använda ett rör för att kombinera katt och sortera.
Så jag kan köra cat students.txt | sortera och
tryck på Enter.
Och nu ser vi innehåll students.txt i
alfabetisk ordning.
>> Så låt oss lägga till ytterligare kommando -
Uniq, eller unik -
till vår pipeline.
Som du kan gissa, uniq, vid leverans en sorterad sekvens av
linjer via stdin, matar ut de unika linjer.
Så nu har vi katt students.txt
| Sortera | uniq.
Slutligen kan vi spara resultatet av rörledningen till en
filen via katt students.txt | Sortera | uniq
> Final.txt.
Så, om vi öppnar final.txt har vi exakt vad vi var
letar efter:
en lista med unika namn i alfabetisk ordning,
sparas i en textfil.
Förresten, vi också kunde ha sagt Sortera <
students.txt | Uniq> final.txt att göra exakt
samma sak med hjälp var och en av de operatörer som vi har sett i
denna video.
>> Mitt namn är Tommy, och detta är CS50.