使用 Bash 最喜欢的命令行技巧是什么？

好吧，这可能有点离题，但是如果你是一个 Emacs 用户，我会说“ Emacs”是最强大的技巧... 在你否决这个之前，在一个 Emacs 实例中尝试“ M-x shell”... 你在 Emacs 中得到一个 shell，并且拥有 Emacs 的所有功能和一个 shell 的功能(有一些限制，比如在其中打开另一个 Emacs，但是在大多数情况下它比普通的 bash 提示要强大得多)。

您可以将 watch 命令与另一个命令结合使用来查找更改。这方面的一个例子是，当我在测试我的路由器时，我想获得最新的数字，比如信噪比等等。

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

比较新奇，但很聪明。

使用的十大命令:

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

输出样本:

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

cd -

它是相当于后退按钮的命令行(将您带到之前所在的目录)。

Bash 可以在 TCP/IP 套接字之间进行重定向。 /dev/tcp/和/dev/udp。

有些人认为这是安全问题, 但这就是操作系统级别的安全性，比如 Solaris X 的监狱。

正如 Will Robertson 所说，将提示符改为 do stuff... 输出命令 # for! nn 设置 Xterm 终端名称。如果它是一个旧的 Xterm，不会嗅到流量来设置它的标题。

我喜欢在提示语中加入一点颜色:

export PS1="\[\033[07;31m\] \h \[\033[47;30m\] \W \[\033[00;31m\] \$ \[\e[m\]"

我恐怕没有截图，但它应该是这样的(都在一行) :

[RED BACK WHITE TEXT] Computer name
[BLACK BACK WHITE TEXT] Working Directory
[WHITE BACK RED TEXT] $

根据您喜欢看到的 :)进行定制

下载大型文件时，我经常这样做:

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

当我完成后，只需要 ctrl + c (或者如果 ls返回非零)。它类似于 watch程序，但是它使用了 shell，所以它可以在没有 watch的平台上工作。

另一个有用的工具是 netcat 或 nc。如果你这样做:

nc -l -p 9100 > printjob.prn

然后，您可以在另一台计算机上设置打印机，但使用运行 Netcat 的计算机的 IP 地址。当打印作业被发送时，它被运行 netcat 的计算机接收并转储到 printjob.prn中。

在寻找音频和视频编辑工具时，我发现了一些有用的 mencoder 命令:

从.xxx 到.avi

mencoder movie.wmv -o movie.avi -ovc lavc -oac lavc

转储视频中的声音:

mplayer -ao pcm -vo null -vc dummy -dumpaudio -dumpfile fileout.mp3 filein.avi

ESC.

插入上一个 bash 命令的最后一个参数。

cp file /to/some/long/path

Cd

在运行命令时，有时我会希望使用前面的参数运行命令。为此，您可以使用以下快捷方式:

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

有时候，如果需要对文件列表运行一系列命令，我会打破单行循环，而不使用 find。

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

中配置命令行历史记录选项。Bash _ login (或。真的很有用。下面是我在 MacbookPro 上使用的一系列设置。

设置以下命令可以删除历史记录中的重复命令:

export HISTCONTROL="erasedups:ignoreboth"

我也把我的历史尺寸提高了很多。为什么不呢？它似乎没有减慢今天的微处理器的任何速度。

export HISTFILESIZE=500000
export HISTSIZE=100000

我要做的另一件事是忽略历史记录中的一些命令。

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

您肯定需要设置 hisappend，否则，当您退出时 bash 将覆盖您的历史记录。

shopt -s histappend

我使用的另一个选项是 cmdhist。

shopt -s cmdhist

最后，在 Mac OS X 上(如果您没有使用 vi 模式) ，您将希望从滚动停止中重置 < CTRL >-S。这可以防止 bash 将其解释为正向搜索。

stty stop ""

重命名

例如:

$ 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

太有用了

另一个最喜欢的:

!!

重复最后一个命令。最有用的形式是:

sudo !!

我喜欢用 Echo构造命令，并将它们导入 shell:

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

为什么？因为它能让我在行动之前看清楚要做什么。这样，如果我有一个可怕的错误(如删除我的主目录) ，我可以赶在它发生之前。显然，这对于破坏性或不可挽回的行为是最重要的。

下面是一些配置调整:

返回文章页面

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

这与 ^R的工作原理相同，但改为使用箭头键。这意味着我可以输入(例如) cd /media/，然后按向上箭头键进入 /media/文件夹中的最后一件事。

(我使用 Gnome 终端，您可能需要更改其他终端模拟器的转义码。)

Bash 补全也非常有用，但是它是一个更加微妙的补充:

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

这将启用每个程序制表符完成(例如，当命令行以 evince开始时，尝试制表符完成将只显示可以打开的文件，它还将制表符完成命令行选项)。

在 ~/.inputrc中也可以很好地使用:

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

作为 CTRL-r 向后搜索的扩展，如果您绑定“ history-search-back”，则可以使用历史记录自动完成当前输入。我通常将它绑定到 tcsh 中的相同密钥: ESC-p。可以通过在。Inputrc 文件:

"\M-p": history-search-backward

例如，如果你以前执行过“ make some _ really _ pain _ long _ target”，你可以输入:

> make <ESC p>

它会给你

> make some_really_painfully_long_target

我是 !$、 !^和 !*扩展的粉丝，从最近提交的命令行返回: 最后一个项目、第一个非命令项目和所有非命令项目。即(注意 shell 首先打印出命令) :

$ 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

当您想编辑其中的一个或两个 vimdiff !*时，比如说 ls filea fileb，这将非常方便。它也可以推广到“ n论证”，如下所示:

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

最后，使用路径名，您可以通过将 :h和 :t附加到上面的任何扩展名来获得路径的某些部分:

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

$ 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

这个对我来说很关键:

(西班牙语)

艾伦

^ R 反向搜索。按 ^ R 键，键入要匹配的前一个命令的片段，然后按 ^ R 键，直到找到所需的命令。这样，我就不必记住最近使用的命令，这些命令仍然保留在我的历史记录中。不仅仅是 bash，还有: ^ E 表示行尾，^ A 表示行首，^ U 和 ^ K 分别在游标之前和之后删除。

我一直很喜欢这个。 将此文件添加到您的/etc/inputrc 或 ~/. inputrc 中

“ e [ A”: 历史-搜索-回溯 E [ B ] : 历史-向前搜索

当您键入 ls <up-arrow>时，它将被替换为以“ ls”开头的最后一个命令或您输入的任何其他命令。

快速重命名/移动带后缀的文件:
cp /home/foo/realllylongname.cpp{,-old}

这种情况扩大到:
cp /home/foo/realllylongname.cpp /home/foo/realllylongname.cpp-old

pushd和 popd几乎总是派得上用场

在命令行中使用‘ set-o vi’，或者更好地使用。Bashrc，将您置于命令行上的 vi 编辑模式。你开始在“插入”模式，所以你可以像往常一样输入和退格，但是如果你犯了一个“大”错误，你可以按 esc 键，然后使用“ b”和“ f”来移动，就像你在 vi 中做的那样。改变一个单词。特别是在您提出要更改的历史命令之后。

这可以防止 更少(越少越好)清除文件末尾的屏幕:

export LESS="-X"

我更喜欢阅读 vi 中的手册页，所以在我的.profile 或.bashrc 文件中有以下内容

man () {
sought=$*
/usr/bin/man $sought | col -b | vim -R -c "set nonumber" -c "set syntax=man"  -
}

我在化名中有很多误植更正

alias mkae=make


alias mroe=less

Ctrl + L通常会清除屏幕。可以从 Bash 提示符(显然)和 广发局以及许多其他提示符中工作。

对于我来说，最简单的按键是! $

echo what the heck?


what the heck?


echo !$


heck?

使用 & & 命令将多个命令串在一起:

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

或者

kill -9 1111 && ./start.sh

当我在树层次结构中相距很远的地方使用多个目录时，一种首选的导航方法是使用 acf _ func。Sh (见下表)。一旦定义，你可以做

CD

查看最近目录的列表，并使用数字菜单

Cd-2

转到第二个最近的目录。

非常容易使用，非常方便。

密码是这样的:

# 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

当在两个不同的目录之间导航和来回复制文件时，我这样做:

cd /some/where/long
src=`pwd`
cd /other/where/long
dest=`pwd`


cp $src/foo $dest


command completion will work by expanding the variable, so you can use tab completion to specify a file you're working with.

我一直偏爱:

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

我也使用 shopt -s cdable_vars，然后您可以创建 bash 变量到公共目录。因此，对于我公司的源代码树，我创建了一系列变量，比如:

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

然后我可以通过 cd Dcentmain切换到那个目录。

< anything > | sort | uniq-c | sort-n

会给你一个所有不同事件的计数 < anything > 。

通常，awk、 sed 或 cut 帮助解析 < anything > 中的数据。

U-a | sort-n | tail -99

找到要清理的大文件(或文件目录)以释放磁盘空间。

我经常使用下面的句子:

打印历史结果的 :p修饰符。

!!:p

将打印最后一个命令，以便在再次运行之前检查它是否正确。只要输入 !!执行它。

同样的道理:

!?foo?:p

将在历史记录中搜索包含字符串“ foo”的最新命令并打印它。

如果你不需要打印,

!?foo

进行搜索并立即执行。

$_(美元下划线) : 前一个命令的最后一个单词。类似于 !$，只是它不像 !$那样在历史记录中添加替换。

我最喜欢的命令是“索尔”

它传唤 神的力量以便于阅读的格式列出最近修改的文件。

消除文件中的重复行

#sort -u filename > filename.new

列出与条件不匹配的所有行

#grep -v ajsk filename

这些不一定是特定于 Bash 的(但是 ls -thor: 也不是)

其他一些有用的 cmds:

Prtdiag，psrinfo，prtconf-more info 给你 and 给你(post on my blog).

type -a PROG

为了找到 PROG 可用的所有位置，通常是在 ~/bin 中的某个位置 而不是在/usr/bin/PROG 中的那个。

alias mycommand = 'verylongcommand -with -a -lot -of -parameters'
alias grep='grep --color'

在 grep 中找到不止一个单词:

netstat -c |grep 'msn\|skype\|icq'

我最喜欢的是“ ^ string ^ string2”，它接受最后一个命令，用 string2替换 string 并执行它

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

Bash 命令行历史指南

不是真的模糊，但我绝对 爱的功能之一是选项卡完成。
当您在整个子树结构中导航时，或者当您使用一些模糊的或长的命令时，这非常有用！

几年前，我发现了 P * 命令或获取有关进程的信息: Ptree、 Pgrep、 Pkill和 档案。当然，其中最重要的是 注意，但是您需要将输出通过管道传输到 更少、 Grep和/或 嗷，以了解重负载下的输出。头儿(及其变体)也有所帮助。

您更改为新目录并希望将文件从新目录移动到旧目录。一招: mv file $OLDPWD

如果我正在搜索某个目录中的某个内容，但是我不确定该文件，那么我只需要通过以下方法对该目录中的文件进行 grep:

find . -exec grep whatIWantToFind {} \;

alias -- ddt='ls -trFld'
dt () { ddt --color "$@" | tail -n 30; }

给你工作目录里最新的文件我一直在用。

与上面的许多类似，我目前最喜欢的是按键[ alt ]。(Alt 和“这和 $是一样的！(插入上一个命令的最后一个参数) ，除了它是即时的，对我来说更容易输入。(只是不能在脚本中使用)

例如:

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

当你意识到你刚刚键入了错误的一行时，一个简单的事情就是点击 Ctrl + C; 如果你想保留这一行，但是需要先执行其他的东西，用一个反斜杠-开始一个新的行，然后点击 Ctrl + C。这条界线将永远留在你们的历史中。

我经常使用 vi、 ls 等等的别名，但是有时候需要避免使用别名。只需在前面的命令中添加一个反斜杠:

例如:

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

很酷吧？

您应该能够将以下内容粘贴到 bash 终端窗口中。

显示 ANSI 调色板:

e="\033["
for f in 0 7 `seq 6`; do
no="" bo=""
for b in n 7 0 `seq 6`; do
co="3$f"; p="  "
[ $b = n ] || { co="$co;4$b";p=""; }
no="${no}${e}${co}m   ${p}${co} ${e}0m"
bo="${bo}${e}1;${co}m ${p}1;${co} ${e}0m"
done
echo -e "$no\n$bo"
done

256彩色演示:

yes "$(seq 232 255;seq 254 -1 233)" |
while read i; do printf "\x1b[48;5;${i}m\n"; sleep .01; done

要获取日志文件的最后几行吗？

tail /var/log/syslog

想要密切关注日志文件的变化吗？

tail -f /var/log/syslog

想从头快速阅读一个文件吗？

more /var/log/syslog

要快速查找文件是否包含某些文本吗？

grep "find this text" /var/log/syslog

CTRL + D 退出 shell。

要快速编辑您知道的 shell 脚本，可以使用 $PATH (不要尝试使用 ls...) :

function viscr { vi $(which $*); }

恰当的历史——使用隐晦的插入符号等并不是完全直观的。打印包含给定字符串的所有历史记录项:

function histgrep { fc -l -$((HISTSIZE-1)) | egrep "$@" ;}

如果你希望 TAB 完成时忽略带有特定后缀的文件或文件夹，那么 FIGNORE 环境变量很不错，例如:

export FIGNORE="CVS:.svn:~"

如果你想定义一个空格以外的项目分隔符，可以使用 IFS 环境变量，例如:

export IFS="
"

这将使您能够循环通过文件和文件夹中的空格，而不执行任何魔术，像这样:

$ touch "with spaces" withoutspaces
$ for i in `ls *`; do echo $i; done
with
spaces
withoutspaces
$ IFS="
"
$ for i in `ls *`; do echo $i; done
with spaces
withoutspaces

! < 命令 > 的前几个字符将执行最后一个匹配的命令。

例如:

!b将运行“ build whatever-O-p-t-i-on” !.将运行 ./a.out

它最适合使用长而重复的命令，比如编译、构建、执行等等。它节省了我很多时间，当编码和测试。

适用于对包含符号链接的目录进行精确的递归复制/备份(而不是像 cp 那样跟随或忽略它们) :

$ mkdir new_dir
$ cd old_dir
$ tar cf - . | ( cd ../old_dir; tar xf - )

自定义选项卡完成(compgen 和完整的 bash 内置程序)

Tab Completion 很不错，但是能够将其应用于不仅仅是文件名的其他方面也很棒。我用它来创建自定义函数，将参数扩展到我一直使用的命令。例如，假设您经常需要将 FQDN 作为参数添加到命令中(例如 ping blah.really.long.domain.name.foo.com)。您可以使用 compgen 和 complete 创建一个 bash 函数，该函数读取/etc/hosts 文件以获得结果，因此您只需输入以下内容:

ping blah.<tab>

它会显示你当前所有的匹配选项。

所以基本上任何可以返回单词列表的东西都可以用作函数。

当运行一个具有大量输出的命令(比如一个大的“ make”)时，我不仅要保存输出，还要查看它:

Make install 2 > & 1 | tee E.make

作为一个快速计算器，比如计算一个百分比:

$ date
Thu Sep 18 12:55:33 EDT 2008
$ answers=60
$ curl "http://stackoverflow.com/questions/68372/what-are-some-of-your-favorite-command-line-tricks-using-bash"  > tmp.html
$ words=`awk '/class="post-text"/ {s = s $0} \
> /<\/div>/ { gsub("<[^>]*>", "", s); print s; s = ""} \
> length(s) > 0 {s = s $0}' tmp.html \
> |  awk '{n = n + NF} END {print n}'`
$ answers=`awk '/([0-9]+) Answers/ {sub("<h2>", "", $1); print $1}' tmp.html`

最后:

$ echo $words words, $answers answers, $((words / $answers)) words per answer
4126 words, 60 answers, 68 words per answer
$

并不是说除法是截断的，而不是四舍五入的，但是通常这对于快速计算来说已经足够好了。

返回文章页面十大命令译者:

history | awk '{ print $2 }' | sort | uniq -c |sort -rn | head

我是在 Mac 上编程的新手，我怀念从 bash 启动 gui 程序的日子... ... 所以我必须创建这样的函数:

function macvim
{
/Applications/MacVim.app/Contents/MacOS/Vim "$@" -gp &
}

我总是将默认提示设置为“ username@hostname:/current/path/name/in/full >”

PS1='\u@\h:\w> '
export PS1

当您处理许多不同的机器时，可以避免许多混淆。

while IFS= read -r line; do
echo "$line"
done < somefile.txt

这是一种逐行处理文件的好方法。需要清除 IFS 以获得行的前端或结尾处的空白字符。需要使用“-r”来获取所有原始字符，包括反斜杠。

我有一个秘密武器: 贝壳。

有数以千计的聪明的提示，很酷的技巧和有效的食谱，大多数时间适合在一个单一的行。

一个我喜欢的(但是因为我使用了 Python 已经安装在大多数 Unix 系统上的事实，所以我作弊了一点) :

alias webshare='python -m SimpleHTTPServer'

现在，每次你输入“ webshare”，工作目录就会通过端口8000提供。当你想在没有 usb 键或远程目录的本地网络上与朋友共享文件时，真的很不错。流媒体视频和音乐也可以。

当然，经典的叉子炸弹完全没用，但仍然很有趣:

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

不要在生产服务器上尝试..。

这里还有一些 Bash 的金块:

Http://codesnippets.joyent.com/tag/bash

我最喜欢的 bash 技巧之一是“ tar 管道”。当你有大量的文件要从一个目录复制到另一个目录时，如果文件数量太多，导致 bash globber 爆炸，那么使用“ cp */an/other/dir”就不起作用，因此，tar 管道:

(cd /path/to/source/dir/ ; tar cf - * ) | (cd /path/to/destination/ ; tar xf - )

... 如果你有网猫，你甚至可以 做“ netcat 焦油管道”通过网络! ！

删除所有 除了 重要文件:

# shopt -s extglob
# rm -rf !(important-file)

切也是如此:

# rm -rf *~important-file

在我知道我必须把重要的字段移到另一本字典之前，删除所有内容，然后再把重要的字段移回来。

我有一个非常愚蠢，但非常有帮助的一个当导航深树结构。把这个放进去。巴希尔(或类似的) :

alias cd6="cd ../../../../../.."
alias cd5="cd ../../../../.."
alias cd4="cd ../../../.."
alias cd3="cd ../../.."
alias cd2="cd ../.."

使用历史替换字符 !#访问当前命令行，结合 ^、 $等。

例如，移开一个前缀为“ old-”的文件:

mv file-with-long-name-typed-with-tab-completion.txt old-!#^

当然，您可以使用“ diff file1.txt file2.txt”，但是 Bash 支持 工序替代工序替代，它允许您使用 diff输出命令。

例如，假设我想确保我的脚本提供了我所期望的输出。我可以直接将脚本包装在 < ()中，然后将其提供给 diff，以获得一个快速而粗糙的单元测试:

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

作为另一个示例，假设我想检查两个服务器是否安装了相同的 RPM 列表。与其在每个服务器上运行 sshing，将每个 RPM 列表写入单独的文件，然后对这些文件执行 diff操作，不如在我的工作站上执行 diff操作:

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

中还有更多的例子 http://tldp.org/LDP/abs/html/process-sub.html高级 Bash 脚本指南。

在 Mac OS X 上,

ESC .

将循环讨论最近的争论。即: 按下并释放 ESC，然后按下并释放 .(周期键)。在 Ubuntu 上，我想是 ALT+.。

你可以不止一次这样做，回顾你最近的所有论点。它有点像 CTRL + R，但只适用于参数。它也比 !!或 $!安全得多，因为在实际运行命令之前，您将获得 你看。

如何在当前目录中列出 只有子目录？

ls -d */

这是一个简单的把戏，但你不会知道我需要多少时间才能找到那一个！

sudo !!

以管理员权限运行最后一个命令。

find -iregex '.*\.py$\|.*\.xml$' | xargs egrep -niH 'a.search.pattern'  | vi -R -

在所有 Python 文件和所有 XML 文件中搜索一个模式，并将结果传送到一个只读的 维姆会话中。

我最喜欢的两个是:

1)使制表符完成大小写不敏感(例如，“ cd/home/User”将命令行转换为: “ cd/home/User”，如果后者存在而前者不存在的话。您可以在提示符下使用“设置完成-忽略-大小写打开”来打开它，或者通过将“设置完成-忽略-大小写打开”添加到您的。Inputrc 文件。

2)内置的‘ type’命令与“ which”类似，但也能识别别名

$ type cdhome
cdhome is aliased to 'cd ~'
$ type bash
bash is /bin/bash

我喜欢设置一个提示，在 xterm 的窗口标题中显示工作目录。它还显示了时间和工作目录。此外，如果 bash 希望报告背景作业已经完成，则使用 ANSI 转义序列以不同的颜色报告。我使用黑光控制台，所以我的颜色可能不适合你，如果你喜欢光对黑色。

PROMPT_COMMAND='echo -e "\033]0;${USER}@${HOSTNAME%%.*}:${PWD/#$HOME/~}\007\033[1;31m${PWD/#$HOME/~}\033[1;34m"'
PS1='\[\e[1;31m\]\t \$ \[\e[0m\]'

确保您了解如何正确地在 PS1字符串中使用 \[和 \]，以便 bash 知道提示字符串在屏幕上实际呈现的时间。这样，当您移动到单行命令之外时，它就可以正确地重新绘制命令行。

我想提一下我们如何使用它的批处理模式(- b)将 top 命令输出重定向到 file

$top-b-n 1 > top.out. $(date +% s)

默认情况下，top 使用交互模式调用，其中 top 无限期运行并接受按键来重新定义 top 的工作方式。

我写的一篇文章可以找到 给你

使用 化名可以节省时间

alias myDir = "cd /this/is/a/long/directory; pwd"

Shell-fu 是一个存储、管理和传播命令行提示和技巧的地方。有点像 StackOverflow，但仅限于 shell。你会在那里找到很多关于这个问题的答案。

我是 Bash 工作控制的忠实粉丝，主要是使用 Control-Z和 fg，尤其是在终端开发的时候。如果我已经打开了 emacs 并且需要编译、部署等等。我只是 Control-Z暂停 emacs，做我需要的，和 fg把它带回来。这样可以保持所有 emacs 缓冲区的完整性，并且比重新启动我正在做的任何事情都要容易得多。

因为我总是需要 for i in $(ls)声明，所以我走了一条捷径:

fea(){
if test -z ${2:0:1}; then action=echo; else action=$2; fi
for i in $(ls $1);
do $action $i ;
done;
}

另一个是:

echo ${!B*}

它将打印以“ B”开头的所有已定义变量的列表。

Http://www.commandlinefu.com 也是一个很棒的网站。

sudo !!

mount | column -t

插入前行最终参数

ALT-.是有史以来最有用的组合键，试试看，出于某种原因没有人知道这一个。

按一次又一次以选择较旧的最后参数。

当你想对刚才用过的东西做点别的事情的时候，这很好。

pbcopy

这个复制到 Mac 系统剪贴板。你可以通过管道向它发送命令... 试试:

pwd | pbcopy

alias ..='cd ..'

因此，在向上导航一个目录时，只需使用 ..<Enter>

如何查找哪些文件匹配文本，使用 find | grep-H 在此示例中，哪个 Ruby 文件包含跳转字符串-

- name’* . rb’-exec grep-H dump {} ;

只有麦克。这是简单的，但男人，我希望我已经知道这一年前。

open ./

打开 Finder 中的工作目录。您也可以使用它来打开任何文件与它的默认应用程序。也可以用于 URL，但只有在 URL 前缀为 http://时才能使用，这限制了它偶尔打开随机站点的效用。

卷曲支架扩展:

在运行有很多选项的 ./configure时非常方便:

./configure --{prefix=/usr,mandir=/usr/man,{,sh}libdir=/usr/lib64,\
enable-{gpl,pthreads,bzlib,lib{faad{,bin},mp3lame,schroedinger,speex,theora,vorbis,xvid,x264},\
pic,shared,postproc,avfilter{-lavf,}},disable-static}

这是我对 ffmpeg 的配置设置，没有大括号就是409个字符。

或者，更好的是:

echo "I can count to a thousand!" ...{0,1,2,3,4,5,6,7,8,9}{0,1,2,3,4,5,6,7,8,9}{0,1,2,3,4,5,6,7,8,9}...

删除所有写的东西

短信

我经常使用这些文本序列，所以我把快捷方式放在 .inputrc中:

# redirection short cuts
"\ew":            "2>&1"
"\eq":            "&>/dev/null &"
"\e\C-q":         "2>/dev/null"
"\eg":            "&>~/.garbage.out &"
"\e\C-g":         "2>~/.garbage.out"


$if term=xterm
"\M-w":           "2>&1"
"\M-q":           "&>/dev/null &"
"\M-\C-q":        "2>/dev/null"
"\M-g":           "&>~/.garbage.out &"
"\M-\C-g":        "2>~/.garbage.out"
$endif

可编程完成:

没什么特别的。当我使用 Knoppix 时，我总是禁用它，因为它太经常妨碍我了。只是一些基本的:

shopt -s progcomp


complete -A stopped -P '%'          bg
complete -A job     -P '%'          fg jobs disown wait
complete -A variable                readonly export
complete -A variable -A function    unset
complete -A setopt                  set
complete -A shopt                   shopt
complete -A helptopic               help
complete -A alias                   alias unalias
complete -A binding                 bind
complete -A command                 type which \
killall pidof
complete -A builtin                 builtin
complete -A disabled                enable

虽然不是真正的交互式 shell 技巧，但作为编写优秀脚本的技巧是有效的。

Getopts，shift，$OPTIND，$OPTARG:

我喜欢制作可定制的脚本:

while getopts 'vo:' flag; do
case "$flag" in
'v')
VERBOSE=1
;;
'o')
OUT="$OPTARG"
;;
esac
done
shift "$((OPTIND-1))"

Xargs (1) :

我有一个三核处理器，喜欢运行脚本执行压缩，或一些其他 CPU 密集型串行操作的一组文件。我喜欢使用 xargs作为作业队列来加快速度。

if [ "$#" -gt 1 ]; then
# schedule using xargs
(for file; do
echo -n "$file"
echo -ne '\0'
done) |xargs -0 -n 1 -P "$NUM_JOBS" -- "$0"
else
# do the actual processing
fi

这很像 make -j [NUM_JOBS]。

./mylittle 算法 < input.txt > output.txt

信号捕捉:

您可以捕获发送到 shell 进程的信号，并让它们在各自的环境中静默地运行命令，就像在命令行上输入一样:

# TERM or QUIT probably means the system is shutting down; make sure history is
# saved to $HISTFILE (does not do this by default)
trap 'logout'                      TERM QUIT


# save history when signalled by cron(1) script with USR1
trap 'history -a && history -n'    USR1

重复的文件查找器

这将从工作目录递归地运行校验和，并返回所有相同校验和结果的文件名:

find ./ -type f -print0 | xargs -0 -n1 md5sum | sort -k 1,32 | uniq -w 32 -d --all-repeated=separate | sed -e 's/^[0-9a-f]*\ *//;'

当然，你可以改变周围的路径。
可以将其放入函数或别名中，并将目标路径作为参数传递。

上水隧道:

ssh -fNR 1234:localhost:22 root@123.123.123.123

对于纯粹的幽默因素，创建一个空文件“自己”，然后: $ touch myself

我有很多目录，我想快速访问，CDPATH变量是解决方案 极大地加速了我的工作流程:

export CDPATH=.:/home/gadolin/sth:/home/gadolin/dir1/importantDir

现在使用 cd，我可以跳转到 /home/gadolin/sth或 /home/gadolin/dir1/importantDir的任何子目录，而不需要提供完整的路径。而且 <tab>在这里工作就像我在那里一样！ 因此，如果有目录 /home/gadolin/sth/1 /home/gadolin/sth/2，我键入 cd 1无论在哪里，我在那里。

# Batch extension renamer (usage: renamer txt mkd)
renamer() {
local fn
for fn in *."$1"; do
mv "$fn" "${fn%.*}"."$2"
done
}

延伸的球状物:

rm !(foo|bar)

像没有 foo或 bar的 *那样膨胀:

$ ls
foo
bar
foobar
FOO
$ echo !(foo|bar)
foobar FOO

GNU/Linux 的 pbcopy 和 pbaste 别名

alias pbcopy='xclip -selection clipboard'
alias pbpaste='xclip -selection clipboard -o'

有人推荐在 Emacs 中使用“ M-x shell RET”，我认为“ M-x shell RET”更好。

在输入可怕的回车之前展开复杂的行

• Alt + Ctrl + e & mash; 壳扩展线壳扩展线壳扩展线(可能需要在键盘上使用 Esc，Ctrl + e)
• Ctrl + _ & mdash; 撤销
• Ctrl + x，* & mdash; GB/T14559 -1993全球扩展词

$echo !$ !-2^ * Alt + Ctrl + e
$echo aword someotherword * Ctrl + _
$echo !$ !-2^ * Ctrl + x *
$echo !$ !-2^ LOG Makefile bar.c foo.h < br/>

等等。

不是我的最爱，如果你用复制和粘贴的方法尝试其他答案的话，这很有帮助:

function $
{
"$@"
}

现在您可以粘贴在每行开头包含 $提示符的示例。