Comando split: Dividindo e Juntando Arquivos Grandes

Comando split: Dividindo e Juntando Arquivos Grandes
Tempo de leitura: Cerca de 8 min Dificuldade: Iniciante

O que você vai conseguir fazer

  • Dividir um arquivo por tamanho, número de linhas ou quantidade de pedaços com `split`
  • Reconstruir o original com `cat prefixo* > arquivo_restaurado`
  • Verificar o arquivo restaurado com `sha256sum`

Pré-requisitos (leia estes primeiro)

E Se o Arquivo For Grande Demais?

Lina: Senpai, tentei copiar um arquivo de log de 5GB para um pendrive e apareceu "file too large"...
Veterano Linny: Esse é o trabalho do comando split. Ele corta um arquivo grande em pedaços pequenos.
Veterano Linny: E você pode juntar esses pedaços depois, exatamente como estavam. Vamos ver como funciona.

As palavras usadas aqui (para não confundir depois)

  • Dividir: cortar um arquivo em vários arquivos menores. O original continua onde está.
  • Juntar: recolocar os pedaços em ordem para reconstruir o arquivo original.
  • Prefixo: o texto colocado no início de cada nome de arquivo gerado.
  • Sufixo: os caracteres colocados no fim do nome. O aa em part_aa é um deles.
  • Hash: um texto parecido com uma impressão digital, calculado a partir do conteúdo do arquivo. "Checksum" quer dizer quase o mesmo.

O Que Você Vai Aprender

  • Como dividir um arquivo grande por tamanho, linhas ou quantidade de pedaços com split
  • Como juntar os pedaços de volta no arquivo original com cat
  • Como usar sufixos numerados (part_01 em vez de xaa)
  • Como verificar se o arquivo está intacto após dividir e juntar

1. O Que é o Comando split?

Conclusão: split quebra um arquivo em vários arquivos menores; concatená-los com cat restaura o original byte a byte.

Lina: Espera, "dividir" danifica o arquivo original?
Veterano Linny: Não. O split lê o conteúdo e escreve em arquivos novos. O original continua intocado.
Veterano Linny: E quando você junta os pedaços na ordem, recupera o original sem perder um único byte.
Lina: Isso é tranquilizador. Quando eu usaria isso?
Veterano Linny: Quando você precisa caber um arquivo em uma mídia com limite de tamanho, ou transferir um arquivo enorme em partes.
Veterano Linny: Também ajuda quando você quer quebrar um log gigante em pedaços mais fáceis de abrir. Vamos começar pela forma mais simples.

Primeiro, crie um arquivo para praticar.

# Criar um arquivo de treino de 50MB (so zeros por dentro)
$ head -c 50M /dev/zero > bigfile.dat

O /dev/zero é um arquivo especial que entrega zeros sem parar. O head -c 50M pega apenas os primeiros 50MB, e o > grava isso em bigfile.dat.

Muitos artigos escrevem isso com o comando dd. O dd recebe o destino no of=.

Aqui evitamos o dd. Escrever o nome de um disco no of= sobrescreve aquele disco direto. Não há lixeira nem pergunta de confirmação, e a máquina pode parar de iniciar.

Com o head -c, o destino só pode ser um arquivo comum. Fique com essa forma enquanto você está começando.

$ ls -lh bigfile.dat
-rw-r--r-- 1 user user 50M Jun  5 10:00 bigfile.dat

2. Como Dividir por Tamanho

Conclusão: Use split -b TAMANHO arquivo prefixo. -b 100M cria pedaços de 100MB, -b 10M cria pedaços de 10MB.

Lina: Deixa eu tentar cortar em pedaços de 10MB.
Veterano Linny: Use o -b, que vem de bytes.
Veterano Linny: O part_ no final é o prefixo. Ele entra no início de cada nome de arquivo gerado.
$ split -b 10M bigfile.dat part_
$ ls -lh part_*
-rw-r--r-- 1 user user 10M Jun  5 10:01 part_aa
-rw-r--r-- 1 user user 10M Jun  5 10:01 part_ab
-rw-r--r-- 1 user user 10M Jun  5 10:01 part_ac
-rw-r--r-- 1 user user 10M Jun  5 10:01 part_ad
-rw-r--r-- 1 user user 10M Jun  5 10:01 part_ae
Lina: Então fica part_aa, part_ab... com as letras aumentando.
Veterano Linny: Isso. Se você omitir o prefixo, os nomes ficam xaa, xab, e assim por diante.
Veterano Linny: As unidades de tamanho são K, M e G.
Veterano Linny: Uma atenção: 10M significa 10x1024x1024 bytes, enquanto 10MB significa 10x1000x1000 bytes. As duas contas são diferentes.

Guia prático de tamanhos

  • split -b 700M -> cabe em um CD
  • split -b 100M -> tamanho fácil para upload na nuvem
  • split -b 1G -> 1GB por pedaço

3. Como Dividir por Número de Linhas

Conclusão: Para texto e logs, split -l LINHAS arquivo prefixo divide nos limites das linhas, para que nenhuma linha seja cortada ao meio.

Lina: E quanto a dividir um arquivo de log a cada 1000 linhas?
Veterano Linny: Use o -l, que vem de linhas.
Veterano Linny: Dividir por tamanho pode cortar uma linha bem no meio. O -l sempre quebra no limite da linha.
Veterano Linny: Isso o torna bem mais seguro para arquivos CSV e logs.
$ split -l 1000 access.log chunk_
$ wc -l chunk_*
   1000 chunk_aa
   1000 chunk_ab
    342 chunk_ac
   2342 total

A divisão por tamanho com -b olha apenas a contagem de bytes. Em um arquivo de texto, isso pode deixar uma linha partida entre dois pedaços.

Quando o significado de cada linha importa, use sempre o -l.

4. Como Dividir em um Número Fixo de Pedaços

Conclusão: split -n QUANTIDADE arquivo prefixo divide o arquivo em exatamente essa quantidade de pedaços iguais.

Lina: Às vezes não me importo com "10MB cada" - só quero exatamente 5 pedaços.
Veterano Linny: Então use o -n, que vem de número.
Veterano Linny: Ele divide o arquivo inteiro em 5 partes iguais, e você nunca precisa calcular tamanhos.
$ split -n 5 bigfile.dat group_
$ ls -lh group_*
-rw-r--r-- 1 user user 10M Jun  5 10:05 group_aa
-rw-r--r-- 1 user user 10M Jun  5 10:05 group_ab
-rw-r--r-- 1 user user 10M Jun  5 10:05 group_ac
-rw-r--r-- 1 user user 10M Jun  5 10:05 group_ad
-rw-r--r-- 1 user user 10M Jun  5 10:05 group_ae

O -n 5 divide pela contagem de bytes, então em um arquivo de texto ele corta linhas ao meio.

Para obter 5 pedaços mantendo as linhas inteiras, escreva split -n l/5. O l vem de line, linha.

$ split -n l/5 access.log group_

5. Como Juntar os Pedaços de Volta

Conclusão: Nenhum comando especial é necessário. cat prefixo* > arquivo_restaurado concatena os pedaços na ordem para reconstruir o original.

Lina: Eu dividi, mas como junto de volta? Existe um comando "join"?
Veterano Linny: Boa pergunta. Existe um comando join, mas ele junta colunas de tabelas. É uma ferramenta completamente diferente.
Veterano Linny: Para remontar os pedaços do split, você usa o cat.
Lina: O comando cat que exibe arquivos?
Veterano Linny: Sim. O cat também concatena vários arquivos na ordem.
Veterano Linny: Redirecione o resultado com > para escrever em um arquivo, e pronto.
$ cat part_* > restored.dat
$ ls -lh restored.dat
-rw-r--r-- 1 user user 50M Jun  5 10:10 restored.dat

Atenção com a ordem. O * em cat part_* expande comparando os nomes como texto.

O aa, ab e ac que o split gera têm sempre a mesma largura, então a ordem sai correta.

Mas se você mesmo nomear os arquivos como part_1, part_2, ... part_10, o part_10 vem antes do part_2. Use a numeração com zeros à esquerda da próxima seção para ficar seguro.

6. Como Usar Sufixos Numerados

Conclusão: -d gera sufixos numéricos (00, 01...), -a define a quantidade de dígitos, e --additional-suffix adiciona uma extensão.

Lina: Prefiro ter 01, 02 do que aa, ab - é mais claro.
Veterano Linny: Adicione o -d para obter números. Ele vem de dígitos.
Veterano Linny: Defina a largura com o -a. E o --additional-suffix ainda permite acrescentar uma extensão como .part.
$ split -b 10M -d -a 2 --additional-suffix=.part bigfile.dat backup_
$ ls backup_*
backup_00.part  backup_01.part  backup_02.part  backup_03.part  backup_04.part

Com números preenchidos com zeros, o cat backup_*.part > restored.dat sempre junta na ordem correta. Isso porque 00, 01, ... 10, 11 têm todos a mesma largura.

Se você espera mais de 100 pedaços, use -a 3 para três dígitos.

7. Como Verificar Se o Arquivo Está Intacto

Conclusão: Compare os hashes sha256sum antes e depois. Valores iguais provam que o arquivo foi restaurado byte a byte.

Lina: Estou nervosa que o arquivo juntado não seja mesmo idêntico ao original.
Veterano Linny: Para isso serve o sha256sum. É uma impressão digital calculada a partir do conteúdo do arquivo.
Veterano Linny: Se o original e o restaurado tiverem a mesma impressão digital, o conteúdo é idêntico.
Veterano Linny: Ele também detecta corrupção que aconteceu durante uma transferência ou uma cópia.
$ sha256sum bigfile.dat restored.dat
9f2c7b1a4e6d8035c1af52e0b73d94e6...  bigfile.dat
9f2c7b1a4e6d8035c1af52e0b73d94e6...  restored.dat

(O hash depende do conteúdo do arquivo. O valor acima só mostra o formato da saída.)

Lina: As strings longas da esquerda são iguais. Que alívio.
Veterano Linny: Se fossem diferentes, seria sinal de que a ordem de junção estava errada. Os dados também podem ter sido corrompidos no transporte.
Veterano Linny: Nesse caso, refaça a divisão.

8. Lina Tropeça: Números Próprios Quebram a Ordem

Conclusão: O * expande comparando os nomes como texto. Números colocados por você, sem zeros à esquerda, quebram a ordem da junção.

Lina: Senpai, renomeei os pedaços eu mesma, de part_1 a part_10. Depois de juntar, o conteúdo estava quebrado.

Vamos ver o que aconteceu com um exemplo pequeno.

$ touch part_1 part_2 part_10
$ ls part_*
part_1
part_10
part_2
Lina: O part_10 vem antes do part_2. O tamanho do número é ignorado.
Veterano Linny: Isso. O * compara os nomes como texto, da esquerda para a direita. Na comparação entre 1 e 2, o part_10 já fica decidido em primeiro.
Lina: Então cat part_* > restored.dat junta nessa ordem?
Veterano Linny: Exatamente. O conteúdo sai fora de sequência e o arquivo restaurado fica quebrado.
Lina: Eu achei que números seriam mais claros e, no fim, eram mais arriscados. Agora fez sentido.
Veterano Linny: Por isso use -d -a 2. Com part_01, part_02 e part_10 na mesma largura, comparar como texto já dá a ordem certa.

O aa, ab e ac que o split gera também têm a mesma largura. Enquanto você não renomear nada, esse acidente de ordem não acontece.

Na dúvida, rode o sha256sum depois de juntar. Valores iguais provam que a ordem e o conteúdo estão corretos.

9. Armadilhas Comuns e Soluções

Conclusão: A maioria dos problemas vem da ordem de junção, confusão de unidades ou falta de espaço em disco. Verifique a capacidade e as unidades antes de dividir.

Sintoma Causa Solução
Arquivo juntado está corrompido Ordem de junção errada Use -d com zeros e cat ...*
Mais/menos pedaços que o esperado M (1024) vs MB (1000) Use uma unidade consistentemente
No space left on device Dividir precisa de ~2x o espaço Verifique espaço livre com df -h primeiro
Linhas de texto cortadas ao meio Você usou -b (bytes) Divida novamente com -l (linhas)

Faça sempre isso, antes e depois de dividir

  • Teste a junção antes de apagar o original
  • Compare os hashes com o sha256sum depois de juntar os pedaços
  • Verifique o espaço livre com df -h antes de começar a dividir

O split e o sha256sum ainda não existem no terminalUm programa interativo que interpreta os comandos digitados e os executa. virtual deste site. Teste os exemplos deste artigo no seu próprio Linux ou terminal.

Apague o original apenas depois que a junção e a verificação de hash derem certo. Diferente de um ambiente gráfico, o rm não manda os arquivos para a lixeira. Eles somem na hora.

10. Mini Exercícios: Tente Você Mesmo

Conclusão: Três exercícios -- dividir por linha, juntar e conferir o hash -- percorrem o caminhoUma sequência de texto que descreve a localização de um arquivo ou diretório. completo na prática.

Lina: Entendi os passos. Quero confirmar na prática.
Veterano Linny: Ótimo. Aqui vão três tarefas. Crie primeiro um diretórioUm local que organiza arquivos. É a mesma ideia da "pasta" do Windows ou macOS. de treino e trabalhe dentro dele.
$ mkdir -p ~/split-practice && cd ~/split-practice
$ seq 1 25 > numbers.txt

Tarefa 1: Divida numbers.txt em pedaços de 10 linhas e confira a contagem de linhas.

Ver dica 1 (direcionamento)

Divida pelo número de linhas, e não pelo tamanho. Use a opção que respeita o limite das linhas.

Ver dica 2 (nome do comando)

Você precisa do split e do wc. O split tem uma opção que divide pela contagem de linhas.

Ver a resposta 
$ split -l 10 numbers.txt num_
$ wc -l num_*
10 num_aa
10 num_ab
 5 num_ac
25 total

São 25 linhas divididas de 10 em 10, então só o último pedaço fica com 5.

Tarefa 2: Junte os pedaços de volta em um arquivo chamado joined.txt.

Ver dica 1 (direcionamento)

Não é preciso nenhum comando especial. Use aquele que concatena vários arquivos na ordem.

Ver dica 2 (nome do comando)

O comando é o cat. O símbolo que grava a saída em um arquivo apareceu na seção 5.

Ver a resposta 
$ cat num_* > joined.txt
$ wc -l joined.txt
25 joined.txt

De volta às 25 linhas do original.

Tarefa 3: Confirme que numbers.txt e joined.txt são exatamente iguais.

Ver dica 1 (direcionamento)

A mesma contagem de linhas não prova o mesmo conteúdo. Compare a impressão digital calculada de cada arquivo.

Ver dica 2 (nome do comando)

O comando é o sha256sum. Ele aceita dois nomes de arquivo lado a lado.

Ver a resposta 
$ sha256sum numbers.txt joined.txt

Se as strings longas da esquerda forem iguais nas duas linhas, o conteúdo bate exatamente.

Quando terminar o treino, dá para remover o diretório inteiro. Olhe o conteúdo antes de apagar.

$ cd ~
$ ls ~/split-practice
$ rm -r ~/split-practice

O rm -r apaga o diretório junto com tudo que está dentro dele. Confirme que o caminho é mesmo ~/split-practice antes de executar.

11. Revisão

Lina: Vou resumir. O split corta e o cat reconstrói. Não entra nenhum comando dedicado de junção.
Veterano Linny: Exato. E há três formas de cortar: -b por tamanho, -l por linhas e -n por quantidade de pedaços.
Lina: Texto e log pedem -l, porque assim nenhuma linha é cortada ao meio.
Veterano Linny: Perfeito. E termine com o sha256sum. Com esse hábito, dá para apagar o original com confiança.

Resumo de Hoje em 3 Linhas

  1. O split corta o arquivo e o cat prefixo* > arquivo_restaurado reconstrói
  2. -b para tamanho, -l para linhas, -n para quantidade de pedaços. Texto e log pedem -l
  3. Depois de juntar, compare com sha256sum e só apague o original quando os valores baterem

Resumo / Próximas Leituras