Qual è il tuo trucco della riga di comando più preferito usando Bash? [chiuso]

Sappiamo tutti come utilizzare <ctrl>-Rper invertire la ricerca nella cronologia, ma sapevi che puoi utilizzare <ctrl>-Sper inoltrare la ricerca se hai impostato stty stop ""? Inoltre, hai mai provato a eseguire bind -p per vedere tutte le scorciatoie da tastiera elencate? Ci sono oltre 455 su Mac OS X per impostazione predefinita.

Qual è il tuo singolo trucco oscuro preferito, scorciatoia da tastiera o configurazione shopt usando bash?

Rinominare / spostare rapidamente i file con i suffissi:
cp /home/foo/realllylongname.cpp{,-old}

Questo si espande a:
cp /home/foo/realllylongname.cpp /home/foo/realllylongname.cpp-old

cd -

È l'equivalente della riga di comando del pulsante Indietro (ti porta alla directory precedente in cui ti trovavi).

Un altro preferito:

!!

Ripete l'ultimo comando. Più utile nella forma:

sudo !!

Il mio preferito è '^ string ^ string2' che accetta l'ultimo comando, sostituisce string con string2 e lo esegue

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

Guida alla cronologia della riga di comando di Bash

rinominare

Esempio:

$ 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

Così utile

Sono un fan di !$, !^ed !*espandi, di ritorno, dalla riga di comando inviata più recente: l'ultimo elemento, il primo elemento non di comando e tutti gli elementi non di comando. Per dire (nota che la shell stampa prima il comando):

$ 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

Questo è utile quando si, diciamo ls filea fileb, e si desidera modificare uno di loro: vi !$o di entrambi: vimdiff !*. Può anche essere generalizzato a "l' nargomento th" in questo modo:

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

Infine, con i nomi dei percorsi, è possibile accedere a parti del percorso aggiungendo :he :ta uno degli espansi sopra indicati:

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

Quando eseguo i comandi, a volte vorrei eseguire un comando con gli argomenti precedenti. Per fare ciò, puoi usare questo collegamento:

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

Occasionalmente, al posto dell'utilizzo di find, interrompo un ciclo di una riga se devo eseguire un gruppo di comandi su un elenco di file.

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

Configurare le opzioni della cronologia della riga di comando nel mio .bash_login (o .bashrc) è davvero utile. Di seguito è riportato un gruppo di impostazioni che utilizzo sul mio Macbook Pro.

L'impostazione di quanto segue fa bash cancellare comandi duplicati nella tua cronologia:

export HISTCONTROL="erasedups:ignoreboth"

Ho anche aumentato la mia dimensione della storia piuttosto in alto. Perchè no? Non sembra rallentare nulla sui microprocessori di oggi.

export HISTFILESIZE=500000
export HISTSIZE=100000

Un'altra cosa che faccio è ignorare alcuni comandi della mia storia. Non è necessario ricordare il comando di uscita.

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

Sicuramente vuoi impostare histappend. Altrimenti, bash sovrascrive la tua cronologia quando esci.

shopt -s histappend

Un'altra opzione che utilizzo è cmdhist. Ciò consente di salvare i comandi multilinea nella cronologia come un solo comando.

shopt -s cmdhist

Infine, su Mac OS X (se non si utilizza la modalità vi), è necessario ripristinare <CTRL> -S dall'arresto dello scorrimento. Questo impedisce a bash di essere in grado di interpretarlo come ricerca in avanti.

stty stop ""

Come elencare solo le sottodirectory di quella attuale?

ls -d */

È un trucco semplice, ma non sapresti quanto tempo ho bisogno per trovarlo!

ESC.

Inserisce gli ultimi argomenti dall'ultimo comando bash. È utile più di quanto pensi.

cp file /to/some/long/path

CD ESC.

Certo, puoi " diff file1.txt file2.txt", ma Bash supporta la sostituzione di processo , che ti permette di diffemettere comandi.

Ad esempio, diciamo che voglio assicurarmi che il mio script mi ​​dia l'output che mi aspetto. Posso semplicemente avvolgere il mio script in <() e dargli da mangiare diffper ottenere un test di unità veloce e sporco:

$ 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
$

Come altro esempio, diciamo che voglio verificare se due server hanno lo stesso elenco di RPM installati. Invece di scrivere su ciascun server, scrivere ogni elenco di RPM in file separati e fare uno diffsu quei file, posso semplicemente farlo diffdalla mia workstation:

$ 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
$

Ci sono altri esempi nella Guida avanzata di script Bash su http://tldp.org/LDP/abs/html/process-sub.html .

Il mio comando preferito è "ls -thor"

Richiama il potere degli dei per elencare i file modificati più di recente in un formato facilmente leggibile.

Più di una novità, ma è intelligente ...

Primi 10 comandi utilizzati:

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

Uscita campione:

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

^ R ricerca inversa. Premi ^ R, digita un frammento di un comando precedente che desideri abbinare e premi ^ R fino a trovare quello che desideri. Quindi non devo ricordare i comandi usati di recente che sono ancora nella mia storia. Non esclusivamente bash, ma anche: ^ E per la fine della riga, ^ A per l'inizio della riga, ^ U e ^ K da eliminare rispettivamente prima e dopo il cursore.

Ho spesso alias per vi, ls, ecc. Ma a volte vuoi sfuggire all'alias. Basta aggiungere una barra rovesciata al comando di fronte:

Per esempio:

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

Fantastico, vero?

Ecco un paio di modifiche alla configurazione:

~/.inputrc:

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

Funziona allo stesso modo ^Rma usando invece i tasti freccia. Questo significa che posso digitare (ad es.) cd /media/Quindi premere la freccia su per andare all'ultima cosa cdall'interno della /media/cartella.

(Uso Gnome Terminal, potrebbe essere necessario modificare i codici di escape per altri emulatori di terminali.)

Anche il completamento di Bash è incredibilmente utile, ma è un'aggiunta molto più sottile. In ~/.bashrc:

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

Ciò consentirà il completamento della scheda per programma (ad es. Il tentativo di completamento della scheda all'avvio della riga di comando evincemostrerà solo i file che possono essere aperti e anche le opzioni della riga di comando che completano la scheda).

Funziona bene con questo anche in ~/.inputrc:

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

Uso molto quanto segue:

Il :pmodificatore per stampare un risultato della cronologia. Per esempio

!!:p

Stampa l'ultimo comando in modo da poter verificare che sia corretto prima di eseguirlo di nuovo. Basta inserire !!per eseguirlo.

Allo stesso modo:

!?foo?:p

Ricerca nella cronologia il comando più recente che conteneva la stringa "pippo" e la stampa.

Se non è necessario stampare,

!?foo

esegue la ricerca e la esegue immediatamente.

Ho un'arma segreta: shell-fu.

Ci sono migliaia di suggerimenti intelligenti, trucchi interessanti e ricette efficaci che il più delle volte si inseriscono in una sola riga.

Uno che adoro (ma imbroglio un po 'dal momento che uso il fatto che Python sia installato sulla maggior parte dei sistemi Unix ora):

alias webshare='python -m SimpleHTTPServer'

Ora ogni volta che si digita "webshare", la directory corrente sarà disponibile attraverso la porta 8000. Davvero bello quando si desidera condividere file con gli amici su una rete locale senza chiave USB o dir remoto. Anche lo streaming di video e musica funzionerà.

E ovviamente la classica bomba a forcella completamente inutile ma comunque molto divertente:

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

Non provarlo in un server di produzione ...

È possibile utilizzare il comando watch insieme a un altro comando per cercare le modifiche. Un esempio di ciò è stato quando stavo testando il mio router e volevo ottenere numeri aggiornati su cose come il rapporto segnale-rumore, ecc.

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

type -a PROG

al fine di trovare tutti i posti in cui PROG è disponibile, di solito da qualche parte in ~ / bin piuttosto che quello in / usr / bin / PROG che ci si poteva aspettare.

Mi piace costruire comandi con eco e inoltrarli alla shell:

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

Perché? Perché mi permette di vedere cosa sarà fatto prima di farlo. In questo modo se ho un errore orribile (come rimuovere la mia directory home), posso prenderlo prima che accada. Ovviamente, questo è molto importante per azioni distruttive o irrevocabili.

Quando scarico un file di grandi dimensioni, lo faccio spesso:

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

E poi basta ctrl + c quando ho finito (o se lsrestituisce un valore diverso da zero). È simile al watchprogramma ma utilizza invece la shell, quindi funziona su piattaforme senza watch.

Un altro strumento utile è netcat, o nc. Se fate:

nc -l -p 9100 > printjob.prn

Quindi è possibile configurare una stampante su un altro computer ma utilizzare invece l'indirizzo IP del computer che esegue netcat. Quando il lavoro di stampa viene inviato, viene ricevuto dal computer che esegue netcat e scaricato printjob.prn.

pushde popdquasi sempre tornano utili

Un modo preferito di navigare quando sto usando più directory in luoghi molto separati in una gerarchia di alberi è usare acf_func.sh (elencato di seguito). Una volta definito, puoi farlo

cd -

per visualizzare un elenco di directory recenti, con un menu numerico

cd -2

per passare alla seconda directory più recente.

Molto facile da usare, molto utile.

Ecco il codice:

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

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

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

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

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

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

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

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

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

  return 0
}

alias cd=cd_func

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

Espandi le linee complicate prima di colpire il temuto invio

• Alt+ Ctrl+ e- shell-expand-line (potrebbe essere necessario utilizzare Esc, Ctrl+ esulla tastiera)
• Ctrl+ _- annulla
• 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.

Sono sempre stato parziale a:

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

Uso anche io shopt -s cdable_vars, quindi puoi creare variabili bash in directory comuni. Quindi, per l'albero dei sorgenti della mia azienda, creo un mucchio di variabili come:

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

quindi posso passare a quella directory da cd Dcentmain.

pbcopy

Questo copia negli appunti del sistema Mac. Puoi inoltrare i comandi ad esso ... prova:

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

L'uso di 'set -o vi' dalla riga di comando, o meglio, in .bashrc, ti mette in modalità di modifica vi sulla riga di comando. Si avvia in modalità 'insert' in modo da poter digitare e backspace come di consueto, ma se si commette un errore 'grande' è possibile premere il tasto esc e quindi usare 'b' e 'f' per spostarsi come si fa in vi. cw per cambiare una parola. Particolarmente utile dopo aver richiamato un comando di cronologia che si desidera modificare.

Simile a molti sopra, il mio preferito preferito è il tasto [alt]. (Alt e "." Insieme) equivale a $! (Inserisce l'ultimo argomento dal comando precedente) tranne per il fatto che è immediato e per me più facile da digitare. (Non può essere usato negli script)

per esempio:

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

Stringi più comandi insieme usando il comando && :

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

o

kill -9 1111 && ./start.sh