O shell é um programa de usuário, que oferecem uma interface personalizável para seu sistema. Além disso, os shells são uma interface de texto e interativa para o sistema operacional (intérprete de comandos), são um ambiente de execução de outros programas, consistindo em um número de variáveis de ambiente, e oferecem suas linguagens de programação, programas completos podem ser escritos nas linguagens do shell.
Os shells são personalizáveis, podendo-se ajustar ao ambiente operacional. São distintos do kernel. Executados para uso interativo pelos usuários, para uso não-interativo pelo sistema. Usam vários arquivos de configuração para seus ambientes operacionais. Podem ser executados dentro de outros shells.
Alguns exemplos de shells são o sh, bash, hsh, csh, tcsh, etc., você pode instalar shells extras usando por exemplo sudo apt-get install csh. O shell padrão é o bash.
Ao digitar csh no terminal, mudamos para o shell, algumas coisas mudam como variáveis e comandos, mas muitos dos comandos permanecem os mesmos.
Vários programas precisam de informações sobre o usuário e suas preferências para poderem rodar. Para evitar que você tenha de passar esses dados a cada comando que executa (por exemplo, caminhos de diretórios de bibliotecas), o shell cria um ambiente operacional composto de inúmeras variáveis. Essas variáveis contém valores que são usados pelos programas e por outros shells. Há dois tipos de variáveis de ambiente, as globais e as do shell (locais).
Variáveis de ambiente são como variáveis globais, pois podem ser passadas a todos os subprocessos do shell, incluindo outros shells. Exemplos:
| Variável | Significado |
|---|---|
| PATH | Lista de Diretórios de Programas Executáveis |
| USER | Nome do Usuário Logado |
| TERM | Tipo de Terminal ou Janela de Terminal em Uso |
| HOME | Diretório Home do Usuário Atual |
| UID | UID do Usuário Atual |
| RANDOM | Gera um Número Aleatório |
| LANG | Idioma, Especificado como Locale |
Os comandos env e printenv mostram as variáveis de ambiente no terminal. Para criar uma variável global, crie uma local e depos exporte-a com o comando export.
Digitando env, nós vemos as variáveis de ambiente do Linux.
As variáveis do shell são como variáveis locais, pois são específicas do shell atual. Outros programas e shells não as herdam, por exemplo SECONDS (número de segundos desde que o shell foi iniciado), e SHELL, que indica o shell em uso atualmente.
Podemos criar uma variável nova digitando algo como NOME=valor no terminal, e verificamos seu valor com o comando echo, como echo $NOME.
Podemos disposinibilizar a variável criada para outros shells ou programas com o comando export, como no caso export $NOME. E podemos remover uma variável de ambiente com o comando unset, como unset $NOME.
Digite esses comandos no shell (ignore a parte após o #):
echo $SECONDS
bash # Nova sessão do bash
echo $SECONDS
exit
echo $SECONDS
echo $SHELL
Um shell pode chamar outro shell e cada um terá suas variáveis locais com nome diferente.
Agora digite esses comandos, da mesma forma (pode ignorar tudo escrito ao lado de #):
teste="teste" # Cria uma variável local e atribui valor
echo $teste # Mostra o conteúdo da variável criada
bash # Cria um novo Processo bash filho
ps # Mostra os dois processos
echo $teste # Mostra o conteúdo da variável criada
exit # VOlta para o processo-pai
ps # Mostra o processo único rodando agora
echo $teste # Mostra o conteúdo da variável criada
export $teste # Exporta a variável teste
bash # Cria um novo Processo bash filho
ps # Mostra os dois processos
echo $teste # Mostra o conteúdo da variável criada
Variáveis de Ambiente podem ser usadas com arrays (variáveis que podem armazenar múltiplos valores). Para configurar um array, liste os seus valores entre parênteses, por exemplo:
testearray=(laranja morango acerola abacaxi)
Para acessar um elemento no array, use seu número de índice (entre colchetes) contanto a partir de zero (todo o conteúdo entre chaves), como echo ${testearray[1]}, para mostrar todo o conteúdo do array, use o asterisco no lugar do índice.
PS: Diferente dos arrays de outra linguagens, não separaramos os índices do array por vírgulas, e sim por espaços. E caso mostre o array diretamente (echo $testearray) ele só mostrará o primeito índice do mesmo.
Digite no terminal esses comandos:
echo $testearray
echo ${testearray[1]}
echo ${testearray[2]}
echo ${testearray[3]}
echo ${testearray[*]}
Para alterar valores de uma posição específica, usamos algo como testearray[2]=banana, pra remover itens individuais usamos unset testearray[2] e pra remover o array todo, unset testearray[*].
Podemos também iniciar o array assim:
pares=()
pares[0]=0
pares[1]=2
pares[2]=4
pares[3]=6
pares[4]=8
for i in ${pares[*]}; do
echo -n "${i} "
done
echo
Para ordenar arrays, podemos fazer esse algoritmo:
tam=10
numeros=(7 4 6 2 1 9 3 5 0 8)
for cont in $(seq 1 1 $tam); do
for i in $(seq 0 1 $[$tam - 2]); do
if [ ${numeros[$i]} -gt ${numeros[$i + 1]} ]; then
aux=${numeros[$i]}
numeros[$i]=${numeros[$i + 1]}
numeros[$i + 1]=$aux
fi
done
done
echo "Elementos do array em ordem crescente:"
echo
for i in $(seq 0 1 $[$tam - 1]); do
echo ${numeros[$i]}
done
É possível definir um alias para um comando ou sequência de comandos usados com frequência. Também permite modificar o comportamento padrão de um comando. Para listar os alieases criados digite alias sem parâmetros. Por padrão, os aliases são locais ao shell e não são repassados a outros programas. Para excluir um alias criado, use unalias nomedoalias.
Digite esses comandos no terminal:
cat /etc/passwd # Lê o arquivo de configuração especificado
alias mo="more" # Criação do alias, que permitirá lermos todo o conteúdo
alias # Lista os alias do sistema, inclusive o criado agora
cat /etc/passwd | mo # Uso do alias na leitura do mesmo arquivo
PS: Esses alias são criados quando o usuário inicializa o sistema, por estarem em arquivos de configuração.
Outro exemplo de criação de alias, com um comando de listar pastas simplificado:
alias lsl="ls -l"
lsl
E para excluir os alias, faça assim:
unalias mo
unalias lsl
O bash também permite trabalhar com funções, que são parecidas com os aliases, mas em vez de comandos, temos pequenos programas, por exemplo:
# Função criada:
palavra() {
cd ~
echo "Linha acrescentada">>teste.txt
}
# Para exibir a função:
palavra
Para ver as funções criadas no bash digite typeset -f | less.
As funções são locais, usadas apenas na sessão de execução, mas é possível colocar elas em arquivos de configurações.
PS: Podemos dar um ls -a para vermos os arquivos ocultos da pasta home, onde muitos deles são de configuração.
Variáveis de ambientes, funções e aliases podem ser configurados automaticamente pelo bash com o uso de alguns arquivos de configuração, de modo a definir o ambientes operacional ao iniciar o sistema. Cada arquivo de configuração tem um escopo e momento de uso definidos, e o arquivo usado depende do método usado para iniciar o bash. Há três formas de se iniciar um bash:
Alguns dos arquivos de configuração são os localizados em /etc, como /etc/profile (arquivo de inicialização, executado durante o login e válido para todo o sistema, contém variáveis de ambiente e programas de inicialização), /etc/bashrc ou /etc/bash.bashrc (arquivo de inicialização, válido para todo o sistema, executado pelo .bashrc do usuário para cada shell bash inidicado. Contém funções e aliases. E vários arquivos no home do usuário, como ~/.bash_profile (executado após o /etc/profile durante o login) e o ~/.bashrc (executado automaticamente quando o bash é iniciado interativamente).
Quando nos logamos no sistema Linux, o shell bash é iniciado em um shell de login. Esse shell procura por quatro arquivos de inicialização para processar seus comandos, na seguinte ordem:
/etc/profile
~/.bash_profile
~/.bash_login
~/.profile
Para vermos o arquivo /etc/profile, digite cat /etc/profile | less.
Quando o bash é iniciado como um shell interativo, ele não processa o arquivo /etc/profile, em vez disso, ele tenta executar o arquivo .bashrc no diretório do usuário atual. O arquivo bashrc pode ser usado para que o usuário insira aliases personalizados e funções de scripts pessoais. Também executa o arquivo global /etc/bashrc ou /etc/bash.bashrc, o qual configura algumas variáveis de ambiente locais.
Para vermos o arquivo .bashrc, digite cat ~/.bashrc | less.
O shell não-interativo é o shell iniciado para executar um script (shell script). Quando um shell é iniciado em modo não interativo, ele verifica a variável de ambiente BASH_ENV para descobrir se há comandos de inicialização a executar. Por padrão, o valor desta variável não é configurado.
Em resumo, quando você se loga no sistema Linux, o shell bash acessa o arquivo de inicialização /etc/profile, e também os arquivos de inicialização locais do seu usuário, presentes no diretório home (.bash_login, .profile e .bash_profile). Esses arquivos locais são todos opcionis e podem ser personalizados pelo usuário para incluir variáveis de ambiente e scripts de inicialização.
PS: Podemos criar nossos próprios scripts e programas em /etc/init.d para inicializar com o sistema, para isso, coloque o script nesse diretório e digite esses comandos:
sudo chmod 755 /etc/init.d/meuscript
sudo update-rc.d meuscript defaults
É possível encadear múltiplos comandos em sequência no bash, bastanto para isso separá-los com um ponto-e-vírgula, por exemplo cd /; ls -l. Essa sequência pode ser considerada como um script do shell ultra-simples. Claro que toda vez que for necessária a execução dessa sequência, devem-se digitar todos os comandos novamente. Para evitar esse problema, criaremos arquivos de script contendo os comandos que queremos executar.
Para criar um arquivo de script, use um edito de texto de sua preferência e crie um arquivo. A primeira tarefa é especificar qual shell será usado na primeira linha do arquivo (geralmente é #!/bin/bash). O símbolo # representa uma linha de comentário, exceto na primeira linha do arquivo, onde a combinação #! indica o shell que rodará o script. Ele não precisa ter extensão, mas normalmente usa a extensão .sh para os identificar.
Após especificar o shell podemos entrar com os comandos a serem executados, juntamente com os comentários necessário, por exemplo:
#!/bin/bash
# Este é o meu primeiro script do BASH
cd /
ls -l
Após digitar os comandos desejados no arquivo de script, salve-o com o nome desejado. É então necessário dar permissão de execução ao script, caso contrário ele não rodará (com chmod +x meuscript.sh). Opcionalmente, adicione também o script a algum diretório presente na variável PATH, ou adicione o diretório que contém a essa variável. Assim dá pra rodar o script chamando-o pelo nome (meuscript.sh). Para rodar o script no local onde ele está, faça como um programa (./meuscript.sh).
Podemos também editar o arquivo, no final dele coloque essa linha:
echo "Esta foi a listagem de arquivos e diretórios dentro da raiz"
O echo mostrará a mensagem no terminal.
PS: Para executar comando após o echo na mesma linha, podemos colocar antes da aspas o parâmetro -n, por exemplo
echo -n "O usuário logado no momento é "
whoami
Nós podemos usar variáveis nos nossos scripts, tanto variáveis de ambientes quanto de usuários. Veha um exemplo de um script que mostra informações do usuário atualmente logado:
#!/bin/bash
# Informações sobre o usuário:
echo "Usuário: $USER"
echo "Diretório home: $HOME"
echo "UID do usuário: $UID"
No script acima, foram usadas variáveis de ambiente do Linux. Observe que mesmo entre as aspas, as variáveis são identificadas por ter o $ na frente (isso é comum em várias linguagens cujas variáveis começam com cifrão, como o Perl e o PHP).
Você pode criar suas próprias variáveis dentro de um script; Variáveis de usuário podem conter até 20 caracteres no nome, e são case-sensitive. O shell determina automaticamente o tipo das variáveis criadas. As variáveis criadas pelo usuário são desalocadas quando termina a execução do script.
Veja um exemplo de criação de variáveis para idade e nome:
#!/bin/bash
# Teste de variáveis
idade=25
nome="Mônica"
echo "$nome tem $idade anos de idade."
No caso acima, a variável idade é int e a nome é string (por isso deve estar entre aspas).
Da mesma forma, podemos mudar o nome e a idade da variável.
Podemos colocar variáveis de usuário e de ambiente no mesmo script, por exemplo:
#!/bin/bash
# Teste de variáveis
echo "Teste de Variáveis de Usuário"
nome="Carlos"
echo "-----------------------------------"
echo "| |"
echo "| O usuário $nome tem o UID $UID |"
echo "-----------------------------------"