Changer la taille de l'onglet de la commande "cat"

Quand je suis dedans, vimje peux changer la taille de l'onglet avec la commande suivante:

:set ts=4

Est-il également possible de définir la taille des onglets pour la catsortie des commandes?

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=4commande)

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_profiledans ~/et ajoutez la ligne ci - dessus à la fin du fichier.

Pour plus d'informations sur la commande tabs, reportez-vous à:

man tabs

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 tsdans 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 expandpouvez é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 ciphersplus 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 -t31ferait exploser la largeur de la sortie d'environ 100 caractères à plus de 160 caractères.

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 trfilter 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.