O Linux tem uma estrutura de diretórios e arquivos similar à do DOS/Win. Arquivos têm nomes-de-arquivo que obedecem a regras especiais, são gravados em diretórios, alguns são executáveis, e a maioria destes tem opções de linha de comando. Além disso, você pode usar caracteres coringa, redirecionamento e canalização. Há apenas algumas pequenas diferenças:
INSUFICI.TXT. No Linux, podemos fazer de um jeito melhor. Se você
instalou o Linux usando um sistema de arquivos como o ext2 ou umsdos, você
pode usar nomes-de-arquivo mais longos (até 255 caracteres), e com mais de
um ponto: por exemplo,
Este_eh.um.nome_de_arquivo.MUITO.longo. Observe que eu usei tanto
caracteres maiúsculos como minúsculos: de fato...
NOMEARQ.tar.gz e nomearq.tar.gz são dois
arquivos diferentes. ls é um comando, LS é um erro;
$ # o seguinte comando cria um diretório chamado "Meus arquivos antigos"
$ mkdir "Meus arquivos antigos"
$ ls
Meus arquivos antigos bin tmp
!*$&.
*' ao final do nome quando você executa o comando
ls -F comando. Por exemplo:
$ ls -F
Eu_sou_um_dir/ cindy.jpg cjpg* letter_to_Joe meu_script* old~
cjpg* e meu_script* são executáveis, isto é,
"programas". No DOS, nomes de arquivos de backup terminam em .BAK,
enquanto no Linux terminam com um til. Além disso, um arquivo cujo nome
comece com um ponto é considerado oculto. Exemplo: o arquivo
.Eu.sou.um.arquivo.oculto não aparece na saída de um comando
ls;
/opção no DOS;
no Linux se usa -opção ou --opção. Exemplo: dir /s
vira ls -R. Observe que muitos programas DOS, como PKZIP e
ARJ, usam opções ao estilo UNIX.
Agora você pode pular para a Seção Traduzindo Comandos do DOS para o Linux, mas, se eu fosse você, continuaria lendo.
O Unix tem um tipo de arquivo que não existe no DOS: a ligação simbólica.
Isto pode ser considerado como um ponteiro para um arquivo ou diretório, e
pode ser usado ao invés do arquivo para o qual aponta; é similar aos
atalhos do Windows 95. Exemplos de ligações simbólicas são
/usr/X11, que aponta para /usr/X11R6;
/dev/modem, que aponta para /dev/cua0 or
/dev/cua1.
Para fazer uma ligação simbólica:
$ ln -s <arq_ou_dir> <nomedaligação>
Exemplo:
$ ln -s /usr/doc/g77/DOC g77manual.txt
Agora você pode se referir a g77manual.txt ao invés de /usr/doc/g77/DOC.
As ligações simbólicas aparecem assim em listagens de diretório:
$ ls -F
g77manual.txt@
$ ls -l
(várias coisas...) g77manual.txt -> /usr/doc/g77/DOC
No DOS, arquivos e diretórios têm os seguintes atributos: A (arquivo), H (oculto), R (somente-para-leitura), e S (sistema). Somente H e R fazem sentido no Linux: arquivos ocultos começam com um ponto, e quanto ao atributo R, siga em frente.
No Unix, cada arquivo tem "permissões" e um dono, que por sua vez pertence a um "grupo". Veja este exemplo:
$ ls -l /bin/ls
-rwxr-xr-x 1 root bin 27281 Aug 15 1995 /bin/ls*
O primeiro campo contém as permissões do arquivo /bin/ls, que
pertence ao root, grupo bin. Deixando as informações restantes de lado,
lembre-se que -rwxr-xr-x significa, da esquerda para a direita:
- é o tipo de arquivo (- = arquivo normal, d = diretório, l = ligação, etc);
rwx são as permissões para o dono do arquivo ("read, write,
execute", i.e., "leitura, gravação, execução");
r-x são as permissões para o grupo do dono do arquivo (leitura,
execução); (eu não explicarei o conceito de grupo, você pode sobreviver sem
isso enquanto for um iniciante ;-) r-x são as permissões para todos os
outros usuários (leitura, execução).
O diretório /bin tem permissões também: veja a Seção
Permissões de Diretórios para mais
detalhes. É por isso que você não pode apagar o arquivo /bin/ls,
a menos que seja o superusuário (root): você não tem permissão para isso. Para mudar as
permissões de um arquivo, o comando é:
$ chmod <quemXperm> <arquivo>
onde quem é u (usuário, i.e., dono), g (grupo), o (outros), X
é ou + ou -, perm é r (leitura), w (gravação), ou x
(execução). Alguns exemplos do uso de chmod:
$ chmod +x arquivo
isto define a permissão de execução do arquivo.
$ chmod go-rw arquivo
isto remove as permissões de leitura e gravação para todos, exceto o dono.
$ chmod ugo+rwx arquivo
isto dá permissão de leitura, gravação e execução para todos.
# chmod +s arquivo
isso faz um arquivo chamado "setuid" ou "suid"---um arquivo que todos podem executar com os privilégios do dono. Normalmente, você encontrará arquivos setuid root; freqüentemente, são programas importantes do sistema, como o servidor X.
Uma maneira mais curta de se referir a permissões é com dígitos:
rwxr-xr-x pode ser expresso como 755 (cada letra corresponde a um bit: --- é 0, --x
é 1, -w- é 2, -wx é 3...). Parece difícil, mas com um pouco de
prática você entenderá a idéia.
Sendo o superusuário, pode-se mudar as permissões de qualquer arquivo. LPM.
À esquerda, os comandos do DOS; à direita, sua contrapartida no Linux.
ATTRIB: chmod
COPY: cp
DEL: rm
MOVE: mv
REN: mv
TYPE: more, less, cat
Operadores de redirecionamento e canalização: < > >> |
Coringas: * ?
nul: /dev/null
prn, lpt1: /dev/lp0 ou /dev/lp1; lpr
DOS Linux
---------------------------------------------------------------------
C:\GUIDO>ATTRIB +R ARQUIVO.TXT $ chmod 400 arquivo.txt
C:\GUIDO>COPY JOE.TXT JOE.DOC $ cp joe.txt joe.doc
C:\GUIDO>COPY *.* TOTAL $ cat * > total
C:\GUIDO>COPY FRACTALS.DOC PRN $ lpr fractals.doc
C:\GUIDO>DEL TEMP $ rm temp
C:\GUIDO>DEL *.BAK $ rm *~
C:\GUIDO>MOVE PAPER.TXT TMP\ $ mv paper.txt tmp/
C:\GUIDO>REN PAPER.TXT PAPER.ASC $ mv paper.txt paper.asc
C:\GUIDO>PRINT LETTER.TXT $ lpr letter.txt
C:\GUIDO>TYPE LETTER.TXT $ more letter.txt
C:\GUIDO>TYPE LETTER.TXT $ less letter.txt
C:\GUIDO>TYPE LETTER.TXT > NUL $ cat letter.txt > /dev/null
n/a $ more *.txt *.asc
n/a $ cat section*.txt | less
Observações:
* é mais inteligente no Linux: * corresponde a todos os
arquivos, exceto os ocultos; .* corresponde a todos os arquivos
ocultos (mas também ao diretório atual `.' e ao diretório pai
`..': cuidado!); *.* corresponde apenas aos arquivos que tenham
um '.' no meio ou terminem com um ponto; p*r corresponde tanto a
`peter' como a `piper'; *c* corresponde a `picked' e `peck';
more, pressione <SPACE> para ler o arquivo;
`q' para sair. less é mais intuitivo, e permite que você use as teclas
de seta;
UNDELETE, então pense duas vezes antes de apagar algo;
< > >>, o Linux tem 2> para
redirecionar mensagens de erro (stderr); além disso, 2>&1
redireciona stderr para stdout (saída padrão), enquanto 1>&2
redireciona stdout para stderr;
[]. Uso: [abc]* corresponde
a arquivos que comecem com a, b, c; *[I-N1-3] corresponde a arquivos
que terminem com I, J, K, L, M, N, 1, 2, 3;
lpr <arquivo> imprime um arquivo em segundo plano. Para
verificar o estado da fila de impressão, use lpq; para remover um
arquivo da fila de impressão, use lprm;
RENAME como no DOS; isto é, mv *.xxx *.yyy não
funciona. Você pode tentar este simples script; consulte a Seção
Roteiros para Shell: Arquivos .BAT com Esteróides
para mais detalhes.
#!/bin/sh
# ren: renomeia múltiplos arquivos de acordo com várias regras
if [ $# -lt 3 ] ; then
echo "uso: ren \"padrão\" \"substituição\" arq..."
exit 1
fi
VELHO=$1 ; NOVO=$2 ; shift ; shift
for arquivo in $*
do
novo=`echo ${arquivo} | sed s/${VELHO}/${NOVO}/g`
mv ${arquivo} $novo
done
REN do DOS, pois usa
"expressões regulares", que você provavelmente ainda não conhece.
Resumidamente, se você quiser simplesmente mudar extensões de arquivos,
faça como: ren "htm$" "html" *htm.
Não se esqueça do $.
cp -i e mv -i para ser avisado antes que um arquivo
seja sobrescrito.
Para executar um programa, digite seu nome, como faria no DOS. Se o
diretório (Seção
Usando Diretórios)
onde o programa está armazenado estiver incluso no PATH (Seção
Arquivos de Inicialização do Sistema),
o programa será iniciado. Exceção: diferentemente do DOS, no Linux um
programa localizado no diretório atual não é executado a menos que seu
diretório seja incluído no PATH. Contorno: sendo prog
o seu programa, digite ./prog.
A linha de comando típica é parecida com essa:
$ comando [-s1 [-s2] ... [-sn]] [par1 [par2] ... [parn]] [< entrada] [> saída]
onde -s1, ..., -sn são as opções do programa, par1,
..., parn são os parâmetros do programa. Você pode dar vários
comandos na mesma linha de comando:
$ comando_1 ; comando_2 ; ... ; comando_n
Isto é tudo que há sobre executar programas, mas é fácil ir um passo a frente. Um dos principais motivos para usar Linux é que é um sistema operacional multitarefa---pode executar vários programas (daqui em diante, processos) ao mesmo tempo. Você pode lançar processos em segundo plano e continuar trabalhando tranqüilamente. Além disso, o Linux permite que você abra várias sessões: é como ter vários computadores para trabalhar ao mesmo tempo.
su - <nomedelogin>. Exemplo: su - root. Isto é útil,
por exemplo, quando você precisa fazer algo que só o superusuário pode fazer.
exit. Se houver trabalhos
interrompidos (veja abaixo), você será avisado.
&'
ao fim da linha de comando:
$ nomeprog [-opções] [parâmetros] [< entrada] [> saída] &
[1] 123
[1];
veja abaixo), e a um PID (Process Identification Number, ou Número de
Identificação de Processo; 123 no nosso exemplo).
ps -ax.
A saída será uma lista dos processos sendo executados.
kill <PID>. Você pode
precisar matar um processo quando você não souber como terminá-lo da
maneira correta... A menos que você seja o superusuário, você não pode matar
processos de outros usuários. Às vezes, um processo somente pode ser
matado através de kill -SIGKILL <PID>.
Além disso, o shell permite que você termine ou suspenda temporariamente
um processo, envie um processo ao segundo plano, e traga um processo do
segundo para o primeiro plano. Nesse contexto, processos são chamados
"jobs" ou trabalhos.
jobs. Aqui os trabalhos são
identificados pelos seus números de trabalho, e não pelos seus PIDs.
bg <job> (ele se torna um trabalho).
fg <job>.
Para trazer o último trabalho que foi enviado ao segundo plano, digite
simplesmente fg.
kill <%job> onde <job>
pode ser 1, 2, 3,...
Usando esses comandos você pode formatar um disco, zipar um conjunto de arquivos, compilar um programa e descompactar um arquivo, tudo ao mesmo tempo, e ainda ter a linha de comando à sua disposição. Tente isso no DOS! E tente no Windows, apenas para ver a diferença de desempenho (se não travar, é claro).
Para executar um programa em uma máquina remota cujo endereço IP seja
maquina.remota.edu, digite:
$ telnet maquina.remota.edu
Depois de entrar no sistema, inicie seu programa favorito. Desnecessário dizer que você deve ter uma conta na máquina remota.
Se você tiver o X11, você pode até mesmo executar uma aplicativo X no
computador remoto, exibindo-o na tela do seu X. Seja
maquina.remota.edu o computador remoto e local.linux.box sua
máquina Linux. Para executar a partir de local.linux.box um programa
X que resida em remote.machine.edu, faça o seguinte:
xterm ou um emulador de terminal
equivalente, e digite:
$ xhost +maquina.remota.edu
$ telnet maquina.remota.edu
remote:$ DISPLAY=local.linux.box:0.0
remote:$ nomeprog &
DISPLAY..., pode ser que você tenha que digitar:
setenv DISPLAY local.linux.box:0.0. Depende do seu interpretador de comandos remoto.)
E voila! Agora nomeprog rodará em maquina.remota.edu e será
exibido na sua máquina. Entretanto, não tente isto usando um modem, pois
será lento demais para ser usável.