Para ayudarlo a aprender sobre el comando dividir, estoy usando un archivo de texto relativamente grande que contiene 17170 líneas y 1.4 MB de tamaño. Puede descargar una copia de este archivo desde el enlace de GitHub.
Tenga en cuenta que no mostraré directamente la salida en estos ejemplos debido al gran tamaño de los archivos. Usaré los comandos ll y wc para resaltar los cambios de archivo.
Le aconsejo que eche un vistazo rápido al comando wc para comprender el resultado de los ejemplos del comando split.
Ejemplos del comando Split en Linux
Esta es la sintaxis del comando Dividir:
split [options] filename [prefix]Veamos cómo usarlo para dividir archivos en Linux.
1. Dividir archivos en varios archivos
De forma predeterminada, el comando dividir crea nuevos archivos por cada 1000 líneas. Si no se especifica ningún prefijo, utilizará 'x'. Las letras que siguen enumeran los archivos, por lo que xaa va primero, luego xab, y así sucesivamente.
Dividamos el archivo de registro de muestra:
split someLogFile.logSi usa el comando ls, puede ver varios archivos nuevos en su directorio.
[email protected]:~/Documents$ ls
someLogFile.log xab xad xaf xah xaj xal xan xap xar
xaa xac xae xag xai xak xam xao xaqPuede usar wc para comprobar rápidamente el número de líneas después de la división.
[email protected]:~/Documents$ wc -l xaa xaq xar
1000 xaa
1000 xaq
170 xarRecuerde que anteriormente vimos que nuestro archivo inicial tenía 17.170 líneas. Entonces podemos ver que nuestro programa ha funcionado como se esperaba al crear 18 archivos nuevos. 17 de ellos tienen 1000 líneas cada uno y el último tiene las 170 líneas restantes.
Otra forma en que podemos demostrar lo que está sucediendo es ejecutar el comando con la opción detallada. Si no estás familiarizado con verbose, ¡te lo estás perdiendo! Proporciona información más detallada sobre lo que está haciendo su sistema y está disponible para usar con muchos comandos.
split someLogFile.log --verbosePuede ver lo que sucede con su comando en la pantalla:
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. Dividir archivos en varios archivos con números de línea específicos
Entiendo que puede que no le guste que los archivos se dividan en archivos de 1000 líneas. Puedes cambiar este comportamiento con -l opción.
Cuando se agrega esto, ahora puede especificar cuántas líneas desea en cada uno de los nuevos archivos.
split someLogFile.log -l 500Como puede adivinar, ahora los archivos divididos tienen 500 líneas cada uno, excepto el último.
[email protected]:~/Documents$ wc -l xbh xbi
500 xbh
170 xbiAhora tienes muchos más archivos, pero con la mitad de líneas en cada uno.
3. Dividir los archivos en n número de archivos
El -n La opción facilita la división en un número designado de piezas o trozos. Puede asignar cuántos archivos desea agregando un valor entero después de -n.
split someLogFile.log -n 15Ahora puede ver que hay 15 archivos nuevos.
[email protected]:~/Documents$ ls
someLogFile.log xaa xab xac xad xae xaf xag xah xai xaj xak xal xam xan xao4. Dividir archivos con prefijo de nombre personalizado
¿Qué sucede si desea usar la división pero mantener el nombre original de mi archivo o crear un nuevo nombre en lugar de usar 'x'?
Es posible que recuerde haber visto el prefijo como parte de la sintaxis descrita al principio del artículo. Puede escribir su propio nombre de archivo personalizado después del archivo de origen.
split someLogFile.log someSeparatedLogFiles.log_Aquí están los archivos divididos con nombres que comienzan con el prefijo dado.
[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. Dividir y especificar la longitud del sufijo
Split presenta una longitud de sufijo predeterminada de 2 [aa, ab, etc.]. Esto cambiará automáticamente a medida que aumente la cantidad de archivos, pero si desea cambiarlo manualmente, también es posible. Entonces, digamos que desea que nuestros archivos se llamen algo así como someSeparatedLogFiles.log_aaaab.
¿Cómo puedes hacer esto? La opción -a nos permite especificar la longitud del sufijo.
split someLogFile.log someSeparatedLogFiles.log_ -a 5Y aquí están los archivos divididos:
[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. Dividir con sufijo de orden numérico
Hasta este punto, ha visto sus archivos separados usando diferentes combinaciones de letras. Personalmente, me resulta mucho más fácil distinguir archivos mediante números.
Mantengamos la longitud del sufijo del ejemplo anterior, pero cambiemos la organización alfabética a numérica con la opción -d .
split someLogFile.log someSeparatedLogFiles.log_ -a 5 -dAsí que ahora tendrá archivos divididos con suficiencias numéricas.
[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. Agregue sufijos hexadecimales para dividir archivos
Otra opción para la creación de sufijos es usar el sufijo hexadecimal integrado que alterna letras y números ordenados.
Para este ejemplo, combinaré algunas cosas que ya te he mostrado. Dividiré el archivo usando mi propio prefijo. Elegí un guión bajo para facilitar la lectura.
Usé el -x opción para crear un sufijo hexadecimal. Luego dividí nuestro archivo en 50 fragmentos y le di al sufijo una longitud de 6.
split someLogFile.log _ -x -n50 -a6Y aquí está el resultado del comando anterior:
[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. Dividir archivos en múltiples archivos de tamaño específico
También es posible usar el tamaño del archivo para dividir archivos en división. Tal vez necesite enviar un archivo grande a través de una red con límite de tamaño de la manera más eficiente posible. Puede especificar el tamaño exacto para sus requisitos.
La sintaxis puede volverse un poco complicada a medida que continuamos agregando opciones. Entonces, explicaré cómo -b el comando funciona antes de mostrar el ejemplo.
Cuando desee crear archivos de un tamaño específico, use -b opción. A continuación, puede escribir n K[B], n M[B], n G[B] donde n es el valor del tamaño de su archivo y K [1024] es -kibi, M es -mebi, G es -gibi, y así sucesivamente. KB [1000] es kilo, MB – mega, etc.
Puede parecer que están sucediendo muchas cosas, pero no es tan complejo cuando lo desglosas. Ha especificado el archivo de origen, nuestro prefijo de nombre de archivo de destino, un sufijo numérico y una separación por tamaño de archivo de 128 KB.
split someLogFile.log someSeparatedLogFiles.log_ -d -b 128KBAquí están los archivos divididos:
[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_10Puede verificar el resultado con el 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. Dividir archivos en varios archivos de tamaño "como máximo" n con
Si desea dividir archivos en aproximadamente el mismo tamaño, pero conservando la estructura de líneas, esta podría ser la mejor opción para usted. Con -C , puede especificar un tamaño máximo. Luego, el programa dividirá automáticamente los archivos en función de las líneas completas.
split someLogFile.log someNewLogFiles.log_ -d -C 1MBPuede ver en la salida que el primer archivo dividido tiene un tamaño de casi 1 MB, mientras que el resto del archivo está en el segundo archivo.
[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_01Consejo adicional:volver a unir archivos divididos
Este no es un comando dividido, pero podría ser útil para los nuevos usuarios.
[email protected]:~/Documents$ ls
xaa xab xac xad xae xaf xag xah xai xaj xak xal xam xan xao xap xaq xarPuede usar otro comando para volver a unir esos archivos y crear una réplica de nuestro documento completo. El comando cat es la abreviatura de concatenar, que es solo una palabra elegante que significa "unir elementos". Dado que todos los archivos comienzan con la letra 'x', el asterisco aplicará el comando a cualquier archivo que comience con esa letra.
[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 xaqComo puede ver, nuestro archivo recreado tiene el mismo tamaño que el original.
wc -l recreatedLogFile.log
17170 recreatedLogFile.logNuestro formato (incluido el número de líneas) se conserva en el archivo creado.
Si eres nuevo en Linux, espero que este tutorial te haya ayudado a comprender el comando dividir. Si tienes más experiencia, ¡cuéntanos tu forma favorita de usar la división en los comentarios a continuación!
Principiante o experimentado, le sugiero que también mire el comando csplit, que es una forma ligeramente mejor de dividir archivos en la línea de comandos de Linux.