A maioria dos usuários iniciantes de sistemas Unix, em particular o Linux, não estão familiarizados com os operadores básicos de linha de comando usados ​​neste sistema operacional. Vamos dar uma olhada mais de perto nas funções e no uso dos operadores find e grep.

Usando os comandos Find e Grep no Linux.

ENCONTRAR

O comando find do Linux é um utilitário de linha de comando para percorrer a hierarquia de arquivos. Ele pode ser usado para procurar por arquivos e diretórios e realizar operações subseqüentes com eles. Ele suporta a pesquisa por arquivo, pasta, nome, data de criação, data de alteração, proprietário e permissões. Usando -exec, outros comandos UNIX podem ser executados para arquivos ou pastas encontrados. Sintaxe:

$ find [onde começar a pesquisa] [a expressão determina o que encontrar] [-options] [o que encontrar]

Opções:

• -exec - o arquivo requerido que atende aos critérios acima e retorna 0 como um estado de saída para execução bem-sucedida do comando;
• -ok - funciona da mesma forma que -exec, exceto que o usuário é solicitado pela primeira vez;
• -inum N - pesquisa com o número "N";
• -links N - pesquisa com links "N";
• -nome demo - procure por arquivos especificados em "demo";
• -novo arquivo - busca por arquivos que foram modificados / criados após “arquivo”;
• -perm octal - procura se a resolução é octal;
• -print - mostra o caminho para os documentos encontrados usando os outros critérios;
• -empty - procura por documentos e diretórios vazios;
• -size + N / -N - blocos de pesquisa "N"; "N" e "c" podem ser usados ​​para medir o tamanho em caracteres; “+ N” significa um tamanho maior de blocos “N” e “-N” significa um tamanho menor de blocos “N”;
• -nome do usuário - procura por documentos pertencentes ao nome do usuário ou ao identificador "nome";
• \ (expr \) - Verdadeiro se "expr" for verdadeiro; Usado para agrupar critérios em conjunto com OR ou AND.

Grep

O comando grep é usado para pesquisar arquivos. A função significa "impressão global de expressões regulares" e é um dos comandos mais poderosos e mais usados ​​no Linux. O comando procura por um ou mais arquivos de entrada que correspondam ao padrão especificado e grava cada linha correspondente na saída padrão. Se nenhum arquivo for especificado, o comando lê a entrada padrão, que geralmente é a saída de outro comando. Neste artigo, mostraremos como inserir um comando, com exemplos práticos e explicações detalhadas das opções mais comuns do GNU grep.

Sintaxe de comando

Antes de começarmos a usar o comando, vamos começar revendo a sintaxe básica. As expressões de utilitário têm o seguinte formato:

[OPÇÕES] PADRÃO [ARQUIVO]

Os itens entre colchetes são opcionais.

• OPÇÕES - zero ou mais opções. A equipe fornece várias opções que controlam seu comportamento.
• PADRÃO - Padrão de busca.
• FILE - zero ou mais nomes de arquivos de entrada.

Como inserir um comando para pesquisar arquivos

O objetivo principal do comando é procurar texto no arquivo. Por exemplo, para exibir a partir do arquivo / etc / passwd contendo a linha bash, você pode usar o seguinte comando:

$ grep bash / etc / passwd

A saída deve ser algo como isto:

root 0: 0: root: / root: / bin / bash

domain1000: 1000: domain: / home / domain: / bin / bash

Se a string contiver espaços, será necessário incluí-la entre aspas simples ou duplas:

$ "Gnome Display Manager" / etc / passwd

Inverter Correspondência (ex)

Para exibir linhas que não correspondem ao padrão, insira o parâmetro –v (ou –invert-match). Por exemplo, para exibir um arquivo que não contém nologin do arquivo / etc / passwd, você pode digitar o seguinte comando:

$ -v nologin / etc / passwd

Saída:

root 0: 0: root: / root: / bin / bash

colord 124: 124 :: / var / lib / colord: / bin / false

git 994: 994: usuário daemon git: /: / usr / bin / git-shell

linuxize 1000: 1000: linuxize: / home / linuxize: / bin / bash

Como usar o comando para procurar na saída

Em vez disso, se você especificar arquivos de entrada, poderá redirecionar a saída de outro comando e exibir apenas as linhas que correspondem ao padrão especificado. Por exemplo, para descobrir quais processos estão sendo executados em seu sistema como um usuário www-data, você pode usar o seguinte comando:

$ ps -ef | www-data

Saída:

www-data 18247 12675 4 16:00? 00:00:00 php-fpm: piscina www

root 18272 17714 0 16:00 pts / 0 00:00:00 —color = auto - exclude-dir = .bzr —exclude-dir = CVS —exclude-dir = .git —exclude-dir = .hg —exclude-dir = .svn www-data

www-data 31147 12770 0 Oct22? 00:05:51 nginx: processo de trabalho

www-data 31148 12770 0 Oct22? 00:00:00 nginx: processo do gerenciador de cache

Você também pode combinar vários canais em uma equipe. Como você pode ver na saída acima, há também uma linha contendo o processo. Se você não quiser que esta linha seja exibida, envie a saída para outra instância, como mostrado abaixo.

$ ps -ef | www-data | grep -v grep

Saída:

www-data 18247 12675 4 16:00? 00:00:00 php-fpm: piscina www

root 18272 17714 0 16:00 pts / 0 00:00:00 —color = auto - exclude-dir = .bzr —exclude-dir = CVS —exclude-dir = .git —exclude-dir = .hg —exclude-dir = .svn www-data

www-data 31147 12770 0 Oct22? 00:05:51 nginx: processo de trabalho

www-data 31148 12770 0 Oct22? 00:00:00 nginx: processo do gerenciador de cache

Pesquisa recursiva

Para pesquisar recursivamente por um padrão, insira a opção –r (ou –recursive). Isso permitirá que você pesquise todos os arquivos no diretório especificado, ignorando os links simbólicos que ocorrem recursivamente. Para percorrer todos os links simbólicos, use a opção –r (ou –dereference-recursive). No exemplo a seguir, estamos procurando domain.com em todos os arquivos dentro do diretório / etc:

$ -r domain.com / etc

O comando imprimirá os campos correspondentes com o prefixo do caminho completo do arquivo.

/etc/hosts:127.0.0.1 node2.domain.com /etc/nginx/sites-available/domain.com: server_name domain.com www.domain.com;

Se em vez de –r você usar a opção –R, o comando seguirá todos os links simbólicos:

$ -R domain.com / etc

Observe o último campo de saída. Isso não é impresso no exemplo acima, porque os arquivos no diretório Nginx habilitado para sites são links simbólicos para arquivos de configuração dentro do diretório disponível para sites.

Saída:

/etc/hosts:127.0.0.1 node2.domain.com

/etc/nginx/sites-available/domain.com: server_name domain.com www.domain.com;

/etc/nginx/sites-enabled/domain.com: server_name domain.com www.domain.com;

Mostrar apenas o nome do arquivo

Para suprimir a saída padrão e imprimir apenas os nomes dos arquivos que contêm o padrão correspondente, você pode inserir a opção –l (ou “files-with-matches”). Por exemplo, para procurar todos os arquivos terminados em .conf no diretório de trabalho atual e para imprimir apenas nomes de arquivos que contenham o tipo domain.com, digite:

$ –L domain.com * .conf

A saída será algo como isto:

tmux.conf

haproxy.conf

A opção -l é geralmente usada em conjunto com a opção -R recursiva:

$ -Rl domain.com / tmp

Insensibilidade caso

Por padrão, o comando faz distinção entre maiúsculas e minúsculas, o que significa que os caracteres maiúsculos e minúsculos são tratados como diferentes. Para ignorar maiúsculas e minúsculas ao pesquisar, insira a opção –i (ou –ignore-case). Por exemplo, se você pesquisar por uma Zebra sem nenhuma opção, o comando a seguir não exibirá nenhuma saída, ou seja, há correspondência.

$ Zebra / usr / share / words

Mas, se você realizar uma pesquisa sem distinção entre maiúsculas e minúsculas, use a opção –i para corresponder às letras maiúsculas e minúsculas:

$ grep -i Zebra / usr / share / words

A indicação “Zebra” corresponderá a “Zebra”, “ZEbrA” ou qualquer outra combinação de letras maiúsculas e minúsculas.

Saída:

zebra

zebra

zebras

Jogo exato

Ao pesquisar, o gnu também imprimirá o gnu, no qual as palavras maiores são inseridas, como cygnus ou magnum.

$ gnu / usr / share / words

Saída:

cygnus

gnu

interregno

lgnu9d

lignum

magnum

Magnuson

esfagno

wingnut

Para retornar apenas as expressões nas quais o campo especificado é uma palavra inteira (não incluída em palavras), você pode usar a opção –w (ou “word-regexp ”).

IMPORTANTE Os caracteres da palavra incluem caracteres alfanuméricos (az, AZ e 0-9) e sublinhados (_). Todos os outros personagens são tratados como caracteres não verbais.

Se você executar o mesmo comando acima, incluindo a opção –w, o comando retornará apenas aqueles que incluem o gnu como uma palavra separada.

$ grep -w gnu / usr / share / words

Saída: gnu

Mostrar números

Para mostrar o número de linhas que contêm um padrão, use o parâmetro –n (ou –line-number). O uso dessa opção imprimirá correspondências para a saída padrão com o prefixo do número em que foi encontrado. Por exemplo, para exibir a partir do arquivo / etc / services contendo o prefixo bash com o número correspondente, você pode usar o seguinte comando:

$ grep -n 10000 / etc / services

A saída abaixo mostra que as correspondências estão em 10423 e 10424.

Saída:

10423: ndmp 10.000 / tcp

10424: ndmp 10000 / udp

Contando

Para imprimir o número de linhas correspondentes na saída padrão, use o parâmetro –c (ou –count). No exemplo abaixo, contamos o número de contas que possuem o shell / usr / bin / zsh.

$ grep -c '/ usr / bin / zsh' / etc / passwd

Saída: 4

Várias linhas (padrões)

O operador OR pode combinar dois ou mais padrões de pesquisa. Por padrão, o comando interpreta o padrão como a expressão regular principal, na qual os metacaracteres perdem seu significado particular e suas versões com uma barra invertida devem ser usadas. No exemplo abaixo, procuramos todas as ocorrências das palavras fatal, erro e crítica no arquivo de log de erros do Nginx:

$ grep 'fatal \ | erro \ | crítico' /var/log/nginx/error.log

Se você usar a opção de expressão regular estendida –E (ou “extended-regexp”), a instrução não deve ter escape, como mostrado abaixo:

$ grep -E 'fatal | erro | crítico' /var/log/nginx/error.log

Expressão regular

O GNU Grep possui dois conjuntos de funções de expressão regular - Básico e Estendido. Por padrão, a função interpreta o padrão como uma expressão regular básica, para alternar para expressões regulares estendidas, é necessário usar a opção –E. Ao usar expressões regulares no modo principal, todos os outros caracteres, exceto metacaracteres, são na verdade expressões regulares que correspondem entre si. Abaixo está uma lista dos metacaracteres mais usados:

• Use o caractere ^ (o caractere de interpolação) para corresponder à expressão no início de uma linha. No exemplo a seguir, ^ kangaroo só será igual se ocorrer no início: $ grep "^ kangaroo" file.txt
• Use o símbolo $ (dólar) para corresponder à expressão no final. No seguinte exemplo, o kangaroo $ só será encontrado se for encontrado no final: grep "kangaroo $" file.txt
• Use o símbolo. (ponto) para corresponder a qualquer caractere único. Por exemplo, para combinar tudo o que começa com kan de dois caracteres e termina com roo, você pode usar o seguinte padrão: $ grep "kan..roo" file.txt
• Use [] (colchetes) para corresponder a qualquer caractere individual entre colchetes. Por exemplo, encontre aqueles que contêm accept ou "accent, você pode usar o seguinte padrão: $ grep" acce [np] t "file.txt

Para evitar o significado especial do próximo caractere, use o caractere \ (barra invertida).

Expressões regulares estendidas

Para interpretar um padrão como uma expressão regular estendida, use o parâmetro –E (ou –extended-regexp). Expressões regulares estendidas incluem todos os metacaracteres básicos, bem como metacaracteres adicionais para criar padrões de pesquisa mais complexos e poderosos. Abaixo estão alguns exemplos:

• Combine e extraia todos os endereços de e-mail desse arquivo: $ grep -E -o "\ b [A-Za-z0-9 ._% + -] [A-Za-z0-9 .-] + \. [A-Za-z] {2.6} \ b "arquivo.txt
• Mapeie e extraia todos os endereços IP válidos deste arquivo: $ grep -E -o '(25 [0-5] | 2 [0-4] [0-9] | [01]? [0-9] [0 -9]?) \. (25 [0-5] | 2 [0-4] [0-9] | [01]? [0-9] [0-9]?) \. (25 [0- 5] | 2 [0-4] [0-9] | [01]? [0-9] [0-9]?) \. (25 [0-5] | 2 [0-4] [0- 9] | [01]? [0-9] [0-9]?) 'Arquivo.txt

A opção -o é usada para imprimir apenas correspondências.

Imprimir antes de contar

Para imprimir um determinado número de linhas antes da correspondência, use o parâmetro –B (ou “before-context”). Por exemplo, para exibir 5 linhas do contexto inicial antes de corresponder, você pode usar o seguinte comando: $ grep -A 5 root / etc / passwd

Imprimir após pesquisa

Para imprimir um número específico de linhas após uma correspondência, use o parâmetro –A (ou –after-context). Por exemplo, para exibir 5 linhas do contexto final após a correspondência de strings, você pode usar o seguinte comando: $ grep -B 5 root / etc / passwd

Tudo isso é necessário para o uso completo de informações de comandos. Se você já usa o Linux e pode dar algum conselho aos iniciantes, compartilhe comentários neste artigo.