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

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

Escreva o comando que lista todos os aliases do sistema:
Escreva um alias chamado logg para listar todos os arquivos ogg em ~/Music — um por linha:
Invoque o alias para provar que funciona:
Agora, modifique o alias para que ele exiba o nome do usuário da sessão e dois pontos antes da listagem:

Invoque-o novamente para provar que esta nova versão também funciona:
Liste novamente todos os aliases e confira se o alias logg aparece na listagem:
Remova o alias:

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

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:
Faça login como user2 para verificar se funciona:
Escreva a mesma função em apenas uma linha:
Invoque a função:
Remova a função:
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 $?
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

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
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

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

Variáveis de ambiente podem ser usadas

Sim

Podem ser escapadas com \

Sim

Não

Podem ser recursivas

Sim

Muito produtivas quando usadas com parâmetros posicionais

Não

Sim

Escreva o comando que lista todos os aliases do sistema:
```
alias
```
Escreva um alias chamado logg para listar todos os arquivos ogg em ~/Music — um por linha:
```
alias logg='ls -1 ~/Music/*ogg'
```
Invoque o alias para provar que funciona:
```
logg
```
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'
```
Invoque-o novamente para provar que esta nova versão também funciona:
```
logg
```
Liste novamente todos os aliases e confira se o alias logg aparece na listagem:
```
alias
```
Remova o alias:
```
unalias logg
```

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.

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
```
Faça login como user2 para verificar se funciona:
```
su - user2
```

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"; }

Invoque a função:
```
my_fun
```
Remova a função:
```
unset -f my_fun
```
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
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

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
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