Réponses:
La première commande émule ici la mise en forme que vous voyez dans vim
. Il étend intelligemment les tabulations au nombre équivalent d'espaces, sur la base d'un paramètre tab-STOP (ts) de toutes les 4 colonnes.
printf "ab\tcd\tde\n" |expand -t4
Production
ab cd de
Pour conserver les onglets sous forme d' onglets et définir les positions d' ARRÊT d' onglet sur toutes les 4 colonnes, vous devez modifier la façon dont l'environnement fonctionne avec un tab-char (tout comme vim le fait avec la :set ts=4
commande)
Par exemple, dans le terminal, vous pouvez définir l'onglet STOP sur 4 avec cette commande;
tabs 4; printf "ab\tcd\tde\n"
Production
ab cd de
Utilisez simplement le code suivant:
tabs -n
Où n est le nombre d'espaces auxquels vous souhaitez que les tabulations correspondent également. Afin de ne pas avoir à le faire chaque fois que vous démarrez le shell, tout simplement modifier votre .bash_profile
dans ~/
et ajoutez la ligne ci - dessus à la fin du fichier.
Pour plus d'informations sur la commande tabs, reportez-vous à:
man tabs
ls
sorties peuvent ne pas être correctement alignées).
Il n'y a aucune notion de tabulations ou de tabulations cat
; le programme canalise simplement les entrées vers la sortie et traite les onglets comme tout autre caractère. Si le périphérique de sortie se trouve être un terminal, les onglets seront traités en fonction du comportement que le terminal est configuré pour fournir.
Les systèmes implémentant POSIX.1 ont une commande appelée tabs(1)
qui ajustera le concept du terminal sur la façon dont les onglets doivent être affichés. Dépendre d'une disposition d'onglet particulière n'est pas considéré comme une bonne idée, car quelqu'un peut envoyer votre fichier à un autre appareil tel qu'une imprimante qui ne fera pas ce que vous vouliez.
Lorsque vous réglez ts
dans vim
(ou ordinaire vi
), tout ce que vous faites est la façon dont le réglage l'éditeur interprète les caractères de tabulation lors de l' affichage. Cela n'a aucune incidence sur ce qui finit dans le dossier.
Sur la base des réponses et des exemples ci-dessus, il semblerait que la commande réelle que l'OP voulait était ...
cat somefile | expand -t4
Cela fonctionne pour moi sur Red Hat 6.4.
Pour développer les réponses déjà données, vous expand
pouvez également prendre une liste de positions de tabulation. Ceci est utile si la longueur du contenu des diverses colonnes varie beaucoup.
Je suis tombé sur cette exigence aujourd'hui quand je voulais rendre la sortie de openssl ciphers
plus lisible:
$ 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
Utiliser uniquement expand -t31
ferait exploser la largeur de la sortie d'environ 100 caractères à plus de 160 caractères.
column
:openssl ciphers -v 'HIGH' | column -t
De nombreux terminaux prennent en charge la définition de taquets de tabulation variables. Ceux qui sont vt100, linux et / ou prennent en charge la norme EMCA-48 font, la plupart des termes sur la prise en charge de la taille des onglets de configuration Linux: xterm et famille (uxterm, urxvt) xfce4-terminal, luit, Terminal, SecureTTY, entre autres.
J'ai donc écrit un script il y a quelques années pour définir mes onglets lors de la connexion à tous les 2 espaces - utilisé pour utiliser 4, puis 3 pendant un court instant, et maintenant à 2 ....
Alors maintenant, si je «cat» un fichier, les onglets du fichier se développeront selon les paramètres de mon terminal.
Si je suis passé par vim ou plus, ils font leur propre extension d'onglet, mais beaucoup d'utilitaires utilisent des onglets.
Inclut le script ici pour référence et / ou usage personnel:
#!/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
J'espère que cela aide...
Selon la page de manuel, le chat ne peut pas le faire seul. Mais vous pouvez par exemple exécuter la sortie de cat through tr
filter pour remplacer les tabulations par le nombre d'espaces que vous souhaitez:
cat somefile | tr '\t' ' '
remplacera le caractère de tabulation par deux espaces.
Mise à jour: comme indiqué dans les commentaires de ce post, cela ne fonctionne pas . Néanmoins, je garde la réponse comme un exemple de la façon de ne pas le faire.
'\t'
un seul espace, peu importe le nombre d'espaces entre la deuxième paire de guillemets' '
tr
ne fonctionne pas de cette façon .. chaque octet d'arg 1 est remplacé par chaque octet correspondant d'arg 2 ..... Imprime donc printf '\t' |tr '\t' 'ळ'
un seul octet dont la valeur hexadécimale est \xE0
.. qui est le premier octet des trois UTF-8 octets codés qui composent le caractère ळ
(dont la valeur Unicode CodePoint est U + 0933)
expand
(à partir du package coreutils) ettabs
(à partir du package ncurses), (2). et la signification de ts est [ T ] ab [ S ] haut