php shell立即返回_shell 返回shell执行结果 - CSDN
精华内容
参与话题
  • 收藏!一篇教会你写90%的shell脚本!

    万次阅读 多人点赞 2020-08-21 17:25:45
    还不会写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脚本支持的一些语言特性,完成想要的功能。

    博主所有文章首发在CSDN 和 公众号:【匠心Java

    【匠心Java】公众号分享工作中涉及到的技术知识,主要分享数据库相关和Java技术干货(JVM+并发+全链路优化);涉及计算机网络、数据结构与算法、linux等编程知识;

    微信扫描下述二维码关注;或微信搜索“匠心Java*”关注,期待与大家的交流

    匠心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

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

    在这里插入图片描述

    展开全文
  • Linux(4) Shell 编程入门

    万次阅读 2019-05-05 09:34:22
    Shell 编程入门 走进 Shell 编程的大门 为什么要学Shell? 学一个东西,我们大部分情况都是往实用性方向着想。从工作角度来讲,学习 Shell 是为了提高我们自己工作效率,提高产出,让我们在更少的时间完成更多的事情...

    Shell 编程入门

    走进 Shell 编程的大门

    为什么要学Shell?

    学一个东西,我们大部分情况都是往实用性方向着想。从工作角度来讲,学习 Shell 是为了提高我们自己工作效率,提高产出,让我们在更少的时间完成更多的事情。

    很多人会说 Shell 编程属于运维方面的知识了,应该是运维人员来做,我们做后端开发的没必要学。我觉得这种说法大错特错,相比于专门做Linux运维的人员来说,我们对 Shell 编程掌握程度的要求要比他们低,但是shell编程也是我们必须要掌握的!

    目前Linux系统下最流行的运维自动化语言就是Shell和Python了。

    两者之间,Shell几乎是IT企业必须使用的运维自动化编程语言,特别是在运维工作中的服务监控、业务快速部署、服务启动停止、数据备份及处理、日志分析等环节里,shell是不可缺的。Python 更适合处理复杂的业务逻辑,以及开发复杂的运维软件工具,实现通过web访问等。Shell是一个命令解释器,解释执行用户所输入的命令和程序。一输入命令,就立即回应的交互的对话方式。

    另外,了解 shell 编程也是大部分互联网公司招聘后端开发人员的要求。下图是我截取的一些知名互联网公司对于 Shell 编程的要求。

    大型互联网公司对于shell编程技能的要求

    什么是 Shell?

    简单来说“Shell编程就是对一堆Linux命令的逻辑化处理”。

    W3Cschool 上的一篇文章是这样介绍 Shell的,如下图所示。 什么是 Shell?

    Shell 编程的 Hello World

    学习任何一门编程语言第一件事就是输出HelloWord了!下面我会从新建文件到shell代码编写来说下Shell 编程如何输出Hello World。

    (1)新建一个文件 helloworld.sh :touch helloworld.sh,扩展名为 sh(sh代表Shell)(扩展名并不影响脚本执行,见名知意就好,如果你用 php 写 shell 脚本,扩展名就用 php 好了)

    (2) 使脚本具有执行权限:chmod +x helloworld.sh

    (3) 使用 vim 命令修改helloworld.sh文件:vim helloworld.sh(vim 文件------>进入文件----->命令模式------>按i进入编辑模式----->编辑文件 ------->按Esc进入底行模式----->输入:wq/q! (输入wq代表写入内容并退出,即保存;输入q!代表强制退出不保存。))

    helloworld.sh 内容如下:

    #!/bin/bash
    #第一个shell小程序,echo 是linux中的输出命令。
    echo  "helloworld!"
    

    shell中 # 符号表示注释。shell 的第一行比较特殊,一般都会以#!开始来指定使用的 shell 类型。在linux中,除了bash shell以外,还有很多版本的shell, 例如zsh、dash等等…不过bash shell还是我们使用最多的。

    (4) 运行脚本:./helloworld.sh 。(注意,一定要写成 ./helloworld.sh ,而不是 helloworld.sh ,运行其它二进制的程序也一样,直接写 helloworld.sh ,linux 系统会去 PATH 里寻找有没有叫 test.sh 的,而只有 /bin, /sbin, /usr/bin,/usr/sbin 等在 PATH 里,你的当前目录通常不在 PATH 里,所以写成 helloworld.sh 是会找不到命令的,要用./helloworld.sh 告诉系统说,就在当前目录找。)

    shell 编程Hello World

    Shell 变量

    Shell 编程中的变量介绍

    Shell编程中一般分为三种变量:

    1. 我们自己定义的变量(自定义变量): 仅在当前 Shell 实例中有效,其他 Shell 启动的程序不能访问局部变量。
    2. Linux已定义的环境变量(环境变量, 例如:$PATH, $HOME 等…, 这类变量我们可以直接使用),使用 env 命令可以查看所有的环境变量,而set命令既可以查看环境变量也可以查看自定义变量。
    3. Shell变量 :Shell变量是由 Shell 程序设置的特殊变量。Shell 变量中有一部分是环境变量,有一部分是局部变量,这些变量保证了 Shell 的正常运行

    常用的环境变量:

    PATH 决定了shell将到哪些目录中寻找命令或程序 HOME 当前用户主目录 HISTSIZE 历史记录数 LOGNAME 当前用户的登录名 HOSTNAME 指主机的名称 SHELL 当前用户Shell类型 LANGUGE  语言相关的环境变量,多语言可以修改此环境变量 MAIL 当前用户的邮件存放目录 PS1 基本提示符,对于root用户是#,对于普通用户是$

    使用 Linux 已定义的环境变量:

    比如我们要看当前用户目录可以使用:echo $HOME命令;如果我们要看当前用户Shell类型 可以使用echo $SHELL命令。可以看出,使用方法非常简单。

    使用自己定义的变量:

    #!/bin/bash
    #自定义变量hello
    hello="hello world"
    echo $hello
    echo  "helloworld!"
    

    使用自己定义的变量

    Shell 编程中的变量名的命名的注意事项:

    • 命名只能使用英文字母,数字和下划线,首个字符不能以数字开头,但是可以使用下划线(_)开头。
    • 中间不能有空格,可以使用下划线(_)。
    • 不能使用标点符号。
    • 不能使用bash里的关键字(可用help命令查看保留关键字)。

    Shell 字符串入门

    字符串是shell编程中最常用最有用的数据类型(除了数字和字符串,也没啥其它类型好用了),字符串可以用单引号,也可以用双引号。这点和Java中有所不同。

    单引号字符串:

    #!/bin/bash
    name='SnailClimb'
    hello='Hello, I  am '$name'!'
    echo $hello
    

    输出内容:

    Hello, I am SnailClimb!
    

    双引号字符串:

    #!/bin/bash
    name='SnailClimb'
    hello="Hello, I  am "$name"!"
    echo $hello
    

    输出内容:

    Hello, I am SnailClimb!
    

    Shell 字符串常见操作

    拼接字符串:

    #!/bin/bash
    name="SnailClimb"
    # 使用双引号拼接
    greeting="hello, "$name" !"
    greeting_1="hello, ${name} !"
    echo $greeting  $greeting_1
    # 使用单引号拼接
    greeting_2='hello, '$name' !'
    greeting_3='hello, ${name} !'
    echo $greeting_2  $greeting_3
    

    输出结果:

    输出结果

    获取字符串长度:

    #!/bin/bash
    #获取字符串长度
    name="SnailClimb"
    # 第一种方式
    echo ${#name} #输出 10
    # 第二种方式
    expr length "$name";
    

    输出结果:

    10
    10
    

    使用 expr 命令时,表达式中的运算符左右必须包含空格,如果不包含空格,将会输出表达式本身:

    expr 5+6    // 直接输出 5+6
    expr 5 + 6       // 输出 11
    

    对于某些运算符,还需要我们使用符号\进行转义,否则就会提示语法错误。

    expr 5 * 6       // 输出错误
    expr 5 \* 6      // 输出30
    

    截取子字符串:

    简单的字符串截取:

    #从字符串第 1 个字符开始往后截取 10 个字符
    str="SnailClimb is a great man"
    echo ${str:0:10} #输出:SnailClimb
    

    根据表达式截取:

    #!bin/bash
    #author:amau
    
    var="http://www.runoob.com/linux/linux-shell-variable.html"
    
    s1=${var%%t*}#h
    s2=${var%t*}#http://www.runoob.com/linux/linux-shell-variable.h
    s3=${var%%.*}#http://www
    s4=${var#*/}#/www.runoob.com/linux/linux-shell-variable.html
    s5=${var##*/}#linux-shell-variable.html
    

    Shell 数组

    bash支持一维数组(不支持多维数组),并且没有限定数组的大小。我下面给了大家一个关于数组操作的 Shell 代码示例,通过该示例大家可以知道如何创建数组、获取数组长度、获取/删除特定位置的数组元素、删除整个数组以及遍历数组。

    #!/bin/bash
    array=(1 2 3 4 5);
    # 获取数组长度
    length=${#array[@]}
    # 或者
    length2=${#array[*]}
    #输出数组长度
    echo $length #输出:5
    echo $length2 #输出:5
    # 输出数组第三个元素
    echo ${array[2]} #输出:3
    unset array[1]# 删除下表为1的元素也就是删除第二个元素
    for i in ${array[@]};do echo $i ;done # 遍历数组,输出: 1 3 4 5 
    unset arr_number; # 删除数组中的所有元素
    for i in ${array[@]};do echo $i ;done # 遍历数组,数组元素为空,没有任何输出内容
    

    Shell 基本运算符

    说明:图片来自《菜鸟教程》

    Shell 编程支持下面几种运算符

    • 算数运算符
    • 关系运算符
    • 布尔运算符
    • 字符串运算符
    • 文件测试运算符

    算数运算符

    算数运算符

    我以加法运算符做一个简单的示例:

    #!/bin/bash
    a=3;b=3;
    val=`expr $a + $b`
    #输出:Total value : 6
    echo "Total value : $val
    

    关系运算符

    关系运算符只支持数字,不支持字符串,除非字符串的值是数字。

    shell关系运算符

    通过一个简单的示例演示关系运算符的使用,下面shell程序的作用是当score=100的时候输出A否则输出B。

    #!/bin/bash
    score=90;
    maxscore=100;
    if [ $score -eq $maxscore ]
    then
       echo "A"
    else
       echo "B"
    fi
    

    输出结果:

    B
    

    逻辑运算符

    逻辑运算符

    示例:

    #!/bin/bash
    a=$(( 1 && 0))
    # 输出:0;逻辑与运算只有相与的两边都是1,与的结果才是1;否则与的结果是0
    echo $a;
    

    布尔运算符

    布尔运算符

    这里就不做演示了,应该挺简单的。

    字符串运算符

     字符串运算符

    简单示例:

    #!/bin/bash
    a="abc";
    b="efg";
    if [ $a = $b ]
    then
       echo "a 等于 b"
    else
       echo "a 不等于 b"
    fi
    

    输出:

    a 不等于 b
    

    文件相关运算符

    文件相关运算符

    使用方式很简单,比如我们定义好了一个文件路径file="/usr/learnshell/test.sh" 如果我们想判断这个文件是否可读,可以这样if [ -r $file ] 如果想判断这个文件是否可写,可以这样-w $file,是不是很简单。

    shell流程控制

    if 条件语句

    简单的 if else-if else 的条件语句示例

    #!/bin/bash
    a=3;
    b=9;
    if [ $a = $b ]
    then
       echo "a 等于 b"
    elif [ $a > $b ]
    then
       echo "a 大于 b"
    else
       echo "a 小于 b"
    fi
    

    输出结果:

    a 大于 b
    

    相信大家通过上面的示例就已经掌握了 shell 编程中的 if 条件语句。不过,还要提到的一点是,不同于我们常见的 Java 以及 PHP 中的 if 条件语句,shell if 条件语句中不能包含空语句也就是什么都不做的语句。

    for 循环语句

    通过下面三个简单的示例认识 for 循环语句最基本的使用,实际上 for 循环语句的功能比下面你看到的示例展现的要大得多。

    输出当前列表中的数据:

    for loop in 1 2 3 4 5
    do
        echo "The value is: $loop"
    done
    

    产生 10 个随机数:

    #!/bin/bash
    for i in {0..9};
    do 
       echo $RANDOM;
    done
    

    输出1到5:

    通常情况下 shell 变量调用需要加 $,但是 for 的 (()) 中不需要,下面来看一个例子:

    #!/bin/bash
    for((i=1;i<=5;i++));do
        echo $i;
    done;
    

    while 语句

    基本的 while 循环语句:

    #!/bin/bash
    int=1
    while(( $int<=5 ))
    do
        echo $int
        let "int++"
    done
    

    while循环可用于读取键盘信息:

    echo '按下 <CTRL-D> 退出'
    echo -n '输入你最喜欢的电影: '
    while read FILM
    do
        echo "是的!$FILM 是一个好电影"
    done
    

    输出内容:

    按下 <CTRL-D> 退出
    输入你最喜欢的电影: 变形金刚
    是的!变形金刚 是一个好电影
    

    无线循环:

    while true
    do
        command
    done
    

    shell 函数

    不带参数没有返回值的函数

    #!/bin/bash
    function(){
        echo "这是我的第一个 shell 函数!"
    }
    function
    

    输出结果:

    这是我的第一个 shell 函数!
    

    有返回值的函数

    输入两个数字之后相加并返回结果:

    #!/bin/bash
    funWithReturn(){
        echo "输入第一个数字: "
        read aNum
        echo "输入第二个数字: "
        read anotherNum
        echo "两个数字分别为 $aNum 和 $anotherNum !"
        return $(($aNum+$anotherNum))
    }
    funWithReturn
    echo "输入的两个数字之和为 $?"
    

    输出结果:

    输入第一个数字: 
    1
    输入第二个数字: 
    2
    两个数字分别为 1 和 2 !
    输入的两个数字之和为 3
    

    带参数的函数

    #!/bin/bash
    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
    

    输出结果:

    第一个参数为 1 !
    第二个参数为 2 !
    第十个参数为 10 !
    第十个参数为 34 !
    第十一个参数为 73 !
    参数总数有 11 个!
    作为一个字符串输出所有参数 1 2 3 4 5 6 7 8 9 34 73 !
    
    展开全文
  • WshShell.Run方法说明

    万次阅读 2011-03-20 01:24:00
    [VBS]WshShell.Run方法说明Run方法说明:object.Run(strCommand, [intWindowStyle], [bWaitOnReturn]) 参数object WshShell 对象。 strCommand 表示要运行的命令行的字符串值。必须包括要传递到可执行文件的所有参数...

    [VBS]WshShell.Run方法说明

    Run方法说明:

    object.Run(strCommand, [intWindowStyle], [bWaitOnReturn]) 参数
    object
    WshShell 对象。
    strCommand
    表示要运行的命令行的字符串值。必须包括要传递到可执行文件的所有参数。
    intWindowStyle
    可选。表示程序窗口外观的整数值。请注意,并非所有程序都使用此信息。
    bWaitOnReturn
    可选。布尔值,表示在继续执行脚本中的下一条语句之前,脚本是否等待执行完程序。如果设为 true,则在执行完程序后才执行脚本,Run 方法返回由程序返回的任何错误代码。如果设为 false(默认值),则 Run 方法将自动在启动程序后立即返回 0(不是错误代码)。
    说明
    Run 方法返回一个整数。Run 方法启动在新 Windows 进程中运行的程序。可以让脚本等到程序执行完后再继续执行。这允许您同步运行脚本和程序。strCommand 参数内的环境变量自动扩展。如果某个文件类型已正确注册到某个程序中,则对该类型的文件调用 Run 方法时将执行该程序。例如,如果您的计算机系统中装有 Word,则对 *.doc 文件调用 Run 方法时将启动 Word 并加载该文档。下表列出了 intWindowStyle 的可用设置。

    intWindowStyle 说明
    0 隐藏一个窗口并激活另一个窗口。
    1 激活并显示窗口。如果窗口处于最小化或最大化状态,则系统将其还原到原始大小和位置。第一次显示该窗口时,应用程序应指定此标志。
    2 激活窗口并将其显示为最小化窗口。
    3 激活窗口并将其显示为最大化窗口。
    4 按最近的窗口大小和位置显示窗口。活动窗口保持活动状态。
    5 激活窗口并按当前的大小和位置显示它。
    6 最小化指定的窗口,并按照 Z 顺序激活下一个顶部窗口。
    7 将窗口显示为最小化窗口。活动窗口保持活动状态。
    8 将窗口显示为当前状态。活动窗口保持活动状态。
    9 激活并显示窗口。如果窗口处于最小化或最大化状态,则系统将其还原到原始大小和位置。还原最小化窗口时,应用程序应指定此标志。
    10 根据启动应用程序的程序状态来设置显示状态。

    关于wshShell对象的详细资料请参阅MSDN

    示例 1
    下面的 vbscript 代码用记事本打开当前运行脚本的副本。

    set wshshell = wscript.createobject("wscript.shell")
    wshshell.run "%windir%/notepad " & wscript.scriptfullname
    下面的 vbscript 代码与上述代码完成的操作相同,不同之处在于,它指定窗口类型,等待用户关闭记事本,关闭记事本时保存从记事本返回的错误代码。

    set wshshell = wscript.createobject("wscript.shell")
    return = wshshell.run("notepad " & wscript.scriptfullname, 1, true)
    示例 2
    下面的 vbscript 代码打开一个命令窗口,将路径改为 c:/,并执行 dir 命令。

    dim oshell
    set oshell = wscript.createobject ("wscript.shell")
    oshell.run "cmd /k cd c:/ & dir"
    set oshell = nothing

    示例3
    var wsh = new ActiveXObject("WScript.Shell");
    wsh.Run ("%WINDIR%//notepad.exe c://docs//readme.txt");
    Run方法中传入正确的命令行即可以执行相应命令


    [From]
    http://bbs.huistd.com/detail.php?pagenum=0&id=1509
    http://ithomecn.com/soft/p273/A27333569.shtml

    http://www.trucy.org/blog/sheryl/archives/2007/12/vbswshshellrune.html

    展开全文
  • 本人网上收集整理的shell教程,非常详细

    千次阅读 多人点赞 2016-09-10 22:24:51
    Shell简介:什么是ShellShell命令的两种执行方式 Shell本身是一个用C语言编写的程序,它是用户使用Unix/Linux的桥梁,用户的大部分工作都是通过Shell完成的。Shell既是一种命令语言,又是一种程序设计语言。作为...

    Shell简介:什么是ShellShell命令的两种执行方式

    Shell本身是一个用C语言编写的程序,它是用户使用Unix/Linux的桥梁,用户的大部分工作都是通过Shell完成的。Shell既是一种命令语言,又是一种程序设计语言。作为命令语言,它交互式地解释和执行用户输入的命令;作为程序设计语言,它定义了各种变量和参数,并提供了许多在高级语言中才具有的控制结构,包括循环和分支。

    它虽然不是Unix/Linux系统内核的一部分,但它调用了系统核心的大部分功能来执行程序、建立文件并以并行的方式协调各个程序的运行。因此,对于用户来说,shell是最重要的实用程序,深入了解和熟练掌握shell的特性极其使用方法,是用好Unix/Linux系统的关键。

    可以说,shell使用的熟练程度反映了用户对Unix/Linux使用的熟练程度。

    注意:单独地学习 Shell 是没有意义的,请先参考Unix/Linux入门教程,了解 Unix/Linux 基础。

    Shell有两种执行命令的方式:

    • 交互式(Interactive):解释执行用户的命令,用户输入一条命令,Shell就解释执行一条。
    • 批处理(Batch):用户事先写一个Shell脚本(Script),其中有很多条命令,让Shell一次把这些命令执行完,而不必一条一条地敲命令。


    Shell脚本和编程语言很相似,也有变量和流程控制语句,但Shell脚本是解释执行的,不需要编译,Shell程序从脚本中一行一行读取并执行这些命令,相当于一个用户把脚本中的命令一行一行敲到Shell提示符下执行。

    Shell初学者请注意,在平常应用中,建议不要用 root 帐号运行 Shell 。作为普通用户,不管您有意还是无意,都无法破坏系统;但如果是 root,那就不同了,只要敲几个字母,就可能导致灾难性后果。

    几种常见的Shell

     

    上面提到过,Shell是一种脚本语言,那么,就必须有解释器来执行这些脚本。

    Unix/Linux上常见的Shell脚本解释器有bash、sh、csh、ksh等,习惯上把它们称作一种Shell。我们常说有多少种Shell,其实说的是Shell脚本解释器。

    bash

    bash是Linux标准默认的shell,本教程也基于bash讲解。bash由Brian Fox和Chet Ramey共同完成,是BourneAgainShell的缩写,内部命令一共有40个。

    Linux使用它作为默认的shell是因为它有诸如以下的特色:

    • 可以使用类似DOS下面的doskey的功能,用方向键查阅和快速输入并修改命令。
    • 自动通过查找匹配的方式给出以某字符串开头的命令。
    • 包含了自身的帮助功能,你只要在提示符下面键入help就可以得到相关的帮助。

    sh

    sh 由Steve Bourne开发,是BourneShell的缩写,sh 是Unix 标准默认的shell。

    ash

    ash shell 是由Kenneth Almquist编写的,Linux中占用系统资源最少的一个小shell,它只包含24个内部命令,因而使用起来很不方便。

    csh

    csh 是Linux比较大的内核,它由以WilliamJoy为代表的共计47位作者编成,共有52个内部命令。该shell其实是指向/bin/tcsh这样的一个shell,也就是说,csh其实就是tcsh。

    ksh

    ksh 是Korn shell的缩写,由EricGisin编写,共有42条内部命令。该shell最大的优点是几乎和商业发行版的ksh完全兼容,这样就可以在不用花钱购买商业版本的情况下尝试商业版本的性能了。

    注意:bash是 Bourne Again Shell 的缩写,是linux标准的默认shell ,它基于Bourne shell,吸收了C shell和Korn shell的一些特性。bash完全兼容sh,也就是说,用sh写的脚本可以不加修改的在bash中执行。

     

    Shell脚本语言与编译型语言的差异

    大体上,可以将程序设计语言可以分为两类:编译型语言和解释型语言。

    编译型语言

    很多传统的程序设计语言,例如Fortran、Ada、Pascal、C、C++和Java,都是编译型语言。这类语言需要预先将我们写好的源代码(source code)转换成目标代码(object code),这个过程被称作“编译”。

    运行程序时,直接读取目标代码(object code)。由于编译后的目标代码(object code)非常接近计算机底层,因此执行效率很高,这是编译型语言的优点。

    但是,由于编译型语言多半运作于底层,所处理的是字节、整数、浮点数或是其他机器层级的对象,往往实现一个简单的功能需要大量复杂的代码。例如,在C++里,就很难进行“将一个目录里所有的文件复制到另一个目录中”之类的简单操作。

    解释型语言

    解释型语言也被称作“脚本语言”。执行这类程序时,解释器(interpreter)需要读取我们编写的源代码(source code),并将其转换成目标代码(object code),再由计算机运行。因为每次执行程序都多了编译的过程,因此效率有所下降。

    使用脚本编程语言的好处是,它们多半运行在比编译型语言还高的层级,能够轻易处理文件与目录之类的对象;缺点是它们的效率通常不如编译型语言。不过权衡之下,通常使用脚本编程还是值得的:花一个小时写成的简单脚本,同样的功能用C或C++来编写实现,可能需要两天,而且一般来说,脚本执行的速度已经够快了,快到足以让人忽略它性能上的问题。脚本编程语言的例子有awk、Perl、Python、Ruby与Shell。

     

    什么时候使用Shell

    因为Shell似乎是各UNIX系统之间通用的功能,并且经过了POSIX的标准化。因此,Shell脚本只要“用心写”一次,即可应用到很多系统上。因此,之所以要使用Shell脚本是基于:

    • 简单性:Shell是一个高级语言;通过它,你可以简洁地表达复杂的操作。
    • 可移植性:使用POSIX所定义的功能,可以做到脚本无须修改就可在不同的系统上执行。
    • 开发容易:可以在短时间内完成一个功能强大又妤用的脚本。


    但是,考虑到Shell脚本的命令限制和效率问题,下列情况一般不使用Shell:

    1. 资源密集型的任务,尤其在需要考虑效率时(比如,排序,hash等等)。
    2. 需要处理大任务的数学操作,尤其是浮点运算,精确运算,或者复杂的算术运算(这种情况一般使用C++或FORTRAN 来处理)。
    3. 有跨平台(操作系统)移植需求(一般使用C 或Java)。
    4. 复杂的应用,在必须使用结构化编程的时候(需要变量的类型检查,函数原型,等等)。
    5. 对于影响系统全局性的关键任务应用。
    6. 对于安全有很高要求的任务,比如你需要一个健壮的系统来防止入侵、破解、恶意破坏等等。
    7. 项目由连串的依赖的各个部分组成。
    8. 需要大规模的文件操作。
    9. 需要多维数组的支持。
    10. 需要数据结构的支持,比如链表或数等数据结构。
    11. 需要产生或操作图形化界面 GUI。
    12. 需要直接操作系统硬件。
    13. 需要 I/O 或socket 接口。
    14. 需要使用库或者遗留下来的老代码的接口。
    15. 私人的、闭源的应用(shell 脚本把代码就放在文本文件中,全世界都能看到)。


    如果你的应用符合上边的任意一条,那么就考虑一下更强大的语言吧——或许是Perl、Tcl、Python、Ruby——或者是更高层次的编译语言比如C/C++,或者是Java。即使如此,你会发现,使用shell来原型开发你的应用,在开发步骤中也是非常有用的。

     

    第一个Shell脚本

     

    打开文本编辑器,新建一个文件,扩展名为sh(sh代表shell),扩展名并不影响脚本执行,见名知意就好,如果你用php写shell 脚本,扩展名就用php好了。

    输入一些代码:

    1. #!/bin/bash
    2. echo "Hello World !"

    “#!” 是一个约定的标记,它告诉系统这个脚本需要什么解释器来执行,即使用哪一种Shell。echo命令用于向窗口输出文本。

    运行Shell脚本有两种方法。

    作为可执行程序

    将上面的代码保存为test.sh,并 cd 到相应目录:

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

    ./test.sh #执行脚本

    注意,一定要写成./test.sh,而不是test.sh。运行其它二进制的程序也一样,直接写test.sh,linux系统会去PATH里寻找有没有叫test.sh的,而只有/bin, /sbin, /usr/bin,/usr/sbin等在PATH里,你的当前目录通常不在PATH里,所以写成test.sh是会找不到命令的,要用./test.sh告诉系统说,就在当前目录找。

    通过这种方式运行bash脚本,第一行一定要写对,好让系统查找到正确的解释器。

    这里的"系统",其实就是shell这个应用程序(想象一下Windows Explorer),但我故意写成系统,是方便理解,既然这个系统就是指shell,那么一个使用/bin/sh作为解释器的脚本是不是可以省去第一行呢?是的。

    作为解释器参数

    这种运行方式是,直接运行解释器,其参数就是shell脚本的文件名,如:

    /bin/sh test.sh

    /bin/php test.php

    这种方式运行的脚本,不需要在第一行指定解释器信息,写了也没用。

    再看一个例子。下面的脚本使用 read 命令从 stdin 获取输入并赋值给 PERSON变量,最后在 stdout 上输出:

    1. #!/bin/bash
    2.  
    3. # Author : mozhiyan
    4. # Copyright (c) http://see.xidian.edu.cn/cpp/linux/
    5. # Script follows here:
    6.  
    7. echo "What is your name?"
    8. read PERSON
    9. echo "Hello, $PERSON"

    运行脚本:

    chmod +x ./test.sh

    $./test.sh

    What is your name?

    mozhiyan

    Hello, mozhiyan

    $

     

    Shell变量:Shell变量的定义、删除变量、只读变量、变量类型

     

    Shell支持自定义变量。

    定义变量

    定义变量时,变量名不加美元符号($),如:

    1. variableName="value"

    注意,变量名和等号之间不能有空格,这可能和你熟悉的所有编程语言都不一样。同时,变量名的命名须遵循如下规则:

    • 首个字符必须为字母(a-z,A-Z)。
    • 中间不能有空格,可以使用下划线(_)。
    • 不能使用标点符号。
    • 不能使用bash里的关键字(可用help命令查看保留关键字)。


    变量定义举例:

    1. myUrl="http://see.xidian.edu.cn/cpp/linux/"
    2. myNum=100

    使用变量

    使用一个定义过的变量,只要在变量名前面加美元符号($)即可,如:

    1. your_name="mozhiyan"
    2. echo $your_name
    3. echo ${your_name}

    变量名外面的花括号是可选的,加不加都行,加花括号是为了帮助解释器识别变量的边界,比如下面这种情况:

    1. for skill in Ada Coffe Action Java
    2. do
    3.     echo "I am good at ${skill}Script"
    4. done

    如果不给skill变量加花括号,写成echo "I am good at $skillScript",解释器就会把$skillScript当成一个变量(其值为空),代码执行结果就不是我们期望的样子了。

    推荐给所有变量加上花括号,这是个好的编程习惯。

    重新定义变量

    已定义的变量,可以被重新定义,如:

    1. myUrl="http://see.xidian.edu.cn/cpp/linux/"
    2. echo ${myUrl}
    3.  
    4. myUrl="http://see.xidian.edu.cn/cpp/shell/"
    5. echo ${myUrl}

    这样写是合法的,但注意,第二次赋值的时候不能写 $myUrl="http://see.xidian.edu.cn/cpp/shell/",使用变量的时候才加美元符($)。

    只读变量

    使用 readonly 命令可以将变量定义为只读变量,只读变量的值不能被改变。

    下面的例子尝试更改只读变量,结果报错:

    1. #!/bin/bash
    2.  
    3. myUrl="http://see.xidian.edu.cn/cpp/shell/"
    4. readonly myUrl
    5. myUrl="http://see.xidian.edu.cn/cpp/danpianji/"

    运行脚本,结果如下:

    /bin/sh: NAME: This variable is read only.

    删除变量

    使用 unset 命令可以删除变量。语法:

    1. unset variable_name

    变量被删除后不能再次使用;unset 命令不能删除只读变量。

    举个例子:

    1. #!/bin/sh
    2.  
    3. myUrl="http://see.xidian.edu.cn/cpp/u/xitong/"
    4. unset myUrl
    5. echo $myUrl

    上面的脚本没有任何输出。

    变量类型

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

    1) 局部变量

    局部变量在脚本或命令中定义,仅在当前shell实例中有效,其他shell启动的程序不能访问局部变量。

    2) 环境变量

    所有的程序,包括shell启动的程序,都能访问环境变量,有些程序需要环境变量来保证其正常运行。必要的时候shell脚本也可以定义环境变量。

    3) shell变量

    shell变量是由shell程序设置的特殊变量。shell变量中有一部分是环境变量,有一部分是局部变量,这些变量保证了shell的正常运行

     

    Shell特殊变量:Shell $0, $#, $*, $@, $?, $$和命令行参数

     

    前面已经讲到,变量名只能包含数字、字母和下划线,因为某些包含其他字符的变量有特殊含义,这样的变量被称为特殊变量。

    例如,$ 表示当前Shell进程的ID,即pid,看下面的代码:

    1. $echo $$

    运行结果

    29949

     

    特殊变量列表

    变量

    含义

    $0

    当前脚本的文件名

    $n

    传递给脚本或函数的参数。n 是一个数字,表示第几个参数。例如,第一个参数是$1,第二个参数是$2。

    $#

    传递给脚本或函数的参数个数。

    $*

    传递给脚本或函数的所有参数。

    $@

    传递给脚本或函数的所有参数。被双引号(" ")包含时,与 $* 稍有不同,下面将会讲到。

    $?

    上个命令的退出状态,或函数的返回值。

    $$

    当前Shell进程ID。对于 Shell 脚本,就是这些脚本所在的进程ID。

    命令行参数

    运行脚本时传递给脚本的参数称为命令行参数。命令行参数用 $n 表示,例如,$1 表示第一个参数,$2 表示第二个参数,依次类推。

    请看下面的脚本:

    1. #!/bin/bash
    2.  
    3. echo "File Name: $0"
    4. echo "First Parameter : $1"
    5. echo "First Parameter : $2"
    6. echo "Quoted Values: $@"
    7. echo "Quoted Values: $*"
    8. echo "Total Number of Parameters : $#"

    运行结果:

    $./test.sh Zara Ali

    File Name : ./test.sh

    First Parameter : Zara

    Second Parameter : Ali

    Quoted Values: Zara Ali

    Quoted Values: Zara Ali

    Total Number of Parameters : 2

    $* 和 $@ 的区别

    $* 和 $@ 都表示传递给函数或脚本的所有参数,不被双引号(" ")包含时,都以"$1" "$2" … "$n" 的形式输出所有参数。

    但是当它们被双引号(" ")包含时,"$*" 会将所有的参数作为一个整体,以"$1 $2 … $n"的形式输出所有参数;"$@" 会将各个参数分开,以"$1" "$2" … "$n" 的形式输出所有参数。

    下面的例子可以清楚的看到 $* 和 $@ 的区别:

    1. #!/bin/bash
    2. echo "\$*=" $*
    3. echo "\"\$*\"=" "$*"
    4.  
    5. echo "\$@=" $@
    6. echo "\"\$@\"=" "$@"
    7.  
    8. echo "print each param from \$*"
    9. for var in $*
    10. do
    11.     echo "$var"
    12. done
    13.  
    14. echo "print each param from \$@"
    15. for var in $@
    16. do
    17.     echo "$var"
    18. done
    19.  
    20. echo "print each param from \"\$*\""
    21. for var in "$*"
    22. do
    23.     echo "$var"
    24. done
    25.  
    26. echo "print each param from \"\$@\""
    27. for var in "$@"
    28. do
    29.     echo "$var"
    30. done

    执行 ./test.sh "a" "b" "c""d",看到下面的结果:

    $*= a b c d

    "$*"= a b c d

    $@= a b c d

    "$@"= a b c d

    print each param from $*

    a

    b

    c

    d

    print each param from $@

    a

    b

    c

    d

    print each param from "$*"

    a b c d

    print each param from "$@"

    a

    b

    c

    d

    退出状态

    $? 可以获取上一个命令的退出状态。所谓退出状态,就是上一个命令执行后的返回结果。

    退出状态是一个数字,一般情况下,大部分命令执行成功会返回 0,失败返回 1。

    不过,也有一些命令返回其他值,表示不同类型的错误。

    下面例子中,命令成功执行:

    $./test.sh Zara Ali

    File Name : ./test.sh

    First Parameter : Zara

    Second Parameter : Ali

    Quoted Values: Zara Ali

    Quoted Values: Zara Ali

    Total Number of Parameters : 2

    $echo $?

    0

    $


    $? 也可以表示函数的返回值,后续将会讲解。

     

    Shell替换:Shell变量替换,命令替换,转义字符

     

    如果表达式中包含特殊字符,Shell 将会进行替换。例如,在双引号中使用变量就是一种替换,转义字符也是一种替换。

    举个例子:

    1. #!/bin/bash
    2.  
    3. a=10
    4. echo -e "Value of a is $a \n"

    运行结果:

    Value of a is 10

    这里 -e 表示对转义字符进行替换。如果不使用 -e 选项,将会原样输出:

    Value of a is 10\n


    下面的转义字符都可以用在 echo 中:

    转义字符

    含义

    \\

    反斜杠

    \a

    警报,响铃

    \b

    退格(删除键)

    \f

    换页(FF),将当前位置移到下页开头

    \n

    换行

    \r

    回车

    \t

    水平制表符(tab键) 

    \v

    垂直制表符

    可以使用 echo 命令的 -E 选项禁止转义,默认也是不转义的;使用 -n 选项可以禁止插入换行符。

    命令替换

    命令替换是指Shell可以先执行命令,将输出结果暂时保存,在适当的地方输出。

    命令替换的语法:

    1. `command`

    注意是反引号,不是单引号,这个键位于 Esc 键下方。

    下面的例子中,将命令执行结果保存在变量中:

    1. #!/bin/bash
    2.  
    3. DATE=`date`
    4. echo "Date is $DATE"
    5.  
    6. USERS=`who | wc -l`
    7. echo "Logged in user are $USERS"
    8.  
    9. UP=`date ; uptime`
    10. echo "Uptime is $UP"

    运行结果:

    Date is Thu Jul  2 03:59:57 MST 2009

    Logged in user are 1

    Uptime is Thu Jul  2 03:59:57 MST 2009

    03:59:57 up 20 days, 14:03,  1 user, load avg: 0.13, 0.07, 0.15

    变量替换

    变量替换可以根据变量的状态(是否为空、是否定义等)来改变它的值

    可以使用的变量替换形式:

    形式

    说明

    ${var}

    变量本来的值

    ${var:-word}

    如果变量 var 为空或已被删除(unset),那么返回 word,但不改变 var 的值。

    ${var:=word}

    如果变量 var 为空或已被删除(unset),那么返回 word,并将 var 的值设置为 word。

    ${var:?message}

    如果变量 var 为空或已被删除(unset),那么将消息 message 送到标准错误输出,可以用来检测变量 var 是否可以被正常赋值。
    若此替换出现在Shell脚本中,那么脚本将停止运行。

    ${var:+word}

    如果变量 var 被定义,那么返回 word,但不改变 var 的值。


    请看下面的例子:

    #!/bin/bash

     

    echo ${var:-"Variable is notset"}

    echo "1 - Value of var is ${var}"

     

    echo ${var:="Variable is notset"}

    echo "2 - Value of var is ${var}"

     

    unset var

    echo ${var:+"This is defaultvalue"}

    echo "3 - Value of var is $var"

     

    var="Prefix"

    echo ${var:+"This is defaultvalue"}

    echo "4 - Value of var is $var"

     

    echo ${var:?"Print this message"}

    echo "5 - Value of var is ${var}"

    运行结果:

    1. Variable is not set
    2. 1 - Value of var is
    3. Variable is not set
    4. 2 - Value of var is Variable is not set
    5.  
    6. 3 - Value of var is
    7. This is default value
    8. 4 - Value of var is Prefix
    9. Prefix
    10. 5 - Value of var is Prefix

     

    Shell运算符:Shell算数运算符、关系运算符、布尔运算符、字符串运算符等

     

    Bash 支持很多运算符,包括算数运算符、关系运算符、布尔运算符、字符串运算符和文件测试运算符。

    原生bash不支持简单的数学运算,但是可以通过其他命令来实现,例如 awk 和 expr,expr 最常用。

    expr 是一款表达式计算工具,使用它能完成表达式的求值操作。

    例如,两个数相加:

    1. #!/bin/bash
    2.  
    3. val=`expr 2 + 2`
    4. echo "Total value : $val"

    运行脚本输出:

    Total value : 4

    两点注意:

    • 表达式和运算符之间要有空格,例如 2+2 是不对的,必须写成 2 + 2,这与我们熟悉的大多数编程语言不一样。
    • 完整的表达式要被 ` ` 包含,注意这个字符不是常用的单引号,在 Esc 键下边。

    算术运算符

    先来看一个使用算术运算符的例子:

    1. #!/bin/sh
    2.  
    3. a=10
    4. b=20
    5. val=`expr $a + $b`
    6. echo "a + b : $val"
    7.  
    8. val=`expr $a - $b`
    9. echo "a - b : $val"
    10.  
    11. val=`expr $a \* $b`
    12. echo "a * b : $val"
    13.  
    14. val=`expr $b / $a`
    15. echo "b / a : $val"
    16.  
    17. val=`expr $b % $a`
    18. echo "b % a : $val"
    19.  
    20. if [ $a == $b ]
    21. then
    22.    echo "a is equal to b"
    23. fi
    24.  
    25. if [ $a != $b ]
    26. then
    27.    echo "a is not equal to b"
    28. fi

    运行结果:

    a + b : 30

    a - b : -10

    a * b : 200

    b / a : 2

    b % a : 0

    a is not equal to b

    注意:

    • 乘号(*)前边必须加反斜杠(\)才能实现乘法运算;
    • if...then...fi 是条件语句,后续将会讲解。

     

    算术运算符列表

    运算符

    说明

    举例

    +

    加法

    `expr $a + $b` 结果为 30。

    -

    减法

    `expr $a - $b` 结果为 10。

    *

    乘法

    `expr $a \* $b` 结果为  200。

    /

    除法

    `expr $b / $a` 结果为 2。

    %

    取余

    `expr $b % $a` 结果为 0。

    =

    赋值

    a=$b 将把变量 b 的值赋给 a。

    ==

    相等。用于比较两个数字,相同则返回 true。

    [ $a == $b ] 返回 false。

    !=

    不相等。用于比较两个数字,不相同则返回 true。

    [ $a != $b ] 返回 true。


    注意:条件表达式要放在方括号之间,并且要有空格,例如 [$a==$b] 是错误的,必须写成 [ $a == $b ]。

    关系运算符

    关系运算符只支持数字,不支持字符串,除非字符串的值是数字。

    先来看一个关系运算符的例子:

    1. #!/bin/sh
    2.  
    3. a=10
    4. b=20
    5. if [ $a -eq $b ]
    6. then
    7.    echo "$a -eq $b : a is equal to b"
    8. else
    9.    echo "$a -eq $b: a is not equal to b"
    10. fi
    11.  
    12. if [ $a -ne $b ]
    13. then
    14.    echo "$a -ne $b: a is not equal to b"
    15. else
    16.    echo "$a -ne $b : a is equal to b"
    17. fi
    18.  
    19. if [ $a -gt $b ]
    20. then
    21.    echo "$a -gt $b: a is greater than b"
    22. else
    23.    echo "$a -gt $b: a is not greater than b"
    24. fi
    25.  
    26. if [ $a -lt $b ]
    27. then
    28.    echo "$a -lt $b: a is less than b"
    29. else
    30.    echo "$a -lt $b: a is not less than b"
    31. fi
    32.  
    33. if [ $a -ge $b ]
    34. then
    35.    echo "$a -ge $b: a is greater or  equal to b"
    36. else
    37.    echo "$a -ge $b: a is not greater or equal to b"
    38. fi
    39.  
    40. if [ $a -le $b ]
    41. then
    42.    echo "$a -le $b: a is less or  equal to b"
    43. else
    44.    echo "$a -le $b: a is not less or equal to b"
    45. fi

    运行结果:

    10 -eq 20: a is not equal to b

    10 -ne 20: a is not equal to b

    10 -gt 20: a is not greater than b

    10 -lt 20: a is less than b

    10 -ge 20: a is not greater or equal to b

    10 -le 20: a is less or  equal to b

     

    关系运算符列表

    运算符

    说明

    举例

    -eq

    检测两个数是否相等,相等返回 true。

    [ $a -eq $b ] 返回 true。

    -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。

    布尔运算符

    先来看一个布尔运算符的例子:

    1. #!/bin/sh
    2.  
    3. a=10
    4. b=20
    5.  
    6. if [ $a != $b ]
    7. then
    8.    echo "$a != $b : a is not equal to b"
    9. else
    10.    echo "$a != $b: a is equal to b"
    11. fi
    12.  
    13. if [ $a -lt 100 -a $b -gt 15 ]
    14. then
    15.    echo "$a -lt 100 -a $b -gt 15 : returns true"
    16. else
    17.    echo "$a -lt 100 -a $b -gt 15 : returns false"
    18. fi
    19.  
    20. if [ $a -lt 100 -o $b -gt 100 ]
    21. then
    22.    echo "$a -lt 100 -o $b -gt 100 : returns true"
    23. else
    24.    echo "$a -lt 100 -o $b -gt 100 : returns false"
    25. fi
    26.  
    27. if [ $a -lt 5 -o $b -gt 100 ]
    28. then
    29.    echo "$a -lt 100 -o $b -gt 100 : returns true"
    30. else
    31.    echo "$a -lt 100 -o $b -gt 100 : returns false"
    32. fi

    运行结果:

    10 != 20 : a is not equal to b

    10 -lt 100 -a 20 -gt 15 : returns true

    10 -lt 100 -o 20 -gt 100 : returns true

    10 -lt 5 -o 20 -gt 100 : returns false

     

    布尔运算符列表

    运算符

    说明

    举例

    !

    非运算,表达式为 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。

    字符串运算符

    先来看一个例子:

    1. #!/bin/sh
    2.  
    3. a="abc"
    4. b="efg"
    5.  
    6. if [ $a = $b ]
    7. then
    8.    echo "$a = $b : a is equal to b"
    9. else
    10.    echo "$a = $b: a is not equal to b"
    11. fi
    12.  
    13. if [ $a != $b ]
    14. then
    15.    echo "$a != $b : a is not equal to b"
    16. else
    17.    echo "$a != $b: a is equal to b"
    18. fi
    19.  
    20. if [ -z $a ]
    21. then
    22.    echo "-z $a : string length is zero"
    23. else
    24.    echo "-z $a : string length is not zero"
    25. fi
    26.  
    27. if [ -n $a ]
    28. then
    29.    echo "-n $a : string length is not zero"
    30. else
    31.    echo "-n $a : string length is zero"
    32. fi
    33.  
    34. if [ $a ]
    35. then
    36.    echo "$a : string is not empty"
    37. else
    38.    echo "$a : string is empty"
    39. fi

    运行结果:

    abc = efg: a is not equal to b

    abc != efg : a is not equal to b

    -z abc : string length is not zero

    -n abc : string length is not zero

    abc : string is not empty

     

    字符串运算符列表

    运算符

    说明

    举例

    =

    检测两个字符串是否相等,相等返回 true。

    [ $a = $b ] 返回 false。

    !=

    检测两个字符串是否相等,不相等返回 true。

    [ $a != $b ] 返回 true。

    -z

    检测字符串长度是否为0,为0返回 true。

    [ -z $a ] 返回 false。

    -n

    检测字符串长度是否为0,不为0返回 true。

    [ -z $a ] 返回 true。

    str

    检测字符串是否为空,不为空返回 true。

    [ $a ] 返回 true。

    文件测试运算符

    文件测试运算符用于检测 Unix 文件的各种属性。

    例如,变量 file 表示文件“/var/www/tutorialspoint/unix/test.sh”,它的大小为100字节,具有 rwx 权限。下面的代码,将检测该文件的各种属性:

    1. #!/bin/sh
    2.  
    3. file="/var/www/tutorialspoint/unix/test.sh"
    4.  
    5. if [ -r $file ]
    6. then
    7.    echo "File has read access"
    8. else
    9.    echo "File does not have read access"
    10. fi
    11.  
    12. if [ -w $file ]
    13. then
    14.    echo "File has write permission"
    15. else
    16.    echo "File does not have write permission"
    17. fi
    18.  
    19. if [ -x $file ]
    20. then
    21.    echo "File has execute permission"
    22. else
    23.    echo "File does not have execute permission"
    24. fi
    25.  
    26. if [ -f $file ]
    27. then
    28.    echo "File is an ordinary file"
    29. else
    30.    echo "This is sepcial file"
    31. fi
    32.  
    33. if [ -d $file ]
    34. then
    35.    echo "File is a directory"
    36. else
    37.    echo "This is not a directory"
    38. fi
    39.  
    40. if [ -s $file ]
    41. then
    42.    echo "File size is zero"
    43. else
    44.    echo "File size is not zero"
    45. fi
    46.  
    47. if [ -e $file ]
    48. then
    49.    echo "File exists"
    50. else
    51.    echo "File does not exist"
    52. fi

    运行结果:

    File has read access

    File has write permission

    File has execute permission

    File is an ordinary file

    This is not a directory

    File size is zero

    File exists

     

    文件测试运算符列表

    操作符

    说明

    举例

    -b file

    检测文件是否是块设备文件,如果是,则返回 true。

    [ -b $file ] 返回 false。

    -c file

    检测文件是否是字符设备文件,如果是,则返回 true。

    [ -b $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。

     

    Shell注释

     

    以“#”开头的行就是注释,会被解释器忽略。

    sh里没有多行注释,只能每一行加一个#号。只能像这样:

    1. #--------------------------------------------
    2. # 这是一个自动打ipa的脚本,基于webfrogs的ipa-build书写:
    3. # https://github.com/webfrogs/xcode_shell/blob/master/ipa-build
    4.  
    5. # 功能:自动为etao ios app打包,产出物为14个渠道的ipa包
    6. # 特色:全自动打包,不需要输入任何参数
    7. #--------------------------------------------
    8.  
    9. ##### 用户配置区 开始 #####
    10. #
    11. #
    12. # 项目根目录,推荐将此脚本放在项目的根目录,这里就不用改了
    13. # 应用名,确保和Xcode里Product下的target_name.app名字一致
    14. #
    15. ##### 用户配置区 结束  #####

    如果在开发过程中,遇到大段的代码需要临时注释起来,过一会儿又取消注释,怎么办呢?每一行加个#符号太费力了,可以把这一段要注释的代码用一对花括号括起来,定义成一个函数,没有地方调用这个函数,这块代码就不会执行,达到了和注释一样的效果。

     

    Shell字符串

     

    字符串是shell编程中最常用最有用的数据类型(除了数字和字符串,也没啥其它类型好用了),字符串可以用单引号,也可以用双引号,也可以不用引号。单双引号的区别跟PHP类似。

    单引号

    1. str='this is a string'

    单引号字符串的限制:

    • 单引号里的任何字符都会原样输出,单引号字符串中的变量是无效的;
    • 单引号字串中不能出现单引号(对单引号使用转义符后也不行)。

    双引号

    1. your_name='qinjx'
    2. str="Hello, I know your are \"$your_name\"! \n"

    双引号的优点:

    • 双引号里可以有变量
    • 双引号里可以出现转义字符

    拼接字符串

    1. your_name="qinjx"
    2. greeting="hello, "$your_name" !"
    3. greeting_1="hello, ${your_name} !"
    4.  
    5. echo $greeting $greeting_1

    获取字符串长度

    1. string="abcd"
    2. echo ${#string} #输出 4

    提取子字符串

    1. string="alibaba is a great company"
    2. echo ${string:1:4} #输出liba

    查找子字符串

    1. string="alibaba is a great company"
    2. echo `expr index "$string" is`

     

    Shell数组:shell数组的定义、数组长度

    Shell在编程方面比Windows批处理强大很多,无论是在循环、运算。

    bash支持一维数组(不支持多维数组),并且没有限定数组的大小。类似与C语言,数组元素的下标由0开始编号。获取数组中的元素要利用下标,下标可以是整数或算术表达式,其值应大于或等于0。

    定义数组

    在Shell中,用括号来表示数组,数组元素用“空格”符号分割开。定义数组的一般形式为:
        array_name=(value1 ... valuen)
    例如:

    1. array_name=(value0 value1 value2 value3)

    或者

    1. array_name=(
    2. value0
    3. value1
    4. value2
    5. value3
    6. )


    还可以单独定义数组的各个分量:

    1. array_name[0]=value0
    2. array_name[1]=value1
    3. array_name[2]=value2

    可以不使用连续的下标,而且下标的范围没有限制。

    读取数组

    读取数组元素值的一般格式是:
        ${array_name[index]}
    例如:

    1. valuen=${array_name[2]}

    举个例子:

    1. #!/bin/sh
    2.  
    3. NAME[0]="Zara"
    4. NAME[1]="Qadir"
    5. NAME[2]="Mahnaz"
    6. NAME[3]="Ayan"
    7. NAME[4]="Daisy"
    8. echo "First Index: ${NAME[0]}"
    9. echo "Second Index: ${NAME[1]}"

    运行脚本,输出:

    $./test.sh

    First Index: Zara

    Second Index: Qadir

    使用@ 或 * 可以获取数组中的所有元素,例如:

    1. ${array_name[*]}
    2. ${array_name[@]}

    举个例子:

    1. #!/bin/sh
    2.  
    3. NAME[0]="Zara"
    4. NAME[1]="Qadir"
    5. NAME[2]="Mahnaz"
    6. NAME[3]="Ayan"
    7. NAME[4]="Daisy"
    8. echo "First Method: ${NAME[*]}"
    9. echo "Second Method: ${NAME[@]}"

    运行脚本,输出:

    $./test.sh

    First Method: Zara Qadir Mahnaz Ayan Daisy

    Second Method: Zara Qadir Mahnaz Ayan Daisy

    获取数组的长度

    获取数组长度的方法与获取字符串长度的方法相同,例如:

    1. # 取得数组元素的个数
    2. length=${#array_name[@]}
    3. # 或者
    4. length=${#array_name[*]}
    5. # 取得数组单个元素的长度
    6. lengthn=${#array_name[n]}

     

    Shell echo命令

    echo是Shell的一个内部指令,用于在屏幕上打印出指定的字符串。命令格式:

    1. echo arg

    您可以使用echo实现更复杂的输出格式控制。

    显示转义字符

    1. echo "\"It is a test\""

    结果将是:
    "It is a test"

    双引号也可以省略。

    显示变量

    1. name="OK"
    2. echo "$name It is a test"

    结果将是:
    OK It is a test

    同样双引号也可以省略。

    如果变量与其它字符相连的话,需要使用大括号({ }):

    1. mouth=8
    2. echo "${mouth}-1-2009"

    结果将是:
    8-1-2009

    显示换行

    1. echo "OK!\n"
    2. echo "It is a test"

    输出:
    OK!
    It is a test

    显示不换行

    1. echo "OK!\c"
    2. echo "It is a test"

    输出:
    OK!It si a test

    显示结果重定向至文件

    1. echo "It is a test" > myfile

    原样输出字符串

    若需要原样输出字符串(不进行转义),请使用单引号。例如:

    1. echo '$name\"'

    显示命令执行结果

    1. echo `date`

    结果将显示当前日期

    从上面可看出,双引号可有可无,单引号主要用在原样输出中。

     

    shell printf命令:格式化输出语句

     

    printf 命令用于格式化输出, 是echo命令的增强版。它是C语言printf()库函数的一个有限的变形,并且在语法上有些不同。

    注意:printf 由 POSIX 标准所定义,移植性要比 echo 好。

    如同 echo 命令,printf 命令也可以输出简单的字符串:

    1. $printf "Hello, Shell\n"
    2. Hello, Shell
    3. $

    printf 不像 echo 那样会自动换行,必须显式添加换行符(\n)。

    printf 命令的语法:

    printf format-string  [arguments...]

    format-string 为格式控制字符串,arguments为参数列表。

    printf()在C语言入门教程中已经讲到,功能和用法与 printf 命令类似,请查看:C语言格式输出函数printf()详解

    这里仅说明与C语言printf()函数的不同:

    • printf 命令不用加括号
    • format-string 可以没有引号,但最好加上,单引号双引号均可。
    • 参数多于格式控制符(%)时,format-string 可以重用,可以将所有参数都转换。
    • arguments 使用空格分隔,不用逗号。


    请看下面的例子:

    1. # format-string为双引号
    2. $ printf "%d %s\n" 1 "abc"
    3. 1 abc
    4. # 单引号与双引号效果一样
    5. $ printf '%d %s\n' 1 "abc"
    6. 1 abc
    7. # 没有引号也可以输出
    8. $ printf %s abcdef
    9. abcdef
    10. # 格式只指定了一个参数,但多出的参数仍然会按照该格式输出,format-string 被重用
    11. $ printf %s abc def
    12. abcdef
    13. $ printf "%s\n" abc def
    14. abc
    15. def
    16. $ printf "%s %s %s\n" a b c d e f g h i j
    17. a b c
    18. d e f
    19. g h i
    20. j
    21. # 如果没有 arguments,那么 %s 用NULL代替,%d 用 0 代替
    22. $ printf "%s and %d \n"
    23. and 0
    24. # 如果以 %d 的格式来显示字符串,那么会有警告,提示无效的数字,此时默认置为 0
    25. $ printf "The first program always prints'%s,%d\n'" Hello Shell
    26. -bash: printf: Shell: invalid number
    27. The first program always prints 'Hello,0'
    28. $


    注意,根据POSIX标准,浮点格式%e、%E、%f、%g与%G是“不需要被支持”。这是因为awk支持浮点预算,且有它自己的printf语句。这样Shell程序中需要将浮点数值进行格式化的打印时,可使用小型的awk程序实现。然而,内建于bash、ksh93和zsh中的printf命令都支持浮点格式。

     

    Shell if else语句

     

    if 语句通过关系运算符判断表达式的真假来决定执行哪个分支。Shell 有三种 if ... else 语句:

    • if ... fi 语句;
    • if ... else ... fi 语句;
    • if ... elif ... else ... fi 语句。

    1) if ... else 语句

    if ... else 语句的语法:

    if [ expression ]

    then

      Statement(s) to be executed if expression is true

    fi

    如果 expression 返回 true,then 后边的语句将会被执行;如果返回 false,不会执行任何语句。

    最后必须以 fi 来结尾闭合 if,fi 就是 if 倒过来拼写,后面也会遇见。

    注意:expression 和方括号([ ])之间必须有空格,否则会有语法错误。

    举个例子:

    1. #!/bin/sh
    2.  
    3. a=10
    4. b=20
    5.  
    6. if [ $a == $b ]
    7. then
    8.    echo "a is equal to b"
    9. fi
    10.  
    11. if [ $a != $b ]
    12. then
    13.    echo "a is not equal to b"
    14. fi

    运行结果:

    a is not equal to b

    2) if ... else ... fi 语句

    if ... else ... fi 语句的语法:

    if [ expression ]

    then

      Statement(s) to be executed if expression is true

    else

      Statement(s) to be executed if expression is not true

    fi

    如果 expression 返回 true,那么 then 后边的语句将会被执行;否则,执行 else 后边的语句。

    举个例子:

    1. #!/bin/sh
    2.  
    3. a=10
    4. b=20
    5.  
    6. if [ $a == $b ]
    7. then
    8.    echo "a is equal to b"
    9. else
    10.    echo "a is not equal to b"
    11. fi

    执行结果:

    a is not equal to b

    3) if ... elif ... fi 语句

    if ... elif ... fi 语句可以对多个条件进行判断,语法为:

    if [ expression 1 ]

    then

      Statement(s) to be executed if expression 1 is true

    elif [ expression 2 ]

    then

      Statement(s) to be executed if expression 2 is true

    elif [ expression 3 ]

    then

      Statement(s) to be executed if expression 3 is true

    else

      Statement(s) to be executed if no expression is true

    fi

    哪一个 expression 的值为 true,就执行哪个 expression 后面的语句;如果都为 false,那么不执行任何语句。

    举个例子:

    1. #!/bin/sh
    2.  
    3. a=10
    4. b=20
    5.  
    6. if [ $a == $b ]
    7. then
    8.    echo "a is equal to b"
    9. elif [ $a -gt $b ]
    10. then
    11.    echo "a is greater than b"
    12. elif [ $a -lt $b ]
    13. then
    14.    echo "a is less than b"
    15. else
    16.    echo "None of the condition met"
    17. fi

    运行结果:

    a is less than b


    if ... else 语句也可以写成一行,以命令的方式来运行,像这样:

    1. if test $[2*3] -eq $[1+5]; then echo 'The two numbers are equal!'; fi;


    if ... else 语句也经常与 test 命令结合使用,如下所示:

    1. num1=$[2*3]
    2. num2=$[1+5]
    3. if test $[num1] -eq $[num2]
    4. then
    5.     echo 'The two numbers are equal!'
    6. else
    7.     echo 'The two numbers are not equal!'
    8. fi

    输出:

    The two numbers are equal!

    test 命令用于检查某个条件是否成立,与方括号([])类似。

     

    Shell case esac语句

     

    case ... esac 与其他语言中的switch ... case 语句类似,是一种多分枝选择结构。

    case 语句匹配一个值或一个模式,如果匹配成功,执行相匹配的命令。case语句格式如下:

    case 值 in

    模式1)

       command1

       command2

       command3

       ;;

    模式2)

       command1

       command2

       command3

       ;;

    *)

       command1

       command2

       command3

       ;;

    esac

    case工作方式如上所示。取值后面必须为关键字in,每一模式必须以右括号结束。取值可以为变量或常数。匹配发现取值符合某一模式后,其间所有命令开始执行直至 ;;。;; 与其他语言中的 break 类似,意思是跳到整个 case 语句的最后。

    取值将检测匹配的每一个模式。一旦模式匹配,则执行完匹配模式相应命令后不再继续其他模式。如果无一匹配模式,使用星号 * 捕获该值,再执行后面的命令。

    下面的脚本提示输入1到4,与每一种模式进行匹配:

    1. echo 'Input a number between 1 to 4'
    2. echo 'Your number is:\c'
    3. read aNum
    4. case $aNum in
    5.     1)  echo 'You select 1'
    6.     ;;
    7.     2)  echo 'You select 2'
    8.     ;;
    9.     3)  echo 'You select 3'
    10.     ;;
    11.     4)  echo 'You select 4'
    12.     ;;
    13.     *)  echo 'You do not select a number between 1 to 4'
    14.     ;;
    15. esac

    输入不同的内容,会有不同的结果,例如:

    Input a number between 1 to 4

    Your number is:3

    You select 3


    再举一个例子:

    1. #!/bin/bash
    2.  
    3. option="${1}"
    4. case ${option} in
    5.    -f) FILE="${2}"
    6.       echo "File name is $FILE"
    7.       ;;
    8.    -d) DIR="${2}"
    9.       echo "Dir name is $DIR"
    10.       ;;
    11.    *)
    12.       echo "`basename ${0}`:usage: [-f file] | [-d directory]"
    13.       exit 1 # Command to come out of the program with status 1
    14.       ;;
    15. esac

    运行结果:

    $./test.sh

    test.sh: usage: [ -f filename ] | [ -ddirectory ]

    $ ./test.sh -f index.htm

    $ vi test.sh

    $ ./test.sh -f index.htm

    File name is index.htm

    $ ./test.sh -d unix

    Dir name is unix

    $

     

    Shell for循环

     

     

    与其他编程语言类似,Shell支持for循环。

    for循环一般格式为:

    for 变量 in 列表

    do

       command1

       command2

       ...

       commandN

    done

    列表是一组值(数字、字符串等)组成的序列,每个值通过空格分隔。每循环一次,就将列表中的下一个值赋给变量。

    in 列表是可选的,如果不用它,for 循环使用命令行的位置参数。

    例如,顺序输出当前列表中的数字:

    1. for loop in 1 2 3 4 5
    2. do
    3.     echo "The value is: $loop"
    4. done

    运行结果:

    The value is: 1

    The value is: 2

    The value is: 3

    The value is: 4

    The value is: 5


    顺序输出字符串中的字符:

    1. for str in 'This is a string'
    2. do
    3.     echo $str
    4. done

    运行结果:

    This is a string


    显示主目录下以 .bash 开头的文件:

    1. #!/bin/bash
    2.  
    3. for FILE in $HOME/.bash*
    4. do
    5.    echo $FILE
    6. done

    运行结果:

    /root/.bash_history

    /root/.bash_logout

    /root/.bash_profile

    /root/.bashrc

     

    Shell while循环

     

    while循环用于不断执行一系列命令,也用于从输入文件中读取数据;命令通常为测试条件。其格式为:

    while command

    do

       Statement(s) to be executed ifcommand is true

    done

    命令执行完毕,控制返回循环顶部,从头开始直至测试条件为假。

    以下是一个基本的while循环,测试条件是:如果COUNTER小于5,那么返回 true。COUNTER从0开始,每次循环处理时,COUNTER加1。运行上述脚本,返回数字1到5,然后终止。

    1. COUNTER=0
    2. while [ $COUNTER -lt 5 ]
    3. do
    4.     COUNTER='expr $COUNTER+1'
    5.     echo $COUNTER
    6. done

    运行脚本,输出:

    1

    2

    3

    4

    5


    while循环可用于读取键盘信息。下面的例子中,输入信息被设置为变量FILM,按<Ctrl-D>结束循环。

    1. echo 'type <CTRL-D> to terminate'
    2. echo -n 'enter your most liked film: '
    3. while read FILM
    4. do
    5.     echo "Yeah! great film the $FILM"
    6. done

    运行脚本,输出类似下面:

    type <CTRL-D> to terminate

    enter your most liked film: Sound of Music

    Yeah! great film the Sound of Music

    Shell until循环

    until 循环执行一系列命令直至条件为 true 时停止。until 循环与 while 循环在处理方式上刚好相反。一般while循环优于until循环,但在某些时候,也只是极少数情况下,until 循环更加有用。

    until 循环格式为:

    until command

    do

      Statement(s) to be executed until command is true

    done

    command 一般为条件表达式,如果返回值为 false,则继续执行循环体内的语句,否则跳出循环。

    例如,使用 until 命令输出 0 ~ 9 的数字:

    1. #!/bin/bash
    2.  
    3. a=0
    4.  
    5. until [ ! $a -lt 10 ]
    6. do
    7.    echo $a
    8.    a=`expr $a + 1`
    9. done

    运行结果:

    0

    1

    2

    3

    4

    5

    6

    7

    8

    9

    Shell breakcontinue命令

     

    在循环过程中,有时候需要在未达到循环结束条件时强制跳出循环,像大多数编程语言一样,Shell也使用 break 和 continue 来跳出循环。

    break命令

    break命令允许跳出所有循环(终止执行后面的所有循环)。

    下面的例子中,脚本进入死循环直至用户输入数字大于5。要跳出这个循环,返回到shell提示符下,就要使用break命令。

    1. #!/bin/bash
    2. while :
    3. do
    4.     echo -n "Input a number between 1 to 5: "
    5.     read aNum
    6.     case $aNum in
    7.         1|2|3|4|5) echo "Your number is $aNum!"
    8.         ;;
    9.         *) echo "You do not select a number between 1 to 5, game is over!"
    10.             break
    11.         ;;
    12.     esac
    13. done

    在嵌套循环中,break 命令后面还可以跟一个整数,表示跳出第几层循环。例如:

    1. break n

    表示跳出第 n 层循环。

    下面是一个嵌套循环的例子,如果 var1 等于 2,并且 var2 等于 0,就跳出循环:

    1. #!/bin/bash
    2.  
    3. for var1 in 1 2 3
    4. do
    5.    for var2 in 0 5
    6.    do
    7.       if [ $var1 -eq 2 -a $var2 -eq 0 ]
    8.       then
    9.          break 2
    10.       else
    11.          echo "$var1 $var2"
    12.       fi
    13.    done
    14. done

    如上,break 2 表示直接跳出外层循环。运行结果:

    1 0

    1 5

    continue命令

    continue命令与break命令类似,只有一点差别,它不会跳出所有循环,仅仅跳出当前循环。

    对上面的例子进行修改:

    1. #!/bin/bash
    2. while :
    3. do
    4.     echo -n "Input a number between 1 to 5: "
    5.     read aNum
    6.     case $aNum in
    7.         1|2|3|4|5) echo "Your number is $aNum!"
    8.         ;;
    9.         *) echo "You do not select a number between 1 to 5!"
    10.             continue
    11.             echo "Game is over!"
    12.         ;;
    13.     esac
    14. done

    运行代码发现,当输入大于5的数字时,该例中的循环不会结束,语句

    1. echo "Game is over!"

    永远不会被执行。

    同样,continue 后面也可以跟一个数字,表示跳出第几层循环。

    再看一个 continue 的例子:

    1. #!/bin/bash
    2.  
    3. NUMS="1 2 3 4 5 6 7"
    4.  
    5. for NUM in $NUMS
    6. do
    7.    Q=`expr $NUM % 2`
    8.    if [ $Q -eq 0 ]
    9.    then
    10.       echo "Number is an even number!!"
    11.       continue
    12.    fi
    13.    echo "Found odd number"
    14. done

    运行结果:

    Found odd number

    Number is an even number!!

    Found odd number

    Number is an even number!!

    Found odd number

    Number is an even number!!

    Found odd number

     

    Shell函数:Shell函数返回值、删除函数、在终端调用函数

     

    函数可以让我们将一个复杂功能划分成若干模块,让程序结构更加清晰,代码重复利用率更高。像其他编程语言一样,Shell 也支持函数。Shell 函数必须先定义后使用。

    Shell 函数的定义格式如下:

    function_name () {

       list of commands

        [return value ]

    }

    如果你愿意,也可以在函数名前加上关键字 function:

    function function_name () {

       list of commands

        [return value ]

    }

    函数返回值,可以显式增加return语句;如果不加,会将最后一条命令运行结果作为返回值。

    Shell 函数返回值只能是整数,一般用来表示函数执行成功与否,0表示成功,其他值表示失败。如果 return 其他数据,比如一个字符串,往往会得到错误提示:“numeric argument required”。

    如果一定要让函数返回字符串,那么可以先定义一个变量,用来接收函数的计算结果,脚本在需要的时候访问这个变量来获得函数返回值。

    先来看一个例子:

    1. #!/bin/bash
    2.  
    3. # Define your function here
    4. Hello () {
    5.    echo "Url is http://see.xidian.edu.cn/cpp/shell/"
    6. }
    7.  
    8. # Invoke your function
    9. Hello

    运行结果:

    $./test.sh

    Hello World

    $

    调用函数只需要给出函数名,不需要加括号。

    再来看一个带有return语句的函数:

    1. #!/bin/bash
    2. funWithReturn(){
    3.     echo "The function is to get the sum of two numbers..."
    4.     echo -n "Input first number: "
    5.     read aNum
    6.     echo -n "Input another number: "
    7.     read anotherNum
    8.     echo "The two numbers are $aNum and $anotherNum !"
    9.     return $(($aNum+$anotherNum))
    10. }
    11. funWithReturn
    12. # Capture value returnd by last command
    13. ret=$?
    14. echo "The sum of two numbers is $ret !"

    运行结果:

    The function is to get the sum of twonumbers...

    Input first number: 25

    Input another number: 50

    The two numbers are 25 and 50 !

    The sum of two numbers is 75 !

    函数返回值在调用该函数后通过 $? 来获得。

    再来看一个函数嵌套的例子:

    1. #!/bin/bash
    2.  
    3. # Calling one function from another
    4. number_one () {
    5.    echo "Url_1 is http://see.xidian.edu.cn/cpp/shell/"
    6.    number_two
    7. }
    8.  
    9. number_two () {
    10.    echo "Url_2 is http://see.xidian.edu.cn/cpp/u/xitong/"
    11. }
    12.  
    13. number_one

    运行结果:

    Url_1 is http://see.xidian.edu.cn/cpp/shell/

    Url_2 ishttp://see.xidian.edu.cn/cpp/u/xitong/

    像删除变量一样,删除函数也可以使用 unset 命令,不过要加上 .f 选项,如下所示:

    1. $unset .f function_name

    如果你希望直接从终端调用函数,可以将函数定义在主目录下的 .profile 文件,这样每次登录后,在命令提示符后面输入函数名字就可以立即调用。

     

    Shell函数参数

     

    在Shell中,调用函数时可以向其传递参数。在函数体内部,通过 $n 的形式来获取参数的值,例如,$1表示第一个参数,$2表示第二个参数...

    带参数的函数示例:

    1. #!/bin/bash
    2. funWithParam(){
    3.     echo "The value of the first parameter is $1 !"
    4.     echo "The value of the second parameter is $2 !"
    5.     echo "The value of the tenth parameter is $10 !"
    6.     echo "The value of the tenth parameter is ${10} !"
    7.     echo "The value of the eleventh parameter is ${11} !"
    8.     echo "The amount of the parameters is $# !"  # 参数个数
    9.     echo "The string of the parameters is $* !"  # 传递给函数的所有参数
    10. }
    11. funWithParam 1 2 3 4 5 6 7 8 9 34 73

    运行脚本:

    The value of the first parameter is 1 !

    The value of the second parameter is 2 !

    The value of the tenth parameter is 10 !

    The value of the tenth parameter is 34 !

    The value of the eleventh parameter is 73 !

    The amount of the parameters is 12 !

    The string of the parameters is 1 2 3 4 5 67 8 9 34 73 !"

    注意,$10 不能获取第十个参数,获取第十个参数需要${10}。当n>=10时,需要使用${n}来获取参数。

    另外,还有几个特殊变量用来处理参数,前面已经提到:

    特殊变量

    说明

    $#

    传递给函数的参数个数。

    $*

    显示所有传递给函数的参数。

    $@

    与$*相同,但是略有区别,请查看Shell特殊变量

    $?

    函数的返回值。

     

    Shell输入输出重定向:ShellHere Document/dev/null文件

     

    Unix 命令默认从标准输入设备(stdin)获取输入,将结果输出到标准输出设备(stdout)显示。一般情况下,标准输入设备就是键盘,标准输出设备就是终端,即显示器。

    输出重定向

    命令的输出不仅可以是显示器,还可以很容易的转移向到文件,这被称为输出重定向。

    命令输出重定向的语法为:

    1. $ command > file

    这样,输出到显示器的内容就可以被重定向到文件。

    例如,下面的命令在显示器上不会看到任何输出:

    1. $ who > users

    打开 users 文件,可以看到下面的内容:

    $ cat users

    oko        tty01   Sep 12 07:30

    ai         tty15   Sep 12 13:32

    ruth       tty21   Sep 12 10:10

    pat        tty24   Sep 12 13:07

    steve      tty25   Sep 12 13:03

    $

    输出重定向会覆盖文件内容,请看下面的例子:

    $ echo line 1 > users

    $ cat users

    line 1

    $

    如果不希望文件内容被覆盖,可以使用 >> 追加到文件末尾,例如:

    $ echo line 2 >> users

    $ cat users

    line 1

    line 2

    $

    输入重定向

    和输出重定向一样,Unix 命令也可以从文件获取输入,语法为:

    1. command < file

    这样,本来需要从键盘获取输入的命令会转移到文件读取内容。

    注意:输出重定向是大于号(>),输入重定向是小于号(<)。

    例如,计算 users 文件中的行数,可以使用下面的命令:

    $ wc -l users

    2 users

    $

    也可以将输入重定向到 users 文件:

    $ wc -l < users

    2

    $

    注意:上面两个例子的结果不同:第一个例子,会输出文件名;第二个不会,因为它仅仅知道从标准输入读取内容。

    重定向深入讲解

    一般情况下,每个 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。

    如果希望 stderr 重定向到 file,可以这样写:

    1. $command 2 > file

    如果希望 stderr 追加到 file 文件末尾,可以这样写:

    1. $command 2 >> file

    2 表示标准错误文件(stderr)。

    如果希望将 stdout 和 stderr 合并后重定向到 file,可以这样写:

    1. $command > file 2>&1

    1. $command >> file 2>&1

    如果希望对 stdin 和 stdout 都重定向,可以这样写:

    1. $command < file1 >file2

    command 命令将 stdin 重定向到 file1,将 stdout 重定向到 file2。 

    全部可用的重定向命令列表

    命令

    说明

    command > file

    将输出重定向到 file。

    command < file

    将输入重定向到 file。

    command >> file

    将输出以追加的方式重定向到 file。

    n > file

    将文件描述符为 n 的文件重定向到 file。

    n >> file

    将文件描述符为 n 的文件以追加的方式重定向到 file。

    n >& m

    将输出文件 m 和 n 合并。

    n <& m

    将输入文件 m 和 n 合并。

    << tag

    将开始标记 tag 和结束标记 tag 之间的内容作为输入。

    Here Document

    Here Document 目前没有统一的翻译,这里暂译为”嵌入文档“。Here Document 是 Shell 中的一种特殊的重定向方式,它的基本的形式如下:

    1. command << delimiter
    2.     document
    3. delimiter

    它的作用是将两个 delimiter 之间的内容(document) 作为输入传递给 command。

    注意:

    • 结尾的delimiter 一定要顶格写,前面不能有任何字符,后面也不能有任何字符,包括空格和 tab 缩进。
    • 开始的delimiter前后的空格会被忽略掉。


    下面的例子,通过 wc -l 命令计算 document 的行数:

    $wc -l << EOF

       This is a simple lookup program

       for good (and bad) restaurants

       in Cape Town.

    EOF

    3

    $

    也可以将 Here Document 用在脚本中,例如:

    1. #!/bin/bash
    2.  
    3. cat << EOF
    4. This is a simple lookup program
    5. for good (and bad) restaurants
    6. in Cape Town.
    7. EOF

    运行结果:

    This is a simple lookup program

    for good (and bad) restaurants

    in Cape Town.


    下面的脚本通过 vi 编辑器将 document 保存到 test.txt 文件:

    1. #!/bin/sh
    2.  
    3. filename=test.txt
    4. vi $filename <<EndOfCommands
    5. i
    6. This file was created automatically from
    7. a shell script
    8. ^[
    9. ZZ
    10. EndOfCommands

    运行脚本:

    $ sh test.sh

    Vim: Warning: Input is not from a terminal

    $

    打开 test.txt,可以看到下面的内容:

    $ cat test.txt

    This file was created automatically from

    a shell script

    $

    /dev/null 文件

    如果希望执行某个命令,但又不希望在屏幕上显示输出结果,那么可以将输出重定向到 /dev/null:

    1. $ command > /dev/null

    /dev/null 是一个特殊的文件,写入到它的内容都会被丢弃;如果尝试从该文件读取内容,那么什么也读不到。但是 /dev/null 文件非常有用,将命令的输出重定向到它,会起到”禁止输出“的效果。

    如果希望屏蔽 stdout 和 stderr,可以这样写:

    1. $ command > /dev/null 2>&1

     

    Shell文件包含

     

    像其他语言一样,Shell 也可以包含外部脚本,将外部脚本的内容合并到当前脚本。

    Shell 中包含脚本可以使用:

    1. . filename

    1. source filename

    两种方式的效果相同,简单起见,一般使用点号(.),但是注意点号(.)和文件名中间有一空格。

    例如,创建两个脚本,一个是被调用脚本 subscript.sh,内容如下:

    1. url="http://see.xidian.edu.cn/cpp/view/2738.html"

    一个是主文件 main.sh,内容如下:

    1. #!/bin/bash
    2. . ./subscript.sh
    3. echo $url

    执行脚本:

    $chomd +x main.sh

    ./main.sh

    http://see.xidian.edu.cn/cpp/view/2738.html

    $

    注意:被包含脚本不需要有执行权限。

    展开全文
  • ubuntu的sh文件编程(一)

    万次阅读 2016-11-15 15:07:18
    打开文本编辑器,新建一个文件,扩展名为sh(sh代表shell),扩展名并不影响脚本执行,见名知意就好,如果你用phpshell 脚本,扩展名就用php好了。 输入一些代码: #!/bin/bashecho "Hello World !" “#!” ...
  • Linux Shell脚本详细教程

    千次阅读 多人点赞 2017-10-16 14:43:50
    Shell简介:什么是ShellShell命令的两种执行方式 Shell本身是一个用C语言编写的程序,它是用户使用Unix/Linux的桥梁,用户的大部分工作都是通过Shell完成的。Shell既是一种命令语言,又是一种程序设计语言。...
  • 交互式shell(Interactive Shells)

    千次阅读 2019-11-09 15:54:48
    本文来自于: ...在linux系统中,我们打开terminal就是开启了一个Bash进程,也就是开启了一个shell,此时的shell就是interactive shell。 下图就开启了一个interactive shell。echo $-时包含i ...
  • 通过前面的学习我们知道了什么是Shell以及它的分类和功能,现在我们将一起学习Shell是怎么执行程序的,也就是Shell的第一个功能。在这里我们首先理解Shell怎么执行程序,学习相关知识(什么是进程、如何创建进程、...
  • Shell脚本学习笔记

    千次阅读 2016-11-18 20:23:23
    Shell学习笔记Shell学习笔记 简介 Shell教程入门 1shell脚本 2shell脚本实践 Shell变量 1使用变量 2只读变量 3删除变量 4变量类型 5shell字符串 6Shell数组 7Shell注释 Shell传递参数 1实例 Shell数组 Shell运算符 1...
  • [Bash Shell] Shell学习笔记

    千次阅读 2016-08-18 13:57:51
    ...1. Shell简介 2. 几种常见的Shell 3. 编译型语言和解释型语言的区别  4. 什么时候使用Shell? 5. 第一个Shell脚本 6. Shell变量 7.Shell特殊变量 8. Shell替换 9. Shell运算符 10.
  • SQL恢复XP_CMDSHLL 以及XPLOG70.DLL被删 直接用SQL连接器开启3389用SQL连接器恢复XP_CMDSHLLE的命令 (1)SQL Query Analyzersp_addextendedproc xp_cmdshell,@dllname=xplog70.dll(2)首先在SqlExec Sunx Version...
  • 队列的概念:1、是队列结构的中间件2、消息放入后不需要立即处理3、由订阅者/消费者按顺序处理队列原理:也是解耦的原理:业务系统和队列处理系统没有关系一个写(业务系统),一...
  • *Php消息队列实现

    万次阅读 2019-03-06 11:18:08
    2、消息放入后不需要立即处理 3、由订阅者/消费者按顺序处理 队列原理: 也是解耦的原理:业务系统和队列处理系统没有关系 一个写(业务系统),一个读(队列管理系统)。 写的只管往队列里写,别的不用操心...
  • shell学习(不错的简单学习教程)

    千次阅读 2015-03-26 15:12:33
    shell脚本   Shell Script,Shell脚本与Windows/Dos下的批处理相似,也就是用各类命令预先放入到一个文件中,方便一次性执行的一个程序文件,主要是方便管理员进行设置或者管理用的。但是它比Windows下的批处理...
  • Shell

    万次阅读 多人点赞 2017-09-04 17:28:11
    shell编程 shell历史 执行脚本 基本语法 变量 文件名代换Globbing 命令代换 算术代换 转义字符 单引号 双引号 Shell脚本语法 条件测试 条件分支 ifthenelifelsefi caseesac 循环 fordodone whiledodone break和...
  • shell 脚本-符号-基础语法

    千次阅读 2016-10-25 14:00:45
    为了便于识别 建议 以.sh 结尾shell脚本 可以放上所有的命令行的指令(源于bash)shell脚本 是 解释型语言 c/c++ 是编译型语言下面用到的 shell代码sh_1.sh#!/bin/bash cd ../ ls pwd解释型脚本的执行过程:script....
  • Linux环境变量配置文件

    千次阅读 2012-08-24 09:58:42
    环境变量配置文件 ...$ PATH="$PATH:/my_new_path" (关闭shell,会还原PATH) 2. 修改profile文件: $ vi /etc/profile 在里面加入: export PATH="$PATH:/my_new_path" 3. 修改.bash
  • UNIX再学习 -- shell编程

    千次阅读 2017-03-23 09:49:41
    UNIX环境高级编程看了三章,遇到不少重定向等shell命令。本想到Linux时再讲,看来有必要提前了。之前有看过一本《嵌入式Linux软硬件开发详解》这本书里有简单介绍了一部分shell常用命令,就结合它来简单介绍下shell...
  • Linux之shell编程

    万次阅读 2018-09-22 10:23:51
     Shell的作用是解释执行用户的命令,用户输入一条命令,Shell就解释执行一条,这种方式称为交互式(Interactive),Shell还有一种执行命令的方式称为批处理(Batch),用户事先写一个Shell脚本(Script),其中有很...
  • [shell]shell快速入门教程

    千次阅读 2017-12-19 11:44:58
    Shell简介什么是ShellShell命令的两种执行方式 Shell本身是一个用C语言编写的程序,它是用户使用Unix/Linux的桥梁,用户的大部分工作都是通过Shell完成的。Shell既是一种命令语言,又是一种程序设计语言。作为命令...
1 2 3 4 5 ... 20
收藏数 8,018
精华内容 3,207
关键字:

php shell立即返回