Lesson 3. Shell (Language)

MinatoYukiii

已于 2023-12-13 15:40:01 修改

阅读量800

点赞数 23

分类专栏： Linux基础课笔记文章标签： linux

于 2023-12-13 15:26:09 首次发布

本文链接：https://blog.csdn.net/m0_67850950/article/details/134973196

版权

Linux基础课笔记专栏收录该内容

7 篇文章 1 订阅

订阅专栏

Lesson 3. Shell (Language)

概述

把逻辑变成一套可以复用的东西(脚本)，本质上是和 OS 沟通的工具，主要用于运维服务器;
解释型语言，不需要编译，可以直接在命令行运行;
bash 是一种 Linux 的命令行解释器;

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

附上y总写的讲义: https://www.acwing.com/file_system/file/content/whole/index/content/2855883/

// ~~感觉东西很多，不需要背过，遇到了再来查 :3~~

// ~~拒绝背成八股文，多试多用~~

脚本执行方式

解释器执行: bash test.sh // 该方式不需要权限也可以执行
可执行文件执行:

ls -l test.sh          # 查看文件的执行权限
chmod +x test.sh       # 为文件增加执行权限
./test.sh

变量

定义变量，有三种定义方式：(等号两边不能有空格)

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

name='a'             # 单引号定义的不会转义: echo '${name}' -> ${name} 
name="a" name=a      # 双引号会转义: echo "${name}" -> a

使用变量，对变量用 ${xxx} ，可以理解为取值;

${name} $name

只读变量，不能改该变量的值;

readonly name
declare -r name

删除变量，不能删除只读变量;

unset name

变量类型：
- 自定义变量(局部变量)：子进程不能访问;
- 环境变量(全局变量)：子进程可以访问;
- 补充知识：一个进程(bash)可以通过命令bash打开子进程，exit退出子进程，在 tmux 中分屏相当于是多开了个 bash;

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

字符串操作;

${#name}             # 提取字符串长度
${name:pos:len}      # 取子串，substr(pos, len) 完全一样

文件参数变量;

./test.sh aa b c d

echo $0             # 文件名 -> ./test.sh
echo $1             # 第一个参数 -> aa
echo $2				# 第二个参数 -> b
echo ${10}          # 第十个参数
echo $?				# exit code 上一条命令退出状态
echo $(ls)          # $(command) 或 `command` 返回 command 的 stdout -> homework test.sh
echo `pwd`			# -> /home/acs
                    # ${xx} 一般取变量的值; $(xx) 一般取 stdout;

数组

定义数组，并读取值，长度;

# 定义数组，每个元素都是字符串
array=(11 abc def 666)    	# 空格隔开每个元素
array[100]=100				# 可以跳着定义，中间的空间都没开，我的理解是像哈希表

# 读取数组元素值
${array[0]}					# -> 11
${array[100]}				# -> 100
${array[55]}				# ->         试下来没定义的输出空，并不会报错

${array[@]} ${array[*]}		# 输出所有元素 -> 11 abc def 666 100 

# 读取数组长度
${#array[@]} ${#array[*]}  	# -> 5

expr 命令

可以理解成 cout (stdout) 返回;
逻辑表达式的 exit code 如果为真则为0，如果为假则为1;

字符串表达式

str="Mianto Yukiii"

echo `expr length "$str"`     # 在 $str 上套个 "" 是由于 str 如果包含<space>则会被认为传入多个参数 -> 13
echo `expr index "$str" aBk`  # 在 str 中从头开始(下标 1 开始)查找 aBk(CharSet) 中任意字符首次出现的位置
                              # 如果没出现过 CharSet 中任意字符，则返回 0 -> 3
echo `expr substr "$str" 8 5` # str.substr(pos, len) -> Yukii

整数表达式

a=3
b=4

echo `expr $a + $b`
echo `expr \( $a + 1 \) '*' \( $b + 1 \)` # 每一个参数直接<space>隔开，"()"和"*"需要转义 -> 4 * 5 = 20
										  # 先写 (a + 1) * (b + 1) 再把所有要加<space>地方加，加转义地方加'\'
a=`expr $a + 4`                           # a += 4;

逻辑表达式

a=3
b=4

echo `expr $a '>' $b`       # 转义可以用 'xxx' 来表示 -> 0 (false)
echo `expr $a '<=' $b`      # -> 1 (true)

c=0
echo `expr $c '&' $a`       # -> 0
echo `expr $c '|' $a`       # -> 3
echo `expr $b '&' $a`       # -> 4
echo `expr $a '|' $b`       # -> 3
                            # 类似于 || 和 && 遵循短路原则，但返回的不是 true 和 false

read 命令

read -p $'Please input your name: \n' -t 5 name
# read 可以理解为 cin; -p 是提示信息; -t 是等待秒数，超过该秒数则跳过该命令;
# -p $'...' 中可以加入转义字符
# -p "..." 则不识别转义字符

echo 命令

echo -e "Hi\n"                       # -e 开启转义
echo -e "Hi\c"                       # \c 不换行
echo "Hello World" > output.txt      # 文件重定向，将内容覆盖输出到output.txt中
echo `command`

printf 命令

和 C++ 一样;

test 命令和判断符号[]

逻辑运算符 && ||

一般利用 && 和 || 的短路原则，如 command1 && command2 只有 command1 成功后 command2 才运行;
进程状态表示结果，0表示真，非0表示假;

test 命令

可以理解成 return (exit code) 返回;

test 2 -lt 3      # less then 
echo $?           # -> 0 (true)

test -e test.sh && echo "exist" || echo "not exist"
# test.sh存在 -> && command1 为真执行 command2 -> command2 一定为 true，||不执行 command3;
# test.sh不存在 -> && command1 为假不执行 command2 -> 前面结果为假 || 执行 command3;

文件类型判断
- -e 文件是否存在;
- -f 判断是否为文件;
- -d 判断是否为目录(文件夹);
文件权限判断 (当前用户)
- -r 文件是否可读;
- -w 文件是否可写;
- -x 文件是否可执行;
- -s 文件是否为空文件;
整数间比较

test $a -eq $b
-eq -ne -gt -lt -ge -le

字符串比较
- -z / -n str 判断 str 是否为空(非空，-n 可以省略);
- str1 == str2 / str1 != str2 test "$s1" == "$s2" && echo "true" || echo "false"

判断符号[]

和 test 命令一样，可以取代 test 命令，[] 中每一项要用 <space> 隔开，变量和常数用 “” 引起来;

[ -e test.sh ] && echo "true" || echo "false"

判断语句

if - else

if [ "$a" -lt "$b" ] && [ ... ]  # if command 判断的是 exit code
then
	...
else
	...
fi

if - elif - else

if [ ... ]
then
	...
elif [ ... ]
then
	...
else
	...
fi

循环语句

for … in … do … done

for var in val1 val2 val3 ...
do
	...
done

for i in abc def 123      	# 遍历 "abc" "def" "123"
for file in `ls` ...		# 遍历当前目录下所有文件名
for i in $(seq 1 10)		# 循环 1~10，也可以 seq 10 1，循环 10~1
for i in $(seq z a)

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

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

while … do … done

while read name			# 读入 name，直到遇到文件退出符 ctrl + d，read 指令返回 false
do
	echo $name
done

until … do … done

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

continue break

和 C++ 中 continue break 差不多，但是 break 不能跳出 case 循环;

杀死死循环

top				# 类似于任务管理器，显示当前的所有进程，找到 test.sh 的 PID
ctrl + c        # 结束 top
kill -9 PID

函数

return 的返回值是 exit code，0表示正常结束(默认);

func()
{
	name="Hello Yukiii"
	echo $name
	
	return 123				# 如果没有 return 默认 return 0
}

# (1)
func						# 直接用函数名调用，可以把函数理解成自己写的命令

# (2)
output=$(func)				# 发现函数里的 echo 并没有输出，是在这里被截获，以此理解下一个例子
ret=$?

echo "output = $output"		# 获取函数的 stdout		-> Hello Yukiii
echo "return = $ret"		# 获取函数的 exit code	-> 123

函数输入参数，递归函数

func() 
{ 
    if [ $1 -le 0 ] 
    then
        echo 0
        return 0
    fi  

    sum=$(func `expr $1 - 1`)		# $(func) 会截获 func stdout 的值，而不输出
    echo $(expr $sum + $1)			
}

echo $(func 10)
# 可以想想为什么只输出一个 55，不输出其他的中间过程呢？

# C++ 版本
int func(int n)
{
	if (n <= 0) return 0;
	return n + func(n - 1);
}

局部变量

func()
{
	local name=Yukiii
}

exit 命令

可以用来退出当前 shell 进程，并返回退出状态，只有0表示成功;
和 return 的区别在于，return 退出的是函数，exit 退出的是进程;

if [ $# -ne 1 ] 
then
    echo "arguments not valid"
    exit 1
else
    echo "arguments valid"
    exit 0
fi

文件重定向

command > file 将 stdout 输出到 file 中 (覆盖);
command < file 从 file 读入变量;
command >> file 将 stdout 输出到 file 中 (追加);

# (1)
echo -e "Hello \c" > output.txt  
echo "World" >> output.txt  

read str < output.txt  
echo $str  								# -> Hello World

# (2)
# ./test.sh 中有 read a, read b
./test.sh < input.txt > output.txt		# 从 input.txt 中读 a, b，结果输出到 output.txt

引入外部脚本

引入外部脚本等价于把脚本在该处展开执行;

source file / . file

作业 [写多个 shell 脚本，熟悉 shell 语法]

养成**为字符串变量加上 “” **的习惯，比如"$1" "$name"以防变量中有 <space> 而识别成多个参数的情况;
一开始写感觉用变量值都加上${a}，获取 stdout 都加上 $(...)比较好(挺容易漏的…);
homework[3]: 在 stdout 中输出 1~n 的按字典序从小到大的顺序数第 m 个全排列;

#include <iostream>

using namespace std;

const int N = 110;

int n, m;
int a[N];
bool st[N];

bool dfs(int u)
{
    if (u == n)
    {
        m --;
        if (!m)
        {
            for (int i = 0; i < n; i ++) cout << a[i] << ' ';
            cout << endl;
            return true;
        }
        return false;
    }
    
    for (int i = 1; i <= n; i ++)
    {
        if (!st[i])
        {
            a[u] = i;
            st[i] = true;
            if (dfs(u + 1)) return true;
            st[i] = false;
        }
    }
    return false;
}

int main()
{
    cin >> n >> m;
    
    dfs(0);
    
    return 0;
}

#! /bin/bash

read n
read m

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

dfs()
{
	# 测试时，为了防止递归死循环崩掉可以加入下面一行，从而在每层卡一下，也可以 echo 一些信息
	# read tmp

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

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

dfs 0