shell 在线编辑器：https://www.runoob.com/try/runcode.php?filename=helloworld&type=bash

一下脚本自行测试查看结果

echo "Hello World !"

your_name="qinjx"
echo your_name

for skill in Ada Coffe Action Java; do
    echo "I am good at ${skill}Script"
done

your_name="tom"
echo $your_name
your_name="alibaba"
echo $your_name

myUrl="https://www.google.com"
echo ${myUrl}
readonly myUrl
# 设置只读以后，不可以重新定义变量，会报错
# myUrl="https://www.runoob.com"

# 删除变量
myUrl2="https://www.runoob.com"
echo $myUrl2
unset myUrl2
echo $myUrl2

# 字符串,'' 和 "" 
your_name='runoob'
str="Hello, I know you are $your_name! \n"
echo -e $str
str2='Hello, I know you are $your_name! \n'
echo -e $str2

# 获取字符串长度
string="abcd"
echo ${#string} #输出 4

# 提取子字符串,  第一个字符的索引值为 0
string="runoob is a great site"
echo ${string:1:4} # 输出 unoo

# 查找子字符串, 查找字符 i 或 o 的位置(结果是第几个，不是索引值)
string="runoob is a great site"
echo `expr index "$string" io`  # 输出 4


# Shell 数组
array_name=(value0 value1 value2 value3)
# 或者
array_name=(
	value0
	value1
	value2
	value3
)
# 还可以单独定义数组的各个分量，可以不使用连续的下标，而且下标的范围没有限制
array_name[0]=value0
array_name[1]=value1
array_name[2]=valuen

# 读取数组，@ 符号可以获取数组中的所有元素
echo ${array_name[2]}
echo ${array_name[@]}

# 获取数组的长度
# 取得数组元素的个数
echo length=${#array_name[@]}
# 或者
echo ${#array_name[*]}

# 取得数组单个元素的长度
lengthn=${#array_name[0]}
echo ${lengthn}

:<<EOF
	注释内容...
	注释内容...
	注释内容...	
EOF

传递参数

编辑一个test.sh 文件

	echo "Shell 传递参数实例！";
	echo "执行的文件名：$0";
	echo "第一个参数为：$1";
	echo "第二个参数为：$2";
	echo "第三个参数为：$3";
	echo "参数个数为：$#";
	echo "传递的参数作为一个字符串显示：$*";

执行：

$ chmod +x test.sh	# 脚本设置可执行权限
$ ./test.sh 1 2 3	# 执行

打印：
Shell 传递参数实例！
执行的文件名：./test.sh
第一个参数为：1
第二个参数为：2
第三个参数为：3
参数个数为：3
传递的参数作为一个字符串显示：1 2 3

特殊字符用来处理参数:

$* 与 $@ 区别：

相同点：都是引用所有参数。
不同点：只有在双引号中体现出来。假设在脚本运行时写了三个参数 1、2、3，，则 " * " 等价于 "1 2 3"（传递了一个参数），而 "@" 等价于 "1" "2" "3"（传递了三个参数）。

for i in "$*"; do
    echo $i
done

for i in "$@"; do
    echo $i
done

执行这个脚本结果：
1 2 3

1
2
3

基本运算符

val=`expr 2 + 2`
echo "两数之和为 : $val"

结果：两数之和为 : 4
注意：
表达式和运算符之间要有空格，例如 2+2 是不对的，必须写成 2 + 2，这与我们熟悉的大多数编程语言不一样。
完整的表达式要被 两个 `` 包含，注意这个字符不是常用的单引号，在 Esc 键下边。

算术运算符

假定变量 a 为 10，变量 b 为 20：

注意：条件表达式要放在方括号之间，并且要有空格，例如: [$a==$b] 是错误的，必须写成 [ $a == $b ]。

实例：

a=10
b=20

val=`expr $a + $b`
echo "a + b : $val"

val=`expr $a - $b`
echo "a - b : $val"

val=`expr $a \* $b`
echo "a * b : $val"

val=`expr $b / $a`
echo "b / a : $val"

val=`expr $b % $a`
echo "b % a : $val"

if [ $a == $b ]
then
   echo "a 等于 b"
fi
if [ $a != $b ]
then
   echo "a 不等于 b"
fi

实例结果：
a + b : 30
a - b : -10
a * b : 200
b / a : 2
b % a : 0
a 不等于 b

注意：

• 乘号(*)前边必须加反斜杠()才能实现乘法运算；
• 在 MAC 中 shell 的 expr 语法是：$((表达式))，此处表达式中的 "*" 不需要转义符号 "" 。

关系运算符

关系运算符只支持数字,假定变量 a 为 10，变量 b 为 20：

实例:

a=10
b=20

if [ $a -eq $b ]
then
   echo "$a -eq $b : a 等于 b"
else
   echo "$a -eq $b: a 不等于 b"
fi
# 10 -eq 20: a 不等于 b
if [ $a -ne $b ]
then
   echo "$a -ne $b: a 不等于 b"
else
   echo "$a -ne $b : a 等于 b"
fi
# 10 -ne 20: a 不等于 b
if [ $a -gt $b ]
then
   echo "$a -gt $b: a 大于 b"
else
   echo "$a -gt $b: a 不大于 b"
fi
# 10 -gt 20: a 不大于 b
if [ $a -lt $b ]
then
   echo "$a -lt $b: a 小于 b"
else
   echo "$a -lt $b: a 不小于 b"
fi
# 10 -lt 20: a 小于 b
if [ $a -ge $b ]
then
   echo "$a -ge $b: a 大于或等于 b"
else
   echo "$a -ge $b: a 小于 b"
fi
# 10 -ge 20: a 小于 b
if [ $a -le $b ]
then
   echo "$a -le $b: a 小于或等于 b"
else
   echo "$a -le $b: a 大于 b"
fi
# 10 -le 20: a 小于或等于 b

布尔运算符

假定变量 a 为 10，变量 b 为 20：

实例：

a=10
b=20

if [ $a != $b ]
then
   echo "$a != $b : a 不等于 b"
else
   echo "$a == $b: a 等于 b"
fi
if [ $a -lt 100 -a $b -gt 15 ]
then
   echo "$a 小于 100 且 $b 大于 15 : 返回 true"
else
   echo "$a 小于 100 且 $b 大于 15 : 返回 false"
fi
if [ $a -lt 100 -o $b -gt 100 ]
then
   echo "$a 小于 100 或 $b 大于 100 : 返回 true"
else
   echo "$a 小于 100 或 $b 大于 100 : 返回 false"
fi
if [ $a -lt 5 -o $b -gt 100 ]
then
   echo "$a 小于 5 或 $b 大于 100 : 返回 true"
else
   echo "$a 小于 5 或 $b 大于 100 : 返回 false"
fi

结果：
10 != 20 : a 不等于 b
10 小于 100 且 20 大于 15 : 返回 true
10 小于 100 或 20 大于 100 : 返回 true
10 小于 5 或 20 大于 100 : 返回 false

逻辑运算符

假定变量 a 为 10，变量 b 为 20:

实例：

a=10
b=20

if [[ $a -lt 100 && $b -gt 100 ]]
then
   echo "返回 true"
else
   echo "返回 false"
fi

if [[ $a -lt 100 || $b -gt 100 ]]
then
   echo "返回 true"
else
   echo "返回 false"
fi

结果：
返回 false
返回 true

字符串运算符

假定变量 a 为 "abc"，变量 b 为 "efg"：

实例：

a="abc"
b="efg"

if [ $a = $b ]
then
   echo "$a = $b : a 等于 b"
else
   echo "$a = $b: a 不等于 b"
fi
# abc = efg: a 不等于 b
if [ $a != $b ]
then
   echo "$a != $b : a 不等于 b"
else
   echo "$a != $b: a 等于 b"
fi
# abc != efg : a 不等于 b
if [ -z $a ]
then
   echo "-z $a : 字符串长度为 0"
else
   echo "-z $a : 字符串长度不为 0"
fi
# -z abc : 字符串长度不为 0
if [ -n "$a" ]
then
   echo "-n $a : 字符串长度不为 0"
else
   echo "-n $a : 字符串长度为 0"
fi
# -n abc : 字符串长度不为 0
if [ $a ]
then
   echo "$a : 字符串不为空"
else
   echo "$a : 字符串为空"
fi
# abc : 字符串不为空

文件测试运算符

用于检测 Unix 文件的各种属性。检测描述如下：

其他检查符：

• -S: 判断某文件是否 socket。
• -L: 检测文件是否存在并且是一个符号链接。

实例：
变量 file 表示文件，它的大小为 100 字节，具有 rwx 权限。下面的代码，将检测该文件的各种属性：

file="/var/www/runoob/test.sh"
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 [ -f $file ]
then
   echo "文件为普通文件"
else
   echo "文件为特殊文件"
fi
# 文件为普通文件
if [ -d $file ]
then
   echo "文件是个目录"
else
   echo "文件不是个目录"
fi
# 文件不是个目录
if [ -s $file ]
then
   echo "文件不为空"
else
   echo "文件为空"
fi
# 文件不为空
if [ -e $file ]
then
   echo "文件存在"
else
   echo "文件不存在"
fi
# 文件存在

函数

注意：所有函数在使用前必须定义。这意味着必须将函数放在脚本开始部分，直至shell解释器首次发现它时，才可以使用。调用函数仅使用其函数名即可。

demoFun(){
    echo "这是我的第一个 shell 函数!"
}
echo "-----函数开始执行-----"
demoFun
echo "-----函数执行完毕-----"

输出结果：
-----函数开始执行-----
这是我的第一个 shell 函数!
-----函数执行完毕-----

带有return语句的函数：

funWithReturn(){
    echo "这个函数会对输入的两个数字进行相加运算..."
    echo "输入第一个数字: "
    read aNum
    echo "输入第二个数字: "
    read anotherNum
    echo "两个数字分别为 $aNum 和 $anotherNum !"
    return $(($aNum+$anotherNum))
}
funWithReturn
echo "输入的两个数字之和为 $? !"

输出:
这个函数会对输入的两个数字进行相加运算...
输入第一个数字:
1
输入第二个数字:
2
两个数字分别为 1 和 2 !
输入的两个数字之和为 3 !

函数参数

funWithParam(){
    echo "第一个参数为 $1 !"
    echo "第二个参数为 $2 !"
    echo "第十个参数为 $10 !"
    echo "第十个参数为 ${10} !"
    echo "第十一个参数为 ${11} !"
    echo "参数总数有 $# 个!"
    echo "作为一个字符串输出所有参数 $* !"
}
funWithParam 1 2 3 4 5 6 7 8 9 34 73

输出结果：
第一个参数为 1 !
第二个参数为 2 !
第十个参数为 10 !
第十个参数为 34 !
第十一个参数为 73 !
参数总数有 11 个!
作为一个字符串输出所有参数 1 2 3 4 5 6 7 8 9 34 73 !

注意，$10 不能获取第十个参数，获取第十个参数需要${10}。当n>=10时，需要使用${n}来获取参数。
另外，还有几个特殊字符用来处理参数：

输入/输出重定向

需要注意的是文件描述符 0 通常是标准输入（STDIN），1 是标准输出（STDOUT），2 是标准错误输出（STDERR）。

command1 < infile > outfile

同时替换输入和输出，执行command1，从文件infile读取内容，然后将输出写入到outfile中。

重定向深入讲解

一般情况下，每个 Unix/Linux 命令运行时都会打开三个文件：

• 标准输入文件(stdin)：stdin的文件描述符为0，Unix程序默认从stdin读取数据。
• 标准输出文件(stdout)：stdout 的文件描述符为1，Unix程序默认向stdout输出数据。
• 标准错误文件(stderr)：stderr的文件描述符为2，Unix程序会向stderr流中写入错误信息。

默认情况下，command > file 将 stdout 重定向到 file，command < file 将stdin 重定向到 file。
如果希望 stderr 重定向到 file，可以这样写：

$ command 2>file

如果希望 stderr 追加到 file 文件末尾，可以这样写：

$ command 2>>file

2 表示标准错误文件(stderr)。
如果希望将 stdout 和 stderr 合并后重定向到 file，可以这样写：

$ command > file 2>&1

或者

$ command >> file 2>&1

如果希望对 stdin 和 stdout 都重定向，可以这样写：

$ command < file1 >file2

command 命令将 stdin 重定向到 file1，将 stdout 重定向到 file2。