Quel est votre truc de ligne de commande le plus préféré avec Bash?

Nous soaps tous comment utiliser -R pour inverser la recherche dans l’historique, mais saviez-vous que vous pouvez utiliser -S pour faire avancer la recherche si vous définissez stty stop "" ? De plus, avez-vous déjà essayé de lancer bind -p pour voir tous les raccourcis clavier répertoriés? Il y a plus de 455 sur Mac OS X par défaut.

Quel est votre truc obscure, votre raccourci clavier ou votre configuration préférée le plus préféré avec bash?

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

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

 cd - 

C’est l’équivalent de la ligne de commande du bouton Retour (vous amène au répertoire précédent dans lequel vous vous trouviez).

Un autre favori:

 !! 

Répète votre dernière commande. Les plus utiles sous la forme:

 sudo !! 

Mon préféré est “^ ssortingng ^ ssortingng2” qui prend la dernière commande, remplace la chaîne par ssortingng2 et l’exécute

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

Guide 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 

Si utile

Je suis fan des !$ ,! !^ Et !* Expandos, en retournant, à partir de la dernière ligne de commande soumise: le dernier élément, le premier élément non-commande et tous les éléments autres que les commandes. À 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 ls filea fileb pratique lorsque vous dites, ls filea fileb , et souhaitez en éditer un: vi !$ Ou les deux: vimdiff !* . Il peut également être généralisé à “le nième argument” comme ceci:

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

Enfin, avec les noms de chemin, vous pouvez accéder à des parties du chemin en ajoutant :h et :t à l’un quelconque 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, je vais briser une boucle d’une ligne si je dois 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 fichier .bash_login (ou .bashrc) est vraiment utile. Ce qui suit est un cadre de parameters que j’utilise sur mon Macbook Pro.

Si vous définissez ce qui suit, bash efface les commandes en double dans votre historique:

 export HISTCONTROL="erasedups:ignoreboth" 

Je fais également monter la taille de mon histoire assez haut aussi. Pourquoi pas? Cela ne semble pas ralentir les microprocesseurs actuels.

 export HISTFILESIZE=500000 export HISTSIZE=100000 

Une autre chose que je fais est d’ignorer certaines commandes de mon histoire. Pas besoin de se souvenir de la commande de sortie.

 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 le cmdhist. Cela vous permet d’enregistrer des 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 -S pour qu’il n’arrête pas le défilement. Cela empêche bash de pouvoir l’interpréter comme une recherche avancée.

 stty stop "" 

Comment lister uniquement les sous-répertoires dans le répertoire actuel?

 ls -d */ 

C’est un truc simple, mais vous ne sauriez pas combien de temps j’ai eu à le trouver!

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 diff la sortie 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 transmettre à diff pour 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 d’envoyer des messages à chaque serveur, d’écrire chaque liste de RPM pour séparer les fichiers et de faire un diff sur ces fichiers, je peux simplement faire la diff depuis 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 d'autres exemples dans le Guide avancé de script Bash à http://tldp.org/LDP/abs/html/process-sub.html .

Ma commande préférée est “ls -thor”

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

Plus d’une nouveauté, mais c’est intelligent …

Top 10 des commandes utilisées:

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

Sortie de l’échantillon:

  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, tapez un fragment d’une commande précédente que vous souhaitez faire correspondre et appuyez sur ^ R jusqu’à ce que vous trouviez celui que vous voulez. Ensuite, je ne dois pas me souvenir des commandes récemment utilisées qui sont encore dans mon histoire. Pas exclusivement bash, mais aussi: ^ E pour fin de ligne, ^ A pour début de ligne, ^ U et ^ K à supprimer avant et après le curseur, respectivement.

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

Par exemple:

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

Cool, n’est-ce pas?

Voici quelques réglages de configuration:

~/.inputrc :

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

Cela fonctionne comme ^R mais 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 accéder à la dernière chose à laquelle je me suis rendu dans le dossier /media/ .

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

L’achèvement de Bash est aussi incroyablement utile, mais c’est un ajout beaucoup plus subtil. Dans ~/.bashrc :

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

Cela permettra de terminer les tabs par programme (par exemple, la tentative de complétion de tabulation lorsque la ligne de commande commence par evince affichera uniquement les fichiers pouvant être ouverts) et complétera également les options de ligne de commande).

Fonctionne bien avec cela aussi 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 modificateur :p pour imprimer un résultat de l’historique. Par exemple

 !!:p 

Imprimera la dernière commande afin que vous puissiez vérifier que c’est correct avant de l’exécuter à nouveau. Il suffit d’entrer !! pour l’exécuter.

Dans la même veine:

 !?foo?:p 

Recherche dans votre historique la commande la plus récente contenant la chaîne ‘foo’ et l’imprime.

Si vous n’avez pas besoin d’imprimer,

 !?foo 

fait la recherche et l’exécute immédiatement.

J’ai une arme secrète: 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.

Un que j’adore (mais je sortingche un peu depuis que j’utilise le fait que Python est installé sur la plupart des systèmes Unix maintenant):

 alias webshare='python -m SimpleHTTPServer' 

Maintenant, chaque fois que vous tapez “webshare”, le répertoire actuel sera disponible via le port 8000. Vraiment sympa lorsque vous souhaitez partager des fichiers avec des amis sur un réseau local sans clé USB ou répertoire distant. La diffusion de vidéos et de 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 dans un serveur de production …

Vous pouvez utiliser la commande watch conjointement avec une autre commande pour rechercher des modifications. Un exemple de ceci é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 dans / usr / bin / PROG qui aurait pu être attendu.

J’aime construire des commandes avec écho 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, cela est très important pour les actions destrucsortingces ou irrévocables.

Lorsque je télécharge un gros fichier, je le fais souvent:

 while ls -la ; do sleep 5; done 

Et puis juste ctrl + c quand je suis fini (ou si ls retourne non nul). Il est similaire au programme de watch mais 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 

Vous pouvez ensuite configurer une imprimante sur un autre ordinateur, mais utiliser 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 .

pushd et popd presque toujours utiles

Un moyen privilégié de naviguer lorsque j’utilise plusieurs répertoires à des endroits très distincts dans une hiérarchie d’arborescence consiste à utiliser acf_func.sh (répertorié ci-dessous). Une fois défini, vous pouvez faire

cd –

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

cd -2

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

Très facile à utiliser, 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 "\"\Cw\":cd_func -- ;" fi 

Développez les lignes compliquées avant de bash l’entrée redoutée

  • Alt + Ctrl + eshell-expand-line (il peut être nécessaire d’utiliser Esc , Ctrl + e sur votre clavier)
  • Ctrl + _annuler
  • Ctrl + x , *glob-expand-word

$ 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 été partisan de:

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

J’utilise aussi shopt -s cdable_vars , puis vous pouvez créer des variables bash dans des répertoires communs. Donc, pour l’arbre source de mon entreprise, je crée un tas de variables comme:

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

alors je peux changer à 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 normalement, mais si vous faites une “grosse” erreur, vous pouvez appuyer sur la touche Echap, puis utiliser “b” et “f” pour vous déplacer comme dans vi. cw pour changer un mot. Particulièrement utile après avoir créé une commande d’historique que vous souhaitez modifier.

Semblable à beaucoup ci-dessus, mon favori actuel est la frappe au clavier [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 que pour moi, il est plus facile à taper. (Ne peut pas être utilisé dans les scripts)

par exemple:

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

Chaînes multiples en utilisant la commande && :

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

ou

 kill -9 1111 && ./start.sh