9 exemplos de script Bash para você começar no Linux

Se você está começando com scripts Bash no Linux, obter uma sólida compreensão do básico será uma boa ajuda. Eles são a base de um conhecimento mais profundo e habilidades de script mais altas.

Lembre-se, torne seus scripts executáveis

Para que o shell execute um script, o script deve ter o conjunto de permissões do arquivo executável. Sem isso, seu script é apenas um arquivo de texto. Com ele, ainda é um arquivo de texto, mas o shell sabe que contém instruções e tentará executá-las quando o script for iniciado.

O ponto primary de escrever scripts é que eles são executados, então o primeiro passo básico é saber como deixar o Linux saber que seu script deve ser considerado executável.

o chmod comando nos permite definir permissões de arquivo. A permissão de execução pode ser definida com o sinalizador +x.

chmod +x script1.sh

Você precisará fazer isso para cada um de seus scripts. Substitua “script1.sh” pelo nome do seu script.

1. O que é essa primeira linha estranha?

A primeira linha de um script informa ao shell qual interpretador deve ser chamado para executar esse script. A primeira linha deve começar com um shebang, “#!”, também conhecido como hashbang. O “#!” informa ao shell que esta linha contém o caminho e o nome do interpretador para o qual o script foi escrito.

Isso é importante porque se você escreveu um script para rodar no Bash, você não quer que ele seja interpretado por um shell diferente. É provável que haja incompatibilidades. Bash—como a maioria dos shells—tem suas próprias peculiaridades de sintaxe e funcionalidade que outros shells não terão, ou terão implementado de forma diferente.

Quando você executa um script, o shell atual abre o script e determina qual shell ou interpretador deve ser usado para executar esse script. Em seguida, ele inicia esse shell e passa o script para ele.

#!/bin/bash

echo Operating in $SHELL

A primeira linha deste script pode ser lida como “Use o interpretador localizado em /bin/bash para executar este script”.

A única linha no script escreve o valor mantido no $SHELL variável de ambiente para a tela do terminal. Isso confirma que o Bash foi usado para executar o script.

./script1.sh

Como um truque de salão, podemos demonstrar que o script é passado para qualquer intérprete que selecionarmos.

#!/bin/cat
All of the traces of textual content are handed to the cat command
and are revealed within the terminal window. That comes with
the shebang line.

script2.sh

Este script é lançado pelo shell atual e passado para o cat comando. o cat comando “executa” o script.

Escrever seus shebangs assim supõe que você sabe onde o shell ou outro interpretador está localizado na máquina de destino. E 99% do pace, tudo bem. Mas algumas pessoas gostam de proteger suas apostas e escrever seus shebangs assim:

#!/usr/bin/env bash

echo Operating in $SHELL

script3.sh

Quando o script é iniciado o shell pesquisas para a localização do shell nomeado. Se o shell estiver em um native não padrão, esse tipo de abordagem pode evitar erros de “interpretador ruim”.

Não ouça, ele está mentindo!

No Linux, sempre há mais de uma maneira de esfolar um gato ou provar que um autor está errado. Para ser completamente factual, existe uma maneira de executar scripts sem enrolação e sem torná-los executáveis.

Se você iniciar o shell que deseja executar o script e passar o script como um parâmetro de linha de comando, o shell iniciará e executará o script — seja ele executável ou não. Como você escolhe o shell na linha de comando, não há necessidade de um shebang.

Este é o roteiro completo:

echo "I have been achieved via" $SHELL

Nós vamos usar ls para ver que o script realmente não é executável e inicie o Bash com o nome do script:

ls

bash script4.sh

Há também uma maneira de ter um script executado pelo atual shell, não um shell lançado especificamente para executar o script. Se você usar o supply comando, que pode ser abreviado para um único ponto “.“, seu script é executado pelo seu shell atual.

Portanto, para executar um script sem um shebang, sem a permissão do arquivo executável e sem iniciar outro shell, você pode usar um destes comandos:

supply script4.sh

. script4.sh

Embora isso seja possível, não é recomendado como uma solução geral. Existem inconvenientes.

Se um script não contém um shebang, você não pode dizer para qual shell ele foi escrito. Você vai se lembrar daqui a um ano? E sem a permissão executável definida no script, o ls O comando não o identificará como um arquivo executável, nem usará cores para distinguir o script dos arquivos de texto simples.

RELACIONADO: Linhas de comando: por que as pessoas ainda se incomodam com elas?

2. Impressão de texto

Escrever texto no terminal é um requisito comum. Um pouco de comments visible vai um longo caminho.

Para mensagens simples, o echo comando será suficiente. Ele permite alguma formatação do texto e permite trabalhar com variáveis ​​também.

#!/bin/bash

echo It is a easy string.
echo "It is a string containing 'unmarried quotes' so it is wrapped in double quotes."
echo "This prints the person title:" $USER
echo -e "The -e possibility shall we us usenformatting directivesnto break up the string."

./script5.sh

o printf O comando nos dá mais flexibilidade e melhores recursos de formatação, incluindo conversão de números.

Este script imprime o mesmo número usando três bases numéricas diferentes. A versão hexadecimal também é formatada para imprimir em maiúsculas, com zeros à esquerda e uma largura de três dígitos.

#!/bin/bash

printf "Decimal: %d, Octal: %o, Hexadecimal: %03Xn" 32 32 32

./script6.sh

Apply que, diferentemente de echovocê deve dizer printf para iniciar uma nova linha com o “n” símbolo.

3. Criando e usando variáveis

As variáveis ​​permitem que você armazene valores dentro de seu programa e os manipule e use. Você pode criar suas próprias variáveis ​​ou usar variáveis ​​de ambiente para valores do sistema.

#!/bin/bash

millennium_text="Years because the millennium:"

current_time=$( date '+%H:%M:%S' )
todays_date=$( date '+%F' )
12 months=$( date '+%Y' )

echo "Present time:" $current_time
echo "As of late's date:" $todays_date

years_since_Y2K=$(( 12 months - 2000 ))

echo $millennium_text $years_since_Y2K

Este script cria uma variável string chamada millennium_text. Ele contém uma linha de texto.

Em seguida, cria três variáveis ​​numéricas.

• o current_time A variável é inicializada no momento em que o script é executado.
• o todays_date variável é definida para a knowledge em que o script é executado.
• o 12 months variável mantém o ano atual.

Para acessar o valor armazenado em uma variável, preceda seu nome com um cifrão “$”.

./script7.sh

O script imprime a hora e a knowledge, depois calcula quantos anos se passaram desde o milênio e armazena isso no years_since_Y2K variável.

Por fim, imprime a string contida no millennium_text variável e o valor numérico armazenado na years_since_Y2K.

RELACIONADO: Como trabalhar com variáveis ​​no Bash

4. Manipulando a entrada do usuário

Para permitir que um usuário insira um valor que o script usará, você precisa capturar a entrada do teclado do usuário. A critica learn comando permite ut fazer exatamente isso. Aqui está um exemplo simples.

#!/bin/bash

echo "Input a host and hit "Input""
learn user_number1;
echo "Input any other quantity and hit "Input""
learn user_number2;

printf "You entered: %d and %dn" $user_number1 $user_number2
printf "Added in combination they make: %dn" $(( user_number1 + user_number2))

O script solicita dois números. Eles são lidos do teclado e armazenados em duas variáveis, user_number1 e user_number2 .

O script imprime os números na janela do terminal, soma-os e imprime o overall.

./script8.sh

Podemos combinar os activates no learn comandos usando o -p (pronta) opção.

#!/bin/bash

learn -p "Input a host and hit "Input" " user_number1;
learn -p "Input any other quantity and hit "Input" " user_number2;

printf "You entered: %d and %dn" $user_number1 $user_number2
printf "Added in combination they make: %dn" $(( user_number1 + user_number2))

Isso torna as coisas mais limpas e fáceis de ler. Scripts que são fáceis de ler também são mais fáceis de depurar.

./script9.sh

O script se comporta um pouco diferente agora. A entrada do usuário está na mesma linha que o steered.

Para capturar a entrada do teclado sem que ela ecoe na janela do terminal, use o -s opção (silenciosa).

#!/bin/bash

learn -s -p "Input your secret PIN and hit "Input" " secret_PIN;

printf "nShhh ... it's %dn" $secret_PIN

./script10.sh

O valor de entrada é capturado e armazenado em uma variável chamada secret_PIN mas não é ecoado na tela quando o usuário digita. O que você faz com isso depois disso é com você.

5. Aceitando Parâmetros

Às vezes é mais conveniente aceitar a entrada do usuário como parâmetros de linha de comando do que ter um script esperando por entrada. Passar valores para um script é fácil. Eles podem ser referenciados dentro do script como se fossem qualquer outra variável.

O primeiro parâmetro torna-se variável $1o segundo parâmetro se torna variável $2, e assim por diante. Variável $0 sempre mantém o nome do script e a variável $# contém o número de parâmetros que foram fornecidos na linha de comando. Variável $@ é uma string que contém todos os parâmetros da linha de comando.

#!/bin/bash

printf "This script is known as: %sn" $0
printf "You used %d command line parametersn" $#

# loop in the course of the variables
for param in "$@"; do
  echo "$param"
carried out

echo "Parameter 2 used to be:" $2

Este script u.s. $0 e $# para imprimir algumas informações. então u.s. ?@ para percorrer todos os parâmetros da linha de comando. Ele u.s. $2 para mostrar como acessar um único valor de parâmetro específico.

./script11.sh

Colocar várias palavras entre aspas “”” combina-as em um único parâmetro.

6. Lendo dados de arquivos

Saber ler dados de um arquivo é uma grande habilidade para se ter. Podemos fazer isso no Bash com um loop whilst.

#!/bin/bash

LineCount=0

whilst IFS='' learn -r LinefromFile || [[ -n "$LinefromFile" ]]; do

  ((LineCount++))
  echo "Studying line $LineCount: $LinefromFile"

carried out < "$1"

Estamos passando o nome do arquivo que queremos que o script processe como um parâmetro de linha de comando. Será o único parâmetro, então dentro do script $1 manterá o nome do arquivo. Estamos redirecionando esse arquivo para o whilst ciclo.

o whilst loop outline o separador de campo interno para uma string vazia, usando o IFS='' atribuição. Isso hinder a learn comando de dividir linhas no espaço em branco. Apenas o retorno de carro no ultimate de uma linha é considerado o verdadeiro ultimate da linha.

o [[ -n "$LinefromFile" ]] cláusula atende à possibilidade de que a última linha no arquivo não termine com um retorno de carro. Mesmo que isso não aconteça, essa última linha será tratada corretamente e tratada como uma linha commonplace compatível com POSIX.

./script12.sh twinkle.txt

7. Usando testes condicionais

Se você quiser que seu script execute ações diferentes para condições diferentes, será necessário realizar testes condicionais. A sintaxe de teste de colchete duplo oferece – a princípio – um número esmagador de opções.

#!/bin/bash

worth=$1

if [[ price -ge 15 ]];
then
  echo "Too pricey."
else
  echo "Purchase it!"
fi

O Bash fornece um conjunto completo de operadores de comparação que permitem determinar coisas como se um arquivo existe, se você pode ler a partir dele, se pode gravar nele e se existe um diretório.

Ele também tem testes numéricos para iguais -qeMaior que -gtMenor ou igual -lee assim por diante, embora você também possa usar o acquainted == , >= , <= notação.

./script13.sh 13

./script13.sh 14

./script13.sh 15

./script13.sh 16

8. O poder dos loops for

Repetir ações repetidamente é melhor realizado usando loops. UMA for loop permite que você execute um loop várias vezes. Isso pode ser até um número específico, ou pode ser até que o loop tenha percorrido uma lista de itens.

#!/bin/bash

for (( i=0; i<=$1; i++ ))
do
  echo "C-style for loop:" $i
carried out

for i in 1..4
do
  echo "For loop with a variety:" $i
carried out

for i in "0" "one" "two" "3"
do
  echo "For loop with an inventory of phrases:" $i
carried out

website online="How To Geek"

for i in $website online
do
  echo "For loop with a number of phrases:" $i
carried out

Todos esses laços são for loops, mas eles estão trabalhando com diferentes tipos de instruções e dados de loop.

./script14.sh 3

O primeiro loop é um estilo C clássico for ciclo. O contador de loops i é inicializado em 0 e incrementado a cada ciclo do loop. Enquanto o valor de i é menor ou igual ao valor detido em $1o loop continuará a ser executado.

O segundo loop funciona através do intervalo de números de 1 a 4. O terceiro loop funciona através de uma lista de palavras. Enquanto houver mais palavras para processar, o loop continua se repetindo.

O último loop funciona através da lista de palavras em uma variável string.

9. Funções

As funções permitem que você encapsule seções de código em rotinas nomeadas que podem ser chamadas de qualquer lugar dentro de seu script.

Suponha que queiramos que nosso script que lê linhas de um arquivo faça algum tipo de processamento em cada linha. Seria conveniente ter esse código contido em uma função.

#!/bin/bash

LineCount=0

serve as count_words() 
  printf "%d phrases in line %dn" $(echo $1 

whilst IFS='' learn -r LinefromFile || [[ -n "$LinefromFile" ]]; do

  ((LineCount++))
  count_words "$LinefromFile" $LineCount

carried out < "$1"

count_words "This is not within the loop" 99

Modificamos nosso programa de leitura de arquivos adicionando uma função chamada count_words. Está definido antes da precisamos usá-lo.

A definição da função começa com a palavra serve as. Isso é seguido por um nome exclusivo para nossa função seguido por parênteses “().” O corpo da função está contido entre chaves “”.

A definição da função não faz com que nenhum código seja executado. Nada na função é executado até que a função seja chamada.

o count_words A função imprime o número de palavras em uma linha de texto e o número da linha. Esses dois parâmetros são passados ​​para a função da mesma forma que os parâmetros são passados ​​para um script. O primeiro parâmetro torna-se função variável $1e o segundo parâmetro se torna a variável de função $2e assim por diante.

o whilst loop lê cada linha do arquivo e passa para o count_words função, juntamente com o número da linha. E apenas para mostrar que podemos chamar a função de diferentes lugares dentro do script, nós a chamamos mais uma vez fora do whilst ciclo.

./script15.sh twinkle.txt

Não tema a curva de aprendizado

Scripting é gratificante e útil, mas difícil de entrar. Uma vez que você tenha algumas técnicas reutilizáveis, você será capaz de escrever scripts que valem a pena com relativa facilidade. Então você pode olhar para funcionalidades mais avançadas.

Caminhe antes de poder correr e reserve um pace para aproveitar a jornada.

RELACIONADO: 10 comandos básicos do Linux para iniciantes