有时候shell解释器会引起麻烦(这种麻烦来自于有时你并不想让shell解释一些字符)

先说一下metacharachter（元字符）：一个含有多重意义的字符被称为元字符，这种字符通常不仅仅包含其自身的字面意思。bash shell有自己的一套metacharachter，并有相应的解释机制。正则表达式系统也有自己的元字符和相应的解释机制，通 常，这些元字符标准是一致的，但是不排除不一致的情况。

bash grep要求在匹配时给出一个pattern，如果此pattern是一个正则表达式，则有可能携带有shell 的metacharacter。

这里情况就变得比较复杂，下面分类：

1，如果该字符是shell metacharachter，同时，在正则表达式里面有其特殊含义，then：

首先记得用strong quoting把这个pattern括起来以防止shell试图对其进行解释而得到不希望得到的结果，其次正确的利用正则表达式本身的机制表达你想要得到的结果（转义，反义，锚定，重复，模糊匹配等等烂七八糟的东西）

2，如果该字符不是shell metacharacter，但是正则表达式的元字符，括不括就随你的便了，但是注意正确表达正则表达式

3，如果该字符是shell metacharachter，而不是正则表达式的元字符，请你把它括起来防止shell解释器解释。

关于以上说法最明显的例子是grep 匹配\字符的情况，正确的写法是：

grep '\\' sourcefile

如果写成 grep \\ 或者grep "\\"

shell会提示：grep：末尾的斜杠，这说明shell解释器对pattern进行了解释，并把解释后的结果（这里是\）递给了grep，grep接到参数后认为这是一个元字符（逃逸字符）并且没有被转义，是非法的，所以会报错。

如果写成grep '\'

shell同样提示：grep:末尾的斜杠，这是因为shell虽然不解释\，但是参数\传给grep以后仍然认为这是一个元字符。

若果写成 grep \ sourcefile

bash shell会停止响应，猜测是因为bash不知道你要grep什么东西了

要说明的是：

强弱quoting的区别在于：

弱quoting（一对双引号）里面的$,\等少数几个字符仍然被shell解释，其余metacharachter不被解释

强quoting（一对单引号）里面的元字符均不被解释，包括$，\在内。

这里写一个匹配的小例子：

human<tab>sfuhojhfa<tab>human

human<tab>dlfuil;djsfikdsf<tab>mouse

rat<tab>ldfkuaselkt;lkfg<tab>human

对于以上文本，要找出两个human中间加一段字符串的行，可以这么写：

human.*human

以上是我对shell grep的理解，有错误还请斧正

    解释一下，变量相关工具就是处理变量用的，输出结果也可以被保存在新变量当中，这和其他语言如c，perl等的字符串处理颇为相似。

    例如：

             str="hello shell"

             root$ new_str=${str:2}

             root$ echo $new_str     ##输出为llo shell

             关于变量相关工具的详细信息，可以参阅这里http://blog.csdn.net/zg_hover/archive/2008/12/15/3523303.aspx

    流相关工具的输入输出对象为“流”，这类的工具有sed，grep，awk，cut等。通过管道符可以实现输入输出流的重定向以及实现各种操作，这一类工具给人的最突出的感觉是以文件为编程元素，可以方便直接的操作文件而不考虑细节。

    例如：

           root$ cat file1| cut  -f3 >SelectedFiled.txt    ##将file1中的内容以tab制表符分成列，并取出第3列写入文件SelectedFiled.txt中

           当然，流相关工具也可以做字符串操作：

           root$ str="hello world"

           root$ echo $str | cut -d" " -f2    ##将“world”字符以标准输出流的形式发送的终端屏幕

           这里echo的作用就是将字符串变量“包装”成输入流，因为流相关工具只能作用于流。

     流相关操作可以看看O‘REILY 的bash shell编程书籍。

  在用shell进行字符串截断时常常会出现一些意想不到的状况，总结了以下，大部分情况是使用的echo命令导致的。

   cat,read等命令读入tab delimited文本，然后用echo输出的时候，文本里面的tab会变成space空格，所以在你尝试以tab为分隔符分割文本的时候要特别注意这种情况。

命令格式：

       chmod [-cfvR] [--help] [--version] mode file...

[root@qs-wg-db2 ~]# chmod --help

Usage: chmod [OPTION]... MODE[,MODE]... FILE...

 or: chmod [OPTION]... OCTAL-MODE FILE...

 or: chmod [OPTION]... --reference=RFILE FILE...

Change the mode of each FILE to MODE.

 -c, --changes           like verbose but report only when a change is made

      --no-preserve-root do not treat `/' specially (the default)

      --preserve-root     fail to operate recursively on `/'

 -f, --silent, --quiet   suppress most error messages

 -v, --verbose           output a diagnostic for every file processed

      --reference=RFILE   use RFILE's mode instead of MODE values

 -R, --recursive         change files and directories recursively

      --help     display this help and exit

      --version output version information and exit

Each MODE is of the form `[ugoa]*([-+=]([rwxXst]*|[ugo]))+'.

Report bugs to <bug-coreutils@gnu.org>.

[root@qs-wg-db2 ~]#

参数说明：

1. -cfvR 部分

       -c : 若该档案权限确实已经更改，才显示其更改动作

       -f : 若该档案权限无法被更改也不要显示错误讯息

       -v : 显示权限变更的详细资料

       -R : 对目前目录下的所有档案与子目录进行相同的权限变更(即以递回的方式逐个变更)， 这个-R 用的还是很多的。

2.  Mode 部分

这部分可以分成如下3块： [who] operator [permission]

                                                 `[ugoa]*([-+=]([rwxXst]*|[ugo]))+'.

who的含义是：

       u 文件属主权限

       g 同组用户权限

       o 其它用户权限

       a 所有用户（包括以上三种）

operator的含义：

       + 增加权限

       - 取消权限

       =  唯一设定权限

permission的含义：

       r 读权限

       w 写权限

       x 执行权限

       X 表示只有当该档案是个子目录或者该档案已经被设定过为可执行。

       s 文件属主和组id

       l 给文件加锁，使其它用户无法访问

如: chmod a+x

3. 示例：

（1）将档案 file1.txt 设为所有人皆可读取 :

       chmod ugo+r file1.txt 

（2）将档案 file1.txt 设为所有人皆可读取 :

       chmod a+r file1.txt 
（3）将档案 file1.txt 与 file2.txt 设为该档案拥有者，与其所属同一个群体者可写入，但其他以外的人则不可写入 :

       chmod ug+w,o-w file1.txt file2.txt 

（4）将 ex1.py 设定为只有该档案拥有者可以执行 :

       chmod u+x ex1.py 

（5）将目前目录下的所有档案与子目录皆设为任何人可读取 :

       chmod -R a+r * 

（6）收回所有用户的对file1的执行权限

       chmod a-x file1

4. 使用数字来赋权

4.1 先看一下文件的权限格式

[root@qs-wg-db2 scripts]# ll

total 20

-rw-r--r-- 1 oracle oinstall    0 Feb 24 00:00 alertlogbyday.log

-rwxr-xr-x 1 oracle oinstall 430 Feb 20 01:10 alertlogbyday.sh

-rwxr-xr-x 1 oracle oinstall    7 Feb 24 05:00 del_st_arch.log

-rwxr-xr-x 1 oracle oinstall 648 Feb 19 00:51 del_st_archive.sh

-rwxr-xr-x 1 oracle oinstall    9 Feb 24 05:00 max_sn.log

drwxr-xr-x 3 root   root     4096 Feb 23 23:40 pymonitor

ll的结果返回七列，分别表示如下含义：

第一栏  [文件属性]

第二栏  [文件数]

第三栏  [拥有者]

第四栏  [所有者群组]

第五栏  [大小]

第六栏  [建档日期]

第七栏  [档名]

我们设置文件的权限就是这是第一栏里的文件属性。

文件属性这块共有十个字段，如：drwxr-xr-x

我们把这10个列分成4块：[d] [rwx] [r-x] [r-x]

第一块：也就是第一列，用来表示这个文件的类型，有如下值：

       （1）[ d ]则是目录，我这里的是d，表示的是一个目录

       （2）[ - ]则是文件；

       （3）[ l ]则表示为连结档(link file)；

       （4）[ b ]则表示为装置文件里面的可供储存的接口设备；

       （5）[ c ]则表示为装置文件里面的串行端口设备，例如键盘、鼠标。

第二块：第 2到4 列，表示文件拥有者的权限。

第三块：第5到7 列，表示拥有者同组人的权限。

第四块：第8到10列，表示是非拥有者组人的权限。

       这些权限均有[rwx] 三个参数表示，而且分别对应不同的位置。每块由3个列组成，每列对应一个值。 [ r ]代表可读、[ w ]代表可写、[ x ]代表可执行。

       举例： 如果拥有者只有只读的权限，那么第2到4列就是[r--],有读写的权限就是[rw-],有读写和执行的权利就是[rwx].

4.2 使用数字赋权

在4.1 中了解准备知识之后，就可以使用数字赋权了。 每块用户有3个权限[rwx]. 他们对应数字：

       r -->4

       w-->2

       x-->1

使用数字赋权的命令格式如下：

       chmod abc filename

其中的abc 分别代表3个数字，并且分别对应问个不同的属组。 即：

       数字a 对应 第2到4位，表示拥有者的权限。

       数字b 对应 第5到7位，表示同组用户的权限。

       数字c 对应第8到10位，表示其他组的权限。

       rwx 对应4，2，1. 那么只读的权限用4表示[r--]，读写用6（4+2）表示[rw-],写加执行用7（4+2+1）表示[rwx]。 只读加执行用5（4+1）表示[r-x]。

示例：

       chmod 755 file1

       chmod 777 file1 <==> chmod a=rwx file 

       chmod 771 file  <==> chmod ug=rwx,o=x file 

以上内容参考自http://blog.csdn.net/tianlesoftware/archive/2011/02/24/6204412.aspx，转载注明出处。

read.table函数在读入文件时，文件中不能含有"/"字符(linux,MS-DOS with "\" I guess)，否则会引起不必要的麻烦.

首先是 ${},它表示变量。

在括号中作相应的变换可以起到相应的变量操作的效果，如果想表示“变量加上一些固定的字符”，可以

这样写：

         root$ ${variable}charactersYouWant，这表示名为variablecharactersYouWant的那个变量

其次是$()和反单引号``。

它们一般用来得到被作用的命令的结果。常用于循环语句中：

for file in `ls -a`                 ####或者写成$(ls -a)

do

echo $file

done

将输出当前目录下所有文件和文件夹的名称

$ man du

NAME
       du - estimate file space usage

SYNOPSIS
       du [OPTION]... [FILE]...
       du [OPTION]... --files0-from=F

DESCRIPTION
       Summarize disk usage of each FILE, recursively for directories.

       Mandatory arguments to long options are mandatory for short options too.

       -a, --all
              write counts for all files, not just directories

       --apparent-size
              print  apparent  sizes,  rather than disk usage; although the apparent size is usually smaller, it may be larger due to holes in ('sparse') files, internal fragmenta-
              tion, indirect blocks, and the like

       -B, --block-size=SIZE use SIZE-byte blocks

       -b, --bytes
              equivalent to '--apparent-size --block-size=1'

       -c, --total
              produce a grand total

       -D, --dereference-args
              dereference FILEs that are symbolic links

       --files0-from=F
              summarize disk usage of the NUL-terminated file names specified in file F

       -H     like --si, but also evokes a warning; will soon change to be equivalent to --dereference-args (-D)

       -h, --human-readable
              print sizes in human readable format (e.g., 1K 234M 2G)

       --si   like -h, but use powers of 1000 not 1024

       -k     like --block-size=1K

       -l, --count-links
              count sizes many times if hard linked

       -m     like --block-size=1M

       -L, --dereference

如果想以G为单位显示当前文件夹下的文件及文件夹大小：

$ du -a -B g . (或者 du -sh .)

我一下子也想不起该起什么标题，就取了这样一个不太合适的标题。
在这里我想说的是几种shell里的小括号,大括号结构和有括号的变量，命令的用法，如下：

上面是简单的例举四种模式匹配替换结构的用法。

以上内容为转贴，出处:http://www.linuxsir.org/bbs/showthread.php?t=180140

I/O重定向详解及应用实例

1、 基本概念（这是理解后面的知识的前提，请务必理解）

a、 I/O重定向通常与 FD有关，shell的FD通常为10个，即 0～9；

b、 常用FD有3个，为0（stdin，标准输入）、1（stdout，标准输出）、2（stderr，标准错误输出），默认与keyboard、monitor、monitor有关；

c、 用 < 来改变读进的数据信道(stdin)，使之从指定的档案读进；

d、 用 > 来改变送出的数据信道(stdout, stderr)，使之输出到指定的档案；

e、 0 是 < 的默认值，因此 < 与 0<是一样的；同理，> 与 1> 是一样的；

f、 在IO重定向 中，stdout 与 stderr 的管道会先准备好，才会从 stdin 读进资料；

g、 管道“|”(pipe line):上一个命令的 stdout 接到下一个命令的 stdin;

h、 tee 命令是在不影响原本 I/O 的情况下，将 stdout 复制一份到档案去;

i、 bash（ksh）执行命令的过程：分析命令－变量求值－命令替代（``和$( )）－重定向－通配符展开－确定路径－执行命令；

j、 ( ) 将 command group 置于 sub-shell 去执行，也称 nested sub-shell，它有一点非常重要的特性是：继承父shell的Standard input, output, and error plus any other open file descriptors。

k、 exec 命令：常用来替代当前 shell 并重新启动一个 shell，换句话说，并没有启动子 shell。使用这一命令时任何现有环境都将会被清除。exec 在对文件描述符进行操作的时候，也只有在这时，exec 不会覆盖你当前的 shell 环境。

2、 基本IO

cmd > file 把 stdout 重定向到 file 文件中；

cmd >> file 把 stdout 重定向到 file 文件中(追加)；

cmd 1> fiel 把 stdout 重定向到 file 文件中；

cmd > file 2>&1 把 stdout 和 stderr 一起重定向到 file 文件中；

cmd 2> file 把 stderr 重定向到 file 文件中；

cmd 2>> file 把 stderr 重定向到 file 文件中(追加)；

cmd >> file 2>&1 把 stderr 和 stderr 一起重定向到 file 文件中(追加)；

cmd < file >file2 cmd 命令以 file 文件作为 stdin，以 file2 文件作为 stdout；

cat <>file 以读写的方式打开 file；

cmd < file cmd 命令以 file 文件作为 stdin；

cmd << delimiter Here document，从 stdin 中读入，直至遇到 delimiter 分界符。

3、 进阶IO

>&n 使用系统调用 dup (2) 复制文件描述符 n 并把结果用作标准输出；

<&n 标准输入复制自文件描述符 n；

<&- 关闭标准输入（键盘）；

>&- 关闭标准输出；

n<&- 表示将 n 号输入关闭；

n>&- 表示将 n 号输出关闭；

上述所有形式都可以前导一个数字，此时建立的文件描述符由这个数字指定而不是缺省的 0 或 1。如：

... 2>file 运行一个命令并把错误输出(文件描述符 2)定向到 file。

... 2>&1 运行一个命令并把它的标准输出和输出合并。(严格的说是通过复制文件描述符 1 来建立文件描述符 2 ，但效果通常是合并了两个流。)

我 们对 2>&1详细说明一下 ：2>&1 也就是 FD2＝FD1 ，这里并不是说FD2 的值 等于FD1的值，因为 > 是改变送出的数据信道，也就是说把 FD2 的 “数据输出通道” 改为 FD1 的 “数据输出通道”。如果仅仅这样，这个改变好像没有什么作用，因为 FD2 的默认输出和 FD1的默认输出本来都是 monitor，一样的！ 但是，当 FD1 是其他文件，甚至是其他 FD 时，这个就具有特殊的用途了。请大家务必理解这一点。

exec 0exec 1>outfilename # 打开文件outfilename作为stdout。

exec 2>errfilename # 打开文件 errfilename作为 stderr。

exec 0<&- # 关闭 FD0。

exec 1>&- # 关闭 FD1。

exec 5>&- # 关闭 FD5。

问： 如果关闭了 FD0、FD1、FD2，其后果是什么？ 恢复 FD0、FD1、FD2与 关闭FD0、FD1、FD2 有什么区别？代码分别是什么？ 打开了FD3～FD9，我们用完之后，你觉得是将他们关闭还是恢复？

下面是提示（例子来源于CU一帖子，忘记出处，来日再补上）：

exec 6>&2 2>ver 
command >>dev/null & 
exec 2>&6 # 恢复 FD2

4、 简单举例

a、stdout和stderr都通过管道送给egrep了：

(ls you no 2>&1;ls yes 2>&1) 2>&1|egrep \* >file 
(ls you no 2>&1;ls yes 2>&1)|egrep \* >file 
(ls you no;ls yes) 2>&1|egrep \* >file

这个例子要注意的就是：

理 解 命令执行顺序 和 管道“|”：在命令执行前，先要进行重定向的处理，并将把 nested sub-shell 的stdout 接到 egrep 命令的 stdin。 nested sub-shell ，在 ( ) 中的两个命令加上（），可以看作一个命令。其 FD1 已经连接到“|”往egrep送了，当遇到 2>&1时，也就是FD2＝FD1，即FD2同FD1一样，往管道 “|”那边送。

b、 没有任何东西通过管道送给egrep，全部送往monitor。 (ls you no 2>&1;ls yes 2>&1) >&2|egrep \* >file。虽然在（）里面将 FD2转往FD1，但在（）外，遇到 >&2 ，结果所有的都送到monitor。 请理解：

(ls you no 2>&1) 1>&2|egrep \* >file ## 送到 monitor ls you no 2>&1 1>&2|egrep \* >file ## 送给 管道 “|” ls you no 1>&2 2>&1|egrep \* >file ## 送到 monitor

5、 中阶例子

条件： stderr通过管道送给egrep，正确消息仍然送给monitor（不变）

exec 4>&1;(ls you no 2>&1 1>&4 4>&-;ls yes 2>&1 1>
&4 4>&-)|egrep \* >file;exec 4>&- 
或者 
exec 4>&1;(ls you no;ls yes) 2>&1 1>
&4 4>&-|egrep \* >file;exec 4>&-

如果加两个条件：

（1）要求cmd1和cmd2并行运行；

（2）将cmd1的返回值赋给变量 ss。

则为：

exec 3>&1;exec 4>&1 
ss=$(((ls you no 2>&1 1>&3 3>&-;echo $? >&4)|egrep \* >file) 4>&1) 
exec 3>&-;exec 4>&-

说明：

exec 3>&1;4>&1 建立FD3，是用来将下面ls那条语句（子shell）中的FD1 恢复到正常FD1，即输出到monitor，你可以把FD3看作最初始的FD1的硬盘备份（即输出到monitor）；建立FD4，到时用作保存ls的返 回值（echo $?），你可以将FD4看作你考试时用于存放计算“echo $?”的草稿纸；

(ls you no 2>&1 1>&3 3>&-;echo $? >&4) 大家还记得前面说的子shell和管道吧。这条命令首先会继承FD0、FD1、FD2、FD3、FD4，它位于管道前，所以在运行命令前会先把子 shell自己的FD1和管道“|”相连。但是我们的条件是stderr通过管道送往egrep，stdout仍然输出到monitor。 于是通过2>&1，先把 子shell的FD1 的管道“送给”FD2，于是子shell中的stderr送往管道“|”；再通过 1>&3，把以前的“硬盘备份”恢复给子shell的FD1，于是子shell中的FD1变成送到monitor了。再通过 3>&- ，将3关闭；接着运行echo $? ，本来其输出值应该送往管道的，通过 >&4 ，将 输出 送往 “草稿纸”FD4，留以备用。

((ls you no 2>&1 1>&3 3>&-;echo $? >&4)|egrep \* >file) 于是，stderr 通过管道送给 egrep ，stdout 送给monitor，但是，还有 FD4，它送到哪去了？ $(((ls you no 2>&1 1>&3 3>&-;echo $? >&4)|egrep \* >file) 4>&1)最后的 4>&1 ，就是把FD4 重定向到 FD1。但由于其输出在 $( )中，其值就赋给变量ss了。最后一行关闭 FD3、FD4。

6、 高阶例子

命令 cmd1, cmd2, cmd3, cmd4. 如何利用单向管道完成下列功能：

1. 所有命令并行执行。

2. cmd1 和 cmd2 不需要 stdin。

3. cmd1 和 cmd2 的 stdout 定向到 cmd3 的 stdin。

4. cmd1 和 cmd2 的 stderr 定向到 cmd4 的 stdin。

5. cmd3 的 stdout 定向到文件 a, stderr 定向到屏幕。

6. cmd4 的 stdout 定向到文件 b, stderr 定向到屏幕。

7. cmd1 的返回码赋给变量 s。

8. 不能利用临时文件。

解决方法：

exec 3>&1; exec 4>&1 
s=$(((((cmd1 1>&3 ; echo $? >&4 )| cmd2 ) 3>
&1 | cmd3 >a 2>&3 ) 2>&1 | cmd4 >b ) 4>&1) 
exec 3>&-; exec 4>&-

这 个我一步步解释（好复杂，自己感觉看明白了，过一会再看，大脑仍然有几分钟空白～～～，没想到我也能看明白。exec 3>&1; exec 4>&1 前面的例子都有说明了，就是建立FD3 ，给cmd1恢复其FD1用和给cmd3 恢复其FD2用，建立FD4，保存“echo $?”输出值的“草稿纸”。

第一对 括号：(cmd1 1>&3 ; echo $? >&4 ) 和其后（第一个）管道。在第一个括号（子shell）中，其FD1已经连到 管道中了，所以用 FD3 将 FD1恢复正常，不让他往管道跑；这里的cmd1没有stdin，接着将 cmd1 运行的返回码 保存到 FD4 中。

第 二对括号：((cmd1 1>&3 ; echo $? >&4 )| cmd2 ) 3>&1 和其后（第二个）管道。前面的 FD1 已经不送给 cmd2了，FD2 默认也不送过来，所以cmd2 也没有stdin ，所以在第二对括号里面：cmd1和cmd2 的stdout、stderr 为默认输出，一直遇到 “3>&1”为止。请注意：“3>&1”，先将第二对括号看出一个命令，他们遇到 第二个管道时，其FD1 连到 管道 “|”，由于“3>&1”的作用，子shell的FD1 送给FD3 使用，所以所有FD3 的输出都 “流往”cmd3，又由于继承关系（继承第一行的命令），FD3实际上就是cmd1和cmd2的stdout，于是“ cmd1 和 cmd2 的 stdout 定向到 cmd3 的 stdin”

第三对括号：(((cmd1 1>&3 ; echo $? >&4 )| cmd2 ) 3>&1 | cmd3 >a 2>&3 ) 2>&1 和其后的第三个管道。cmd1 和 cmd2 的 stdout 已经定向到 cmd3 的 stdin，处理之后，cmd3 >a 意味着将其 stdout 送给 a 文件。而2>&3的意思是：恢复cmd3的错误输出为FD3，即送往 monitor。于是“cmd3 的 stdout 定向到文件 a, stderr 定向到屏幕”。如果没有“2>&3”，那么cmd3的错误输出就会干扰cmd1和cmd2的错误输出，所以它是必须的！请注意第三对括号后 的 “2>&1”| ，其子shell的FD1 本来连接着管道“|”，但子shell FD1 慷慨大方，送给了 FD2，于是FD2 连接着管道。还记得前面的 cmd1 和 cmd2 吗？他们的stderr一直没动了。于是在这里，通过管道送给了 第四个命令cmd4 了。即“cmd1 和 cmd2 的 stderr 定向到 cmd4 的 stdin”。后面就比较简单了。cmd4 >b 表示“cmd4 的 stdout 定向到文件 b, stderr 定向到屏幕（默认）”

第四对括 号：((((cmd1 1>&3 ; echo $? >&4 )| cmd2 ) 3>&1 | cmd3 >a 2>&3 ) 2>&1 | cmd4 >b ) 与其后的 4>&1。四对括号里面的 FD1、FD2都处理完了。但是还记得前面“echo $? >&4”那块“草稿纸”吗？“4>&1”的作用就是“将草稿纸上的内容送给monitor”，但是由于最外面还有 $() 将其“包着”。于是其值赋给变量“s”。

出处：http://www.xxlinux.com/linux/article/development/shell/2006-10-16/5018.html

Bash shell 的算术运算有四种方式:
1：使用 expr 外部程式

加法 r=`expr 4 + 5`
echo $r
注意! '4' '+' '5' 这三者之间要有空白
r=`expr 4 * 5` #错误
乘法 r=`expr 4 \* 5`

2：使用 $(( ))
r=$(( 4 + 5 ))
echo $r

3：使用 $[ ]

r=$[ 4 + 5 ]
echo $r

乘法
r=`expr 4 \* 5`
r=$(( 4 * 5 ))
r=$[ 4 * 5 ]
echo $r

除法
r=`expr 40 / 5`
r=$(( 40 / 5 ))
r=$[ 40 / 5 ]
echo $r

减法
r=`expr 40 - 5`
r=$(( 40 - 5 ))
r=$[ 40 - 5 ]
echo $r

求余数
r=$[ 100 % 43 ]
echo $r

乘幂 (如 2 的 3 次方)
r=$(( 2 ** 3 ))
r=$[ 2 ** 3 ]
echo $r
注：expr 沒有乘幂

4：使用let 命令
加法：
n=10
let n=n+1
echo $n #n=11

乘法：
let m=n*10
echo $m

除法：
let r=m/10
echo $r

求余数：
let r=m%7
echo $r

乘冪：
let r=m**2
echo $r

虽然Bash shell 有四种算术运算方法，但并不是每一种都是跨平台的，建议使用expr。
另外，我们在 script 中经常有加1操作，以下四法皆可：
m=$[ m + 1]
m=`expr $m + 1`
m=$(($m + 1))
let m=m+1

转载注明出处：http://www.cppblog.com/fwxjj/archive/2009/09/04/95342.html

不像在C里面if else根据数目和相对位置匹配，在R中，if else 靠行来匹配，例如

if(condition1) {

        statement1

        if(subcondition1) {

                  substatement1

         } else {

                  substatement2

                   }

} else {

       statement2

           }

这里 "} else"要放在一行，不然会出错。

ANSI-C Quoting

Words of the form $'string' are treated specially. The word expands to string, with backslash-escaped characters replaced as specifed by the ANSI C standard. Backslash escape sequences, if present, are decoded as follows:

\a

alert (bell)

\b

backspace

\e

an escape character (not ANSI C)

\f

form feed

\n

newline

\r

carriage return

\t

horizontal tab

\v

vertical tab

\\

backslash

\'

single quote

\nnn

the character whose ASCII code is the octal value nnn (one to three digits)

\xnnn

the character whose ASCII code is the hexadecimal value nnn (one to three digits)

The expanded result is single-quoted, as if the dollar sign had not been present.

也就是说如果你想在source.txt里面grep匹配tab+targetword内容，那么写法应该是：

grep $'\t'targetword  source.txt.

shell的逻辑运算符 涉及有以下几种类型，因此只要适当选择，可以解决我们很多复杂的判断，达到事半功倍效果。

一、逻辑运算符

二、逻辑表达式

• test 命令

使用方法：test EXPRESSION

如：

[root@localhost ~]# test 1 = 1 && echo 'ok'
ok

[root@localhost ~]# test -d /etc/ && echo 'ok'
ok

[root@localhost ~]# test 1 -eq 1 && echo 'ok'
ok

 

[root@localhost ~]# if test 1 = 1 ; then echo 'ok'; fi
ok

注意：所有字符 与逻辑运算符直接用“空格”分开，不能连到一起。

• 精简表达式

• [] 表达式

[root@localhost ~]# [ 1 -eq 1 ] && echo 'ok'          
ok

[root@localhost ~]# [ 2 < 1 ] && echo 'ok'                 
-bash: 2: No such file or directory

[root@localhost ~]# [ 2 \< 1 ] && echo 'ok'

[root@localhost ~]# [ 2 -gt 1 -a 3 -lt 4 ] && echo 'ok'

ok    

[root@localhost ~]# [ 2 -gt 1 && 3 -lt 4 ] && echo 'ok'  
-bash: [: missing `]'

注意：在[] 表达式中，常见的>,<需要加转义字符，表示字符串大小比较，以acill码 位置作为比较。 不直接支持<>运算符，还有逻辑运算符|| && 它需要用-a[and] –o[or]表示

 

 

• [[]] 表达式

[root@localhost ~]# [ 1 -eq 1 ] && echo 'ok'          
ok

[root@localhost ~]$ [[ 2 < 3 ]] && echo 'ok'
ok

[root@localhost ~]$ [[ 2 < 3 && 4 > 5 ]] && echo 'ok'
ok

注意：[[]] 运算符只是[]运算符的扩充。能够支持<,>符号运算不需要转义符，它还是以字符串比较大小。里面支持逻辑运算符：|| &&

 

三、性能比较

bash的条件表达式中有三个几乎等效的符号和命令：test，[]和[[]]。通常，大家习惯用if [];then这样的形式。而[[]]的出现，根据ABS所说，是为了兼容><之类的运算符。以下是比较它们性能，发现[[]]是最快的。

$ time (for m in {1..100000}; do test -d .;done;)
real    0m0.658s
user    0m0.558s
sys     0m0.100s

$ time (for m in {1..100000}; do [ -d . ];done;)
real    0m0.609s
user    0m0.524s
sys     0m0.085s

$ time (for m in {1..100000}; do [[ -d . ]];done;)
real    0m0.311s
user    0m0.275s
sys     0m0.036s

转载注明出处：http://www.cnblogs.com/chengmo/archive/2010/10/01/1839942.html

当正则表达式中的pattern部分使用变量时，应当注意转义符的解释问题。

my $a = "MGI:87854|Ensembl:ENSMUSG00000030359";
my $pattern = "MGI:\d+";
if($a =~ /$pattern/){
print "$&\n";
}

这样写本来的意图是匹配MGI:87854，但是却达不到效果，是因为逃逸符本身没有被逃逸而被perl解释器解释掉了，所以应当这样写pattern：

my $pattern = "MGI:\\d+";

注意，若将双引号换成但引号，则pattern仍可写成MGI:\d+形式，这也说明perl对引号的解释机制类似于bash，双引号的解释强度强于单引号，单引号中\不被解释称转义字符。

另外，若想匹配在正则表达式系统中有特殊含义的字符：\,|,^,$,则需要在pattern中提前加一个转义\。