精华内容
下载资源
问答
  • shell脚本基础

    万次阅读 多人点赞 2019-11-21 13:14:10
    文章目录shell脚本结构和执行方法shell脚本中date命令的用法 shell脚本结构和执行方法 1.shell脚本开头需要加#!/bin/bash 2.以#开头的行作为注释 3.脚本的名字以.sh结尾,用于区分这是一个shell脚本 4.执行方法有两...

    shell简介:shell是一种脚本语言,可以使用逻辑判断、循环等语法,可以自定义函数,是系统命令的集合

    shell脚本结构和执行方法

    1.shell脚本开头需要加#!/bin/bash
    2.以#开头的行作为注释
    3.脚本的名字以.sh结尾,用于区分这是一个shell脚本
    4.执行方法有两种:
    1)bash test.sh
    2)./test.sh
    #第二种执行方式需要有执行权限(chmod +x test.sh)
    5.查看脚本执行过程:bash -x test.sh
    6.查看脚本是否语法错误:bash -n test.sh

    #bash可以使用sh命令代替(在/usr/bin目录下,sh是bash的软连接文件)

    date命令的用法

    年月日:

    [root@linux ~]# date
    2019年 11月 19日 星期二 16:20:04 CST
    [root@linux ~]# date +%Y-%m-%d
    2019-11-19
    [root@linux ~]# date +%Y
    2019
    [root@linux ~]# date +%m
    11
    [root@linux ~]# date +%d
    19
    [root@linux ~]# date +%y	#表示2019年,忽略20
    19
    [root@linux ~]# date +%F
    2019-11-19
    

    时分秒:

    [root@linux ~]# date
    2019年 11月 19日 星期二 16:27:46 CST
    [root@linux ~]# date +%H-%M-%S
    16-28-04
    [root@linux ~]# date +%T
    16:28:09
    

    周:

    [root@linux ~]# date +%w	#表示星期几
    2
    [root@linux ~]# date +%W	表示今年的第多少周
    46
    

    时间戳:

    [root@linux ~]# date +%s	#表示1970年1月1日到现在
    1574152197
    [root@linux ~]# date -d @1534150197		#倒推时间戳
    2018年 08月 13日 星期一 16:49:57 CST
    

    补充:

    [root@linux ~]# date
    2019年 11月 19日 星期二 16:34:37 CST
    
    [root@linux ~]# date -d "+3day"			#三天后
    2019年 11月 22日 星期五 16:34:45 CST
    
    [root@linux ~]# date -d "-3day" +%F		#三天前
    2019-11-16
    
    [root@linux ~]# date -d "-3 month" +%F		#三个月前
    2019-08-19
    
    [root@linux ~]# date -d "-30 min" +%F_%T	#30分钟前
    2019-11-19_16:06:16
    

    shell中变量的用法

    使用变量的情况:

    1.当脚本中使用某个字符串较频繁并且字符串长度很长时就应该使用变量代替
    2.使用条件语句时,常使用变量判断大小 if [ $a -gt 1 ]; then … ; fi
    3.引用某个命令的结果时,用变量替代 n=wc -l test.txt
    4.写和用户交互的脚本时,变量也是必不可少的 :

    [root@linux ~]# read -p "input a number:" n
    input a number:15
    [root@linux ~]# echo $n
    15
    

    如果没有自定义变量,可以使用内置变量$REPLY:

    [root@linux ~]# read -p "input a number:" 
    input a number:9
    [root@linux ~]# echo $REPLY
    9
    

    5.内置变量

    $1,$2,$3,$# ($1 第一个参数,$2 第二个参数,$#表示参数的和):

    #!/bin/bash
    echo "第一个参数是$1"
    echo "第二个参数是$2"
    echo "一共有$#个参数"
    

    结果示例:

    [root@linux ~]# ./test.sh a b c
    第一个参数是a
    第二个参数是b
    一共有3个参数
    

    $0表示脚本名(根据执行脚本方式的不同结果不同):

    #!/bin/bash
    echo "\$0是:$0"
    

    结果示例:

    [root@linux ~]# /root/test.sh 
    $0是:/root/test.sh
    [root@linux ~]# ./test.sh 
    $0是:./test.sh
    [root@linux ~]# sh test.sh 
    $0是:test.sh
    

    6.数学运算a=1;b=2; c=$(($a+$b))或者$[$a+$b]:

    [root@linux ~]# a=1
    [root@linux ~]# b=2
    
    [root@linux ~]# c=$(($a+$b))
    [root@linux ~]# echo $c
    3
    [root@linux ~]# d=$[$a+$b]
    [root@linux ~]# echo $d
    3
    

    shell逻辑判断语法

    格式1:if 条件 ; then 语句; fi

    #!/bin/bash
    read -p "input a number:" n
    if [ $n -gt 5 ]
    then
        echo "1"
    fi
    

    格式2:if 条件; then 语句; else 语句; fi

    #!/bin/bash
    read -p "input a number:" n
    if [ $n -gt 5 ]
    then
        echo "1"
    else
        echo "2"
    fi
    

    格式3:if …; then … ;elif …; then …; else …; fi

    #!/bin/bash
    read -p "input a number:" n
    if [ $n -gt 90 ]
    then
        echo "A"
    elif [ $n -gt 70 ]
    then
        echo "B"
    else
        echo "C"
    fi
    

    格式4:if 中嵌套 if

    #!/bin/bash
    read -p "input a number:" n
    if [ $n -gt 70 ]
    then
        echo "OK"
        if [ $n -gt 90 ]
        then
             echo "A"
        elif [ $n -gt 80 ]
        then
    	 echo "B"
        else
    	 echo "C"
        fi
    else
        echo "???"
    fi
    

    补充:
    -gt 大于(>)
    -lt 小于 (<)
    -ge 大于等于 (>=)
    -le 小于等于 (<=)
    -eq 等于 (==)
    -ne 不等于 (!=)

    可以使用 && || 结合多个条件

    大于5并且小于10:

    if [ $a -gt 5 ] && [ $a -lt 10 ]; then
    

    第二种写法:

    if [ $a -gt 5 -a $a -lt 10 ]; then
    

    #-a表示:and

    大于5或小于3:

    if [ $b -gt 5 ] || [ $b -lt 3 ]; then
    

    第二种写法:

    if [ $b -gt 5 -o $b -lt 3 ]; then
    

    #-o表示or

    if判断文件或目录的属性

    [ -f file ] 判断是否是普通文件,且存在
    [ -d file ] 判断是否是目录,且存在
    [ -e file ] 判断文件或目录是否存在
    [ -r file ] 判断文件是否可读
    [ -w file ] 判断文件是否可写
    [ -x file ] 判断文件是否可执行

    补充:
    1.如果判断对象为socket等特殊文件,可以使用-e判断是否存在

    2.root用户对文件的读写比较特殊,即使一个文件没有给root用户读或者写的权限,root用户照样可以读或者写(x:执行权限除外)

    3.取反使用感叹号:

    if [ ! -f filename ]
    

    if判断的一些特殊用法

    判断变量为空时:

    if [ -z "$a" ]; then ...
    

    判断变量不为空时:

    if [ -n "$a" ]; then ...
    

    判断命令成功时:

    if ls /tmp/test.sh; then ...
    

    #判断文件是否存在的用法,当ls命令执行成功时,要怎样…

    将产生的信息重定向到/dev/null:

    if ls /tmp/test.sh &> /dev/null; then ...
    

    #不管ls命令执行是否成功,都将输出的信息流写入到/dev/null,不打印

    判断文件是否包含关键字:

    if grep -q '123' /tmp/test.sh; then ...
    

    #当文件包含关键字时,要怎样…,-q:包含关键字时,不输出匹配到的信息

    if [ $a -gt 5 ]的另一种写法:

    if (($a>5)); then ...
    

    #[ ] 中不能使用<,>,==,!=,>=,<=这样的符号,但双括号中可以

    shell中case判断用法

    case  变量名 in 
       value1)    
            command  
    	    ;;
       value2)      
            command  
            ;; 
       *)  
            commond 
            ;;     
         esac
    
    在case中,可以在条件中使用|,表示或的意思:
        2|3)     
    	    command
    	    ;;
    

    示例:

    #!/bin/bash
    read -p "input a number: " n
    #判断输入内容是否为空
    if [ -z "$n" ]
    then
        echo "Please input a number."
        exit 1
    fi
    #判断输入内容是否含有非数字
    n1=`echo $n|sed 's/[0-9]//g'`
    if [ -n "$n1" ]
    then
     echo "Please input a number."
     exit 1
    fi
    #当输入内容非空且为纯数字时,开始判断
    if [ $n -lt 60 ] && [ $n -ge 0 ]
    then
        t=1
    elif [ $n -ge 60 ] && [ $n -lt 80 ]
    then
        t=2
    elif [ $n -ge 80 ]  && [ $n -lt 90 ]
    then
        t=3
    elif [ $n -ge 90 ] && [ $n -le 100 ]
    then
        t=4
    else 
        t=0
    fi
    
    case $t in
        1)
    		echo "D"
            ;;
        2)
            echo "C"
            ;;
        3)
            echo "B"
            ;;
        4)
            echo "A"
            ;;
        *)
            echo "The number range must be 0-100."
            ;; 
    esac
    

    for、while循环

    for循环语法:for 变量名 in 条件; do …; done

    示例一:打印1-100的数字并求和

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

    seq1 2 10:打印结果1,3,5,7,9(2表示步长,打印结果间隔为2)
    seq10 -2 1:打印结果10,8,6,4,2(倒序打印步长为负)
    seq -w 1 10:打印结果01,02,03,04,05,06,07,08,09,10(-w 表示等宽)

    示例二:打印指定目录下的文件

    #!/bin/bash
    cd /etc
    for i in `ls /etc`
    do
    	if [ -f $i ]
    	then
    		ls -l $i
    	fi
    done
    

    while循环语法:while 条件; do … ; done

    示例一:平均1分钟负载大于5时,发送邮件

    #!/bin/bash
    while :
    do
            load=`w|head -1|awk -F 'load average: ' '{print $2}'|cut -d . -f1`
            if [ $load -gt 5 ]
            then
                    d=`date +%F_%T`
                    top -nb1|mail -s "$d load is high: $load" asnfy@qq.com
            fi
            sleep 30
    done
    

    示例二:判断输入内容是否为空或包含非数字

    #!/bin/bash
    while :
    do
        read -p "Please input a number: " n
        if [ -z "$n" ]
        then
    		echo "you need input sth."
    		continue
        fi
        n1=`echo $n|sed 's/[0-9]//g'`
        if [ -n "$n1" ]
        then
    		echo "you just only input numbers."
            continue
        fi
        break
    done
    echo "you input number is $n"
    

    #如果输入的内容为空为包含非数字,continue跳出重新执行,否则break结束循环

    补充:
    当使用for遍历一个文件中的每行内容时(for i in `cat test`),如果某行中有一个或多个空格,这行的内容就会被当做两行或多行打印,为了避免这种情况可以使用while来循环输出文件中的每行内容
    示例:

    #!/bin/bash
    cat test.txt|while read i
    do
    	echo $i
    done
    

    #使用while遍历文件中的内容,即使某行有空格,也会被正常打印

    break、continue、exit

    break:直接结束循环

    #!/bin/bash
    for i in `seq 1 5`
    do
    	echo "第一次输出:$i"
    	if(($i==3))
    	then
    		break
    	fi
    	echo "第二次输出:$i"
    done
    echo "循环结束"
    

    执行结果:

    [root@linux ~]# sh a.sh 
    第一次输出:1
    第二次输出:1
    第一次输出:2
    第二次输出:2
    第一次输出:3
    循环结束
    

    continue:忽略后面的代码,从新开始循环

    #!/bin/bash
    for i in `seq 1 5`
    do
    	echo "第一次输出:$i"
    	if(($i==3))
    	then
    		continue
    	fi
    	echo "第二次输出:$i"
    done
    echo "循环结束"
    

    执行结果:

    [root@linux ~]# sh a.sh 
    第一次输出:1
    第二次输出:1
    第一次输出:2
    第二次输出:2
    第一次输出:3
    第一次输出:4
    第二次输出:4
    第一次输出:5
    第二次输出:5
    循环结束
    

    注意:循环支持嵌套,如果一个循环中嵌套了多个循环,break或continue只能作用于所在的某个循环中

    exit:直接退出脚本

    #!/bin/bash
    for i in `seq 1 5`
    do
    	echo "第一次输出:$i"
    	if(($i==3))
    	then
    		exit	
    	fi
    	echo "第二次输出:$i"
    done
    echo "循环结束"
    

    执行结果:

    [root@linux ~]# sh a.sh 
    第一次输出:1
    第二次输出:1
    第一次输出:2
    第二次输出:2
    第一次输出:3
    

    #循环外的echo语句没有输出,当脚本中遇到exit,会直接退出,后面所有内容都不再执行

    补充:
    当脚本遇到exit直接退出后,echo $? 查看执行结果会显示0,表示执行成功,所以一般使用exit会在后面加上指定的非0数字,方便调用结果(比如:exit 5)

    shell中的函数

    函数(也叫方法)就是把一段代码整理到了一个小单元中,并给这个小单元起一个名字,当用到这段代码时直接调用这个小单元的名字即可

    格式:

    function f_name() 
    { 
    	command
    }
    

    示例一:调用该函数,输出函数的第一、第二个参数以及参数总数

    #!/bin/bash
    function test()
    {
    	echo $1 $2 $#
    }
    test a b c
    

    执行结果:

    [root@linux ~]# sh fun1.sh 
    a b 3
    

    示例二:将两个参数求和

    #!/bin/bash
    function test()
    {
    	n=$[$1+$2]
    	echo $n
    }
    test 1 2
    

    执行结果:

    [root@linux ~]# sh fun2.sh 
    3
    

    示例三:输出指定网卡的IP地址

    #!/bin/bash
    function ip()
    {
    	ifconfig |grep -A1 "$1:" |tail -1 |awk '{print $2}'
    }
    read -p "Please input the eth name: " e
    eth=`ip $e`
    echo "$e address is $eth"
    

    执行结果:

    [root@linux ~]# sh fun3.sh 
    Please input the eth name: ens33
    ens33 address is 192.168.234.128
    

    补充:
    1.函数在脚本中需要放在最前面
    2.定义函数时允许只写函数名,可以忽略掉function

    shell中的数组

    数组可以理解为变量,与普通变量不同的是,数组可以定义多个值,把每个值叫做元素

    定义一个数组:

    [root@linux ~]# array=(a b c)
    

    #数组名:array,包含3个元素:a,b,c

    获取数组的第一个元素:

    [root@linux ~]# echo ${array[0]}
    a
    

    获取数组的第二个元素:

    [root@linux ~]# echo ${array[2]}
    c
    

    #元素的排序是以0开始的:0代表第一个元素,1代表第二个元素,以此类推…

    获取数组所有元素的两种方式:

    [root@linux ~]# echo ${array[@]}
    a b c
    [root@linux ~]# echo ${array[*]}
    a b c
    

    获取数组元素个数的两种方式:

    [root@linux ~]# echo ${#array[*]}
    3
    [root@linux ~]# echo ${#array[@]}
    3
    

    修改第一个元素的值:

    [root@linux ~]# array[0]=x
    [root@linux ~]# echo ${array[@]}
    x b c
    

    增减一个元素:

    [root@linux ~]# array[3]=y
    [root@linux ~]# echo ${array[@]}
    x b c y
    

    删除第一个元素:

    [root@linux ~]# unset array[0]
    [root@linux ~]# echo ${array[@]}
    b c y
    

    删除数组:

    [root@linux ~]# unset array
    

    数组的分片:

    添加一个数组:

    [root@linux ~]# array=(`seq 1 5`)
    [root@linux ~]# echo ${array[@]}
    1 2 3 4 5
    

    从第1个元素开始截取3个元素:

    [root@linux ~]# echo ${array[@]:0:3}
    1 2 3
    

    #0表示第一个元素,3表示截取元素的数量

    从第4个元素开始截取2个元素:

    [root@linux ~]# echo ${array[@]:3:2}
    4 5
    

    #3表示第四个元素,2表示截取元素的数量

    从倒数第3个元素开始截取3个元素:

    [root@linux ~]# echo ${array[@]:0-3:3}
    3 4 5
    

    #0-3表示倒数第三个元素,3表示截取元素的数量

    数组的替换:

    将数组中值为3的元素替换为33:

    [root@linux ~]# echo ${array[@]/3/33}
    1 2 33 4 5
    [root@linux ~]# echo ${array[@]}
    1 2 3 4 5
    

    #该操作只是替换输出的结果,并没有真正替换数组中的元素

    替换数组中的元素:

    [root@linux ~]# array=(${array[@]/5/55})
    [root@linux ~]# echo ${array[@]}
    1 2 3 4 55
    

    #该操作是直接替换数值中的值,而不是只替换输出结果

    展开全文
  • Linux中编写Shell脚本

    万次阅读 多人点赞 2018-10-08 11:22:35
    Shell脚本的执行 Shell脚本编写规范 Shell 中的变量 变量的算术运算 双小括号 (()) 数值运算命令的用法 let 运算命令的用法 expr 命令的用法 br 命令的用法 $[]符号的运算示例 Shell脚本的条件测试 几种...
    展开全文
  • Shell脚本

    万次阅读 2020-10-04 20:29:52
    Shell脚本 这里写目录标题Shell脚本1.Shell脚本简介2.Shell2.1 Shell 脚本的解释器2.2 脚本的编写规范2.3 执行脚本的三种方式2.4变量的声明2.5变量的引用2.6删除变量 只读变量2.7字符串使用2.8字符串长度及截取2.9...

    Shell脚本


    1.Shell脚本简介

    Shell 是一个用 C 语言编写的程序,通过 Shell 用户可以访问操作系统内核服务。Shell 既是一种命令语言,又是一种程序设计语言。Shell script 是一种为 shell 编写的脚本程序。Shell 编程一般指 shell脚本编程,不是指开发 shell 自身。Shell 编程跟 java、php 编程一样,只要有一个能编写代码的文本编辑器和一个能解释执行的脚本解释器就可以了。Linux 的 Shell 解释器 种类众多,一个系统可以存在多个 shell,可以通过 cat /etc/shells 命令查看系统中安装的 shell解释器。Bash 由于易用和免费,在日常工作中被广泛使用。同时,Bash 也是大多数Linux 系统默认的 Shell。

    2.Shell

    2.1 Shell 脚本的解释器

    /bin/sh
    /bin/bash
    /sbin/nologin
    /bin/dash
    /bin/tcsh
    /bin/csh
    

    2.2 脚本的编写规范

    首行描述解释器 #!/bin/bash

    2.3 执行脚本的三种方式

    1、bash 脚本名称 脚本参数
    2、 sh 脚本名称 脚本参数
    3、 ./脚本名称 脚本参数【./脚本名称之间没有空格】【chmod 777 脚本名称】

    2.4变量的声明

    变量名=”值”【中间不能有空格】
    变量名要求 字母或下划线或数字(开头不能是数字)构成

    2.5变量的引用

    使用$ 或 ${}引用变量

    2.6删除变量 只读变量

    删除 unset 变量名
    只读 readonly 变量名

    2.7字符串使用

    双引号(””):内部可以使用变量
    单引号(‘’):内部所有的原样输出
    反引号(``):表示可执行

    2.8字符串长度及截取

    长度: echo ${#skill}
    截取: echo ${str:2:2} 【在第二个字符开始截取截取两位】

    2.9脚本参数传递

    bash 脚本名 参数1 参数2 参数3 。。。。。。
    脚本内
    $0 脚本名称
    $1 参数1
    $2 参数2
    $n 参数n
    $* 所有参数
    $# 参数的个数

    2.10算数运算符

    加法计算 expr 2 + 2
    乘法计算 expr 2 \* 2

    2.11流程控制if

    if [ $a -gt 10 ];then
    代码1
    elif [ $a -lt 10 ];then
    代码2
    else 代码3
    fi

    2.12关系运算符

    在这里插入图片描述

    2.13循环

    For 循环
    For aa in XXXX
    do
    循环体
    done

    While循环
    While 条件 ;
    do
    循环体
    done

    跳出循环
    跳出所有循环 break
    跳出当前循环,进入下一次循环 continue

    case ()

    case 值 in
    结果1) 结果1对应的操作;;
    结果2) 结果2对应的操作;;
    结果3) 结果3对应的操作;;
    esac

    2.14接收控制台数据

    read 变量名
    函数的使用
    函数声明:
    [function] 函数名(){
    函数体
    $参数1
    $参数2
    $参数3
    }

    函数调用 函数名 参数1 参数2 参数3

    2.15数组

    数组声明: 数组名称=(元素1 元素2 元素3 元素4)
    数组的使用
    单个使用 echo 数组名[角标] 【角标从0开始】
    遍历数组
    for var in ${my_arr[*]}
    do
    echo $var
    done

    2.16文件加载

    在文件中添加 . 脚本名称 或者 source 脚本名称
    #!/bin/bash
    source ./test1.sh # 加载test1.sh 的文件内容

    展开全文
  • 收藏!一篇教会你写90%的shell脚本

    万次阅读 多人点赞 2019-09-06 18:18:36
    还不会写shell脚本?这篇文章教会你写90%的shell脚本

    在公司项目的开发过程中,需要编写shell脚本去处理一个业务,在编写过程中发现自身对shell脚本的知识不够完善,顾整理一下,本文章主要内容来自菜鸟教程 , 也添加了一些知识点

    看完这边文章应该就可以独立完成大部分脚本得编写

    shell脚本?

    在说什么是shell脚本之前,先说说什么是shell。

    shell是外壳的意思,就是操作系统的外壳。我们可以通过shell命令来操作和控制操作系统,比如Linux中的Shell命令就包括ls、cd、pwd等等。总结来说,Shell是一个命令解释器,它通过接受用户输入的Shell命令来启动、暂停、停止程序的运行或对计算机进行控制。

    shell 是一个应用程序,它连接了用户和 Linux 内核,让用户能够更加高效、安全、低成本地使用 Linux 内核,这就是 Shell 的本质。

    shell 本身并不是内核的一部分,它只是站在内核的基础上编写的一个应用程序。

    那么什么是shell脚本呢?

    shell脚本就是由Shell命令组成的执行文件,将一些命令整合到一个文件中,进行处理业务逻辑,脚本不用编译即可运行。它通过解释器解释运行,所以速度相对来说比较慢。

    shell脚本中最重要的就是对shell命令的使用与组合,再使用shell脚本支持的一些语言特性,完成想要的功能。

    微信扫下述二维码关注公众号,回复“源码”,即可免费获取“经典飞机大战源码 + 经典像素鸟游戏源码 + 人事管理系统源码 ”!
    匠心Java*

    注释

    “# ”开头的就是注释,被编译器忽略

    • 单行注释: #
    • 多行注释: :<<EOF … EOF 或者 :<<! … ! (:<< 标识多行注释开始,并指定一个标识符作为开始结束的标志)

    变量

    变量类型
    运行shell时,会同时存在三种变量:

    1. 局部变量:局部变量在脚本或命令中定义,仅在当前shell实例中有效,其他shell启动的程序不能访问局部变量。
    2. 环境变量:所有的程序,包括shell启动的程序,都能访问环境变量,有些程序需要环境变量来保证其正常运行。必要的时候shell脚本也可以定义环境变量。
    3. shell变量:shell变量是由shell程序设置的特殊变量。shell变量中有一部分是环境变量,有一部分是局部变量,这些变量保证了shell的正常运行

    变量操作

    • 创建普通变量: name=“test” (=两边不可有空格)
    • 创建只可函数体中使用的局部变量: local name=“test” (使用local修饰的变量在函数体外无法访问,并且local只能在函数体内使用)
    • 使用变量: echo $name 或者 echo ${name} (推荐使用大括号版)
    • 变量重新赋值: name=“new_test” (将原值覆盖)
    • 只读变量: name=“only_read” -> readonly name (使用readonly标识后的变量,不可被修改)
    • 删除变量: unset name; (删除之后不可访问,删除不掉只读变量)

    字符串变量
    1)单引号

    • 单引号变量var='test' ,只能原样输出,变量无效
    • 单引号中不能出现一个单独的单引号,转义也不可以

    2)双引号

    • 双引号变量var="my name is ${name}",变量有效
    • 可出现转义符

    3)拼接字符串

    • 中间无任何+,之类的字符
    • name=“this is”" my name"; name=“this is my name”; name=“this” is “my name” 等效
    • name=‘this is’’ my nam’; name=‘this is my name’; name=‘this’ is ‘my name’ 等效

    4)获取字符串长度

    • 在${}中使用“#”获取长度
    • name=“test”;
    • echo ${#name}; # 输出为4

    5)提取子字符串

    • 1:4 从第2个开始 往后截取4个字符
    • ::4 从第一个字符开始 往后截取4个字符
    • name=“this is my name”;
    • echo ${name:1:4} #输出 his
    • echo ${name::4} #输出 this

    数组

    bash只支持一维数组,不支持多维数组

    • 定义数组:array_name=(li wang xiang zhang) (小括号做边界、使用空格分离)
    • 单独定义数组的元素: array_para[0]=“w”; array_para[3]=“s” (定义时下标不连续也可以)
    • 赋值数组元素:array_name[0]=“zhao”;
    • 获取数组元素:
      • array_name[0]=“li”
      • array_name[3]=“zhang”
      • echo ${array_name[0]} # 输出"li"
      • echo ${array_name[1]} # 输出" "
      • echo ${array_name[3]} # 输出"zhang"
      • echo ${array_name[@]} # 输出"li zhang" 输出数组所有元素,没有元素的下标省略
    • 取得元素个数:${#array_name[@]} 或者 ${#array_name[*]}
    • 取得单个元素长度:${#array_name[1]}

    参数传递

    • 获取参数值:
      • $0 : 固定,代表执行的文件名
      • $1 : 代表传入的第1个参数
      • $n : 代表传入的第n个参数
    • $#:参数个数
    • $*: 以一个单字符串显示所有向脚本传递的参数。如"$*“用「”」括起来的情况、以"$1 $2 … $n"的形式输出所有参数
    • $@:与$*相同,但是使用时加引号,并在引号中返回每个参数。
    • $$:脚本运行的当前进程号
    • $!:后台运行的最后一个进程的ID
    • $?: 显示最后命令的退出状态。0表示没有错误,其他任何值表明有错误。
    • $* 与 $@ 区别
      • 相同点:都是引用所有参数。
      • 不同点:只有在双引号中体现出来。假设在脚本运行时写了三个参数 1、2、3,,则 " * " 等价于 “1 2 3”(传递了一个参数),而 “@” 等价于 “1” “2” “3”(传递了三个参数)。

    运算符

    算数运算

    • + 、-、*、\ : 乘号前必须加\进行转义才可以进行乘法运算
    • 加法运算
      • val=`expr 2 + 2` (使用linux命令expr进行辅助运算)
      • val=$[2+2] (4个空格不是必要的,不同于条件判断)
      • val=$((2+2))

    数字关系运算符
    关系运算符只支持数字,不支持字符串,除非字符串的值是数字。
    下面假定变量 a 为 10,变量 b 为 20

    • -eq :检测两个数是否相等,相等返回 true。 [ $a -eq $b ] 返回 false。
    • -ne: 检测两个数是否不相等,不相等返回 true。 [ $a -ne $b ] 返回 true。
    • -gt: 检测左边的数是否大于右边的,如果是,则返回 true。 [ $a -gt $b ] 返回 false。
    • -lt : 检测左边的数是否小于右边的,如果是,则返回 true。 [ $a -lt $b ] 返回 true。
    • -ge: 检测左边的数是否大于等于右边的,如果是,则返回 true。 [ $a -ge $b ] 返回 false。
    • -le : 检测左边的数是否小于等于右边的,如果是,则返回 true。 [ $a -le $b ] 返回 true。

    字符串运算符
    下表列出了常用的字符串运算符,假定变量 a 为 “abc”,变量 b 为 “efg”:

    • = :检测两个字符串是否相等,相等返回 true。 [ $a = $b ] 返回 false。
    • != :检测两个字符串是否相等,不相等返回 true。 [ $a != $b ] 返回 true。
    • -z :检测字符串长度是否为0,为0返回 true。 [ -z $a ] 返回 false。
    • -n :检测字符串长度是否为0,不为0返回 true。 [ -n “$a” ] 返回 true。
    • $ :检测字符串是否为空,不为空返回 true。 [ $a ] 返回 true。

    布尔运算符
    下表列出了常用的布尔运算符,假定变量 a 为 10,变量 b 为 20:

    • ! :非运算,表达式为 true 则返回 false,否则返回 true。 [ ! false ] 返回 true。
    • -o :或运算,有一个表达式为 true 则返回 true。 [ $a -lt 20 -o $b -gt 100 ] 返回 true。
    • -a :与运算,两个表达式都为 true 才返回 true。 [ $a -lt 20 -a $b -gt 100 ] 返回 false。

    逻辑运算符
    以下介绍 Shell 的逻辑运算符,假定变量 a 为 10,变量 b 为 20:

    • && :逻辑的 AND [[ $a -lt 100 && $b -gt 100 ]] 返回 false
    • || :逻辑的 OR [[ $a -lt 100 || $b -gt 100 ]] 返回 true

    文件运算符

    • -b file :检测文件是否是块设备文件,如果是,则返回 true。 [ -b $file ] 返回 false。
    • -c file :检测文件是否是字符设备文件,如果是,则返回 true。 [ -c $file ] 返回 false。
    • -d file :检测文件是否是目录,如果是,则返回 true。 [ -d $file ] 返回 false。
    • -f file :检测文件是否是普通文件(既不是目录,也不是设备文件),如果是,则返回 true。 [ -f $file ] 返回 true。
    • -g file :检测文件是否设置了 SGID 位,如果是,则返回 true。 [ -g $file ] 返回 false。
    • -k file :检测文件是否设置了粘着位(Sticky Bit),如果是,则返回 true。 [ -k $file ] 返回 false。
    • -p file :检测文件是否是有名管道,如果是,则返回 true。 [ -p $file ] 返回 false。
    • -u file :检测文件是否设置了 SUID 位,如果是,则返回 true。 [ -u $file ] 返回 false。
    • -r file :检测文件是否可读,如果是,则返回 true。 [ -r $file ] 返回 true。
    • -w file :检测文件是否可写,如果是,则返回 true。 [ -w $file ] 返回 true。
    • -x file :检测文件是否可执行,如果是,则返回 true。 [ -x $file ] 返回 true。
    • -s file :检测文件是否为空(文件大小是否大于0),不为空返回 true。 [ -s $file ] 返回 true。
    • -e file :检测文件(包括目录)是否存在,如果是,则返回 true。 [ -e $file ] 返回 true。

    执行相关

    命令替换
    命令替换与变量替换差不多,都是用来重组命令行的,先完成引号里的命令行,然后将其结果替换出来,再重组成新的命令行。
    执行命令:

    1. `ls /etc` : 反引号 (所有的unix系统都支持)
    2. $(ls /etc) : $+() (部分unix系统不支持)
      多个嵌套使用时,从内向外执行

    for file in \s /etc\ 或 for file in $(ls /etc) 循环中使用
    `dirname $0` 获取脚本文件所在的目录
    path=$(cd `dirname $0`;pwd) : 获取脚本当前所在目录,并且执行cd命令到达该目录,使用pwd获取路径并赋值到path变量

    算术运算

    1. $[ ] : 加减乘除,不必添加空格
    2. $(( )) :加减乘除等,不必添加空格

    逻辑判断

    1. [ ] : 中括号旁边和运算符两边必须添加空格 (可以使用,不推荐)
    2. [[ ]]:中括号旁边和运算符两边必须添加空格 (字符串验证时,推荐使用)
    3. (()) : 中括号旁边和运算符两边必须添加空格 (数字验证时,推荐使用)
    4. [[]] 和 (()) 分别是[ ]的针对数学比较表达式和字符串表达式的加强版。
    5. 使用[[ … ]]条件判断结构,而不是[ … ],能够防止脚本中的许多逻辑错误。比如,&&、||、<和> 操作符能够正常存在于[[ ]]条件判断结构中,但是如果出现在[ ]结构中的话,会报错。比如可以直接使用if [[ $a != 1 && $a != 2 ]], 如果不适用双括号, 则为if [ $a -ne 1] && [ $a != 2 ]或者if [ $a -ne 1 -a $a != 2 ]。
      [[ ]]中增加模式匹配特效;
      (( ))不需要再将表达式里面的大小于符号转义,除了可以使用标准的数学运算符外,还增加了以下符号
      在这里插入图片描述

    输出

    echo
    仅用于字符串的输出,没有使用printf作为输出的移植性好,建议使用printf

    printf

    printf 不会像 echo 自动添加换行符,我们可以手动添加 \n
    无大括号,直接以空格分隔

    • 格式:printf format-string [arguments...] 其中(format-string: 格式控制字符串、arguments: 参数列表)
    • 案例:printf "%-10s %-8s %-4.2f\n" 郭靖 男 66.1234
    • %s %c %d %f 都是格式替代符
      • d:Decimal 十进制整数 对应位置参数必须是十进制整数,否则报错!
      • s:String 字符串 对应位置参数必须是字符串或者字符型 否则报错
      • c:Char 字符 对应位置参数必须是字符串或者字符型 否则报错
      • f:Float 浮点 对应位置参数必须是数字型 否则报错
    • %-10s : 指一个宽度为10个字符(-表示左对齐,没有则表示右对齐),任何字符都会被显示在10个字符宽的字符内,如果不足则自动以空格填充,超过也会将内容全部显示出来。
    • %-4.2f :指格式化为小数,宽度为4个字符,其中.2指保留2位小数。
    • 转义符:
      • \a :警告字符,通常为ASCII的BEL字符
      • \b :后退
      • \c :抑制(不显示)输出结果中任何结尾的换行字符(只在%b格式指示符控制下的参数字符串中有效),而且,任何留在参数里的字符、任何接下来的参数以及任何留在格式字符串中的字符,都被忽略
      • \f :换页(formfeed)
      • \n :换行
      • \r :回车(Carriage return)
      • \t :水平制表符
      • \v :垂直制表符
      • \ :一个字面上的反斜杠字符
      • \ddd :表示1到3位数八进制值的字符。仅在格式字符串中有效
      • \0ddd :表示1到3位的八进制值字符

    流程控制

    和Java、PHP等语言不一样,sh的流程控制不可为空,即if或者else的大括号中无任何语句
    if else

    • if
    if condition
    then
        command1 
        command2
        ...
        commandN 
    fi
    
    • if else
    if condition
    then
        command1 
        command2
        ...
        commandN
    else
        command
    fi
    
    • if else-if else
    if condition1
    then
        command1
    elif condition2 
    then 
        command2
    else
        commandN
    fi
    

    for

    for var in item1 item2 ... itemN
    do
        command1
        command2
        ...
        commandN
    done
    

    while

    • while condition
    while condition
    do
        command
    done
    
    • while 无限循环
    while :
    do
        command
    done
    

    until
    until 循环执行一系列命令直至条件为 true 时停止。
    until 循环与 while 循环在处理方式上刚好相反。

    until condition
    do
        command
    done
    

    case
    Shell case语句为多选择语句。可以用case语句匹配一个值与一个模式,如果匹配成功,执行相匹配的命令。
    case需要一个esac(就是case反过来)作为结束标记,每个case分支用右圆括号,用两个分号表示break,其中“;;”不是跳出循环,是不在去匹配下面的模式
    case语句格式如下:

    casein
      模式1)
        command1
        command2
        ...
        commandN
        ;;
      模式2)
        command1
        command2
        ...
        commandN
        ;;
    esac
    

    跳出循环

    1. break :跳出总循环
    2. continue:跳出当前循环,继续下一次循环

    定义函数

    可以带function fun() 定义,也可以直接fun() 定义,不带任何参数。

    • 函数定义
    [ function ] funname()
    {
        action;
        [return int;]
    }
    
    • 参数传递
      • 调用函数: fun_name 2 3 4
      • 函数中使用:和shell取用函数相同 $n $# $* $? 或者加上{}
    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
    echo $?  \# 判断执行是否成功
    
    • 函数返回值
      • return字样可存在也可不存在
      • return 只能为 return [0-255],此处的返回可作为函数执行的状态,通过$?获取的便是这个返回值
      • 如果不加return , 则默认最后一条语句的执行状态所为函数执行状态的返回值,如果最后一条语句执行成功,则$?为0,否则不为0
    • 使用函数返回值(Janusgraph图数据库官方启动服务脚本片段)
      • return返回的数字,只是作为函数执行状态的返回值,也就是接下来$?获取的值
      • 对于类似于下面的BIN=\abs_path``语句,获取的是函数体内所有的echo、printf输出组合成的一个字符串
    abs_path() {
        SOURCE="${BASH_SOURCE[0]}"
        while [ -h "$SOURCE" ]; do
            DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
            SOURCE="$(readlink "$SOURCE")"
            [[ $SOURCE != /* ]] && SOURCE="$DIR/$SOURCE"
        done
        echo "test"  
        echo "$( cd -P "$( dirname "$SOURCE" )" && pwd )"  
        # 此函数的两个echo输出会组合成一个字符串作为下述BIN的值
    }
    
    BIN=`abs_path` # BIN赋值函数返回值,如果没有return,则函数中所有的echo、printf输出组合成一个字符串传入BIN
    path=${BIN}/nodetool # 可直接使用
    

    输入输出重定向

    一般情况下,每个 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。
    如果希望执行某个命令,但又不希望在屏幕上显示输出结果,那么可以将输出重定向到 /dev/null:

    输入重定向

    1. bash.sh < file : 将脚本的输入重定向到file,由file提供参数

    输出重定向

    1. bash.sh > file : 将脚本的输出数据重定向到file中,覆盖数据
    2. bash.sh >> file : 将脚本的输出数据重定向到file中,追加数据
    3. command >> file 2>&1 : 将 stdout 和 stderr 合并后重定向到 file

    读取外部输入

    命令:read arg (脚本读取外部输入并赋值到变量上)
    在shell脚本执行到上述命令时,停止脚本执行并等待外部输入,将外部输入赋值到arg变量上,继续执行脚本

    文件引用

    引用其他的文件之后,可以使用其变量、函数等等,相当于将引用的文件包含进了当前文件
    两种方式:

    1. . file_path\file_name
    2. source file_path\file_name

    颜色标识

    printf  "\033[32m SUCCESS: yay \033[0m\n";
    printf  "\033[33m WARNING: hmm \033[0m\n";
    printf  "\033[31m ERROR: fubar \033[0m\n";
    

    输出结果:
    在这里插入图片描述

    长句换行

    在shell中为避免一个语句过长,可以使用“\”进行换行
    使用“\”换行,在脚本执行过程中还是当做一行一个语句执行,不同于enter直接换行

    注意:\ 前添加一个空格 。 \ 后无空格直接换行。

     /mysql/bin/mysql \
      -h test_host  -P 000 \
      -u test_user -ptest_password ;
    

    shell操作mysql

    下面案例为登录mysql,并选择操作数据库,之后进行导入数据

     /mysql/mysql/bin/mysql \
      -h test_host  -P 000 \
      -u test_user -ptest_password \
      -e"use test_database; source data_faile; " # -e 代表执行sql语句
    

    -u 用户名
    -p 用户密码
    -h 服务器ip地址
    -D 连接的数据库
    -N 不输出列信息
    -B 使用tab键 代替 分隔符
    -e 执行的SQL语句

    退出脚本

    命令:exit

    在退出脚本时使用不同的错误码,这样可以根据错误码来判断发生了什么错误。

    在绝大多数 shell 脚本中,exit 0 表示执行成功,exit 1 表示发生错误。
    对错误与错误码进行一对一的映射,这样有助于脚本调试。

    命令:set -e 或者 set +e
    set -e表示从当前位置开始,如果出现任何错误都将触发exit。相反,set +e表示不管出现任何错误继续执行脚本。

    如果脚本是有状态的(每个后续步骤都依赖前一个步骤),那么请使用set -e,在脚本出现错误时立即退出脚本。
    如果要求所有命令都要执行完(很少会这样),那么就使用set +e。

    shell脚本调试

    检查是否有语法错误-n
    bash -n script_name.sh
    使用下面的命令来执行并调试 Shell 脚本-x
    bash -x script_name.sh
    调试count_odd_number.sh 程序案例:

    #!/usr/bin.env bash
    
    # 用于计算数组中奇数的和
    # @author liyangyang
    # @time 2019/09/17
    
    sum=0
    for num in 1 2 3 4;do
        re=${num}%2
        if (( ${re} == 1 ));then
            sum=$[${sum}+${num}]
        fi
    done
    echo ${sum}
    
    1. 首先检查有无语法错误:
      bash -n count_odd_number.sh
    2. 没有输出,说明没有错误,开始实际调试:
      bash -x count_odd_number.sh
    3. 调试结果如下:
    + sum=0
    + for num in 1 2 3 4
    + re=1%2
    + ((  1%2 == 1  ))
    + sum=1
    + for num in 1 2 3 4
    + re=2%2
    + ((  2%2 == 1  ))
    + for num in 1 2 3 4
    + re=3%2
    + ((  3%2 == 1  ))
    + sum=4
    + for num in 1 2 3 4
    + re=4%2
    + ((  4%2 == 1  ))
    + echo 4
    4
    

    其中的输出显示了程序执行的每一步,通过观察程序执行的步骤是否满足预期从而达到调试的效果
    带有 + 表示的是 Shell 调试器的输出,不带 + 表示程序的输出。

    案例:

    这是es(ElasticSearch)官方启动服务的脚本,看可不可以理解吧~

    #!/usr/bin/env bash
    
    # CONTROLLING STARTUP:
    #
    # This script relies on a few environment variables to determine startup
    # behavior, those variables are:
    #
    #   ES_PATH_CONF -- Path to config directory
    #   ES_JAVA_OPTS -- External Java Opts on top of the defaults set
    #
    # Optionally, exact memory values can be set using the `ES_JAVA_OPTS`. Note that
    # the Xms and Xmx lines in the JVM options file must be commented out. Example
    # values are "512m", and "10g".
    #
    #   ES_JAVA_OPTS="-Xms8g -Xmx8g" ./bin/elasticsearch
    
    source "`dirname "$0"`"/elasticsearch-env
    
    parse_jvm_options() {
      if [ -f "$1" ]; then
        echo "`grep "^-" "$1" | tr '\n' ' '`"
      fi
    }
    
    ES_JVM_OPTIONS="$ES_PATH_CONF"/jvm.options
    
    ES_JAVA_OPTS="`parse_jvm_options "$ES_JVM_OPTIONS"` $ES_JAVA_OPTS"
    
    # manual parsing to find out, if process should be detached
    if ! echo $* | grep -E '(^-d |-d$| -d |--daemonize$|--daemonize )' > /dev/null; then
      exec \
        "$JAVA" \
        $ES_JAVA_OPTS \
        -Des.path.home="$ES_HOME" \
        -Des.path.conf="$ES_PATH_CONF" \
        -cp "$ES_CLASSPATH" \
        org.elasticsearch.bootstrap.Elasticsearch \
        "$@"
    else
      exec \
        "$JAVA" \
        $ES_JAVA_OPTS \
        -Des.path.home="$ES_HOME" \
        -Des.path.conf="$ES_PATH_CONF" \
        -cp "$ES_CLASSPATH" \
        org.elasticsearch.bootstrap.Elasticsearch \
        "$@" \
        <&- &
      retval=$?
      pid=$!
      [ $retval -eq 0 ] || exit $retval
      if [ ! -z "$ES_STARTUP_SLEEP_TIME" ]; then
        sleep $ES_STARTUP_SLEEP_TIME
      fi
      if ! ps -p $pid > /dev/null ; then
        exit 1
      fi
      exit 0
    fi
    
    exit $?
    

    推荐阅读:
    Git-【技术干货】工作中Git的使用实践
    Git - 使用git不知道内部实现机制怎么行

    如果转载此博文,请附上本文链接,谢谢合作~ :https://blog.csdn.net/CSDN___LYY/article/details/100584638

    如果感觉这篇文章对您有所帮助,请点击一下“喜欢”或者“关注”博主,您的喜欢和关注将是我前进的最大动力!谢谢大家~

    在这里插入图片描述

    展开全文
  • shell脚本--sed的用法

    万次阅读 多人点赞 2018-05-17 01:04:27
    sed在处理文本时是逐行读取文件内容,读到匹配的行就根据指令做操作,不匹配就跳...本文主要介绍sed的一些基本用法,并通过shell脚本演示sed的使用实例。 1.sed的使用方法,调用sed 命令的语法有两种: 一.在命令...
  • shell 脚本里$?什么意思

    千次阅读 2020-10-27 11:47:09
    $? 上个bai命令的退出状态,或函du数的返回值。 例子1 : ls 命令没zhi有找到匹配的结果. 所以返回2 $? 就是dao2 [root@sg-rhel6-17 etc]# ls /tmp/*.log ls: cannot access ... -ne 0 ] then #脚本不正常退出 exit 1 fi
  • bash,shell脚本中的fi的解读

    万次阅读 2017-09-13 10:35:14
    then export APP_DIR=pwd fi export FWD_DIR=dirname $APP_DIR/forward 这两段是什么意思啊,主要是那个’-z’ ‘fi’ ‘forward’这三个 ik.qb.data.add(‘page’,’fromWap’,’0’); -z判断变量值是否为空,如果...
  • shell脚本基本语法详解

    万次阅读 多人点赞 2016-09-28 20:16:04
    编写shell脚本的时候,最前面要加上一行:#!/bin/bash,因为linux里面不仅仅只有bash一个解析器,还有其它的,它们之间的语法会有一些不同,所以最好加上这一句话,告诉系统要用这个解析器。一.shell变量shell变量和...
  • shell 脚本中的$?是什么意思

    千次阅读 2016-07-02 18:33:23
    echo $? 就是输出上次脚本的退出码。如果是0说明上次脚本执行成功,如果非0说明上次脚本执行失败。 楼上正解,但不是很全,不一定是执行脚本,多指执行命令,一般在程序里面会对其进行判断,如果发现上一行的...fi
  • shell脚本if elif fi的使用

    万次阅读 2018-08-16 23:09:52
    demo 接收一个参数 sh testif.sh 1 #! /bin/bash set -e  ...fi 注意点: 1、每一个if 或者elif后面需要一个then 2、if 的条件判断[]中的表达式必须和[或者]留有一个字符的宽度  
  • Shell脚本及钩子

    千次阅读 2017-04-05 19:52:10
    什么Shell脚本什么要用脚本 创建一个简单脚本 运行脚本 Shell命令的组合运用 Shell的变量 Shell控制语句 if then elif fi case esac fordodone whiledodone Shell脚本的调试方法 Shell函数 一些操作符的区别 ...
  • shell脚本自动生成注释,这样以后写脚本就会方便很多
  • shell 脚本 if then else fi

    万次阅读 2007-03-09 14:07:00
    fi  注意有空格哦------------------------------------------ if [ "$1" = "hello" ] ; then  echo "hello!" elif [ "$1" = "" ]; then  echo " no parameter" else  echo "only hello " fi   [dev@...
  • shell脚本中的-n什么意思

    千次阅读 2020-12-09 13:01:05
    不为空返回 true if [ $a ] then echo "$a : 字符串不为空" else echo "$a : 字符串为空" fi 三、shell脚本中自增1的方式 #!/bin/sh #本脚本测试shell脚本中整型变量自增 加1的几种方法 #定义整型变量 a=1 echo $a #...
  • shell 脚本功能汇总

    千次阅读 2016-08-22 14:49:05
    在任意目录下使用某个shell脚本之前只知道如果想用某个命令的话,在环境变量里设置下这个目录就好了,其实在任意目录下使用某个shell脚本,也是在环境变量里配置。 我的是mac环境: 1. 执行命令 open ./.bash_...
  • shell脚本总结

    千次阅读 多人点赞 2014-07-02 21:52:35
    建立shell脚本的步骤:建立shell脚本,编写任意多行操作系统命令或shell命令,增加文件的执行权限,结束   shell变量 shell允许用户建立变量存储数据,但不支持数据类型。将任何赋给变量的值都解释为一串字符 ...
  • shell脚本语法

    万次阅读 2018-06-30 21:26:23
    shell脚本基本语法 默认一行处理一条命令,但也可以用;分割多条命令,按顺序执行。 脚本文件中第一行必须用#! path-to-shell指定所用的shell。 除了第一行之外的#都是注释的开始标记,注释此行中#之后的...
  • shell脚本 > /dev/null 2>&1
  • Shell脚本规范

    千次阅读 2018-11-05 17:03:01
    Shell脚本规范 Google 开源项目风格指南 Google 开源项目风格指南英文版 Google Shell脚本规范 背景 使用哪一种Shell Bash是唯一被允许执行的shell脚本语言 文件扩展名 可执行文件应该没有扩展名(强烈建议)...
  • shell脚本调试

    千次阅读 2015-07-14 12:49:20
    这将执行脚本并显示所有变量的值如,脚本:#!/bin/bash #a test about shift if [ $# -le 0 ] then echo "there is no parameters" exit 0 fi sum=0 while [ $# -gt 0 ] do sum=`expr $sum + $1` shift done echo ...
  • Shell脚本编程基础

    千次阅读 2019-04-29 15:18:18
    【3】第一个shell脚本【4】运行脚本的两种方式1.作为可执行程序2.作为命令解释器【5】shell变量【6】Shell 传递参数示例【7】环境变量【8】条件语句 if else示例1示例2【9】循环语句 while示例1示例2【10】算术...
  • Shell脚本(一)

    万次阅读 多人点赞 2018-07-30 08:44:01
    20.1 什么Shell脚本 shell脚本并不能作为正式的编程语言,因为它是在linux的shell中运行的,所以称为shell脚本。事实上,shell脚本就是一些命令的集合。 假如完成某个需求需要一口气输入10条命令,对于简单的命令...
  • Shell脚本基础详解

    千次阅读 2021-01-04 10:36:10
    Shell脚本 是一个脚本语言,用来自动执行我们指定的系统命令的。 通俗的讲,再shell脚本当中,我们会编写一些需要使用的系统命令于其中再运行这个叫本的时候,这些被编写进去的系统命令会按照书写的顺序及规则以此...
  • shell脚本(一)

    千次阅读 2018-12-24 23:11:24
    20.1 shell脚本介绍 20.2 shell脚本结构和执行 20.3 date命令用法 20.4 shell脚本中的变量 20.5 shell脚本中的逻辑判断 shell脚本介绍 shell是一种脚本语言,可以使用逻辑判断、循环等语法,可以自定义函数。 与其他...
  • ``` function maybe_prompt_user() { if $ASSUME_YES; then return 0 else read -p "$1" if [[ $REPLY =~ ^[Yy]$ ]]; then return 0 ...这段脚本什么意思,没太看明白,哪位高手指点一下,谢谢!
  • shell脚本编写笔记

    千次阅读 2019-07-26 14:32:28
    本文主要介绍如何编写简单的shell脚本,给shell脚本传参,shell脚本获取当前运行时间,通过shell执行hql语句。
  • shell脚本打印日志方法

    万次阅读 2015-11-24 22:02:16
    博客:http://blog.csdn.net/wylfengyujiancheng在shell脚本执行过程中如果没有日志记录,特别是脚本比较长的情况下在执行完再定位问题很难发现问题原因,因此在脚本中增加日志显得十分重要。下面介绍日志打印方法...
  • Shell脚本学习笔记

    千次阅读 2016-11-18 19:37:51
    1shell脚本 2shell脚本实践 Shell变量 1使用变量 2只读变量 3删除变量 4变量类型 5shell字符串 6Shell数组 7Shell注释 Shell传递参数 1实例 Shell数组 Shell运算符 1算术运算符 2关系运算符 3布尔运算符 4逻辑运算符...
  • Shell-alias在Shell脚本中的使用

    万次阅读 2017-07-26 20:28:08
    概述众所周知,shell脚本使用的是非交互式方式,在非交互式模式下alias扩展功能默认是关闭的,此时虽然可以定义alias别名,但是shell不会将alias别名扩展成对应的命令,而是将alias别名本身当作命令执行,如果shell...
  • shell脚本调用另一个shell脚本

    千次阅读 2018-06-12 17:38:08
    #!/bin/bashvar=`source ./ftp.sh $1`#输出长度echo ${#var}#如果长度大于10输出1if [ ${#var} -ge 10 ];then echo '1'else echo '2'fi

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 90,210
精华内容 36,084
关键字:

shell脚本fi是什么意思