Como copiar arquivos com padrões específicos usando curingas no Linux

Introdução

Os curingas do Linux (wildcards), também conhecidos como padrões de globbing, são caracteres especiais usados no shell para corresponder e expandir nomes de arquivos. Compreender como usar essas ferramentas poderosas pode melhorar significativamente sua eficiência ao trabalhar com a linha de comando do Linux. Este tutorial irá guiá-lo pelos fundamentos dos curingas do Linux e demonstrar como aproveitá-los para copiar arquivos com padrões específicos, ajudando você a otimizar suas tarefas de gerenciamento de arquivos.

Compreendendo os Curingas Básicos

No Linux, os curingas (wildcards) são caracteres especiais que ajudam a corresponder a múltiplos arquivos usando padrões. Eles são particularmente úteis quando você precisa gerenciar muitos arquivos de uma vez. Vamos explorar os curingas mais comuns examinando os arquivos em nosso diretório atual.

Primeiro, vamos ver todos os arquivos com os quais temos que trabalhar:

cd ~/project/wildcards_lab
ls

Você deve ver uma lista de arquivos com várias extensões como esta:

backup        data_02.csv  doc2.pdf     file3.txt    image3.jpg      readme.md
config.yml    data_03.csv  documents    images       report1.txt     report_final.txt
data_01.csv   doc1.pdf     file1.txt    image1.jpg   report2.txt     script.sh
file2.txt     image2.jpg

O Curinga Asterisco (*)

O asterisco * é o curinga mais comum. Ele corresponde a qualquer número de caracteres (incluindo zero). Vamos vê-lo em ação:

Para listar todos os arquivos de texto (terminando com .txt):

ls *.txt

Você deve ver:

file1.txt  file2.txt  file3.txt  report1.txt  report2.txt  report_final.txt

Para listar todos os arquivos de imagem (terminando com .jpg):

ls *.jpg

Saída:

image1.jpg  image2.jpg  image3.jpg

O Curinga Ponto de Interrogação (?)

O ponto de interrogação ? corresponde exatamente a um caractere. Vamos usá-lo para encontrar arquivos:

ls file?.txt

Este comando listará arquivos que começam com "file", seguido por exatamente um caractere, e terminam com ".txt".

Saída:

file1.txt  file2.txt  file3.txt

O Curinga Colchetes ([])

Os colchetes [] permitem que você corresponda a qualquer caractere único de um conjunto especificado:

ls data_0[1-2].csv

Este comando lista arquivos CSV cujos nomes correspondem a "data_0" seguido por 1 ou 2, e então ".csv".

Saída:

data_01.csv  data_02.csv

Listando Arquivos Ocultos

No Linux, arquivos que começam com um ponto (.) são arquivos ocultos. Podemos usar curingas para encontrá-los também:

ls .*

A saída incluirá:

.  ..  .hidden_file1  .hidden_file2

Observação: Os diretórios . e .. representam o diretório atual e o diretório pai, respectivamente.

Experimente esses comandos e observe os resultados. Compreender esses curingas básicos é essencial antes de prosseguirmos para usá-los em operações de cópia de arquivos.

Copiando Arquivos Usando Curingas

Agora que você entende os curingas básicos, vamos usá-los para copiar arquivos de forma eficiente. A sintaxe geral para copiar arquivos é:

cp [options] source_file(s) destination

Vamos criar alguns diretórios de organização e praticar a cópia de arquivos com diferentes padrões.

Copiando Todos os Arquivos com uma Extensão Específica

Vamos copiar todos os arquivos de texto para o diretório de backup:

cd ~/project/wildcards_lab
cp *.txt backup/

Este comando copia todos os arquivos terminando com .txt para o diretório de backup. Vamos verificar:

ls backup/

Você deve ver:

file1.txt  file2.txt  file3.txt  report1.txt  report2.txt  report_final.txt

Copiando Arquivos Começando com Padrões Específicos

Em seguida, vamos copiar todos os arquivos de imagem para o diretório de imagens:

cp image*.jpg images/

Isso copia todos os arquivos começando com "image" e terminando com ".jpg" para o diretório de imagens. Vamos verificar:

ls images/

Saída:

image1.jpg  image2.jpg  image3.jpg

Copiando Arquivos com Múltiplos Padrões Usando Expansão de Chaves

A expansão de chaves {pattern1,pattern2} permite que você especifique múltiplos padrões. Vamos copiar arquivos PDF e CSV para o diretório de documentos:

cp *.{pdf,csv} documents/

Este comando copia todos os arquivos terminando com .pdf ou .csv para o diretório de documentos. Vamos verificar:

ls documents/

Saída:

data_01.csv  data_02.csv  data_03.csv  doc1.pdf  doc2.pdf

Copiando Arquivos com Múltiplos Padrões usando or (||)

Também podemos usar o operador || para copiar arquivos que correspondem a diferentes padrões:

cp report*.txt script.sh backup/

Isso copia todos os arquivos começando com "report" e terminando com ".txt", bem como o arquivo script.sh, para o diretório de backup. Vamos verificar o que está no diretório de backup agora:

ls backup/

Saída atualizada:

file1.txt  file2.txt  file3.txt  report1.txt  report2.txt  report_final.txt  script.sh

Copiando Arquivos Preservando Atributos

Ao copiar arquivos, você pode querer preservar atributos como timestamps e permissões. Use a opção -p:

cp -p config.yml backup/

Para verificar se os atributos foram preservados:

ls -l config.yml
ls -l backup/config.yml

Os timestamps e permissões devem ser idênticos para ambos os arquivos.

Experimente esses comandos e explore como diferentes padrões de curingas ajudam você a copiar arquivos de forma eficiente.

Técnicas Avançadas de Curingas

Agora que você dominou o básico, vamos explorar alguns padrões de curingas mais avançados para realizar operações de arquivos mais específicas.

Criando um Novo Diretório para Operações Avançadas

Primeiro, vamos criar um novo diretório para praticar técnicas avançadas:

cd ~/project/wildcards_lab
mkdir advanced

Usando Classes de Caracteres com Colchetes

Classes de caracteres permitem que você corresponda a um único caractere de um conjunto de caracteres:

## Copiar arquivos que começam com 'd' ou 'f'
cp [df]*.* advanced/

Isso copia todos os arquivos começando com 'd' ou 'f' para o diretório advanced. Vamos verificar:

ls advanced/

Saída:

data_01.csv  data_02.csv  data_03.csv  doc1.pdf  doc2.pdf  file1.txt  file2.txt  file3.txt

Usando Negação em Classes de Caracteres

Você pode usar o símbolo ! ou ^ após o colchete de abertura para negar a classe de caracteres. Vamos copiar arquivos que não começam com 'r' ou 'i':

mkdir advanced/filtered
cp [^ri]*.txt advanced/filtered/

Vamos verificar:

ls advanced/filtered/

Saída:

file1.txt  file2.txt  file3.txt

Combinando Múltiplos Curingas

Vamos combinar diferentes curingas para criar padrões mais específicos:

## Copiar arquivos que começam com 'data_0', seguido por um único dígito, e terminam com '.csv'
cp data_0?.csv advanced/

Vamos verificar se isso copiou nossos arquivos CSV corretamente:

ls advanced/*.csv

Saída:

advanced/data_01.csv  advanced/data_02.csv  advanced/data_03.csv

Usando Globbing Estendido

O Bash fornece padrões de globbing estendidos, que são mais poderosos do que curingas padrão. Primeiro, habilite o globbing estendido:

shopt -s extglob

Agora podemos usar padrões como:

• ?(pattern): Corresponde a zero ou uma ocorrência do padrão
• *(pattern): Corresponde a zero ou mais ocorrências
• +(pattern): Corresponde a uma ou mais ocorrências
• @(pattern): Corresponde exatamente a uma ocorrência
• !(pattern): Corresponde a tudo, exceto o padrão

Vamos tentar um exemplo:

## Copiar arquivos que têm um número seguido por .txt
mkdir advanced/numbered
cp +([0-9])*.txt advanced/numbered/

O resultado pode estar vazio, pois nossos arquivos originais não correspondem a este padrão exato. Vamos criar um arquivo que corresponda:

touch 123file.txt
cp +([0-9])*.txt advanced/numbered/
ls advanced/numbered/

Saída:

123file.txt

Usando Expansão de Chaves para Padrões Complexos

A expansão de chaves é útil para criar padrões complexos:

## Criar um diretório para arquivos de relatório
mkdir advanced/reports

## Copiar todos os arquivos de relatório e arquivos de configuração
cp {report*.txt,*.yml} advanced/reports/

Vamos verificar:

ls advanced/reports/

Saída:

config.yml  report1.txt  report2.txt  report_final.txt

Essas técnicas avançadas ajudarão você a ser mais preciso ao selecionar arquivos, economizando tempo e esforço no gerenciamento do seu sistema de arquivos. Experimente combinações desses curingas para ver como eles podem ajudar você a gerenciar arquivos de forma mais eficiente.

Exercício Prático de Gerenciamento de Arquivos

Nesta etapa final, vamos juntar tudo o que aprendemos para resolver um problema prático de gerenciamento de arquivos. Este exercício irá reforçar sua compreensão de curingas e demonstrar sua aplicação prática.

Cenário

Imagine que você é um administrador de sistema responsável por organizar um diretório contendo vários tipos de arquivos. Você precisa:

1. Identificar e categorizar arquivos por tipo
2. Fazer um backup de arquivos importantes
3. Extrair arquivos com base em padrões de nomenclatura específicos

Vamos simular este cenário:

Criando um Diretório de Projeto Simulado

Primeiro, vamos criar um novo diretório de projeto com vários tipos de arquivos:

cd ~/project/wildcards_lab
mkdir project_files
cd project_files

## Criar vários tipos de arquivos
touch project_doc_v1.txt project_doc_v2.txt project_doc_final.txt
touch data_2023_01.csv data_2023_02.csv data_2023_03.csv
touch config_dev.yml config_test.yml config_prod.yml
touch backup_script_v1.sh backup_script_v2.sh
touch image001.png image002.png image003.png
touch .project_config .project_log

Vamos verificar nosso diretório:

ls

Saída:

backup_script_v1.sh  config_prod.yml      data_2023_02.csv     image002.png          project_doc_v1.txt
backup_script_v2.sh  config_test.yml      data_2023_03.csv     image003.png          project_doc_v2.txt
config_dev.yml       data_2023_01.csv     image001.png         project_doc_final.txt

Observação: Os arquivos ocultos (começando com .) não aparecerão na saída básica do ls.

Organizando Arquivos por Tipo

Agora, vamos criar diretórios para diferentes tipos de arquivos e organizar nossos arquivos:

## Criar diretórios
mkdir docs configs scripts data images backups

## Copiar documentos de texto para o diretório docs
cp *doc*.txt docs/

## Copiar arquivos de configuração para o diretório configs
cp *.yml configs/

## Copiar scripts para o diretório scripts
cp *.sh scripts/

## Copiar arquivos de dados para o diretório data
cp *.csv data/

## Copiar imagens para o diretório images
cp *.png images/

Vamos verificar nossa organização:

echo "Documentos:"
ls docs/

echo "Configurações:"
ls configs/

echo "Scripts:"
ls scripts/

echo "Arquivos de dados:"
ls data/

echo "Imagens:"
ls images/

Saída:

Documentos:
project_doc_final.txt  project_doc_v1.txt  project_doc_v2.txt

Configurações:
config_dev.yml  config_prod.yml  config_test.yml

Scripts:
backup_script_v1.sh  backup_script_v2.sh

Arquivos de dados:
data_2023_01.csv  data_2023_02.csv  data_2023_03.csv

Imagens:
image001.png  image002.png  image003.png

Criando um Backup Abrangente

Vamos criar um backup abrangente que inclua todos os arquivos importantes:

## Criar um backup de todos os arquivos que não são imagens
cp !(*.png|*backup*) backups/

## Vamos ver o que está no nosso diretório de backups
ls backups/

Saída:

config_dev.yml   config_test.yml  data_2023_01.csv  data_2023_03.csv  project_doc_final.txt  project_doc_v2.txt
config_prod.yml  data_2023_02.csv  project_doc_v1.txt

Encontrando Arquivos com Padrões Específicos

Agora, vamos encontrar arquivos que correspondam a padrões específicos:

## Encontrar todos os arquivos de 2023
echo "Arquivos de 2023:"
ls *2023*

## Encontrar todas as versões finais ou de produção
echo "Versões Finais/Produção:"
ls *final* *prod*

## Encontrar todos os arquivos da versão 2
echo "Arquivos da versão 2:"
ls *v2*

Saída:

Arquivos de 2023:
data_2023_01.csv  data_2023_02.csv  data_2023_03.csv

Versões Finais/Produção:
config_prod.yml  project_doc_final.txt

Arquivos da versão 2:
backup_script_v2.sh  project_doc_v2.txt

Aplicação Prática: Criando um Pacote de Implantação

Finalmente, vamos criar um pacote de implantação contendo apenas configurações de produção e documentação final:

mkdir deployment_package
cp *prod*.yml *final*.txt deployment_package/

## Verifique nosso pacote de implantação
ls deployment_package/

Saída:

config_prod.yml  project_doc_final.txt

Parabéns! Você concluiu com sucesso um exercício prático de gerenciamento de arquivos usando curingas do Linux. Essas habilidades serão inestimáveis para gerenciar arquivos de forma eficiente em um ambiente Linux, automatizar tarefas repetitivas e organizar seu sistema de arquivos de forma eficaz.

Resumo

Neste laboratório, você aprendeu a usar efetivamente os curingas do Linux para copiar e gerenciar arquivos com padrões específicos. Você começou com curingas básicos como o asterisco (*), ponto de interrogação (?), e colchetes ([]), e então progrediu para técnicas mais avançadas, como classes de caracteres, negação e globbing estendido.

Aqui estão as principais habilidades que você adquiriu:

1. Usando curingas básicos (*,?,[ ]) para corresponder a padrões de arquivos
2. Copiando arquivos com extensões específicas ou padrões de nomenclatura
3. Usando técnicas avançadas de curingas para uma seleção de arquivos mais precisa
4. Combinando múltiplos curingas e expansão de chaves para padrões complexos
5. Aplicando essas habilidades para organizar e gerenciar arquivos em um cenário prático

Essas habilidades aumentarão significativamente sua produtividade ao trabalhar com a linha de comando do Linux, permitindo que você automatize tarefas de gerenciamento de arquivos e organize seu sistema de arquivos de forma eficiente. À medida que você continua a trabalhar com o Linux, essas técnicas de curingas se tornarão ferramentas valiosas em suas operações diárias.

Lembre-se que a prática leva à perfeição. Quanto mais você usar esses curingas em seu trabalho diário, mais confortável e proficiente você se tornará com eles.