shell学习笔记

一 :编写Linux 脚本

shell脚本基本构成

开头 ：
程序必须以下面的行开始（必须方在文件的第一行）：

#!/bin/sh

符号#!用来告诉系统它后面的参数是用来执行该文件的程序。在这个例子中我们使用/bin/sh来执行程序。（可以运行echo $SHELL来看你的系统是使用那一类shell， 比如ubuntu使用的是/bin/bash，则第一行写成#!/bin/bash）

当编辑好脚本时，如果要执行该脚本，还必须使其可执行。 要使脚本可执行：

编译 chmod +x filename 这样才能用./filename 来运行

#!/bin/sh
echo -n "时间"
date
echo -n "路径"  $path
echo  "当前用户名：` whoami` "
echo -n "当前目录"
pwd
#end 

-n 不自动换行
# 注释（执行的时候忽略）
`` 命令执行

1.2 包含外部脚本

test.sh脚本如下

#!/bin/bash
name="This is test1"

引入外部脚本的四种方式
第一种

. test.sh

第二种

source test.sh

#第三种

. ./test.sh

#第四种

source ./test.sh

test2.sh脚本，导入外部脚本test.sh

#!/bin/bash
source ./test.sh
echo "output: $name"

运行一下：

 bash test2

效果：

执行shell脚本

方法1 在命令提示符下执行
eg：

chmod ugo+x 1.sh 

./1

方法2 在指定shell下执行
shell 名称 脚本名 【参数】
eg：

sh 1

调试shell脚本

利用bash 命令解释程序的选项实现：
-v 和 - x 来 追踪程序
-v 选项 允许用户查看shell 的 读入和执行。发生错误则终止执行，读取之后 按照 读入时候的形式 给显示出来。
eg : 2.sh

#!/bin/sh
echo -n "当前时间："
date
#end

bash -x 2

bash -v 2

-v	-x
打印命令行原始内容	打印出的是经过替换后的内容
先读取命令，按照读取的命令显示，然后执行	命令先执行，替换之后才显示每一个被替换后的命令，且在行前加前缀 符号 +

原始内容

echo -n "当前时间："

的“ ” 用 -x 打印的话 被替换了，-v则正常显示

-v 经过了 读取 显示读取 替换 显示替换 执行 这四步，
-x 则读取完先执行之后，才显示替换的内容，没有显示读取的内容。比如 在下面， -x的话 shell脚本的开头和结尾都没有显示，只显示执行的过程，不显示读取的过程。

二 shell变量

变量类型

和PHP一样是弱类型语言不需要制定类型。
分为

• 用户变量(全局变量、局部变量)

编写时定义，可以任意使用和修改，仅在当前shell生效
其他shell不能访问

• 环境变量
  不必定义，所有shell 都可以访问。

• 内部变量
  linux提供的特殊变量类型，用于在程序中做判断。在shell内无法被修改。
  稍作举例，课本 171页右下角有。
  eg：

  1 $#

  说明：$#变量是命令行参数或位置参数的数量
  

  2 $*

    说明：$* 变量的值表示所有的位置参数，其值是所有位置参数的值。
  

  3 @

    说明：$@ 变量的值类似于$*，表示所有的位置参数，其值也是所有位置参数的值。
  

举例：
3.sh
下面的$*是位置参数（表示运行脚本时候传递给脚本的参数）

#! /bin/sh
a=5      #全局变量
 
func(){
	echo "the number of func is :$#" 
	echo "the member of func is :$*" 
	local a=6   #局部变量
	echo "the number of local var:a=$a"
}
 
func 12 34 56     #函数传参属于内部变量

echo "the number of script is :$#"           #脚本参数属于内部变量
echo "the member of script is :$*"
#end

运行一下
bash 3

变量的赋值和访问：

定义变量
shell在定义变量的时候，变量名与变量之间不能存在空格，这个大多数的语言的这个不同还是蛮大的，不过定义的规则就其他的语言定义的规则大致相同了。

使用变量
使用一个已经定义过的变量，只需要在变量的名字前加$，例如下面的例子。
4.sh

#!/bin/bash
line="Hello world"
echo $line

运行：

bash 4

结果：

只读变量 readonly
在变量的前面 添加readonly把变量定义为一个只能读取的变量，无法进行修改。
eg : 5.sh

#!/bin/bash
name='leeguo'
readonly name
name='idealcitier'
echo ${name}

运行：
bash 5
结果：

删除变量unset
使用unset定义一个变量，变量的内容就被删除了。
eg ： 6.sh

#!/bin/bash
name='idealcitier'
unset name
echo ${name}

运行：

bash 6

结果：

在运行之后，是没有输出的。

全局变量（环境变量）

定义环境变量
用户也可以根据自己的需要定义自己的环境变量（全局变量），定义环境变量的方法：

export  variable_name（变量名）=value（变量值）

variable_name=value
export  variable_name

举个例子：
定义

export NAME=aaaaaaaaaa

显示：

 env | grep NAME

可以看出，定义的环境变量，成功了。

对环境变量进行操作
可以使用echo对环境变量进行显示。

 env

这种方法只对 当前的shell 和子shell下面有效，shell关闭之后失效。
要永久生效的话。编辑文件/etc/profile.
删除环境变量：

unset NAME

eg：

env | grep NAME

可以看到，运行之后不存在了。

变量的输出：
echo 语句
eg：7.sh

#!/bin/bash
#字符串拼接
name="b"
echo "心里没点${name}数"
#原样输出用' 转义，比如想输出 $name\" 这个字符串
echo '$name\"'
echo $name\"
#在双引号中显示特殊符号的话，需要用\转义 比如想输出$#字符
echo "$name \$#"
echo "$name $#"

运行：

 bash 7

pritf输出和C语言一样，体验一下：
eg ：8.sh

#!/bin/bash
# author:菜鸟教程
# url:www.runoob.com
 
printf "%-10s %-8s %-4s\n" 姓名 性别 体重kg  
printf "%-10s %-8s %-4.2f\n" 郭靖 男 66.1234 
printf "%-10s %-8s %-4.2f\n" 杨过 男 48.6543 
printf "%-10s %-8s %-4.2f\n" 郭芙 女 47.9876
执行脚本，输出结果如下所示：

运行：

bash 8

变量读取和替换：

read命令
接收标准输入（键盘）的输入。
得到输入后，read命令将数据放入一个标准变量中。
类似C语言的 scanf。
eg：9.sh

#!/bin/bash
echo -n "Enter your name:"   #参数-n的作用是不换行，echo默认是换行
read  name                   #从键盘输入
echo "hello $name,welcome "     #显示信息

运行：

bash 9

变量替换

形式	说明
${var}	变量本来的值
${var:-word}	如果变量 var 为空或已被删除(unset)，那么返回 word，但不改变 var 的值。
${var:=word}	如果变量 var 为空或已被删除(unset)，那么返回 word，并将 var 的值设置为 word。
${var:?message}	如果变量 var 为空或已被删除(unset)，那么将消息 message 送到标准错误输出，可以用来检测变量 var 是否可以被正常赋值。若此替换出现在Shell脚本中，那么脚本将停止运行。
${var:+word}	如果变量 var 被定义，那么返回 word，但不改变 var 的值。

eg ： 10.sh

#!/bin/bash
#如果变量 var 为空或已被删除(unset)，那么返回 word，但不改变 var 的值。
echo ${var:-"word"}
echo "1 var的值是 ${var}"
echo $var
echo ----------------------------------
#如果变量 var 为空或已被删除(unset)，那么返回 word，并将 var 的值设置为 word。
echo ${var:="word"}
echo "2 - var的值是 ${var}"

echo ----------------------------------


#如果变量 var 被定义，那么返回 word，但不改变 var 的值
var="var经过定义的值aaa"
echo ${var:+"word"}
echo "3 - var的值是 $var"

echo ----------------------------------
#如果变量 var 为空或已被删除(unset)，那么将消息 message 送到标准错误输出，可以用来检测变量 var 是否可以被正常赋值。

echo ${var:?"message"}
echo "4- var的值是 ${var}"

运行：

bash 10

结果：

shell数组

定义
三种方法：
eg：11.sh

#!bin/sh

# 可以这样定义
array=( one two three )
echo ${array[@]}

# 也可以这样定义
array=(
    one
    two
    three
)
echo ${array[@]}

# 还可以这样定义
array[0]=one
array[1]=two
array[2]=three
echo ${array[@]}

运行：

bash 11

结果：

shell表达式和运算符

表达式分为逻辑表达式和算数表达式

逻辑表达式

eg：

 test "1" == "1" && echo true || echo false

 test "1" == "2" && echo true || echo false

算数表达式：

bash自身不支持，可以通过expr和let命令实现
数字和 运算符之间要加空格，否则会当成字符串输出。

 expr 5+3

expr 5 + 3

其他方式：

echo $[5+3]

let VAR=(1+2)*3 ; echo $VAR
9

算数运算符
加减乘除没什么好说的

eg ： 12.sh

#!/bin/bash

#created by yuki on 20180723
#this script is used for doing ......

a=10
b=20

result=`expr $a + $b`
echo "a + b = $result"

result=`expr $a - $b`
echo "a - b = $result"

result=`expr $a \* $b`
echo "a * b = $result"

result=`expr $b / $a`
echo " b / a = $result"

result=`expr $b % $a`
echo "b % a = $result"

bash 12

整数关系运算符：

eg：13.sh

#!/bin/bash
a=5
b=10

if [ $a -eq $b ]
then
	echo "eq 关系运算结果: a等于b"
else
	echo "eq 关系运算结果: a不等于b"
fi


if [ $a -ne $b ]
then 
	echo "ne 关系运算结果: a不等于b"
else
	echo "ne 关系运算结果: a等于b"
fi


if [ $a -gt $b ]
then
	echo "gt 关系运算结果: a大于b"
else
	echo "gt 关系运算结果: a小于等于b"
fi


if [ $a -lt $b ]
then
	echo "lt 关系运算结果：a小于b"
else
	echo "lt 关系运算结果：a大于等于b"
fi


if [ $a -ge $b ]
then
	echo "ge 关系运算结果：a大于等于b"
else
	echo "ge 关系运算结果：a小于b"
fi


if [ $a -le $b ]
then
	echo "le 关系运算结果：a小于等于b"
else 
	echo "le 关系运算结果：a大于b"
fi

字符串运算符

eg： 14.sh

#!/bin/bash

#created by yuki on 20180723
#this script is used for doing ......

a="cfe"
b="efr"

if [ "$a" = "$b" ]
then 
	echo "字符串a和字符串b相等"
else
	echo "字符串a和字符串b不相等"
fi



if [ "$a" != "$b" ]
then
	echo "字符串a和字符串b不相等"
else
	echo "字符串a和字符串b相等"
fi

if [ -z "$a" ]
then
	echo "字符串a的长度为0,即字符串a为空？"
else
	echo "字符串a的长度不为0"
fi 

if [ -n "$a" ]
then
	echo "字符串a的长度不为0"
else
	echo "字符串a的长度为0,即字符串a为空？"
fi

if [ "$a" ]
then
	echo "字符串a不为空"
else
	echo "字符串不为空"
fi

运行

bash 14

结果：

文件测试运算符

eg 15.sh （去检测 test.sh的属性）

#!/bin/bash
file="/root/shell/test.sh"
if [ -e $file ]
then
	echo "这个已经存在"
else
	echo "这个不存在"
fi


if [ -r $file ]
then
	echo "当前用户可读此文件"
else
	echo "当前用户没有读此文件的权限"
fi

if [ -w $file ]
then
	echo "当前用户可写此文件"
else 
	echo "当前用户没有写此文件的权限"
fi

if [ -x $file ]
then
	echo "当前用户可以执行此文件"
else
	echo "当前用户没有执行此文件的权限"
fi

if [ -d $file ]
then
	echo "这个是目录"
else	
	echo "这个不是目录"
fi

if [ -f $file ]
then
	echo "这个是普通文件"
else
	echo "这个不是普通文件"
fi

if [ -s $file ]
then
	echo "此文件大小不为0"
else
	echo "此文件大小为0,即文件内容为空"
fi

运行

bash 15

逻辑运算符：

eg：16.sh
提示：（lt：< ，gt： >）

#!/bin/bash
a=5
b=10
echo a=5，b=10
if [ $a != $b ]
then
	echo "!= 逻辑非运算结果：a不等于b"
else 
	echo "!=逻辑非运算结果： a等于b"
fi

if [ $a -lt 50 -a  $b -gt 8 ]
then
	echo "and 逻辑与运算结果：真"
else
	echo "and 逻辑与运算结果：假"
fi


if [ $a -lt 50 -o $b -gt 12 ]
then
	echo "or 逻辑或运算结果：真"
else
	echo "or 逻辑或运算结果：假"
fi

if [ $a -lt 3 -o $b -gt 8 ]
then
	echo "or 逻辑或运算结果：真"
else
	echo "or 逻辑或运算结果：假"
fi

运行:

bash 16

结果：

流程控制语句：

条件语句

if else fi
上面的例子，和其他语言的不同在于 结尾处要以fi闭合。
if elif
eg ：17.sh

read -p '请输入分数:' score
if [ $score -lt 60 ]; then
    echo '60分以下'    
elif  [ $score -lt 70 ]; then
    echo '60-70分之间'    
elif  [ $score -lt 80 ]; then
    echo '70-80分之间'
elif [ $score -lt 90 ];    then
    echo '80-90分之间'
else 
    echo '90分以上'
fi

运行：

bash 17

结果：

case语句：

和其他高级语言类似，每个分支多了个分号
结尾要用 esac
语法结构 ：

case  $变量名   in
"值1"

         如果变量的值等于值1，则执行程序1

        ；；

"值2"

          如果变量的值等于2，则执行程序2

           ；；

   ……省略其他分支……

  *

          如果变量的值都不是以上的值，则执行此程序

           ；；
           esac

eg：18.sh

#!/bin/bash
echo "郑爽 : 1"

echo "刘诗诗 : 2"

echo "赵丽颖 : 3"

read  -t  30  -p "请输入你的选择:" cho
case "$cho" in
      "1")

                   echo "郑爽"

                   ;;
      "2")

                   echo "刘诗诗"

                  ;;
       "3")

                  echo "赵丽颖"

                  ;;
           *)

                      echo "请输入正确选择"

                      ;;
esac

运行：

bash 18

结果：

循环语句

while循环：
语法：

while condition
do
    command
done

下面的循环是num 为五，当num大于-5时，打印并自减一。
eg：19.sh

num=5
while [ $num -gt -5 ]; do
    if [ $(($num%2)) -eq 0 ];then
        echo -e "\033[31m${num}\033[0m"            #红色字体
    else
        echo $num
    fi
    num=$(($num-1))
    sleep 1                                 #休眠一秒钟
done                                        #跳出循环后的输出
    echo $num

运行：

bash 19

until 循环
until 语法格式:

until condition
do
    command
done

eg：20.sh
i = 6， 满足i<11 就打印i 然后i 自增。

var_i_five=6
until [ ! $var_i_five -lt 11 ]
do
    echo "i_five:$var_i_five"
    var_i_five=`expr $var_i_five + 1`
done
echo '---------------------------------------------------'

运行：

bash 20

结果：

for循环：
for循环一般格式为：

for var in item1 item2 ... itemN
do
    command1
    command2
    ...
    commandN
done

eg：21.sh
顺序输出当前列表中的数字：

for loop in 1 2 3 4 5
do
    echo "The value is: $loop"
done

运行：

bash 21

结果：

跳出循环
在循环过程中，有时候需要在未达到循环结束条件时强制跳出循环，Shell使用两个命令来实现该功能：break和continue。

1.break命令
break命令允许跳出所有循环（终止执行后面的所有循环）。

2.continue
continue命令与break命令类似，只有一点差别，它不会跳出所有循环，仅仅跳出当前循环。
eg：22.sh
下面的例子中，脚本进入死循环直至用户输入数字大于5。要跳出这个循环，返回到shell提示符下，需要使用break命令。

#!/bin/bash
while :
do
    echo -n "输入 1 到 5 之间的数字:"
    read aNum
    case $aNum in
        1|2|3|4|5) echo "你输入的数字为 $aNum!"
        ;;
        *) echo "你输入的数字不是 1 到 5 之间的! 游戏结束"
            break
        ;;
    esac
done

运行：

bash 22

结果：

函数

函数的定义和调用：

定义有两种方法：
方法1：
函数名() {
函数体
return n
}

方法2：
function 函数名() {
函数体
return n
}
调用函数：

#!/bin/bash
function fun1() {
    echo "hello word "
}
fun1      ##调用函数

运行：

bash 23

函数的返回值：

在Shell中，return语句只能返回某个0-255之间的整数值,如果超出这个范围就会返回错误的结果。
如果一定要返回任意值，有下面三种方法：
方法一：使用全局变量
通过一个全局变量myresult，来保存返回值。
在 函数外echo，

#方法一
function myfunc() 
{ 
    myresult='方法一' 
} 
myfunc 
echo $myresult 

方法二：使用标准输出
将一个shell函数作为一个子程序调用，将返回值写到子程序的标准输出，来达到返回任意字符串的目的。
在函数里面echo

#方法二：
function myfunc() 
{ 
    local  myresult='方法二' 
    echo "$myresult" 
} 
  
result=$(myfunc)   
echo $result  

方法一和方法二 在 24.sh
运行：

bash 24

方法三：使用return
使用 $?这个特殊的内部变量，可以获取上一个命令执行的结果

#!/bin/bash
fun(){
ret=`expr $1 + $2`
return ${ret}

}
fun 3  6 
  ret=$?
echo $ret

运行：

bash  25

函数参数

上个例子中，$1 ,$2分别代表第一个和第二个参数。
fun 3 6
表示 第一个参数是3，第二个参数是六。