bash学习记录（八）循环和分支（2）

Posted on 2018-06-11 | In Bash

Words count in article: 758 | Reading time ≈ 3

循环和分支(二)

多重循环

就像C，Java一样，bash同样可以实现多重循环,下面的例子简单的实现双重循环，如果加上循环控制可能就更难一些了。

for ((i=0;i<5;i++))
do
    for bin in 1 2 4
    do
    echo $bin
    done
echo $i
done

循环控制

影响循环行为的语句。有 break 和 continue 两个循环控制命令,break 命令可以终止循环，而continue可以跳过当前循环提前进入下一次循环，这里和C语言定义的类似。

下面举一个简单的break和continue的例子；

LIMIT=9
a=0
#while [[ $a -le $LIMIT ]]
#do
#let "a=a+1"
#if [ $a -eq 3 ] || [ $a -eq 11 ]
#then
#	continue
#fi
#echo $a
# done

while [[ $a -le $LIMIT ]]
do
    let "a=a+1"
    if [ $a -gt 2 ]
    then
    break
    fi
    echo $a
done

简单的break循环只能跳出最内容的循环，而不能跳出多层的循环，可以使用 break N 来跳出多层循环。n为想要跳出循环的层数。

和break像似的continue，同样可以使用 continue N 来实现。这里使用到了一个非常简单明了的例子

#!/bin/bash
for outer in I II III IV V           # outer loop
do
  echo; echo -n "Group $outer: "

  # --------------------------------------------------------------------
  for inner in 1 2 3 4 5 6 7 8 9 10  # inner loop
  do

    if [[ "$inner" -eq 7 && "$outer" = "III" ]]
    then
      continue 2  # Continue at loop on 2nd level, that is "outer loop".
                  # Replace above line with a simple "continue"
                  # to see normal loop behavior.
    fi  
    echo -n "$inner "  # 7 8 9 10 will not echo on "Group III."
  done  
  # --------------------------------------------------------------------
done
echo; echo
exit 0

测试和分支

使用 case 和 select 结构体，不像一个循环，因为它没有一个迭代的一个过程，但是它们能够通过条件指导程序的流向。

通过程序块控制程序流向

Case (in) /esac

在bash中的case结构类似C中的switch结构，是在拥有多种条件下可以使用到的代码块。case结构可以参见下面代码。 (其实是可以有condition的左边的括号的，嗯，可以加上的)

case "$variable" in 

 "$condition1" ) 
 command... 
 ;; 

 "$condition2" ) 
 command... 
 ;;

下面以后会非常有用处的例子

#! /bin/bash

case "$1" in
  "") echo "Usage: ${0##*/} <filename>"; exit $E_PARAM;;
                      # No command-line parameters,
                      # or first parameter empty.
# Note that ${0##*/} is ${var##pattern} param substitution. 
# 可以通过使用##partern把前面的./去掉

  -*) FILENAME=./$1;;   #  If filename passed as argument ($1)
                      #+ starts with a dash,
                      #+ replace it with ./$1
                      #+ so further commands don't interpret it
                      #+ as an option.

  * ) FILENAME=$1;;     # Otherwise, $1.
esac

select

select是和case结构意义相同的结构体，可以使用自定义的PS3也就是选择提示符。格式如下：

select variable [in list]
do
 command...
 break
done

简单实例，这个例子不完整需要再去考虑很多东西。

PS3="Choose your favorite vegetable:"
select vegetable in "beans" "carrots" "potatoes"
do
	if [[ $vegetable = "beans" ]] || [[ $vegetable = "carrots" ]] || [[$vegetable = "potatoes" ]]
		then 
			echo 
			echo "your favorite veggie is $vegetable"
			echo 
			continue
		else
			echo "your vegetable not on this list"
			break
		fi

done

bash学习记录（七）循环和分支（1）

Posted on 2018-06-11 | In Bash

Words count in article: 720 | Reading time ≈ 3

循环和分支

循环

循环就是一块当条件为真的迭代的代码块。

for循环

for arg in [list] 这是最基础的循环形式。如果do和for在一行里，那么就需要在do前面加分号如：for arg in list ;do

for arg in list
do
.. commend(s)
done

for循环有很多用法，举几个例子来了解一下for循环都能够干些什么吧。

# for i in "hello world !" # 这样当作整个字符串
for i in  hello world !
do
	echo $i
done
# 与命令结合
if [ -e "/bin/bash" ]
then
	echo "is exist"
fi

# 输出当前目录下匹配文件的内容 类似使用find命令
FILE="*txt"
for file in $FILE
do
	echo "Contents of $file"
	echo "------------------"
	cat "$file"
	echo
done

# 如果in list内容缺失就表示使用 in $@ 也就是所有传进来的参数
for a
do
	echo  "$a"
done
#通过使用命令来构造for循环的list
for b in `ls`
do
	echo $b
done

# 使用for循环输出用户的信息
PASSWORD_FILE=/etc/passwd
n=1
for name in $(awk 'BEGIN{FS=":";}{print $1}'< "$PASSWORD_FILE")
do
	echo "USER #$n=$name"
	let "n+=1"
done

#使用函数给for循环作值
give_parm(){
	echo "1 2 3 5 6"
}
for c in $(give_parm)
do
	echo $c
done

# 类C语言的for循环
for (( ai=1;ai<5;ai++))
do
	echo $ai
done

while循环

while循环用来测试一个条件,并且一直循环直到条件为true也就是退出码为0的时候退出循环。一般while循环用在提前不知道循环次数的时候。while循环使用中括号把条件括起来，也可以使用双中括号。

while [condition]
do
····commends
done

当while有多个条件的时候，只有最后一个参数会决定循环次数

while echo "previous-variable = $previous"
      echo
      previous=$var1
      [ "$var1" != end ] # Keeps track of what $var1 was previously.
      # Four conditions on *while*, but only the final one controls loop.
      # The *last* exit status is the one that counts.
do
echo "Input variable #1 (end to exit) "
  read var1
  echo "variable #1 = $var1"
done

也有类似C语言的while条件。

while (( a <= LIMIT ))   #  Double parentheses,
do                       # + and no "$" preceding variables.
  echo -n "$a "
  ((a += 1))             # let "a+=1" 算数运算
  # Yes, indeed.
  # Double parentheses permit incrementing a variable with C-like syntax.
  # 双小括号允许递增一个变量使用类C的运算方式
done

同样的while后的条件可以是一个函数

condition ()
{
  ((t++))
  if [ $t -lt 5 ]
  then
    return 0  # true
  else
    return 1  # false
  fi
}
while condition
#     ^^^^^^^^^
#     Function call -- four loop iterations.
do
  echo "Still going: t = $t"
done

while可以和read命令进行结合，形成 while read 结构体，能够有效的读和处理文件。

while read line
do
    echo $line #读取1.txt中的每一行
done < 1.txt

until循环

until循环是和while循环正好相反，until会一直进行循环，直到条件变为false；

until [ condition-is-true ]
do
 command(s)...
done

正则表达式的入门

Posted on 2018-06-06 | In Linux

Words count in article: 972 | Reading time ≈ 3

正则表达式

最近会时常遇到编写正则表达式，所以现在写一篇正则表达式的文章来简单记录一下学习正则的过程。

在这个网站有正则表达式的中文文档 -》正则表达式手册

特殊字符

一般使用反斜杠 \ 来转义特殊字符如在正则中有特殊意义的* 或者. 如果要使用原意则需要使用\来进行转义如 \*。下面介绍几个具体的实例。

^ 匹配输入字符串的开始位置
$ 匹配输入字符串的结束位置
. 匹配除去换行符之外的所有字符
* 匹配前面字符0次或者多次
? 匹配前面大的字符0次或者1次
+ 匹配前面字符一次或多次
\w 匹配字母或者数字
\s 匹配任意空白
\d 匹配数字
\b 匹配单词的开始或者结束

一般使用 ^ 开头并且以 $ 结束，如验证5-12位数字的时候可以这样写 ^\d{5,12}$ 当字符串为 "hello world 是，使用$时匹配到一处，而使用\b时会匹配到四处，分别为每个单词的开头和结尾。

特殊字符非常重要，是正则表达式的基本。在上面的例子中使用到了重复，也就是{m,n} m和n是重复的次数，如果n存在，那么就重复m到n次如果不存在，就重复m次。

字符匹配

当使用到非特殊字符的时候，可以使用中括号，如 [aeiou]用来表示其中的字符都可以匹配到。比如字符串 ‘how hello’ 使用到正则表达式 h[oe] 这样可以提示匹配到两处

当需要使用与特殊字符相反的含义的时候 使用反斜杠+大写字符的格式来进行匹配。比如匹配非字母和数字的字符就应该使用\W(因为使用匹配字母和数字的特殊字符是\w)。非特殊字符的反义使用^号。如[^aeiou]表示原因字符意外的任意字符。

当想匹配多种情况的时候，比如我想匹配x或者y字符串那么就使用 x|y 来表示匹配x或者y。这样可以解决很多二义性的匹配串。

分组的匹配

当想对一个字符串进行重复，那么可以使用分组的功能。使用小括号来实现。典型的ip地址的匹配就可以这样使用(\d{1,3}.){3}\d{1,3}

使用 \\+数字 的形式来实现重复那个分组的操作
如 \b(\w+)\b\s+\1\b 就可以匹配相同的字符串。

贪婪模式

当使用?紧跟其他任何一个其他限制符之后比如. * 之后，匹配模式是非贪婪的，尽可能少的匹配搜素的所有字符串。比如搜多ppppppp字符串，使用‘o+?’会匹配到单个o

关于的后续

(?:pattern) 匹配pattern但不获取结果。这在使用|来组合一个模式的各个部分非常有用，比如常规匹配两种字符串“username|userManner”可以使用user(?:name|Manner)来简写。
(?=pattern) 正向肯定预查。比如windows(?=95|03|NT)能够匹配到windows95中的windows而不能匹配到windowsxp中的windows
(?!pattern) 正向否定预查。与上面的意思相似，就是能够匹配到非的指定条件。比如windows(?!95|03|NT`能够匹配到windowsxp中的windows而不能匹配到windows95中的windows
(?<=pattern) 反向肯定预查。和第一个很相近，只不过方向不同。
(?<!) 反向否定预查。

这次的正则表达式就先总结到这里，以后肯定会遇到更多的关于正则的问题。有时间一定还要读读英文的正则教程

bash学习记录（五） bash中关于变量的更多的知识

Posted on 2018-05-01

Words count in article: 2.2k | Reading time ≈ 9

字符串操作

bash支持很多关于字符串的操作，不过可惜的是，这些操作缺乏统一性，有一些是使用参数等，另外一些是通过内建命令expr命令来实现，这会导致不同的语法功能的重叠，会比较混乱，下面简单介绍一下使用参数和命令的实现字符串的操作。

字符串长度（String Length）

$(#string) 这里是和C语言中的strlen()是相同的。

expr length $string 同样表示string串的长度。

#! /bin/bash
string=abcdefgHIGKL
#使用第一种方法$(#string)
echo "string的长度是：${#string}"
#使用第二种方法使用expr内建命令 优点简单易懂
echo "string的长度是：`expr length $string`"
`

字符串从开头匹配子字串的长度

方法如下：

stringZ=abcABC123ABCab 
echo `expr match "$stringZ" 'abc[A-Z]*.2'`
echo `expr $stringZ : 'abc[A-Z]*.2'`

匹配到子串的位置 (index)

echo `expr index $stringZ 'abc[A-Z]*.2'`

子字符串的截取
1. ${string:position} 从positon位置截取字符串string。
2. ${string:positong:length} 从positon位置截取字符串string，并且限定截取长度为length。
3. expr substr $string $positon $length 意思同上。
4. expr match $string ‘$substring $’ 这里的substring是正则表达式。
  1
  2
  3
  4
  5
  #截取字符串
  echo ${stringZ:5}
  echo ${stringZ:5:4}
  echo `expr substr $stringZ 5 4`
  echo `expr match $stringZ '$abc[A-Z]*.2$'`
从字符串中移除子字符串
1. ${string#substring} substring是子字符串。并且需要注意的是：该方法表示的是向后移除该子字符串最短匹配到的字符串。
2. ${string##substring} 与上面的正好相反。该方法表示的是向后移除该字符串最长匹配到的字符串。
3. ${string%substring} 该方法表示的是由后向前移除该子字符串最短匹配到的字符串。
4. ${string%%substring} 该方法表示的是由后向前移除该字符串最长匹配到的字符串。
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  echo "移除字符串"
  echo ${stringZ#a*b}
  echo ${stringZ##a*b}
  echo ${stringZ%a*c}
  echo ${stringZ%%a*c}
  #结果：
  #ABC123ABCabc
  #c
  #abcABC123ABC
  #

子字符串替换

${string/substring/replacement} 替换第一个匹配到substring的字符串，替换为replacement。
${string//substring/replacement} 替换所有匹配到的字符。
${string/#substring/replacement} 替换由前向后匹配到的字符。

${string/%substring/replacement} 替换由后向前匹配到的字符。

echo "---------字符串替换---------"
echo ${stringZ/abc/xyz}
echo ${stringZ//abc/xyz}
echo ${stringZ/#abc/xyz}
echo ${stringZ/%abc/xyz}
#结果：
#xyzABC123ABCabc
#xyzABC123ABCxyz
#xyzABC123ABCabc
#abcABC123ABCxyz

使用awk操作字符串

现学先卖，三十分钟学会AWK,快速了解和应用awk。

基于以上，使用awk练习。

工作流分为大致三部分， read->excute->repeat,实现对文本的处理。

程序机构

BEGIN 语法：BEGIN {awk-commands} 是可以省略的部分块，主要作用是声明变量，初始化变量，
BODY块：{commonds}，是必须填写的部分，主要作用是处理文本，会对输入的每一行都执行body块中的命令，并且body是没有关键字的。

-END ：END {commands},同BEGIN，是可以省略的部分

基础语法

awk命令行，可以通过执行awk [-option] files来实现对files文件的处理。如 awk {print} mark.txt 这里就不具体举例了，开头的链接里讲的非常详细，这里只做简单的记录和查看。
使用命令文件方式 awk -f command.awk marks.txt 使用-f参数，可以使用文件中的命令。
awk基本选项：这里不具体总结，linux环境下终端 man awk可以看到非常多的选项。

基本使用示例

基本打印文件内容

$ awk '{print}' mark.txt 
1)  Amit    Physics  80
2)  Rahul   Maths    90
3)  Shyam   Biology  87
4)  Kedar   English  85
5)  Hari    History  89

打印具体项内容

$ awk '{print $1 "\t" $2 }' mark.txt
1)      Amit
2)      Rahul
3)      Shyam
4)      Kedar
5)      Hari

添加限定条件的打印内容

$ awk  '/a/  {print $1 "\t" $2 }' mark.txt
2)      Rahul
3)      Shyam
4)      Kedar
5)      Hari

结果只显示匹配到a的行

打印匹配到的行数

$ awk 'BEGIN{count=0} /a/ { count++} END{print count}' mark.txt
4

打印字符数量超过16的行

$ awk 'length($0) > 18' marks.txt
3) Shyam   Biology   87
4) Kedar   English   85

NOTE:在这里的参数和bash中的参数类似。$0当前行，$1之后表示对应文件的行的列。

内建变量

AWK提供了很多内建变量提供使用，能够起到很大的作用。

标准awk变量

ARGC 命令行参数个数

$ awk 'BEGIN{print "argument=",ARGC}' one two three
argument= 4

ARGV 命令行参数数组如 ARGV[1]=...
CONVFMT 数字的约定格式，默认值是%.6g

ENVIRON 环境变量

$ awk 'BEGIN {print "User is",ENVIRON["USER"]}'
User is nanyin

FILENAME 当前文件的名称

$ awk 'END{print "this file name is", FILENAME}' mark.txt
this file name is mark.txt

FS 分割符默认是空格也可以使用-F设置分割符
NF 当前行的字段数目
1
2
$ awk 'END{print NF}' mark.txt
4
NR 行号
FNR 当前文件的行号
OFS 输出字段分隔符
ORS 输出行分割符

RLENGTH 表示match函数匹配字符床的长度

$ awk 'BEGIN {if(match("One  Three","ree")) {print RLENGTH}}'
3

RSTART 表示match函数第一次匹配到的位置

$ awk 'BEGIN {if(match("One  Three","ree")) {print RSTART}}' 
8

操作符

与C语言的操作符基本相同，如数字的一元二元三元操作等，字符串的链接，数组元素等

正则表达式

AWK对正则的处理非常强大，通常你一个小小的正则表达式能够处理很复杂的问题。关于正则，有时间整理一篇专门关于正则的文章。

数组

AWK支持关联数组，也就是说，不仅可以使用数字索引的数组，还可以使用字符串作为索引。删除数组元素使用delete语句

流程控制

流程控制if while for 与C相同

函数

查手册吧。。一次性看不完。。。。内建函数手册，这里有在这章比较重要的字符串函数。接下来就来看看有哪些函数比较重要。

AWK对字符串操作的函数

整理出awk对字符串的几个具体函数操作。

asort(source,dest,how)
asorti(source,dest,how)

以上两个函数的how先不解释，前两个参数分别为source数组和排序方式，第二个可以不写，默认使用第一位的进行排位。
1
2
3
4
awk 'BEGIN{a[0]="xiaohong";a[1]="aiaolan";asort(a);for(i=2;i>=0;i--) {print a[i]}}'
xiaohong
aiaolan
`
asorti()函数会将顺序替换到数组的value处如：
1
2
3
awk 'BEGIN{a[0]="xiaohong";a[1]="aiaolan";asorti(a);for(i=2;i>=0;i--) {print a[i]}}'
1
0
gensub(regexp,replacement,how[,target]) 类似gsub和sub

替换匹配到的正则regexp为replacement.如果how是g或者G(global的简写),则表示替换所有使用regexp匹配到的字符串,target是目标字符串

如果使用regexp未匹配到，则返回原始target的值
1
2
3
4
5
6
7
8
9
10
11
# 第一个
echo a b c a d | gawk '{print gensub(/a/,"AA",2)}'
a b c AA d
# 第二个
awk '
BEGIN{
a="abc def"
b = gensub(/(.+) (.+)/,"\\2 \\1","g",a)
print b
}'
def abc

gsub(regexp,replacement[,target])

gsub中的‘g’其实是表示的是global,寻找目标的匹配到从左最长的，不重叠的,找到并且替换掉。
1
{ gsub(/Britain/, "United Kingdom"); print }
返回的值为匹配到的次数
index(in,find)

寻找in串内符合find匹配到的字符的index位置
1
2
3
$ awk 'BEGIN{
quote> print index("hello","lo")}'
4
length([string]) 顾名思义，不解释了
1
2
$ awk 'BEGIN{print length("hello")}'
5
NOTE: If no argument is supplied, length() returns the length of $0.
match(string,regexp,[,array])

使用正则匹配字符串，返回匹配到的位置，若未匹配到返回0
split(string,array[,fieldsep[,seps]])

分割string字符串，使用array存放分割后产生的字符组，使用fieldsep组为分割符，seps存放每次分割产生的分割符。一个分割出来的存放到array[1]中，第二个存放到array[2]中，以此类推。如果分割符fieldsep不写，则默认分割符为空格。
1
2
3
4
5
$ awk 'BEGIN{print split("cul-de-sac",a,"-",seps);for(i=1;i<4;i++){print a[i]}}'
3
cul
de
sac
sprintf(format,expression1,..)

是printf的功能，并且能够返回字符串
strtonum (str)

类似java的parseInt()函数，由String字符串转成数字
sub（regexp,replacement[,target]）

最左最长匹配原则进行匹配，sub个gsub的作用相同，分割字符串，并进行替换
substr(string,start[,end])

分割字符串
tolower(string) & toupper(string)

大小写转换

关于awk的就总结到这了。。十分基础的总结。。推荐文档，清晰明了。下一篇打算先整理整理正则表达式。现在哪里都会用到正则，还是很有必要看看正则的。

bash学习记录（五） bash中关于变量的更多的知识

Posted on 2018-05-01 | In Bash

Words count in article: 2.2k | Reading time ≈ 9

字符串操作

字符串长度（String Length）

$(#string) 这里是和C语言中的strlen()是相同的。

expr length $string 同样表示string串的长度。

#! /bin/bash
string=abcdefgHIGKL
#使用第一种方法$(#string)
echo "string的长度是：${#string}"
#使用第二种方法使用expr内建命令 优点简单易懂
echo "string的长度是：`expr length $string`"
`

字符串从开头匹配子字串的长度

方法如下：

stringZ=abcABC123ABCab 
echo `expr match "$stringZ" 'abc[A-Z]*.2'`
echo `expr $stringZ : 'abc[A-Z]*.2'`

匹配到子串的位置 (index)

echo `expr index $stringZ 'abc[A-Z]*.2'`

子字符串的截取
1. ${string:position} 从positon位置截取字符串string。
2. ${string:positong:length} 从positon位置截取字符串string，并且限定截取长度为length。
3. expr substr $string $positon $length 意思同上。
4. expr match $string ‘$substring $’ 这里的substring是正则表达式。
  1
  2
  3
  4
  5
  #截取字符串
  echo ${stringZ:5}
  echo ${stringZ:5:4}
  echo `expr substr $stringZ 5 4`
  echo `expr match $stringZ '$abc[A-Z]*.2$'`
从字符串中移除子字符串
1. ${string#substring} substring是子字符串。并且需要注意的是：该方法表示的是向后移除该子字符串最短匹配到的字符串。
2. ${string##substring} 与上面的正好相反。该方法表示的是向后移除该字符串最长匹配到的字符串。
3. ${string%substring} 该方法表示的是由后向前移除该子字符串最短匹配到的字符串。
4. ${string%%substring} 该方法表示的是由后向前移除该字符串最长匹配到的字符串。
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  echo "移除字符串"
  echo ${stringZ#a*b}
  echo ${stringZ##a*b}
  echo ${stringZ%a*c}
  echo ${stringZ%%a*c}
  #结果：
  #ABC123ABCabc
  #c
  #abcABC123ABC
  #

子字符串替换

${string/substring/replacement} 替换第一个匹配到substring的字符串，替换为replacement。
${string//substring/replacement} 替换所有匹配到的字符。
${string/#substring/replacement} 替换由前向后匹配到的字符。

${string/%substring/replacement} 替换由后向前匹配到的字符。

echo "---------字符串替换---------"
echo ${stringZ/abc/xyz}
echo ${stringZ//abc/xyz}
echo ${stringZ/#abc/xyz}
echo ${stringZ/%abc/xyz}
#结果：
#xyzABC123ABCabc
#xyzABC123ABCxyz
#xyzABC123ABCabc
#abcABC123ABCxyz

使用awk操作字符串

现学先卖，三十分钟学会AWK,快速了解和应用awk。

基于以上，使用awk练习。

工作流分为大致三部分， read->excute->repeat,实现对文本的处理。

程序机构

BEGIN 语法：BEGIN {awk-commands} 是可以省略的部分块，主要作用是声明变量，初始化变量，
BODY块：{commonds}，是必须填写的部分，主要作用是处理文本，会对输入的每一行都执行body块中的命令，并且body是没有关键字的。

-END ：END {commands},同BEGIN，是可以省略的部分

基础语法

awk命令行，可以通过执行awk [-option] files来实现对files文件的处理。如 awk {print} mark.txt 这里就不具体举例了，开头的链接里讲的非常详细，这里只做简单的记录和查看。
使用命令文件方式 awk -f command.awk marks.txt 使用-f参数，可以使用文件中的命令。
awk基本选项：这里不具体总结，linux环境下终端 man awk可以看到非常多的选项。

基本使用示例

基本打印文件内容

$ awk '{print}' mark.txt 
1)  Amit    Physics  80
2)  Rahul   Maths    90
3)  Shyam   Biology  87
4)  Kedar   English  85
5)  Hari    History  89

打印具体项内容

$ awk '{print $1 "\t" $2 }' mark.txt
1)      Amit
2)      Rahul
3)      Shyam
4)      Kedar
5)      Hari

添加限定条件的打印内容

$ awk  '/a/  {print $1 "\t" $2 }' mark.txt
2)      Rahul
3)      Shyam
4)      Kedar
5)      Hari

结果只显示匹配到a的行

打印匹配到的行数

$ awk 'BEGIN{count=0} /a/ { count++} END{print count}' mark.txt
4

打印字符数量超过16的行

$ awk 'length($0) > 18' marks.txt
3) Shyam   Biology   87
4) Kedar   English   85

NOTE:在这里的参数和bash中的参数类似。$0当前行，$1之后表示对应文件的行的列。

内建变量

AWK提供了很多内建变量提供使用，能够起到很大的作用。

标准awk变量

ARGC 命令行参数个数

$ awk 'BEGIN{print "argument=",ARGC}' one two three
argument= 4

ARGV 命令行参数数组如 ARGV[1]=...
CONVFMT 数字的约定格式，默认值是%.6g

ENVIRON 环境变量

$ awk 'BEGIN {print "User is",ENVIRON["USER"]}'
User is nanyin

FILENAME 当前文件的名称

$ awk 'END{print "this file name is", FILENAME}' mark.txt
this file name is mark.txt

FS 分割符默认是空格也可以使用-F设置分割符
NF 当前行的字段数目
1
2
$ awk 'END{print NF}' mark.txt
4
NR 行号
FNR 当前文件的行号
OFS 输出字段分隔符
ORS 输出行分割符

RLENGTH 表示match函数匹配字符床的长度

$ awk 'BEGIN {if(match("One  Three","ree")) {print RLENGTH}}'
3

RSTART 表示match函数第一次匹配到的位置

$ awk 'BEGIN {if(match("One  Three","ree")) {print RSTART}}' 
8

操作符

与C语言的操作符基本相同，如数字的一元二元三元操作等，字符串的链接，数组元素等

正则表达式

AWK对正则的处理非常强大，通常你一个小小的正则表达式能够处理很复杂的问题。关于正则，有时间整理一篇专门关于正则的文章。

数组

AWK支持关联数组，也就是说，不仅可以使用数字索引的数组，还可以使用字符串作为索引。删除数组元素使用delete语句

流程控制

流程控制if while for 与C相同

函数

查手册吧。。一次性看不完。。。。内建函数手册，这里有在这章比较重要的字符串函数。接下来就来看看有哪些函数比较重要。

AWK对字符串操作的函数

整理出awk对字符串的几个具体函数操作。

asort(source,dest,how)
asorti(source,dest,how)

以上两个函数的how先不解释，前两个参数分别为source数组和排序方式，第二个可以不写，默认使用第一位的进行排位。
1
2
3
4
awk 'BEGIN{a[0]="xiaohong";a[1]="aiaolan";asort(a);for(i=2;i>=0;i--) {print a[i]}}'
xiaohong
aiaolan
`
asorti()函数会将顺序替换到数组的value处如：
1
2
3
awk 'BEGIN{a[0]="xiaohong";a[1]="aiaolan";asorti(a);for(i=2;i>=0;i--) {print a[i]}}'
1
0
gensub(regexp,replacement,how[,target]) 类似gsub和sub

替换匹配到的正则regexp为replacement.如果how是g或者G(global的简写),则表示替换所有使用regexp匹配到的字符串,target是目标字符串

如果使用regexp未匹配到，则返回原始target的值
1
2
3
4
5
6
7
8
9
10
11
# 第一个
echo a b c a d | gawk '{print gensub(/a/,"AA",2)}'
a b c AA d
# 第二个
awk '
BEGIN{
a="abc def"
b = gensub(/(.+) (.+)/,"\\2 \\1","g",a)
print b
}'
def abc

gsub(regexp,replacement[,target])

gsub中的‘g’其实是表示的是global,寻找目标的匹配到从左最长的，不重叠的,找到并且替换掉。
1
{ gsub(/Britain/, "United Kingdom"); print }
返回的值为匹配到的次数
index(in,find)

寻找in串内符合find匹配到的字符的index位置
1
2
3
$ awk 'BEGIN{
quote> print index("hello","lo")}'
4
length([string]) 顾名思义，不解释了
1
2
$ awk 'BEGIN{print length("hello")}'
5
NOTE: If no argument is supplied, length() returns the length of $0.
match(string,regexp,[,array])

使用正则匹配字符串，返回匹配到的位置，若未匹配到返回0
split(string,array[,fieldsep[,seps]])

分割string字符串，使用array存放分割后产生的字符组，使用fieldsep组为分割符，seps存放每次分割产生的分割符。一个分割出来的存放到array[1]中，第二个存放到array[2]中，以此类推。如果分割符fieldsep不写，则默认分割符为空格。
1
2
3
4
5
$ awk 'BEGIN{print split("cul-de-sac",a,"-",seps);for(i=1;i<4;i++){print a[i]}}'
3
cul
de
sac
sprintf(format,expression1,..)

是printf的功能，并且能够返回字符串
strtonum (str)

类似java的parseInt()函数，由String字符串转成数字
sub（regexp,replacement[,target]）

最左最长匹配原则进行匹配，sub个gsub的作用相同，分割字符串，并进行替换
substr(string,start[,end])

分割字符串
tolower(string) & toupper(string)

大小写转换

Java设计模式分类和原则

Posted on 2018-04-17 | In 设计模式

Words count in article: 515 | Reading time ≈ 1

Java设计模式分类与原则

每次学习完设计模式，过一阵就忘了，所以写几篇博客记录下，让自己的记忆更深刻一下。

推荐 Java中23种设计模式–超快速入门及举例代码这篇博客。能快速了解设计模式。

推荐github上的项目java-design-patterns 有例子源码，可以通过具体例子了解设计模式。

Java设计模式的基本分类

java的设计模式大体上分为三大类：

创建型模式（5种）：工厂方法模式，抽象工厂模式，单例模式，建造者模式，原型模式。
结构型模式（7种）：适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式。
行为型模式（11种）：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式

设计模式遵循的原则有六个

开闭原则（Open Close Principle）

　对扩展开放，对修改关闭。
里氏代换原则（Liskov Substitution Principle）

只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。
依赖倒转原则（Dependence Inversion Principle）

　　这个是开闭原则的基础，对接口编程，依赖于抽象而不依赖于具体。
接口隔离原则（Interface Segregation Principle）

使用多个隔离的接口来降低耦合度。
迪米特法则（最少知道原则）（Demeter Principle）

一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。
合成复用原则（Composite Reuse Principle）

　原则是尽量使用合成/聚合的方式，而不是使用继承。继承实际上破坏了类的封装性，超类的方法可能会被子类修改。

bash学习记录（四） bash中的操作及相关话题

Posted on 2018-04-12 | In Bash

Words count in article: 352 | Reading time ≈ 1

bash学习记录（四） bash中的操作及相关话题

计算符 Operators

一.赋值（assignment）

变量赋值：初始化变量或者改变变量的值

在所有的赋值操作中，计算赋值和字符串复制都是可以的，并不存在差异。

var=27
category=minerals  
# No spaces allowed after the "=".

二.计算操作符

+，-，*，/,%（取模运算），+=，-=，*=,/=,%=这些操作符和其他语言（比如java）语义相同。唯一有个差异的是 ** 是乘方操作

#一般赋值
i=1
bash="/bin/bash"

#一般操作符
let "z=i+1"
echo $z

let "i+=2"
echo $i

let "z=i**2"
echo $z

需要注意的是bash不能理解浮点数，他会默认把浮点数当作字符串来处理。

需要在脚本中使用 bc来计算浮点数

三.其他操作符

按位操作：

<< : bitwise left shift (multiplies by 2 for each shift position)

>>: bitwise right shift (divides by 2 for each shift position)

&,|，～，^ : 分别对应位与，位或，位否,异或
逻辑操作

！ ：非

&& ： AND

|| ： OR

杂项

， ：逗号操作符，连接多个计算表达式，但是需要注意的是，这样只能返回最后一个算式的值

let "t1 = ((5 + 3, 7 - 1, 15 - 4))"
echo "t1 = $t1"            # t1 = 11
# Here t1 is set to the result of the last operation. Why?

let "t2 = ((a = 9, 15 / 3))"      # Set "a" and calculate "t2".
echo "t2 = $t2    a = $a"         # t2 = 5    a = 9
`

bash学习记录（三） bash中的退出码和测试（Test）

Posted on 2018-04-12 | In Bash

Words count in article: 1.2k | Reading time ≈ 5

bash学习记录（三） bash退出码和测试

1. Bash退出码

脚本的退出命令，类似C语言中的 return value ，可以供脚本的父进程调用。
每条命令返回一条状态状态，命令执行成功返回0，执行失败返回非0状态码可以理解为一个错误码（error code）。
最后的命令返回的状态或者 exit nnn（这里的nnn必须是1～255之间的整数）传递给shell。

exit nnn exit exit $? 或者空。都可以，是bash Return value的方式。

可以使用 ！来反转状态。

2. Bash中的test

每个编程语言都会有对一个情况下测试的功能，Bash也不例外，bash提供test命令，多种的括号操作，最终要的If/else结构语句来实现test功能。

测试结构体(Test Constructs)

一个if/else结构体会测试一系列命令的返回值是否是0也就是命令是否执行成功。如果成功执行另外一系列操作。
bash使用 [ 来进行测试，但是在后来的版本里，bash引进了 [[ 来拓展test命令，bash把[[$a -lt $b]]看作一个元素，他会返回一个状态码（成功0，不成功是非0）
当使用let 和 (()) 的时候，对计算表达式进行运算的时候也会返回exit code，用于对算式的测试

(( 0 && 1 ))                 # Logical AND
echo $?     # 1     ***
# And so ...
let "num = (( 0 && 1 ))"
echo $num   # 0
# But ...
let "num = (( 0 && 1 ))"
echo $?     # 1     ***


(( 200 || 11 ))              # Logical OR
echo $?     # 0     ***
# ...
let "num = (( 200 || 11 ))"
echo $num   # 1
let "num = (( 200 || 11 ))"
echo $?     # 0     ***


(( 200 | 11 ))               # Bitwise OR
echo $?                      # 0     ***
# ...
let "num = (( 200 | 11 ))"
echo $num                    # 203
let "num = (( 200 | 11 ))"
echo $?                      # 0     ***

# The "let" construct returns the same exit status
#+ as the double-parentheses arithmetic expansion.

if可以测试任何条件不仅仅是包在括号里面的条件。

Else if and elif

elif相当与 else if，要请求分支需要用到elif

if [ condition1 ]
then
command1
command2
command3
elif [ condition2 ]
# Same as else if
then
command4
command5
else
default-command
fi

Equivalence of test, /usr/bin/test,[ ], and /usr/bin/[ 使用这几个做判断都是一样的。更复杂的表达式要使用[[]]来代替[]。

Using the [[ … ]] test construct, rather than [ … ] can prevent many logic errors in scripts. 这是Advanced Bash-Scripting Guide给出的建议。

文件测试操作（File）

-e 文件是否存在
-a 文件是否存在（以弃用）
-f 是否是普通文件(不是目录文件或者设备文件)
-s 是否是空文件
-d 是否是目录
-b 是否是块设备(block device)
-c 是否是字符设备(character device)
-h 是否是链接文件(symbolic link)
-S file is socket
-r -w -x 分别对应文件的读写执行权限
-O 是否是文件的拥有者
-G group-id是否和你自己的相同
-N 在最后一次被读之后文件已经更改
f1 -nt f2 f1比f2新
-ot f1比f2旧
-ef f1和f2 引用同一个文件

例子

for directory in $directorys; do
    if [ -d $directory ]
    then linkchk $directory
    else 
        echo "$directory is not a directory"
        echo "Usage: $0 dir1 dir2 ..."
    fi
done

其他比较操作（Integer，String）

整型和字符串类型使用两组不同的操作

整形

-eq 相等比较 if [ "$a" -eq "$b" ]
-ne 比较不相等 if [ "$a" -ne "$b" ]
-gt 大于等于(is greater than or equal to) if [ "$a" -ge "$b" ]
-lt 小于(is less than) if [ "$a" -lt "$b" ]
-le 小于等于(is less than or equal to) `if [ “$a” -le “$b” ]
< > <= >= 对应大于，小于，小于等于，大于等于这些相应的操作

String类型

= 判断字符串是否相等
== 和 = 相同，同样是判断字符串是否相同但 == 在 [] 和 [[]] 中定义不同，下面举例：

[[ $a == z* ]]   # True if $a starts with an "z" (pattern matching).
[[ $a == "z*" ]] # True if $a is equal to z* (literal matching).

[ $a == z* ]     # File globbing and word splitting take place.
[ "$a" == "z*" ] # True if $a is equal to z* (literal matching).

!= 不等于
< and > 大于小于按照ASCII 码比较
-z 空字符串,因此，字符串长度为0
-n 字符串不为空

逻辑比较

-a 表示逻辑与
-o 表示逻辑或

-a -o 要使用在单个中括号中if [ "$expr1" -a "$expr2" ]

&& and || 但是要在双中括号中使用[[ condition1 && condition2 ]]

嵌套 `if else`

如其他编程语言类似,if else结构能够嵌套，但是嵌套结构和使用 && 比较符结果相同

a=3

if [ "$a" -gt 0 ]
then
  if [ "$a" -lt 5 ]
  then
    echo "The value of \"a\" lies somewhere between 0 and 5."
  fi
fi

# Same result as:

if [ "$a" -gt 0 ] && [ "$a" -lt 5 ]
then
  echo "The value of \"a\" lies somewhere between 0 and 5."
fi

bash学习记录（二） bash中的变量和参数

Posted on 2018-04-11 | In Bash

Words count in article: 683 | Reading time ≈ 2

bash学习记录（二） bash中的变量和参数

变量就是一个标签在脚本中代表数据，不过是给分配在电脑内存中的数据一个名字，经常会出现在数学计算和大量操作(manipulation of quantities)和字符串解析(string parsing)中。

变量置换 (Variable Substitution) $

The name of a variable is a placeholder for its value, the data it holds. Referencing (retrieving) its value is called variable substitution. 大致意思就是变量引用具体的值。使用$来引用变量如

bash$ variable1=23

bash$ echo variable1
//variable1

bash$ echo $variable1
//23

在(“..”)里引用不会干涉变量的引用，这叫做局部引用(partial quoting),也叫弱引用.但使用(‘..’)单引号会直接把变量名打印出来，不会引用变量，叫做全引用(full quoting),也叫做强引用。

注意：其实使用$variable1和使用${variable1}是一样的但是某些语境下前者可能会出问题。

未初始化的变量有一个默认的的值为”null“而不是‘0’，并且bash中的变量不分类型。

变量分配(Variable Assignment) =

等号-> the assignment operator (no space before and after) 前后不能有空格

#举一个比较典型的小例子，之前不知道区别。。
a=`ls -l`         # Assigns result of 'ls -l' command to 'a'
echo $a           # Unquoted, however, it removes tabs and newlines.
echo
echo "$a"         # The quoted variable preserves whitespace.

使用双引号扩起来的$a有空格，而没有双引号的是去掉空格的。

R=$(cat /etc/redhat-release)
arch=$(uname -m)

可以看出使用$()的作用和使用``的作用相同，都可以对命令进行包裹。

bash变量没有类型

不像其他的很多编程语言，bash脚本中的变量是没有类型的。无类型的变量是把双刃剑，一方面更加灵活，另一方面会渗透一些小的问题。

所以bash提供声明变量，会在后面的章节对声明变量的参数等信息详细列出来。

特殊的变量类型(Special Variable Types)

本地变量：变量只能在代码块和函数中可见
系统变量：变量影响shell的行为和用户的接口（比如设置Java环境变量）

如果脚本需要设置环境变量那么就去 export ..
位置参数：

$0是脚本名称，1-9等对应其位置，10之后要使用大括号扩起来。$#对应最后一个元素

使用shift命令可以将位置参数重新排列，实际上就是向左移动一级。

这次篇幅较小，主要讲了讲bash中的变量和位置参数的含义和使用，属于非常基础，非常容易理解的部分。

bash学习记录（一）初识和bash中的特殊字符

Posted on 2018-04-10 | In Bash

Words count in article: 1.1k | Reading time ≈ 4

bash学习记录（一）初识bash和特殊字符

初识Bash

鉴于本人的表达能力，不适合想要去系统学习bash的人来查看，提前分享两个不同阶段，不同人群学习的资料。

想要学习bash但是不想学习太深的人: bash-handbook
想要系统学习bash的人：Advanced Bash-Scripting Guide

其实bash很难，要考虑的东西很多，但现在学到的只是皮毛，希望能够多看多实践，才能更进一步。

Starting Off With a Sha-Bang

sha-bang(#!)在起始的位置来告诉你的系统这个文件是命令的集合，能够使用哪个命令解释器来执行（/bin/bash）->path,这个命令路径必须正确

如果系统默认解释器是/bin/bash 或者其他则不用使用 #! /bin/bash 来放到开头

Special Characters

下面来简单总结一下有特殊意义的字符

‘#‘ 跟在#号后面的相当与是注释，不会被解释器执行,可以出现单行，也可以出现在命令后作注释用
; 分号 允许将多条命令放到单行用

;; 两个分号，在case的场景下使用如

case "$variable" in

abc)  echo "\$variable = abc" ;;

xyz)  echo "\$variable = xyz" ;;

esac

. dot

相当与linux的内建命令source

作为文件名的一部分如 .vimrc等

作为目录导向如 ./表示当前目录 ../相当与父目录

正则表达式中可以表示为1个字符
“ 双引号 部分引用字符串，大部分还是字符串，但是能够引用变量 ‘$value’，并且特殊字符需要转义
‘ 单引号 可以保存全部特殊字符，不能引用变量
, 逗号 表示连接多个计算表达式,多个表达式都会执行，但是只有最后一个计算式会返回值。也做链接字符串
1
2
let "t2 = ((a = 9, 15 / 3))"
# Set "a = 9" and "t2 = 15 / 3"
\ 反斜杠 escape [backslash] 可是实现对单个字符的转义
/ 斜杠 Filename path separator [forward slash]本身就叫做文件分割符可以明了做什么用的了
` command substitution 命令替换如 a=`echo “hello world” `;echo $a 等或者 a=`date` ; echo $a
: 冒号 空命令等价与‘NOP’ do-nothing operation 也是有状态的相当与内建函数 true 比如
1
2
3
4
5
6
7
8
9
10
11
12
13
while :
do
operation-1
operation-2
...
operation-n
done

# Same as:
# while true
# do
# ...
# done
作if判断的分支
1
2
3
4
5
if condition
then : # Do nothing and branch ahead
else # Or else ...
take-some-action
fi
放在必须要有两元操作的地方作为分隔符，如：: ${username=`whoami`}

配合管道命令 :> :>>如果文件没有存在则创建

做分割符如 echo $PATH 会出现很多以：作为分割符的字符串

在函数里可以作为站位符防止函数提为空
!叹号 作为 非出现如！null 或者退出码 exit code。在不同的语境下可以作为间接变量引用。
* 星号可以作为全匹配来使用如 echo * 。表示乘法 1*2
? 问号 test operator. Within certain expressions, the ? indicates a test for a condition. 还可以作为匹配任意单个字符。
$ 变量引用正则表达式中表示行尾
${} 变量引用
$(…) 多个变量同时引用
1
2
3
file1="file"
file2="nofile"
echo $'file1,file2'
输出内容：file1,file2
$* $@ 位置参数 $*是将所有参数作为一个整体返回（字符串），而$@是将每个参数作为单元返回一个参数列表
() 小括号

操作组(a=hello; echo $a)
数组初始化

{} 花括号扩展 用来扩展参数如 abou{t,y,u}
[] 中括号

shell内建测试的一部分
表达数组的部分如array[1]
表示字符集的范围，在正表达式中，方括号表示该位置可以匹配的字符集范围。

[[]] 双中括号(double brackets)。

这个结构也是测试，测试[[]]之中的表达式(Shell的关键字)。这个比单中括号更能防止脚本里面的逻辑错误
$[ … ] and (()) 都表示Integer计算 integer expansion.

a=3
b=7
echo $[$a+$b]
echo (($a+$b))

| 管道 非常基础的概念如 ls|grep .. 。
&：后台执行 && 和 || ：逻辑操作符
+ - * % 各自意义就不详细解释了

资料引用 Advanced Bash-Scripting Guide 文章特别详尽，有兴趣非常鼓励看原文。这里我只做了部分比较常用的比较容易理解的部分做了精简（原谅我英文不好 :) 破产版总结 - - ）。

作为bash学习总结的第一篇文章，篇幅不大，尽量做到简单，详尽易懂。当遇到问题能够回头看一看，希望能够起到好的作用！！

循环和分支(二)

多重循环

循环控制

测试和分支

通过程序块控制程序流向

Case (in) /esac

select

循环和分支

循环

for循环

while循环

until循环

正则表达式

特殊字符

字符匹配

分组的匹配

贪婪模式

关于 的后续

字符串操作

使用awk操作字符串

程序机构

基础语法

基本使用示例

内建变量

标准awk变量

操作符

正则表达式

数组

流程控制

函数

AWK对字符串操作的函数

字符串操作

使用awk操作字符串

程序机构

基础语法

基本使用示例

内建变量

标准awk变量

操作符

正则表达式

数组

流程控制

函数

AWK对字符串操作的函数

Java设计模式分类与原则

Java设计模式的基本分类

设计模式遵循的原则有六个

bash学习记录（四） bash中的操作及相关话题

计算符 Operators

一.赋值（assignment）

二.计算操作符

三.其他操作符

bash学习记录（三） bash退出码和测试

1. Bash退出码

2. Bash中的test

测试结构体(Test Constructs)

文件测试操作（File）

其他比较操作（Integer，String）

整形

String类型

逻辑比较

嵌套 if else

bash学习记录（二） bash中的变量和参数

变量置换 (Variable Substitution) $

变量分配(Variable Assignment) =

bash变量没有类型

特殊的变量类型(Special Variable Types)

这次篇幅较小，主要讲了讲bash中的变量和位置参数的含义和使用，属于非常基础，非常容易理解的部分。

bash学习记录（一）初识bash和特殊字符

初识Bash

Starting Off With a Sha-Bang

Special Characters

关于的后续

嵌套 `if else`