combinar archivos de texto en columnas

Agradeceríamos tu apoyo para compartir nuestros ensayos sobre las ciencias de la computación.

Solución:

Solo necesitas el column comando, y dígale que use pestañas para separar columnas

paste file1 file2 | column -s $'t' -t

Para abordar la controversia de la “celda vacía”, solo necesitamos -n opción a column:

$ paste <(echo foo; echo; echo barbarbar) <(seq 3) | column -s $'t' -t
foo        1
2
barbarbar  3

$ paste <(echo foo; echo; echo barbarbar) <(seq 3) | column -s $'t' -tn
foo        1
           2
barbarbar  3

La página de manual de mi columna indica -n es una "extensión Debian GNU / Linux". Mi sistema Fedora no presenta el problema de las celdas vacías: parece derivar de BSD y la página de manual dice "La versión 2.23 cambió la opción -s para que no sea codiciosa"

Estás buscando al dandy útil pr mando:

paste file1 file2 | pr -t -e24

El "-e24" es "expandir tabuladores a 24 espacios". Afortunadamente, paste pone un carácter de tabulación entre columnas, por lo que pr puede expandirlo. Elegí 24 contando los caracteres en "Recursivamente enumerable" y agregando 2.

Actualizar: Aquí hay un script mucho más simple (que el que está al final de la pregunta) para la salida tabulada. Simplemente pase el nombre del archivo como lo haría paste... Usa html para hacer el marco, por lo que se puede modificar. Conserva varios espacios y la alineación de la columna se conserva cuando encuentra caracteres Unicode. Sin embargo, la forma en que el editor o visor representa el Unicode es otro asunto completamente ...

┌──────────────────────┬────────────────┬──────────┬────────────────────────────┐
│ Languages            │ Minimal        │ Chomsky  │ Unrestricted               │
├──────────────────────┼────────────────┼──────────┼────────────────────────────┤
│ Recursive            │ Turing machine │ Finite   │     space indented         │
├──────────────────────┼────────────────┼──────────┼────────────────────────────┤
│ Regular              │ Grammars       │          │ ➀ unicode may render oddly │
├──────────────────────┼────────────────┼──────────┼────────────────────────────┤
│ 1 2  3   4    spaces │                │ Symbol-& │ but the column count is ok │
├──────────────────────┼────────────────┼──────────┼────────────────────────────┤
│                      │                │          │ Context                    │
└──────────────────────┴────────────────┴──────────┴────────────────────────────┘

#!/bin/bash
sed -re 's#(.*)#x091x09#' -e 's#x09# 

 #g' -e 's#^ 

 $#n#'
  echo -e "n"
 |w3m -dump -T 'text/html'

---

Una sinopsis de las herramientas presentado en las respuestas (hasta ahora).
Los he mirado bastante de cerca; esto es lo que encontré:

paste # Esta herramienta es común a todas las respuestas presentadas hasta ahora. # Puede manejar varios archivos; por lo tanto, varias columnas ... ¡Bien! # Delimita cada columna con un Tab ... Bueno. # Su salida no está tabulada.

¡Todas las herramientas a continuación eliminan este delimitador! ... Malo si necesita un delimitador.

column # Elimina el delimitador de tabulación, por lo que la identificación de campo es puramente por columnas que parece manejar bastante bien .. No he detectado nada malo ... # Aparte de no tener un delimitador único, ¡funciona bien!

expand # Solo tiene una configuración de pestaña única, por lo que es impredecible más allá de 2 columnas.

pr # Solo tiene una configuración de pestaña única, por lo que es impredecible más allá de 2 columnas. # La alineación de las columnas no es precisa cuando se maneja unicode, y elimina el delimitador de tabulación, por lo que la identificación de los campos es puramente por alineación de columnas

A mi, column es la mejor solución obvia como una sola línea. Si desea el delimitador o una tabulación de arte ASCII de sus archivos, siga leyendo, de lo contrario ... columns es bastante bueno 🙂 ...

Aquí hay una secuencia de comandos que toma cualquier número de archivos y crea una presentación tabulada de arte ASCII. (Tenga en cuenta que es posible que Unicode no se procese con el ancho esperado, por ejemplo, ௵ que es un solo carácter. Esto es bastante diferente a la columna los números son incorrectos, como es el caso de algunas de las utilidades mencionadas anteriormente.) ... La salida del script, que se muestra a continuación, es de 4 archivos de entrada, llamados F1 F2 F3 F4 ...

+------------------------+-------------------+-------------------+--------------+
| Languages              | Minimal automaton | Chomsky hierarchy | Grammars     |
| Recursively enumerable | Turing machine    | Type-0            | Unrestricted |
| Regular                | Finite            | —                 |              |
| Alphabet               |                   | Symbol            |              |
|                        |                   |                   | Context      |
+------------------------+-------------------+-------------------+--------------+

#!/bin/bash

# Note: The next line is for testing purposes only!
set F1 F2 F3 F4 # Simulate commandline filename args $1 $2 etc...

p=' '                                # The pad character
# Get line and column stats
cc=$#@; lmax=                      # Count of columns (== input files)
for c in $(seq 1 $cc) ;do            # Filenames from the commandline 
  F[$c]="$!c"        
  wc=($(wc -l -L <$F[$c]))         # File length and width of longest line 
  l[$c]=$wc[0]                     # File length  (per file)
  L[$c]=$wc[1]                     # Longest line (per file) 
  ((lmax<$l[$c])) && lmax=$l[$c] # Length of longest file
done
# Determine line-count deficits  of shorter files
for c in $(seq 1 $cc) ;do  
  (($l[$c]"$source" echo 'paste '
for c in $(seq 1 $cc) ;do
    (($L[$c]==0)) && e="x" || e=":a -e "s/^.0,$(($L[$c]-1))$/&$p/;ta""
    >>"$source" echo '<(sed -re '"$e"' <(cat "$F['$c']"; echo -n "$N['$c']")) '
done
# include the ASCII-art Table framework
>>"$source" echo ' | sed  -e "s/.*/| & |/" -e "s/t/ | /g" '   # Add vertical frame lines
>>"$source" echo ' | sed -re "1 h;s/[^" ' # Add top and botom frame lines 
>>"$source" echo '        -e "$ /+/g"'
>>"$source" echo  
# Run the code
source "$source"
rm     "$source"
exit

Aquí está mi respuesta original (recortada un poco en lugar del script anterior)

Utilizando wc para obtener el ancho de la columna, y sed a la almohadilla derecha con un visible personaje . (solo para este ejemplo) ... y luego paste para unir las dos columnas con un Pestaña carbonizarse...

paste <(sed -re :a -e 's/^.1,'"$(($(wc -L 

paste <( sed -re :a -e 's/^.1,'"$(($(wc -L