查看cpu信息（型号）
# cat /proc/cpuinfo | grep name | cut -f2 -d: | uniq -c

查看内存信息
# cat /proc/meminfo

查看主板型号：
# dmidecode |grep -a16 "system information$"

查看机器型号
# dmidecode | grep "product name"

查看当前操作系统内核信息
# uname -a

查看当前操作系统发行版信息
# cat /etc/issue | grep linux

所有日期、时间的api都在datetime模块内。

1. datetime => string

now = datetime.datetime.now()
now.strftime('%y-%m-%d %h:%m:%s')
#输出2012-03-05 16:26:23.870105

strftime是datetime类的实例方法。

2. string => datetime

t_str = '2012-03-05 16:26:23'
d = datetime.datetime.strptime(t_str, '%y-%m-%d %h:%m:%s')

strptime是datetime类的静态方法。

2. 日期比较操作

在datetime模块中有timedelta类，这个类的对象用于表示一个时间间隔，比如两个日期或者时间的差别。

构造方法：

datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)

所有的参数都有默认值0，这些参数可以是int或float，正的或负的。

可以通过timedelta.days、tiemdelta.seconds等获取相应的时间值。

timedelta类的实例，支持加、减、乘、除等操作，所得的结果也是timedelta类的实例。比如：

year = timedelta(days=365)
ten_years = year *10
nine_years = ten_years - year

同时，date、time和datetime类也支持与timedelta的加、减运算。

datetime1 = datetime2  /- timedelta
timedelta = datetime1 - datetime2

这样，可以很方便的实现一些功能。

1. 两个日期相差多少天。

d1 = datetime.datetime.strptime('2012-03-05 17:41:20', '%y-%m-%d %h:%m:%s')
d2 = datetime.datetime.strptime('2012-03-02 17:41:20', '%y-%m-%d %h:%m:%s')
delta = d1 - d2
print delta.days

输出：3

2. 今天的n天后的日期。

now = datetime.datetime.now()
delta = datetime.timedelta(days=3)
n_days = now   delta
print n_days.strftime('%y-%m-%d %h:%m:%s')

输出：2012-03-08 17:44:50

#coding=utf-8
import datetime
now=datetime.datetime.now()
print now
#将日期转化为字符串 datetime => string
print now.strftime('%y-%m-%d %h:%m:%s')
t_str = '2012-03-05 16:26:23'
#将字符串转换为日期 string => datetime
d=datetime.datetime.strptime(t_str,'%y-%m-%d %h:%m:%s')
print d
#在datetime模块中有timedelta类，这个类的对象用于表示一个时间间隔，比如两个日#期或者时间的差别。
#计算两个日期的间隔
d1 = datetime.datetime.strptime('2012-03-05 17:41:20', '%y-%m-%d %h:%m:%s')
d2 = datetime.datetime.strptime('2012-03-02 17:41:20', '%y-%m-%d %h:%m:%s')
delta = d1 - d2
print delta.days
print delta
#今天的n天后的日期。
now=datetime.datetime.now()
delta=datetime.timedelta(days=3)
n_days=now delta
print n_days.strftime('%y-%m-%d %h:%m:%s')

直接看代码示例吧。

(1) 顺序执行的代码

 1 #!/bin/bash  2 date  3 for i in `seq 1 5`  4 do  5 {  6     echo "sleep 5"  7     sleep 5  8 }  9 done 10 date 

输出：

sat nov 19 09:21:51 cst 2016 sleep 5 sleep 5 sleep 5 sleep 5 sleep 5 sat nov 19 09:22:16 cst 2016

(2) 并行代码

使用'&' wait 实现“多进程”实现

 1 #!/bin/bash  2 date  3 for i in `seq 1 5`  4 do  5 {  6     echo "sleep 5"  7     sleep 5  8 } &  9 done 10 wait  ##等待所有子后台进程结束 11 date

输出：

sat nov 19 09:25:07 cst 2016 sleep 5 sleep 5 sleep 5 sleep 5 sleep 5 sat nov 19 09:25:12 cst 2016

 (3) 对于大量处理任务如何实现启动后台进程的数量可控？

　　简单的方法可以使用2层for/while循环实现，每次wait内层循环的多个后台程序执行完成。

　　但是这种方式的问题是，如果内层循环有“慢节点”可能导致整个任务的执行执行时间长。

　　更高级的实现可以看(4)

(4) 使用命名管道(fifo)实现每次启动后台进程数量可控。 

 1 #!/bin/bash  2   3 function my_cmd(){  4     t=$random  5     t=$[t%15]  6     sleep $t  7     echo "sleep $t s"  8 }  9  10 tmp_fifofile="/tmp/$$.fifo"  11 mkfifo $tmp_fifofile      # 新建一个fifo类型的文件 12 exec 6<>$tmp_fifofile     # 将fd6指向fifo类型 13 rm $tmp_fifofile    #删也可以 14  15 thread_num=5  # 最大可同时执行线程数量 16 job_num=100   # 任务总数 17  18 #根据线程总数量设置令牌个数 19 for ((i=0;i<${thread_num};i  ));do 20     echo 21 done >&6  22  23 for ((i=0;i<${job_num};i  ));do # 任务数量 24     # 一个read -u6命令执行一次，就从fd6中减去一个回车符，然后向下执行， 25     # fd6中没有回车符的时候，就停在这了，从而实现了线程数量控制 26     read -u6  27  28     #可以把具体的需要执行的命令封装成一个函数 29     {    30         my_cmd 31     } & 32  33     echo >&6 # 当进程结束以后，再向fd6中加上一个回车符，即补上了read -u6减去的那个 34 done 35  36 wait 37 exec 6>&- # 关闭fd6 38 echo "over"

参考:http://lawrence-zxc.github.io/2012/06/16/shell-thread/

可参照：http://www.voidcn.com/blog/vindra/article/p-4917667.html

一、get请求 

curl "http://www.baidu.com"  如果这里的url指向的是一个文件或者一幅图都可以直接下载到本地

curl -i "http://www.baidu.com"  显示全部信息

curl -l "http://www.baidu.com" 只显示头部信息

curl -v "http://www.baidu.com" 显示get请求全过程解析

wget "http://www.baidu.com"也可以

二、post请求

curl -d "param1=value1¶m2=value2" "http://www.baidu.com"

三、json格式的post请求

curl -l -h "content-type: application/json" -x post -d '{"phone":"13521389587","password":"test"}' http://domain/apis/users.json

例如：

curl -l -h "content-type: application/json" -x post -d '{"ver": "1.0","soa":{"req":"123"},"iface":"me.ele.lpdinfra.prediction.service.predictionservice","method":"restaurant_make_order_time","args":{"arg2":"\"stable\"","arg1":"{\"code\":[\"wind\"],\"temperature\":11.11}","arg0":"{\"tracking_id\":\"100000000331770936\",\"eleme_order_id\":\"100000000331770936\",\"platform_id\":\"4\",\"restaurant_id\":\"482571\",\"dish_num\":1,\"dish_info\":[{\"entity_id\":142547763,\"quantity\":1,\"category_id\":1,\"dish_name\":\"[0xe7][0x89][0xb9][0xe4][0xbb][0xb7][0xe8][0x85][0x8a][0xe5][0x91][0xb3][0xe5][0x8f][0x89][0xe7][0x83][0xa7][0xe5][0x8f][0x8c][0xe6][0x8b][0xbc][0xe7][0x85][0xb2][0xe4][0xbb][0x94][0xe9][0xa5][0xad]\",\"price\":31.0}],\"merchant_location\":{\"longitude\":\"121.47831425\",\"latitude\":\"31.27576153\"},\"customer_location\":{\"longitude\":\"121.47831425\",\"latitude\":\"31.27576153\"},\"created_at\":1477896550,\"confirmed_at\":1477896550,\"dishes_total_price\":0.0,\"food_boxes_total_price\":2.0,\"delivery_total_price\":2.0,\"pay_amount\":35.0,\"city_id\":\"1\"}"}}' http://vpcb-lpdinfra-stream-1.vm.elenet.me:8989/rpc

ps：json串内层参数需要格式化

blogjava-凯发k8网页登录

1.1. 功能

1. 一个安全认证协议

2. 用tickets验证

3. 避免本地保存密码和在互联网上传输密码

4. 包含一个可信任的第三方

5. 使用对称加密

6. 客户端与服务器（非kdc）之间能够相互验证

kerberos只提供一种功能——在网络上安全的完成用户的身份验证。它并不提供授权功能或者审计功能。

1.2. 概念

首次请求，三次通信方

• the authentication server
• the ticket granting server
• the service or host machine that you’re wanting access to.

图 1‑1 角色

其他知识点

• 每次通信，消息包含两部分，一部分可解码，一部分不可解码
• 服务端不会直接有kdc通信
• kdc保存所有机器的账户名和密码
• kdc本身具有一个密码

　　我们这里已获取服务器中的一张表（数据）的服务以为，为一个http服务。

2.1. 你和验证服务

　　如果想要获取http服务，你首先要向kdc表名你自己的身份。这个过程可以在你的程序启动时进行。kerberos可以通过kinit获取。介绍自己通过未加密的信息发送至kdc获取ticket granting ticket (tgt)。

（1）信息包含

• 你的用户名/id
• 你的ip地址
• tgt的有效时间

　　authentication server收到你的请求后，会去数据库中验证，你是否存在。注意，仅仅是验证是否存在，不会验证对错。

　　如果存在，authentication server会产生一个随机的session key(可以是一个64位的字符串)。这个key用于你和ticket granting server (tgs)之间通信。

（2）回送信息

　　authentication server同样会发送两部分信息给你，一部分信息为tgt，通过kdc自己的密码进行加密，包含：

• 你的name/id
• tgs的name/id
• 时间戳
• 你的ip地址
• tgt的生命周期
• tgs session key

另外一部分通过你的密码进行加密，包含的信息有

• tgs的name/id
• 时间戳
• 生命周期
• tgs session key

图 2‑1 第一次通信

　　如果你的密码是正确的，你就能解密第二部分信息，获取到tgs session key。如果，密码不正确，无法解密，则认证失败。第一部分信息tgt，你是无法解密的，但需要展示缓存起来。

2.2. 你和tgs

如果第一部分你已经成功，你已经拥有无法解密的tgt和一个tgs session key。

（1）    请求信息

　a)  通过tgs session key加密的认证器部分：

• 你的name/id
• 时间戳

b)       明文传输部分：

• 请求的http服务名（就是请求信息）
• http service的ticket生命周期

c)        tgt部分

　　ticket granting server收到信息后，首先检查数据库中是否包含有你请求的http服务名。如果无，直接返回错误信息。

　　如果存在，则通过kdc的密码解密tgt，这个时候。我们就能获取到tgs session key。然后，通过tgs session key去解密你传输的第一部分认证器，获取到你的用户名和时间戳。

tgs再进行验证：

1. 对比tgt中的用户名与认证器中的用户名
2. 比较时间戳（网上有说认证器中的时间错和tgt中的时间错，个人觉得应该是认证器中的时间戳和系统的时间戳），不能超过一定范围
3. 检查是否过期
4. 检查ip地址是否一致
5. 检查认证器是否已在tgs缓存中（避免应答攻击）
6. 可以在这部分添加权限认证服务

　　tgs随机产生一个http service session key, 同时准备http service ticket(st)。

（2）    回答信息

　　a)        通过http服务的密码进行加密的信息（st）：

• 你的name/id
• http服务name/id
• 你的ip地址
• 时间戳
• st的生命周期
• http service session key

　　b)       通过tgs session key加密的信息

• http服务name/id
• 时间戳
• st的生命周期
• http service session key

　　你收到信息后，通过tgs session key解密，获取到了http service session key，但是你无法解密st。

图 2‑2 第二次通信

2.3. 你和http服务

　　在前面两步成功后，以后每次获取http服务，在ticket没有过期，或者无更新的情况下，都可直接进行这一步。省略前面两个步骤。

（1）    请求信息

　　a)        通过http service session key，加密部分

• 你的name/id
• 时间戳

　　b)       st

　　　http服务端通过自己的密码解压st（kdc是用http服务的密码加密的），这样就能够获取到http service session key，解密第一部分。

服务端解密好st后，进行检查

1. 对比st中的用户名（kdc给的）与认证器中的用户名
2. 比较时间戳（网上有说认证器中的时间错和tgt中的时间错，个人觉得应该是认证器中的时间戳和系统的时间戳），不能超过一定范围
3. 检查是否过期
4. 检查ip地址是否一致
5. 检查认证器是否已在http服务端的缓存中（避免应答攻击）

（2）    应答信息

a)        通过http service session key加密的信息

• http服务name/id
• 时间戳

图 2‑3 第三次通信

　　你在通过缓存的http service session key解密这部分信息，然后验证是否是你想要的服务器发送给你的信息。完成你的服务器的验证。

至此，整个过程全部完成。

所谓bom，全称是，它是一个unicode字符，通常出现在文本的开头，用来标识字节序（big/little endian），除此以外还可以标识编码（utf-8/16/32），如果出现在文本中间，则解释为。 注：unicode相关知识的详细介绍请参考。

对于utf-8/16/32而言，它们名字中的8/16/32指的是编码单位是多少位的，也就是说，它们的编码单位分别是8/16/32位，换算成字节就
是1/2/4字节，如果是多字节，就要牵扯到字节序，utf-8以单字节为编码单位，所以不存在字节序。
utf-8主要的优点是可以兼容ascii，但如果使用bom的话，这个好处就荡然无存了，除此以外，bom的存在还可能引发一些问题，比如下面错误便都
有可能是bom导致的：

• shell: no such file or directory
  
• php: warning: cannot modify header information – headers already sent
  

在详细讨论utf-8编码中bom的检测与删除问题前，不妨先通过一个例子热热身：

shell> curl -s http://phone.10086.cn/ | head -1 | sed -n l
\357\273\277//en" "http://www.w3.org/tr/xhtml1/dtd/xhtml1-transitional.dtd">\r$

如上所示，前三个字节分别是357、273、277，这就是八进制的bom。

shell> curl -s http://phone.10086.cn/ | head -1 | hexdump -c
00000000  ef bb bf 3c 21 44 4f 43 54 59 50 45 20 68 74 6d |...00000010 6c 20 50 55 42 4c 49 43 20 22 2d 2f 2f 57 33 43 |l public "-//w3c|
00000020  2f 2f 44 54 44 20 58 48  54 4d 4c 20 31 2e 30 20  |//dtd xhtml 1.0 |
00000030  54 72 61 6e 73 69 74 69  6f 6e 61 6c 2f 2f 45 4e  |transitional//en|
00000040  22 20 22 68 74 74 70 3a  2f 2f 77 77 77 2e 77 33  |" "http://www.w3|
00000050  2e 6f 72 67 2f 54 52 2f  78 68 74 6d 6c 31 2f 44  |.org/tr/xhtml1/d|
00000060  54 44 2f 78 68 74 6d 6c  31 2d 74 72 61 6e 73 69  |td/xhtml1-transi|
00000070  74 69 6f 6e 61 6c 2e 64  74 64 22 3e 0d 0a        |tional.dtd">..|

如上所示，前三个字节分别是ef、bb、bf，这就是十六进制的bom。 注：用到了第三方网站的页面，不能保证例子始终可用。
实际做项目开发时，可能会面对成百上千个文本文件，如果有几个文件混入了bom，那么很难察觉，如果没有带bom的utf-8文本文件，可以用vi杜撰几
个，相关命令如下：

设置utf-8编码：

:set fileencoding=utf-8

添加bom：

:set bomb

删除bom：

:set nobomb

查询bom：

:set bomb?

如何检测utf-8编码中的bom呢？

shell> grep -r -i -l $'^\xef\xbb\xbf' /path

如何删除utf-8编码中的bom呢？

shell> grep -r -i -l $'^\xef\xbb\xbf' /path | xargs sed -i 's/^\xef\xbb\xbf//;q'

推荐：如果你使用svn的话，可以在pre-commit钩子里加上相关代码用以杜绝bom。

#!/bin/bash

repos="$1"
txn="$2"

svnlook=/usr/bin/svnlook

for file in $($svnlook changed -t "$txn" "$repos" | awk '/^[au]/ {print $nf}'); do
 if $svnlook cat -t "$txn" "$repos" "$file" | grep -q $'^\xef\xbb\xbf'; then
        echo "byte order mark be found in $file" 1>&2
 exit 1
 fi
done

本文用到了很多shell命令，篇幅所限，恕不详述，如果有不明白的就请自己搜索吧。

当我们需要把二进制转成c语言中使用的16进制字符数组时，命令xxd是很有用的。

xxd 帮助信息如下：关键选项标黑。

[root@localhost ]# xxd --help
usage:
       xxd [options] [infile [outfile]]
    or
       xxd -r [-s [-]offset] [-c cols] [-ps] [infile [outfile]]
options:
    -a          toggle autoskip: a single '*' replaces nul-lines. default off.
    -b          binary digit dump (incompatible with -p,-i,-r). default hex.
    -c cols     format octets per line. default 16 (-i: 12, -ps: 30).
    -e          show characters in ebcdic. default ascii.
    -g          number of octets per group in normal output. default 2. 每个goup的字节数，默认为2，可设置。
    -h          print this summary.
    -i          output in c include file style. ：输出为c包含文件的风格，数组方式存在。
    -l len      stop after octets.        ：转换到len个字节后停止转换。
    -ps         output in postscript plain hexdump style.
    -r          reverse operation: convert (or patch) hexdump into binary.
    -r -s off   revert with added to file positions found in hexdump.
    -s [ ][-]seek start at bytes abs. (or : rel.) infile offset.
   -u          use upper case hex letters. ： 字节大写方式
    -v          show version: "xxd v1.10 27oct98 by juergen weigert".

比如运行：

> xxd -g 1 -i -u -l 10000000 nm.ts > xxd_test.txt

生成的文本显示：

unsigned char __0513_1634_ch32_666_10_ts[] = {
0x47, 0x02, 0x03, 0x13, 0xf8, 0x5a, 0xc5, 0x40, 0x26, 0xe4, 0xd0, 0xde,
0xad, 0xb8, 0x76, 0x89, 0x85, 0x23, 0x06, 0x04, 0x6e, 0x05, 0x8b, 0x09,
0xc0, 0x5c, 0x96, 0x4f, 0x18, 0x51, 0x41, 0xc8, 0x40, 0x9f, 0x06, 0x93,
0x38, 0xc1, 0xbb, 0x1a, 0xbc, 0xac, 0x47, 0xff, 0x5e, 0x54, 0xeb, 0xa7,
0x14, 0x36, 0x85, 0x8a, 0x90, 0x14, 0x17, 0xa2, 0x9d, 0xc0, 0x84, 0x56,
0xcb, 0x97, 0x78, 0xc8, 0x57, 0x15, 0x3e, 0x61, 0x6f, 0xfe, 0xc9, 0x39,
0xef, 0xd3, 0xb6, 0x6a, 0xd2, 0xe4, 0xfb, 0x4c, 0x05, 0xf6, 0x03, 0xed,
0x50, 0xb3, 0xe7, 0x46, 0x57, 0x24, 0x71, 0x16, 0x38, 0x45, 0x53, 0x19,
0x56, 0x25, 0x3c, 0x8d, 0x4c, 0xa9, 0x28, 0x9a, 0xb2, 0x99, 0x76, 0x52,
0x28, 0xe9, 0xd6, 0xd6, 0x11, 0x94, 0x89, 0x19, 0x4d, 0xea, 0x68, 0x76,
0x53, 0xc6, 0xaa, 0x3a, 0xd4, 0xa1, 0x25, 0xa5, 0x03, 0xb0, 0x73, 0xa0,
0xae, 0x11, 0xc9, 0xbd, 0x37, 0x17, 0x11, 0x5f, 0x30, 0x34, 0x34, 0x0b

.....

};

unsigned int nm.ts_len = 10000000;

另外，在vim中也可以把文件转换为16进制来显示：

:%!xxd

返回正常显示：

:%!xxd -r

linux下查看二进制文件
以十六进制格式输出：
od [选项] 文件
od -d 文件  十进制输出
   -o 文件  八进制输出
   -x 文件  十六进制输出
xxd 文件  输出十六进制

在vi命令状态下：
:%!xxd   :%!od    将当前文本转化为16进制格式
:%!xxd -c 12 每行显示12个字节
:%!xxd -r    将当前文本转化回文本格式

一、ifs 介绍

     shell 脚本中有个变量叫 ifs(internal field seprator) ，内部域分隔符。完整定义是the shell uses the value stored in ifs, which is the space, tab, and newline characters by default, to delimit words for the read and set commands, when parsing output from command substitution, and when performing variable substitution.

     shell 的环境变量分为 set, env 两种，其中 set 变量可以通过 export 工具导入到 env 变量中。其中，set 是显示设置shell变量，仅在本 shell 中有效；env 是显示设置用户环境变量 ，仅在当前会话中有效。换句话说，set 变量里包含了 env 变量，但 set 变量不一定都是 env 变量。这两种变量不同之处在于变量的作用域不同。显然，env 变量的作用域要大些，它可以在 subshell 中使用。

     而 ifs 是一种 set 变量，当 shell 处理"命令替换"和"参数替换"时，shell 根据 ifs 的值，默认是 space, tab, newline 来拆解读入的变量，然后对特殊字符进行处理，最后重新组合赋值给该变量。

二、ifs 简单实例

1、查看变量 ifs 的值。

$ echo $ifs  $ echo "$ifs" | od -b 0000000 040 011 012 012 0000004

直接输出ifs是看不到的，把它转化为二进制就可以看到了，"040"是空格，"011"是tab，"012"是换行符"\n" 。最后一个 012 是因为 echo 默认是会换行的。

2、$* 和 $@ 的细微差别
     从下面的例子中可以看出，如果是用冒号引起来，表示这个变量不用ifs替换！！所以可以看到这个变量的"原始值"。反之，如果不加引号，输出时会根据ifs的值来分割后合并输出！ $* 是按照ifs中的第一个值来确定的！下面这两个例子还有细微的差别！

$ ifs=:; $ set x y z $ echo $* x y z $ echo "$*" x:y:z $ echo $@ x y z $ echo "$@" x y z

$ set "x" "y z" $ echo $* x y z $ echo "$*" x:y z $ echo $@ x y z $ echo "$@" x y z $ echo $* |od -b 0000000 170 040 171 040 172 012 0000006 $ echo "$*" |od -b 0000000 170 072 171 040 172 012 0000006

小结：$* 会根据 ifs 的不同来组合值，而 $@ 则会将值用" "来组合值！

3、for 循环中的奇怪现象

$ for x in $var ;do echo $x |od -b ;done 0000000 012 0000001 0000000 040 141 012 0000003 0000000 142 012 0000002 0000000 012 0000001 0000000 143 012 0000002

$ echo $var |od -b 0000000 040 040 141 040 142 040 040 143 012 0000011 $ echo "$var" |od -b 0000000 072 040 141 072 142 072 072 143 072 012 0000012

"$var"的值应该没做替换，所以还是 ": a:b::c:" (注 "072" 表示冒号)，但是$var 则发生了变化！注意输出的最后一个冒号没有了，也没有替换为空格！why？

使用 $var 时是经历了这样一个过程！首先，按照这样的规则 [变量][ifs][变量][ifs]……根据原始 var 值中所有的分割符(此处是":")划分出变量，如果ifs的值是有多个字符组成，如ifs=":;"，那么此处的[ifs]指的是ifs中的任意一个字符($* 是按第一个字符来分隔！)，如 ":" 或者 ";" ，后面不再对[ifs]做类似说明！(注：[ifs]会有多个值，多亏 的提醒)；然后，得到类似这样的 list， ""   " a"   "b"  ""   "c"  。如果此时 echo $var，则需要在这些变量之间用空格隔开，也就是""  [space]   "  a"  [space]  "b" [space]  "" [space]  "c" ，忽略掉空值，最终输出是 [space][space]a[space]b[space][space]c ！

如果最后一个字符不是分隔符，如 var="a:b"，那么最后一个分隔符后的变量就是最后一个变量！

这个地方要注意下！！如果ifs就是空格，那么类似于" [space][space]a[space]b[space][space]c "会合并重复的部分，且去头空格，去尾空格，那么最终输出会变成类似 a[space]b[space]c ，所以，如果ifs是默认值，那么处理的结果就很好算出来，直接合并、忽略多余空格即可！

另外，$* 和 $@ 在函数中的处理过程是这样的(只考虑"原始值"！)！"$@"，就是像上面处理后赋值，但是 "$*" 却不一样！它的值是用分隔符(如":")而不是空格隔开！具体例子见最后一个例子！

好了，现在来解释 for 循环的内容。for 循环遍历上面这个列表就可以了，所以 for 循环的第一个输出是空！("012"是echo输出的换行符 )。。。。后面的依次类推！不信可以试试下面这个例子，结果是一样的！

$ for x in "" " a" "b" "" "c" ;do echo $x |od -b ;done 0000000 012 0000001 0000000 040 141 012 0000003 0000000 012 0000001 0000000 142 012 0000002 0000000 012 0000001 0000000 143 012 0000002

三、ifs的其他实例

example 1:

$ ifs=: $ var=ab::cd $ echo $var ab  cd $ echo "$var" ab::cd

example 2 :

$ read a        xy  z $ echo $a xy  z

解释：这是  上的一个例子。此时ifs是默认值，本希望把所有的输入(包括空格)都放入变量a中，但是输出的a却把前面的空格给忽略了！！原因是：默认的 ifs 会按 space tab newline 来分割。这里需要注意的一点是，read 命令的实现过程，即在读入时已经替换了。解决办法是在开头加上一句 ifs=";" ，这里必须加上双引号，因为分号有特殊含义。

example 3 :

$ tmp="   xy z" $ a=$tmp $ echo $a $ echo "$a"

解释：什么时候会根据 ifs 来"处理"呢？我觉得是，对于不加引号的变量，使用时都会参考ifs，但是要注意其原始值！

example 4 ：

#!/bin/bash ifs_old=$ifs      #将原ifs值保存，以便用完后恢复 ifs=$’\n’        #更改ifs值为$’\n’ ，注意，以回车做为分隔符，ifs必须为：$’\n’ for i in $((cat pwd.txt)) #pwd.txt 来自这个命令：cat /etc/passwd >pwd.txt do     echo $i done ifs=$ifs_old      #恢复原ifs值

example 5 :

#!/bin/bash  ip=220.112.253.111 ifs="." tmpip=$(echo $ip) ifs=" " # space echo $tmpip for x in $tmpip ;do      xip="${x}.$xip" done echo ${xip%.}

complex_example 1:  

function output_args_ifs(){     echo "=$*"     echo "="$*     for m in $* ;do          echo "[$m]"     done }  ifs=':' var='::a:b::c:::' output_args_ifs $var

输出为：

=::a:b::c::  # 少了最后一个冒号！看前面就知道为什么了 =  a b  c  [] [] [a] [b] [] [c] []

由于 "output_args_ifs $var" 中 $var 没有加引号，所以根据ifs替换！根据ifs划分出变量： ""  ""  "a"  "b"  ""  "c" "" ""(可以通过输出 $# 来测试参数的个数！)，重组的结果为

 "$@" 的值是  "" [space] "" [space]  "a" [space]  "b"  [space] "" [space]  "c" [space] "" [space] ""，可以通过，echo==>"  a b  c   "
"$*" 的值是   "" [ifs] "" [ifs]  "a" [ifs]  "b"  [ifs] "" [ifs]  "c" [ifs] "" [ifs] ""，忽略""，echo=>"::a:b::c::"

注意， $* 和 $@ 的值都是  ""   ""   "a"   "b"   ""   "c"  ""  "" 。可以说是一个列表……因为他们本来就是由 $1 $2 $3……组成的。

所以，《linux程序设计》里推荐使用 $@，而不是$*

总结：ifs 其实还是很麻烦的，稍有不慎就会产生很奇怪的结果，因此使用的时候要注意！我也走了不少弯路，只希望能给后来者一些帮助。本文若有问题，欢迎指正！！谢谢！

如有转载，请注明
参考：

在项目中遇到一个奇怪的bug，是由一行简单代码引起的。
代码作用：比较两个unix文本文件，找出并打印文本2比文本1新增加的内容。
代码调用了diff命令，例如：
 
 

# diff命令输出结果

说明：输出结果去掉了两个文件的共同内容，只输出了temp2.txt的新增部分，和预想的结果一样。
 
但是，随着temp1.txt文件内容的增加，diff命令出现了不同预期的结果：

可以看到，diff命令不但输出了temp2.txt文件的新增部分（20110304-20110314），也同时输出了两个文件的共同内容（20110228-20110303），从而导致了与预期不一致的结果。
查看diff命令的man手册发现，diff的作用是比较两个文件的内容，并输出两个文件之间的差异，产生一个能够将两个文件互相转换的列表，但这个列表并不能100%保证是最小集。
于是，以上例子中，可以看到diff给出了temp1.txt和temp2.txt文件的比较差异结果，但其中包含了两个文件的共同部分，因此与预期不一样。
 
解决方法：
用comm命令代替diff，例如：

comm命令用来比较两个文件，具体用法：
comm [-123] file1 file2
-1 过滤file1独有的内容
-2 过滤file2独有的内容
-3 过滤file1和file2重复的内容
 
备注：
diff的输出格式，主要有以下几种：
n1 a n3,n4
n1,n2 d n3
n1,n2 c n3,n4
例如"1,2d0" "5a4,5" "1,55c1,11"等。
其中n1和n2指第一个文件的行数，n3和n4指第二个文件的行数。"a"代表add增加，"d"代表delete删除，"c"代表change整块变动。
有了diff的输出结果，可以使用patch命令将一个文件恢复成另一个，例如：

原文地址：http://www.itwis.com/html/os/linux/20100202/7360.html

linux中用shell获取昨天、明天或多天前的日期:

在linux中对man date -d 参数说的比较模糊,以下举例进一步说明:

# -d, --date=string display time described by string, not `now’

date=$(date %y%m%d --date '2 days ago') #获取昨天或多天前的日期

名称 : date

使用权限 : 所有使用者

使用方式 : date [-u] [-d datestr] [-s datestr] [--utc] [--universal] [--date=datestr] [--set=datestr] [--help] [--version] [ format] [mmddhhmm[[cc]yy][.ss]]

说明 : date 能用来显示或设定系统的日期和时间，在显示方面，使用者能设定欲显示的格式，格式设定为一个加号后接数个标记，其中可用的标记列表如下 :

若是不以加号作为开头，则表示要设定时间，而时间格式为 mmddhhmm[[cc]yy][.ss]，

其中 mm 为月份，

dd 为日，

hh 为小时，

mm 为分钟，

cc 为年份前两位数字，

yy 为年份后两位数字，

ss 为秒数

把计 :

-d datestr : 显示 datestr 中所设定的时间 (非系统时间)

--help : 显示辅助讯息

-s datestr : 将系统时间设为 datestr 中所设定的时间

-u : 显示目前的格林威治时间

--version : 显示版本编号

例子 :

显示时间后跳行，再显示目前日期 : date %t%n%d

显示月份和日数 : date %b %d

显示日期和设定时间(12:34:56) : date --date 12:34:56

设置系统当前时间（12:34:56）：date --s 12:34:56

注意 : 当你不希望出现无意义的 0 时(比如说 1999/03/07)，则能在标记中插入 - 符号，比如说 date %-h:%-m:%-s 会把时分秒中无意义的 0 给去掉，像是原本的 08:09:04 会变为 8:9:4。另外，只有取得权限者(比如说 root)才能设定系统时间。 当你以 root 身分更改了系统时间之后，请记得以 clock -w 来将系统时间写入 cmos 中，这样下次重新开机时系统时间才会持续抱持最新的正确值。

ntp时间同步

linux系统下默认安装了ntp服务，手动进行ntp同步如下

ntpdate ntp1.nl.net

当然，也能指定其他的ntp服务器

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

扩展功能

date 工具可以完成更多的工作，不仅仅只是打印出当前的系统日期。您可以使用它来得到给定的日期究竟是星期几，并得到相对于当前日期的相对日期。了解某一天是星期几

gnu 对 date 命令的另一个扩展是 -d 选项，当您的桌上没有日历表时（unix 用户不需要日历表），该选项非常有用。使用这个功能强大的选项，通过将日期作为引号括起来的参数提供，您可以快速地查明一个特定的日期究竟是星期几：

$ date -d "nov 22"

wed nov 22 00:00:00 est 2006

$

在本示例中，您可以看到今年的 11 月 22 日是星期三。

所以，假设在 11 月 22 日召开一个重大的会议，您可以立即了解到这一天是星期三，而这一天您将赶到驻地办公室。

获得相对日期

d 选项还可以告诉您，相对于 当前日期若干天的究竟是哪一天，从现在开始的若干天或若干星期以后，或者以前（过去）。通过将这个相对偏移使用引号括起来，作为 -d 选项的参数，就可以完成这项任务。

例如，您需要了解两星期以后的日期。如果您处于 shell 提示符处，那么可以迅速地得到答案：

$ date -d ’2 weeks’

这个技巧非常有用，它可以根据将来的日期为自己设置提醒，可能是在脚本或 shell 启动文件中，如下所示：

day=`date -d '2 weeks' "%b %d"`

if test "`echo $day`" = "aug 16"; then echo 'product launch is now two weeks away!'; fi 

bash shell 脚本执行的方法有多种，本文作一个总结，供大家学习参考。

    假设我们编写好的shell脚本的文件名为hello.sh，文件位置在/data/shell目录中并已有执行权限。

方法一：切换到shell脚本所在的目录（此时，称为工作目录）执行shell脚本：
cd /data/shell
./hello.sh
./的意思是说在当前的工作目录下执行hello.sh。如果不加上./，bash可能会响应找到不到hello.sh的错误信息。因为目前的工作目录（/data/shell）可能不在执行程序默认的搜索路径之列,也就是说，不在环境变量pash的内容之中。查看path的内容可用 echo $pash 命令。现在的/data/shell就不在环境变量pash中的，所以必须加上./才可执行。

方法二：以绝对路径的方式去执行bash shell脚本：
/data/shell/hello.sh

方法三：直接使用bash 或sh 来执行bash shell脚本：
cd /data/shell

bash hello.sh
或
cd /data/shell

sh hello.sh
    注意，若是以方法三的方式来执行，那么，可以不必事先设定shell的执行权限，甚至都不用写shell文件中的第一行（指定bash路径）。因为方法三是将hello.sh作为参数传给sh(bash)命令来执行的。这时不是hello.sh自己来执行，而是被人家调用执行，所以不要执行权限。那么不用指定bash路径自然也好理解了啊，呵呵……。

方法四：在当前的shell环境中执行bash shell脚本：
cd /data/shell

. hello.sh
或
cd /data/shell

source hello.sh
    前三种方法执行shell脚本时都是在当前shell（称为父shell）开启一个子shell环境，此shell脚本就在这个子shell环境中执行。shell脚本执行完后子shell环境随即关闭，然后又回到父shell中。而方法四则是在当前shell中执行的。

假设shell脚本文件为hello.sh
放在/root目录下。

下面介绍几种在终端执行shell脚本的方法：

1.切换到shell脚本所在的目录，执行：

2.以绝对路径的方式执行：

3.直接用bash或sh执行：

   注意：用以上三种方法执行shell脚本，现行的shell会开启一个子shell环境，去执行shell脚本，前两种必须要有执行权限才能够执行。也可以让shell脚本在现行的shell中执行：

4.现行的shell中执行

    对于第4种不会创建子进程，而是在父进程中直接执行。
    上面的差异是因为子进程不能改变父进程的执行环境，所以cd(内建命令，只有内建命令才可以改变shell 的执行环境)没有成功，但是第4种没有子进程，所以cd成功。

perl的模式匹配非常强大，同时匹配的符号有很多种，难以阅读和维护。

在文本处理方面，python通过加载re模块来实现模式匹配的查找和替换。而perl内置就有模式匹配功能。

note：内置命令和外部命令的区别。

通过代码来直接做比较。

python版：

#!/usr/bin/python
import re
import fileinput
exists_re = re.compile(r'^(.*?) info.*such a record already exists', re.i)
location_re = re.compile(r'^awblocation (.*?) insert into', re.i)
for line in fileinput.input():
    fn = fileinput.filename()
    currline = line.rstrip()
    mprev = exists_re.search(currline)
    if(mprev):
        xlogtime = mprev.group(1)
    mcurr = location_re.search(currline)
    if(mcurr):
        print fn, xlogtime, mcurr.group(1)

#!/usr/bin/perl
while (<>) {
    chomp;
    if (m/^(.*?) info.*such a record already exists/i) {
        $xlogtime = $1;
    }
    if (m/^awblocation (.*?) insert into/i) {
        print "$argv $xlogtime $1\n";
    }
}

time process_file.py *log  > summarypy.log

real   0m8.185s

user  0m8.018s

sys    0m0.092s

time process_file.pl  *log > summaypl.log

real    0m1.481s

user   0m1.294s

sys     0m0.124s

所以在处理大文件如大日志方面，用perl更好，因为更快。

如果对速度要求不是很严格的话，用python更好，因为python简洁易懂，容易维护和阅读。

为什么在文本处理时，perl比python快很多呢？

这是因为perl的模式匹配是其内置功能，而python需要加载re模块，使用内置命令比外部命令要快很多。

用type命令可以分辨内部命令与外部命令。

[root@tp ~]# /etc/rc.d/init.d/iptables save

这样就可以写到/etc/sysconfig/iptables文件里了.写入后记得把防火墙重起一下,才能起作用．

[root@tp ~]# service iptables restart

 echo "cfoo'barxml" | sed "s/'/::/g" |  sed 's/::/\\:/g' |  sed "s/:/'/g"    替换单引号为 \'

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

sed 替换单引号'

echo "mmm'sss" > test
cat test


把test内容中单引号替换成双引号
sed 's/'"'"/'"''/g' test  ==> sed 's/' " ' " / ' " ' '/g' test
解析下：
's/' => 要进行替换操作，后紧跟匹配字符
"'" => 用双引号包裹着单引号
/   =>分割符
'"'  => 用单引号包裹着双引号
'/g' =>分隔符，全局替换


当然还可以使用下面这两种方法替换：
sed s#\'#\"#g test   最外层使用#分隔，里面使用转义单引号，转义双引号
sed "s/'/\"/g" test    最外层使用双引号，里面使用单引号，转义双引号


echo "mmm'sss"  | sed 's/'"'"/'"''/g'
echo "mmm'sss"  | sed s#\'#\"#g
echo "mmm'sss"  | sed "s/'/\"/g"

awk '{print "sed '\''s/"$1"\\t/"$2"\\t/g'\'' ref_zv9_top_level.bed.chrom"}' ref_zv9_top_level.gff3_transid

sed 's/rna10004\t/xr_223343.1\t/g' ref_zv9_top_level.bed.chrom
sed 's/rna10000\t/xr_223342.1\t/g' ref_zv9_top_level.bed.chrom

sed 's/\]/\"/g'   替换]为“

sed 's/\[/\"/g'   替换[为“

在linux操作系统中，find命令非常强大，在文件与目录的查找方面可谓无所不至其极，如果能结合xargs命令使得，更是强大无比。

以下来看看find命令忽略目录查找的用法吧。

例1，根据文件属性查找：

例2，根据文件内容查找：

原文地址： 

下载单个文件，默认将输出打印到标准输出中(stdout)中

curl http://www.centos.org

通过-o/-o选项保存下载的文件到指定的文件中：
-o：将文件保存为命令行中指定的文件名的文件中
-o：使用url中默认的文件名保存文件到本地

1 # 将文件下载到本地并命名为mygettext.html
2 curl -o mygettext.html http://www.gnu.org/software/gettext/manual/gettext.html
3 
4 # 将文件保存到本地并命名为gettext.html
5 curl -o http://www.gnu.org/software/gettext/manual/gettext.html

同样可以使用转向字符">"对输出进行转向输出

同时获取多个文件

1 curl -o url1 -o url2

若同时从同一站点下载多个文件时，curl会尝试重用链接(connection)。

通过-l选项进行重定向
默认情况下curl不会发送http location headers(重定向).当一个被请求页面移动到另一个站点时，会发送一个http loaction header作为请求，然后将请求重定向到新的地址上。
例如：访问google.com时，会自动将地址重定向到google.com.hk上。

 1 curl http://www.google.com
 2 
 3 
 4     "content-type" content="text/html;charset=utf-8">
 5     
 6 
 7 
 8     
 9     the document has moved
10     .
11 
12 

上述输出说明所请求的档案被转移到了http://www.google.com.hk。

这是可以通过使用-l选项进行强制重定向

1 # 让curl使用地址重定向，此时会查询google.com.hk站点
2 curl -l http://www.google.com

断点续传

通过使用-c选项可对大文件使用断点续传功能，如：

1 # 当文件在下载完成之前结束该进程
2 $ curl -o http://www.gnu.org/software/gettext/manual/gettext.html
3 ##############             20.1%
4 
5 # 通过添加-c选项继续对该文件进行下载，已经下载过的文件不会被重新下载
6 curl -c - -o http://www.gnu.org/software/gettext/manual/gettext.html
7 ###############            21.1%

对curl使用网络限速
通过--limit-rate选项对curl的最大网络使用进行限制

1 # 下载速度最大不会超过1000b/second
2 
3 curl --limit-rate 1000b -o http://www.gnu.org/software/gettext/manual/gettext.html

下载指定时间内修改过的文件

当下载一个文件时，可对该文件的最后修改日期进行判断，如果该文件在指定日期内修改过，就进行下载，否则不下载。
该功能可通过使用-z选项来实现：

1 # 若yy.html文件在2011/12/21之后有过更新才会进行下载
2 curl -z 21-dec-11 http://www.example.com/yy.html

curl授权

在访问需要授权的页面时，可通过-u选项提供用户名和密码进行授权

1 curl -u username:password url
2 
3 # 通常的做法是在命令行只输入用户名，之后会提示输入密码，这样可以保证在查看历史记录时不会将密码泄露
4 curl -u username url

从ftp服务器下载文件

curl同样支持ftp下载，若在url中指定的是某个文件路径而非具体的某个要下载的文件名，curl则会列出该目录下的所有文件名而并非下载该目录下的所有文件

1 # 列出public_html下的所有文件夹和文件
2 curl -u ftpuser:ftppass -o ftp://ftp_server/public_html/
3 
4 # 下载xss.php文件
5 curl -u ftpuser:ftppass -o ftp://ftp_server/public_html/xss.php

上传文件到ftp服务器

通过 -t 选项可将指定的本地文件上传到ftp服务器上

# 将myfile.txt文件上传到服务器
curl -u ftpuser:ftppass -t myfile.txt ftp://ftp.testserver.com

# 同时上传多个文件
curl -u ftpuser:ftppass -t "{file1,file2}" ftp://ftp.testserver.com

# 从标准输入获取内容保存到服务器指定的文件中
curl -u ftpuser:ftppass -t - ftp://ftp.testserver.com/myfile_1.txt

获取更多信息

通过使用 -v 和 -trace获取更多的链接信息

通过字典查询单词

1 # 查询bash单词的含义
2 curl dict://dict.org/d:bash
3 
4 # 列出所有可用词典
5 curl dict://dict.org/show:db
6 
7 # 在foldoc词典中查询bash单词的含义
8 curl dict://dict.org/d:bash:foldoc

为curl设置代理

-x 选项可以为curl添加代理功能

1 # 指定代理主机和端口
2 curl -x proxysever.test.com:3128 http://google.co.in

其他网站整理

保存与使用网站cookie信息

1 # 将网站的cookies信息保存到sugarcookies文件中
2 curl -d sugarcookies http://localhost/sugarcrm/index.php
3 
4 # 使用上次保存的cookie信息
5 curl -b sugarcookies http://localhost/sugarcrm/index.php

传递请求数据

默认curl使用get方式请求数据，这种方式下直接通过url传递数据
可以通过 --data/-d 方式指定使用post方式传递数据

1 # get
2 curl -u username https://api.github.com/user?access_token=xxxxxxxxxx
3 
4 # post
5 curl -u username --data "param1=value1¶m2=value" https://api.github.com
6 
7 # 也可以指定一个文件，将该文件中的内容当作数据传递给服务器端
8 curl --data @filename https://github.api.com/authorizations

注：默认情况下，通过post方式传递过去的数据中若有特殊字符，首先需要将特殊字符转义在传递给服务器端，如value值中包含有空格，则需要先将空格转换成 ，如：

1 curl -d "value 1" http://hostname.com

在新版本的curl中，提供了新的选项 --data-urlencode，通过该选项提供的参数会自动转义特殊字符。

1 curl --data-urlencode "value 1" http://hostname.com

除了使用get和post协议外，还可以通过 -x 选项指定其它协议，如：

1 curl -i -x delete https://api.github.cim

上传文件

1 curl --form "fileupload=@filename.txt" http://hostname/resource