In this post I show you how to use the split utility in Unix-based systems, an utility to split files into smaller parts.

In questo post vi mostro come usare il programma split su sistemi basati su Unix, un programma per dividere file in parti più piccole.

How to split and restore files on Unix-based systems

Hello world!
Have you ever had the need to transfer a very big file (or several ones) from a system to another?
Maybe you have a pendrive to store it, but, because it is FAT-formatted the copy procedure stops?
If that's the case, this post is for you.

As you remember, I switched to the Debian distribution, but in order for me to do that, I had to perform a full backup of my personal data.
I had a 12 Gb VirtualBox hard disk image (fixed length) and in order to backup it (I was using an old 5th generation iPod video formatted by Windows), I had to first split the file into 4 parts, copy them on the iPod, finish the installation, and rebuild the original file from the new installed system.

I had this "WindowsXP.vdi" file, I split it by invoking a terminal window and typing:

split --numeric-suffixes --bytes=3G WindowsXP.vdi "WinPart"

All this does is to split the 12 Gb file into the files "WinPart00", "WinPart01", "WinPart02" and "WinPart03".
Each file will be named "WinPartNN", where WinPart is the prefix ("x" if not specified) and "NN" is a numeric suffix indicating the order of the single parts.

Let's see the available options in more detail:

  • --numeric-suffixes or -d:
    They specify to use numbers as suffixes instead of letters.
  • --suffix-length=N or -a N: They specify the suffix length (default length is 2)
  • --bytes or -b N: They specify the dimension of each part.
    The size is in bytes, but you can use the following multipliers to simplify calculations:
    • K or KB
      (1 K = 1024 bytes, 1 KB = 1000 bytes)
    • M or MB
      (1 M = 1024 K, 1 MB = 1000 KB)
    • G or GB
      (1 G = 1024 M, 1 GB = 1000 MB)
    • T or TB
      (1 T = 1024 G, 1 TB = 1000 GB)
    • P or PB
      (1 P = 1024 T, 1 PB = 1000 TB)
    • E or EB
      (1 E = 1024 P, 1 EB = 1000 PB)
    • Z or ZB
      (1 Z = 1024 E, 1 ZB = 1000 EB)
    • Y or YB
      (1 Y = 1024 Z, 1 YB = 1000 ZB)
  • --lines=N or -l N: They specify how many lines (intended as text line) each part must contain (useful for text files).
  • --line-bytes=N or -C N: They specify how many characters each part must contain (please notice that if a newline character is encountered, the current part is considered full and the remaining characters will be carried over to the next part).

Well, I've described the options, but in order to understand, it's best to see them in action.
For simplicity, I will use all the features on text files, so it is easy to test the result.
The file is named "test.txt" and contains the following text:

Hi guys! How are you? I hope you're fine.
This is an example in order to make you understand how to use this program.
Today the weather's fine.
Yesterday I watched the Back to the Future Trilogy.
I did that one month ago.
Who you're going to call?

Every file contains at most 4 lines

  • Input
    split test.txt -l 4
  • Output
    • File "xa"
      Hi guys! How are you? I hope you're fine.
      This is an example in order to make you understand how to use this program.
      Today the weather's fine.
      Yesterday I watched the Back to the Future Trilogy.
    • File "xb":
      I did that one month ago.
      Who you're going to call?

Every part will have the prefix "expr" and will contain at most 50 characters

  • Input
    split test.txt -C 50 expr
  • Output
    • File "expra"
      Hi guys! How are you? I hope you're fine.
    • File "exprb"
      This is an example in order to make you understand 
    • File "exprc"
      how to use this program.
    • File "exprd"
      Today the weather's fine.
    • File "expre"
      Yesterday I watched the Back to the Future Trilogy
    • File "exprf"
      .
    • File "exprg"
      I did that one month ago.
    • File "exprh"
      Who you're going to call?

Every part will have the prefix "expr", numeric suffixes with 4 digits, and a size of 10 bytes each

  • Input
    split test.txt -d -a 4 -b 10 expr
  • Output
    • File "expr0000"
      Hi guys! H
    • File "expr0001"
      ow are you
    • File "expr0002"
      ? I hope y
    • Etcetera

Well, let's say we managed to split our file and we brought the parts where we needed to, now what?
We need a way to restore the original file, otherwise, these parts can be considered junk.
We're going to use an utility called cat.

Normally, the cat command is used to show the content of files.
If you provide two or more files, the program will show the contents consecutively, as if they were a single file.
Considering that in Unix, you can "grab" the output of programs and put it to file, we can provide all the parts to the cat utility, redirect the output to a new file, and expect this new file to become our original file.

To do this, you may want to use the command cat as follows:

cat filepart0 filepart1 filepart2 ... > restoredfile

To use my VirtualBox example again, in order to get my original file, I would have to type:

cat WinPart00 WinPart01 WinPart02 WinPart03 > WindowsXP.vdi

That's all for today, I hope this post will be useful to anyone, and see you another time, in another post!

Go back to the top, Share, Look at the comments or Comment yourself!

Come dividere e ripristinare file su sistemi basati su Unix

Salve mondo!
Avete mai avuto la necessità di trasferire un file molto grande (o molti file grandi) da un sistema all'altro?
Magari avete una pennetta usb per immagazzinarlo, ma poiché è formattata FAT la procedura di copia si ferma?
Se questo è il vostro caso, questo post fa per voi.

Come ricorderete, sono passato sulla distribuzione Debian, ma per poterlo fare, ho dovuto effettuare un backup totale dei miei dati personali.
Avevo un'immagine di hard disk di VirtualBox da 12 Gb (a lunghezza fissa) e per salvarlo (usavo un vecchio iPod video di quinta generazione formattato su Windows), ho dovuto suddividere il file in 4 parti, copiarle sull'iPod, finire l'installazione, e ricostruire il file di origine dal nuovo sistema installato.

Avevo questo file "WindowsXP.vdi", l'ho suddiviso invocando una finestra di terminale e digitando:

split --numeric-suffixes --bytes=3G WindowsXP.vdi "WinPart"

Questo comando suddivide il file da 12 Gb nei file "WinPart00", "WinPart01", "WinPart02" e "WinPart03".
Ogni file verrà chiamato "WinPartNN", dove WinPart è il prefisso ("x" se non specificato) e "NN" è un suffisso numerico indicante l'ordine delle singole parti.

Vediamo le opzioni disponibili più in dettaglio:

  • --numeric-suffixes o -d:
    Specificano di usare numeri come suffissi invece delle lettere.
  • --suffix-length=N o -a N: Specificano la lunghezza del suffisso (la lunghezza predefinita è 2)
  • --bytes o -b N: Specificano la dimensione di ogni parte:
    La dimensione è in byte, tuttavia è possibile usare i seguenti moltiplicatori per semplificare i calcoli:
    • K or KB
      (1 K = 1024 byte, 1 KB = 1000 byte)
    • M or MB
      (1 M = 1024 K, 1 MB = 1000 KB)
    • G or GB
      (1 G = 1024 M, 1 GB = 1000 MB)
    • T or TB
      (1 T = 1024 G, 1 TB = 1000 GB)
    • P or PB
      (1 P = 1024 T, 1 PB = 1000 TB)
    • E or EB
      (1 E = 1024 P, 1 EB = 1000 PB)
    • Z or ZB
      (1 Z = 1024 E, 1 ZB = 1000 EB)
    • Y or YB
      (1 Y = 1024 Z, 1 YB = 1000 ZB)
  • --lines=N o -l N: Specificano quante righe (intese come righe di testo) ogni parte debba contenere (utile per i file di testo).
  • --line-bytes=N o -C N: Specificano quanti caratteri ogni parte debba contenere (vi faccio notare che se viene incontrato il carattere di nuova riga, la parte attuale viene considerata completa e i caratteri rimasti verranno assegnati alla parte successiva).

Bene, ho descritto le opzioni, ma per poter capire, è meglio vederle in azione.
Per semplicità, userò tutte le caratteristiche del programma su file di testo, cosìcche sia più semplice testare il risultato.
Il file si chiama "test.txt" e contiene il testo seguente:

Hi guys! How are you? I hope you're fine.
This is an example in order to make you understand how to use this program.
Today the weather's fine.
Yesterday I watched the Back to the Future Trilogy.
I did that one month ago.
Who you're going to call?

Ogni file contiene al massimo 4 righe

  • Input
    split test.txt -l 4
  • Output
    • File "xa"
      Hi guys! How are you? I hope you're fine.
      This is an example in order to make you understand how to use this program.
      Today the weather's fine.
      Yesterday I watched the Back to the Future Trilogy.
    • File "xb":
      I did that one month ago.
      Who you're going to call?

Ogni parte avrà come prefisso "expr" e conterrà al massimo 50 caratteri

  • Input
    split test.txt -C 50 expr
  • Output
    • File "expra"
      Hi guys! How are you? I hope you're fine.
    • File "exprb"
      This is an example in order to make you understand 
    • File "exprc"
      how to use this program.
    • File "exprd"
      Today the weather's fine.
    • File "expre"
      Yesterday I watched the Back to the Future Trilogy
    • File "exprf"
      .
    • File "exprg"
      I did that one month ago.
    • File "exprh"
      Who you're going to call?

Ogni parte avrà il prefisso "expr", suffissi numerici con almeno 4 cifre, e una dimensione di 10 byte ciascuna

  • Input
    split test.txt -d -a 4 -b 10 expr
  • Output
    • File "expr0000"
      Hi guys! H
    • File "expr0001"
      ow are you
    • File "expr0002"
      ? I hope y
    • Eccetera

Bene, diciamo di essere riusciti a suddividere il nostro file e che abbiamo portato le parti dove ci servivano, cosa si fa adesso?
Ci serve un modo per ripristinare il file d'origine, altrimente, questi file potremo considerarli spazzatura.
Utilizzeremo il programma chiamato cat.

Normalmente, il comando cat viene utilizzato per mostrare il contenuto dei file.
Se gli vengono forniti due o più file, il programma mostrerà i rispettivi contenuti consecutivamente, come se fossero un singolo file.
Poiché in Unix è possibile "catturare" l'output dei programmi e metterlo su file, possiamo fornire a cat tutte le parti, redirigere l'output su un nuovo file, e aspettarci che questo nuovo file diventi il file di origine.

Per fare ciò si dovrebbe usare il comando cat in questo modo:

cat filepart0 filepart1 filepart2 ... > restoredfile

Per usare ancora l'esempio di VirtualBox, per ottenere il mio file d'origine, dovrei digitare:

cat WinPart00 WinPart01 WinPart02 WinPart03 > WindowsXP.vdi

Questo è tutto per oggi, spero che questo post vi torni utile e ci si vede un'altra volta, in un altro post!

Torna in cima, Condividi, Guarda i commenti o Commenta tu stesso!