配置变量与语句

首页 > 代码库 > 配置变量与语句

2024-09-16 06:44:20 205人阅读

bash——CLI(命令行接口)的一种

bash同样属于完整的应用程序，也有这四类文件：

bash的配置文件：

三类：

profile类：

为交互式登录的shell进程实现功能初始化的配置文件；

bashrc类：

为非交互式登录的shell进程实现功能启动配置的配置文件；

logout类：

为交互式登录的shell进程提供终止及清理类功能的配置文件；

shell的类型：

交互式登录的shell：

1.直接通过某个终端输入账号和密码后登录打开的shell进程；

2.使用su - USERNAME或su -l USERNAME执行切换登录打开的shell进程；

非交互式登录的shell：

1.在图形界面下，通过菜单或右键菜单打开的终端的shell进程；

2.使用su USERNAME执行切换登录打开的shell进程；

bash的配置文件：

profile类：

全局：对所有用户都生效的配置文件；

/etc/profile

/etc/profile.d/*.sh

注意：在RHEL或CentOS系列的操作系统中，通常情况下，如果一个配置文件内容很多，格式复杂，我们会将其切割成多个片段，将切割出来的片段统一的存放在"程序名称.d"目录中；在这样目录中所保存的片段文件，大多以统一的文件后缀名来命名；

用户个人：仅仅只是针对某个用户有效的配置文件；

~/.bash_profile

profile类配置的文件的作用：

1.用于定义用户的环境变量；

2.用于运行脚本或执行命令；

bashrc类：

全局：

/etc/bashrc

用户个人：

~/.bashrc

bashrc类配置的文件的作用：

1.用于定义本地变量；

2.用于定义命令的别名；

3.定义umask；

注意：只有超级用户root可以修改全局类的配置文件；普通用户只能修改其家目录中的个人配置文件；

交互式登录的shell进程，会按照顺序加载下列配置文件：

/etc/profile --> /etc/profile.d/*.sh --> ~/.bash_profile --> ~/.bashrc --> /etc/bashrc

非交互式登录的shell进程，会按照顺序加载下列配置文件：

~/.bashrc --> /etc/bashrc --> /etc/profile.d/*.sh

所有在命令行中执行的命令的操作，只要没涉及到文件的修改的，一般都只是针对当前的shell生命周期有效；只要shell进程结束，所有的设置均失效；

配置文件的作用：使得我们赖以生存的配置信息可以长期有效，只要不修改配置文件中的内容，每一次打开shell都会使曾经的配置生效；

让配置文件中新定义的配置能够立即生效的方式：

1.source命令：

source /PATH/TO/SOME_CONF_FILES

. /PATH/TO/SOME_CONF_FILES

2.exec命令：

exec /PATH/TO/SOME_CONF_FILES

bash中变量中存放的字符串处理方式：

弱变量：

1.无需事先定义即可使用；

2.没有变量数据类型的硬性要求，默认是字符型；

1.字符串切片：

${#VAR}：返回字符串类型的变量VAR的长度；

${VAR:offset}：返回字符串变量VAR中第offset个字符后面的内容，不包括第offset个字符；offset的取值范围为：0 ~ $[${#VAR}-1]

${VAR:offset:number}：返回字符串变量VAR中从第offset个字符后开始，长度为number的字符部分；

${VAR: -length}：取字符串最右侧的length个字符；

2.基于模式取字串：

${VAR#*PATTERN}：自左而右，查找VAR变量所存储的字符串中，第一次被PATTERN匹配的字符，删除从字符串开始到PATTERN匹配的字符之间的所有字符；

${VAR##*PATTERN}：自左而右，查找VAR变量所存储的字符串中，所有被PATTERN匹配的字符，删除从字符串开始到最好一个PATTERN匹配的字符之间的所有字符；

${VAR%PATTERN*}：自右而左，查找VAR变量所存储的字符串中，第一次被PATTERN匹配的字符，删除从字符串结尾到PATTERN匹配的字符之间的所有字符；

${VAR%%PATTERN*}：自右而左，查找VAR变量所存储的字符串中，所有被PATTERN匹配的字符，删除从字符串结尾到最好一个PATTERN匹配的字符之间的所有字符；

3.查找替换：

${VAR/PATTERN/SUBSTRING}：在VAR变量中查找匹配PATTERN的内容，将其第一个匹配到的结果更换成SUBSTRING；

${VAR//PATTERN/SUBSTRING}：在VAR变量中查找匹配PATTERN的内容，将其所有匹配到的结果都更换成SUBSTRING；

${VAR/#PATTERN/SUBSTRING}：在VAR变量中查找行首匹配PATTERN的内容，将匹配的结果更换成SUBSTRING；

${VAR/%PATTERN/SUBSTRING}：在VAR变量中查找行尾匹配PATTERN的内容，将匹配的结果更换成SUBSTRING；

4.查找删除：

${VAR/PATTERN}：在VAR变量中查找匹配PATTERN的内容，将其第一个匹配到的结果删除；

${VAR//PATTERN}：在VAR变量中查找匹配PATTERN的内容，将其第一个匹配到的结果删除；

${VAR/#PATTERN}：在VAR变量中查找匹配PATTERN的内容，将其行首匹配到的结果删除；

${VAR/%PATTERN}：在VAR变量中查找匹配PATTERN的内容，将其行尾匹配到的结果删除；

5.字符的大小写转换：

${VAR^^}：将VAR变量中的所有小写字母转换为大写字母；

${VAR,,}：将VAR变量中的所有大写字母转换为小写字母；

6.变量赋值：

${VAR:-value}：如果变量VAR为空或未被设置，那么直接返回value的值；否则返回变量VAR的值；

${VAR:+value}：如果变量VAR不为空，则返回value；

${VAR:=value}：如果变量VAR为空或未被设置，那么直接返回value的值，并且将value的值赋值给变量VAR；否则返回变量VAR的值；

7.变量的间接引用：

如果第一个变量的值恰好是第二个变量的变量名，从第一个变量引用第二个变量的值的方法，就称为变量的间接引用，也称为间接变量引用；

VAR1=VAR2

VAR2=value

bash提供了两种格式的间接变量引用方式：

eval MYVAR=\$$VAR1

MYVAR=$(!VAR1)

1.有大文本文件file1，查询file1里面空行的所在行号；

2.编写shell脚本查询file1以abc结尾的行，并打印出前3行。

回顾：

颜色代码：

\033[

echo -e ""

bash的配置文件：

交互式登录shell进程

非交互式登陆shell进程

profile

bashrc

logout

变量中的字符串处理：

数组

变量：内存的存储空间；

变量的特点：每个变量中只能存放一个数据，变量只能进行一次性的赋值；

存放本班每个人的名字于变量：

1.一次性赋值：

NAME="name1 name2 name3 ..."

2.使用多个变量，分别赋值：

NAME1=xu

NAME2=shen

3.数组变量：

数组：存放一个或多个元素的连续的内存空间；相当于多个变量的集合；

数组元素：数组中任何一个存放数据的存储单元；

数组的索引：

1.数字：索引数组(Index ARRAY)

0,1,2,...

2.名称(字符串)：关联数组(Related ARRAY)

bash4.0以上的版本才支持；

稠密数组和稀疏数组：

稠密数组：索引编号必须连续

稀疏数组：索引编号可以不连续，bash数组属于此类；

声明数组：

1.declare命令

declare -i NAME：将NAME声明为整型变量；

declare -x NAME：将NAME声明为环境变量；

declare -a NAME：将NAME声明为索引数组(如果支持)；

declare -A NAME：将NAME声明为关联数组(如果支持)；

declare -a NAME=("value1" "value2" "value3" ...)

declare -a NAME=([0]="value1" [1]="value2" [5]="value3" ...)

2.直接声明数组：

直接为数组赋值：

ARRAY_NAME=("value1" "value2" "value3" ...) 声明稠密数组；

ARRAY_NAME=([0]="value1" [1]="value2" [5]="value3" ...) 声明稀疏数组；

3.定义数组的元素而创建数组：

ARRAY_NAME[0]=value1

ARRAY_NAME[1]=value2

...

引用数组中元素：

引用变量的方法：${NAME}

引用数组元素的方法：${ARRAY_NAME[INDEX]}

注意：如果不给出INDEX，则表示引用数组的第一个元素，即INDEX=0的元素；

引用整个数组的所有元素：${ARRAY_ANME[*]}或者${ARRAY_ANME[@]}

引用数组的索引：${!ARRAY_ANME[*]}或者${!ARRAY_ANME[@]}

查看数组的长度(数组中有效元素的个数)

${#ARRAY_NAME[*]} 或者 ${#ARRAY_NAME[@]}

数组切片：

${ARRAY_NAME:offset}：显示包括offset数字所表示的索引位置及以后的所有元素；

${ARRAY_NAME:6}：跳过0-5，从6开始显示

${ARRAY_NAME:offset:number}：显示包括offset数字所表示的索引位置及以后的number个元素；${ARRAY_NAME:6:3}：跳过0-5，从6开始显示3个元素；

想数组中追加元素：

1.稠密数组：

ARRAY_NAME[${#ARRAY_NAME[*]}]=valueN

0 1 2 3 4 5 6 7

2.稀疏数组：

ARRAY_ANME[INDEX]=valueN

注意：INDEX必须为未被使用的数组元素索引编号；

撤销数组：

usnet ARRAY_NAME

删除数组中的元素：

unset ARRAY_NAME[INDEX]

RANDOM变量：0-32767

熵池

/dev/random

/dev/urandom

bash脚本编程：

写一个脚本：

创建一个用户alice，如果该用户已经存在，就提示用户已经存在的信息；否则将创建用户；

shell脚本编程的特点：

过程式编程语言

脚本类语言

解释型语言

过程式编程语言：

顺序执行结构：

以从左到右，从上到下顺序执行所有的语句(命令)

shell脚本的主体结构；

选择执行结构：

依照给定条件的逻辑判断结果或者依照可选的取值范围，进而选择某个分支中的语句来执行；

if：分支选择标准：逻辑判断的结果；

case：分支选择标准：根据可选的取值；

循环执行结构：

对于某特定语句，重复执行0次，1次或多次；

for：遍历指定的列表；

while：根据逻辑判断的结果；

until：根据逻辑判断的结果；

select：死循环，利用循环机制提供选择列表；

选择执行结构：

if语句：

if 命令; then 命令; [ elif 命令; then 命令; ]... [ else 命令; ] fi

if语句单分支结构：如果条件为真，则执行then后的命令，否则，不做任何操作；

if CONDITION

then STATEMENT

if CONDITION ; then

STATEMENT1

STATEMENT2

...

注意：想要执行then后面的STATEMENTS，前提条件是CONDITION部分为真；

if语句的双分支结构：如果条件为真，就执行then后面的命令；否则就执行else后面的命令；

if CONDITION ; then

STATEMENT

...

else

STATEMENT

...

if语句的多分支结构：首先判断CONDITION1是否为真，如果为真，则执行第一个then后面的语句；否则就判断CONDITION2是否为真，如果为真，就执行第二个then后面的语句；否则就判断CONDITION3是否为真，如果为真，就执行第三个then后面的语句...；如果所有的CONDITION都为假，就执行else后面的语句；

if CONDITION1 ; then

STATEMENT

...

elif CONDITION2 ; then

STATEMENT

...

elif CONDITION3 ; then

STATEMENT

...

else

STATEMENT

...

建议：if多分支结构，能不用就不用；

练习：

1.写一个脚本，列出系统中默认shell为bash用户；

bash脚本编程之用户交互：

位置参数变量：$1, $2, $3, ...

特殊变量：

$#：所有的位置参数的总数；

$*：给出的所有位置参数的列表；当使用双引号引用时，整个参数列表被当做一个字符串；

$@：给出的所有位置参数的列表；当时有双引号引用时，每个参数作为单独的字符串存在；

$0：所执行的脚本文件自身的路径；

2.写一个脚本，给脚本传递用户名参数，判断参数数量是否合格；并且判断用户是否存在，如果存在，就显示相应信息；否则就创建之并为其设置密码；

#!/bin/bash

if [ $# -ne 1 ] ; then

echo "Only ONE USERNAME can be specified."

exit 5

if id $1 &> /dev/null ; then

echo "$1 exists already."

else

useradd $1

echo $1 | passwd --stdin $1 &> /dev/null

echo "Create $1 successfully."

read命令：

read [-a 数组] [-p 提示符] [-t 超时] [名称 ...]

名称一般为变量名或数组名：如果不写名称，则系统会将read读到的信息保存在REPLY变量中；

LInux哲学思想：尽量不与用户交互；

注意：在使用read命令的时候，通常会使用-t选项来规定超时时间；一旦使用-t选项定义了超时时间，我们必须在后面判断给定的变量是否为空，如果为空需要为变量提供默认值；

写一个脚本：

能够添加或删除用户账户，可以使用-a选项完成添加，使用-d选项完成删除用户；

#!/bin/bash

if [ $# -ne 2 ] ; then

echo "Usage: $(basename $0) -a Username | -d Username."

exit 5

if [ $1 == ‘-a‘ ] ; then

if id $2 &> /dev/null ; then

echo "$2 exists already."

else

useradd $2

echo $2 | passwd --stdin $2 &> /dev/null

echo "Create $2 successfully."

if [ $1 == ‘-d‘ ] ; then

if id $2 &> /dev/null ; then

userdel -r $2

echo "Delte $2 finished."

else

echo "User $2 does not exist."

写脚本解决问题：

1.判断给出的文件大小是否大于100KB，如果大于100KB，就显示这是个大文件；否则就显示这是个小文件；

#!/bin/bash

FILESIZE=$(wc -c < $1)

if [ $FILESIZE -le 102400 ] ; then

echo "Big file."

else

echo "Small file."

2.判断给出的一个字符串是否为整数

#!/bin/bash

if echo $1 | grep "^\<[[:digit:]]\+\>$" &> /dev/null ; then

echo "$1 is integer."

else

echo "$1 is not integer."

周一：7:00 8:00 12:00 1:30 6:00 12:00 100分钟学习linux

回顾：

数组变量：一维数组

与bash交互的方式：

位置参数变量

read命令

if 单分支双分支

位置参数变量：

$1, $2, $3, ...

shift [n]

移位位置参数。

编写简易计算器：

绘制流程图

如果用户存在那么

提示用户存在

否则

创建用户

果如

if id ; then

echo

else

useradd

如果第一个参数是-a 那么

如果第二个参数是用户名并存在那么

显示存在

否则

创建

果如

if语句多分支结构：

if CONDITION1 ; then

STATEMENT

...

elif CONDITION2 ; then

STATEMENT

...

elif CONDITION3 ; then

STATEMENT

...

else

STATEMENT

...

循环执行结构：

将一段代码重复的执行0次、1次或多次；

一个好的循环结构，必须要包括两个最重要的环节：

进入循环的条件：

开始循环时所满足的条件；

退出循环的条件：

循环结束所满足的条件；

bash脚本：

for

while

until

select

for循环：

1.遍历列表

for VAR_NAME in LIST ; do 循环体; done

for VAR_NAME in LIST ; do

循环体

done

VAR_NAME：任意指定的变量名称，变量的值是从LIST中取值并赋值的；

循环体：一般来说是能够用到VAR_NAME的命令或命令的组合；如果循环体中没有包括VAR_NAME，则可能出现死循环；

LIST的生成方式：

1) 直接给出

2) 纯整数列表

seq：输出一个整数列表

seq [FIRST [INCREMENT]] LAST

3) 花括号展开

{FIRST..LAST}

4) 命令的执行结果的返回值

5) GLOBBING

6) 某些变量的引用：$@, $*

写一个脚本：

能够添加或删除用户账户，可以使用-a选项完成添加一个或多个用户，使用-d选项完成删除一个或多个用户；

示例：

#!/bin/bash

if [ $# -lt 2 ] ; then

echo "Usage: $(basename $0) -a User1 User2 ... | -d User1 User2 ..."

exit 5

if [ $1 == ‘-a‘ ] ; then

shift

for I in $* ; do

if id $I &> /dev/null ; then

echo "$I exists already."

else

useradd $I

echo $I | passwd --stdin $I &> /dev/null

echo "Create $I successfully."

done

if [ $1 == ‘-d‘ ] ; then

shift

for J in $* ; do

if id $J &> /dev/null ; then

userdel -r $J

echo "Delte $J finished."

else

echo "User $J does not exist."

done

for循环：

进入循环的条件：LIST中有元素可以取用；

退出循环的条件：LIST中以被取空，再无元素可用；

for循环的特点：

1.几乎不会出现死循环；

2.在执行循环的过程中，需要将这个LIST载入内存；因此对于大列表来说可能会过多的消耗内存和CPU资源；

示例：计算100以内所有整数的和；

#!/bin/bash

read -t 5 -p "Please input a integer[0]: " INTEGER

if [ -z $INTEGER ] ; then

INTEGER=0

if ! echo $INTEGER | grep -q "^\<[[:digit:]]\+\>$" ; then

echo "You must input an integer."

exit 5

for I in $(seq $INTEGER) ; do

# let SUM+=$I

# let SUM=$SUM+$I

SUM=$[SUM+I]

done

echo $SUM

2*[5-(5-1)]-1 = 9

********* 1 0 9 行-1个空格以及 2*(总行数-行)+1 个星星

******* 2 1 7

***** 3 2 5

*** 4 3 3

* 5 4 1

写一个脚本，打印由*组成的倒置的等腰三角形；

#!/bin/bash

LINENUM=$1

for I in $(seq $LINENUM) ; do

for J in $(seq $[I-1]) ; do

echo -n " "

done

for K in $(seq $[2*(LINENUM-I)+1]) ; do

echo -n "*"

done

echo

done

打印九九乘法表

#!/bin/bash

for I in {1..9} ; do

for J in $(seq $I) ; do

echo -ne "$I*$J=$[I*J]\t"

done

echo

done

1X1=1 1X2=2 1X3=3 ... 1X9=9

2X2=4 2X3=6 ... 2X9=18

...

9X9=81

注意：使用for循环嵌套的时候，外层for循环，控制行数的输出；内层for循环，控制列数的输出；

2.控制变量

for (( 表达式1; 表达式2; 表达式3 )); do 命令; done

for (( 表达式1; 表达式2; 表达式3 )) ; do

循环体

done

表达式1：为变量赋初始值；

表达式2：循环的退出条件；

表达式3：变量值的变化规律；

#!/bin/bash

for (( I=1; I<=100; I++ )); do

let SUM+=$I

done

echo $SUM

本文出自 “12481507” 博客，请务必保留此出处http://12491507.blog.51cto.com/12481507/1917962

配置变量与语句

声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉：投诉/举报工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。

联系
我们

首页 > 代码库 > 配置变量与语句

配置变量与语句

看完仍有疑问？有类似问题直接问程序猿