Jaki jest twój najbardziej ulubiony trik wiersza poleceń przy użyciu Bash? [zamknięte]

Szybkie zmienianie nazw/przenoszenie plików z przyrostkami:
cp /home/foo/realllylongname.cpp{,-old}

To rozszerza się na:
cp /home/foo/realllylongname.cpp /home/foo/realllylongname.cpp-old

cd -

Jest to odpowiednik przycisku back w wierszu poleceń (przenosi cię do poprzedniego katalogu, w którym się znajdowałeś).

Kolejny ulubiony:

!!

Powtarza Twoje ostatnie polecenie. Najbardziej przydatne w formie:

sudo !!

Moim ulubionym jest '^ string^string2', który pobiera ostatnią komendę, zastępuje string string2 i wykonuje ją

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

Przewodnik historii wiersza poleceń Bash

Zmień nazwę

Przykład:

$ 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

So useful

Jestem fanem !$, !^ i !* rozszerzenia, zwracające, z ostatniej przesłanej linii poleceń: ostatni element, pierwszy element niebędący poleceniem i wszystkie elementy niebędące poleceniem. Do wit (zauważ, że powłoka wypisuje polecenie jako pierwsza):

$ 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

Przydaje się to, gdy mówisz ls filea fileb i chcesz edytować jedną z nich: vi !$ lub obie: vimdiff !*. Można go również uogólnić do "argumentu nth" w ten sposób:

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

Wreszcie, z nazwami ścieżek, można uzyskać na części ścieżka przez dodanie :h i :t do dowolnego z powyższych rozszerzeń:

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

Jak wyświetlić tylko podkatalogi w bieżącym ?

ls -d */

To prosta sztuczka, ale nie wiesz, ile czasu potrzebowałem, aby ją znaleźć !

ESC.

Wstawia Ostatnie argumenty z ostatniego polecenia bash. Przydaje się bardziej niż myślisz.

cp file /to/some/long/path

Cd ESC.

Oczywiście, możesz "diff file1.txt file2.txt", ale Bash obsługuje zastępowanie procesów , co pozwala na diff Wyjście poleceń.

Powiedzmy, że chcę mieć pewność, że mój skrypt da mi wynik, którego oczekuję. Mogę po prostu zawinąć mój skrypt w diff, aby uzyskać szybki i brudny test jednostkowy:

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

Jako kolejny przykład, powiedzmy, że chcę sprawdzić, czy dwa serwery mają tę samą listę rpm zainstalowanych. Zamiast sshing do każdego serwera, zapisywanie każdej listy rpm aby oddzielić pliki i zrobić diff na tych plikach, mogę po prostu zrobić diff z mojej stacji roboczej:

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

Jest więcej przykładów w Advanced Bash-Scripting Guide at http://tldp.org/LDP/abs/html/process-sub.html .

Moim ulubionym poleceniem jest "ls-thor"

Przywołuje moc bogów , Aby wyświetlić listę ostatnio zmodyfikowanych plików w wygodnym formacie.

Więcej nowości, ale sprytne...

Top 10 poleceń używanych:

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

Przykładowe wyjście:

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

^R Hit ^R, wpisz fragment poprzedniego polecenia, które chcesz dopasować, i hit ^R, aż znajdziesz ten, który chcesz. Wtedy nie muszę pamiętać ostatnio używanych poleceń, które są nadal w mojej historii. Nie tylko bash, ale także: ^E Dla końca linii, ^a dla początku linii, ^U i ^K, aby usunąć odpowiednio przed i za kursorem.

Często mam aliasy dla vi, ls, itp. ale czasami chcesz uciec od pseudonimu. Po prostu dodaj ukośnik do komendy z przodu:

Eg:

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

Oto kilka poprawek konfiguracji:

~/.inputrc:

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

Działa to tak samo jak ^R, ale zamiast tego używa się klawiszy strzałek. Oznacza to, że mogę wpisać (np.) cd /media/, a następnie nacisnąć strzałkę w górę, aby przejść do ostatniej rzeczy i cd'd do wewnątrz /media/ folderu.

(używam terminala Gnome, być może trzeba będzie zmienić kody escape dla innych emulatorów terminala.)

Ukończenie Bash jest również niezwykle przydatne, ale jest o wiele bardziej subtelnym dodatkiem. W ~/.bashrc:

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

Spowoduje to włączenie uzupełniania kart dla każdego programu (np. próba uzupełnienia kart, gdy linia poleceń zaczyna się od evince pokaże tylko pliki, które evince może otworzyć, a także opcje linii poleceń uzupełniania kart).

Działa ładnie z tym również w ~/.inputrc:

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

Używam często następujących:

Modyfikator :p do wyświetlenia wyniku historii. Np.

!!:p

Wyświetli ostatnią komendę, abyś mógł sprawdzić, czy jest poprawna przed ponownym uruchomieniem. Wystarczy wpisać !!, aby ją uruchomić.

W podobnym tonie:

!?foo?:p

PrzeszukaÄ ‡ historiÄ ™ w poszukiwaniu najnowszego polecenia, ktĂłre zawieraĺ 'o napis" foo " i wydrukować.

Jeśli nie musisz drukować,

!?foo

Wykonuje wyszukiwanie i wykonuje je od razu.

Mam tajną broń: shell-fu.

Jeden, który kocham (ale oszukuję trochę, ponieważ używam faktu, że Python jest zainstalowany na większości systemów Unix teraz):

alias webshare='python -m SimpleHTTPServer'

Teraz za każdym razem, gdy wpisujesz "webshare", bieżący katalog będzie dostępny przez port 8000. Naprawdę miło, gdy chcesz udostępniać pliki znajomym w sieci lokalnej bez klucz usb lub zdalny dir. Streaming wideo i muzyki będzie działać zbyt.

I oczywiście klasyczny Fork bomb, który jest całkowicie bezużyteczny, ale nadal dużo zabawy:

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

Możesz użyć polecenia watch w połączeniu z innym poleceniem, aby wyszukać zmiany. Przykładem tego było, gdy testowałem mój router i chciałem uzyskać aktualne numery na takich rzeczach, jak stosunek sygnału do szumu itp.

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

type -a PROG

Aby znaleźć wszystkie miejsca, w których PROG jest dostępny, zwykle gdzieś w ~ / bin zamiast tego w /usr / bin / PROG, którego można się było spodziewać.

Lubię konstruować komendy z echo i przesyłać je do powłoki:

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

Podczas pobierania dużego pliku dość często robię:

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

I po prostu ctrl+c, gdy skończę (lub jeśli ls zwróci wartość niezerową). Jest podobny do programu watch, ale zamiast tego używa powłoki, więc działa na platformach bez watch.

Innym użytecznym narzędziem jest netcat, lub nc. Jeśli tak:

nc -l -p 9100 > printjob.prn

Następnie możesz skonfigurować drukarkę na innym komputerze, ale zamiast tego użyj adresu IP komputera, na którym działa netcat. Po wysłaniu zadania drukowania jest ono odbierane przez komputer uruchamianie netcata i wrzucanie do printjob.prn.

pushd i popd prawie zawsze się przydają

Jednym z preferowanych sposobów nawigacji, gdy używam wielu katalogów w szeroko oddzielnych miejscach w hierarchii drzewa jest użycie acf_func.sh (wymienione poniżej). Po zdefiniowaniu można wykonać

Cd --

Aby zobaczyć listę ostatnich katalogów, z menu numerycznym

Cd -2

Aby przejść do drugiego-najnowszego katalogu.

Bardzo łatwy w użyciu, bardzo poręczny.

Oto kod:

# 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

Rozwiń skomplikowane linie przed uderzeniem przerażającego enter

• Alt+Ctrl+e - shell-expand-line (może być konieczne użycie Esc, Ctrl+e na klawiaturze)
• Ctrl+_ - undo
• 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.

Zawsze byłem częściowy do:

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

Używam również shopt -s cdable_vars, wtedy można tworzyć zmienne bash do popularnych katalogów. Tak więc, dla drzewa źródłowego mojej firmy, tworzę kilka zmiennych takich jak:

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

Wtedy mogę zmienić ten katalog przez cd Dcentmain.

pbcopy

To kopiuje do schowka systemu Mac. Możesz skierować do niego polecenia...try:

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

Użycie 'set-o vi' z linii poleceń, lub lepiej, w .bashrc, umieszcza cię w trybie edycji vi w wierszu poleceń. Zaczynasz w trybie "Wstaw", więc możesz normalnie wpisywać i backspace, ale jeśli popełnisz "duży" błąd, możesz nacisnąć klawisz esc, a następnie użyć "b" I "f", aby poruszać się tak, jak to robisz w vi. cw, aby zmienić słowo. Szczególnie przydatne po wywołaniu polecenia historia, które chcesz zmienić.

Podobnie jak wiele wyżej, moim obecnym ulubionym jest naciśnięcie klawisza [alt]. (Alt i "."keys together) to to samo co $! (Wstawia ostatni argument z poprzedniego polecenia) z tym, że jest to natychmiastowe i dla mnie łatwiejsze do wpisania. (Po prostu nie może być używany w skryptach)

Eg:

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

String multiple commands together using the && polecenie:

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

Lub

kill -9 1111 && ./start.sh