Risposte:
Il primo comando qui emula la formattazione che vedi in vim. Espande in modo intelligente le schede al numero equivalente di spazi, in base a un'impostazione di tab-STOP (ts) di ogni 4 colonne.
printf "ab\tcd\tde\n" |expand -t4
Produzione
ab cd de
Per mantenere le schede come schede e impostare la posizione STOP delle schede su ogni quarta colonna, è necessario modificare il modo in cui l'ambiente funziona con un carattere di tabulazione (proprio come fa vim con il :set ts=4comando)
Ad esempio, nel terminale, è possibile impostare la scheda STOP su 4 con questo comando;
tabs 4; printf "ab\tcd\tde\n"
Produzione
ab cd de
Basta usare il seguente codice:
tabs -n
Dove n è il numero di spazi in cui si desidera corrispondere anche alle schede. Per non doverlo fare ogni volta che avvii la shell, modifica il tuo .bash_profilein ~/e aggiungi la riga sopra alla fine del file.
Per ulteriori informazioni sul comando tabs, consultare:
man tabs
ls, put put potrebbe sembrare non allineato correttamente).
Non vi è alcuna nozione di tab o di tab stop in cat; il programma incanala gli input verso l'output e tratta le schede come qualsiasi altro personaggio. Se il dispositivo di output risulta essere un terminale, le schede verranno gestite in base al comportamento configurato dal terminale.
I sistemi che implementano POSIX.1 hanno un comando chiamato tabs(1)che regolerà il concetto del terminale di come visualizzare le schede. A seconda di un particolare layout di scheda non è considerata una buona idea, in quanto qualcuno potrebbe inviare il tuo file ad altri dispositivi come una stampante che non farà ciò che desideri.
Quando si regola tsin vim(o semplice vi), tutto quello che stai facendo è la regolazione come i personaggi scheda Editor interpreta se visualizzato. Non ha alcuna influenza su ciò che finisce nel file.
Sulla base delle risposte e degli esempi precedenti, sembrerebbe che il comando effettivo richiesto dall'OP sia ...
cat somefile | expand -t4
Questo funziona per me su Red Hat 6.4.
Per espandere le risposte già fornite, expandpuoi anche prendere un elenco di posizioni di tabulazione. Ciò è utile se la lunghezza del contenuto delle colonne varlious varia molto.
Ho soddisfatto questo requisito oggi quando volevo rendere openssl cipherspiù leggibile l'output :
$ openssl ciphers -v 'HIGH'|tr -s ' ' '\t'|expand -t31,41,57,70,90
ECDHE-RSA-AES256-GCM-SHA384 TLSv1.2 Kx=ECDH Au=RSA Enc=AESGCM(256) Mac=AEAD
ECDHE-ECDSA-AES256-GCM-SHA384 TLSv1.2 Kx=ECDH Au=ECDSA Enc=AESGCM(256) Mac=AEAD
ECDHE-RSA-AES256-SHA384 TLSv1.2 Kx=ECDH Au=RSA Enc=AES(256) Mac=SHA384
ECDHE-ECDSA-AES256-SHA384 TLSv1.2 Kx=ECDH Au=ECDSA Enc=AES(256) Mac=SHA384
...
ECDH-ECDSA-AES128-SHA SSLv3 Kx=ECDH/ECDSA Au=ECDH Enc=AES(128) Mac=SHA1
AES128-GCM-SHA256 TLSv1.2 Kx=RSA Au=RSA Enc=AESGCM(128) Mac=AEAD
AES128-SHA256 TLSv1.2 Kx=RSA Au=RSA Enc=AES(128) Mac=SHA256
AES128-SHA SSLv3 Kx=RSA Au=RSA Enc=AES(128) Mac=SHA1
CAMELLIA128-SHA SSLv3 Kx=RSA Au=RSA Enc=Camellia(128) Mac=SHA1
PSK-AES128-CBC-SHA SSLv3 Kx=PSK Au=PSK Enc=AES(128) Mac=SHA1
L'uso di solo expand -t31farebbe saltare in aria la larghezza dell'output da circa 100 caratteri a più di 160 caratteri.
column:openssl ciphers -v 'HIGH' | column -t
Molti terminali supportano l'impostazione di tabulazioni variabili. Quelli che sono vt100, linux e che supportano lo standard EMCA-48 lo fanno, la maggior parte dei termini su linux supportano le dimensioni della scheda di impostazione: xterm e family (uxterm, urxvt) xfce4-terminal, luit, Terminal, SecureTTY, tra gli altri.
Così ho scritto una sceneggiatura qualche anno fa per impostare le mie schede al login su ogni 2 spazi - usato per usare 4, poi 3 per un po ', e ora a 2 ....
Quindi ora, se 'cat' un file, le schede nel file si espandono alle impostazioni del mio terminale.
Se ho superato vim o più, fanno la propria espansione delle schede, ma molte utility usano le schede.
Includerà lo script qui come riferimento e / o per uso personale:
#!/bin/bash -u
#console_codes(4) man page... vt100/2 et && EMCA-48 standard
# (c) la walsh (2013) -- free to use and modify for personal use.
# -- optionally licenced under Gnu v3 license.
# v0.0.3 - try to reduce tabcols to minimal set to reproduce.
# v0.0.2 - set tabs for full terminal width (try to get term width)
shopt -s expand_aliases extglob
alias my=declare
alias int='my -i' array='my -a' intArray='my -ia' string=my
my _Pt=$(type -t P)
[[ $_Pt && $_Pt == function ]] && unset -f P
alias P=printf
unset _Pt
P -v clrallts "\x1b[3g" #Clear All TabStops
P -v hts "\033H" #Horizontal TabStop
P -v cpr "\x1b[6n" #Current Position Report
getcols() { # try to read terminal width
local sttyout="$(stty size </dev/tty)"
int default_cols=80
if [[ -n ${COLUMNS:-""} && $COLUMNS =~ ^[0-9]+$ ]]; then
default_cols=$COLUMNS; fi
[[ -z ${sttyout:-""} ]] && { echo $default_cols; return 0; }
int cols="${sttyout#*\ }"
echo -n $[cols<2?default_cols:cols]
return 0
}
getpos () {
string ans wanted=${1:-xy}
int attempt=0 max_attempt=1 # in case of rare failure case
# use 'attempt' value as additional
# time to wait for response
while : ; do
( ( P "\x1b[6n" >/dev/tty) & 2>/dev/null )
read -sd R -r -t $[2 + attempt] ans </dev/tty;
ans=${ans:2};
int x=0-1 y=0-1
if ! x="${ans#*;}" y="${ans%;*}" 2>/dev/null ||
((x==-1||y==-1)); then
((attempt+=1 < max_attempt)) && continue
fi
break; done
string out=""
[[ $wanted =~ x ]] && out="$x"
[[ $wanted =~ y ]] && out="${out:+$x }$y"
[[ $out ]] && echo -n "$out"
}
declare -ia tabs
get_tabs () {
P "\r"
tabs=()
int pos=0 oldpos=0-1
while ((oldpos!=pos));do
((pos)) && tabs+=($pos)
oldpos=pos
P "\t"
pos=$(getpos x)
done
P "\r"
return 0
}
# Note: this func uses ability to _read_ tabstops as _proxy_ for setting them
# (i.e. it makes no sense to be able to read them if you can't set them)
test_tabset_ability () {
string prompt="tty_tab:"
int newcol=${#prompt}+1
P "\r$prompt"
int mycol=$(getpos x)
((mycol && mycol==newcol)) && return 0 ## return OK
{ P " Term tabset ability not detected mycol=${mycol:-''},"
P " promptlen=$newcol)\n"; } >&2
exit -1
}
do_help_n_display_curtabs () {
P " <n> - set tab stop to N\r"
intArray diffs;
int last=1 cur i
string eol=""
get_tabs && {
for ((i=0; i<${#tabs[@]}; ++i)); do
cur=${tabs[i]}
diffs[i]=cur-last
last=cur
done
intArray reverse_tabs_set=()
int prevtab=0-1
for ((i=${#diffs[@]}-2; i>0; --i)); do
int thistab=${diffs[i]}
if ((thistab!= prevtab)) ;then
reverse_tabs_set+=($thistab)
prevtab=thistab
fi
done
P "current value: tty_tab "
for ((i=${#reverse_tabs_set[@]}-1; i>=0; --i)); do
P "%d " "${reverse_tabs_set[i]}"; done
P "\r";
}
get_tabs && {
P "(from 1, tabs skip to column: "
P "%s " "${tabs[@]}"
P "\r\n"
}
}
set_tabs () {
int max_col=${1:=0-80}
int tabstop=${2:-?"need a param for tabstop"}
int tab=$tabstop pos=0
string str=""
P $clrallts ## reset old tabs
while ((++pos<cols)) ;do ## move across screen setting tabs
str+=" "
((pos%tab)) || str+="$hts"
done
P "\r$str\r"
}
int cols=$(getcols)
test_tabset_ability ## exits if no ability
if (($#==0)) ; then
do_help_n_display_curtabs
exit 1
else
set_tabs "$cols" "$@"
fi
# vim: ts=2 sw=2
Spero che sia d'aiuto...
Secondo la manpage, il gatto non può farlo da solo. Ma puoi ad esempio eseguire l'output da cat attraverso il trfiltro per sostituire le schede con qualsiasi numero di spazi desideri:
cat somefile | tr '\t' ' '
sostituirà il carattere di tabulazione con due spazi.
Aggiornamento: come sottolineato nei commenti a questo post, questo in realtà non funziona. Tuttavia, sto mantenendo la risposta come esempio di come non farlo.
'\t'con un solo spazio, non importa quanti spazi ci siano tra la seconda coppia di virgolette' '
trnon funziona in questo modo .. ogni byte di arg 1 è sostituito da ogni byte corrispondente di arg 2 ..... Quindi printf '\t' |tr '\t' 'ळ' stampa un singolo byte il cui valore esadecimale è \xE0.. che è il primo byte dei tre UTF-8 byte codificati che compongono il carattere ळ(il cui valore Unicode CodePoint è U + 0933)
expand(dal pacchetto coreutils) etabs(dal pacchetto ncurses), (2). e il significato di ts è [ T ] ab [ S ] top