兴海北路

    目的：1）享受用shell解决问题的乐趣 2）和朋友们一起交流和探讨
    初步计划：先零散地写些东西，之后再不断补充，最后整理成册。
    适合读者：已经熟悉linux基本知识，比如文件系统结构、常用命令行工具、shell编程基础等。
    建议：大家在看这些范例的时候，参考网络中流传的《shell基础十二篇》和《shell十三问》，见ChinaUnix Shell讨论区。
    环境：如果没有特别说明，以后"shell编程范例"系列使用的shell将特指bash，版本在3.1.17以上。
    说明：本序列的组织不是依据Shell语法，而是面向某些潜在的操作对象和操作本身，它们反应了现实应用。当然，在这个过程当中肯定会涉及到Shell的语法。另外，欢迎您对帖子里头存在的问题进行批评指正，也欢迎您对一些范例进行改进。

$ i=0;
$ ((i++))
$ echo $i
1
$ let i++
$ echo $i
2
$ expr $i + 1
3
$ echo $i
2
$ echo $i 1 | awk '{printf $1+$2}'
3

$ type type
type is a shell builtin
$ type let
let is a shell builtin
$ type expr
expr is hashed (/usr/bin/expr)
$ type bc
bc is hashed (/usr/bin/bc)
$ type awk
awk is /usr/bin/awk

$ bash calc.sh
$ type bash
bash is hashed (/bin/bash)

$ . ./calc.sh
或
$ source ./calc.sh
$ type .
. is a shell builtin
$ type source
source is a shell builtin

$ chmod ./calc.sh
$ ./calc.sh

$ time calc.sh
10000

real    0m1.319s
user    0m1.056s
sys     0m0.036s
$ time calc_let.sh
10000

real    0m1.426s
user    0m1.176s
sys     0m0.032s
$  time calc_expr.sh
1000

real    0m27.425s
user    0m5.060s
sys     0m14.177s
$ time calc_bc.sh
1000

real    0m56.576s
user    0m9.353s
sys     0m24.618s
$ time ./calc_awk.sh
100

real    0m11.672s
user    0m2.604s
sys     0m2.660s

//求模
$ expr 5 % 2
1
$ let i=5%2
$ echo $i
1
$ echo 5 % 2 | bc
1
$ ((i=5%2))
$ echo $i
1
//求幂
$ let i=5**2
$ echo $i
25
$ ((i=5**2))
$ echo $i
25
$ echo "5^2" | bc
25

$ echo "scale=3; 1/13"  | bc
.076
$ echo "1 13" | awk '{printf("%0.3f\n",$1/$2)}'
0.077

$ echo 1/13100 | bc -l
.00007633587786259541

1 3 4490
2 5 3896
3 4 3112
4 4 4716
5 4 4578
6 6 5399
7 3 5089
8 6 3029
9 4 6195
10 5 5145

$ ./gettopfamily.sh income
7 1696.33
9 1548.75
1 1496.67
4 1179.00
5 1144.50
10 1029.00
6 899.83
2 779.20
3 778.00
8 504.83

$ echo $RANDOM
81
$ echo "" | awk '{srand(); printf("%f", rand());}'
0.237788

$ expr $RANDOM / 128
$ echo "" | awk '{srand(); printf("%d\n", rand()*255);}'

$ seq 5
1
2
3
4
5
$ seq 1 5
1
2
3
4
5
$ seq 1 2 5
1
3
5
$ seq -s: 1 2 5
1:3:5
$ seq 1 2 14
1
3
5
7
9
11
13
$ seq -w 1 2 14
01
03
05
07
09
11
13
$ $ seq -s: -w 1 2 14
01:03:05:07:09:11:13

$ for i in {1..5}; do echo -n "$i "; done
1 2 3 4 5

//统计每个单词出现的次数
$ cat text | sed -e "s/[^a-zA-Z]/\n/g" | grep -v ^$ | sort | uniq -c
//统计出出现频率最高的前10个单词
$ cat text | sed -e "s/[^a-zA-Z]/\n/g" | grep -v ^$ | sort | uniq -c | sort -n -k 1 -r | head -10
     45 is
     40 to
     32 of
     31 a
     28 and
     27 the
     25 happiness
     19 happy
     18 it
     18 in

$ chmod +x statistic_words.sh
$ ./statistic_words.sh text is Action happy
     45 is
      1 Action
     19 happy

$ ./statistic_words.sh text is Action happy
     45 is
      1 Action
     19 happy

$ cat text | sed -e "s/[^a-zA-Z]/\n/g" | grep -v ^$ | sort | grep -E "^Action$|^is$" | uniq
-c
或者
$ cat text | sed -e "s/[^a-zA-Z]/\n/g" | grep -v ^$ | sort | egrep  "^Action$|^is$" | uniq
-c
[/code]
所以，可见这些命令sed,grep,uniq,sort是多么有用，它们本身虽然只完成简单的功能，但是通过一定的组合，就可以实现你想要实现的功能啦。对了，统计单词还有个非常有用的命令wc -w，需要用到的时候也可以用它。

补充：在《高级Bash脚本编程指南》一书中还提到jot命令和factor命令，由于我机器上没有，所以没有测试，factor命令可以产生某个数的所有素数。如：
[quote]
$ factor 100
100: 2 2 5 5

//用bc -l计算，可以获得高精度
$ export cos=0.996293; echo "scale=100; a(sqrt(1-$cos^2)/$cos)*180/(a(1)*4)" |bc -l
4.934954755411383632719834036931840605159706398655243875372764917732\
5495504159766011527078286004072131
//用awk
$ echo 0.996293 | awk '{ printf("%-10s %-10s", $1, atan2(sqrt(1-$1^2),$1)*180/3.1415926535);}'

$ cat data
2000     1         0
2005     0.996293     4.93515
2010     0.999609     1.60303
2015     0.98501     9.9332
2020     0.999488     1.83398
2025     0.999409     1.9702
2030     0.99943     1.93381
2035     0.999267     2.19348
2040     0.99679     4.59235
$ awk '{ printf("%-10s%-10s%-10s", $1, $2, $3); system("echo \"scale=10; a(sqrt(1-"$2"^2)/"$2")*180/3.1415926535\" | bc -l ");}' data
2000     1       0       0
2005     0.996293 4.93515   4.9349547602
2010     0.999609 1.60303   1.6022865295
2015     0.98501   9.9332   9.9330460660
2020     0.999488 1.83398   1.8335432105
2025     0.999409 1.9702   1.9699389820
2030     0.99943   1.93381   1.9346200645
2035     0.999267 2.19348   2.1938966333
2040     0.99679   4.59235   4.5920476729
$ awk '{ printf("%-10s%-10s%-10s %f\n", $1, $2, $3, atan2(sqrt(1-$2^2), $2)*180/3.1415926535)}' data
2000     1       0       0.000000
2005     0.996293 4.93515   4.934955
2010     0.999609 1.60303   1.602286
2015     0.98501   9.9332   9.933046
2020     0.999488 1.83398   1.833543
2025     0.999409 1.9702   1.969939
2030     0.99943   1.93381   1.934620
2035     0.999267 2.19348   2.193897
2040     0.99679   4.59235   4.592048

// 单独测试true和false，可以看出true是真值，false为假
$ if true;then echo "YES"; else echo "NO"; fi
YES
$ if false;then echo "YES"; else echo "NO"; fi
NO
// 与运算
$ if true && true;then echo "YES"; else echo "NO"; fi
YES
$ if true && false;then echo "YES"; else echo "NO"; fi
NO
$ if false && false;then echo "YES"; else echo "NO"; fi
NO
$ if false && true;then echo "YES"; else echo "NO"; fi
NO
// 或运算
$ if true || true;then echo "YES"; else echo "NO"; fi
YES
$ if true || false;then echo "YES"; else echo "NO"; fi
YES
$ if false || true;then echo "YES"; else echo "NO"; fi
YES
$ if false || false;then echo "YES"; else echo "NO"; fi
NO
// 非运算，即取反
$ if ! false;then echo "YES"; else echo "NO"; fi
YES
$ if ! true;then echo "YES"; else echo "NO"; fi
NO

// true和false它们本身并非逻辑值，它们是shell内置命令，返回了“逻辑值”
$ true
$ echo $?
0
$ false
$ echo $?
1
// 看看true和false帮助和类型
$ help true false
true: true
     Return a successful result.
false: false
     Return an unsuccessful result.
$ type true false
true is a shell builtin
false is a shell builtin

// 数值测试
$ if test 5 -eq 5;then echo "YES"; else echo "NO"; fi
YES
$ if test 5 -ne 5;then echo "YES"; else echo "NO"; fi
NO
// 字符串测试
$ if test -n "not empty";then echo "YES"; else echo "NO"; fi
YES
$ if test -z "not empty";then echo "YES"; else echo "NO"; fi
NO
$ if test -z "";then echo "YES"; else echo "NO"; fi
YES
$ if test -n "";then echo "YES"; else echo "NO"; fi
NO
// 文件测试
$ if test -f /boot/System.map; then echo "YES"; else echo "NO"; fi
YES
$ if test -d /boot/System.map; then echo "YES"; else echo "NO"; fi
NO
// 各种测试的组合
// 如果a,b,c都等于下面对应的值，那么打印YES，这里通过-a进行"与"测试
$ a=5;b=4;c=6;
$ if test $a -eq 5 -a $b -eq 4 -a $c -eq 6; then echo "YES"; else echo "NO"; fi
YES
// 测试某个“东西”是文件或者目录，这里通过-o进行“或”运算
$ if test -f /etc/profile -o -d /etc/profile;then echo "YES"; else echo "NO"; fi
YES
// 测试非运算
$ if test ! -f /etc/profile; then echo "YES"; else echo "NO"; fi
NO

// 要求某个文件有可执行权限并且有内容，用-a和&&分别实现
$ vim test.sh
$ cat test.sh
#!/bin/bash

echo "test"
$ chmod +x test.sh
$ if test -s test.sh -a -x test.sh; then echo "YES"; else echo "NO"; fi
YES
$ if test -s test.sh && test -x test.sh; then echo "YES"; else echo "NO"; fi
YES
// 要求某个字符串要么为空，要么和某个字符串相等
$ str1="test"
$ str2="test"
$ if test -z "$str2" -o "$str2" == "$str1"; then echo "YES"; else echo "NO"; fi
YES
$ if test -z "$str2" || test "$str2" == "$str1"; then echo "YES"; else echo "NO"; fi
YES
// 测试某个数字不满足指定的所有条件
$ i=5
$ if test ! $i -lt 5 -a $i -ne 6; then echo "YES"; else echo "NO"; fi
YES
$ if ! test $i -lt 5 -a $i -eq 6; then echo "YES"; else echo "NO"; fi
YES

// -ne和-eq对应的，我们有时候可以免去!运算
$ i=5
$ if test $i -eq 5; then echo "YES"; else echo "NO"; fi
YES
$ if test $i -ne 5; then echo "YES"; else echo "NO"; fi
NO
$ if test ! $i -eq 5; then echo "YES"; else echo "NO"; fi
NO
// 用[  ]可以取代test，这样看上去会“美观”很多
$ if [ $i -eq 5 ]; then echo "YES"; else echo "NO"; fi
YES
$ if [ $i -gt 4 ] && [ $i -lt 6 ]; then echo "YES"; else echo "NO"; fi
YES
// 记得给一些字符串变量加上""，记得[之后与]之前多加一个空格
$ str=""
$ if [ "$str" = "test"]; then echo "YES"; else echo "NO"; fi
-bash: [: missing `]'
NO
$ if [ $str = "test" ]; then echo "YES"; else echo "NO"; fi
-bash: [: =: unary operator expected
NO
$ if [ "$str" = "test" ]; then echo "YES"; else echo "NO"; fi
NO

// 如果ping通www.lzu.edu.cn，那么打印连通信息
$ ping -c 1 www.lzu.edu.cn -W 1 && echo "=======connected======="
// 这种情况下，只执行第一条命令
$ echo "iiii" || echo "jjjj"
iiii

$ chmod +x ftpls.sh
$ ./ftpls.sh mirror.lzu.edu.cn
about.html
cldp
doc
gentoo
gnu.org
index.html
kernel.org
knoppix
os
rfc
slackware
slind
software
tldp
tmp
ubuntu
ubuntu-cn
welcome.msg
$ ./ftpls.sh xxxy.lzu.edu.cn ftp ftp gb2312
incoming
pub
xxxy.lzu.edu.cn.url
管理员的信箱是xxxylzu@gmail.com
近期由于大量非校园网用户连接FTP，导致正常用户无法访问，故暂时关闭外网访问

字符串:
简称“串”。有限字符的序列。数据元素为字符的线性表，是一种数据的逻辑结构。在计算机中可有不同的存储结构。在串上可进行求子串、插入字符、删除字符、置换字符等运算。

字符:
计算机程序设计及操作时使用的符号。包括字母、数字、空格符、提示符及各种专用字符等。

// 数字或者数字组合（能够返回结果，即程序提出状态是0，说明属于这种类型，反之不然）
$ i=5;j=9423483247234;
$ echo $i | grep [0-9]*
5
$ echo $j | grep [0-9]*
9423483247234
$ echo $j | grep [0-9]* >/dev/null
$ echo $?
0
// 字符组合（小写字母、大写字母、两者的组合）
$ c="A"; d="fwefewjuew"; e="fewfEFWefwefe"
$ echo $c | grep [A-Z]
A
$ echo $d | grep "[a-z]*"
fwefewjuew
$ echo $e | grep "[a-zA-Z]*"
fewfEFWefwefe
// 字母和数字的组合
$ ic="432fwfwefeFWEwefwef"
$ echo $ic | grep "[0-9a-zA-Z]*"
432fwfwefeFWEwefwef
// 空格或者Tab键等
$ echo " " | grep " "
 
$ echo -e "\t" | grep "[[:space:]]" #[[:space:]]会同时匹配空格和TAB键

$ echo -e " \t" | grep "[[:space:]]"

$ echo -e "\t" | grep "<tab>" #<tab>为在键盘上按下TAB键，而不是字符<tab>
// 匹配邮件地址
$ echo "test2007@lzu.cn" | grep "[0-9a-zA-Z\.]*@[0-9a-zA-Z\.]"
test2007@lzu.cn
// 匹配URL地址(以http链接为例）
$ echo "http://news.lzu.edu.cn/article.jsp?newsid=10135" | grep "http://[0-9a-zA-Z\./=?]*"
http://news.lzu.edu.cn/article.jsp?newsid=10135

// 用grep判断某个字符是否为可打印字符
$ echo "\t\n" | grep "[[:print:]]"
\t\n
$ echo $?
0
$ echo -e "\t\n" | grep "[[:print:]]"
$ echo $?
1
// 用echo的-e选项在屏幕控制字符显示位置、颜色、背景等
$ echo -e "\33[31;40m" #设置前景色为黑色，背景色为红色
$ echo -e "\33[11;29H Hello, World\!" #在屏幕的第11行，29列开始打印字符串Hello,World!
// 在屏幕的某个位置动态显示当前系统时间
$ while :; do echo -e "\33[11;29H "$(date "+%Y-%m-%d %H:%M:%S"); done
// 用col命令过滤掉某些控制字符，在处理诸如script,screen等截屏命令的输出结果时，很有用
$ screen -L
$ cat /bin/cat
$ exit
$ cat screenlog.0 | col -b   # 把一些控制字符过滤后，就可以保留可读的操作日志

// 计算某个字符串的长度，即所有字符的个数[这计算方法是五花八门，择其优着而用之]
$ var="get the length of me"
$ echo ${var}     # 这里等同于$var
get the length of me
$ echo ${#var}
20
$ expr length "$var"
20
$ echo $var | awk '{printf("%d\n", length($0));}'
20
$ echo -n $var |  wc -c
20
// 计算某些指定一个字符或者多个字符的个数
$ echo $var | tr -cd g | wc -c
2
$ echo -n $var | sed -e 's/[^g]//g' | wc -c
2
$ echo -n $var | sed -e 's/[^gt]//g' | wc -c
5
// 如果要统计单词个数，更多相关信息见《shell编程之数值计算》之 _单词统计_ 实例。
$ echo $var | wc -w
5
$ echo "$var" | tr " " "\n" | grep get | uniq -c
1
$ echo "$var" | tr " " "\n" | grep get | wc -l
1

//1. bash提供的数组数据结构，它是以数字为下标的，和C语言从0开始的下标一样
$ var="get the length of me"
$ var_arr=($var)    #这里把字符串var存放到字符串数组var_arr中了，默认以空格作为分割符
$ echo ${var_arr[0]} ${var_arr[1]} ${var_arr[2]} ${var_arr[3]} ${var_arr[4]}
get the length of me
$ echo ${var_arr[@]}    #这个就是整个字符串所有部分啦，这里可以用*代替@，下同
get the length of me
$ echo ${#var_arr[@]}    #记得上面求某个字符串的长度么，#操作符，如果想求某个数组元素的字符串长度，那么就把@换成下标吧
5
// 你也可以直接给某个数组元素赋值
$ var_arr[5]="new_element"
$ echo ${var_arr[5]}
6
$ echo ${var_arr[5]}
new_element
// bash里头实际上还提供了一种类似于“数组”的功能，即"for i in 用指定分割符分开的字符串" 的用法
// 即，你可以很方便的获取某个字符串的某个部分
$  for i in $var; do echo -n $i" "; done;
get the length of me

//2. awk里头的数组，注意比较它和bash提供的数组的异同
// split把一行按照空格分割，存放到数组var_arr中，并返回数组的长度。注意：这里的第一个元素下标不是0，而是1
$ echo $var | awk '{printf("%d %s\n", split($0, var_arr, " "), var_arr[1]);}'
5 get
// 实际上，上面的操作很类似awk自身的行处理功能：awk默认把一行按照空格分割为多个域，并可以通过$1,$2,$3...来获取,$0表示整行
// 这里的NF是该行的域的总数，类似于上面数组的长度，它同样提供了一种通过“下标”访问某个字符串的功能
$ echo $var | awk '{printf("%d | %s %s %s %s %s | %s\n", NF, $1, $2, $3, $4, $5, $0);}'
5 | get the length of me | get the length of me
// awk的“数组”功能何止于此呢，看看它的for引用吧，注意，这个和bash里头的for不太一样，i不是元素本身，而是下标
$ echo $var | awk '{split($0, var_arr, " "); for(i in var_arr) printf("%s ",var_arr);}'
get the length of me
$ echo $var | awk '{split($0, var_arr, " "); for(i in var_arr) printf("%s ",i);}'
1 2 3 4 5
// awk还有更“厉害”的处理能力，它的下标可以不是数字，而可以是字符串，从而变成了“关联”数组，这种“关联”的作用在某些方便将让我们非常方便
// 比如，我们这里就实现一个非凡的应用，把某个文件中的某个系统调用名替换成地址，如果你真正用起它，你会感慨它的“鬼斧神工”的。
// 这就是我在一个场合最好才发现的随好的实现方案：有兴趣看看awk手册帖子中我在3楼回复的实例吧。
$ cat symbol
sys_exit
sys_read
sys_close
$ ls /boot/System.map*
$ awk '{if(FILENAME ~ "System.map") map[$3]=$1; else {printf("%s\n", map[$1])}}' /boot/System.map-2.6.20-16-generic symbol
c0129a80
c0177310
c0175d80
// 另外，awk还支持删除某个数组元素，如果你不用了就可以用delete函数给删除掉。如果某些场合有需要的话，别忘了awk还支持二维数组。

// 按照位置取子串，比如从什么位置开始，取多少个字符
$ var="get the length of me"
$ echo ${var:0:3}
get
$ echo ${var:(-2)}   # 方向相反呢
me
$ echo `expr substr "$var" 5 3` #记得把$var引起来，否则expr会因为空格而解析错误
the
$ echo $var | awk '{printf("%s\n", substr($0, 9, 6))}'
length

// 匹配字符求子串
$ echo ${var%% *} #从右边开始计算，删除最左边的空格右边的所有字符
get
$ echo ${var% *} #从右边开始计算，删除第一个空格右边的所有字符
get the length of
$ echo ${var##* }  #从左边开始计算，删除最右边的空格左边的所有字符
me
$ echo ${var#* }  #从左边开始计算，删除第一个空格左边的所有字符
the length of me

$ echo $var | awk '{printf("%s\n", $1);}' # awk把$var按照空格分开为多个变量，依次为$1,$2,$3,$4,$5
get
$ echo $var | awk '{printf("%s\n", $5);}'
me

$ echo $var | cut -d" " -f 5  #差点把cut这个小东西忘记啦，用起来和awk类似, -d指定分割符，如同awk用-F指定分割符一样，-f指定“域”，如同awk的$数字。

$ echo $var | sed 's/ [a-z]*//g'  #删除所有 空格＋字母串 的字符串，所以get后面的全部被删除了
get
$ echo $var | sed 's/[a-z]* //g'
me

$ echo $var | tr " " "\n" | sed -n 1p #sed有按地址（行）打印(p)的功能，记得先用tr把空格换成行号
get
$ echo $var | tr " " "\n" | sed -n 5p
me

// tr也可以用来取子串哦，它也可以类似#和%来“拿掉”一些字符串来实现取子串
$ echo $var | tr -d " "
getthelengthofme
$ echo $var | tr -cd "[a-z]" #把所有的空格都拿掉了，仅仅保留字母字符串，注意-c和-d的用法
getthelengthofme

$ echo "abcdefghijk" | head -c 4
abcd
$ echo -n "abcdefghijk" | tail -c 4
hijk

// 查询子串在目标串中的位置
$ var="get the length of me"
$ expr index "$var" t        #貌似仅仅可以返回某个字符或者多个字符中第一个字符出现的位置
3  
$ echo $var | awk '{printf("%d\n", match($0,"the"));}'    #awk却能找出字串,match还可以匹配正则表达式
5

// 查询子串，返回包含子串的行(awk,sed都可以实现这些功能,但是grep最擅长）
$ grep "consists of" text   # 查询text文件包含consists of的行，并打印这些行
$ grep "consists[[:space:]]of" -n -H text # 打印文件名，子串所在行的行号和该行的内容
$ grep "consists[[:space:]]of" -n -o text # 仅仅打印行号和匹配到的子串本身的内容
$ awk '/consists of/{ printf("%s:%d:%s\n",FILENAME, FNR, $0)}' text  #看到没？和grep的结果一样
$ sed -n -e '/consists of/=;/consists of/p' text #同样可以打印行号

// 用{}运算符，还记得么？网中人的教程。
$ var="get the length of me"
$ echo ${var/ /_}        #把第一个空格替换成下划线
get_the length of me
$ echo ${var// /_}        #把所有空格都替换成了下划线了
get_the_length_of_me

// 用awk，awk提供了转换的最小替换函数sub和全局替换函数gsub，类似/和//
$ echo $var | awk '{sub(" ", "_", $0); printf("%s\n", $0);}'
get_the length of me
$ echo $var | awk '{gsub(" ", "_", $0); printf("%s\n", $0);}'
get_the_length_of_me

// 用sed了，子串替换可是sed的特长
$ echo $var | sed -e 's/ /_/'    #s <= substitude
get_the length of me
$ echo $var | sed -e 's/ /_/g'    #看到没有，简短两个命令就实现了最小匹配和最大匹配g <= global
get_the_length_of_me

// 有忘记tr命令么？可以用替换单个字符的
$ echo $var | tr " " "_"
get_the_length_of_me
$ echo $var | tr '[a-z]' '[A-Z]'   #这个可有意思了，把所有小写字母都替换为大写字母
GET THE LENGTH OF ME

// 用{}
$ var="get the length of me"
$ echo ${var/ /_ }        #在指定字符串之前插入一个字符串
get_ the length of me
$ echo ${var// /_ }
get_ the_ length_ of_ me
$ echo ${var/ / _}        #在指定字符串之后插入一个字符串
get _the length of me
$ echo ${var// / _}
get _the _length _of _me

// 其他的还用演示么？这里主要介绍sed怎么用来插入字符吧，因为它的标签功能很有趣
$ echo $var | sed -e 's/\( \)/_\1/' #\(和\)将不匹配到的字符串存放为一个标签，按匹配顺序为\1,\2...
get_ the length of me
$ echo $var | sed -e 's/\( \)/_\1/g'
get_ the_ length_ of_ me
$ echo $var | sed -e 's/\( \)/\1_/'
get _the length of me
$ echo $var | sed -e 's/\( \)/\1_/g'
get _the _length _of _me

// 看看sed的标签的顺序是不是\1,\2....，看到没？\2和\1掉换位置后，the和get的位置掉换了
$ echo $var | sed -e 's/\([a-z]*\) \([a-z]*\) /\2 \1 /g'
the get of length me
// sed还有专门的插入指令，a和i,分别表示在匹配的行后和行前插入指定字符
$ echo $var | sed '/get/a test'
get the length of me
test
$ echo $var | sed '/get/i test'
test
get the length of me

// 再用{}
$ echo ${var// /}
getthelengthofme
// 再用awk
$ echo $var | awk '{gsub(" ","",$0); printf("%s\n", $0);}'
// 再用sed
$ echo $var | sed 's/ //g'
getthelengthofme
// 还有更简单的tr命令，tr也可以把" "给删除掉，看
$ echo $var | tr -d " "
getthelengthofme

$ var="get the length of me"
$ echo $var | tr ' ' '\n' | sort   #正序排
get
length
me
of
the
$ echo $var | tr ' ' '\n' | sort  -r #反序排
the
of
me
length
get
$ cat data.txt
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
41 45 44 44 26 44 42 20 20 38 37 25 45 45 45
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
44 20 30 39 35 38 38 28 25 30 36 20 24 32 33
31 32 33 34 35 36 37 38 39 40 41 42 43 44 45
41 33 51 39 20 20 44 37 38 39 42 40 37 50 50
46 47 48 49 50 51 52 53 54 55 56
42 43 41 42 45 42 19 39 75 17 17
$ cat data.txt | sort -k 2 -n
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
44 20 30 39 35 38 38 28 25 30 36 20 24 32 33
31 32 33 34 35 36 37 38 39 40 41 42 43 44 45
41 33 51 39 20 20 44 37 38 39 42 40 37 50 50
42 43 41 42 45 42 19 39 75 17 17
41 45 44 44 26 44 42 20 20 38 37 25 45 45 45
46 47 48 49 50 51 52 53 54 55 56

$ echo "ibase=10;obase=16;10" | bc
A

$ nihao_gb2312=$(echo "你好" | iconv -f utf8 -t gb2312)
$ echo $nihao_gb2312
����
$ nihao_utf8=$(echo $nihao_gb2312 | iconv -f gb2312 -t utf8)
$ PS1="$ "
$ echo $nihao_utf8
你好

$ url="ftp://anonymous:ftp@mirror.lzu.edu.cn/software/scim-1.4.7.tar.gz"
// 匹配URL地址，判断URL地址的有效性
$ echo $url | grep "ftp://[a-z]*:[a-z]*@[a-z\./-]*"
// 截取服务器类型
$ echo ${url%%:*}
ftp
$ echo $url | cut -d":" -f 1
ftp
// 截取域名
$ tmp=${url##*@} ; echo ${tmp%%/*}
mirror.lzu.edu.cn
// 截取路径
$ tmp=${url##*@} ; echo ${tmp%/*}
mirror.lzu.edu.cn/software
// 截取文件名
$ basename $url
scim-1.4.7.tar.gz
$ echo ${url##*/}
scim-1.4.7.tar.gz
// 截取文件类型（扩展名）
$ echo $url | sed -e 's/.*[0-9].\(.*\)/\1/g'
tar.gz

// 选取/etc/passwd文件中的用户名和组ID两列
$ cat /etc/passwd | cut -d":" -f1,4
// 选取/etc/group文件中的组名和组ID两列
$ cat /etc/group | cut -d":" -f1,3
// 如果想找出所有用户所在的组，怎么办？
$ join -o 1.1,2.1 -t":" -1 4 -2 3 /etc/passwd /etc/group
root:root
bin:bin
daemon:daemon
adm:adm
lp:lp
pop:pop
nobody:nogroup
falcon:users
// 先解释一下：join命令用来连接两个文件，有点类似于数据库的两个表的连接。-t指定分割符，"-1 4 -2 3"指定按照第一个文件的第4列和第二个文件的第3列，即组ID进行连接，"-o 1.1,2.1"表示仅仅输出第一个文件的第一列和第二个文件的第一列，这样就得到了我们要的结果，不过，可惜的是，这个结果并不准确，再进行下面的操 作，你就会发现：
$ cat /etc/passwd | sort -t":" -n -k 4 > /tmp/passwd
$ cat /etc/group | sort -t":" -n -k 3 > /tmp/group
$ join -o 1.1,2.1 -t":" -1 4 -2 3 /tmp/passwd /tmp/group
halt:root
operator:root
root:root
shutdown:root
sync:root
bin:bin
daemon:daemon
adm:adm
lp:lp
pop:pop
nobody:nogroup
falcon:users
games:users
// 可以看到这个结果才是正确的，所以以后使用join千万要注意这个问题，否则采取更保守的做法似乎更能保证正确性，更多关于文件连接的讨论见参考资料[14]

$ IFS=":"; cat /etc/group | while read C1 C2 C3 C4; do echo $C1 $C3; done

$ cat /etc/passwd | cut -d":" -f1,3 --output-delimiter=" "
root 0
bin 1
daemon 2

$ cat a
root    bin     daemon 
0       1       2

$ ls -l
total 12
drwxr-xr-x 2 root root 4096 2007-12-07 20:08 directory_file
prw-r--r-- 1 root root    0 2007-12-07 20:18 fifo_pipe
brw-r--r-- 1 root root 3, 1 2007-12-07 21:44 hda1_block_dev_file
crw-r--r-- 1 root root 1, 3 2007-12-07 21:43 null_char_dev_file
-rw-r--r-- 2 root root  506 2007-12-07 21:55 regular_file
-rw-r--r-- 2 root root  506 2007-12-07 21:55 regular_file_hard_link
lrwxrwxrwx 1 root root   12 2007-12-07 20:15 regular_file_soft_link -> regular_file
$ stat directory_file/
  File: `directory_file/'
  Size: 4096            Blocks: 8          IO Block: 4096   directory
Device: 301h/769d       Inode: 521521      Links: 2
Access: (0755/drwxr-xr-x)  Uid: (    0/    root)   Gid: (    0/    root)
Access: 2007-12-07 20:08:18.000000000 +0800
Modify: 2007-12-07 20:08:18.000000000 +0800
Change: 2007-12-07 20:08:18.000000000 +0800
$ stat null_char_dev_file
  File: `null_char_dev_file'
  Size: 0               Blocks: 0          IO Block: 4096   character special file
Device: 301h/769d       Inode: 521240      Links: 1     Device type: 1,3
Access: (0644/crw-r--r--)  Uid: (    0/    root)   Gid: (    0/    root)
Access: 2007-12-07 21:43:38.000000000 +0800
Modify: 2007-12-07 21:43:38.000000000 +0800
Change: 2007-12-07 21:43:38.000000000 +0800

// 对于普通文件：就是一序列字符的集合，所以可以读、写等
$ echo "hello, world" > regular_file
$ cat regular_file
hello, world
// 目录文件下，我们可以创建新的文件，所以目录文件还有叫法：文件夹，到后面我们会分析目录文件的结构体，它实际上存放了它下面的各个文件的文件名。
$ cd directory_file
$ touch file1 file2 file3
// 对于有名管道，操作起来比较有意思：如果你要读它，除非有内容，否则阻塞；如果你要写它，除非有人来读，否则阻塞。它常用于进程通信中。你可以打开两个终端terminal1和terminal2，试试看：
terminal1$ cat fifo_pipe   #刚开始阻塞在这里，直到下面的写动作发生，才打印test字符串
terminal2$ echo "test" > fifo_pipe
// 关于块设备，字符设备，上面的两个设备文件对应于/dev/hda1和/dev/null，如果你用过u盘，或者是写过简单的脚本的话，这样的用法你应该用过 :-)
$ mount hda1_block_dev_file /mnt   #挂载硬盘的第一个分区到/mnt下（关于挂载的原理，我们在下一节讨论）
$ echo "fewfewfef" > /dev/null  #/dev/null像个黑洞，什么东西丢进去都消失殆尽
// 最后两个文件分别是regular_file文件的硬链接和软链接，你去读写它们，他们的内容是相同的，不过你去删除它们，他们去互不相干，硬链接和软链 接又有什么不同呢？前者可以说就是原文件，后者呢只是有那么一个inode，但没有实际的存储空间，建议用stat命令查看它们之间的区别，包括它们的 Blocks,inode等值，也可以考虑用diff比较它们的大小。
$ ls regular_file*
ls regular_file* -l
-rw-r--r-- 2 root root 204800 2007-12-07 22:30 regular_file
-rw-r--r-- 2 root root 204800 2007-12-07 22:30 regular_file_hard_link
lrwxrwxrwx 1 root root     12 2007-12-07 20:15 regular_file_soft_link -> regular_file
$ rm regular_file      #删除原文件
$ cat regular_file_hard_link   #硬链接还在，而且里头的内容还有呢
fefe
$ cat regular_file_soft_link  
cat: regular_file_soft_link: No such file or directory
                                            #虽然软链接文件本身还在，不过因为它本身不存储内容，所以读不大东西拉，这就是软链接和硬链接的区别，该知道则么用它们了吧。

$ file ./
./: directory
$ file /etc/profile
/etc/profile: ASCII English text
$ file /lib/libc-2.5.so
/lib/libc-2.5.so: ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV), not stripped
$ file /bin/test
/bin/test: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked (uses shared libs), stripped
$ file /dev/hda
/dev/hda: block special (3/0)
$ file /dev/console
/dev/console: character special (5/1)
$ cp /etc/profile .
$ tar zcf profile.tar.gz profile
$ file profile.tar.gz
profile.tar.gz: gzip compressed data, from Unix, last modified: Tue Jan  4 18:53:53 2000
$ mkfifo fifo_test
$ file fifo_test
fifo_test: fifo (named pipe)

$ chown 用户名:组名 文件名

$ ls -n regular_file
-rw-r--r-- 1 0 0 115 2007-12-07 23:45 regular_file
$ ls -l regular_file
-rw-r--r-- 1 root root 115 2007-12-07 23:45 regular_file

$ strace -f -o strace.log ls -l regular_file
$ cat strace.log | egrep "passwd|group|shadow"
2989  open("/etc/passwd", O_RDONLY)     = 3
2989  open("/etc/group", O_RDONLY)      = 3

$ chmod a+rwx regular_file
或
$ chmod 777 regular_file

$ ls -l /usr/bin/passwd
-rwx--x--x 1 root root 36092 2007-06-19 14:59 /usr/bin/passwd
$ su      #切换到root用户，给程序或者命令添加“粘着位”
$ chmod +s /usr/bin/passwd
$ ls -l /usr/bin/passwd
-rws--s--x 1 root root 36092 2007-06-19 14:59 /usr/bin/passwd
$ exit
$ passwd #普通用户通过执行该命令，修改自己的密码

$ chattr +i regular_file
$ lsattr regular_file
----i-------- regular_file
$ rm regular_file      #加了immutable位以后，你无法对文件进行任何“破坏性”的活动啦
rm: remove write-protected regular file `regular_file'? y
rm: cannot remove `regular_file': Operation not permitted
$ chattr -i regular_file #如果想对它进行常规操作，那么可以把这个位去掉
$ rm regular_file

$ echo -n "abcde" > regular_file   #往regular_file写入5字节
$ ls -l regular_file*
-rw-r--r-- 2 root root  5 2007-12-08 15:28 regular_file
-rw-r--r-- 2 root root  5 2007-12-08 15:28 regular_file_hard_file
lrwxrwxrwx 1 root root 12 2007-12-07 20:15 regular_file_soft_link -> regular_file
lrwxrwxrwx 1 root root 22 2007-12-08 15:21 regular_file_soft_link_link -> regular_file_soft_link
$ i="regular_file"
$ j="regular_file_soft_link"
$ echo ${#i} ${#j}   #可以参考，软链接存放的刚好是它们指向的原文件的文件名的字节数
12 22

$ ls -l hda1_block_dev_file
brw-r--r-- 1 root root 3, 1 2007-12-07 21:44 hda1_block_dev_file
$ ls -l null_char_dev_file
crw-r--r-- 1 root root 1, 3 2007-12-07 21:43 null_char_dev_file

$ ls -ld directory_file/
drwxr-xr-x 2 root root 4096 2007-12-07 23:14 directory_file/

$ touch regular_file      #创建普通文件
$ mkdir directory_file     #创建目录文件，目录文件里头可以包含更多文件
$ ln regular_file regular_file_hard_link  #硬链接，是原文件的一个完整拷比
$ ln -s regular_file regular_file_soft_link  #类似一个文件指针，指向原文件
$ mkfifo fifo_pipe   #或者通过 "mknod fifo_pipe p" 来创建，FIFO满足先进先出的特点
$ mknod hda1_block_dev_file b 3 1  #块设备
$ mknod null_char_dev_file c 1 3   #字符设备

$ tree 当前目录
或者
$ ls 当前目录

$ rm regular_file
$ rmdir directory_file
$ rm -r directory_file_not_empty

// 用cp命令常规地复制文件（复制目录需要-r选项）
$ cp regular_file regular_file_copy
$ cp -r diretory_file directory_file_copy
// 创建硬链接(link和copy不同之处是后者是同步更新，前者则不然，复制之后两者不再相关)
$ ln regular_file regular_file_hard_link
// 创建软链接
$ ln -s regular_file regluar_file_soft_link

$ mv regular_file regular_file_new_name

// 创建一个文件并写入abcde
$ echo "abcde" > new_regular_file
// 再往上面的文件中追加一行abcde
$ echo "abcde" >> new_regular_file
// 按行读一个文件
$ while read LINE; do echo $LINE; done < test.sh

$ redirect="echo \"abcde\" >test_redirect_file"
$ $redirect   #这里会把>当作字符 > 打印出来，而不会当作 重定向 解释
"abcde" >test_redirect_file
$ eval $redirect    #这样才会把 > 解释成 重定向
$ cat test_redirect_file
abcde

// tar, 这在某种意义上来不是文件的压缩，仅仅是“把一堆东西放在一起，当成一个文件来看”。
$ tar -cf file.tar file   #压缩
$ tar -xf file.tar    #解压
// gz  
$ gzip  -9 file
$ gunzip file
// tar.gz
$ tar -zcf file.tar.gz file
$ tar -zxf file.tar.gz
// bz2
$ bzip2 file
$ bunzip2 file
// tar.bz2
$ tar -jcf file.tar.bz2 file
$ tar -jxf file.tar.bz2

// find命令基本使用演示
$ find ./ -name "*.c" -o -name "*.h"  #找出所有的C语言文件，-o是或者
$ find ./ \( -name "*.c" -o -name "*.h" \) -exec mv '{}' ./c_files/ \;     #把找到的文件移到c_files下，这种用法非常有趣，不过她可以用xargs命令替代，例如
$ find ./ -name "*.c" -o -name "*.h" | xargs -i mv '{}' ./c_files/     #如果要对文件做更复杂的操作，可以考虑把mv改写为你自己的处理命令，例如，我需要修改所有的文件名后缀为大写。
$ find ./ -name "*.c" -o -name "*.h" | xargs -i ./toupper.sh '{}' ./c_files/     #toupper.sh就是我们需要实现的转换小写为大写的一个处理文件，具体实现如下：
$ cat toupper.sh
#!/bin/bash

# the {} will be expended to the current line and becomen the first argument of this script
FROM=$1
BASENAME=${FROM##*/}

BASE=${BASENAME%.*}
SUFFIX=${BASENAME##*.}

TOSUFFIX="$(echo $SUFFIX | tr '[a-z]' '[A-Z]')"
TO=$2/$BASE.$TOSUFFIX
COM="mv $FROM $TO"
echo $COM
eval $COM
// updatedb+locate基本使用演示
$ updatedb #更新库
$ locate find*.gz #查找包含find字符串的所有gz压缩包

$ which find
/usr/bin/find
$ whereis find
find: /usr/bin/find /usr/X11R6/bin/find /usr/bin/X11/find /usr/X11/bin/find /usr/man/man1/find.1.gz /usr/share/man/man1/find.1.gz /usr/X11/man/man1/find.1.gz

//创建一个符号链接，虽然前面的文件不存在，但是符号链接还是创建了
$ ln -s /path/to/a/file/notexist notexist  
//不过，试图访问这个符号链接时却试图访问前面那个链接，所以找不到那个文件，但提示的时候却提示符号链接名指定的文件不存在，所以要千万注意这个有趣的情况
$ cat notexist
cat: notexist: No such file or directory

$ mkdir -p /tmp/path/to/a/file/notexist
$ cat notexist1/
cat: notexist1/: Is a directory
$ rmdir /tmp/path/to/a/file/notexist
$ cat notexist1
cat: notexist1: No such file or directory

// 更新系统中文件索引数据库(有点慢，不耐烦就按下CTRL+C取消掉）
$ updatedb
// 查找scsi相关的驱动
$ locate scsi*.ko
// 查找usb相关的驱动
$ locate usb*.ko

$ sleep 100 &            #让sleep程序在后台运行
[1] 9298
$ pidof sleep             #用pidof可以查看指定程序名的进程ID
9298
$ cat /proc/9298/maps    #查看进程的内存映像
08048000-0804b000 r-xp 00000000 08:01 977399     /bin/sleep
0804b000-0804c000 rw-p 00003000 08:01 977399     /bin/sleep
0804c000-0806d000 rw-p 0804c000 00:00 0          [heap]
b7c8b000-b7cca000 r--p 00000000 08:01 443354    
...
bfbd8000-bfbed000 rw-p bfbd8000 00:00 0          [stack]
ffffe000-fffff000 r-xp 00000000 00:00 0          [vdso]

$ ps -ef #查看系统所有当前进程的属性
$ ps -C init #查看命令中包含某个指定字符的程序对应的进程，进程ID是1，TTY为？表示和终端没有关联
  PID TTY          TIME CMD
    1 ?        00:00:01 init
$ ps -U falcon #选择某个特定用户启动的进程
$ ps -e -o "%C %c"  #可以按照指定格式输出指定内容，这里会输出命令名和cpu使用率
$ ps -e -o "%C %c" | sort -u -k1 -r | head -5  #这样则会打印cpu使用率最高的前4个程序
 7.5 firefox-bin
 1.1 Xorg
 0.8 scim-panel-gtk
 0.2 scim-bridge
$ ps -e -o "%z %c" | sort -n -k1 -r | head -5  #使用虚拟内存最大的5个进程
349588 firefox-bin
 96612 xfce4-terminal
 88840 xfdesktop
 76332 gedit
 58920 scim-panel-gtk

$ pstree #打印系统进程调用树，可以非常清楚地看到当前系统中所有活动进程之间的调用关系

$ top

$ cat hello.c   #典型的hello, world程序
#include <stdio.h>

int main(void)
{
        printf("hello, world!\n");
        return 0;
}
$ gcc -c hello.c   #编译，产生可重定向的目标代码
$ readelf -h hello.o | grep Type   #通过readelf查看文件头部找出该类型
  Type:                              REL (Relocatable file)
$ gcc -o hello hello.o   #生成可执行文件
$ readelf -h hello | grep Type
  Type:                              EXEC (Executable file)
$ gcc -fpic -shared -W1,-soname,libhello.so.0 -o libhello.so.0.0 hello.o  #生成共享库
$ readelf -h libhello.so.0.0 | grep Type
  Type:                              DYN (Shared object file)

$ readelf -S hello  #可执行文件、可共享库、可重定位文件默认都生成有节区表
...
Section Headers:
  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al
  [ 0]                   NULL            00000000 000000 000000 00      0   0  0
  [ 1] .interp           PROGBITS        08048114 000114 000013 00   A  0   0  1
  [ 2] .note.ABI-tag     NOTE            08048128 000128 000020 00   A  0   0  4
  [ 3] .hash             HASH            08048148 000148 000028 04   A  5   0  4
...
    [ 7] .gnu.version      VERSYM          0804822a 00022a 00000a 02   A  5   0  2
...
  [11] .init             PROGBITS        08048274 000274 000030 00  AX  0   0  4
...
  [13] .text             PROGBITS        080482f0 0002f0 000148 00  AX  0   0 16
  [14] .fini             PROGBITS        08048438 000438 00001c 00  AX  0   0  4
...

$ readelf -l hello.o #对于可重定向文件，gcc没有产生程序头部，因为它对可重定向文件没用

There are no program headers in this file.
$  readelf -l hello  #而可执行文件和可共享文件都有程序头部
...
Program Headers:
  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align
  PHDR           0x000034 0x08048034 0x08048034 0x000e0 0x000e0 R E 0x4
  INTERP         0x000114 0x08048114 0x08048114 0x00013 0x00013 R   0x1
      [Requesting program interpreter: /lib/ld-linux.so.2]
  LOAD           0x000000 0x08048000 0x08048000 0x00470 0x00470 R E 0x1000
  LOAD           0x000470 0x08049470 0x08049470 0x0010c 0x00110 RW  0x1000
  DYNAMIC        0x000484 0x08049484 0x08049484 0x000d0 0x000d0 RW  0x4
  NOTE           0x000128 0x08048128 0x08048128 0x00020 0x00020 R   0x4
  GNU_STACK      0x000000 0x00000000 0x00000000 0x00000 0x00000 RW  0x4

 Section to Segment mapping:
  Segment Sections...
   00    
   01     .interp
   02     .interp .note.ABI-tag .hash .gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rel.dyn .rel.plt .init .plt .text .fini .rodata .eh_frame
   03     .ctors .dtors .jcr .dynamic .got .got.plt .data .bss
   04     .dynamic
   05     .note.ABI-tag
   06    
$  readelf -l libhello.so.0.0  #节区和上面类似，这里省略