Capitulo4 - Command Line Skills

A maior parte das pessoas está mais familiarizada
como o Graphical User Interface (GUI) para

controlar o computador.
Introduzido para as massas pela Apple no

computador Macintosh e popularizado pela
Microsoft, o GUI proporciona uma forma fácil e
intuitiva de gerir o sistema.
Sem a GUI, algumas ferramentas para gráfica e

video não seriam utilizáveis.
Antes da popularidade da GUI, a Command Line
Interface (CLI) era a forma preferencial de controlar
o computador.
A CLI reporta-se apenas a entradas via teclado.
Qualquer ação que queiramos que o computador

faça, tem que ser introduzindo comandos, em vez
de se “pressionar íconos”.
Se nunca usou a CLI, os primeiros tempos serão
um desafio porque tem que memorizar comandos
e as respetivas opções.
Contudo, a CLI proporciona maior precisão e

velocidade e a capacidade de fácil automatização
de tarefas através de scripting.
Embora o Linux tenha muitos ambientes de GUI,

você será capaz de controlar o Linux muito mais
eficazmente com recurso á Command Line
Interface.
A Command Line Interface (CLI), é uma interface
com o computador ,text-based , em que o
utilizador introduz um comando e o computador o
executa.
O ambiente CLI é providenciado por uma

aplicação, no computador, conhecida como
terminal.
O terminal aceita o que o utilizador escreve, e
passa isso para a shell.
A shell interpreta o que o utilizador escreveu em

instruções que podem ser executadas pelo sistema
operativo.
Se o comando produzir uma saída, então esse

texto será visualizado no terminal.
Se forem detatados problemas com o comando,

então será visualizada uma mensagem de erro.
Há muitas maneiras de se aceder á janela do terminal .
Alguns sistemas arrancam diretamente para o terminal.
É o caso dos servers, em que a Graphical User Interface

(GUI) pode gastar muitos recursos, e poderá não ser
necessária para as operações baseadas no servidor.
Um bom exemplo de server que não requer
necessáriamente de GUI é o web server.
Os Web servers têm que funcionar o mais rápidamente

possível e o GUI tornam o sistema mais lento.
Nos sistemas que a seguir ao boot vão para a GUI,
há habitualmente 2 maneiras de aceder ao
terminal: o “GUI-based terminal “ e o “virtual
terminal”:
O “GUI terminal” é um programa com ambiente

gráfico que emula a janela terminal .
Os terminais gráficos podem ser acedidos através

do sistema de menus.
Por examplo, no CentOS pode clicar-se

em Applications no menu , depois System Tools
> e finalmente, Terminal:
Terminal
O terminal virtual pode correr ao mesmo tempo
que o GUI, mas requer que o utilizador faça log in
via terminal virtual antes que ele possa executar
comandos.
Muitos sistemas têm multiplos terminais virtuais

que podem ser acedidos através de combinações
de teclas como, por exemplo: Ctrl-
Ctrl-Alt-
Alt-F1
Nota:
Nota Em máquinas virtuais os terminais virtuais
podem não estar disponíveis.
A janela terminal exibe a prompt;
A prompt aparece quando nenhum comando está a

correr ou quando todas as saídas de comando
foram visualizadas na tela.
A prompt é desenhada para indicar ao utilizador

para inserir um comando.
A estrutura da prompt pode variar conforme as
distribuições, mas incluirá tipicamente informação
sobre o utilizador e o sistema.
Vejamos uma típica estrutura de prompt:
sysadmin@localhost:~$
sysadmin@localhost ~$
A prompt anterior dá o nome do utilizador que fez
login (sysadmin), e o nome do sistema (localhost) e
a diretoria atual (~).
O símbolo ~ é usado como taquigrafia para a

diretoria “home” do utilizador (tipicamente a
“home directory” para o utilizador está sob a
diretoria /home e nomeada após a conta do
utilizador, por exemplo: /home/sysadmin .
A shell é o interpretador que traduz os comandos
inseridos pelo utilizador em ações para serem
executadas pelo sistema operativo.
O ambiente Linux providencia muitos diferentes

tipos de shells, algumas das quais já são usadas
há muitos anos.
A mais comum das shells usadas nas distribuições
Linux é a BASH shell.
É uma shell que proporciona muitas

funcionalidades avançadas, tal como o histórico de
comandos, que nos prossibilita re-executar
comandos anteriormente executados.
A BASH shell tem outras populares funcionalidades,
como:
Scripting:
Scripting Habilidade de colocar comandos num ficheiro
e executá-lo, resultando na execução de todos os
comandos. Também possibilita a inclusão de
funcionalidades de programação.
Aliases:
Aliases Possibilidade de criação de pequenos
"nicknames" para longos comandos.
Variáveis:
Variáveis Usadas para armazenar informação para a
BASH shell. Estas variáveis podem ser usadas para
modificar como os comandos e funções trabalham, bem
como proporcionar informação vital para o sistema de
informação.
Muitos comandos podem ser usados por si só sem
quaisquer argumentos adicionais.
Outros comandos requerem entradas adicionais

para funcionarem corretamente.
O tipico formato de comando é:
comando [opções] [argumentos]

As opções são usadas para modificar o
comportamento nuclear do comando, enquanto
que os argumentos são usadaos para facultar
informação adicional (tal como filename ou
username).
As opções e argumentos são normalmente

separadas por um espaço.
Não esquecer: O Linux é “case sensitive”.

O comando ls dá uma listagem de ficheiros e
diretórios, contidos na nossa diretoria de trabalho:
sysadmin@localhost:~$ ls
Desktop Documents Downloads Music Pictures Pu
blic
Templates Videos
Um argumento também pode ser passado para o
comando ls , para especificar por exemplo
ficheiros de uma certa diretoria.
Por exemplo, o comando ls /etc/ppp mostrará os

conteúdos da diretoria /etc/ppp em vez de listar
conteúdo da diretoria atual:
sysadmin@localhost:~$ ls /etc/ppp
ip-down.d ip-up.d
Dado que o comando ls aceita múltiplos argumentos,
poderemos listar o conteúdo de multiplas diretorias de
uma só vez, digitando o comando: ls /etc/ppp /etc/ssh
sysadmin@localhost:~$ ls /etc/ppp /etc/ssh
/etc/ppp:
ip-down.d ip-up.d
/etc/ssh:
moduli ssh_host_dsa_key.pub ssh_host_rsa_k
ey sshd_configssh_config
ssh_host_ecdsa_key ssh_host_rsa_key.pub
ssh_host_dsa_key ssh_host_ecdsa_key.pub ssh_impor
t_id
As opções podem ser usadas com os comandos
para expandir ou modificar a forma como o
comando se comporta.
As Opções são geralmente letras simples;
Contudo por vezes também podem ser “palavras”.

Tipicamente os comandos antigos usam letras
simples enquanto os comandos mais recentes
usam palavras completas como opções.
As opções de letra simples são precedidas por um
traço -.
Opções de palavra são precedidas por 2 traços --.
--.
Por exemplo, podemos usar a opção -l com o
comando ls para exibir mais informação sobre os ficheiros
listados.
O comando ls –l listará os ficheiros contidos na diretoria atual

e dará informação adicional, tal como permissões e tamanho
dos ficheiros:
sysadmin@localhost:~$ ls -l
total 0
drwxr-xr-x 1 sysadmin sysadmin 0 Jan 29 2015 Desktop
drwxr-xr-x 1 sysadmin sysadmin 0 Jan 29 2015 Documents
drwxr-xr-x 1 sysadmin sysadmin 0 Jan 29 2015 Downloads
drwxr-xr-x 1 sysadmin sysadmin 0 Jan 29 2015 Music
drwxr-xr-x 1 sysadmin sysadmin 0 Jan 29 2015 Pictures
drwxr-xr-x 1 sysadmin sysadmin 0 Jan 29 2015 Public
drwxr-xr-x 1 sysadmin sysadmin 0 Jan 29 2015 Templates
drwxr-xr-x 1 sysadmin sysadmin 0 Jan 29 2015 Videos
Em muitos casos as opções podem ser usadas
conjuntamente com outra opções.
Por exemplo, o comando ls -l -h ou ls -lh listará

ficheiros com detalhes, mas exibirá o tamanho dos
ficheiros num formato “ human-readable” em vez
do valor por defeito (bytes):
sysadmin@localhost:~$ ls -l /usr/bin/perl
-rwxr-xr-x 2 root root 10376 Feb 4 2014 /usr/bi
usr/bi
n/perl
n/perl
sysadmin@localhost:~$ ls -lh /usr/bin/perl
-rwxr-xr-x 2 root root 11K Feb 4 2014 /usr/bin/
usr/bin/
perl
As Opções podem ser usadas com um argumento.
De facto, algumas opções requerem os seus
próprios argumentos.
Podemos usar opções e argumentos com o

comando ls para listar o conteúdo de outro
diretório atravésw da execução do comando ls -l
/etc/ppp:
sysadmin@localhost:~$ ls -l /etc/ppp
total 0
drwxr-xr-x 1 root root 10 Jan 29 2015 ip
ip--down.d
drwxr-xr-x 1 root root 10 Jan 29 2015 ip-
ip-up.d
Quando damos um comando no terminal, o
comando é armazenado no "history list".
Isto serve para podermos usar “antigas ordens”
com menos trabalho – sem termos que repetir tudo
de novo.
Para vermos o histórico do terminal usamos o

comando history :
sysadmin@localhost:~$ date
Sun Nov 1 00:40:28 UTC 2015
sysadmin@localhost:~$ ls
Desktop Documents Downloads Music Pictures
Public Templates Videos
sysadmin@localhost:~$ cal 5 2015
May 2015
Su Mo Tu We Th Fr Sa
1 2
3 4 5 6 7 8 9
10 11 12 13 14 15 16
17 18 19 20 21 22 23
24 25 26 27 28 29 30
31
sysadmin@localhost:~$ history
1 date
2 ls
3 cal 5 2015
4 history
Pressionando a tecla ↑ mostrará o comando
anterior na prompt line.
(Podemos repetir para navegar)
Quando encontramos o comando pretendido,

podemos usar as teclas ← e → para
posicionarmos o cursor para editarmos.
Outras teclas úteis para a edição são

: Home,
Home End,
End Backspace e Delete .
Se vermos o comando que queremos usar na lista gerada pelo comando
history, podemos executar esse comando escrevendo um ponto de
exclamação seguido do número junto ao comando, por exemplo:
!3
sysadmin@localhost:~$ history
1 date
2 ls
3 cal 5 2015
4 history
sysadmin@localhost:~$ !3
cal 5 2015
May 2015
1 2
3 4 5 6 7 8 9
10 11 12 13 14 15 16
17 18 19 20 21 22 23
24 25 26 27 28 29 30
31
Alguns exemplos adicionais do comando history :
Exemplo Significado
history 5 Mostra os últimos 5 comandos do histórico
!! Executa de novo o último comando
!-5 Executa o 5º comando
!ls Executa o comando ls mais recente
A “BASH shell variable” é uma funcionalidade que
nos permite (a nós ou á shell), armazenar dados.
Estes dados podem ser usados para fornecer

informação de sistema crítica, ou para alterar o
comportamento funcional da BASH shell (ou de
outros comandos).
São dados nomes ás variáveis, as quais são
temporáriamente armazenadas na memória.
Quando encerramos o terminal ou a janela da

shell,todas as variáveis são perdidas.
Contudo, o sistema recria automáticamente muitas

destas variáveis quando uma nova shell é aberta.
Para exibir o valor da variável, podemos usar o
comando echo .
O comando echo é utilizado para mostrar o output

no terminal;
No exemplo seguinte, o comando exibirá o valor da

variável HISTSIZE:
sysadmin@localhost:~$ echo $HISTSIZE
1000
A variável HISTSIZE define quantos comandos
foram armazenados na history list.
Para exibir o valor da variável, utilizamos o

símbolo dólar $ antes do nome da variável.
Para modificar o valor da variável não usamos o

caractere $ :
sysadmin@localhost:~$ HISTSIZE=500
sysadmin@localhost:~$ echo $HISTSIZE
500
Uma das mais importantes variáveis da BASH shell
é a variável PATH.
O termo path refere-se á lista que define que

directorias a shell olhará para os comandos.
Se introduzirmos um comando e recebermos a

mensagem de erro "command not found" , é
porque a BASH shell não foi capaz de localizar o
comando com esse nome em nenhuma das
directorias incluidas na path.
O seguinte comando mostra a path da atual shell:
sysadmin@localhost:~$ echo $PATH
/home/sysadmin/bin:/usr/local/sbin:/usr/local/bi
n:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games
Baseado no no seguinte output, quando tentamos
executar o comando, a shell olhará primeiro para o
comando na diretoria /usr/lib/qt-3.3/bin .
Se o comando for encontrado no diretório, então

será executado.
Se não for encontrado então a shell irá procurar

na diretoria /usr/local/bin .
Se o comando não for encontrado em nenhuma
diretoria listada na variável PATH , então
receberemos uma mensagem - command not
found error:
sysadmin@localhost:~$ zed
-bash: zed: command not found
Se houver software aplicacional instalado no nosso
sistema, poderemos necessitar de modificar a
PATH por forma a tornar mais fácil a execução
desses comandos.
Por exemplo, o seguinte vai adicionar a

diretoria /usr/bin/custom á variável PATH:
PATH=/usr/bin/custom:$PATH
sysadmin@localhost:~$ echo $PATH
/usr/bin/custom:/home/sysadmin/bin:/usr/local/s
bin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/u
sr/games
Há 2 tipos de variáveis usadas na BASH shell,
“locais e ambientais”.
As “Variáveis ambientais”, tais

como PATH e HOME, são usadas pela BASH
quando iterpreta comandos e quando executa
tarefas.
As “As variáveis Locais” estão associadas a tarefas

baseadas nos utilizadores, e convencionou-se
serem escritas em letra minúscula.
Para criar uma variável local, podemos
simplesmente escrever:
sysadmin@localhost:~$ variable1='Something'
Para vermos o conteúdo da variável , colocamos o
caractere $ antes da mesma:
sysadmin@localhost:~$ echo $variable1
Something
Para se ver as variáveis ambientais, usamos o
comando env (procurando através do output
usando o grep.
Neste caso a busca para a variável 1 , nas variáveis

ambientais resulta na ausência de output:
sysadmin@localhost:~$ env | grep variable1
Após a exportação da variable1, esta é agora uma
“environment variable”.
Observemos que desta vez, há correspondência na

pesquisa através das variáveis ambientais:
sysadmin@localhost:~$ export variable1
variable1=Something
variable1
O comando export também pode ser usado na
criação de variáveis ambientais:
sysadmin@localhost:~$ export variable2='Else'
variable2=Else
variable2
Para alterar o valor de uma variável ambiental basta
simplesmente omitir o $ quando nos referimos a
ela:
sysadmin@localhost:~$ variable1=$variable1' '$va
riable2
sysadmin@localhost:~$ echo $variable1
Something Else
As variáveis exportadas podem ser removidas
usando o comando unset :
sysadmin@localhost:~$ unset $variable2
Podem haver situações em que existem várias
versões do mesmo comando instalados no sistema
ou em que os comandos são acessíveis a alguns
utilizadores e não a outros.
Se um comando não apresenta o comportamento

expectável, ou se não está a cessível como deveria,
é aconselhável verificar como é que a Shell
encontra o comando, ou qual a versão usada.
Seria fastidioso termos que analisar manualmente
cada diretório listado na varpável PATH .
Em vez disso, podemos usar o comando
which para mostrar rodo o caminho do comando
em questão:
sysadmin@localhost:~$ which date
/bin/date
sysadmin@localhost:~$ which cal
/usr/bin/cal
O comando which procura a localização do

comando pesquisando na variável PATH .
O comando type pode ser usado para determinar
informação sobre vários comandos.
Alguns comandos são oridinados a partir de um

ficheiro específico:
sysadmin@localhost:~$ type which
O which é indexado (/usr/bin/which)
Este output deverá ser similar ao output do
comando which , visto anteriormante:
sysadmin@localhost:~$ which which
/usr/bin/which
O comando type também pode identificar
comandos embutidos na bash (ou outra)
shell:
sysadmin@localhost:~$ type echo
echo is a shell builtin
Neste caso, o output é significafivamente
diferente do output do comando which:
sysadmin@localhost:~$ which echo

/bin/echo
Usando a opção -a , o comando type pode
também revelar o caminho de outro
comando:
sysadmin@localhost:~$ type -a echo
echo is a shell builtin
echo is /bin/echo
O comando type também pode identificar
“aliases” para outros comandos:
sysadmin@localhost:~$ type ll
ll is aliased to `ls -alF'
sysadmin@localhost:~$ type ls
ls is aliased to `ls --color=auto'
O output daqueles comandos indica que ll é
um alias para ls -alF, e o ls é um alias para ls
--color=auto.
Mais uma vez:o output é significativamente

diferente daquele do comando which:
sysadmin@localhost:~$ which ll
sysadmin@localhost:~$ which ls
/bin/ls
O comando type suporta outras opções, e
pode pesquisar múltiplos comandos
simultâneamente.
Para exibir apenas uma simples palavra

descrevendo os comandos echo, ll, e which,
usa-se a opção -t :
sysadmin@localhost:~$ type -t echo ll which
builtin
alias
file
Um alias pode ser usado para mapear longos
comandos em sequências mais pequenas.
Quando a shell vê um alias para ser executado,

substitui-o pela sequência longa, antes de
proceder á interpretação dos comandos.
Por exemplo, o comando ls –l é habitualmente

transformado em l ou ll.
Dado que estes comandos mais pequenos são mais

fáceis de digitar, isto torna o processo mais rápido.
Podemos determinar que aliases estão
parameterizados na nossa shell utilizando o
comando alias :
sysadmin@localhost:~$ alias
alias egrep='egrep --color=auto'
alias fgrep='fgrep --color=auto'
alias grep='grep --color=auto'
alias l='ls -CF'
alias la='ls -A'
alias ll='ls -alF'
alias ls='ls --color=auto'
Por exemplo, podemos criar um alias em
que lh mostre uma longa lista de ficheiros,
ordenados pelo tamanho com um aspecto
“humano e amigável” lh='ls -Shl'.
Escrever lh resultará no mesmo que escrever o

comando ls -Shl :
sysadmin@localhost:~$ alias lh='ls -Shl'
sysadmin@localhost:~$ lh /etc/ppp
total 0
drwxr-xr-x 1 root root 10 Jan 29 2015 ip-ip-down.d
drwxr-xr-x 1 root root 10 Jan 29 2015 ip-ip-up.d
As "wild cards“são simbolos com significado
especial para a shell.
Estes caracteres são interpretados pela shell

antes de ser corrido por qualquer comando , e
podem ser usados com qualquer comando.
O asterisco é usado para representar zero ou mais
de qualquer caractere num nome de ficheiro.
Por exemplo, se quisermos mostrar todos os

ficheiros na diretoria /etc cpmeçados pela letra t:
sysadmin@localhost:~$ echo /etc/t*
/etc/terminfo /etc/timezone
O padrão t* significa “correspondência com
qualquer ficheiro começado pelo caractere t com
zero ou mais de qualquer caractere após o t".
Podemos usar o asterisco em qualquer sítio do
nome de ficheiro.
Por exemplo, o seguinte mostrará correspondência
com qualquer filename na diretoria /etc que
termine com .d:
sysadmin@localhost:~$ echo /etc/*.d
/etc/apparmor.d /etc/bash_completion.d
/etc/cron.d /etc/depmod.d /etc/fstab.d
/etc/init.d /etc/insserv.conf.d /etc/ld.so.conf.d
/etc/logrotate.d /etc/modprobe.d /etc/pam.d
/etc/profile.d /etc/rc0.d /etc/rc1.d /etc/rc2.d
/etc/rc3.d /etc/rc4.d /etc/rc5.d /etc/rc6.d
/etc/rcS.d /etc/rsyslog.d /etc/sudoers.d
/etc/sysctl.d /etc/update-motd.d
No próximo exemplo, todos os ficheiros no
diretório /etc que comecem com a letra r e
que terminem com .conf serão visualisados:
sysadmin@localhost:~$ echo /etc/r*.conf
/etc/resolv.conf /etc/rsyslog.conf
O caractere ? representa qualquer caractere unitário.
Cada símbolo ? Faz a correspondência exacta com 1

caractere: nem mais, nem menos.
Suponhamos que se pretende mostrar todos os

ficheiros na diretoria /etc que comecem pela tetra t e
que tenham exatamente 7 caracteres após o
caractere t :
sysadmin@localhost:~$ echo /etc/t???????
/etc/terminfo /etc/timezone
Os caracteres especiais podem ser usados em
conjunto para encontrar padrões mais
complexos.
O comando /etc/*???????????????????? Mostrará
apenas ficheiros da diretoria /etc com 20 ou
mais caracteres no filename:
sysadmin@localhost:~$ echo /etc/*??????????????
??????
/etc/bindresvport.blacklist /etc/ca-certificates.
conf
O * e o ? Também podem ser usados
conjuntamente para analisar ficheiros com
extensão de 3 letras usando o comando echo
/etc/*.??? :
sysadmin@localhost:~$ echo /etc/*.???
/etc/blkid.tab /etc/issue.net
Os [] são usados para a correspondência de um
carcter unitário representando uma gama de
caracteres para possível correspondência.
Por exemplo, echo /etc/[gu]* mostrará qualquer
ficheiro que comece pelo caractere g ou u e
contenha zero ou mais caracteres adicionais :
sysadmin@localhost:~$ echo /etc/[gu]*
/etc/gai.conf /etc/groff /etc/group /etc/group- /e
tc/gshadow /etc/gshadow- /etc/ucf.conf /etc/ude
v /etc/ufw /etc/update-motd.d /etc/updatedb.con
f
Os [] também podem ser usados para representar uma
gama de caracteres.
Por exemplo, o comando echo /etc/[a-d]* mostrará
todos os ficheiros que comecem por qualquer letra
entre a e d (inclusive):
sysadmin@localhost:~$ echo /etc/[a-d]*
/etc/adduser.conf /etc/adjtime /etc/alternatives /etc/a
pparmor.d
/etc/apt /etc/bash.bashrc /etc/bash_completion.d /etc
/bind /etc/bindresvport.blacklist /etc/blkid.conf /etc/bl
kid.tab /etc/ca-certificates /etc/ca-certificates.conf /et
c/calendar /etc/cron.d /etc/cron.daily /etc/cron.hourly
/etc/cron.monthly /etc/cron.weekly /etc/crontab /etc/d
bus-1 /etc/debconf.conf /etc/debian_version /etc/defa
ult
/etc/deluser.conf /etc/depmod.d /etc/dpkg
O comando echo /etc/*[0-9]* mostrará qualquer
ficheiro que contenha pelo menos um número:
sysadmin@localhost:~$ echo /etc/*[0-9]*
/etc/dbus-1 /etc/iproute2 /etc/mke2fs.conf /etc/
python2.7 /etc/rc0.d
/etc/rc1.d /etc/rc2.d /etc/rc3.d /etc/rc4.d /etc/rc
5.d /etc/rc6.d
A gama (range) é baseada na tabela de texto ASCII .
Esta tabela define a lista de caracteres,

organizando-os numa ordem específica
standartizada.
Se referenciarmos uma ordem inválida, não

haverão correspondências:
sysadmin@localhost:~$ echo /etc/*[9-0]*
/etc/*[9-0]*
O ponto de exclamação é usado
conjuntamente com os [] para negar a gama
(range).
Por exemplo, o comando echo
[!DP]* mostrará qualquer ficheiro que não
comece por D ou P.
Há 3 tipos de cotas com especial significado
para a Bash shell: ", ', e `.
Cada conjunto de cotas indica á shell que tem

que tratar o texto dentro das cotas de forma
diferente.
As “ “ fazem a shell parar de interpretar os mesmos
metacaracteres, incluindo caracteres especiais.
Entre as duplas aspas um * é apenas um * , um ? é
apenas um ?, etc.
Isto significa que quando usamos o 2º
comando echo abaixo, a BASH shell não converte o
padrão em nomes de ficheiro correspondentes a esse
padrão:
sysadmin@localhost:~$ echo /etc/[DP]*
/etc/DIR_COLORS /etc/DIR_COLORS.256color
/etc/DIR_COLORS.lightbgcolor /etc/PackageKit
sysadmin@localhost:~$ echo "/etc/[DP]*"
/etc/[DP]*
Isto é útil qundo pretendemos visualizar algo na
tela que seja normalmente um catactere especial
para a shell:
sysadmin@localhost:~$ echo "The glob characters
are *, ? and [ ]"
The glob characters are *, ? and [ ]
As duplas aspas ainda permitem a substituição do
comando (discutido mais á frente), substituição da
variável e permite mais alguns metacaracteres.
For exemplo, na demonstração seguinte, podemos

observar que o valor da variável PATH é mostrado:
sysadmin@localhost:~$ echo "The path is $PATH"
The path is
/usr/bin/custom:/home/sysadmin/bin:/usr/local/s
bin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/u
sr/games sysadmin@localhost
sysadmin@localhost:~$:~$
As aspas simples previnem a shell de fazer
qualquer interpretação de caracteres
especiais.
Isto inclui caracteres especiais, variáveis,
substituiçaõ de comandos e de ouros
metacaracteres.
Por exemplo, se quisermos que o
caractere $ signifique simplesmente $, em vez de
indicar á shell para olhar para o valor da variável,
poderemos executar o 2º comando abaixo:
sysadmin@localhost:~$ echo The car costs $100
The car costs 00
sysadmin@localhost:~$ echo 'The car costs $100'
The car costs $100
Podemos usar uma técnica alternativa para atribuir
cotas unitárias a carcteres unitários.
Por exemplo, suponhamos que se pretende exibir o

seguinte: “The services costs $100 and the path is
$PATH".
Se colocarmos tudo entre duplas

aspas, $1 e $PATH são considerados variáveis.
Se colocarmos tudo entre aspas simples,$1

e $PATH não serão variáveis.
Mas e se quisermos $PATH tratato como variável e
$1 não?
Se colocarmos o caractere \ antes de outro
caractere, ele trata o outro caractere como se
estivesse submetido a aspas simples.
O 3º comando abaixo demonstra o uso do

caractere \ enquanto os outros 2
demonstram como as variáveis serão tratadas
entre duplas aspas e aspas simples:
sysadmin@localhost:~$ echo "The service costs
$100 and the path is $PATH“
The service costs 00 and the path is
/usr/bin/custom:/home/sysadmin/bin:/usr/local
/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bi
n:/usr/games
sysadmin@localhost:~$ echo 'The service costs
$100 and the path is $PATH'
The service costs $100 and the path is $PATH
sysadmin@localhost:~$ echo The service costs
\$100 and the path is $PATH
The service costs $100 and the path is
/usr/bin/custom:/home/sysadmin/bin:/usr/local
/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bi
n:/usr/games sysadmin@localhost:~$
As Back quotes são usadas para especificar um
comando dentro de outro comando, processo
conhecido como substituição de comando.
Isto permite o uso muito sofisticado e poderoso

dos comandos.
Como isto pode parecer confuso, um exemplo

tornará as coisas mais claras. Para começar
observemos o output do comado date:
sysadmin@localhost:~$ date
Mon Nov 2 03:35:50 UTC 2015
Agora observemos o output do comando echo
Today is date :
sysadmin@localhost:~$ echo Today is date
Today is date
No comanso anterior a palavra date é tratada como

texto normal e a shell passa simplesmente os
dados para o comando echo .
Mas nós provávelmente queremos executar o
comando date e enviar o output deste comando
para o comando echo.
Para isto acontecer deveremos escrever a linha de

comando: echo Today is `date`command line:
sysadmin@localhost:~$ echo Today is `date`
Today is Mon Nov 2 03:40:04 UTC 2015
Permite usar múltiplos comandos de uma sá
vez, ou correr comandos adicionais,
dependendo do sucesso do comando.
Tipicamente isto é usado dentro dos scripts,

mas também pode ser usado na linha de
comandos.
O ponto e vírgula pode ser uusado para
correr múltiplos comandos, um após o outro.
Cada comando corre independente e

consecutivamente;
Não importa o resultado do 1ª comando: o 2º

correrá após o 1º ter sido completado, a
seguir o 3º e assim sucessivamente…
Por examplo, se quisermos ver os meses de Janeiro, Fevereiro e Março
de 2015, podemos executar cal 1 2015; cal 2 2015; cal 3 2015 na linha
de comandos:
sysadmin@localhost:~$ cal 1 2015; cal 2 2015; cal 3 2015
January 2015
1 2 3
4 5 6 7 8 9 10
11 12 13 14 15 16 17
18 19 20 21 22 23 24
25 26 27 28 29 30 31
February 2015
1 2 3 4 5 6 7
8 9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
March 2015
1 2 3 4 5 6 7
8 9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29 30 31
O duplo && atua como um "and" lógico - if 1º
comando teve sucesso , then o 2º comando (á
direita do &&) também irá correr.
If o 1º comando falha, then o 2º comando não
correrá.
Para melhor compreensão de como isto funciona,

consideremos primeiro o conceito de falha e de
sucesso dos comandos.
Os Comandos têm sucesso quando trabalham

apropriadamente e falham quando qualquer coisa
corre mal.
Por exemplo, consideremos a linha de comandos ls
/etc/xml.
O comando será bem sucedido se a diretoria
etc/xml estiver acessível e falhará se não estiver.
Por exemplo, o 1º comando terá sucesso porque a

diretoria /etc/xml existe e está accessivel ao passo que
o 2º comando falhará porque não existe a
diretoria /junk :
sysadmin@localhost:~$ ls /etc/xml
catalog catalog.old xml-core.xml xml-core.xml.old
sysadmin@localhost:~$ ls /etc/junk
ls: cannot access /etc/junk: No such file or directory
O modo em que podemos usar o sucesso ou a falha do
comando ls conjuntamente com o && consisterá na
execução de uma linha de comando como a seguinte:
sysadmin@localhost:~$ ls /etc/xml && echo success
catalog catalog.old xml-core.xml xml-core.xml.old
success
sysadmin@localhost:~$ ls /etc/junk && echo success
ls: cannot access /etc/junk: No such file or directory
No 1º exemplo, o comando echo é executado porque o
comando ls foi bem suceedido.
No 2º exemplo, o comando echo naão foi executado
porque o comando ls falhou.
O duplo || é um "or“ lógico. Funciona de forma similar
ao &&;
Dependendo do resultado do 1º comando, o 2º

comando será executado ou ignorado.
Com o duplo ||, se o 1º comando correr com sucesso, o

2º comando será ignorado; se o 1º comando falhar,
então o 2º comando será executado.
Por outras palavras, estamos essencialmente a dizer á

shell, “Executa o 1º comando ou então o 2º”.
No exemplo seguinte, o comando echo sá será
executado se o comando ls falhar:
sysadmin@localhost:~$ ls /etc/xml || echo failed
catalog catalog.old xml-core.xml xml-
core.xml.old
sysadmin@localhost:~$ ls /etc/junk || echo failed
ls: cannot access /etc/junk: No such file or
directory failed

Capitulo4 - Command Line Skills

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Capitulo4 - Command Line Skills

Caricato da

Copyright:

Formati disponibili

A maior parte das pessoas está mais familiarizada

como o Graphical User Interface (GUI) para

Introduzido para as massas pela Apple no

Sem a GUI, algumas ferramentas para gráfica e

A CLI reporta-se apenas a entradas via teclado.

Qualquer ação que queiramos que o computador

Contudo, a CLI proporciona maior precisão e

Embora o Linux tenha muitos ambientes de GUI,

O ambiente CLI é providenciado por uma

A shell interpreta o que o utilizador escreveu em

Se o comando produzir uma saída, então esse

Se forem detatados problemas com o comando,

Alguns sistemas arrancam diretamente para o terminal.

É o caso dos servers, em que a Graphical User Interface

Os Web servers têm que funcionar o mais rápidamente

O “GUI terminal” é um programa com ambiente

Os terminais gráficos podem ser acedidos através

Por examplo, no CentOS pode clicar-se

Muitos sistemas têm multiplos terminais virtuais

A prompt aparece quando nenhum comando está a

A prompt é desenhada para indicar ao utilizador

Vejamos uma típica estrutura de prompt:

O símbolo ~ é usado como taquigrafia para a

O ambiente Linux providencia muitos diferentes

É uma shell que proporciona muitas

Outros comandos requerem entradas adicionais

O tipico formato de comando é:

comando [opções] [argumentos]

As opções e argumentos são normalmente

Não esquecer: O Linux é “case sensitive”.

Por exemplo, o comando ls /etc/ppp mostrará os

As Opções são geralmente letras simples;

Contudo por vezes também podem ser “palavras”.

O comando ls –l listará os ficheiros contidos na diretoria atual

Por exemplo, o comando ls -l -h ou ls -lh listará

Podemos usar opções e argumentos com o

Para vermos o histórico do terminal usamos o

Quando encontramos o comando pretendido,

Outras teclas úteis para a edição são

Estes dados podem ser usados para fornecer

Quando encerramos o terminal ou a janela da

Contudo, o sistema recria automáticamente muitas

O comando echo é utilizado para mostrar o output

No exemplo seguinte, o comando exibirá o valor da

Para exibir o valor da variável, utilizamos o

Para modificar o valor da variável não usamos o

O termo path refere-se á lista que define que

Se introduzirmos um comando e recebermos a

Se o comando for encontrado no diretório, então

Se não for encontrado então a shell irá procurar

Por exemplo, o seguinte vai adicionar a

As “Variáveis ambientais”, tais

As “As variáveis Locais” estão associadas a tarefas

Neste caso a busca para a variável 1 , nas variáveis

Observemos que desta vez, há correspondência na

Se um comando não apresenta o comportamento

O comando which procura a localização do

Alguns comandos são oridinados a partir de um

sysadmin@localhost:~$ which echo

Mais uma vez:o output é significativamente

Para exibir apenas uma simples palavra

Quando a shell vê um alias para ser executado,

Por exemplo, o comando ls –l é habitualmente