it-swarm-eu.dev

Quelles sont vos fonctionnalités ou astuces préférées en ligne de commande?

Partagez vos fonctionnalités et astuces en ligne de commande pour Unix/Linux. Essayez de garder le Shell/distro agnostique si possible. Intéressé à voir des alias, des lignes simples, des raccourcis clavier, de petits scripts Shell, etc.

93
cmcginty

Cela s'étend un peu sur le !! astuce mentionnée dans cette réponse . Il y a en fait un tas de commandes liées à l'histoire qui ont tendance à être oubliées (les gens ont tendance à poignarder Up 100 fois au lieu de chercher une commande qu'ils savent avoir tapée).

  • La commande history affichera une liste des commandes récemment exécutées avec un désignateur d'événement à gauche
  • !N remplacera la commande associée au désignateur d'événement N
  • !-N remplacera le N e commande la plus récente; par exemple. !-1 remplacera la commande la plus récente, !-2 le deuxième plus récent, etc.
  • Comme mentionné dans l'autre réponse, !! est un raccourci pour !-1, pour remplacer rapidement la dernière commande
  • !string remplacera la commande la plus récente commençant par string
  • !?string? remplacera la commande la plus récente qui contient string

Des désignateurs de mots peuvent être ajoutés à un ! commande historique pour modifier les résultats. Un deux-points sépare les désignateurs d'événement et de mot, par exemple !!:0. Le désignateur d'événement !! peut être abrégé en ! lorsque vous utilisez un indicateur Word, donc !!:0 est équivalent à !:0.

  • !:0 obtiendra la commande qui a été exécutée
  • !:1 obtiendra le premier argument (et !:2 le deuxième, etc.)
  • !:2-3 obtiendra les deuxième et troisième arguments
  • !:^ est une autre façon d'obtenir le premier argument. !:$ obtiendra le dernier
  • !:* obtiendra tous les arguments (mais pas la commande)

Les modificateurs peuvent également être ajoutés à un ! commande historique, chacune précédée d'un deux-points. N'importe quel nombre peut être empilé (par exemple !:t:r:p).

  • h - Aligne sur le nom de fichier de base
  • t - Seul le nom de fichier de base
  • r - Aligne l'extension de nom de fichier
  • e - Seule l'extension du nom de fichier
  • s/search/replacement - Remplace la première occurrence de search par replacement
  • gs/search/replacement - Remplace toutes les occurrences de search par replacement
88
Michael Mrozek

bash - insérer le paramètre final de la ligne précédente

alt-. la combinaison de touches la plus utile de tous les temps, essayez-la et voyez, pour une raison inconnue, personne ne la connaît.

appuyez encore et encore pour sélectionner les derniers paramètres les plus anciens.

génial quand vous voulez faire quelque chose de plus avec l'argument/fichier que vous avez utilisé il y a un instant.

64
chillitom

Mon favori est

man 7 ascii

Simple et donc très utile.

   Oct   Dec   Hex   Char                        Oct   Dec   Hex   Char
   ────────────────────────────────────────────────────────────────────────
   000   0     00    NUL '\0' (null character)   100   64    40    @
   001   1     01    SOH (start of heading)      101   65    41    A
   002   2     02    STX (start of text)         102   66    42    B
   003   3     03    ETX (end of text)           103   67    43    C
   004   4     04    EOT (end of transmission)   104   68    44    D
   005   5     05    ENQ (enquiry)               105   69    45    E
   006   6     06    ACK (acknowledge)           106   70    46    F
   007   7     07    BEL '\a' (bell)             107   71    47    G
   010   8     08    BS  '\b' (backspace)        110   72    48    H
   011   9     09    HT  '\t' (horizontal tab)   111   73    49    I
   012   10    0A    LF  '\n' (new line)         112   74    4A    J
   013   11    0B    VT  '\v' (vertical tab)     113   75    4B    K
   014   12    0C    FF  '\f' (form feed)        114   76    4C    L
   015   13    0D    CR  '\r' (carriage ret)     115   77    4D    M
   016   14    0E    SO  (shift out)             116   78    4E    N
   017   15    0F    SI  (shift in)              117   79    4F    O
   020   16    10    DLE (data link escape)      120   80    50    P
   021   17    11    DC1 (device control 1)      121   81    51    Q
   022   18    12    DC2 (device control 2)      122   82    52    R
   023   19    13    DC3 (device control 3)      123   83    53    S
   024   20    14    DC4 (device control 4)      124   84    54    T
   025   21    15    NAK (negative ack.)         125   85    55    U
   026   22    16    SYN (synchronous idle)      126   86    56    V
   027   23    17    ETB (end of trans. blk)     127   87    57    W
   030   24    18    CAN (cancel)                130   88    58    X
   031   25    19    EM  (end of medium)         131   89    59    Y
   032   26    1A    SUB (substitute)            132   90    5A    Z
   033   27    1B    ESC (escape)                133   91    5B    [
   034   28    1C    FS  (file separator)        134   92    5C    \  '\\'
   035   29    1D    GS  (group separator)       135   93    5D    ]
   036   30    1E    RS  (record separator)      136   94    5E    ^
   037   31    1F    US  (unit separator)        137   95    5F    _
   040   32    20    SPACE                       140   96    60    `
   041   33    21    !                           141   97    61    a
   042   34    22    "                           142   98    62    b
   043   35    23    #                           143   99    63    c
   044   36    24    $                           144   100   64    d
   045   37    25    %                           145   101   65    e
   046   38    26    &                           146   102   66    f
   047   39    27    '                           147   103   67    g
   050   40    28    (                           150   104   68    h
   051   41    29    )                           151   105   69    i
   052   42    2A    *                           152   106   6A    j
   053   43    2B    +                           153   107   6B    k
   054   44    2C    ,                           154   108   6C    l
   055   45    2D    -                           155   109   6D    m

   056   46    2E    .                           156   110   6E    n
   057   47    2F    /                           157   111   6F    o
   060   48    30    0                           160   112   70    p
   061   49    31    1                           161   113   71    q
   062   50    32    2                           162   114   72    r
   063   51    33    3                           163   115   73    s
   064   52    34    4                           164   116   74    t
   065   53    35    5                           165   117   75    u
   066   54    36    6                           166   118   76    v
   067   55    37    7                           167   119   77    w
   070   56    38    8                           170   120   78    x
   071   57    39    9                           171   121   79    y
   072   58    3A    :                           172   122   7A    z
   073   59    3B    ;                           173   123   7B    {
   074   60    3C    <                           174   124   7C    |
   075   61    3D    =                           175   125   7D    }
   076   62    3E    >                           176   126   7E    ~
   077   63    3F    ?                           177   127   7F    DEL

Jetez un œil à ce site Web commandlinefu.com .

Vous pouvez également consulter ces quatre articles de Peteris Krumins sur son blog

49
Moeb

Exécutez la dernière commande en tant que root:

Sudo !!
46
Alex B

Je ne sais pas si cela compte comme un "truc", mais les gens semblent très peu au courant des raccourcis clavier de ligne de lecture standard. D'une utilisation particulière dans les coquilles:

  • Ctrl+U - Couper la ligne actuelle
  • Ctrl+Y - Collez une ligne coupée avec Ctrl+U
  • Ctrl+L - Effacez l'écran et redessinez la ligne actuelle
  • Ctrl+G - Obtenez une nouvelle ligne et abandonnez la ligne actuelle
42
Michael Mrozek

CTRL+R en BASH pour rechercher/activer des commandes précédemment exécutées (le contenu de ~/.bash_history).

C'est souvent extrêmement utile. L'exécution de cet alias servira le PWD sur HTTP (indexé) sur le port 8000:

alias webserver="python -m SimpleHTTPServer"

Et parce que je lance make tout le temps, et que je tape trop vite, ces alias sont probablement mes plus utilisés (sérieusement):

alias maek=make
alias mkae=make
alias meak=make
alias amka=make
alias akme=make

Et probablement mon morceau de BASH le plus fréquemment utilisé est un simple script que j'appelle upload. Je l'utilise pour intégrer tout type de contenu à mon Linode, et il copie l'URL HTTP résultante dans mon presse-papiers (clic du milieu). Très utile pour coller des trucs à des personnes dans IRC:

scp -r $* [email protected]$Host:public_html && {
    URL="http://$Host/~$user/$(basename $1)"
    echo "$URL"
    xselection -replace PRIMARY "$URL"
}

Juste un couple. Je peux poster beaucoup plus tard, je dois retourner au travail!

36
Aaron Bockover

diff la sortie de deux commandes sans créer manuellement un fichier temporaire (bash):

diff <(ls dir1) <(ls dir2)
31
Alex B

Assez basique, mais les gens ne semblent pas le savoir, vous ramène au répertoire précédent:

cd -
30
Robert Swisher

Expansion de l'accolade :

L'expansion d'accolade est un mécanisme par lequel des chaînes arbitraires peuvent être générées.

Il vous permet de remplacer les lignes fastidieuses comme:

mv loong/and/complex/file/name loong/and/complex/file/name.bacukup

avec une instance plus courte

mv loong/and/complex/file/name{,backup}

quelques autres utilisations

# to display the diff between /etc/rc.conf and /etc/rc.conf.pacsave
diff /etc/rc.conf{,.pacsave}

# to list files in both /usr/share and /usr/local/share
ls /usr/{,local}/share 

Expansion arithmétique :

L'expansion arithmétique permet l'évaluation d'une expression arithmétique et la substitution du résultat. Le format de l'expansion arithmétique est le suivant:

$((expression))

L'expression est traitée comme si elle se trouvait entre guillemets doubles, mais un guillemet double entre parenthèses n'est pas traité spécialement. Tous les jetons de l'expression subissent une expansion de paramètre, une expansion de chaîne, une substitution de commande et une suppression de devis. Les extensions arithmétiques peuvent être imbriquées.

$ a=1
$ b=2
$ echo $(( a+(b*2) ))
5
29
Stefan

C'est généralement dans mon script de démarrage (.bashrc, .profile, peu importe)

shopt bonté, vérifiez les commentaires:

shopt -s cdspell        # try to correct typos in path
shopt -s dotglob        # include dotfiles in path expansion
shopt -s hostcomplete   # try to autocomplete hostnames

Un alias qui enregistre les frappes: mkdir et cd dedans:

mkcd () { mkdir -p "[email protected]" && cd "[email protected]"; }

Et enfin et surtout, j'ai abandonné la mémorisation de la syntaxe tar, donc:

extract () {
    if [ -f $1 ] ; then
        case $1 in
            *.tar.bz2)  tar xjf $1      ;;
            *.tar.gz)   tar xzf $1      ;;
            *.bz2)      bunzip2 $1      ;;
            *.rar)      rar x $1        ;;
            *.gz)       gunzip $1       ;;
            *.tar)      tar xf $1       ;;
            *.tbz2)     tar xjf $1      ;;
            *.tgz)      tar xzf $1      ;;
            *.Zip)      unzip $1        ;;
            *.Z)        uncompress $1   ;;
            *)          echo "'$1' cannot be extracted via extract()" ;;
        esac
    else
        echo "'$1' is not a valid file"
    fi
}
29
Sygo

Deux fonctions bash qui me font économiser de nombreux coups de touches.

Faites automatiquement un ls après chaque cd réussi:

function cd {
    builtin cd "[email protected]" && ls
}

Montez n niveaux:

# Usage .. [n]
function .. (){
    local arg=${1:-1};
    local dir=""
    while [ $arg -gt 0 ]; do
        dir="../$dir"
        arg=$(($arg - 1));
    done
    cd $dir #>&/dev/null
}
21
Maik

Étant donné que je suis généralement à mi-chemin d'une ligne de commande avant de vouloir rechercher (CTRL-R en bash), j'ai ce qui suit dans mon .bashrc

bind '"\e[A"':history-search-backward
bind '"\e[B"':history-search-forward

Cela signifie que si je tape cd puis appuyez sur haut/bas, je peux voir toutes les options que j'ai sur cd'd. Fondamentalement, je l'utilise pour les répertoires souvent utilisés. Comme "cd w" et je finis par parcourir tous les espaces de travail que j'utilise beaucoup.

17
mendicant

Une chose qui me fait gagner beaucoup de temps est les commandes pushd/popd. Ces gars vous permettent de créer une pile de répertoires et de réduire beaucoup la frappe:

/foobar/ > pushd /src/whatever/foo/test
/foobar/src/whatever/foo/test > make run
/foobar/src/whatever/foo/test > popd
/foobar/ > make
17
jacksonh

Le screencommande . Il enregistre essentiellement votre session de ligne de commande lorsque vous revenez. C'est une sorte de gestionnaire de terminaux, comme un gestionnaire de fenêtres. De cette façon, dans une seule session de terminal, vous pouvez avoir plusieurs terminaux virtuels en cours. C'est vraiment cool.

Si l'on utilise screen, cette fonction Shell (mettez-la dans .bashrc) est extrêmement utile:

function scr {
    if screen -ls | grep -q Main; then
         # reattach to Main: 
         screen -xr Main
    else
         # name session "Main":
         screen -S Main
    fi
   }

en tapant scr, il vérifiera si votre session principale existe et s'y attachera. Sinon, il le créera.

14
user394

Si vous devez modifier une ligne de commande particulièrement longue dans bash

^X^E (Ctrl-X Ctrl-E) 

l'ouvrira dans l'éditeur ($ EDITOR).

Dans zsh, vous pouvez obtenir le même comportement en ajoutant ceci à .zshrc:

autoload edit-command-line
zle -N edit-command-line
bindkey '^X^e' edit-command-line 
13
redacted

Si vous êtes un dactylographe rapide, ceux-ci sont utiles:

alias grpe='grep --color=tty'
alias gpre='grep --color=tty'
alias rgep='grep --color=tty'
alias gerp='grep --color=tty'

Cette macro vous aide à calculer les totaux d'une colonne de sortie: tailles de fichier, octets, paquets, tout ce que vous avez à faire est de spécifier la colonne que vous souhaitez ajouter:

total ()
{
        if [ x$1 = x ]; then set `echo 1`; fi
        awk "{total += \$$1} END {print total}"
}

Vous l'utilisez comme ceci par exemple, sans argument, il ajoute le total de la première colonne:

du | total

Si vous fournissez l'argument, il additionnera cette colonne, par exemple, cela vous donne le nombre total d'octets utilisés par tous les fichiers C # dans/tmp:

ls -l /tmp/*cs | total 5

Parfois, votre console est gâchée parce que vous avez accidentellement consulté un fichier binaire (cat/bin/ls par exemple), vous pouvez restaurer le terminal avec cette fonction Shell:

restaura ()
{
    Perl -e 'print "\e)B";'
}

J'aime que mes ls utilisent des caractères pour distinguer la classe de fichiers, et aussi pour cacher les fichiers de sauvegarde générés par mon éditeur (les fichiers de sauvegarde se terminent par le caractère ~):

alias ls='ls -FB'
12
miguel.de.icaza
alias s='Sudo'
alias r='rake' # i'm a Ruby developer
alias ..='cd ..' # although with autocd feature for zsh this comes packed.

Un de mes favoris quand j'oublie s:

$ s !! # last command with super user priviledges
11
Eimantas

Si une commande prend l'entrée stdin, vous pouvez lire l'entrée d'un fichier avec <filename. Cela peut apparaître n'importe où dans la commande, donc ces lignes sont équivalentes:

cat filename
cat <filename
<filename cat

Ceci est particulièrement utile pour grep, car il vous permet de placer l'expression à la fin de la ligne, de sorte que vous pouvez rapidement modifier une commande grep en appuyant sur Up, sans avoir besoin de faire défiler vers la gauche pour dépasser le nom de fichier:

<filename grep 'expression'
10
Michael Mrozek

Vous pouvez utiliser CDPATH pour configurer l'équivalent du répertoire de PATH; si vous essayez de cd foo et il n'y a pas de foo dans le répertoire courant, le Shell vérifiera chacun des répertoires dans CDPATH recherchant foo dedans, et basculera vers le premier qu'il trouve:

export CDPATH="/usr"
cd bin # switches to 'bin' if there is one in the current directory, or /usr/bin otherwise
9
Michael Mrozek
vi `which scriptname`

Car quand vous ne savez pas où vit quelque chose et que vous vous en fichez.

9
Matt Simmons

Le esperluette. Il met votre commande en arrière-plan, vous pouvez donc continuer à taper.

$> Sudo updatedb &

En travaillant le long et après un certain temps, vous voyez:

[1] 17403

Et votre processus est terminé! Idéal pour les choses où vous n'avez pas besoin d'attendre qu'elles se terminent.

9
user394

Fin de tabulation. À quel point cela serait-il nul si vous deviez taper tous les caractères de chaque chemin?

8
user394

J'ai ceci dans mon .bashrc

#shortcut for CTRL+C and CTRL+V
alias c-c='xclip -sel clip'
alias c-v='xclip -o -sel clip'

function find-all() {
    python -c "import re
import sys
for i in re.findall('$1', sys.stdin.read()):
    if type(i) == type(''):
        print i
    else:
        print i[0]"
}

Et quand j'ai du code source html dans le presse-papiers et que je veux trouver tous les liens que j'utilise

c-v | find-all 'href="([^"]*)"' | c-c

Et j'ai toutes les URL dans le presse-papiers

J'ai aussi cette fonction

function lsq(){
    ls -lh [email protected] | tr -s ' ' | cut -d' ' -f5,8
}

qui affichent la taille (lisible par l'homme) et le nom du fichier.

alias temp='cat /proc/acpi/thermal_zone/THRM/temperature'

cet alias est pour afficher la température

function separate() {
    python -c "import sys,re; print '$1'.join(re.split('\s*', sys.stdin.read().strip()))";
}

avec cette fonction, je peux calculer le produit ou la somme des arguments.

alias sum='separate + | bc'
alias product='separate * | bc'

function split-join() {
    python -c "import sys,re; print '$2'.join(re.split('$1', sys.stdin.read().strip()))";
}

Il s'agit d'une fonction utile qui divise l'entrée standard séparée par l'expression régulière et joint ensuite le résultat.

function factorial() {
    seq -s* $1 | bc
}

fonction factorielle

function wiki() { Dig +short txt $1.wp.dg.cx; }

Cette fonction affiche le texte wiki sur DNS

J'ai aussi trois fonctions de couleur

function blue() {
    echo -e "\x1b[34m\x1b[1m"[email protected]"\x1b[0m";
}

function green() {
    echo -e "\x1b[32m\x1b[1m"[email protected]"\x1b[0m";
}

function red() {
    echo -e "\x1b[31m\x1b[1m"[email protected]"\x1b[0m";
}

function md5check() {
    test `md5sum $2 | cut -d' ' -f1` = "$1" && green [OK] || red [FAIL]
}

Cette fonction valide le hachage du fichier md5.

cela affichera un message d'erreur pour un code donné

function strerror() { python -c "import os; print os.strerror($1)"; }

Vous pouvez imprimer tous les messages avec

alias all-errors='for i in `seq 131`; do echo -n "$i: "; strerror $i; done'
7
jcubic

Dernier appareil monté:

mount /media/whatever
...
u!mo

!mo se développe jusqu'à la dernière commande qui a commencé par mo (au moins en bash). Parfois, on fait mv au milieu, donc u!m ne fonctionnera pas aussi souvent.

7
Roberto Bonvallet

Une autre astuce ZSH utile:

Traitez la sortie d'une commande comme un fichier:

emacs =(hg cat -r 100 somefile)

Cela ouvre une ancienne version d'un fichier suivi Mercurial dans emacs pour une visualisation mise en évidence par la syntaxe. Sans cela, je devrais jouer avec hg revert, hg archive, ou envoyer explicitement hg cat sortie vers un fichier temporaire.

Bien sûr, cela fonctionne avec tout programme qui ouvre des fichiers et tout programme qui imprime sur une sortie standard.

6
Matthew Flaschen

Une fonction spécifique à ZSH est constituée d'alias de suffixe, définis en donnant à alias le -s drapeau:

alias -s ext=program

Si une extension donnée a un alias de suffixe, vous pouvez exécuter un fichier avec cette extension directement, et ZSH lancera le programme donné et passera le nom de fichier comme argument. Donc, si l'alias ci-dessus est en vigueur, ces lignes sont équivalentes:

/path/to/foo.ext
program /path/to/foo.ext
5
Michael Mrozek

Une de mes fonctionnalités ZSH préférées de tous les temps est nommée répertoires. Vous pouvez exporter une variable avec un nom donné, avec une valeur qui pointe vers un certain chemin:

export foo=/usr/bin

Vous pouvez maintenant utiliser ~foo dans une commande pour faire référence à /usr/bin:

cd ~foo
~foo/ls
cat ~foo/filename
5
Michael Mrozek
  • La commande ne rien faire : un péché

    while :; do :; done
    
  • Expansion de l'entretoise en combinaison avec des boucles for:

    for c in {1..3}; do :; done
    
  • ! opérateur et opérateurs de court-circuit || et &&

    [ -d /tmp/dir ] || mkdir /tmp/dir
    
    if ! ping 34.41.34.1; then :; fi
    
  • utiliser des sous-shells au lieu de pop/Push (est très pratique dans les scripts)

    ~$ ( cd /tmp; echo $PWD )
    /tmp
    ~$
    
  • le genre de what-is commande type

    ~$ type type
    type is a Shell builtin
    ~$ type ls
    ls is aliased to `ls --color=auto'
    ~$ f(){ :; }
    ~$ type f
    f is a function
    f () 
    { 
         :
    
    }
    
  • aussi très sympa: ici-cordes

    ~$ cat <<<"here $PWD"
    here /home/yourname
    ~$
    
  • et mon préféré: redirection sur une liste de commandes

    { w; ps; ls /tmp; } 2>/dev/null |less
    
4
artistoex

Voir ceci question.

Lorsque vous exécutez ps ax | grep string:

[st[email protected] ~]$ ps ax | grep 'openbox'
 3363 ?        Ss     0:00 /usr/bin/openbox
 3382 ?        Ss     0:00 /usr/bin/ssh-agent -- /usr/bin/openbox-session
 3386 ?        S      0:00 /bin/sh /usr/bin/openbox-session
 3388 ?        S      0:00 /bin/sh /usr/bin/openbox-session
 3389 ?        S      0:00 /bin/sh /usr/bin/openbox-session
 3390 ?        S      0:00 /bin/sh /usr/bin/openbox-session
 5100 pts/0    S+     0:00 grep openbox

la dernière ligne contenant grep est quelque chose d'un peu ennuyeux

Vous pouvez vous en débarrasser en exécutant ps ax | grep '[s]tring':

[[email protected] ~]$ ps ax | grep '[o]penbox'
 3363 ?        Ss     0:00 /usr/bin/openbox
 3382 ?        Ss     0:00 /usr/bin/ssh-agent -- /usr/bin/openbox-session
 3386 ?        S      0:00 /bin/sh /usr/bin/openbox-session
 3388 ?        S      0:00 /bin/sh /usr/bin/openbox-session
 3389 ?        S      0:00 /bin/sh /usr/bin/openbox-session
 3390 ?        S      0:00 /bin/sh /usr/bin/openbox-session

mise à jour : ou exécutez simplement pgrep string

4
Stefan

Parfois, les paramètres bash sont tels que rm est aliasé à rm -i et nécessite donc une confirmation pour chaque fichier supprimé. Lorsque je travaille occasionnellement sur un tel compte, j'utilise \rm pour récupérer le comportement d'origine de rm sans modifier la configuration utilisateur.

3
mouviciel

J'adore insérer autant de choses que possible dans ma PS1. Quelques choses utiles à retenir:

\e[s et \e[u enregistrer et annuler la position du curseur respectivement. Je l'utilise pour créer une "barre d'informations" en haut de l'écran, longue de quelques lignes, qui peut contenir plus de choses. Exemple:

PS1='\[\e[s\e[7m\e[1;1H\]\w\n\t        \j / \! / \#\[\e[u\e[0m\e[33;1m\][\[email protected]\h \[\e[34m\]\W]\[\e[0m\]\$ '

Combiner avec alias clear='echo -e "\e[2J\n"'. Essaye le!

Également Prompt_COMMAND variable définit une commande à exécuter avant la PS1 à chaque fois.

Une autre est la commande bg. Si vous oubliez de mettre & à la fin d'une commande, appuyez simplement sur ^Z et tapez bg, et il s'exécute en arrière-plan.

3
Lucas Jones

Afficher la branche et l'état de Git dans l'invite

 export GIT_PS1_SHOWDIRTYSTATE = true 
 
 if ["$ color_Prompt" = yes]; alors 
 PS1 = '$ {debian_chroot: + ($ debian_chroot)}\[\ 033 [01; 32m \]\u @\h\[\ 033 [00m \]:\[\ 033 [01; 34m \]\w\[\ 033 [00m \] $ (__ git_ps1 "#% s")\$ '
 Else 
 PS1 =' $ {debian_chroot: + ($ debian_chroot)}\u @\h:\w $ (__ git_ps1 "#% s")\$ '
 fi 
3
Bauna

Ma commande préférée est 'trouver', je l'utilise partout ... exemples:

find . -name "*.log" -exec ls -l {} \; | grep "$(find . -name "*.log" -exec ls -l {} \;| nawk '{print $5}' | sort -n | tail )"

Affichez simplement les fichiers les plus lourds au format ls -l (long).

Ensuite, si vous avez besoin de votre code avec les autorisations 0640, recherchez simplement:

find . \( \( ! -perm 0640 \) -a \( -name "*.cpp" -o -name "*.h" \) \) -ls | nawk '{print $3"\t"$11}'

ou remplacer:

find . \( -name "*.cpp" -o -name "*.h" \) | xargs chmod 640

Alors, avez-vous besoin d'un symbole et vous ne savez pas où il se trouve ??

(
  for myObj in $(find . -name "*.o"); do
    gotSym=$(dump -Xany -t $myObj | grep .MY_SYMBOL)
    if ! test "x$gotSym" = "x"
    then
      echo "OBJECT [$myObj] ========================"
      echo "$gotSym"
      echo "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^"^
    fi
  done
)

Fichiers plus récents que XFILE ??

find . -newer XFILE -type f

Ouais, "trouve" rulez!

3
D4RIO

Une fois si souvent lorsque vous avez tapé une longue commande et avant de la terminer, vous avez réalisé que cela ne fonctionnera pas tout de suite, car vous devez exécuter autre chose avant (par exemple, entré git commit -m "long commit message here"), vous pouvez appuyer sur ^A^K pour aller au début de la ligne et la tuer (sauvegarde dans un tampon), ensuite exécuter une commande pour corriger les choses, et enfin ^Y pour coller la commande supprimée et continuer. Économise beaucoup de retaper. Tout cela, bien sûr, c'est quand readline est en mode Emacs.

Un autre gain de temps: mkdir -p some/nested/dirs/to/be/created crée tous les répertoires d'un chemin s'ils sont manquants.

3
alex

Affiche un bel art ascii de l'arbre de processus actuel, avec le processus le plus intensif en CPU mis en évidence.

while true; do 
  clear; 
  pstree $( ps -eo pid --sort %cpu | tail -n 1 ); 
  sleep 1;
done

Tuez-le avec Ctrl + C

3
Stefan

Voir la sortie de commande mise à jour toutes les n secondes

watch -n 60 df -h (displays df -h every 60 seconds)

Afficher les statistiques sur le périphérique réseau wlan0

ip -s link ls wlan0

Afficher la table de routage pour le périphérique eth1

ip route ls dev eth1

Afficher les statistiques de tous les routeurs parcourus par les paquets pour atteindre l'hôte

mtr --interval 5 HOSTNAME

Consulter les enregistrements DNS inversés pour les noms d'hôte sur le RÉSEAU

nmap -sL NETWORK

Comparer un site Web

ab

Obtenez tous les liens d'une page Web

lynx -dump http://www.yahoo.com | awk '/http/{print $2}'

Afficher la passerelle par défaut

netstat -rn | awk '/UG/{print $2}'

Écrire une erreur standard dans un fichier

foo 2> errors.txt

Rediriger stderr vers stdout

foo 2>&1

Redirigez stderr et stdout vers le même fichier.

foo > file.txt 2>&1
2
boardstretcher
# change chmod to file dowloaded --> $_

wget -c http://link/to/file -O /path/to/save/namefile && chmod 0755 $_

# extract tar.bz2 or tar.gz whit less work
# this avoids having to unpack and then move the files to another location, in this case have # already extracted in the desired location

tar jxvf file.tar.bz2 -C /pat/to/extract

# calculator with bc - in bashrc
calc(){ echo "scale=2;[email protected]" | bc;}

# set magic-space in bashrc
bind Space:magic-space                 # !pin<space>  expand last cmd pin...

# alias to open last edited file in vim
alias lvim="vim -c \"normal '0\""

# alias to show your path set
alias path='echo -e ${PATH//:/\\n}'
2
SergioAraujo

Remplacez des parties de la commande précédente:

^chercher^remplacer

$ echo a b c d
a b c d
$ ^b c^X
echo a X d
a X d

Idéal pour les fautes de frappe:

$ mkae
-bash: mkae: command not found
$ ^ka^ak
make
[...]
2
user6362

Résumer la taille du répertoire, avec une taille humaine décroissante

du -hs */ | sort -hr

par exemple.

10.2G   foo/
4M      bar/
2
Eric Fortis

expansion double étoile avec zsh (qui descend récursivement l'arborescence des répertoires, pas seulement un niveau, quelque chose de similaire à $(find ! -type d):

grep string **/*.cc
2
Andre Holzner

ma fonction préférée est PAS DE COULEURS! =)

TERM = xterm-mono ou TERM = linux-m dépend du système d'exploitation ...

J'aime vraiment l'IRSSI en noir et blanc, le mc et tout autre outil "Interface utilisateur texte"

2
holms

ZSH a des alias globaux. Il étend l'alias n'importe où dans la ligne de commande. J'ai trouvé cela utile pour les noms d'hôtes:

Par exemple.:

alias -g sub='sub.domain.tld'

Ensuite, je peux faire par exemple:

sftp sub
ssh sub

etc.

2
Matthew Flaschen

Pas vraiment un one-liner mais je pense que c'est utile. Convertissez de nombreux fichiers en majuscules, par exemple file_to_upper *php *c. Il existe de nombreux cas similaires comme la conversion en versions inférieures, le changement de nom de tous les fichiers par suffixe/préfixe, etc.

file_to_upper ()
{
    for file in "[email protected]"
    do
        if [ ! -f "$file" ]; then
            echo "File $file does not exist";
        else
            mv -f "$file" "`echo "$file" | tr '[a-z]' '[A-Z]'`"
        fi
    done

    return 0
}
1
sakisk

obtenir le nom du fichier avec l'horodatage le plus récent dans le répertoire courant:

latest () { ls -lrt | tail -1 | awk '{print $NF}' }

1
Moses Xu
function calc() { echo $* p | dc }

dc est une calculatrice RPN; cette fonction me permet de taper l'expression comme arguments de commande:

$ calc 5 3 +
8
1
André Paramés

Afficher une invite où le nom d'hôte est gras. J'ai essayé les invites de couleur pendant un certain temps, mais la couleur semblait parfois mauvaise en fonction de l'arrière-plan. Bold fonctionne pour moi pour un fond clair, un fond sombre, un fond bleu, etc.

C'est dans mon .bashrc:

    bold=$(tput bold)
    reset=$(tput sgr0)
    export PS1="\[email protected]\[$bold\]\h\[$reset\]:\w \$ "
1
Stefan Lasiewski

J'ai trouvé les éléments suivants utiles lors de la commutation constante entre Windows et Unix/Linux:

alias dir="ls -l"
alias copy="cp"
alias del="rm"
1
artdanil

C'est pour zsh, pas bash, fyi (si vous ne l'avez pas utilisé, vous ne regretterez pas de l'avoir essayé). C'est vraiment utile pour taper rapidement de longs chemins pour les transferts scp. Cela fonctionne exactement comme pour compléter ou lister les noms de fichiers/répertoires disponibles.

Exemple

scp [email protected]:/home/webdev/domains/example.com/http.public/long<tab>

terminera le chemin vers /home/webdev/domains/example.com/http.public/longdirname.

Je suis mauvais dans les exemples, mais cela devrait vous donner l'idée. Essayez-le, cela peut vraiment vous éviter de taper des doigts.

# SSH Completion
zstyle ':completion:*:scp:*' tag-order \
   files users 'hosts:-Host hosts:-domain:domain hosts:-ipaddr"IP\ Address *'
zstyle ':completion:*:scp:*' group-order \
   files all-files users hosts-domain hosts-Host hosts-ipaddr
zstyle ':completion:*:ssh:*' tag-order \
   users 'hosts:-Host hosts:-domain:domain hosts:-ipaddr"IP\ Address *'
zstyle ':completion:*:ssh:*' group-order \
   hosts-domain hosts-Host users hosts-ipaddr
zstyle '*' single-ignored show
1
pho3nixf1re

ReTTY , qui vous permet de déplacer un programme en cours d'exécution d'un terminal à un autre. De cette façon, si vous avez un programme ncurses exécuté en dehors de screen, tmux ou ssh, vous pouvez le joindre à une session ssh ou à un écran en réseau ou à une session tmux en exécutant ReTTY dans le terminal où vous souhaitez utiliser le programme en question. En d'autres termes, il est similaire à screen et tmux mais avec les exceptions que (a) il ne peut exécuter qu'un seul programme à la fois, et (b) il peut être exécuté après vous démarrez le processus enfant.

1
mmirate

Mon préféré est d'utiliser la commande python pour créer le serveur http temporaire:

python -m SimpleHTTPServer

et accéder aux fichiers de cette machine sur le lan en tant que:

http://192.168.1.70:80

Une autre consiste à télécharger le fichier tar sous forme extraite sous la forme:

wget -qO - http://192.168.1.70:8000/test.bz2 | tar xjvf -

Ici, le lien peut être n'importe lequel sur le www et bz2 peut être soit gz, tgz ou bz2 lui-même d'ailleurs.

1
SHW

Sauvegardez automatiquement vos fichiers de points fantaisie

.Bashrc modulaire -> .bashrc.d

mkdir -p ~/.bashrc.d
cat<<'EOF' >> ~/.bashrc
echo ""
echo -n ".bashrc.d warming up: "
for script in ~/.bashrc.d/* ; do
  if [ -x "$script" ] ; then
    echo -n "${script##*/} "
    . "$script"
  fi
done
echo ""
echo ""
echo "  All systems are go."
echo ""
EOF

RM plus sûr, compatible avec Linux et Mac OS X

rm() {
  local src
  local final_status=0

  for src in "[email protected]"; do
    # Process only non command-line arguments.
    if [[ "$src" != -* ]]; then
      local trash="$HOME/.Trash"
      if [ ! -e "$src" ]; then
        echo "Safer rm: $src: No such file or directory."
        final_status=1
      fi
      # Create the trash directory if needed.
      if [ ! -d "$trash" ]; then
        # Assume Mac trash, but it'll work on *nix too.
        mkdir -p "$trash"
        if [ ! -d "$trash" ]; then
          echo "Safer rm: Unable to create trash directory $trash"
          echo ""
          echo "   Nothing moved or deleted.  Consider carefully:"
          echo ""
          echo "      /bin/rm -rf $src"
          return 1
        fi
      fi
      local dest="$trash/${src##*/}"

      # Find a filename combination which does not already exist.
      if [ -e "$dest" ]; then
        # Try appending ISO datetime.
        dest="$dest.$(date +%Y-%m-%dT%H-%M-%S)"
        if [ -e "$dest" ]; then
          local n=1
          # Try increasing monotony.
          while [ -e "$dest.$n" ]; do
            n = $[n + 1]
          done
          dest="$dest.$n"
        fi
      fi
      echo -n "Safer rm: Trashing $src to $dest ..."
      /bin/mv "$src" "$dest"
      echo " done."
      echo ""
      echo "  To restore:  /bin/mv     '$dest' '$src'"
      echo ""
      echo "  To purge:  /bin/rm -rf '$dest'"
      echo ""
      echo ""
    fi
  done
  return $final_status
}

Action "cd" super chaude

# Don't ask why I need 15 levels of cd ..

alias ..='cd ..'
alias .2='cd ../..'
alias ...='.2'
alias .3='cd ../../..'
alias .4='cd ../../../..'
alias .5='cd ../../../../..'
alias .6='cd ../../../../../..'
alias .7='cd ../../../../../../..'
alias .8='cd ../../../../../../../..'
alias .9='cd ../../../../../../../../..'
alias .10='cd ../../../../../../../../../..'
alias .11='cd ../../../../../../../../../../..'
alias .12='cd ../../../../../../../../../../../..'
alias .13='cd ../../../../../../../../../../../../..'
alias .14='cd ../../../../../../../../../../../../../..'
alias .15='cd ../../../../../../../../../../../../../../..'

Readline est votre seul vrai dieu.

bind -p | egrep -v '(not|self)' # No existential jokes included.

Polices de terminal

Après avoir regardé des milliards de polices, j'utilise 14 pt Monaco, Anti-aliased avec iTerm2.

Sur Mac (applications): essayez cette application qui fournit des raccourcis clavier.

KeyCue (tm) (r) (c) ($) donne le contexte de presque TOUTE application en cours d'exécution en tenant simplement command.

1
dhchdhd

fonction pushd automatique de zsh:

setopt autopushd

et avec ça:

alias dirs='dirs -v'

Pour qu'à tout moment, je puisse taper dirs et obtenir l'historique de ma position:

0   /var/log
1   /tmp
2   /usr/local/bin
3   ~

puis je peux cd revenir par exemple /usr/local/bin en tappant:

cd ~2
1
Andre Holzner

Aucun des "trucs" suivants n'est techniquement difficile ou impressionnant, mais ils ont un certain impact sur l'autre personne. Si nous ne pouvons pas utiliser nos emplois pour rendre nos vies plus heureuses, alors nous devrions réfléchir à nouveau à certaines choses.

J'aime alias. Mon astuce préférée est d'éditer les ~/.bash_aliases sur l'ordinateur de mon amie car elle est manquante et d'ajouter une ligne comme:

alias gfname='echo Myname is thinking of you'

ou une autre citation romantique.

Un autre "truc" que j'aime particulièrement est:

#!/bin/bash
xaa=123`
for ((a=1; a <= xaa; a++))
do
#sleep 1;
mail -s "Happy Birthday $a" [email protected] < mails.txt
done
exit 0`

où 123 est celui de la personne à qui j'aimerais souhaiter un joyeux anniversaire et mails.txt contient le message que j'aimerais écrire comme corps de l'email. Sleep 1; est parfois nécessaire car il y a une limite sur fork (). Vous pouvez également utiliser des arguments de ligne de commande $1 etc...

1
Dimitris Leventeas

J'ai des dossiers nommés dans mon dossier d'accueil comme Document, Téléchargements, Temp, etc. avec la première lettre en majuscule. Quand je travaille sur le terminal, c'est ennuyeux de changer de position, appuyez sur la première touche lorsque vous êtes dans un répertoire. Saisissez simplement les informations suivantes dans votre terminal et bash corrigera automatiquement le cas pour vous.

shopt -s nocaseglob
1
tsudot

Utilisation pgrep foo au lieu de ps aux | grep foo si vous voulez savoir combien d'instances de foo sont en cours d'exécution et leurs pids:

par exemple. au lieu de ps aux | grep firefox, utilisation pgrep firefox

1
user1888

Je ne peux pas vivre sans

set editing-mode vi
set blink-matching-paren on

dans mon ~/.inputrc.

Les active dans chaque application compatible avec la lecture en ligne. Seule l'activation de l'édition de ligne de commande vi dans le shell fonctionne via:

set -o vi

Ainsi, en appuyant sur ESC ou CTRL + [ vous obtenez le mode vi-commande bien connu. Et vous pouvez utiliser des commandes vi puissantes partout!

1
maxschlepzig

Il existe un excellent site pour cela à: http://www.commandlinefu.com/commands/browse

1
Andrew Stern

Mon préféré est

find . -name <i>filename</i> | xargs grep -in '<i>pattern to search for</i>'

Ce que fait la commande ci-dessus, c'est de trouver un fichier de nom x, puis de rechercher dans ce fichier le modèle que vous recherchez. Incroyablement utile si vous recherchez un morceau de code particulier dans un fichier quelque part dans vos sous-répertoires.

0
Mark D
find path expr -exec ls -ld {} \;

Belle façon facile de voir la propriété, les autorisations, les tailles (si les fichiers) et d'autres caractéristiques de tout ce que votre expression de recherche renvoie.

0
TCKMusing

Je remarque souvent, juste après avoir démarré une commande de 15 minutes, que j'aurais voulu ajouter d'autres éléments à la ligne de commande en utilisant &&. Au lieu d'interrompre le travail déjà en cours d'exécution, j'ai tendance à utiliser at pour mettre le deuxième en file d'attente, me donnant ainsi plus de temps, je n'ai pas besoin de regarder le terminal.

Généralement, at met en file d'attente les tâches à exécuter à un moment donné:

$ at 14:30
> myscript
> anotherscript
> <CTRL-D>

Les entrées de la file d'attente peuvent être affichées avec atq et supprimées avec atrm.

Un autre ajout aux conseils de personnalisation de l'invite bash: j'aime inverser l'invite, car cela donne de bons indices visuels où la sortie de la commande commence et se termine dans de longues listes de terminaux. Cela fonctionne bien pour les arrière-plans lumineux et sombres.

export PS1="\[\e[7m\][\[email protected]\h \w]\[\e[0m\]$ "
0
jstarek

synchronisation; synchronisation; synchronisation; redémarrage

peut être très utile parfois. Faites attention !

0
Tony Lambert

Je trouve que la compréhension des frappes de touches bash conduit à un décorticage plus efficace, et que beaucoup d'entre elles sont directement issues d'emacs clarifie leur utilisation (c'est-à-dire que meta-XXX est la version grand frère de ctrl-XXX commande habituellement).

La touche "méta" est généralement la touche "alt", mais peut également être la touche "esc". par exemple. meta-f peut être obtenu avec alt-f ou esc f.

Pour que les mappages de touches alt fonctionnent, vous devrez peut-être désactiver les "touches d'accès au menu" ou son équivalent dans les options de la console. Fondamentalement, si vous appuyez sur alt-f et que le menu Fichier s'affiche, désactivez les menus d'accès Alt-Key.

ctrl-a / ctrl-e : move to start / end of line notions de base dont vous ne pouvez vous passer

ctrl-f, meta-f : forward char/Word appuyer sur alt-f vous fait avancer "1 mot" qui sur la ligne de commande est à peu près une commande ou un argument

ctrl-b, meta-b : backwards char/Word identique à alt-f, mais en arrière pour revenir en arrière à travers la ligne de commande

ctrl-d, meta-d : delete char/Word appuyer sur alt-d supprimera (jusqu'à la fin de) le mot en cours sous le curseur. beaucoup plus rapide puis en maintenant la touche Suppr enfoncée pendant 30 secondes. Utile lorsque vous complétez un onglet au milieu de quelque chose et que vous souhaitez transférer la suppression à la fin de Word.

ctrl-k : kill line supprime jusqu'à la fin de la ligne

ctrl-u : undo par exemple. en tapant un mot de passe, et vous savez que vous vous êtes trompé quelque part, au lieu de revenir 20 fois en arrière, appuyez simplement sur ctrl-u. efface également la ligne de commande actuelle.

meta-# : insert comment c'est idéal pour conserver votre ligne de commande que vous créez en tant que commentaire avant de l'exécuter si vous devez d'abord faire autre chose. il entrera dans l'historique de vos commandes mais ne s'exécutera pas.

ctrl-r : reverse search recherche en arrière dans l'historique de votre Shell (répétition des touches ctrl-r pour le match suivant)

ctrl-g : abort si vous êtes au milieu de ctrl-r et souhaitez simplement revenir à l'endroit où vous avez tapé, abandonnez simplement votre recherche avec ctrl-g

meta-space / ctrl-x ctrl-x : set mark and jump to mark si vous devez passer rapidement à une position dans votre ligne de commande, définissez d'abord la marque, puis revenez-y avec ctrl-x ctrl-x. Notez que vous devrez peut-être utiliser esc-space pour obtenir la marque définie comme alt-space est souvent lié à la réduction du menu de la console.

ctrl-] <char> : quick jump to <char> saute vers le caractère saisi après le ctrl-] sur la ligne de commande. Le grand frère Meta-ctrl-] <char> saute en arrière.

0
markf

Mes favoris sont ci-dessous. J'utilise la plupart d'entre eux régulièrement

df -k (vérifier les systèmes de fichiers) kill ou kill -9 (kill a process) set -o vi (définissez votre ligne de commande sur vi) topas (outil de performance) monter/démonter

oh ouais et comment pourrais-je oublier le> (pour rediriger la sortie vers un fichier) ls> /tmp/tmp.txt

Beaucoup plus, mais certains du haut de ma tête.

0
vegasbrianc