Cor no script

Linux cor colorindo shell script cores

—

Você pode deixar seu script BASH mais bonito, colorindo sua saída. Use seqüências de escape ANSI para definir propriedades de texto como cores de primeiro plano e plano de fundo. Colorizing Shell – Use o seguinte modelo para escrever texto colorido:

—

echo -e “\e[CORmAmostra Texto\e[0m”

—

Exitem cores de texto, formato de texto e cores de fundo para serem usadas no Bash. As cores de texto tem uma numeração diferente das cores de fundo. A cor do texto, formato e fundo podem ser combinados e usados todos juntos.

—

Executo no terminal:

echo -e “\e[1;31;43m*** Texto negrito, vermelho, fundo amarelo ***\e[0m”

—

As cores de texto por exemplo, podem ser:

preto=30, vermelho=31, verde=32, amarelo=33, azul=34, púrpura=35, cyan=36, branco=37.

—

As cores de fundo mais usadas, comaçam a partir do número 40. Exemplos:

preto=40, vermelho=41, verde=42, amarelo=43, azul=44, púrpura=45, cyan=46, branco=47.

Então de 30 a 37 cores de texto. De 40 a 47 cores de fundo.

—

O texto em si pode ser normal=0, negrito/bold=1, sublinhado=4.

—

Por exemplo, fundo amarelo com texto vermelho é bem visível. Fundo branco com verde BOLD também.

—

Entendendo melhor…

—————————————-
Opção | Descrição
—————————————-
-e | Permite escapar \
—————————————-
\e[ | inicio da modificação de cor
—————————————-
CORm | cód cor+m no fim
—————————————-
\e[0m | fim modificação de cor
—————————————-

Exemplos:

1) TEXTO EM VERMELHO

echo -e “\e[31mTexto vermelho\e[0m”

echo -e “\e[31m Texto vermelho \e[0m”

echo -e “\e[31m*** Texto vermelho ***\e[0m”

—

2) TEXTO COM FUNDO VERDE

echo -e “\e[42mFundo verde\e[0m”

echo -e “\e[42m Fundo verde \e[0m”

echo -e “\e[42m*** Fundo verde ***\e[0m”

OBS: fundos – vermelho (41), preto (40), azul (44), cyan (46),

—

3) TEXTO EM VERDE

echo -e “\e[32mTexto verde\e[0m”

echo -e “\e[32m Texto verde \e[0m”

echo -e “\e[32m*** Texto verde ***\e[0m”

—

4) TEXTO AZUL

echo -e “\e[34mTexto azul\e[0m”

echo -e “\e[34m Texto azul \e[0m”

echo -e “\e[34m*** Texto azul ***\e[0m”

—

5) TEXTO CYAN

echo -e “\e[36mTexto cyan\e[0m”

echo -e “\e[36m Texto cyan \e[0m”

echo -e “\e[36m*** Texto cyan ***\e[0m”

—

A sequência de escape também permite controlar a maneira como os caracteres são exibidos na tela:

Exemplos:

echo -e “\e[1mTexto bold\e[0m”

echo -e “\e[1;36mTexto bold CYAN\e[0m”

echo -e “\e[4mTexto sublinhado\e[0m”

echo -e “\e[4;32mTexto sublinhado VERDE\e[0m”

echo -e “\e[1;4;32mTexto sublinhado BOLD VERDE\e[0m”

echo -e “\e[5mTexto piscando\e[0m”

echo -e “\e[1;4;5mTexto piscando sublinhado bold\e[0m”

echo -e “\e[1;4;31;5mTexto piscando sublinhado bold vermelho\e[0m”

echo -e “\e[5m*** Texto piscando ***\e[0m”

echo -e “\e[5m*** Fatal Error! ***\e[0m”

echo -e “\e[7m*** Video caracteres reverso ***\e[0m”

—

Ao combinar todas essas seqüências de escape, podemos obter um efeito mais sofisticado.

echo -e “\e[COLOR1;COLOR2mTexto exemplo\e[0m”

—

Podemos combinar o código de primeiro plano e o código de fundo.

—

código de primeiro plano código de fundo

Dark Gray 1;30 1;40
Light Red 1;31 1;41
Light Green 1;32 1;42
Yellow 1;33 1;43
Light Blue 1;34 1;44
Light Purple 1;35 1;45
Light Cyan 1;36 1;46
White 1;37 1;47

—

Exemplos:

echo -e “\e[1;34mTexto azul claro\e[0m”

echo -e “\e[1;33;4;44mFundo azul amarelo sublinhado\e[0m”

—

Podemos colocar tudo isto facilmente em um shell script só para testar:

—

#!/usr/bin/env bash

# titulo: testando_cores_do_bash.sh
# autor: claytu_dinamiti_1000
# Data: 2020

clear
echo
echo -e “\e[1;36m \n# —> Testando as cores do Bash no Linux! Fundo verde <-\n\e[0m”
sleep 2
echo -e “\e[1;42m*** Fundo VERDE BOLD! ***\n\e[0m”
sleep 2
echo -e “\e[34mTexto azul\n\e[0m”
sleep 3
echo -e “\e[34m Texto azul\n \e[0m”
sleep 2
echo -e “\e[34m*** Texto azul ***\n\e[0m”
sleep 3
echo -e “\e[36mTexto cyan\n\e[0m”
sleep 2
echo -e “\e[36m Texto cyan\n \e[0m”
sleep 3
echo -e “\e[36m*** Texto cyan ***\n\e[0m”
sleep 2
echo -e “\e[1mTexto BOLD\n\e[0m”
sleep 3
echo -e “\e[1;36mTexto BOLD CYAN\n\e[0m”
sleep 2
echo -e “\e[4mTexto sublinhado\n\e[0m”
sleep 3
echo -e “\e[4;32mTexto sublinhado VERDE\n\e[0m”
sleep 2
echo -e “\e[1;4;32mTexto sublinhado VERDE BOLD\n\e[0m”
sleep 3
echo -e “\e[5mTexto piscando\n\e[0m”
sleep 2
echo -e “\e[1;4;5mTexto piscando sublinhado BOLD\n\e[0m”
sleep 3
echo -e “\e[1;4;31;5mTexto piscando sublinhado BOLD vermelho\n\e[0m”
sleep 2
echo -e “\e[5m*** Texto piscando ***\n\e[0m”
sleep 3
echo -e “\e[1;31;5m*** Fatal Error! ***\n\e[0m”
sleep 2
echo -e “\e[1;36;5m*** Brincadeirinha! Just kidding! Kkk… ***\n\e[0m”
sleep 3
echo -e “\e[7m*** Video caracteres reverso ***\n\e[0m”
sleep 2
echo -e “\e[7m*** Linux Life! ***\n\e[0m”
sleep 2
echo -e “\e[1;36;5m\n*** FEITO! SAINDO EM 5 SEGUNDOS! ***\n\e[0m”
sleep 5
clear
exit 0

—

Linux laços loops for, while e until com Shell Script

—

O for em loop de comando, onde irá executar o trecho entre do e done uma vez para cada palavra listada no comando ls ~

Exemplos:

1) for f in $(ls ~/); do { echo “$f”; } done

2) for f in $(ls -tlA ~); do { echo “$f”; } done

—

Exemplo do comando for em loop de lista, onde irá executar o trecho entre do e done substituindo cada vez a variável $i pelas var. Em uma linha:

1) for i in “var 1” “var laranjas” “var luvas”; do { echo “$i”; } done

Em arquivo shell script .sh:

#!/usr/bin/env bash

for foo in “var 1” “var laranjas” “var luvas”; do
{
echo “$foo”
}
done

—

Uns símbolos usados no Bash

Vezes sem conta esqueço os nomes destes tipos abaixo. Parece tolice, mas vale um post.
—
Nome de uns símbolos usados em scripts:
() Parêntesis
{} Chaves
[] Colchetes
$ Cifrão
# Cerquilha
& E comercial
% Porcentagem
* Asterisco
@ Arrouba
\ Barra invertida
/ Barra
? Interrogação
! Exclamação
^ Acento circunflexo
~ Til
< Menor que
> Maior que
—
Até Breve!

🙂

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!

🙂

—

Dicas Linux Shell Script

:: Dicas Linux Shell Script ::

---

Vamos dar uma olhada em algumas dicas e truques sobre como trabalhar com o shell script do Linux.

---

: COMANDO BEM SUCEDIDO E MALSUCEDIDO...

Dica: Quando um comando retorna após o erro, ele retorna um status de saída diferente de zero. O comando retorna zero quando termina após a conclusão bem-sucedida. O status de retorno pode ser lido da variável especial $? (execute echo $? imediatamente após a instrução de execução do comando para imprimir o status de saída).

---

: FORK BOMB...

---

:(){:|:&};:

---

Dica: Esta função recursiva é uma função que chama a si mesma. Ele gera processos infinitamente e acaba em um ataque de negação de serviço.

& é pós-fixado com a chamada de função para colocar o subprocesso em segundo plano. Este é um código perigoso, pois ele cria processos e, portanto, é chamado de fork bomb.

Você pode achar difícil interpretar o código acima.
Veja a página da Wikipedia:

http://en.wikipedia.org/wiki/Fork_bomb para mais detalhes e interpretação da bomba.

Ele pode ser evitado restringindo o número máximo de processos que podem ser gerados a partir do arquivo de configuração /etc/security/limits.conf.

---

: ESPECIFIQUE -maxdepth e -mindepth como o terceiro argumento...

Dica: -maxdepth e -mindepth devem ser especificados como o terceiro argumento para o find. Se eles forem especificados como quarto ou mais argumentos, isso poderá afetar a eficiência do find, já que ele precisa fazer verificações desnecessárias (por exemplo, se –maxdepth for especificado como o quarto argumento e –type como o terceiro argumento, o comando find primeiro descobre todos os arquivos que possuem o tipo especificado e, em seguida, localiza todos os arquivos correspondentes com a profundidade especificada.No entanto, se a profundidade for especificada como o terceiro argumento e –type como a quarta, find poderá coletar todos os arquivos mais a profundidade especificada e, em seguida, verifique o tipo de arquivo, que é a maneira mais eficiente de pesquisa.

---

-exec COM VÁRIOS COMANDOS

Dica: Não podemos usar vários comandos junto com o parâmetro –exec. Aceita apenas um único comando, mas podemos usar um truque. Escreva vários comandos em um script de shell (por exemplo, commands.sh) e use-o com –exec da seguinte forma:

-exec ./commands.sh {} ;

---

-n OPÇÃO PARA ORDENAÇÃO NUMÉRICA

Sugestão: Tenha sempre cuidado com a opção -n para ordenação numérica. O comando sort trata a classificação alfabética e o ordenamento numérico de forma diferente. Portanto, para especificar a classificação numérica, a opção –n deve ser fornecida.

---

O ## OPERADOR

Dica: O operador ## tem mais preferência sobre o operador # para extrair uma extensão de um nome de arquivo, pois o nome do arquivo pode conter vários caracteres "." Como ## faz uma combinação gananciosa, ele sempre extrai apenas extensões.

---

: PESQUISE RECURSIVAMENTE MUITOS ARQUIVOS...

Dica: Para pesquisar recursivamente por um texto sobre vários diretórios de descendentes, use:

$ grep "text" . -R -n

Este é um dos comandos mais utilizados pelos desenvolvedores. Ele é usado para localizar o arquivo do código-fonte no qual um determinado texto existe.

---

: COLOCAR ATRIBUIÇÕES DE VARIÁVEIS...

Dica: Geralmente, colocamos atribuições de variáveis iniciais, como var = 0; e instruções para imprimir o cabeçalho do arquivo no bloco BEGIN. No bloco END {}, colocamos instruções como resultados de impressão e assim por diante.

---

ARGUMENTO -d

Dica: O argumento -d sempre deve ser fornecido entre aspas. Se aspas não forem usadas, & é interpretado pelo shell para indicar que este deve ser um processo em segundo plano.

---

: EXCLUINDO UM CONJUNTO DE ARQUIVOS DO ARQUIVAMENTO...

Dica: É possível excluir um conjunto de arquivos do arquivamento especificando padrões. Use –exclude [PATTERN] para excluir arquivos correspondentes a padrões de curingas. Por exemplo, para excluir todos os arquivos .txt do uso de arquivamento:

$ tar -cf arch.tar * --exclude "*.txt"

Observe que o padrão deve ser colocado entre aspas duplas.

---

: USANDO O COMANDO CPIO PARA CAMINHOS ABSOLUTOS...

Dica: Usando o cpio, também podemos arquivar usando arquivos como caminhos absolutos. / usr / somedir é um caminho absoluto, pois contém o caminho completo a partir da raiz (/).
Um caminho relativo não será iniciado com / mas inicia o caminho a partir do diretório atual. Por exemplo, test / file significa que existe um teste de diretório e o arquivo está dentro do diretório de teste.
Ao extrair, o cpio extrai para o caminho absoluto em si. Mas no caso do tar, ele remove o / no caminho absoluto e o converte em caminho relativo.

---

: FORMATO PATH...

Dica: Para o formato PATH, se usarmos / no final da fonte, o rsync copiará o conteúdo desse diretório final especificado no source_path para o destino.
Se estiver no final da fonte, o rsync irá copiar o próprio diretório final para o destino.

---

/ NO FINAL DO DESTINATION_PATH

Dica: Se / estiver no final de destination_path, o rsync copiará a origem para o diretório de destino. Se / não for usado no final do caminho de destino, o rsync criará uma pasta, com nome semelhante ao diretório de origem, no final do caminho de destino e copiará a origem nesse diretório.

---

: COMANDO DE ESPERA...

Dica: O comando wait permite que um script seja finalizado somente após o término ou completo de todos os seus processos-filhos ou processos em segundo plano.
Primeiro argumento do comando sftp

Dica: -oPort deve ser o primeiro argumento do comando sftp.

---

: EXECUTANDO DU DIRECTORY...

Dica: Executar du DIRECTORY irá produzir um resultado similar, mas mostrará apenas o tamanho consumido pelos subdiretórios. No entanto, eles não mostram o uso do disco para cada um dos arquivos. Para imprimir o uso do disco por arquivos, -a é obrigatória.

---

: COMANDOS DO DIRECTORY DU TRANSVERSAL...

Dica: du pode ser restrito para percorrer apenas um único sistema de arquivos usando o argumento –x.

Suponha que du DIRECTORY seja executado, ele percorrerá todos os subdiretórios possíveis de DIRECTORY recursivamente.

Um subdiretório na hierarquia de diretórios pode ser um ponto de montagem (por exemplo, /mnt/sda1 é um subdiretório de /mnt e é um ponto de montagem para o dispositivo /dev/sda1).

du percorrerá esse ponto de montagem e calculará a soma do uso do disco para o sistema de arquivos do dispositivo também.

Para impedir que o du seja percorrido e para calcular a partir de outros pontos de montagem ou sistemas de arquivos, use o sinalizador -x junto com outras du opções.

du –x/ excluirá todos os pontos de montagem em /mnt/ para cálculo de uso do disco.

---

: USE UM CAMINHO ABSOLUTO PARA O EXECUTÁVEL...

Dica: Um binário executável do comando time está disponível em /usr/bin/time, assim como existe um tempo nomeado no shell embutido.

Quando corremos o tempo, ele chama o shell embutido por padrão. O tempo interno do shell tem opções limitadas. Portanto, devemos usar um caminho absoluto para o executável (/usr/bin/time) para executar funcionalidades adicionais.

---

: ARGUMENTO -X...

Dica: O argumento -x junto com -a especifica para remover a restrição TTY transmitida, por padrão, por ps. Geralmente, o uso de ps sem argumentos imprime processos conectados apenas ao terminal.

---

: PARÂMETROS PARA -o

Dica: Os parâmetros para -o são delimitados usando o operador vírgula (,). Deve-se notar que não há espaço entre o operador vírgula e o próximo parâmetro. Principalmente, a opção -o é combinada com a opção -e (every) (-oe), pois deve listar todos os processos em execução no sistema. No entanto, quando determinados filtros são usados junto com –o, como aqueles usados para listar os processos pertencentes a usuários especificados, -e não é usado junto com –o. O uso de -e com um filtro anulará o filtro e mostrará todas as entradas do processo.

---

: COMANDO PGREP...

Dica: O pgrep requer apenas uma parte do nome do comando como seu argumento de entrada para extrair um comando Bash, por exemplo, pgrep ash ou pgrep bas também funcionará. Mas ps requer que você digite o comando exato.

---

: APROPOS...

Dica: Às vezes precisamos procurar se algum comando relacionado a uma palavra existe. Em seguida, podemos pesquisar as páginas de manual por strings no comando. Para isso, podemos usar:

apropos COMMAND

---

NEWLINE IN ECHO: Quando usar -n, quando usar \c
echo: -n ou \c

Felizmente, isso está se tornando um problema menor, mas vale a pena estar ciente, especialmente se você estiver escrevendo scripts para sistemas Unix mais antigos.

Quando você usa a instrução echo, uma nova linha é adicionada no final do comando. Isto é, se o seu script se parece com isto:

#!/bin/sh
echo Hello
echo World

Então a saída será:

Hello
World

e não:

HelloWorld

---

FREQÜENTEMENTE, é exatamente isso que você quer, mas às vezes você quer que o eco não insira essa nova linha automaticamente.

Há uma correção para isso ... bem, com mais precisão, há duas correções para isso.

Primeiro, você precisa estar ciente de que o eco é implementado pela maioria dos shells (como um comando interno do shell) e também pelo sistema operacional (normalmente como /bin/echo). Portanto, o comportamento exato depende de qual shell você está usando, se ele está configurado para usar o eco integrado ou o nativo /bin/echo e, nessa situação, você precisa saber em qual sistema operacional o script está sendo executado e como ele implementa esse recurso.

Algumas implementações usam echo -n message para dizer ao echo para não acrescentar uma nova linha; outros não têm -n, então você tem que usar echo message \c para fazer a mesma coisa. Na maioria das vezes, você vai querer echo -n, mas se você precisa que seu script seja totalmente portátil, você precisa permitir ambos:

#!/bin/sh
echo -n "Enter your name: "
read name
echo "Hello, $name"

---

ISSO FUNCIONARÁ EM ALGUNS SISTEMAS E FICARÁ ASSIM:

Digite seu nome: Stevao
Ola stevao

No entanto, em outros sistemas, ficará assim, o que não é ideal:

-n Digite seu nome: Stevao
Ola stevao

Em outros sistemas, você precisa escrever o código assim:

echo "Enter your name: \c"
read name
echo "Hello, $name"

---

ISSO FORNECERÁ os resultados corretos nesses sistemas, mas poderá fornecer resultados errados em outros sistemas (onde \c não possui nenhum significado especial, será interpretado como um caractere c literal).

Bem, isso é uma dor. Aqui está uma solução que funcionará em ambos:

if [ "`echo -n`" = "-n" ]; then
n=""
c="\c"
else
n="-n"
c=""
fi

echo $n "Enter your name: $c"
read name
echo "Hello, $name"

---

SE echo -n não fosse interpretado pelo eco, seria exibido apenas o texto literal -n. Em caso afirmativo, $ n é definido como a string vazia e $c é definido como \c.

Neste exemplo, o comando echo $n "Digite seu nome: $c" será analisado como:

echo -n "Enter your name: "

Caso contrário, o echo interpretou -n como um argumento para alterar seu comportamento, portanto, $ n é definido como -n e $c é definido como a cadeia vazia. O comando echo $ n "Digite seu nome: $c" será analisado como:

echo "Enter your name: \c"

DE QUALQUER MANEIRA, O RESULTADO DESEJADO FOI ALCANÇADO.

---

Até Breve!

🙂

.