Intro

Atualmente tenho passado boa parte do meu tempo no computador em linhas de comando de shells do Linux, como zsh e bash.

Acho a linha de comando uma excelente ferramenta de produtividade e automação de tarefas.

Compartilharei nessa série dicas e comandos que tenho utilizado, em um formato acessível para que pessoas com pouca experiência em shells possam explorar esse fantástico universo da linha de comando.

onde executar

Essas dicas serão focadas em shells Linux, mas para pessoas que trabalham em ambientes Windows há algumas opções onde elas poderão ser aplicadas.

A que utilizo no trabalho é o WSL (Windows Subsystem for Linux), que permite executar um Linux de verdade no Windows.

Outra opção é o Git Bash, que vem junto com a instalação do Git para Windows. Não é um Linux de verdade mas possui vários utilitários do GNU compilados para Windows (ex: grep, find, sed, awk etc.).

No Mac deve funcionar também.

filosofia Unix

A filosofia Unix propõe um estilo de desenvolvimento, no qual cito 2 principais, que acho importante para trabalhar de forma mais efetiva com os programas na linha de comando:

Style

A number of maxims have gained currency among the builders and users of the UNIX system to explain and promote its characteristic style:

(i) Make each program do one thing well. To do a new job, build afresh rather than complicate old programs by adding new "features."

(ii) Expect the output of every program to become the input to another, as yet unknown, program. Don't clutter output with extraneous information. Avoid stringently columnar or binary input formats. Don't insist on interactive input.

Bell System Technical Journal, 57: 6. July-August 1978 pp 1899-1904. UNIX Time-Sharing System: Forward. (McIlroy, M.D.; Pinson, E.N.; Tague, B.A.)

Ou seja, pequenos programas com propósitos bem específicos, que podem ser combinados encadeando a saída de um programa (em formato de texto) na entrada de outro programa. Dessa forma diversos programas simples podem ser encadeados para efetuar tarefas complexas.

Essa filosofia se aplica também aos sistemas derivados do Unix, como o Linux.

Exemplifico essa ideia utilizando 2 programas:

seq - programa que tem a finalidade de gerar sequências numéricas

ex: sequência numérica de 1 a 10 em incrementos de 2

$ seq 1 2 10
1
3
5
7
9

wc - tem a finalidade de contar linhas, palavras ou bytes

ex: conta quantas linhas tem na sequência de números ímpares de 1 a 10

$ seq 1 2 10 | wc -l 
5

Nesse exemplo, o primeiro processo (seq) gera a sequência numérica em formato de texto.

O operador | redireciona a saída (stdout) do processo seq para a entrada (stdin) do segundo processo (wc), que executa a contagem das linhas.

Como não há mais redirecionamentos para outros processos, a saída (stdout do último processo) é exibida no terminal.

Esse encadeamento de comandos é chamado de pipeline.

onde procurar ajuda

Caso tenha dúvidas sobre algum comando específico, a ajuda pode ser obtida no próprio shell das seguintes formas:

man - a maioria dos comandos possui uma página de documentação detalhada que pode ser acessada através do utilitário man na linha de comando, que vai explicar os argumentos do comando e em muitos casos alguns exemplos de uso. (obs: não funciona no git bash)

$ man seq

SEQ(1)                           User Commands                          SEQ(1)

NAME
       seq - print a sequence of numbers

SYNOPSIS
       seq [OPTION]... LAST
       seq [OPTION]... FIRST LAST
       seq [OPTION]... FIRST INCREMENT LAST

DESCRIPTION
       Print numbers from FIRST to LAST, in steps of INCREMENT.

       Mandatory  arguments  to  long  options are mandatory for short options
       too.

       -f, --format=FORMAT
              use printf style floating-point FORMAT

       -s, --separator=STRING
              use STRING to separate numbers (default: \n)

       -w, --equal-width
              equalize width by padding with leading zeroes

       --help display this help and exit

       --version
              output version information and exit

       If FIRST or INCREMENT is omitted, it defaults to 1.  That is, an  omit‐
       ted  INCREMENT defaults to 1 even when LAST is smaller than FIRST.  The
       sequence of numbers ends when the sum of the current number and  INCRE‐
       MENT  would  become  greater than LAST.  FIRST, INCREMENT, and LAST are
       interpreted as floating point values.  INCREMENT is usually positive if
       FIRST  is smaller than LAST, and INCREMENT is usually negative if FIRST
       is greater than LAST.  INCREMENT must not be 0; none of  FIRST,  INCRE‐
       MENT and LAST may be NaN.  FORMAT must be suitable for printing one ar‐
       gument of type 'double'; it defaults to %.PRECf  if  FIRST,  INCREMENT,
       and  LAST  are  all  fixed point decimal numbers with maximum precision
       PREC, and to %g otherwise.

AUTHOR
       Written by Ulrich Drepper.

REPORTING BUGS
       GNU coreutils online help: <https://www.gnu.org/software/coreutils/>
       Report any translation bugs to <https://translationproject.org/team/>

COPYRIGHT
       Copyright © 2020 Free Software Foundation, Inc.   License  GPLv3+:  GNU
       GPL version 3 or later <https://gnu.org/licenses/gpl.html>.
       This  is  free  software:  you  are free to change and redistribute it.
       There is NO WARRANTY, to the extent permitted by law.

SEE ALSO
       Full documentation <https://www.gnu.org/software/coreutils/seq>
       or available locally via: info '(coreutils) seq invocation'

GNU coreutils 8.32               February 2022                          SEQ(1)

apropos - caso não se lembre o nome do comando para acessar o manual, pode procurar por algum texto que possa estar presente no mesmo. Ele irá listar os manuais que contém esse texto. (detalhes de uso desse comando podem ser obtidas no manual do mesmo man apropos)

$ apropos counts
get_avphys_pages (3) - get total and available physical page counts
get_phys_pages (3)   - get total and available physical page counts
goa-daemon (8)       - GNOME Online Accounts Daemon
wc (1)               - print newline, word, and byte counts for each file

--help - outra opção que também existe na maioria dos comandos é o argumento --help do próprio comando.

$ wc --help
Usage: wc [OPTION]... [FILE]...
  or:  wc [OPTION]... --files0-from=F
Print newline, word, and byte counts for each FILE, and a total line if
more than one FILE is specified.  A word is a non-zero-length sequence of
characters delimited by white space.

With no FILE, or when FILE is -, read standard input.

The options below may be used to select which counts are printed, always in
the following order: newline, word, character, byte, maximum line length.
  -c, --bytes            print the byte counts
  -m, --chars            print the character counts
  -l, --lines            print the newline counts
      --files0-from=F    read input from the files specified by
                           NUL-terminated names in file F;
                           If F is - then read names from standard input
  -L, --max-line-length  print the maximum display width
  -w, --words            print the word counts
      --help     display this help and exit
      --version  output version information and exit

GNU coreutils online help: <https://www.gnu.org/software/coreutils/>
Full documentation <https://www.gnu.org/software/coreutils/wc>
or available locally via: info '(coreutils) wc invocation'

Alguns argumentos possuem 2 formatos equivalentes, um mais curto, de uma letra, especificado com - e outro mais longo, especificado com --.

Os argumentos curtos podem ser combinados, por exemplo ls -l -t -r é equivalente a ls -ltr.

conclusão

filosofia unix - programas simples, que podem ser combinados para fazer tarefas complexas
ajuda para os comandos pode ser obtida no próprio shell, através de man pages e --help

Leandro Conca De Luccia's Blog