Leid standaard I/O en fouten om. Linux I/O-omleiding

Voorbeeld 16-1. Omleiden met exec

#!/bin/bash # Stdin omleiden met "exec". ex 6<&0 # Связать дескр. #6 со стандартным вводом (stdin). # Сохраняя stdin. exec < data-file # stdin заменяется файлом "data-file" read a1 # Читается первая строка из "data-file". read a2 # Читается вторая строка из "data-file." echo echo "Следующие строки были прочитаны из файла." echo "——————————————" echo $a1 echo $a2 echo; echo; echo exec 0<&6 6<&- # Восстанавливается stdin из дескр. #6, где он был предварительно сохранен, #+ и дескр. #6 закрывается (6<&-) освобождая его для других процессов. # # <&6 6<&- дает тот же результат. echo -n "Введите строку " read b1 # Теперь функция "read", как и следовало ожидать, принимает данные с обычного stdin. echo "Строка, принятая со stdin." echo "—————————" echo "b1 = $b1" echo exit 0

Zo ook het ontwerp exec >bestandsnaam stuurt de uitvoer door naar het opgegeven bestand. Hierna wordt alle uitvoer van opdrachten waar normaal gesproken naartoe zou worden gestuurd, nu naar dit bestand uitgevoerd.

Voorbeeld 16-2. Omleiden met exec

#!/bin/bash # reassign-stdout.sh LOGFILE=logfile.txt exec 6>&1 # Linkbesch. #6 met stdout. # Stdout opslaan. exec > $LOGFILE # stdout wordt vervangen door het bestand "logfile.txt". # ———————————————————— # # Alle uitvoer van de opdrachten in dit blok wordt naar het $LOGFILE-bestand geschreven. echo -n "Logbestand: " datum echo "————————————-" echo echo "Uitvoer van \"ls -al\"" echo ls -al echo; echo echo "Uitvoer van het commando \"df\"" echo df # ———————————————————— # exec 1>&6 6>&- # Herstel stdout en sluit het bestand. #6. echo echo "== stdout hersteld naar standaard == " echo ls -al echo exit 0

Voorbeeld 16-3. Gelijktijdige omleiding van apparaten, en met behulp van de exec-opdracht

#!/bin/bash # upperconv.sh # Converteert tekens in het invoerbestand naar hoofdletters. E_FILE_ACCESS=70 E_WRONG_ARGS=71 als [ ! -r "$1" ] # Is het bestand leesbaar? echo dan "Kan het opgegeven bestand niet lezen!" echo "Gebruik: $0 invoerbestand uitvoerbestand" exit $E_FILE_ACCESS fi # Als het invoerbestand ($1) niet #+ is gespecificeerd, zal de afsluitcode hetzelfde zijn. if [ -z "$2" ] then echo "Het uitvoerbestand moet worden opgegeven." echo "Gebruik: $0 invoerbestand uitvoerbestand" exit $E_WRONG_ARGS fi exec 4<&0 exec < $1 # Назначить ввод из входного файла. exec 7>&1 exec > $2 # Wijs uitvoer toe aan een uitvoerbestand. # Ervan uitgaande dat het uitvoerbestand beschrijfbaar is # (controle toevoegen?). # ————————————————— kat — | tr a-z A-Z # Converteren naar hoofdletters # ^^^^^ # Lezen van stdin. # ^^^^^^^^^^ # Schrijf naar stdout. # Zowel stdin als stdout zijn echter omgeleid. # ———————————————— exec 1>&7 7>&- # Stdout herstellen. exec 0<&4 4<&- # Восстановить stdin. # После восстановления, следующая строка выводится на stdout, чего и следовало ожидать. echo "Символы из \"$1\" преобразованы в верхний регистр, результат записан в \"$2\"." exit 0

Volgende: Fouten omleiden naar een bestand Omhoog: I/O-omleiding Vorig: Invoer uit een bestand omleiden Inhoud Inhoudsopgave

Uitvoer omleiden naar een bestand

Om standaarduitvoer naar een bestand om te leiden, gebruikt u de operator `>'.

I/O-omleiding in Linux

Volg de opdrachtnaam met de operator >, gevolgd door de naam van het bestand dat als bestemming voor de uitvoer zal dienen. Als u bijvoorbeeld de uitvoer van een programma naar een bestand wilt schrijven, voert u het volgende in:

Als u de standaarduitvoer omleidt naar een reeds bestaand bestand, wordt dit vanaf het begin overschreven. Om standaarduitvoer aan de inhoud van een bestaand bestand toe te voegen, moet u de operator `"' gebruiken. Als u bijvoorbeeld de resultaten van het werk wilt toevoegen wanneer u het programma opnieuw aan een bestand uitvoert, voert u het volgende in:

Alex Otwagin 2002-12-16

Een programma is meestal waardevol omdat het gegevens kan verwerken: het ene accepteren, het andere als uitvoer produceren, en bijna alles kan als gegevens fungeren: tekst, getallen, geluid, video... De invoer- en uitvoergegevensstromen voor een opdracht worden genoemd invoer En conclusie. Elk programma kan meerdere invoer- en uitvoerstromen hebben. Elk proces ontvangt, wanneer het wordt gemaakt, noodzakelijkerwijs de zogenaamde standaard invoer(standaardinvoer, stdin) en standaard uitvoer(standaarduitvoer, stdout) en standaard foutuitvoer(standaardfout, stderr).

Standaard invoer-/uitvoerstromen zijn primair bedoeld voor het uitwisselen van tekstinformatie. Het maakt niet eens uit wie via sms communiceert: een persoon met een programma of programma's onderling - het belangrijkste is dat ze een datatransmissiekanaal hebben en dat ze “dezelfde taal” spreken.

Het tekstuele principe van het werken met een machine stelt je in staat om te ontsnappen aan specifieke delen van de computer, zoals het systeemtoetsenbord en de videokaart met een monitor, en naar een enkele te kijken eindapparaat, waarmee de gebruiker tekst (opdrachten) invoert en deze naar het systeem verzendt, en het systeem de door de gebruiker vereiste gegevens en berichten weergeeft (diagnostiek en fouten). Zo'n apparaat heet terminal. Over het algemeen is een terminal het toegangspunt van een gebruiker tot een systeem dat de mogelijkheid heeft om tekstinformatie te verzenden. Een terminal kan een afzonderlijk extern apparaat zijn dat via een seriële datapoort op een computer is aangesloten (in een personal computer wordt dit een “COM-poort” genoemd). Een programma (bijvoorbeeld xterm of ssh) kan ook als terminal werken (met enige ondersteuning van het systeem). Eindelijk, virtuele consoles- ook terminals, alleen programmatisch georganiseerd met behulp van geschikte apparaten van een moderne computer.

Wanneer u op de opdrachtregel werkt, wordt de standaardinvoer van de shell geassocieerd met het toetsenbord, en worden de standaarduitvoer en foutuitvoer geassocieerd met het beeldscherm (of het terminalemulatorvenster). Laten we het laten zien met het eenvoudigste commando - cat. Meestal de ploeg kat leest gegevens uit alle bestanden die zijn opgegeven als parameters en verzendt de lezing rechtstreeks naar de standaarduitvoer (stdout). Daarom het commando

/home/larry/papers# cat history-finale masterproef

zal eerst de inhoud van het bestand weergeven, en dan het bestand.

Als de bestandsnaam echter niet is opgegeven, wordt het programma kat leest invoer van stdin en stuurt deze onmiddellijk terug naar stdout (zonder deze op enigerlei wijze te wijzigen). Gegevens passeren kat zoals door een pijp. Laten we een voorbeeld geven:

/home/larry/papers# cat Hallo daar. Hallo daar. Doei. Doei. Ctrl—D/home/larry/papieren#

Elke regel die via het toetsenbord wordt ingevoerd, wordt door het cat-programma onmiddellijk teruggestuurd naar het scherm. Bij het invoeren van informatie via standaardinvoer wordt het einde van de tekst meestal aangegeven door het invoeren van een speciale toetsencombinatie Ctrl—D.

Laten we nog een voorbeeld geven. Team soort leest regels invoertekst (ook van stdin als er geen bestandsnaam is opgegeven) en voert een set van deze regels in een geordende vorm uit op stdout. Laten we de actie ervan controleren.

/home/larry/papers# bananen wortelen appels sorteren Ctrl+D appels bananen wortelen /home/larry/papers#

Zoals je kunt zien, na het indrukken Ctrl—D, soort Toont de regels in alfabetische volgorde.

Standaardinvoer en standaarduitvoer

Stel dat u de uitvoer van de sorteeropdracht naar een bestand wilt doorsturen om een ​​alfabetisch geordende lijst op schijf op te slaan. Met de opdrachtshell kunt u de standaarduitvoer van een opdracht omleiden naar een bestand met behulp van een symbool. Laten we een voorbeeld geven:

/home/larry/papers# sorteer > boodschappenlijstje bananen wortelen appels Ctrl—D/home/larry/papieren#

U kunt zien dat de uitvoer van het sorteercommando niet op het scherm wordt afgedrukt, maar wordt opgeslagen in een bestand met de naam. Laten we de inhoud van dit bestand weergeven:

/home/larry/papers# katten boodschappenlijstje appels bananen wortelen /home/larry/papers#

Laat nu de originele ongeordende lijst in een bestand staan. Deze lijst kan worden gesorteerd met behulp van de opdracht soort, door het te vertellen dat het uit een bepaald bestand moet lezen in plaats van uit de standaardinvoer, en bovendien de standaarduitvoer om te leiden naar een bestand, zoals hierboven werd gedaan. Voorbeeld:

/home/larry/papers# items sorteren boodschappenlijstje /home/larry/papers# katten boodschappenlijstje appels bananen wortelen /home/larry/papers#

U kunt het echter anders doen door niet alleen de standaarduitvoer om te leiden, maar ook standaard invoer hulpprogramma's uit het bestand met behulp van het symbool:

/home/larry/papers# sorteren< items apples bananas carrots /home/larry/papers#

Commandoresultaat soort< items gelijk aan de opdracht artikelen sorteren, maar de eerste laat het volgende zien: bij het geven van de opdracht soort< items het systeem gedraagt ​​zich alsof de gegevens in het bestand via standaardinvoer zijn ingevoerd. Omleiding wordt gedaan door de opdrachtshell. Team soort de bestandsnaam werd niet gerapporteerd: dit commando las gegevens uit de standaardinvoer alsof we deze via het toetsenbord hadden ingevoerd.

Laten we het concept introduceren filter. Een filter is een programma dat gegevens uit standaardinvoer leest, deze op de een of andere manier verwerkt en het resultaat naar standaarduitvoer verzendt. Wanneer omleiding wordt toegepast, kunnen bestanden worden gebruikt als standaard invoer en uitvoer. Zoals hierboven vermeld, verwijzen stdin en stdout standaard naar respectievelijk het toetsenbord en het scherm. Het sorteerprogramma is een eenvoudig filter: het sorteert de invoergegevens en stuurt het resultaat naar de standaarduitvoer. Een heel eenvoudig filter is het programma kat- het doet niets met de invoergegevens, maar stuurt deze eenvoudig naar de uitvoer.

We hebben hierboven al gedemonstreerd hoe je het sorteerprogramma als filter kunt gebruiken. In deze voorbeelden werd ervan uitgegaan dat de brongegevens zich in een bepaald bestand bevonden of dat de brongegevens via het toetsenbord zouden worden ingevoerd (standaardinvoer). Maar wat als u gegevens wilt sorteren die het resultaat zijn van een ander commando, bijvoorbeeld: ls?

We sorteren de gegevens in omgekeerde alfabetische volgorde; dit wordt gedaan door de opdrachtoptie soort. Als u de bestanden in de huidige map in omgekeerde alfabetische volgorde wilt weergeven, kunt u dit op de volgende manier doen.

I/O-omleiding

Laten we eerst het commando gebruiken ls:

/home/larry/papers# ls engelse lijst geschiedenis-finale masterscriptie-aantekeningen /home/larry/papers#

Nu leiden we de opdrachtuitvoer om ls naar een bestand met de naam file-list

/home/larry/papers# ls > bestandenlijst /home/larry/papers# sort -r bestandslijst notities masterproefgeschiedenis-finale engelse lijst /home/larry/papers#

Hier is de opdrachtuitvoer ls opgeslagen in een bestand, en daarna werd dit bestand verwerkt door de opdracht soort. Dit pad is echter onelegant en vereist het gebruik van een tijdelijk bestand om de programma-uitvoer op te slaan ls.

Een oplossing voor deze situatie zou kunnen zijn om te creëren gedockte opdrachten(pijpleidingen). Het docken wordt uitgevoerd door de opdrachtshell, die de stdout van het eerste commando naar de stdin van het tweede commando stuurt. In dit geval willen we opdrachten naar stdout sturen ls naar stdin-opdrachten soort. Voor het koppelen wordt een symbool gebruikt, zoals weergegeven in het volgende voorbeeld:

/home/larry/papers# ls | sort -r notes masterscriptie geschiedenis-finale engelse lijst /home/larry/papers#

Deze opdracht is korter dan een verzameling opdrachten en is gemakkelijker te typen.

Laten we eens naar een ander nuttig voorbeeld kijken. Team

/home/larry/papers# ls /usr/bin

retourneert een lange lijst met bestanden. Het grootste deel van deze lijst vliegt te snel over het scherm om de inhoud van deze lijst te kunnen lezen. Laten we proberen de opdracht more te gebruiken om deze lijst in delen weer te geven:

/home/larry/papers# ls /usr/bin | meer

Nu kunt u deze lijst ‘doorbladeren’.

Je kunt verder gaan en meer dan twee teams aanmeren. Denk aan het team hoofd, wat een filter is met de volgende eigenschap: het voert de eerste regels uit de invoerstroom uit (in ons geval zal de invoer de uitvoer zijn van verschillende aaneengeschakelde opdrachten). Als we de laatste alfabetische bestandsnaam in de huidige map willen weergeven, kunnen we de volgende lange opdracht gebruiken:

/home/larry/papers# ls | sorteer -r | hoofd -1 notities /home/larry/papers\#

waar is de ploeg hoofd geeft de eerste regel weer van de invoerstroom van regels die het ontvangt (in ons geval bestaat de stroom uit gegevens van de opdracht ls), gesorteerd in omgekeerde alfabetische volgorde.

Gestapelde opdrachten gebruiken (pijplijn)

Het effect van het gebruik van een symbool om de bestandsuitvoer om te leiden is destructief; met andere woorden: het team

/home/larry/papers# ls > bestandslijst

zal de inhoud van het bestand vernietigen als het bestand eerder bestond en in plaats daarvan een nieuw bestand maken.

Als de omleiding in plaats daarvan wordt uitgevoerd met behulp van symbolen, wordt de uitvoer toegevoegd aan het einde van het opgegeven bestand zonder de oorspronkelijke inhoud van het bestand te vernietigen. De opdracht bijvoorbeeld

/home/larry/papers# ls >> bestandslijst

schrijft de uitvoer van de opdracht toe ls naar het einde van het bestand.

Houd er rekening mee dat invoer- en uitvoeromleiding en opdrachtsplitsing worden uitgevoerd door shells die het gebruik van symbolen ondersteunen. De teams zijn zelf niet in staat deze symbolen waar te nemen en te interpreteren.

Niet-destructieve uitvoeromleiding

Zoiets zou moeten doen wat je nodig hebt?

Kijk eens: wintee

Cygwin is niet nodig.

Ik ben echter enkele problemen tegengekomen en gerapporteerd.

Misschien wil je ook http://unxutils.sourceforge.net/ bekijken omdat het tee bevat (en geen cygwin nodig heeft), maar wees voorzichtig dat de EOL-uitvoer UNIX-achtig is.

Last but not least, als je PowerShell hebt, kun je Tee-Object proberen. Typ de PowerShell-console voor meer informatie.

Dit werkt, hoewel het een beetje lelijk is:

Het is iets flexibeler dan sommige andere oplossingen, omdat het op zijn eigen manier werkt, zodat u het kunt gebruiken om iets toe te voegen.

Ik gebruik dit vrij vaak in batchbestanden om berichten te loggen en weer te geven:

Ja, je zou de ECHO-verklaring gewoon kunnen herhalen (een keer voor het scherm en een tweede keer doorverwijzen naar het logbestand), maar dat ziet er net zo slecht uit en is een onderhoudsprobleem.

Het omleiden van input en output

Zo hoef je in ieder geval niet op twee plekken wijzigingen in berichten aan te brengen.

Houd er rekening mee dat _ slechts een korte bestandsnaam is, dus u moet deze aan het einde van uw batchbestand verwijderen (als u een batchbestand gebruikt).

Hierdoor wordt een logbestand gemaakt met de huidige tijd en tijd en kunt u tijdens het proces de consoleregels gebruiken

Als u cygwin in uw Windows-omgevingspad hebt, kunt u het volgende gebruiken:

Een eenvoudige C#-consoletoepassing zou voldoende zijn:

Om dit te gebruiken, geeft u eenvoudigweg de source-opdracht door aan het programma en geeft u het pad op naar alle bestanden waarvan u de uitvoer wilt dupliceren. Bijvoorbeeld:

Zal zoekresultaten weergeven en de resultaten ook opslaan in files1.txt en files2.txt.

Houd er rekening mee dat er niet veel foutafhandeling is (niets!) en dat ondersteuning voor meerdere bestanden mogelijk niet nodig is.

Ik was ook op zoek naar dezelfde oplossing, na een beetje proberen kon ik dit met succes doen op de opdrachtregel. Hier is mijn oplossing:

Het kaapt zelfs elk PAUSE-commando.

Een alternatief is om stdout naar stderr in je programma te zetten:

Vervolgens in uw dos-batchbestand:

Stdout gaat naar het logbestand en stderr (dezelfde gegevens) wordt op de console weergegeven.

Uitvoer weergeven en omleiden naar een bestand. Stel dat als ik de opdracht dos, dir> test.txt gebruik, deze opdracht de uitvoer omleidt naar het bestand test.txt zonder de resultaten weer te geven. hoe je een opdracht schrijft om de uitvoer af te drukken en de uitvoer om te leiden naar een bestand met behulp van DOS, d.w.z. de Windows-opdrachtregel, niet UNIX/LINUX.

Mogelijk vindt u deze commando's in biterscripting (http://www.biterscripting.com) handig.

Dit is een variatie op het eerdere antwoord van MTS, maar het voegt enkele functies toe die voor anderen nuttig kunnen zijn. Hier is de methode die ik heb gebruikt:

• De opdracht wordt ingesteld als een variabele die later in de code kan worden gebruikt om naar het opdrachtvenster te worden uitgevoerd en aan het logbestand te worden toegevoegd met behulp van
  • het commando vermijdt omleiding met behulp van het wortelsymbool, zodat commando's in eerste instantie niet worden geëvalueerd
• Er wordt een tijdelijk bestand gemaakt met een bestandsnaam die lijkt op die van een batchbestand, dat de syntaxis van de opdrachtregeloptie-extensie gebruikt om de naam van het batchbestand te verkrijgen.
• Het resultaat wordt toegevoegd aan een apart logbestand

Hier is de volgorde van de opdrachten:

1. Uitvoer- en foutmeldingen worden naar een tijdelijk bestand verzonden
2. De inhoud van het tijdelijke bestand is dan:
   • toegevoegd aan logbestand
   • uitvoer naar het opdrachtvenster
3. Het tijdelijke bestand met het bericht wordt verwijderd

Hier is een voorbeeld:

Op deze manier kan het commando eenvoudig na latere commando's worden toegevoegd in een batchbestand, dat er veel overzichtelijker uitziet:

Dit kan ook aan het einde van andere opdrachten worden toegevoegd. Voor zover ik weet, werkt dit als berichten uit meerdere regels bestaan. Met de volgende opdracht worden bijvoorbeeld twee regels afgedrukt als er een foutmelding is:

Ik ben het met Brian Rasmussen eens: de unxutils-poort is de gemakkelijkste manier om dit te doen. In de sectie Batchbestanden van zijn Scripting-pagina's biedt Rob van der Woude een schat aan informatie over het gebruik van MS-DOS- en CMD-opdrachten. Ik dacht dat het misschien een eigen oplossing voor je probleem had, en nadat TEE.BAT daar rond had gezocht, vond ik TEE.BAT, wat precies dat lijkt te zijn: een verpakt MS-DOS-taalpakket. Dit is een vrij complex batchbestand en ik zou geneigd zijn de unxutils-poort te gebruiken.

Ik installeer perl op de meeste van mijn machines, dus het antwoord is het gebruik van perl: tee.pl

richt | perl tee.pl of catalogus | perl tee.pl dir.bat

rauw en ongetest.

Een van de interessantste en nuttigste onderwerpen voor systeembeheerders en nieuwe gebruikers die net beginnen te begrijpen hoe ze met de terminal moeten werken, is het omleiden van Linux I/O-streams. Met deze terminalfunctie kunt u de uitvoer van opdrachten naar een bestand omleiden, of de inhoud van een bestand naar opdrachtinvoer omleiden, opdrachten samenvoegen en opdrachtpijplijnen vormen.

In dit artikel zullen we bekijken hoe I/O-streamomleiding in Linux wordt uitgevoerd, welke operators hiervoor worden gebruikt en waar dit allemaal kan worden gebruikt.

Alle opdrachten die we uitvoeren, leveren ons drie soorten gegevens op:

• Het resultaat van de opdracht, meestal tekstgegevens opgevraagd door de gebruiker;
• Foutmeldingen - informeer over het proces van opdrachtuitvoering en onverwachte omstandigheden die zich hebben voorgedaan;
• De returncode is een getal waarmee u kunt beoordelen of het programma correct heeft gewerkt.

In Linux worden alle substanties beschouwd als bestanden, inclusief Linux input/output-streams - bestanden. Elke distributie heeft drie hoofdstroombestanden die programma's kunnen gebruiken. Deze worden gedefinieerd door de shell en geïdentificeerd door hun bestandsdescriptornummer:

• STDIN of 0- dit bestand is gekoppeld aan het toetsenbord en de meeste opdrachten ontvangen gegevens om vanaf hier te werken;
• STDOUT of 1- dit is de standaarduitvoer; het programma verzendt hier alle resultaten van zijn werk. Het wordt geassocieerd met het scherm, of om preciezer te zijn, met de terminal waarin het programma draait;
• STDERR of 2- alle foutmeldingen worden naar dit bestand uitgevoerd.

Met I/O-omleiding kunt u een van deze bestanden vervangen door uw eigen bestanden. U kunt bijvoorbeeld een programma dwingen gegevens uit een bestand op het bestandssysteem te lezen in plaats van op het toetsenbord, u kunt ook fouten naar een bestand afdrukken in plaats van naar het scherm, enz. Dit alles gebeurt met behulp van symbolen "<" En ">" .

Uitvoer omleiden naar bestand

Alles is heel eenvoudig. U kunt de uitvoer naar een bestand omleiden met behulp van het > symbool. Laten we bijvoorbeeld de uitvoer van het topcommando opslaan:

top -bn 5 > top.log

De optie -b zorgt ervoor dat het programma in niet-interactieve batchmodus draait, en n - herhaalt de bewerking vijf keer om informatie over alle processen te verkrijgen. Laten we nu eens kijken wat er met de kat is gebeurd:

Symbool ">" overschrijft informatie uit een bestand als er al iets is. Om gegevens toe te voegen aan het eindgebruik ">>" . Stuur de uitvoer bijvoorbeeld door naar een Linux-bestand voor top:

top -bn 5 >> top.log

Standaard wordt de stgebruikt voor omleiding. Maar u kunt dit expliciet specificeren. Dit commando geeft hetzelfde resultaat:

top -bn 5 1>top.log

Fouten omleiden naar bestand

Om de foutuitvoer naar een bestand om te leiden, moet u expliciet de bestandsdescriptor opgeven die u gaat omleiden. Voor fouten is dit nummer 2. Wanneer u bijvoorbeeld probeert toegang te krijgen tot de superuser-directory, zal ls een foutmelding genereren:

U kunt de standaardfout omleiden naar een bestand als dit:

ls -l /root/ 2> ls-error.log
$ cat ls-error.log

Gebruik hetzelfde symbool om gegevens aan het einde van het bestand toe te voegen:

ls -l /root/ 2>>ls-error.log

Leid standaarduitvoer en fouten om naar bestand

U kunt ook alle uitvoer, fouten en standaarduitvoer omleiden naar één enkel bestand. Er zijn twee manieren om dit te doen. De eerste, oudere, is om beide handvatten door te geven:

ls -l /root/ >ls-error.log 2>&1

Eerst wordt de uitvoer van het ls-commando naar het ls-error.log-bestand gestuurd met behulp van het eerste omleidingsteken. Vervolgens worden alle fouten naar hetzelfde bestand verzonden. De tweede methode is eenvoudiger:

ls -l /root/ &> ls-error.log

U kunt ook toevoegen gebruiken in plaats van herschrijven:

ls -l /root/ &>> ls-error.log

Standaardinvoer uit bestand

De meeste programma's, behalve services, ontvangen gegevens voor hun werk via standaardinvoer. Standaard verwacht standaardinvoer invoer van het toetsenbord. Maar u kunt het programma dwingen gegevens uit een bestand te lezen met behulp van de operator "<" :

kat

U kunt de uitvoer ook onmiddellijk naar een bestand omleiden. Laten we de lijst bijvoorbeeld opnieuw sorteren:

soort sorteer.uitvoer

We sturen dus invoer/uitvoer met één opdracht om naar Linux.

Gebruik van tunnels

U kunt niet alleen met bestanden werken, maar ook de uitvoer van het ene commando omleiden als de invoer van een ander commando. Dit is erg handig bij het uitvoeren van complexe bewerkingen. Laten we bijvoorbeeld vijf onlangs gewijzigde bestanden weergeven:

ls -lt | hoofd -n 5

Met het hulpprogramma xargs kunt u opdrachten combineren, zodat standaardinvoer als parameters wordt doorgegeven. Laten we bijvoorbeeld één bestand naar verschillende mappen kopiëren:

echotest/tmp/ | xargs -n 1 cp -v testbestand.sh

Hier specificeert de -n 1 optie dat slechts één parameter per commando moet worden opgegeven, en de -v optie voor cp maakt het mogelijk om gedetailleerde informatie over bewegingen af ​​te drukken. Een ander nuttig commando in dergelijke gevallen is tee. Het leest gegevens uit standaardinvoer en schrijft naar standaarduitvoer of bestanden. Bijvoorbeeld:

echo "T-bedieningstest" | tee-bestand1

In combinatie met andere commando's kunnen deze worden gebruikt om complexe instructies met meerdere commando's te creëren.

conclusies

In dit artikel hebben we de basisprincipes van Linux I/O-streamomleiding besproken. Nu weet je hoe je de uitvoer naar een Linux-bestand of de uitvoer uit een bestand kunt omleiden. Het is heel eenvoudig en handig. Als je vragen hebt, stel ze dan in de reacties!

Als de uitvoer naar de (grafische) console niet erg omvangrijk is, kunt u eenvoudig met de muis een stuk selecteren en dit in het bericht invoegen door op de middelste knop te klikken. Anders kunt u de uitvoer via een trechter omleiden naar een bestand, zoals deze:

Some_command-parameters > logbestand.txt

Om het uitvoeringsresultaat op het scherm te zien en tegelijkertijd naar een bestand te schrijven, kunt u het tee-commando gebruiken:

Some_command-parameters | tee -een logbestand.txt

De opdracht setterm -dump maakt een momentopname van de huidige virtuele consolebuffer als een eenvoudig tekstbestand met de standaardnaam screen.dump. Als argument kun je het nummer van de console gebruiken waarvoor je wilt dumpen. En als u de optie -file bestandsnaam toevoegt, wordt deze dump omgeleid naar een bestand met de opgegeven naam. De optie -append voegt een nieuwe dump toe aan een reeds bestaand bestand - de "standaard" screen.dump of genoemd met de optie -file.

Die. na gebruik van het commando like

Setterm -dump -bestand /root/screenlog

respectievelijk in het bestand /root/schermlog zal de inhoud zijn van één consolepagina.

Ik heb een andere oplossing gevonden voor het kopiëren/plakken van tekst in een tekstconsole zonder muis. Je kunt ook tekst uit de scrollbuffer kopiëren (dus alles op het scherm en boven het scherm). Voor een beter begrip leest u over het consolevensterbeheerscherm. Het kan ook nuttig zijn om de scrollbuffergrootte te vergroten.

1) Startscherm

2) Druk op Enter. Alle. We bevinden ons in consolevenster nul.

3) Voer de benodigde opdrachten uit, waarvan de uitvoer moet worden gekopieerd.

4) Ctrl+A, Ctrl+[ - we bevinden ons in de kopieermodus. Plaats de cursor aan het begin van de selectie, druk op de spatiebalk, plaats de cursor vervolgens aan het einde van de selectie en druk op de spatiebalk. De tekst is naar het klembord gekopieerd.

5) Ctrl+A, c - we hebben een nieuw eerste venster gemaakt.

6) Ctrl+A, 1 - we gingen naar het eerste venster.

7) Open een (?) teksteditor (ik heb het in mc geprobeerd) en druk op Ctrl+A, Ctrl+] - de tekst wordt ingevoegd. Redden.

8) Ctrl+A, Ctrl+0 - ga terug naar het nulvenster.

Hoe kan ik de scrollback-buffer vergroten?

De eerste oplossing zou zijn om de standaardbuffergrootte in de kernelbronnen te vergroten en deze opnieuw te compileren. Laat ik ervan uitgaan dat u hier net zo afkerig van bent als ik en op zoek bent naar een flexibelere oplossing.

En er is zo'n tool, en het heet framebuffer console, kortweg fbcon. Dit apparaat heeft een documentatiebestand fbcon.txt; als je de kerneldocumentatie hebt geïnstalleerd, dan heb je die. Zoek hem ergens in de omgeving /usr/deel branches (ik kan het exacte pad niet specificeren vanwege verschillen in distributies).

Op dit punt bied ik mijn excuses aan: we moeten een kleine uitweiding maken en wat praten over de videobuffer ( framebuffer ).

Een videobuffer is een buffer tussen het beeldscherm en de videoadapter. Het mooie ervan is dat het kan worden gemanipuleerd: het maakt trucs mogelijk die niet zouden werken als de adapter rechtstreeks op het scherm zou worden aangesloten.

Eén zo'n truc betreft de scrollbuffer; Het blijkt dat je de videobuffer kunt "vragen" om meer geheugen aan de scrollbuffer toe te wijzen. Dit wordt bereikt via kernel-opstartparameters. Eerst eis je framebuffer(videobuffer); Dan vraag je een grotere scrollbuffer aan.

Het volgende voorbeeld is voor GRUB, maar kan eenvoudig worden aangepast aan LILO. In het GRUB-configuratiebestand - menu.lst- zoek de regel die overeenkomt met de kernel, en dan: Verwijder de optie vga=xxx, indien aanwezig. Voeg de optie video=vesabf toe of wat dan ook overeenkomt met uw hardware. Voeg de optie fbcon=scrollback:128 toe. Na deze procedure zou de kernelparameterregel er ongeveer zo uit moeten zien:

Kernel /vmlinuz root=/dev/sdb5 video=radeonfb fbcon=scrollback:128

De vraag is: waarom zou u de optie vga=xxx verwijderen? Vanwege mogelijke conflicten met de video-optie. Op mijn ATI-adapter kan ik de scrollbuffer niet wijzigen als vga=xxx in de lijst staat. Het kan zijn dat dit in uw geval niet het geval is. Als de bovenstaande opties werken, goed; maar wat als u het aantal regels wilt vergroten of een kleiner lettertype op het scherm wilt instellen? Je deed dit altijd met de optie vga=xxx - en die is verdwenen. Maak je geen zorgen: hetzelfde kan worden bereikt door de fbcon-parameters te wijzigen zoals beschreven in het bestand fbcon.txt(maar niet beschreven in dit artikel).

Met de optie fbcon=scrollback:128 werd mijn scrollbuffer vergroot tot 17 schermen (35 keer Shift+PgUp over een half scherm). Trouwens, 128 is een kilobyte. De auteur van het artikel beweert dat het onmogelijk is om meer vast te stellen. Ik heb het niet geprobeerd.

Je kunt een script gebruiken.

Scriptbestandsnaam.log

wanneer alle noodzakelijke opdrachten zijn voltooid -

Alles wordt vastgelegd in bestandsnaam.log

FreeBSD heeft een prachtig watch-hulpprogramma waarmee je terminals kunt monitoren, maar het blijkt dat het in Linux compleet andere functies vervult =\ Als je dit onderwerp googlet, zul je iets vinden...

• Vertaling

Als je de basisprincipes van de terminal al onder de knie hebt, ben je misschien klaar om de commando's die je hebt geleerd te combineren. Soms is het één voor één uitvoeren van shell-commando's voldoende om een ​​bepaald probleem op te lossen, maar in sommige gevallen is het invoeren van commando na commando te vervelend en irrationeel. In een situatie als deze kunnen enkele speciale symbolen, zoals punthaken, van pas komen.

Voor de shell, de Linux-opdrachtinterpreter, zijn deze extra tekens geen verspilling van schermruimte. Het zijn krachtige teams die verschillende stukjes informatie aan elkaar kunnen koppelen, wat voorheen één geheel was, kunnen scheiden en nog veel meer kunnen doen. Een van de eenvoudigste, maar krachtigste en meest gebruikte functies van de shell is het omleiden van standaard invoer-/uitvoerstromen.

Drie standaard I/O-streams

De eerste is de standaardinvoerstroom. In het systeem is dit thread nr. 0 (aangezien bij computers het tellen meestal vanaf nul begint). Draadnummers worden ook wel descriptors genoemd. Deze stroom vertegenwoordigt een deel van de informatie die naar de terminal wordt doorgegeven, in het bijzonder instructies die ter uitvoering naar de shell worden doorgegeven. Doorgaans komen gegevens in deze stroom binnen terwijl de gebruiker deze via het toetsenbord invoert.

De tweede stroom is de standaarduitvoerstroom, genummerd 1. Dit is de gegevensstroom die de shell uitvoert na het uitvoeren van een bepaalde actie. Normaal gesproken komen deze gegevens terecht in hetzelfde terminalvenster waar de opdracht die ervoor zorgde dat ze verschenen, werd ingevoerd.

En ten slotte is de derde stream de standaardfoutstream, deze heeft handvat 2. Deze stream is vergelijkbaar met de standaarduitvoerstream, omdat wat erin gaat meestal op het terminalscherm terechtkomt. Het verschilt echter inherent van de standaarduitvoer, en als gevolg daarvan kunnen deze stromen desgewenst afzonderlijk worden bestuurd. Dit is bijvoorbeeld handig in de volgende situatie. Er is een team dat een grote hoeveelheid data verwerkt en daarbij een complexe en foutgevoelige operatie uitvoert. U wilt dat de payload die deze opdracht genereert, niet wordt gemengd met foutmeldingen. Dit wordt bereikt door afzonderlijke omleiding van uitvoer- en foutstromen.

Zoals je waarschijnlijk al geraden had, betekent I/O-omleiding het werken met de hierboven beschreven stromen en het omleiden van de gegevens waar de programmeur deze nodig heeft. Dit gebeurt met de symbolen > en< в различных комбинациях, применение которых зависит от того, куда, в итоге, должны попасть перенаправляемые данные.

Standaarduitvoer omleiden

Wanneer u omleiding gebruikt, wordt elk bestand dat na > wordt opgegeven, overschreven. Als er niets waardevols in het bestand zit en de inhoud ervan verloren kan gaan, is het in ons ontwerp acceptabel om een ​​reeds bestaand bestand te gebruiken. Meestal is het in dit geval beter om een ​​bestandsnaam te gebruiken die nog niet bestaat. Dit bestand wordt aangemaakt nadat de opdracht is uitgevoerd. Laten we het date.txt noemen. De bestandsextensie na de punt doet er meestal niet zoveel toe, maar extensies helpen de zaken overzichtelijk te houden. Dus hier is onze opdracht:

$datum>datum.txt
Dit wil niet zeggen dat dit commando zelf ongelooflijk nuttig is, maar op basis daarvan kunnen we al iets interessants doen. Stel dat u wilt weten hoe uw internetverkeer naar een bepaald eindpunt wordt omgeleid door de gegevens dagelijks vast te leggen. De opdracht traceroute helpt bij het oplossen van dit probleem, die details rapporteert over de verkeersroute tussen onze computer en het eindpunt dat is opgegeven bij het aanroepen van de opdracht in de vorm van een URL. De gegevens bevatten informatie over alle routers waar het verkeer doorheen gaat.

Omdat we al een bestand met de datum hebben, zou het zeer gerechtvaardigd zijn om de gegevens die we van traceroute ontvangen eenvoudigweg aan dit bestand toe te voegen. Om dit te doen, moet u twee > symbolen gebruiken, achter elkaar geplaatst. Als gevolg hiervan zal een nieuw commando dat de uitvoer naar een bestand omleidt, maar het niet overschrijft, maar nieuwe gegevens toevoegt na de oude, er als volgt uitzien:

$ traceroute google.com >> datum.txt
Nu hoeven we alleen nog maar de bestandsnaam te veranderen in iets betekenisvols met behulp van de opdracht mv, waarbij de oorspronkelijke bestandsnaam als eerste argument wordt gebruikt en de nieuwe bestandsnaam als tweede:

$ mv datum.txt trace1.txt

Standaardinvoer omleiden

Laten we zeggen dat we twee bestanden hebben: list1.txt en list2.txt, die elk een ongesorteerde lijst met tekenreeksen bevatten. Elke lijst bevat elementen die uniek zijn, maar sommige elementen in de lijst zijn hetzelfde. We kunnen de regels in zowel de eerste als de tweede lijst vinden met behulp van de opdracht comm, maar voordat we deze kunnen gebruiken, moeten de lijsten worden gesorteerd.

Er is een sorteeropdracht die een gesorteerde lijst naar de terminal retourneert zonder de gesorteerde gegevens op te slaan in het bestand waaruit deze zijn gehaald. U kunt een gesorteerde versie van elke lijst naar een nieuw bestand sturen met de opdracht > en vervolgens de opdracht comm gebruiken. Deze aanpak vereist echter minstens twee opdrachten, hoewel hetzelfde op één regel kan worden gedaan zonder onnodige bestanden te maken.

We kunnen het commando dus gebruiken< для перенаправления отсортированной версии каждого файла команде comm . Вот что у нас получилось:

$ comm<(sort list1.txt) <(sort list2.txt)
De haakjes hebben hier dezelfde betekenis als in de wiskunde. De shell verwerkt eerst de opdrachten tussen haakjes en daarna al het andere. In ons voorbeeld worden de regels uit de bestanden eerst gesorteerd en vervolgens wordt het resultaat doorgegeven aan de opdracht comm, die vervolgens het resultaat van het vergelijken van de lijsten weergeeft.

Standaardfoutstroom omleiden

Wat moet u bijvoorbeeld doen als u uw hele systeem wilt doorzoeken op informatie over draadloze interfaces die toegankelijk zijn voor gebruikers die geen rootrechten hebben? Om dit te doen, kunt u het krachtige zoekcommando gebruiken.

Wanneer een normale gebruiker de find-opdracht over het hele systeem uitvoert, worden doorgaans zowel nuttige gegevens als fouten naar de terminal verzonden. Tegelijkertijd zijn er meestal meer van de laatste dan de eerste, wat het moeilijk maakt om te vinden wat je nodig hebt in de opdrachtuitvoer. De oplossing voor dit probleem is vrij eenvoudig: stuur de standaardfoutstroom gewoon om naar een bestand met behulp van de opdracht 2> (onthoud dat 2 een descriptor is voor de standaardfoutstroom). Als gevolg hiervan verschijnt alleen wat de opdracht naar de standaarduitvoer verzendt op het scherm:

$ vind / -naam draadloos 2> geweigerd.txt
Wat als u de resultaten van een opdracht in een apart bestand moet opslaan zonder deze gegevens te vermengen met foutinformatie? Omdat streams onafhankelijk van elkaar kunnen worden omgeleid, kunnen we aan het einde van onze constructie een opdracht toevoegen om standaarduitvoer naar een bestand om te leiden:

$ vind / -naam draadloos 2> geweigerd.txt> gevonden.txt
Let op: de eerste hoekbeugel wordt geleverd met het nummer - 2>, en de tweede zonder. Dit komt omdat de standaarduitvoer handle 1 heeft, en de opdracht > is bedoeld om de standaarduitvoer om te leiden als er geen handlenummer is opgegeven.

Tenslotte, als je wilt dat alles wat de opdracht uitvoert in één bestand terechtkomt, kun je beide streams naar dezelfde locatie omleiden met behulp van de opdracht &>:

$ vind / -naam draadloos &> resultaten.txt

Resultaten

Beste lezers! Kent u interessante voorbeelden van het gebruik van thread-omleiding in Linux die nieuwkomers zullen helpen zich meer op hun gemak te voelen met deze terminaltechniek?