Pipes: wat u moet weten om ze te gaan gebruiken in GNU / Linux

een pijp of pipe is eigenlijk een pijplijn die beschikbaar is voor UNIX / Linux en erg praktisch. Maar om volledig te begrijpen wat een pipe is, moet u weten dat deze in een * nix-omgeving 3 ingebouwde datastromen heeft. Dat betekent voor degenen die het niet weten, dat de gegevens van of naar drie punten kunnen reizen.

Dan begrijpt u dit op een betere manier, maar wat ik je nu duidelijk wil maken, is dat je met een pijp kunt channelen van een van die punten naar andere. Dit maakt het mogelijk de uitvoer of het resultaat te nemen dat een programma naar de invoer van een ander gooit, zodat het kan worden gebruikt, enz. Ik zal proberen het uit te leggen met enkele praktische voorbeelden die je zullen helpen het goed te begrijpen.

Die punten waar ik het over had of datastromenzijn:

• stdin: komt overeen met 0 en is de standaardinvoer. Over het algemeen is de standaard gegevensinvoer op een * nix-systeem het toetsenbord. Dat wil zeggen, wat u typt, is de gebruikte informatie. Ze heeft een speciaal apparaat dat eraan is gekoppeld en dat is / dev / stdin.
• stdout: geïdentificeerd met 1, het is de standaarduitvoer. Meestal komt het overeen met de monitor of het scherm van uw computer, waar u de informatie kunt zien. Als je bijvoorbeeld een ls-commando uitvoert, wordt de inhoudsopgave op het scherm weergegeven, toch? Het bijbehorende apparaat is / dev / stdout.
• stderr: geïdentificeerd met 2, het is de standaard foutuitvoer, voor wanneer er een fout optreedt in een programma. Het bijbehorende apparaat is / dev / stderr.

Met een pijplijn kun je de standaarduitvoer of stdout van de ene opdracht rechtstreeks naar de standaardinvoer van een andere laten gaan​ Dat wil zeggen, u kunt het ene programma het andere laten voeden. In plaats van via het toetsenbord ingevoerde parameters te gebruiken, levert een pipe de informatie die is gegenereerd door de vorige opdracht via deze pijplijn die wordt weergegeven door de |

met de voorbeelden je zult het beter begrijpen. Stel dat u de inhoud van een directory wilt weergeven, maar u bent alleen geïnteresseerd in het zien van de namen die overeenkomen met het word doc. Je zou dus een pijplijn kunnen gebruiken om de uitvoer van ls naar de invoer van het grep-filter te pipen om het te vertellen dat alleen degene moet worden weergegeven die overeenkomen met dat patroon:

ls -l | grep doc

Dus in plaats van je alle namen te laten zien, laat het je gewoon zien degenen die je echt interesseren​ U kunt hetzelfde doen met de inhoud van een bestand. Stel je voor dat je alleen de informatie wilt zien van de processen met de naam firefox en niet alle:

ps aux | grep firefox

In plaats van alle output van het ps-programma op het scherm te tonen (stdout), stuurt het het naar de input van het grep-filter en laat het alleen in de output zien wat in dit geval overeenkomt met het firefox-patroon ...

Als je wilt, kun je gebruiken verschillende pijpen om de uitvoer van een commando naar de invoer van een ander tweede commando te brengen, en de uitvoer van die tweede naar de invoer van een derde, enzovoort. Bijvoorbeeld:

cat libro | grep love | more

Zoals u ziet, de mogelijkheden zijn legio, alles wat u zich kunt voorstellen en is toegestaan. Laat zelfs alleen de eerste en laatste regels van een bestand zien, tel de regels die wc binnenkomen en die uit de lijst komen, en sorteer ze zelfs:

cat listado | head
cat listado | tail
cat listado | wc -l
cat listado | sort

U kunt er ook mee werken fouten met | & en zoek bijvoorbeeld naar het woord alert in de uitvoer van een script als het mislukt:

./miscript |& grep alerta 

En tot slot zijn er twee commando's die nauw verbonden zijn met pijpen die dat wel zijn tee en xargs en dat ze de mogelijkheden hiervan verder kunnen uitbreiden. In het geval van tee is het mogelijk om het resultaat van het vorige programma op de standaarduitvoer weer te geven, zodat u het kunt zien, en daarnaast het naar een ander bestand kan doorsturen. Een voorbeeld zou zijn als u de inhoud van een map opsomt en de uitvoer van ls -l op dit moment wilt zien en deze ook wilt opslaan in een bestand listing.txt:

ls -l | tee listado.txt

Als je geen tee gebruikt, kun je de uitvoer niet zien op je console ...

Y xargs in sommige gevallen is het zelfs nog interessanter. In dit geval is het in staat om een ​​commando op te bouwen op basis van de standaardinvoer die het via de pijplijn ontvangt. Met andere woorden, het is in staat om alles vast te leggen dat een vorig programma heeft gestart via zijn uitvoer en dat xargs bereikt via de pijplijn om het als argumenten door te geven aan een ander commando.

Snap je het nog steeds niet? Je zult het veel beter zien met een voorbeeld. Stel je voor dat je alle verdomde thumbs.db-bestanden van een map, schijf of partitie wilt verwijderen. Als er veel zijn, kan het onmogelijk zijn om een ​​voor een met de opdracht rm te gaan om ze handmatig te verwijderen. Maar met xargs kun je alles automatiseren. En je kunt het doen door find te gebruiken om ze te lokaliseren, de uitvoer door de invoer van xargs te sturen en dit geeft op zijn beurt rm de namen als argumenten. Daarom worden alle gelokaliseerde automatisch verwijderd:

find ./ -name "thumbs.db" | xargs rm

Stel dat u /home/name/thumbs.db, /media/test/thumbs.db en /tmp/thumbs.db vindt. Welnu, xargs gaat ze aan rm afleveren alsof het argumenten zijn. Dat wil zeggen, alsof we hadden uitgevoerd: rm /home/name/thumbs.db, dan rm /media/test/thumbs.db en dan rm /tmp/thumbs.db.