Linux Professional Institute Learning Logo.
Ir para o conteúdo principal
  • Home
    • Todos os recursos
    • LPI Materiais Didáticos
    • Colabore Conosco
    • Publishing Partners
    • Seja um Publishing Partner
    • Quem Somos
    • FAQ
    • Colaboradores
    • Contato
  • LPI.org
105.1 Lição 3
Tópico 105: Shells e scripts do Shell
105.1 Personalizar e trabalhar no ambiente shell
  • 105.1 Lição 1
  • 105.1 Lição 2
  • 105.1 Lição 3
105.2 Editar e escrever scripts simples
  • 105.2 Lição 1
  • 105.2 Lição 2
Tópico 106: Interfaces de usuário e Desktops
106.1 Instalar e configurar o X11
  • 106.1 Lição 1
106.2 Desktops gráficos
  • 106.2 Lição 1
106.3 Acessibilidade
  • 106.3 Lição 1
Tópico 107: Tarefas administrativas
107.1 Administrar contas de usuário, grupos e arquivos de sistema relacionados
  • 107.1 Lição 1
  • 107.1 Lição 2
107.2 Automatizar e agendar tarefas administrativas de sistema
  • 107.2 Lição 1
  • 107.2 Lição 2
107.3 Localização e internacionalização
  • 107.3 Lição 1
Tópico 108: Serviços essenciais do sistema
108.1 Manutenção da data e hora do sistema
  • 108.1 Lição 1
  • 108.1 Lição 2
108.2 Log do sistema
  • 108.2 Lição 1
  • 108.2 Lição 2
108.3 Fundamentos de MTA (Mail Transfer Agent)
  • 108.3 Lição 1
108.4 Configurar impressoras e impressão
  • 108.4 Lição 1
Tópico 109: Fundamentos de Rede
109.1 Fundamentos de protocolos de internet
  • 109.1 Lição 1
  • 109.1 Lição 2
109.2 Configuração persistente de rede
  • 109.2 Lição 1
  • 109.2 Lição 2
109.3 Soluções para problemas simples de rede
  • 109.3 Lição 1
  • 109.3 Lição 2
109.4 Configurar DNS cliente
  • 109.4 Lição 1
Tópico 110: Segurança
110.1 Tarefas administrativas de segurança
  • 110.1 Lição 1
110.2 Configurar a segurança do host
  • 110.2 Lição 1
110.3 Proteção de dados com criptografia
  • 110.3 Lição 1
  • 110.3 Lição 2
How to get certified
  1. Tópico 105: Shells e scripts do Shell
  2. 105.1 Personalizar e trabalhar no ambiente shell
  3. 105.1 Lição 3

105.1 Lição 3

Certificação:

LPIC-1

Versão:

5.0

Tópico:

105 Shells e scripts do Shell

Objetivo:

105.1 Personalizar e usar o ambiente do shell

Lição:

3 de 3

Introdução

Agora que aprendemos sobre shells, scripts de inicialização e variáveis nas lições anteriores, vamos concluir o tópico da personalização do shell apresentando dois elementos de shell bastante interessantes: aliases e funções. Na verdade, o que compõe o ambiente do shell é todo o grupo de variáveis, aliases e funções — e a maneira como se influenciam mutuamente.

Esses dois recursos do shell são flexíveis e ajudam a ganhar tempo no trabalho. Seu ponto forte está no conceito de encapsulamento: eles oferecem a possibilidade de reunir — sob um único comando — uma série de comandos repetitivos ou recorrentes.

Criando aliases

Um alias é um nome substituto para outro(s) comando(s). Ele pode ser executado como um comando normal, mas, na verdade, executa outro comando de acordo com a definição do alias.

A sintaxe para declarar aliases é bastante simples. Os aliases são declarados escrevendo-se a palavra-chave alias seguida pela atribuição do alias. Por sua vez, a atribuição do alias consiste no nome do alias, um sinal de igual e um ou mais comandos:

alias alias_name=command(s)

Por exemplo:

$ alias oldshell=sh

Este alias bizarro inicia uma instância do shell sh original quando o usuário digitar oldshell no terminal:

$ oldshell
$

O poder dos aliases reside no fato de nos permitirem escrever versões curtas de comandos longos:

$ alias ls='ls --color=auto'
Note

Para saber mais sobre o ls e suas cores, digite man dir_colors no terminal.

Da mesma forma, podemos criar aliases para uma série de comandos concatenados — o ponto e vírgula (;) é usado como um delimitador. Podemos, por exemplo, ter um alias que nos dá informações sobre a localização do executável git e sua versão:

$ alias git_info='which git;git --version'

Para invocar um alias, digitamos seu nome no terminal:

$ git_info
/usr/bin/git
git version 2.7.4

O comando alias produz uma lista de todos os aliases disponíveis no sistema:

$ alias
alias git-info='which git;git --version'
alias ls='ls --color=auto'
alias oldshell='sh'

O comando unalias remove aliases. Podemos, por exemplo, digitar unalias git-info e ver como ele desaparece da listagem:

$ unalias git-info
$ alias
alias ls='ls --color=auto'
alias oldshell='sh'

Como vimos com alias hi='echo We salute you.' em uma lição anterior, precisamos colocar os comandos entre aspas (simples ou duplas) quando — devido aos argumentos ou parâmetros — eles contêm espaços :

$ alias greet='echo Hello world!'
$ greet
Hello world!

Os comandos que incluem opções também têm espaços:

$ alias ll='ls -al'

Agora, ll listará todos os arquivos — incluindo os ocultos (a) — no formato longo (l).

Podemos referenciar variáveis em aliases:

$ reptile=uromastyx
$ alias greet='echo Hello $reptile!'
$ greet
Hello uromastyx!

A variável também pode ser atribuída dentro do alias:

$ alias greet='reptile=tortoise; echo Hello $reptile!'
$ greet
Hello tortoise!

Podemos escapar um alias com \:

$ alias where?='echo $PWD'
$ where?
/home/user2
$ \where?
-bash: where?: command not found

O escape de um alias é útil quando um alias tem o mesmo nome de um comando regular. Nesse caso, o alias tem precedência sobre o comando original, que, no entanto, ainda pode ser acessado escapando-se o alias.

Da mesma forma, podemos colocar um alias dentro de outro alias:

$ where?
/home/user2
$ alias my_home=where?
$ my_home
/home/user2

Além disso, também é possível colocar uma função dentro de um alias, como será demonstrado mais adiante.

Expansão e avaliação de aspas em aliases

Ao se usar aspas com variáveis de ambiente, as aspas simples tornam a expansão dinâmica:

$ alias where?='echo $PWD'
$ where?
/home/user2
$ cd Music
$ where?
/home/user2/Music

No entanto, com aspas duplas, a expansão é feita estaticamente:

$ alias where?="echo $PWD"
$ where?
/home/user2
$ cd Music
$ where?
/home/user2

Persistência de aliases: scripts de inicialização

Como no caso das variáveis, para que nossos aliases se tornem persistentes devemos colocá-los em scripts de inicialização que são originados quando o sistema é iniciado. Como já sabemos, um bom arquivo para os usuários colocarem seus aliases pessoais é ~/.bashrc. Já deve haver alguns aliases por lá (a maioria deles comentados e prontos para uso, bastando remover o # inicial):

$ grep alias .bashrc
# enable color support of ls and also add handy aliases
    alias ls='ls --color=auto'
    #alias dir='dir --color=
    #alias vdir='vdir --color=
    #alias grep='grep --color=
    #alias fgrep='fgrep --color'
    #alias egrep='egrep --color=
# some more ls aliases
#ll='ls -al'
#alias la='ls -A'
#alias l='ls -CF'
# ~/.bash_aliases, instead of adding them here directly.
if [ -f ~/.bash_aliases ]; then
   . ~/.bash_aliases

Como podemos ver nas últimas três linhas, é possível ter nosso próprio arquivo dedicado aos aliases — ~/.bash_aliases — para o .bashrc abrir e executar a cada inicialização do sistema. Ao escolher essa opção, criamos e preenchemos esse arquivo:

###########
# .bash_aliases:
# a file to be populated by the user's personal aliases (and sourced by ~/.bashrc).
###########
alias git_info='which git;git --version'
alias greet='echo Hello world!'
alias ll='ls -al'
alias where?='echo $PWD'

Criando funções

Comparadas aos aliases, as funções são mais programáticas e flexíveis, especialmente quando se trata de aproveitar todo o potencial das variáveis internas especiais e parâmetros posicionais do Bash. Elas também são ótimas para trabalhar com estruturas de controle de fluxo, como loops ou condicionais. Podemos pensar em uma função como um comando que inclui lógica por meio de blocos ou coleções de outros comandos.

Duas sintaxes para criar funções

Existem duas sintaxes válidas para definir funções.

Usando a palavra-chave function

Por um lado, podemos usar a palavra-chave function, seguida pelo nome da função e os comandos entre chaves:

function function_name {
command #1
command #2
command #3
.
.
.
command #n
}
Using ()

Por outro lado, podemos deixar de fora a palavra-chave function e usar duas chaves logo após o nome da função:

function_name() {
command #1
command #2
command #3
.
.
.
command #n
}

É comum colocar funções em arquivos ou scripts. No entanto, elas também podem ser escritas diretamente no prompt do shell com cada comando em uma linha diferente — note PS2(>) indicando uma nova linha após uma quebra de linha:

$ greet() {
> greeting="Hello world!"
> echo $greeting
> }

Seja qual for o caso — e independentemente da sintaxe que escolhermos — , se decidirmos pular as quebras de linha e escrever uma função em apenas uma linha, os comandos devem ser separados por ponto e vírgula (observe o ponto e vírgula inclusive após o último comando):

$ greet() { greeting="Hello world!"; echo $greeting; }

O bash não reclamou quando pressionamos Enter, de modo que nossa função está pronta para ser chamada. Para invocar uma função, temos de digitar seu nome no terminal:

$ greet
Hello world!

Como no caso das variáveis e aliases, se quisermos que as funções sejam persistentes durante as reinicializações do sistema, temos de colocá-las em scripts de inicialização do shell, como /etc/bash.bashrc (global) ou ~/.bashrc (local).

Warning

Depois de adicionar aliases ou funções para qualquer arquivo de script de inicialização, é preciso executar . ou source nesses arquivos para que as alterações tenham efeito (caso você não queira fazer logout e login novamente ou reinicializar o sistema).

Variáveis integradas especiais do Bash

O Bourne Again Shell vem com um conjunto de variáveis especiais que são particularmente úteis para funções e scripts. Elas são especiais porque só podem ser referenciadas — e não atribuídas. Eis uma lista das mais relevantes:

$?

A referência desta variável se expande para o resultado do último comando executado. Um valor de 0 significa sucesso:

$ ps aux | grep bash
user2      420  0.0  0.4  21156  5012 pts/0    Ss   17:10   0:00 -bash
user2      640  0.0  0.0  12784   936 pts/0    S+   18:04   0:00 grep bash
$ echo $?
0

Um valor diferente de 0 significa erro:

user1@debian:~$ ps aux |rep bash
-bash: rep: command not found
user1@debian:~$ echo $?
127
$$

Expande-se para o PID do shell (ID do processo):

$ ps aux | grep bash
user2      420  0.0  0.4  21156  5012 pts/0    Ss   17:10   0:00 -bash
user2      640  0.0  0.0  12784   936 pts/0    S+   18:04   0:00 grep bash
$ echo $$
420
$!

Expande-se para o PID do último trabalho em segundo plano:

$ ps aux | grep bash &
[1] 663
$ user2      420  0.0  0.4  21156  5012 pts/0    Ss+  17:10   0:00 -bash
user2      663  0.0  0.0  12784   972 pts/0    S    18:08   0:00 grep bash
^C
[1]+  Done                   ps aux | grep bash
$ echo $!
663
Note

Lembre-se, o e comercial (&) é usado para iniciar processos em segundo plano.

Parâmetros posicionais $0 a $9

Expandem-se para os parâmetros ou argumentos que estão sendo passados para a função (alias ou script) — $0 se expande para o nome do script ou shell.

Vamos criar uma função para demonstrar os parâmetros posicionais — note PS2 (>) indicando novas linhas após as quebras de linha:

$ special_vars() {
> echo $0
> echo $1
> echo $2
> echo $3
}

Agora, vamos invocar a função (special_vars) passando três parâmetros para ela (debian, ubuntu, zorin):

$ special_vars debian ubuntu zorin
-bash
debian
ubuntu
zorin

Tudo funcionou como esperado.

Warning

Embora seja tecnicamente possível passar parâmetros posicionais para aliases, não é lá muito prático, já que — com aliases — os parâmetros posicionais são sempre passados no final:

$ alias great_editor='echo $1 is a great text editor'
$ great_editor emacs
is a great text editor emacs

Outras variáveis integradas especiais do Bash incluem:

$#

Expande-se para o número de argumentos passados para o comando.

$@, $*

Expandem-se para os argumentos passados para o comando.

$_

Expande-se para o último parâmetro ou o nome do script (dentre outras coisas; consulte man bash para saber mais!):

Variáveis em funções

Obviamente, as variáveis podem ser usadas dentro de funções.

Para provar, desta vez vamos criar um novo arquivo vazio chamado funed e colocar nele a seguinte função:

editors() {

editor=emacs

echo "My editor is: $editor. $editor is a fun text editor."
}

Como você já deve ter adivinhado, precisamos primeiro originar o arquivo para poder invocar a função:

$ . funed

E agora podemos testá-la:

$ editors
My editor is emacs. emacs is a fun text editor.

Como você pode perceber, para que a função editors funcione corretamente, a variável editor deve primeiro ser definida. O escopo dessa variável é local para o shell atual e podemos referenciá-la enquanto a sessão durar:

$ echo $editor
emacs

Juntamente com as variáveis locais, também podemos incluir variáveis de ambiente em nossa função:

editors() {

editor=emacs

echo "The text editor of $USER is: $editor."
}

editors

Observe como desta vez decidimos chamar a função de dentro do próprio arquivo (editors na última linha). Dessa forma, quando o arquivo for aberto e executado, a função também será chamada — tudo de uma vez:

$ . funed
The text editor of user2 is: emacs.

Parâmetros posicionais em funções

Ocorre algo semelhante com os parâmetros posicionais.

Podemos passá-los para funções de dentro do arquivo ou script (observe a última linha: editors tortoise):

editors() {

editor=emacs

echo "The text editor of $USER is: $editor."
echo "Bash is not a $1 shell."
}

editors tortoise

Fazemos source no arquivo para provar que funciona:

$ . funed
The text editor of user2 is: emacs.
Bash is not a tortoise shell.

E também podemos passar parâmetros posicionais para funções na linha de comando. Para provar, removemos a última linha do arquivo:

editors() {

editor=emacs

echo "The text editor of $USER is: $editor."
echo "Bash is not a $1 shell."
}

Em seguida, temos de fazer source no arquivo:

$ . funed

Finalmente, invocamos a função com tortoise como o parâmetro posicional $1 na linha de comando:

$ editors tortoise
The text editor of user2 is: emacs.
Bash is not a tortoise shell.

Funções em scripts

As funções são encontradas principalmente em scripts do Bash.

É facílimo transformar nosso arquivo funed em um script (vamos chamá-lo de funed.sh):

#!/bin/bash

editors() {

editor=emacs

echo "The text editor of $USER is: $editor."
echo "Bash is not a $1 shell."
}

editors tortoise

É só isso! Adicionamos apenas duas linhas:

  • A primeira linha é o shebang e define qual programa irá interpretar o script: #!/bin/bash. Curiosamente, esse programa é o próprio bash.

  • A última linha é simplesmente a invocação da função.

Agora só resta uma coisa — tornar o script executável:

$ chmod +x funed.sh

E agora ele está pronto para ser executado:

$ ./funed.sh
The text editor of user2 is: emacs.
Bash is not a tortoise shell.
Note

Você aprenderá tudo sobre criar scripts do shell nas próximas lições.

Uma função dentro de um alias

Como dito acima, podemos colocar uma função dentro de um alias:

$ alias great_editor='gr8_ed() { echo $1 is a great text editor; unset -f gr8_ed; }; gr8_ed'

Este longo valor de alias merece uma explicação. Vamos decompô-lo:

  • Primeiro, temos a função em si: gr8_ed() { echo $1 is a great text editor; unset -f gr8_ed; }

  • O último comando da função — unset -f gr8_ed — remove a função definida, de forma que ela não permanece na sessão atual do bash depois que o alias é chamado.

  • Por fim, para ter uma invocação de alias bem-sucedida, devemos primeiro invocar também a função: gr8_ed.

Vamos invocar o alias e provar que ele funciona:

$ great_editor emacs
emacs is a great text editor

Como mostrado em unset -f gr8_ed acima, o comando unset não é usado somente para remover as variáveis definidas, mas também as funções. Na verdade, existem opções específicas:

unset -v

para as variáveis

unset -f

para as funções

Se usado sem opções, o unset tenta primeiro remover uma variável e — se falhar — ele tenta remover uma função.

Uma função dentro de uma função

Agora, digamos que queremos comunicar duas coisas a user2 toda vez que ele se logar no sistema:

  • Dizer oi e recomendar/elogiar um editor de texto.

  • Como ele tem posto muitos arquivos de vídeo Matroska na pasta $HOME/Video folder, também queremos adverti-la de que existe um limite.

Para cumprir esse objetivo, colocamos as duas funções a seguir em /home/user2/.bashrc:

A primeira função (check_vids) faz a verificação dos arquivos .mkv e emite o aviso:

check_vids() {
    ls -1 ~/Video/*.mkv > /dev/null 2>&1
    if [ "$?" = "0" ];then
        echo -e "Remember, you must not keep more than 5 video files in your Video folder.\nThanks."
    else
	echo -e "You do not have any videos in the Video folder. You can keep up to 5.\nThanks."
    fi
}

check_vids faz três coisas:

  • Lista os arquivos mkv em ~/Video enviando a saída — e quaisquer erros — para o chamado bit-bucket (/dev/null).

  • Testa a saída do comando anterior.

  • Dependendo do resultado do teste, ecoa uma mensagem (dentre duas opções).

A segunda função é uma versão modificada da nossa função editors:

editors() {

editor=emacs

echo "Hi, $USER!"
echo "$editor is more than a text editor!"

check_vids
}

editors

É importante observar duas coisas:

  • O último comando de editors invoca check_vids, de modo que as duas funções são encadeadas: A saudação, a recomendação e a verificação e aviso são executados em sequência.

  • editors é o ponto de entrada para a seqüência de funções, portanto é invocado na última linha (editors).

Agora, vamos entrar como user2 para provar que funciona:

# su - user2
Hi, user2!
emacs is more than a text editor!
Remember, you must not keep more than 5 video files in your Video folder.
Thanks.

Exercícios Guiados

  1. Complete a tabela com “Sim” ou “Não” levando em conta as capacidades dos aliases e funções:

    Recurso Aliases? Funções?

    Variáveis locais podem ser usadas

    Variáveis de ambiente podem ser usadas

    Podem ser escapadas com \

    Podem ser recursivas

    Muito produtivas quando usadas com parâmetros posicionais

  2. Escreva o comando que lista todos os aliases do sistema:

  3. Escreva um alias chamado logg para listar todos os arquivos ogg em ~/Music — um por linha:

  4. Invoque o alias para provar que funciona:

  5. Agora, modifique o alias para que ele exiba o nome do usuário da sessão e dois pontos antes da listagem:

  1. Invoque-o novamente para provar que esta nova versão também funciona:

  2. Liste novamente todos os aliases e confira se o alias logg aparece na listagem:

  3. Remova o alias:

  4. Estude as colunas “Nome do Alias” e “Comando(s) com Alias” e atribua corretamente os aliases a seus valores:

    Nome do Alias Comando(s) com Alias Atribuição do Alias

    b

    bash

    bash_info

    which bash + echo "$BASH_VERSION"

    kernel_info

    uname -r

    greet

    echo Hi, $USER!

    computer

    pc=slimbook + echo My computer is a $pc

  5. Como root, escreva uma função chamada my_fun em /etc/bash.bashrc. A função deve dizer olá ao usuário e informá-lo de qual é seu caminho. Invoque-a para que o usuário receba ambas as mensagens a cada vez que fizer login:

  6. Faça login como user2 para verificar se funciona:

  7. Escreva a mesma função em apenas uma linha:

  8. Invoque a função:

  9. Remova a função:

  10. Esta é uma versão modificada da função special_vars:

    $ special_vars2() {
    > echo $#
    > echo $_
    > echo $1
    > echo $4
    > echo $6
    > echo $7
    > echo $_
    > echo $@
    > echo $?
    > }

    Este é o comando que usamos para invocá-la:

    $ special_vars2 crying cockles and mussels alive alive oh

    Adivinhe as saídas:

    Referência Valor

    echo $#

    echo $_

    echo $1

    echo $4

    echo $6

    echo $7

    echo $_

    echo $@

    echo $?

  11. Com base na função de exemplo (check_vids) da seção “Uma função dentro de uma função”, escreva uma função chamada check_music a ser incluída em um script de inicialização do bash que aceite parâmetros posicionais, sendo assim possível modificá-la facilmente:

    • tipo de arquivo a ser verificado: ogg

    • diretório em que os arquivos são salvos: ~/Music

    • tipo de arquivo sendo guardado: music

    • número de arquivos salvos: 7

Exercícios Exploratórios

  1. Funções somente leitura são aquelas cujo conteúdo não podemos modificar. Faça uma pesquisa sobre funções somente leitura e preencha a seguinte tabela:

    Nome da função Torná-la somente leitura Listar todas as funções somente leitura

    my_fun

  2. Pesquise na web como modificar PS1, além de outras informações necessárias para escrever uma função chamada fyi (a ser posta em um script de inicialização) que forneça ao usuário as seguintes informações:

    • nome do usuário

    • diretório inicial

    • nome do host

    • tipo de sistema operacional

    • caminho de pesquisa para executáveis

    • diretório de email

    • frequência de verificação do email

    • quantas camadas de shell tem a sessão atual

    • prompt (deve ser modificado para exibir <user>@<host-date>)

Resumo

Nesta lição, você aprendeu:

  • Tanto aliases quanto funções são recursos importantes do shell que permitem encapsular blocos de código recorrentes.

  • Os aliases são úteis para criar versões mais curtas de comandos longos e/ou complicados.

  • As funções são procedimentos que implementam lógica e permitem automatizar tarefas, especialmente quando usadas em scripts.

  • A sintaxe para criar aliases e funções.

  • Como concatenar diversos comandos usando ponto e vírgula (;).

  • Como usar aspas corretamente com os aliases.

  • Como tornar persistentes os aliases e funções.

  • Variáveis especiais nativas do Bash: $?, $$, $!, parâmetros posicionais ($0-$9), $#, $@, $* e $_.

  • Como usar variáveis e parâmetros posicionais com funções.

  • Como usar funções em scripts.

  • Como invocar uma função a partir de um alias.

  • Como invocar uma função a partir de outra função.

  • Noções básicas para a criação de um script bash.

Comandos e palavras-chave usados nesta lição:

alias

Criar aliases.

unalias

Remover aliases.

cd

Mudar de diretório.

grep

Imprimir linhas de acordo com um padrão.

function

Palavra-chave do shell para criar funções.

.

Buscar e executar um arquivo.

source

Buscar e executar um arquivo.

ps

Exibir um instantâneo dos processos atuais.

echo

Exibir uma linha de texto.

chmod

Alterar os bits de modo de um arquivo, por exemplo para torná-lo executável.

unset

Remover variáveis e funções definidas.

su

Alterar o ID do usuário ou torná-lo superusuário.

Respostas aos Exercícios Guiados

  1. Complete a tabela com “Sim” ou “Não” levando em conta as capacidades dos aliases e funções:

    Recurso Aliases? Funções?

    Variáveis locais podem ser usadas

    Sim

    Sim

    Variáveis de ambiente podem ser usadas

    Sim

    Sim

    Podem ser escapadas com \

    Sim

    Não

    Podem ser recursivas

    Sim

    Sim

    Muito produtivas quando usadas com parâmetros posicionais

    Não

    Sim

  2. Escreva o comando que lista todos os aliases do sistema:

    alias
  3. Escreva um alias chamado logg para listar todos os arquivos ogg em ~/Music — um por linha:

    alias logg='ls -1 ~/Music/*ogg'
  4. Invoque o alias para provar que funciona:

    logg
  5. Agora, modifique o alias para que ele exiba o nome do usuário da sessão e dois pontos antes da listagem:

    alias logg='echo $USER:; ls -1 ~/Music/*ogg'
  6. Invoque-o novamente para provar que esta nova versão também funciona:

    logg
  7. Liste novamente todos os aliases e confira se o alias logg aparece na listagem:

    alias
  8. Remova o alias:

    unalias logg
  9. Estude as colunas “Nome do Alias” e “Comando(s) com Alias” e atribua corretamente os aliases a seus valores:

    Nome do Alias Comando(s) com Alias Atribuição do Alias

    b

    bash

    alias b=bash

    bash_info

    which bash + echo "$BASH_VERSION"

    alias bash_info='which bash; echo "$BASH_VERSION"'

    kernel_info

    uname -r

    alias kernel_info='uname -r'

    greet

    echo Hi, $USER!

    alias greet='echo Hi, $USER'

    computer

    pc=slimbook + echo My computer is a $pc

    alias computer='pc=slimbook; echo My computer is a $pc'

    Note

    As aspas simples podem ser substituídas por aspas duplas.

  10. Como root, escreva uma função chamada my_fun em /etc/bash.bashrc. A função deve dizer olá ao usuário e informá-lo de qual é seu caminho. Invoque-a para que o usuário receba ambas as mensagens a cada vez que fizer login:

    Opção A:

    my_fun() {
    echo Hello, $USER!
    echo Your path is: $PATH
    }
    my_fun

    Opção B:

    function my_fun {
    echo Hello, $USER!
    echo Your path is: $PATH
    }
    my_fun
  11. Faça login como user2 para verificar se funciona:

    su - user2
  12. Escreva a mesma função em apenas uma linha:

    Opção A:

    my_fun() { echo "Hello, $USER!"; echo "Your path is: $PATH"; }

    Opção B:

    function my_fun { echo "Hello, $USER!"; echo "Your path is: $PATH"; }
  13. Invoque a função:

    my_fun
  14. Remova a função:

    unset -f my_fun
  15. Esta é uma versão modificada da função special_vars:

    $ special_vars2() {
    > echo $#
    > echo $_
    > echo $1
    > echo $4
    > echo $6
    > echo $7
    > echo $_
    > echo $@
    > echo $?
    > }

    Este é o comando que usamos para invocá-la:

    $ special_vars2 crying cockles and mussels alive alive oh

    Adivinhe as saídas:

    Referência Valor

    echo $#

    7

    echo $_

    7

    echo $1

    crying

    echo $4

    mussels

    echo $6

    alive

    echo $7

    oh

    echo $_

    oh

    echo $@

    crying cockles and mussels alive alive oh

    echo $?

    0

  16. Com base na função de exemplo (check_vids) da seção “Uma função dentro de uma função”, escreva uma função chamada check_music a ser incluída em um script de inicialização do bash que aceite parâmetros posicionais, sendo assim possível modificá-la facilmente:

    • tipo de arquivo a ser verificado: ogg

    • diretório em que os arquivos são salvos: ~/Music

    • tipo de arquivo sendo guardado: music

    • número de arquivos salvos: 7

      check_music() {
          ls -1 ~/$1/*.$2 > ~/.mkv.log 2>&1
          if [ "$?" = "0" ];then
              echo -e "Remember, you must not keep more than $3 $4 files in your $1 folder.\nThanks."
          else
      	 echo -e "You do not have any $4 files in the $1 folder. You can keep up to $3.\nThanks."
          fi
      }
      
      check_music Music ogg 7 music

Respostas aos Exercícios Exploratórios

  1. Funções somente leitura são aquelas cujo conteúdo não podemos modificar. Faça uma pesquisa sobre funções somente leitura e preencha a seguinte tabela:

    Nome da função

    Torná-la somenrte leitura

    Listar todas as funções somente leitura

    my_fun

    readonly -f my_fun

    readonly -f

  2. Pesquise na web como modificar PS1, além de outras informações necessárias para escrever uma função chamada fyi (a ser posta em um script de inicialização) que forneça ao usuário as seguintes informações:

    • nome do usuário

    • diretório inicial

    • nome do host

    • tipo de sistema operacional

    • caminho de pesquisa para executáveis

    • diretório de email

    • frequência de verificação do email

    • quantas camadas de shell tem a sessão atual

    • prompt (deve ser modificado para exibir <user>@<host-date>)

      fyi() {
          echo -e "For your Information:\n
          Username: $USER
          Home directory: $HOME
          Host: $HOSTNAME
          Operating System: $OSTYPE
          Path for executable files: $PATH
          Your mail directory is $MAIL and is searched every $MAILCHECK seconds.
          The current level of your shell is: $SHLVL"
          PS1="\u@\h-\d "
      }
      
      fyi

Linux Professional Insitute Inc. Todos os direitos reservados. Visite o site dos Materiais Didáticos: https://learning.lpi.org
31/5000 Este trabalho está licenciado sob a Licença Creative Commons Atribuição-Uso Não-Comercial-NãoDerivativos 4.0 Internacional.

Próxima Lição

105.2 Editar e escrever scripts simples (105.2 Lição 1)

Ir para a próxima lição

Linux Professional Insitute Inc. Todos os direitos reservados. Visite o site dos Materiais Didáticos: https://learning.lpi.org
31/5000 Este trabalho está licenciado sob a Licença Creative Commons Atribuição-Uso Não-Comercial-NãoDerivativos 4.0 Internacional.

A LPI é uma organização sem fins lucrativos.

© 2023 O Linux Professional Institute (LPI) é um organismo de apoio aos profissionais de Open Source e referência mundial em certificação. Com mais de 200.000 pessoas certificadas, somos o principal organismo de certificação independente para Linux e Open Source do mundo. O LPI certificou profissionais de mais de 180 países, oferece exames em diversos idiomas e tem centenas de parcerias de formação em todo o globo.

Nossa missão é proporcionar oportunidades econômicas e criativas para todos, tornando universalmente acessível a certificação de conhecimentos e competências em matéria de Open Source.

  • LinkedIn
  • flogo-RGB-HEX-Blk-58 Facebook
  • Twitter
  • Entre em Contato
  • Política de Privacidade e Cookies

Encontrou um erro ou quer ajudar a aprimorar esta página? Escreva pra nós.

© 1999–2023 The Linux Professional Institute Inc. Todos os direitos reservados.