[Powered by Google Translate] TOMMY: I denne videoen, vil vi lære om
omdirigere og rør.
Så langt har vi brukt funksjoner som printf til
utdata til terminalen og funksjoner som GetString
å tillate brukeren å gi innspill til vårt
programmet ved hjelp av tastaturet.
La oss raskt ta en titt på et program som får en linje av
input fra brukeren, og deretter utganger det.
>> På linje 7, vi spørre brukeren for en streng, og
deretter på linje 8, vi skriver den ut igjen.
La oss kompilere og kjøre programmet vårt.
Flott.
Strengen vi gitt var echoed tilbake
til oss på terminalen.
Dette skjedde fordi printf funksjonen skrev til en
bekk kalt standard ut, eller s-t-d-out.
Når noe er skrevet til stdout, er det som standard
vises av terminalen.
>> Så det er vel og bra, men hva om, i stedet for bare
viser strengen, ønsket vi å lagre den til en fil?
For eksempel kan vi ønsker å huske nøyaktig hva våre
Programmet gjorde da vi ga det en bestemt inngang senere.
En tilnærming ville være å gjøre dette i vår C-program ved hjelp
noen spesielle funksjoner for å skrive til filer som vi vil
se i en annen video.
Enda enklere, skjønt, ville være å liksom
omdirigere stdout til en fil.
På den måten når printf skriver til stdout, innholdet vil
bli skrevet til en fil i stedet
vises av terminalen.
Vi kan gjøre akkurat det ved å legge til en større-enn-tegn, etterfulgt
ved et filnavn, til kommandoen bruker vi til å gjennomføre vårt program.
>> Så, i stedet for bare å kjøre. / Redirect, kan vi
kjøre. / redirect, etterfulgt av en større enn tegn, etterfulgt av
filnavn, som file.txt.
La oss se hva som skjer.
OK.
Legg merke til at denne tiden ble noe som vises i terminalen,
men vi har ikke endret innholdet i vår
C-program i det hele tatt.
La oss nå undersøke innholdet i denne katalogen med ls.
>> OK.
Vi har nå en ny fil i katalogen vår som heter file.txt,
som er filnavnet vi levert da vi kjørte våre
Omadresser program.
La oss åpne opp file.txt.
Og her kan vi se at stdout av omdirigere var
skrevet til filen som heter file.txt.
Så la oss kjøre den forrige kommandoen igjen, men leverer en
annen inngang denne gangen.
Okay.
La oss ta en titt på file.txt nå.
>> Vi ser her at filen er overskrevet, så vår
opprinnelige inngangen er ikke der lenger.
Dersom vi i stedet ønsker å føye til denne filen, setter den nye
innspill under det eksisterende innholdet i filen, kan vi
bruke to større-enn tegn i stedet for bare én.
La oss prøve det.
Nå, hvis vi åpner file.txt igjen, kan vi se både av våre
innspill linjer.
I noen tilfeller kan vi ønsker å forkaste ethvert
produksjon av vårt program.
Snarere enn å skrive ut til en fil og deretter slette
filen når vi er ferdig med det, kan vi skrive et særskilt
fil som heter / dev / null.
Når noe er skrevet til / dev/null--
eller bare devnull for kort -
den automatisk kassert.
Så tenk på devnull som et svart hull for dine data.
>> Så nå har vi sett hvordan større enn-tegn kan omdirigere
stdout, la oss se hvordan vi kan omdirigere standard i -
eller s-t-d-i -
den analog stdout.
Mens funksjoner som printf skrive til bekk kalt
stdout, GetString og lignende funksjoner lese fra bekken
kalt stdin, som standard, er strømmen av
tegn skrevet på tastaturet.
Vi kan omdirigere stdin med mindre enn-tegn, etterfulgt
av et filnavn.
Nå, i stedet for å spørre brukeren om innspill på
terminal, vil et program åpne filen vi spesifisert og bruke
linjene som input.
>> La oss se hva som skjer.
Flott.
Den første linjen av file.txt er trykt til terminalen
fordi vi kaller GetString gang.
Hvis vi hadde et annet kall til GetString i vårt program, det
neste linje av file.txt ville ha blitt brukt som
innspill til samtalen.
Igjen har vi ikke endret våre C-program i det hele tatt.
Vi bare endrer hvordan vi driver det.
Og også huske, vi har ikke omdirigert stdout denne gangen,
slik at produksjonen av programmet var fortsatt
vises på terminalen.
Vi kan selvsagt omdirigere både stdin
og stdout som dette.
Nå inneholder file2.txt den første linjen i file.txt.
>> Så ved hjelp av disse operatørene, har vi vært i stand til å lese og
skrive fra tekstfiler.
Nå, la oss se hvordan vi kan bruke resultatet av ett program som
inngangen til et annet program.
Så her er et annet enkelt C-program jeg
har her kalt hallo.c.
Som du kan se, utganger dette rett og slett "Hei
det! "til brukeren.
Hvis jeg vil omdirigere bruke som input utgang av hei -
et annet program -
Jeg kunne først omdirigere stdout av hei til en fil som heter
input.txt, deretter omdirigere stdin av omdirigere til den samme
file - input.txt.
Så jeg kan gjøre. / Hallo> input.txt.
Trykk Enter for å utføre dette.
Etterfulgt av. / Redirect <
input.txt, og gjennomføre det.
Så vi kan forkorte dette litt med et semikolon, som lar
oss å kjøre to eller flere kommandoer på samme linje.
Så jeg kan si,. / Hallo> input.txt, semikolon,
. / Redirect <input.txt.
>> Så dette fungerer, men det føles fortsatt ganske uelegant.
Jeg mener, vi trenger virkelig dette mellomleddet tekstfil som er
ikke lenger nødvendig etter omdirigere kjører?
Heldigvis, kan vi unngå denne ekstra tekstfil med hva som er
kalt en pipe.
Hvis jeg sier, / hallo |.. / Redirect, så stdout av
programmet på venstre -
i dette tilfellet, hello -
vil bli brukt som standard input for
Programmet til høyre.
I dette tilfellet, viderekobling. Så la oss kjøre dette.
>> Det vi går.
Vi kan se at resultatet av hallo ble brukt som input
for viderekobling.
Ved å sette kommandoer sammen med rør, danner vi hva som er
kalt en rørledning, siden vår produksjonen er hovedsak beveger
gjennom en sekvens av kommandoer.
Ved hjelp av rør, kan vi gjøre noen kule ting uten å måtte
skrive kode i det hele tatt.
For eksempel, la oss si at vi ønsker å vite hvor mange filer er
innsiden av denne katalogen.
Ved hjelp av et rør, kan vi kombinere ls kommandoen med wc -
eller wordcount -
kommandoen.
Ls vil sende hver fil i katalogen til stdout, og
wc vil fortelle oss hvor mange linjer ble gitt til det via stdin.
Så hvis vi sier ls | wc-l -
forsyne-l flagget til wc å fortelle det å telle linjer -
Vi kan se nøyaktig hvor mange filer er
i gjeldende katalog.
>> Så la oss ta en titt på et eksempel.
Jeg har her en fil som heter students.txt,
med en liste over navn.
Men disse navnene er ikke i hvilken som helst rekkefølge det hele, og det ser
som noen navn er gjentatt.
Det vi ønsker er en liste over unike navn i alfabetisk
rekkefølge, lagres i en fil som heter final.txt.
Vi kunne selvsagt skrive et C-program for å gjøre dette for oss.
Men det kommer til å bli unødvendig
kompleks ganske raskt.
La oss i stedet bruke rør og noen innebygde-verktøy for å løse
dette problemet.
>> Det første vi må gjøre er å lese filen students.txt.
Katten kommandoen vil gjøre nettopp det.
Det vil lese i den angitte filen og skrive
innholdet til stdout.
Etter at vi har lest tekstfilen, vil vi
vil sortere navnene.
Sort kommandoen kan håndtere dette for oss.
Sorter vil sende linjen levert via stdin til stdout
i sortert rekkefølge.
For å forsyne innholdet i students.txt til
sorter er stdin, vi kunne bruke et rør for å kombinere katt og slag.
Så jeg kan kjøre cat students.txt | sortere og
trykk på Enter.
Og nå ser vi innholdet i students.txt i
alfabetisk rekkefølge.
>> Så la oss legge til en annen kommando -
Uniq, eller unike -
til rørledningen vår.
Som du kanskje skjønner, uniq, da levert en sortert sekvens av
linjer via stdin, vil sende ut unike linjer.
Så nå har vi katt students.txt
| Sort | uniq.
Endelig kan vi lagre utdataene av rørledningen til en
fil via cat students.txt | sort | uniq
> Final.txt.
Så hvis vi åpner opp final.txt, har vi nøyaktig hva vi var
leter etter:
en liste over unike navn i alfabetisk rekkefølge,
lagret i en tekstfil.
Forresten, vi også kunne ha sagt slags <
students.txt | uniq> final.txt å gjøre akkurat
det samme, med hvert av de operatørene vi har sett i
denne videoen.
>> Mitt navn er Tommy, og dette er CS50.