[Powered by Google Translate] TOMMY: En aquest vídeo, aprendrem sobre
reorientar i canonades.
Fins ara, hem estat utilitzant funcions com printf per
les dades de sortida de la terminal i funciona com GetString
per permetre a l'usuari per proporcionar entrada al nostre
programa mitjançant el teclat.
Anem a fer una ullada ràpida a un programa que té una línia de
l'entrada de l'usuari i després dóna sortida.
>> En la línia 7, estem indicant a l'usuari per a una cadena, i
a continuació, en la línia 8, ho estem imprimint a sortir.
Anem a compilar i executar el nostre programa.
Gran.
La cadena que sempre es va fer ressò de nou
a nosaltres a la terminal.
Això va succeir perquè la funció printf escriure a un
corrent anomenat de sortida estàndard, o s-t-d fora.
Quan alguna cosa s'escriu en stdout, és per defecte
mostrat pel terminal.
>> Així que això és tot molt bé, però què passaria si, en comptes de
mostrar la cadena, volíem que el guardi en un arxiu?
Per exemple, podríem voler recordar exactament el que el nostre
programa va fer quan li vam donar una entrada particular després.
Un enfocament seria fer això en el nostre programa en C, utilitzant
algunes funcions especials per escriure en els arxius que anem a
veure en un altre vídeo.
Encara més fàcil, però, seria d'alguna manera
redirigir stdout a un arxiu.
D'aquesta manera, quan escriu a la sortida estàndard printf, el contingut es
escrita a un arxiu en lloc de
mostrat pel terminal.
Podem fer justament això mitjançant l'addició d'un signe de major que, seguit
per un nom de fitxer, la comanda que fem servir per executar el nostre programa.
>> Així, en lloc de limitar-se a executar. / Redirect, podem
executar. / redirigir, seguit per un signe de major que, seguit per
nom d'arxiu, com fitxer.txt.
Anem a veure què passa.
Acceptar.
Tingueu en compte que aquesta vegada, res es mostra a la part terminal,
però no hem modificat els continguts de la nostra
C programa en absolut.
Ara anem a examinar el contingut d'aquest directori amb ls.
>> Està bé.
Ara tenim un nou arxiu en el nostre directori anomenat fitxer.txt,
que és el nom del fitxer que subministra quan ens trobem amb el nostre
Redirigir programa.
Anem a obrir fitxer.txt.
I aquí, podem veure que la sortida estàndard de redirecció era
s'escriu al fitxer denominat fitxer.txt.
Així que anem a executar la comanda anterior de nou, però el subministrament d'una
entrada diferent aquesta vegada.
Bé.
Anem a fer una ullada a fitxer.txt ara.
>> Podem veure aquí que l'arxiu ha estat sobreescrit, pel que el nostre
entrada original ja no hi és.
Si en canvi voleu afegir a aquesta imatge, posar el nou
d'entrada per sota del contingut existent de l'arxiu, podem
utilitzar dos signes major que en comptes d'un de sol.
Intentarem això.
Ara bé, si obrim fitxer.txt vegada més, podem veure tant del nostre
línies d'entrada.
En alguns casos, el que es vol descartar qualsevol
sortida del nostre programa.
En lloc d'escriure la sortida al fitxer i després esborrar
l'arxiu quan hagi acabat amb ell, podem escriure una especial per
arxiu anomenat / dev / null.
Quan alguna cosa s'escriu en / dev/null--
o simplement per abreujar devnull -
es descarten automàticament.
Així que pensa en devnull com un forat negre per les seves dades.
>> Així que ara que hem vist com el signe més gran que pot redirigir
stdout, veurem com podem redirigir estàndard -
o s-t-d-en -
l'anàleg de stdout.
Mentre que les funcions com printf escriure en la seqüència anomenada
stdout, GetString i funcions similars llegeix en la seqüència
anomenat stdin, que, per defecte, és el corrent de
caràcters que es teclejat.
Podem redirigir stdin utilitzant el signe menor que, seguit
per un nom de fitxer.
Ara, en lloc de sol · licitar a l'usuari l'entrada a la
terminal, el programa s'obrirà l'arxiu que especifiquem i utilitzar
les seves línies com a entrada.
>> Anem a veure què passa.
Gran.
La primera línia de fitxer.txt ha estat impresa al terminal
perquè estem cridant GetString vegada.
Si tinguéssim una altra crida a GetString en el nostre programa, el
següent línia de fitxer.txt s'han utilitzat com
entrada a aquesta crida.
Un cop més, no hem modificat el nostre programa en C en absolut.
Només estem canviant la manera com s'executa.
I també recordo, no hem redireccionat stdout aquest temps,
de manera que la sortida del programa era encara
mostren en el terminal.
Podem, és clar, redirigir stdin
i stdout com aquest.
Ara, file2.txt conté la primera línia de fitxer.txt.
>> Per tant, l'ús d'aquests operadors, hem estat capaços de llegir i
escriure a partir d'arxius de text.
Ara, anem a veure com podem utilitzar la sortida d'un programa com
l'entrada d'un altre programa.
Així que aquí està un altre senzill programa en C que
aquí he anomenat hello.c.
Com pot veure, això simplement dóna sortida "Hola
allà! "per a l'usuari.
Si vull redirigir a utilitzar com a entrada la sortida de hello -
altre programa -
La primera vegada que podria redirigir la sortida estàndard de saludar un arxiu anomenat
input.txt, a continuació, redirigir l'entrada estàndard de redirigir a la mateixa
arxiu - input.txt.
Així que puc fer. / Hello> input.txt.
Premeu Intro per executar aquest.
Seguit per. / Redirect <
input.txt i executar això.
Així que podem escurçar això una mica amb un punt i coma, que permet
ens per executar dos o més ordres en la mateixa línia.
Així que puc dir,. / Hola> input.txt, punt i coma,
. / Redirect input.txt <.
>> Així funciona això, però encara se sent bastant poc elegant.
Vull dir, realment necessitem aquest arxiu de text que és intermediari
ja no cal després de redirigir carreres?
Per sort, podem evitar aquest arxiu de text addicional usant el que és
diu un tub.
Si jo dic, / hola | .. / Redirecció, llavors l'eixida del
el programa de l'esquerra -
en aquest cas, hello -
s'utilitza com l'entrada estàndard per a la
programa a la dreta.
En aquest cas, redirigir. Així que anem a executar aquest.
>> Aquí anem.
Podem veure que la sortida de hola s'utilitza com l'entrada
per redirigir.
En encadenar comandes juntament amb tubs, formem el que és
anomenat una canonada, ja que la nostra producció és essencialment moviment
a través d'una seqüència de comandaments.
Utilitzant tubs, podem fer algunes coses interessants sense necessitat de
escriure cap codi.
Per exemple, diguem que volem saber quants arxius
dins d'aquest directori.
L'ús d'un tub, podem combinar la comanda ls amb el wc -
o recompte de paraules -
comandament.
Ls donarà sortida a cada arxiu al directori a stdout, i
wc ens dirà quantes línies es va donar a ella a través de stdin.
Per tant, si diem ls | wc-l -
subministrar la opció-l per wc per indicar-li que ha de comptar amb línies -
podem veure exactament quants arxius
al directori actual.
>> Així que donem una ullada a un exemple més.
Tinc aquí un arxiu anomenat students.txt,
amb una llista de noms.
No obstant això, aquests noms no estan en cap ordre tot, i sembla que
com alguns noms es repeteixen.
El que volem és una llista de noms únics en ordre alfabètic
ordre, guardar en un arxiu anomenat final.txt.
Podríem, per descomptat, escriure un programa en C per fer això per nosaltres.
Però arribarà innecessàriament
complex amb força rapidesa.
Utilitzarem en el seu lloc tubs i algunes eines integrades per resoldre-
aquest problema.
>> El primer que hem de fer és llegir el students.txt arxiu.
La comanda cat farà precisament això.
Es llegirà a l'arxiu especificat i escriure
seu contingut a stdout.
Després que hagi llegit l'arxiu de text, anem a
desitja ordenar els noms.
La comanda sort pot gestionar això per nosaltres.
Ordenar donarà sortida a la línia de subministrament a través de l'entrada estàndard a la sortida estàndard
de manera ordenada.
Per tal de subministrar el contingut de students.txt a
stdin tipus, podríem utilitzar un tub per combinar gat i ordenar.
Així que puc executar gat students.txt | ordenar i
premeu Intro.
I ara, podem veure el contingut de students.txt en
ordre alfabètic.
>> Així que anem a afegir un altre ordre -
uniq, o únic -
a la nostra cartera.
Com es pot endevinar, uniq, quan es subministra una seqüència ordenada de
línies a través de l'entrada estàndard, és la sortida de les línies úniques.
Així que ara tenim students.txt gat
| Sort | uniq.
Finalment, podem guardar la sortida de la canonada a una
arxiu a través de gat students.txt | sort | uniq
> Final.txt.
Així doncs, si ens obrim final.txt, tenim exactament el que estàvem
buscant:
una llista de noms únics en ordre alfabètic,
guardar en un arxiu de text.
Per cert, també podria haver dit sort <
students.txt | uniq> final.txt fer exactament
el mateix, utilitzant cada un dels operadors que hem vist en
aquest vídeo.
>> El meu nom és Tommy, i això és CS50.