Per aiutarti a conoscere il comando split, sto usando un file di testo relativamente grande contenente 17170 righe e una dimensione di 1,4 MB. Puoi scaricare una copia di questo file dal link GitHub.
Nota che non visualizzerò direttamente l'output in questi esempi a causa delle grandi dimensioni dei file. Userò i comandi ll e wc per evidenziare le modifiche ai file.
Ti consiglio di dare una rapida occhiata al comando wc per capire l'output degli esempi di comando split.
Esempi di comando Split in Linux
Questa è la sintassi del comando Dividi:
split [options] filename [prefix]Vediamo come usarlo per dividere i file in Linux.
1. Dividi i file in più file
Per impostazione predefinita, il comando dividi crea nuovi file ogni 1000 righe. Se non viene specificato alcun prefisso, utilizzerà 'x'. Le lettere che seguono enumerano i file, quindi viene prima xaa, poi xab e così via.
Dividiamo il file di registro di esempio:
split someLogFile.logSe usi il comando ls, puoi vedere più nuovi file nella tua directory.
[email protected]:~/Documents$ ls
someLogFile.log xab xad xaf xah xaj xal xan xap xar
xaa xac xae xag xai xak xam xao xaqPuoi utilizzare wc per controllare rapidamente i conteggi delle righe dopo la divisione.
[email protected]:~/Documents$ wc -l xaa xaq xar
1000 xaa
1000 xaq
170 xarRicorda da prima che abbiamo visto che il nostro file iniziale aveva 17.170 righe. Quindi possiamo vedere che il nostro programma ha fatto come previsto creando 18 nuovi file. 17 di essi sono riempiti con 1000 righe ciascuno e l'ultimo ha le restanti 170 righe.
Un altro modo per dimostrare cosa sta succedendo è eseguire il comando con l'opzione dettagliata. Se non hai familiarità con il verbose, ti stai perdendo! Fornisce un feedback più dettagliato su ciò che sta facendo il tuo sistema ed è disponibile per l'uso con molti comandi.
split someLogFile.log --verbosePuoi vedere cosa sta succedendo con il tuo comando sul display:
creating file 'xaa'
creating file 'xab'
creating file 'xac'
creating file 'xad'
creating file 'xae'
creating file 'xaf'
creating file 'xag'
creating file 'xah'
creating file 'xai'
creating file 'xaj'
creating file 'xak'
creating file 'xal'
creating file 'xam'
creating file 'xan'
creating file 'xao'
creating file 'xap'
creating file 'xaq'
creating file 'xar'2. Dividi i file in più file con numeri di riga specifici
Capisco che potrebbe non piacerti che i file siano divisi in file di 1000 righe. Puoi modificare questo comportamento con -l opzione.
Quando questo viene aggiunto, ora puoi specificare quante righe vuoi in ciascuno dei nuovi file.
split someLogFile.log -l 500Come puoi intuire, ora i file divisi hanno 500 righe ciascuno, tranne l'ultima.
[email protected]:~/Documents$ wc -l xbh xbi
500 xbh
170 xbiOra hai molti più file, ma con la metà delle righe in ciascuno.
3. Dividi i file in n numero di file
Il -n l'opzione rende facile la divisione in un numero designato di pezzi o pezzi. Puoi assegnare quanti file vuoi aggiungendo un valore intero dopo -n.
split someLogFile.log -n 15Ora puoi vedere che ci sono 15 nuovi file.
[email protected]:~/Documents$ ls
someLogFile.log xaa xab xac xad xae xaf xag xah xai xaj xak xal xam xan xao4. Dividi i file con un prefisso del nome personalizzato
E se volessi usare la divisione ma mantenere il nome originale del mio file o creare un nuovo nome del tutto invece di usare "x"?
Potresti ricordare di aver visto il prefisso come parte della sintassi descritta all'inizio dell'articolo. Puoi scrivere il tuo nome file personalizzato dopo il file di origine.
split someLogFile.log someSeparatedLogFiles.log_Ecco i file divisi con nomi che iniziano con il prefisso specificato.
[email protected]:~/Documents$ ls
someLogFile.log someSeparatedLogFiles.log_aj
someSeparatedLogFiles.log_aa someSeparatedLogFiles.log_ak
someSeparatedLogFiles.log_ab someSeparatedLogFiles.log_al
someSeparatedLogFiles.log_ac someSeparatedLogFiles.log_am
someSeparatedLogFiles.log_ad someSeparatedLogFiles.log_an
someSeparatedLogFiles.log_ae someSeparatedLogFiles.log_ao
someSeparatedLogFiles.log_af someSeparatedLogFiles.log_ap
someSeparatedLogFiles.log_ag someSeparatedLogFiles.log_aq
someSeparatedLogFiles.log_ah someSeparatedLogFiles.log_ar
someSeparatedLogFiles.log_ai5. Dividi e specifica la lunghezza del suffisso
Split presenta una lunghezza del suffisso predefinita di 2 [aa, ab, ecc.]. Questo cambierà automaticamente all'aumentare del numero di file, ma se desideri modificarlo manualmente, è anche possibile. Quindi supponiamo che tu voglia che i nostri file abbiano un nome come someSeparatedLogFiles.log_aaaab.
Come puoi farlo? L'opzione -a ci permette di specificare la lunghezza del suffisso.
split someLogFile.log someSeparatedLogFiles.log_ -a 5Ed ecco i file divisi:
[email protected]:~/Documents$ ls
someLogFile.log someSeparatedLogFiles.log_aaaae someSeparatedLogFiles.log_aaaaj someSeparatedLogFiles.log_aaaao
someSeparatedLogFiles.log_aaaaa someSeparatedLogFiles.log_aaaaf someSeparatedLogFiles.log_aaaak someSeparatedLogFiles.log_aaaap
someSeparatedLogFiles.log_aaaab someSeparatedLogFiles.log_aaaag someSeparatedLogFiles.log_aaaal someSeparatedLogFiles.log_aaaaq
someSeparatedLogFiles.log_aaaac someSeparatedLogFiles.log_aaaah someSeparatedLogFiles.log_aaaam someSeparatedLogFiles.log_aaaar
someSeparatedLogFiles.log_aaaad someSeparatedLogFiles.log_aaaai someSeparatedLogFiles.log_aaaan6. Dividi con suffisso ordine numerico
Fino a questo punto, hai visto i tuoi file separati utilizzando diverse combinazioni di lettere. Personalmente, trovo molto più facile distinguere i file usando i numeri.
Manteniamo la lunghezza del suffisso dell'esempio precedente, ma cambiamo l'organizzazione alfabetica in numerica con l'opzione -d .
split someLogFile.log someSeparatedLogFiles.log_ -a 5 -dQuindi ora avrai file divisi con numeri sufficienti.
[email protected]:~/Documents$ ls
someLogFile.log someSeparatedLogFiles.log_00004 someSeparatedLogFiles.log_00009 someSeparatedLogFiles.log_00014
someSeparatedLogFiles.log_00000 someSeparatedLogFiles.log_00005 someSeparatedLogFiles.log_00010 someSeparatedLogFiles.log_00015
someSeparatedLogFiles.log_00001 someSeparatedLogFiles.log_00006 someSeparatedLogFiles.log_00011 someSeparatedLogFiles.log_00016
someSeparatedLogFiles.log_00002 someSeparatedLogFiles.log_00007 someSeparatedLogFiles.log_00012 someSeparatedLogFiles.log_00017
someSeparatedLogFiles.log_00003 someSeparatedLogFiles.log_00008 someSeparatedLogFiles.log_000137. Aggiungi suffissi esadecimali per dividere i file
Un'altra opzione per la creazione del suffisso è quella di utilizzare il suffisso esadecimale integrato che alterna lettere e numeri ordinati.
Per questo esempio, combinerò alcune cose che ti ho già mostrato. Dividerò il file usando il mio prefisso. Ho scelto un trattino basso per motivi di leggibilità.
Ho usato -x opzione per creare un suffisso esadecimale. Quindi ho diviso il nostro file in 50 blocchi e ho assegnato al suffisso una lunghezza di 6.
split someLogFile.log _ -x -n50 -a6Ed ecco il risultato del comando precedente:
[email protected]:~/Documents$ ls
_000000 _000003 _000006 _000009 _00000c _00000f _000012 _000015 _000018 _00001b _00001e _000021 _000024 _000027 _00002a _00002d _000030
_000001 _000004 _000007 _00000a _00000d _000010 _000013 _000016 _000019 _00001c _00001f _000022 _000025 _000028 _00002b _00002e _000031
_000002 _000005 _000008 _00000b _00000e _000011 _000014 _000017 _00001a _00001d _000020 _000023 _000026 _000029 _00002c _00002f someLogFile.log8. Dividi i file in più file di dimensioni specifiche
È anche possibile utilizzare la dimensione del file per suddividere i file in una divisione. Forse è necessario inviare un file di grandi dimensioni su una rete con limite di dimensioni nel modo più efficiente possibile. Puoi specificare la dimensione esatta per le tue esigenze.
La sintassi può diventare un po' complicata mentre continuiamo ad aggiungere opzioni. Quindi, spiegherò come funziona il -b il comando funziona prima di mostrare l'esempio.
Quando vuoi creare file di una dimensione specifica, usa il -b opzione. Puoi quindi scrivere n K[B], n M[B], n G[B] dove n è il valore della dimensione del tuo file e K [1024] è -kibi, M è -mebi, G è -gibi e così via. KB [1000] è kilo, MB – mega ecc.
Può sembrare che ci siano molte cose da fare, ma non è così complesso quando lo scomponi. Hai specificato il file di origine, il prefisso del nome del file di destinazione, un suffisso numerico e una separazione per dimensione del file di 128 kB.
split someLogFile.log someSeparatedLogFiles.log_ -d -b 128KBEcco i file divisi:
[email protected]:~/Documents$ ls
someLogFile.log someSeparatedLogFiles.log_02 someSeparatedLogFiles.log_05 someSeparatedLogFiles.log_08
someSeparatedLogFiles.log_00 someSeparatedLogFiles.log_03 someSeparatedLogFiles.log_06 someSeparatedLogFiles.log_09
someSeparatedLogFiles.log_01 someSeparatedLogFiles.log_04 someSeparatedLogFiles.log_07 someSeparatedLogFiles.log_10Puoi verificare il risultato con il comando 'wc'.
[email protected]:~/Documents$ wc someSeparatedLogFiles.log_0*
1605 4959 128000 someSeparatedLogFiles.log_00
1605 4969 128000 someSeparatedLogFiles.log_01
1605 4953 128000 someSeparatedLogFiles.log_02
1605 4976 128000 someSeparatedLogFiles.log_03
1605 4955 128000 someSeparatedLogFiles.log_04
1605 4975 128000 someSeparatedLogFiles.log_05
1605 4966 128000 someSeparatedLogFiles.log_06
1605 4964 128000 someSeparatedLogFiles.log_07
1605 4968 128000 someSeparatedLogFiles.log_08
1605 4959 128000 someSeparatedLogFiles.log_09
16050 49644 1280000 total9. Dividi i file in più file di dimensione "Al massimo" n con
Se desideri dividere i file più o meno nella stessa dimensione, ma preservare la struttura della linea, questa potrebbe essere la scelta migliore per te. Con -C , puoi specificare una dimensione massima. Quindi il programma dividerà automaticamente i file in base a righe complete.
split someLogFile.log someNewLogFiles.log_ -d -C 1MBPuoi vedere nell'output che il primo file diviso ha una dimensione di quasi 1 MB mentre il resto del file si trova nel secondo file.
[email protected]:~/Documents$ ll
total 2772
drwxr-xr-x 2 chris chris 81920 Jul 24 22:01 ./
drwxr-xr-x 19 chris chris 4096 Jul 23 22:23 ../
-rw-r--r-- 1 chris chris 1369273 Jul 20 17:52 someLogFile.log
-rw-r--r-- 1 chris chris 999997 Jul 24 22:01 someNewLogFiles.log_00
-rw-r--r-- 1 chris chris 369276 Jul 24 22:01 someNewLogFiles.log_01Suggerimento bonus:ricongiungere i file divisi
Questo non è un comando diviso, ma potrebbe essere utile per i nuovi utenti.
[email protected]:~/Documents$ ls
xaa xab xac xad xae xaf xag xah xai xaj xak xal xam xan xao xap xaq xarPuoi usare un altro comando per riunire quei file e creare una replica del nostro documento completo. Il comando cat è l'abbreviazione di concatenate, che è solo una parola di fantasia che significa "unire elementi insieme". Poiché tutti i file iniziano con la lettera "x", l'asterisco applicherà il comando a tutti i file che iniziano con quella lettera.
[email protected]:~/Documents$ cat x* > recoveredLogFile.log
[email protected]:~/Documents$ ls
recoveredLogFile.log xab xad xaf xah xaj xal xan xap xar
xaa xac xae xag xai xak xam xao xaqCome puoi vedere, il nostro file ricreato ha le stesse dimensioni del nostro originale.
wc -l recreatedLogFile.log
17170 recreatedLogFile.logLa nostra formattazione (compreso il numero di righe) viene preservata nel file creato.
Se non conosci Linux, spero che questo tutorial ti abbia aiutato a comprendere il comando split. Se sei più esperto, dicci il tuo modo preferito di utilizzare lo split nei commenti qui sotto!
Principiante o esperto, ti suggerirei di guardare anche il comando csplit che è un modo leggermente migliore per dividere i file nella riga di comando di Linux.