shell_shellcode - CSDN
shell 订阅
在计算机科学中,Shell俗称壳(用来区别于核),是指“为使用者提供操作界面”的软件(命令解析器)。它类似于DOS下的command.com和后来的cmd.exe。它接收用户命令,然后调用相应的应用程序。 展开全文
在计算机科学中,Shell俗称壳(用来区别于核),是指“为使用者提供操作界面”的软件(命令解析器)。它类似于DOS下的command.com和后来的cmd.exe。它接收用户命令,然后调用相应的应用程序。
信息
性    质
命令解析器
外文名
shell
用    途
接收用户命令
中文名
shell术语
同时它又是一种程序设计语言。作为命令语言,它交互式解释和执行用户输入的命令或者自动地解释和执行预先设定好的一连串的命令;作为程序设计语言,它定义了各种变量和参数,并提供了许多在高级语言中才具有的控制结构,包括循环和分支。在排序算法中,Shell是希尔排序的名称。基本上shell分两大类:一:图形界面shell(Graphical User Interface shell 即 GUI shell)例如:应用最为广泛的 Windows Explorer (微软的windows系列操作系统),还有也包括广为人知的 Linux shell,其中linux shell 包括 X window manager (BlackBox和FluxBox),以及功能更强大的CDE、GNOME、KDE、 XFCE。二:命令行式shell(Command Line Interface shell ,即CLI shell)例如:bash / sh / ksh / csh / zsh(Unix/linux 系统)(MS-DOS系统)cmd.exe/ 命令提示字符(Windows NT 系统)Windows PowerShell(支持 .NET Framework 技术的 Windows NT 系统)传统意义上的shell指的是命令行式的shell,以后如果不特别注明,shell是指命令行式的shell。文字操作系统与外部最主要的接口就叫做shell。shell是操作系统最外面的一层。shell管理你与操作系统之间的交互:等待你输入,向操作系统解释你的输入,并且处理各种各样的操作系统的输出结果。shell提供了你与操作系统之间通讯的方式。这种通讯可以以交互方式(从键盘输入,并且可以立即得到响应),或者以shell script(非交互)方式执行。shell script是放在文件中的一串shell和操作系统命令,它们可以被重复使用。本质上,shell script是命令行命令简单的组合到一个文件里面。Shell基本上是一个命令解释器,类似于DOS下的command。它接收用户命令(如ls等),然后调用相应的应用程序。较为通用的shell有标准的Bourne shell (sh)和C shell (csh)。交互式shell和非交互式shell交互式模式就是shell等待你的输入,并且执行你提交的命令。这种模式被称作交互式是因为shell与用户进行交互。这种模式也是大多数用户非常熟悉的:登录、执行一些命令、签退。当你签退后,shell也终止了。shell也可以运行在另外一种模式:非交互式模式。在这种模式下,shell不与你进行交互,而是读取存放在文件中的命令,并且执行它们。当它读到文件的结尾,shell也就终止了。shell的类型在UNIX中主要有:Bourne shell (包括 sh,ksh,and bash)Bourne shell ( sh)Korn shell ( ksh)Bourne Again shell ( bash)POSIX shell ( sh)C shell (包括 csh and tcsh)C shell ( csh)TENEX/TOPS C shell ( tcsh)Bourne Shell  首个重要的标准Unix Shell是1979年底在V7 Unix(AT&T第7版)中引入的,并且以它的创始科技部基础条件平台“国家气象网络计算应用节点建设”(2004DKA50730)资助者Stephen Bourne的名字命名。Bourne shell 是一个交换式的命令解释器和命令编程语言。Bourne shell 可以运行为login shell或者login shell的子shell(subshell)。只有login命令可以调用Bourne shell作为一个login shell。此时,shell先读取/etc/profile文件和$HOME/.profile文件。/etc/profile文件为所有的用户定制环境,$HOME/.profile文件为本用户定制环境。最后,shell会等待读取你的输入。C Shell Bill Joy于20世纪80年代早期,在伯克利的加利福尼亚大学开发了C shell。它主要是为了让用户更容易的使用交互式功能,并把ALGOL风格的语法结构变成了C语言风格。它新增了命令历史、别名、文件名替换、作业控制等功能。Korn Shell 有很长一段时间,只有两类shell供人们选择,Bourne shell用来编程,C shell用来交互。为了改变这种状况,AT&T的bell实验室David Korn开发了Korn shell。ksh结合了所有的C shell的交互式特性,并融入了Bourne shell的语法。因此,Korn shell广受用户的欢迎。它还新增了数学计算,进程协作(coprocess)、行内编辑(inline editing)等功能。Korn Shell 是一个交互式的命令解释器和命令编程语言.它符合POSIX——一个操作系统的国际标准.POSIX不是一个操作系统,而是一个目标在于应用程序的移植性的标准——在源程序一级跨越多种平台。Bourne Again Shell (bash) bash是GNU计划的一部分,用来替代Bourne shell。它用于基于GNU的系统如Linux.大多数的Linux(Red Hat,Slackware,Caldera)都以bash作为缺省的shell,并且运行sh时,其实调用的是bash。POSIX Shell POSIX shell 是Korn shell的一个变种. 当前提供POSIX shell的最大卖主是Hewlett-Packard。在HP-UX 11.0,POSIX shell 就是/bin/sh,而bsh是/usr/old/bin/sh.各主要操作系统下缺省的shell:AIX下是Korn Shell.Solaris缺省的是Bourne shell.FreeBSD缺省的是C shellHP-UX缺省的是POSIX shell.Linux是Bourne Again shell.Windows PowerShell是一种新的交互式的命令行和基于任务脚本编写技术,它使信息技术(IT) 管理员能够全面地自动操作和控制系统管理任务,从而提高了管理员的生产力。Windows PowerShell 包括多个系统管理实用工具、一致的语法和命名惯例、及对普通管理数据更好地导航,如登记、证书存储 或 Windows Management Instrumentation (WMI)。Windows PowerShell 还专门针对 IT 管理,提供直观的脚本编写语言。Shell也是一个VB函数,它的作用是运行程序,语法是Shell(命令字符串[,窗口类型])
收起全文
精华内容
参与话题
  • Shell是一个功能相当强大的编程语言,易编写、易调试、灵活性强。Shell可以帮助我们来管理大数据集群,提高开发效率。 本课程详细讲解:Shell解析器、变量、运算符、条件判断、流程控制、函数、cut、sed、awk...
  • 收藏!一篇教会你写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

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

    在这里插入图片描述

    展开全文
  • Shell——你只需要了解这么多

    万次阅读 多人点赞 2020-08-09 10:16:22
    一.Shell简介 Shell是一个用C语言编写的程序,通过Shell用户可以访问操作系统内核服务,类似于DOS下的command和后来的cmd.exe。Shell既是一种命令语言,又是一种程序设计语言。作为命令语言,它交互式地解释和执行...

    原文地址: Shell——你只需要了解这么多

    一.Shell简介

    Shell是一个用C语言编写的程序,通过Shell用户可以访问操作系统内核服务,类似于DOS下的command和后来的cmd.exe。Shell既是一种命令语言,又是一种程序设计语言。作为命令语言,它交互式地解释和执行用户输入的命令;作为程序设计语言,它定义了各种变量、参数、函数、流程控制等等。它调用了系统核心的大部分功能来执行程序、建立文件并以并行的方式协调各个程序的运行。因此,对于用户来说,shell是最重要的实用程序,深入了解和熟练掌握shell的特性极其使用方法,是用好Unix/Linux系统的关键。

    二.两类程序设计语言

    我经常说道shell脚本,其实是因为Shell是一种脚本语言,也就是解释性语言。程序设计语言可以分为两类:编译型语言和解释型语言。

    语言 区别
    编译型语言 需要预先将我们写好的源代码转换成目标代码,这个过程被称作“编译”。运行程序时,直接读取目标代码。由于编译后的目标代码非常接近计算机底层,因此执行效率很高,这是编译型语言的优点
    解释型语言 也叫做脚本语言。执行这类程序时,解释器需要读取我们编写的源代码,并将其转换成目标代码,再由计算机运行。因为每次执行程序都多了编译的过程,因此效率有所下降

    三.Shell脚本解释器

    Linux的Shell脚本解释器种类众多,一个系统可以存在多个shell脚本解释器,可以通过cat /etc/shells 命令查看系统中安装的shell脚本解释器。

    [root@centos6-1 ~]# cat /etc/shells 
    /bin/sh
    /bin/bash
    /sbin/nologin
    /bin/dash
    /bin/tcsh
    /bin/csh
    [root@centos6-1 ~]# 
    

    bash由于易用和免费,在日常工作中被广泛使用。同时,Bash也是大多数Linux系统默认的Shell脚本解释器。

    四.Hello World

    新建helloworld.sh

    [root@centos6-1 ~]# touch helloworld.sh
    

    编辑helloworld.sh文件,添入一下内容

    #!/bin/bash
    echo "helloworld"
    
    • #! 是一个约定的标记,它告诉系统这个脚本需要什么解释器来执行,即使用哪一种Shell,这里指定bash
    • echo 是Shell的一个内部指令,用于在屏幕上打印出指定的字符串

    赋予当前用户helloworld.sh的执行权限(刚创建的文件没有执行权限)

    [root@centos6-1 ~]# chmod u+x helloworld.sh
    

    执行hellowo.sh脚本方式一

    [root@centos6-1 ~]# ./helloworld.sh 
    helloworld
    [root@centos6-1 ~]# 
    

    注意,一定要写成./helloworld.sh,而不是helloworld.sh,linux系统会去PATH里寻找有没有叫helloworld.sh的,而helloworld.sh不在PATH里,所以写成helloworld.sh是会找不到命令的,要用./helloworld.sh告诉系统说,就在当前目录找。

    执行hellowo.sh脚本方式二

    [root@centos6-1 ~]# /bin/sh helloworld.sh 
    helloworld
    [root@centos6-1 ~]# 
    

    这种运行方式是,直接运行解释器,其参数就是shell脚本的文件名,当使用这种方式时,脚本中的#!/bin/bash指定的解释器是不生效的,当前使用什么解释器就是什么解释器

    五.变量

    • 语法格式:变量名=变量值

    shell变量定义的严格语法限制:

    1. 变量名和等号之间不能有空格
    2. 变量名首个字符必须为英文字母
    3. 不能包含标点符号但能够使用下划线(_)
    4. 不能使用空格
    5. 不能使用 bash 里的关键字
    

    1.变量类型

    类型 解释
    局部变量 局部变量在脚本或命令中定义,仅在当前shell实例中有效,其他shell启动的程序不能访问局部变量
    环境变量 所有的程序,包括shell启动的程序,都能访问环境变量,有些程 序需要环境变量来保证其正常运行。可以用过set命令查看当前环境变量
    shell变量 由shell程序设置的特殊变量。shell变量中有一部分是环境变量,有一部分是局部变量,这些变量保证了shell 的正常运行

    2.定义变量

    name="zaomianbao"
    

    3.引用变量

    name="zaomianbao"
    echo ${name}
    echo $name
    

    引用一个定义过的变量,只要在变量名前面加$即可,变量名外面的花括号是可选的,加不加都行,加花括号是为了帮助解释器识别变量的边界。

    4.重新定义变量

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

    name="zaomianbao"
    echo ${name}
    name="tiechui"
    echo ${name}
    

    5.只读变量

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

    name="zaomianbao"
    readonly name
    name="tiechui"
    

    6.删除变量

    name="zaomianbao"
    unset name
    echo $name
    

    使用unset命令可以删除变量,变量被删除后不能再次使用,同时unset命令不能删除只读变量。

    六.参数传递

    在执行Shell脚本时,可以向脚本传递参数。脚本内获取参数的格式为:$n。n代表一个数字,1为执行脚本的第一个参数,2为执行脚本的第二个参数,以此类推…
    $0 表示当前脚本名称。

    1.修改helloworld.sh为

    #!/bin/bash
    echo $1
    echo $2
    echo $3
    

    2.执行携带参数

    [root@centos6-1 ~]# ./helloworld.sh haha wowow nini
    haha
    wowow
    nini
    [root@centos6-1 ~]#
    

    七.特殊字符

    字符 意义
    $# 传递到脚本的参数个数
    $* 以一个单字符串显示所有向脚本传递的参数
    $$ 脚本运行的当前进程ID号
    $! 后台运行的最后一个进程的ID号
    $@ 与$*相同,但是使用时加引号,并在引号中返回每个参数
    $? 显示最后命令的退出状态。0表示没有错误,其他任何值表明有错误

    $*和$@区别:

    • 相同点:都表示传递给脚本的所有参数。
    • 不同点:不被" “包含时,$和$@都以$1 $2… $n 的形式组成参数列表。
      被" “包含时,”$
      ” 会将所有的参数作为一个整体,以"$1 $2 … $n" 的形式组成一个整串;"$@" 会将各个参数分开,以"$1" “$2” … “$n” 的 形式组成一个参数列表。

    八.Shell字符串

    shell字符串可以用单引号,也可以用双引号,也可以不用引号

    单引号

    name='my name is zaomianbao'
    
    • 单引号字符串中不支持引用变量,任何字符都会原样输出
    • 单引号字串中不能出现单引号(对单引号使用转义符后也不行)

    双引号

    name='my name is zaomianbao'
    name_again="\"${name}\""
    
    • 双引号里可以引有变量
    • 双引号里支持转义字符

    字符串长度

    name='my name is zaomianbao'
    echo ${#name}   //执行输出为21
    

    截取字符串

    name='my name is zaomianbao'
    echo ${name:11:20}   //执行输出zaomianbao
    

    九.shell数组

    • bash支持一维数组(不支持多维数组),并且没有限定数组的大小。在Shell中,用括号来表示数组,数组元素用“空格”符号分割开。定义数组的一般形式为:
        array_name=(value1 … valuen)

    下面的例子将展示shell数组常见的所有操作

    //第一数组
    [root@centos6-1 ~]# usernames=(1 2 33 44 adsd1)
    //默认读取第一个
    [root@centos6-1 ~]# echo ${usernames}
    1
    //读取下标为0的
    [root@centos6-1 ~]# echo ${usernames[0]}
    1
    //读取下标为1的
    [root@centos6-1 ~]# echo ${usernames[1]}
    2
    //读取所有
    [root@centos6-1 ~]# echo ${usernames[*]}
    1 2 33 44 adsd1
    //同样是读取所有
    [root@centos6-1 ~]# echo ${usernames[@]}
    1 2 33 44 adsd1
    //获取数组长度
    [root@centos6-1 ~]# echo ${#usernames[@]}
    5
    //同样可以获取数组长度
    [root@centos6-1 ~]# echo ${#usernames[*]}
    5
    [root@centos6-1 ~]# 
    

    十.shell运算符

    • Shell和其他编程语音一样,支持包括:算术、关系、布尔、字符串等运算符。
    • 原生bash不支持简单的数学运算,但是可以通过其他命令来实现,例如 awk 和 expr,expr 最常用。expr 是一款表达式计算工具,使用它能完成表达式的求值操作。

    1.算术运算符

    运算符 意义
    + 加法
    - 减法
    * 乘法
    / 除法
    % 模,即取余

    下面是详细例子

    #!/bin/bash
    
    a=10
    b=20
    
    val=`expr $a + $b`
    echo "a + b : $val"
    
    val=`expr $a - $b`
    echo "a - b : $val"
    
    val=`expr $a \* $b`
    echo "a * b : $val"
    
    val=`expr $b / $a`
    echo "b / a : $val"
    
    val=`expr $b % $a`
    echo "b % a : $val"
    
    if [ $a == $b ]
    then
       echo "a 等于 b"
    fi
    if [ $a != $b ]
    then
       echo "a 不等于 b"
    fi
    

    执行

    [root@centos6-1 ~]# ./helloworld.sh 
    a + b : 30
    a - b : -10
    a * b : 200
    b / a : 2
    b % a : 0
    a 不等于 b
    [root@centos6-1 ~]# 
    

    注意:

    -  1.乘号(*)前边必须加反斜杠(\)
    -  2.条件表达式要放在方括号之间,并且要有空格
    

    2.关系运算符

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

    运算符 意义
    -eq EQUAL等于
    -ne NOT EQUAL不等于
    -gt GREATER THAN大于
    -lt LESS THAN小于
    -ge GREATER THAN OR EQUAL 大于等于
    -le LESS THAN OR EQUAL 小于等

    下面是详细例子

    #!/bin/bash
    
    a=10
    b=20
    
    if [ $a -eq $b ]
    then
       echo "$a -eq $b : a 等于 b"
    else
       echo "$a -eq $b: a 不等于 b"
    fi
    if [ $a -ne $b ]
    then
       echo "$a -ne $b: a 不等于 b"
    else
       echo "$a -ne $b : a 等于 b"
    fi
    if [ $a -gt $b ]
    then
       echo "$a -gt $b: a 大于 b"
    else
       echo "$a -gt $b: a 不大于 b"
    fi
    if [ $a -lt $b ]
    then
       echo "$a -lt $b: a 小于 b"
    else
       echo "$a -lt $b: a 不小于 b"
    fi
    if [ $a -ge $b ]
    then
       echo "$a -ge $b: a 大于或等于 b"
    else
       echo "$a -ge $b: a 小于 b"
    fi
    if [ $a -le $b ]
    then
       echo "$a -le $b: a 小于或等于 b"
    else
       echo "$a -le $b: a 大于 b"
    fi
    

    执行

    [root@centos6-1 ~]# ./helloworld.sh  
    10 -eq 20: a 不等于 b
    10 -ne 20: a 不等于 b
    10 -gt 20: a 不大于 b
    10 -lt 20: a 小于 b
    10 -ge 20: a 小于 b
    10 -le 20: a 小于或等于 b
    [root@centos6-1 ~]# 
    

    3.布尔运算符

    运算符 意义
    &&
    ||

    下面是详细例子

    #!/bin/bash
    
    a=10
    b=20
    
    if [[ $a -lt 100 && $b -gt 100 ]]
    then
       echo "返回 true"
    else
       echo "返回 false"
    fi
    
    if [[ $a -lt 100 || $b -gt 100 ]]
    then
       echo "返回 true"
    else
       echo "返回 false"
    fi
    

    执行

    [root@centos6-1 ~]# ./helloworld.sh 
    返回 false
    返回 true
    [root@centos6-1 ~]# 
    

    4.字符串运算符

    操作符 意义
    -z 字符串长度是否为0,为0返回 true
    -n 字符串长度是否为0,不为0返回 true
    str 字符串是否为空,不为空返回 true

    下面是详细例子

    #!/bin/bash
    
    a="abc"
    b="efg"
    
    if [ $a = $b ]
    then
       echo "$a = $b : a 等于 b"
    else
       echo "$a = $b: a 不等于 b"
    fi
    if [ $a != $b ]
    then
       echo "$a != $b : a 不等于 b"
    else
       echo "$a != $b: a 等于 b"
    fi
    if [ -z $a ]
    then
       echo "-z $a : 字符串长度为 0"
    else
       echo "-z $a : 字符串长度不为 0"
    fi
    if [ -n $a ]
    then
       echo "-n $a : 字符串长度不为 0"
    else
       echo "-n $a : 字符串长度为 0"
    fi
    if [ $a ]
    then
       echo "$a : 字符串不为空"
    else
       echo "$a : 字符串为空"
    fi
    

    执行

    [root@centos6-1 ~]# ./helloworld.sh 
    abc = efg: a 不等于 b
    abc != efg : a 不等于 b
    -z abc : 字符串长度不为 0
    -n abc : 字符串长度不为 0
    abc : 字符串不为空
    [root@centos6-1 ~]# 
    

    5.文件测试运算符

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

    下面是详细例子

    #!/bin/bash
    
    file="/com/zaomianbao"
    if [ -r $file ]
    then
       echo "文件可读"
    else
       echo "文件不可读"
    fi
    if [ -w $file ]
    then
       echo "文件可写"
    else
       echo "文件不可写"
    fi
    if [ -x $file ]
    then
       echo "文件可执行"
    else
       echo "文件不可执行"
    fi
    if [ -f $file ]
    then
       echo "文件为普通文件"
    else
       echo "文件为特殊文件"
    fi
    if [ -d $file ]
    then
       echo "文件是个目录"
    else
       echo "文件不是个目录"
    fi
    if [ -s $file ]
    then
       echo "文件不为空"
    else
       echo "文件为空"
    fi
    if [ -e $file ]
    then
       echo "文件存在"
    else
       echo "文件不存在"
    fi
    

    执行

    [root@centos6-1 ~]# ./helloworld.sh 
    文件不可读
    文件不可写
    文件不可执行
    文件为特殊文件
    文件不是个目录
    文件为空
    文件不存在
    [root@centos6-1 ~]# 
    

    十一.流程控制

    1.if-else

    
    if condition
    then
        //做你想做的事
    else
        //做你想做的事
    fi
    
    
    if condition1
    then
        //做你想做的事
    elif condition2 
    then 
        //做你想做的事
    else
        //做你想做的事
    fi
    

    2.case

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

    case 值 in
    模式1)
        //做你想做的事
        ;;
    模式2)
        //做你想做的事
        ;;
    *)
        //做你想做的事
        ;;
    esac
    

    取值后面必须为关键字 in,每一模式必须以右括号结束。取值可以为变量或常数。匹配发现取值符合某一模式后,其间所有命令开始执行直至 ;;。;; 与其他语言中的 break 类似,意思是跳到整个 case 语句的最后。取值将检测匹配的每一个模式。一旦模式匹配,则执行完匹配模式相应命令后不再继续其他模式。如果无一匹配模式,使用星号 * 捕获该值,再执行后面的命令。

    3.for

    for 变量 in 列表
    do
        //做你想做的事
    done
    

    4.while

    while command
    do
       //做你想做的是
    done
    

    5.until

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

    until command
    do
       //做你想做的事
    done
    

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

    十二.函数

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

    #!/bin/bash
    
    demoFun(){
        echo "这是我的第一个 shell 函数!"
    }
    echo "-----函数开始执行-----"
    demoFun 
    echo "-----函数执行完毕-----"
    

    执行

    [root@centos6-1 ~]# ./helloworld.sh 
    -----函数开始执行-----
    这是我的第一个 shell 函数!
    -----函数执行完毕-----
    [root@centos6-1 ~]# 
    

    如果函数有返回值,则函数返回值可以在调用该函数后通过 $? 来获得。

    参考资料:
    https://baike.baidu.com/item/shell/99702?fr=aladdin
    http://www.runoob.com/linux/linux-shell.html
    https://www.cnblogs.com/maybe2030/p/5022595.html
    https://baike.baidu.com/item/POSIX/3792413?fr=aladdin

    展开全文
  • 10小时全掌握Linux下shell编程

    千人学习 2020-02-06 14:14:51
    从没上过课的学渣 学了还不会的学弱 想学懂的学霸 10小时全掌握Linux下shell编程 工作、面试全没问题。
  • shell脚本精简教程

    万人学习 2018-10-22 21:38:06
    详细的介绍shell脚本的使用。
  • 字体颜色部分 诸如xterm,rxvt,PuTTY的通用终端仿真器以及UNIX / Linux桌面环境的默认终端仿真器均支持基于转义序列的文本颜色和形状处理。(例如,警告消息的红色或闪烁文本或状态消息的其他颜色)。...

    字体颜色部分

    诸如xterm,rxvt,PuTTY的通用终端仿真器以及UNIX /Linux桌面环境的默认终端仿真器均支持基于转义序列的文本颜色和形状处理。(例如,警告消息的红色或闪烁文本或状态消息的其他颜色)。

    - 实现过程:
    终端的字符颜色是用转义序列控制的,是文本模式下的系统显示功能,和具体的语言无关。
    转义序列是以ESC开头,即用\033来完成(ESC的ASCII码用十进制表示是27,用八进制表示就是033)。
    - 书写格式:

    echo -e +开头部分:\033[前景色;背景色;显示方式m + 输出内容 + 结尾部分:\033[0m

    • 注意:
      -e 是用来开启echo中的转义。
      开头部分的三个参数:显示方式,前景色,背景色是可选参数,可以只写其中的某一个;另外由于表示三个参数不同含义的数值都是唯一的没有重复的,所以三个参数的书写先后顺序没有固定要求,系统都能识别;但是,建议按照默认的格式规范书写。
      结尾部分,代表回归默然字符颜色,不写会影响后面输入内容的颜色,建议\033[***m开头,\033[0m结尾。

    #实例演示:

    $ echo -e '\033[42;37;1mThis is print\033[0m'
    

    意思是输出背景色为42绿、文字是37白、1代表高亮度的,m是分割标志,“This is print”是待输出的内容。

    • 为啥字符串[42;37;1m前还要加个\33呢,这就涉及到另一知识点:
      escape序列这是一个相当古老的ANSI标准,基本所有的Unix/Linux terminal都支持escape序列。escape序列以八进制 \033 即 ESC 的ASCII码开头,主要用来控制字体的颜色和其他特征如闪烁,下划线等。
    • 我们知道了字符串颜色就是由这一串\033[42;37;1m控制的
      为啥字符串后边还要加一个\033[0m呢?因为\033[42;37;1m只把输出字符串变成了这个颜色,并没有变回去,\033[0m相当于初始化了,让变色的影响只限于此。
    • 如果不变回去会导致后面的输出内容沿用这个颜色,例如下边这个脚本colourtest.sh,执行它,会输出两个“背景色为42绿、文字是37白、1代表高亮度的”字符串。甚至执行完后的指令输入框背景色也会显示成绿色。。。
    $ [root@halamadrid]# cat colourtest1.sh 
    #!/bin/bashe
    echo -e '\033[42;37;1mThis is print'
    echo 'hello world!'
    

    附颜色参数对照: 背景色:0 透明(使用终端颜色), 40 黑, 41 红, 42 绿, 43 黄, 44 蓝 45 紫, 46 青绿,47白(灰)
    前景色: 30 黑 31 红, 32绿, 33 黄, 34 蓝, 35 紫, 36 青绿, 37 白(灰)
    高亮度:高亮是1,不高亮是0。注意m后面紧跟字符串。



    函数传参部分

    函数的写法及$ 1、$ 2、$ #、$ @($和参数间不带空格)

    $ [root@halamadrid]# cat colourtest2.sh 
    #!/bin/bash
    xmessage()
    {
            echo -e "\033[1;$1;$2m$3\033[0m"
            echo -e "$1""\n$2""\n$3""\n$#""\n$@"
    
    }
    xmessage 42 37 "hello world"
    
    $ [root@halamadrid]# ./colourtest2.sh nice goal  
    hello world    #此行脑补绿底白字
    42
    37
    hello world
    3
    42 37 hello world
    

    函数里面的$ 1不是输入的第一个参数,而是调用函数时传入的第一个参数。$ #是传入的参数个数,$ @则是所有的传入参数。

    参考资源:
    函数传参$1$2
    echo输出颜色字体

    展开全文
  • 我正在尝试使用echo命令在终端中打印文本。 我想用红色打印文本。 我怎样才能做到这一点?

    我正在尝试使用echo命令在终端中打印文本。

    我想用红色打印文本。 我怎样才能做到这一点?


    #1楼

    您可以使用很棒的tput命令(在Ignacio的答案中建议)来为各种事物产生终端控制代码。


    用法

    稍后将讨论特定的tput子命令。

    直接

    调用tput作为命令序列的一部分:

    tput setaf 1; echo "this is red text"
    

    使用; 而不是&&因此如果tput错误仍然显示文本。

    外壳变量

    另一种选择是使用外壳变量:

    red=`tput setaf 1`
    green=`tput setaf 2`
    reset=`tput sgr0`
    echo "${red}red text ${green}green text${reset}"
    

    tput产生的字符序列被终端解释为具有特殊含义。 他们不会自己显示。 请注意,它们仍然可以保存到文件中,也可以由终端以外的程序作为输入进行处理。

    命令替换

    使用命令替换tput的输出直接插入echo字符串中可能会更方便:

    echo "$(tput setaf 1)Red text $(tput setab 7)and white background$(tput sgr 0)"
    

    上面的命令在Ubuntu上生成:

    彩色终端文本的屏幕截图


    前景和背景颜色命令

    tput setab [1-7] # Set the background colour using ANSI escape
    tput setaf [1-7] # Set the foreground colour using ANSI escape
    

    颜色如下:

    Num  Colour    #define         R G B
    
    0    black     COLOR_BLACK     0,0,0
    1    red       COLOR_RED       1,0,0
    2    green     COLOR_GREEN     0,1,0
    3    yellow    COLOR_YELLOW    1,1,0
    4    blue      COLOR_BLUE      0,0,1
    5    magenta   COLOR_MAGENTA   1,0,1
    6    cyan      COLOR_CYAN      0,1,1
    7    white     COLOR_WHITE     1,1,1
    

    还有颜色设置功能的非ANSI版本( setb代替setabsetf代替setaf ),它们使用不同的数字,此处未给出。

    文字模式命令

    tput bold    # Select bold mode
    tput dim     # Select dim (half-bright) mode
    tput smul    # Enable underline mode
    tput rmul    # Disable underline mode
    tput rev     # Turn on reverse video mode
    tput smso    # Enter standout (bold) mode
    tput rmso    # Exit standout mode
    

    光标移动命令

    tput cup Y X # Move cursor to screen postion X,Y (top left is 0,0)
    tput cuf N   # Move N characters forward (right)
    tput cub N   # Move N characters back (left)
    tput cuu N   # Move N lines up
    tput ll      # Move to last line, first column (if no cup)
    tput sc      # Save the cursor position
    tput rc      # Restore the cursor position
    tput lines   # Output the number of lines of the terminal
    tput cols    # Output the number of columns of the terminal
    

    清除并插入命令

    tput ech N   # Erase N characters
    tput clear   # Clear screen and move the cursor to 0,0
    tput el 1    # Clear to beginning of line
    tput el      # Clear to end of line
    tput ed      # Clear to end of screen
    tput ich N   # Insert N characters (moves rest of line forward!)
    tput il N    # Insert N lines
    

    其他命令

    tput sgr0    # Reset text format to the terminal's default
    tput bel     # Play a bell
    

    使用compiz摆动窗口时bel命令会使终端摆动一秒钟,以引起用户的注意。


    剧本

    tput接受每行包含一个命令的脚本,这些脚本按顺序在tput退出之前执行。

    通过回显多行字符串并将其用管道传递来避免使用临时文件:

    echo -e "setf 7\nsetb 1" | tput -S  # set fg white and bg red
    

    也可以看看

    • man 1 tput
    • 有关完整的命令列表和这些选项的更多详细信息,请参见man 5 terminfo 。 (相应的tput命令在Cap-name 81行开始的巨大表的Cap-name列中列出。)

    #2楼

    一种仅对一个echo更改颜色的巧妙方法是定义以下功能:

    function coloredEcho(){
        local exp=$1;
        local color=$2;
        if ! [[ $color =~ '^[0-9]$' ]] ; then
           case $(echo $color | tr '[:upper:]' '[:lower:]') in
            black) color=0 ;;
            red) color=1 ;;
            green) color=2 ;;
            yellow) color=3 ;;
            blue) color=4 ;;
            magenta) color=5 ;;
            cyan) color=6 ;;
            white|*) color=7 ;; # white or invalid color
           esac
        fi
        tput setaf $color;
        echo $exp;
        tput sgr0;
    }
    

    用法:

    coloredEcho "This text is green" green
    

    或者,您可以直接使用Drew的答案中提到的颜色代码:

    coloredEcho "This text is green" 2
    

    #3楼

    red='\e[0;31m'
    NC='\e[0m' # No Color
    echo -e "${red}Hello Stackoverflow${NC}"
    

    这个答案是正确的,除了对颜色的调用不应放在引号内。

    echo -e ${red}"Hello Stackoverflow"${NC}
    

    应该做到的。


    #4楼

    为了提高可读性

    如果要提高代码的可读性 ,可以先echo显字符串,然后再使用sed添加颜色:

    echo 'Hello World!' | sed $'s/World/\e[1m&\e[0m/' 
    

    #5楼

    这些代码可在我的Ubuntu机器上使用:

    在此处输入图片说明

    echo -e "\x1B[31m foobar \x1B[0m"
    echo -e "\x1B[32m foobar \x1B[0m"
    echo -e "\x1B[96m foobar \x1B[0m"
    echo -e "\x1B[01;96m foobar \x1B[0m"
    echo -e "\x1B[01;95m foobar \x1B[0m"
    echo -e "\x1B[01;94m foobar \x1B[0m"
    echo -e "\x1B[01;93m foobar \x1B[0m"
    echo -e "\x1B[01;91m foobar \x1B[0m"
    echo -e "\x1B[01;90m foobar \x1B[0m"
    echo -e "\x1B[01;89m foobar \x1B[0m"
    echo -e "\x1B[01;36m foobar \x1B[0m"
    

    这会以不同的颜色打印字母abcd:

    echo -e "\x1B[0;93m a \x1B[0m b \x1B[0;92m c \x1B[0;93m d \x1B[0;94m"
    

    对于循环:

    for (( i = 0; i < 17; i++ )); 
    do echo "$(tput setaf $i)This is ($i) $(tput sgr0)"; 
    done
    

    在此处输入图片说明


    #6楼

    这是颜色开关 \\033[ 。 查看历史

    颜色代码例如1;32 (浅绿色), 0;34 (蓝色), 1;34 (浅蓝色)等。

    我们用彩色开关终止颜色序列\\033[0m -color代码。 就像以标记语言打开和关闭选项卡一样。

      SWITCH="\033["
      NORMAL="${SWITCH}0m"
      YELLOW="${SWITCH}1;33m"
      echo "${YELLOW}hello, yellow${NORMAL}"
    

    简单的颜色echo功能解决方案:

    cecho() {
      local code="\033["
      case "$1" in
        black  | bk) color="${code}0;30m";;
        red    |  r) color="${code}1;31m";;
        green  |  g) color="${code}1;32m";;
        yellow |  y) color="${code}1;33m";;
        blue   |  b) color="${code}1;34m";;
        purple |  p) color="${code}1;35m";;
        cyan   |  c) color="${code}1;36m";;
        gray   | gr) color="${code}0;37m";;
        *) local text="$1"
      esac
      [ -z "$text" ] && local text="$color$2${code}0m"
      echo "$text"
    }
    
    cecho "Normal"
    cecho y "Yellow!"
    

    #7楼

    您可以使用一些变量:

    # Reset
    Color_Off='\033[0m'       # Text Reset
    
    # Regular Colors
    Black='\033[0;30m'        # Black
    Red='\033[0;31m'          # Red
    Green='\033[0;32m'        # Green
    Yellow='\033[0;33m'       # Yellow
    Blue='\033[0;34m'         # Blue
    Purple='\033[0;35m'       # Purple
    Cyan='\033[0;36m'         # Cyan
    White='\033[0;37m'        # White
    
    # Bold
    BBlack='\033[1;30m'       # Black
    BRed='\033[1;31m'         # Red
    BGreen='\033[1;32m'       # Green
    BYellow='\033[1;33m'      # Yellow
    BBlue='\033[1;34m'        # Blue
    BPurple='\033[1;35m'      # Purple
    BCyan='\033[1;36m'        # Cyan
    BWhite='\033[1;37m'       # White
    
    # Underline
    UBlack='\033[4;30m'       # Black
    URed='\033[4;31m'         # Red
    UGreen='\033[4;32m'       # Green
    UYellow='\033[4;33m'      # Yellow
    UBlue='\033[4;34m'        # Blue
    UPurple='\033[4;35m'      # Purple
    UCyan='\033[4;36m'        # Cyan
    UWhite='\033[4;37m'       # White
    
    # Background
    On_Black='\033[40m'       # Black
    On_Red='\033[41m'         # Red
    On_Green='\033[42m'       # Green
    On_Yellow='\033[43m'      # Yellow
    On_Blue='\033[44m'        # Blue
    On_Purple='\033[45m'      # Purple
    On_Cyan='\033[46m'        # Cyan
    On_White='\033[47m'       # White
    
    # High Intensity
    IBlack='\033[0;90m'       # Black
    IRed='\033[0;91m'         # Red
    IGreen='\033[0;92m'       # Green
    IYellow='\033[0;93m'      # Yellow
    IBlue='\033[0;94m'        # Blue
    IPurple='\033[0;95m'      # Purple
    ICyan='\033[0;96m'        # Cyan
    IWhite='\033[0;97m'       # White
    
    # Bold High Intensity
    BIBlack='\033[1;90m'      # Black
    BIRed='\033[1;91m'        # Red
    BIGreen='\033[1;92m'      # Green
    BIYellow='\033[1;93m'     # Yellow
    BIBlue='\033[1;94m'       # Blue
    BIPurple='\033[1;95m'     # Purple
    BICyan='\033[1;96m'       # Cyan
    BIWhite='\033[1;97m'      # White
    
    # High Intensity backgrounds
    On_IBlack='\033[0;100m'   # Black
    On_IRed='\033[0;101m'     # Red
    On_IGreen='\033[0;102m'   # Green
    On_IYellow='\033[0;103m'  # Yellow
    On_IBlue='\033[0;104m'    # Blue
    On_IPurple='\033[0;105m'  # Purple
    On_ICyan='\033[0;106m'    # Cyan
    On_IWhite='\033[0;107m'   # White
    

    line5-900px-%23F80.svg?sanitize=true

    bashhexoctal的转义字符分别为:

    |       | bash  | hex    | octal   | NOTE                         |
    |-------+-------+--------+---------+------------------------------|
    | start | \e    | \x1b   | \033    |                              |
    | start | \E    | \x1B   | -       | x cannot be capital          |
    | end   | \e[0m | \x1m0m | \033[0m |                              |
    | end   | \e[m  | \x1b[m | \033[m  | 0 is appended if you omit it |
    |       |       |        |         |                              |
    

    简短的例子:

    | color       | bash         | hex            | octal          | NOTE                                  |
    |-------------+--------------+----------------+----------------+---------------------------------------|
    | start green | \e[32m<text> | \x1b[32m<text> | \033[32m<text> | m is NOT optional                     |
    | reset       | <text>\e[0m  | <text>\1xb[0m  | <text>\033[om  | o is optional (do it as best practice |
    |             |              |                |                |                                       |
    

    bash例外:

    如果您打算在特殊的bash变量中使用这些代码

    • PS0
    • PS1
    • PS2(=用于提示)
    • PS4

    您应该添加额外的转义字符,以便可以正确解释它们。 如果没有添加额外的转义字符,它就可以工作,但是当您使用Ctrl + r在历史记录中进行搜索时,您将遇到问题。

    bash例外规则

    您应该在任何开始的ANSI代码之前添加\\[ ,在任何结束的ANSI代码之后添加\\]
    例:
    正常使用: \\033[32mThis is in green\\033[0m
    对于PS0 / 1/2/4: \\[\\033[32m\\]This is in green\\[\\033[m\\]

    \\[用于表示一系列不可打印的字符
    \\]用于不可打印字符序列的结尾

    提示:要记住,您可以先添加\\[\\] ,然后将ANSI代码放在它们之间:
    - \\[start-ANSI-code\\]
    - \\[end-ANSI-code\\]

    颜色序列的类型:

    1. 3/4位
    2. 8位
    3. 24位

    在深入研究这些颜色之前,您应该了解以下代码的4种模式:

    1.颜色模式

    它修改了非文本颜色的样式。 例如,使颜色变亮或变暗。

    • 0重置
    • 1; 比正常轻
    • 2; 比正常暗

    此模式不受广泛支持。 它完全支持Gnome终端。

    2.文字模式

    此模式用于修改文本的样式,而不是颜色。

    • 3; 斜体
    • 4; 强调
    • 5; 闪烁(慢)
    • 6; 闪烁(快速)
    • 7; 相反
    • 8; 隐藏
    • 9; 划掉

    并且几乎得到支持。
    例如,KDE-Konsole支持5; 但是Gnome终端不支持,而Gnome支持8; 但是KDE不会。

    3.前台模式

    此模式用于给前景着色。

    4.后台模式

    此模式用于给背景着色。

    line5-900px-%23F80.svg?sanitize=true

    下表总结了ANSI-color的3/4位版本

    |------------+----------+---------+-------+------------------+------------------------------+--------------------------------------|
    | color-mode | octal    | hex     | bash  | description      | example (= in octal)         | NOTE                                 |
    |------------+----------+---------+-------+------------------+------------------------------+--------------------------------------|
    |          0 | \033[0m  | \x1b[0m | \e[0m | reset any affect | echo -e "\033[0m"            | 0m equals to m                       |
    |          1 | \033[1m  |         |       | light (= bright) | echo -e "\033[1m####\033[m"  | -                                    |
    |          2 | \033[2m  |         |       | dark (= fade)    | echo -e "\033[2m####\033[m"  | -                                    |
    |------------+----------+---------+-------+------------------+------------------------------+--------------------------------------|
    |  text-mode | ~        |         |       | ~                | ~                            | ~                                    |
    |------------+----------+---------+-------+------------------+------------------------------+--------------------------------------|
    |          3 | \033[3m  |         |       | italic           | echo -e "\033[3m####\033[m"  |                                      |
    |          4 | \033[4m  |         |       | underline        | echo -e "\033[4m####\033[m"  |                                      |
    |          5 | \033[5m  |         |       | blink (slow)     | echo -e "\033[3m####\033[m"  |                                      |
    |          6 | \033[6m  |         |       | blink (fast)     | ?                            | not wildly support                   |
    |          7 | \003[7m  |         |       | reverse          | echo -e "\033[7m####\033[m"  | it affects the background/foreground |
    |          8 | \033[8m  |         |       | hide             | echo -e "\033[8m####\033[m"  | it affects the background/foreground |
    |          9 | \033[9m  |         |       | cross            | echo -e "\033[9m####\033[m"  |                                      |
    |------------+----------+---------+-------+------------------+------------------------------+--------------------------------------|
    | foreground | ~        |         |       | ~                | ~                            | ~                                    |
    |------------+----------+---------+-------+------------------+------------------------------+--------------------------------------|
    |         30 | \033[30m |         |       | black            | echo -e "\033[30m####\033[m" |                                      |
    |         31 | \033[31m |         |       | red              | echo -e "\033[31m####\033[m" |                                      |
    |         32 | \033[32m |         |       | green            | echo -e "\033[32m####\033[m" |                                      |
    |         33 | \033[32m |         |       | yellow           | echo -e "\033[33m####\033[m" |                                      |
    |         34 | \033[32m |         |       | blue             | echo -e "\033[34m####\033[m" |                                      |
    |         35 | \033[32m |         |       | purple           | echo -e "\033[35m####\033[m" | real name: magenta = reddish-purple  |
    |         36 | \033[32m |         |       | cyan             | echo -e "\033[36m####\033[m" |                                      |
    |         37 | \033[32m |         |       | white            | echo -e "\033[37m####\033[m" |                                      |
    |------------+----------+---------+-------+------------------+------------------------------+--------------------------------------|
    |         38 | 8/24     |                    This is for special use of 8-bit or 24-bit                                            |
    |------------+----------+---------+-------+------------------+------------------------------+--------------------------------------|
    | background | ~        |         |       | ~                | ~                            | ~                                    |
    |------------+----------+---------+-------+------------------+------------------------------+--------------------------------------|
    |         40 | \033[40m |         |       | black            | echo -e "\033[40m####\033[m" |                                      |
    |         41 | \033[41m |         |       | red              | echo -e "\033[41m####\033[m" |                                      |
    |         42 | \033[42m |         |       | green            | echo -e "\033[42m####\033[m" |                                      |
    |         43 | \033[43m |         |       | yellow           | echo -e "\033[43m####\033[m" |                                      |
    |         44 | \033[44m |         |       | blue             | echo -e "\033[44m####\033[m" |                                      |
    |         45 | \033[45m |         |       | purple           | echo -e "\033[45m####\033[m" | real name: magenta = reddish-purple  |
    |         46 | \033[46m |         |       | cyan             | echo -e "\033[46m####\033[m" |                                      |
    |         47 | \033[47m |         |       | white            | echo -e "\033[47m####\033[m" |                                      |
    |------------+----------+---------+-------+------------------+------------------------------+--------------------------------------|
    |         48 | 8/24     |                    This is for special use of 8-bit or 24-bit                                            |                                                                                       |
    |------------+----------+---------+-------+------------------+------------------------------+--------------------------------------|
    

    line5-900px-%23F80.svg?sanitize=true

    下表总结了ANSI-color的8位版本

    |------------+-----------+-----------+---------+------------------+------------------------------------+-------------------------|
    | foreground | octal     | hex       | bash    | description      | example                            | NOTE                    |
    |------------+-----------+-----------+---------+------------------+------------------------------------+-------------------------|
    |        0-7 | \033[38;5 | \x1b[38;5 | \e[38;5 | standard. normal | echo -e '\033[38;5;1m####\033[m'   |                         |
    |       8-15 |           |           |         | standard. light  | echo -e '\033[38;5;9m####\033[m'   |                         |
    |     16-231 |           |           |         | more resolution  | echo -e '\033[38;5;45m####\033[m'  | has no specific pattern |
    |    232-255 |           |           |         |                  | echo -e '\033[38;5;242m####\033[m' | from black to white     |
    |------------+-----------+-----------+---------+------------------+------------------------------------+-------------------------|
    | foreground | octal     | hex       | bash    | description      | example                            | NOTE                    |
    |------------+-----------+-----------+---------+------------------+------------------------------------+-------------------------|
    |        0-7 |           |           |         | standard. normal | echo -e '\033[48;5;1m####\033[m'   |                         |
    |       8-15 |           |           |         | standard. light  | echo -e '\033[48;5;9m####\033[m'   |                         |
    |     16-231 |           |           |         | more resolution  | echo -e '\033[48;5;45m####\033[m'  |                         |
    |    232-255 |           |           |         |                  | echo -e '\033[48;5;242m####\033[m' | from black to white     |
    |------------+-----------+-----------+---------+------------------+------------------------------------+-------------------------|
    

    8位快速测试:
    for code in {0..255}; do echo -e "\\e[38;05;${code}m $code: Test"; done

    line5-900px-%23F80.svg?sanitize=true

    下表总结了ANSI-color的24位版本

    |------------+-----------+-----------+---------+-------------+------------------------------------------+-----------------|
    | foreground | octal     | hex       | bash    | description | example                                  | NOTE            |
    |------------+-----------+-----------+---------+-------------+------------------------------------------+-----------------|
    |      0-255 | \033[38;2 | \x1b[38;2 | \e[38;2 | R = red     | echo -e '\033[38;2;255;0;02m####\033[m'  | R=255, G=0, B=0 |
    |      0-255 | \033[38;2 | \x1b[38;2 | \e[38;2 | G = green   | echo -e '\033[38;2;;0;255;02m####\033[m' | R=0, G=255, B=0 |
    |      0-255 | \033[38;2 | \x1b[38;2 | \e[38;2 | B = blue    | echo -e '\033[38;2;0;0;2552m####\033[m'  | R=0, G=0, B=255 |
    |------------+-----------+-----------+---------+-------------+------------------------------------------+-----------------|
    | background | octal     | hex       | bash    | description | example                                  | NOTE            |
    |------------+-----------+-----------+---------+-------------+------------------------------------------+-----------------|
    |      0-255 | \033[48;2 | \x1b[48;2 | \e[48;2 | R = red     | echo -e '\033[48;2;255;0;02m####\033[m'  | R=255, G=0, B=0 |
    |      0-255 | \033[48;2 | \x1b[48;2 | \e[48;2 | G = green   | echo -e '\033[48;2;;0;255;02m####\033[m' | R=0, G=255, B=0 |
    |      0-255 | \033[48;2 | \x1b[48;2 | \e[48;2 | B = blue    | echo -e '\033[48;2;0;0;2552m####\033[m'  | R=0, G=0, B=255 |
    |------------+-----------+-----------+---------+-------------+------------------------------------------+-----------------|
    

    line5-900px-%23F80.svg?sanitize=true

    一些屏幕截图

    .gif前景8位摘要

    前景色.gif

    .gif背景8位摘要

    background.gif

    颜色摘要及其值

    在此处输入图片说明 在此处输入图片说明 在此处输入图片说明 在此处输入图片说明

    在KDE终端上blinking

    KDE闪烁

    cecho.svg?sanitize=true 一个简单的C代码,向您展示更多

    cecho_screenshot

    bline.svg?sanitize=true 我开发的用于处理这些颜色的更高级的工具:

    line


    彩色模式拍摄

    褪色-正常-亮

    文字模式拍摄

    纯文本模式

    合并还可以

    结合

    更多的镜头


    面向高级用户和程序员的提示和技巧:

    我们可以在编程语言中使用这些代码吗?

    是的你可以。 我对

    它们会降低程序速度吗?

    我觉得不行。

    我们可以在Windows上使用它们吗?

    3/4位是,如果您使用gcc编译代码
    Win-7上的一些屏幕截图

    如何计算代码长度?

    \\033[ = 2,其他部分1

    我们在哪里可以使用这些代码?

    任何有tty解释器的地方
    xtermgnome-terminalkde-terminalmysql-client-CLI等。
    例如,如果要使用mysql着色输出,可以使用Perl

    #!/usr/bin/perl -n
    print "\033[1m\033[31m$1\033[36m$2\033[32m$3\033[33m$4\033[m" while /([|+-]+)|([0-9]+)|([a-zA-Z_]+)|([^\w])/g;
    

    将此代码存储在文件名: pcc (= Perl Colorize Character)中,然后将文件a放入有效的PATH然后在您喜欢的任何地方使用它。

    ls | pcc
    df | pcc

    mysql内部,首先为pager注册它,然后尝试:

    [user2:db2] pager pcc
    PAGER set to 'pcc'
    [user2:db2] select * from table-name;
    

    个人电脑

    处理Unicode的。

    这些代码仅进行着色吗?

    不,他们可以做很多有趣的事情。 尝试:

    echo -e '\033[2K'  # clear the screen and do not move the position
    

    要么:

    echo -e '\033[2J\033[u' # clear the screen and reset the position
    

    有很多初学者想用system( "clear" )来清除屏幕,因此您可以使用它代替system(3)调用

    它们可以使用Unicode吗?

    是。 \

    这些颜色的哪个版本更好?

    使用3/4-bit很容易,但是使用24-bit则非常准确和美观。
    如果您没有使用经验,那么这里有一个快速教程:
    24位表示: 000000000000000000000000 。 每个8位用于特定颜色。
    1..8用于 r-FF0000.svg?sanitize=true9..16用于 g-00FF00.svg?sanitize=true17..24b-0000FF.svg?sanitize=true
    所以在 #FF0000表示 r-FF0000.svg?sanitize=true 这是: 255;0;0
    #00FF00表示 g-00FF00.svg?sanitize=true 这是: 0;255;0
    那有意义吗? 您想要什么颜色将其与这三个8位值组合在一起。


    参考:
    维基百科
    ANSI转义序列
    tldp.org
    tldp.org
    misc.flogisoft.com
    我不记得的一些博客/网页


    #8楼

    这是我最近整理的一个简单小脚本,它将为任何管道输入着色,而不是使用“厕所”。

    File: color.bsh

    #!/usr/bin/env bash 
    
    ## A.M.Danischewski 2015+(c) Free - for (all (uses and 
    ## modifications)) - except you must keep this notice intact. 
    
    declare INPUT_TXT=""
    declare    ADD_LF="\n" 
    declare -i DONE=0
    declare -r COLOR_NUMBER="${1:-247}"
    declare -r ASCII_FG="\\033[38;05;"
    declare -r COLOR_OUT="${ASCII_FG}${COLOR_NUMBER}m"
    
    function show_colors() { 
       ## perhaps will add bg 48 to first loop eventually 
     for fgbg in 38; do for color in {0..256} ; do 
     echo -en "\\033[${fgbg};5;${color}m ${color}\t\\033[0m"; 
     (($((${color}+1))%10==0)) && echo; done; echo; done
    } 
    
    if [[ ! $# -eq 1 || ${1} =~ ^-. ]]; then 
      show_colors 
      echo " Usage: ${0##*/} <color fg>" 
      echo "  E.g. echo \"Hello world!\" | figlet | ${0##*/} 54" 
    else  
     while IFS= read -r PIPED_INPUT || { DONE=1; ADD_LF=""; }; do 
      PIPED_INPUT=$(sed 's#\\#\\\\#g' <<< "${PIPED_INPUT}")
      INPUT_TXT="${INPUT_TXT}${PIPED_INPUT}${ADD_LF}"
      ((${DONE})) && break; 
     done
     echo -en "${COLOR_OUT}${INPUT_TXT}\\033[00m"
    fi 
    

    然后将其命名为红色(196):
    $> echo "text you want colored red" | color.bsh 196


    #9楼

    就像有些东西一样,通过grep将其突出显示为红色(但只能是红色)。 您还可以使用命名管道,使您的字符串更接近行尾:

     grep '.*' --color=always <(echo "foobar")
    

    #10楼

    为了扩展这个答案 ,我们懒惰的人:

    function echocolor() { # $1 = string
        COLOR='\033[1;33m'
        NC='\033[0m'
        printf "${COLOR}$1${NC}\n"
    }
    
    echo "This won't be colored"
    echocolor "This will be colorful"
    

    #11楼

    到目前为止,我最喜欢的答案是coloredEcho。

    只是要发布另一个选项,您可以查看这个小工具xcol

    https://ownyourbits.com/2017/01/23/colorize-your-stdout-with-xcol/

    您就像grep一样使用它,并且它将为每个参数为stdin着色不同的颜色,例如

    sudo netstat -putan | xcol httpd sshd dnsmasq pulseaudio conky tor Telegram firefox "[[:digit:]]+\.[[:digit:]]+\.[[:digit:]]+\.[[:digit:]]+" ":[[:digit:]]+" "tcp." "udp." LISTEN ESTABLISHED TIME_WAIT
    

    xcol示例

    请注意,它接受sed将接受的任何正则表达式。

    该工具使用以下定义

    #normal=$(tput sgr0)                      # normal text
    normal=$'\e[0m'                           # (works better sometimes)
    bold=$(tput bold)                         # make colors bold/bright
    red="$bold$(tput setaf 1)"                # bright red text
    green=$(tput setaf 2)                     # dim green text
    fawn=$(tput setaf 3); beige="$fawn"       # dark yellow text
    yellow="$bold$fawn"                       # bright yellow text
    darkblue=$(tput setaf 4)                  # dim blue text
    blue="$bold$darkblue"                     # bright blue text
    purple=$(tput setaf 5); magenta="$purple" # magenta text
    pink="$bold$purple"                       # bright magenta text
    darkcyan=$(tput setaf 6)                  # dim cyan text
    cyan="$bold$darkcyan"                     # bright cyan text
    gray=$(tput setaf 7)                      # dim white text
    darkgray="$bold"$(tput setaf 0)           # bold black = dark gray text
    white="$bold$gray"                        # bright white text
    

    我像这样在脚本中使用这些变量

    echo "${red}hello ${yellow}this is ${green}coloured${normal}"
    

    #12楼

    这就是我用来查看所有组合并确定哪个显示很酷的内容:

    for (( i = 0; i < 8; i++ )); do
        for (( j = 0; j < 8; j++ )); do
            printf "$(tput setab $i)$(tput setaf $j)(b=$i, f=$j)$(tput sgr0)\n"
        done
    done
    

    #13楼

    我写了赃物来实现这一目标。

    你可以做

    pip install swag
    

    现在,您可以通过以下方式将所有转义命令以txt文件的形式安装到给定的目的地:

    swag install -d <colorsdir>
    

    甚至更容易通过:

    swag install
    

    将颜色安装到~/.colors

    您可以像这样使用它们:

    echo $(cat ~/.colors/blue.txt) This will be blue
    

    或这样,我发现实际上更有趣:

    swag print -c red -t underline "I will turn red and be underlined"
    

    检查出asciinema


    #14楼

    使用tput计算颜色代码。 避免使用ANSI转义码(例如\\E[31;1m表示红色),因为它不那么可移植。 例如,OS X上的Bash不支持它。

    BLACK=`tput setaf 0`
    RED=`tput setaf 1`
    GREEN=`tput setaf 2`
    YELLOW=`tput setaf 3`
    BLUE=`tput setaf 4`
    MAGENTA=`tput setaf 5`
    CYAN=`tput setaf 6`
    WHITE=`tput setaf 7`
    
    BOLD=`tput bold`
    RESET=`tput sgr0`
    
    echo -e "hello ${RED}some red text${RESET} world"
    

    #15楼

    感谢@ k-five的答案

    declare -A colors
    #curl www.bunlongheng.com/code/colors.png
    
    # Reset
    colors[Color_Off]='\033[0m'       # Text Reset
    
    # Regular Colors
    colors[Black]='\033[0;30m'        # Black
    colors[Red]='\033[0;31m'          # Red
    colors[Green]='\033[0;32m'        # Green
    colors[Yellow]='\033[0;33m'       # Yellow
    colors[Blue]='\033[0;34m'         # Blue
    colors[Purple]='\033[0;35m'       # Purple
    colors[Cyan]='\033[0;36m'         # Cyan
    colors[White]='\033[0;37m'        # White
    
    # Bold
    colors[BBlack]='\033[1;30m'       # Black
    colors[BRed]='\033[1;31m'         # Red
    colors[BGreen]='\033[1;32m'       # Green
    colors[BYellow]='\033[1;33m'      # Yellow
    colors[BBlue]='\033[1;34m'        # Blue
    colors[BPurple]='\033[1;35m'      # Purple
    colors[BCyan]='\033[1;36m'        # Cyan
    colors[BWhite]='\033[1;37m'       # White
    
    # Underline
    colors[UBlack]='\033[4;30m'       # Black
    colors[URed]='\033[4;31m'         # Red
    colors[UGreen]='\033[4;32m'       # Green
    colors[UYellow]='\033[4;33m'      # Yellow
    colors[UBlue]='\033[4;34m'        # Blue
    colors[UPurple]='\033[4;35m'      # Purple
    colors[UCyan]='\033[4;36m'        # Cyan
    colors[UWhite]='\033[4;37m'       # White
    
    # Background
    colors[On_Black]='\033[40m'       # Black
    colors[On_Red]='\033[41m'         # Red
    colors[On_Green]='\033[42m'       # Green
    colors[On_Yellow]='\033[43m'      # Yellow
    colors[On_Blue]='\033[44m'        # Blue
    colors[On_Purple]='\033[45m'      # Purple
    colors[On_Cyan]='\033[46m'        # Cyan
    colors[On_White]='\033[47m'       # White
    
    # High Intensity
    colors[IBlack]='\033[0;90m'       # Black
    colors[IRed]='\033[0;91m'         # Red
    colors[IGreen]='\033[0;92m'       # Green
    colors[IYellow]='\033[0;93m'      # Yellow
    colors[IBlue]='\033[0;94m'        # Blue
    colors[IPurple]='\033[0;95m'      # Purple
    colors[ICyan]='\033[0;96m'        # Cyan
    colors[IWhite]='\033[0;97m'       # White
    
    # Bold High Intensity
    colors[BIBlack]='\033[1;90m'      # Black
    colors[BIRed]='\033[1;91m'        # Red
    colors[BIGreen]='\033[1;92m'      # Green
    colors[BIYellow]='\033[1;93m'     # Yellow
    colors[BIBlue]='\033[1;94m'       # Blue
    colors[BIPurple]='\033[1;95m'     # Purple
    colors[BICyan]='\033[1;96m'       # Cyan
    colors[BIWhite]='\033[1;97m'      # White
    
    # High Intensity backgrounds
    colors[On_IBlack]='\033[0;100m'   # Black
    colors[On_IRed]='\033[0;101m'     # Red
    colors[On_IGreen]='\033[0;102m'   # Green
    colors[On_IYellow]='\033[0;103m'  # Yellow
    colors[On_IBlue]='\033[0;104m'    # Blue
    colors[On_IPurple]='\033[0;105m'  # Purple
    colors[On_ICyan]='\033[0;106m'    # Cyan
    colors[On_IWhite]='\033[0;107m'   # White
    
    
    color=${colors[$input_color]}
    white=${colors[White]}
    # echo $white
    
    
    
    for i in "${!colors[@]}"
    do
      echo -e "$i = ${colors[$i]}I love you$white"
    done
    

    结果

    在此处输入图片说明

    希望这张图片能帮助您为bash选择颜色:D


    #16楼

    这个问题已经被一遍又一遍地回答:-),但是为什么不呢。

    第一次使用tput在现代环境中比通过echo -E手动注入ASCII代码更容易携带

    这是一个快速的bash函数:

     say() {
         echo "$@" | sed \
                 -e "s/\(\(@\(red\|green\|yellow\|blue\|magenta\|cyan\|white\|reset\|b\|u\)\)\+\)[[]\{2\}\(.*\)[]]\{2\}/\1\4@reset/g" \
                 -e "s/@red/$(tput setaf 1)/g" \
                 -e "s/@green/$(tput setaf 2)/g" \
                 -e "s/@yellow/$(tput setaf 3)/g" \
                 -e "s/@blue/$(tput setaf 4)/g" \
                 -e "s/@magenta/$(tput setaf 5)/g" \
                 -e "s/@cyan/$(tput setaf 6)/g" \
                 -e "s/@white/$(tput setaf 7)/g" \
                 -e "s/@reset/$(tput sgr0)/g" \
                 -e "s/@b/$(tput bold)/g" \
                 -e "s/@u/$(tput sgr 0 1)/g"
      }
    

    现在您可以使用:

     say @b@green[[Success]] 
    

    要得到:

    大胆的绿色成功

    关于tput可移植性的注意事项

    1986年9月首次上载tput(1)源代码

    tput(1)在1990年代的X / Open curses语义中可用(1997标准具有以下提及的语义)。

    因此,它是( 相当 )普遍。


    #17楼

    我们可以为文本和背景使用24位RGB真彩色

     ESC[38;2;⟨r⟩;⟨g⟩;⟨b⟩m  /*Foreground color*/
     ESC[48;2;⟨r⟩;⟨g⟩;⟨b⟩m  /*Background color*/
    

    红色文字示例和结束标记:

     echo -e "\e[38;2;255;0;0mHello world\e[0m"
    

    发电机:

     text.addEventListener("input",update) back.addEventListener("input",update) function update(){ let a = text.value.substr(1).match(/.{1,2}/g) let b = back.value.substr(1).match(/.{1,2}/g) out1.textContent = "echo -e \\"\\\\" + `033[38;2;${parseInt(a[0],16)};${parseInt(a[1],16)};${parseInt(a[2],16)}mHello\\"` out2.textContent = "echo -e \\"\\\\" + `033[48;2;${parseInt(b[0],16)};${parseInt(b[1],16)};${parseInt(b[2],16)}mWorld!\\"` } 
     div {padding:1rem;font-size:larger} 
     TEXT COLOR: <input type="color" id="text" value="#23233"> <br><div id="out1"></div> BACK COLOR: <input type="color" id="back" value="#FFFF00"> <br><div id="out2"> 

    24位:具有16至24位颜色的“真彩色”图形卡变得很普遍,Xterm,KDE的Konsole以及所有基于libvte的终端(包括GNOME终端)都支持24位前景和背景颜色设置https:// /en.wikipedia.org/wiki/ANSI_escape_code#24位

    在我的脚本中使用安全吗?

    是! 8位和16位端子将仅作为可用调色板范围内的颜色显示为回退,以保持最佳的对比度,没有破损!


    同样,没有人注意到ANSI代码7 反向视频的有用性。

    通过交换前景色和背景色,它可以在任何终端方案颜色,黑色或白色背景或其他奇特的调色板上保持可读性。

    例如,对于可在任何地方使用的红色背景:

    echo -e "\033[31;7mHello world\e[0m";
    

    这是更改终端内置方案时的外观:

    在此处输入图片说明

    这是用于gif的循环脚本。

    for i in {30..49};do echo -e "\033[$i;7mReversed color code $i\e[0m Hello world!";done
    

    参见https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_(Select_Graphic_Rendition)_parameters


    #18楼

    绝对应该在原始ANSI控制序列上使用tput。

    因为存在大量不同的终端控制语言,所以系统通常具有中间通信层。 在数据库中查找当前检测到的终端类型的实际代码,然后向API发出标准请求,或者(从外壳程序)向命令发出标准请求。

    这些命令之一是tputtput接受一组称为功能名称和任何参数(如果适用)的首字母缩写词,然后在terminfo数据库中为检测到的终端查找正确的转义序列,并输出正确的代码(终端希望能理解)。

    来自http://wiki.bash-hackers.org/scripting/terminalcodes

    就是说,我编写了一个名为bash-tint的小型帮助程序库,该库在tput之上添加了另一层,使其更易于使用(imho):

    示例: tint "white(Cyan(T)Magenta(I)Yellow(N)Black(T)) is bold(really) easy to use."

    将给出以下结果: 在此处输入图片说明


    #19楼

    这是最简单易读的解决方案。 使用bashj( https://sourceforge.net/projects/bashj/ ),您只需选择以下行之一:

    #!/usr/bin/bash
    
    W="Hello world!"
    echo $W
    
    R=130
    G=60
    B=190
    
    echo u.colored($R,$G,$B,$W)
    
    echo u.colored(255,127,0,$W)
    echo u.red($W)
    echo u.bold($W)
    echo u.italic($W)
    
    Y=u.yellow($W)
    echo $Y
    echo u.bold($Y)
    

    如果终端应用程序中有颜色支持,则可以使用256x256x256种颜色。


    #20楼

    我刚刚合并了所有解决方案中的好方法,最后得出:

    cecho(){
        RED="\033[0;31m"
        GREEN="\033[0;32m"
        YELLOW="\033[1;33m"
        # ... ADD MORE COLORS
        NC="\033[0m" # No Color
    
        printf "${!1}${2} ${NC}\n"
    }
    

    您可以将其称为:

    cecho "RED" "Helloworld"
    

    #21楼

    参考:

    echo_red(){
        echo -e "\e[1;31m$1\e[0m"
    }
    echo_green(){
        echo -e "\e[1;32m$1\e[0m"
    }
    echo_yellow(){
        echo -e "\e[1;33m$1\e[0m"
    }
    echo_blue(){
        echo -e "\e[1;34m$1\e[0m"
    }
    

    #22楼

    这是一个在MacOS终端上工作的实现,用于为PS1设置颜色以及不设置颜色。

    有两种实现方式,一种是依靠echo,另一种是依靠printf来动态调用方法而又不会松懈。

    这只是一个开始,但功能强大,不会闪烁终端。 现在支持git branch,但是最终可以扩展为做很多事情。

    可以在这里找到:

    https://github.com/momomo/opensource/blob/master/momomo.com.shell.style.sh

    应该可以通过复制和粘贴来工作。 没有依赖关系。


    #23楼

    要显示不同颜色的消息输出,可以使:

    echo -e "\033[31;1mYour Message\033[0m"
    

    -黑色0; 30深灰色1; 30

    -红色0; 31浅红色1; 31

    -绿色0; 32浅绿色1; 32

    -棕色/橙色0; 33黄色1; 33

    -蓝色0; 34浅蓝色1; 34

    -紫色0; 35浅紫色1; 35

    -青色0; 36浅青色1; 36

    -浅灰色0; 37白色1; 37


    #24楼

    如果您使用的是zshbash

    black() {
        echo -e "\e[30m${1}\e[0m"
    }
    
    red() {
        echo -e "\e[31m${1}\e[0m"
    }
    
    green() {
        echo -e "\e[32m${1}\e[0m"
    }
    
    yellow() {
        echo -e "\e[33m${1}\e[0m"
    }
    
    blue() {
        echo -e "\e[34m${1}\e[0m"
    }
    
    magenta() {
        echo -e "\e[35m${1}\e[0m"
    }
    
    cyan() {
        echo -e "\e[36m${1}\e[0m"
    }
    
    gray() {
        echo -e "\e[90m${1}\e[0m"
    }
    
    black 'BLACK'
    red 'RED'
    green 'GREEN'
    yellow 'YELLOW'
    blue 'BLUE'
    magenta 'MAGENTA'
    cyan 'CYAN'
    gray 'GRAY'
    

    在线尝试


    #25楼

    从线程混合其他解决方案后,这就是我如何在npm scripts输出(gitbash CLI)中获取颜色的方法:

    {
        "deploy": "echo \u001b[1;32m && ng build && echo \u001b[1;0mdeploy {\u001b[1;33mcopy\u001b[1;0m: \u001b[1;32m0% && cp -r -f dist/packaged/* \\\\SERVER-01\\dist\\ && echo \u001b[1;0mdeploy {\u001b[1;33mcopy\u001b[1;0m} \u001b[1;34m\u001b[1;1m100% DEPLOYED"
    }
    

    在此处输入图片说明


    #26楼

    您可以在bash脚本中定义颜色,如下所示:

    red=$'\e[1;31m'
    grn=$'\e[1;32m'
    yel=$'\e[1;33m'
    blu=$'\e[1;34m'
    mag=$'\e[1;35m'
    cyn=$'\e[1;36m'
    end=$'\e[0m'
    

    然后使用它们以您需要的颜色进行打印:

    printf "%s\n" "Text in ${red}red${end}, white and ${blu}blue${end}."
    

    #27楼

    echo -e "\033[31m Hello World"
    

    [31m控制文本颜色:

    • 30 - 37前景色
    • 40 - 47背景颜色

    可以在此处找到更完整的颜色代码列表。

    优良作法是在字符串末尾将文本颜色重置回\\033[0m


    #28楼

    使用具有setaf功能和参数1 tput

    echo "$(tput setaf 1)Hello, world$(tput sgr0)"
    

    #29楼

    您可以使用以下ANSI转义码

    Black        0;30     Dark Gray     1;30
    Red          0;31     Light Red     1;31
    Green        0;32     Light Green   1;32
    Brown/Orange 0;33     Yellow        1;33
    Blue         0;34     Light Blue    1;34
    Purple       0;35     Light Purple  1;35
    Cyan         0;36     Light Cyan    1;36
    Light Gray   0;37     White         1;37
    

    然后在脚本中像这样使用它们:

    #    .---------- constant part!
    #    vvvv vvvv-- the code from above
    RED='\033[0;31m'
    NC='\033[0m' # No Color
    printf "I ${RED}love${NC} Stack Overflow\n"
    

    用红色印出love

    根据@ james-lim的注释, 如果使用的是echo命令,请确保使用-e标志以允许反斜杠转义

    # Continued from above example
    echo -e "I ${RED}love${NC} Stack Overflow"
    

    (除非要添加其他空行,否则在使用echo时请勿添加"\\n"

    展开全文
  • ANSI控制码 简介 ANSI控制码用于在字符显示系统中控制光标移动和字符色彩等,常用于BBS系统中。 ANSI ESCAPE SEQUENCES又称为VT100系列控制...ANSI控制码依赖终端,不是依赖语言,所以在shell,perl,c里应用均没有...
  • for 循环 for 变量名 in 值列表 do  命令序列 done  值列表:  {1..10} 产生1到10的多个数字的列表,但是里面不能有变量  $(seq $起始数 $终止数字) 可以用变量生成多个数据 类C++的for循环 ...for ...
  • shell字体颜色应用

    2019-07-07 04:05:19
    输出特效格式控制: \033[0m 关闭所有属性 \033[1m 设置高亮度 \03[4m 下划线 \033[5m 闪烁 \033[7m 反显 \033[8m 消隐 \033[30m -- \033[37m 设置前景色 \033[40m -- \033[47m 设置背景色 光标位置等的格式控制...
  • shell

    万次阅读 多人点赞 2019-09-16 20:22:38
    shell 什么是shell: 现在我们使用的操作系统(Windows、Mac OS、Android、iOS等)都是带图形界面的,简单直观,容易上手,对专业用户(程序员、网管等)和普通用户(家庭主妇、老年人等)都非常适用;计算机的普及...
  • 在sed中引入shell变量的四种方法

    万次阅读 2017-03-15 10:06:29
    今天在写一个脚本遇到问题,----需要在sed中引入shell变量,在网上搜了变天才找到,经过测试 这四种方法都可用,在这里跟大家分享下,=---同时谢谢netman大哥,前辈就是前辈哈哈 1.eval sed ’s/$a/$b/’ ...
  • 介绍下Shell中的${}、##和%%使用范例,本文给出了不同情况下得到的结果。假设定义了一个变量为:代码如下:file=/dir1/dir2/dir3/my.file.txt可以用${ }分别替换得到不同的值:${file#*/}:删掉第一个 / 及其左边的...
  • shell的本质

    千次阅读 2018-09-22 17:00:36
    shell 摘要:shell是什么语言?shell语言的本质“Shell是Linux/Unix的一个外壳,你理解成衣服也行。它负责外界与Linux内核的交互,接收用户或其他应用程序的命令,然后把这些命令转化成内核能理解的语言,传给内核,内核是...
  • shell脚本实现逻辑关系与、或、非

    万次阅读 2017-01-03 19:11:45
    shell脚本实现逻辑关系与、或、非
  • Shell中的$0、$1、$2的含义

    万次阅读 多人点赞 2017-08-11 10:58:59
    shell 中我们会见到 $0、$1、$2这样的符号,这是什么意思呢? 简单来说$0就是你写的shell脚本本身的名字,$1是你给shell传的第一个参数,$2是你给shell传的第二个参数
  • adb shell退出

    万次阅读 2013-03-14 18:49:39
    今天遇到ctrl+c不能退出adb shell >exit //ok
  • shell 如何来分割字符串让结果为一个字符串串数组
  • 症状:shell中大于,大于等于,小于等于,lt,gt ,ne,ge,le 很对应。 应对方法: 大于 -gt (greater than) 小于 -lt (less than) 大于或等于 -ge (greater than or equal) 小于或等于 -le (less than or equal) ...
  • Windows下运行shell脚本

    万次阅读 2018-04-25 16:27:55
    1.安装 git2.cmd中进入git所在目录的bin文件夹下3.输入sh .\test.sh成功。
1 2 3 4 5 ... 20
收藏数 1,135,297
精华内容 454,118
关键字:

shell