Quelle est votre astuce de ligne de commande la plus préférée avec Bash? [fermé]

Nous savons tous comment utiliser <ctrl>-Rpour inverser la recherche dans l'historique, mais saviez-vous que vous pouvez utiliser <ctrl>-Spour transférer la recherche si vous le définissez stty stop ""? De plus, avez-vous déjà essayé d'exécuter bind -p pour voir tous vos raccourcis clavier répertoriés? Il y en a plus de 455 sur Mac OS X par défaut.

Quelle est votre astuce obscure, raccourci clavier ou configuration shopt la plus préférée avec bash?

Renommer / déplacer rapidement des fichiers avec des suffixes:
cp /home/foo/realllylongname.cpp{,-old}

Cela s'étend à:
cp /home/foo/realllylongname.cpp /home/foo/realllylongname.cpp-old

cd -

C'est l'équivalent en ligne de commande du bouton Précédent (vous amène au répertoire précédent dans lequel vous étiez).

Un autre coup de coeur:

!!

Répète votre dernière commande. Le plus utile sous la forme:

sudo !!

Mon préféré est '^ string ^ string2' qui prend la dernière commande, remplace string par string2 et l'exécute

$ ehco foo bar baz
bash: ehco: command not found
$ ^ehco^echo
foo bar baz

Guide de l'historique de la ligne de commande Bash

Renommer

Exemple:

$ ls
this_has_text_to_find_1.txt
this_has_text_to_find_2.txt
this_has_text_to_find_3.txt
this_has_text_to_find_4.txt

$ rename 's/text_to_find/been_renamed/' *.txt
$ ls
this_has_been_renamed_1.txt
this_has_been_renamed_2.txt
this_has_been_renamed_3.txt
this_has_been_renamed_4.txt

Tellement utile

Je suis fan de !$, !^et !*expandos, qui reviennent de la ligne de commande soumise la plus récente: le dernier élément, le premier élément non commandé et tous les éléments non commandés. À savoir (notez que le shell imprime d'abord la commande):

$ echo foo bar baz
foo bar baz
$ echo bang-dollar: !$ bang-hat: !^ bang-star: !*
echo bang-dollar: baz bang-hat: foo bang-star: foo bar baz
bang-dollar: baz bang-hat: foo bang-star: foo bar baz

Cela est très pratique lorsque vous, par exemple ls filea fileb, et que vous voulez modifier l' un d'entre eux: vi !$ou les deux: vimdiff !*. Il peut également être généralisé au " nème argument" comme ceci:

$ echo foo bar baz
$ echo !:2
echo bar
bar

Enfin, avec les chemins, vous pouvez accéder à certaines parties du chemin en ajoutant :het :tà l'un des expandos ci-dessus:

$ ls /usr/bin/id
/usr/bin/id
$ echo Head: !$:h  Tail: !$:t
echo Head: /usr/bin Tail: id
Head: /usr/bin Tail: id

Lors de l'exécution de commandes, je souhaite parfois exécuter une commande avec les arguments précédents. Pour ce faire, vous pouvez utiliser ce raccourci:

$ mkdir /tmp/new
$ cd !!:*

Parfois, au lieu d'utiliser find, j'éclate une boucle d'une ligne si j'ai besoin d'exécuter un tas de commandes sur une liste de fichiers.

for file in *.wav; do lame "$file" "$(basename "$file" .wav).mp3" ; done;

La configuration des options d'historique de ligne de commande dans mon .bash_login (ou .bashrc) est vraiment utile. Ce qui suit est un ensemble de paramètres que j'utilise sur mon Macbook Pro.

La configuration de ce qui suit fait que bash efface les commandes en double dans votre historique:

export HISTCONTROL="erasedups:ignoreboth"

J'ai également augmenté la taille de mon histoire assez haut. Pourquoi pas? Cela ne semble rien ralentir sur les microprocesseurs actuels.

export HISTFILESIZE=500000
export HISTSIZE=100000

Une autre chose que je fais est d'ignorer certaines commandes de mon historique. Pas besoin de se souvenir de la commande exit.

export HISTIGNORE="&:[ ]*:exit"

Vous voulez certainement définir histappend. Sinon, bash écrase votre historique lorsque vous quittez.

shopt -s histappend

Une autre option que j'utilise est cmdhist. Cela vous permet d'enregistrer les commandes multilignes dans l'historique en une seule commande.

shopt -s cmdhist

Enfin, sous Mac OS X (si vous n'utilisez pas le mode vi), vous voudrez réinitialiser <CTRL> -S pour ne pas être arrêté de défilement. Cela empêche bash de pouvoir l'interpréter comme une recherche vers l'avant.

stty stop ""

Comment ne lister que les sous-répertoires de l'actuel?

ls -d */

C'est une astuce simple, mais vous ne sauriez pas combien de temps il me fallait pour trouver celle-là!

ESC.

Insère les derniers arguments de votre dernière commande bash. C'est plus pratique que vous ne le pensez.

cp file /to/some/long/path

CD ESC.

Bien sûr, vous pouvez " diff file1.txt file2.txt", mais Bash prend en charge la substitution de processus , ce qui vous permet de diffsortir des commandes.

Par exemple, disons que je veux m'assurer que mon script me donne le résultat attendu. Je peux simplement envelopper mon script dans <() et le nourrir diffpour obtenir un test unitaire rapide et sale:

$ cat myscript.sh
#!/bin/sh
echo -e "one\nthree"
$
$ ./myscript.sh 
one
three
$
$ cat expected_output.txt
one
two
three
$
$ diff <(./myscript.sh) expected_output.txt
1a2
> two
$

Comme autre exemple, disons que je veux vérifier si deux serveurs ont la même liste de RPM installés. Plutôt que de sshing sur chaque serveur, d'écrire chaque liste de RPM dans des fichiers séparés et de faire un diffsur ces fichiers, je peux simplement faire le diffdepuis mon poste de travail:

$ diff <(ssh server1 'rpm -qa | sort') <(ssh server2 'rpm -qa | sort')
241c240
< kernel-2.6.18-92.1.6.el5
---
> kernel-2.6.18-92.el5
317d315
< libsmi-0.4.5-2.el5
727,728d724
< wireshark-0.99.7-1.el5
< wireshark-gnome-0.99.7-1.el5
$

Il y a plus d'exemples dans le Advanced Bash-Scripting Guide à http://tldp.org/LDP/abs/html/process-sub.html .

Ma commande préférée est "ls -thor"

Il invoque le pouvoir des dieux de répertorier les fichiers les plus récemment modifiés dans un format facilement lisible.

Plus une nouveauté, mais c'est malin ...

Top 10 des commandes utilisées:

$ history | awk '{print $2}' | awk 'BEGIN {FS="|"}{print $1}' | sort | uniq -c | sort -nr | head

Exemple de sortie:

 242 git
  83 rake
  43 cd
  33 ss
  24 ls
  15 rsg
  11 cap
  10 dig
   9 ping
   3 vi

^ R recherche inversée. Appuyez sur ^ R, saisissez un fragment d'une commande précédente que vous souhaitez associer et appuyez sur ^ R jusqu'à ce que vous trouviez celle que vous souhaitez. Ensuite, je n'ai pas à me souvenir des commandes récemment utilisées qui sont encore dans mon histoire. Pas exclusivement bash, mais aussi: ^ E pour la fin de la ligne, ^ A pour le début de la ligne, ^ U et ^ K pour supprimer respectivement avant et après le curseur.

J'ai souvent des alias pour vi, ls, etc. mais parfois vous voulez échapper l'alias. Ajoutez simplement une barre oblique inverse à la commande devant:

Par exemple:

$ alias vi=vim
$ # To escape the alias for vi:
$ \vi # This doesn't open VIM

Cool, non?

Voici quelques modifications de configuration:

~/.inputrc:

"\C-[[A": history-search-backward
"\C-[[B": history-search-forward

Cela fonctionne de la même manière que ^Rmais en utilisant les touches fléchées à la place. Cela signifie que je peux taper (par exemple) cd /media/puis appuyer sur la flèche vers le haut pour aller à la dernière chose que je voulais cddans le /media/dossier.

(J'utilise Gnome Terminal, vous devrez peut-être changer les codes d'échappement pour d'autres émulateurs de terminal.)

La complétion Bash est également incroyablement utile, mais c'est un ajout beaucoup plus subtil. Dans ~/.bashrc:

if [ -f /etc/bash_completion ]; then
    . /etc/bash_completion
fi

Cela activera la complétion de tabulation par programme (par exemple, la tentative de complétion de tabulation lorsque la ligne de commande commence par evincen'affichera que les fichiers que evince peut ouvrir, et il affichera également les options de ligne de commande de tabulation complète).

Fonctionne bien avec cela également dans ~/.inputrc:

set completion-ignore-case on
set show-all-if-ambiguous on
set show-all-if-unmodified on

J'utilise beaucoup ce qui suit:

Le :pmodificateur pour imprimer un résultat d'historique. Par exemple

!!:p

Imprime la dernière commande afin que vous puissiez vérifier qu'elle est correcte avant de l'exécuter à nouveau. Entrez simplement !!pour l'exécuter.

Dans le même ordre d'idées:

!?foo?:p

Rechercher dans votre historique la commande la plus récente contenant la chaîne «foo» et l'afficher.

Si vous n'avez pas besoin d'imprimer,

!?foo

effectue la recherche et l'exécute immédiatement.

J'ai une arme secrète: le shell-fu.

Il existe des milliers de conseils intelligents, de trucs sympas et de recettes efficaces qui, la plupart du temps, tiennent sur une seule ligne.

Celui que j'adore (mais je triche un peu car j'utilise le fait que Python est installé sur la plupart des systèmes Unix maintenant):

alias webshare='python -m SimpleHTTPServer'

Désormais, chaque fois que vous tapez "webshare", le répertoire courant sera disponible via le port 8000. Vraiment sympa lorsque vous voulez partager des fichiers avec des amis sur un réseau local sans clé usb ni répertoire distant. Le streaming vidéo et musique fonctionnera également.

Et bien sûr la bombe à fourche classique qui est complètement inutile mais toujours très amusante:

$ :(){ :|:& };:

N'essayez pas cela sur un serveur de production ...

Vous pouvez utiliser la commande watch en conjonction avec une autre commande pour rechercher des modifications. Un exemple de cela était lorsque je testais mon routeur, et je voulais obtenir des chiffres à jour sur des choses comme le rapport signal sur bruit, etc.

watch --interval=10 lynx -dump http://dslrouter/stats.html

type -a PROG

afin de trouver tous les endroits où PROG est disponible, généralement quelque part dans ~ / bin plutôt que celui de / usr / bin / PROG auquel on aurait pu s'attendre.

J'aime construire des commandes avec echo et les diriger vers le shell:

$ find dir -name \*~ | xargs echo rm
...
$ find dir -name \*~ | xargs echo rm | ksh -s

Pourquoi? Parce que cela me permet de voir ce qui va être fait avant de le faire. De cette façon, si j'ai une erreur horrible (comme supprimer mon répertoire personnel), je peux l'attraper avant qu'elle ne se produise. De toute évidence, c'est le plus important pour les actions destructives ou irrévocables.

Lors du téléchargement d'un gros fichier, je fais assez souvent:

while ls -la <filename>; do sleep 5; done

Et puis ctrl + c quand j'ai terminé (ou si lsretourne une valeur non nulle). C'est similaire au watchprogramme mais il utilise le shell à la place, donc il fonctionne sur les plates-formes sans watch.

Un autre outil utile est netcat, ou nc. Si tu fais:

nc -l -p 9100 > printjob.prn

Ensuite, vous pouvez configurer une imprimante sur un autre ordinateur, mais utiliser à la place l'adresse IP de l'ordinateur exécutant netcat. Lorsque le travail d'impression est envoyé, il est reçu par l'ordinateur exécutant netcat et vidé dans printjob.prn.

pushdet sont popdpresque toujours utiles

Une façon préférée de naviguer lorsque j'utilise plusieurs répertoires dans des endroits très séparés dans une hiérarchie d'arborescence est d'utiliser acf_func.sh (répertorié ci-dessous). Une fois défini, vous pouvez faire

cd -

pour voir une liste des répertoires récents, avec un menu numérique

cd -2

pour accéder au deuxième répertoire le plus récent.

Très simple d'utilisation, très pratique.

Voici le code:

# do ". acd_func.sh"
# acd_func 1.0.5, 10-nov-2004
# petar marinov, http:/geocities.com/h2428, this is public domain

cd_func ()
{
  local x2 the_new_dir adir index
  local -i cnt

  if [[ $1 ==  "--" ]]; then
    dirs -v
    return 0
  fi

  the_new_dir=$1
  [[ -z $1 ]] && the_new_dir=$HOME

  if [[ ${the_new_dir:0:1} == '-' ]]; then
    #
    # Extract dir N from dirs
    index=${the_new_dir:1}
    [[ -z $index ]] && index=1
    adir=$(dirs +$index)
    [[ -z $adir ]] && return 1
    the_new_dir=$adir
  fi

  #
  # '~' has to be substituted by ${HOME}
  [[ ${the_new_dir:0:1} == '~' ]] && the_new_dir="${HOME}${the_new_dir:1}"

  #
  # Now change to the new dir and add to the top of the stack
  pushd "${the_new_dir}" > /dev/null
  [[ $? -ne 0 ]] && return 1
  the_new_dir=$(pwd)

  #
  # Trim down everything beyond 11th entry
  popd -n +11 2>/dev/null 1>/dev/null

  #
  # Remove any other occurence of this dir, skipping the top of the stack
  for ((cnt=1; cnt <= 10; cnt++)); do
    x2=$(dirs +${cnt} 2>/dev/null)
    [[ $? -ne 0 ]] && return 0
    [[ ${x2:0:1} == '~' ]] && x2="${HOME}${x2:1}"
    if [[ "${x2}" == "${the_new_dir}" ]]; then
      popd -n +$cnt 2>/dev/null 1>/dev/null
      cnt=cnt-1
    fi
  done

  return 0
}

alias cd=cd_func

if [[ $BASH_VERSION > "2.05a" ]]; then
  # ctrl+w shows the menu
  bind -x "\"\C-w\":cd_func -- ;"
fi

Développez les lignes compliquées avant de frapper l'entrée redoutée

• Alt+ Ctrl+ e- shell-expand-line (peut - être besoin d'utiliser Esc, Ctrl+ esur votre clavier)
• Ctrl+ _- annuler
• Ctrl+ x, *- glob-expand-mot

$ echo !$ !-2^ * Alt+ Ctrl+ e
$ echo aword someotherword * Ctrl+ _
$ echo !$ !-2^ * Ctrl+ x, *
$echo !$ !-2^ LOG Makefile bar.c foo.h

& c.

J'ai toujours aimé:

ctrl-E # move cursor to end of line
ctrl-A # move cursor to beginning of line

J'utilise également shopt -s cdable_vars, alors vous pouvez créer des variables bash dans des répertoires communs. Donc, pour l'arborescence des sources de mon entreprise, je crée un tas de variables comme:

export Dcentmain="/var/localdata/p4ws/centaur/main/apps/core"

alors je peux passer à ce répertoire par cd Dcentmain.

pbcopy

Cela copie dans le presse-papiers du système Mac. Vous pouvez y diriger des commandes ... essayez:

pwd | pbcopy

$ touch {1,2}.txt
$ ls [12].txt
1.txt  2.txt
$ rm !:1
rm [12].txt
$ history | tail -10
...
10007  touch {1,2}.txt
...
$ !10007
touch {1,2}.txt
$ for f in *.txt; do mv $f ${f/txt/doc}; done

Utiliser 'set -o vi' depuis la ligne de commande, ou mieux, dans .bashrc, vous met en mode d'édition vi sur la ligne de commande. Vous commencez en mode «insertion» pour pouvoir taper et revenir en arrière comme d'habitude, mais si vous faites une «grosse» erreur, vous pouvez appuyer sur la touche échap et ensuite utiliser «b» et «f» pour vous déplacer comme vous le faites dans vi. cw pour changer un mot. Particulièrement utile après avoir mis en place une commande d'historique que vous souhaitez modifier.

Semblable à beaucoup ci-dessus, mon préféré actuel est la touche [alt]. (Touches Alt et "." Ensemble) c'est la même chose que $! (Insère le dernier argument de la commande précédente) sauf qu'il est immédiat et pour moi plus facile à taper. (Ne peut tout simplement pas être utilisé dans les scripts)

par exemple:

mkdir -p /tmp/test/blah/oops/something
cd [alt].

Chaîne plusieurs commandes ensemble à l'aide de la commande && :

./run.sh && tail -f log.txt

ou

kill -9 1111 && ./start.sh