linux shell 字符串操作详解 (长度,读取,替换,截取,连接,对比,删除,位置 )(转)

 linux, shell  linux shell 字符串操作详解 (长度,读取,替换,截取,连接,对比,删除,位置 )(转)已关闭评论
4月 012021
 

网上看到的一篇关于shell下操作字符串的好文章,linux shell 字符串操作详解 (长度,读取,替换,截取,连接,对比,删除,位置 ),原文地址见文末。

 

1.Linux shell 截取字符变量的前8位

实现方法有如下几种:

  1. expr substr “$a” 1 8
  2. echo $a|awk ‘{print substr(,1,8)}’
  3. echo $a|cut -c1-8
  4. echo $
  5. expr $a : ‘\(.\\).*’
  6. echo $a|dd bs=1 count=8 2>/dev/null

 

2.按指定的字符串截取

(1)第一种方法:

从左向右截取最后一个string后的字符串
${varible##*string}
从左向右截取第一个string后的字符串
${varible#*string}
从右向左截取最后一个string后的字符串
${varible%%string*}
从右向左截取第一个string后的字符串
${varible%string*}
“*”只是一个通配符可以不要

请看下面的例子:

$ MYVAR=foodforthought.jpg
$ echo ${MYVAR##*fo}
rthought.jpg
$ echo ${MYVAR#*fo}
odforthought.jpg

(2)第二种方法:

${varible:n1:n2}:截取变量varible从n1开始的n2个字符,组成一个子字符串。可以根据特定字符偏移和长度,使用另一种形式的变量扩展,来选择特定子字符串。试着在 bash 中输入以下行:

$ EXCLAIM=cowabunga
$ echo ${EXCLAIM:0:3}
cow
$ echo ${EXCLAIM:3:7}
abunga

这种形式的字符串截断非常简便,只需用冒号分开来指定起始字符和子字符串长度。

3.按照指定要求分割:

比如获取后缀名

ls -al | cut -d “.” -f2

小结:shell对应字符串的处理方法很多,根据需求灵活选择。

 

在做shell批处理程序时候,经常会涉及到字符串相关操作。有很多命令语句,如:awk,sed都可以做字符串各种操作。 其实shell内置一系列操作符号,可以达到类似效果,大家知道,使用内部操作符会省略启动外部程序等时间,因此速度会非常的快。

 

一、判断读取字符串值

表达式 含义

${var} 变量var的值, 与$var相同
${var-DEFAULT} 如果var没有被声明, 那么就以$DEFAULT作为其值 *
${var:-DEFAULT} 如果var没有被声明, 或者其值为空, 那么就以$DEFAULT作为其值 *
${var=DEFAULT} 如果var没有被声明, 那么就以$DEFAULT作为其值 *
${var:=DEFAULT} 如果var没有被声明, 或者其值为空, 那么就以$DEFAULT作为其值 *
${var+OTHER} 如果var声明了, 那么其值就是$OTHER, 否则就为null字符串
${var:+OTHER} 如果var被设置了, 那么其值就是$OTHER, 否则就为null字符串
${var?ERR_MSG} 如果var没被声明, 那么就打印$ERR_MSG *
${var:?ERR_MSG} 如果var没被设置, 那么就打印$ERR_MSG *
${!varprefix*} 匹配之前所有以varprefix开头进行声明的变量
${!varprefix@} 匹配之前所有以varprefix开头进行声明的变量

加入了“*”  不是意思是: 当然, 如果变量var已经被设置的话, 那么其值就是$var.

 

 

二、字符串操作(长度,读取,替换)

表达式 含义

${#string} $string的长度
${string:position} 在$string中, 从位置$position开始提取子串
${string:position:length} 在$string中, 从位置$position开始提取长度为$length的子串
${string#substring} 从变量$string的开头, 删除最短匹配$substring的子串
${string##substring} 从变量$string的开头, 删除最长匹配$substring的子串
${string%substring} 从变量$string的结尾, 删除最短匹配$substring的子串
${string%%substring} 从变量$string的结尾, 删除最长匹配$substring的子串
${string/substring/replacement} 使用$replacement, 来代替第一个匹配的$substring
${string//substring/replacement} 使用$replacement, 代替所有匹配的$substring
${string/#substring/replacement} 如果$string的前缀匹配$substring, 那么就用$replacement来代替匹配到的$substring
${string/%substring/replacement} 如果$string的后缀匹配$substring, 那么就用$replacement来代替匹配到的$substring

说明:”* $substring”可以是一个正则表达式.

 

实例:

 

读取:

Java代码  收藏代码
  1. $ echo ${abc-‘ok’}  
  2. ok
  3. $ echo $abc
  4. $ echo ${abc=‘ok’}  
  5. ok
  6. $ echo $abc
  7. ok
  8. #如果abc 没有声明“=” 还会给abc赋值。
  9. $ var1=11;var2=12;var3=  
  10. $ echo ${!v@}
  11. var1 var2 var3
  12. $ echo ${!v*}
  13. var1 var2 var3
  14. #${!varprefix*}与${!varprefix@}相似,可以通过变量名前缀字符,搜索已经定义的变量,无论是否为空值。

 

1,取得字符串长度

C代码  收藏代码
  1. string=abc12342341          //等号二边不要有空格  
  2. echo ${#string}             //结果11  
  3. expr length $string         //结果11  
  4. expr “$string” : “.*”       //结果11 分号二边要有空格,这里的:根match的用法差不多  

2,字符串所在位置

C代码  收藏代码
  1. expr index $string ‘123’    //结果4 字符串对应的下标是从1开始的   
C代码  收藏代码
  1. str=“abc”  
  2. expr index $str “a”  # 1  
  3. expr index $str “b”  # 2  
  4. expr index $str “x”  # 0  
  5. expr index $str “”   # 0   

 

这个方法让我想起来了js的indexOf,各种语言对字符串的操作方法大方向都差不多,如果有语言基础的话,学习shell会很快的。

 

3,从字符串开头到子串的最大长度

C代码  收藏代码
  1. expr match $string ‘abc.*3’ //结果9    

个人觉得这个函数的用处不大,为什么要从开头开始呢。

 

4,字符串截取

C代码  收藏代码
  1. echo ${string:4}      //2342341  从第4位开始截取后面所有字符串    
  2. echo ${string:3:3}    //123      从第3位开始截取后面3位    
  3. echo ${string:3:6}    //123423   从第3位开始截取后面6位    
  4. echo ${string: -4}    //2341  :右边有空格   截取后4位    
  5. echo ${string:(-4)}   //2341  同上    
  6. expr substr $string 3 3   //123  从第3位开始截取后面3位    

 

C代码  收藏代码
  1. str=“abcdef”  
  2. expr substr “$str” 1 3  # 从第一个位置开始取3个字符, abc  
  3. expr substr “$str” 2 5  # 从第二个位置开始取5个字符, bcdef   
  4. expr substr “$str” 4 5  # 从第四个位置开始取5个字符, def  
  5. echo ${str:2}           # 从第二个位置开始提取字符串, bcdef
  6. echo ${str:2:3}         # 从第二个位置开始提取3个字符, bcd
  7. echo ${str:(-6):5}        # 从倒数第二个位置向左提取字符串, abcde
  8. echo ${str:(-4):3}      # 从倒数第二个位置向左提取6个字符, cde

 

上面的方法让我想起了,php的substr函数,后面截取的规则是一样的。

 

5,匹配显示内容

C代码  收藏代码
  1. //例3中也有match和这里的match不同,上面显示的是匹配字符的长度,而下面的是匹配的内容    
  2. expr match $string ‘\([a-c]*[0-9]*\)’  //abc12342341    
  3. expr $string : ‘\([a-c]*[0-9]\)’       //abc1    
  4. expr $string : ‘.*\([0-9][0-9][0-9]\)’ //341 显示括号中匹配的内容    

 

这里括号的用法,是不是根其他的括号用法有相似之处呢,

 

6,截取不匹配的内容

C代码  收藏代码
  1. echo ${string#a*3}     //42341  从$string左边开始,去掉最短匹配子串    
  2. echo ${string#c*3}     //abc12342341  这样什么也没有匹配到    
  3. echo ${string#*c1*3}   //42341  从$string左边开始,去掉最短匹配子串    
  4. echo ${string##a*3}    //41     从$string左边开始,去掉最长匹配子串    
  5. echo ${string%3*1}     //abc12342  从$string右边开始,去掉最短匹配子串    
  6. echo ${string%%3*1}    //abc12     从$string右边开始,去掉最长匹配子串    
C代码  收藏代码
  1. str=“abbc,def,ghi,abcjkl”  
  2. echo ${str#a*c}     # 输出,def,ghi,abcjkl  一个井号(#) 表示从左边截取掉最短的匹配 (这里把abbc字串去掉)
  3. echo ${str##a*c}    # 输出jkl,             两个井号(##) 表示从左边截取掉最长的匹配 (这里把abbc,def,ghi,abc字串去掉)
  4. echo ${str#“a*c”}   # 输出abbc,def,ghi,abcjkl 因为str中没有”a*c”子串  
  5. echo ${str##“a*c”}  # 输出abbc,def,ghi,abcjkl 同理  
  6. echo ${str#*a*c*}   # 空
  7. echo ${str##*a*c*}  # 空
  8. echo ${str#d*f)     # 输出abbc,def,ghi,abcjkl,
  9. echo ${str#*d*f}    # 输出,ghi,abcjkl
  10. echo ${str%a*l}     # abbc,def,ghi  一个百分号(%)表示从右边截取最短的匹配
  11. echo ${str%%b*l}    # a             两个百分号表示(%%)表示从右边截取最长的匹配
  12. echo ${str%a*c}     # abbc,def,ghi,abcjkl

这里要注意,必须从字符串的第一个字符开始,或者从最后一个开始,可以这样记忆, 井号(#)通常用于表示一个数字,它是放在前面的;百分号(%)卸载数字的后面; 或者这样记忆,在键盘布局中,井号(#)总是位于百分号(%)的左边(即前面)  。

 

7,匹配并且替换

C代码  收藏代码
  1. echo ${string/23/bb}   //abc1bb42341  替换一次    
  2. echo ${string//23/bb}  //abc1bb4bb41  双斜杠替换所有匹配    
  3. echo ${string/#abc/bb} //bb12342341   #以什么开头来匹配,根php中的^有点像    
  4. echo ${string/%41/bb}  //abc123423bb  %以什么结尾来匹配,根php中的$有点像   

 

C代码  收藏代码
  1. str=“apple, tree, apple tree”  
  2. echo ${str/apple/APPLE}   # 替换第一次出现的apple
  3. echo ${str//apple/APPLE}  # 替换所有apple  
  4. echo ${str/#apple/APPLE}  # 如果字符串str以apple开头,则用APPLE替换它
  5. echo ${str/%apple/APPLE}  # 如果字符串str以apple结尾,则用APPLE替换它
C代码  收藏代码
  1. $ test=‘c:/windows/boot.ini’  
  2. $ echo ${test/\//\\}  
  3. c:\windows/boot.ini
  4. $ echo ${test//\//\\}  
  5. c:\windows\boot.ini
  6. #${变量/查找/替换值} 一个“/”表示替换第一个,”//”表示替换所有,当查找中出现了:”/”请加转义符”\/”表示。  

8. 比较

C代码  收藏代码
  1. [[ “a.txt” == a* ]]        # 逻辑真 (pattern matching)  
  2. [[ “a.txt” =~ .*\.txt ]]   # 逻辑真 (regex matching)  
  3. [[ “abc” == “abc” ]]       # 逻辑真 (string comparision)   
  4. [[ “11” < “2” ]]           # 逻辑真 (string comparision), 按ascii值比较  

9. 连接

C代码  收藏代码
  1. s1=“hello”  
  2. s2=“world”  
  3. echo ${s1}${s2}   # 当然这样写 $s1$s2 也行,但最好加上大括号
10. 字符串删除

Java代码  收藏代码
  1. $ test=‘c:/windows/boot.ini’  
  2. $ echo ${test#/}
  3. c:/windows/boot.ini
  4. $ echo ${test#*/}
  5. windows/boot.ini
  6. $ echo ${test##*/}
  7. boot.ini
  8. $ echo ${test%/*} 
  9. c:/windows 
  10. $ echo ${test%%/*} 
  11. #${变量名#substring正则表达式}从字符串开头开始配备substring,删除匹配上的表达式。 
  12. #${变量名%substring正则表达式}从字符串结尾开始配备substring,删除匹配上的表达式。 
  13. #注意:${test##*/},${test%/*} 分别是得到文件名,或者目录地址最简单方法。   

转自:https://www.cnblogs.com/gaochsh/p/6901809.html

文章二: 使用ssh实现内网穿透及SSH端口转发详解(转)

 ssh  文章二: 使用ssh实现内网穿透及SSH端口转发详解(转)已关闭评论
2月 202021
 

以下内容是关于SSH端口转发的详解使用,文章通俗易懂,比前面的文章一写的更好,强烈推荐!原文地址见文末。

 

SSH有三种端口转发模式,本地端口转发(Local Port Forwarding)远程端口转发(Remote Port Forwarding)以及动态端口转发(Dynamic Port Forwarding)。对于本地/远程端口转发,两者的方向恰好相反。动态端口转发则可以用于科学上网。

SSH端口转发也被称作SSH隧道(SSH Tunnel),因为它们都是通过SSH登陆之后,在SSH客户端SSH服务端之间建立了一个隧道,从而进行通信。SSH隧道是非常安全的,因为SSH是通过加密传输数据的(SSH全称为Secure Shell)。

在本文所有示例中,本地主机A1为SSH客户端,远程云主机B1为SSH服务端。从A1主机通过SSH登陆B1主机,指定不同的端口转发选项(-L、-R和-D),即可在A1与B1之间建立SSH隧道,从而进行不同的端口转发。

本地端口转发

应用场景:

远程云主机B1运行了一个服务,端口为3000,本地主机A1需要访问这个服务。

示例为一个简单的Node.js服务:

var http = require('http');

var server = http.createServer(function(request, response)
{
    response.writeHead(200,
    {
        "Content-Type": "text/plain"
    });
    response.end("Hello O-u-u.com\n");
});

server.listen(3000);

假设云主机B1的IP为103.59.22.17,则该服务的访问地址为:http://103.59.22.17:3000

为啥需要本地端口转发呢?

一般来讲,云主机的防火墙默认只打开了22端口,如果需要访问3000端口的话,需要修改防火墙。为了保证安全,防火墙需要配置允许访问的IP地址。但是,本地公网IP通常是网络提供商动态分配的,是不断变化的。这样的话,防火墙配置需要经常修改,就会很麻烦。

什么是本地端口转发?

所谓本地端口转发,就是将发送到本地端口的请求,转发到目标端口。这样,就可以通过访问本地端口,来访问目标端口的服务。使用-L属性,就可以指定需要转发的端口,语法是这样的:

-L 本地网卡地址:本地端口:目标地址:目标端口

通过本地端口转发,可以将发送到本地主机A1端口2000的请求,转发到远程云主机B1的3000端口。

# 在本地主机A1登陆远程云主机B1,并进行本地端口转发
ssh -L localhost:2000:localhost:3000 [email protected]

这样,在本地主机A1上可以通过访问http://localhost:2000来访问远程云主机B1上的Node.js服务。

# 在本地主机A1访问远程云主机B1上的Node.js服务
curl http://localhost:2000
Hello O-u-u.com

实际上,-L选项中的本地网卡地址是可以省略的,这时表示2000端口绑定了本地主机A1的所有网卡:

# 在本地主机A1登陆远程云主机B1,并进行本地端口转发。2000端口绑定本地所有网卡
ssh -L 2000:localhost:3000 [email protected]

若本地主机A2能够访问A1,则A2也可以通过A1访问远程远程云主机B1上的Node.js服务。

另外,-L选项中的目标地址也可以是其他主机的地址。假设远程云主机B2的局域网IP地址为192.168.59.100,则可以这样进行端口转发:

# 在本地主机A1登陆远程云主机B1,并进行本地端口转发。请求被转发到远程云主机B2上
ssh -L 2000:192.168.59.100:3000 [email protected]

若将Node.js服务运行在远程云主机B2上,则发送到A1主机2000端口的请求,都会被转发到B2主机上。

远程端口转发

应用场景:

本地主机A1运行了一个服务,端口为3000,远程云主机B1需要访问这个服务。

将前文的Node.js服务运行在本地,在本地就可以通过http://localhost:3000访问该服务。

为啥需要远程端口转发呢?

通常,本地主机是没有独立的公网IP的,它与同一网络中的主机共享一个IP。没有公网IP,云主机是无法访问本地主机上的服务的。

什么是远程端口转发?

所谓远程端口转发,就是将发送到远程端口的请求,转发到目标端口。这样,就可以通过访问远程端口,来访问目标端口的服务。使用-R属性,就可以指定需要转发的端口,语法是这样的:

-R 远程网卡地址:远程端口:目标地址:目标端口

这时,通过远程端口转发,可以将发送到远程云主机B1端口2000的请求,转发到本地主机A1端口3000。

# 在本地主机A1登陆远程云主机B1,并进行远程端口转发
ssh -R localhost:2000:localhost:3000 [email protected]

这样,在远程云主机A1可以通过访问http://localhost:2000来访问本地主机的服务。

# 在远程云主机B1访问本地主机A1上的Node.js服务
curl http://localhost:2000
Hello O-u-u.com

同理,远程网卡地址可以省略,目标地址也可以是其他主机地址。假设本地主机A2的局域网IP地址为192.168.0.100。

# 在本地主机A1登陆远程云主机B1,并进行远程端口转发
ssh -R 2000:192.168.0.100:3000 [email protected]

若将Node.js服务运行在本地主机A2上,则发送到远程云主机A1端口2000的请求,都会被转发到A2主机上。

动态端口转发

应用场景:

远程云主机B1运行了多个服务,分别使用了不同端口,本地主机A1需要访问这些服务。

为啥需要动态端口转发呢?

一方面,由于防火墙限制,本地主机A1并不能直接访问远程云主机B1上的服务,因此需要进行端口转发;另一方面,为每个端口分别创建本地端口转发非常麻烦。

什么是动态端口转发?

对于本地端口转发远程端口转发,都存在两个一一对应的端口,分别位于SSH的客户端和服务端,而动态端口转发则只是绑定了一个本地端口,而目标地址:目标端口则是不固定的。目标地址:目标端口是由发起的请求决定的,比如,请求地址为192.168.1.100:3000,则通过SSH转发的请求地址也是192.168.1.100:3000

-D 本地网卡地址:本地端口

这时,通过动态端口转发,可以将在本地主机A1发起的请求,转发到远程主机B1,而由B1去真正地发起请求。

# 在本地主机A1登陆远程云主机B1,并进行动态端口转发
ssh -D localhost:2000 [email protected]

而在本地发起的请求,需要由Socket代理(Socket Proxy)转发到SSH绑定的2000端口。以Firefox浏览器为例,配置Socket代理需要找到首选项>高级>网络>连接->设置:

这样的话,Firefox浏览器发起的请求都会转发到2000端口,然后通过SSH转发到真正地请求地址。若Node.js服务运行在远程云主机B1上,则在Firefox中访问localhost:3000即可以访问。如果主机B1能够访问外网的话,则可以科学上网……

链式端口转发

本地端口转发远程端口转发结合起来使用,可以进行链式转发。假设A主机在公司,B主机在家,C主机为远程云主机。A主机上运行了前文的Node.js服务,需要在B主机上访问该服务。由于A和B不在同一个网络,且A主机没有独立公共IP地址,所以无法直接访问服务。

通过本地端口转发,将发送到B主机3000端口的请求,转发到远程云主机C的2000端口。

# 在B主机登陆远程云主机C,并进行本地端口转发
ssh -L localhost:3000:localhost:2000 [email protected]

通过远程端口转发,将发送到远程云主机C端口2000的请求,转发到A主机的3000端口。

# 在A主机登陆远程云主机C,并进行远程端口转发
ssh -R localhost:2000:localhost:3000 [email protected]

这样,在主机B可以通过访问http://localhost:3000来访问主机A上的服务。

# 在主机B访问主机A上的服务
curl http://localhost:3000
Hello O-u-u.com

 

转自:https://blog.fundebug.com/2017/04/24/ssh-port-forwarding/

标准SQL下分区函数Partition By结合row_number()的用法,以及排序rank()的用法详解(转)

 数据库  标准SQL下分区函数Partition By结合row_number()的用法,以及排序rank()的用法详解(转)已关闭评论
10月 222020
 
网上看到的一篇文章: 描述分区函数Partition By结合row_number()的用法,以及排序rank()的用法
,比如获取分组(分区)中前几条记录。

partition by关键字是分析性函数的一部分,它和聚合函数不同的地方在于它能返回一个分组中的多条记录,而聚合函数一般只有一条反映统计值的记录,partition by用于给结果集分组,如果没有指定那么它把整个结果集作为一个分组,分区函数一般与排名函数一起使用。

准备测试数据:

复制代码
create table Student  --学生成绩表
(
 id int,  --主键
 Grade int, --班级
 Score int --分数
)
go

insert into Student values(1,1,88)
insert into Student values(2,1,66)
insert into Student values(3,1,75)
insert into Student values(4,2,30)
insert into Student values(5,2,70)
insert into Student values(6,2,80)
insert into Student values(7,2,60)
insert into Student values(8,3,90)
insert into Student values(9,3,70)
insert into Student values(10,3,80)
insert into Student values(11,3,80)
复制代码

一、分区函数Partition By的与row_number()的用法

1、不分班按学生成绩排名

select *,row_number() over(order by Score desc) as Sequence from Student

执行结果:

2、分班后按学生成绩排名

select *,row_number() over(partition by Grade order by Score desc) as Sequence from Student

执行结果:

3、获取每个班的前1(几)名

select * from
(
select *,row_number() over(partition by Grade order by Score desc) as Sequence from Student
)T where T.Sequence<=1

执行结果:

 

二、分区函数Partition By与排序rank()的用法

1、分班后按学生成绩排名 该语句是对分数相同的记录进行了同一排名,例如:两个80分的并列第2名,第4名就没有了

select *,rank() over(partition by Grade order by Score desc) as Sequence from Student

执行结果:

2、获取每个班的前2(几)名 该语句是对分数相同的记录进行了同一排名,例如:两个80分的并列第2名,第4名就没有了

select * from
(
select *,rank() over(partition by Grade order by Score desc) as Sequence from Student
)T where T.Sequence<=2

执行结果:

Android下使用Picasso图片加载库详解

 android  Android下使用Picasso图片加载库详解已关闭评论
7月 012020
 

网上看到的一篇关于Android下 使用 Picasso 图片加载库的好文章,虽然有点老,但还是值得分享 !来自:https://www.jianshu.com/p/c68a3b9ca07a

写在前面

Android 中有几个比较有名的图片加载框架,Universal ImageLoader、Picasso、Glide和Fresco。它们各有优点,以前一直用的是ImageLoader 做项目中的图片加载,由于作者宣布ImageLoader 不会在更新了,因此新的项目打算换一个图片加载框架-Picasso, Picasso 是Square 公司开源的Android 端的图片加载和缓存框架。Square 真是一家良心公司啊,为我们Android开发者贡献了很多优秀的开源项目有木有!像什么Rerefoit 、OkHttp、LeakCanary、Picasso等等都是非常火的开源项目。扯远了,回到正题,除了使用简单方便,Picasso还能自动帮我们做以下事情:

  • 处理Adapter 中ImageView的回收和取消下载。
  • 使用最小的内存 来做复杂的图片变换。比如高斯模糊,圆角、圆形等处理。
  • 自动帮我们缓存图片。内存和磁盘缓存。

以上只是列出了Picasso 比较核心的几点,其实它的优点远远不止这些,接下来就看一下如何使用Picasso。

Picasso-Android.png

本文目录

0,添加依赖
1, 加载显示图片
2,Placeholder & noPlaceholder & noFade
3, 设置图片尺寸(Resize)、缩放(Scale)和裁剪(Crop)
4,图片旋转Rotation()
5, 转换器Transformation
6,请求优先级
7,Tag管理请求
8,同步/异步加载图片
9,缓存(Disk 和 Memory)
10,Debug 和日志
11,Picasso 扩展

正文

0. 添加依赖

要使用Picasso,首先我们要添加版本依赖,去官网或者Github 看一下当前的最新版本(截止本文最新版本为2.5.2),然后在build.gradle中添加依赖:

   compile 'com.squareup.picasso:picasso:2.5.2'

1. 加载显示图片

将Picasso添加到项目之后,我们就可以用它来加载图片了,使用方法非常简单:

 Picasso.with(this)
        .load("http://ww3.sinaimg.cn/large/610dc034jw1fasakfvqe1j20u00mhgn2.jpg")
        .into(mImageView);

只需要一行代码就完成了加载图片到显示的整个过程,链式调用,非常简洁,其实有三步,一次调用了三个方法:

  • with(Context) 获取一个Picasso单例,参数是一个Context上下文
  • load(String) 调用load 方法加载图片
  • into (ImageView) 将图片显示在对应的View上,可以是ImageView,也可以是实现了Target j接口的自定义View。

上面演示了加载一张网络图片,它还支持其它形式的图片加载,加载文件图片,加载本地资源图片,加载一个Uri 路径给的图片,提供了几个重载的方法:

1, load(Uri uri) 加载一个以Uri路径给的图片

Uri uri = Uri.parse(ANDROID_RESOURCE + context.getPackageName() + FOREWARD_SLASH + resourceId)

Picasso.with(this).load(uri).into(mImageView);

** 2,load(File file) 加载File中的图片**

 Picasso.with(this).load(file).into(mImageView);

3, load(int resourceId) 加载本地资源图片

Picasso.with(this).load(R.mipmap.ic_launcher).into(mImageView);

提醒:上面介绍了load的几个重载方法,加载不同资源的图片,另外提醒注意一下load(String path)接受String 参数的这个方法,参数String 可以是一个网络图片url,也可以是file 路径、content资源 和Android Resource。看一下源码的注释。

/**
   * Start an image request using the specified path. This is a convenience method for calling
   * {@link #load(Uri)}.
   * <p>
   * This path may be a remote URL, file resource (prefixed with {@code file:}), content resource
   * (prefixed with {@code content:}), or android resource (prefixed with {@code
   * android.resource:}.
   * <p>
   * Passing {@code null} as a {@code path} will not trigger any request but will set a
   * placeholder, if one is specified.
   *
   * @see #load(Uri)
   * @see #load(File)
   * @see #load(int)
   * @throws IllegalArgumentException if {@code path} is empty or blank string.
   */
  public RequestCreator load(String path) {
    if (path == null) {
      return new RequestCreator(this, null, 0);
    }
    if (path.trim().length() == 0) {
      throw new IllegalArgumentException("Path must not be empty.");
    }
    return load(Uri.parse(path));
  }

要使用string 参数加载上面的几种资源,除了网络url,其它几种需要加上对应前缀,file文件路径前缀:file: , content 添加前缀:content: ,Android Resource 添加:android.resource:

2. placeholder& error & noPlaceholder & noFade

通过上面的第一步我们就可以通过Picasso 加载图片了,我们的项目中通常最常用的就是加载网络图片,但是由于网络环境的差异,有时侯加载网络图片的过程有点慢,这样界面上就会显示空ImageView什么也看不见,用户体验非常不好。其实以前用过ImageLoader的同学都知道,ImageLoader 是可以设置加载中显示默认图片的,Picasso当然也给我们提供了这个功能,这就是我们要说的placeholder(占位图)。

1,placeholder
placeholder提供一张在网络请求还没有完成时显示的图片,它必须是本地图片,代码如下:

 Picasso.with(this).load(URL)
                .placeholder(R.drawable.default_bg)
                .into(mImageView);

设置placeholder之后,在加载图片的时候,就可以显示设置的默认图了,提升用户体验。
2, error
和placeholder 的用法一样,error 提供一张在加载图片出错的情况下显示的默认图


        Picasso.with(this).load(URL)
                .placeholder(R.drawable.default_bg)
                .error(R.drawable.error_iamge)
                .into(mImageView);

3,noPlaceholder
这个方法的意思就是:在调用into的时候明确告诉你没有占位图设置。根据这个方法签名的解释是阻止View被回收的时候Picasso清空target或者设置一个应用的占位图。需要注意的是placeholder和noPlaceholder 不能同时应用在同一个请求上,会抛异常。


        Picasso.with(this).load(URL)
                .noPlaceholder()
                .error(R.drawable.error_iamge)
                .into(mImageView);

4,noFade
无论你是否设置了占位图,Picasso 从磁盘或者网络加载图片时,into 显示到ImageView 都会有一个简单的渐入过度效果,让你的UI视觉效果更柔顺丝滑一点,如果你不要这个渐入的效果(没有这么坑爹的需求吧!!!),就调用noFade方法。

 Picasso.with(this).load(URL)
                .placeholder(R.drawable.default_bg)
                .error(R.drawable.error_iamge)
                .noFade()
                .into(mImageView);

3. 设置图片尺寸(Resize)、缩放(Scale)和裁剪(Crop)

1, Resize(int w,int h)
在项目中,为了带宽、内存使用和下载速度等考虑,服务端给我们的图片的size 应该和我们View 实际的size一样的,但是实际情况并非如此,服务端可能给我们一些奇怪的尺寸的图片,我们可以使用resize(int w,int hei) 来重新设置尺寸。

 Picasso.with(this).load(URL)
                .placeholder(R.drawable.default_bg)
                .error(R.drawable.error_iamge)
                .resize(400,200)
                .into(mImageView);

resize()方法接受的参数的单位是pixels,还有一个可以设置dp单位的方法,将你的尺寸写在dimens.xml文件中,然后用resizeDimen(int targetWidthResId, int targetHeightResId)方法

 <dimen name="image_width">300dp</dimen>
 <dimen name="image_height">200dp</dimen>

 Picasso.with(this).load(URL)
                .placeholder(R.drawable.default_bg)
                .error(R.drawable.error_iamge)
                .resizeDimen(R.dimen.image_width,R.dimen.image_height)
                .into(mImageView);

2,onlyScaleDown
当调用了resize 方法重新设置图片尺寸的时候,调用onlyScaleDown 方法,只有当原始图片的尺寸大于我们指定的尺寸时,resize才起作用,如:

  Picasso.with(this).load(URL)
                .placeholder(R.drawable.default_bg)
                .error(R.drawable.error_iamge)
                .resize(4000,2000)
                .onlyScaleDown()
                .into(mImageView);

只有当原来的图片尺寸大于4000 x 2000的时候,resize 才起作用。
3,图片裁剪 centerCrop()
这个属性应该不陌生吧!ImageView 的ScaleType 就有这个属性。当我们使用resize 来重新设置图片的尺寸的时候,你会发现有些图片拉伸或者扭曲了(使用ImageView的时候碰到过吧),我要避免这种情况,Picasso 同样给我们提供了一个方法,centerCrop,充满ImageView 的边界,居中裁剪

 Picasso.with(this).load(URL)
                .placeholder(R.drawable.default_bg)
                .error(R.drawable.error_iamge)
                .resize(400,200)
                .centerCrop()
                .into(mImageView);

4,centerInside
上面的centerCrop是可能看不到全部图片的,如果你想让View将图片展示完全,可以用centerInside,但是如果图片尺寸小于View尺寸的话,是不能充满View边界的。

 Picasso.with(this).load(URL)
                .placeholder(R.drawable.default_bg)
                .error(R.drawable.error_iamge)
                .resize(400,200)
                .centerInside()
                .into(mImageView);

5,fit
fit 是干什的呢?上面我们需要用resize()来指定我们需要的图片的尺寸,那就是说在程序中需要我们计算我们需要的尺寸(固定大小的除外),这样很麻烦,fit 方法就帮我们解决了这个问题。fit 它会自动测量我们的View的大小,然后内部调用reszie方法把图片裁剪到View的大小,这就帮我们做了计算size和调用resize 这2步。非常方便。代码如下:

Picasso.with(this).load(URL)
                .placeholder(R.drawable.default_bg)
                .error(R.drawable.error_iamge)
                .fit()
                .into(mImageView);

使用fit 还是会出现拉伸扭曲的情况,因此最好配合前面的centerCrop使用,代码如下:

 Picasso.with(this).load(URL)
                .placeholder(R.drawable.default_bg)
                .error(R.drawable.error_iamge)
                .fit()
                .centerCrop()
                .into(mImageView);

看一下对比图:
fit(会拉伸):

image_fit.png

fit & centerCrop (不会拉伸):

fit_centerCrop.png

注意:特别注意,
1,fit 只对ImageView 有效
2,使用fit时,ImageView 宽和高不能为wrap_content,很好理解,因为它要测量宽高。

4. 图片旋转Rotation()

在图片显示到ImageView 之前,还可以对图片做一些旋转操作,调用rotate(int degree)方法

Picasso.with(this).load(URL)
                .placeholder(R.drawable.default_bg)
                .error(R.drawable.error_iamge)
                .rotate(180)
                .into(mImageView);

这个方法它是以(0,0)点旋转,但是有些时候我们并不想以(0,0)点旋转,还提供了另外一个方法可以指定原点:

  • rotate(float degrees, float pivotX, float pivotY) 以(pivotX, pivotY)为原点旋转

 Picasso.with(this).load(URL)
                .placeholder(R.drawable.default_bg)
                .error(R.drawable.error_iamge)
                .rotate(180,200,100)
                .into(mImageView);

5. 转换器Transformation

Transformation 这就是Picasso的一个非常强大的功能了,它允许你在load图片 -> into ImageView 中间这个过成对图片做一系列的变换。比如你要做图片高斯模糊、添加圆角、做度灰处理、圆形图片等等都可以通过Transformation来完成。

来看一个高斯模糊的例子:

1,首先定义一个转换器继承 Transformation

 public static class BlurTransformation implements Transformation{

        RenderScript rs;

        public BlurTransformation(Context context) {
            super();
            rs = RenderScript.create(context);
        }

        @Override
        public Bitmap transform(Bitmap bitmap) {
            // Create another bitmap that will hold the results of the filter.
            Bitmap blurredBitmap = bitmap.copy(Bitmap.Config.ARGB_8888, true);

            // Allocate memory for Renderscript to work with
            Allocation input = Allocation.createFromBitmap(rs, blurredBitmap, Allocation.MipmapControl.MIPMAP_FULL, Allocation.USAGE_SHARED);
            Allocation output = Allocation.createTyped(rs, input.getType());

            // Load up an instance of the specific script that we want to use.
            ScriptIntrinsicBlur script = ScriptIntrinsicBlur.create(rs, Element.U8_4(rs));
            script.setInput(input);

            // Set the blur radius
            script.setRadius(25);

            // Start the ScriptIntrinisicBlur
            script.forEach(output);

            // Copy the output to the blurred bitmap
            output.copyTo(blurredBitmap);

            bitmap.recycle();

            return blurredBitmap;
        }

        @Override
        public String key() {
            return "blur";
        }
    }

2, 加载图片的时候,在into 方法前面调用 transform方法 应用Transformation

  Picasso.with(this).load(URL)
                .placeholder(R.drawable.default_bg)
                .error(R.drawable.error_iamge)
                .transform(new BlurTransformation(this))
                .into(mBlurImage);

看一下效果图:

transformation.png

上面为原图,下面为高斯模糊图

是不是很强大,任何复杂的变换都可以通过Transformation 来做。

还不止于此,还有更强大的功能。可以在一个请求上应用多个Transformation

比如:我想先做个度灰处理然后在做一个高斯模糊图:

1, 度灰的Transformation

 public static class GrayTransformation implements Transformation{

        @Override
        public Bitmap transform(Bitmap source) {
            int width, height;
            height = source.getHeight();
            width = source.getWidth();

            Bitmap bmpGrayscale = Bitmap.createBitmap(width, height, Bitmap.Config.RGB_565);
            Canvas c = new Canvas(bmpGrayscale);
            Paint paint = new Paint();
            ColorMatrix cm = new ColorMatrix();
            cm.setSaturation(0);
            ColorMatrixColorFilter f = new ColorMatrixColorFilter(cm);
            paint.setColorFilter(f);
            c.drawBitmap(source, 0, 0, paint);

            if(source!=null && source!=bmpGrayscale){
                source.recycle();
            }
            return bmpGrayscale;
        }

        @Override
        public String key() {
            return "gray";
        }
    }

2, 如果是多个Transformation操作,有2种方式应用
方式一:直接调用多次transform 方法,不会覆盖的。它只是保存到了一个List 里面

 Picasso.with(this).load(URL)
                .placeholder(R.drawable.default_bg)
                .error(R.drawable.error_iamge)
                .fit()
                .centerCrop()
                .transform(new GrayTransformation())//度灰处理
                .transform(new BlurTransformation(this))//高斯模糊
                .into(mBlurImage);

需要注意调用的顺序
方式二:接受一个List,将Transformation 放大list 里

        List<Transformation> transformations = new ArrayList<>();
        transformations.add(new GrayTransformation());
        transformations.add(new BlurTransformation(this));

        Picasso.with(this).load(URL)
                .placeholder(R.drawable.default_bg)
                .error(R.drawable.error_iamge)
                .fit()
                .centerCrop()
                .transform(transformations)
                .into(mBlurImage);

效果图:

gray_blur.png

如上图,第一张为度灰操作,第二张为 度灰+高斯模糊

另外发现了一个开源库,专门写了很多好玩的Transformation,有兴趣的可以看一下:
picasso-transformations

6. 请求优先级

Picasso 为请求设置有优先级,有三种优先级,LOW、NORMAL、HIGH。默认情况下都是NORMAL,除了调用fetch 方法,fetch 方法的优先级是LOW。

public enum Priority {
    LOW,
    NORMAL,
    HIGH
  }

可以通过priority方法设置请求的优先级,这会影响请求的执行顺序,但是这是不能保证的,它只会往高的优先级靠拢。代码如下:

 Picasso.with(this).load(URL)
                .placeholder(R.drawable.default_bg)
                .error(R.drawable.error_iamge)
                .priority(Picasso.Priority.HIGH)
               // .priority(Picasso.Priority.LOW)
                .into(mImageView);

7. Tag管理请求

Picasso 允许我们为一个请求设置tag来管理请求,看一下对应的几个方法:
下面3个方法是Picasso这个类的:

  • cancelTag(Object tag) 取消设置了给定tag的所有请求
  • pauseTag(Object tag) 暂停设置了给定tag 的所有请求
  • resumeTag(Object tag) resume 被暂停的给定tag的所有请求

还有一个方法是RequestCreator的:

  • tag(Object tag) 为请求设置tag

几个方法的意思也很明确,就是我们可以暂停、resume、和取消请求,可以用在哪些场景呢?

场景一: 比如一个照片流列表,当我们快速滑动列表浏览照片的时候,后台会一直发起请求加载照片的,这可能会导致卡顿,那么我们就可以为每个请求设置一个相同的Tag,在快速滑动的时候,调用pauseTag暂停请求,当滑动停止的时候,调用resumeTag恢复请求,这样的体验是不是就会更好一些呢。

Adapter中添加如下代码:

Picasso.with(this).load(mData.get(position))
                .placeholder(R.drawable.default_bg)
                .error(R.drawable.error_iamge)
                .tag("PhotoTag")
                .into(holder.mImageView);

Activity中为RecyclerView添加滑动监听:

mRecyclerView.addOnScrollListener(new RecyclerView.OnScrollListener() {
            @Override
            public void onScrollStateChanged(RecyclerView recyclerView, int newState) {
                final Picasso picasso = Picasso.with(MainActivity.this);

                if (newState == SCROLL_STATE_IDLE) {
                    picasso.resumeTag("PhotoTag");
                } else {
                    picasso.pauseTag("PhotoTag");
                }
            }
        });

场景二: 比如一个照片流列表界面,在弱网环境下,加载很慢,退出这个界面时可能会有很多请求没有完成,这个时候我们就可 以通过tag 来取消请求了。

 @Override
    protected void onDestroy() {
        super.onDestroy();
        Picasso.with(this).cancelTag("PhotoTag");
    }

8. 同步/异步加载图片

Picasso 加载图片也有同步/异步两种方式
**1,get() 同步 **
很简单,同步加载使用get() 方法,返回一个Bitmap 对象,代码如下:

 try {
           Bitmap bitmap =  Picasso.with(this).load(URL).get();
        } catch (IOException e) {
            e.printStackTrace();
        }

注意:使用同步方式加载,不能放在主线程来做。

2,异步的方式加载图片,fetch()
一般直接加载图片通过into显示到ImageView 是异步的方式,除此之外,还提供了2个异步的方法:

  • fetch() 异步方式加载图片
  • fetch(Callback callback) 异步方式加载图片并给一个回调接口。

  Picasso.with(this).load(URL).fetch(new Callback() {
            @Override
            public void onSuccess() {
                //加载成功
            }

            @Override
            public void onError() {
              //加载失败
            }
        });

这里就要吐槽一下接口设计了,回调并没有返回Bitmap, 不知道作者是怎么考虑的,只是一个通知效果,知道请求失败还是成功。
**fetch 方法异步加载图片并没有返回Bitmap,这个方法在请求成功之后,将结果存到了缓存,包括磁盘和内存缓存。所以使用这种方式加载图片适用于这种场景:知道稍后会加载图片,使用fetch 先加载缓存,起到一个预加载的效果。 **

9. 缓存(Disk 和 Memory)

Picasso 有内存缓存(Memory)和磁盘缓存( Disk), 首先来看一下源码中对于缓存的介绍:

  • LRU memory cache of 15% the available application RAM
  • Disk cache of 2% storage space up to 50MB but no less than 5MB. (Note: this is only
    available on API 14+ <em>or</em> if you are using a standalone library that provides a disk cache on all API levels like OkHttp)
  • Three download threads for disk and network access.

可以看出,内存缓存是使用的LRU 策略的缓存实现,它的大小是内存大小的15%,可以自定义它的大小,最后在扩展那一章节再讲,磁盘缓存是磁盘容量的2%但是不超过50M,不少于5M。处理一个请求的时候,按照这个顺讯检查:memory->disk->network 。先检查有木有内存缓存,如果命中,直接返回结果,否则检查磁盘缓存,命中则返回结果,没有命中则从网上获取。

默认情况下,Picasso 内存缓存和磁盘缓存都开启了的,也就是加载图片的时候,内存和磁盘都缓存了,但是有些时候,我们并不需要缓存,比如说:加载一张大图片的时候,如果再内存中保存一份,很容易造成OOM,这时候我们只希望有磁盘缓存,而不希望缓存到内存,因此就需要我们设置缓存策略了。Picasso 提供了这样的方法。

1,memoryPolicy 设置内存缓存策略
就像上面所说的,有时候我们不希望有内存缓存,我们可以通过 memoryPolicy 来设置。MemoryPolicy是一个枚举,有两个值

NO_CACHE:表示处理请求的时候跳过检查内存缓存
**NO_STORE: ** 表示请求成功之后,不将最终的结果存到内存。

示例代码如下:

with(this).load(URL)
                .placeholder(R.drawable.default_bg)
                .error(R.drawable.error_iamge)
                .memoryPolicy(MemoryPolicy.NO_CACHE,MemoryPolicy.NO_STORE) //静止内存缓存
                .into(mBlurImage);

2,networkPolicy 设置磁盘缓存策略
和内存缓存一样,加载一张图片的时候,你也可以跳过磁盘缓存,和内存缓存策略的控制方式一样,磁盘缓存调用方法networkPolicy(NetworkPolicy policy, NetworkPolicy... additional) , NetworkPolicy是一个枚举类型,有三个值:

NO_CACHE: 表示处理请求的时候跳过处理磁盘缓存
** NO_STORE:** 表示请求成功后,不将结果缓存到Disk,但是这个只对OkHttp有效。
OFFLINE: 这个就跟 上面两个不一样了,如果networkPolicy方法用的是这个参数,那么Picasso会强制这次请求从缓存中获取结果,不会发起网络请求,不管缓存中能否获取到结果。

使用示例:

 with(this).load(URL)
                .placeholder(R.drawable.default_bg)
                .error(R.drawable.error_iamge)
                .memoryPolicy(MemoryPolicy.NO_CACHE,MemoryPolicy.NO_STORE)//跳过内存缓存
                .networkPolicy(NetworkPolicy.NO_CACHE)//跳过磁盘缓存
                .into(mBlurImage);

强制从缓存获取:

 with(this).load(URL)
                .placeholder(R.drawable.default_bg)
                .error(R.drawable.error_iamge)
                .networkPolicy(NetworkPolicy.OFFLINE)//强制从缓存获取结果
                .into(mBlurImage);

10. Debug 和日志

1,缓存指示器

上一节说了,Picasso 有内存缓存和磁盘缓存,先从内存获取,没有再去磁盘缓存获取,都有就从网络加载,网络加载是比较昂贵和耗时的。因此,作为一个开发者,我们往往需要加载的图片是从哪儿来的(内存、Disk还是网络),Picasso让我们很容易就实现了。只需要调用一个方法setIndicatorsEnabled(boolean)就可以了,它会在图片的左上角出现一个带色块的三角形标示,有3种颜色,绿色表示从内存加载、蓝色表示从磁盘加载、红色表示从网络加载。

 Picasso.with(this)
        .setIndicatorsEnabled(true);//显示指示器

效果图:

cache_indicator.png

如上图所示,第一张图从网络获取,第二张从磁盘获取,第三张图从内存获取。

看一下源码中定义指示器的颜色:

 /** Describes where the image was loaded from. */
  public enum LoadedFrom {
    MEMORY(Color.GREEN),
    DISK(Color.BLUE),
    NETWORK(Color.RED);

    final int debugColor;

    private LoadedFrom(int debugColor) {
      this.debugColor = debugColor;
    }
  }

可以很清楚看出,对应三种颜色代表着图片的来源。

2,日志
上面的指示器能够很好的帮助我们看出图片的来源,但是有时候我们需要更详细的信息,Picasso,可以打印一些日志,比如一些关键方法的执行时间等等,我们只需要调用setLoggingEnabled(true)方法,然后App在加载图片的过程中,我们就可以从logcat 看到一些关键的日志信息。

   Picasso.with(this)
          .setLoggingEnabled(true);//开启日志打印

11. Picasso 扩展

到目前为止,Picasso的基本使用已经讲得差不多了,但是在实际项目中我们这可能还满足不了我们的需求,我们需要对它做一些自己的扩展,比如我们需要换缓存的位置、我们需要扩大缓存、自定义线程池、自定义下载器等等。这些都是可以的,接下来我们来看一下可以做哪些方面的扩展。

1,用Builder 自己构造一个Picasso Instance
我们来回顾一下前面是怎么用Picasso 加载图片的:

Picasso.with(this)
       .load("http://ww3.sinaimg.cn/large/610dc034jw1fasakfvqe1j20u00mhgn2.jpg")
       .into(mImageView);

总共3步:
1,用with方法获取一个Picasso 示例
2,用load方法加载图片
3,用into 放法显示图片

首先Picasso是一个单例模式,我们每一次获取的示例都是默认提供给我们的实例。但是也可以不用它给的Instance,我们直接用builder来构造一个Picasso:

       Picasso.Builder builder = new Picasso.Builder(this);
        //构造一个Picasso
        Picasso picasso = builder.build();
        //加载图片
        picasso.load(URL)
                .into(mImageView);

这样我们就构造了一个局部的Picasso实例,当然了,我们直接用new 了一个builder,然后build()生成了一个Picasso。这跟默认的通过with方法获取的实例是一样的。那么现在我们就可以配置一些自定义的功能了。
2, 配置自定义下载器 downLoader
如果我们不想用默认提供的Downloader,那么我们可以自定义一个下载器然后配置进去。举个例子:

(1) 先自定义一个Downloader(只是举个例子,并没有实现):

/**
 * Created by zhouwei on 17/2/26.
 */

public class CustomDownloader implements Downloader {

    @Override
    public Response load(Uri uri, int networkPolicy) throws IOException {
        return null;
    }

    @Override
    public void shutdown() {

    }
}

(2) 然后通过builder 配置:

        //配置下载器
        builder.downloader(new CustomDownloader());
        //构造一个Picasso
        Picasso picasso = builder.build();

这样配置后,我们用build()生成的Picasso 实例来加载图片就会使用自定义的下载器来下载图片了。

** 3, 配置缓存**
前面说过,内存缓存是用的LRU Cahce ,大小是手机内存的15% ,如果你想缓存大小更大一点或者更小一点,可以自定义,然后配置。

        //配置缓存
        LruCache cache = new LruCache(5*1024*1024);// 设置缓存大小
        builder.memoryCache(cache);

上面只是一个简单的举例,当然了你可以自定义,也可以使用LRUCache,改变大小,改变存储路径等等。

提示: 很遗憾,好像没有提供改变磁盘缓存的接口,那就只能用默认的了。

4, 配置线程池
Picasso 默认的线程池的核心线程数为3,如果你觉得不够用的话,可以配置自己需要的线程池,举个列子:

        //配置线程池
        ExecutorService executorService = Executors.newFixedThreadPool(8);
        builder.executor(executorService);

**5, 配置全局的 Picasso Instance **
上面说的这些自定义配置项目都是应用在一个局部的Picasso instance 上的,我们不可能每一次使用都要重新配置一下,这样就太麻烦了。我们希望我们的这些自定义配置能在整个项目都应用上,并且只配置一次。其实Picasso 给我们提供了这样的方法。可以调用setSingletonInstance(Picasso picasso)就可以了,看一下这个方法的源码:

 /**
   * Set the global instance returned from {@link #with}.
   * <p>
   * This method must be called before any calls to {@link #with} and may only be called once.
   */
  public static void setSingletonInstance(Picasso picasso) {
    synchronized (Picasso.class) {
      if (singleton != null) {
        throw new IllegalStateException("Singleton instance already exists.");
      }
      singleton = picasso;
    }
  }

设置一个通过with方法返回的全局instance。我们只希望配置一次,所以,我们应该在Application 的onCreate方法中做全局配置就可以了。app一启动就配置好,然后直接和前面的使用方法一样,调用with方法获取Picasso instance 加载图片就OK了。

因此在Application 中添加如下代码:

 @Override
    public void onCreate() {
        super.onCreate();
        
        // 配置全局的Picasso instance 
        
        Picasso.Builder builder = new Picasso.Builder(this);
        //配置下载器
        builder.downloader(new CustomDownloader());
        //配置缓存
        LruCache cache = new LruCache(5*1024*1024);// 设置缓存大小
        builder.memoryCache(cache);
        //配置线程池
        ExecutorService executorService = Executors.newFixedThreadPool(8);
        builder.executor(executorService);

        //构造一个Picasso
        Picasso picasso = builder.build();
        // 设置全局单列instance 
        Picasso.setSingletonInstance(picasso);
        
        
    }

然后应用这些自定义配置加载图片

Picasso.with(this).load("http://ww3.sinaimg.cn/large/610dc034jw1fasakfvqe1j20u00mhgn2.jpg").into(mImageView);

用法和以前的一样,但是我们已经将我们的自定义配置应用上了。

结尾

以上就是对Picasso 用法的全部总结,如有什么问题,欢迎留言指正。Picasso真的是一个强大的图片加载缓存库,API 简单好用,而且是链式调用的(这点我特别喜欢)。官方文档写的比较简单,很多用法都要看源码和注释才知道。希望本文能给才开始使用Picasso 的同学一点帮助。

参考

Picasso官网
Picasso — Getting Started

以太坊客户端Geth命令用法-参数详解

 eth, 区块链  以太坊客户端Geth命令用法-参数详解已关闭评论
10月 162018
 

geth的命令行详解,备用。

geth在以太坊智能合约开发中最常用的工具(必备开发工具),一个多用途的命令行工具。
熟悉Geth可以让我们有更好的效率,大家可收藏起来作为Geth命令用法手册。 本文主要是对geth help的翻译,基于最新的geth 1.7.3-stable版本。

命令用法

geth [选项] 命令 [命令选项] [参数…]

版本:

1.7.3-stable

命令:

account    管理账户
attach     启动交互式JavaScript环境(连接到节点)
bug        上报bug Issues
console    启动交互式JavaScript环境
copydb     从文件夹创建本地链
dump       Dump(分析)一个特定的块存储
dumpconfig 显示配置值
export     导出区块链到文件
import     导入一个区块链文件
init       启动并初始化一个新的创世纪块
js         执行指定的JavaScript文件(多个)
license    显示许可信息
makecache  生成ethash验证缓存(用于测试)
makedag    生成ethash 挖矿DAG(用于测试)
monitor    监控和可视化节点指标
removedb   删除区块链和状态数据库
version    打印版本号
wallet     管理Ethereum预售钱包
help,h     显示一个命令或帮助一个命令列表

ETHEREUM选项:

--config value          TOML 配置文件
--datadir “xxx”         数据库和keystore密钥的数据目录
--keystore              keystore存放目录(默认在datadir内)
--nousb                 禁用监控和管理USB硬件钱包
--networkid value       网络标识符(整型, 1=Frontier, 2=Morden (弃用), 3=Ropsten, 4=Rinkeby) (默认: 1)
--testnet               Ropsten网络:预先配置的POW(proof-of-work)测试网络
--rinkeby               Rinkeby网络: 预先配置的POA(proof-of-authority)测试网络
--syncmode "fast"       同步模式 ("fast", "full", or "light")
--ethstats value        上报ethstats service  URL (nodename:secret@host:port)
--identity value        自定义节点名
--lightserv value       允许LES请求时间最大百分比(0 – 90)(默认值:0) 
--lightpeers value      最大LES client peers数量(默认值:20)
--lightkdf              在KDF强度消费时降低key-derivation RAM&CPU使用

开发者(模式)选项:

--dev               使用POA共识网络,默认预分配一个开发者账户并且会自动开启挖矿。
--dev.period value  开发者模式下挖矿周期 (0 = 仅在交易时) (默认: 0)

ETHASH 选项:

--ethash.cachedir                        ethash验证缓存目录(默认 = datadir目录内)
--ethash.cachesinmem value               在内存保存的最近的ethash缓存个数  (每个缓存16MB ) (默认: 2)
--ethash.cachesondisk value              在磁盘保存的最近的ethash缓存个数 (每个缓存16MB) (默认: 3)
--ethash.dagdir ""                       存ethash DAGs目录 (默认 = 用户hom目录)
--ethash.dagsinmem value                 在内存保存的最近的ethash DAGs 个数 (每个1GB以上) (默认: 1)
--ethash.dagsondisk value                在磁盘保存的最近的ethash DAGs 个数 (每个1GB以上) (默认: 2)

交易池选项:

--txpool.nolocals            为本地提交交易禁用价格豁免
--txpool.journal value       本地交易的磁盘日志:用于节点重启 (默认: "transactions.rlp")
--txpool.rejournal value     重新生成本地交易日志的时间间隔 (默认: 1小时)
--txpool.pricelimit value    加入交易池的最小的gas价格限制(默认: 1)
--txpool.pricebump value     价格波动百分比(相对之前已有交易) (默认: 10)
--txpool.accountslots value  每个帐户保证可执行的最少交易槽数量  (默认: 16)
--txpool.globalslots value   所有帐户可执行的最大交易槽数量 (默认: 4096)
--txpool.accountqueue value  每个帐户允许的最多非可执行交易槽数量 (默认: 64)
--txpool.globalqueue value   所有帐户非可执行交易最大槽数量  (默认: 1024)
--txpool.lifetime value      非可执行交易最大入队时间(默认: 3小时)

性能调优的选项:

--cache value                分配给内部缓存的内存MB数量,缓存值(最低16 mb /数据库强制要求)(默认:128)
--trie-cache-gens value      保持在内存中产生的trie node数量(默认:120)

帐户选项:

--unlock value              需解锁账户用逗号分隔
--password value            用于非交互式密码输入的密码文件

API和控制台选项:

--rpc                       启用HTTP-RPC服务器
--rpcaddr value             HTTP-RPC服务器接口地址(默认值:“localhost”)
--rpcport value             HTTP-RPC服务器监听端口(默认值:8545)
--rpcapi value              基于HTTP-RPC接口提供的API
--ws                        启用WS-RPC服务器
--wsaddr value              WS-RPC服务器监听接口地址(默认值:“localhost”)
--wsport value              WS-RPC服务器监听端口(默认值:8546)
--wsapi  value              基于WS-RPC的接口提供的API
--wsorigins value           websockets请求允许的源
--ipcdisable                禁用IPC-RPC服务器
--ipcpath                   包含在datadir里的IPC socket/pipe文件名(转义过的显式路径)
--rpccorsdomain value       允许跨域请求的域名列表(逗号分隔)(浏览器强制)
--jspath loadScript         JavaScript加载脚本的根路径(默认值:“.”)
--exec value                执行JavaScript语句(只能结合console/attach使用)
--preload value             预加载到控制台的JavaScript文件列表(逗号分隔)

网络选项:

--bootnodes value    用于P2P发现引导的enode urls(逗号分隔)(对于light servers用v4+v5代替)
--bootnodesv4 value  用于P2P v4发现引导的enode urls(逗号分隔) (light server, 全节点)
--bootnodesv5 value  用于P2P v5发现引导的enode urls(逗号分隔) (light server, 轻节点)
--port value         网卡监听端口(默认值:30303)
--maxpeers value     最大的网络节点数量(如果设置为0,网络将被禁用)(默认值:25)
--maxpendpeers value    最大尝试连接的数量(如果设置为0,则将使用默认值)(默认值:0)
--nat value             NAT端口映射机制 (any|none|upnp|pmp|extip:<IP>) (默认: “any”)
--nodiscover            禁用节点发现机制(手动添加节点)
--v5disc                启用实验性的RLPx V5(Topic发现)机制
--nodekey value         P2P节点密钥文件
--nodekeyhex value      十六进制的P2P节点密钥(用于测试)

矿工选项:

--mine                  打开挖矿
--minerthreads value    挖矿使用的CPU线程数量(默认值:8)
--etherbase value       挖矿奖励地址(默认=第一个创建的帐户)(默认值:“0”)
--targetgaslimit value  目标gas限制:设置最低gas限制(低于这个不会被挖?) (默认值:“4712388”)
--gasprice value        挖矿接受交易的最低gas价格
--extradata value       矿工设置的额外块数据(默认=client version)

GAS价格选项:

--gpoblocks value      用于检查gas价格的最近块的个数  (默认: 10)
--gpopercentile value  建议gas价参考最近交易的gas价的百分位数,(默认: 50)

虚拟机的选项:

--vmdebug        记录VM及合约调试信息

日志和调试选项:

--metrics            启用metrics收集和报告
--fakepow            禁用proof-of-work验证
--verbosity value    日志详细度:0=silent, 1=error, 2=warn, 3=info, 4=debug, 5=detail (default: 3)
--vmodule value      每个模块详细度:以 <pattern>=<level>的逗号分隔列表 (比如 eth/*=6,p2p=5)
--backtrace value    请求特定日志记录堆栈跟踪 (比如 “block.go:271”)
--debug                     突出显示调用位置日志(文件名及行号)
--pprof                     启用pprof HTTP服务器
--pprofaddr value           pprof HTTP服务器监听接口(默认值:127.0.0.1)
--pprofport value           pprof HTTP服务器监听端口(默认值:6060)
--memprofilerate value      按指定频率打开memory profiling    (默认:524288)
--blockprofilerate value    按指定频率打开block profiling    (默认值:0)
--cpuprofile value          将CPU profile写入指定文件
--trace value               将execution trace写入指定文件

WHISPER实验选项:

--shh                        启用Whisper
--shh.maxmessagesize value   可接受的最大的消息大小 (默认值: 1048576)
--shh.pow value              可接受的最小的POW (默认值: 0.2)

弃用选项:

--fast     开启快速同步
--light    启用轻客户端模式

其他选项:

–help, -h    显示帮助
转自:https://learnblockchain.cn/2017/11/29/geth_cmd_options/

maven POM.xml 标签详解

 MAVEN  maven POM.xml 标签详解已关闭评论
5月 282018
 

作为参考资料,记录下:

转自:http://blog.csdn.net/sunzhenhua0608/article/details/32938533 

 pom作为项目对象模型。通过xml表示maven项目,使用pom.xml来实现。主要描述了项目:包括配置文件;开发者需要遵循的规则,缺陷管理系统,组织和licenses,项目的url,项目的依赖性,以及其他所有的项目相关因素

具体描述如下:

<project xmlns=”http://maven.apache.org/POM/4.0.0″     
    xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”     
xsi:schemaLocation=”http://maven.apache.org/POM/4.0.0http://maven.apache.org/maven-v4_0_0.xsd”>     
    <!–父项目的坐标。如果项目中没有规定某个元素的值,那么父项目中的对应值即为项目的默认值。 坐标包括group ID,artifact ID和 version。–>    
    <parent>    
     <!–被继承的父项目的构件标识符–>    
     <artifactId/>    
     <!–被继承的父项目的全球唯一标识符–>    
     <groupId/>    
     <!–被继承的父项目的版本–>    
     <version/>    
     <!– 父项目的pom.xml文件的相对路径。相对路径允许你选择一个不同的路径。默认值是../pom.xml。Maven首先在构建当前项目的地方寻找父项 目的pom,其次在文件系统的这个位置(relativePath位置),然后在本地仓库,最后在远程仓库寻找父项目的pom。–>    
     <relativePath/>    
 </parent>    
 <!–声明项目描述符遵循哪一个POM模型版本。模型本身的版本很少改变,虽然如此,但它仍然是必不可少的,这是为了当Maven引入了新的特性或者其他模型变更的时候,确保稳定性。–>       
    <modelVersion>4.0.0</modelVersion>     
    <!–项目的全球唯一标识符,通常使用全限定的包名区分该项目和其他项目。并且构建时生成的路径也是由此生成, 如com.mycompany.app生成的相对路径为:/com/mycompany/app–>     
    <groupId>asia.banseon</groupId>     
    <!– 构件的标识符,它和group ID一起唯一标识一个构件。换句话说,你不能有两个不同的项目拥有同样的artifact ID和groupID;在某个 特定的group ID下,artifact ID也必须是唯一的。构件是项目产生的或使用的一个东西,Maven为项目产生的构件包括:JARs,源 码,二进制发布和WARs等。–>     
    <artifactId>banseon-maven2</artifactId>     
    <!–项目产生的构件类型,例如jar、war、ear、pom。插件可以创建他们自己的构件类型,所以前面列的不是全部构件类型–>     
    <packaging>jar</packaging>     
    <!–项目当前版本,格式为:主版本.次版本.增量版本-限定版本号–>     
    <version>1.0-SNAPSHOT</version>     
    <!–项目的名称, Maven产生的文档用–>     
    <name>banseon-maven</name>     
    <!–项目主页的URL, Maven产生的文档用–>     
    <url>http://www.baidu.com/banseon</url>     
    <!– 项目的详细描述, Maven 产生的文档用。  当这个元素能够用HTML格式描述时(例如,CDATA中的文本会被解析器忽略,就可以包含HTML标 签), 不鼓励使用纯文本描述。如果你需要修改产生的web站点的索引页面,你应该修改你自己的索引页文件,而不是调整这里的文档。–>     
    <description>A maven project to study maven.</description>     
    <!–描述了这个项目构建环境中的前提条件。–>    
 <prerequisites>    
  <!–构建该项目或使用该插件所需要的Maven的最低版本–>    
    <maven/>    
 </prerequisites>    
 <!–项目的问题管理系统(Bugzilla, Jira, Scarab,或任何你喜欢的问题管理系统)的名称和URL,本例为 jira–>     
    <issueManagement>    
     <!–问题管理系统(例如jira)的名字,–>     
        <system>jira</system>     
        <!–该项目使用的问题管理系统的URL–>    
        <url>http://jira.baidu.com/banseon</url>     
    </issueManagement>     
    <!–项目持续集成信息–>    
 <ciManagement>    
  <!–持续集成系统的名字,例如continuum–>    
  <system/>    
  <!–该项目使用的持续集成系统的URL(如果持续集成系统有web接口的话)。–>    
  <url/>    
  <!–构建完成时,需要通知的开发者/用户的配置项。包括被通知者信息和通知条件(错误,失败,成功,警告)–>    
  <notifiers>    
   <!–配置一种方式,当构建中断时,以该方式通知用户/开发者–>    
   <notifier>    
    <!–传送通知的途径–>    
    <type/>    
    <!–发生错误时是否通知–>    
    <sendOnError/>    
    <!–构建失败时是否通知–>    
    <sendOnFailure/>    
    <!–构建成功时是否通知–>    
    <sendOnSuccess/>    
    <!–发生警告时是否通知–>    
    <sendOnWarning/>    
    <!–不赞成使用。通知发送到哪里–>    
    <address/>    
    <!–扩展配置项–>    
    <configuration/>    
   </notifier>    
  </notifiers>    
 </ciManagement>    
 <!–项目创建年份,4位数字。当产生版权信息时需要使用这个值。–>    
    <inceptionYear/>    
    <!–项目相关邮件列表信息–>     
    <mailingLists>    
     <!–该元素描述了项目相关的所有邮件列表。自动产生的网站引用这些信息。–>     
        <mailingList>     
         <!–邮件的名称–>    
            <name>Demo</name>     
            <!–发送邮件的地址或链接,如果是邮件地址,创建文档时,mailto: 链接会被自动创建–>     
            <post>[email protected]</post>     
            <!–订阅邮件的地址或链接,如果是邮件地址,创建文档时,mailto: 链接会被自动创建–>     
            <subscribe>[email protected]</subscribe>     
            <!–取消订阅邮件的地址或链接,如果是邮件地址,创建文档时,mailto: 链接会被自动创建–>     
            <unsubscribe>[email protected]</unsubscribe>     
            <!–你可以浏览邮件信息的URL–>    
            <archive>http:/hi.baidu.com/banseon/demo/dev/</archive>     
        </mailingList>     
    </mailingLists>     
    <!–项目开发者列表–>     
    <developers>     
     <!–某个项目开发者的信息–>    
        <developer>     
         <!–SCM里项目开发者的唯一标识符–>    
            <id>HELLO WORLD</id>     
            <!–项目开发者的全名–>    
            <name>banseon</name>     
            <!–项目开发者的email–>    
            <email>[email protected]</email>     
            <!–项目开发者的主页的URL–>    
            <url/>    
            <!–项目开发者在项目中扮演的角色,角色元素描述了各种角色–>    
            <roles>     
                <role>Project Manager</role>     
                <role>Architect</role>     
            </roles>    
            <!–项目开发者所属组织–>    
            <organization>demo</organization>     
            <!–项目开发者所属组织的URL–>    
            <organizationUrl>http://hi.baidu.com/banseon</organizationUrl>     
            <!–项目开发者属性,如即时消息如何处理等–>    
            <properties>     
                <dept>No</dept>     
            </properties>    
            <!–项目开发者所在时区, -11到12范围内的整数。–>    
            <timezone>-5</timezone>     
        </developer>     
    </developers>     
    <!–项目的其他贡献者列表–>     
    <contributors>    
     <!–项目的其他贡献者。参见developers/developer元素–>    
     <contributor>    
   <name/><email/><url/><organization/><organizationUrl/><roles/><timezone/><properties/>    
     </contributor>         
    </contributors>       
    <!–该元素描述了项目所有License列表。 应该只列出该项目的license列表,不要列出依赖项目的 license列表。如果列出多个license,用户可以选择它们中的一个而不是接受所有license。–>     
    <licenses>    
     <!–描述了项目的license,用于生成项目的web站点的license页面,其他一些报表和validation也会用到该元素。–>     
        <license>    
         <!–license用于法律上的名称–>    
            <name>Apache 2</name>     
            <!–官方的license正文页面的URL–>    
            <url>http://www.baidu.com/banseon/LICENSE-2.0.txt</url>     
            <!–项目分发的主要方式:    
              repo,可以从Maven库下载    
              manual, 用户必须手动下载和安装依赖–>    
            <distribution>repo</distribution>     
            <!–关于license的补充信息–>    
            <comments>A business-friendly OSS license</comments>     
        </license>     
    </licenses>     
    <!–SCM(Source Control Management)标签允许你配置你的代码库,供Maven web站点和其它插件使用。–>     
    <scm>     
        <!–SCM的URL,该URL描述了版本库和如何连接到版本库。欲知详情,请看SCMs提供的URL格式和列表。该连接只读。–>     
        <connection>     
            scm:svn:http://svn.baidu.com/banseon/maven/banseon/banseon-maven2-trunk(dao-trunk)      
        </connection>     
        <!–给开发者使用的,类似connection元素。即该连接不仅仅只读–>    
        <developerConnection>     
            scm:svn:http://svn.baidu.com/banseon/maven/banseon/dao-trunk      
        </developerConnection>    
        <!–当前代码的标签,在开发阶段默认为HEAD–>    
        <tag/>           
        <!–指向项目的可浏览SCM库(例如ViewVC或者Fisheye)的URL。–>     
        <url>http://svn.baidu.com/banseon</url>     
    </scm>     
    <!–描述项目所属组织的各种属性。Maven产生的文档用–>     
    <organization>     
     <!–组织的全名–>    
        <name>demo</name>     
        <!–组织主页的URL–>    
        <url>http://www.baidu.com/banseon</url>     
    </organization>    
    <!–构建项目需要的信息–>    
    <build>    
     <!–该元素设置了项目源码目录,当构建项目的时候,构建系统会编译目录里的源码。该路径是相对于pom.xml的相对路径。–>    
  <sourceDirectory/>    
  <!–该元素设置了项目脚本源码目录,该目录和源码目录不同:绝大多数情况下,该目录下的内容 会被拷贝到输出目录(因为脚本是被解释的,而不是被编译的)。–>    
  <scriptSourceDirectory/>    
  <!–该元素设置了项目单元测试使用的源码目录,当测试项目的时候,构建系统会编译目录里的源码。该路径是相对于pom.xml的相对路径。–>    
  <testSourceDirectory/>    
  <!–被编译过的应用程序class文件存放的目录。–>    
  <outputDirectory/>    
  <!–被编译过的测试class文件存放的目录。–>    
  <testOutputDirectory/>    
  <!–使用来自该项目的一系列构建扩展–>    
  <extensions>    
   <!–描述使用到的构建扩展。–>    
   <extension>    
    <!–构建扩展的groupId–>    
    <groupId/>    
    <!–构建扩展的artifactId–>    
    <artifactId/>    
    <!–构建扩展的版本–>    
    <version/>    
   </extension>    
  </extensions>    
  <!–当项目没有规定目标(Maven2 叫做阶段)时的默认值–>    
  <defaultGoal/>    
  <!–这个元素描述了项目相关的所有资源路径列表,例如和项目相关的属性文件,这些资源被包含在最终的打包文件里。–>    
  <resources>    
   <!–这个元素描述了项目相关或测试相关的所有资源路径–>    
   <resource>    
    <!– 描述了资源的目标路径。该路径相对target/classes目录(例如${project.build.outputDirectory})。举个例 子,如果你想资源在特定的包里(org.apache.maven.messages),你就必须该元素设置为org/apache/maven /messages。然而,如果你只是想把资源放到源码目录结构里,就不需要该配置。–>    
    <targetPath/>    
    <!–是否使用参数值代替参数名。参数值取自properties元素或者文件里配置的属性,文件在filters元素里列出。–>    
    <filtering/>    
    <!–描述存放资源的目录,该路径相对POM路径–>    
    <directory/>    
    <!–包含的模式列表,例如**/*.xml.–>    
    <includes/>    
    <!–排除的模式列表,例如**/*.xml–>    
    <excludes/>    
   </resource>    
  </resources>    
  <!–这个元素描述了单元测试相关的所有资源路径,例如和单元测试相关的属性文件。–>    
  <testResources>    
   <!–这个元素描述了测试相关的所有资源路径,参见build/resources/resource元素的说明–>    
   <testResource>    
    <targetPath/><filtering/><directory/><includes/><excludes/>    
   </testResource>    
  </testResources>    
  <!–构建产生的所有文件存放的目录–>    
  <directory/>    
  <!–产生的构件的文件名,默认值是${artifactId}-${version}。–>    
  <finalName/>    
  <!–当filtering开关打开时,使用到的过滤器属性文件列表–>    
  <filters/>    
  <!–子项目可以引用的默认插件信息。该插件配置项直到被引用时才会被解析或绑定到生命周期。给定插件的任何本地配置都会覆盖这里的配置–>    
  <pluginManagement>    
   <!–使用的插件列表 。–>    
   <plugins>    
    <!–plugin元素包含描述插件所需要的信息。–>    
    <plugin>    
     <!–插件在仓库里的group ID–>    
     <groupId/>    
     <!–插件在仓库里的artifact ID–>    
     <artifactId/>    
     <!–被使用的插件的版本(或版本范围)–>    
     <version/>    
     <!–是否从该插件下载Maven扩展(例如打包和类型处理器),由于性能原因,只有在真需要下载时,该元素才被设置成enabled。–>    
     <extensions/>    
     <!–在构建生命周期中执行一组目标的配置。每个目标可能有不同的配置。–>    
     <executions>    
      <!–execution元素包含了插件执行需要的信息–>    
      <execution>    
       <!–执行目标的标识符,用于标识构建过程中的目标,或者匹配继承过程中需要合并的执行目标–>    
       <id/>    
       <!–绑定了目标的构建生命周期阶段,如果省略,目标会被绑定到源数据里配置的默认阶段–>    
       <phase/>    
       <!–配置的执行目标–>    
       <goals/>    
       <!–配置是否被传播到子POM–>    
       <inherited/>    
       <!–作为DOM对象的配置–>    
       <configuration/>    
      </execution>    
     </executions>    
     <!–项目引入插件所需要的额外依赖–>    
     <dependencies>    
      <!–参见dependencies/dependency元素–>    
      <dependency>    
       ……    
      </dependency>    
     </dependencies>         
     <!–任何配置是否被传播到子项目–>    
     <inherited/>    
     <!–作为DOM对象的配置–>    
     <configuration/>    
    </plugin>    
   </plugins>    
  </pluginManagement>    
  <!–使用的插件列表–>    
  <plugins>    
   <!–参见build/pluginManagement/plugins/plugin元素–>    
   <plugin>    
    <groupId/><artifactId/><version/><extensions/>    
    <executions>    
     <execution>    
      <id/><phase/><goals/><inherited/><configuration/>    
     </execution>    
    </executions>    
    <dependencies>    
     <!–参见dependencies/dependency元素–>    
     <dependency>    
      ……    
     </dependency>    
    </dependencies>    
    <goals/><inherited/><configuration/>    
   </plugin>    
  </plugins>    
 </build>    
 <!–在列的项目构建profile,如果被激活,会修改构建处理–>    
 <profiles>    
  <!–根据环境参数或命令行参数激活某个构建处理–>    
  <profile>    
   <!–构建配置的唯一标识符。即用于命令行激活,也用于在继承时合并具有相同标识符的profile。–>    
   <id/>    
   <!–自动触发profile的条件逻辑。Activation是profile的开启钥匙。profile的力量来自于它    
   能够在某些特定的环境中自动使用某些特定的值;这些环境通过activation元素指定。activation元素并不是激活profile的唯一方式。–>    
   <activation>    
    <!–profile默认是否激活的标志–>    
    <activeByDefault/>    
    <!–当匹配的jdk被检测到,profile被激活。例如,1.4激活JDK1.4,1.4.0_2,而!1.4激活所有版本不是以1.4开头的JDK。–>    
    <jdk/>    
    <!–当匹配的操作系统属性被检测到,profile被激活。os元素可以定义一些操作系统相关的属性。–>    
    <os>    
     <!–激活profile的操作系统的名字–>    
     <name>Windows XP</name>    
     <!–激活profile的操作系统所属家族(如 ‘windows’)–>    
     <family>Windows</family>    
     <!–激活profile的操作系统体系结构 –>    
     <arch>x86</arch>    
     <!–激活profile的操作系统版本–>    
     <version>5.1.2600</version>    
    </os>    
    <!–如果Maven检测到某一个属性(其值可以在POM中通过${名称}引用),其拥有对应的名称和值,Profile就会被激活。如果值    
    字段是空的,那么存在属性名称字段就会激活profile,否则按区分大小写方式匹配属性值字段–>    
    <property>    
     <!–激活profile的属性的名称–>    
     <name>mavenVersion</name>    
     <!–激活profile的属性的值–>    
     <value>2.0.3</value>    
    </property>    
    <!–提供一个文件名,通过检测该文件的存在或不存在来激活profile。missing检查文件是否存在,如果不存在则激活    
    profile。另一方面,exists则会检查文件是否存在,如果存在则激活profile。–>    
    <file>    
     <!–如果指定的文件存在,则激活profile。–>    
     <exists>/usr/local/hudson/hudson-home/jobs/maven-guide-zh-to-production/workspace/</exists>    
     <!–如果指定的文件不存在,则激活profile。–>    
     <missing>/usr/local/hudson/hudson-home/jobs/maven-guide-zh-to-production/workspace/</missing>    
    </file>    
   </activation>    
   <!–构建项目所需要的信息。参见build元素–>    
   <build>    
    <defaultGoal/>    
    <resources>    
     <resource>    
      <targetPath/><filtering/><directory/><includes/><excludes/>    
     </resource>    
    </resources>    
    <testResources>    
     <testResource>    
      <targetPath/><filtering/><directory/><includes/><excludes/>    
     </testResource>    
    </testResources>    
    <directory/><finalName/><filters/>    
    <pluginManagement>    
     <plugins>    
      <!–参见build/pluginManagement/plugins/plugin元素–>    
      <plugin>    
       <groupId/><artifactId/><version/><extensions/>    
       <executions>    
        <execution>    
         <id/><phase/><goals/><inherited/><configuration/>    
        </execution>    
       </executions>    
       <dependencies>    
        <!–参见dependencies/dependency元素–>    
        <dependency>    
         ……    
        </dependency>    
       </dependencies>    
       <goals/><inherited/><configuration/>    
      </plugin>    
     </plugins>    
    </pluginManagement>    
    <plugins>    
     <!–参见build/pluginManagement/plugins/plugin元素–>    
     <plugin>    
      <groupId/><artifactId/><version/><extensions/>    
      <executions>    
       <execution>    
        <id/><phase/><goals/><inherited/><configuration/>    
       </execution>    
      </executions>    
      <dependencies>    
       <!–参见dependencies/dependency元素–>    
       <dependency>    
        ……    
       </dependency>    
      </dependencies>    
      <goals/><inherited/><configuration/>    
     </plugin>    
    </plugins>    
   </build>    
   <!–模块(有时称作子项目) 被构建成项目的一部分。列出的每个模块元素是指向该模块的目录的相对路径–>    
   <modules/>    
   <!–发现依赖和扩展的远程仓库列表。–>    
   <repositories>    
    <!–参见repositories/repository元素–>    
    <repository>    
     <releases>    
      <enabled/><updatePolicy/><checksumPolicy/>    
     </releases>    
     <snapshots>    
      <enabled/><updatePolicy/><checksumPolicy/>    
     </snapshots>    
     <id/><name/><url/><layout/>    
    </repository>    
   </repositories>    
   <!–发现插件的远程仓库列表,这些插件用于构建和报表–>    
   <pluginRepositories>    
    <!–包含需要连接到远程插件仓库的信息.参见repositories/repository元素–>        
    <pluginRepository>    
     <releases>    
      <enabled/><updatePolicy/><checksumPolicy/>    
     </releases>    
     <snapshots>    
      <enabled/><updatePolicy/><checksumPolicy/>    
     </snapshots>    
     <id/><name/><url/><layout/>    
    </pluginRepository>    
   </pluginRepositories>    
   <!–该元素描述了项目相关的所有依赖。 这些依赖组成了项目构建过程中的一个个环节。它们自动从项目定义的仓库中下载。要获取更多信息,请看项目依赖机制。–>    
   <dependencies>    
    <!–参见dependencies/dependency元素–>    
    <dependency>    
     ……    
    </dependency>    
   </dependencies>    
   <!–不赞成使用. 现在Maven忽略该元素.–>    
   <reports/>       
   <!–该元素包括使用报表插件产生报表的规范。当用户执行“mvn site”,这些报表就会运行。 在页面导航栏能看到所有报表的链接。参见reporting元素–>    
   <reporting>    
    ……    
   </reporting>    
   <!–参见dependencyManagement元素–>    
   <dependencyManagement>    
    <dependencies>    
     <!–参见dependencies/dependency元素–>    
     <dependency>    
      ……    
     </dependency>    
    </dependencies>    
   </dependencyManagement>    
   <!–参见distributionManagement元素–>    
   <distributionManagement>    
    ……    
   </distributionManagement>    
   <!–参见properties元素–>    
   <properties/>    
  </profile>    
 </profiles>    
 <!–模块(有时称作子项目) 被构建成项目的一部分。列出的每个模块元素是指向该模块的目录的相对路径–>    
 <modules/>    
    <!–发现依赖和扩展的远程仓库列表。–>     
    <repositories>     
     <!–包含需要连接到远程仓库的信息–>    
        <repository>    
         <!–如何处理远程仓库里发布版本的下载–>    
         <releases>    
          <!–true或者false表示该仓库是否为下载某种类型构件(发布版,快照版)开启。 –>    
    <enabled/>    
    <!–该元素指定更新发生的频率。Maven会比较本地POM和远程POM的时间戳。这里的选项是:always(一直),daily(默认,每日),interval:X(这里X是以分钟为单位的时间间隔),或者never(从不)。–>    
    <updatePolicy/>    
    <!–当Maven验证构件校验文件失败时该怎么做:ignore(忽略),fail(失败),或者warn(警告)。–>    
    <checksumPolicy/>    
   </releases>    
   <!– 如何处理远程仓库里快照版本的下载。有了releases和snapshots这两组配置,POM就可以在每个单独的仓库中,为每种类型的构件采取不同的 策略。例如,可能有人会决定只为开发目的开启对快照版本下载的支持。参见repositories/repository/releases元素 –>    
   <snapshots>    
    <enabled/><updatePolicy/><checksumPolicy/>    
   </snapshots>    
   <!–远程仓库唯一标识符。可以用来匹配在settings.xml文件里配置的远程仓库–>    
   <id>banseon-repository-proxy</id>     
   <!–远程仓库名称–>    
            <name>banseon-repository-proxy</name>     
            <!–远程仓库URL,按protocol://hostname/path形式–>    
            <url>http://192.168.1.169:9999/repository/</url>     
            <!– 用于定位和排序构件的仓库布局类型-可以是default(默认)或者legacy(遗留)。Maven 2为其仓库提供了一个默认的布局;然 而,Maven 1.x有一种不同的布局。我们可以使用该元素指定布局是default(默认)还是legacy(遗留)。–>    
            <layout>default</layout>               
        </repository>     
    </repositories>    
    <!–发现插件的远程仓库列表,这些插件用于构建和报表–>    
    <pluginRepositories>    
     <!–包含需要连接到远程插件仓库的信息.参见repositories/repository元素–>    
  <pluginRepository>    
   ……    
  </pluginRepository>    
 </pluginRepositories>    
       
    <!–该元素描述了项目相关的所有依赖。 这些依赖组成了项目构建过程中的一个个环节。它们自动从项目定义的仓库中下载。要获取更多信息,请看项目依赖机制。–>     
    <dependencies>     
        <dependency>    
   <!–依赖的group ID–>    
            <groupId>org.apache.maven</groupId>     
            <!–依赖的artifact ID–>    
            <artifactId>maven-artifact</artifactId>     
            <!–依赖的版本号。 在Maven 2里, 也可以配置成版本号的范围。–>    
            <version>3.8.1</version>     
            <!– 依赖类型,默认类型是jar。它通常表示依赖的文件的扩展名,但也有例外。一个类型可以被映射成另外一个扩展名或分类器。类型经常和使用的打包方式对应, 尽管这也有例外。一些类型的例子:jar,war,ejb-client和test-jar。如果设置extensions为 true,就可以在 plugin里定义新的类型。所以前面的类型的例子不完整。–>    
            <type>jar</type>    
            <!– 依赖的分类器。分类器可以区分属于同一个POM,但不同构建方式的构件。分类器名被附加到文件名的版本号后面。例如,如果你想要构建两个单独的构件成 JAR,一个使用Java 1.4编译器,另一个使用Java 6编译器,你就可以使用分类器来生成两个单独的JAR构件。–>    
            <classifier></classifier>    
            <!–依赖范围。在项目发布过程中,帮助决定哪些构件被包括进来。欲知详情请参考依赖机制。    
                – compile :默认范围,用于编译      
                – provided:类似于编译,但支持你期待jdk或者容器提供,类似于classpath      
                – runtime: 在执行时需要使用      
                – test:    用于test任务时使用      
                – system: 需要外在提供相应的元素。通过systemPath来取得      
                – systemPath: 仅用于范围为system。提供相应的路径      
                – optional:   当项目自身被依赖时,标注依赖是否传递。用于连续依赖时使用–>     
            <scope>test</scope>       
            <!–仅供system范围使用。注意,不鼓励使用这个元素,并且在新的版本中该元素可能被覆盖掉。该元素为依赖规定了文件系统上的路径。需要绝对路径而不是相对路径。推荐使用属性匹配绝对路径,例如${java.home}。–>    
            <systemPath></systemPath>     
            <!–当计算传递依赖时, 从依赖构件列表里,列出被排除的依赖构件集。即告诉maven你只依赖指定的项目,不依赖项目的依赖。此元素主要用于解决版本冲突问题–>    
            <exclusions>    
             <exclusion>     
                    <artifactId>spring-core</artifactId>     
                    <groupId>org.springframework</groupId>     
                </exclusion>     
            </exclusions>       
            <!–可选依赖,如果你在项目B中把C依赖声明为可选,你就需要在依赖于B的项目(例如项目A)中显式的引用对C的依赖。可选依赖阻断依赖的传递性。–>     
            <optional>true</optional>    
        </dependency>    
    </dependencies>    
    <!–不赞成使用. 现在Maven忽略该元素.–>    
    <reports></reports>    
    <!–该元素描述使用报表插件产生报表的规范。当用户执行“mvn site”,这些报表就会运行。 在页面导航栏能看到所有报表的链接。–>    
 <reporting>    
  <!–true,则,网站不包括默认的报表。这包括“项目信息”菜单中的报表。–>    
  <excludeDefaults/>    
  <!–所有产生的报表存放到哪里。默认值是${project.build.directory}/site。–>    
  <outputDirectory/>    
  <!–使用的报表插件和他们的配置。–>    
  <plugins>    
   <!–plugin元素包含描述报表插件需要的信息–>    
   <plugin>    
    <!–报表插件在仓库里的group ID–>    
    <groupId/>    
    <!–报表插件在仓库里的artifact ID–>    
    <artifactId/>    
    <!–被使用的报表插件的版本(或版本范围)–>    
    <version/>    
    <!–任何配置是否被传播到子项目–>    
    <inherited/>    
    <!–报表插件的配置–>    
    <configuration/>    
    <!–一组报表的多重规范,每个规范可能有不同的配置。一个规范(报表集)对应一个执行目标 。例如,有1,2,3,4,5,6,7,8,9个报表。1,2,5构成A报表集,对应一个执行目标。2,5,8构成B报表集,对应另一个执行目标–>    
    <reportSets>    
     <!–表示报表的一个集合,以及产生该集合的配置–>    
     <reportSet>    
      <!–报表集合的唯一标识符,POM继承时用到–>    
      <id/>    
      <!–产生报表集合时,被使用的报表的配置–>    
      <configuration/>    
      <!–配置是否被继承到子POMs–>    
      <inherited/>    
      <!–这个集合里使用到哪些报表–>    
      <reports/>    
     </reportSet>    
    </reportSets>    
   </plugin>    
  </plugins>    
 </reporting>    
 <!– 继承自该项目的所有子项目的默认依赖信息。这部分的依赖信息不会被立即解析,而是当子项目声明一个依赖(必须描述group ID和 artifact ID信息),如果group ID和artifact ID以外的一些信息没有描述,则通过group ID和artifact ID 匹配到这里的依赖,并使用这里的依赖信息。–>    
 <dependencyManagement>    
  <dependencies>    
   <!–参见dependencies/dependency元素–>    
   <dependency>    
    ……    
   </dependency>    
  </dependencies>    
 </dependencyManagement>       
    <!–项目分发信息,在执行mvn deploy后表示要发布的位置。有了这些信息就可以把网站部署到远程服务器或者把构件部署到远程仓库。–>     
    <distributionManagement>    
        <!–部署项目产生的构件到远程仓库需要的信息–>    
        <repository>    
         <!–是分配给快照一个唯一的版本号(由时间戳和构建流水号)?还是每次都使用相同的版本号?参见repositories/repository元素–>    
   <uniqueVersion/>    
   <id>banseon-maven2</id>     
   <name>banseon maven2</name>     
            <url>file://${basedir}/target/deploy</url>     
            <layout/>    
  </repository>    
  <!–构件的快照部署到哪里?如果没有配置该元素,默认部署到repository元素配置的仓库,参见distributionManagement/repository元素–>     
  <snapshotRepository>    
   <uniqueVersion/>    
   <id>banseon-maven2</id>    
            <name>Banseon-maven2 Snapshot Repository</name>    
            <url>scp://svn.baidu.com/banseon:/usr/local/maven-snapshot</url>     
   <layout/>    
  </snapshotRepository>    
  <!–部署项目的网站需要的信息–>     
        <site>    
         <!–部署位置的唯一标识符,用来匹配站点和settings.xml文件里的配置–>     
            <id>banseon-site</id>     
            <!–部署位置的名称–>    
            <name>business api website</name>     
            <!–部署位置的URL,按protocol://hostname/path形式–>    
            <url>     
                scp://svn.baidu.com/banseon:/var/www/localhost/banseon-web      
            </url>     
        </site>    
  <!–项目下载页面的URL。如果没有该元素,用户应该参考主页。使用该元素的原因是:帮助定位那些不在仓库里的构件(由于license限制)。–>    
  <downloadUrl/>    
  <!–如果构件有了新的group ID和artifact ID(构件移到了新的位置),这里列出构件的重定位信息。–>    
  <relocation>    
   <!–构件新的group ID–>    
   <groupId/>    
   <!–构件新的artifact ID–>    
   <artifactId/>    
   <!–构件新的版本号–>    
   <version/>    
   <!–显示给用户的,关于移动的额外信息,例如原因。–>    
   <message/>    
  </relocation>    
  <!– 给出该构件在远程仓库的状态。不得在本地项目中设置该元素,因为这是工具自动更新的。有效的值有:none(默认),converted(仓库管理员从 Maven 1 POM转换过来),partner(直接从伙伴Maven 2仓库同步过来),deployed(从Maven 2实例部 署),verified(被核实时正确的和最终的)。–>    
  <status/>           
    </distributionManagement>    
    <!–以值替代名称,Properties可以在整个POM中使用,也可以作为触发条件(见settings.xml配置文件里activation元素的说明)。格式是<name>value</name>。–>    
    <properties/>    
</project>

spring @Transactional注解参数详解

 spring  spring @Transactional注解参数详解已关闭评论
2月 072018
 

写的比较清楚,来自:https://www.cnblogs.com/caoyc/p/5632963.html

事物注解方式: @Transactional

当标于类前时, 标示类中所有方法都进行事物处理 , 例子:

1 @Transactional public class TestServiceBean implements TestService {}

当类中某些方法不需要事物时:

@Transactional  
public class TestServiceBean implements TestService { 
    private TestDao dao; 
    public void setDao(TestDao dao) { 
        this.dao = dao; 
    } 
    @Transactional(propagation =Propagation.NOT_SUPPORTED)
    public List getAll() { 
        return null; 
    } 
}

事物传播行为介绍: 

@Transactional(propagation=Propagation.REQUIRED) :如果有事务, 那么加入事务, 没有的话新建一个(默认情况下)
@Transactional(propagation=Propagation.NOT_SUPPORTED) :容器不为这个方法开启事务
@Transactional(propagation=Propagation.REQUIRES_NEW) :不管是否存在事务,都创建一个新的事务,原来的挂起,新的执行完毕,继续执行老的事务
@Transactional(propagation=Propagation.MANDATORY) :必须在一个已有的事务中执行,否则抛出异常
@Transactional(propagation=Propagation.NEVER) :必须在一个没有的事务中执行,否则抛出异常(与Propagation.MANDATORY相反)
@Transactional(propagation=Propagation.SUPPORTS) :如果其他bean调用这个方法,在其他bean中声明事务,那就用事务.如果其他bean没有声明事务,那就不用事务.

 

事物超时设置:

@Transactional(timeout=30) //默认是30秒

 

事务隔离级别:

@Transactional(isolation = Isolation.READ_UNCOMMITTED):读取未提交数据(会出现脏读, 不可重复读) 基本不使用
@Transactional(isolation = Isolation.READ_COMMITTED):读取已提交数据(会出现不可重复读和幻读)
@Transactional(isolation = Isolation.REPEATABLE_READ):可重复读(会出现幻读)
@Transactional(isolation = Isolation.SERIALIZABLE):串行化

MYSQL: 默认为REPEATABLE_READ级别
SQLSERVER: 默认为READ_COMMITTED

脏读 : 一个事务读取到另一事务未提交的更新数据
不可重复读 : 在同一事务中, 多次读取同一数据返回的结果有所不同, 换句话说, 
后续读取可以读到另一事务已提交的更新数据. 相反, “可重复读”在同一事务中多次
读取数据时, 能够保证所读数据一样, 也就是后续读取不能读到另一事务已提交的更新数据
幻读 : 一个事务读到另一个事务已提交的insert数据

 

@Transactional注解中常用参数说明

参数名称

功能描述

readOnly

该属性用于设置当前事务是否为只读事务,设置为true表示只读,false则表示可读写,默认值为false。例如:@Transactional(readOnly=true)

rollbackFor

该属性用于设置需要进行回滚的异常类数组,当方法中抛出指定异常数组中的异常时,则进行事务回滚。例如:

指定单一异常类:@Transactional(rollbackFor=RuntimeException.class)

指定多个异常类:@Transactional(rollbackFor={RuntimeException.class, Exception.class})

rollbackForClassName

该属性用于设置需要进行回滚的异常类名称数组,当方法中抛出指定异常名称数组中的异常时,则进行事务回滚。例如:

指定单一异常类名称:@Transactional(rollbackForClassName=”RuntimeException”)

指定多个异常类名称:@Transactional(rollbackForClassName={“RuntimeException”,”Exception”})

noRollbackFor

该属性用于设置不需要进行回滚的异常类数组,当方法中抛出指定异常数组中的异常时,不进行事务回滚。例如:

指定单一异常类:@Transactional(noRollbackFor=RuntimeException.class)

指定多个异常类:@Transactional(noRollbackFor={RuntimeException.class, Exception.class})

noRollbackForClassName

该属性用于设置不需要进行回滚的异常类名称数组,当方法中抛出指定异常名称数组中的异常时,不进行事务回滚。例如:

指定单一异常类名称:@Transactional(noRollbackForClassName=”RuntimeException”)

指定多个异常类名称:

@Transactional(noRollbackForClassName={“RuntimeException”,”Exception”})

propagation

该属性用于设置事务的传播行为,具体取值可参考表6-7。

例如:@Transactional(propagation=Propagation.NOT_SUPPORTED,readOnly=true)

isolation

该属性用于设置底层数据库的事务隔离级别,事务隔离级别用于处理多事务并发的情况,通常使用数据库的默认隔离级别即可,基本不需要进行设置

timeout

该属性用于设置事务的超时秒数,默认值为-1表示永不超时

 

 

注意的几点:


1、@Transactional 只能被应用到public方法上, 对于其它非public的方法,如果标记了@Transactional也不会报错,但方法没有事务功能.
2、用 spring 事务管理器,由spring来负责数据库的打开,提交,回滚.默认遇到运行期例外(throw new RuntimeException(“注释”);)会回滚,即遇到不受检查(unchecked)的例外时回滚;而遇到需要捕获的例外(throw new Exception(“注释”);)不会回滚,即遇到受检查的例外(就是非运行时抛出的异常,编译器会检查到的异常叫受检查例外或说受检查异常)时,需我们指定方式来让事务回滚要想所有异常都回滚,要加上 @Transactional( rollbackFor={Exception.class,其它异常}) .如果让unchecked例外不回滚: @Transactional(notRollbackFor=RunTimeException.class)
如下:

复制代码
1 @Transactional(rollbackFor=Exception.class) //指定回滚,遇到异常Exception时回滚 2 public void methodName() { 3 throw new Exception("注释"); 4 } 5 @Transactional(noRollbackFor=Exception.class)//指定不回滚,遇到运行期例外(throw new RuntimeException("注释");)会回滚 6 public ItimDaoImpl getItemDaoImpl() { 7 throw new RuntimeException("注释"); 8 }
复制代码

3、@Transactional 注解应该只被应用到 public 可见度的方法上。 如果你在 protected、private 或者 package-visible 的方法上使用 @Transactional 注解,它也不会报错, 但是这个被注解的方法将不会展示已配置的事务设置。


4、@Transactional 注解可以被应用于接口定义和接口方法、类定义和类的 public 方法上。然而,请注意仅仅 @Transactional 注解的出现不足于开启事务行为,它仅仅 是一种元数据,能够被可以识别 @Transactional 注解和上述的配置适当的具有事务行为的beans所使用。上面的例子中,其实正是 元素的出现 开启 了事务行为。


5、Spring团队的建议是你在具体的类(或类的方法)上使用 @Transactional 注解,而不要使用在类所要实现的任何接口上。你当然可以在接口上使用 @Transactional 注解,但是这将只能当你设置了基于接口的代理时它才生效。因为注解是不能继承的,这就意味着如果你正在使用基于类的代理时,那么事务的设置将不能被基于类的代理所识别,而且对象也将不会被事务代理所包装(将被确认为严重的)。因此,请接受Spring团队的建议并且在具体的类上使用 @Transactional 注解。

JQuery中的load()、$.get()和$.post()详解

 jquery  JQuery中的load()、$.get()和$.post()详解已关闭评论
1月 182018
 

文章解析的比较清楚,来自: http://blog.csdn.net/csdn_yudong/article/details/52537609

load()

1.载入HTML文档 
load()方法是jQuery中最为简单和常用的Ajax方法,能载入远程HTML代码并插入DOM中。 
它的结构为:

load(url [,data][,callback])
参数名称 类型 说明
url String 请求HTML页面的URL地址
data(可选) Object 发送至服务器的key/value数据
callback(可选) Function 请求完成时的回调函数,无论请求成功或失败

首先创建一个test.html文件,用于被load()方法加载并追加到页面中。

test.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <title></title> <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> </head> <body> <div class="comment"> <h6>张三:</h6> <p class="para">沙发.</p> </div> <div class="comment"> <h6>李四:</h6> <p class="para">板凳.</p> </div> <div class="comment"> <h6>王五:</h6> <p class="para">地板.</p> </div> </body> </html> 

然后再建一个demo1.html,在上面添加两个元素:<button>用来触发Ajax事件,id为”resText”的元素用来显示追加的HTML内容。HTML代码如下:

demo1.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <title></title> <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <style type="text/css"> * { margin:0; padding:0;} body { font-size:12px;} .comment { margin-top:10px; padding:10px; border:1px solid #ccc;background:#DDD;} .comment h6 { font-weight:700; font-size:14px;} .para { margin-top:5px; text-indent:2em;background:#DDD;} </style> <!--   引入jQuery --> <script src="https://cdn.bootcss.com/jquery/1.7.1/jquery.min.js"></script> <script language="javascript" type="text/javascript"> $(function(){ $("#send").click(function(){ $("#resText").load("test.html");
      })
  }) </script> </head> <body> <input type="button" id="send" value="Ajax获取" /> <div class="comment"> 已有评论: </div> <div id="resText" ></div> </body> </html> 

显然,load()方法完成了原本很繁琐的工作。开发人员只需要使用jQuery选择器为HTML片段指定目标位置,然后将要加载的文件的URL作为参数传递给load()方法即可。当单击按钮后,test.html页面的HTML内ring就会被加载并插入主页面<div id=”resText”></div>的元素中。

2.筛选载入的HTML文档 
上面的例子是将test.html页面中的内容都加载到id为”resText”的元素里。如果只需要加载test.html页面内的某些元素,那么可以使用load()方法的URL参数来达到目的。通过为URL参数指定选择符,就可以很方便地从加载过来的HTML文档里筛选出所需要的内容。

load()方法的URL参数的语法结构为:“url selector”。注意,URL和选择器之间有一个空格。

例如只需要加载test.html页面中class为”para”的内容,可以将demo1.html中的

$("#resText").load("test.html");

改为

$("#resText").load("test.html  .para");

3.传递方法 
load()方法的传递方式根据参数data来自动指定。如果没有参数传递,则采用GET方式传递;反之,则会自动转换为POST方法。

//无参数传递,则是GET方式
$('#resText').load('test.php',function(){
    //... });
//有参数传递,则是POST方式
$('#resText').load('test.php',{name:'rain',age:'22'},function(){
    //... });

4.回调函数 
对于必须在加载完成后才能继续的操作,load()方法提供了回调函数(callback),该函数有3个参数,分别代表请求返回的内容请求状态XMLHttpRequest对象,jQuery代码如下:

$("#resText").load("test.html",function (responseText, textStatus, XMLHttpRequest){ alert(responseText); //请求返回的内容 alert(textStatus); //请求状态:success,error alert(XMLHttpRequest); //XMLHttpRequest对象 });

在load()方法中,无论Ajax请求是否成功,只要当请求完成(complete)后,回调函数(callback)就被触发。


load()方法通常用来从Web服务器上获取静态的数据文件,然后这并不能体现Ajax的全部价值。在项目中,如果需要传递一些参数给服务器中的页面,那么可以使用$.get()或者$.post()或者$.ajax()方法。


$.get()

$.get()方法使用GET方式来进行异步请求。 
它的结构为:

$.get(url[,data][,callback][,type])
参数名称 类型 说明
url String 请求的HTML页的URL地址
data(可选) Object 发送至服务器的key/value数据会作为QueryString附加到请求URL中
callback(可选) Function 载入成功时回调函数(只有当Response的返回状态是success才调用该方法)自动将请求结果和状态传递给该方法
type(可选) String 服务器端返回内容的样式,包括xml、html、script、json、text和_default

我们用$.get()来实现评论的功能:

get1.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <title></title> <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <style type="text/css"> * { margin:0; padding:0;} body { font-size:12px;} .comment { margin-top:10px; padding:10px; border:1px solid #ccc;background:#DDD;} .comment h6 { font-weight:700; font-size:14px;} .para { margin-top:5px; text-indent:2em;background:#DDD;} </style> <!--   引入jQuery --> <script src="../scripts/jquery.js" type="text/javascript"></script> <script type="text/javascript"> //<![CDATA[ $(function(){ $("#send").click(function(){ $.get("get1.php", { 
                        username :  $("#username").val() , 
                        content :  $("#content").val()  
                    }, function (data, textStatus){ $("#resText").html(data); // 把返回的数据添加到页面上 }
            );
       })
    }) //]]> </script> </head> <body> <form id="form1" action="#"> <p>评论:</p> <p>姓名: <input type="text" name="username" id="username" /></p> <p>内容: <textarea name="content" id="content" rows="2" cols="20"></textarea></p> <p><input type="button" id="send" value="提交"/></p> </form> <div class='comment'>已有评论:</div> <div id="resText" > </div> </body> </html> 

get1.html向get1.php发送get请求,服务器端get1.php的代码如下:

<?php 
    header("Content-Type:text/html; charset=utf-8");
    echo "<div class='comment'><h6>{$_REQUEST['username']}:</h6><p class='para'>{$_REQUEST['content']}</p></div>";
?> 

由于服务器端get1.php返回的数据格式是一段HTML片段,因此并不需要经过处理就可以将新的HTML数据插入到主页面中。 
我们再来看一下get.html中的核心代码jQuery是如何完成get请求的:

$(function(){ $("#send").click(function(){ $.get("get1.php", { 
                        username :  $("#username").val() , 
                        content :  $("#content").val()  
                    }, function (data, textStatus){ $("#resText").html(data); // 把返回的数据添加到页面上 }
            );
       })
    })

我们可以看到在回调函数中,我们直接将返回回来的data(也就是HTML片段)直接在html中使用。

HTML片段实现起来只需要很少的工作量,但这种固定的数据结构并不一定能够在其他的Web应用程序中得到重用。

XML文档

服务器端是如何接收数据然后返回XML的呢? 
代码如下:

get2.php 
<?php 
    header("Content-Type:text/xml; charset=utf-8");
    echo "<?xml version='1.0' encoding='utf-8'?>".
         "<comments>".
         "<comment username='{$_REQUEST['username'] }' >".
         "<content>{$_REQUEST['content']}</content>".
         "</comment>".
         "</comments>";
?> 

注意:由于服务器端返回的数据格式是XML文档,因此需要在服务端设置Content-Type类型,代码如下:

header("Content-Type:text/xml; charset=utf-8");

对于服务器端返回的数据是XML格式的情况,我们需要对返回的数据进行处理,才能应用到HTML中,jQuery有强大的DOM处理能力,处理XML文档与处理HTML文档一样,也可以使用常规的attr()、find()、filter()以及其他方法。jQuery代码如下:

$(function(){ $("#send").click(function(){ $.get("get2.php", { 
      username :  $("#username").val() , 
      content :  $("#content").val()  
    }, function (data, textStatus){ var username = $(data).find("comment").attr("username"); var content = $(data).find("comment content").text(); var txtHtml = "<div class='comment'><h6>"+username+":</h6><p class='para'>"+content+"</p></div>";
      $("#resText").html(txtHtml); // 把返回的数据添加到页面上 },'XML');
  });
})

返回数据格式为XML文档的过程实现起来比HTML片段要稍微复杂些,但XML文档的可移植性是其他数据格式无法比拟的,因此以这种格式提供的数据的重要性将极大提高。不过,XML文档体积相对较大,与其他文件格式相比,解析和操作它们的速度要慢一些。

JSON文件 
之所以会出现这种数据格式的文件,很大程度上是因为XML文档体积大和难以解析。JSON文件和XML文档一样,也可以方便的被重用。而且,JSON文件非常简洁,也容易阅读。

服务器端是如何接收数据然后返回JSON的呢? 
代码如下:

get3.php 
<?php 
    header("Content-Type:text/html; charset=utf-8");
    echo "{ \"username\" : \"{$_REQUEST['username']}\" , \"content\" : \"{$_REQUEST['content']}\"}" ?>

JSON的格式还是比较严格的,所以格式不能写错了。 
由于服务器端返回的数据格式是JSON文件,因此需要对返回的数据进行处理之后,才可以将新的HTML数据添加到主页面中。HTML文件其他部分还是一样,要修改的地方是jQuery部分,jQuery代码如下:

$(function(){ $("#send").click(function(){ $.get("get3.php", { 
                username :  $("#username").val() , 
                content :  $("#content").val()  
            }, function (data, textStatus){ var username = data.username; var content = data.content; var txtHtml = "<div class='comment'><h6>"+username+":</h6><p class='para'>"+content+"</p></div>";
        $("#resText").html(txtHtml); // 把返回的数据添加到页面上 },"json");
       });
    })

在上面的代码中,将$.get()方法的第4个参数(type)设置为”json”来代表期待服务器返回的数据格式。

对于服务器端返回HTML片段、XML数据、JSON数据的优缺点进行分析,可以的得知在不需要与其他应用程序共享数据的时候,使用HTML片段来提供返回数据一般来说是最简单的;如果数据需要重用,那么JSON文件是不错的选择,它在性能和文件大小方面具有优势,它是Web服务器领域的“世界语”,我们推荐使用JSON。

$.post()

它与$.get()方法的结构和使用方式都相同,不过它们之间仍然有以下区别。

  • GET请求会将参数跟在URL后进行传递,而POST请求则是作为HTPP消息的实体内容发送给Web服务器。当然,在Ajax请求中,这种区别对用户是不可见的
  • GET方式对传输的数据有大小限制(通常不能大于2KB),而使用POST方式传递的数据量要比GET方式大得多(理论上不受限制)
  • GET方式请求的数据会被浏览器缓存起来,因此其他人就可以从浏览器的历史记录中读取到这些数据,例如账号和密码等。在某种情况下,GET方式会带来严重的安全性问题,而POST方式相对来说就可以避免这些问题。
  • GET方式和POST方式传递的数据在服务器端的获取也不相同。在PHP中,GET方式的数据可以用$_GET[]获取,而POST方式可以用$_POST[]获取。两种方式都可以用$_REQUEST[]来获取。

由于POST和GET方式提交的所有数据都可以通过$_REQUEST[]来获取,因此只需要改变jQuery函数,就可以将程序在GET请求和POST请求之间切换。 
代码如下:

$(function(){ $("#send").click(function(){ $.post("post1.php", { 
      username :  $("#username").val() , 
      content :  $("#content").val()  
    }, function (data, textStatus){ $("#resText").html(data); // 把返回的数据添加到页面上 });
  })
})

load()、$.get()和$.post(),我们可以发现,$.get()和$.post()方法是jQuery中的全局函数,而在此之前讲的load()是对jQuery对象进行操作的。

iptables详解

 iptables  iptables详解已关闭评论
10月 312017
 

一篇非常好的介绍iptables的文章,http://www.cnblogs.com/metoy/p/4320813.html

iptables简介

       netfilter/iptables(简称为iptables)组成Linux平台下的包过滤防火墙,与大多数的Linux软件一样,这个包过滤防火墙是免费的,它可以代替昂贵的商业防火墙解决方案,完成封包过滤、封包重定向和网络地址转换(NAT)等功能。

 

iptables基础


       规则(rules)其实就是网络管理员预定义的条件,规则一般的定义为“如果数据包头符合这样的条件,就这样处理这个数据包”。规则存储在内核空间的信息 包过滤表中,这些规则分别指定了源地址、目的地址、传输协议(如TCP、UDP、ICMP)和服务类型(如HTTP、FTP和SMTP)等。当数据包与规 则匹配时,iptables就根据规则所定义的方法来处理这些数据包,如放行(accept)、拒绝(reject)和丢弃(drop)等。配置防火墙的 主要工作就是添加、修改和删除这些规则。

 

iptables和netfilter的关系:

       这是第一个要说的地方,Iptables和netfilter的关系是一个很容易让人搞不清的问题。很多的知道iptables却不知道 netfilter。其实iptables只是Linux防火墙的管理工具而已,位于/sbin/iptables。真正实现防火墙功能的是 netfilter,它是Linux内核中实现包过滤的内部结构。

 

iptables传输数据包的过程

① 当一个数据包进入网卡时,它首先进入PREROUTING链,内核根据数据包目的IP判断是否需要转送出去。 
② 如果数据包就是进入本机的,它就会沿着图向下移动,到达INPUT链。数据包到了INPUT链后,任何进程都会收到它。本机上运行的程序可以发送数据包,这些数据包会经过OUTPUT链,然后到达POSTROUTING链输出。 
③ 如果数据包是要转发出去的,且内核允许转发,数据包就会如图所示向右移动,经过FORWARD链,然后到达POSTROUTING链输出。

 

iptables的规则表和链:

      表(tables)提供特定的功能,iptables内置了4个表,即filter表、nat表、mangle表和raw表,分别用于实现包过滤,网络地址转换、包重构(修改)和数据跟踪处理。

     链(chains)是数据包传播的路径,每一条链其实就是众多规则中的一个检查清单,每一条链中可以有一 条或数条规则。当一个数据包到达一个链时,iptables就会从链中第一条规则开始检查,看该数据包是否满足规则所定义的条件。如果满足,系统就会根据 该条规则所定义的方法处理该数据包;否则iptables将继续检查下一条规则,如果该数据包不符合链中任一条规则,iptables就会根据该链预先定 义的默认策略来处理数据包。

       Iptables采用“表”和“链”的分层结构。在REHL4中是三张表五个链。现在REHL5成了四张表五个链了,不过多出来的那个表用的也不太多,所以基本还是和以前一样。下面罗列一下这四张表和五个链。注意一定要明白这些表和链的关系及作用。

规则表:

1.filter表——三个链:INPUT、FORWARD、OUTPUT
作用:过滤数据包  内核模块:iptables_filter.
2.Nat表——三个链:PREROUTING、POSTROUTING、OUTPUT
作用:用于网络地址转换(IP、端口) 内核模块:iptable_nat
3.Mangle表——五个链:PREROUTING、POSTROUTING、INPUT、OUTPUT、FORWARD
作用:修改数据包的服务类型、TTL、并且可以配置路由实现QOS内核模块:iptable_mangle(别看这个表这么麻烦,咱们设置策略时几乎都不会用到它)
4.Raw表——两个链:OUTPUT、PREROUTING
作用:决定数据包是否被状态跟踪机制处理  内核模块:iptable_raw
(这个是REHL4没有的,不过不用怕,用的不多)

 

规则链:


1.INPUT——进来的数据包应用此规则链中的策略
2.OUTPUT——外出的数据包应用此规则链中的策略
3.FORWARD——转发数据包时应用此规则链中的策略
4.PREROUTING——对数据包作路由选择前应用此链中的规则
(记住!所有的数据包进来的时侯都先由这个链处理)
5.POSTROUTING——对数据包作路由选择后应用此链中的规则
(所有的数据包出来的时侯都先由这个链处理)


规则表之间的优先顺序:

Raw——mangle——nat——filter
规则链之间的优先顺序(分三种情况):

第一种情况:入站数据流向

       从外界到达防火墙的数据包,先被PREROUTING规则链处理(是否修改数据包地址等),之后会进行路由选择(判断该数据包应该发往何处),如果数据包 的目标主机是防火墙本机(比如说Internet用户访问防火墙主机中的web服务器的数据包),那么内核将其传给INPUT链进行处理(决定是否允许通 过等),通过以后再交给系统上层的应用程序(比如Apache服务器)进行响应。

第二冲情况:转发数据流向

       来自外界的数据包到达防火墙后,首先被PREROUTING规则链处理,之后会进行路由选择,如果数据包的目标地址是其它外部地址(比如局域网用户通过网 关访问QQ站点的数据包),则内核将其传递给FORWARD链进行处理(是否转发或拦截),然后再交给POSTROUTING规则链(是否修改数据包的地 址等)进行处理。

第三种情况:出站数据流向
       防火墙本机向外部地址发送的数据包(比如在防火墙主机中测试公网DNS服务器时),首先被OUTPUT规则链处理,之后进行路由选择,然后传递给POSTROUTING规则链(是否修改数据包的地址等)进行处理。

管理和设置iptables规则

 

 

iptables的基本语法格式

iptables [-t 表名] 命令选项 [链名] [条件匹配] [-j 目标动作或跳转]
说明:表名、链名用于指定 iptables命令所操作的表和链,命令选项用于指定管理iptables规则的方式(比如:插入、增加、删除、查看等;条件匹配用于指定对符合什么样 条件的数据包进行处理;目标动作或跳转用于指定数据包的处理方式(比如允许通过、拒绝、丢弃、跳转(Jump)给其它链处理。

 

iptables命令的管理控制选项

复制代码

-A 在指定链的末尾添加(append)一条新的规则
-D 删除(delete)指定链中的某一条规则,可以按规则序号和内容删除
-I 在指定链中插入(insert)一条新的规则,默认在第一行添加
-R 修改、替换(replace)指定链中的某一条规则,可以按规则序号和内容替换
-L 列出(list)指定链中所有的规则进行查看
-E 重命名用户定义的链,不改变链本身
-F 清空(flush)
-N 新建(new-chain)一条用户自己定义的规则链
-X 删除指定表中用户自定义的规则链(delete-chain)
-P 设置指定链的默认策略(policy)
-Z 将所有表的所有链的字节和数据包计数器清零
-n 使用数字形式(numeric)显示输出结果
-v 查看规则表详细信息(verbose)的信息
-V 查看版本(version)
-h 获取帮助(help)

复制代码

防火墙处理数据包的四种方式

ACCEPT 允许数据包通过
DROP 直接丢弃数据包,不给任何回应信息
REJECT 拒绝数据包通过,必要时会给数据发送端一个响应的信息。
LOG在/var/log/messages文件中记录日志信息,然后将数据包传递给下一条规则

 

iptables防火墙规则的保存与恢复

iptables-save把规则保存到文件中,再由目录rc.d下的脚本(/etc/rc.d/init.d/iptables)自动装载

使用命令iptables-save来保存规则。一般用

iptables-save > /etc/sysconfig/iptables

生成保存规则的文件 /etc/sysconfig/iptables,

也可以用

service iptables save

它能把规则自动保存在/etc/sysconfig/iptables中。

当计算机启动时,rc.d下的脚本将用命令iptables-restore调用这个文件,从而就自动恢复了规则。

 

删除INPUT链的第一条规则

iptables -D INPUT 1

iptables防火墙常用的策略


1.拒绝进入防火墙的所有ICMP协议数据包

iptables -I INPUT -p icmp -j REJECT

 

2.允许防火墙转发除ICMP协议以外的所有数据包

iptables -A FORWARD -p ! icmp -j ACCEPT

说明:使用“!”可以将条件取反。

 

3.拒绝转发来自192.168.1.10主机的数据,允许转发来自192.168.0.0/24网段的数据

iptables -A FORWARD -s 192.168.1.11 -j REJECT 
iptables -A FORWARD -s 192.168.0.0/24 -j ACCEPT

说明:注意要把拒绝的放在前面不然就不起作用了啊。

 

4.丢弃从外网接口(eth1)进入防火墙本机的源地址为私网地址的数据包

iptables -A INPUT -i eth1 -s 192.168.0.0/16 -j DROP 
iptables -A INPUT -i eth1 -s 172.16.0.0/12 -j DROP 
iptables -A INPUT -i eth1 -s 10.0.0.0/8 -j DROP

 

5.封堵网段(192.168.1.0/24),两小时后解封。

# iptables -I INPUT -s 10.20.30.0/24 -j DROP 
# iptables -I FORWARD -s 10.20.30.0/24 -j DROP 
# at now 2 hours at> iptables -D INPUT 1 at> iptables -D FORWARD 1

说明:这个策略咱们借助crond计划任务来完成,就再好不过了。
[1]   Stopped     at now 2 hours

 

6.只允许管理员从202.13.0.0/16网段使用SSH远程登录防火墙主机。

iptables -A INPUT -p tcp –dport 22 -s 202.13.0.0/16 -j ACCEPT 
iptables -A INPUT -p tcp –dport 22 -j DROP

说明:这个用法比较适合对设备进行远程管理时使用,比如位于分公司中的SQL服务器需要被总公司的管理员管理时。

 

7.允许本机开放从TCP端口20-1024提供的应用服务。

iptables -A INPUT -p tcp –dport 20:1024 -j ACCEPT 
iptables -A OUTPUT -p tcp –sport 20:1024 -j ACCEPT

 

8.允许转发来自192.168.0.0/24局域网段的DNS解析请求数据包。

iptables -A FORWARD -s 192.168.0.0/24 -p udp –dport 53 -j ACCEPT 
iptables -A FORWARD -d 192.168.0.0/24 -p udp –sport 53 -j ACCEPT

 

9.禁止其他主机ping防火墙主机,但是允许从防火墙上ping其他主机

iptables -I INPUT -p icmp –icmp-type Echo-Request -j DROP 
iptables -I INPUT -p icmp –icmp-type Echo-Reply -j ACCEPT 
iptables -I INPUT -p icmp –icmp-type destination-Unreachable -j ACCEPT

 

10.禁止转发来自MAC地址为00:0C:29:27:55:3F的和主机的数据包

iptables -A FORWARD -m mac –mac-source 00:0c:29:27:55:3F -j DROP

说明:iptables中使用“-m 模块关键字”的形式调用显示匹配。咱们这里用“-m mac –mac-source”来表示数据包的源MAC地址。

 

11.允许防火墙本机对外开放TCP端口20、21、25、110以及被动模式FTP端口1250-1280

iptables -A INPUT -p tcp -m multiport –dport 20,21,25,110,1250:1280 -j ACCEPT

说明:这里用“-m multiport –dport”来指定目的端口及范围

 

12.禁止转发源IP地址为192.168.1.20-192.168.1.99的TCP数据包。

iptables -A FORWARD -p tcp -m iprange –src-range 192.168.1.20-192.168.1.99 -j DROP

说明:此处用“-m –iprange –src-range”指定IP范围。

 

13.禁止转发与正常TCP连接无关的非—syn请求数据包。

iptables -A FORWARD -m state –state NEW -p tcp ! –syn -j DROP

说明:“-m state”表示数据包的连接状态,“NEW”表示与任何连接无关的,新的嘛!

 

14.拒绝访问防火墙的新数据包,但允许响应连接或与已有连接相关的数据包

iptables -A INPUT -p tcp -m state –state NEW -j DROP 
iptables -A INPUT -p tcp -m state –state ESTABLISHED,RELATED -j ACCEPT

说明:“ESTABLISHED”表示已经响应请求或者已经建立连接的数据包,“RELATED”表示与已建立的连接有相关性的,比如FTP数据连接等。

 

15.只开放本机的web服务(80)、FTP(20、21、20450-20480),放行外部主机发住服务器其它端口的应答数据包,将其他入站数据包均予以丢弃处理。

复制代码

iptables -I INPUT -p tcp -m multiport –dport 20,21,80 -j ACCEPT 
iptables -I INPUT -p tcp –dport 20450:20480 -j ACCEPT 
iptables -I INPUT -p tcp -m state –state ESTABLISHED -j ACCEPT 
iptables -P INPUT DROP

文章参考

http://netfilter.org/ iptables官方网站
http://www.linux.gov.cn/netweb/iptables.htm iptables配置手册
http://man.chinaunix.net/
http://man.chinaunix.net/network/iptables-tutorial-cn-1.1.19.html iptables配置手册
http://blog.csdn.net/thmono/archive/2010/04/08/5462043.aspx
http://netsecurity.51cto.com/art/200512/14457.htm
http://blog.sina.com.cn/s/blog_40ba724c0100jz12.html
http://qiliuping.blog.163.com/blog/static/1023829320105245337799/

复制代码

javascript中 == 和 === 内部的实现机制

 javascript  javascript中 == 和 === 内部的实现机制已关闭评论
7月 102017
 

知其然还需知其所以然, 在知乎看到对==和===的解析,分享下。

作者:林建入
链接:https://www.zhihu.com/question/20348948/answer/19601270
来源:知乎

很多时候我们会对某个语言的某个特性争论不休,通常都只是因为我们不知道它是怎么实现的。其实解决这个疑惑的最好的方法,就是弄清楚 == 和 === 内部的实现机制。
例如 Google v8 就是开源的,只要看看里面的代码,就能知道到底是怎么一回事了。但是我相信绝大多数人都是没有这个耐心的——我知道大家都在忙着挣钱养家——好吧,那咱就不看 Google v8 了,看看 ECMA-262 吧,里面已经把实现算法描述得很清楚了,只要看懂了下面的内容,以后就再也不会有此类疑问了。
一、严格相等运算符 === 的实现
=== 被称为 Strict Equals Operator,假设有表达式 a === b,则它的实际运算过程如下

  1. 计算出表达式 a 的结果,并存入 lref 变量
  2. 将 GetValue(lref) 的结果存入 lval 变量
  3. 计算出表达式 b 的结果,并存入 rref 变量
  4. 将 GetValue(rref) 的结果存入 rval 变量
  5. 执行 Strict Equality Comparison 算法判断 rval === lval 并将结果直接返回

这里的 Strict Equality Comparison 算法很关键,假设要计算的是 x === y,则过程如下

1. 如果 Type(x) 和 Type(y) 不同,返回 false

2. 如果 Type(x) 为 Undefined,返回 true

3. 如果 Type(x) 为 Null,返回 true

4. 如果 Type(x) 为 Number,则进入下面的判断逻辑

4.1. 如果 x 为 NaN,返回 false

4.2. 如果 y 为 NaN,返回 false

4.3. 如果 x 的数字值和 y 相等,返回 true

4.4. 如果 x 是 +0 且 y 是 -0,返回 true

4.5. 如果 x 是 -0 且 y 是 +0,返回 ture

4.6. 返回 false

5. 如果 Type(x) 为 String,则当且仅当 x 与 y 的字符序列完全相同(长度相等,每个位置上的字符相同)时返回 true,否则返回 false

6. 如果 Type(x) 为 Boolean,则若 x 与 y 同为 true 或同为 false 时返回 true,否则返回 false

7. 如果 x 和 y 引用的是同一个对象,返回 true,否则返回 false

二、相等运算符 == 的实现
好了,当你明白了 === 的实现之后,我们再来看看 == 的实现,比较一下他们有何不同?
== 被称为 Equals Operator (注意看没有 Strict 了),假设有表达式 a == b,则它的实际运算过程如下

  1. 计算出表达式 a 的结果,并存入 lref 变量
  2. 将 GetValue(lref) 的结果存入 lval 变量
  3. 计算出表达式 b 的结果,并存入 rref 变量
  4. 将 GetValue(rref) 的结果存入 rval 变量
  5. 执行 Abstract Equality Comparison 算法判断 rval == lval 并将结果直接返回

注意,其中的前 4 个步骤是和 === 完全相同的。唯独 5 不同。对于 === 来说,调用的是 Strict Equality Comparison 算法,但是 == 则调用的是 Abstract Equality Comparison 算法。虽然仅一词之差,但是却有质的不同,我们下面就来看看到底它是怎么实现的
假设要计算的是 x == y,Abstract Equality Comparison 计算的过程如下(很冗长,但是每个步骤都很简单)

1. 如果 Type(x) 和 Type(y) 相同,则

1.1. 如果 Type(x) 为 Undefined,返回 true

1.2. 如果 Type(x) 为 Null,返回 true

1.3. 如果 Type(x) 为 Number,则

1.3.1. 如果 x 是 NaN,返回 false

1.3.2. 如果 y 是 NaN,返回 false

1.3.3. 如果 x 的数值与 y 相同,返回 true

1.3.4. 如果 x 是 +0 且 y 是 -0,返回 true

1.3.5. 如果 x 是 -0 且 y 是 +0,返回 true

1.3.6. 返回 false

1.4. 如果 Type(x) 为 String,则当且仅当 x 与 y 的字符序列完全相同(长度相等,每个位置上的字符相同)时返回 true,否则返回 false

1.5. 如果 Type(x) 为 Boolean,则若 x 与 y 同为 true 或同为 false 时返回 true,否则返回 false

1.6. 如果 x 和 y 引用的是同一个对象,返回 true,否则返回 false

2. 如果 x 是 null 且 y 是 undefined,返回 true

3. 如果 x 是 undefined 且 y 是 null,返回 ture

4. 如果 Type(x) 为 Number 且 Type(y) 为 String,以 x == ToNumber(y) 的比较结果作为返回

5. 如果 Type(x) 为 String 且 Type(y) 为 Number,以 ToNumber(x) == y 的比较结果作为返回值

6. 如果 Type(x) 为 Boolean,以 ToNumber(x) == y 的比较结果作为返回值

7. 如果 Type(y) 为 Boolean,以 x == ToNumber(y) 的比较结果作为返回值

8. 如果 Type(x) 为 String 或 Number 且 Type(y) 为 Object,以 x == ToPrimitive(y) 的比较结果作为返回值

9. 如果 Type(x) 为 Object 且 Type(y) 为 String 或 Number,以 ToPrimitive(x) == y 的比较结果作为返回值

10. 返回 false

三、总结

从上面的算法流程可以看出,a === b 是最简单的。如果 a 和 b 的类型不同,那么一定会返回 false。而 a == b 则要灵活得多。JavaScript 会尝试调整 a 和 b 的类型,例如若 a 为字符串 b 为数字,则将字符串先转化为数字再与 b 比较,等等。这在很多时候简化了程序员的代码量。

一些程序员害怕 == 而提倡使用 === 的根本原因是,他们不知道在 == 的内部具体发生了什么。而这就导致误用和出错。

JavaScript中eval()函数用法详解

 javascript  JavaScript中eval()函数用法详解已关闭评论
7月 032017
 

eval函数的用法,学习了, 来自:http://www.jb51.net/article/76374.htm

eval() 函数计算 JavaScript 字符串,并把它作为脚本代码来执行。

如果参数是一个表达式,eval() 函数将执行表达式。如果参数是Javascript语句,eval()将执行 Javascript 语句。

语法

复制代码代码如下:

eval(string)
参数 描述
string 必需。要计算的字符串,其中含有要计算的 JavaScript 表达式或要执行的语句。

eval()函数用法详解:

此函数可能使用的频率并不是太高,但是在某些情况下具有很大的作用,下面就介绍一下eval()函数的用法。

此函数可以接受一个字符串str作为参数,并把此str当做一段javascript代码去执行,如果str执行结果是一个值则返回此值,否则返回undefined。如果参数不是一个字符串,则直接返回该参数,实例如下:

eval("var a=1");//声明一个变量a并赋值1。
eval("2+3");//执行加运算,并返回运算值。
eval("mytest()");//执行mytest()函数。
eval("{b:2}");//声明一个对象。

在以上代码特别注意的是,最后一个语句是声明了一个对象,如果想返回此对象,则需要在对象外面再嵌套一层小括号,如下:

复制代码代码如下:

eval(“({b:2})”); 

以上内容简单介绍了eval()函数的用法,比较容易理解。此函数最让人感到困惑的是关于它的作用域问题,下面就结合实例来介绍一下相关内容,先看一段代码实例:

function a(){ 
 eval("var x=1"); 
 console.log(x); 
} 
a(); 
console.log(x); 

在上面的代码中,第一个alert()函数能够弹出1,而第二个会因为x未定义而报错。
由以上表现可以得出,eval()函数并不会创建一个新的作用域,并且它的作用域就是它所在的作用域。这在所有主流浏览器都是如此,但是有时候需要将eval()函数的作用域设置为全局,当然可以将eval()在全局作用域中使用,但是往往实际应用中,需要在局部作用域使用具有全局作用域的此函数,这个时候可以用window.eval()的方式实现,例如以上代码可以改造如下:

function a(){ 
 window.eval("var x=1"); 
 console.log(x); 
} 
a(); 
console.log(x); 

在上面的代码中,两个alert()语句都能够正常弹出1。但是此中方式在标准浏览器中是可以的,但是在IE8和IE8以下浏览器中的表现依然和eval()一样,作用域是它们所在的作用域。这个时候可以使用IE浏览器独有的window.execScript()解决IE8和IE8浏览器的问题。为了实现兼容所有主流浏览器,把代码改造如下:

function a(){ 
 if(window.execScript){ 
  window.execScript("var x=1"); 
 } 
 else{ 
  window.eval("var x=1"); 
 } 
 console.log(x); 
} 
a(); 
console.log(x); 

如果浏览器支持window.execScript(),则使用此函数,不支持则使用window.eval(),这样就可以解决IE8和IE8以下浏览器的问题。

web.xml 中的listener、 filter、servlet 加载顺序及其详解

 http  web.xml 中的listener、 filter、servlet 加载顺序及其详解已关闭评论
3月 152014
 

看了很有帮助,和大家一起分享下:

在项目中总会遇到一些关于加载的优先级问题,近期也同样遇到过类似的,所以自己查找资料总结了下,下面有些是转载其他人的,毕竟人家写的不错,自己也就不重复造轮子了,只是略加点了自己的修饰。

        首先可以肯定的是,加载顺序与它们在 web.xml 文件中的先后顺序无关。即不会因为 filter 写在 listener 的前面而会先加载 filter。最终得出的结论是:listener -> filter -> servlet

        同时还存在着这样一种配置节:context-param,它用于向 ServletContext 提供键值对,即应用程序上下文信息。我们的 listener, filter 等在初始化时会用到这些上下文中的信息,那么 context-param 配置节是不是应该写在 listener 配置节前呢?实际上 context-param 配置节可写在任意位置,因此真正的加载顺序为:context-param -> listener -> filter -> servlet

        对于某类配置节而言,与它们出现的顺序是有关的。以 filter 为例,web.xml 中当然可以定义多个 filter,与 filter 相关的一个配置节是 filter-mapping,这里一定要注意,对于拥有相同 filter-name 的 filter 和 filter-mapping 配置节而言,filter-mapping 必须出现在 filter 之后,否则当解析到 filter-mapping 时,它所对应的 filter-name 还未定义。web 容器启动时初始化每个 filter 时,是按照 filter 配置节出现的顺序来初始化的,当请求资源匹配多个 filter-mapping 时,filter 拦截资源是按照 filter-mapping 配置节出现的顺序来依次调用 doFilter() 方法的。

        servlet 同 filter 类似,此处不再赘述。

       由此,可以看出,web.xml 的加载顺序是:context-param -> listener -> filter -> servlet ,而同个类型之间的实际程序调用的时候的顺序是根据对应的 mapping 的顺序进行调用的。

 

web.xml文件详解

Xml代码  收藏代码

  1. Web.xml常用元素   
  2. <web-app>   
  3. <display-name></display-name>定义了WEB应用的名字   
  4. <description></description> 声明WEB应用的描述信息   
  5.   
  6. <context-param></context-param> context-param元素声明应用范围内的初始化参数。   
  7. <filter></filter> 过滤器元素将一个名字与一个实现javax.servlet.Filter接口的类相关联。   
  8. <filter-mapping></filter-mapping> 一旦命名了一个过滤器,就要利用filter-mapping元素把它与一个或多个servlet或JSP页面相关联。   
  9. <listener></listener>servlet API的版本2.3增加了对事件监听程序的支持,事件监听程序在建立、修改和删除会话或servlet环境时得到通知。   
  10.                      Listener元素指出事件监听程序类。   
  11. <servlet></servlet> 在向servlet或JSP页面制定初始化参数或定制URL时,必须首先命名servlet或JSP页面。Servlet元素就是用来完成此项任务的。   
  12. <servlet-mapping></servlet-mapping> 服务器一般为servlet提供一个缺省的URL:http://host/webAppPrefix/servlet/ServletName。   
  13.               但是,常常会更改这个URL,以便servlet可以访问初始化参数或更容易地处理相对URL。在更改缺省URL时,使用servlet-mapping元素。   
  14.   
  15. <session-config></session-config> 如果某个会话在一定时间内未被访问,服务器可以抛弃它以节省内存。   
  16.           可通过使用HttpSession的setMaxInactiveInterval方法明确设置单个会话对象的超时值,或者可利用session-config元素制定缺省超时值。   
  17.   
  18. <mime-mapping></mime-mapping>如果Web应用具有想到特殊的文件,希望能保证给他们分配特定的MIME类型,则mime-mapping元素提供这种保证。   
  19. <welcome-file-list></welcome-file-list> 指示服务器在收到引用一个目录名而不是文件名的URL时,使用哪个文件。   
  20. <error-page></error-page> 在返回特定HTTP状态代码时,或者特定类型的异常被抛出时,能够制定将要显示的页面。   
  21. <taglib></taglib> 对标记库描述符文件(Tag Libraryu Descriptor file)指定别名。此功能使你能够更改TLD文件的位置,   
  22.                   而不用编辑使用这些文件的JSP页面。   
  23. <resource-env-ref></resource-env-ref>声明与资源相关的一个管理对象。   
  24. <resource-ref></resource-ref> 声明一个资源工厂使用的外部资源。   
  25. <security-constraint></security-constraint> 制定应该保护的URL。它与login-config元素联合使用   
  26. <login-config></login-config> 指定服务器应该怎样给试图访问受保护页面的用户授权。它与sercurity-constraint元素联合使用。   
  27. <security-role></security-role>给出安全角色的一个列表,这些角色将出现在servlet元素内的security-role-ref元素   
  28.                    的role-name子元素中。分别地声明角色可使高级IDE处理安全信息更为容易。   
  29. <env-entry></env-entry>声明Web应用的环境项。   
  30. <ejb-ref></ejb-ref>声明一个EJB的主目录的引用。   
  31. < ejb-local-ref></ ejb-local-ref>声明一个EJB的本地主目录的应用。   
  32. </web-app>   
  33.   
  34.   
  35. 相应元素配置   
  36.   
  37. 1、Web应用图标:指出IDE和GUI工具用来表示Web应用的大图标和小图标   
  38. <icon>   
  39. <small-icon>/images/app_small.gif</small-icon>   
  40. <large-icon>/images/app_large.gif</large-icon>   
  41. </icon>   
  42. 2、Web 应用名称:提供GUI工具可能会用来标记这个特定的Web应用的一个名称   
  43. <display-name>Tomcat Example</display-name>   
  44. 3、Web 应用描述: 给出于此相关的说明性文本   
  45. <disciption>Tomcat Example servlets and JSP pages.</disciption>   
  46. 4、上下文参数:声明应用范围内的初始化参数。   
  47.   <context-param>   
  48.     <param-name>ContextParameter</para-name>   
  49.     <param-value>test</param-value>   
  50.     <description>It is a test parameter.</description>   
  51.   </context-param>   
  52.   在servlet里面可以通过getServletContext().getInitParameter(“context/param”)得到   
  53.   
  54. 5、过滤器配置:将一个名字与一个实现javaxs.servlet.Filter接口的类相关联。   
  55.   <filter>   
  56.         <filter-name>setCharacterEncoding</filter-name>   
  57.         <filter-class>com.myTest.setCharacterEncodingFilter</filter-class>   
  58.         <init-param>   
  59.             <param-name>encoding</param-name>   
  60.             <param-value>GB2312</param-value>   
  61.         </init-param>   
  62.   </filter>   
  63.   <filter-mapping>   
  64.         <filter-name>setCharacterEncoding</filter-name>   
  65.         <url-pattern>/*</url-pattern>   
  66.   </filter-mapping>   
  67. 6、监听器配置   
  68.   <listener>   
  69.       <listerner-class>listener.SessionListener</listener-class>   
  70.   </listener>   
  71. 7、Servlet配置   
  72.    基本配置   
  73.    <servlet>   
  74.       <servlet-name>snoop</servlet-name>   
  75.       <servlet-class>SnoopServlet</servlet-class>   
  76.    </servlet>   
  77.    <servlet-mapping>   
  78.       <servlet-name>snoop</servlet-name>   
  79.       <url-pattern>/snoop</url-pattern>   
  80.    </servlet-mapping>   
  81.    高级配置   
  82.    <servlet>   
  83.       <servlet-name>snoop</servlet-name>   
  84.       <servlet-class>SnoopServlet</servlet-class>   
  85.       <init-param>   
  86.          <param-name>foo</param-name>   
  87.          <param-value>bar</param-value>   
  88.       </init-param>   
  89.       <run-as>   
  90.          <description>Security role for anonymous access</description>   
  91.          <role-name>tomcat</role-name>   
  92.       </run-as>   
  93.    </servlet>   
  94.    <servlet-mapping>   
  95.       <servlet-name>snoop</servlet-name>   
  96.       <url-pattern>/snoop</url-pattern>   
  97.    </servlet-mapping>   
  98.    元素说明   
  99.      <servlet></servlet> 用来声明一个servlet的数据,主要有以下子元素:   
  100.      <servlet-name></servlet-name> 指定servlet的名称   
  101.      <servlet-class></servlet-class> 指定servlet的类名称   
  102.      <jsp-file></jsp-file> 指定web站台中的某个JSP网页的完整路径   
  103.      <init-param></init-param> 用来定义参数,可有多个init-param。在servlet类中通过getInitParamenter(String name)方法访问初始化参数   
  104.      <load-on-startup></load-on-startup>指定当Web应用启动时,装载Servlet的次序。   
  105.                                  当值为正数或零时:Servlet容器先加载数值小的servlet,再依次加载其他数值大的servlet.   
  106.                                  当值为负或未定义:Servlet容器将在Web客户首次访问这个servlet时加载它   
  107.      <servlet-mapping></servlet-mapping> 用来定义servlet所对应的URL,包含两个子元素   
  108.        <servlet-name></servlet-name> 指定servlet的名称   
  109.        <url-pattern></url-pattern> 指定servlet所对应的URL   
  110. 8、会话超时配置(单位为分钟)   
  111.    <session-config>   
  112.       <session-timeout>120</session-timeout>   
  113.    </session-config>   
  114. 9、MIME类型配置   
  115.    <mime-mapping>   
  116.       <extension>htm</extension>   
  117.       <mime-type>text/html</mime-type>   
  118.    </mime-mapping>   
  119. 10、指定欢迎文件页配置   
  120.    <welcome-file-list>   
  121.       <welcome-file>index.jsp</welcome-file>   
  122.       <welcome-file>index.html</welcome-file>   
  123.       <welcome-file>index.htm</welcome-file>   
  124.    </welcome-file-list>   
  125. 11、配置错误页面   
  126.   一、 通过错误码来配置error-page   
  127.    <error-page>   
  128.       <error-code>404</error-code>   
  129.       <location>/NotFound.jsp</location>   
  130.    </error-page>   
  131.   上面配置了当系统发生404错误时,跳转到错误处理页面NotFound.jsp。   
  132. 二、通过异常的类型配置error-page   
  133.    <error-page>   
  134.        <exception-type>java.lang.NullException</exception-type>   
  135.        <location>/error.jsp</location>   
  136.    </error-page>   
  137.   上面配置了当系统发生java.lang.NullException(即空指针异常)时,跳转到错误处理页面error.jsp   
  138. 12、TLD配置   
  139.    <taglib>   
  140.        <taglib-uri>http://jakarta.apache.org/tomcat/debug-taglib</taglib-uri>   
  141.        <taglib-location>/WEB-INF/jsp/debug-taglib.tld</taglib-location>   
  142.    </taglib>   
  143.    如果MyEclipse一直在报错,应该把<taglib> 放到 <jsp-config>中   
  144.    <jsp-config>   
  145.       <taglib>   
  146.           <taglib-uri>http://jakarta.apache.org/tomcat/debug-taglib</taglib-uri>   
  147.           <taglib-location>/WEB-INF/pager-taglib.tld</taglib-location>   
  148.       </taglib>   
  149.    </jsp-config>   
  150. 13、资源管理对象配置   
  151.    <resource-env-ref>   
  152.        <resource-env-ref-name>jms/StockQueue</resource-env-ref-name>   
  153.    </resource-env-ref>   
  154. 14、资源工厂配置   
  155.    <resource-ref>   
  156.        <res-ref-name>mail/Session</res-ref-name>   
  157.        <res-type>javax.mail.Session</res-type>   
  158.        <res-auth>Container</res-auth>   
  159.    </resource-ref>   
  160.    配置数据库连接池就可在此配置:   
  161.    <resource-ref>   
  162.        <description>JNDI JDBC DataSource of shop</description>   
  163.        <res-ref-name>jdbc/sample_db</res-ref-name>   
  164.        <res-type>javax.sql.DataSource</res-type>   
  165.        <res-auth>Container</res-auth>   
  166.    </resource-ref>   
  167. 15、安全限制配置   
  168.    <security-constraint>   
  169.       <display-name>Example Security Constraint</display-name>   
  170.       <web-resource-collection>   
  171.          <web-resource-name>Protected Area</web-resource-name>   
  172.          <url-pattern>/jsp/security/protected/*</url-pattern>   
  173.          <http-method>DELETE</http-method>   
  174.          <http-method>GET</http-method>   
  175.          <http-method>POST</http-method>   
  176.          <http-method>PUT</http-method>   
  177.       </web-resource-collection>   
  178.       <auth-constraint>   
  179.         <role-name>tomcat</role-name>   
  180.         <role-name>role1</role-name>   
  181.       </auth-constraint>   
  182.    </security-constraint>   
  183. 16、登陆验证配置   
  184.    <login-config>   
  185.      <auth-method>FORM</auth-method>   
  186.      <realm-name>Example-Based Authentiation Area</realm-name>   
  187.      <form-login-config>   
  188.         <form-login-page>/jsp/security/protected/login.jsp</form-login-page>   
  189.         <form-error-page>/jsp/security/protected/error.jsp</form-error-page>   
  190.      </form-login-config>   
  191.    </login-config>   
  192. 17、安全角色:security-role元素给出安全角色的一个列表,这些角色将出现在servlet元素内的security-role-ref元素的role-name子元素中。   
  193.     分别地声明角色可使高级IDE处理安全信息更为容易。   
  194.   <security-role>   
  195.      <role-name>tomcat</role-name>   
  196.   </security-role>   
  197. 18、Web环境参数:env-entry元素声明Web应用的环境项   
  198.   <env-entry>   
  199.      <env-entry-name>minExemptions</env-entry-name>   
  200.      <env-entry-value>1</env-entry-value>   
  201.      <env-entry-type>java.lang.Integer</env-entry-type>   
  202.   </env-entry>   
  203. 19、EJB 声明   
  204.   <ejb-ref>   
  205.      <description>Example EJB reference</decription>   
  206.      <ejb-ref-name>ejb/Account</ejb-ref-name>   
  207.      <ejb-ref-type>Entity</ejb-ref-type>   
  208.      <home>com.mycompany.mypackage.AccountHome</home>   
  209.      <remote>com.mycompany.mypackage.Account</remote>   
  210.   </ejb-ref>   
  211. 20、本地EJB声明   
  212.   <ejb-local-ref>   
  213.      <description>Example Loacal EJB reference</decription>   
  214.      <ejb-ref-name>ejb/ProcessOrder</ejb-ref-name>   
  215.      <ejb-ref-type>Session</ejb-ref-type>   
  216.      <local-home>com.mycompany.mypackage.ProcessOrderHome</local-home>   
  217.      <local>com.mycompany.mypackage.ProcessOrder</local>   
  218.   </ejb-local-ref>   
  219. 21、配置DWR   
  220.   <servlet>   
  221.       <servlet-name>dwr-invoker</servlet-name>   
  222.       <servlet-class>uk.ltd.getahead.dwr.DWRServlet</servlet-class>   
  223.   </servlet>   
  224.   <servlet-mapping>   
  225.       <servlet-name>dwr-invoker</servlet-name>   
  226.       <url-pattern>/dwr/*</url-pattern>   
  227.   </servlet-mapping>   
  228. 22、配置Struts   
  229.     <display-name>Struts Blank Application</display-name>   
  230.     <servlet>   
  231.         <servlet-name>action</servlet-name>   
  232.         <servlet-class>   
  233.             org.apache.struts.action.ActionServlet   
  234.         </servlet-class>   
  235.         <init-param>   
  236.             <param-name>detail</param-name>   
  237.             <param-value>2</param-value>   
  238.         </init-param>   
  239.         <init-param>   
  240.             <param-name>debug</param-name>   
  241.             <param-value>2</param-value>   
  242.         </init-param>   
  243.         <init-param>   
  244.             <param-name>config</param-name>   
  245.             <param-value>/WEB-INF/struts-config.xml</param-value>   
  246.         </init-param>   
  247.         <init-param>   
  248.             <param-name>application</param-name>   
  249.             <param-value>ApplicationResources</param-value>   
  250.         </init-param>   
  251.         <load-on-startup>2</load-on-startup>   
  252.     </servlet>   
  253.     <servlet-mapping>   
  254.         <servlet-name>action</servlet-name>   
  255.         <url-pattern>*.do</url-pattern>   
  256.     </servlet-mapping>   
  257.     <welcome-file-list>   
  258.         <welcome-file>index.jsp</welcome-file>   
  259.     </welcome-file-list>   
  260.   
  261.     <!– Struts Tag Library Descriptors –>   
  262.     <taglib>   
  263.         <taglib-uri>struts-bean</taglib-uri>   
  264.         <taglib-location>/WEB-INF/tld/struts-bean.tld</taglib-location>   
  265.     </taglib>   
  266.     <taglib>   
  267.         <taglib-uri>struts-html</taglib-uri>   
  268.         <taglib-location>/WEB-INF/tld/struts-html.tld</taglib-location>   
  269.     </taglib>   
  270.     <taglib>   
  271.     <taglib-uri>struts-nested</taglib-uri>   
  272.     <taglib-location>/WEB-INF/tld/struts-nested.tld</taglib-location>   
  273.     </taglib>   
  274.     <taglib>   
  275.         <taglib-uri>struts-logic</taglib-uri>   
  276.         <taglib-location>/WEB-INF/tld/struts-logic.tld</taglib-location>   
  277.     </taglib>   
  278.     <taglib>   
  279.         <taglib-uri>struts-tiles</taglib-uri>   
  280.         <taglib-location>/WEB-INF/tld/struts-tiles.tld</taglib-location>   
  281.     </taglib>   
  282. 23、配置Spring(基本上都是在Struts中配置的)   
  283.   
  284.    <!– 指定spring配置文件位置 –>   
  285.    <context-param>   
  286.       <param-name>contextConfigLocation</param-name>   
  287.       <param-value>   
  288.        <!–加载多个spring配置文件 –>   
  289.         /WEB-INF/applicationContext.xml, /WEB-INF/action-servlet.xml   
  290.       </param-value>   
  291.    </context-param>   
  292.   
  293.    <!– 定义SPRING监听器,加载spring –>   
  294.   
  295.   <listener>   
  296.      <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>   
  297.   </listener>   
  298.   
  299.   <listener>   
  300.      <listener-class>   
  301.        org.springframework.web.context.request.RequestContextListener   
  302.      </listener-class>   
  303.   </listener>   

 转自:http://zhxing.iteye.com/blog/399668

awk使用手册详解

 awk  awk使用手册详解已关闭评论
2月 132014
 

什么是awk?

你 可能对UNIX比较熟悉,但你可能对awk很陌生,这一点也不奇怪,的确,与其优秀的功能相比,awk还远没达到它应有的知名度。awk是什么?与其它大 多数UNIX命令不同的是,从名字上看,我们不可能知道awk的功能:它既不是具有独立意义的英文单词,也不是几个相关单词的缩写。事实上,awk是三个 人名的缩写,他们是:Aho、(Peter)Weinberg和(Brain)Kernighan。正是这三个人创造了awk—一个优秀的样式扫描与 处理工具。 

AWK的功能是什么?与sed和grep很相似,awk是一种样式扫描与处理工具。但其功能却大大强于sed和grep。 awk提供了极其强大的功能:它几乎可以完成grep和sed所能完成的全部工作,同时,它还可以可以进行样式装入、流控制、数学运算符、进程控制语句甚 至于内置的变量和函数。它具备了一个完整的语言所应具有的几乎所有精美特性。实际上,awk的确拥有自己的语言:awk程序设计语言,awk的三位创建者 已将它正式定义为:样式扫描和处理语言。 

为什么使用awk?

即使如此,你也许仍然会问,我为什么要使用awk?

使 用awk的第一个理由是基于文本的样式扫描和处理是我们经常做的工作,awk所做的工作有些象数据库,但与数据库不同的是,它处理的是文本文件,这些文件 没有专门的存储格式,普通的人们就能编辑、阅读、理解和处理它们。而数据库文件往往具有特殊的存储格式,这使得它们必须用数据库处理程序来处理它们。既然 这种类似于数据库的处理工作我们经常会遇到,我们就应当找到处理它们的简便易行的方法,UNIX有很多这方面的工具,例如sed 、grep、sort以及find等等,awk是其中十分优秀的一种。

使用awk的第二个理由是awk是一个简单的工具,当然这是相对于 其强大的功能来说的。的确,UNIX有许多优秀的工具,例如UNIX天然的开发工具C语言及其延续C++就非常的优秀。但相对于它们来说,awk完成同样 的功能要方便和简捷得多。这首先是因为awk提供了适应多种需要的解决方案:从解决简单问题的awk命令行到复杂而精巧的awk程序设计语言,这样做的好 处是,你可以不必用复杂的方法去解决本来很简单的问题。例如,你可以用一个命令行解决简单的问题,而C不行,即使一个再简单的程序,C语言也必须经过编 写、编译的全过程。其次,awk本身是解释执行的,这就使得awk程序不必经过编译的过程,同时,这也使得它与shell script程序能够很好的契合。最后,awk本身较C语言简单,虽然awk吸收了C语言很多优秀的成分,熟悉C语言会对学习awk有很大的帮助,但 awk本身不须要会使用C语言——一种功能强大但需要大量时间学习才能掌握其技巧的开发工具。

使用awk的第三个理由是awk是一个容易 获得的工具。与C和C++语言不同,awk只有一个文件(/bin/awk),而且几乎每个版本的UNIX都提供各自版本的awk,你完全不必费心去想如 何获得awk。但C语言却不是这样,虽然C语言是UNIX天然的开发工具,但这个开发工具却是单独发行的,换言之,你必须为你的UNIX版本的C语言开发 工具单独付费(当然使用D版者除外),获得并安装它,然后你才可以使用它。

基于以上理由,再加上awk强大的功能,我们有理由说,如果你 要处理与文本样式扫描相关的工作,awk应该是你的第一选择。在这里有一个可遵循的一般原则:如果你用普通的shell工具或shell script有困难的话,试试awk,如果awk仍不能解决问题,则便用C语言,如果C语言仍然失败,则移至C++。

awk的调用方式
前面曾经说过,awk提供了适应多种需要的不同解决方案,它们是:

一、 awk命令行,你可以象使用普通UNIX命令一样使用awk,在命令行中你也可以使用awk程序设计语言,虽然awk支持多行的录入,但是录入长长的命令 行并保证其正确无误却是一件令人头疼的事,因此,这种方法一般只用于解决简单的问题。当然,你也可以在shell script程序中引用awk命令行甚至awk程序脚本。

二、使用-f选项调用awk程序。awk允许将一段awk程序写入一个文本文件,然后在awk命令行中用-f选项调用并执行这段程序。具体的方法我们将在后面的awk语法中讲到。

三、利用命令解释器调用awk程序:利用UNIX支持的命令解释器功能,我们可以将一段awk程序写入文本文件,然后在它的第一行加上:
#!/bin/awk -f
并赋予这个文本文件以执行的权限。这样做之后,你就可以在命令行中用类似于下面这样的方式调用并执行这段awk程序了。

$awk脚本文本名 待处理文件

awk的语法: 
与其它UNIX命令一样,awk拥有自己的语法:

awk [ -F re] [parameter…] [‘prog’] [-f progfile][in_file…] 

参数说明:

-F re:允许awk更改其字段分隔符。

parameter: 该参数帮助为不同的变量赋值。

‘prog’: awk的程序语句段。这个语句段必须用单拓号:’和’括起,以防被shell解释。这个程序语句段的标准形式为:

‘pattern {action}’

其 中pattern参数可以是egrep正则表达式中的任何一个,它可以使用语法/re/再加上一些样式匹配技巧构成。与sed类似,你也可以使用”,”分 开两样式以选择某个范围。关于匹配的细节,你可以参考附录,如果仍不懂的话,找本UNIX书学学grep和sed(本人是在学习ed时掌握匹配技术的)。 action参数总是被大括号包围,它由一系统awk语句组成,各语句之间用”;”分隔。awk解释它们,并在pattern给定的样式匹配的记录上执行 其操作。与shell类似,你也可以使用“#”作为注释符,它使“#”到行尾的内容成为注释,在解释执行时,它们将被忽略。你可以省略pattern和 action之一,但不能两者同时省略,当省略pattern时没有样式匹配,表示对所有行(记录)均执行操作,省略action时执行缺省的操作——在 标准输出上显示。 

-f progfile:允许awk调用并执行progfile指定有程序文件。progfile是一个文本文件,他必须符合awk的语法。 

in_file:awk的输入文件,awk允许对多个输入文件进行处理。值得注意的是awk不修改输入文件。如果未指定输入文件,awk将接受标准输入,并将结果显示在标准输出上。awk支持输入输出重定向。 

awk的记录、字段与内置变量:

前 面说过,awk处理的工作与数据库的处理方式有相同之处,其相同处之一就是awk支持对记录和字段的处理,其中对字段的处理是grep和sed不能实现 的,这也是awk优于二者的原因之一。在awk中,缺省的情况下总是将文本文件中的一行视为一个记录,而将一行中的某一部分作为记录中的一个字段。为了操 作这些不同的字段,awk借用shell的方法,用$1,$2,$3…这样的方式来顺序地表示行(记录)中的不同字段。特殊地,awk用$0表示整个 行(记录)。不同的字段之间是用称作分隔符的字符分隔开的。系统默认的分隔符是空格。awk允许在命令行中用-F re的形式来改变这个分隔符。事实上,awk用一个内置的变量FS来记忆这个分隔符。awk中有好几个这样的内置变量,例如,记录分隔符变量RS、当前工 作的记录数NR等等,本文后面的附表列出了全部的内置变量。这些内置的变量可以在awk程序中引用或修改,例如,你可以利用NR变量在模式匹配中指定工作 范围,也可以通过修改记录分隔符RS让一个特殊字符而不是换行符作为记录的分隔符。

例:显示文本文件myfile中第七行到第十五行中以字符%分隔的第一字段,第三字段和第七字段:

awk -F % ‘NR==7,NR==15 {printf $1 $3 $7}’ 

awk的内置函数

awk 之所以成为一种优秀的程序设计语言的原因之一是它吸收了某些优秀的程序设计语言(例如C)语言的许多优点。这些优点之一就是内置函数的使用,awk定义并 支持了一系列的内置函数,由于这些函数的使用,使得awk提供的功能更为完善和强大,例如,awk使用了一系列的字符串处理内置函数(这些函数看起来与C 语言的字符串处理函数相似,其使用方式与C语言中的函数也相差无几),正是由于这些内置函数的使用,使awk处理字符串的功能更加强大。本文后面的附录中 列有一般的awk所提供的内置函数,这些内置函数也许与你的awk版本有些出入,因此,在使用之前,最好参考一下你的系统中的联机帮助。

作 为内置函数的一个例子,我们将在这里介绍awk的printf函数,这个函数使得awk与c语言的输出相一致。实际上,awk中有许多引用形式都是从C语 言借用过来的。如果你熟悉C语言,你也许会记得其中的printf函数,它提供的强大格式输出功能曾经带我们许多的方便。幸运的是,我们在awk中又和它 重逢了。awk中printf几乎与C语言中一模一样,如果你熟悉C语言的话,你完全可以照C语言的模式使用awk中的printf。因此在这里,我们只 给出一个例子,如果你不熟悉的话,请随便找一本C语言的入门书翻翻。

例:显示文件myfile中的行号和第3字段:

$awk ‘{printf”%03d%sn”,NR,$1}’ myfile

在命令行使用awk

按 照顺序,我们应当讲解awk程序设计的内容了,但在讲解之前,我们将用一些例子来对前面的知识进行回顾,这些例子都是在命令行中使用的,由此我们可以知道 在命令行中使用awk是多么的方便。这样做的原因一方面是为下面的内容作铺垫,另一方面是介绍一些解决简单问题的方法,我们完全没有必要用复杂的方法来解 决简单的问题—-既然awk提供了较为简单的方法的话。

例:显示文本文件mydoc匹配(含有)字符串”sun”的所有行。

$awk ‘/sun/{print}’ mydoc 

由于显示整个记录(全行)是awk的缺省动作,因此可以省略action项。

$awk ‘/sun/’ mydoc 

例:下面是一个较为复杂的匹配的示例:

$awk ‘/[Ss]un/,/[Mm]oon/ {print}’ myfile

它将显示第一个匹配Sun或sun的行与第一个匹配Moon或moon的行之间的行,并显示到标准输出上。 

例:下面的示例显示了内置变量和内置函数length()的使用:

$awk ‘length($0)>80 {print NR}’ myfile 

该命令行将显示文本myfile中所有超过80个字符的行号,在这里,用$0表示整个记录(行),同时,内置变量NR不使用标志符’$’。 

例: 作为一个较为实际的例子,我们假设要对UNIX中的用户进行安全性检查,方法是考察/etc下的passwd文件,检查其中的passwd字段(第二字 段)是否为”*”,如不为”*”,则表示该用户没有设置密码,显示出这些用户名(第一字段)。我们可以用如下语句实现:

#awk -F: ‘$2==”” {printf(“%s no password!n”,$1’ /etc/passwd

在这个示例中,passwd文件的字段分隔符是“:”,因此,必须用-F:来更改默认的字段分隔符,这个示例中也涉及到了内置函数printf的使用。 

awk的变量

如同其它程序设计语言一样,awk允许在程序语言中设置变量,事实上,提供变量的功能是程序设计语言的其本要求,不提供变量的程序设计语言本人还从未见过。

awk 提供两种变量,一种是awk内置的变量,这前面我们已经讲过,需要着重指出的是,与后面提到的其它变量不同的是,在awk程序中引用内置变量不需要使用标 志符”$”(回忆一下前面讲过的NR的使用)。awk提供的另一种变量是自定义变量。awk允许用户在awk程序语句中定义并调用自已的变量。当然这种变 量不能与内置变量及其它awk保留字相同,在awk中引用自定义变量必须在它前面加上标志符”$”。与C语言不同的是,awk中不需要对变量进行初始化, awk根据其在awk中第一次出现的形式和上下文确定其具体的数据类型。当变量类型不确定时,awk默认其为字符串类型。这里有一个技巧:如果你要让你的 awk程序知道你所使用的变量的明确类型,你应当在在程序中给它赋初值。在后面的实例中,我们将用到这一技巧。 

运算与判断:

作 为一种程序设计语言所应具有的特点之一,awk支持多种运算,这些运算与C语言提供的几本相同:如+、-、*、/、%等等,同时,awk也支持C语言中类 似++、–、+=、-=、=+、=-之类的功能,这给熟悉C语言的使用者编写awk程序带来了极大的方便。作为对运算功能的一种扩展,awk还提供了一 系列内置的运算函数(如log、sqr、cos、sin等等)和一些用于对字符串进行操作(运算)的函数(如length、substr等等)。这些函数 的引用大大的提高了awk的运算功能。 

作为对条件转移指令的一部分,关系判断是每种程序设计语言都具备的功能,awk也不例外。 awk中允许进行多种测试,如常用的==(等于)、!=(不等于)、>(大于)、<(小于)、>=(大于等于)、>=(小于等 于)等等,同时,作为样式匹配,还提供了~(匹配于)和!~(不匹配于)判断。

作为对测试的一种扩充,awk也支持用逻辑运算符:!(非)、&&(与)、||(或)和括号()进行多重判断,这大大增强了awk的功能。本文的附录中列出了awk所允许的运算、判断以及操作符的优先级。

awk的流程控制

流程控制语句是任何程序设计语言都不能缺少的部分。任何好的语言都有一些执行流程控制的语句。awk提供的完备的流程控制语句类似于C语言,这给我们编程带来了极大的方便。

1、BEGIN和END:

在awk 中两个特别的表达式,BEGIN和END,这两者都可用于pattern中(参考前面的awk语法),提供BEGIN和END的作用是给程序赋予初始状态 和在程序结束之后执行一些扫尾的工作。任何在BEGIN之后列出的操作(在{}内)将在awk开始扫描输入之前执行,而END之后列出的操作将在扫描完全 部的输入之后执行。因此,通常使用BEGIN来显示变量和预置(初始化)变量,使用END来输出最终结果。

例:累计销售文件xs中的销售金额(假设销售金额在记录的第三字段):

$awk
>’BEGIN { FS=”:”;print “统计销售金额”;total=0}
>{print $3;total=total+$3;}
>END {printf “销售金额总计:%.2f”,total}’ sx
(注:>是shell提供的第二提示符,如要在shell程序awk语句和awk语言中换行,则需在行尾加反斜杠)

在这里,BEGIN预置了内部变量FS(字段分隔符)和自定义变量total,同时在扫描之前显示出输出行头。而END则在扫描完成后打印出总合计。

2、流程控制语句
awk提供了完备的流程控制语句,其用法与C语言类似。下面我们一一加以说明:

2.1、if…else语句:

格式:
if(表达式)
语句1
else
语句2

格式中”语句1″可以是多个语句,如果你为了方便awk判断也方便你自已阅读,你最好将多个语句用{}括起来。awk分枝结构允许嵌套,其格式为:

if(表达式1)
{if(表达式2)
语句1
else
语句2
}
语句3
else {if(表达式3)
语句4
else
语句5
}
语句6

当然实际操作过程中你可能不会用到如此复杂的分枝结构,这里只是为了给出其样式罢了。

2.2、while语句

格式为:

while(表达式)
语句

2.3、do-while语句

格式为:

do
{
语句
}while(条件判断语句)

2.4、for语句

格式为:

for(初始表达式;终止条件;步长表达式)
{语句}

在awk 的 while、do-while和for语句中允许使用break,continue语句来控制流程走向,也允许使用exit这样的语句来退出。break 中断当前正在执行的循环并跳到循环外执行下一条语句。continue从当前位置跳到循环开始处执行。对于exit的执行有两种情况:当exit语句不在 END中时,任何操作中的exit命令表现得如同到了文件尾,所有模式或操作执行将停止,END模式中的操作被执行。而出现在END中的exit将导致程 序终止。

例:为了 

awk中的自定义函数

定义和调用用户自己的函数是几乎每个高级语言都具有的功能,awk也不例外,但原始的awk并不提供函数功能,只有在nawk或较新的awk版本中才可以增加函数。

函数的使用包含两部分:函数的定义与函数调用。其中函数定义又包括要执行的代码(函数本身)和从主程序代码传递到该函数的临时调用。 

awk函数的定义方法如下: 

function 函数名(参数表){
函数体
}

在gawk中允许将function省略为func,但其它版本的awk不允许。函数名必须是一个合法的标志符,参数表中可以不提供参数(但在调用函数时函数名后的一对括号仍然是不可缺少的),也可以提供一个或多个参数。与C语言相似,awk的参数也是通过值来传递的。

在awk 中调用函数比较简单,其方法与C语言相似,但awk比C语言更为灵活,它不执行参数有效性检查。换句话说,在你调用函数时,可以列出比函数预计(函数定义 中规定)的多或少的参数,多余的参数会被awk所忽略,而不足的参数,awk将它们置为缺省值0或空字符串,具体置为何值,将取决于参数的使用方式。

awk函数有两种返回方式:隐式返回和显式返回。当awk执行到函数的结尾时,它自动地返回到调用程序,这是函数是隐式返回的。如果需要在结束之前退出函数,可以明确地使用返回语句提前退出。方法是在函数中使用形如:return 返回值 格式的语句。 

例: 下面的例子演示了函数的使用。在这个示例中,定义了一个名为print_header的函数,该函数调用了两个参数FileName和PageNum, FileName参数传给函数当前使用的文件名,PageNum参数是当前页的页号。这个函数的功能是打印(显示)出当前文件的文件名,和当前页的页号。 完成这个功能后,这个函数将返回下一页的页号。

nawk 
>’BEGIN{pageno=1;file=FILENAME 
>pageno=print_header(file,pageno);#调用函数print_header
>printf(“当前页页号是:%dn”,pageno);
>}

>#定义函数print_header
>function print_header(FileName,PageNum){
>printf(“%s %dn”,FileName,PageNum); >PageNum++;return PageNUm; 
>}
>}’ myfile 

执行这个程序将显示如下内容:

myfile 1
当前页页号是:2

awk高级输入输出

1.读取下一条记录:

awk的next语句导致awk读取下一个记录并完成模式匹配,然后立即执行相应的操作。通常它用匹配的模式执行操作中的代码。next导致这个记录的任何额外匹配模式被忽略。

2.简单地读取一条记录

awk 的 getline语句用于简单地读取一条记录。如果用户有一个数据记录类似两个物理记录,那么getline将尤其有用。它完成一般字段的分离(设置字段变 量$0 FNR NF NR)。如果成功则返回1,失败则返回0(到达文件尾)。如果需简单地读取一个文件,则可以编写以下代码:

例:示例getline的使用

{while(getline==1)
{
#process the inputted fields
}
}

也可以使getline保存输入数据在一个字段中,而不是通过使用getline variable的形式处理一般字段。当使用这种方式时,NF被置成0,FNR和NR被增值。

用 户也可以使用getline<“filename”方式从一个给定的文件中输入数据,而不是从命令行所列内容输入数据。此时,getline将完成 一般字段分离(设置字段变量$0和NF)。如果文件不存在,返回-1,成功,返回1,返回0表示失败。用户可以从给定文件中读取数据到一个变量中,也可以 用stdin(标准输入设备)或一个包含这个文件名的变量代替filename。值得注意的是当使用这种方式时不修改FNR和NR。

另一种使用getline语句的方法是从UNIX命令接受输入,例如下面的例子:

例:示例从UNIX命令接受输入

{while(“who -u”|getline)
{
#process each line from the who command
}
}

当然,也可以使用如下形式:

“command” | getline variable

3.关闭文件:

awk中允许在程序中关闭一个输入或输出文件,方法是使用awk的close语句。

close(“filename”)

filename可以是getline打开的文件(也可以是stdin,包含文件名的变量或者getline使用的确切命令)。或一个输出文件(可以是stdout,包含文件名的变量或使用管道的确切命令)。

4.输出到一个文件:

awk中允许用如下方式将结果输出到一个文件:

printf(“hello word!n”)>”datafile”

printf(“hello word!n”)>>”datafile”

5.输出到一个命令

awk中允许用如下方式将结果输出到一个命令:

printf(“hello word!n”)|”sort-t’,'” 

awk与shell script混合编程

因 为awk可以作为一个shell命令使用,因此awk能与shell批处理程序很好的融合在一起,这给实现awk与shell程序的混合编程提供了可能。 实现混合编程的关键是awk与shell script之间的对话,换言之,就是awk与shell script之间的信息交流:awk从shell script中获取所需的信息(通常是变量的值)、在awk中执行shell命令行、shell script将命令执行的结果送给awk处理以及shell script读取awk的执行结果等等。

1.awk读取Shell script程序变量

在awk中我们可以通过“’$变量名’”的方式读取sell scrpit程序中的变量。

例:在下面的示例中,我们将读取sell scrpit程序中的变量Name,该变量存放的是文本myfile的撰写者,awk将打印出这个人名。

$cat writename
:
# @(#)
#
.
.
.
Name=”张三” nawk ‘BEGIN {name=”‘Name'”; printf(“t%st撰写者%sn”,FILENAME,name”);}
{…}END{…}’ myfile
.
.
.

2.将shell命令的执行结果送给awk处理

作为信息传送的一种方法,我们可以将一条shell命令的结果通过管道线(|)传递给awk处理:

例:示例awk处理shell命令的执行结果

$who -u | awk ‘{printf(“%s正在执行%sn”,$2,$1)}’

该命令将打印出注册终端正在执行的程序名。

3.shell script程序读awk的执行结果

为 了实现shell script程序读取awk执行的结果,我们可以采取一些特殊的方法,例如我们可以用变量名=`awk语句`的形式将awk执行的结果存放入一个 shell script变量。当然也可以用管道线的方法将awk执行结果传递给shell script程序处理。 

例:作为传送消 息的机制之一,UNIX提供了一个向其所有用户传送消息的命令wall(意思是write to all写给所有用户),该命令允许向所有工作中的用户(终端)发送消息。为此,我们可以通过一段shell批处理程序wall.shell来模拟这一程序 (事实上比较老的版本中wall就是一段shell批处理程序:

$cat wall.shell
:
# @(#) wall.shell:发送消息给每个已注册终端
#
cat >/tmp/$$
#用户录入消息文本 who -u | awk ‘{print $2}’ | while read tty
do
cat /tmp/$$>$tty
done

在 这个程序里,awk接受who -u命令的执行结果,该命令打印出所有已注册终端的信息,其中第二个字段是已注册终端的设备名,因此用awk命令析出该设备名,然后用while read tty语句循环读出这些文件名到变量(shell script变量)tty中,作为信息传送的终结地址。

4.在awk中执行shell命令行—-嵌入函数system()

system()是一个不适合字符或数字类型的嵌入函数,该函数的功能是处理作为参数传递给它的字符串。system对这个参数的处理就是将其作为命令处理,也就是说将其当作命令行一样加以执行。这使得用户在自己的awk程序需要时可以灵活地执行命令或脚本。

例:下面的程序将使用system嵌入函数打印用户编制好的报表文件,这个文件存放在名为myreport.txt的文件中。为简约起见,我们只列出了其END部分:

.
.
.
END {close(“myreport.txt”);system(“lp myreport.txt”);} 

在这个示例中,我们首先使用close语句关闭了文件myreport.txt文件,然后使用system嵌入函数将myreport.txt送入打印机打印。

写 到这里,我不得不跟朋友们说再见了,实在地说,这些内容仍然是awk的初步知识,电脑永远是前进的科学,awk也不例外,本篇所能做的只是在你前行的漫漫 长途中铺平一段小小开端,剩下的路还得靠你自己去走。老实说,如果本文真能给你前行的路上带来些许的方便,那本人就知足了!

如对本篇有任何疑问,请E-mail To:[email protected]或到主页http://chizling.yeah.net中留言。

附录:

1.awk的常规表达式元字符

换码序列
^ 在字符串的开头开始匹配
$ 在字符串的结尾开始匹配
. 与任何单个字符串匹配
[ABC] 与[]内的任一字符匹配
[A-Ca-c] 与A-C及a-c范围内的字符匹配(按字母表顺序)
[^ABC] 与除[]内的所有字符以外的任一字符匹配
Desk|Chair 与Desk和Chair中的任一个匹配
[ABC][DEF] 关联。与A、B、C中的任一字符匹配,且其后要跟D、E、F中的任一个字符。
* 与A、B或C中任一个出现0次或多次的字符相匹配 
+ 与A、B或C中任何一个出现1次或多次的字符相匹配
? 与一个空串或A、B或C在任何一个字符相匹配
(Blue|Black)berry 合并常规表达式,与Blueberry或Blackberry相匹配 

2.awk算术运算符

运算符 用途
——————
x^y x的y次幂
x**y 同上
x%y 计算x/y的余数(求模)
x+y x加y
x-y x减y
x*y x乘y
x/y x除y
-y 负y(y的开关符号);也称一目减
++y y加1后使用y(前置加)
y++ 使用y值后加1(后缀加)
–y y减1后使用y(前置减)
y– 使用后y减1(后缀减)
x=y 将y的值赋给x
x+=y 将x+y的值赋给x
x-=y 将x-y的值赋给x
x*=y 将x*y的值赋给x
x/=y 将x/y的值赋给x x%=y 将x%y的值赋给x
x^=y 将x^y的值赋给x
x**=y 将x**y的值赋给x
3.awk允许的测试:
操作符 含义
x==y x等于y
x!=y x不等于y
x>y x大于y
x>=y x大于或等于y
x<y x小于y
x<=y x小于或等于y?
x~re x匹配正则表达式re?
x!~re x不匹配正则表达式re? 
4.awk的操作符(按优先级升序排列)
= 、+=、 -=、 *= 、/= 、 %=
||
&&
> >= < <= == != ~ !~
xy (字符串连结,’x”y’变成”xy”)
+ –
* / % 
++ —
5.awk内置变量(预定义变量)
说明:表中v项表示第一个支持变量的工具(下同):A=awk,N=nawk,P=POSIX awk,G=gawk
V 变量 含义 缺省值
——————————————————–
N ARGC 命令行参数个数 
G ARGIND 当前被处理文件的ARGV标志符
N ARGV 命令行参数数组
G CONVFMT 数字转换格式 %.6g
P ENVIRON UNIX环境变量
N ERRNO UNIX系统错误消息
G FIELDWIDTHS 输入字段宽度的空白分隔字符串
A FILENAME 当前输入文件的名字
P FNR 当前记录数
A FS 输入字段分隔符 空格
G IGNORECASE 控制大小写敏感0(大小写敏感)
A NF 当前记录中的字段个数
A NR 已经读出的记录数
A OFMT 数字的输出格式 %.6g
A OFS 输出字段分隔符 空格
A ORS 输出的记录分隔符 新行
A RS 输入的记录他隔符 新行
N RSTART 被匹配函数匹配的字符串首
N RLENGTH 被匹配函数匹配的字符串长度
N SUBSEP 下标分隔符 “34”
6.awk的内置函数
V 函数 用途或返回值
————————————————
N gsub(reg,string,target) 每次常规表达式reg匹配时替换target中的string
N index(search,string) 返回string中search串的位置
A length(string) 求串string中的字符个数
N match(string,reg) 返回常规表达式reg匹配的string中的位置
N printf(format,variable) 格式化输出,按format提供的格式输出变量variable。
N split(string,store,delim) 根据分界符delim,分解string为store的数组元素
N sprintf(format,variable) 返回一个包含基于format的格式化数据,variables是要放到串中的数据
G strftime(format,timestamp) 返回一个基于format的日期或者时间串,timestmp是systime()函数返回的时间
N sub(reg,string,target) 第一次当常规表达式reg匹配,替换target串中的字符串
A substr(string,position,len) 返回一个以position开始len个字符的子串
P totower(string) 返回string中对应的小写字符
P toupper(string) 返回string中对应的大写字符
A atan(x,y) x的余切(弧度)
N cos(x) x的余弦(弧度)
A exp(x) e的x幂
A int(x) x的整数部分
A log(x) x的自然对数值
N rand() 0-1之间的随机数
N sin(x) x的正弦(弧度)
A sqrt(x) x的平方根
A srand(x) 初始化随机数发生器。如果忽略x,则使用system()

G system() 返回自1970年1月1日以来经过的时间(按秒计算)

转自:http://net.pku.edu.cn/~yhf/tutorial/awk_manual.html