it-swarm-es.tech

¿Cuáles son tus características o trucos favoritos de la línea de comandos?

Comparta sus características y trucos de la línea de comandos para Unix/Linux. Intente mantenerlo agnóstico de Shell/distro si es posible. Interesado en ver alias, líneas simples, atajos de teclado, pequeños scripts de Shell, etc.

93
cmcginty

Esto se expande un poco en el !! truco mencionado en esta respuesta . En realidad, hay un montón de comandos relacionados con la historia que tienden a olvidarse (las personas tienden a apuñalar Up 100 veces buscando un comando que saben que escribieron).

  • El comando history mostrará una lista de comandos ejecutados recientemente con un designador de eventos a la izquierda
  • !N sustituirá el comando asociado con el designador de eventos N
  • !-N sustituirá a N th comando más reciente; p.ej. !-1 sustituirá el comando más reciente, !-2 el segundo más reciente, etc.
  • Como se menciona en la otra respuesta, !! es la abreviatura de !-1, para sustituir rápidamente el último comando
  • !string sustituirá el comando más reciente que comienza con string
  • !?string? sustituirá el comando más reciente que contiene string

Los designadores de palabras se pueden agregar a un ! comando de historial para modificar los resultados. Los dos puntos separan el evento y los designadores de Word, p. !!:0. El designador del evento !! se puede abreviar a solo ! cuando se usa un designador de Word, entonces !!:0 es equivalente a !:0.

  • !:0 obtendrá el comando que se ejecutó
  • !:1 obtendrá el primer argumento (y !:2 el segundo, etc.)
  • !:2-3 obtendrá el segundo y tercer argumento
  • !:^ es otra forma de obtener el primer argumento. !:$ obtendrá el último
  • !:* obtendrá todos los argumentos (pero no el comando)

Los modificadores también se pueden agregar a un ! comando de historial, cada uno precedido por dos puntos. Se puede apilar cualquier número (por ejemplo, !:t:r:p).

  • h - En línea con el nombre del archivo base
  • t - Solo el nombre de archivo base
  • r - En línea con la extensión del nombre del archivo
  • e - Solo la extensión del nombre del archivo
  • s/search/replacement - Reemplace la primera aparición de search con replacement
  • gs/search/replacement - Reemplace todas las apariciones de search con replacement
88
Michael Mrozek

bash - inserta el parámetro final de la línea anterior

alt-. la combinación de teclas más útil que haya existido, pruébela y vea, por alguna razón, nadie sabe sobre esta.

presiónelo una y otra vez para seleccionar los últimos parámetros anteriores.

genial cuando quieres hacer algo más al argumento/archivo que usaste hace un momento.

64
chillitom

Mi favorito es

man 7 ascii

Simple y muy útil.

   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

Echa un vistazo a este sitio web commandlinefu.com .

También puedes echar un vistazo a estos cuatro artículos de Peteris Krumins en su blog.

49
Moeb

Ejecute el último comando como root:

Sudo !!
46
Alex B

No estoy seguro si esto cuenta como un "truco", pero la gente parece desconocer las teclas de acceso rápido estándar de readline. De uso particular en conchas:

  • Ctrl+U - Cortar la línea actual
  • Ctrl+Y - Pegue una línea cortada con Ctrl+U
  • Ctrl+L - Borrar la pantalla y volver a dibujar la línea actual
  • Ctrl+G - Obtenga una nueva línea y abandone la actual
42
Michael Mrozek

CTRL+R en BASH para buscar/activar comandos ejecutados previamente (el contenido de ~/.bash_history).

Esto a menudo es extremadamente útil. Ejecutar este alias servirá el PWD a través de HTTP (indexado) en el puerto 8000:

alias webserver="python -m SimpleHTTPServer"

Y debido a que corro make todo el tiempo, y spaz y tecleo demasiado rápido, estos alias son probablemente los más utilizados (en serio):

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

Y probablemente mi pieza más utilizada de BASH es un script simple que llamo upload. Lo uso para enviar cualquier tipo de contenido a mi Linode, y copia la URL HTTP resultante en mi portapapeles (clic central). Muy útil para pegar cosas a personas en IRC:

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

Solo un par. Puedo publicar mucho más tarde, ¡debo volver al trabajo!

36
Aaron Bockover

diff la salida de dos comandos sin crear un archivo temporal manualmente (bash):

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

Bastante básico, pero la gente no parece saberlo, te devuelve al directorio anterior:

cd -
30
Robert Swisher

Expansión de llaves :

La expansión de llaves es un mecanismo por el cual se pueden generar cadenas arbitrarias.

Le permite reemplazar líneas tediosas como:

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

con una instancia más corta

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

¡algunos otros usos

# 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 

Expansión aritmética :

La expansión aritmética permite la evaluación de una expresión aritmética y la sustitución del resultado. El formato para la expansión aritmética es:

$((expression))

La expresión se trata como si estuviera entre comillas dobles, pero una comilla doble entre paréntesis no se trata especialmente. Todos los tokens en la expresión experimentan expansión de parámetros, expansión de cadena, sustitución de comandos y eliminación de comillas. Las expansiones aritméticas pueden estar anidadas.

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

Esto suele estar en mi script de inicio (.bashrc, .profile, lo que sea)

shopt bondad, revisa los comentarios:

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 que guarda las pulsaciones de teclas: mkdir y cd en él:

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

Y por último, pero no menos importante, he renunciado a memorizar la sintaxis del alquitrán, así que:

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

Dos funciones bash que me ahorran muchas pulsaciones de teclas.

Haga automáticamente un ls después de cada cd exitoso:

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

Sube n niveles:

# 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

Como generalmente estoy a mitad de camino en una línea de comando antes de querer buscar (CTRL-R en bash) tengo lo siguiente en mi .bashrc

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

Esto significa que si escribo cd y luego presiono arriba/abajo, puedo ver todas las opciones a las que he hecho cd. Básicamente, uso esto para directorios de uso frecuente. Como "cd w" y termino revisando todos los espacios de trabajo que uso mucho.

17
mendicant

Una cosa que me ahorra mucho tiempo son los comandos pushd/popd. Estos chicos te permiten crear una pila de directorios y reducir mucho la escritura:

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

El screencomando . Básicamente guarda su sesión de línea de comando para cuando regrese. Es una especie de administrador de terminales, como un administrador de ventanas. De esa manera, en una sola sesión de terminal, puede tener múltiples terminales virtuales en funcionamiento. Es muy genial.

Si uno usa screen, esta función Shell (póngala en .bashrc) es extremadamente útil:

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

al escribir scr, verificará si su sesión principal existe y se adjuntará a ella. De lo contrario, lo creará.

14
user394

Si necesita editar una línea de comando particularmente larga en bash

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

lo abrirá en el editor ($ EDITOR).

En zsh puede obtener el mismo comportamiento agregando esto a .zshrc:

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

Si usted es un mecanógrafo rápido, estos son útiles:

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

Esta macro le ayuda a calcular los totales de una columna de salida: tamaños de archivo, bytes, paquetes, todo lo que tiene que hacer es especificar la columna que desea agregar:

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

Lo usa así, por ejemplo, sin argumentos, agrega el total de la primera columna:

du | total

Si proporciona el argumento, sumará esa columna, por ejemplo, esto le da el número total de bytes utilizados por todos los archivos C # en/tmp:

ls -l /tmp/*cs | total 5

A veces, su consola se estropea porque accidentalmente vio un archivo binario (cat/bin/ls, por ejemplo), puede restaurar el terminal con esta función de Shell:

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

Me gusta que mi ls use caracteres para distinguir la clase de archivos y también para ocultar los archivos de respaldo generados por mi editor (los archivos de respaldo terminan con el carácter ~):

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.

Uno de mis favoritos cuando olvido s:

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

Si un comando toma una entrada estándar, puede leer la entrada de un archivo con <filename. Esto puede aparecer en cualquier parte del comando, por lo que estas líneas son equivalentes:

cat filename
cat <filename
<filename cat

Esto es particularmente útil para grep, ya que le permite colocar la expresión al final de la línea, para que pueda modificar rápidamente un comando grep presionando Up, sin necesidad de desplazarse hacia la izquierda para pasar el nombre del archivo:

<filename grep 'expression'
10
Michael Mrozek

Puede usar CDPATH para configurar el directorio equivalente a PATH; si intentas cd foo y no hay foo en el directorio actual, el Shell verificará cada uno de los directorios en CDPATH buscando foo en ellos, y cambiará al primero encuentra:

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`

Para cuando no sabes dónde vive algo y tampoco te importa.

9
Matt Simmons

El ampersand. Pone su comando en segundo plano, para que pueda seguir escribiendo.

$> Sudo updatedb &

Trabajando juntos, y después de un tiempo ves:

[1] 17403

¡Y tu proceso está hecho! Ideal para cosas en las que no necesita esperar a que terminen.

9
user394

Completar pestaña. ¿Qué tan mal sería tener que escribir todos los caracteres de cada ruta?

8
user394

Tengo esto en mi .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]"
}

Y cuando tengo el código fuente HTML en el portapapeles y quiero encontrar todos los enlaces que uso

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

Y tengo todas las URL en el portapapeles

También tengo esta función

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

qué tamaño de pantalla (legible por humanos) y nombre de archivo.

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

este alias es para mostrar la temperatura

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

con esta función puedo calcular el producto o la suma de argumentos.

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()))";
}

Esta es una función útil que divide la entrada estándar separada por expresiones regulares y luego une el resultado.

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

función factorial

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

Esta función muestra el texto wiki sobre DNS

También tengo tres funciones de color.

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]
}

Esta función valida el archivo md5 hash.

esto mostrará un mensaje de error para un código dado

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

Puede imprimir todos los mensajes con

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

Desmontar el último dispositivo montado:

mount /media/whatever
...
u!mo

!mo se expande al último comando que comenzó con mo (al menos en bash). A veces uno hace mv en el medio, entonces u!m no funcionará tan a menudo.

7
Roberto Bonvallet

Otro truco útil de ZSH:

Trate la salida de un comando como un archivo:

emacs =(hg cat -r 100 somefile)

Esto abre una versión anterior de un archivo con seguimiento de Mercurial en emacs para una visualización resaltada de sintaxis. Sin eso, tendría que perder el tiempo con hg revert, hg archive, o enviar explícitamente hg cat salida a un archivo temporal.

Por supuesto, esto funciona con cualquier programa que abra archivos y cualquier programa que imprima a la salida estándar.

6
Matthew Flaschen

Una característica específica de ZSH son los alias de sufijo, que se establecen dando alias the -s bandera:

alias -s ext=program

Si una extensión dada tiene un alias de sufijo, puede ejecutar un archivo con esa extensión directamente, y ZSH iniciará el programa dado y pasará el nombre del archivo como argumento. Entonces, si el alias anterior está vigente, estas líneas son equivalentes:

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

Una de mis características favoritas de todos los tiempos de ZSH son los directorios con nombre. Puede exportar una variable con un nombre dado, con un valor que apunta a una ruta determinada:

export foo=/usr/bin

Ahora puedes usar ~foo en un comando para referirse a /usr/bin:

cd ~foo
~foo/ls
cat ~foo/filename
5
Michael Mrozek
  • El comando no hacer nada : como en

    while :; do :; done
    
  • Expansión de abrazaderas en combinación con bucles for:

    for c in {1..3}; do :; done
    
  • ! operador y operadores de cortocircuito || y &&

    [ -d /tmp/dir ] || mkdir /tmp/dir
    
    if ! ping 34.41.34.1; then :; fi
    
  • usando sub shells en lugar de pop/Push (es útil en scripts)

    ~$ ( cd /tmp; echo $PWD )
    /tmp
    ~$
    
  • the kind-of what-is command 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 () 
    { 
         :
    
    }
    
  • también muy agradable: cuerdas aquí

    ~$ cat <<<"here $PWD"
    here /home/yourname
    ~$
    
  • y mi favorito: redirección en una lista de comandos

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

Vea esto pregunta.

Cuando corres ps ax | grep string:

[[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 última línea que contiene grep es algo un poco molesto

Puedes deshacerte de esto ejecutando 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

actualizar : o simplemente ejecutar pgrep string

4
Stefan

A veces, la configuración de bash es tal que rm tiene un alias de rm -i y, por lo tanto, requiere confirmación para cada archivo que se elimina. Cuando trabajo ocasionalmente en dicha cuenta, uso \rm para recuperar el comportamiento original de rm sin cambiar la configuración del usuario.

3
mouviciel

Me encanta meter tantas cosas como puedo en mi PS1. Algunas cosas útiles para recordar:

\e[s y \e[u guardar y dejar de guardar la posición del cursor respectivamente. Lo uso para crear una 'barra de información' en la parte superior de la pantalla, un par de líneas de largo, que puede caber más cosas. Ejemplo:

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\]\$ '

Combinar con alias clear='echo -e "\e[2J\n"'. ¡Pruébalo!

También el Prompt_COMMAND variable define un comando para ejecutar antes de la PS1 cada vez.

Otro es el comando bg. Si olvidas poner & al final de un comando, solo presione ^Z y escriba bg, y se ejecuta en segundo plano.

3
Lucas Jones

Mostrar la rama y el estado de Git en el indicador

 exportar GIT_PS1_SHOWDIRTYSTATE = verdadero 
 
 if ["$ color_Prompt" = yes]; luego 
 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

Mi comando favorito es 'buscar', lo uso en todas partes ... ejemplos:

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

Simplemente muestre los archivos más pesados ​​en formato ls -l (largo).

Luego, si necesita su código con permisos 0640, simplemente busque:

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

o reemplazar:

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

Entonces, ¿necesitas un símbolo y no sabes dónde está?

(
  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
)

¿Archivos más nuevos que XFILE?

find . -newer XFILE -type f

Sí, "encontrar" rulez!

3
D4RIO

Una vez tan a menudo, cuando ha escrito un comando largo y antes de terminarlo, se ha dado cuenta de que no funcionará de inmediato, porque necesita ejecutar otra cosa antes (por ejemplo, ingresó git commit -m "long commit message here"), puedes presionar ^A^K para ir al inicio de la línea y matarla (guardar en un búfer), luego ejecutar un comando para arreglar las cosas y finalmente ^Y para pegar el comando eliminado y continuar. Ahorra mucho reescribiendo. Todo esto, por supuesto, es cuando readline está en modo Emacs.

Otro ahorro de tiempo: mkdir -p some/nested/dirs/to/be/created crea todos los directorios en una ruta si faltan.

3
alex

Muestra un buen arte ascii del árbol de proceso actual, con el proceso más intensivo de CPU resaltado.

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

¡Mátalo con Ctrl + C

3
Stefan

Vea la salida del comando actualizada cada n segundos

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

Mostrar estadísticas sobre el dispositivo de red wlan0

ip -s link ls wlan0

Mostrar tabla de enrutamiento para el dispositivo eth1

ip route ls dev eth1

Mostrar estadísticas de todos los enrutadores que viajan los paquetes para llegar al Host

mtr --interval 5 HOSTNAME

Consultar registros DNS inversos para nombres de host en RED

nmap -sL NETWORK

Benchmark de un sitio web

ab

Obtenga todos los enlaces de una página web

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

Mostrar puerta de enlace predeterminada

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

Escribir error estándar en un archivo

foo 2> errors.txt

Redirigir stderr a stdout

foo 2>&1

Redireccionar stderr y stdout al mismo archivo.

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

Reemplazar partes del comando anterior:

^buscar^reemplazar

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

Ideal para errores tipográficos:

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

Resume el tamaño del directorio, con tamaño humano descendente

du -hs */ | sort -hr

p.ej.

10.2G   foo/
4M      bar/
2
Eric Fortis

expansión de doble estrella con zsh (que recursivamente desciende el árbol de directorios, no solo un nivel, algo similar a $(find ! -type d):

grep string **/*.cc
2
Andre Holzner

¡Mi característica favorita es SIN COLORES! =)

TERM = xterm-mono o TERM = linux-m depende del sistema operativo ...

Me gusta mucho IRSSI en blanco y negro, mc y cualquier otra herramienta de "interfaz de usuario de texto"

2
holms

ZSH tiene alias globales. Expande el alias en cualquier lugar de la línea de comando. He encontrado esto útil para los nombres de host:

P.ej.:

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

Entonces, puedo hacer, por ejemplo:

sftp sub
ssh sub

etc.

2
Matthew Flaschen

Realmente no es una frase, pero creo que es útil. Convierta muchos archivos a mayúsculas, por ejemplo file_to_upper *php *c. Hay muchos casos similares, como convertir a menor, cambiar el nombre de todos los archivos por sufijo/prefijo, 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

obtener el nombre del archivo con la marca de tiempo más reciente en el directorio actual:

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

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

dc es una calculadora RPN; Esta función me permite escribir la expresión como argumentos de comando:

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

Mostrar un mensaje donde el nombre de host es negrita. Probé las indicaciones de color por un tiempo, pero el color a veces se veía mal dependiendo del fondo. Bold funciona para mí para fondo claro, fondo oscuro, fondos azules, etc.

Esto está en mi .bashrc:

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

Encontré lo siguiente útil al cambiar constantemente entre Windows y Unix/Linux:

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

Esto es para zsh, no bash, fyi (si no lo ha usado, no se arrepentirá de haberlo probado). Esto es realmente útil para escribir rápidamente rutas largas para transferencias scp. Funciona igual que usar para completar o enumerar los nombres de archivo/directorios disponibles.

Ejemplo

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

completará el camino a /home/webdev/domains/example.com/http.public/longdirname.

Soy malo con los ejemplos, pero eso debería darte la idea. Pruébelo, realmente puede evitar que sus dedos escriban.

# 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 , que le permite mover un programa en ejecución de un terminal a otro. De esa manera, si tiene un programa ncurses que se ejecuta fuera de la pantalla, tmux o ssh, puede adjuntarlo a una sesión ssh o una pantalla en red o sesión tmux ejecutando ReTTY dentro del terminal donde desea utilizar el programa en cuestión. En otras palabras, es similar a screen y tmux pero con las excepciones de que (a) solo puede ejecutar un programa a la vez, y (b) puede ejecutarse después de comienzas el proceso hijo.

1
mmirate

Mi favorito es usar el comando python) para crear el servidor http temporal:

python -m SimpleHTTPServer

y acceder a los archivos de esta máquina a través de la LAN como:

http://192.168.1.70:80

Otra es descargar el archivo tar en forma extraída como:

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

Aquí el enlace puede ser cualquiera sobre www y bz2 puede ser gz, tgz o bz2 en sí mismo.

1
SHW

Haga una copia de seguridad de sus elegantes archivos dot automáticamente

.Bashrc modular -> .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 más seguro, compatible con Linux y 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
}

Acción super caliente 'cd'

# 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 es tu único dios verdadero.

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

Fuentes de terminal

Después de mirar miles de millones de fuentes, uso 14 pt Monaco, Anti-aliased con iTerm2.

En Mac (Aplicaciones): pruebe esta aplicación que ofrece enlaces de teclas.

KeyCue (tm) (r) (c) ($) proporciona el contexto de casi CUALQUIER aplicación en ejecución simplemente manteniendo command.

1
dhchdhd

función de inserción automática de zsh:

setopt autopushd

y junto con eso:

alias dirs='dirs -v'

Para que en cualquier momento, pueda escribir dirs y obtenga el historial de dónde he estado:

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

y luego puedo cd nuevamente en /usr/local/bin escribiendo:

cd ~2
1
Andre Holzner

Ninguno de los siguientes 'trucos' es técnicamente desafiante o impresionante, pero tienen algún impacto en la otra persona. Si no podemos usar nuestros trabajos para hacer nuestras vidas más felices, entonces deberíamos pensar nuevamente en algunas cosas.

Me gusta alias. Mi truco favorito es editar los ~/.bash_aliases en la computadora de mi novia ya que ella falta y agregar una línea como:

alias gfname='echo Myname is thinking of you'

u otra cita romántica.

Otro "truco" que me gusta especialmente es:

#!/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`

donde 123 es la persona a la que me gustaría desear feliz cumpleaños y mails.txt contiene el mensaje que me gustaría escribir como el cuerpo del correo electrónico. Dormir 1; a veces es necesario ya que hay un límite en fork (). También puede usar argumentos de línea de comando $1 etc ...

1
Dimitris Leventeas

Tengo carpetas nombradas en mi carpeta de inicio como Documento, Descargas, Temp, etc. con la primera letra en mayúscula. Cuando trabajo en el terminal, es molesto cambiar de puesto, presione la primera tecla cuando esté ingresando en un directorio. Simplemente ingrese lo siguiente en su terminal y bash corregirá automáticamente el caso por usted.

shopt -s nocaseglob
1
tsudot

Utilizar pgrep foo en lugar de ps aux | grep foo si quieres saber cuántas instancias de foo se están ejecutando y sus pids:

p.ej. en lugar de ps aux | grep firefox, utilizar pgrep firefox

1
user1888

No puedo vivir sin

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

en mi ~/.inputrc.

Los activa en todas las aplicaciones habilitadas para readline. Solo la activación de la edición de línea de comando vi en Shell funciona mediante:

set -o vi

Por lo tanto, presionar ESC o CTRL + [te da el conocido modo vi-command. ¡Y puedes usar poderosos comandos vi en todas partes!

1
maxschlepzig

Hay un gran sitio para esto en: http://www.commandlinefu.com/commands/browse

1
Andrew Stern

Mi favorito personal es

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

Lo que hace el comando anterior es encontrar un archivo de nombre x y luego busca en dicho archivo cualquier patrón que esté buscando. Increíblemente útil si está buscando un fragmento de código en particular en un archivo que está en algún lugar de sus subdirectorios.

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

Una manera fácil y agradable de ver la propiedad, los permisos, los tamaños (si son archivos) y otras características de lo que devuelva la expresión 'find'.

0
TCKMusing

A menudo me doy cuenta, justo después de comenzar un comando de 15 minutos, que hubiera querido agregar algunas otras cosas a la línea de comando usando &&. En lugar de interrumpir el trabajo que ya se está ejecutando, tiendo a usar at para poner en cola el segundo, dándome un tiempo más largo no necesito mirar el terminal.

Generalmente, at pone en cola los trabajos para su ejecución en un momento dado:

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

Las entradas a la cola se pueden ver con atq y eliminar con atrm.

Otra adición a los consejos de personalización de Bash Prompt: me gusta invertir el indicador, ya que esto proporciona buenas señales visuales donde el resultado del comando comienza y termina en largas listas de terminales. Esto funciona bien para fondos brillantes y oscuros.

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

sincronización; sincronización; sincronización; reiniciar

puede ser realmente útil a veces. Ten cuidado !

0
Tony Lambert

Me parece que la comprensión de las pulsaciones de teclas bash conduce a un bombardeo más eficiente, y que muchos de ellos son directamente de emacs aclara su uso (es decir, que meta-XXX Es la versión hermano mayor del comando ctrl-XXX Por lo general).

La tecla "meta" suele ser la tecla "alt", pero también puede ser la tecla "esc". p.ej. meta-f Se puede obtener con alt-f O esc f.

Para que las asignaciones de teclas alternativas funcionen, es posible que tenga que desactivar las "teclas de acceso al menú" o su equivalente en las opciones de la consola. Básicamente, si presiona alt-f y obtiene el mensaje del menú de archivo, apague los menús de acceso de tecla alt.

ctrl-a / ctrl-e : move to start / end of line Conceptos básicos que no puedes prescindir

ctrl-f, meta-f : forward char/Word Al presionar alt-f salta hacia adelante "1 palabra", que en la línea de comando es más o menos un comando o argumento

ctrl-b, meta-b : backwards char/Word Igual que alt-f, pero hacia atrás para saltar hacia atrás a través de la línea de comando

ctrl-d, meta-d : delete char/Word Presionando alt-d eliminará (hasta el final de) la palabra actual debajo del cursor. mucho más rápido que mantener presionado eliminar durante 30 segundos. Es útil cuando la pestaña se completa en medio de algo y desea reenviar la eliminación al final de Word.

ctrl-k : kill line Se elimina al final de la línea

ctrl-u : undo P. escribiendo una contraseña, y sabe que se equivocó en alguna parte, en lugar de presionar la tecla de retroceso 20 veces, simplemente presione ctrl-u. También borra la línea de comando actual.

meta-# : insert comment Esto es excelente para mantener la línea de comandos que está creando como comentario antes de ejecutarla si necesita hacer algo más primero. entrará en su historial de comandos pero no se ejecutará.

ctrl-r : reverse search Buscando hacia atrás a través de su historial de Shell (ctrl-r repetido para la próxima coincidencia)

ctrl-g : abort Si está en medio de ctrl-r Y desea volver al lugar donde estaba escribiendo, ¡simplemente cancele su búsqueda con ctrl-g

meta-space / ctrl-x ctrl-x : set mark and jump to mark Si necesita saltar rápidamente a una posición en su línea de comando, primero establezca la marca, luego vuelva a saltar con ctrl-x ctrl-x. Tenga en cuenta que puede que tenga que usar esc-space Para obtener la marca establecida como alt-space A menudo está obligado a bajar el menú de la consola.

ctrl-] <char> : quick jump to <char> Salta hacia adelante al carácter escrito después de ctrl-] En la línea de comando. El hermano mayor Meta-ctrl-] <char> Salta hacia atrás.

0
markf

Mis favoritos están abajo. Yo uso la mayoría de ellos regularmente

df -k (verificar sistemas de archivos) kill o kill -9 (kill a process) set -o vi (configure su línea de comando en vi) topas (herramienta de rendimiento) montar/desmontar

oh sí, y cómo podría olvidar el> (para redirigir la salida a un archivo) ls> /tmp/tmp.txt

Muchos más pero algunos fuera de mi cabeza.

0
vegasbrianc