Unix Embrapa

ISSN 1677-9274
Dezembro, 2009
Empresa Brasileira de Pesquisa Agropecuria
Embrapa Informtica Agropecuria
Ministrio da Agricultura, Pecuria e Abastecimento
Documentos 99
Shells do Unix: Tutorial

Fbio Danilo Vieira

Campinas, SP
2009

Av. Andr Tosello, 209 - Baro Geraldo
Caixa Postal 6041 - 13083-886 - Campinas, SP
Fone: (19) 3211-5700 - Fax: (19) 3211-5754
www.cnptia.embrapa.br
sac@cnptia.embrapa.br
Comit de Publicaes
Presidente: Silvia Maria Fonseca Silveira Massruh
Membros: Poliana Fernanda Giachetto, Roberto Hiroshi Higa, Stanley Robson de
Medeiros Oliveira, Marcia Izabel Fugisawa Souza, Adriana Farah Gonzalez, Neide
Makiko Furukawa, Suzilei Almeida Carneiro
Membros suplentes: Alexandre de Castro, Fernando Attique Mximo, Paula Regina
Kuser Falco, Maria Goretti Gurgel Praxedes
Supervisor editorial: Neide Makiko Furukawa, Suzilei Almeida Carneiro
Revisor de texto: Adriana Farah Gonzalez
Normalizao bibliogrfica: Maria Goretti Gurgel Praxedes
Editorao eletrnica: Neide Makiko Furukawa
Secretria: Suzilei Almeida Carneiro
1a edio on-line 2009
Todos os direitos reservados.
A reproduo no autorizada desta publicao, no todo ou em parte, constitui violao dos
direitos autorais (Lei n 9.610).
Dados Internacionais de Catalogao na Publicao (CIP)
Vieira, Fbio Danilo
Shells do Unix : tutorial / Fbio Danilo Vieira. - Campinas : Embrapa Informtica
Agropecuria, 2009.

69 p. : il. - (Documentos / Embrapa Informtica Agropecuria, ISSN 1677-9274 ; 99).
1. Unix. 2. Sistema operacional. 3. Programao. I. Ttulo. II. Srie.

CDD: 005.432 (21.ed.)
Embrapa 2009
Autor
Fbio Danilo Vieira

Analista da Embrapa Informtica Agropecuria
Caixa Postal 6041, Baro Geraldo
13083-886 - Campinas, SP
Fone: (19) 3211-5798
e-mail: fabiodv@cnptia.embrapa.br
Apresentao
O Unix e suas vertentes (Linux, FreeBSD, OpenBSD, Solaris, etc) sempre
foi considerado pouco acessvel por muitas pessoas, sejam elas profissionais da rea de informtica ou no.
Hoje em dia, com a modernizao de ambientes grficos, como KDE e
GNOME, a utilizao desses diversos sabores de sistemas operacionais
derivados do Unix se tornaram um pouco mais populares, mesmo que
ainda bem abaixo de seu concorrente principal, o MS Windows.
Entretanto, o ponto forte do Unix no est nesses ambientes grficos mais
requintados dos dias de hoje, e sim na sua velha e tradicional linha de
comando e no que possvel se fazer atravs dela. E na interface destas
linhas de comando esto diversos Shells, que so como espcies de tradutores do que o usurio digita, e o kernel do sistema, que o crebro do
sistema operacional Unix e seus derivados.
Este tutorial, portanto, foi escrito com o intuito de desmitificar essa forte
capacidade dos sistemas operacionais baseados em Unix e de auxiliar
usurios que pouco conhecem este sistema a explorar as inmeras funcionalidades que os Shells oferecem.
Kleber Xavier Sampaio de Souza
Chefe-Geral
Sumrio
Captulo 1
Shell: Interpretador de Comandos. .....................................................9
A estrutura do Sistema Unix.......................................................................9
O Kernel................................................................................................ 10
O Shell. ................................................................................................. 10
Utilitrios do Unix.................................................................................... 11
Os Shells disponveis no Unix.................................................................. 11

O Shell Bourne....................................................................................... 12
O Shell C............................................................................................... 12
O Shell Korn........................................................................................... 13
O Shell tcsh (verso modificada do Shell C). ............................................. 14
O Shell Bourne-Again - bash................................................................. 15
Outros Shells do Unix.............................................................................. 15
Identificando o Shell.................................................................................15
Escolhendo um novo Shell.......................................................................17
O ambiente Shell......................................................................................19
Definindo variveis.................................................................................. 20
Variveis ambientais. .............................................................................. 21
Arquivos de inicializao do Shell............................................................25
Captulo 2
Um pouco mais do Shell C e do Shell Korn.................................... 29
Os mecanismos de histrico do Shell C e do Shell Korn......................... 29
Como usar o histrico para economizar digitao................................... 32
Como usar os aliases de comandos........................................................34
Como personalizar prompts.....................................................................37
Captulo 3
Programao de scripts de Shell.......................................................39
Definindo variveis...................................................................................39
Operadores..............................................................................................40
Comandos de controle de fluxo................................................................42
if...fi.......................................................................................................42
case...esac............................................................................................. 44
goto.......................................................................................................44
switch...endsw........................................................................................ 45
Expresses de loop..................................................................................46
for...done. .............................................................................................. 47
while...done............................................................................................ 48
Outros comandos usados nos scripts......................................................49

clear......................................................................................................49
echo......................................................................................................49
exit........................................................................................................50
expr.......................................................................................................50
read.......................................................................................................51
sleep. ....................................................................................................52
Captulo 4
Controle de servio...............................................................................53
Interrompendo servios............................................................................53
Primeiro plano / segundo plano................................................................56
Obtendo informaes sobre as tarefas que esto sendo
executadas...............................................................................................59
Terminando processos.............................................................................63
Concluso................................................................................................67
Referncias..............................................................................................69
Literatura recomendada.......................................................................69
Shells do Unix: Tutorial

Fbio Danilo Vieira
ulo
t
ap
Shell: Interpretador de Comandos
A estrutura do Sistema Unix

Unix um sistema operacional muito abrangente e complexo, que funciona em uma grande variedade de plataformas de hardware, desde PCs a
Mainframes. Ele possui muitos comandos com milhares de opes associadas. Entretanto, por trs de todos esses comandos, est uma estrutura
que d suporte para o funcionamento integral e preciso desses comandos,
sendo que o Shell faz parte dessa estrutura. Consequentemente, para
entender melhor o papel do Shell dentro do Unix, antes necessrio saber
como o sistema operacional Unix est dividido em sua estrutura. Dessa
forma, as partes do Unix podem ser, em relao ao seu funcionamento,
classificadas em 3 nveis: o Kernel, o Shell e os Utilitrios do Unix. Veja
a Figura 1, representativa dessa estrutura:
Teminal
Utilitrios
do Unix
Shell
Kernel
Figura 1. Componentes do sistema Unix.
Hardware
10
Embrapa Informtica Agropecuria. Documentos, 99
Em seguida, sero explicadas todas as partes da estrutura do sistema

operacional Unix.
O Kernel
O Kernel organiza as tarefas do sistema, alm de administrar o armazenamento e transporte de dados. Ele o crebro do sistema Unix, controlando o hardware e dispositivos do computador quando um comando os
solicita. Por exemplo, quando voc digita um comando como cat arq1.txt,
o Kernel ir direcionar o computador para a leitura do arquivo arq1.txt no
disco e, logo em seguida, exibi-lo na tela.
Todos os sistemas operacionais possuem um Kernel, claro que devem ter
outros nomes, mas com funes semelhantes. Em seguida, lista-se um
resumo das funes do Kernel:
Estabelece o sistema de arquivos Unix, organizando e gerenciando o
armazenamento de dados;
Em relao segurana, impede que usurios desautorizados acessem
informaes protegidas;
Executa pedidos de entrada e sada, isto , transfere dados de/para
dispositivos de I/O (Entrada/Sada);
Coordena vrias funes internas do sistema operacional, como a alocao de memria e de outros recursos do sistema, para processos que
esto sendo executados em um determinado momento.
Garante que muitos programas ou aplicaes possam rodar ao mesmo
tempo sem que interfiram uns com os outros, pelo fato de o Unix ser um
sistema multiusurio e multitarefa.
O Shell
J em relao ao Shell, ele o programa que interpreta os comandos digitados por um usurio. uma parte do sistema operacional que funciona
como um agente de ligao entre os comandos que a pessoa digita e as
atividades (funes) que o Kernel deve realizar. No momento em que uma
pessoa digita um comando, o Shell ir traduzir o nome daquele comando
em linguagem de mquina, ou melhor, num conjunto de chamadas em
linguagem de mquina, possibilitando ao Kernel realizar suas tarefas.
Shells do Unix: tutorial
Nota-se, ento, que cada comando no Unix nada mais do que um nome
fcil de se lembrar, sendo que esse nome de comando est ligado a um
conjunto especfico de chamadas do sistema.
O objetivo do Shell deixar o sistema operacional mais amigvel, ou seja,
fazer com que o usurio, ao invs de se lembrar de um conjunto complicado de chamadas de sistema, lembre-se apenas do nome do comando.
bom ressaltar que a grande maioria dos sistemas Unix possuem mais de
um Shell, e esses Shells sero vistos e discutidos mais adiante.
Utilitrios do Unix
Na camada mais externa da estrutura do Unix esto os Utilitrios
(Ferramentas e Aplicativos), que so programas pr-determinados a
realizarem funes (tarefas) especficas. Dentro da variedade de sistemas
operacionais Unix, existem muitos Utilitrios, nem todos esto disponveis
em determinados sistemas.
Um usurio pode realizar muitas tarefas com esses utilitrios, como:
clculos aritmticos, redirecionamento de sada para impressoras, desenvolvimento de programas, edio de um texto, canalizao de comandos,
etc.
O nmero de Utilitrios dentro da famlia de sistemas operacionais Unix
imenso, e, alm dessa grande variedade de aplicativos, h a possibilidade
de combinao de comandos usando os pipelines (cujo smbolo |), permitindo ao usurio obter um resultado de acordo com sua necessidade ou
mais prximo dela e, tambm, de um modo mais rpido.
Os Shells disponveis no Unix

Como j foi dito anteriormente, o Shell estabelece a interface entre o
usurio do sistema e o Kernel. Tambm foi comentado, rapidamente, que
a grande maioria dos sistemas Unix possuem mais de um Shell disponvel
junto a eles, o que permite ao usurio escolher com qual quer trabalhar, fazendo do Unix um sistema multiescolha, alm de multitarefa e multiusurio.
Vale lembrar, s por questo de curiosidade, que o Macintosh tambm
possui vrios interpretadores de comandos. Caso a pessoa que o estiver
11
12
usando no quiser trabalhar com a interface padro, poder optar pelo

DiskTop, AtErase ou Square-One.
J em relao ao Unix, (quando inventado) foi projetado como um sistema operacional voltado para o programador, permitindo que este pudesse
adequar o sistema de acordo com sua vontade. Consequentemente, no
surpresa alguma que vrios shells tenham surgido no mercado, frutos da
mente de alguns programadores fanticos por Unix (e Linguagem C, usada
na construo do Unix). importante ressaltar que o cdigo-fonte de algumas verses do Unix pode ser obtido facilmente atravs da internet, assim
como o prprio sistema operacional.
O Shell Bourne
O precursor de todos esses shells existentes no mercado foi escrito por
Ken Thompson, dos Laboratrios Bell da AT&T, por volta de 1979, como
parte do projeto que envolvia o sistema de arquivos do Unix. Este ainda
era complicado de se trabalhar. No entanto, depois de algum tempo,
um outro componente da AT&T, Steven Bourne, se voltou para o shell
escrito por Thompson e comeou a modific-lo e expandi-lo. A partir da,
o Unix teve um rpido crescimento e foi largamente distribudo entre
instituies comerciais e universidades, e o sh ficou conhecido como o
Shell Bourne. Este shell possui algumas caractersticas peculiares, pois
mais usado, principalmente hoje, para escrever scripts do que como
um shell de comando e, est presente em praticamente todos os sistemas Unix existentes atualmente, alm de possuir muitas variantes de
shell baseadas nele.
O Shell C
Um dos mais importantes (se no o mais) shell do Unix, o Shell C. Ele foi
projetado por Bill Joy, da Universidade da Califrnia, em Berkeley. Quando
estava desenvolvendo o editor de texto vi em linguagem C, Joy, admirador
dessa linguagem, decidiu tambm criar um shell de comando que tivesse
e compartilhasse muitas das estruturas da linguagem C, e que permitisse
escrever scripts de shell mais poderosos e requintados, cujo nome ficou
conhecido como Shell C ou csh. Neste shell, ele implementou algumas
novidades em relao ao Shell Bourne, como:
Aliases de comando: possibilitam aos usurios renomear e reconfigurar

comandos facilmente, permitindo, assim, inserir uma string menor para
um comando extenso.
Histrico de comando: esse mecanismo faz com que o shell grave os
comandos que um usurio utilizou, permitindo repeti-los sem precisar
digit-los inteiros novamente.
Controles de Servio: esses controles permitem aos usurios utilizar
vrios programas de uma s vez. Desse modo, pode-se usar um programa aplicativo num mesmo momento em que outro est sendo executado
em segundo plano.
Pode-se notar, atravs desses aspectos, que o Shell C bem interativo e
flexvel de se trabalhar, proporcionando mais facilidades e recursos para
seus usurios.
O Shell Korn
O Shell Korn, ksh, foi desenhado como sendo uma extenso do Shell
Bourne, com alguns recursos do Shell C, como aliases de comando
(entretanto, num formato ligeiramente diferente), histricos de comando e
controles de servio. Ele foi desenvolvido por David Korn dos Laboratrios
Bell da AT&T, no ano de 1982, com maiores aperfeioamentos realizados
em 1986, 1988 e 1993. O Shell Korn est incluso de forma padro, no
Unix System V Release 4 e alguns outros sistemas, alm de poder ser
adquirido separadamente. Algumas propriedades desse shell so descritas abaixo:
Edio interativa de linha de comando, inclusive com histrico de comando.
Habilidade para extrair a parte de uma string especificada por um padro, ou seja, pode-se procurar uma (ou algumas) determinada (s) palavra (s) dentro de um arquivo fornecendo ao sistema (com o Shell Korn) a
descrio da palavra ou parte dela.
Facilidade de se mover entre um diretrio e outro, etc.
O Shell Korn est, cada vez mais, tornando-se popular. Com os recursos
que possui, est se transformando numa alternativa para o Shell C.
13
14
O Shell tcsh (verso modificada do Shell C)

Surgindo como uma verso modificada do Shell C, o tcsh possui fortes recursos, tanto como interpretador de comandos como para escrever scripts.
Ele apresenta 95% de csh e 5% de novos recursos. Os mais importantes
adicionais do tcsh em relao ao Shell C so:
Leitura atenta da lista de histrico de comandos;
Identificao de arquivos com os primeiros caracteres;
Correo ortogrfica de comando, arquivo e nomes de usurio;
Desconexo automtica depois de um determinado perodo inativo;
Capacidade de monitorar logins, usurios e terminais;
Novas variveis de ambiente: HOST e HOSTTYPE
Exemplos de alguns recursos do Shell tcsh:
Leitura atenta do histrico de comandos com o comando history:
[fabio@hobbes]$ history
1 15:59 history
Configurao do Prompt
2 15:59 s -l
3 16:00 cd ~/
4 16:00 ls
5 16:00 pwd
6 16:00 tail -4 tcsh.txt
7 16:02 head -10 tcsh.txt | grep Cornell
8 16:03 who | tee who.out
9 16:03 cat who.out
10 16:03 history
Novas variveis de ambiente:

[fabio@hobbes]$ echo $HOST
hobbes
[fabio@hobbes]$ echo $HOSTTYPE
i386-linux
O smbolo $ significa valor de e o comando echo exibe o valor de uma

varivel (esse comando ser visto com mais detalhes no Captulo 3).
O Shell Bourne-Again - bash

O bash um shell que se encontra em todos os sistemas operacionais
GNU. O projeto GNU visava desenvolver um sistema de softwares que
deixasse o Unix mais completo, sendo que tal projeto foi criado pela Free
Software Foundation, uma organizao fundada por Richard Stallman. A
sigla GNU significa GNUs Not Unix (o G em GNU deve ser pronunciado). Alguns softwares desenvolvidos e distribudos pelo projeto GNU so o
editor Emacs, o compilador gcc e o depurador gdb.
O acrnimo Bourne-Again do bash um trocadilho para Steven Bourne, o
autor do Shell Bourne, sendo que o bash uma reimplementao do shell
original (Shell Bourne), tendo muitos novos recursos e no apresentando
restries de licena. Ele tambm possui implementaes do Shell C e do
Shell Korn.
Outros Shells do Unix

Alguns sistemas Unix ainda podem ter outros shells, alm dos que j foram
discutidos anteriormente. Geralmente, eles so adquiridos separadamente
pelos proprietrios de sistemas Unix. Logo a seguir, esto listados esses
shells menos comumente usados:
Shell rsh: uma verso restrita do Shell Bourne, indicado para sites
que tenham mecanismos de segurana. Houve discusses sobre alguns
problemas de segurana envolvendo esse shell.
Shell jsh: tambm uma verso do Shell Bourne, que inclui os recursos
de controles de servio do Shell C.
Shell MH(msh): esse shell foi desenvolvido por causa do programa de
correio eletrnico MH, projetado pela Rand Corporation. Ele permite ter
acesso instantneo a qualquer correio eletrnico presente no sistema.
Identificando o Shell
H muitas formas de se identificar o shell que se est usando. A primeira
delas e, talvez a mais fcil, entrar no arquivo etc/passwd (sendo que etc
um subdiretrio do diretrio raiz e passwd um arquivo pertencente ao
15
16
diretrio etc) e ver o que est presente em sua conta. Veja o exemplo que
se segue:
Exemplo:
[fabio@hobbes /]$ tail -8 etc/passwd
bene:5VgR1rD9qxT2w:500:500:Benedito Aparecido Cruz:/home/staff/bene:/bin/bash
kleber:bUXQIdilUbxiE:502:502::/home/staff/kleber:/bin/bash
rosa::503:503:Rosa Cristina Martins de Medeiros:/home/staff/rosa:/bin/bash
gonzal:1hI2zJUNyJdjE:504:504:Carlos Gustavo Gonzales,,,,:/home/staff/gonzal:/
bin/bash
rossano::505:505:Rossano Pablo Pinto,,,,:/home/staff/rossano:/bin/bash
brito::506:506:Antonio Brito,,,,:/home/staff/brito:/bin/bash
fabio:b.NlENts7oItc:501:501:Fabio Danilo Vieira:/home/staff/fabio:/bin/bash
joao:afltY24Vk/.xM:507:507:Joao da Silva:/home/staff/joao:/bin/bash
Veja no exemplo que os 8 ltimos usurios do arquivo etc/passwd tm

como shell padro (ou shell de login) o Shell bash (o restante foi ignorado por ter informaes compreendidas somente por um administrador de
sistema).
No entanto, bom conhecer outros modos de identificao, pois em alguns
sistemas no tem o arquivo etc/passwd relacionado a segurana. Sendo
assim, outra maneira bem simples de se identificar o shell consiste em
observar o seu prompt. Se ele contm um %, provavelmente o shell que
se est usando o Shell C (csh) ou o Shell C modificado (tcsh), mas se o
prompt for $, o shell em uso pode ser o Shell Bourne, o Shell Korn ou uma
das variantes destes.
H tambm um modo mais confivel de se obter o shell utilizado, que pedir
ao sistema operacional o programa que est sendo executado no momento.
Atravs da linha de comando do exemplo a seguir, isso pode ser feito.
Exemplo:
[fabio@hobbes /]$ ps | grep $$

326
p0 S 0:00 -bash
O comando ps exibe o que o sistema operacional est executando no

momento e grep $$ pesquisa por um nome de shell na lista de ps. Nesse
exemplo, verifica-se que o shell utilizado o bash.
Outra maneira de se conseguir identificar o shell utilizado usar o comando awk, que um programa que contm um kit de programao capaz
de analisar e manipular arquivos de texto que tenham palavras, para ler o
arquivo etc/passwd novamente. Veja o exemplo abaixo:
Exemplo:
[fabio@hobbes /]$ awk F: { if ($1 == fabio) print seu shell : $7 } < /etc/
passwd
seu shell : /bin/bash
Nesse exemplo, o comando awk verifica se o primeiro campo do arquivo

passwd contm fabio. Caso contenha, ele ir imprimir o stimo campo de
tal arquivo, que possui o nome do shell relacionado a fabio.
Escolhendo um novo Shell

Foi visto, anteriormente. como identificar o shell que est sendo utilizado
pelo sistema. Uma vez identificado esse shell, pode-se escolher um outro
de acordo com a nossa preferncia.
Antigamente, mudar de um shell para outro era bem complicado. A nica
alternativa era solicitar ao administrador do sistema para alterar o arquivo etc/passwd, e isso s era possvel se ele tivesse tempo disponvel.
Felizmente, hoje, existe um programa simples (presente em quase todos
os sistemas Unix) para alterar shells de login, que o chsh, ou change
shell (alterar shell). Esse comando no possui flags, no requer que nomes
de arquivos sejam especificados e pode ser usado em qualquer local do
sistema. s digitar chsh e pressionar ENTER.
Antes de mais nada, vale dizer que o usurio tambm pode alternar de um
shell para outro digitando apenas o nome do shell para o qual quer mudar.
Ele no precisa, necessariamente, modificar o seu shell de login com o
comando chsh, podendo usar outro subshell de acordo com sua necessidade.
Entretanto, antes de se mudar de shell, preciso identificar os shells
disponveis no sistema. H um local no sistema de arquivos do Unix em
que estes esto guardados, e, por conveno, eles tm sh em algum lugar
de seus nomes. Um dos locais no diretrio /bin (subdiretrio do diretrio
raiz). Veja um exemplo de listagem desse diretrio:
Exemplo:
[fabio@hobbes /]$ ls lF /bin/*sh*
-rwxr-xr-x
1 root
root
56380
-rwxr-xr-x
1 root
root
300668
Dec 23
Sep 3
1996 /bin/ash*
1996 /bin/bash*
17
18
lrwxrwxrwx
-rwxr-xr-x
lrwxrwxrwx
-rwxr-xr-x
1 root
1 root
1 root
1 root
root
root
root
root
3
105356
4
233732
Aug 27
Aug 12
Aug 27
Dec 18
1997 /bin/bsh -> ash*

1996 /bin/csh*
1997 /bin/sh -> bash*
1996 /bin/tcsh*
Pode-se notar que h uma entrada em /bin/bsh e em /bin/sh para os shells

ash e bash, respectivamente, embora seja realmente apenas um link apontando para o shell ash e shell bash.
Em outros sistemas, podem haver outros locais de armazenamento dos
shells. Um exemplo disso pode ser visto abaixo:
Exemplo: (Tirado do livro Aprenda em 24 horas Unix)
% ls lF /usr/local/bin/*sh*
-lrwxr-xr-x 1 root
8
--rwxr-xr-x 1 root
266240
Jul 26 14:46 /usr/local/ksh->bin/ksh*

Jan 19 1993 /usr/local/tcsh*
Evidentemente que podem existir outros shells no sistema, mas isso no

influenciar no modo de alterar de um shell para o outro. Portanto, para
modificar o shell de login para qualquer um dos shells disponveis no sistema ou at mesmo s para verificar o shell que est se executando, usa-se
o comando chsh (comentado anteriormente). Veja o exemplo:
Exemplo:
[fabio@hobbes fabio]$ chsh
Changing login shell for fabio
Old shell: /bin/bash
New shell: _
Nesse exemplo, o programa indica que bin/bash o shell de login e pede

para digitar o nome de um shell alternativo. Caso tente especific-lo com
algum outro nome de arquivo, o comando retorna uma mensagem dizendo
que aquele nome inaceitvel como um novo shell. Confira o exemplo:
Exemplo:
New shell: ~/arq.txt
home/staff/fabio/arq.txt is unacceptable as a new shell.
O comando chsh no aceita essa mudana porque ele verifica no arquivo /

etc/shells os nomes de shells vlidos. Veja, em seguida, a leitura do arquivo /etc/shells em um sistema Unix:
Exemplo:
[fabio@hobbes fabio]$ cat /etc/shells
/bin/ash*
/bin/bash*
/bin/bsh -> ash*
/bin/csh*
/bin/sh -> bash*
/bin/tcsh*
Sabendo, ento, os nomes dos shells vlidos, pode-se alterar com preciso o shell:
Exemplo:
New shell: /bin/csh
Novo Prompt
[fabio@hobbes]$
Pode-se notar que a alterao obteve sucesso, isso porque o Unix no

mostrou nenhuma mensagem de erro e tambm por causa da mudana da
configurao do prompt (entretanto, este fator no deve ser sempre levado
em considerao, pois, s vezes, o prompt pode permanecer o mesmo). O
novo shell agora o Shell C, o mais popular e usado shell do Unix, e por
esse motivo, daqui para frente, ele ser tratado de forma mais especfica,
principalmente nos prximos captulos.
O ambiente Shell
O ambiente um espao na memria onde se pode colocar definies de
variveis do shell para que elas fiquem acessveis a qualquer programa
que for executado. Se no colocar a definio de uma varivel no ambiente, apenas o shell ir conhecer o valor de tal varivel.
A insero da definio de uma varivel no ambiente feita em 2 etapas:
na primeira define-se a varivel do shell e, na segunda, se coloca-se a definio no ambiente Unix. Depois ela ser chamada de varivel ambiental
(e continua sendo uma varivel do shell).
Portanto, o shell o principal programa interessado no ambiente, pois nele
so armazenados os valores de algumas de suas relativas variveis. Por
19
20
que algumas? Porque ele no procura no ambiente certas variveis, e sim

apenas a sua definio, ou seja, o que interessa para ele apenas o valor
que est definido para essas variveis, e no seu valor no ambiente.
Um exemplo a varivel history, do Shell C, cuja definio lida pelo csh.
Essa varivel ser vista com mais detalhes no prximo captulo.
J um exemplo de varivel ambiental a PATH, a qual todos os shells utilizam e onde, tambm, se define a rota de procura de programas.
Definindo variveis
A definio de uma varivel varia de shell para shell e, por este motivo,
ser mostrado como definir variveis apenas nos dois principais shells:
Shell Bourne e Shell C. Mas, os modos de como definir variveis destes
shells podem ser iguais a outros, principalmente em suas variantes.
Para se definir uma varivel para o Shell Bourne e para o Shell C, usam-se
as seguintes sintaxes de linhas de comandos:
$ variavel=valor
% set variavel=valor
(Shell Bourne)
(Shell C)
Nesses casos, variavel o nome da varivel, e valor pode ser tanto um

nmero quanto uma sequncia de caracteres. Uma varivel do shell contendo um valor numrico tratada pelo shell como se ela tivesse um valor
texto ou alfanumrico. Observa-se tambm que o Shell C usa o comando
set para definir variveis.
Logo abaixo seguem alguns exemplos de definies de variveis para o
Shell Bourne e Shell C:
Exemplos:
No Shell Bourne:
$ usuario=Jose da Silva
No Shell C:
% set usuario=Jose da Silva
No Shell Bourne:
$ PATH=:/bin:/usr/bin
No Shell C:
% set PATH=:/bin:/usr/bin
No Shell Bourne:
$ arq1=/bin/vi arq2=/usr/bin/gnuemacs
No Shell C:
% set arq1=/bin/vi arq2=/usr/bin/gnuemacs
A varivel usuario definida como sendo Jose da Silva. A varivel do

shell, PATH, redefinida com o valor :/bin:/usr/bin. Tambm se pode definir mais de uma varivel por linha, com arq1 sendo /bin/vi e arq2 sendo /
usr/bin/gnuemacs.
Para se exibir o valor de uma varivel tanto do Shell Bourne quanto do
Shell C, usa-se o comando echo mais o nome da varivel precedida pelo
sinal de cifro ($), que significa valor de. Veja, em seguida, como exibir o
contedo das variveis definidas anteriormente:
$ echo $usuario
Jose da Silva
% echo $PATH
:/bin:/usr/bin
$ echo $arq1
/bin/vi
% echo $arq2
/usr/bin/gnuemacs
Apesar de se ter definido usuario, PATH, arq1 e arq2 como variveis do

Shell Bourne e do Shell C, elas ainda no so variveis ambientais porque
no foram colocadas no ambiente, mas isso ser visto no prximo item.
Variveis ambientais
Depois que se definem as variveis para o shell pode-se transform-las em
variveis ambientais.
Obs: em Shell C, define-se uma varivel que se transforma em varivel
ambiental com apenas um comando, o qual ser visto frente.
As variveis ficam disponveis a cada processo de programa assim que
sua execuo comea. Um processo poder ou no usar a informao
guardada na varivel ambiental. Portanto, as informaes ambientais
21
22
fornecem uma maneira de se passar informaes globais para qualquer

programa que esteja em execuo.
Tendo por base o que foi dito, define-se que varivel ambiental simplesmente uma varivel do shell que foi inserida no ambiente. Mas, assim
como a definio de uma varivel varia de shell para shell, o modo de se
colocar uma varivel no ambiente tambm varia de um shell para outro.
Como exemplos dessas diferenas, novamente ir se usar o Shell Bourne
e o Shell C.
Para se inserir uma varivel do Shell Bourne no ambiente, usa-se o comando export. Observe a sintaxe da linha de comando:
$ export variavel
Sendo assim, a definio de uma varivel ambiental do Shell Bourne consiste em duas etapas:
A criao
Exportao da varivel
Como exemplo, ir se definir a varivel do prompt do Shell Bourne, PS1, e
coloc-la no ambiente.
Exemplo:
$ PS1=Aguardando ordem; export PS1
Aguardando ordem _
Observe que foram colocados dois comandos na mesma linha, separados

por ponto-e-vrgula, e o prompt foi modificado. O usurio tambm pode
fazer com que PS1 volte ao seu valor original, digitando:
Aguardando ordem PS1=$; export PS1
$_
Para o Shell C, tem-se a possibilidade de definir e acrescentar uma varivel no ambiente em apenas uma etapa, usando o comando setenv. Veja a
sintaxe:
% setenv variavel valor
Como exemplo, tambm ir se redefinir o prompt do Shell C:

% setenv prompt $
$_
Note que ele ficou igual ao prompt padro do Shell Bourne, mesmo estando no Shell C. Portanto, quando for se identificar o shell em uso, a con-
figurao do prompt nem sempre a maneira mais confivel de se fazer

isso.
Para distingui-los de outras variveis do shell, os nomes das variveis ambientais do Shell Bourne so, geralmente, escritos com letras maisculas.
No Shell C tambm h algumas variveis com nomes em letras maisculas, mas o restante das variveis esto mesmo em minsculas. Veja, em
seguida, uma lista de variveis ambientais comumente usadas pelo Shell
Bourne e Shell C. Observe tambm que no se deve utilizar os mesmos
nomes para outras variveis que venham a ser definidas, isso para evitar
conflitos com os nomes reservados:
HOME: seu diretrio domstico, obtido do quarto campo do arquivo de
senha (/etc/passwd); O diretrio onde seu shell est originalmente posicionado depois que se inicia uma sesso no sistema.
PATH: rotas (os caminhos) para a procura de comandos, as quais consistem em uma lista de diretrios que o shell e outros comandos pesquisam para encontrar programas solicitados pelos usurios quando o
caminho no for especificado.
MAIL: indica o caminho para o seu arquivo de correspondncia onde
suas mensagens esto guardadas.
TERM: modelo do seu terminal.
SHELL: indica o shell que est sendo usado. Muito utilizada por programas como o editor de texto vi, por exemplo.
PS1: prompt principal do Shell Bourne (e tambm do Shell Korn). O valor
padro $.
PS2: prompt secundrio do Shell Bourne. O valor padro >.
TES: separadores internos de campo, que podem ser os caracteres TAB,
espao e avano de linha. Eles separam palavras na linha de comando
do shell.
TZ: especifica o fuso horrio, cujo valor tem o formato xxxnzzz, onde
xxx a abreviao padro do fuso horrio local, n a diferena em
horas da hora de Greenwich (GMT) e zzz a abreviao do horrio de
vero no fuso horrio considerado, se houver. Por exemplo, PST8PDT
a especificao do fuso-horrio da costa-oeste dos Estados Unidos, com
8 horas de diferena de Greenwich.
23
24
LOGNAME: a identificao do usurio que est executando o shell.

NAME: obtida do campo 5 do arquivo /etc/passwd (ou equivalente), ela
til para programas de correio eletrnico e de impresso que, s vezes,
precisam saber o nome real completo do usurio do sistema.
USER: sinnimo de LOGNAME, ou seja, ela d a identificao do usurio que est usando o shell.
Obs: antigamente, LOGNAME era uma varivel pertencente ao Shell
Bourne e USER ao Shell C, mas, hoje, ambos os shells utilizam essas
duas variveis.
No entanto, no somente o shell que usa variveis ambientais. Alguns
comandos tambm utilizam-se delas. Um exemplo o comando more.
Quando esse comando est sendo executado, ele procura no ambiente
pela varivel MORE. Se tal varivel for encontrada, seu valor interpretado por esse comando, como opes de linha de comando. Caso o usurio,
por exemplo, no queira ver as linhas em branco nos arquivos, ele pode
atribuir varivel MORE a opo s. Observe as linhas de comando:
No Shell Bourne:
$ MORE= -s
(atribui um valor a MORE)
$ export MORE (exporta-a para o ambiente)
No Shell C:
% setenv MORE s (atribui um valor varivel e exporta-na para o ambiente)
No Shell C a definio e a colocao de uma varivel no ambiente se d em

apenas uma etapa, enquanto que no Shell Bourne se d em duas etapas.
Para se listar os vrios aspectos de um ambiente, pode-se usar o comando
env. Veja o exemplo:
Exemplo:
[fabio@hobbes]$ env
HISTSIZE=1000
HOSTNAME=hobbes
LOGNAME=fabio
HISTFILESIZE=1000
MAIL=/var/spool/mail/fabio
TERM=ansi
HOSTTYPE=i386
PATH=/usr/local/bin:/bin:/usr/bin:/usr/X11R6/bin
HOME=/home/staff/fabio
SHELL=/bin/bash
PS1=[\u@\h \W]\$
USER=fabio
OSTYPE=Linux
SHLVL=1
_=/usr/bin/env
Nesse exemplo, verifica-se que aparecem algumas variveis desconhecidas, mas que no tm muita importncia em relao configurao necessria para o sistema funcionar adequadamente, comportando-se apenas
como opes do prprio usurio ou administrador do sistema.
Arquivos de inicializao do Shell

Foi visto, no item anterior, como personalizar seu ambiente manualmente atravs de comandos, logo aps ter se conectado ao sistema. Porm,
pode-se colocar esses mesmos comandos dentro de um arquivo executvel. Esse arquivo chamado de arquivo de inicializao do shell, e ele
executado automaticamente toda vez que algum se identifica no sistema.
Esse arquivo tem um nome especial, que reconhecido somente pelo
shell de login do usurio, e seu nome est armazenado juntamente com os
dados de login do usurio no arquivo /etc/passwd ou equivalente. O Shell
Bourne reconhece o arquivo de inicializao .profile, e o Shell C reconhece
tanto o arquivo .login quanto o .cshrc.
O arquivo .cshrc do Shell C executado quando o usurio se identifica no
sistema e tambm toda vez que se cria um subshell, isto , quando o usurio muda de um outro shell qualquer para o Shell C.
H muitos comandos que se pode colocar nos arquivos de inicializao
.profile do Shell Bourne e .login do Shell C. Logo abaixo segue-se uma lista
de possveis incluses que se pode realizar nesses arquivos:
Definio de variveis do shell e tambm sua colocao no ambiente.
Redefinio da configurao do prompt do shell.
Redefinio da rota de procura de comandos pela varivel PATH.
Definio de opes de configurao para o terminal usando o comando
stty (set tty drivers options, ou definir opes do driver tty).
25
26
Existem tambm alguns comandos optativos que podem ser inseridos no

arquivo .login ou cshrc do Shell C:
Ativao da funo de histrico de comandos.
Definio de aliases (pseudnimos) para comandos.
Redefinio de variveis do Shell C e tambm sua insero no ambiente.
Logo a seguir, tem-se alguns exemplos desses 3 arquivos: .profile do Shell
Bourne, .login e .cshrc do Shell C:
Exemplos:
Exemplo 1:
$ cat .profile
PATH=:/bin:/usr/bin:/usr/lbin
TERM=kA
export PATH TERM
stty erase ^h kill ^x quit û intr ^c
stty ixon
echo A hora de sua identificao date.
echo No momento h who|ws a terminais em linha.
echo As variveis do shell que esto definidas so:
set
echo A linha do terminal est assim configurada:
stty
Exemplo 2:
% cat .login
# @(#) $Revision: 62.2 $
setenv TERM vt100
stty erase ^h kill û intr ^c eof ^d
stty crtbs crterase
# variveis do shell
set history=100 savehist=50
# define algumas variveis de ambiente globais...
setenv EXINIT : set ignorecase
setenv NAME Dave Taylor
Exemplo 3:
% cat .cshrc
# .cshrc
# User specific aliases and functions

alias rm rm -i
alias cp cp -i
alias mv mv -i
setenv PATH=.:/usr/sbin:/sbin:$PATH
set prompt=\[ìd -nu`@`hostname -s`\]\#\
Em primeiro lugar, quando aparece o caractere # mais um texto, significa

que tal sequncia refere-se a um comentrio. Entretanto, pode-se ver que
aparecem algumas variveis e alguns comandos novos em relao ao
que foi visto at aqui. Nos arquivos .profile e .login aparece o comando
stty citado anteriormente, que configura opes de um terminal. No arquivo .login, por exemplo, a linha stty assegura que ^h (as teclas control +
h) equivale a apagar (backspace), û equivale a excluir uma linha inteira
de comando, ^c envia uma interrupo para o programa que est sendo
executado e ^d indica o final de um arquivo. J a segunda linha do stty
assegura que a CRT (uma tecnologia usada na tela de um terminal padro) seja capaz de apagar e excluir caracteres na tela. Outro comando
o alias, que surge no arquivo .cshrc. Apesar de, no prximo captulo,
ser bastante enfocado, por enquanto deve-se saber que o formato de
execuo alias word command e que ele fornece um pseudnimo para
linhas de comando muito extensas. No exemplo do .cshrc, ele permite que,
digitando-se apenas rm, cp e mv, o flag i j esteja incluso.
Em relao s variveis, s no arquivo .login aparecem algumas diferentes das que foram comentadas at aqui. A varivel history=100 permite
ao sistema informar os ltimos 100 comandos utilizados e savehist=50
grava e depois informa cinquenta deles, mesmo que se desligue o sistema e conecte-se novamente. E, finalmente, a varivel EXINIT utilizada
pelo editor de texto vi e est definida para que tal editor possa realizar
uma pesquisa de texto sem levar em considerao letras maisculas e
minsculas. Vale dizer que as variveis history e savehist sero revistas no
prximo captulo.
Chega-se, ento, ao final do primeiro captulo, que teve como objetivo dar
a definio da estrutura do sistema operacional Unix, explicar as funes
do shell dentro do Unix, assim como comentar sobre os shells mais importantes e alguns ainda menos difundidos pela comunidade Unix. Foi
visto como se faz para identificar o shell em uso, bem como mudar de um
shell para outro. Explicou-se, tambm, sobre como definir suas variveis e
27
28
export-las para o ambiente. Outro ponto importante foi sobre os arquivos

de inicializao de shell, entre os quais esto o .login e o .cshrc do Shell C
e o .profile do Shell Bourne.
lo 2
tu
ap
Um pouco mais do Shell C e do Shell Korn
No captulo anterior, foram apresentados alguns shells disponveis no Unix.

No entanto, como j foi dito anteriormente, o Shell C o que est mais
presente na grande maioria dos sistemas Unix existentes no mundo, e por
esse motivo, ser bastante enfatizado nesse captulo. Alm disso, tambm
sero discutidos alguns recursos importantes do Shell Korn, que uma
alternativa para o Shell C.
Os mecanismos de histrico do Shell C e do Shell Korn

O mecanismo de histrico de comandos, tanto do Shell C quanto do Shell
Korn, permite que o usurio possa relembrar e utilizar um comando anteriormente executado por ele no sistema. A partir do momento que um
usurio se conecta ao sistema e digita o primeiro comando, este equivale
ao comando 1, e o restante que tal usurio digitar ser incrementado a
esse primeiro comando. Sendo assim, para se fazer uma reviso ou repetir
qualquer comando basta apenas tocar algumas teclas.
O Shell C utiliza o comando history para visualizar at os ltimos n comandos digitados, sendo que esse n o nmero de comandos que o
usurio gostaria de lembrar quando executasse history. Para se definir n
(nmero de comandos) utiliza-se uma varivel do Shell C chamada history
(no estranhem; ela, realmente, tem o mesmo nome do comando). Veja a
sintaxe de linha de comando abaixo:
% set history=n
Depois que a varivel history estiver definida, toda vez que o comando
history for chamado, ele ir consultar essa varivel e o valor de n atribudo
a ela, para com isso poder exibir a quantidade de comandos desejada pelo
usurio. Caso aparea uma quantidade menor, porque no foi utilizado
um nmero suficiente de comandos para atingir o valor de n.
Observe que essa varivel no foi transportada para o ambiente, isso
porque um tipo de varivel que s o Shell C pode reconhecer, portanto,
ela no necessita ser definida no ambiente, mas precisa ser definida para
o Shell C.
30
J para o Shell Korn, o valor de n nico e padro, e corresponde a 128.

Sendo assim, o usurio ir visualizar apenas os ltimos 128 comandos
digitados por ele (caso ele tenha digitado tudo isso). Esse valor pode ser
considerado pequeno em relao ao Shell C, no qual se pode atribuir valores bem maiores que esse. Para visualizar o histrico no ksh, tambm se
utiliza o comando history, apesar de que nesse shell, history um alias
para a linha de comando fc l.
Em seguida so exibidos alguns exemplos do que foi discutido desse mecanismo at aqui:
Exemplo de definio da varivel history no Shell C:
[fabio@hobbes]$ set history=1000
Verificando as variveis definidas para o Shell C, inclusive history:

[fabio@hobbes]$ set
argv ()
cwd
/home/staff/fabio
history 1000
home /home/staff/fabio
i
/etc/profile.d/*.csh
path
(/usr/local/bin /bin /usr/bin /usr/X11R6/bin /home/staff/fabio/bin /usr/X11R6/bin)
prompt [fabio@hobbes]$
shell /bin/csh
status 0
term ansi
user fabio
Exemplos de utilizao do comando history, que valem tanto para o Shell

C quanto para o Shell Korn:
Antes de se utilizar o comando history, sero digitados alguns comandos
de exemplos para se observar a sada fornecida pelo comando de histrico:
[fabio@hobbes]$ ls -lF
total 1168
-rw-------
1 fabio
drwxr-xr-x
2 fabio
drwxrwxr-x
2 fabio
-rwxrwxr-x
1 fabio
-rw-rw-r--
1 fabio
drwxrwxrwx
2 fabio
-r--r--r-- 1 fabio fabio
Lista-se o diretrio por permisso e tipos de arquivos

fabio
fabio
fabio
fabio
fabio
fabio
183109
821
1024
1024
3959
95
1024
Mar 4
Mar 7
Mar 4
Mar 7
Mar 6
Mar 6
Mar 4
23:34
16:08
20:41
08:13
16:45
16:45
20:34
tcsh.1
mbox
novell/
ocultos/
prog*
prog.c
public/
-rw-rw-r--
-rw-rw-r--
-rw-rw-r--
-rw-rw-r--
-rw-rw-r--
1 fabio
1 fabio
1 fabio
1 fabio
1 fabio
fabio
fabio
fabio
fabio
fabio
[fabio@hobbes]$ wc prog.c
11
15
95 prog.c
[fabio@hobbes]$ date
Sat Mar 7 18:09:39 EST 1998
493265
250862
250862
48
85
Mar 4
Mar 5
Mar 5
Mar 4
Mar 6
23:35
00:13
00:09
20:28
16:03
tcsh.lj
tcsh.lt1
tcsh.txt
testfile
who.out
Obtm-se o nmero de linhas, palavras

e caracteres do arquivo prog.c
Obtm-se data e hora do sistema
Agora sim, se utilizar o comando history:

[fabio@hobbes]$ history
1 18:03 set history=1000
2 18:03 ls -lF
3 18:08 wc prog.c
4 18:09 date
5 18:10 history
Observe que a primeira linha de comando da lista o set history=1000, o

qual foi executado no item anterior, e o restante so os exemplos utilizados
para demonstrar a funo do comando history.
Para que esse comando possa ser usado permanentemente, pode-se adicionar a linha comando set history no arquivo .login ou .cshrc do csh. Se
o usurio desejar que os comandos sejam lembrados pelo shell, mesmo
que se desligue o sistema, acrescenta-se tambm a varivel savehist. Um
exemplo o arquivo .login, visto no captulo anterior, que possua essas
variveis:
Exemplo do arquivo .login:
% cat .login
# @(#) $Revision: 62.2 $
setenv TERM vt100
stty erase ^h kill û intr ^c eof ^d
stty crtbs crterase
# variveis do shell
Variveis history e savehist
set history=100 savehist=50

# define algumas variveis de ambiente globais...
setenv EXINIT : set ignorecase
setenv NAME Dave Taylor
31
32
Em relao ao Shell Korn, no se precisa fazer alteraes em seus arquivos de inicializao, pois o comando history est pronto para ser usado
imediatamente.
Como usar o histrico para economizar digitao

No item anterior foi visto como obter uma lista de histrico de comandos.
Agora, veremos como us-la.
Para se executar um comando de histrico no Shell C, utiliza-se o ponto
de exclamao ( ! ) no incio de tal comando. Por exemplo, se o vigsimo
quinto comando digitado foi o comando date, para execut-lo novamente,
insere-se !25 na linha de comando. Outra opo inserir um ou mais caracteres do comando, por exemplo: !d, !da ou !date. Deve-se colocar caracteres suficientes para identific-lo exclusivamente na lista de histrico.
Para se consertar um comando anterior ( ou mesmo para reedit-lo ),
digita-se: ^padro a ser alterado^padro correto. Por exemplo, caso o
usurio tenha executado o comando ls a* ( listar todos os arquivos que
possuam nomes que comecem com a ) e queira edit-lo novamente, para
acrescentar mais a letra t junto letra a, ele poder usar a seguinte linha
de comando: â*ât*.
O comando !! talvez seja o mais til dentre todos os comandos de histrico
do Shell C. Ele repete o ltimo comando executado. Por exemplo, se o ltimo comando usado foi grep fabio /etc/passwd (pesquisar por fabio no
arquivo passwd), digitando-se !! e apertando ENTER, esse comando ser
executado novamente.
O Shell C possui outros comandos de histrico, como !$, que vai at a
ltima palavra da linha de comando anterior, e !*, que recupera todas as
palavras da linha de comando anterior, menos a primeira. Um exemplo
desse comando podia ser o caso do usurio ter usado, como ltima linha
de comando, ls /etc/passwd, e, em seguida, modific-la, trocando-se apenas a primeira palavra: cat !* ( = cat /etc/passwd ).
J em relao ao Shell Korn, ele dispe de quase todos os comandos
de histrico do Shell C. Para se repetir comandos pelo nmero, utiliza-se
a linha de comando rn, onde n o nmero do comando ( por exemplo,
r45 ). Para se repetir comandos, usando, ao invs do nmero, o nome do
comando, digita-se rnome-do-comando ( Exemplo: rls ). Sem quaisquer

argumentos, r repetir o comando anterior.
Em seguida, so transcritos alguns exemplos do que foi dito sobre comandos de histrico at aqui. Os exemplos sero baseados no Shell C, mas
seus equivalentes em ksh sero lembrados.
1. Primeiro deve-se consultar a lista de histrico para usar os comandos
que esto l guardados:
% history
1 15:05 set history=1000
2 15:08 history
3 15:09 cat arq.txt
4 15:11 ls
5 15:14 date
6 15:14 history
Lembrando que, no Shell Korn, usa-se o mesmo nome de comando para

obter o histrico.
2. Para se repetir o comando date, basta especificar seu nmero de comando:
% !5
date
Sat Mar 14 13:05:03 Est 1998
No Shell Korn, o equivalente seria r5.

3. Para se repetir a linha de comando cat arq.txt, basta especificar sua
primeira letra.
% !c
cat arq.txt

Shell: interpretador de comandos

Kernel: controla dispositivos de hardware e gerencia dados
%_
No Shell Korn, o equivalente seria rc.

4. Para executar o ltimo comando do histrico, usa-se:
% !!
history
1 15:05
2 15:08
3 15:09
4 15:11
set history=1000
history
cat arq.txt
ls
33
34
5 15:14 date
6 15:14 history
O equivalente no ksh r.
Pode-se usar centenas de exemplos desses comandos de histrico, mas
os que foram dados e a explicao feita so suficientes para se utilizar
plenamente o recurso de histrico de comandos. A tabela 1 a seguir exibe
os comandos de histrico do Shell C:
Tabela 1. Comandos de histrico do Shell C.
Comando
Funo
!!
Repete o comando anterior.
!$
Repete a ltima palavra do comando anterior.
!*
Repete todas as palavras do comado anterior, menos a primeira.
â^b
!n
Substitui a por b no comando anterior.

Repete o comando n da lista de histrico.
Obs.: Tabela retirada do livro Aprenda em 24 horas Unix
Como usar os aliases de comandos

Como j foi comentado no captulo anterior, os aliases de comando possibilitam que se renomeie e reconfigure comandos de modo que se facilite o
uso destes. Os aliases reduzem bastante o processo de digitao, assim
como o mecanismo de histrico de comandos.
Para se usar o mecanismo de alias no csh, utiliza-se o formato padro
alias palavra comando ( ou sequncia de comandos ). J no ksh, o formato utilizado alias palavra=comando ( ou sequncia de comandos ).
Se for inserido, tanto no Shell C quanto no Shell Korn, somente o comando alias, sem quaisquer argumentos, ser mostrada uma sada com uma
lista de aliases que o usurio definiu (se tiverem aliases definidas). No csh
se for usado a linha de comando alias palavra, ser listado o alias atual,
relacionado quela palavra.
Alguns exemplos desse poderoso comando so listados e comentados em
seguida:
1. Uma das linhas de comandos mais usadas do Unix o ls FC, que

lista o contedo de um determinado diretrio em vrias colunas, informando os tipos de arquivos e os subdiretrios. Pode se criar um alias
para ela:
% alias ls ls FC
Observa-se que o nome usado para substituir a linha de comando o

nome do prprio comando. Portanto, quando se for usar ls sozinho, ele
substituir ls FC. Mas isso no impede que o comando ls seja usado com
outras opes. Observe, ento, a sada de ls:
% ls
mbox ocultos/
novell/ prog*
prog.c
public/
tcsh.1
tcsh.lj
testfile vin@
who.out
Com essa sada, possvel se identificar os subdiretrios (os que possuem

uma barra na frente do nome) e os tipos de arquivos (executveis: com
asterisco na frente do nome; textos: sem nada embutido ao nome; vnculos
simblicos: com o smbolo arroba @ na frente do nome).
O equivalente uso do comando alias no ksh alias ls=ls FC.
2. Pode-se, tambm, criar aliases para sequncia de comandos, ou seja,
junes de dois ou mais comandos para fornecer uma determinada
sada. Por exemplo, possvel se incrementar o alias anterior, fazendo
com que, alm de sair uma listagem que especifica os subdiretrios e
arquivos, seja exibida tambm a quantidade de espao usado em disco
pelo contedo daquele diretrio (comando du):
% alias ls ls FC; du s
mbox ocultos/ prog.c
novell/ prog*
public/
1325
tcsh.1
tcsh.lj
testfile vin@
who.out
A sada fornece o total usado pelo contedo do diretrio em kilobytes.

Nesse caso, o total 1325 kilobytes.
O equivalente em ksh alias ls=ls FC; du s.
3. Para usurios que esto acostumados com os comandos do DOS e
comearam a usar o Unix agora, o alias um grande aliado para quem
ainda no conseguiu se familiarizar com a sintaxe do Unix. Com os aliases, pode se recriar os comandos do DOS, renomeando seus equivalentes no Unix:
35
36
% alias DIR ls lF
% alias REN mv
% alias COPY cp i
% alias DEL rm i
Testando alguns deles:

% DIR arq1.txt
-rw-rw---- 1 fabio fabio
% REN arq1.txt arq2.txt
% DIR arq2.txt
-rw-rw---- 1 fabio fabio
220 Dec 3 14:15 arq1.txt

220 Dec 3 14:15 arq2.txt
Foram, nesse caso, recriados apenas os comandos mais usados do DOS,

mas o usurio pode incrementar outros mais, de acordo com sua vontade.
Para que as definies de aliases fiquem permanentes, ou seja, para que
no se precise defini-las toda vez que se entrar no sistema, deve-se inserilos nos arquivos de inicializao de seus respectivos shells. No caso do
Shell C, insere-se no arquivo .cshrc e. no Shell Korn, coloca-se no .profile.
Num exemplo dado anteriormente do arquivo .cshrc, havia algumas linhas
de aliases. Veja ele novamente:
% cat .cshrc
# .cshrc
# User specific aliases and functions
alias rm rm -i
alias cp cp -i
alias mv mv -i
Exemplos de algumas
aliases.
setenv PATH=.:/usr/sbin:/sbin:$PATH
set prompt=\[ìd -nu`@`hostname -s`\]\#\
Com essas linhas de aliases inseridas nesse exemplo do arquivo .cshrc,

o usurio, quando utilizar um daqueles trs comandos ( cp, rm e mv ),
no precisar digitar o flag i, pois ele j estar implicitamente incluso em
qualquer um deles, o flag i emite uma mensagem antes da execuo, de
fato, do comando em que utilizado; geralmente, um pedido de confirmao para que se execute tal comando. Para se desativar um alias, devemos usar o comando unalias mais o nome do alias. Caso esse alias esteja
configurado em um arquivo de inicializao de shell, o comando unalias o
desativar temporariamente, enquanto o sistema no for desligado.
Percebe-se, com o que foi visto at agora, que seriam necessrias muitas
horas para citar os possveis usos do comando alias. Entretanto, o funda-
mento e as utilidades desse incrvel comando ficou bem clara, e cabe ao

usurio utiliz-lo de acordo com sua imaginao e necessidade.
Como personalizar prompts

Muitos usurios no gostam dos prompts que o Unix oferece. Realmente,
alguns so bem grotescos e desagradveis de se trabalhar. mas, alguns
shells do Unix (a maioria deles), como o csh e o ksh, permitem ao usurio
configurar seu prprio prompt.
A linha de comando usado no Shell C para se definir o prompt set
prompt=valor, enquanto que no Shell Korn PS1=valor.
Logo a seguir, so relatados alguns exemplos de configurao de prompt
no Shell C e seus equivalentes no ksh:
1. O primeiro exemplo o mais simples de todos, pois o prompt configurado como sendo um texto qualquer digitado pelo usurio. Nesse caso,
o texto Ol, digite algo: .
% set prompt=Ol, digite algo:
Ol, digite algo: _
Seu equivalente no Shell Korn PS1=Ol, digite algo: .

2. Porm, h informaes mais teis para se colocar no prompt do que
apenas simples textos ou sinais. Um exemplo bem til seria utilizar a
varivel cwd, que informa o caminho do diretrio de trabalho atual:
% set prompt=cwd:
/users/fabio: _
Com isso, o prompt torna-se um pouco mais amigvel. Lembre-se

que, no Shell Korn a atribuio da varivel cwd ao prompt seria assim:
PS1=cwd.
3. Tambm se pode configurar o prompt para que ele informe o nmero do
comando atual. Veja como:
% set prompt=(\!)%
(202)% _
O equivalente em ksh PS1=(\!)$, sendo que o smbolo $ optativo e

s foi colocado por ser padro do Shell Korn.
37
38
4. Outra maneira de se fazer com que o prompt tenha uma utilidade maior
defini-lo de modo que ele informe o nome do computador atual, o
nome do diretrio de trabalho no momento e o nmero do comando
atual. Observe: (exemplo tirado do livro Aprenda em 24 horas Unix)
%set prompt= $system($cwd:t)(\!)%
limbo(taylor)(26)% _
A varivel cwd com a opo :t informa somente o nome do diretrio atual, e no seu caminho inteiro, diminuindo um pouco mais o tamanho do
prompt. No Shell Korn s trocaria set prompt por PS1.
Logo a seguir, so resumidos, numa tabela, os valores especiais para o
prompt do sistema (tabela retirada do livro Aprenda em 24 horas Unix):
Valor
Resultado
cwd
O diretrio de trabalho atual.
\!
O nmero do comando atual.
$var
O valor de var.
â^b
O final (ltima palavra) do valor de var.
O captulo 2 chega a seu fim. Ele se destinou a dar maiores informaes

sobre alguns recursos importantes dos Shells C e Korn, como os aliases
e histrico de comandos, por exemplo. Tendo em mos a forma de utilizar
tais recursos, o trabalho do usurio no Unix ser bastante facilitado.
ulo
t
ap
Programao de scripts de Shell
No captulo anterior, alguns fortes recursos do Shell C e do Shell Korn,

como o uso de aliases, do mecanismo de histrico de comandos e a definio de prompts personalizados, foram discutidos. Entretanto, para o uso
de todos eles precisa-se se escrever muitas linhas de comandos, o que
no muito agradvel, principalmente quando h muitos aliases ou variveis a serem definidas. nessa hora que os scripts de shell entram para
resolver tal problema. Estes nada mais so que arquivos que contm uma
srie de comandos de shell. Quando alteradas as permisses dos scripts
para inserir a permisso de execuo, eles agem como qualquer outro
comando do Unix.
Para se inserir a permisso de execuo a um arquivo script, basta digitar
a seguinte linha de comando:
% chmod 777 nome-do-arquivo
Para se criar programas-scripts, pode-se utilizar qualquer editor de texto

disponvel no Unix, como o vi, por exemplo.
O shell, no Unix, possui duas funes, que so: interpretar os comandos
de linha digitados pelo usurio e atuar como linguagem de programao
quando os comandos so inseridos num arquivo de lote (scripts).
Os shells mais utilizados do Unix para se desenvolver scripts so o Shell C,
Shell Bourne e o Shell Korn, pelo fato de terem mais recursos que outros.
Definindo variveis
A definio de uma varivel dentro dos scripts se d da mesma maneira
que se faz na linha de comando, ou seja, quando se atribui um valor qualquer a uma determinada palavra, esta se torna uma varivel (em alguns
casos dentro do script, porm, com o uso de certos comandos, a definio
de uma varivel se d com o uso de tais comandos, como por exemplo,
com o comando read, que ser visto mais frente). Por exemplo, no Shell
C, para se definir uma varivel, como j se sabe, usa-se a seguinte linha
de comando:
40
% set var=valor
No Shell Bourne seria var=valor (que tambm j foi explicado).

Portanto, nos scripts no necessria uma predefinio de variveis antes
de sua utilizao, a partir da primeira atribuio de valor ela j passa a
existir.
Exemplos:
set var_num=10
word=MUNDO
var_vetor=( um dois tres )
Outro modo comum de se fazer atribuio de variveis a partir de argumentos da linha de comando. O shell possui variveis especficas para
acess-la, as quais possuem a forma $?, sendo que? vai de 1 a 9. Observe
o exemplo a seguir, que j considera a existncia de um script de soma:
% script_soma 50 100
No exemplo acima, $1 igual a 50 e $2, a 100, num script supostamente

j criado para se somar nmeros.
Nota-se que no h dificuldade alguma em se criar variveis no Unix, seja
atravs da linha de comando ou dentro dos scripts, e isso uma grande
vantagem quando se est fazendo um programa-script, principalmente
quando ele for muito complexo.
Operadores
Dentro dos programas-scripts, pode se necessitar de determinadas operaes para se gerar um ou mais resultados, como fazer comparaes de
variveis, adicionar valores s variveis, etc.
Logo a seguir esto relacionados alguns operadores comumente usados
para escrever scripts de shell. Muitos deles j esto presentes em algumas
linguagens de programao.
Operadores de comparao usados pelo csh, sh e ksh (e suas variantes):
z-gt maior que
-lt menor que
-eq igual a
-o ou
Operadores de comparao usados somente pelo csh
!=
=
==
!
&&
!!
>
<
>=
<=
diferente
atribui valor
igual a
negao booleana
e booleano
ou booleano
maior que
menor que
maior igual
menor igual
Operadores para variveis inteiras

+
++
%
*
/
--
adio
subtrao
soma 1
mdulo
multiplicao
diviso
decrementa 1
Operadores para bits

>>
<<
~
!
|
^
&
deslocamento para a direita

deslocamento para a esquerda
complemento
negao lgica
ou inclusive
ou exclusivo
e
Operadores que testam caractersticas de um arquivo ou diretrio

-d
-e
-f
-o
-r
verdadeiro se o arquivo for um diretrio

verdadeiro se o arquivo existir
verdadeiro se o arquivo existe e regular ( texto )
verdadeiro se o usurio for o dono
verdadeiro se o arquivo pode ser lido pelo usurio
41
42
-w verdadeiro se o arquivo pode ser alterado pelo usurio

-x verdadeiro se o arquivo pode ser executado pelo usurio
-z verdadeiro se o arquivo estiver vazio
Entre esses operadores para arquivos e diretrios, os mais usados so os
flags f e d, sendo que os outros so usados em situaes extraordinrias.
Pode se ver que uma lista extensa de operadores, que possibilitam criar
diversos tipos de scripts, principalmente quando combinados com comandos de controle de fluxo, de loop e outros.
Comandos de controle de fluxo

Como o prprio nome j diz, os comandos de controle de fluxo controlam o
fluxo de execuo do programa, ou seja, geram sadas de acordo com as
entradas.
Em seguida, so explicados alguns desses comandos para se escrever
scripts.
if...fi
O if o controle de fluxo mais utilizado na programao de scripts, e tem a
seguinte forma:
if
bloco-de-comandos
then
bloco-de-comandos
fi
Um bloco-de-comandos uma sequncia de um ou mais comandos do

shell. O primeiro bloco ser sempre executado, e o segundo depender do
resultado do primeiro. Veja alguns exemplos, lembrando que o smbolo $
quer dizer valor de e o smbolo # significa que o que vem frente dele
um comentrio e no tem valor como parte da programao.
Exemplo 1:
var=10
if
[ $var -gt 0 ]
then
echo $var maior que zero
fi
# emite-se uma mensagem
Exemplo 2:
file=arquivo.txt
# file recebe o nome do arq. arquivo.txt
if
[ -f $file ]
then
echo $file um arquivo regular
fi
O exemplo 1 bem simples, no qual se utiliza o comando if para verificar

se a varivel var, que inicialmente vale 10, maior que zero e, se for, como
, no caso aqui apresentado, transmite a mensagem afirmativa. J no
exemplo 2, se o arquivo ( valor de file ) for regular, if informa ao usurio,
caso contrrio ele no exibe nada. Porm, isso pode ser mudado, fazendo
com que se exiba uma mensagem mesmo quando o arquivo no for regular, utilizando-se a palavra-chave else logo aps if:
file=$1
# file recebe o argumento 1 da linha de comando
if
[ -f $file ]
then
else
echo $file no um arquivo regular
fi
possvel ainda realizar-se mais de uma comparao, usando outra

palavra-chave, que elif:
file=$1
# file recebe o argumento 1 da linha de comando
if
[ -f $file ]
then
elif
[ -d $file ]
then
echo $file um diretrio
else
echo $file no um arquivo regular ou diretrio
fi
43
44
Nesse ltimo exemplo, if verifica se o arquivo regular e caso seja, emite

uma mensagem afirmando tal condio, seno, se o arquivo for, na verdade, um diretrio, a mensagem relativa a essa condio ser exibida,
e, finalmente, se o arquivo no for regular nem diretrio, uma mensagem
referindo-se a esse resultado que ser mostrada na tela.
Pode-se, ento, expandir qualquer instruo if para um nmero ilimitado
de ramificaes com elif.
case...esac
Quando se usa o if e nele h muitas ramificaes (elif), o cdigo ficar
um pouco confuso, e nesse momento que o uso do comando case se
encaixa. Observe sua sintaxe, que um pouco mais complicada que a do
comando if, mas ainda compreensvel:
case varivel in
padro 1) bloco-de-comandos;;
padro 2) bloco-de-comandos;;
...
esac
Caso estivesse procurando valores possveis para uma varivel, poderia

usar-se o case:
echo O que voc quer:
read var
# aguarda entrada de dados
case $var in
veiculo) echo O preo alto;;
casa) echo O preo muito alto;;
*) echo O preo desconhecido;;
esac
Nesse exemplo, case executado aps uma solicitao de entrada e d o

resultado (o preo no caso) de acordo com tal entrada. Essa lista poderia
ser bem maior caso o algoritmo precisasse.
goto
O comando goto desvia o fluxo de execuo para um ponto especfico
(label) de um script. Os nomes dos labels so sucedidos por dois pontos e
devem aparecer sozinhos na linha.
Esse comando muito usado em programas muito extensos, em que h a

necessidade de dividi-lo em vrios labels para melhor compreenso.
Observe o exemplo abaixo, com esse comando:
var=20
if
[ $var -gt 0 ]
then
echo $var maior que zero
goto resultado
else
echo $var no maior que zero
fi
# o label que o comando goto chama
resultado:
echo Resultado positivo !
exit
Nesse exemplo, if verifica se o valor de var maior que zero, se for,

emite-se uma mensagem e redireciona-se o fluxo de execuo para o label
resultado, que tambm exibir uma mensagem e terminar o programa
com o comando exit. S para esclarecer, o comando echo pode exibir
mensagens tanto sem aspas como entre aspas; o resultado ser sempre o
mesmo.
switch...endsw
O comando switch possui uma sintaxe semelhante do comando case,
s que em vez de executar um bloco de comandos, direciona o fluxo de
execuo para um label do script, sendo que esse label est relacionado
a uma determinada condio do switch. Dentro deste, existe o comando
breaksw, que direciona o controle para o comando seguinte, ao fim do
switch (endsw) . Caso no haja nenhum label correspondente condio
especificada, o controle transferido para o label default, se estiver definido, seno a execuo continua aps o comando endsw. Veja uma exemplo de script com o controle de fluxo switch a seguir:
Exemplo:
echo Opo 1 Somar
echo Opo 2 Sair
read varop
# aguarda entrada de dados para varop
45
46
switch($varop)
case 1:
soma
breaksw
case 2:
breaksw
default:
echo Digite opo vlida
endsw
exit
soma:
read varnum1
read varnum2
echo O valor da soma :
expr $varnum1 + $varnum2 # faz a soma das variveis
)
No exemplo dado, primeiramente se l a varivel varop. Logo aps, o comando switch avalia o valor de tal varivel. Caso seja 1, ser chamado o
label soma, que ir ler (atravs do comando read) duas variveis e fazer a
soma delas atravs do comando expr (que ser comentado mais frente).
Caso varop seja 2, o controle de execuo ser direcionado para o comando exit, e se varop no possuir nenhum dos dois valores, ser executado o
label default, o qual emitir uma mensagem de opo invlida.
Expresses de loop
De vez em quando, aparecem programas em que h a necessidade de
se executar vrias vezes um mesmo conjunto de comandos e, em vez de
escrev-los vrias vezes, utilizam-se os comandos de loop (ou de laos).
E na programao, em geral, h dois tipos de loop: o determinado e o
indeterminado.
Um loop determinado aquele em que se sabe o valor exato de quantas
vezes ir se executar os comandos, antes mesmo de se inseri-lo o loop. J
o indeterminado aquele em que necessrio se executar um conjunto de
comandos at que uma determinada condio no seja mais verdadeira.
Logo a seguir, sero explicados os comandos de loop mais usados nos
scripts de shell, que so o for...done e o while...done.
for...done
O comando voltado para um loop determinado nos scripts de shell o
comando for. Outras linguagens de programao (pelo menos a maioria
delas), possuem esse comando. Sua sintaxe para o uso em scripts tem a
seguinte forma:
for var-in-list
do
bloco-de-comandos
done
Nos scripts de shell, esse comando bastante utilizado para listas de arquivos, sendo bastante eficiente, pois essas listas, geralmente, so extensas. Veja um exemplo com o comando de loop for numa determinada lista
de arquivos de um diretrio:
Exemplo:
for var in ls
do
if
[ -f $var ]
then
echo $var um arquivo regular
fi
done
Nesse exemplo, a sada fornece uma lista com todos os arquivos regulares, sendo que var a varivel que ir ser usada dentro do loop e que ir
fornecer o nome de cada arquivo regular da lista. Vale observar que a lista
utilizada para se fazer tal pesquisa obtida de uma comando ls no diretrio corrente.
Se a parte in list for omitida do comando for, ele ir percorrer a lista de
argumentos da linha de comando. Veja o exemplo:
Exemplo:
j=0
for i # a varivel i definida dentro do lao for
do
j=expr $j + 1
# faz a soma de j=j+1
echo $i o argumento $j
done
47
48
Nesse ltimo exemplo, o comando for percorre os argumentos da linha de

comando e identifica a ordem em que eles esto, ou seja, fornece a descrio do argumento e seu nmero de ordem na linha de comando.
while...done
No item anterior, quando se usou o comando for, j se sabia o nmero de
vezes que um bloco de comandos seria executado. Mas, existem casos em
que se precisa executar blocos de comandos at que algo acontea, e a
que o comando while se encaixa. A sintaxe do comando while a seguinte:
while condio
do
bloco-de-comandos
done
Um exemplo de loop indeterminado quando se est esperando a chegada de um arquivo em seu diretrio, mas no se sabe quando poder
chegar. Esse arquivo pode ser enviado pelo servidor ou por outro usurio
que tenha permisso para gravar dados em sua rea.
Com o uso do loop while, pode-se resolver essa situao. Dentro da condio, aps o comando while, faz-se uma verificao se o primeiro arquivo
mais recente que o segundo; se for, aguarda-se mais 60 segundos e
faz-se outra verificao. O primeiro arquivo, nesse caso, seria um arquivo
qualquer de seu diretrio, que seria usado apenas como ponto de verificao com o segundo arquivo, aquele o arquivo que se est aguardando
chegar em seu diretrio. Para se fazer tal verificao, usa-se o flag nt,
que retorna verdadeiro se o primeiro arquivo for mais recente que o segundo. Veja como ficaria em termos de programao:
while
do
done
[ prog.c -nt arqcheg ]

sleep 60
# aguarda 60 segundos
Esse lao (loop) do programa, portanto, esperaria um minuto entre as

verificaes. Se o arquivo arqcheg ainda no estiver inserido no diretrio, o
programa esperar mais um minuto ainda.
Os loops while tambm podem ser usados de forma determinada, como o
comando for. Observe o exemplo a seguir:
Exemplo:
# este script conta de 20 a 1
var_num=20
while
[ $var_num -gt 0 ]
do
echo $var_num
expr $var_num 1
done
# subtrai 1 de var_num
Essa sequncia anterior ser executada 19 vezes, exibindo o valor da varivel var_num na tela enquanto tal varivel for maior que zero.
Outros comandos usados nos scripts

Na construo dos scripts, tambm so utilizados outros comandos auxiliares alm dos de controle de fluxo e os de loop. Tais comandos auxiliares
so to teis quanto os que foram explicados at aqui, pois so eles que
do o complemento aos comandos de fluxo e de loop. Os comandos auxiliares podem ser usados tanto nos scripts quanto em linhas de comandos.
Logo a seguir, sero explicados alguns deles.
clear
O comando clear limpa o contedo da tela e posiciona o cursor no canto
superior esquerdo do monitor. Ele um dos comandos mais usados nos
scripts, principalmente no incio de cada um, pois assim, a tela anterior
apagada e s o resultado do script exibido.
echo
O comando echo, que j foi explicado e muito usado anteriormente, exibe
strings ou contedo de variveis de memria na tela. Quando for exibir o
contedo de variveis, utiliza-se o smbolo $ antes delas. O comando echo
exibe strings ou contedo de variveis tanto entre aspas como sem aspas.
Veja exemplos:
Exemplos:
49
50
1)
echo $variavel
ou
echo $variavel
2)
echo Isto um teste
ou
echo Isto um teste
O comando echo tambm possui alguns parmetros importantes:

-n
\\b
\\f
\\n
\\r
\\t
no gera avano de linha aps exibio

retrocesso
alimentao de pgina
avano de linha (default)
carriage return (retorno do carro de impresso da impressora)
tabulao
exit
O comando exit abandona o fluxo do script, ou seja, ele quebra a sequncia de execuo de script e retorna ao sistema operacional. Todo final de
script deve possuir esse comando.
Quando usado diretamente na linha de comando, ele faz a desconexo do
terminal com o servidor ou, se o usurio estiver usando um subshell, ele
retorna ao shell de login.
expr
O comando expr, que tambm foi muito usado anteriormente, tem como
funo executar uma operao aritmtica numa varivel de memria ou
diretamente em nmeros fornecidos pelo usurio.
Abaixo esto listados dois exemplos, sendo que o primeiro executado a
partir da linha de comando e o segundo, dentro de um script qualquer:
Exemplos:
1)
$ expr 3 + 2
5
$_
2)
# script de subtrao
var=10
expr $var 5
Operaes possveis com expr:

+
\*
%
\
adio
multiplicao
resto
subtrao
diviso
read
Antes de mais nada, a sintaxe do comando read a seguinte:
read nome-da-varivel
O comando read fica aguardando uma entrada de dados pelo usurio e,

logo aps, atribui o valor dessa entrada varivel especificada.
Esse tambm foi um comando que se utilizou anteriormente. Veja mais um
exemplo dele:
Exemplo:
# script que aguarda a entrada de uma expresso e
# verifica se igual a palavra acertou
echo Digite algo:
read algo
if
[ $algo = acertou ]
then
echo Voc acertou a palavra!
else
echo Voc errou a palavra!
fi
exit
51
52
A varivel que ser usada como parmetro do comando read no precisa

ser definida anteriormente, pois ela receber um valor s quando for feita
uma entrada de dados e a, ir possuir uma definio completa, como no
exemplo que foi dado, no qual a varivel algo no possui uma definio
anterior, mas aguarda uma entrada de dados e depois efetua uma comparao para ver se igual palavra acertou ou no.
sleep
A sintaxe do comando sleep a seguinte:
sleep numero-de-segundos
Esse comando aguarda um determinado tempo em segundos para continuar a execuo normal do script (ou de comandos, caso seja utilizado
a partir da linha de comando). Para quem se lembra, ele foi utilizado no
exemplo da expresso de loop while...done,em que se aguardava intervalos de 60 segundos para a gravao de um arquivo no diretrio do usurio.
E, com a explicao desse ltimo comando, chega-se ao final do captulo
3, que tratou da programao bsica para shell ( vlida tanto para o Shell
C, Shell Bourne, Shell Korn e as variantes desses trs ). Foram tratados e
explicados alguns comandos teis para a programao de scripts, como
os de controle de fluxo (if...fi, goto, etc.), os de loop (for...done, while...
done) e outros auxiliares (clear, exit, expr, etc.), alm do uso de operadores e tratamento de variveis. O principal objetivo desse captulo no foi
mostrar como ser um extraordinrio programador de scripts, mas sim, explicar a finalidade e os fundamentos bsicos de como se trabalhar e utilizar
corretamente os scripts de shell.
ulo
t
ap
Controle de Servio
J foi dito, anteriormente, que o Unix um sistema operacional multitarefa,

o que quer dizer que ele pode executar mais de um programa ao mesmo
tempo. Um programa em execuo no Unix denominado processo (ou
servio). Mais precisamente, o sistema s pode executar um programa em
um dado instante, entretanto, ele muda to rapidamente de um processo
para outro que, na maioria das vezes, parece que tudo executado ao
mesmo tempo. Quando o sistema estiver sendo usado por muitos usurios ou estiver com a carga pesada por alguma outra razo, os programas
parecero demorar mais do que o normal para serem executados, e, nesse
momento, entram os comandos de controle de servio. Vale ressaltar que
tanto o Shell C quanto o Shell Korn possuem tais comandos, alm de suas
variantes.
Com os comandos de controle de servio possvel suspender programas
em execuo e depois reinici-los; colocar programas para serem executados no segundo plano, enquanto se executam outros no primeiro; chamar programas do segundo para o primeiro plano ou mesmo encerr-los.
Enfim, uma srie de controles que facilitam a vida do usurio.
Interrompendo servios
Como j foi dito, no Unix, qualquer programa que esteja sendo executado
se constitui num processo. No Shell C e no Shell Korn, os processos so
conhecidos tambm como servios, e o programa executado no momento
conhecido como servio atual.
Tanto no Shell C quanto no Shell Korn (ou mesmo nas variantes destes),
para se interromper um processo (ou servio) em execuo, deve-se
pressionar ^z (control + z). Para reiniciar o processo novamente, utiliza-se
o comando fg.
Esse tipo de controle de servio , geralmente, usado para comandos que
geram sadas muito longas, como ls (listar o contedo dos diretrios), cat
(exibem o contedo de um arquivo) e man (exibir uma documentao de
ajuda do comando especificado), alm de outros.
54
Em seguida, transcrito um exemplo de comando em que a sada muito

longa. Esse comando o man, que, neste caso, ir mostrar a documentao do comando ls.
Exemplo:
% man ls
LS(1)
LS(1)
NAME
ls, dir, vdir - list contents of directories
SYNOPSIS
ls [-abcdfgiklmnpqrstuxABCFGLNQRSUX1] [-w cols] [-T cols]
[-I pattern] [--all] [--escape] [--directory] [--inode]
[--kilobytes] [--numeric-uid-gid] [--no-group] [--hidecontrol-chars] [--reverse] [--size] [--width=cols] [--tabsize=cols] [--almost-all] [--ignore-backups] [--classify]
[--file-type] [--full-time] [--ignore=pattern] [--dereference] [--literal] [--quote-name] [--recursive]
[--sort={none,time,size,extension}] [--format={long,verbose,commas,across,vertical,single-column}]
[--time={atime,access,use,ctime,status}] [--help] [--version] [--color[={yes,no,tty}]] [--colour[={yes,no,tty}]]
[name...]
DESCRIPTION
This documentation is no longer being maintained and may
--More-- _
No exemplo dado, observa-se que h mais informaes a serem fornecidas sobre o comando ls, pois aparece a palavra more no final da tela (em
alguns sistemas pode aparecer: em vez da palavra more), e no END, que
indica o final da documentao de um comando. Sendo assim, se o usurio quiser terminar a execuo, ele pode pressionar q, e o programa man
ser finalizado, mas, se ao invs disso, ele preferir interromp-lo temporariamente e ver o restante da documentao de ls num outro momento,
pode pressionar ^z. Veja o que acontecer:
% man ls
LS(1)
LS(1)
NAME
SYNOPSIS

[name...]
DESCRIPTION
--More-- _
Stopped
A palavra Stopped (interrompido) exibida aps o usurio ter interrompido

a execuo do programa. Alguns sistemas podem exibir outras mensagens
ou no exibir nada, mas a interrupo do programa ser feita em todos.
Em seguida, o usurio poder executar outros comandos, se desejar.
Quando ele resolver olhar o restante da sada do comando man, interrompido com ^z, poder, ento, usar o comando fg, que retornar ao ponto
em que o programa foi suspenso.
% fg
man ls
LS(1)
LS(1)
NAME
SYNOPSIS
[name...]
55
56
DESCRIPTION
--More-- _
A sada a mesma que a anterior, isso porque foi o ponto em que o comando man foi interrompido, e a partir do qual poder continuar. O nome
do comando fg uma abreviao para foreground, que quer dizer primeiro
plano, sendo que primeiro plano uma referncia ao programa com o qual
o monitor e o teclado esto trabalhando.
Primeiro plano / segundo plano

s vezes, o usurio tem que utilizar programas que possuem um tempo
de execuo um pouco extenso, se for necessrio realizar outras tarefas
simultaneamente, pode-se interferir nesse execuo. Entretanto, ele pode
chamar um programa para ser executado no segundo plano (background),
enquanto se utiliza de outros comandos no primeiro plano (foreground).
A grande vantagem de se rodar programas no segundo plano que, ao
contrrio dos processos no primeiro plano, os processos do segundo plano
no precisam que sua execuo seja encerrada para que outro processo
possa ser iniciado. Logo aps ter inserido um processo no segundo plano,
o shell em execuo exibir o prompt para sinalizar que se pode chamar
um outro comando no plano principal (ou mesmo no segundo plano, novamente).
Antes de se explicar como executar programas em segundo plano, importante ressaltar alguns pontos sobre o funcionamento desse recurso. Um
deles o fato de que o Unix, embora permita executar mais de um processo no segundo plano, possui um limite de execues em background, que
, geralmente, entre 20 e 50 por usurio e entre 100 e 250 para o sistema
todo. Outro ponto importante que, quanto mais processos estiverem
sendo executados em segundo plano, mais lento o sistema ficar, fazendo
com que o tempo consumido seja igual ao da sua execuo em primeiro
plano. Um ltimo ponto sobre as sadas que os processos em segundo
plano, quando encerrados, fornecem. Elas, geralmente, aparecem misturadas na tela com as sadas de processos executados no plano principal e
at de outros processos em segundo plano. Dessa forma, pode-se evitar
tal problema redirecionando as sadas dos processos em segundo plano

para arquivos em disco. Para se fazer isso, utiliza-se sinal de maior ( > )
mais o nome do arquivo para o qual a sada ser enviada. Um exemplo de
como se fazer redirecionamento dado abaixo:
Exemplo:
% ls > saida.txt
importante observar, tambm, que no se deve iniciar um processo no

segundo plano que leia a entrada do teclado, isso porque, quando se estiver utilizando um programa no plano principal que tambm requeira entrada do teclado, haver conflitos entre os dois processos.
Sendo assim, existem duas formas para se chamar programas em segundo plano: uma pode ser feita diretamente, ou seja, desde o incio de sua
execuo e outra a partir do ponto em que um programa foi interrompido
( ^z ).
Para se iniciar um programa em segundo plano, basta digitar o smbolo &
no final da linha de comando. Com isso, o Unix ir gerenci-lo desde o seu
incio at seu fim. Como exemplo, pode-se utilizar o comando du, executado no segundo plano para se verificar o espao total em disco:
Exemplo:
% du s / > arq.du &
290
%_
O nmero que foi mostrado como sada nada mais que o nmero do
processo (no o espao usado do disco) que est sendo executado
e, que nesse caso, 290. A opo s do comando du faz com que ele
exiba apenas o total usado em disco e no o espao ocupado por cada
arquivo e diretrio tambm. J a barra ( / ) faz com que ele pesquise o
disco todo.
Alguns sistemas podem exibir, alm do nmero do processo, o nmero do
controle de servio, que o nmero de ordem dos comandos de controle
de servio. Veja:
Exemplo:
% du s / > arq.du &
[1] 290
%_
57
58
O nmero do controle de servio o que est entre colchetes e que, neste

caso, 1. Tanto o nmero do processo quanto o nmero do controle de
servio so importantes para a explicao dos comandos restantes. Para
se saber, ento, o espao em disco ocupado, s consultar o arquivo arq.
du depois de um certo tempo, logo aps du ter sido executado em segundo plano. Observe:
% cat arq.du
26106
%_
Com o uso do comando cat para observar o contedo do arquivo arq.du,

pde-se obter o total de 26106 kilobytes usados em disco.
Existe tambm a possibilidade de se continuar a execuo em segundo
plano de programas interrompidos com ^z. Em vez de cham-los para o
primeiro plano com o comando fg, utiliza-se o comando bg (background)
para envi-lo para o segundo plano e dar continuidade a sua execuo.
O mesmo exemplo da linha de comando anterior pode ser usado, s que
sem o smbolo & no final da linha:
Exemplo:
% du s / > arq.du
Stopped
%_
Nota-se que o processo foi interrompido com ^z, pois a palavra Stopped
exibida logo abaixo da linha de comando. J se sabe que, para se trazer
esse processo para ser executado no plano principal, utiliza-se o comando
fg, mas tambm foi dito como lev-lo para o segundo plano, que usando
o comando bg. Veja o exemplo abaixo:
Exemplo:
% bg
[2] du s / > arq.du
%_
Pelo exemplo, pode se ver que o comando bg exibe, como sada, o nmero do controle de servio entre colchetes (n 2) mais a linha de comando
que foi interrompida e ser executada em segundo plano. Em alguns sistemas esse nmero de controle de servio pode ser trocado pelo nmero do
processo.
importante ressaltar que, at por uma questo de simplicidade, o

artifcio de se executar programas interrompidos em segundo plano
menos usado que o de se executar programas desde o incio em segundo plano.
Obtendo informaes sobre as tarefas que esto

sendo executadas
Agora que j foi visto como interromper processos e execut-los em primeiro ou segundo plano, ser, ento, explicado como se obter informaes
sobre eles. Para se fazer isso, utiliza-se do comando ps ou do comando
jobs, cujas sadas informam sobre o estado dos processos, mas somente
dos que esto em segundo plano ou interrompidos.
O primeiro a ser explicado ser o comando ps, mas, antes de tudo, sero
fornecidos alguns exemplos de processos para que possam ser utilizados
tanto na explicao de ps quanto na de jobs. O primeiro exemplo ser de
um comando executado e interrompido em seguida, o segundo ser de um
comando executado no plano principal, e o terceiro, de um comando sendo
executado em segundo plano.
Exemplo 1: ( J usado anteriormente )
% man ls
LS(1)
LS(1)
NAME
SYNOPSIS
[name...]
59
60
DESCRIPTION
--More-- _
Stopped
%_
Exemplo 2:
% cat prog.c
#include <stdio.h>
main()
{
int i;

for ( i=0; i<=4; i++ )

printf(Nmero: %d, i+1);
return;
}
%_
Exemplo 3: ( Tambm j usado anteriormente )

% du s / > arq.du &
[2] 660
%_
Considerando-se os exemplos dados, pode-se, ento, utilizar o ps:

% ps
PID TTY STAT TIME COMMAND
639 P0
S
0:00 csh
652 P0
T
0:00 man ls
660 P0
R
0:04 du s /
667 P0
R
0:00 ps
Observa-se que a sada s mostrou dados do comando interrompido e

do que est sendo executado em segundo plano, alm do nome do shell
em execuo ( csh ) e o nome do prprio comando ps, que acabou de ser
utilizado. Sobre o comando cat, do exemplo 2, no foi exibido nenhuma
informao, isto porque ele foi executado normalmente, isto , em primeiro
plano.
O significado de cada campo da sada de ps explicado abaixo:
PID: nmero do processo
TTY: nmero do terminal
STAT: o estado atual do processo
TIME: tempo efetivo de execuo do processo em minutos e segundos

COMMAND: nome do comando (ou parte da linha de comando)
O campo STAT, seus possveis valores e seus respectivos estados so
listados na tabela seguinte:
Possveis valores de status do processo ( STAT )
Valor
Significado
Executando
Dormindo (20 segundos ou menos)
Inativo (dormindo mais de 20 segundos)
Interrompido
Fonte: Taylor, Armstrone Junior, 1998.
No exemplo dado do comando ps, o estado do processo nmero 639

(Shell csh) dormindo, ou seja, est a 20 segundos ou menos sem ser
executado, mas no est interrompido. Caso ele tenha que interpretar um
comando, por exemplo, voltar ao estado executando, mas, rapidamente, retornar ao estado dormindo. O processo 667 (o prprio comando
ps) est no estado executando, pois quando a sada foi listada, ps ainda
estava sendo executado. J o processo de PID 652 (man ls) est como
interrompido, como realmente deveria estar, enquanto que o do comando
du ( PID 660 ) est como executando, como tambm deveria estar, e o
tempo de execuo dele j chegou a 4 segundos. Caso seja digitado ps,
novamente, mais o nmero de processo relativo ao comando du (660,
neste caso), ser exibido um tempo de execuo maior, isto porque sua
execuo ainda est em progresso. Veja:
% ps 660
660 P0
R
0:10 du s /
%_
O tempo passado de execuo do comando du, agora, equivalente a 10

segundos. Quando sua execuo estiver terminada, a sada ser a seguinte:
% ps 660
%_
61
62
A sada no mostrou nada, pois o processo j foi encerrado. Com isso, se

for listar o contedo do arquivo arq.du (cat), ser exibido o resultado de
todo o processo, ou seja, o espao usado em disco.
Como j se pde notar, o comando ps no exibe o nmero do controle de
servio. Somente o nmero do processo listado.
O comando jobs, ao contrrio de ps, exibe o nmero do controle de servio no lugar do nmero do processo. Esse comando fornece uma sada
um pouco mais resumida do que o ps, mas com informaes suficientes
para se saber o estado de um processo. A sada de jobs para os exemplos
dados a seguinte:
% jobs
[1] + Stopped
[2] - Running
man ls
du s / > arq.du
A sada mostra os respectivos nmeros (entre colchetes) de controle de

servio das linhas de comandos man ls e du s / > arq.du, observando
que eles obedecem ordem de execuo. Tambm mostrado o estado
em que cada processo est, sendo que o primeiro est interrompido e o
segundo est em execuo no segundo plano.
Outro fato que merece ser comentado neste momento, aps a explicao de ps e jobs, o de que, tanto o comando fg quanto o bg, tambm
possuem parmetros, ou seja, existe uma forma de execut-los sem ser
sozinhos. Esses parmetros podem ser o nmero relativo ao processo
ou o nmero do controle de servio, sendo que este ltimo necessita ser
especificado junto ao smbolo % antes dele. No caso de existirem vrios
processos interrompidos ou em segundo plano, o uso de parmetros para
fg ou bg bastante til e, utilizando-se os comandos ps ou jobs, possvel visualizar tais parmetros.
Exemplo 1: ( Utilizando o ps )
% ps
639 P0
S
0:00 csh
652 P0
T
0:00 man ls
660 P0
R
0:04 du s /
667 P0
R
0:00 ps
% fg 652
man ls
LS(1)
LS(1)
NAME
SYNOPSIS
[name...]
DESCRIPTION
--More-- _
% fg 660
du s / > arq.du
Depois s verificar o contedo

do arquivo arq.du com cat
Exemplo 2: ( Utilizando o jobs )

% jobs
[1] + Stopped
[2] - Running
% fg %1
% fg %2
man ls
du s / > arq.du
mesma sada que o fg 652
mesma sada que o fg 660
Terminando processos
Nos itens anteriores, foi explicado como trabalhar com processos interrompidos e em segundo plano e tambm como visualizar o estado em que
estavam. Neste item, ser abordado um comando para finalizar tais processos, ou seja, interromp-los definitivamente. Esse comando o kill, e
sua sintaxe bem simples:
kill numero-do-processo
ou
kill %numero-do-controle-de-servio
63
64
A necessidade de se utilizar esse comando pode aparecer em diversas situaes, como no caso do usurio descobrir que um processo, em segundo plano, no est sendo executado corretamente ou no caso do sistema
estar muito lento, por existir muitos processos interrompidos e outros em
segundo plano.
Observe um exemplo simples abaixo, em que criado um processo em
segundo plano e depois ele terminado:
Exemplo:
% man sort > sort.txt &
[1] 450
% kill 450
%_
ou
% kill %1
%_
Nesse exemplo, pedido ao comando man para fornecer uma documentao do comando sort, com a sada redirecionada para o arquivo sort.txt,
sendo todo processo executado em segundo plano. Feito isso, exibido o
nmero do controle de servio mais o nmero do processo (lembrando que
alguns sistemas podem listar somente o nmero do processo). Logo aps,
utiliza-se o comando kill para encerrar tal processo e, como parmetro,
pode ser passado tanto o nmero do controle de servio (com o sinal %
acompanhado) quanto o nmero do processo, que, nesse caso so, respectivamente, 1 e 450. Em alguns sistemas seria mostrada a mensagem
450:Terminated (450 Terminado), mas em outros, nenhuma mensagem
exibida, devendo-se, ento, usar os comandos ps ou jobs para saber
se o processo realmente foi terminado. Usando o ps para verificar se os
processos anteriores foram encerrados, obtm-se:
% ps
405 P0
S
0:00 csh
700 P0
R
0:00 ps
Pela sada de ps, pode-se confirmar que o processo realmente foi encerrado.
possvel, tambm, ocorrer a necessidade do usurio querer se lembrar
do nmero do processo ou do controle de servio para finalizar um deter-
minado processo (interrompido ou em segundo plano). Ocorrendo, ento,

tal necessidade, ele pode utilizar o comando ps ou o comando jobs para
se lembrar do nmero do processo ou de controle, respectivamente. Veja
exemplos a seguir, os quais se utilizam dos exemplos de ps e jobs do item
anterior:
Exemplos:
1. Pega a sada de ps e encerra um processo interrompido e outro em
segundo plano:
% ps
639 P0
S
0:00 csh
652 P0
T
0:00 man ls
660 P0
R
0:04 du s /
667 P0
R
0:00 ps
% kill 652 660
%_
Verifica-se, ento, a sada de ps:

% ps
639 P0
S
0:00 csh
667 P0
R
0:00 ps
%_
Os processos foram, definitivamente, encerrados.

2. Utiliza-se, agora, a sada de jobs para encerrar os processos determinados:
% jobs
[1] + Stopped
[2] - Running
% kill %1 %2
%_
man ls
du s / > arq.du
Verificando-se a sada de jobs novamente:

% jobs
%_
Como no foi exibido nada, conclui-se que no h nenhum processo

interrompido ou em segundo plano, portanto, o comando kill finalizou os
processos especificados.
65
66
O captulo 4 est, por aqui, finalizado. Nele foi discutido sobre um dos melhores recursos do Unix, que o controle de servio, presente nos shells
C e Korn, alm de algumas variantes destes e em shells mais recentes.
Com os comandos de controle de servio, como foi explicado, possvel
se interromper a execuo de comandos (processos), inserir processos em
segundo plano, visualizar os estados dos processos ou mesmo encerrar
processos interrompidos ou em segundo plano.
Concluso
A estrutura do sistema operacional Unix dividida em 3 partes: o Kernel,
o Shell e os Utilitrios. A nfase deste trabalho dada ao Shell, que o
interpretador de comandos do Unix.
No Unix existem vrios shells, sendo que cada um deles possui caractersticas pertinentes e que os diferem uns dos outros. No obstante, um shell
tambm pode ter caractersticas que outros shells possuem. Os shells
mais importantes do Unix so o Shell C (csh), Shell Bourne (sh) e o Shell
Korn (ksh). Para se identificar o shell em uso, pode-se utilizar vrias tcnicas, sendo que uma delas a linha de comando ps | grep $$. J para se
mudar o shell de login, ou seja, o shell padro de quando se inicia o sistema, digita-se o comando chsh. No caso do usurio querer apenas alterar,
momentaneamente, de um shell para outro, digita-se somente o nome do
novo shell. Os shells do Unix, como o csh e o sh, tambm possuem variveis que servem para configurar o ambiente com o qual eles iro trabalhar,
alm de permitir a criao e a definio de outras pelo usurio. Essas variveis tambm podem ser inseridas nos arquivos de inicializao de shell,
nos quais pode-se estabelecer um ambiente inicial toda vez que se entrar
no sistema.
Alguns shells, como os Shells C e Korn possuem alguns recursos interessantes em relao aos outros shells. Esses recursos so: o mecanismo
de histrico de comandos, os aliases de comandos e a configurao de
prompts personalizados. Com o mecanismo de histrico de comandos,
possvel se lembrar de um programa anteriormente usado no sistema,
digitando-se apenas alguns comandos curtos. Entre esses comandos est
o !!, que executa o ltimo programa utilizado. No entanto, no csh, para que
esse mecanismo funcione bem, preciso, antes, que a varivel history
esteja definida com o nmero de comandos que devero ser lembrados
para uma eventual execuo de um comando de histrico. Com os aliases
possvel dar pseudnimos a comandos (ou sequncia de comandos)
que oferecem uma certa dificuldade para o usurio, seja essa dificuldade
de digitao ou de execuo. Com esse recurso, pode-se dar nomes bem
curtos para linhas de comandos muito extensas. J o recurso de configurao de prompts permite ao usurio configurar o prompt de acordo com sua
67
68
vontade, possibilitando a insero de textos, visualizao do diretrio de

trabalho atual e nmero do processo atual. Esse recurso de grande utilidade, pois a maioria dos sistemas Unix possuem prompts nada amigveis.
O Unix tambm permite a construo de programas que contenham
comandos de shell, chamados de scripts de shell. Aqueles mais utilizados para se escrever scripts so o Shell C, Shell Bourne e Shell Korn.
Com esses scripts, possvel solucionar vrios problemas com os quais
o usurio pode se deparar durante seu trabalho no Unix. Dentro desses
scripts pode-se colocar, alm dos comandos usuais do shell, comandos
de controle de fluxo, como o if...fi, e os comandos de loop, como o for...
done. Tambm so utilizados alguns comandos auxiliares para incrementar ainda mais esses scripts, como o expr, por exemplo, que faz clculos
aritmticos. Tais comandos auxiliares tambm podem ser usados em
linhas de comandos.
Como j foi dito, o Unix um sistema operacional multitarefa, isto , pode
executar vrios programas ao mesmo tempo. Na verdade, ele executa
uma tarefa de cada vez, mas, com a rapidez com que ele as executa temse a impresso de que tudo est sendo processado no mesmo momento.
No Shell C e Korn, um programa em execuo denominado processo
ou servio. Esses processos podem ser executados tanto no plano principal (primeiro plano) quanto no segundo plano. possvel, ento,utilizar
programas no primeiro plano enquanto outros esto sendo executados
em segundo plano, agilizando um pouco mais o trabalho do usurio. H a
possibilidade, tambm, de se interromper processos e reinici-los, seja em
primeiro ou em segundo plano (comandos fg e bg, respectivamente), alm
de poder visualizar os processos em execuo e aqueles interrompidos
(comandos ps e jobs) e encerrar processos com o comando kill.
Considerando-se o que foi explicado, conclui-se que a possibilidade que o
Unix oferece de se trabalhar com diversos shells, facilita, de forma significativa, o trabalho de um usurio, principalmente quando se necessita
utilizar um recurso presente somente em um shell diferente do que est
sendo usado. Outro ponto importante o fato de que alguns shells no
agem apenas como simples interpretadores de comandos, mas tambm
como linguagens de programao, possibilitando ao usurio construir seus
prprios programas e utiliz-los como sendo comandos normais.
Por isso, alm de outras razes, que o sistema operacional Unix ainda
est bem difundido entre empresas, instituies e profissionais de infor-
mtica em geral, e com uma tendncia ainda maior de se perdurar por um

bom tempo no mundo da informtica. Para quem nunca teve oportunidade
de us-lo, vale a pena tentar, pois, afinal, o Unix no apenas um poderoso sistema operacional; ele faz parte da histria da informtica.
Referncias
TAYLOR, D.; ARMSTRONG JNIOR, J.C. Aprenda em 24 horas UNIX. Rio de Janeiro : Ed.
Campus, 1998. 672 p.
Literatura recomendada
ABRAHAMS, P.W.; LARSON, B.R. Unix for the impatient. 2nd ed. Reading : Addison-Wesley,
1996. 824 p.
ANUNCIAO, H. Unix para redes brasileiras. So Paulo : Ed. rica, 1997. 196 p.
BOURNE, S.R. The Unix System V environment. Wokingham : Addison-Wesley, 1987. 378 p.
THOMAS, R.; YATES, J. Unix total. So Paulo : Ed. McGraw-Hill, 1988. 744 p.
69

Unix Embrapa

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Unix Embrapa

Uploaded by

Copyright:

Available Formats

ISSN 1677-9274

Shells do Unix: Tutorial

Embrapa Informtica Agropecuria

Embrapa Informtica Agropecuria

69 p. : il. - (Documentos / Embrapa Informtica Agropecuria, ISSN 1677-9274 ; 99).

1. Unix. 2. Sistema operacional. 3. Programao. I. Ttulo. II. Srie.

Fbio Danilo Vieira

Os Shells disponveis no Unix.................................................................. 11

Arquivos de inicializao do Shell............................................................25

Outros comandos usados nos scripts......................................................49

Shells do Unix: Tutorial

Shell: Interpretador de Comandos

A estrutura do Sistema Unix

Figura 1. Componentes do sistema Unix.

Embrapa Informtica Agropecuria. Documentos, 99

Em seguida, sero explicadas todas as partes da estrutura do sistema

Shells do Unix: tutorial

Os Shells disponveis no Unix

Embrapa Informtica Agropecuria. Documentos, 99

usando no quiser trabalhar com a interface padro, poder optar pelo

Shells do Unix: tutorial

Aliases de comando: possibilitam aos usurios renomear e reconfigurar

Embrapa Informtica Agropecuria. Documentos, 99

O Shell tcsh (verso modificada do Shell C)

Novas variveis de ambiente:

O smbolo $ significa valor de e o comando echo exibe o valor de uma

Shells do Unix: tutorial

O Shell Bourne-Again - bash

Outros Shells do Unix

Embrapa Informtica Agropecuria. Documentos, 99

Veja no exemplo que os 8 ltimos usurios do arquivo etc/passwd tm

O comando ps exibe o que o sistema operacional est executando no

Shells do Unix: tutorial

Nesse exemplo, o comando awk verifica se o primeiro campo do arquivo

Escolhendo um novo Shell

Embrapa Informtica Agropecuria. Documentos, 99

1997 /bin/bsh -> ash*

Pode-se notar que h uma entrada em /bin/bsh e em /bin/sh para os shells

Jul 26 14:46 /usr/local/ksh->bin/ksh*

Evidentemente que podem existir outros shells no sistema, mas isso no

Nesse exemplo, o programa indica que bin/bash o shell de login e pede

O comando chsh no aceita essa mudana porque ele verifica no arquivo /

Shells do Unix: tutorial

Pode-se notar que a alterao obteve sucesso, isso porque o Unix no

Embrapa Informtica Agropecuria. Documentos, 99

que algumas? Porque ele no procura no ambiente certas variveis, e sim

Nesses casos, variavel o nome da varivel, e valor pode ser tanto um

Shells do Unix: tutorial

A varivel usuario definida como sendo Jose da Silva. A varivel do

Apesar de se ter definido usuario, PATH, arq1 e arq2 como variveis do

Embrapa Informtica Agropecuria. Documentos, 99

fornecem uma maneira de se passar informaes globais para qualquer

Observe que foram colocados dois comandos na mesma linha, separados

Como exemplo, tambm ir se redefinir o prompt do Shell C:

Shells do Unix: tutorial

figurao do prompt nem sempre a maneira mais confivel de se fazer

Embrapa Informtica Agropecuria. Documentos, 99

LOGNAME: a identificao do usurio que est executando o shell.

No Shell C a definio e a colocao de uma varivel no ambiente se d em

Shells do Unix: tutorial

Arquivos de inicializao do Shell

Embrapa Informtica Agropecuria. Documentos, 99

Existem tambm alguns comandos optativos que podem ser inseridos no

Shells do Unix: tutorial