Como depurar um script de bash?

Qualquer programa precisa estar livre de erros antes de chegar aos consumidores. Os desenvolvedores de software tentam o seu melhor para tornar os programas de software sem bugs. Mas é difícil tornar um código sem falhas quando há milhares de linhas. A depuração é um processo contínuo; Ajuda a detectar erros imediatamente, reunindo informações valiosas sobre código e eliminando pedaços de código redundantes.

Todas as linguagens de programação têm algumas abordagens comuns e poucas distintas para encontrar bugs. Por exemplo, programas de depuração podem ser usados ​​para remover erros rapidamente. Enquanto o shell script não possui nenhuma ferramenta específica para depurar o código. Esta redação é sobre discutir várias técnicas de depuração que podem ser usadas para tornar o script Bash sem erros. Antes de mergulhar nos métodos, vamos ter um entendimento básico de conchas e scripts de conchas:

Qual é a concha no Linux?

Quando você inicializa seu computador, o kernel obtém informações sobre o hardware anexado e permite que outros componentes anexados interajam. Além disso, ele gerencia memória, CPU e reconhece qualquer novo periférico. Em suma, um kernel é a espinha dorsal de qualquer sistema operacional. Mas você já pensou em interagir diretamente com o kernel, comandar para executar uma tarefa específica? É até praticável fazer isso? Absolutamente! Com a ajuda de um shell, um programa de computador com uma interface interativa, qualquer um pode operar o kernel. O shell permite que os humanos interajam com o kernel e o instrua a executar qualquer tarefa.

No Unix, existem duas conchas principais Bourne Shell e C Shell. Ambos os tipos têm suas subcategorias. Diferentes tipos de conchas de bourne são Korn Shell (Ksh), Almquist Shell (Ash), Bourne novamente Shell (Bash), e Z Shell (ZSH). Ao mesmo tempo, o shell C tem suas próprias subcategorias como C Shell (CSH) e Tenex c shell (TCSH). Como mencionado acima, de todas as conchas, Bash (Bourne novamente Shell) é a concha mais usada e sai da caixa em muitas distribuições Linux devido à sua eficiência e facilidade de uso.

Bash é o shell padrão de muitas distribuições Linux e é amplamente usado por milhões de usuários do Linux. É tão diversificado e influente que pode executar todas as tarefas que você geralmente executa em aplicativos baseados em GUI. Você pode editar arquivos, gerenciar arquivos, visualizar fotos, ouvir música, reproduzir vídeos e muito mais.

O que é um script de shell:

Como aprendemos a idéia básica de Shell, agora vamos para o script de shell. O script Shell é um programa de computador que executa vários comandos em um shell que atua como um intérprete para desempenhar uma função específica. Como discutido acima, existem 2 tipos particulares de conchas. No entanto, este guia está focado no shell de Bourne novamente (Bash).
Então, o que é um script de festa? No Linux, todos os comandos do BASH são armazenados em "/Usr/bin" e "/bin" pastas. Por exemplo, sempre que você executa um comando, bases pesquisas se houver no diretório ou não. O comando é executado se encontrar nos diretórios que mais dê um erro.

Que tal executar uma tarefa que precisa de vários comandos para executar no terminal? Nesta situação específica, o script de bash pode ajudá -lo. Bash Script é uma forma de script de shell que permite que você faça programas para executar vários comandos bash para executar uma tarefa específica.

O que são bugs no script de bash:

Enquanto trabalha com scripts de bash ou com outras linguagens de programação, você encontra muitos erros. Um bug é um erro ou uma falha no programa que pode fazer com que o programa se comporte incorretamente.

Toda linguagem de programação tem seu próprio procedimento para encontrar bugs; Da mesma forma, Bash também tem muitas opções de construção para depurar um programa de terminal.

Gerenciar erros e depurar um programa não é menos que um aborrecimento. É um trabalho demorado e pode piorar se você não estiver ciente das ferramentas certas para depurar seu programa. Este artigo é um guia completo sobre a depuração de scripts de bash para tornar seu script sem erros. Então, vamos começar:

Como depurar um script Bash:

Quando você trabalha em grandes projetos de programação, você encontra muitos erros ou bugs. Debugando um programa às vezes pode ser complicado. Os programadores geralmente utilizam ferramentas de depuração, e muitos editores de código também ajudam na descoberta de bugs, destacando a sintaxe.

Existem várias ferramentas no Linux para depurar códigos, por exemplo, GNU Debugger, também conhecido como “GDB.”Ferramentas como o GDB são úteis para linguagens de programação que compilam em binários. Como Bash é uma linguagem interpretada simples, não há necessidade de ferramentas pesadas para depurar.

Existem várias técnicas tradicionais para depurar um código de script bash, e uma delas está adicionando “Afirações.” Asserções são condições adicionadas aos programas para verificar condições específicas e executar o programa de acordo. É uma técnica defensiva que ajuda a encontrar bugs e testes também. Você pode encontrar muitas ferramentas que ajudam a adicionar afirmações em scripts de bash.

Bem, adicionar afirmações é uma das técnicas tradicionais antigas. Existem conjuntos de bandeiras/opções disponíveis no Bash para depurar um script de basquete. Essas opções podem ser adicionadas junto com Shebang nos scripts ou adicionados ao executar o programa no terminal. Os tópicos que vamos ocupar estão listados abaixo:

1. Como depurar o script Bash, permitindo Verbose “-v” opção
2. Como depurar o script Bash usando xtrace “-x” opção
3. Como depurar o script Bash usando NoExec "-n" opção
4. Como identificar o variáveis ​​não definidas Enquanto depura o script Bash
5. Como depurar o parte específica do script Bash
6. Como depurar um script de bash usando o "armadilha" comando
7. Como depurar um script de bash, eliminando Globbing de arquivos usando o "-F" opção
8. Como combinar Opções de depuração para depurar um script de shell
9. Como Redirecionar o relato de depuração para um arquivo

Então, vamos verificar várias técnicas em Bash para depurar um script de bash:

Como depurar o script Bash, permitindo a opção detalhada “-v”:

Uma das abordagens mais fáceis de depurar o script bash é usar o "-V" opção, também conhecida como detalhe. A opção pode ser adicionada ao shebang ou explicitamente colocada com o nome do arquivo de script enquanto executa. A opção Verbose será executada e imprimirá todas as linhas do código como o processo pelo intérprete. Vamos entender com um exemplo de script de bash:

#! /BIN/BASH
eco "Enter Number1"
Leia o número1
eco "Enter Number2"
Leia o número2
Se ["$ número1" -gt "$ número2"]
então
eco "número1 é maior que o número2"
Elif ["$ número1" -eq "$ número2"]
então
eco "número1 é igual a número2"
outro
eco "número2 é maior que o número1"
fi

O código acima está recebendo dois números do usuário e, em seguida, executando algumas declarações condicionais para verificar se o número é mais significativo, menos ou igual ao outro número inserido. Embora qualquer editor de texto possa ser usado para scripts de bash, estou usando o VIM Editor. O VIM é um editor poderoso e rico em recursos que destaca a sintaxe dos scripts do Bash e reduz as chances de erros de sintaxe. Se você não possui editor do VIM, obtenha -o executando o comando mencionado abaixo:

$ sudo apt install vim

Crie um arquivo de script bash usando:

$ vim b_script.sh

Se você é novo no editor do VIM, recomendo que você aprenda a usar o editor do VIM antes de prosseguir.

Agora, de volta ao script, execute o script usando "-V" opção:

$ bash -v b_script.sh

Pode ser visto na saída acima que cada linha do script é impressa no terminal enquanto processam pelo intérprete. Observe que o script deixará de receber a entrada do usuário e depois processará a próxima linha do script. Como discutido acima, o "-V" A opção pode ser colocada após Shebang, como mostrado no seguinte:

#! /bin/bash -v

Da mesma forma, a bandeira detalhada também pode ser adicionada na próxima linha de Shebang usando o "definir" comando:

#! /BIN/BASH
SET -V

Qualquer um dos métodos discutidos acima pode ativar detalhadamente.

2 Como depurar o script Bash usando a opção XTRACE “-x”:

O rastreamento de execução, também conhecido como Xtrace, é uma opção de depuração inteligente e útil, especialmente para rastrear erros lógicos. Erros lógicos são geralmente associados a variáveis ​​e comandos. Para verificar o estado da variável durante a execução do script, usamos o "-X" opção. Agora, novamente, execute o “B_Script.sh ” arquivo com o "-X" bandeira:

$ bash -x b_script.sh

A saída está mostrando explicitamente o valor de cada variável durante o processo de execução. Novamente, o "-X" pode ser usado ao lado do shebang e depois da linha Shebang usando o comando set. O XTRACE coloca o sinal "+" com cada linha do script.

3 Como depurar o script Bash usando a opção Noexec “-n”:

Erros de sintaxe são uma das principais causas de bugs. Para depurar sintaticamente o script Bash, usamos “Noexec” (sem execução) modo. A opção usada para o modo NoExec é “-N.” Ele exibirá apenas os erros de sintaxe do código em vez de executá -lo. Uma abordagem muito mais segura para depurar o código. Vamos executar “B_Script.sh ” novamente com o "-N" opção:

$ bash -n b_script.sh

Não haverá execução de código se não houver erro de sintaxe. Agora, vamos modificar nosso código:

#! /BIN/BASH
eco "Enter Number1"
Leia o número1
eco "Enter Number2"
Leia o número2
Se ["$ número1" -gt "$ número2"]
então
eco "número1 é maior que o número2"
Elif ["$ número1" -eq "$ número2"]
#então
eco "número1 é igual a número2"
outro
eco "número2 é maior que o número1"
fi

Estou comentando "então" depois "Elif". Agora, com execução "-n" “B_Script.sh ” roteiro:

$ bash -n b_script.sh

Como previsto, ele identificou claramente o erro e o exibiu no terminal.

4 Como identificar as variáveis ​​não definidas durante o script de depuração:

Fazer um erro de digitação ao escrever um código é comum. Freqüentemente, você visita uma variável, que não deixa o código executar. Para identificar esse erro, usamos o "-você" opção. Vamos modificar o código novamente:

#! /BIN/BASH
eco "Enter Number1"
Leia o número1
eco "Enter Number2"
Leia o número2
Se ["$ num1" -gt "$ número2"]
então
eco "número1 é maior que o número2"
Elif ["$ número1" -eq "$ número2"]
então
eco "número1 é igual a número2"
outro
eco "número2 é maior que o número1"
fi

Em primeiro "se" declaração condicional, eu renomeei o "número 1" variável para "Num1". Agora "Num1" é uma variável não definida. Agora execute o script:

$ bash -u b_script.sh

A saída identificou e exibe explicitamente o nome de uma variável não definida.

Como depurar a parte específica do script Bash:

O modo XTrace processa todas as linhas do código e fornece saída. No entanto, encontrar erros em um código grande seria demorado se já soubéssemos qual parte está potencialmente causando o erro. Felizmente, o Xtrace também permite depurar uma parte específica do código, que pode ser realizada usando o "definir" comando. Lugar "Set -x" no início da parte que precisa ser depurada e depois "Set +X" no final. Por exemplo, quero depurar as declarações condicionais de “B_Script.sh ”, Então, vou incluir todas as declarações condicionais em "Set -x" e "Set +X" Opções como mostrado no código abaixo:

#! /BIN/BASH
eco "Enter Number1"
Leia o número1
eco "Enter Number2"
Leia o número2
set -x
Se ["$ número" -gt "$ número2"]
então
eco "número1 é maior que o número2"
Elif ["$ número1" -eq "$ número2"]
então
eco "número1 é igual a número2"
outro
eco "número2 é maior que o número1"
fi
set +x

Agora, execute o script usando “Bash b_script.sh ”.

A saída está apenas depurando as condições IF, conforme especificado.

Como depurar um script Bash usando o comando "trap":

Se seu script for complicado, também existem mais técnicas elaborativas para a depuração. Um deles é o "armadilha" comando. O "armadilha" O comando pega os sinais e executa um comando quando uma situação específica ocorre. O comando pode ser um sinal ou uma função. Eu criei outro script pelo nome de “Sum_script.sh ”:

#! /BIN/BASH
TRAP 'Echo "Line $ lineno: o primeiro número é $ número1, o segundo número é $ número2 e a soma é $ sum"' Debug
eco "digite o primeiro número"
Leia o número1
eco "Digite o segundo número"
Leia o número2
soma = $ [número1 + número2]
eco "a soma é $ sum"

O "armadilha" comando com "DEPURAR" Sinal exibe o status das variáveis "número 1", "número 2" e "soma" Após a execução de cada linha, como mostrado na imagem de saída a seguir:

Os blocos amarelos são espaços em branco porque o usuário ainda não inseriu entrada; Esses espaços serão preenchidos à medida que o usuário insere valores. Este método também é bastante útil para depurar scripts de bash.

Como depurar um script Bash eliminando o Globbing de arquivos usando a opção "-f":

Globbing de arquivos é um processo de encontrar os arquivos com caracteres curinga, eu.e., "*" e ““?”. Em muitas situações, você não precisa expandir arquivos enquanto depura. Nesses casos, você pode bloquear o globbing de arquivos usando o "-F" opção. Vamos entender com um script “Fglobe_script.sh ”:

#! /BIN/BASH
eco "Exiba todos os arquivos de texto."
LS *.TXT

O código acima exibirá todos os arquivos de texto no diretório atual, execute:

$ Bash fglobe_script.sh

Para desligar o globbing de arquivos, use o "-F" opção:

$ bash -f fglobe_script.sh

Da mesma forma, você pode usá -lo com o shebang e com o "definir" comando também:

#! /BIN/BASH
eco "Exiba todos os arquivos de texto."
LS *.TXT
set -f
eco "Exiba todos os arquivos de texto"
LS *.TXT
set +f

Agora, corra “Bash fglobe_script.sh ”:

A parte fechada com “Set -f/set +f” Opções não processaram comandos com caracteres curinga.

Como combinar opções de depuração para depurar script de shell:

Usamos apenas uma opção nas técnicas de depuração acima mencionada, mas podemos combinar várias opções para uma melhor compreensão. Vamos implementar "-X" e "-V" opções para o “Sum_script.sh ” roteiro. Estou usando o “Sum_script.sh ” roteiro.

#! /BIN/BASH
eco "digite o primeiro número"
Leia o número1
eco "Digite o segundo número"
Leia o número2
soma = $ [número1 + número2]
eco "a soma é $ sum"

Agora execute:

$ bash -xv sum_script.sh

Ambos "-X" e "-V" As saídas são combinadas, conforme exibido na imagem de saída. Da mesma forma, também podemos combinar o "-você" opção com "-v" verbose para detecção de erro. Estou substituindo o "número 1" variável com "Num" Na sexta linha do script:

#! /BIN/BASH
é $ número2 e soma é $ sum "'Debug
eco "digite o primeiro número"
Leia o número1
eco "Digite o segundo número"
Leia o número2
soma = $ [num + número2]
eco "a soma é $ sum"

Para visualizar a saída, execute o comando abaixo mencionado:

$ bash -uv sum_script.sh

Como redirecionar o relato de depuração para um arquivo:

Salvar um relatório de depuração de um script bash em um arquivo pode ser útil em muitas situações. É um pouco complicado porque redirecionar o relatório de depuração para um arquivo; Usamos algumas variáveis ​​especiais. Vamos implementá -lo em “B_Script.sh ” código:

#! /BIN/BASH
exec 5> dubug_report.registro
Bash_xtraced = "5"
Ps4 = '$ lineno--'
eco "Enter Number1"
Leia o número1
eco "Enter Number2"
Leia o número2
Se ["$ número" -gt "$ número2"]
então
eco "número1 é maior que o número2"
Elif ["$ número1" -eq "$ número2"]
então
eco "número1 é igual a número2"
outro
eco "número2 é maior que o número1"
fi

Na segunda linha do código, pode -se ver que estamos redirecionando a saída para um “Debug_report.registro" arquivo usando o “Exec” Comando com o Descritor de Arquivo 5 (FD5).

EXEC 5> Debug_report.registro: O “Exec” O comando está redirecionando tudo que está acontecendo no shell para um arquivo “Debug_report.registro.”

Bash_xtracefd = ”5”: É uma variável de bash em particular e não pode ser usada em qualquer outra concha. Ele precisa ser atribuído um descritor de arquivo válido e o Bash escreverá a saída extraída para “Debug_report.registro.”

Ps4 = '$ lineno- ': É também uma variável bash usada para imprimir o número da linha durante a depuração usando o modo Xtrace. O valor padrão do PS4 é o "+" sinal

O script acima está gerando um arquivo de log chamado “Debug_report.registro," Para lê -lo, use o "gato" comando:

Conclusão:

Um código cheio de bugs pode afetar o desempenho do programa e prejudicial ao hardware também. A depuração é muito crucial para todos os programas, pois torna o programa mais eficiente. Encontrar erros existentes e potenciais durante o desenvolvimento de um programa pode impedir que seu programa se comporte inesperadamente. Códigos grandes geralmente precisam de depuração ativa, aumentando a eficácia do código, eliminando o recurso que consome pedaços de código.

Muitas linguagens e ambientes de programação têm seus próprios depuradores de companheiro. Na script de bash, várias técnicas podem ser implementadas para depurar o script. Este guia focou completamente em todos os métodos que podem ser usados ​​para encontrar bugs nos scripts do Bash. Portanto, sempre que você sentir que seu script bash não está se comportando como esperado, use qualquer uma das técnicas mencionadas acima, mas o modo XTrace (-x) é bastante útil na maioria dos casos.