DAY5 C高级笔记

C高级

一、嵌入式系统

应用层       【0--->3G】

内核层       【3--->4G】

硬件层

操作系统：向上提供接口，向下控制硬件

二、操作系统

电脑	windows	macOS	Ubuntu
	NT内核	Unix	Linux
移动设备	安卓	鸿蒙	iOS
	Linux	类Linux	Unix

三、配置Ubuntu的网络

【1】三种联网方式

1.桥接vmnet0------->主机和Ubuntu都有一个ip地址

2.NAT模式vmnet8------->Ubuntu和主机是同一个ip地址

3.主机模式vmnet1------->只能和主机进行通信

【2】网络配置----->桥接

具体配置转(1条消息) ubuntu如何配置桥接网络_qq_49846847的博-CSDN博客

 四、共享文件夹

1、在主机内新建/选择一个文件夹与Ubuntu共享

虚拟机----->设置----->选项------>共享文件夹（总是启用）

2、查看是否共享成功

ls/mnt/hgfs ----->看结果是否有共享文件夹

五、Ubuntu软件安装

【1】离线安装

1.sudo dpkg -i sl ···· ---->软件包 安装软件

2.sudo dpkg -r 软件名 

-r 不完全卸载，不会删除配置文件

3.sudo dpkg -P 软件名

-P完全卸载，删除配置文件

4.sudo dpkg -l 软件名

查看软件的安装状态

5.sudo dpkg -L 软件名

查看软件安装路径

不会检查软件依赖。

【2】在线安装软件

需要更新软件源：阿里源，清华源，163源

sudo apt-get updata

1、在线安装软件

sudo apt-get install 软件名

2、卸载软件

sudo apt-get remove 软件名 （不完全卸载）

sudo apt-get remove 软件名 --purge（完全卸载）

3、完全卸载软件

sudo apt-get purge 软件名

4、下载软件安装包

sudo apt-get download 软件名

下载完安装包后，可以通过dpkg进行离线安装

5、下载软件源码

sudo apt-get source 软件名

需要更改source.list中的文件，把deb-src解除注释

6、清理软件安装包

sudo apt-get clean

/var/cache/apt/archives删除这个目录下的安装包

六、压缩文件

压缩结束之后，源文件不存在，只能压缩文件，不能操作目录

1、gzip

gzip 要压缩的文件 ----->生成.gz后缀的压缩文件

2、bzip2

bzip2 要压缩的文件 ----->生成bz2后缀的文件

3、xz

xz 要压缩的文件 ----->生成.xz后缀的文件

-v，实现压缩的过程

解压缩

1、gunzip

gzip 压缩文件

2、bunzip2

bzip2 压缩文件

3、unxz

xz 压缩文件

三种压缩工具比较

效率（生成的压缩文件更小）:xz>bzip2>gzip

时间（从大到小）:xz>bzip2>gzip

七、归档和拆包 tar

【1】归档/归档并压缩

会保留源文件

tar 可以跟参数

     -c       归档

     -v       显示过程

     -f        后面加文件名，f参数一定放在所有参数的后面

在使用归档并压缩是：后缀一定要与参数对应的工具名一致

    -i         用bzip2工具进行压缩

    -j         用xz工具进行压缩

    -z        用gzip工具进行压缩

sudo tar -czf snap.tar.xz snap    ------------>应该生成.gz后缀

【2】拆包解压缩

tar -xf 要拆包/拆包并压缩的文件名 -------> 万能的拆包解压缩的指令

tar -x 拆包/解压缩

八、文件相关的操作

【1】cat

>重定向符  <

>>追加  <<

cat 1.c >2.c //如果2.c不存在创建2.c/存在,把1.c中的内容重定向到2.c中，覆盖原有内容

cat 1.c >> 2.c //如果2.c不存在创建2.c/存在,把1.c中的内容追加到2.c中

echo 12345 > 2.c //如果2.c不存在创建2.c/存在,把12345重定向到2.c中，覆盖原有内容

echo 12345 >> 2.c //如果2.c不存在创建2.c/存在,把12345追加到2.c中

【2】wc [word count]

wc -w 单词数

      -c 字节数

      -l 行数

wc 文件名

行数 单词数 字节数 文件名

【3】find**重要

底层课程会用到

查找文件

find 路径 -name 查找的内容

find test.c

默认在当前目录下，按名字查找

 【4】head和tail**

head 文件名 -----> 默认显示前十行

tail 文件名 -----> 默认显示文件的后10行

head -n 文件名 -----> 显示文件的前n行

tail -n 文件名 -----> 默认显示文件

head和tail指令，一般不会单独使用，输出文件的第i行 

【5】管道符 |*

把上一条命令的输出作为后一条命令的输入

shell1 | shell2 | shell3·······

把shell1的结果作为shell2的输入

【6】file**

查看文件详细信息

file 文件名

查看文件的详细信息

file a.out ----> ELF类型的，小端存储的可执行文件

【7】查找字符串

grep

grep "查找的字符串" 路径 参数

-n:回显行号

-R:递归搜索

-i:不区分大小写

-w:按单词查找

grep "^helo" ./ -ni ---->开始为hello的字符串

grep "hello$" ./ -ni ----> 结尾为hello的字符串

【8】 剪切字符串

cut

cut -d "分隔符" -f 域 字符串

练习：

把passwd中，ubuntu用户的用户名，描述信息，用户id，组id，组用户，家目录都截取出来。 grep "ubuntu" ./passwd | cut -d ":" -f 1,6

 练习：

1.把www.baidu.com截取出baidu和www

read arr
s=`echo $arr | cut -d "." -f 1`
n=`echo $arr | cut -d "." -f 2`
echo $s
echo $n

2、把/etc/group拷贝到家目录下,截取出root组用户的组id

#!/bin/bash
`cp /etc/group ~/`

s=`grep "root" ~/group | cut -d ":" -f 3`
echo $s

九、文件属性相关操作

文件的类型：7种

bcd-lsp

b:块设备文件

c:字符设备文件

d:目录文件

-：普通文件

l:连接文件---->软链接文件

s:套接字文件

p:管道文件

【1】文件权限

w--2   r--4  x--1

可写  可读  可执行 

         u                       g                        o

所属用户           所属组用户            其他用户

chmod 通过字母表示法

chmod 通过八进制数

八进制数0-7

【2】修改文件的所属组

chgrp 组用户名 文件名

【3】修改文件所属用户

chown 用户名 文件名

chown ubuntu: test.c #把test.c的文件所属用户和文件所属组用户都改成ubuntu

chown ubuntu:root test.c #把test.c的文件所属用户改成Ubuntu，文件所属组用户改成root chown :root test.c #把test.c的文件所属组用户改成

root chown root test.c #把文件所属用户改成root

【4】创建链接文件

硬链接

ln 绝对路径/文件名 绝对路径/连接名

创建了硬链接------> 可以理解为复制了一份，没有重新开辟内存

如果硬链接文件中的内容，修改了那么源文件的内容也会被修改，源文件和硬链接文件中的内容是保持一致 的。

如果删除了源文件，链接文件仍然存在，并且可以使用。

软链接

 ln -s 绝对路径/文件名 绝对路径/链接名

创建软连接------> 可以理解为快捷方式

如果源文件被删除，则链接断开，再重新创建一个同名的源文件，就会重新链接。

当相对路径创建软连接时，如果源文件路径改变，链接文件就会失效

十、开关机的指令

sudo shutdown now #立刻关机

sudo shutdown 10：08 #在10：08分关机

sudo shutdown +10 #在10分钟之后关机

sudo shutdown -r now #立刻关机

sudo shutdown -r 10：08 #在10：08分关机

sudo shutdown -r +10 #在10分钟之后关机

sudo reboot #重启

十一、用户相关的操作

【1】创建用户

sudo adduser 用户名 ---->超级用户才能添加用户或数组

【2】给新用户添加sudo权限

sudo vim/etc/sudoers

【3】查看当前用户

whoami

【4】查看用户ID号

id 用户名

【5】删除用户

sudo deluser 用户名  -------->不会删除用户家目录，rm -r /home/用户名

sudo userdel -r 用户名 ------->删除用户及用户的目录

【6】修改用户的详细信息

修改用户信息的前提是，要修改的用户，在当前开机之后没有登录过

sudo usermod -c 999 ubuntu

#修改用户的描述信息，修改的是开机时候的名字

sudo usermod -m -d /home/hello ubuntu

#把Ubuntu用户的家目录，改为/home/hello

sudo usermod -g 目标组 用户名

#修改用户的所属组为目标组

sudo usermod -l hello ubuntu

#修改用户Ubuntu的名字为hello

【7】特殊字符----通配符

*:匹配一个或者多个字符

?:匹配一个字符

[ ]:1)[1-6]:匹配1-6当中的任一个字符

    2)[1234]:匹配1，2，3，4中的任一个字符

    ?[1,2,3,4]

    ?[1,2,3,4,a,b,c,d]

 shell编程

一、shell

【1】编程语言的分类

解释性语言——shell

编译型语言——c、c++

【3】shell使用的解析器

bash ----> Ubuntu用的解析器

sh ----->开发板常用的

【4】第一个shell脚本

#!/bin/bash
#写明解析器
#打印hello world
echo "hello world"

【5】执行脚本文件

1）修改文件权限

chmod 777 hello.sh #让hello.sh变成一个可执行的脚本文件

./hello.sh #执行脚本文件

#不加#！bin/bash也可以执行

 2）bash脚本文件

bash hello.sh #不需要修改文件权限

#其实是在后台打开了另一个终端，把结果返回到当前终端

#不加#！bin/bash也可以执行

3）source脚本文件

 source hello.sh

#不需要修改文件权限

#当前终端解析指令，在当前终端返回 #

不加#！bin/bash也可以执行

 练习：在脚本文件中完成以下操作:

1.在自己的用户主目录下新建两个子目录subdir1 subdir2

2.将/etc/passwd文件拷贝到subdir1，将/etc/group拷贝到subdir2

3.将subdir2重命名为subdir

4.对subdir1进行打包并且压缩成xz格式

5.将打包后的xz格式文件拷贝到subdir目录下

6.解压subdir目录下的压缩格式文件

7.查看subdir目录下所有的文件，在subdir目录下搜索ubuntu字符串并打印行号，不区分大小写

#!/bin/bash
mkdir ~/subdir1 ~/subdir2
cp /etc/passwd ~/subdir1 
cp /etc/group ~/subdir2
mv ~/subdir2 ~/subdir 
tar -cJf ~/subdir1.tar.xz ~/subdir1 
cp ~/subdir1.tar.xz ~/subdir 
unxz ~/subdir/subdir1.tar.xz 
ls ~/subdir 
grep "ubuntu" ~/subdir/group -ni

 二、shell中的变量

【1】shell中变量的定义和使用

1、在shell脚本中没有数据类型的说法，只有字符串 定义变量的格式：

变量名=变量的值

变量名='变量的值'

变量名="变量的值"

2、变量名的命名规范，和C语言中一致。

3、定义变量时等号的两侧都不能加空格

4、使用变量

     $变量名

     ${变量名} (推荐使用)

5、使用已有的变量给新的变量赋值

#定义变量

#打印变量

#定义变量，变量的值有空格

#定义新的变量，使用已经定义的变量去赋值

#定义新的变量，使用已经定义的变量去赋值，中间带空格

#!/bin/bash
#定义变量
a=10 #定义了一个变量a值为10
b='2 3' #定义了一个变量b值为2 3
#c = 9 #error 等号两侧不能加空格
c=hello
#打印变量
echo ${a}
echo ${b}
echo ${c}
#使用已有的变量给新的变量赋值如果带空格需要使用""
#d=${c} world #error
d="${c} world"
#f='${c} i'
echo ${d}
#echo ${f} ${c} i
f=${c}
echo ${f}

 【2】shell中的位置变量

$0 ----> $n

$1

$2

....

${10} ----> 9之后需要用{10}

【3】 命令置换符

#把指令运行的结果赋给变量。
#!/bin/bash
a=`ls` #把ls的结果赋值给a
echo $a
b=$(ls ~) #把ls ~的结果赋值给b
echo $b
echo -n #输出的内容 ---->输出但是不换行

三、Linux中提供的特殊的系统变量

【1】方式1----->临时生效

env来查看系统变量 PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/us r/local/games:/home/ubuntu/121linux/:/snap/bin

【2】配置环境变量的路径

1）方式1 ---->临时生效

 export PATH=${PATH}:/home/ubuntu

               |                             |

        环境变量              追加的值

只对当前终端有效，退出终端就不生效了

2）方式2---->修改/etc/environment（常用）

 把想要添加的路径加到PATH的最后， 使配置生效

1、重启

2、source /etc/envirnment

特点：对所有用户都生效

3）方式3---->修改/etc/bash.bashrc（常用）

 在文件的最后添加语句

export PATH=${PATH}:/home/ubuntu         把Ubuntu添加到环境变量中

使配置生效

1、重启

2、source /etc/envirnment

特点：对所有用户都生效

4）方式4---->修改家目录下的.bashrc文件

 在文件的最后添加语句

export PATH=${PATH}:/home/ubuntu把Ubuntu添加到环境变量中

使配置生效

1、重启

2、source /etc/envirnment

特点：只对当前用户生效

四、shell中的数组

 【1】数组的定义和初始化

数组名=(数组的值)

#初始化

数组名=(元素值 元素值 元素值 元素值 ····)

数组名=([下标]=元素值 [下标]=元素值 ····)

#第二种初始化方式，元素的个数就是具体值的个数

 【2】访问数组中的元素

${arr[下标]} -----> 一定加{}

 【3】使用数组中的某个元素

${arr[*]} -----> 全部元素

${arr[@]} -----> 全部元素

#个数相关

${#arr[*]} -----> 全部元素的个数

${#arr[@]} -----> 全部元素

${#arr[0]} -----> 打印arr[0]元素的长度

 查看家目录下的文件，把结果放到数组中，打印个数，并且打印所有元素

#!/bin/bash 
arr=(`ls ~`)
echo ${#arr[*]}
echo ${arr[*]}

通过命令行传参，给数组初始化，并且把数组中的第一个元素，修改为hello world，打印数组中 元素的个数，打印所有元素。

#!/bin/bash
arr=($*)
arr[0]='hello word'
echo ${#arr[*]}
echo ${arr[*]}

【4】数组的拼接

数组名=(${arr[*] $brr[*]}) #本质也是数组初始化

 五、shell中的输入输出

【1】输入---->read

read var1 ----> 从终端读入把值赋给var1

read -p "提示字符" 变量名 ------> 输出提示字符

read -t

#read var1
#echo ${var1}
#-p可以输出提示字符
#read -p "请输入：" var2
#echo ${var2}
#read var3 var4 #同时获取两个变量
#echo ${var3}
#echo ${var4}
#控制时间，5秒内不输入内容自动结束
#read -t 5 var1
#echo ${var1}
#控制位数
#read -n 3 var2
#echo ${var2}
#终端输入不显示,类似于输入密码
read -s -n 3 var3
echo ${var3}

 【2】输出---->echo

1. echo默认不解析转义字符加参数-e解析转义字符

2. -n取消换行

#!/bin/bash
a=hello
#echo $a world --->hello world
echo '$a world' #''可以用在变量的值有空格并且只有赋值操作
echo "$a world"
b=hi
echo $a $b
echo '$a $b'
echo "$a $b\n" #echo默认不解析转义字符
echo '${a} ${b}' #变量不会被展开
echo -ne "${a} ${b}\n" #-e解析转义字符

六、shell中的算术运算

**幂运算

【1】使用(())进行算数运算----->常用于算数运算

1. 格式：((表达式1，表达式2，表达式3·····)) ------>取最后一个表达式的结果

2. 在(())中使用变量时，可以加$也可以不加(推荐加)

3. 使用表达式的值，需要加$，变量名=$(())

4. 运算符两边可以加空格，也可以不加空格。

5. ((变量名=表达式))，可以直接在小括号内进行赋值操作

6. (())内，支持C语言的语法，可以完成复杂的运算

7. 支持自增自减运算，不需要转义

使用for循环，实现1-100的累加和

#!/bin/bash
i=0
sum=0
for ((i=0;i<=100;i++))
	{
		((sum=sum+i))
	}
	echo $sum

写一个脚本，传递两个整数给脚本，让脚本分别计算并显示这两个整数的和，差，积，商

read -p "请输入:" a b
echo $((a+b))
echo $((a-b))
echo $((a*b)) #(())中*不需要转义
echo $((a/b))

【2】使用$[]进行算数运算

1. 格式：变量名=$[表达式1，表达式2，表达式3·····]

2. 取最后一个表达式的结果

3. 使用变量可以加$，也可以不加

4. 运算符两个可以加空格，也可以不加空格。

5. 必须使用变量接收表达式的结果 ----> $[]不能单独存在

#!/bin/bash
a=9
b=7
c=$[a + b]
#$[]不能单独存在,需要使用变量接收或者打印
#$[$a-$b]
echo $c
#echo $d

【3】let进行算术运算

1. 格式：let 变量名=表达式

2. 运算符两侧不能加空格

3. 使用变量的时候，可以加$也可以不加$

4. let必须放在表达式起始的位置

#!/bin/bash
a=9
b=7
let c=a+b
echo $c

【4】使用expr进行算数运算

常用于对字符串的操作

1. 格式：expr 表达式

2. 运算符两侧必须加空格

3. 使用变量时必须加$

4. expr不能进行，自增和自减运算

expr $a++ #error

expr $a + 1 #OK

5. 在expr中使用某些字符的时候需要转义，\

6. 如果想把expr的运算结果赋值给变量，需要使用命令置换符

7. expr可以执行更多的运算。

8. expr本质是一个指令

expr ARG1 | ARG2

如果arg1不为0/arg1和arg2同时为真，输出arg1的结果

如果arg2为真，arge为假，才输出arg2的结果

expr ARG1 & ARG2

如果两个都为真输出agr1的结果，如果有一个为假，结果为0

expr ARG1 < ARG2

expr ARG1 = ARG2

expr ARG1 > ARG2 结果为0/1

#!/bin/bash
a=10
b=20
echo -n "a | b ="
expr $a \| $b
echo -n "a & b ="
expr $a \& $b
echo -n "a < b ="
expr $a \< $b
echo -n "a > b ="
expr $a \> $b
echo -n "a != b ="
expr $a != $b

 

#!/bin/bash
str=hello
#判断两个字符串，是否有一个可以作为另一个的子串，返回子串的长度
#返回配完全成功的个数
expr match "$str" "h"
#substr string 位置 截取长度
#如果截取长度超过了字符串的长度，把字符串剩余的部分全部截除
expr substr "$str" 2 8
#获取某个字符，在字符串中第一次出现的位置
expr index "$str" "i"
#求字符串长度
expr length "hi"

通过read读入一个网址，将网址赋值给一个数组，如下： 使用expr以.为界限，截取字符串放入到数组中并输出 arr[0]=www arr[1]=hqyj arr[2]=com 注:不能用cut

#!/bin/bash
read -p "请输入一个网址：" str
len=`expr length "$str"`
a=`expr index "$str" "."`
arr[0]=`expr substr "$str" "1" "$((a-1))"`
str1=`expr substr "$str" "$((a+1))" "$((len-a))"`
len1=`expr length "$str1"`
a1=`expr index "$str1" "."`
arr[1]=`expr substr "$str1" "1" "$((a1-1))"`
arr[2]=`expr substr "$str1" "$((a1+1))" "$len1"`
echo "${arr[0]}"
echo "${arr[1]}"
echo "${arr[2]}"

七、判断语句

【1】if····then···fi

if [ 表达式 ] #单分支 -----> if [ 表达式 ] ; then

then

        shell语句

fi i

f [ 表达式 ] #双分支

then

       shell语句

else

       shell语句

fi

 注意：

1. 一个if后面必须有一个then

2. 一个单独的if后面必须有一个fi，表示if语句结束

【2】if···then···elif···then····fi

if [ 表达式 ] #双分支

then

        shell语句

elif [ 表达式 ] 

then

       shell语句

fi

 练习： 编写脚本 yesorno.sh，提示用户输入yes或no,并判断用户输入的是yes还是no,或是其它信息

#!/bin/bash
read -p "请输入yes或no:" str
if [ "$str" == "yes" ]
then
	echo "输入的为yes"
elif [ "$str" == "no" ]
then
	echo "输入为no"
else
	echo "输入为其他"
fi

【3】[]和test指令的应用

if test 表达式

then

       shell语句

fi

 EXPRESSION1 -a EXPRESSION2

both EXPRESSION1 and EXPRESSION2 are true

EXPRESSION1 -o EXPRESSION2

either EXPRESSION1 or EXPRESSION2 is true

-n STRING

the length of STRING is nonzero

STRING equivalent to -n STRING

-z STRING

the length of STRING is zero

STRING1 = STRING2       ==也可以

the strings are equal

STRING1 != STRING2

the strings are not equa

#!/bin/bash
#read str
#if [ -z $str ]
#then
# echo "str为空"
#else
# echo "str不为空"
#fi
#判断字符串的大小关系，按位判断，遇到不同的就比较
str=hello
str1=hell
if [ "$str" == "$str1" ]
then
echo "str==str1"
else
echo "str!=str1"
fi

 2、对数据的操作

-eq:相等

-ge:大于等于

-gt:大于

-le:小于等于

-lt:小于

-ne:不等于

 

#!/bin/bash
a=100
read b
#对于数据元素的操作
if test $b -ge $a
then
echo "b>=a"
if test $b -eq $a
then
echo "b=a"
else
echo "b>a"
fi
fi

3、对文件相关的操作

#!/bin/bash
#硬链接文件和源文件有相同的inode号
#inode号唯一标识一个文件
if [ yes.sh -ef 1.sh ]
then
echo "有相同的inode号"
fi

3、对文件相关的操作

-b,是否为块设备文件

-c

-d

-e

-L,是否为链接文件

-s

-p

-f,判断是否为普通文件

 4、对文件权限的操作

-r:判断文件是否存在，是否有可读权限

-w:判断文件是否存在，是否有可写权限

-x:判断文件是否存在，是否有可执行权限

 练习： 输入一个文件名，判断文件是否为普通文件，如果为普通文件，判断是否有可执行权限，如果没有可执 行权限，添加可执行权限。

#!/bin/bash
read -p "请输入文件名:" arr
if test -f "$arr"
then
	if test -x "$arr"
	then
		echo "$arr为普通文件有可执行权限"
	else
		chmod 777 "$arr"
		echo "$arr为普通文件无可执行权限已为其添加权限"
	fi
else
	echo "不是普通文件"
fi

输入文件名，判断文件是否存在，再判断是否为目录文件，判断是否为普通文件。

#!/bin/bash
read -p "请输入文件名:" arr
if test -e $arr
then
	if test -f $arr
	then
		echo "为普通文件"
	elif test -d $arr 
	then
		echo "为目录文件"
	fi
else
	echo "不存在"
fi

输入两个文件名，判断文件是否存在，再判断是否为同组用户的文件 -G

#!/bin/bash
read -p "请输入两个文件名" file1 file2
if test -e $file1
then
	if test -e $file2
	then 
		echo "两个文件都存在"
	fi
fi
g1=$( ls "$file1" -lh | cut -d " " -f 4 )
id1=$( grep "^$g1" /etc/group -n | cut -d ":" -f 4 )

g2=$( ls "$file2" -lh | cut -d " " -f 4 )
id2=$( grep "^$g2" /etc/group -n | cut -d ":" -f 4 )
if test $id1 -eq $id2
then
	echo "为同组文件"
else
	echo "不为同组文件"
fi

1. 使用数组统计用户家目录下文件的个数

#!/bin/bash
arr=(`ls ~`)
echo "家文件下的文件数为："${#arr[*]}

2. 输入学生成绩，输出成绩等级，[100-90]A,[90-80]B,[80-70]C,[70-60]D,[60-0]E,小于0，大于100输 入不合理

#!/bin/bash
read -p "请输入学生成绩: " i
if test $i -le 100 -a $i -ge 90
then
	echo "A"
elif test $i -ge 80 -a $i -lt 90
then
	echo "B"
elif test $i -ge 70 -a $i -lt 80
then 
	echo "C"
elif test $i -ge 60 -a $i -lt 70
then
	echo "D"
elif test $i -ge 0 -a $i -lt 60
then
	echo "E"
else
	echo "不合理"
fi

【4】case···in分支语句

case ${变量名} in

       表达式1)

                shell语句

                 ;; ---->相当于switch···case里面的break，;;必须写出来

       表达式2)

               shell语句

                 ;; ·····

                 *)         ---->最后一种情况，不需要加;;

               shell语句

esac

表达式可以是常量

Y|yes|y|YES) ---->匹配四个字符串中的任一个

[1-6]) -----> 匹配1-6中的任一个字符

*} ---->相当于switch···case中的default，但是作为一个通配符，*放置的位置会影响执行的效 果

 1、终端输入年月，判断这个月有多少天。

#!/bin/bash
read -p "请输入年月" year mon
case $mon in
	1|3|5|7|8|10|12)
		echo "$year $mon有31天"
		;;
	4|6|9|11)
		echo "$year $mon有30天"
		;;
	2)
		if [ $(($year%4==0 && $year%100!=0 || $year%400==0)) -eq 1 ]
		then
			echo "$year $mon 有29天"
		else
			echo "$year $mon 有28天"
		fi
		;;
	*)
		echo "$mon输入不合理"
esac

2、终端输入一个字符，判断是否为数字，不是数字判断是否为字母，其他情况，输出是其他字符

 

#!/bin/bash
read -p "请输入一个字符" c
case $c in
	[0-9])
		echo "数字"
		;;
	[a-Z])
		echo "字母"
		;;
	*)
		echo "其他"
esac

八、while循环

【1】格式

while [ 表达式 ] ----> while [ 表达式 ] ; do

do

       shell语句

done

while true -----> while(1)

do    

        语句块

done

 【2】练习

1-100求和

#!/bin/bash
i=0
sum=0
while (( $i<101 ))
do
	((sum=$sum+$i))
	((i++))
done
echo $sum

九、for循环

【1】格式

第一种：

for ((i=0;i<8;i++))

do

     shell语句

done

第二种：

for 变量名 in aa bb cc --->in后面是i可以出现的内容，控制循环次数

do

       shell语句

done

seq队列 ----> 是一条指令，可以和for结合使用，一般放在in后面的位置

seq 起始值 间隔值 终止值

可以使用命令置换符，获取seq的结果。

 1、求1-100的和

#!/bin/bash
i=0
sum=0
for i in `seq 0 1 100`
do
	((sum=$sum+$i))
done
echo $sum

2、求数组元素的和

#!/bin/bash
i=0
sum=0
arr=(11 22 33)
#使用c风格的for循环实现数组求和
for ((i=0;i<3;i++))
do
((sum=sum+${arr[$i]}))
done
echo $sum
arr=(11 22 33 44 55) #数组中的所有元素${arr[*]}
sum=0
for i in ${arr[*]}
do
((sum=sum+i))
done
echo $sum

3、使用for循环，计算家目录下普通文件和目录文件的个数

#!/bin/bash
#计算家目录下，普通文件和目录文件的个数
file=0
dir=0
for i in `ls ~`
do
if [ -f /home/ubuntu/$i ]
then
((file++))
elif [ -d /home/ubuntu/$i ]
then
((dir++))
fi
done
echo $file
echo $dir

描述写一个 bash脚本以输出数字 0 到 200 中 7 的倍数(0 7 14 21...)的命令

#!/bin/bash
sum=0
for i in `seq 0 7 200`
do 
	((sum++))
	echo $i
done
echo $sum

输入一个无符号的八位数，循环输出他的二进制数，要求使用位运算。

#!/bin/bash
read -p "请输入一个数" var
for i in `seq 0 1 7`
do
	if [ $((var&0x80)) -gt 0 ]
	then 
		echo -n "1"
	else
		echo -n "0"
	fi
	((var=var<<1))
done
echo ""

十、select···in语句

【1】格式

#!/bin/bash
select var in aa bb cc dd
do
echo $var
done
#运行效果
ubuntu@ubuntu:day4$ bash sele.sh
1) aa
2) bb
3) cc
4) dd
#?       --->提示输入
         --->可以输入具体的数字，选择某一项
         --->如果什么都不输入直接回车，再输出提示

 【2】与case···in结合使用

#!/bin/bash
select fruit in apple banana grape orange
do 
	case $fruit in
		"apple")
			echo "一天一苹果医生远离我"
			;;
		"banana")
			echo "巴拉拉"
			;;
		"grape")
			echo "夏波丽丽葡萄"
			;;
		"orange")
			echo "好吃"
	esac
done

十一、break/continue 

1、break n ----->跳出n层循环

     break 1 ----> 跳出一层循环，1可以不写

     break 2 ----> 跳出两层循环

2、continue n ----->跳出n层本次循环

     continue 1 ----> 跳出一层本次循环，1可以不写

     continue 2 ----> 跳出两层本次循环

 1、打印直角三角形，使用break，seq，终端输入三角形的行数---->read读

#!/bin/bash
read -p "请输入层数" c
i=0
j=0
for i in `seq 1 1 $c`
do
	for j in `seq 1 1 $c`
	do
		echo -n "*" 
		if [ $j -ge $i ]
		then
			break 1
		fi

	done
	echo ""
done

十一、shell中的函数 

 【1】格式

function 函数名()

{

shell语句

}

1>shell中定义函数时，可以不加function,也可以加function，推荐加

2>shell中没有参数列表，具体根据调用的格式决定

3>shell中函数没有返回值类型，具体根据函数内部书写格式决定

4>shell中仍然遵循，先定义后调用的规则，但是shell中，函数的定义和声明不能分开,只能把函数定义在 函数调用的上方

5>shell函数中的变量，是全局变量

补充：shell修饰变量

unset :清空变量 -----> 不能清空只读变量

readonly :只读变量

local :局部变量 ----->只能在函数中定义

【2】参数获取

通过位置变量获取参数

$1····$n---->9以上${10}

$#传参个数

$* $@ 所有参数

 【3】返回值

只能返回[0-255]之间的数
#!/bin/bash
sum=9
#readonly sum=9 #readonly修饰的变量不能被清空
#echo $sum
#unset sum
#echo $sum
#local a=8
#echo $a
#function add()
#{
# return $(($1+$2))
#}
#add $1 $2
add()
{
echo $(($1+$2))
}
sum=`add 255 9` #只能返回[0-255]之间的数
#如果想计算，超过255的数，就不能返回结果
#可以使用echo打印，如果相接收，使用命令置换符接收
a=`echo $sum`
echo $sum

#!/bin/bash
function add()
{
return $(($1+$2)) #add函数有返回值
}
function add2()
{
echo $(($1+$2))
}
a=`add 1 3`
sum=$? #$?是上一条指令的返回值
#add2 10 9 #----->命令的执行结果是19
sum1=`add2 10 9`
echo "sum=$sum sum1=$sum1"
echo "a=$a" #空

输入用户的名字，判断该系统上是否存在该用户 (封装为函数get_user_line()，若用户存在返回在/etc/passwd中的行号)2.若存在该用户将这个用户 名和uid和gid显示出来 (封装为函数get_user_info()，将上述的函数返回的行号传递到这个函数中，返回uid和gid)

#!/bin/bash
read -p "请输入用户" name
function get_user_line()
{
str=`grep "^$name" /etc/passwd -n`
num=`echo $str | cut -d ":" -f 1`
if [ -z $str ]
then
return "$name不存在"
else
return $num
fi
}
function get_user_info()
{
str=`head -$1 /etc/passwd | tail -1`
uid=`echo $str | cut -d ":" -f 3`
gid=`echo $str | cut -d ":" -f 4`
echo $uid
echo $gid
}
get_user_line $name
a=$?
get_user_info $a

十二、Makefile

【1】什么是Makefile

是一个工程项目管理工具

【2】学习Makefile的前提

1. 编译过程

2. 变量基础

3. 目标和依赖的思想

预处理 编译 汇编 链接

gcc -E .c -o .i

gcc -S .i -o .s

gcc -c .s -o .o --->Makefile

gcc .o -o exe

 .i文件，依赖于.c文件，

【3】Makefile的语法

规则和依赖组成

变量

规则的构成：

目标

依赖

命令

一个目标可以没有依赖，可以没有命令

一个目标也可以有多个依赖

一个规则必须有一个目标

 Makefile把程序的执行分为两步

源文件----->汇编文件

汇编文件----->可执行文件

当文件发生修改，Makefile会根据，文件的时间戳判断文件是否更新，再决定是否重新编译。

all:hello
hello:main.o hello.o
gcc main.o hello.o -o hello
main.o:main.c
gcc -c main.c -o mian.o
hello.o:hello.c
gcc -c hello.c -o hello.o

 【4】Makefile中的变量

可以理解为宏定义 ${变量名} $(变量名)

变量的概念

=：延迟赋值

+=：追加赋值

:=:直接赋值

？=:条件复制 ----->如果变量前面有值就不赋值

自动变量

$^:所有依赖

$@:所有目标

$<:第一个依赖

 第二版Makefile

CC = gcc
EXE = hello
OBJS += main.o
OBJS += hello.o
#引入%通配符
#自动变量$@,$^,$<是针对一条规则而言的
#规则：目标、依赖和命令构成
all:${EXE}
${EXE}:${OBJS}
${CC} $^ -o $@
main.o:main.c
${CC} -c $^ -o $@
hello.o:hello.c
${CC} -c $^ -o $@
#会检查文件的时间戳
clean:
rm *.o ${EXE}

 【5】最终版Makefile

引入通配符

% ------> 目标和依赖之间的唯一匹配

CC = gcc
EXE = hello
OBJS += main.o
OBJS += hello.o
#引入%通配符
#自动变量$@,$^,$<是针对一条规则而言的
#规则：目标、依赖和命令构成
all:${EXE}
${EXE}:${OBJS}
${CC} $^ -o $@
%.o:%.c
${CC} -c $^ -o $@
#会检查文件的时间戳
clean:
rm *.o ${EXE}