历史记录

清除记录

猜你想搜

AcWing热点
App
登录/注册

Linux基础课笔记3（shell 语法）

作者：

知白和光 , 2023-07-19 23:18:21 , 所有人可见 , 阅读 118

1 `shell` 语法

本篇笔记参考 y总的讲义，AcWing用户 zst_2001 大佬的笔记，和各位大佬在y总讲义下的评论

1.1 概论

概述

shell 是我们通过命令与操作系统沟通的语言

shell 脚本可以直接在命令行中执行，也可以将一套逻辑组织成一个文件，方便复用

Ac Terminal中的命令行可以看成是一个 “shell 脚本在逐行执行”

Linux系统中一般默认使用 bash，所以接下来讲解 bash 中的语法。

文件开头需要写 #! /bin/bash，指明bash为脚本解释器。

脚本示例及运行方式

新建一个 test.sh 文件，内容如下：

#! /bin/bash

echo "Hello World!"

作为可执行文件运行

chmod +x test.sh # 使脚本具有可执行权限

./test.sh # 当前路径下执行
Hello World! # 脚本输出

/home/acs/test.sh # 绝对路径下执行
Hello World! # 脚本输出

~/test.sh # 家目录路径下执行
Hello World! # 脚本输出

直接执行需要可执行权限

可使用命令 ls -l test.sh 查看文件权限

使用解释器 bash 执行

bash test.sh
Hello World! # 脚本输出

解释器不需要可执行权限

1.2 注释

单行注释

使用 #

# 这是一行注释

echo 'Hello World'  #  这也是注释

多行注释

格式如下，其中 EOF 可以换成其他字符串

:<<EOF
第一行注释
第二行注释
第三行注释
EOF

1.3 变量

定义变量

定义变量，不需要加 $，且 = 两侧不能有空格：

name1='yxc'  # 单引号定义字符串
name2="yxc"  # 双引号定义字符串
name3=yxc    # 也可以不加引号，同样表示字符串

定义变量的时候变量都是字符串，但当变量需要是整数时，会自动把变量转换成整数

使用变量

使用变量，需要加上 $ 符号，或者 ${} 符号。花括号是可选的，主要为了帮助解释器识别变量边界。

name=yxc
echo $name  # 输出yxc
echo ${name}  # 输出yxc
echo ${name}acwing  # 输出yxcacwing

只读变量

使用 readonly 或者 declare 可以将变量变为只读。

name=yxc
readonly name
declare -r name  # 两种写法均可

name=abc  # 会报错，因为此时name只读

y总碎碎念：

type + 指令 能查看某条指令的来源

删除变量

unset 可以删除变量。

name=yxc
unset name
echo $name  # 输出空行

被声明为只读的变量无法被 unset 删除

变量类型

自定义变量（局部变量）：子进程不能访问的变量
环境变量（全局变量）：子进程可以访问的变量

自定义变量改成环境变量：

name=zst # 定义自定义变量
export name # 第一种方法改环境变量
declare -x name # 第二种方法改环境变量

环境变量改成自定义变量：

export name=zst # 定义环境变量
declare +x name # 改为自定义变量

tmux 分屏的两个 pane 实际上是两个 bash，在一个 bash 中自定义的 bash 变量仅可以被当前bash 访问，通过 bash 命令开启的子进程也无法访问。export 后变量变为环境变量，就可以被全局访问。（该方法也可用于验证某个变量是否是环境变量）
bash：开启子进程，exit 或 ctrl d 退出子进程

字符串

字符串可以用单引号，也可以用双引号，也可以不用引号（效果和双引号相同）。

单引号与双引号的区别：

单引号中的内容会原样输出，不会转义、不会执行、不会取变量；
双引号中的内容可以转义、可以执行、可以取变量；

name=yxc  # 不用引号
echo 'hello, $name \"hh\"'  # 单引号字符串，输出 hello, $name \"hh\"
echo "hello, $name \"hh\""  # 双引号字符串，输出 hello, yxc "hh"

获取字符串长度 ${#string}

name="yxc"
echo ${#name}  # 输出3

提取子串 ${string:index1:length}

name="hello, yxc"
echo ${name:0:5}  # 提取从0开始的5个字符

1.4 默认变量

文件参数变量

在执行shell脚本时，可以向脚本传递参数。$1 是第一个参数，$2 是第二个参数，以此类推。特殊的，$0 是文件名（包含路径）。例如：

创建文件 test.sh：

#! /bin/bash

echo "文件名："$0
echo "第一个参数："$1
echo "第二个参数："$2
echo "第三个参数："$3
echo "第四个参数："$4

执行脚本：

chmod +x test.sh
./test.sh 1 2 3 4 # 参数分别为 1 2 3 4
文件名：./test.sh
第一个参数：1
第二个参数：2
第三个参数：3
第四个参数：4

向脚本传递参数时，参数个数超过一位需要用大括号括起来，如 echo ${10}

其他参数相关变量

下面这个表格的内容挺重要的，后面会多次用到这里面的参数

参数	说明
`$#`	代表文件传入的参数个数，如上例中值为4（不包括文件名参数）
`$*`	由所有参数构成的用空格隔开的字符串，如上例中值为 `$1 $2 $3 $4`
`$@`	每个参数分别用双引号括起来的字符串，如上例中值为`"$1" "$2" "$3" "$4"`
`$$`	脚本当前运行的进程ID
`$?`	上一条命令的退出状态（注意不是stdout，而是exit code）。0表示正常退出，其他值表示错误
`$(command)`	返回 `command` 这条命令的stdout（可嵌套）
`command`	返回command这条命令的stdout（不可嵌套），另外注意这个符号不是单引号，而是键盘左上角的 `

1.5 数组

数组中可以存放多个不同类型的值，只支持一维数组，初始化时不需要指明数组大小。
数组下标从0开始。

定义

数组用小括号表示，元素之间用空格隔开。例如：

array=(1 abc "def" yxc)

也可以直接定义数组中某个元素的值：

array[0]=1
array[1]=abc
array[2]="def"
array[3]=yxc

读取数组中某个元素的值

格式：

${array[index]}

使用变量那里提到了，要加上 $ 才能读取

array=(1 abc "def" yxc)
echo ${array[0]}
echo ${array[1]}
echo ${array[2]}
echo ${array[3]}

读取整个数组

格式：

${array[@]}  # 第一种写法
${array[*]}  # 第二种写法

数组长度

类似于字符串，在前面加上 # 能得到结果

${#array[@]}  # 第一种写法
${#array[*]}  # 第二种写法

数组存储方式

shell 的数组存储方式比较特殊，示例如下

array[0]=1
array[1]=abc
array[2]="def"
array[1000]=yxc

${array[@]}  # 输出数组成员
${#array[@]} # 输出数组长度

结果如下：

1 abc def yxc # 只会输出实际被使用的空间里的成员
4 # 只会输出实际被使用的空间的长度

1.6 `expr` 命令

expr 命令用于求表达式的值，格式为：

expr 表达式

表达式说明：

用空格隔开每一项
用反斜杠 \ 放在shell特定的字符前面进行转义
可以用单引号代替 '' ，能实现相同的效果
需要转义的符号：*, (, ), >, <, >=, <=, |, &
对包含空格和其他特殊字符的字符串要用引号括起来
expr 会在 stdout 中输出结果。如果为逻辑关系表达式，则结果为真时，stdout 输出1，否则输出0。
expr 的 exit code：如果为逻辑关系表达式，则结果为真时，exit code 为0，否则为1。
expr 可以用 $() 和 `` 取返回值
即其他参数相关变量表格里的 $() 和 ``
expr 可以用 $[] 代替，且 $[] 不需要转义

字符串表达式

expr length string ：返回 string 的长度
expr index string charset：charset 中任意单个字符在 string 中最前面的字符位置，下标从1开始。如果在 string 中完全不存在 charset 中的字符，则返回0。
expr substr string position length：返回 string 字符串中从 position 开始，长度最大为length 的子串。如果 position 或 length 为负数，0或非数值，则返回空字符串。

str="Hello World!"

echo `expr length "$str"`  # ``不是单引号，表示执行该命令，输出12
echo `expr index "$str" aWd`  # 输出7，下标从1开始
echo `expr substr "$str" 2 3`  # 输出 ell

整数表达式

expr 支持普通的算术操作，算术表达式优先级低于字符串表达式，高于逻辑关系表达式。

+ -：加减运算。两端参数会转换为整数，如果转换失败则报错。
* / %：乘，除，取模运算。两端参数会转换为整数，如果转换失败则报错。
()：可以改变优先级，但需要用反斜杠转义。

a=3
b=4

echo `expr $a + $b`  # 输出7
echo `expr $a - $b`  # 输出-1
echo `expr $a \* $b`  # 输出12，*需要转义
echo `expr $a / $b`  # 输出0，整除
echo `expr $a % $b` # 输出3
echo `expr \( $a + 1 \) \* \( $b + 1 \)`  # 输出20，值为(a + 1) * (b + 1)

逻辑关系表达式

|：如果第一个参数非空且非0，则返回第一个参数的值，否则返回第二个参数的值，但要求第二个参数的值也是非空或非0，否则返回0。（短路）如果第一个参数是非空或非0时，不会计算第二个参数。
&：如果两个参数都非空且非0，则返回第一个参数，否则返回0。如果第一个参为0或为空，则不会计算第二个参数。
< <= = == != >= >：比较两端的参数，如果为true，则返回1，否则返回0。”==”是”=”的同义词。”expr”首先尝试将两端参数转换为整数，并做算术比较，如果转换失败，则按字符集排序规则做字符比较。
()：可以改变优先级，但需要用反斜杠转义。

a=3
b=4

echo `expr $a \> $b`  # 输出0，>需要转义
echo `expr $a '<' $b`  # 输出1，也可以将特殊字符用引号引起来
echo `expr $a '>=' $b`  # 输出0
echo `expr $a \<\= $b`  # 输出1

c=0
d=5

echo `expr $c \& $d`  # 输出0
echo `expr $a \& $b`  # 输出3
echo `expr $c \| $d`  # 输出5
echo `expr $a \| $b`  # 输出3

1.7 `read` 命令

read 命令用于从标准输入中读取单行数据。当读到文件结束符时，exit code 为1，否则为0。

参数说明

-p：后面可以接提示信息
-t：后面跟秒数，定义输入字符的等待时间，超过等待时间后会自动忽略此命令

read name  # 读入name的值
acwing yxc  # 标准输入
echo $name  # 输出name的值
acwing yxc  #标准输出

read -p "Please input your name: " -t 30 name  # 读入name的值，等待时间30秒
Please input your name: acwing yxc  # 标准输入
echo $name  # 输出name的值
acwing yxc  # 标准输出

1.8 `echo` 命令

echo 用于输出字符串。命令格式：

echo string

显示普通字符串

echo "Hello AC Terminal"
echo Hello AC Terminal  # 引号可以省略

显示转义字符

echo "\"Hello AC Terminal\""  # 注意只能使用双引号，如果使用单引号，则不转义
echo \"Hello AC Terminal\"  # 也可以省略双引号

实质是双引号字符串和无引号字符串均会转义，但单引号字符串不会转义

显示变量

name=yxc
echo "My name is $name"  # 输出 My name is yxc

显示换行

echo -e "Hi\n"  # -e 开启转义
echo "acwing"

输出结果：

Hi

acwing

显示不换行

echo -e "Hi \c" # -e 开启转义 \c 不换行
echo "acwing"

输出结果：

Hi acwing

注：\\, \a, \b, \c, \d, \e, \f, \n, \r, \t, \v 这些字符只用双引号无法输出，必须加上 -e，且加上 -e 后使用单引号也能实现转义（双引号或单引号不能省略）

显示结果定向至文件

echo "Hello World" > output.txt # 将内容以覆盖的方式输出到output.txt中

原样输出字符串，不进行转义或取变量(用单引号)

name=acwing
echo '$name\"'

输出结果

$name\"

显示命令的执行结果

echo `date`

输出结果：

Wed Sep 1 11:45:33 CST 2021

1.9 `printf` 命令

printf 命令用于格式化输出，类似于 C/C++ 中的 printf 函数。默认不会在字符串末尾添加换行符。

命令格式：

printf format-string [arguments...]

示例：

printf "%10d.\n" 123  # 占10位，右对齐
printf "%-10.2f.\n" 123.123321  # 占10位，保留2位小数，左对齐
printf "My name is %s\n" "yxc"  # 格式化输出字符串
printf "%d * %d = %d\n"  2 3 `expr 2 \* 3` # 表达式的值作为参数

输出结果：

       123.
123.12    .
My name is yxc
2 * 3 = 6

1.10 `test` 命令与判断符号 `[]`

逻辑运算符 `&&` 和 `||`

&& 表示与，|| 表示或
二者具有短路原则：
expr1 && expr2：当 expr1 为假时，直接忽略 expr2
expr1 || expr2：当 expr1 为真时，直接忽略 expr2
表达式的 exit code 为0，表示真；为非零，表示假。（与 C/C++中的定义相反）

`test` 命令

在命令行中输入 man test，可以查看 test 命令的用法。

test 命令用于判断文件类型，以及对变量做比较。

test 命令用 exit code 返回结果，而不是使用 stdout。0表示真，非0表示假。

例如：

test 2 -lt 3  # 为真，返回值为0
echo $?  # 输出上个命令的返回值，输出0

ls  # 列出当前目录下的所有文件
homework  output.txt  test.sh  tmp

# 可以用 && 和 || 实现if/else语句
test -e test.sh && echo "exist" || echo "Not exist"
exist  # test.sh 文件存在

test -e test2.sh && echo "exist" || echo "Not exist"
Not exist  # testh2.sh 文件不存在

test 用法汇总

test -e filename # 判断文件是否存在
test -f filename # 判断是否为文件
test -d filename # 判断是否为目录

test -r filename # 判断文件是否可读
test -w filename # 判断文件是否可写
test -x filename # 判断文件是否可执行
test -s filename # 判断文件是否为空文件

test $a -eq $b # 判断a是否等于b
test $a -ne $b # 判断a是否不等于b
test $a -gt $b # 判断a是否大于b
test $a -lt $b # 判断a是否小于b
test $a -ge $b # 判断a是否大于等于b
test $a -le $b # 判断a是否小于等于b

test -z string # 判断string是否为空，如果为空，则返回true
test -n string # 判断string是否非空，如果非空，则返回true（-n可以省略）

test str1 == str2 # 判断str1是否等于str2
test str1 != str2 # 判断str1是否不等于str2
test str1 < str2 # 判断str1的字典序是否小于str2
test str1 > str2 # 判断str1的字典序是否大于str2

test EXPR1 -a EXPR2 # 判断两个条件是否同时成立
test EXPR1 -o EXPR2 # 判断两个条件是否至少一个成立
test ! EXPR1 # 判断取反后是否成立

判断符号 `[]`

[] 与 test 用法几乎一模一样，更常用于 if 语句中。另外 [[]] 是 [] 的加强版，支持的特性更多。

示例：

[ 2 -lt 3 ]  # 为真，返回值为0
echo $?  # 输出上个命令的返回值，输出0

ls  # 列出当前目录下的所有文件
homework  output.txt  test.sh  tmp

[ -e test.sh ] && echo "exist" || echo "Not exist"
exist  # test.sh 文件存在

[ -e test2.sh ] && echo "exist" || echo "Not exist"
Not exist  # test2.sh 文件不存在

注意：

[] 内的每一项都要用空格隔开（包括左右两个方括号）
中括号内的变量，最好用双引号括起来
中括号内的常数，最好用单或双引号括起来

name="acwing yxc"
[ $name == "acwing yxc" ]  # 错误，等价于 [ acwing yxc == "acwing yxc" ]，参数太多
[ "$name" == "acwing yxc" ]  # 正确

1.11 判断语句

单层 `if`

命令格式：

if condition
then
    语句1
    语句2
    ...
fi

示例：

a=3
b=4

if [ "$a" -lt "$b" ] && [ "$a" -gt 2 ]
then
    echo ${a}在范围内
fi

输出结果：

3在范围内

单层 `if-else`

if condition
then
    语句1
    语句2
    ...
else
    语句1
    语句2
    ...
fi

多层 `if-elif-elif-else`

if condition
then
    语句1
    语句2
    ...
elif condition
then
    语句1
    语句2
    ...
elif condition
then
    语句1
    语句2
else
    语句1
    语句2
    ...
fi

`case…esac` 形式

类似于 C/C++ 中的 switch 语句。

命令格式

case $变量名称 in
    值1)
        语句1
        语句2
        ...
        ;;  # 类似于C/C++中的break
    值2)
        语句1
        语句2
        ...
        ;;
    *)  # 类似于C/C++中的default
        语句1
        语句2
        ...
        ;;
esac

示例

a=4

case $a in
    1)
        echo ${a}等于1
        ;;  
    2)
        echo ${a}等于2
        ;;  
    3)                                                
        echo ${a}等于3
        ;;  
    *)
        echo 其他
        ;;  
esac

输出结果：

其他

1.12 循环语句

`for…in…do…done`

命令格式：

for var in val1 val2 val3
do
    语句1
    语句2
    ...
done

示例1，输出 a 2 cc，每个元素一行：

for i in a 2 cc
do
    echo $i
done

示例2，输出当前路径下的所有文件名，每个文件名一行：

for file in `ls`
do
    echo $file
done

示例3，输出1-10

for i in $(seq 1 10)
do
    echo $i
done

示例4，使用 {1..10} 或者 {a..z}

for i in {a..z}
do
    echo $i
done

`for ((…;…;…)) do…done`

命令格式：

for ((expression; condition; expression))
do
    语句1
    语句2
done

示例，输出 1-10 ，每个数占一行：

for ((i=1; i<=10; i++))
do
    echo $i
done

`while…do…done` 循环

命令格式：

while condition
do
    语句1
    语句2
    ...
done

示例，文件结束符为 Ctrl+d，输入文件结束符后 read 指令返回 false。

while read name
do
    echo $name
done

`until…do…done` 循环

当条件为真时结束。

命令格式：

until condition
do
    语句1
    语句2
    ...
done

示例，当用户输入 yes 或者 YES 时结束，否则一直等待读入。

until [ "${word}" == "yes" ] || [ "${word}" == "YES" ]
do
    read -p "Please input yes/YES to stop this program: " word
done

`break` 命令

跳出当前一层循环，注意与 C/C++ 不同的是：break 不能跳出 case 语句。

示例

while read name
do
    for ((i=1;i<=10;i++))
    do
        case $i in
            8)
                break
                ;;
            *)
                echo $i
                ;;
        esac
    done
done

该示例每读入非 EOF 的字符串，会输出一遍 1-7。
该程序可以输入 Ctrl+d 文件结束符来结束，也可以直接用 Ctrl+c 杀掉该进程。

`continue` 命令

跳出当前循环。

示例：

for ((i=1;i<=10;i++))
do
    if [ `expr $i % 2` -eq 0 ]
    then
        continue
    fi
    echo $i
done

该程序输出 1-10 中的所有奇数。

死循环的处理方式

如果AC Terminal可以打开该程序，则输入Ctrl+c 即可。

否则可以直接关闭进程：

使用 top 命令找到进程的PID
输入kill -9 PID 即可关掉此进程

1.13 函数

关于 `return` 和 `stdout`

bash 中的函数类似于 C/C++ 中的函数，但 return 的返回值与 C/C++ 不同，返回的是 exit code，取值为 0-255，0 表示正常结束。

如果想获取函数的输出结果，可以通过 echo 输出到 stdout 中，然后通过 $(function_name) 来获取 stdout 中的结果。

函数的 return 值可以通过 $? 来获取。

命令格式：

[function] func_name() {  # function关键字可以省略
    语句1
    语句2
    ...
}

不获取 `return` 值和 `stdout` 值

示例

func() {
    name=yxc
    echo "Hello $name"
}

func

输出结果：

Hello yxc

获取 `return` 值和 `stdout` 值

不写 return 时，默认 return 0。

示例

func() {
    name=yxc
    echo "Hello $name"

    return 123
}

output=$(func)
ret=$?

echo "output = $output"
echo "return = $ret"

输出结果：

output = Hello yxc
return = 123

函数的输入参数

在函数内，$1 表示第一个输入参数，$2 表示第二个输入参数，依此类推。

注意：函数内的 $0 仍然是文件名，而不是函数名。

示例：

func() {  # 递归计算 $1 + ($1 - 1) + ($1 - 2) + ... + 0
    word=""
    while [ "${word}" != 'y' ] && [ "${word}" != 'n' ]
    do
        read -p "要进入func($1)函数吗？请输入y/n：" word
    done

    if [ "$word" == 'n' ]
    then
        echo 0
        return 0
    fi  

    if [ $1 -le 0 ] 
    then
        echo 0
        return 0
    fi  

    sum=$(func $(expr $1 - 1))
    echo $(expr $sum + $1)
}

echo $(func 10)

输出结果：

注意：为什么只输出 55 不输出其他的值，因为在 echo 函数后面有 $, 这个 $ 会截获掉 stdout 里的值，使得 echo 找不到 stdout 里的数据从而不能输出，在递归往回调用的过程中上一层的 echo 会被这一层的 sum= $(func $(expr $1 - 1)) 中的第一个 $ 捕获从而没有输出，而最后一层的 echo 会被函数外的 echo $(func 10) 的 $ 捕获，因此是函数外的 echo 输出的55 。如果你把函数外的 echo $(func 10) 改成 func 10 就是最后一层递归 echo $(expr $sum + $1) 输出的 55.

函数内的局部变量

可以在函数内定义局部变量，作用范围仅在当前函数内。

可以在递归函数中定义局部变量。

命令格式：

local 变量名=变量值

例如：

#! /bin/bash

func() {
    local name=yxc
    echo $name
}
func

echo $name

输出结果：

yxc

第一行为函数内的name变量，第二行为函数外调用name变量，会发现此时该变量不存在。

1.14 `exit` 命令

exit 命令用来退出当前 shell 进程，并返回一个退出状态；使用 $? 可以接收这个退出状态。

exit 命令可以接受一个整数值作为参数，代表退出状态。如果不指定，默认状态值是 0。

exit 退出状态只能是一个介于 0~255 之间的整数，其中只有 0 表示成功，其它值都表示失败。

示例：

创建脚本 test.sh，内容如下：

#! /bin/bash

if [ $# -ne 1 ]  # 如果传入参数个数等于1，则正常退出；否则非正常退出。
then
    echo "arguments not valid"
    exit 1
else
    echo "arguments valid"
    exit 0
fi

执行该脚本：

chmod +x test.sh 
./test.sh acwing
arguments valid
echo $?  # 传入一个参数，则正常退出，exit code为0
0
./test.sh 
arguments not valid
echo $?  # 传入参数个数不是1，则非正常退出，exit code为1
1

`return` 和 `exit` 的区别

return 和 exit 的共同之处都是返回 exit code，区别是 return 结束当前函数，exit 结束整个 shell 脚本

1.15 文件重定向

每个进程默认打开3个文件描述符：

stdin 标准输入，从命令行读取数据，文件描述符为0
stdout 标准输出，向命令行输出数据，文件描述符为1
stderr 标准错误输出，向命令行输出数据，文件描述符为2

可以用文件重定向将这三个文件重定向到其他文件中。

重定向命令列表

命令	说明
`command > file`	将 `stdout` 重定向到 `file` 中
`command < file`	将 `stdin` 重定向到 `file` 中
`command >> file`	将 `stdout` 以追加方式重定向到 `file` 中
`command n> file`	将文件描述符 `n` 重定向到 `file` 中
`command n>> file`	将文件描述符 `n` 以追加方式重定向到 `file` 中

输入和输出重定向

echo -e "Hello \c" > output.txt  # 将stdout重定向到output.txt中
echo "World" >> output.txt  # 将字符串追加到output.txt中

read str < output.txt  # 从output.txt中读取字符串

echo $str  # 输出结果：Hello World

同时重定向 `stdin` 和 `stdout`

创建bash脚本：

#! /bin/bash

read a
read b

echo $(expr "$a" + "$b")

创建input.txt，里面的内容为：

3
4

执行命令：

chmod +x test.sh  # 添加可执行权限
./test.sh < input.txt > output.txt  # 从input.txt中读取内容，将输出写入output.txt中
cat output.txt  # 查看output.txt中的内容
7

1.16 引入外部脚本

类似于 C/C++ 中的 include 操作，bash 也可以引入其他文件中的代码。

语法格式：

. filename  # 注意点和文件名之间有一个空格
或
source filename

示例

创建 test1.sh，内容为：

#! /bin/bash

name=yxc  # 定义变量name

然后创建 test2.sh，内容为：

#! /bin/bash

source test1.sh # 或 . test1.sh

echo My name is: $name  # 可以使用test1.sh中的变量

执行命令：

chmod +x test2.sh 
./test2.sh 
My name is: yxc

2 作业与解答

homework_0

题目

进入 homework_0 文件夹，编写自动完成 lesson_1 作业的脚本 helper.sh 。要求：

当前目录下仅包含 helper.sh
helper.sh 具有可执行权限
在任意路径依次执行下列命令后，lesson_1 的作业可以得到满分：
homework 1 create
/home/acs/homework/lesson_3/homework_0/helper.sh

解答

cd homework_0
vim helper.sh
输入helper.sh内容
chmod +x helper.sh

helper.sh 中内容如下：

#! /bin/bash

cd /home/acs/homework/lesson_1

cd homework_0
mkdir dir_a
mkdir dir_b
mkdir dir_c

cd ..
cd homework_1
cp a.txt a.txt.bak
cp b.txt b.txt.bak
cp c.txt c.txt.bak

cd ..
cd homework_2
mv a.txt a_new.txt
mv b.txt b_new.txt
mv c.txt c_new.txt

cd ..
cd homework_3
mv dir_a/a.txt dir_b
mv dir_a/b.txt dir_b
mv dir_a/c.txt dir_b

cd ..
cd homework_4
rm a.txt
rm b.txt
rm c.txt

cd ..
cd homework_5
rm dir_a -r
rm dir_b -r
rm dir_c -r

cd ..
cd homework_6
mkdir dir_a
mv task.txt dir_a/done.txt

cd ..
cd homework_7
mkdir dir_0
mkdir dir_1
mkdir dir_2
cp a.txt dir_0/a0.txt
cp b.txt dir_0/b0.txt
cp c.txt dir_0/c0.txt
cp a.txt dir_1/a1.txt
cp b.txt dir_1/b1.txt
cp c.txt dir_1/c1.txt
cp a.txt dir_2/a2.txt
cp b.txt dir_2/b2.txt
cp c.txt dir_2/c2.txt

cd ..
cd homework_8
rm dir_a/a.txt
mv dir_b/b.txt dir_b/b_new.txt
cp dir_c/c.txt dir_c/c.txt.bak

cd ..
cd homework_9
rm *.txt

另一种写法：

#! /bin/bash

dir0=/home/acs/homework/lesson_1/homework_0
for i in dir_a dir_b dir_c
do
    mkdir ${dir0}/$i
done

dir1=/home/acs/homework/lesson_1/homework_1
for i in a.txt b.txt c.txt
do
    cp ${dir1}/${i} ${dir1}/${i}.bak
done

dir2=/home/acs/homework/lesson_1/homework_2
for i in a b c
do
    mv ${dir2}/${i}.txt ${dir2}/${i}_new.txt
done

dir3=/home/acs/homework/lesson_1/homework_3
for i in a.txt b.txt c.txt
do
    mv ${dir3}/dir_a/${i} ${dir3}/dir_b/
done

dir4=/home/acs/homework/lesson_1/homework_4
for i in a.txt b.txt c.txt
do
    rm ${dir4}/${i}
done

dir5=/home/acs/homework/lesson_1/homework_5                                                                                                                                  
for i in dir_a dir_b dir_c
do
    rm ${dir5}/${i} -r
done

dir6=/home/acs/homework/lesson_1/homework_6
mv ${dir6}/task.txt "${dir6}/done.txt"
mkdir ${dir6}/dir_a
mv "${dir6}/done.txt" ${dir6}/dir_a

dir7=/home/acs/homework/lesson_1/homework_7
for ((i=0;i<3;i++))
do
    mkdir ${dir7}/dir_$i
    for j in a b c
    do
        cp ${dir7}/${j}.txt ${dir7}/dir_${i}/${j}${i}.txt
    done
done

dir8=/home/acs/homework/lesson_1/homework_8
rm ${dir8}/dir_a/a.txt
mv ${dir8}/dir_b/b.txt ${dir8}/dir_b/b_new.txt
cp ${dir8}/dir_c/c.txt ${dir8}/dir_c/c.txt.bak

dir9=/home/acs/homework/lesson_1/homework_9
rm ${dir9}/*.txt

homework_1

题目

进入 homework_1 文件夹，编写脚本 check_file.sh 。要求：

当前目录下仅包含 check_file.sh 。
check_file.sh 具有可执行权限。
check_file.sh 接收一个传入参数。格式为 ./check_file.sh file
判断传递参数，分别在标准输出中输出如下内容（不包括双引号）：
1) 如果传入参数个数不是 1，则输出一行："arguments not valid"，然后退出，退出状态等于 1。
2) 如果 file 文件不存在，则输出一行："not exist"，然后退出，退出状态等于 2。
3) 如果 file 文件存在，则输出分别进行如下 5 个判断，然后退出，退出状态等于 0。
1. 如果 file 为普通文件，则输出一行："regular file"
2. 如果 file 为目录（文件夹），则输出一行："directory"
3. 如果 file 具有可读权限，则输出一行："readable"
4. 如果 file 具有可写权限，则输出一行："writable"
5. 如果 file 具有可执行权限，则输出一行："executable"

解答

cd homework_1
vim check_file.sh
输入check_file.sh内容
chmod +x check_file.sh

check_file.sh 中内容如下：

#! /bin/bash

if [ $# -ne 1 ] 
then
    echo "arguments not valid"
    exit 1
elif ! [ -e "$1" ]
then
    echo "not exist"
    exit 2
else
    if [ -f "$1" ]
    then
        echo "regular file"
    fi
    if [ -d "$1" ]
    then
        echo "directory"
    fi
    if [ -r "$1" ]
    then
        echo "readable"
    fi
    if [ -w "$1" ]
    then
        echo "writable"
    fi
    if [ -x "$1" ]
    then
        echo "executable"
    fi
    exit 0
fi

homework_2

题目

进入 homework_2 文件夹，编写脚本 main.sh 。要求：

当前目录下仅包含 main.sh
main.sh 具有可执行权限
该文件从 stdin (标准输入)中读取一个整数 n
在 stdout (标准输出)输出斐波那契数列的第 n 项。即：a[0] = 1, a[1] = 1, a[i] = a[i - 1] + a[i - 2], 求 a[n]。
数据保证 0 <= n <= 20，脚本不需要判断 n 的合法性。

解答

cd homework_2
vim main.sh
输入main.sh内容
chmod +x main.sh

main.sh 中内容如下：

#! /bin/bash

read n

a[0]=1
a[1]=1

for ((i=2; i<=n; i++))
do
    a[$i]=$(expr ${a[`expr $i - 1`]} + ${a[`expr $i - 2`]})
done

echo ${a[$n]}

homework_3

题目

进入 homework_3 文件夹，编写脚本 main.sh。要求：

当前目录下仅包含 main.sh
main.sh 具有可执行权限
该文件从 stdin (标准输入)中读取两行整数 n 和 m
在 stdout (标准输出)中输出 1~n 的按字典序从小到大的顺序数第 m 个全排列，输出一行，用空格隔开所有数，行末可以有多余空格。
数据保证 1 <= n <= 10, 1 <= m <= min(100, n!)，脚本不需要判断数据的合法性。

解答

cd homework_3
vim main.sh
输入main.sh内容
chmod +x main.sh

main.sh 中内容如下：

#! /bin/bash

read n
read m

count=0

for ((i=0; i<n; i++))
do
    st[$i]=0
done

dfs() {
    if [ $1 -eq $n ]
    then
        count=$(expr $count + 1)
        if [ $count -eq $m ]
        then
            local j=0
            for ((j=0; j<n; j++))
            do
                echo -e "${a[$j]} \c"
            done
            return 0
        fi
        return 1
    fi  

    local j=0
    for ((j=0; j<n; j++))
    do
        if [ ${st[$j]} -eq 0 ]
        then
            st[$j]=1
            a[$1]=$(expr $j + 1)
            if dfs $(expr $1 + 1)
            then
                return 0
            fi
            st[$j]=0
        fi
    done

    return 1
}

dfs 0

homework_4

题目

进入 homework_4 文件夹，编写脚本 main.sh。要求：

当前目录下仅包含 main.sh
main.sh 具有可执行权限
main.sh 接收两个传入参数。格式为 ./main.sh input_file output_file
从 input_file 中读取一个正整数 n，然后将前 n 个正整数的平方和写入 output_file 中
数据保证 1 <= n <= 100，脚本不需要判断所有数据的合法性。

解答

#! /bin/bash

read n < $1

sum=0

for ((i=1; i<=n; i++))
do
    sum=$(expr $sum + $(expr $i '*' $i))
done

echo $sum > $2

0 评论

App 内打开

Linux基础课笔记3（shell 语法）

1 shell 语法

1.1 概论

概述

脚本示例及运行方式

1.2 注释

单行注释

多行注释

1.3 变量

定义变量

使用变量

只读变量

删除变量

变量类型

字符串

1.4 默认变量

文件参数变量

其他参数相关变量

1.5 数组

定义

读取数组中某个元素的值

读取整个数组

数组长度

数组存储方式

1.6 expr 命令

字符串表达式

整数表达式

逻辑关系表达式

1.7 read 命令

1.8 echo 命令

显示普通字符串

显示转义字符

显示变量

显示换行

显示不换行

显示结果定向至文件

原样输出字符串，不进行转义或取变量(用单引号)

显示命令的执行结果

1.9 printf 命令

1.10 test 命令与判断符号 []

逻辑运算符 && 和 ||

test 命令

判断符号 []

1.11 判断语句

单层 if

单层 if-else

多层 if-elif-elif-else

case…esac 形式

1.12 循环语句

for…in…do…done

for ((…;…;…)) do…done

while…do…done 循环

until…do…done 循环

break 命令

continue 命令

死循环的处理方式

1.13 函数

关于 return 和 stdout

不获取 return 值和 stdout 值

获取 return 值和 stdout 值

函数的输入参数

函数内的局部变量

1.14 exit 命令

return 和 exit 的区别

1.15 文件重定向

重定向命令列表

输入和输出重定向

同时重定向 stdin 和 stdout

1.16 引入外部脚本

2 作业与解答

homework_0

homework_1

homework_2

homework_3

homework_4

0 评论

1 `shell` 语法

1.6 `expr` 命令

1.7 `read` 命令

1.8 `echo` 命令

1.9 `printf` 命令

1.10 `test` 命令与判断符号 `[]`

逻辑运算符 `&&` 和 `||`

`test` 命令

判断符号 `[]`

单层 `if`

单层 `if-else`

多层 `if-elif-elif-else`

`case…esac` 形式

`for…in…do…done`

`for ((…;…;…)) do…done`

`while…do…done` 循环

`until…do…done` 循环

`break` 命令

`continue` 命令

关于 `return` 和 `stdout`

不获取 `return` 值和 `stdout` 值

获取 `return` 值和 `stdout` 值

1.14 `exit` 命令

`return` 和 `exit` 的区别

同时重定向 `stdin` 和 `stdout`