linux - site - raccourci clavier ubuntu pdf




Historique de Bash sans numéros de ligne (7)

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]\+[ ]*//'"

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/


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

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.


Je suis en retard sur celui-ci, mais la méthode la plus courte serait d'ajouter ce qui suit dans votre fichier ~/.bashrc ou ~/.profile :

HISTTIMEFORMAT="$(echo -e '\r\e[K')"

À partir de la manpage bash:

       HISTTIMEFORMAT
              If this variable is set and not null, its value is used as a
              format string for strftime(3) to print the time stamp associated
              with each history entry displayed by the history builtin.  If
              this variable is set, time stamps are written to the history
              file so they may be preserved across shell sessions.  This uses
              the history comment character to distinguish timestamps from
              other history lines.

En utilisant cette fonctionnalité, un hack intelligent consiste à faire de la variable "print" un retour chariot ( \r ) et à effacer la ligne (code ANSI K ) au lieu d'un horodatage réel.


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


$ hh -n

Vous pouvez essayer https://github.com/dvorka/hstr qui permet de filtrer l'historique de Bash avec l'option "suggérer le style de boîte", avec des commandes basées sur des mesures (facultatives), c'est-à-dire beaucoup plus efficace et rapide dans les directions avant et arrière:

Il peut être facilement lié à Ctrl-r et / ou Ctrl-s


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'






bash