C++博客-beautykingdom-随笔分类-Shell

shell从1+到100

chatler — Thu, 28 Oct 2010 03:12:00 GMT

第一种方法：

#!/bin/bash

echo -e "\t${!#}"

for (( i = 0; i < 100; i++ ))

result=$[ ${result} + ${i} ]

done

echo $result

第二种方法：

seq -s"+" 1 100|bc

第三种方法：

s=0

for ((i=1;i<=100;i++)) ; do

s=`expr $s + $i`

done

echo $s

第四种方法：

#!/bin/sh
s=0
for i in `seq 1 100`
do
s=`expr $s + $i`
done
echo $s

第五种方法：

echo {1..100}|sed 's/ /+/g'|bc

from：
http://bbs.chinaunix.net/thread-1777298-1-1.html

chatler 2010-10-28 11:12 发表评论

文本过滤工具GREP

chatler — Tue, 01 Jun 2010 01:48:00 GMT

grep:
传统的 grep 程序, 在没有参数的情况下, 只输出符合 RE 字符串之句子. 常见参数如下:
-v: 逆反模示, 只输出"不含" RE 字符串之句子.
-r: 递归模式, 可同时处理所有层级子目录里的文件.
-q: 静默模式, 不输出任何结果(stderr 除外. 常用以获取 return value, 符合为 true, 否则为 false .)
-i: 忽略大小写.
-w: 整词比对, 类似 \ .
-n: 同时输出行号.
-c: 只输出符合比对的行数.
-l: 只输出符合比对的文件名称.
-o: 只输出符合 RE 的字符串. (gnu 新版独有, 不见得所有版本都支持.)
-E: 切换为 egrep .

* egrep:
为 grep 的扩充版本, 改良了许多传统 grep 不能或不便的操作. 比方说:
- grep 之下不支持 ? 与 + 这两种 modifier, 但 egrep 则可.
- grep 不支持 a|b 或 (abc|xyz) 这类"或一"比对, 但 egrep 则可.
- grep 在处理 {n,m} 时, 需用 \{ 与 \} 处理, 但 egrep 则不需.
诸如此类的... 我个人会建议能用 egrep 就不用 grep 啦... ^_^

* fgrep:
不作 RE 处理, 表达式仅作一般字符串处理, 所有 meta 均失去功能.

单引号双引号
在g r e p命令中输入字符串参数时，最好将其用双引号括起来。
在调用模式匹配时，应使用单引号。

开始讨论之前，先生成一个文件，插入一段文本，并在每列后加入< Ta b >键，g r e p命令示例中绝大多数将以此为例，其命名为d a t a . . f。生成一个文件，d a t a . f的记录结构如下：

QUOTE:

第1列：城市位置编号。
第2列：月份。
第3列：存储代码及出库年份。
第4列：产品代号。
第5列：产品统一标价。
第6列：标识号。
第7列：合格数量。

文件内容如下：

$ cat data.f
48 Dec 3BC1977 LPSX 68.00 LVX2A 138
483 Sept 5AP1996 USP 65.00 LVX2C 189
47 Oct 3ZL1998 LPSX 43.00 KVM9D 512
219 dec 2CC1999 CAD 23.00 PLV2C 68
484 nov 7PL1996 CAD 49.00 PLV2C 234
483 may 5PA1998 USP 37.00 KVM9D 644
216 sept 3ZL1998 USP 86.00 KVM9E 234

1、查询多个文件
在所有文件中查询单词“ sort it”

$ grep "sort it" *

2、行匹配
1)显示包含“4 8”字符串的文本：

$ grep "48"data.f

2)输出匹配行的总数

$ grep -c "48"data.f
4

g r e p返回数字4，表示：包含字符串“4 8”的有4行。

3)行数
显示满足匹配模式的所有行行数：

$ grep -n "48"data.f

行数在输出第一列，后跟包含4 8的每一匹配行。

4)显示非匹配行
显示所有不包含4 8的各行

$ grep -v "48"data.f

5)精确匹配
可能大家已注意到，在上一例中，抽取字符串“ 4 8”，返回结果包含诸如4 8 4和4 8 3等包含“4 8”的其他字符串，实际上应精确抽取只包含4 8的各行。
使用g r e p抽取精确匹配的一种更有效方式是在抽取字符串后加\ >。假定现在精确抽取4 8，方法如下：

$grep "48\>" data.f

QUOTE:

另一种方法我试过，好像不行：
注意在每个匹配模式中抽取字符串后有一个< Ta b >键，所以应操作如下：
< Ta b >表示点击t a b键。
$grep "48" data.f

6)大小写敏感
缺省情况下， g r e p是大小写敏感的，如要查询大小写不敏感字符串，必须使用- i开关。在d a t a . f文件中有月份字符S e p t，既有大写也有小写，要取得此字符串大小写不敏感查询，方法如下：

$grep -i "48" data.f

grep和正则表达式

使用正则表达式使模式匹配加入一些规则，因此可以在抽取信息中加入更多选择。使用正则表达式时最好用单引号括起来，这样可以防止g r e p中使用的专有模式与一些s h e l l命令的特殊方式相混淆。

1、模式范围
抽取代码为4 8 4和4 8 3的城市位置，可以使用[ ]来指定字符串范围。

$ grep "48[34]" data.f
483 Sept 5AP1996 USP 65.00 LVX2C 189
484 nov 7PL1996 CAD 49.00 PLV2C 234
483 may 5PA1998 USP 37.00 KVM9D 644

2、不匹配行首
使行首不是4或8，可以在方括号中使用^记号。

$ grep "^[^48]" data.f
219 dec 2CC1999 CAD 23.00 PLV2C 68
216 sept 3ZL1998 USP 86.00 KVM9E 234

如果是字符串48

$ grep -v "^[^48]" data.f

3、设置大小写
使用- i开关可以屏蔽月份S e p t的大小写敏感

[sam@chenwy sam]$ grep -i "sept" data.f
483 Sept 5AP1996 USP 65.00 LVX2C 189
216 sept 3ZL1998 USP 86.00 KVM9E 234

也可以用另一种方式[ ]模式抽取各行包含S e p t和s e p t的所有信息。

[sam@chenwy sam]$ grep '[sS]ept' data.f

如果要抽取包含S e p t的所有月份，不管其大小写，并且此行包含字符串483，可以使用管道命令，即符号“|”左边命令的输出作为“ |”右边命令的输入。举例如下：

[sam@chenwy sam]$ grep '[sS]ept' data.f | grep 48
483 Sept 5AP1996 USP 65.00 LVX2C 189

不必将文件名放在第二个g r e p命令中，因为其输入信息来自于第一个g r e p命令的输出

4、匹配任意字符
如果抽取以K开头，以D结尾的所有代码，可使用下述方法，因为已知代码长度为5个字符：

[sam@chenwy sam]$ grep 'K...D' data.f
47 Oct 3ZL1998 LPSX 43.00 KVM9D 512
483 may 5PA1998 USP 37.00 KVM9D 644

将上述代码做轻微改变，头两个是大写字母，中间两个任意，并以C结尾：

[sam@chenwy sam]$ grep '[A-Z]..C' data.f
483 Sept 5AP1996 USP 65.00 LVX2C 189
219 dec 2CC1999 CAD 23.00 PLV2C 68
484 nov 7PL1996 CAD 49.00 PLV2C 234

5、日期查询
一个常用的查询模式是日期查询。先查询所有以5开始以1 9 9 6或1 9 9 8结尾的所有记录。使用模式5 . . 1 9 9 [ 6 , 8 ]。这意味着第一个字符为5，后跟两个点，接着是1 9 9，剩余两个数字是6或8。

[sam@chenwy sam]$ grep '5..199[6,8]' data.f
483 Sept 5AP1996 USP 65.00 LVX2C 189
483 may 5PA1998 USP 37.00 KVM9D 644

6、范围组合
必须学会使用[ ]抽取信息。假定要取得城市代码，第一个字符为0-9，第二个字符在0到5之间，第三个字符在0到6之间，使用下列模式即可实现。

[sam@chenwy sam]$ grep '[0-9][0-5[0-6]' data.f
48 Dec 3BC1977 LPSX 68.00 LVX2A 138
483 Sept 5AP1996 USP 65.00 LVX2C 189
47 Oct 3ZL1998 LPSX 43.00 KVM9D 512
219 dec 2CC1999 CAD 23.00 PLV2C 68
484 nov 7PL1996 CAD 49.00 PLV2C 234
483 may 5PA1998 USP 37.00 KVM9D 644
216 sept 3ZL1998 USP 86.00 KVM9E 234

这里返回很多信息，有想要的，也有不想要的。参照模式，返回结果是正确的，因此这里

[sam@chenwy sam]$ grep '^[0-9][0-5][0-6]' data.f
219 dec 2CC1999 CAD 23.00 PLV2C 68
216 sept 3ZL1998 USP 86.00 KVM9E 234

这样可以返回一个预期的正确结果。
以下要注意有无边界字符的区别
7、模式出现机率
抽取包含数字4至少重复出现两次的所有行，方法如下：

[sam@chenwy sam]$ grep '4\{2,\}' data.f
483 may 5PA1998 USP 37.00 KVM9D 644

上述语法指明数字4至少重复出现两次，注意有无边界字符的区别。
同样，抽取记录使之包含数字9 9 9（三个9），方法如下：

[sam@chenwy sam]$ grep '9\{3,\}' data.f
219 dec 2CC1999 CAD 23.00 PLV2C 68

如果要查询重复出现次数一定的所有行，语法如下，数字9重复出现两次或三次：

[sam@chenwy sam]$ grep '9\{3\}' data.f
219 dec 2CC1999 CAD 23.00 PLV2C 68
[sam@chenwy sam]$ grep '9\{2\}' data.f
483 Sept 5AP1996 USP 65.00 LVX2C 189
47 Oct 3ZL1998 LPSX 43.00 KVM9D 512
219 dec 2CC1999 CAD 23.00 PLV2C 68
484 nov 7PL1996 CAD 49.00 PLV2C 234

有时要查询重复出现次数在一定范围内，比如数字或字母重复出现2到6次，下例匹配数字8重复出现2到6次，并以3结尾：

[sam@chenwy sam]$ cat myfile
83
888883
8884
88883
[sam@chenwy sam]$ grep '8\{2,6\}3' myfile
888883
88883

8、使用grep匹配“与”或者“或”模式
g r e p命令加- E参数，这一扩展允许使用扩展模式匹配。例如，要抽取城市代码为2 1 9或2 1 6，方法如下：

[sam@chenwy sam]$ grep -E '219|216' data.f
219 dec 2CC1999 CAD 23.00 PLV2C 68
216 sept 3ZL1998 USP 86.00 KVM9E 234

9、空行
结合使用^和$可查询空行。使用- c参数显示总行数：

[sam@chenwy sam]$ grep -c '^$' myfile

使用- n参数显示实际在哪一行：

[sam@chenwy sam]$ grep -c '^$' myfile

10、匹配特殊字符
查询有特殊含义的字符，诸如$ . ' " * [] ^ | \ + ? ,必须在特定字符前加\。假设要查询包含“.”的所有行，脚本如下：

[sam@chenwy sam]$ grep '\.' myfile

或者是一个双引号：

[sam@chenwy sam]$ grep '\"' myfile

以同样的方式，如要查询文件名c o n f t r o l l . c o n f（这是一个配置文件），脚本如下：

[sam@chenwy sam]$ grep 'conftroll\.conf' myfile

11、查询格式化文件名
使用正则表达式可匹配任意文件名。系统中对文本文件有其标准的命名格式。一般最多六个小写字符，后跟句点，接着是两个大写字符。

[sam@chenwy sam]$ grep '^[a-z]\{1,6\}\.[A-Z]\{1,2\}' filename

这个写法我不知道有没有错 :oops: :oops: :oops:

12 查询IP地址
要查看n n n . n n n网络地址，如果忘了第二部分中的其余部分，只知有两个句点，例如n n n . n n . .。要抽取其中所有nnn.nnn IP地址，使用[ 0 - 9 ] \ { 3 \ } \ . [ 0 - 0 \ { 3 \ } \。含义是任意数字出现3次，后跟句点，接着是任意数字出现3次，后跟句点。

[0-9]\{3\}\.[0-9]\{3\}\.'

shell基础八：文本过滤工具（grep）

1、类名

g r e p允许使用国际字符模式匹配或匹配模式的类名形式。
类名及其等价的正则表达式类等价的正则表达式类等价的正则表达式

QUOTE:

[ [ : u p p e r : ] ] [ A - Z ] [ [ : a l n u m : ] ] [ 0 - 9 a - zA-Z]
[ [ : l o w e r : ] ] [ a - z ] [ [ : s p a c e : ] ] 空格或t a b键
[ [ : d i g i t : ] ] [ 0 - 9 ] [ [ : a l p h a : ] ] [ a - z A - Z ]

例一：取以5开头，后跟至少两个大写字母：

$grep '5[[:upper:]][[:upper]]' data.f

取以P或D结尾的所有产品代码：

grep '[[:upper:]][[:upper:]][P,D]' data.f

2、使用通配符*的匹配模式

$cat testfile
looks
likes
looker
long

试试如下：

grep "l.*s" testfile

如在行尾查询某一单词，试如下模式：

grep "ng$" testfile

这将在所有文件中查询行尾包含单词ng的所有行。

3、系统grep

文件passwd

[root@Linux_chenwy sam]# grep "sam" /etc/passwd
sam:x:506:4::/usr/sam:/bin/bash

上述脚本查询/ e t c / p a s s w d文件是否包含sam字符串

如果误输入以下脚本：

[root@Linux_chenwy sam]# grep "sam" /etc/password
grep: /etc/password: 没有那个文件或目录

将返回g r e p命令错误代码'No such file or directory'。
上述结果表明输入文件名不存在，使用g r e p命令- s开关，可屏蔽错误信息。
返回命令提示符，而没有文件不存在的错误提示。

[root@Linux_chenwy sam]# grep -s "sam" /etc/password

如果g r e p命令不支持- s开关，可替代使用以下命令：

[root@Linux_chenwy sam]# grep "sam" /tec/password >/dev/null 2>&1

脚本含义是匹配命令输出或错误（ 2 > $ 1），并将结果输出到系统池。大多数系统管理员称/ d e v / n u l l为比特池，没关系，可以将之看成一个无底洞，有进没有出，永远也不会填满。

上述两个例子并不算好，因为这里的目的只想知道查询是否成功。

如要保存g r e p命令的查询结果，可将命令输出重定向到一个文件。

[root@Linux_chenwy sam]# grep "sam" /etc/passwd >/usr/sam/passwd.out
[root@Linux_chenwy sam]# cat /usr/sam/passwd.out
sam:x:506:4::/usr/sam:/bin/bash

脚本将输出重定向到目录/ t m p下文件p a s s w d . o u t中。

使用ps命令
使用带有ps x命令的g r e p可查询系统上运行的进程。ps x命令意为显示系统上运行的所有进程列表。要查看D N S服务器是否正在运行（通常称为n a m e d），方法如下：

[root@Linux_chenwy sam]# ps ax|grep "named"
2897 pts/1 S 0:00 grep named

输出也应包含此g r e p命令，因为g r e p命令创建了相应进程， ps x将找到它。在g r e p命令中使用- v选项可丢弃p s命令中的g r e p进程。如果ps x不适用于用户系统，替代使用ps -ef。这里，由于我没有DNS服务，因而只有grep进程。

对一个字符串使用grep
g r e p不只应用于文件，也可应用于字符串。为此使用e c h o字符串命令，然后对g r e p命令使用管道输入。

[root@Linux_chenwy sam]# STR="Mary Joe Peter Pauline"
[root@Linux_chenwy sam]# echo $STR | grep "Mary"
Mary Joe Peter Pauline

匹配成功实现。

[root@Linux_chenwy sam]# echo $STR | grep "Simon"

因为没有匹配字符串，所以没有输出结果。

4、egrep
e g r e p代表e x p r e s s i o n或extended grep，适情况而定。e g r e p接受所有的正则表达式， e g r e p的一个显著特性是可以以一个文件作为保存的字符串，然后将之传给e g r e p作为参数，为此使用- f开关。如果创建一个名为g r e p s t r i n g s的文件，并输入4 8 4和4 7：

[root@Linux_chenwy sam]# vi grepstrings
[root@Linux_chenwy sam]# cat grepstrings
484
47

[root@Linux_chenwy sam]# egrep -f grepstrings data.f
47 Oct 3ZL1998 LPSX 43.00 KVM9D 512
484 nov 7PL1996 CAD 49.00 PLV2C 234

上述脚本匹配d a t a . f中包含4 8 4或4 7的所有记录。当匹配大量模式时， - f开关很有用，而在一个命令行中敲入这些模式显然极为繁琐。

如果要查询存储代码3 2 L或2 C C，可以使用（|）符号，意即“|”符号两边之一或全部。

[root@Linux_chenwy sam]# egrep '(3ZL|2CC)' data.f
47 Oct 3ZL1998 LPSX 43.00 KVM9D 512
219 dec 2CC1999 CAD 23.00 PLV2C 68
216 sept 3ZL1998 USP 86.00 KVM9E 234

可以使用任意多竖线符“ |”，例如要查看在系统中是否有帐号l o u i s e、m a t t y或pauline ，使用w h o命令并管道输出至e g r e p。

$who |egrep (louise|matty|pauline)

还可以使用^符号排除字符串。如果要查看系统上的用户，但不包括m a t t y和p a u l i n e，方法如下：

$who |egrep -v '^(matty|pauline)'

如果要查询一个文件列表，包括s h u t d o w n、s h u t d o w n s、r e b o o t和r e b o o t s，使用e g r e p可容易地实现。

$egrep '(shutdown |reboot) (s)?' *

from：
http://bbs.chinaunix.net/thread-446683-1-1.html

chatler 2010-06-01 09:48 发表评论

史上最强bash函数库

chatler — Mon, 03 May 2010 14:42:00 GMT

## ---------------------------------------------------------
## common functions
## author:   samli AT tencent.com | huanlf AT gmail.com
## usage:    source "./func-common.sh"
## last mod: 2009-07-10
## ---------------------------------------------------------






## ---------------- classical usage ------------------------
## export WORKDIR=$( cd ` dirname $0 ` && pwd )
## 
## if [[ ! -r "$WORKDIR/func-common.sh" ]]; then
##     echo "[$WORKDIR/func-common.sh] NOT FOUND"
##     exit 1
## fi
## 
## . "$WORKDIR/func-common.sh" || exit 1
## 
## cd "$WORKDIR" || exit 1
## ---------------------------------------------------------






## set -x 
## set -e     ## Sorry, can not set -e here, fix later

## -------------------- GLOBAL VAR -------------------------

## some vars initialized in the end of this file, check it

## make sure we will find commands needed
export PATH=/sbin:/usr/sbin:/usr/local/sbin:/usr/local/bin:/usr/bin:/bin:$PATH

## just a var to keep the val from get_localip
## use a strange var name to avoid collision
export LLLOCALIP

## the dir we are working in
export WORKDIR

## some addictional logs may redirected to here
## such as: make >> $LLLOG && make install >> $LLLOG
## use a strange var name to avoid collision
export LLLOG
export LLLOGDIR

## set locale as POSIX, to work around with i180-ed apps
export LANG=C
export LC_ALL=C

## set umask to 022 to avoid wrong access mode
umask 022

## ---------------------------------------------------------






## -------------------- colourful print --------------------

## ANSI Foreground color codes:
## 30=black 31=red 32=green 33=yellow 34=blue 35=magenta 36=cyan 37=white 39=default
## ANSI Background color codes:
## 40=black 41=red 42=green 43=yellow 44=blue 45=magenta 46=cyan 47=white 49=default

COLOR_RED=$(    echo -e "\e[31;49m" ) 
COLOR_GREEN=$(  echo -e "\e[32;49m" )
COLOR_YELLO=$(  echo -e "\e[33;49m" )
COLOR_BLUE=$(   echo -e "\e[34;49m" )
COLOR_MAGENTA=$(echo -e "\e[35;49m" )
COLOR_CYAN=$(   echo -e "\e[36;49m" )
COLOR_RESET=$(  echo -e "\e[0m"     )

## *msg argv: "$str"
msg()  { gmsg "$@";                               }
rmsg() { echo "${COLOR_RED}$*${COLOR_RESET}";     }
gmsg() { echo "${COLOR_GREEN}$*${COLOR_RESET}";   }
ymsg() { echo "${COLOR_YELLO}$*${COLOR_RESET}";   }
bmsg() { echo "${COLOR_BLUE}$*${COLOR_RESET}";    }
mmsg() { echo "${COLOR_MAGENTA}$*${COLOR_RESET}"; }
cmsg() { echo "${COLOR_CYAN}$*${COLOR_RESET}";    }

# colourful print without "\n"
msg_()  {  msg "$@" | tr -d '\n'; }
rmsg_() { rmsg "$@" | tr -d '\n'; }
gmsg_() { gmsg "$@" | tr -d '\n'; }
ymsg_() { ymsg "$@" | tr -d '\n'; }
bmsg_() { bmsg "$@" | tr -d '\n'; }
mmsg_() { mmsg "$@" | tr -d '\n'; }
cmsg_() { cmsg "$@" | tr -d '\n'; }

## normal message print and log
logmsg()
{
    local t=$( date '+%F %T' )

    gmsg "[$t $LLLOCALIP]: $*"

    ## no color in logs
    mkdir -p "$LLLOGDIR" || { rmsg "can not create $LLLOGDIR"; exit 1; }
    echo "[$t $ip]: $*" >> "$LLLOG"
}

## normal message print and log, without "\n"
logmsg_()
{
    local t=$( date '+%F %T' )

    gmsg_ "[$t $LLLOCALIP]: $*"

    ## no color in logs
    mkdir -p "$LLLOGDIR" || { rmsg "can not create $LLLOGDIR"; exit 1; }
    echo -n "[$t $ip]: $*" >> "$LLLOG"
}

## warning
warn()
{
    local t=$( date '+%F %T' )

    ## write to STDERR
    mmsg "[$t $LLLOCALIP]WARNING: $*" >&2

    mkdir -p "$LLLOGDIR" || { rmsg "can not create $LLLOGDIR"; exit 1; }
    echo "[$t $ip]WARNING: $*" >> "$LLLOG"
}

## fatal, will exit with code 1
die()
{
    local t=$( date '+%F %T' )

    ## write to STDERR
    rmsg "[$t $LLLOCALIP]FATAL: $*" >&2

    mkdir -p "$WORKDIR/log.d" || { rmsg "can not create $WORKDIR/log.d"; exit 1; }
    echo "[$t $ip]FATAL: $*" >> "$LLLOG"

    exit 1
}

## ---------------------------------------------------------






## ---------------------- IP / NIC  ------------------------

## get all interfaces ip addr, but default lo
get_ipaddr()
{
    local ipall=$(
        /sbin/ifconfig | 
          awk '/inet addr:/ { if ($2 !~ /127.0.0.1/) { print substr($2,6)} } '
    )

    ipall=$( echo $ipall )  ## trim spaces, blank charachers
    
    if [[ -n $ipall ]]; then
        echo $ipall
    else
        return 1
    fi
}

## get all lan ipaddr. not strict
get_localip_all()
{
    local ip ipall

    for ip in $( get_ipaddr ); do
       case $ip in
           172.*|192.*|10.*)
               ## should deal with the newline symbol '\n' by yourself
               ipall="$ipall $ip"
               ;;
       esac
    done

    ipall=$( echo $ipall )  ## trim spaces, blank charachers

    if [[ -n $ipall ]]; then
        echo $ipall
    else
        return 1
    fi
}

## get login ip from ssh env val, useful if we have mutilple NICs
## this func is not very reliable, use get_localip instead
get_loginip()
{
    local ip

    for ip in $( echo $SSH2_CLIENT    | awk '{ print $3 }' ) \
              $( echo $SSH_CONNECTION | awk '{ print $3 }' ) \
              $( echo $SSH_CLIENT     | awk '{ print $1 }' ) ; do
        if [[ -n $ip ]]; then  ## never failed ?
            echo $ip
            return 0
        fi
    done

    return 1
}

## get a lan ipaddr, must be an private IP, the ip we login is prefered
get_localip()
{
    ## to speed up, this func may be called frequently
    ## maybe we should use $LLLOCALIP directlly instead of callin get_localip
    [[ -n "$LLLOCALIP" ]] && { echo $LLLOCALIP;  return 0; }

    local default_ip=127.0.0.1  ## make sure we return an "IP"
    local ipall=$( get_localip_all )
    local ip

    for ip in $( get_loginip ) $ipall; do
       case $ip in      ## check if a private IP, need more strict checking ?
           172.*|192.*|10.*)
                # make sure we find the ip on local host
                # result from get_login may not correct
                # note that we do not get '127.0.0.1' from get_localip_all
                if echo $ipall | grep -wq $ip; then
                    LLLOCALIP=$ip 
                    break
                fi
            ;;
        esac
    done

    if [[ -n "$LLLOCALIP" ]]; then
        echo $LLLOCALIP
        return 0
    else
        echo $default_ip
        return 1
    fi
}

## return the the ip on the given interface
## argv: $interface
## example: get_ip_for_interface "eth0"
get_ip_for_interface()
{
    local iface=$1

    ## /sbin/ifconfig "$iface" 2>/dev/null |
    /sbin/ifconfig "$iface" |
       awk '/inet addr:/ { print substr($2,6) } '

    # return the status of ifconfig
    return ${PIPESTATUS[0]}
}

## include sub interface's ip
get_all_ip_for_interface()
{
    local iface=$1
    local ipall=$( 
        {   
            ## physical interface
            /sbin/ifconfig | grep -A1 -E "^$iface[[:space:]]+"
            ## sub interface, such as eth0:0
            /sbin/ifconfig | grep -A1 -E "^$iface:[0-9]+[[:space:]]+"
        } |
        awk '/inet addr:/ { print substr($2,6) } '
    )

    ipall=$( echo $ipall )  ## trim spaces, blank charachers

    if [[ -n $ipall ]]; then
        echo $ipall
    else
        return 1
    fi
}


## return the netmask for an interface
## argv: $interface
## example: get_netmask_for_interface "eth0"
get_netmask_for_interface()
{
    local iface=$1
    [[ -n $iface ]] || return 1

    /sbin/ifconfig "$iface" | awk -F: '/Mask:/ { print $NF }'

    ## return the status of ifconfig
    return ${PIPESTATUS[0]}
}

## 2009-01-12, get mtu for an interface
## argv: $interface
## example: get_mtu_for_interface "eth0"
get_mtu_for_interface()
{
    local iface=$1
    ## mtu on the sub ifc is the same with the physical ifc
    ## local iface=${1%%:*}

    /sbin/ifconfig "$iface" | 
      awk '/MTU:/ {
      if ( $3 ~ /RUNNING/ ) {
          print substr($5,5)
      }
      else {
          print substr($4,5)
      }  }'

    ## return the status of ifconfig
    return ${PIPESTATUS[0]}
}

## return the interface name having the "$ip"
## maybe a sub interface or a real physical interface
get_interface_by_ip()
{
    local ip=$1
    local ifc

    ifc=$(
        ## use -a to prevent that the iface is down by ip not cleared
        /sbin/ifconfig -a | grep -B1 -w "$ip" |
        awk ' NR == 1 { print $1 } ' 
    )

    if [[ -n $ifc ]]; then
        echo $ifc
    else
        return 1
    fi
}

## return a real physical interface even if the ip is on a sub interface
get_real_interface_by_ip()
{
    local ip=$1
    local r_ifc

    r_ifc=$( get_interface_by_ip "$ip" | sed 's/:[0-9]\+//' )

    if [[ -n $r_ifc ]]; then
        echo $r_ifc
    else
        return 1
    fi
}

## return the interface with local ip
get_local_iface()
{
    local ip
    local ifcall=$( 
        for ip in $( get_localip_all ); do
            get_interface_by_ip "$ip"
        done
    )

    if [[ -n $ifcall ]]; then
        echo $ifcall
    else
        return 1
    fi
}

## return the interface with wan ip, actually, with not lan ip
get_wan_iface()
{
    local wanall
    ## one interface per line
    get_local_iface | xargs -n1 > /tmp/local.iface
    /sbin/ifconfig | grep -B1 'addr:[0-9]' |
      awk '/^(eth|wlan|ppp)/ { print $1 }' > /tmp/all.iface

    wanall=$( grep -xvf /tmp/local.iface /tmp/all.iface )
    ## /bin/rm "/tmp/local.iface" "/tmp/all.iface"

    if [[ -n $wanall ]]; then
        echo $wanall
    else
        return 1
    fi
}

## return physical iface with local ip
get_real_local_iface()
{
    get_local_iface | xargs -n1 | sed 's/:.*//' | sort -u
}

## return physical iface with wan ip
get_real_wan_iface()
{
    get_wan_iface   | xargs -n1 | sed 's/:.*//' | sort -u
}

## return the interface without a ip configured on it
get_free_iface()
{
    local ifcall=$(
        /sbin/ifconfig -a |
          grep -w 'BROADCAST' -B1 |
          awk '/^[a-z\.]+/ { print $1 }'
    )

    if [[ -n $ifcall ]]; then
        echo $ifcall
    else
        return 1
    fi
}

## if we have eth0, this fun may return eth0:0
## if we have eth:0, may return eth0:1 ....
get_a_free_subname_on()
{
    local iface=$1
    local i=0
    local ip=
    
    while (( i < 100 )); do
        ip=$( get_ip_for_interface "${iface}:$i" )
        if [[ -z $ip ]]; then   ## no ip, so it's free
            echo "${iface}:$i"
            return 0    ## return directly, not use break
        fi
        
        (( i++ ))
    done
        
    return 1
}

## check if we have at least a sub interface, may used on lvs box
## return true / false
has_sub_iface()
{
    /sbin/ifconfig | grep -m1 -Eq '^eth[0-9]+:[0-9]+'
}

## call this fun two times, the increment is the flux
## argv: $interface
get_current_transmit_flux_for()
{
    local dev=$1
    local NETDEV="/proc/net/dev"

    grep -w "$dev" "$NETDEV" | awk -F: '{ print $2; }' | awk '{ print $9; }'

    return ${PIPESTATUS[0]}
}

## try to find default gw, return the most used ip if default gw not found
## this func check gw ip loosely, check following code
get_gateway_ip()
{
    /bin/netstat -nr | perl -lnwe '
        ( $dest, $gw ) = (split)[0,1];
        if ( $dest eq "0.0.0.0" ) {
            $default_gw = $gw;
        }
        else {  
            $rec{ $gw }++; 
        }

        END {
        if ( defined $default_gw ) {
            print $default_gw;
            exit 0;
        }
    
        $max = 0;
        for $g ( keys %rec ) {
            if ( $rec{ $g } > $max ) {
                $max = $rec{ $g };
                $default_gw = $g;
            }
        }
        print "$default_gw";
    }'
}

## this func check DEFAULT gw ip, may return more than one ip !
get_default_gateway_ip_on_interface()
{
    local iface=$1

    /bin/netstat -nr |
    awk -vifc="$iface" '{ if ($1 == "0.0.0.0" && $NF == ifc) { print $2 } }'  
}

## may return more than 1 ip, check it by yourself !
## this func check gwip loosely, check following code
get_gateway_ip_on_interface()
{   
    local ifc=$1

    if [[ -z $ifc ]]; then
        return 1
    fi

    netstat -nr | perl -lne '
        BEGIN{ $ifc = pop @ARGV; }

        next unless /^\d/;

        if (/^0\.0\.0\.0\s+(\d+\.\d+\.\d+\.\d+).*$ifc\s*$/) {
            $found=1;
            print $1;
            exit 0;
        }
        elsif (/^\d+\.\d+\.\d+\.\d+\s+(\d+\.\d+\.\d+\.\d+).*$ifc\s*$/) {
            next if $1 eq "0.0.0.0";
            $gw{$1}++;

            ## print "found [$_]"
        }

        END {
            unless ( $found ) {
                for ( sort keys %gw ) {
                    ## print "$_\t$gw{$_}";
                    print $_;
                }
            }
        }

    ' "$ifc"
}

## check if a host online
## return true / false
is_host_online()
{
    local host=$1
    local try=2

    [[ -n $host ]] || return 1

    ## some old versions of nmap seems more slowly when dest unreachable
    while (( try >= 0 )); do
        if ping -c2 -w2 "$host" 2>/dev/null | grep -q ' [12] received'; then
            return 0
        fi

        (( try-- ))
    done

    return 1
}

## return true / false
is_a_valid_port()
{
    local port=$1
    local p=$( echo $port | tr -d '0-9' )

    ## having non-digit character
    if [[ -n "$p" ]]; then
        return 1
    fi
    
    if (( port >= 1 )) && (( port <= 65535 )); then
        return 0
    else
        return 1
    fi
}

## return true / false
is_an_valid_ip()
{
    local ip=$1

    ## simple checking
    if [[ "$ip" == "0.0.0.0" ]] || [[ "$ip" == "255.255.255.255" ]]; then
        return 1
    fi

    ## not perfect checking ...
    echo "$ip" | grep -qE '^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$'
}

ifdown_an_ip()
{
    local ip=$1
    
    [[ -n $ip ]] || return 1

    local iface=$( get_interface_by_ip "$ip" )
    if [[ -z $iface ]]; then
        return 1    ## no-op
    fi

    ifdown_an_iface "$iface"
}

## dangerous to down a phycal interface, use "force" as argv[2] if you know what you are doing
ifdown_an_iface()
{
    local iface=$1
    local downall=$2

    local ip_cnt

    [[ -n $iface ]] || return 1

    case $iface in
    *:[0-9]*)   ## sub interface, just clear the ip configured
        /sbin/ifconfig "$iface" 0 &> /dev/null || :
        ;;
    *)  ## physical interface, if there is only one ip, down the nic
        ## else just clear the ip configured
        ip_cnt=$( get_all_ip_for_interface "$iface" | xargs -n1 | wc -l )
        if (( ip_cnt > 1 )); then
            if [[ $downall == "force" ]]; then
                /sbin/ifconfig "$iface" 0 down &> /dev/null || :
            else
                /sbin/ifconfig "$iface" 0      &> /dev/null || :
            fi
        ## no mare than 1 ip on it, safe
        else
            /sbin/ifconfig "$iface" 0 down     &> /dev/null || :
        fi
        ;;
    esac

    if [[ -z $( get_ip_for_interface "$iface" ) ]]; then
        return 0
    else
        return 1
    fi
}

use_ip_2ping()
{
    local src_ip=$1
    local dest_ip=$2

    local cnt=3

    while (( cnt >= 0 )); do
        ping -c1 -w1 -I "$src_ip" "$dest_ip" 2>/dev/null | 
         grep -q '[[:blank:]]0% packet loss'

        (( $? == 0 )) && return 0
        (( cnt-- ))
    done

    return 1
}

## ---------------------------------------------------------





## ------------------- dir /path / --------------------------

## get the working dir name, may return the dirname of the script we are running
## actually, we may have to find the workdir first to source this file -_-!
## anyway, var LLLOG needs this
get_workdir()
{
    local d

    ## may be I should check $0 ~ *.sh simplly
    case $- in
        *i*)    ## sourced in an interactive-bash ?
            d=$( pwd )
            ;;
        *)
            d=$( cd `dirname "$0"` && pwd )
            ;;
    esac

    echo "$d"
}

## rename a file or dir to make sure the filename or dirname would be OK to reuse
## if "abc" exits, it will be renamed as "abc.old"
## argv: $pathname
## example: remove_old "/usr/local/apache" && ./configure --prefix=/usr/local/apache
remove_old()
{
    local name="$1"
    local oldname="${name}.old"

    if ! [[ -e "$name" || -L "$name" ]]; then
        return
    fi
    
    ## never rename '/', $1 must be an error argv
    [[ "$name" == "/" ]] && die "you really rename / ?"

    [[ -e "$oldname"  ]] && rm -rf "$oldname"
    [[ -L "$oldname"  ]] && rm -rf "$oldname"

    /bin/mv "$name" "$oldname"
}

## a simple mktemp. some old os have no /bin/mktemp, to create uniq temp file/dir
## the command on slk and suse behaves differently, so re-write it
## argv1: -d / -f
## argv2: $path
## example: mktemp -f /tmp/
mktemp()
{
    local opt=$1        ## file or dir
    local dir=$2        ## base path
    local tmp

    ## make sure we find a uniq file / dir name
    while :; do
        if [[ -n "$dir" ]]; then
            tmp="$dir/$( date +%s ).$$.$RANDOM"
        elif [[ -n "$WORKDIR" ]]; then
            tmp="$WORKDIR/$( date +%s ).$$.$RANDOM"
        else
            tmp="./$$.$RANDOM.$( date +%s )"
        fi

        [[ -e $tmp ]] || break
    done

    if [[ $opt == "-d" ]]; then
        mkdir -p "$tmp" || return 1
    else
        mkdir -p "$( dirname $tmp )" || return 1
        touch "$tmp"    || return 1
    fi

    echo $tmp
}

## essential files/dirs must be there
## argv: $pathname
## example: must_exist "$WORKDIR/mysql.tar.bz"
must_exist()
{
    local t
    local flag=0

    for t; do
        if [[ -e "$t" ]]; then
            logmsg "[$t] FOUND, OK"
        else
            flag=1
            warn "[$t] NOT FOUND, NOTOK"
        fi
    done

    (( flag != 0 )) && die "FILES NOT FOUND, ABORTING ..."
}

## try to find the mountpoint for a pathname
get_mountpoint_for_pathname()
{
    local path=$1
    
    [[ -n $path ]] || return 1
    [[ -e $path ]] || return 1

    df "$path" 2>/dev/null | awk 'NR == 2 { print $NF }'
}

## try to find the mountpoint for a pathname
get_devname_for_mountpoint()
{
    local path=$1

    [[ -n $path ]] || return 1
    [[ -d $path ]] || return 1

    df "$path" 2>/dev/null | awk 'NR == 2 { print $1 }'
}

## ---------------------------------------------------------






## --------------------- OS / HW info ----------------------

## check if running on SUSE OS
## return true / false
check_suseos()
{
    if [[ -f "/etc/SuSE-release" ]]; then
        grep -wqF 'SUSE' /etc/SuSE-release && return 0
    fi

    [[ -x /sbin/yast2 ]]  && return 0 || :
    
    return 1
}

## check if running on Slackware OS
## return true / false
check_slkos()
{
    if [[ -f "/etc/slackware-version" ]]; then
        grep -wqF 'Slackware' /etc/slackware-version &>/dev/null && return 0
    fi

    [[ -x /sbin/installpkg ]]  && return 0 || :

    return 1
}

## check if running on RedHat OS
## return true / false
check_rhos()
{
    if [[ -f /etc/redhat-release ]]; then
        grep -wqi red /etc/redhat-release &>/dev/null && return 0
    fi

    return 1
}

## print OS info, now just os version 
get_osinfo()
{
    ## use xargs to delete '\n', I love xargs!
    if check_suseos; then
        xargs < /etc/SuSE-release
    elif check_slkos; then
        xargs < /etc/slackware-version
    elif check_rhos; then
        xargs < /etc/redhat-release
    else
        ## lsb_release may be found on ubuntu, debian, etc.
        lsb_release -d 2>/dev/null || echo 'UNKNOWD OS'
    fi
}

## print OS name
get_osname()
{
    if check_suseos; then
        echo SUSE
    elif check_slkos; then
        echo SLK
    elif check_rhos; then
        echo RH
    else
        echo UNKNOWN
        return 1
    fi
}

## with bit flag
get_osname2()
{
    echo $( get_osver )_$( get_cputype )
}

## return 32/64, based on OS but not hardware
get_cputype()
{
    if uname -a | grep -Fq 'x86_64'; then
        echo 64
    else
        echo 32
    fi
}

get_osver()
{
    if grep -Eq 'Slackware[[:blank:]]+8\.[0-9]'  /etc/slackware-version; then
        echo slk8
    elif grep -Eq 'Slackware[[:blank:]]+10\.[0-9]'  /etc/slackware-version; then
        echo slk10
    elif check_suseos; then
        echo "suse$( get_cputype )"
    elif check_rhos; then
        echo "rh$( get_cputype   )"
    else
        echo "UNKNOWN"
    fi 2>/dev/null
}

## return kernel version: 2.4 / 2.6
get_kernver()
{
    /sbin/kernelversion 2>/dev/null ||
        uname -r | grep -o '^2\..'
}

## get free capacity of a partition by a filename/pathname
get_free_cap()
{
    local path=$1

    if [[ ! -e "$path" ]]; then
        echo 0B
        return
    fi

    ## df so cool!
    df -h "$path" | awk 'NR==2 { print $4 }'
}


## get the size of files by du
## example: get_file_size "/var/log"
get_file_size()
{
    ## do not quote [$file], may contain more than one filename
    local file=$1
    local size=$( du -sh $file 2>/dev/null | awk '{ print $1; exit }' || echo 0B )

    echo ${size: -1} | grep -q '^[0-9]$' && size=${size}B
    echo ${size:-0B}
}

## get the size of physical mem
get_mem_size()
{
    local unit=$1
    local resut dividend

    case $unit in 
    k|K)
        dividend=1
        ;;
    m|M)
        dividend=1000
        ;;
    g|G)
        dividend=1000000
        ;;
    t|T)
        dividend=1000000000
        ;;
    *)
        dividend=1  ## default, K
        ;;
    esac

    resut=$( awk '/^MemTotal/ { print $2 }' /proc/meminfo )
    calculate2 "$resut / $dividend"
}

## get the size of all hard disks
get_hdd_size()
{
    local unit=$1
    local resut dividend

    case $unit in 
    k|K)
        dividend=1
        ;;
    m|M)
        dividend=1000
        ;;
    g|G)
        dividend=1000000
        ;;
    t|T)
        dividend=1000000000
        ;;
    *)
        dividend=1  ## default, K
        ;;
    esac

    ## check /proc/partitions, fdisk -l not reliable
    resut=$( 
        awk 'BEGIN{ total = 0 }
        {
            if ( $1 !~ /^[[:space:]]*[0-9]+/ ) {
                next
            }
        
            if ( $NF ~ /cciss\/c[0-9]d[0-9][[:space:]]*$/ || $NF ~ /[sh]d[a-z][[:space:]]*$/ ) {
                total += $3
            }
        }
        END { printf("%d", total) }' /proc/partitions
    )

    calculate2 "$resut / $dividend"
}

## get cpu name: intel/amd x $core_num
get_cpu_name()
{
    awk 'BEGIN{ num = 0; name = "unknow"; FS = ":" }
    {
        if ( $1 !~ /^model name/ ) {
            next
        }
        if ( $0 ~ /[Ii]ntel/ ) {
            name = "Intel"
        }
        else if ( $0 ~ /AMD/ ) {
            name = "Amd"
        }
        else {
            name = 'unknow'
        }
        num++
    }
    END { print name"x"num }' /proc/cpuinfo
}

## get cpu cache sizes
get_cpu_cachesize()
{
    awk 'BEGIN{ num = 0; size = 0; FS = ":"; }
    {
        if ( $1 ~ /^cache size/ ) {
            num++
            size = $2 + 0
        }
    }
    END { print size"Kx"num }' /proc/cpuinfo
}

## 2009-01-14 samli, check if a partition readonly
## argv: $mountpoint / $pathname
## return true / false
is_partition_readonly()
{
    local p=$1
    local mountpoint
    local rw_flag
    
    mountpoint=$( get_mountpoint_for_pathname "$p" )

    ## rw_flag: ro / rw
    rw_flag=$(
      awk -vp=$mountpoint '
      {
          if ( $1 != "/dev/root" && $2 == p ) {
              str=$4
              gsub(",.*", "", str)
              print str
              exit
          }
      }' /proc/mounts )
      
      if [[ $rw_flag == "ro" ]]; then
          return 0
      else
          return 1
      fi
}

## 2009-01-14 samli, check if a partition no space left
## argv: $mountpoint / $pathname
## return true / false
is_partition_full()
{
    local p=$1
    local full_flag

    case $p in
    /*)
        ;;
    *)
        return 1
        ;;
    esac
    
    ## check inode and data area
    full_flag=$( 
      { df -Pi "$p"; df -Pk "$p"; } |
       awk '! /^Filesystem/ {
         usage = $(NF-1) + 0
         if ( usage == 100 ) {
           print "Y"
           exit
         }
       }'
     )

    if [[ $full_flag == "Y" ]]; then
	    return 0
    else
	    return 1
    fi
}  

## find the username we added manually
## see man shadow to find the detail of the policy
find_non_sys_user()
{

    # need root privilege to access '/etc/shadow'
    (( UID == 0 )) || return 1

    perl -we '
    use strict;
    my @users;
    my $fd;
    my ( $user, $pass, $uid );
    
    ## find the username having password
    open ($fd, "<", "/etc/shadow") or die "Can not open /etc/shadow\n";
    while (<$fd>) {
        ($user, $pass ) = (split ":")[0,1];
        next if $user eq "root";
    
        if ( $pass =~ m{ [a-zA-Z0-9/\$] }x ) {
            push @users, $user;
        }            
        elsif ( $pass eq "" ) {
            push @users, $user;
        }
    }
    close $fd or die "Can not close $fd\n";

    ## find the username having uid >= normal uid
    open ($fd, "<", "/etc/passwd") or die "Can not open /etc/passwd\n";
    while (<$fd>) {
        ($user, $uid ) = (split ":")[0,2];
        next if $user eq "root";
        next if $user eq "nobody";
    
        if ( $uid >= 1000 ) { ## should  read this val from /etc/login.defs
            push @users, $user unless grep { /\b$user\b/ }  @users;
        }
        elsif ( $uid == 0 ) { ## make sure dangerous user with uid = 0
            push @users, $user unless grep { /\b$user\b/ }  @users;
        }
    }
    close $fd or die "Can not close $fd\n";

    for my $u (sort @users) {
        print "$u", " ";
    }
    '
}

## ---------------------------------------------------------






## ------------------------ KERNELL ------------------------
## check if kernel supports iptables
## return true / false
kernel_support_iptables()
{
    iptables -L -n &> /dev/null
}

## check if kernel supports ip conntrack
## return true / false
kernel_support_state()
{
    ## [[ -f /proc/sys/net/ipv4/ip_conntrack_max ]]
    [[ -f /proc/net/ip_conntrack ]]
}

## check if kernel supports lvs-rs by checking tunl interface 
## return true / false
kernel_support_rs()
{
    /sbin/ifconfig tunl0 &> /dev/null
}

## check if kernel supports lvs-ld
## return true / false
kernel_support_ld()
{
    kernel_support_rs        || return 1
    [[ -f /proc/net/ip_vs ]] || return 1

    return 0
}

## 2009-03-25, get the label name of stateful kernel from lilo.conf
#+ but do not change 2.4->2.6 or 2.6->2.4 unthinkingly, nic name may change after reboot
## argv: 2.4 / 2.6
get_state_label_for_slk()
{
    ver=$1

    case $ver in
        2.4)    ##
            grep -m1 -E 'vmlinuz-2\.4.*STATE' /etc/lilo.conf -A4 |
              awk -F= '/label/{ print $2 }'                      |
              trim
            ;;
        2.6)
            grep -m1 -E 'vmlinuz-2\.6.*STATE' /etc/lilo.conf -A4 |
              awk -F= '/label/{ print $2 }'                      |
              trim
            ;;
        *)
            return 1
            ;;
    esac
}

## ---------------------------------------------------------






## ------------------------ tarball ------------------------

## get tarball dirname,  /1/2/3/abc.tar.bz -> abc
## argv: $path_to_tarballname
## return dirname
get_tarball_dirname()
{
    local tb="$1"
    case $tb in
        *.tar.bz2|*.tar.gz)
            echo $tb | sed -e 's@.*/@@g' -e 's@\.tar\.\(bz2\|gz\)$@@'
            ;;
        *.tgz|*.tbz)
            echo $tb | sed -e 's@.*/@@g' -e 's@\.\(tbz\|tgz\)$@@'
            ;;
        *.tar)
            echo $tb | sed -e 's@.*/@@g' -e 's@\.tar$@@'
            ;;
        *)
            echo $tb
            return 1
            ;;
    esac
}

## argv: $path_to_tarballname
## return bzip2 / gzip / tar
get_tarball_type()
{
    if file   "$1" | grep -Fq 'bzip2 compressed data'; then
        echo bzip2 
    elif file "$1" | grep -Fq 'gzip compressed data'; then
        echo gzip
    elif file "$1" | grep -Fq "POSIX tar archive"; then
        echo tar
    else
        return 1
    fi
}

## ---------------------------------------------------------






## --------------------------- NUM -------------------------

## a simple int calculater
## argv: "$math_expression"
## example: calculate "10 / 2"
calculate()
{
    local expr=$@

    if which bc &>/dev/null; then
        echo "scale = 0; $expr" | bc
    elif which perl &>/dev/null; then
        echo "$expr" | perl -lne ' print int (eval) '
    else
        echo $(( $expr ))
    fi
}

## support float
calculate2()
{
    local expr=$@

    if which bc &>/dev/null; then
        echo "scale = 2; $expr" | bc
    elif which perl &>/dev/null; then
        echo "$expr" | perl -lne ' printf ("%0.2f",  (eval) ) '
    else    ## may try awk here
        return 1
    fi
}
## check if argv1 >= argv2
## argv1: $num_1
## argv2: $num_2
compare_two_num()
{
    if (( $# != 2 )); then
        return 1
    fi

    ## hope perl is install in every OS ...
    perl -we ' my ($v1, $v2) = @ARGV; exit ( $v1 >= $v2 ? 0 : 1 ) ' $1 $2
}

## get a random num
## argv: $max, optionall
get_a_random_num()
{
    local max=$1
    local rand=0

    if [[ -z $max ]]; then
        echo $(( RANDOM + 1 ))   ## 1 ~ 32768, see man bash
    else
        # echo $RANDOM$RANDOM % $1 | perl -lne ' print eval '
        while (( rand == 0 )); do
            ## 3276732767 < ( 2^32 = 4294967296 )
            rand=$( calculate "( $RANDOM$RANDOM + $RANDOM + $RANDOM ) % $max" )
        done
        echo $rand
    fi
}

## get ntp time offset
## sorry to hear that ntpdate is deprecated in opensuse 11.1
get_ntp_offset()
{
    local NTP_SERVER="pool.ntp.org"
    local offset

    ## to speed up, just query one server every time
    ## so , the ntp server must be reliable
    for srv in $NTP_SERVER; do
        offset=$( 
            /usr/sbin/ntpdate -q $NTP_SERVER 2> /dev/null  |
            awk '/time server.*sec$/ { print $( NF -1 ) }' |
            sed 's/-//' ## get abs val
        )

        if [[ -n $offset ]]; then
            echo $offset
            return 0
        fi
    done

    return 1
}

## ---------------------------------------------------------






## ------------------------- MISC --------------------------

dump_cron()
{
    local user=$1

    local user_flag

    if [[ -n $user ]]; then
        if (( UID != 0 )); then
            return 1
        fi

        user_flag="-u $user"
    fi

    crontab $user_flag -l | 
     perl -lne ' print if ( ( $. > 3 ) || ( $. <= 3 && /^[^#] /) ) ' 
}

## add a cron jobs line to crontab, with 'force' arg to add a comment line
## example: add_cron "### sync clock every hour" "force"
## example: add_cron "30 * * * * /usr/sbin/ntpdate 172.23.32.142 &> /dev/null"
## example: add_cron "30 * * * * /usr/sbin/ntpdate 172.23.32.142 &> /dev/null" "mqq"
add_cron()
{
    local cmd=$1
    local force=$2
    local user=$3
    local key
    local is_comment

    local user_flag

    if [[ -n $user ]]; then
        if (( UID != 0 )); then
            return 1
        fi

        user_flag="-u $user"
    fi

    # good to use absolute path in crontab
    local c
    for c in $cmd; do
        case $c in
            /*)
                ## key=$( basename $c )
                key=$c
                break
                ;;
        esac
    done

    if ! [[ $force == "force" || $force == "FORCE" ]]; then
        if [[ -z "$key" ]]; then
            warn "failed, [$cmd] not use abs_path to command"
            return 1
        fi

        if [[ ! -x "$c" ]]; then
            warn "failed, [$c] not executable"
            return 1
        fi

        if crontab $user_flag -l | grep -F -v '#' | grep -Fqw -- "$key"; then
            warn "failed, keyword [$key] found in crontab already"
            return 1
        fi
    fi

    if echo "$cmd" | grep -Eq '^[[:blank:]]+#'; then
        is_comment=yes
    fi

    # update crontab
    # crontab $user_flag -l | perl -lne ' print if ( ( $. > 3 ) || ( $. <= 3 && /^[^#] /) ) ' |
    dump_cron "$user" |
    {   
      cat 
      [[ $is_comment == "yes" ]] || echo "## DO NOT DELETE! [ $key ] added by AMC at $(date '+%F %T')"
      echo  "$cmd"
    } | crontab - $user_flag
}    

comment_cron()
{
    local key=$1
    local user=$2

    local user_flag

    [[ -n $key ]] || return 1

    if [[ -n $user ]]; then
        if (( UID != 0 )); then
            return 1
        fi

        user_flag="-u $user"
    fi

    # crontab $user_flag -l | perl -lne ' print if ( ( $. > 3 ) || ( $. <= 3 && /^[^#] /) ) ' |
    dump_cron "$user" |
     sed "/$key/ s/^/## /" | crontab - $user_flag
}

del_cron()
{
    local key=$1
    local user=$2

    local user_flag

    [[ -n $key ]] || return 1

    if [[ -n $user ]]; then
        if (( UID != 0 )); then
            return 1
        fi

        user_flag="-u $user"
    fi

    ## nonsense 3 lines header
    # crontab $user_flag -l | perl -lne ' print if ( ( $. > 3 ) || ( $. <= 3 && /^[^#] /) ) ' |
    dump_cron "$user" |
     grep -v -- "$key" | crontab - $user_flag
}

## trim leading space and tailing space
## example: iptables -nvL | trim
## example: trim < file
trim()
{
    sed -e 's/^[[:space:]]\+//' -e 's/[[:space:]]\+$//'
}

## check if a string already in a file which is not commented
## argv1: $str
## argv2: $filename
## return true / false
is_str_infile()
{
    local str="$1"
    local file="$2"

    grep -Fv '#' "$file" | grep -Fwq -- "$str"
}

## kill a process if it's running
## argv: $app_name
try_kill_proc()
{
    local proc="$1"

    if killall -0 "$proc" &>/dev/null; then
        if killall -9 "$proc"; then
            logmsg "found old "$proc" running, kill OK"
        else
            die "found old "$proc" running, kill FAILED"
        fi
    fi
}

## to grep multipul times, supposed to be used after a pipe or with read redirection
## example: ps -ef | mgrep samli ssh
mgrep()
{
    local key="$1"
    local opt=

    if [[ -z "$key" ]]; then
        cat     
        return  
    fi

    while [[ ${key:0:1} == '-' ]]; do
        opt="$opt $key"
        shift
        key="$1"
    done

    shift   
    grep $opt $key | mgrep "$@"
}


## thanks kangkang 
dectobin()
{
    local s=$1
    local n 

    while (( $s != 0 )); do
        n=$(( s % 2 ))$n
        s=$(( s / 2 ))
    done    

    echo $n 
}

## thanks kangkang 
cidr_mask()
{
    local i
    local mask=$1
    local out

    for i in $( echo $mask | tr '.' ' ' ); do
        out=$out$(dectobin $i)
    done
    
    out=$(echo $out | sed 's/0*$//g' )

    if echo $out | grep -q 0; then
        return 1
    fi

    echo -n $out | wc -c
}

## xor op, usring P$1" 
## argv[1]: key to xor with
## argv[2]: str to xor
myxor()
{
    local key=$1
    local str=$2

    perl -lwe ' 
        my $key = shift;
        $_ = shift;
        my @new;
        for my $s ( split( "" ) ) {
            push @new, chr( (ord $s) ^ $key );
        }
        print join "", @new;
    ' "$key" "$str"
}

## get_name_of_pid()
## {
##     local pid=$1
## 
##     /bin/ls -l "/proc/$pid/exe" 2>/dev/null
## }

is_dos_file()
{
    local file=$1

    file "$file" | grep -q 'with CRLF line terminators'
}

## dos2unix is lost on some servers -_-!
my_dos2unix()
{
    local file=$1

    if which dos2unix ; then
        dos2unix "$file"
    else
        perl -pi -e 's/\r$//' "$file"
    fi &> /dev/null
}

dos2unix_if_necessary()
{
    local file=$1

    [[ -f $file ]] || return 1

    if is_dos_file "$file"; then
        my_dos2unix "$file"
    else
        return 0
    fi
}

## find the java dirname without unpacking jdk*.bin
## we may return [jdk1.5.0_06] for [jdk-1_5_0_06-linux-i586.bin]
get_javadir_from_javabin()
{
    javabin=$1  ## such as [jdk-1_5_0_06-linux-i586.bin]

    if [[ -z $javabin ]] || [[ ! -f $javabin ]]; then
        return 1
    fi

    grep -m1 -a '^javahome=jdk.*' "$javabin" |
      awk -F= '{ print $2 }'
}

## ---------------------------------------------------------




## ----------------------- PROCESS -------------------------

## check if a given pid/appname running
## argv: pid / appname
is_app_running()
{
    local $p=$1
    local RC

    [[ -n $p ]] || return 1
    
    ## pid
    if [[ -z $( echo $p | tr -d '[0-9]') ]]; then
        kill -0 "$p" &> /dev/null
        RC=$?
    ## app name
    else
        killall -0 "$p" &> /dev/null
        RC=$?
    fi

    return $RC
}

lock_on()
{
    local f=$1
    local freefd=6  ## do not use fd 5

    ## make sure the file be there
    mkdir -p "$( dirname $f )"
    touch "$f"

    ## find a free fd
    while (( freefd <= 9 )); do
        [[ -L /dev/fd/$freefd ]] || break
        (( freefd++ ))
    done

    (( freefd == 10 )) && return 1

    ## open the lock file
    eval "exec $freefd< \"$f\""
}

is_locked()
{
    local f=$1

    fuser "$f" &> /dev/null
}

## -------------------- init global vars -------------------

## init LLLOCALIP, do not delete following line, logmsg/warn/die use this val
LLLOCALIP=$( get_localip )

## init WORKDIR
[[ -n $WORKDIR ]]  || WORKDIR=$( get_workdir )

## init LLLOG, LLLOGDIR 
## this val must be used after the logdir created in func logmsg/logmsg_/warn/die
[[ -n $LLLOG    ]] || LLLOG="$WORKDIR/log.d/log.$LLLOCALIP"
[[ -n $LLLOGDIR ]] || LLLOGDIR=${LLLOG%/*}

## ---------------------------------------------------------

from:
http://bbs.linuxeden.com/thread-192227-1-1.html
http://huan.googlecode.com/svn/bash/func-common.sh

chatler 2010-05-03 22:42 发表评论

想挂掉就运行的shell脚本，最好不要去试哈

chatler — Fri, 26 Mar 2010 09:24:00 GMT

:() { :|:& }; :
# <--- 這個別亂跑！好奇會死人的！

echo '十人|日一|十十o' | sed 's/.../&\n/g'
# <--- 跟你講就不聽，再跑這個好了...

chatler 2010-03-26 17:24 发表评论

shell版俄罗斯方块

chatler — Fri, 26 Mar 2010 03:51:00 GMT

#!/bin/bash

# Tetris Game
# 10.21.2003 xhchen<[email]xhchen@winbond.com.tw[/email]>

#APP declaration
APP_NAME="${0##*[\\/]}"
APP_VERSION="1.0"

#颜色定义
cRed=1
cGreen=2
cYellow=3
cBlue=4
cFuchsia=5
cCyan=6
cWhite=7
colorTable=($cRed $cGreen $cYellow $cBlue $cFuchsia $cCyan $cWhite)

#位置和大小
iLeft=3
iTop=2
((iTrayLeft = iLeft + 2))
((iTrayTop = iTop + 1))
((iTrayWidth = 10))
((iTrayHeight = 15))

#颜色设置
cBorder=$cGreen
cScore=$cFuchsia
cScoreValue=$cCyan

#控制信号
#改游戏使用两个进程，一个用于接收输入，一个用于游戏流程和显示界面;
#当前者接收到上下左右等按键时，通过向后者发送signal的方式通知后者。
sigRotate=25
sigLeft=26
sigRight=27
sigDown=28
sigAllDown=29
sigExit=30

#七中不同的方块的定义
#通过旋转，每种方块的显示的样式可能有几种
box0=(0 0 0 1 1 0 1 1)
box1=(0 2 1 2 2 2 3 2 1 0 1 1 1 2 1 3)
box2=(0 0 0 1 1 1 1 2 0 1 1 0 1 1 2 0)
box3=(0 1 0 2 1 0 1 1 0 0 1 0 1 1 2 1)
box4=(0 1 0 2 1 1 2 1 1 0 1 1 1 2 2 2 0 1 1 1 2 0 2 1 0 0 1 0 1 1 1 2)
box5=(0 1 1 1 2 1 2 2 1 0 1 1 1 2 2 0 0 0 0 1 1 1 2 1 0 2 1 0 1 1 1 2)
box6=(0 1 1 1 1 2 2 1 1 0 1 1 1 2 2 1 0 1 1 0 1 1 2 1 0 1 1 0 1 1 1 2)
#所有其中方块的定义都放到box变量中
box=(${box0[@]} ${box1[@]} ${box2[@]} ${box3[@]} ${box4[@]} ${box5[@]} ${box6[@]})
#各种方块旋转后可能的样式数目
countBox=(1 2 2 2 4 4 4)
#各种方块再box数组中的偏移
offsetBox=(0 1 3 5 7 11 15)

#每提高一个速度级需要积累的分数
iScoreEachLevel=50        #be greater than 7

#运行时数据
sig=0                #接收到的signal
iScore=0        #总分
iLevel=0        #速度级
boxNew=()        #新下落的方块的位置定义
cBoxNew=0        #新下落的方块的颜色
iBoxNewType=0        #新下落的方块的种类
iBoxNewRotate=0        #新下落的方块的旋转角度
boxCur=()        #当前方块的位置定义
cBoxCur=0        #当前方块的颜色
iBoxCurType=0        #当前方块的种类
iBoxCurRotate=0        #当前方块的旋转角度
boxCurX=-1        #当前方块的x坐标位置
boxCurY=-1        #当前方块的y坐标位置
iMap=()                #背景方块图表

#初始化所有背景方块为-1, 表示没有方块
for ((i = 0; i < iTrayHeight * iTrayWidth; i++)); do iMap[$i]=-1; done

#接收输入的进程的主函数
function RunAsKeyReceiver()
{
        local pidDisplayer key aKey sig cESC sTTY

        pidDisplayer=$1
        aKey=(0 0 0)

        cESC=`echo -ne "\033"`
        cSpace=`echo -ne "\040"`

        #保存终端属性。在read -s读取终端键时，终端的属性会被暂时改变。
        #如果在read -s时程序被不幸杀掉，可能会导致终端混乱，
        #需要在程序退出时恢复终端属性。
        sTTY=`stty -g`

        #捕捉退出信号
        trap "MyExit;" INT TERM
        trap "MyExitNoSub;" $sigExit

        #隐藏光标
        echo -ne "\033[?25l"

        while :
        do
                #读取输入。注-s不回显，-n读到一个字符立即返回
                read -s -n 1 key

                aKey[0]=${aKey[1]}
                aKey[1]=${aKey[2]}
                aKey[2]=$key
                sig=0

                #判断输入了何种键
                if [[ $key == $cESC && ${aKey[1]} == $cESC ]]
                then
                        #ESC键
                        MyExit
                elif [[ ${aKey[0]} == $cESC && ${aKey[1]} == "[" ]]
                then
                        if [[ $key == "A" ]]; then sig=$sigRotate        #<向上键>
                        elif [[ $key == "B" ]]; then sig=$sigDown        #<向下键>
                        elif [[ $key == "D" ]]; then sig=$sigLeft        #<向左键>
                        elif [[ $key == "C" ]]; then sig=$sigRight        #<向右键>
                        fi
                elif [[ $key == "W" || $key == "w" ]]; then sig=$sigRotate        #W, w
                elif [[ $key == "S" || $key == "s" ]]; then sig=$sigDown        #S, s
                elif [[ $key == "A" || $key == "a" ]]; then sig=$sigLeft        #A, a
                elif [[ $key == "D" || $key == "d" ]]; then sig=$sigRight        #D, d
                elif [[ "[$key]" == "[]" ]]; then sig=$sigAllDown        #空格键
                elif [[ $key == "Q" || $key == "q" ]]                        #Q, q
                then
                        MyExit
                fi

                if [[ $sig != 0 ]]
                then
                        #向另一进程发送消息
                        kill -$sig $pidDisplayer
                fi
        done
}

#退出前的恢复
function MyExitNoSub()
{
        local y

        #恢复终端属性
        stty $sTTY
        ((y = iTop + iTrayHeight + 4))

        #显示光标
        echo -e "\033[?25h\033[${y};0H"
        exit
}

function MyExit()
{
        #通知显示进程需要退出
        kill -$sigExit $pidDisplayer

        MyExitNoSub
}

#处理显示和游戏流程的主函数
function RunAsDisplayer()
{
        local sigThis
        InitDraw

        #挂载各种信号的处理函数
        trap "sig=$sigRotate;" $sigRotate
        trap "sig=$sigLeft;" $sigLeft
        trap "sig=$sigRight;" $sigRight
        trap "sig=$sigDown;" $sigDown
        trap "sig=$sigAllDown;" $sigAllDown
        trap "ShowExit;" $sigExit

        while :
        do
                #根据当前的速度级iLevel不同，设定相应的循环的次数
                for ((i = 0; i < 21 - iLevel; i++))
                do
                        sleep 0.02
                        sigThis=$sig
                        sig=0

                        #根据sig变量判断是否接受到相应的信号
                        if ((sigThis == sigRotate)); then BoxRotate;        #旋转
                        elif ((sigThis == sigLeft)); then BoxLeft;        #左移一列
                        elif ((sigThis == sigRight)); then BoxRight;        #右移一列
                        elif ((sigThis == sigDown)); then BoxDown;        #下落一行
                        elif ((sigThis == sigAllDown)); then BoxAllDown;        #下落到底
                        fi
                done
                #kill -$sigDown $$
                BoxDown        #下落一行
        done
}

#BoxMove(y, x), 测试是否可以把移动中的方块移到(x, y)的位置, 返回0则可以, 1不可以
function BoxMove()
{
        local j i x y xTest yTest
        yTest=$1
        xTest=$2
        for ((j = 0; j < 8; j += 2))
        do
                ((i = j + 1))
                ((y = ${boxCur[$j]} + yTest))
                ((x = ${boxCur[$i]} + xTest))
                if (( y < 0 || y >= iTrayHeight || x < 0 || x >= iTrayWidth))
                then
                        #撞到墙壁了
                        return 1
                fi
                if ((${iMap[y * iTrayWidth + x]} != -1 ))
                then
                        #撞到其他已经存在的方块了
                        return 1
                fi
        done
        return 0;
}

#将当前移动中的方块放到背景方块中去,
#并计算新的分数和速度级。(即一次方块落到底部)
function Box2Map()
{
        local j i x y xp yp line

        #将当前移动中的方块放到背景方块中去
        for ((j = 0; j < 8; j += 2))
        do
                ((i = j + 1))
                ((y = ${boxCur[$j]} + boxCurY))
                ((x = ${boxCur[$i]} + boxCurX))
                ((i = y * iTrayWidth + x))
                iMap[$i]=$cBoxCur
        done

        #消去可被消去的行
        line=0
        for ((j = 0; j < iTrayWidth * iTrayHeight; j += iTrayWidth))
        do
                for ((i = j + iTrayWidth - 1; i >= j; i--))
                do
                        if ((${iMap[$i]} == -1)); then break; fi
                done
                if ((i >= j)); then continue; fi

                ((line++))
                for ((i = j - 1; i >= 0; i--))
                do
                        ((x = i + iTrayWidth))
                        iMap[$x]=${iMap[$i]}
                done
                for ((i = 0; i < iTrayWidth; i++))
                do
                        iMap[$i]=-1
                done
        done

        if ((line == 0)); then return; fi

        #根据消去的行数line计算分数和速度级
        ((x = iLeft + iTrayWidth * 2 + 7))
        ((y = iTop + 11))
        ((iScore += line * 2 - 1))
        #显示新的分数
        echo -ne "\033[1m\033[3${cScoreValue}m\033[${y};${x}H${iScore}         "
        if ((iScore % iScoreEachLevel < line * 2 - 1))
        then
                if ((iLevel < 20))
                then
                        ((iLevel++))
                        ((y = iTop + 14))
                        #显示新的速度级
                        echo -ne "\033[3${cScoreValue}m\033[${y};${x}H${iLevel}        "
                fi
        fi
        echo -ne "\033[0m"

        #重新显示背景方块
        for ((y = 0; y < iTrayHeight; y++))
        do
                ((yp = y + iTrayTop + 1))
                ((xp = iTrayLeft + 1))
                ((i = y * iTrayWidth))
                echo -ne "\033[${yp};${xp}H"
                for ((x = 0; x < iTrayWidth; x++))
                do
                        ((j = i + x))
                        if ((${iMap[$j]} == -1))
                        then
                                echo -ne " "
                        else
                                echo -ne "\033[1m\033[7m\033[3${iMap[$j]}m\033[4${iMap[$j]}m[]\033[0m"
                        fi
                done
        done
}

#下落一行
function BoxDown()
{
        local y s
        ((y = boxCurY + 1))        #新的y坐标
        if BoxMove $y $boxCurX        #测试是否可以下落一行
        then
                s="`DrawCurBox 0`"        #将旧的方块抹去
                ((boxCurY = y))
                s="$s`DrawCurBox 1`"        #显示新的下落后方块
                echo -ne $s
        else
                #走到这儿, 如果不能下落了
                Box2Map                #将当前移动中的方块贴到背景方块中
                RandomBox        #产生新的方块
        fi
}

#左移一列
function BoxLeft()
{
        local x s
        ((x = boxCurX - 1))
        if BoxMove $boxCurY $x
        then
                s=`DrawCurBox 0`
                ((boxCurX = x))
                s=$s`DrawCurBox 1`
                echo -ne $s
        fi
}

#右移一列
function BoxRight()
{
        local x s
        ((x = boxCurX + 1))
        if BoxMove $boxCurY $x
        then
                s=`DrawCurBox 0`
                ((boxCurX = x))
                s=$s`DrawCurBox 1`
                echo -ne $s
        fi
}

#下落到底
function BoxAllDown()
{
        local k j i x y iDown s
        iDown=$iTrayHeight

        #计算一共需要下落多少行
        for ((j = 0; j < 8; j += 2))
        do
                ((i = j + 1))
                ((y = ${boxCur[$j]} + boxCurY))
                ((x = ${boxCur[$i]} + boxCurX))
                for ((k = y + 1; k < iTrayHeight; k++))
                do
                        ((i = k * iTrayWidth + x))
                        if (( ${iMap[$i]} != -1)); then break; fi
                done
                ((k -= y + 1))
                if (( $iDown > $k )); then iDown=$k; fi
        done

        s=`DrawCurBox 0`        #将旧的方块抹去
        ((boxCurY += iDown))
        s=$s`DrawCurBox 1`        #显示新的下落后的方块
        echo -ne $s
        Box2Map                #将当前移动中的方块贴到背景方块中
        RandomBox        #产生新的方块
}

#旋转方块
function BoxRotate()
{
        local iCount iTestRotate boxTest j i s
        iCount=${countBox[$iBoxCurType]}        #当前的方块经旋转可以产生的样式的数目

        #计算旋转后的新的样式
        ((iTestRotate = iBoxCurRotate + 1))
        if ((iTestRotate >= iCount))
        then
                ((iTestRotate = 0))
        fi

        #更新到新的样式, 保存老的样式(但不显示)
        for ((j = 0, i = (${offsetBox[$iBoxCurType]} + $iTestRotate) * 8; j < 8; j++, i++))
        do
                boxTest[$j]=${boxCur[$j]}
                boxCur[$j]=${box[$i]}
        done

        if BoxMove $boxCurY $boxCurX        #测试旋转后是否有空间放的下
        then
                #抹去旧的方块
                for ((j = 0; j < 8; j++))
                do
                        boxCur[$j]=${boxTest[$j]}
                done
                s=`DrawCurBox 0`

                #画上新的方块
                for ((j = 0, i = (${offsetBox[$iBoxCurType]} + $iTestRotate) * 8; j < 8; j++, i++))
                do
                        boxCur[$j]=${box[$i]}
                done
                s=$s`DrawCurBox 1`
                echo -ne $s
                iBoxCurRotate=$iTestRotate
        else
                #不能旋转，还是继续使用老的样式
                for ((j = 0; j < 8; j++))
                do
                        boxCur[$j]=${boxTest[$j]}
                done
        fi
}

#DrawCurBox(bDraw), 绘制当前移动中的方块, bDraw为1, 画上, bDraw为0, 抹去方块。
function DrawCurBox()
{
        local i j t bDraw sBox s
        bDraw=$1

        s=""
        if (( bDraw == 0 ))
        then
                sBox="\040\040"
        else
                sBox="[]"
                s=$s"\033[1m\033[7m\033[3${cBoxCur}m\033[4${cBoxCur}m"
        fi

        for ((j = 0; j < 8; j += 2))
        do
                ((i = iTrayTop + 1 + ${boxCur[$j]} + boxCurY))
                ((t = iTrayLeft + 1 + 2 * (boxCurX + ${boxCur[$j + 1]})))
                #\033[y;xH, 光标到(x, y)处
                s=$s"\033[${i};${t}H${sBox}"
        done
        s=$s"\033[0m"
        echo -n $s
}

#更新新的方块
function RandomBox()
{
        local i j t

        #更新当前移动的方块
        iBoxCurType=${iBoxNewType}
        iBoxCurRotate=${iBoxNewRotate}
        cBoxCur=${cBoxNew}
        for ((j = 0; j < ${#boxNew[@]}; j++))
        do
                boxCur[$j]=${boxNew[$j]}
        done

        #显示当前移动的方块
        if (( ${#boxCur[@]} == 8 ))
        then
                #计算当前方块该从顶端哪一行"冒"出来
                for ((j = 0, t = 4; j < 8; j += 2))
                do
                        if ((${boxCur[$j]} < t)); then t=${boxCur[$j]}; fi
                done
                ((boxCurY = -t))
                for ((j = 1, i = -4, t = 20; j < 8; j += 2))
                do
                        if ((${boxCur[$j]} > i)); then i=${boxCur[$j]}; fi
                        if ((${boxCur[$j]} < t)); then t=${boxCur[$j]}; fi
                done
                ((boxCurX = (iTrayWidth - 1 - i - t) / 2))

                #显示当前移动的方块
                echo -ne `DrawCurBox 1`

                #如果方块一出来就没处放，Game over!
                if ! BoxMove $boxCurY $boxCurX
                then
                        kill -$sigExit ${PPID}
                        ShowExit
                fi
        fi

        #清除右边预显示的方块
        for ((j = 0; j < 4; j++))
        do
                ((i = iTop + 1 + j))
                ((t = iLeft + 2 * iTrayWidth + 7))
                echo -ne "\033[${i};${t}H        "
        done

        #随机产生新的方块
        ((iBoxNewType = RANDOM % ${#offsetBox[@]}))
        ((iBoxNewRotate = RANDOM % ${countBox[$iBoxNewType]}))
        for ((j = 0, i = (${offsetBox[$iBoxNewType]} + $iBoxNewRotate) * 8; j < 8; j++, i++))
        do
                boxNew[$j]=${box[$i]};
        done

        ((cBoxNew = ${colorTable[RANDOM % ${#colorTable[@]}]}))

        #显示右边预显示的方块
        echo -ne "\033[1m\033[7m\033[3${cBoxNew}m\033[4${cBoxNew}m"
        for ((j = 0; j < 8; j += 2))
        do
                ((i = iTop + 1 + ${boxNew[$j]}))
                ((t = iLeft + 2 * iTrayWidth + 7 + 2 * ${boxNew[$j + 1]}))
                echo -ne "\033[${i};${t}H[]"
        done
        echo -ne "\033[0m"
}

#初始绘制
function InitDraw()
{
        clear
        RandomBox        #随机产生方块，这时右边预显示窗口中有方快了
        RandomBox        #再随机产生方块，右边预显示窗口中的方块被更新，原先的方块将开始下落
        local i t1 t2 t3

        #显示边框
        echo -ne "\033[1m"
        echo -ne "\033[3${cBorder}m\033[4${cBorder}m"

        ((t2 = iLeft + 1))
        ((t3 = iLeft + iTrayWidth * 2 + 3))
        for ((i = 0; i < iTrayHeight; i++))
        do
                ((t1 = i + iTop + 2))
                echo -ne "\033[${t1};${t2}H||"
                echo -ne "\033[${t1};${t3}H||"
        done

        ((t2 = iTop + iTrayHeight + 2))
        for ((i = 0; i < iTrayWidth + 2; i++))
        do
                ((t1 = i * 2 + iLeft + 1))
                echo -ne "\033[${iTrayTop};${t1}H=="
                echo -ne "\033[${t2};${t1}H=="
        done
        echo -ne "\033[0m"

        #显示"Score"和"Level"字样
        echo -ne "\033[1m"
        ((t1 = iLeft + iTrayWidth * 2 + 7))
        ((t2 = iTop + 10))
        echo -ne "\033[3${cScore}m\033[${t2};${t1}HScore"
        ((t2 = iTop + 11))
        echo -ne "\033[3${cScoreValue}m\033[${t2};${t1}H${iScore}"
        ((t2 = iTop + 13))
        echo -ne "\033[3${cScore}m\033[${t2};${t1}HLevel"
        ((t2 = iTop + 14))
        echo -ne "\033[3${cScoreValue}m\033[${t2};${t1}H${iLevel}"
        echo -ne "\033[0m"
}

#退出时显示GameOVer!
function ShowExit()
{
        local y
        ((y = iTrayHeight + iTrayTop + 3))
        echo -e "\033[${y};0HGameOver!\033[0m"
        exit
}

#显示用法.
function Usage
{
        cat << EOF
Usage: $APP_NAME
Start tetris game.

-h, --help              display this help and exit
      --version           output version information and exit
EOF
}

#游戏主程序在这儿开始.
if [[ "$1" == "-h" || "$1" == "--help" ]]; then
        Usage
elif [[ "$1" == "--version" ]]; then
        echo "$APP_NAME $APP_VERSION"
elif [[ "$1" == "--show" ]]; then
        #当发现具有参数--show时，运行显示函数
        RunAsDisplayer
else
        bash $0 --show&        #以参数--show将本程序再运行一遍
        RunAsKeyReceiver $!        #以上一行产生的进程的进程号作为参数
fi

from:
http://bbs.chinaunix.net/thread-184858-1-1.html

chatler 2010-03-26 11:51 发表评论

ANSI控制码

chatler — Fri, 26 Mar 2010 03:41:00 GMT

ANSI控制码的说明
例如:
  echo -ne "\33[32m" 可以将字符的显示颜色改为绿色
  echo -ne "\33[3;1H" 可以将光标移到第3行第1列处
具体的摘抄一些如下：
\33[0m  关闭所有属性
\33[1m  设置高亮度
\33[4m  下划线
\33[5m  闪烁
\33[7m  反显
\33[8m  消隐
\33[30m -- \33[37m  设置前景色
\33[40m -- \33[47m  设置背景色
\33[nA  光标上移n行
\33[nB  光标下移n行
\33[nC  光标右移n行
\33[nD  光标左移n行
\33[y;xH设置光标位置
\33[2J  清屏
\33[K 清除从光标到行尾的内容
\33[s 保存光标位置
\33[u 恢复光标位置
\33[?25l  隐藏光标
\33[?25h  显示光标

不同的shell,转义是不同的,
/home/lee#echo "\\033[32mddd"
ddd
/home/lee#
/home/lee#bash
/home/lee#echo "\\033[33maddd"
\033[33maddd
/home/lee#exit
/home/lee#echo "\\033[34maddd"
addd
/home/lee#echo $0
-ksh
/home/lee#

from:
http://bbs.chinaunix.net/thread-207837-1-1.html

chatler 2010-03-26 11:41 发表评论

shell基础二：查找技巧,find及xargs的使用

chatler — Wed, 17 Mar 2010 03:14:00 GMT

摘要: Normal 0 7.8 磅 0 2 false false false MicrosoftInternetExplorer4 st1\:*{behavior:url(#ieooui) } /* Style Definitions */ table.MsoNormalT... 阅读全文

chatler 2010-03-17 11:14 发表评论

五大非常见Linux命令

chatler — Sat, 06 Mar 2010 03:26:00 GMT

Linux有大量的命令行工具，从每天都会使用的ls、cd以及ps这些工具，到您可能还没有使用过，或者甚至没有听说过的不常见的工具。

　　我们将看一下五个不常见，但可以让您的使用更轻松的工具。我们会简单地看看每一个命令及其标志和参数，但请不要忘了对每一个命令使用man命令，去获取所有可能的标志和参数信息。

　　logsave

　　我们将查看的第一个工具是logsave。logsave命令可以将一个命令的输出保存到一个日志文件中：

　　$ logsave /var/log/partsize df –h

　　这里，logsave命令将df命令的输出保存到/var/log/partsize文件中，同时会添加一个时间戳并将命令的执行结果输出到标准输出。

听起来并不是那么的有趣，是吗？logsave特殊的魔力在于，如果文件，在这个例子中是/var/log/partsize，并不存在，那么 logsave会在内存中将数据进行排队，等待该文件的产生。对于在启动过程中，当您在对一个还没有挂载上的分区进行写操作时，用logsave去跟踪命令的执行输出是非常有用的。为了保存可能会丢失的命令行输出，我经常在自动配置和引导过程中，使用logsave。

　　diff3

下一个工具是diff3命令。您可能已经使用过diff命令去生成文件之间的差异。相对于diff的两个文件，diff3可以对三个文件执行同样的功能，但包括diff中的一些更复杂的选项。让我们看一个简单的例子。我们有三个文件：cat、dog以及mouse，它们各自包含一个字符串。我们可以用 diff3对所有的三个文件进行比较：

$ diff3 dog cat mouse
====
1:1c
This is a dog
2:1c
This is a cat
3:1c
This is a mouse

　　diff3命令显示了三个文件中不同的字符串。您也可以用“-”标记代表一个文件。这将会把标准输入和其他文件进行比较。

　　您也可以使用-A标记，在所有的文件里面，去合并不同，并对任何冲突之处进行高亮显示。

$ diff3 -A dog cat mouse
1a
||||||| cat
This is a cat
=======
This is a mouse
>>>>>>> mouse
.
0a
<<<<<<< dog
.

　　pstree

您可能已经在您的主机上，使用过ps去列出所有的进程。但您可能还没有听说过pstree——一个用于以树的形式显示您的进程的命令。一个进程或者从 init进程，从一个您可以指定的PID（进程ID）分支出来，或者从一个您可以指定的用户分支出来。每一个进程及其子进程如下所示：

　　pstree命令也包括一些您可以使用的命令行标志。比如-a标志会显示进程所使用的命令行，而-p标志会在树中添加进程的进程ID。

　　nl命令很少有人知道，但却可以执行一个很漂亮的小功能——它在输出中添加行号。让我们看一个简单的例子，对一个叫做dog的文件执行nl命令。

$ nl dog
1 This is a dog
2 This is not a dog

　　您可以看到nl获取了dog文件的内容，并在输出中添加了行号。然后，您可以将这些输出通过管道放到一个新文件中。

　　$ nl dog > dog_numbered

　　然后，我们就可以显示这个带有新的行号内容的文件：

$ cat dog_numbered
1 This is a dog
2 This is not a dog

　　split

　　我们要看的最后一个命令是split。split命令通常基于尺寸将文件分割为多个片段。我使用这个命令,去将大的日志文件分割为更好管理的日志片段，例如：

　　$ split --bytes=1m /tmp/largelogfile /tmp/smallerfile

　　split命令有根据字节数和行数对文件进行分割的参数。这里,我们通过指定--bytes=1m参数，将大的日志文件分割为1M字节的块（您可以指定b去代表字节，k代表千字节，g代表十亿字节）。

　　我们可以像这样根据行数对文件进行分割：

　　$ split --lines=1000 /tmp/largelogfile /tmp/smallerfile

　　这里，文件会被分为多个1000行的块。

在我们的例子中，会将每个块都存在/tmp目录下，其文件名会包含一个前缀smallerfile。第一个文件为smallerfileaa，第二个是 smallerfileab等等。您也可以使用-d标记，去使用数字而不是通过字母的增长来对块进行计数。最后，除了可以指定一个文件，您也可以使用 “-”去让split命令以标准输入为输入，并分割为独立的文件。

from:
http://www.searchsv.com.cn/showcontent_31396.htm

chatler 2010-03-06 11:26 发表评论

LINUX命令xargs的简单应用及举例

chatler — Tue, 16 Feb 2010 20:11:00 GMT

xargs
大多数 Linux 命令都会产生输出：文件列表、字符串列表等。但如果要使用其他某个命令并将前一个命令的输出作为参数该怎么办？例如，file 命令显示文件类型（可执行文件、ascii 文本等）；您可以处理输出，使其仅显示文件名，现在您希望将这些名称传递给 ls -l 命令以查看时间戳记。xargs 命令就是用来完成此项工作的。它允许您对输出执行其他某些命令。记住下面这个来自于第 1 部分中的语法：

file -Lz * | grep ASCII | cut -d":" -f1 | xargs ls -ltr

让我们来剖析这个命令字符串。第一个，file -Lz *，用于查找是符号链接或者经过压缩的文件。它将输出传递给下一个命令 grep ASCII，该命令在其中搜索 "ASCII" 字符串并产生如下所示的输出：
alert_DBA102.log: ASCII English text
alert_DBA102.log.Z: ASCII text (compress'd data 16 bits)
dba102_asmb_12307.trc.Z: ASCII English text (compress'd data 16 bits)
dba102_asmb_20653.trc.Z: ASCII English text (compress'd data 16 bits)

由于我们只对文件名感兴趣，因此我们应用下一个命令 cut -d":" -f1，仅显示第一个字段：
alert_DBA102.log
alert_DBA102.log.Z
dba102_asmb_12307.trc.Z
dba102_asmb_20653.trc.Z

现在，我们希望使用 ls -l 命令，将上述列表作为参数进行传递，一次传递一个。xargs 命令允许您这样做。最后一部分，xargs ls -ltr，用于接收输出并对其执行 ls -ltr 命令，如下所示：

ls -ltr alert_DBA102.log
ls -ltr alert_DBA102.log.Z
ls -ltr dba102_asmb_12307.trc.Z
ls -ltr dba102_asmb_20653.trc.Z

因此，xargs 本身虽然没有多大用处，但在与其他命令相结合时，它的功能非常强大。

下面是另一个示例，我们希望计算这些文件中的行数：

$ file * | grep ASCII | cut -d":" -f1 | xargs wc -l
47853 alert_DBA102.log
     19 dba102_cjq0_14493.trc
29053 dba102_mmnl_14497.trc
    154 dba102_reco_14491.trc
     43 dba102_rvwr_14518.trc
77122 total

（注：上述任务还可用以下命令完成：）

$ wc -l ‘file * | grep ASCII | cut -d":" -f1 | grep ASCII | cut -d":" -f1‘

该 xargs 版本用于阐释概念。Linux 可以用几种方法来完成同一个任务；请使用最适合您的情况的方法。

使用该方法，您可以快速重命名目录中的文件。

$ ls | xargs -t -i mv {} {}.bak

-i 选项告诉 xargs 用每项的名称替换 {}。-t 选项指示 xargs 先打印命令，然后再执行。

另一个非常有用的操作是当您使用 vi 打开要编辑的文件时：

$ file * | grep ASCII | cut -d":" -f1 | xargs vi

该命令使用 vi 逐个打开文件。当您希望搜索多个文件并打开它们进行编辑时，使用该命令非常方便。

它还有几个选项。最有用的可能是 -p 选项，它使操作具有可交互性：

$ file * | grep ASCII | cut -d":" -f1 | xargs -p vi
vi alert_DBA102.log dba102_cjq0_14493.trc dba102_mmnl_14497.trc dba102_reco_14491.trc dba102_rvwr_14518.trc ?...

此处的 xarg 要求您在运行每个命令之前进行确认。如果您按下 "y"，则执行命令。当您对文件进行某些可能有破坏且不可恢复的操作（如删除或覆盖）时，您会发现该选项非常有用。

-t 选项使用一个详细模式；它显示要运行的命令，是调试过程中一个非常有帮助的选项。

如果传递给 xargs 的输出为空怎么办？考虑以下命令：

$ file * | grep SSSSSS | cut -d":" -f1 | xargs -t wc -l
wc -l
0
$

在此处，搜索 "SSSSSS" 后没有匹配的内容；因此 xargs 的输入均为空，如第二行所示（由于我们使用 -t 这个详细选项而产生的结果）。虽然这可能会有所帮助，但在某些情况下，如果没有要处理的内容，您可能希望停止 xargs；如果是这样，可以使用 -r 选项：
$ file * | grep SSSSSS | cut -d":" -f1 | xargs -t -r wc -l
$

如果没有要运行的内容，该命令退出。

假设您希望使用 rm 命令（该命令将作为 xargs 命令的参数）删除文件。然而，rm 只能接受有限数量的参数。如果您的参数列表超出该限制怎么办？xargs 的 -n 选项限制单个命令行的参数个数。

下面显示了如何限制每个命令行仅使用两个参数：即使向 xargs ls -ltr 传递五个文件，但每次向 ls -ltr 仅传递两个文件。

$ file * | grep ASCII | cut -d":" -f1 | xargs -t -n2 ls -ltr
ls -ltr alert_DBA102.log dba102_cjq0_14493.trc
-rw-r-----    1 oracle   dba           738 Aug 10 19:18 dba102_cjq0_14493.trc
-rw-r--r--    1 oracle   dba       2410225 Aug 13 05:31 alert_DBA102.log
ls -ltr dba102_mmnl_14497.trc dba102_reco_14491.trc
-rw-r-----    1 oracle   dba       5386163 Aug 10 17:55 dba102_mmnl_14497.trc
-rw-r-----    1 oracle   dba          6808 Aug 13 05:21 dba102_reco_14491.trc
ls -ltr dba102_rvwr_14518.trc
-rw-r-----    1 oracle   dba          2087 Aug 10 04:30 dba102_rvwr_14518.trc

使用该方法，您可以快速重命名目录中的文件。

$ ls | xargs -t -i mv {} {}.bak

-i 选项告诉 xargs 用每项的名称替换 {}。

我需要将一个用.svn管理的项目改成由CVS来管理，因此，在导入整个项目到CVS中之前，我需要删除所有目录下以及子孙目录下的.svn目录及.svn 目录下的的子目录和文件。我一直寻找一种最简单的方法，最后写了一个程序去干这事情。结果同事告诉我只需要一条指令就可以了：find -name '.svn' |xargs rm -rf
这个教训非常惨重，我一生讨厌傻瓜，可那一刻发现自己是最大的傻瓜！

是的，虽然我们——至少是我，天天使用LINUX但是真的是在高效的使用这个系统吗？不，很多时候并没有花时间去研究它，使用一些固有愚蠢的方式和思维模式在使用这个系统。

1. 建立多级目录:

mkidr 指令用来建立目录，事实上，我们一直都是这么干的。但是在这么使用的时候我们并没有去看它的那些参数提供了哪些额外的功能.

mkidr -p /share/dragon ; 在根目录下建立share目录，并在/share目录下建立dragon目录。mkdir -p guicmd/{bin,lib,src,share/version,doc/{html,pdf,info,man}}
;用来建立一个复杂的项目目录树。

2.find 配合xargs使用：

find -name '.svn' |xargs rm -rf ;这个不用说了，就是我前面提到的。
xargs更加象一个筛选器，将符合管道传递过来的文件名的内容一并处理掉，这是一个极度高效的方法。

from: http://www.cppblog.com/prayer/archive/2009/11/17/90188.html#101210

chatler 2010-02-17 04:11 发表评论

如何准确的截取出IP段

chatler — Tue, 16 Feb 2010 10:19:00 GMT

比如用到下面的命令得出了一堆信息，如何获取到本地和远端的ip呢

netstat -an | grep tcp

tcp 0 0 0.0.0.0:5989 0.0.0.0:* LISTEN

tcp 0 0 127.0.0.1:427 0.0.0.0:* LISTEN

tcp 0 0 0.0.0.0:111 0.0.0.0:* LISTEN

tcp 0 0 127.0.0.1:2544 0.0.0.0:* LISTEN

tcp 0 0 127.0.0.1:25 0.0.0.0:* LISTEN

tcp 0 0 :::22 :::* LISTEN

tcp 0 0 ::1:25 :::* LISTEN

tcp 0 52 192.168.2.4:22 192.168.2.2:3107 ESTABLISHED

tcp 0 0 192.168.2.4:22 192.168.2.100:2184 ESTABLISHED

可以考虑用awk和cut的结合

netstat -an | grep tcp | awk '{print $5}' | cut -d: -f1

得出远端ip的信息

0.0.0.0

192.168.2.2

192.168.2.100

若是本地的ip信息也可以用类似的方法炮制，只是awk里的$n有点变化罢了。

chatler 2010-02-16 18:19 发表评论

shell中管道两边的进程是怎么通信的

chatler — Sat, 13 Feb 2010 15:42:00 GMT

   要执行一个简单命令 shell 首先复制自身，然后 shell 等待实际上执行命令的 subshell （子shell）完成，在 subshell 中做重定向和执行 exec 系统调用，用指定程序的代码段和数据段替代 shell 代码段和数据段，进程 id 等元信息不变。
   管道线 a | b 执行：shell 创建一个管道，复制一个 subshell, 在其中把输出标准重定向到管道写端然后 exec a，shell 不等待这个 subshell 执行完成; shell 接着复制一个 subshell，在其中把标准输入重定向到管道读端然后 exec b, shell 等待它这个 subshell 完成。
   在 (...) 方式执行命令时候涉及到进一步的进程复制，shell 在复制 subshell 之后不等待其完成；subshell 在执行除了最后一个命令之外所有命令的时候都复制一个 subsubshell，在其中做重定向和 exec, subshell 在自身中重定向和 exec 最后一个命令.   如果管道由 subshell( exec a) 创建，那么subshell(exec b)就无法通过继承得到该管道描述符，从而进行重定向，那么只能使用使用named pipe了？

from：linuxforum

chatler 2010-02-13 23:42 发表评论

GNU Linux核心命令和工具的源代码路径

chatler — Fri, 01 Jan 2010 08:09:00 GMT

Commands and Utilities

--------------------------------------------------------------------------------

The table below lists all of the commands and utilities set forth in chapter 17 of the Linux Standard Base specification. Also listed are the source code packages used by Architect to provide the commands as well as the primary download location for the source code.

chatler 2010-01-01 16:09 发表评论

ftp下载文件完整性校验-shell脚本

chatler — Mon, 23 Nov 2009 13:23:00 GMT

#!/bin/sh
#date=20080916
#echo $date
ftp -i -n 192.168.1.161 <user name password
cd bj
ls *20080916* 20080916
bye
EOF
aaaa=`ls *20080916* |wc -l`
echo $aaaa
bbbb=`cat 20080916|wc -l`
echo $bbbb
if [ $aaaa -eq $bbbb ]
then
echo "ftp transfered completely "
else
echo "ftp transfered error"
fi

#!/bin/sh
ftp -i -n 192.168.1.152 <user name password
ls -lt file1
bye
EOF
ls -lt >file2
awk '{print $5}'file2 | while read tty
do\
awk 'BEGIN {...}END{name="'tty'";\
if($5==$name)\
printf("%s",zhengque);\
else\
printf("%s transfer error\n",$9);\
printf("the size of source file is %d,the size of this file after ftp\
transferred is %d",$name,$5);\
}\
' file1\
done\

转自：
http://blog.chinaunix.net/u/28584/showart.php?id=1211619

chatler 2009-11-23 21:23 发表评论

SED用法小结

chatler — Mon, 23 Nov 2009 13:21:00 GMT

quote.txt

The honeysuckle hand played all night long for only $90.

It was an evening of splendid music and company.

Too bad the disco floor fell through at 23:10.

The local nurse Miss P.Neave was in attendance.

显示行

$sed -n '2p' quote.txt

范围

$sed -n '1,3p' quote.txt

匹配单词

$sed -n '/The/'p quote.txt

匹配某行单词

$sed -n '4,/The/'p quote.txt

匹配元字符

$sed -n '/\$/'p quote.txt

显示整个文件

$sed -n '1,$p' quote.txt sed -n '1,$'p quote.txt

任意字符

$sed -n '/.*ing/'p quote.txt 任意字符出现一次或N次以ing结尾

首末行

$sed -n '1p' quote.txt

$sed -n '$p' quote.txt

打印行号

$sed -n '/music/=' quote.txt

$sed -n -e '/music/p' -e '/music/=' quote.txt

It was an evening of splendid music and company.

附加文件

!/bin/sed -f

/文件中匹配的字符/ a\

插入的字符 +x; *.sed quote.txt

删除行

$sed '1d' quote.txt 删除第一行

$sed '1,3d' quote.txt 删除1到3行

$sed '$d' quote.txt 删除最后一行

$sed '/Neave/d' quote.txt 删除带Neave的行

替换文本

$sed 's/night/NIGHT/' quote.txt s替换/night/NIGHT/

$sed 's/\$//' quote.txt $换成空格

$sed 's/The/Wow!/g' quote.txt g替换所有

$sed 's/splendid/SPLENDID/w sed.out' quote.txt w sed.out此行写入文件

$sed -n 's/nurse/"Hello" &/p' quote.txt

The local "Hello" nurse Miss P.Neave was in attendance.

$sed -n 's/played/from Hockering &/p' quote.txt

将sed结果写入文件命令

$sed '1,2 w filedt' quote.txt 第一二行写入文件

$sed '/Neave/ w dht' quote.txt 匹配//的写入文件

从文件中读文本

$sed '/company./r sedex.txt' quote.txt

在quote.txt的company后换行,写入sedex.txt的内容

匹配后退出

$sed '/.a.*/q' quote.txt

任意字符后跟a,再跟任意字符0次或任意次匹配:

Line 1.band Line 2.bad Liner3.was Line 4.was

The honeysuckle hand played all night long for only $90.

vi dos.txt

12332##DISO##45.12^M

00332##LPSO##23.11^M

01299##USPD##34.46^M

用一个空格替换所有的##,删除最前边的0,删除尾部^M

$sed 's/##*/ /g' dos.txt

$sed 's/^0*/ /g' dos.txt

$sed 's/\^M//g' dos.txt

$cat dos.txt |sed 's/##*/ /g'|sed 's/^0*/ /'|sed 's/\^M//g'

处理报文输出

Database Size(MB) Date Created

-------------------------------------

GOSOUTH 2244 12/11/97

TRISUD 5632 8/9/99

(2 rows affected)

1>使用s/-*//g删除 -----------

2>使用/^$/d删除空行

3>使用$d删除最后一行

4>使用1d删除第一行

5>使用awk {print $1}打印第一列

cat sql.txt | sed 's/--*//g' | sed '/^$/d' | sed '$d' | sed '1d' | awk '{print $1}'

去除行首数字

$vi UNH.txt

12345UND SPLLFC 234344

9999999UND SKKLT 3423

1UND SPLLY 434

$sed 's/^[0-9]*//g' UND.txt

附加文本每一行末尾加上字符串'passwd'

vi ok.txt

AC456

AC492169

AC9967

AC88345

$sed 's/[0-9]*/& Passwd/g' ok.txt

从sed输出中设置shell变量

$NAME="It's a go situation"

$REPLACE="GO"

$NEW_NAME='echo $NAME | sed "s/go/$REPLACE/g"'

$echo $NEW_NAME

快速一行命令

's/\.$//g' 删除以.结尾的行

'-e /abcd/d' 删除包含abcd的行

's/[][][]*/[]/g' 删除一个以上的空格,用一个空格代替

's/^[][]*//g' 删除行首空格

's/\.[][]*/[]//g 删除.后跟2或多个空格,以一个空格代替

's/COL$...$//g'删除COL和它后边的3个字母的行

's/^\//g' 删除第一个\

's/[]/[]//g' 删除所有空格并用tab替代

's/^[]//g' 删除行首tab键

's/[]*//g' 删除所有tab键

插入文本

$echo "Mr Willis"|sed 's/Mr/& Bruce/g'

删除首字符

$echo "attkla.dc"|sed 's/^./g'

删除文件扩展名

$echo "attkla.dc"|sed 's/.dc//g'

增加扩展名

$echo "attkla"|sed 's/$/.dc/g'

替换字符系列

$x="Department+payroll%Building G"

+ 换成of %换成located

$echo $x | sed 's/\+/ of /g' | sed 's/\%/ Located at /g '

直接替换
sed -i 's/from/to/' filename

转自：
http://blog.chinaunix.net/u/28584/showart.php?id=1712332

chatler 2009-11-23 21:21 发表评论

AWK使用

chatler — Mon, 23 Nov 2009 13:20:00 GMT

以前还在玩UNIX的时候就觉得里面有个命令很好用AWK,功能强大.还有SED和ED，用这三个命令就可以解决平时工作中的问题。
前几天在单位做报批量处理时,要是用手工一个网点一个网点慢慢的改的话,不通宵也得搞到3、4点钟。对于我这种懒人，那是很痛苦的事，于是只得做些懒人喜欢做的事了。花了二十分钟左右，终于把SHELL的脚本写好，每次处理43个网点的报表，用时不到15秒。
脚本中所用命令为：
find
awk
由于长时间没有写SHELL里的脚本了，花了好些时间测试，这里重温下AWK的一些常用的用法：
awk 用法：awk ' pattern {action} '
变量名   含义
ARGC   命令行变元个数
ARGV   命令行变元数组
FILENAME  当前输入文件名
FNR   当前文件中的记录号
FS   输入域分隔符，默认为一个空格
RS   输入记录分隔符
NF   当前记录里域个数
NR   到目前为止记录数
OFS   输出域分隔符
ORS   输出记录分隔符
1、awk '/101/' file 显示文件file中包含101的匹配行。
awk '/101/,/105/' file
awk '$1 == 5' file
awk '$1 == "CT"' file 注意必须带双引号
awk '$1 * $2 >100 ' file
awk '$2 >5 && $2<=15' file
2、awk '{print NR,NF,$1,$NF,}' file 显示文件file的当前记录号、域数和每一行的第一个和最后一个域。
awk '/101/ {print $1,$2 + 10}' file 显示文件file的匹配行的第一、二个域加10。
awk '/101/ {print $1$2}' file
awk '/101/ {print $1 $2}' file 显示文件file的匹配行的第一、二个域，但显示时域中间没有分隔符。
3、df | awk '$4>1000000 ' 通过管道符获得输入，如：显示第4个域满足条件的行。
4、awk -F "|" '{print $1}' file 按照新的分隔符“|”进行操作。
awk 'BEGIN { FS="[: \t|]" }
{print $1,$2,$3}' file 通过设置输入分隔符（FS="[: \t|]"）修改输入分隔符。
Sep="|"
awk -F $Sep '{print $1}' file 按照环境变量Sep的值做为分隔符。
awk -F '[ :\t|]' '{print $1}' file 按照正则表达式的值做为分隔符，这里代表空格、:、TAB、|同时做为分隔符。
awk -F '[][]' '{print $1}' file 按照正则表达式的值做为分隔符，这里代表[、]
5、awk -f awkfile file 通过文件awkfile的内容依次进行控制。
cat awkfile
/101/{print "\047 Hello! \047"} --遇到匹配行以后打印 ' Hello! '.\047代表单引号。
{print $1,$2} --因为没有模式控制，打印每一行的前两个域。
6、awk '$1 ~ /101/ {print $1}' file 显示文件中第一个域匹配101的行（记录）。
7、awk 'BEGIN { OFS="%"}
{print $1,$2}' file 通过设置输出分隔符（OFS="%"）修改输出格式。
8、awk 'BEGIN { max=100 ;print "max=" max} BEGIN 表示在处理任意行之前进行的操作。
{max=($1 >max ?$1:max); print $1,"Now max is "max}' file 取得文件第一个域的最大值。
（表达式1?表达式2:表达式3 相当于：
if (表达式1)
表达式2
else
表达式3
awk '{print ($1>4 ? "high "$1: "low "$1)}' file
9、awk '$1 * $2 >100 {print $1}' file 显示文件中第一个域匹配101的行（记录）。
10、awk '{$1 == 'Chi' {$3 = 'China'; print}' file 找到匹配行后先将第3个域替换后再显示该行（记录）。
awk '{$7 %= 3; print $7}' file 将第7域被3除，并将余数赋给第7域再打印。
11、awk '/tom/ {wage=$2+$3; printf wage}' file 找到匹配行后为变量wage赋值并打印该变量。
12、awk '/tom/ {count++;}
END {print "tom was found "count" times"}' file END表示在所有输入行处理完后进行处理。
13、awk 'gsub(/\$/,"");gsub(/,/,""); cost+=$4;
END {print "The total is $" cost>"filename"}' file gsub函数用空串替换$和,再将结果输出到filename中。
1 2 3 $1,200.00
1 2 3 $2,300.00
1 2 3 $4,000.00
awk '{gsub(/\$/,"");gsub(/,/,"");
if ($4>1000&&$4<2000) c1+=$4;
else if ($4>2000&&$4<3000) c2+=$4;
else if ($4>3000&&$4<4000) c3+=$4;
else c4+=$4; }
END {printf "c1=[%d];c2=[%d];c3=[%d];c4=[%d]\n",c1,c2,c3,c4}"' file
通过if和else if完成条件语句
awk '{gsub(/\$/,"");gsub(/,/,"");
if ($4>3000&&$4<4000) exit;
else c4+=$4; }
END {printf "c1=[%d];c2=[%d];c3=[%d];c4=[%d]\n",c1,c2,c3,c4}"' file
通过exit在某条件时退出，但是仍执行END操作。
awk '{gsub(/\$/,"");gsub(/,/,"");
if ($4>3000) next;
else c4+=$4; }
END {printf "c4=[%d]\n",c4}"' file
通过next在某条件时跳过该行，对下一行执行操作。

14、awk '{ print FILENAME,$0 }' file1 file2 file3>fileall 把file1、file2、file3的文件内容全部写到fileall中，格式为
打印文件并前置文件名。
15、awk ' $1!=previous { close(previous); previous=$1 }
{print substr($0,index($0," ") +1)>$1}' fileall 把合并后的文件重新分拆为3个文件。并与原文件一致。
16、awk 'BEGIN {"date"|getline d; print d}' 通过管道把date的执行结果送给getline，并赋给变量d，然后打印。
17、awk 'BEGIN {system("echo "Input your name:\\c""); getline d;print "\nYour name is",d,"\b!\n"}'
通过getline命令交互输入name，并显示出来。
awk 'BEGIN {FS=":"; while(getline< "/etc/passwd" >0) { if($1~"050[0-9]_") print $1}}'
打印/etc/passwd文件中用户名包含050x_的用户名。
18、awk '{ i=1;while(iawk '{ for(i=1;itype file|awk -F "/" '
{ for(i=1;i{ if(i==NF-1) { printf "%s",$i }
else { printf "%s/",$i } }}' 显示一个文件的全路径。
用for和if显示日期
awk 'BEGIN {
for(j=1;j<=12;j++)
{ flag=0;
printf "\n%d月份\n",j;
for(i=1;i<=31;i++)
{
if (j==2&&i>28) flag=1;
if ((j==4||j==6||j==9||j==11)&&i>30) flag=1;
if (flag==0) {printf "%02d%02d ",j,i}
}
}
}'
19、在awk中调用系统变量必须用单引号，如果是双引号，则表示字符串
Flag=abcd
awk '{print '$Flag'}' 结果为abcd
awk '{print "$Flag"}' 结果为$Flag

转自：
http://blog.chinaunix.net/u/28584/showart.php?id=1712347

chatler 2009-11-23 21:20 发表评论

find命令详解<转>

chatler — Tue, 10 Nov 2009 14:32:00 GMT

find /etc/rc.d -name '*crond' -exec file {} \;

查找/etc/rc.d目录下面所有以crond结束的文件，并使用file指令查看其属性，注意：exec和file间是一个空格，file和{}间是一个空格，file和\;之间是一个空格，\;是一个整体。

要在/usr/linux中查找所有的*.h，并在这些文件中查找“SYSCALL_VECTOR"，最后打印出所有包含"SYSCALL_VECTOR"的文件名，有以下几种方法实现
find /usr/linux -name "*.h" | xargs -n50 grep SYSCALL_VECTOR
grep SYSCALL_VECTOR /usr/linux/*.h | cut -d':' -f1 | uniq > filename
find /usr/linux -name "*.h" -exec grep "SYSCALL_VECTOR" {} \; -print

　　我用find / -name filename| rm -rf，不成功，请问为什么不成功？
find / -name filename -exec rm -rf {} \;
find . -name filename |rm -rf试一下{} 表示你找出来的结果。
\; 则相当于“宪法”，没什么说头，就是这么规定的，在 -exec 后面需要一个表示该命令终结的的符号。可以在 man find 中找到***。
要让rm识别find的结果，如下：
find / -name filename |xargs rm -rf
之所以find . -name filename |rm -rf不通过，是因为rm命令不接受从标准输入传过来的指令
　　查找含特定字符串的文件
例如查找当前目录下含有"the string you want find..."字符串的文件：
$find . -type f -exec grep “the string you want find...” {} ; -print

　　从根目录开始查tmpfile，一旦查到马上删除
find / -name "tmpfile" -exec rm {} \;

　　find 的perm问题
请问一下以下命令什么意思？关键是那个数字前的-，其他都还知道
find -name ".*" -perm -007
我知道
find -name ".*" -perm 755
这个是用来查找权限位为755的隐藏文件
噢，对了还有，我上边的命令都省略了find的pathname参数 find默认是查找当前工作目录的吗？
如果我用 -ok 替代 -exec, 那么还需要加上 {} \; 吗？
这个已经清楚，仍然需要，因为 -ok 只是 -exec 的提示模式，它只是多了一个确认操作的步骤,刚才没有读懂那几句E文的意思呵呵不好意思
-007是指查找所有用户都可读、写、执行的文件，要小心呀~~~
解释解释？
find -name ".*" -perm -007 和 find -name ".*" -perm 777 有区别吗？
-007是怎么来得呢？
不过有一个问题
我用 find . -perm -100 会列出当前目录 . , 这是为什么呢？

下面引用由explover在 2002/10/01 06:15am 发表的内容：
-007是指查找所有用户都可读、写、执行的文件，要小心呀~~~
-007是查找含其它用户(不同组,非属主)可读,写,执行的文件.并不一定要同组可读写,-是指最少权限为007.
下面引用由一颗小白菜在 2002/10/01 10:16am 发表的内容：
OK了，呵呵
不过有一个问题
我用 find . -perm -100 会列出当前目录 . , 这是为什么呢？
这种方法不会准确的找出目录的. -100是指权限至少是属主可运行.
在unix系统下,你可以拥有对目录文件的执行权你才可以进入一个目录.这便是目录文件被列出的原因.
find . -perm -001 -print找到往往是目录文件.
我的意思当然不是使用这种方法来找目录，只不过不明白其中的 -100 意义了
那以此类推，是不是 -010是指权限至少是owner同组可执行的吗？也就是说其实这里的010和-是分开的，-表示一个至少的意思，而且010才是真正用来描述权限位的？
这样子就明白了谢谢你噢

　　将find出来的东西拷到另一个地方?
find *.c -exec cp '{}' /tmp ';'
如果有特殊文件，可以用cpio，也可以用这样的语法：
find dir -name filename -print | cpio -pdv newdir

　　找出磁盘中某个大小范围内的文件
比如要查找磁盘中大于3M的文件：
find . -size +3000k -exec ls -ld {} ;

　　如何用find查找某一天更改的文件？
可以使用这一行命令来实现：
A=`find ~ -print` | ls -l --full-time $A 2>/dev/null | grep "Jun 27" | grep 1998

　　使用find 命令查找某个时间段的shell怎么写。比如11点到12点的。thanks
创建一个脚本judgetime，内容如下：
ls -l $*|awk '{split($8,hour,":");if((hour[1]>23 || hour[1] < 1)&&hour[1]<24)print}'
到要查找的目录下，运行
find ./ -name "*" -exec judgetime {} \;
注意时间格式为２４小时制。
thank you ，如果我要精确到分钟呢
touch -t 04241112 starttemp #精确到12分钟
touch -t 04241220 endtemp #截止到12点20
find [dir] -newer starttemp -a ! -newer endtemp -exec ls -l {} \;
ｎｅｗｅｒ？
那昨天１２：１０文件如何呢？
每天执行的时候，用当天的日期和时间戳替换一下不就行了吗？
我不知道他是不是把所有的11：00~12：00的都找出来，是不是只执行一次还是每天都执行？
这种情况俺猜想是自己的东西放在哪忘了，只记得当时是深夜了。
有道理！
不愧是斑竹！
不光知道怎么解决问题，还知道在什么情况下出现这类问题，佩服佩服！
问题又出现了。创建这个文件的时候。本来应该是时间的一栏现在写上了2002，而不是12：00.
等到12：00过了吧！

　　删除指定日期的文件
find ./ -name 文件名 -exec rm -f {} \;
例：删除当前30天内没用过的文件,用如下命令：
find / -atime +30 -exec rm -f {} \;
我自己试着写了一小段SHELL,也用ll ,grep, rm 几个命令，用起来还差强人意。
对过滤出来的文件名列表中用了一个FOR语句，再执行rm 。现在我想把这段SHELL 扩展一下让它每天定时运行将 n 天前的文件删掉，有没有人能给我一些提示，谢谢！
还有个问题，对于前面那位朋友提到的"find / -atime +30 -exec rm -f {} \;
"方法，我很早就试过几次，不过好像都不太对，参数 -atime n 是查找n天前被访问过的文件，我不明白的是这里的时间参照点是什么，以及这个n天是怎么计算的。
问题二、对于"ll |cut -f 1" 这个命令我是不是用错了，我只想取出 ll 中列出的文件名，但用cut -f 命令做不到，我只好换用 ll |cut -c 59- 这种方式得到我要的文件名，but it's a pool idear ！我也试过用awk ，好像也不对，看看大家可不可以给我一些小小的提醒，TKS SO MUCH
问题三、如何改变 I结点的日期格式我现在的系统显示的格式是：
-rw-r----- 1 msahz01 users 2253 2002年2月 2日 poheader.i
我想把这换成
-rw-rw-rw- 1 house users 2193 Apr 19 2001 hkdisp.p
如何才能做到这点？
awk 应该可以
ll | awk '{print $9}'
　　删除多少天之前的文件
find /yourpath -mtime +31 -exec rm {} \;
find /yourpath -mtime +366 -exec rm {} \;

find中, -ctime, -mtime及其-atime有何区别

请问 -ctime 和 -mtime 有什么关系 ?
如果父目录的 ctime 改变, 那它下面的文件的 ctime 就会自动都改了吗 ?
-ctime 和 -mtime ,-atime 这些信息是存在哪儿呢 ?

我用 -mtime -1 找到了新建或改的文件.
但怎样才能找到一天内 mv 来的文件呢( 它们的时间是原有的时间,早于一天 ) ?

用-newer选项啊。
你可以先touch一个你想要的时间的文件如下：
$ touch -t 08190800 test
$ ls -l test
-rw-r--r-- 1 dba other 0 Aug 19 08:00 test
然后
$ find . -newer test -print
.
./.sh_history
$ ls -l .sh_history
-rw------- 1 dba other 154 Aug 20 17:39 .sh_history

用touch可以写出你想要的任何时间的文件，然后用-newer ,! -newer选项即可成功。

1.ctime含inode信息修改的时间.mtime只指文件内容建立或修改的时间.
2 不会.
3.这些信息应该是存在文件系统的超级块里.

我查了书 -ctime 是指 inode 的改变(或称文件的状态改变).
请问 inode 存了哪些信息 ?
做了些小测试,-mtime 改, -ctime 一定也改.
改文件名, -ctime 也会改.
谁能回答 i-node 存了哪些东西 ?

vi /usr/include/sys/inode.h

班主,我不能 access /usr/include/sys/inode.h .
摘书如下:
Directories contain directory entries. Each entry contains a file or subdirectory name and an index node reference number (i-node number). To increase speed and enhance use of disk space, the data in a file is stored at various locations in the computer's memory. The i-node contains the addresses used to locate all the scattered blocks of data associated with a file. The i-node also records other information about the file including time of modification and access, access modes, number of links, file owner, and file type.
可我发现 -atime 改了, -ctime 还没改. why ?
( 我先 cat 一个 ASCII 文件,再用 -atime -1 有它用 -ctime -1 居然没有它.)
着岂不跟 inode 信息改变, ctime 就改矛盾吗?

我不同意你贴出来的那段文章,正如我提到的那样,atime,ctime,mtime是放到超级块里,在sco unix下是一种叫stat的结构.(stat_32),不同的系统文件系统可能不同.
sco 下inode的结构如下:

typedef struct inode
{
struct inode *i_forw; /* inode hash chain */
struct inode *i_back; /* '' */
struct inode *av_forw; /* freelist chain */
struct inode *av_back; /* '' */
int *i_fsptr; /* "typeless" pointer to fs dependent */
ino32_t i_number; /* i number, 1-to-1 with dev address */
ushort i_ftype; /* file type = IFDIR, IFREG, etc. */
short i_fstyp; /* File system type */
off_t i_size; /* size of file */
ushort i_uid; /* owner */
ushort i_gid; /* group of owner */
ushort i_flag;
ushort i_want; /* i_flag extension to avoid MP races */
ushort i_count; /* reference count */
short i_nlink; /* directory entries */
dev_t i_rdev; /* Raw device number */
#define i_namtype i_rdev /* i_ftype==IFNAM subtype */
dev_t i_dev; /* device where inode resides */
struct mount *i_mton;/* ptr to mount table entry that */
/* this directory is mounted on */
struct region *i_rp; /* ptr to shared region if any */
struct stdata *i_sp; /* ptr to associated stream */
struct iisem *isem; /* ptr to XENIX semaphores */
struct iisd *isd; /* ptr to XENIX shared data */
} i_un;
#define i_mnton i_un.i_mton /* i_ftype==IFDIR IMOUNT */
#define i_rptr i_un.i_rp /* i_ftype==IFREG || i_ftype==IFBLK */
#define i_sptr i_un.i_sp /* i_ftype==IFCHR || i_ftype==IFIFO */
#define i_sem i_un.isem /* i_ftype==IFNAM && i_namtype==IFSEM */
#define i_sd i_un.isd /* i_ftype==IFNAM && i_namtype==IFSHD */

struct fstypsw *i_fstypp; /* ptr to file system switch FSPTR */
long *i_filocks; /* pointer to filock (structure) list */
unsigned long i_mappages; /* number of pages currently cached */
unsigned long i_vcode; /* read-ahead block save (NFS) */
short i_wcnt; /* write open count or ITEXT count */
struct lockb i_cilock; /* tas to synchronize i_flag changes */
ushort i_rdlocks; /* count of non-exclusive lockers */
} inode_t;

所以,访问一个文件不能改变inode信息.
使用chown, chgrp, chmod命令可以很好的比较mtime和ctime
chown改变一个文件的属主,用ctime可以找到,用mtime便找不到.
试试看.

多谢斑竹! 我是在 Solaris 上面试的.我是对 -ctime 不明白.
试的结果如下:
修改文件,-mtime 改了, -ctime 也会改.
访问文件,-atime 改了, -ctime 没变.
chown, chgrp, chmod,mv, 都会使 -ctime 改变,但不影响 -atime 和 -mtime.
touch 可以改 -mtime and/or -atime,但 touch -a 只改访问时间时,-ctime也改了.
touch -m 改修改时间时,-ctime当然也改了.
好象还有别的很多东西可以令 -ctime 改变, 搞不清楚.
有什么方法可以显示 -mtime,atime,ctime 吗?
可以用 -ctime 来实现对目录的增量文件进行备份或 transfer 吗 ?
多谢!

没有什么工具显示,(可能是俺不知道)
把下面程序里的st_mtime换成st_ctime,或st_atime便可以得到你要的了.
＃i nclude
int
main (int argc, char **argv)
{
struct stat buf;
char date[80];
char fname[80];
printf("Enter filename (with full path) to check mtime : ");
scanf("%s",fname);
stat(fname, &buf);
printf ("mtime (in sec) of %s = %ld\n", fname, buf.st_mtime);
strcpy(date, ctime((time_t *)&(buf.st_mtime)));
printf ("mtime (in date) of %s = %s\n", fname, date);
}

至于文件备份,有什么不可以的么?

mtime ls -l 最近修改文件内容的时间
atime ls -lu 最近访问文件的时间
ctime ls -li 最近文件有所改变的状态 ,如文件修改,属性\属主改变 ,节点 ,链接变化等 ,应该是不拘泥只是时间前后的改变

俺看了ls的帮助,以为只是按ctime或atime排序,显示的时间还是mtime.

仔细比较了一下,ayhan说的是对的.谢谢ayhan.

多谢 ahyan 提示 ! 我在 Solaris 上试过如下:
mtime 用 ls -l 看到
atime 用 ls -lu 看到
ctime 用 ls -lc 看到. (ls -li 只有 inode number)
摘书如下:
-c Uses time of last modification of the i-node (file
created, mode changed, and so forth) for sorting (-t)
or printing (-l or -n).
-u Uses time of last access instead of last modification
for sorting (with the -t option) or printing (with the
-l option).
-i For each file, prints the i-node number in the first
column of the report.

我在sco unix5.0.5中试了一下，好像不对：chmod,chgrp等不会改变ls -il显示的时间；vi,touch倒是有影响。
每一种操作系统都是由成千上万个不同种类的文件所组成的。其中有系统本身自带的文件，用户自己的文件，还有共享文件等等。我们有时候经常忘记某份文件放在硬盘中的哪个地方。在微软的WINDOWS操作系统中要查找一份文件是相当简单的事情，只要在桌面上点击“开始”－“搜索”中就能按照各种方式在本地硬盘上，局域网络，甚至在INTERNET上查找各种文件，文档。
　　可是使用linux的用户就没有那么幸运了，在Linux上查找某个文件确实是一件比较麻烦的事情。毕竟在linux中需要我们使用专用的“查找”命令来寻找在硬盘上的文件。Linux 下的文件表达格式非常复杂，不象WINDOWS,DOS下都是统一的AAAAAAA.BBB格式那么方便查找，在WINDOWS中，只要知道要查找的文件的文件名或者后缀就非常容易查找到。linux中查找文件的命令通常为“find”命令，“find”命令能帮助我们在使用,管理linux的日常事务中方便的查找出我们需要的文件。对于linux新手来说，“find”命令也是了解和学习Linux 文件特点的方法。因为linux发行版本繁多，版本升级很快，在Linux书籍上往往写明某个配置文件的所在位置，往往linux新手按图索骥还是不能找到。比如说REDHAT Linux 7.O 和REDHAT linux 7.1中有些重要的配置文件所在的硬盘位置和文件目录就有了很大的改变，如果不学会使用“find”命令，那么在成千上万的linux文件中要找到其中的一个配置文件是相当困难的，笔者在没有精通“find”命令之前就吃过这样的苦头。好，下面就详细为大家介绍强大的“find”命令的全部使用方法和用途。

通过文件名查找法：
　　这个方法说起来就和在WINDOWS下查找文件一样容易理解了。如果你把这个文件放在单个的文件夹里面，只要使用常见的“ls"命令就能方便的查找出来，那么使用“find”命令来查找它就不能给你留下深刻的印象，毕竟“find”命令的强大功能不止这个。如果知道了某个文件的文件名，而不知道这个文件放到哪个文件夹，甚至是层层套嵌的文件夹里。举例说明，假设你忘记了httpd.conf这个文件在系统的哪个目录下，甚至在系统的某个地方也不知道，则这是可以使用如下命令：
　　find / -name httpd.conf
　　这个命令语法看起来很容易就明白了，就是直接在find后面写上 -name，表明要求系统按照文件名查找，最后写上httpd.conf这个目标文件名即可。稍等一会系统会在计算机屏幕上显示出查找结果列表：
　　etc/httpd/conf/httpd.conf
　　这就是httpd.conf这个文件在linux系统中的完整路径。查找成功。
　　如果输入以上查找命令后系统并没有显示出结果，那么不要以为系统没有执行 find/ -name httpd.conf命令，而可能是你的系统中没有安装Apache服务器，这时只要你安装了Apache Web服务器，然后再使用find / -name httpd.conf就能找到这个配置文件了。

无错误查找技巧：
　　在linux系统中“find”命令是大多数系统用户都可以使用的命令，并不是ROOT系统管理员的专利。但是普通用户使用“find”命令时也有可能遇到这样的问题，那就是L inux系统中系统管理员ROOT可以把某些文件目录设置成禁止访问模式。这样普通用户就没有权限用“find”命令来查询这些目录或者文件。当普通用户使用“find”命令来查询这些文件目录是，往往会出现"Permissiondenied."（禁止访问）字样。系统将无法查询到你想要的文件。为了避免这样的错误，我们可是使用转移错误提示的方法尝试着查找文件，输入
　　find / -name access_log 2>/dev/null
　　这个方法是把查找错误提示转移到特定的目录中去。系统执行这个命令后，遇到错误的信息就直接输送到stderrstream 2 中，access_log 2 就是表明系统将把错误信息输送到stderrstream 2中，/dev/null是一个特殊的文件，表明空的或者错误的信息，这样查询到的错误信息将被转移了，不会再显示了。

　　在linux系统查找文件也会遇到这样一个实际问题。如果我们在整个硬盘，这个系统中查找某个文件就要花费相当长的一段时间，特别是大型linux系统和容量较大的硬盘，文件放在套嵌很深的目录中的时候。如果我们知道了这个文件存放在某个大的目录中，那么只要在这个目录中往下找就能节省很多时间了。使用find /etc -name httpd.conf 就可以解决这个问题。上面的命令就是表示在etc目录中查询httpd.conf这个文件。这里再说明一下“/ ”这个函数符号的含义，如果输入 “find/ ”就是表示要求linux系统在整个 ROOT目录下查找文件，也就是在整个硬盘上查找文件，而“find/etc”就是只在 etc目录下查找文件。因为“find/etc”表示只在etc目录下查找文件，所以查找的速度就相应要快很多了。

根据部分文件名查找方法：
　　这个方法和在WINDOWS中查找已知的文件名方法是一样的。不过在linux中根据部分文件名查找文件的方法要比在WINDOWS中的同类查找方法要强大得多。例如我们知道某个文件包含有srm这3个字母，那么要找到系统中所有包含有这3个字母的文件是可以实现的，输入：
　　find /etc -name '*srm*'
　　这个命令表明了linux系统将在/etc 整个目录中查找所有的包含有srm这3个字母的文件，比如 absrmyz，tibc.srm等等符合条件的文件都能显示出来。如果你还知道这个文件是由 srm 这3个字母打头的，那么我们还可以省略最前面的星号，命令如下：
　　find/etc -name 'srm*'
　　这是只有像srmyz 这样的文件才被查找出来，象absrmyz或者absrm这样的文件都不符合要求，不被显示，这样查找文件的效率和可靠性就大大增强了。

根据文件的特征查询方法：
　　如果只知道某个文件的大小，修改日期等特征也可以使用"find"命令查找出来，这和 WINDOWS系统中的"搜索"功能是基本相同的。在微软的"搜索"中WINDOWS中的"搜索助理"使得搜索文件和文件夹、打印机、用户以及网络中的其他计算机更加容易。它甚至使在 Internet 上搜索更加容易。"搜索助理"还包括一个索引服务，该服务维护了计算机中所有文件的索引，使得搜索速度更快。使用"搜索助理"时，用户可以指定多个搜索标准。例如，用户可以按名称、类型及大小搜索文件和文件夹。用户甚至可以搜索包含特定文本的文件。如果用户正使用 Active Directory，这时还可以搜索带有特定名称或位置的打印机。
　　例如我们知道一个linux文件大小为1,500 bytes，那么我们可是使用如下命令来查询 find / -size 1500c，字符 c 表明这个要查找的文件的大小是以bytes为单位。如果我们连这个文件的具体大小都不知道，那么在linux中还可以进行模糊查找方式来解决。例如我们输入find/ -size +10000000c 这个命令，则标明我们指定系统在根目录中查找出大于10000000字节的文件并显示出来。命令中的“＋”是表示要求系统只列出大于指定大小的文件，而使用“-”则表示要求系统列出小于指定大小的文件。下面的列表就是在linux使用不同"find"命令后系统所要作出的查找动作，从中我们很容易看出在linux中使用"find" 命令的方式是很多的，"find"命令查找文件只要灵活应用，丝毫不必在WINDOWS中查找能力差。
　　find / -amin -10 # 查找在系统中最后10分钟访问的文件
　　find / -atime -2 # 查找在系统中最后48小时访问的文件
　　find / -empty # 查找在系统中为空的文件或者文件夹
　　find / -group cat # 查找在系统中属于 groupcat的文件
　　find / -mmin -5 # 查找在系统中最后5分钟里修改过的文件
　　find / -mtime -1 #查找在系统中最后24小时里修改过的文件
　　find / -nouser #查找在系统中属于作废用户的文件
　　find / -user fred #查找在系统中属于FRED这个用户的文件
　　下面的列表就是对find命令所可以指定文件的特征进行查找的部分条件。在这里并没有列举所有的查找条件，参考有关linux有关书籍可以知道所有find命令的查找函数。
-amin n
查找系统中最后N分钟访问的文件
-atime n
查找系统中最后n*24小时访问的文件
-cmin n
查找系统中最后N分钟被改变状态的文件
-ctime n
查找系统中最后n*24小时被改变状态的文件
-empty
查找系统中空白的文件，或空白的文件目录，或目录中没有子目录的文件夹
-false
查找系统中总是错误的文件
-fstype type
查找系统中存在于指定文件系统的文件，例如：ext2
-gid n
查找系统中文件数字组 ID 为 n的文件
-group gname
查找系统中文件属于gnam文件组，并且指定组和ID的文件

Find命令的控制选项说明：
Find命令也提供给用户一些特有的选项来控制查找操作。下表就是我们总结出的最基本，最常用的find命令的控制选项及其用法。
选项
用途描述
-daystart
.测试系统从今天开始24小时以内的文件，用法类似-amin
-depth
使用深度级别的查找过程方式,在某层指定目录中优先查找文件内容
-follow
遵循通配符链接方式查找; 另外，也可忽略通配符链接方式查询
-help
显示命令摘要
-maxdepth levels
在某个层次的目录中按照递减方法查找
-mount
不在文件系统目录中查找，用法类似 -xdev.
-noleaf
禁止在非UNUX文件系统，MS-DOS系统，CD-ROM文件系统中进行最优化查找
-version
打印版本数字

使用-follow选项后，find命令则遵循通配符链接方式进行查找，除非你指定这个选项，否则一般情况下find命令将忽略通配符链接方式进行文件查找。

-maxdepth选项的作用就是限制find命令在目录中按照递减方式查找文件的时候搜索文件超过某个级别或者搜索过多的目录，这样导致查找速度变慢，查找花费的时间过多。例如，我们要在当前(.)目录技巧子目录中查找一个名叫fred的文件，我们可以使用如下命令
find . -maxdepth 2 -name fred

假如这个fred文件在./sub1/fred目录中，那么这个命令就会直接定位这个文件，查找很容易成功。假如，这个文件在. /sub1/sub2/fred目录中，那么这个命令就无法查找到。因为前面已经给find命令在目录中最大的查询目录级别为2，只能查找2层目录下的文件。这样做的目的就是为了让find命令更加精确的定位文件，如果你已经知道了某个文件大概所在的文件目录级数，那么加入-maxdepth n 就很快的能在指定目录中查找成功。

使用混合查找方式查找文件
find命令可以使用混合查找的方法，例如我们想在/tmp目录中查找大于100000000字节并且在48小时内修改的某个文件，我们可以使用-and 来把两个查找选项链接起来组合成一个混合的查找方式。
find /tmp -size +10000000c -and -mtime +2

学习过计算机语言的朋友都知道，在计算机语言里，使用and ,or 分别表示“与”和“或”的关系。在linux系统的查找命令中一样通用。
还有这样的例子，
find / -user fred -or -user george

我们可以解释为在/tmp目录中查找属于fred或者george这两个用户的文件。
在find命令中还可以使用“非”的关系来查找文件，如果我们要在/tmp目录中查找所有不属于panda的文件，使用一个简单的
find /tmp ! -user panda
命令就可以解决了。很简单。

查找并显示文件的方法
查找到某个文件是我们的目的，我们更想知道查找到的文件的详细信息和属性，如果我们采取现查找文件，在使用LS命令来查看文件信息是相当繁琐的，现在我们也可以把这两个命令结合起来使用。
find / -name "httpd.conf" -ls

系统查找到httpd.conf文件后立即在屏幕上显示httpd.conf文件信息。
12063 34 -rw-r--r-- 1 root root 33545 Dec 30 15:36 /etc/httpd/conf/httpd.conf

下面的表格就是一些常用的查找文件并显示文件信息的参数和使用方法
选项
用途描述
-exec command;
查找并执行命令
-fprint file
打印文件完整文件名
-fprint0 file
打印文件完整文件名包括空的文件
-fprintf file format
打印文件格式
-ok command;
给用户命令执行操作，根据用户的Y 确认输入执行
-printf format
打印文件格式
-ls
打印同种文件格式的文件

总结：到这里为止我们已经学习了这名多关于find命令的使用方法，也列出了很多常用的find命令的选项，如果我们能熟练掌握在linux中find命令的使用方法，那么在Linux中查找文件也不是一件困难的事情。

转自：
http://www.lupaworld.com/94908/viewspace-109380.html

chatler 2009-11-10 22:32 发表评论

linux shell 小片段

chatler — Sun, 08 Nov 2009 03:19:00 GMT

1.关于文件对比的Scripts
diff -b -r $Dir1 $Dir2 | grep -v "Common subdirectories" | grep -e "^diff" -e "^Binary files" -e "^Only"
diff:
-b --ignore-space-change
             Ignore changes in the amount of white space.
-r --recursive
              Recursively compare any subdirectories found.
grep:
-v, --invert-match
              Invert the sense of matching, to select non-matching lines.
-e PATTERN, --regexp=PATTERN
              Use PATTERN as the pattern; useful to protect patterns beginning with -.

2. grep的正则表达式：
比如,要匹配两个单詞:  word  exec
grep -E "word|execl"  是可以得到正确结果的
AND:
grep -E "word&execl"  和预期的不一样
grep -E 'excel.*word|work.*excel'是可以的。
注：正则表达式跟逻辑操作符是俩概念，只有awk支持||，&&这样的操作，
用grep的话，也只支持|而不支持&。
正则基础：)
$cat rfile
abcd
abc
ab
$grep -E 'abc.*' rfile
abcd
abc
$grep -E 'abc*' rfile
abcd
abc
ab

3. 如何获得一个文件的前N列或是其中的几列？
cut -f-2 -d ' ' filename
-f field   -d dilimeter

4.删除某个目录下不是以.sh .h .c结尾的文件
find . -type f | awk '!/\.sh$/ && !/\.[c|h]$/{print $1}' | xargs rm

5.原来用冒号分隔的，选出几列来，改成用竖杠分隔的
cat /etc/passwd | awk -F: '{print $1"|"$2"|"$3"|"$4}'

6.去掉文件中的字符，比如去掉从win上传到Linux上的文件时会有个^M,若去掉他可以用：
tr -d '\015' < filename

7.目录树是
A/B/C/
A/B/C/ccc/...
A/B/C/bbb/...
A/B/C/D/aaa/...
我现在在A下，我要查找html后缀文件，但是不想它在包含aaa||bbb||ccc的目录下查找.
find . $ -name Input -o -name Output -o -name Current $ -type d -prune -o -name "*.htm" -print
这个命令中的目录排除没有起作用，为什么嗯？很困惑。
find . -wholename './A/B' -prune -o -print
这个命令也不起作用，更困惑了，不认wholename

8. 循环读文件的命令
for x in `seq 1 12`; do cat $x|awk '{print $9}' && sleep 3;done

seq 是Linux 中一個預設的外部命令,一般用作一堆數字的簡化寫法，如
seq 1 10
便會出現
1
2
3
4
5
6
7
8
9
10
它還有三個選項
-f, --format=FORMAT      use printf style floating-point FORMAT (default: %g)
-s, --separator=STRING   use STRING to separate numbers (default: \n)
-w, --equal-width        equalize width by padding with leading zeroes

-f 最常用 , 例如一次制做 10 個名 dir001 , dir002 .. dir010 的目錄，它便很有用途,我們可以這樣

下一個命令便可了
seq -f 'dir%03g' 1 10 | xargs mkdir
或
mkdir $(seq -f 'dir%03g' 1 10)
它用的是 printf 的格式 , %03g' 代表以三位浮點數,以此方法，

如用bash3 的 printf也可作為等價命令
printf 'dir%03d\n' {1..10} | xargs mkdir 或 mkdir `printf 'dir%03d ' {1..10}`

awk 當然也可以
awk 'BEGIN { while (num < 10 ) printf "dir%03d\n", ++num ; exit}' | xargs mkdir

這樣會比寫一個腳本快, 不必寫成
for dir in 001 002 003 004 005 006 007 008 009 010
do
mkdir dir${dir}
done

9.找出当前目录下大于100M的目录
find . -maxdepth 1 -type d | xargs du -sh | grep -v '\.$'| grep -P '^\S+M\t' | awk -FM '$1>1'

chatler 2009-11-08 11:19 发表评论

linux 下 scp 的用法<转>

chatler — Mon, 02 Nov 2009 02:25:00 GMT

copy 本地的档案到远程的机器上 scp /etc/lilo.conf k@net67.ee.oit.edu.tw:/home/k 会将本地的 /etc/lilo.conf 这个档案 copy 到 net67.ee.oit.edu.tw，使用者 k 的家目录下。 copy远程机器上的档案到本地来 scp k@net67.ee.oit.edu.tw:/etc/lilo.conf /etc 会将 net67.ee.oitdu.tw 中 /etc/lilo.conf 档案 copy 到本地的 /etc 目录下。保持从来源 host 档案的属性 scp –p k@net67.ee.tw:/etc/lilo.conf /etc 如果想使用特定端口使用 scp –p（大写）如 scp –p 1234 k@net67.ee.tw:/etc/lilo.conf /etc 在此必须注意使用者的权限是否可读取远程上的档案，若想知道更多关于 scp 的使用方法，可去看看 scp 的使用手册。 ssh-keygen 产生公开钥 (pulib key) 和私人钥 (private key)，以保障 ssh 联机的安性，当 ssh 连 shd 服务器，会交换公开钥上，系统会检查 /etc/ssh_know_hosts 内储存的 key，如果找到客户端就用这个 key 产生一个随机产生的session key 传给服务器，两端都用这个 key 来继续完成 ssh 剩下来的阶段。它会产生 identity.pub、identity 两个档案，私人钥存放于identity，公开钥存放于 identity.pub 中，接下来使用 scp 将 identity.pub copy 到远程机器的家目录下.ssh下的authorized_keys。 .ssh/authorized_keys(这个 authorized_keys 档案相当于协议的 rhosts 档案)，之后使用者能够不用密码去登入。RSA的认证绝对是比 rhosts 认证更来的安全可靠。执行： scp identity.pub k@linux1.ee.oit.edu.tw:.ssh/authorized_keys 若在使用 ssh-keygen 产生钥匙对时没有输入密码，则如上所示不需输入密码即可从 net67.ee.oit.edu.tw 去登入 linux1.ee.oit.edu.tw。在此，这里输入的密码可以跟帐号的密码不同，也可以不输入密码。转自: http://www.cnblogs.com/gergro/archive/2008/06/19/1225959.html

chatler 2009-11-02 10:25 发表评论

BASH 中的字符串处理

chatler — Mon, 05 Oct 2009 10:07:00 GMT

得到长度

[Copy to clipboard] [ - ]

CODE:

%x="abcd"
#方法一
%expr length $x
4
# 方法二
%echo ${#x}
4
# 方法三
%expr "$x" : ".*"
4
# expr 的帮助
# STRING : REGEXP anchored pattern match of REGEXP in STRING

查找子串

[Copy to clipboard] [ - ]

CODE:

%expr index  $x "b"
2
%expr index  $x "a"
1
%expr index  $x "b"
2
%expr index  $x "c"
3
%expr index  $x "d"
4

得到子字符串

[Copy to clipboard] [ - ]

CODE:

# 方法一
# expr startpos length
%expr substr "$x" 1 3
abc
%expr substr "$x" 1 5
abcd
%expr substr "$x" 2 5
bcd
# 方法二
# ${x:pos:lenght}
%echo ${x:1}
bcd
%echo ${x:2}
cd
%echo ${x:0}
abcd
%echo ${x:0:2}
ab
%pos=1
%len=2
%echo ${x:$pos:$len}
bc

匹配正则表达式

[Copy to clipboard] [ - ]

CODE:

# 打印匹配长度
%expr match $x "."
1
%expr match $x "abc"
3
%expr match $x "bc"
0

字符串的掐头去尾

[Copy to clipboard] [ - ]

CODE:

%x=aabbaarealwwvvww
%echo "${x%w*w}"
aabbaarealwwvv
%echo "${x%%w*w}"
aabbaareal
%echo "${x##a*a}"
lwwvvww
%echo "${x#a*a}"
bbaarealwwvvww

其中 , # 表示掐头，因为键盘上 # 在 $ 的左面。
其中 , % 表示%，因为键盘上 % 在 $ 的右面。
单个的表示最小匹配，双个表示最大匹配。
也就是说，当匹配的有多种方案的时候，选择匹配的最大长度还是最小长度。

字符串的替换

[Copy to clipboard] [ - ]

CODE:

%x=abcdabcd
%echo ${x/a/b} # 只替换一个
bbcdabcd
%echo ${x//a/b} # 替换所有
bbcdbbcd

不可以使用 regexp ，只能用 * ? 的文件扩展方式。

转自：
http://bbs.chinaunix.net/viewthread.php?tid=201843

chatler 2009-10-05 18:07 发表评论

shell解释器问题--命令不听话

chatler — Mon, 05 Oct 2009 03:05:00 GMT

经常会遇到一些问题就是为什么命令不是安你想要的执行!!!!举个例子你
find /usr -type f -name string*
你本意你想找string.c .h阿.什么之类的.就是*是当通配符了.可是如果你的当前路径有个string.c文件的话,你就知道问题了。

[root@mip-123456 string]# ls
[root@mip-123456 string]# find /usr/src/linux-2.6.18/arch/ -type f -name string*
/usr/src/linux-2.6.18/arch/ppc/lib/string.S
/usr/src/linux-2.6.18/arch/ppc/boot/common/string.S
/usr/src/linux-2.6.18/arch/m68k/lib/string.c
/usr/src/linux-2.6.18/arch/cris/arch-v10/lib/string.c
/usr/src/linux-2.6.18/arch/cris/arch-v32/lib/string.c
/usr/src/linux-2.6.18/arch/s390/lib/string.c
/usr/src/linux-2.6.18/arch/powerpc/lib/string.S
/usr/src/linux-2.6.18/arch/powerpc/boot/string.h
/usr/src/linux-2.6.18/arch/powerpc/boot/string.S
[root@mip-123456 string]# touch string.h
[root@mip-123456 string]# find /usr/src/linux-2.6.18/arch/ -type f -name string*
/usr/src/linux-2.6.18/arch/powerpc/boot/string.h
[root@mip-123456 string]# find /usr/src/linux-2.6.18/arch/ -type f -name "string*"
/usr/src/linux-2.6.18/arch/ppc/lib/string.S
/usr/src/linux-2.6.18/arch/ppc/boot/common/string.S
/usr/src/linux-2.6.18/arch/m68k/lib/string.c
/usr/src/linux-2.6.18/arch/cris/arch-v10/lib/string.c
/usr/src/linux-2.6.18/arch/cris/arch-v32/lib/string.c
/usr/src/linux-2.6.18/arch/s390/lib/string.c
/usr/src/linux-2.6.18/arch/powerpc/lib/string.S
/usr/src/linux-2.6.18/arch/powerpc/boot/string.h
/usr/src/linux-2.6.18/arch/powerpc/boot/string.S
聪明的你已经看出问题了。

由于[0-9]这种匹配模式是出现在命令的 argument位置上,所以由shell负责解释(所以严格而言, [0-9]是通配符,而不是正则表达式)。对shell而言,统配符只对文件名有效,也就是说,当shell遇到出现在某个命令行的argument位置上的通配符时,它先要去参数所指定的目录下搜索所有已经存在的文件,所有文件名字与之匹配的都要替换到argument位置上(这与很多标准的命令支持多个文件名参数是一致的),然后调用该命令执行.

对于mkdir ./dir[0-9]而言,shell无法在当前目录下找到与之匹配的文件名,所以就不替换,dir[0-9]按照原样传给mkdir程序,所以mkdir就建立了一个名字为dir[0-9]的目录.

总之一句话,通配符(出现在argument位置)由shell负责解释(与现有的文件名匹配),与具体的命令(ls,rm,mkdir)无关.正则表达式(出现在option位置上)由具体的应用程序解释(grep,sed,awk),与shell无关。

一个试验的例子是:
如果当前目录下已经有一个名为dir5的目录,执行 mkdir ./dir[0-9]后,出现错误提示:mkdir: cannot create directory `./dir5': File exists 这就证明了,因为存在dir5,所以shell匹配到了dir5,所以真正执行的是mkdir ./dir5

seq -f 'dir%01g' 0 9 | xargs mkdir
[victor@localhost tmp]$ ls
[victor@localhost tmp]$ seq -f 'dir%01g' 0 9 | xargs mkdir
[victor@localhost tmp]$ ls
dir0 dir1 dir2 dir3 dir4 dir5 dir6 dir7 dir8 dir9

-f 最常用 , 例如一次制做 10 個名 dir001 , dir002 .. dir010 的目錄，它便很有用途,我們可以這樣

下一個命令便可了
seq -f 'dir%03g' 1 10 | xargs mkdir
或
mkdir $(seq -f 'dir%03g' 1 10)
它用的是 printf 的格式 , %03g' 代表以三位浮點數,以此方法，

如用bash3 的 printf也可作為等價命令
printf 'dir%03d\n' {1..10} | xargs mkdir 或 mkdir `printf 'dir%03d ' {1..10}`

awk 當然也可以
awk 'BEGIN { while (num < 10 ) printf "dir%03d\n", ++num ; exit}' | xargs mkdir

這樣會比寫一個腳本快, 不必寫成
for dir in 001 002 003 004 005 006 007 008 009 010
do
mkdir dir${dir}
done

转自：
http://blog.chinaunix.net/u2/76292/showart_1931660.html

chatler 2009-10-05 11:05 发表评论

date命令使用

chatler — Fri, 19 Jun 2009 15:17:00 GMT

1.设置时间
(1)可以用date 061923122009，即月日时分年
(2)要是想使用更详细的设置，可以用date -s '2009-06-19 23:09:00',这样可以设置到秒。

chatler 2009-06-19 23:17 发表评论

shell十三问<转>

chatler — Tue, 02 Jun 2009 01:03:00 GMT

摘要: 转自：http://blog.csdn.net/chinalinuxzend/archive/2007/10/16/1826623.aspxshell 十三问：1) 为何叫做 shell ？ 2) shell prompt(PS1) 与 Carriage Return(CR) 的关系？ 3) 别人 echo、你也 echo ，是问 echo 知多少？ 4) " "(双引号) 与 ' '(单引号)差... 阅读全文

chatler 2009-06-02 09:03 发表评论

Linux Shell Learning Notes ---- String

chatler — Mon, 01 Jun 2009 06:08:00 GMT

转自：
http://hi.baidu.com/wangyuquansky/blog/item/46863716e253e756f2de322a.html

1.字符串的操作：
1.1 字符串的类型
/ 数字或者数字组合（能够返回结果，即程序退出状态是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键，而不是字符
// 匹配邮件地址
$ 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

说明：
[1] /dev/null和/dev/zero是非常有趣的两个设备，它们都犹如一个黑洞，什么东西掉进去都会消失殆尽；后者则是一个能源箱，你总能从那里取到0，直到你退出。两者的部分用法见：关于zero及NULL设备的一些问题
[2] [[:space:]]是grep用于匹配空格或者TAB键类型字符串的一种标记，其他类似的标记请查看grep的帮助,man grep。
[3] 上面都是用grep来进行模式匹配，实际上sed, awk都可以用来做模式匹配，关于匹配中用到的正则匹配模式知识，大家可以参考正则匹配模式，更多相关资料请看参考资料。
[4] 如果仅仅想判断字符串是否为空，即判断字符串的长度是否为零，那么可以简单的通过test命令的-z选项来判断，具体用法见test命令，man test.

概要示例: 判断字符是否可打印？如何控制字符在终端的显示。

// 用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 # 把一些控制字符过滤后，就可以保留可读的操作日志

更多关于字符在终端的显示控制方法，请参考资料[20]和字符显示实例[21]：用shell实现的一个动态时钟。

1.2 字符串的长度

概要示例: 除了组成字符串的字符类型外，字符串还有哪些属性呢？组成字符串的字符个数。下面我们来计算字符串的长度，即所有字符的个数，并简单介绍几种求字符串中指定字符个数的方法。

// 计算某个字符串的长度，即所有字符的个数[这计算方法是五花八门，择其优着而用之]
$ 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

说明：
${}操作符在Bash里头一个“大牛”，能胜任相当多的工作，具体就看看网中人的《shell十三问》之《Shell十三问》之"$(( )) 與 $( ) 還有${ } 差在哪？" 吧。

1.3 字符串的存储

在我们看来，字符串是一连串的字符而已，但是为了操作方便，我们往往可以让字符串呈现出一定的结构。在这里，我们不关心字符串在内存中的实际存储结构，仅仅关系它呈现出来的逻辑结构。比如，这样一个字符串："get the length of me"，我们可以从不同的方面来呈现它。

1.3.1 通过字符在串中的位置来呈现它

这样我们就可以通过指定位置来找到某个子串。这在c语言里头通常可以利用指针来做。而在shell编程中，有很多可用的工具，诸如expr，awk都提供了类似的方法来实现子串的查询动作。两者都几乎支持模式匹配(match)和完全匹配(index)。这在后面的字符串操作中将详细介绍。

1.3.2 根据某个分割符来取得字符串的各个部分

这里最常见的就是行分割符、空格或者TAB分割符了，前者用来当行号，我们似乎已经司空见惯了，因为我们的编辑器就这样“莫名”地处理着行分割符（在 unix下为\n，在其他系统下有一些不同，比如windows下为\r\n)。而空格或者TAB键经常用来分割数据库的各个字段，这似乎也是司空见惯的事情。

正是因为这样，所以产生了大量优秀的行编辑工具，诸如grep,awk,sed等。在“行内”（姑且这么说吧，就是处理单行，即字符串里头不再包含行分割符）的字符串分割方面，cut和awk提供了非常优越的“行内”（处理单行）处理能力。

1.3.3 更方便地处理用分割符分割好的各个部分

同样是用到分割符，但为了更方便的操作分割以后的字符串的各个部分，我们抽象了“数组”这么一个数据结构，从而让我们更加方便地通过下标来获取某个指定的部分。bash提供了这么一种数据结构，而优秀的awk也同样提供了它，我们这里将简单介绍它们的用法。

概要示例：利用数组存放"get the length of me"的用空格分开的各个部分。

//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还支持二维数组。

okay，就介绍到这里啦。为什么要介绍这些内容？再接着看下面的内容，你就会发现，那些有些的工具是怎么产生和发展起来的了，如果累了，看看最后一篇参考资料吧，它介绍了一些linux命令名字的由来，说不定可以帮助你理解本节下面的部分呢。

2. 字符串常规操作

字符串操作包括取子串、查询子串、插入子串、删除子串、子串替换、子串比较、子串排序、子串进制转换、子串编码转换等。

2.1 取子串

概要示例：取子串的方法主要有：直接到指定位置求子串，字符匹配求子串。

// 按照位置取子串，比如从什么位置开始，取多少个字符
$ 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

说明：
[1] %和#的区别是，删除字符的方向不一样,前者在右，后者在左，%%和%,##和#的方向是前者是最大匹配，后者是最小匹配。(好的记忆方法见网中人的键盘记忆法:#$%是键盘依次从左到右的三个键)
[2] tr的-c选项是complement的缩写，即invert，而-d选项是删除的意思，tr -cd "[a-z]"这样一来就变成保留所有的字母啦。

对于字符串的截取，实际上还有一些命令，如果head,tail等可以实现有意思的功能，可以截取某个字符串的前面、后面指定的行数或者字节数。例如：

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

2.2. 查询子串

概要示例：子串查询包括：返回符合某个模式的子串本身和返回子串在目标串中的位置。

准备：在进行下面的操作之前，请把http://oss.lzu.edu.cn/blog/blog.php?do_showone/tid_1385.html链接中的内容复制到一个文本text里头，用于下面的操作。

// 查询子串在目标串中的位置
$ 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 #同样可以打印行号

说明：
[1] awk,grep,sed都能通过模式匹配查找指定的字符串，但是它们各有擅长的领域，我们将在后续的章节中继续使用和比较它们，从而发现各自的优点。
[2] 在这里我们姑且把文件内容当成了一个大的字符串，在后面的章节中我们将专门介绍文件的操作，所以对文件内容中存放字符串的操作将会有更深入的分析和介绍。

2.3. 子串替换

子串替换就是把某个指定的子串替换成其他的字符串，实际上这里就蕴含了“插入子串”和“删除子串”的操作。例如，你想插入某个字符串到某个子串之前，就可以把原来的子串替换成”子串+新的字符串“，如果想删除某个子串，就把子串替换成空串。不过有些工具提供了一些专门的用法来做插入子串和删除子串的操作，所以呆伙还是会专门介绍的。另外，要想替换掉某个子串，一般都是先找到子串（查询子串），然后再把它替换掉的，实质上很多工具在使用和设计上都体现了这么一点。

概要示例：下面我们把变量var中的空格替换成下划线看看。

// 用{}运算符，还记得么？网中人的教程。
$ 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

说明：sed还有很有趣的标签用法呢，下面再介绍吧。

有一种比较有意思的字符串替换是，整个文件行的倒置，这个可以通过tac命令实现，它会把文件中所有的行全部倒转过来。在一定意义上来说，排序实际上也是一个字符串替换。

2.4. 插入子串

插入子串：就是在指定的位置插入子串，这个位置可能是某个子串的位置，也可能是从某个文件开头算起的某个长度。通过上面的练习，我们发现这两者之间实际上是类似的。

公式：插入子串=把"old子串"替换成"old子串+new子串"或者"new子串+old子串"

概要示例：：下面在var字符串的空格之前或之后插入一个下划线

// 用{}
$ 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

2.5. 删除子串删除子串：应该很简单了吧，把子串替换成“空”（什么都没有）不就变成了删除么。还是来简单复习一下替换吧。概要示例：：把var字符串中所有的空格给删除掉。鼓励：这样一替换不知道变成什么单词啦，谁认得呢？但是中文却是连在一起的，所以中文有多难，你想到了么？原来你也是个语言天才，而英语并不可怕，你有学会它的天赋，只要你有这个打算。如果要删除掉第一个空格后面所有的字符串该怎么办呢？还记得{}的#和%用法么？如果不记得，回到这一节的还头开始复习吧。（实际上删除子串和取子串未尝不是两种互补的运算呢，删除掉某些不想要的子串，也就同时取得另外那些想要的子串——这个世界就是一个“二元”的世界，非常有趣）这个很简单：还记得test命令的用法么？man test。它可以用来判断两个字符串是否相等的。另外，你发现了“字符串是否相等”和“字符串能否跟另外一个字符串匹配"两个问题之间的关系吗？如果两个字符串完全匹配，那么这两个字符串就相等了。所以呢，上面用到的字符串匹配方法，也同样可以用到这里。差点忘记这个重要的内容了，子串排序可是经常用到的，常见的有按字母序、数字序等正序或反序排列。sort命令可以用来做这个工作，它和其他行处理命令一样，是按行操作的，另外，它类似cut和awk，可以指定分割符，并指定需要排序的列。如果字母和数字字符用来计数，那么就存在进制转换的问题。在数值计算一节的回复资料里，我们已经介绍了bc命令，这里再简单的复习一下。说明：ibase指定输入进制，obase指出输出进制，这样通过调整ibase和obase，你想怎么转就怎么转啦！什么是字符编码？这个就不用介绍了吧，看过那些乱七八糟显示的网页么？大多是因为浏览器显示时的”编码“和网页实际采用的”编码“不一致导致的。字符编码通常是指把一序列”可打印“字符转换成二进制表示，而字符解码呢则是执行相反的过程，如果这两个过程不匹配，则出现了所谓的”乱码“。为了解决”乱码“问题呢？就需要进行编码转换。在linux下，我们可以使用iconv这个工具来进行相关操作。这样的情况经常在不同的操作系统之间移动文件，不同的编辑器之间交换文件的时候遇到，目前在windows下常用的汉字编码是gb2312，而在linux下则大多采用utf8。说明：我的终端默认编码是utf8，所以结果如上。实际上，在用Bash编程时，大部分时间都是在处理字符串，因此把这一节熟练掌握非常重要。范例演示：处理URL地址URL地址 (URL（Uniform Resoure Locator：统一资源定位器）是WWW页的地址)几乎是我们日常生活的玩伴，我们已经到了无法离开它的地步啦，对它的操作很多，包括判断URL地址的有效性，截取地址的各个部分（服务器类型、服务器地址、端口、路径等）并对各个部分进行进一步的操作。下面我们来具体处理这个URL地址：有了上面的知识，我们就可以非常容易地进行这些工作啦：修改某个文件的文件名，比如调整它的编码，下载某个网页里头的所有pdf文档等。这些就作为练习自己做吧，如果遇到问题，可以在回帖交流。相应地可以参考这个例子：[1] 用脚本下载某个网页中的英文原著(pdf文档）平时做工作，大多数时候处理的都是一些“格式化”的文本，比如类似/etc/passwd这样的有固定行和列的文本，也有类似tree命令输出的那种具有树形结构的文本，当然还有其他具有特定结构的文本。关于树状结构的文本的处理，可以考虑看看这两个例子： [1] 用AWK转换树形数据成关系表[2] 用Graphviz进行可视化操作──绘制函数调用关系图实际上，只要把握好特性结构的一些特点，并根据具体的应用场合，处理起来就不会困难。下面我们来介绍具体有固定行和列的文本的操作，以/etc/passwd文件为例。关于这个文件的帮忙和用户，请通过man 5 passwd查看。下面我们对这个文件以及相关的文件进行一些有意义的操作。上面涉及到了处理某格式化行中的指定列，包括截取（如SQL的select用法），连接（如SQL的join用法），排序（如SQL的order by用法)，都可以通过指定分割符来拆分某个格式化的行，另外，“截取”的做法还有很多，不光是cut，awk，甚至通过IFS指定分割符的read命令也可以做到，例如：因此，熟悉这些用法，我们的工作将变得非常灵活有趣。到这里，需要做一个简单的练习，如何把按照列对应的用户名和用户ID转换成按照行对应的，即把类似下面的数据：转换成：并转换回去，有什么办法呢？记得诸如tr，paste,split等命令都可以使用。参考方法：＊正转换：先截取用户名一列存入文件user，再截取用户ID存入id，再把两个文件用paste -s命令连在一起，这样就完成了正转换。＊逆转换：先把正转换得到的结果用split -1拆分成两个文件，再把两个拆分后的文件用tr把分割符"\t"替换成"\n"，只有用paste命令把两个文件连在一起，这样就完成了逆转换。更多有趣的例子，可以参考该序列第一部分的回复，即参考资料[16]的回复，以及兰大开源社区镜像站用的镜像脚本，即参考资料[17]，另外，参考资料[18] 关于用Shell实现一个五笔反查小工具也值得阅读和改进。

chatler 2009-06-01 14:08 发表评论

sed使用心得<转>

chatler — Wed, 01 Apr 2009 03:53:00 GMT

sed 是一种UNIX/LINUX 平台下的轻量级流编辑器，日常一般用于处理文本文件。sed 有许多很好的特性。首先，它相当小巧；其次， sed 可以配合强大的 shell 完成许多复杂的功能。在我看来，sed完全可以看成一个脚本解释器，用类似于编程的手段完成许多事情。

sed简单示例

sed命令的格式是
sed [-options] [command] [stdin]
比如这个例子
$ sed –e ‘d’ ./Mydir/Myfile
执行该命令，将得不到任何输出。在该例中，用一个编辑命令 'd' 调用 sed；sed 打开 ./Mydir/Myfile 将一行读入其模式缓冲区，执行’d’（“删除行”）；然后打印模式缓冲区（缓冲区已为空）；它对后面的每一行重复这些步骤，这不会产生输出！
对这个命令要说明的几点是：首先，它根本没有修改 ./Mydir/Myfile。这是因为 sed 是流处理器，它只读取在命令行指定的文件，它不试图修改该文件。其次， sed 是面向行的，'d' 命令不是简单地告诉 sed 一下子删除所有输入数据；相反，sed 逐行将 ./Mydir/Myfile 的每一行读入其称为模式缓冲区的内部缓冲区，一旦将一行读入模式缓冲区，它就执行 'd' 命令，然后打印模式缓冲区的内容。最后要注意的事是括起 'd' 命令的单引号的用法，这样可以禁用 shell 扩展。

指定sed的作用范围

看下面的三个例子
$ sed –e ‘1d’ ./Mydir/Myfile
$ sed –e ‘1,10d’ ./Mydir/Myfile
$ sed –e ‘/begin/,/end/p’ ./Mydir/Myfile
第一个例子说明只删除./Mydir/Myfile第一行的缓冲，第二个例子将删除第1~10行的缓冲。第三个例子最复杂，它定义了以字符串’begin’开始到’end’结束的作用范围

sed中的正则表达式

sed支持正则表达式，比如
$ sed –n -e ‘/regexp/p’ ./Mydir/Myfile
比如要删除所有的空行
$ sed –e ‘/^$/d’ ./Mydir/Myfile
sed中的一些特殊定义是
    规则表达式    描述
    /./       将与包含至少一个字符的任何行匹配
    /../      将与包含至少两个字符的任何行匹配
    /^#/      将与以 '#' 开始的任何行匹配
    /^$/      将与所有空行匹配
    /}^/      将与以 '}'（无空格）结束的任何行匹配
    /} *^/    将与以 '}' 后面跟有零或多个空格结束的任何行匹配
    /[abc]/   将与包含小写 'a'、'b' 或 'c' 的任何行匹配
    /^[abc]/  将与以 'a'、'b' 或 'c' 开始的任何行匹配
再比如一个经典的例子，打印c源代码中的main函数内容，其命令可以写成如下
$ sed –n –e ‘/main[[:space]]*(/,/^}/p’ ./Mydir/*.c
其中[:space]表示空格，[[:space]]*表示有0~多个空格，所以main[[:space]]*(的意思是匹配“main (”字符串；“^}”表示这一行有且只有一个字符}。当然，上面的命令不是十分严谨。

sed –e ‘s/regexp/repalcement’ file

替换是sed命令中最常用的命令，比如如下的例子
$ sed –e ‘s/a/b’ ./Mydir/Myfile
$ sed –e ‘s/a/b/g’ ./Mydir/Myfile
第一个命令将./Mydir/Myfile中每一行第一次出现的字符a替换成字符b；第二个命令由于加入了’/g’，表示是全局（全部）替换字符a成字符b。

经常还可以看见如下两种形式的sed
$ sed –e ‘1,10s/a/b’ ./Mydir/Myfile
$ sed –e ‘/^$/,/^END/s/a/b/g’ ./Mydir/Myfile
第一个命令是指替换1~10行；第二个命令是指全局替换从空行开始到以END开始的行中的内容。

替换命令不一定非要以/分隔，比如
$ sed –e ‘s:usr/local:/usr:g’ ./Mydir/Myfile
就是将./Mydir/Myfile中的usr/local全部替换成/usr

要用好替换命令，当然要使用正则表达式，除了上面所说的表达式的例子，还有一些是非常有用的
    字符类   描述
    [:alnum:]  字母数字 [a-z A-Z 0-9]
    [:alpha:]  字母 [a-z A-Z]
    [:blank:]  空格或制表键
    [:cntrl:]  任何控制字符
    [:digit:]  数字 [0-9]
    [:graph:]  任何可视字符（无空格）
    [:lower:]  小写 [a-z]
    [:print:]  非控制字符
    [:punct:]  标点字符
    [:space:]  空格
    [:upper:]  大写 [A-Z]
    [:xdigit:]  十六进制数字 [0-9 a-f A-F]
比如下面这个例子
$ sed –e ‘s/<[^>]*>//g’ ./Mydir/Myfile
< [^>]*>匹配<…>这样的字符串（…中不含>）。运行这个命令，能够将 “This is what I meant.”这样的字符串替换成“This is what I meant.”

考察如下的命令
$ sed -e 's/.*/# &/' ./Mydir/Myfile
这个命令将所有的非空行以“#”注释掉——&告诉sed在行首插入字符。

‘s///’允许我们在规则表达式中定义区域，然后可以在替换字符串中引用这些特定区域。这些区域是以$和$隔开的。
比如定义三个匹配非空字符的区域'$.*$ $.*$ $.*$'，现在可以定义这三个区域的动作，比如
$ sed -e 's/$.*$ $.*$ $.*$/PreFix \1-\2 Fix \3/' ./Mydir/Myfile
假如把三个区域分别命名为a、b、c，则最后结果是 PreFix a-b Fix c

sed中组合命令

sed中的命令可以组合，以；号隔开，比如
$ sed –n –e ‘=;p’ ./Mydir/Myfile
=表示打印行号，p表示打印。对于更复杂的指令，则可以写成命令脚本，然后用-f选项导入，比如
$ sed –n –f MyScript.sed ./Mydir/Myfile
对于同一个地址上的操作，则可以用{}组合，比如
$ sed –n ‘1,20{ s/samba/Samba/g s/posix/POSIX/g }’ ./Mydir/Myfile

sed中的行附加命令

在当前行之前插入行“i\”，如果要插入多行，则将多行用\分隔
在当前行之后插入行“a\”，用法和上面相似
更改当前行“c\”

chatler 2009-04-01 11:53 发表评论