Linux o que é pipe? O que são pipes e como usar?

—

O que é um Pipe no Linux?

O Pipe é um comando usado em sistemas operacionais GNU/Linux que permite usar dois ou mais comandos, de forma que a saída de um comando sirva como entrada para o próximo.

Em resumo, a saída de cada processo diretamente como entrada para o próximo como um pipeline.

O símbolo ‘|’ denota um cano. Pipes ajudam a mash-up de dois ou mais comandos ao mesmo tempo e executá-los consecutivamente.

Você pode usar comandos poderosos que podem executar tarefas complexas em um instante.

—

Executo os comandos:

cd ~/Documentos/

mkdir -v TESTES

cd TESTES

touch nomedoarquivo.txt

echo -e “Morcego \nBat \nBode \napple \nGoat \nMaçã \nApple \nComer \nEat \neat \n9 Goat \n1 Eat \n4 Bat” > nomedoarquivo.txt

—

Vou entender isso com exemplos:

cat nomedoarquivo.txt | less (para sair teclo q)

cat nomedoarquivo.txt | pg (este não é muito usado)

cat nomedoarquivo.txt | more (este é o mais usado)

—

Resultado exemplo:

~/Documentos/TESTES:$ cat nomedoarquivo.txt | more
Morcego
Bat
Bode
apple
Goat
Maçã
Apple
Comer
Eat
eat
9 Goat
1 Eat
4 Bat
~/Documentos/TESTES:$

—

Quando você usa o comando ‘cat’ para exibir um arquivo que abrange várias páginas, o prompt salta rapidamente para a última página do arquivo e você não vê o conteúdo no meio. Para evitar isso, você pode canalizar a saída do comando ‘cat’ para ‘less’, que mostrará apenas um tamanho de rolagem de conteúdo por vez.

—

O comando grep é GNU. Execute:

grep –help

Relate os problemas para: bug-grep@gnu.org
página de GNU grep: <_ http://www.gnu.org=”www.gnu.org&#8221; software=”software” grep=”grep” _=”_”>
Ajuda geral sobre uso de software GNU: <_ http://www.gnu.org=”www.gnu.org&#8221; gethelp=”gethelp” _=”_”>

—

O comando grep:

grep ‘Apple’ nomedoarquivo.txt

—

Resultado é algo parecido com:

~/Documentos/TESTES:$ grep ‘Apple’ nomedoarquivo.txt
Apple
~/Documentos/TESTES:$

—

grep ‘Eat’ nomedoarquivo.txt

—

Resultado é algo parecido com:

~/Documentos/TESTES:$ grep ‘Eat’ nomedoarquivo.txt
Eat
~/Documentos/TESTES:$

—

Aqui, o comando grep pesquisou no arquivo a string ‘Apple’ e ‘Eat’.

—

As seguintes opções podem ser usadas com este comando.

Opção / Função (da opção): -v, -c, -n, -i, -l

—

A opção -v Tem a função de mostrar todas as linhas que não correspondem à sequência pesquisada,

Executo:
grep -v ‘Eat’ nomedoarquivo.txt

—

-c Exibe apenas a contagem de linhas correspondentes,

Executo:
grep -c ‘Eat’ nomedoarquivo.txt

—

-n Mostra a linha correspondente e seu número,

Executo:
grep -n ‘Eat’ nomedoarquivo.txt

—

-i Corresponde a maiúsculas e minúsculas,

Executo:
grep -i ‘Eat’ nomedoarquivo.txt

—

-l Mostra apenas o nome do arquivo com a sequência.

Executo:
grep -l ‘Eat’ nomedoarquivo.txt

—

Vamos tentar a primeira opção ‘-i’ no mesmo arquivo usado acima

grep -i ‘Bat’ nomedoarquivo.txt

—

Usando a opção ‘i’, o grep filtrou a string ‘a’ (sem distinção entre maiúsculas e minúsculas) de todas as linhas.

—

O comando ‘grep’ – Suponha que você queira pesquisar uma informação específica no código postal de um arquivo de texto. Você pode folhear manualmente o conteúdo para rastrear as informações. Uma opção melhor é usar o comando grep. Ele digitalizará o documento para obter as informações desejadas e apresentará o resultado no formato desejado. Sintaxe: grep search_string.

—

OBS:

Usando grep com o comando cat que também é GNU. Faz parte do pacote coreutils e sem o pacote coreutils nenhum sistema operacional gratúito baseado no kernel Linux funciona.

Imagine o que seria dos montes de scripts (códigos) escritos durante uns vinte anos até o dia de hoje, se os comandos do pacote coreutils fossem removidos?

—

Continuando:

cat nomedoarquivo.txt | grep -i a

—

Resultado é algo parecido com:

~/Documentos/TESTES:$ cat nomedoarquivo.txt | grep -i a
Bat
apple
Goat
Maçã
Apple
Eat
eat
~/Documentos/TESTES:$

—

Executo:

cat nomedoarquivo.txt | grep -v a

cat nomedoarquivo.txt | grep -c a

cat nomedoarquivo.txt | grep -n a

cat nomedoarquivo.txt | grep -l a

—

Resultado é algo parecido com:

~/Documentos/TESTES:$ cat nomedoarquivo.txt | grep -v a
Morcego
Bode
Apple
Comer
~/Documentos/TESTES:$ cat nomedoarquivo.txt | grep -c a
6
~/Documentos/TESTES:$ cat nomedoarquivo.txt | grep -n a
2:Bat
4:apple
5:Goat
6:Maçã
9:Eat
10:eat
~/Documentos/TESTES:$ cat nomedoarquivo.txt | grep -l a
(entrada padrão)
~/Documentos/TESTES:$

—

O comando ‘sort’ – Este comando ajuda a classificar o conteúdo de um arquivo em ordem alfabética. A sintaxe para este comando é:

sort nome-do-arquivo

Considere o conteúdo de um arquivo. Comando GNU/Linux/Unix, Grep & Sort – Usando o comando de classificação.

—

OBS:

O comando sort é GNU. Veja:

Página de ajuda do GNU coreutils: <_ http://www.gnu.org=”www.gnu.org&#8221; software=”software” coreutils=”coreutils” _=”_”>
Relate erros de tradução para <_ translationproject.org=”translationproject.org” team=”team” pt_br.html=”pt_br.html”>
Documentação completa em <_ http://www.gnu.org=”www.gnu.org&#8221; software=”software” coreutils=”coreutils” sort=”sort”>
ou disponível localmente via: info “(coreutils) sort invocation”

—

Executo o comando sort e o Resultado é algo parecido com:

~/Documentos/TESTES:$ sort nomedoarquivo.txt
apple
Apple
Bat
Bode
Comer
eat
Eat
Goat
Maçã
Morcego
~/Documentos/TESTES:$

—

O comando de classificação ‘sort’ possui três opções que podem ser usadas com ele e são listadas aqui. Opção – Função:

-r Inverte a classificação.
-n Classifica numericamente.
-f Classificação insensível a maiúsculas e minúsculas.

—

Executo:

sort -r nomedoarquivo.txt

sort -n nomedoarquivo.txt

sort -f nomedoarquivo.txt

—

Resultado é algo parecido com:

~/Documentos/TESTES:$ sort -r nomedoarquivo.txt
Morcego
Maçã
Goat
Eat
eat
Comer
Bode
Bat
Apple
apple
~/Documentos/TESTES:$ sort -n nomedoarquivo.txt
apple
Apple
Bat
Bode
Comer
eat
Eat
Goat
Maçã
Morcego
~/Documentos/TESTES:$ sort -f nomedoarquivo.txt
Apple
apple
Bat
Bode
Comer
eat
Eat
Goat
Maçã
Morcego
~/Documentos/TESTES:$

—

O que é um filtro? O Linux possui muitos comandos de filtro como awk, grep, sed, spell e wc. Um filtro recebe a entrada de um comando, faz algum processamento e fornece a saída. Quando você canaliza dois comandos, a saída “filtrada” do primeiro comando é fornecida para o próximo. Queremos destacar apenas as linhas que não contêm o caractere ‘a’, mas o resultado deve estar na ordem inversa. Para isso, a seguinte sintaxe pode ser usada:

cat nomedoarquivo.txt | grep -v a | sort – r

—

E para terminar lembro que:

Pipes (tubos) ‘|’ enviam a saída de um comando como entrada de outro comando. O filtro recebe a entrada de um comando, faz algum processamento e fornece a saída. O comando grep pode ser usado para encontrar cadeias e valores em um documento de texto. A canalização através do grep deve ser um dos comandos mais comuns.

O ‘sort’, classifica menos o conteúdo de um arquivo em ordem alfabética; comandos pg e more são usados para dividir um arquivo longo em bits legíveis. Tudo isso graças ao projeto GNU, que oferece o pacote coreutils gratuitamente a todos.

Não esqueço o Kernel Linux. Sem o Kernel o meu computador nem meu smartphone funcionariam. Sem o núcleo do GNU não existe um sistema gratuito do GNU/Linux. Ah e o meu smartphone também possui shell scripts que usam o pacote coreutils que permitem o seu ótimo funcionamento. O sistema Android usa o Kernel Linux alterado e usa também o pacote coreutils do projeto GNU.

Sem scripts não dá para o meu smartphone nem fazer chamadas telefônicas.

A base de tantas maravilhas do mundo atual bem aqui eu posso ver, escrever alguns scripts com funções, loops que funcionam (as vezes) e me divertem.

—

Linux shell bash loops funções exemplos

—

COLA BASH FUNÇÕES E LOOPS

—

Basicamente, a função bash é um conjunto de comandos. É usado principalmente para executar um único ou grupo de comandos repetidamente. As funções facilitam a leitura do código e a execução de instruções significativas do código do conjunto.

—

Você pode declarar uma função bash nos dois seguintes formatos:

—formato-1

function_name() {
commands
}

—formato-2

function function_name() {
commands
}

—

Execute no terminal:

function nome_da_funcao() { echo ‘Alou Mundo!’; echo ‘Como vai você?’; }

—

Chame a função:

nome_da_funcao

—

RESULTADO:

~:$ function nome_da_funcao() { echo ‘Alou Mundo!’; echo ‘Como vai você?’; }
~:$ nome_da_funcao
Alou Mundo!
Como vai você?
~:$

—

OBS:

EXISTEM EXEMPLOS QUE TEM ESPAÇO ENTRE O NOME DA FUNÇÃO PARÊNTESES E AS CHAVES. VOCÊ PODE DECLARAR UMA FUNÇÃO E EXECUTAR ELA NO MESMO SCRIPT.

—

Declaração da função Bash

A sintaxe para declarar uma função bash é muito simples. Elas podem ser declaradas em formatos diferentes como já foi dito aqui. O primeiro formato começa com o nome da função, seguido por parênteses. Dizem que este é o formato preferido e mais usado:

#!/usr/bin/env bash

function_name () {
command1
command2
command3
}

—

Em uma só linha:

function_name () { comando1; comando2; comando3; }

—

Teste:

hello () { echo -e ‘\nHello World!\n’; }

—

Executando a função…

NO TERMINAL CHAMA A FUNÇÃO PELO NOME.

$ hello

—

O SEGUNDO FORMATO COMEÇA COM A PALAVRA RESERVADA DA FUNÇÃO SEGUIDA PELO NOME DA FUNÇÃO.

function function_name {
comando1
comando2
comando3
}

—

EM UM LINHA SÓ:

function function_name { cmd1; cmd2; cmd3; }

—

NO TERMINAL CHAMA A FUNÇÃO PELO NOME:

$ function_name

—

Teste:

function mycmd { ls -At; pwd; date; whoami; }

—

NO TERMINAL CHAMA A FUNÇÃO PELO NOME:

$ mycmd

—

FUNCIONA TANBÉM USANDO O EXEMPLO ABAIXO:

==> FUNÇÃO

function myfunc(){ cmd1; cmd2; cmd3; }

—

Teste:

function diatemp(){ echo ‘Que dia hoje?’; date; echo ‘Tempo pc ligado?’; uptime; }

NO TERMINAL CHAMA A FUNÇÃO PELO NOME:

$ diatemp

—

Exemplo:

~:$ function diatemp(){ echo ‘Que dia hoje?’; date; echo ‘Tempo pc ligado?’; uptime; }
~:$ diatemp
Que dia hoje?
ter mar 10 06:22:50 -03 2020
Tempo pc ligado?
06:22:51 up 3:06, 1 user, load average: 5,48, 5,24, 6,09
~:$

—

==> LOOP FOR

1- Executa cmd 5x:

for i in {1..5}; do cmd_1_aqui; cmd_2_aqui; cmd_n_aqui; done

—

Exemplo:

~:$ for i in {1..5}; do echo ‘Alô Mundo!’; done
Alô Mundo!
Alô Mundo!
Alô Mundo!
Alô Mundo!
Alô Mundo!

—

2-Trabalha Arquivos:

for i in *; do echo $i; done

—

for i in /etc/*.conf; do cp $i /bkp; done

—

Escopo das variáveis – Variáveis globais são variáveis que podem ser acessadas de qualquer lugar do script, independentemente do escopo. No Bash, todas as variáveis por padrão são definidas como globais, mesmo se declaradas dentro da função. Variáveis locais podem ser declaradas dentro do corpo da função com a palavra-chave local e podem ser usadas apenas dentro dessa função. Você pode ter variáveis locais com o mesmo nome em diferentes funções.

Para ilustrar melhor como o escopo das variáveis funciona no Bash, vamos considerar um exemplo:

—

#!/usr/bin/env bash

# Nome: variaveis_escopo.sh

var1=’A’
var2=’B’

my_function () {
local var1=’C’
var2=’D’
echo “Primeira alteração: var1: $var1, var2: $var2”
}

echo “Variaveis iniciais: var1: $var1, var2: $var2”

my_function

echo “Depois de executar a função: var1: $var1, var2: $var2″

—

Outra opção melhor para retornar um valor de uma função é enviar o valor para stdout usando echo ou printf, como mostrado abaixo:

—

#!/bin/bash

# Título: retorna_valores.sh

my_function () {
local func_result=”Resultado: claytu dinamiti.”
echo “$func_result”
}

func_result=”$(my_function)”
echo $func_result

—

RETORNAR VALORES – diferente das funções em outras linguagens de programação, as funções do Bash não permitem que você retorne um valor quando chamado. Quando uma função bash é concluída, seu valor de retorno é o status da última instrução executada na função, 0 para êxito e número decimal diferente de zero no intervalo de 1 a 255 para falha. O status de retorno pode ser especificado usando a palavra-chave return e é atribuído à variável 0. A instrução return encerra a função. Você pode pensar nisso como o status de saída da função.

#!/bin/bash

my_function () {
func_result=”Algum Resultado”
}

my_function
echo $func_result

—

PASSANDO ARGUMENTOS PARA FUNÇÕES BASH – Para passar qualquer número de argumentos para a função bash, basta colocá-los logo após o nome da função, separados por um espaço. É uma boa prática aspas duplas nos argumentos para evitar a análise incorreta de um argumento com espaços nele.

1) Os parâmetros passados são $1, $2, $3 … $n, correspondentes à posição do parâmetro após o nome da função.

2) Parâmetro $0 A variável é reservada para o nome da função.

3) Parâmetro $# A variável mantém o número de parâmetros / argumentos posicionais passados para a função.

4) Parâmetro $* e $@ variaveis mantém todos os positional parameters/argumentos passados para a função.

5) Quando entre aspas o parâmetro, “$*” expande para uma única sequência separada por espaço (o primeiro caractere do IFS).

6) Quando entre aspas o parâmetro, “$@” expande para separar strings – “$1” “$2” “$n”.

7) Sem aspas duplas os parâmetros, $* e $@ são os mesmos, não tem diferença.

—

Aqui um exemplo:

./passando_argumentos.sh

—

#!/usr/bin/env bash

# Título: passando_argumentos.sh

saudacao () {
echo “Olá $1”
}

—

OBS:

Salve o script. De permissão de execução. Chame o nome da função seguida de “Jorge”.

—

$ saudacao “Jorge”
Olá Jorge

—

BASH LOOP FUNÇÕES

USE O LOOP FOR PARA EXCLUIR ARQUIVOS:

—

#!/usr/bin/env bash

for f in ~/*.txt; do [ -f “$f” ] && rm “$f”; done

# oneliner # if (se) tem arquivo, delete eles

—

==> Executar um loop sobre vários arquivos escolhidos executando um comando:

for f in file1 file2 file3 file4; do AQUI_O_CMD; done

—

Teste o comando abaixo no terminal:

for i in 1 2 3 4 5 6; do ls -t; pwd; done

—

DECLARANDO E CHAMANDO A FUNÇÃO:

—

#!/usr/bin/env bash

# Nome: Bem-vindo.sh

# declarando Bem-vindo() function

Bem-vindo () {
# lista de comandos
echo ‘Bem-vindo(a) aqui!’
}

# chamando a função Bem-vindo

Bem-vindo

—

PERMISSÃO DE EXECUÇÃO PARA O SCRIPT:

chmod +x Bem-vindo.sh

—

Resultado:

~:$ ./Bem-vindo.sh
Bem-vindo(a) aqui!
~:$

—

Conclusão – Uma função Bash é um bloco de código reutilizável projetado para executar uma operação específica. Uma vez definida, a função pode ser chamada várias vezes em um script. Você também pode usar uma função Bash para criar um comando de atalho memorável para um comando mais longo.

—

Até Breve!

🙂

—