linux pour - Historique de Bash sans numéros de ligne




les nuls (9)

La commande bash history est très cool. Je comprends pourquoi il affiche les numéros de ligne, mais est-il possible d'invoquer la commande history et de supprimer les numéros de ligne?

Le point ici est d'utiliser la commande history, alors s'il vous plaît ne répondez pas cat ~/.bash_history

Sortie actuelle:

  529 man history
  530 ls
  531 ll
  532 clear
  533 cd ~
  534 history

Source graphique historique.

Sortie désirée:

man history
ls
ll
clear
cd ~
history

Source graphique historique.

Merci à tous pour vos excellentes solutions. Paul est le plus simple et fonctionnera pour moi car la taille de mon historique de bash est fixée à 2000.

Je voulais aussi partager un bon article que j'ai trouvé ce matin. Il a quelques bonnes options que j'utilise maintenant, comme garder les entrées en double de l'histoire de bash et m'assurer que plusieurs sessions de bash ne remplacent pas le fichier d'historique: http://blog.macromates.com/2008/working-with-history-in-bash/


Answers

Je suis tout à fait conscient que cette question est pour bash et beaucoup de gens préféreraient ne pas passer à zsh (cue downvotes ...)

Cependant, si vous étiez prêt à passer à zsh, alors zsh le supporte nativement (ainsi que d'autres options pour la mise en forme de l'historique)

zsh> fc -ln 0

(Voir https://serverfault.com/questions/114988/removing-history-or-line-numbers-from-zsh-history-file )


Je passais par ce fil et trouvé des solutions sont bonnes. Tout en essayant une solution awk trouvé que dans l'histoire s'il y a des commandes de ligne multiples sont là ou des espaces etc. ils peuvent avoir des défis pour imprimer ce que l'exigence réelle OP était. Laissez-moi donner un exemple ici, j'ai exécuté une commande comme celle-ci.

awk '
match ($0, /<property class="java.lang.String" name="WorkJobNumber" value="[0-9]*"\/>/) {sub (substr ($0, RSTART+63, RLENGTH-66), _)
                                                                                        }
1123
'  Input_file

Donc, dans l'histoire, il apparaîtra sous le numéro de séquence 1, mais cela pourrait être un problème si cela est négligé dans la solution / s. Donc, suivre peut éviter une situation où des commandes spécialement multi-lignes ont été exécutées.

history | awk '{Q=$1;sub(/^[[:space:]]+/,"",Q);if(LAST+1==Q && LAST && Q ~ /^[0-9]+/){;$1="";print;} else {print;};if(Q ~ /^[0-9]+/ && Q+0 == LAST+1 && $0 !~ /^$/){LAST=Q+0};next} (Q ~ /^[0-9]+/ && $0 !~ /^$/){LAST=Q+0} 1'

Une forme de solution non-doublure aussi comme suit:

history | awk '{
        Q=$1;
        sub(/^[[:space:]]+/,"",Q);
        if(LAST+1==Q && LAST && Q ~ /^[0-9]+/){;
                            $1="";
                            print;
                              } 
                else                                  {
                            print;
                                  };
                if(Q ~ /^[0-9]+/ && Q+0 == LAST+1 && $0 !~ /^$/){
                                 LAST=Q+0
                                        };
                next
               } 
               (Q ~ /^[0-9]+/ && $0 !~ /^$/){
                             LAST=Q+0
                                            } 
               1
              '

L'explication du code ci-dessus est aussi (il ne faut pas courir après car c'est seulement à des fins d'explication):

history |                                          #### Running history command here and using pipe to use this command's standard output to standard input for next awk command.
awk '                                              #### Starting awk command from here.
{Q=$1                                              #### Starting a variable named Q, whose value is $1 of current line.
sub(/^[[:space:]]+/,"",Q)                          #### subsitute initial space of variable Q(which has $1 of current line too) to NULL now.
if(LAST+1==Q && LAST && Q ~ /^[0-9]+/)             #### mentioning here a if condition which is checking following conditions.
                                                 i- check if variable named LAST's value +1 is equal to variable Q's value(where LAST variable is the variable which has previous line's number.
                                                ii- check LAST's value should NOT be NULL.
                                               iii- check  variable Q's value should be always starting from digits(As running multi-lie commands eg--> awk you could have commands there so making sure our LAST variable doesn't have any junk in it).
{;$1="";print;}                                    #### making $1's value NULL so that history number will not print and then printing the current line.
else                                               #### Mentioning else, in case above if condition is NOT TRUE then following statements should execute.
{;print}                                           #### simply print the current line.
;if(Q ~ /^[0-9]+/ && Q+0 == LAST+1 && $0 !~ /^$/)  #### checking following conditions here.
                                                 i- check if variable Q's value always starts from digits to make sure no junk will come apart from history numbers in variable here.
                                                ii- check Q+0 == LAST+1, here Q+0 I am mentioning because in my history it was showing 772*(in a row) so Q+0 will make sure only numbers are being captured here. then comparing it with LAST+1 value, if both are equal here.
                                               iii- Making sure each line starts NOT from a space(in multi-line commands you may see spaces).
{LAST=Q+0};next}                                   #### Assigning variable LAST's value to Q's value(by doing Q+0 making sure like only digits should be captured here). Mentioning next here which is awk's in-built keyword and will skip all next statements then.
(Q ~ /^[0-9]+/ && $0 !~ /^$/)                      #### This condition will be executed when previous are not true, checking Q's value should be starting from digits only to get the history's sequence number only and checking a line shouldn't start from space etc.
{LAST=Q+0}                                         #### Assigning variable LAST's value to value of Q+0 which will make sure only digits should come.
1'                                                 #### So awk works on pattern{action} method, so by mentioning 1 I am making a pattern/condition true and then not mentioning any action here so by default print action will happen and it will print the current line, it will happen only in those cases when a history doesn't have any sequence number in it.

Bien que cette commande puisse avoir quelques défis aussi, j'ai essayé mon meilleur pour le garder impeccable, ouvert aux commentaires ou suggestions.


Bien que coupé avec l'option -c fonctionne pour la plupart des objectifs pratiques, je pense que l'histoire de la tuyauterie à awk serait une meilleure solution. Par exemple:

history | awk '{ $1=""; print }'

OU

history | awk '{ $1=""; print $0 }'

Ces deux solutions font la même chose. La sortie de l'histoire est nourrie à awk. Awk efface alors la première colonne, qui correspond aux nombres dans la sortie de la commande history. Ici awk est plus pratique car vous n'avez pas à vous soucier du nombre de caractères dans la partie numérique de la sortie.

print $0 équivaut à print , car la valeur par défaut est d'imprimer tout ce qui apparaît sur la ligne. Taper print $0 est plus explicite, mais celui que vous choisissez est à vous. Le comportement de print $0 et simplement print lorsqu'il est utilisé avec awk est plus évident si vous avez utilisé awk pour imprimer un fichier ( cat serait plus rapide à taper au lieu de awk, mais ceci est pour illustrer un point).

[Ex] Utiliser awk pour afficher le contenu d'un fichier avec $ 0

$ awk '{print $0}' /tmp/hello-world.txt
Hello World!

[Ex] Utiliser awk pour afficher le contenu d'un fichier sans $ 0 explicite

$ awk '{print}' /tmp/hello-world.txt
Hello World!

[Ex] Utiliser awk lorsque la ligne d'historique s'étend sur plusieurs lignes

$ history
   11  clear
   12  echo "In word processing and desktop publishing, a hard return or paragraph break indicates a new paragraph, to be distinguished from the soft return at the end of a line internal to a paragraph. This distinction allows word wrap to automatically re-flow text as it is edited, without losing paragraph breaks. The software may apply vertical whitespace or indenting at paragraph breaks, depending on the selected style."

$ history | awk ' $1=""; {print}'
 clear
 echo "In word processing and desktop publishing, a hard return or paragraph break indicates a new paragraph, to be distinguished from the soft return at the end of a line internal to a paragraph. This distinction allows word wrap to automatically re-flow text as it is edited, without losing paragraph breaks. The software may apply vertical whitespace or indenting at paragraph breaks, depending on the selected style."

Essaye ça:

$ history | cut -c 8-

Vous pouvez utiliser la commande cut pour le résoudre:

Découpez les champs de STDIN ou des fichiers.

  • Découpez les seize premiers caractères de chaque ligne de STDIN: cut -c 1-16

  • Découpez les seize premiers caractères de chaque ligne des fichiers donnés: fichier cut -c 1-16 file

  • Découpez tout du 3ème caractère à la fin de chaque ligne: cut -c3-

  • Découpez le cinquième champ de chaque ligne, en utilisant un deux-points comme un délimiteur de champ (délimiteur par défaut est un onglet): cut -d':' -f5

  • Découpe les 2ème et 10ème champs de chaque ligne, en utilisant un point-virgule comme délimiteur: cut -d';' -f2,10 cut -d';' -f2,10

  • Découpez les champs 3 à 7 de chaque ligne, en utilisant un espace comme délimiteur: cut -d' ' -f3-7


awk peut aider:

history|awk '{$1="";print substr($0,2)}'

Cette réponse peut échouer si vous avez un long hsitory.

HTH


history commande history n'a pas d'option pour supprimer les numéros de ligne. Vous devrez combiner plusieurs commandes comme tout le monde le suggère:

Exemple :

history | cut -d' ' -f4- | sed 's/^ \(.*$\)/\1/g'

Alternativement, vous pouvez utiliser sed:

history | sed 's/^[ ]*[0-9]\+[ ]*//'

En utilisant l'alias, vous pouvez le définir comme votre standard (le coller dans votre bash_profile):

alias history="history | sed 's/^[ ]*[0-9]\+[ ]*//'"

Notez que cela ne fonctionnera pas

foo=HELLO
bar=WORLD
foobar=PREFIX_$foo_$bar

comme il semble tomber $ foo et vous laisse avec:

PREFIX_WORLD

mais cela fonctionnera:

foobar=PREFIX_"$foo"_"$bar"

et vous laisser avec la sortie correcte:

PREFIX_HELLO_WORLD







linux bash