Linux 快捷命令学习

发表于 分类于 ， 阅读次数： 本文字数： 13k 阅读时长 ≈ 12 分钟

Introduction

Linux 对于开发人员来讲，是一款必学的操作系统。且现服务器端基本都是部署于Linux；常见的有Red Hat、CentOS、Ubuntu……

熟悉Linux系统下诸多命令的常用用法，在服务器端进行生产时，将会事半功倍；往往一个简单的操作，可以使用很多自己熟悉的方式进行实现；Python、Perl、R可能都可以实现，但是在Linux操作系统下，其配套的shell不会更香吗？Shell一行代码能解决的事情，Python却要一个脚本，怎么想都差点意思。

这里主要是记录一些常用的文本处理涉及到的shell命令。

Getting started

可惜的是没有对各种命令进行整理，后续有时间可以归纳分类一下。

1. find

1.1 查找某个目录下的某个文件

1
2
3
4
5
$ find ./ -name "**"
$ find ./ -type f ## 打印出当前目录下的所有文件；file
$ find ./ -type d ## 打印出当前目录下的所有文件夹；
$ find . -maxdepth 1 -name "*.sh"  ## 只在当前一级目录下查找
$ find -L -name "cxd"  ## -L 参数是对当前目录下的所有文件递归查找，包括在该路径下的软链接目录

1.2 对查找得到的文件进行某项操作

后面的 占位符{} 用来表示 find 到的文件名。

1
2
3
4
5
6
$ find dir -exec cmd {} \;  ## 每 find 到一个文件就会执行一次 cmd 命令
$ find dir -exec cmd {} +   ## 当 find 到所有满足条件的文件之后，一次性执行 cmd 命令
$ find ./ -type f -exec chmod 644 {} \; ## 对当前目录下的所有 file 赋予 644 权限（拥有者可读可写，其他群组或其他用户只可读）

### 扩展---【-ok】
### 参数 -ok 的作用与 -exec 类似；但多个用户确认的环节；适合的使用场景为需要对查找的文件进行删除操作时，使用 -ok；可实现进一步的确认是否删除，从而提高删除操作的an'quan'xin

1.3 按创建时间，修改时间查找文件

1
2
3
4
5
6
7
8
9
10
$ find dir -ctime -7 -amin -30
## 查找 7天 内被修改过，且 30 分钟 内又被读取过的文件
# 【-mtime】修改时间（Modification time）：最后一次文件内容有过更改的时间点
# 【-atime】访问时间（Access time）：最后一次文件有被读取过的时间点
# 【-ctime】变更时间（Change time）：最后一次文件有被变更过的时间点（如内容被修改，或权限等 metadata 被修改）
#### 表现方式
# -mtime 2：该文件 2 天前被修改过
# -mtime -2：该文件 2 天以内被修改过
# -mtime +2：该文件距离上次修改已经超过 2 天时间
#### 同理还有分钟级别的查找；【-mmin, -amin, -cmin】；相同的前缀，不同的只有后面的time改成min

1.4 -exec 的花样使用

使用了一段时间的 find -exec 参数，就会发现，参数 -exec 只能支持linux系统的原生终端命令；一些通过alias改写的快捷命令并不能使用，且还不支持管道符 |

当我们需要对查找到的文件路径进行复杂操作时，-exec的用法就有点鸡肋了；于是我们能不能通过占位符 ‘{}’ 来进行传参并通过管道符 ‘|’ 来完成一系列的操作呢？？？

1
2
3
4
5
6
7
8
### 首先，必须了解的另一种用法
$ echo -e "echo "hello""               ## output: echo hello
$ sh -c 'echo -e "echo "hello""'	   ## output: echo hello
$ echo -e "echo "hello"" | sh          ## output: hello  ## 这里就很好的解释了管道符 '|' 的作用，就是将前面echo打印出的 "echo "hello""（即标准输出） 传入 sh 命令并运行命令，最终便打印出 hello（'echo "hello"' 命令的运行结果）
$ sh -c 'echo -e "echo "hello"" | sh'  ## output: hello  ## sh -c 命令便是解决 -exec 参数不能使用管道符的限制，可以尝试以下哈


## find /data5/Rawdata/Sequencer/bcl/* -maxdepth 0 -type d -ctime -7 -exec sh -c 'echo {} | awk '\''{print "=="$0}'\''' \;

2. du

2.1 查询当前目录下文件的大小

1
$ du -h --max-depth=1

2.2 计算文件大小，单位 Mb

1
2
$ du -sm test.fq.gz  ## 以 Mb 为单位输出文件 test.fq.gz 的文件大小
## 3066    test.fq.gz  ## 说明 test.fq.gz 的文件大小为 3066Mbp

3. grep

3.1 匹配多个字符

1
2
3
$ grep "ins\|del" annot.xls  ## 打印出含有 ins 或 del 字符的行
## or
$ grep -E "ins|del" annot.xls

3.2 只匹配整个单词

1
$ grep -w on ddd.txt   ## 这只会匹配完整单词 on，而不会匹配含有 on 的单词，如不会匹配 only

3.3 同时匹配多个字符

1
2
$ grep -E "EML4.*ALK" ddd.txt  ## 打印出同时含有 EML4 和 ALK 的行
$ grep -El "BCR|RUNX1" *  ## 打印出当前目录下满足

3.4 去除空行

1
$ grep -v '^$' ddd.txt ## 打印除了空行以外的所有

3.5 取匹配的前3行

1
$ grep -B 3 str xxx.txt

3.6 取匹配的后3行

1
$ grep -A 3 str xxx.txt

3.7 取匹配的前后3行

1
2
3
$ grep -C 3 str xxx.txt
## or
$ grep -3 str xxx.txt

4. sed

4.1 替换前 n 个字符

1
2
3
$ sed 's/^.\{15\}//g' ddd.txt  ## 替换前 15 个字符
$ sed 's/^.\{n\}//g' ddd.txt  ## 替换前 n 个字符
$ sed 's/^.//g' ddd.txt  ## 替换第一个字符

4.2 替换某一行

1
$ sed '1c str' ddd.txt  ## 替换文件 ddd.txt 的第一行为 "str"

4.3 删除某一行

1
$ sed '1d' ddd.txt  ## 删除文件 ddd.txt 的di

4.4 某一行前插入一行

1
$ sed -i "1i##charu" ddd.txt  ## 在文件 ddd.txt 的第一行插入 ##charu

4.5 替换换行符\n

正常情况下，sed 并不能替换 \n， 需要额外添加参数

那 sed 为什么不能直接替换换行符 \n 呢？

原因在于 sed 是逐行处理替换操作的，且在每进行一次替换之后，都会在行尾自动添加 trailing newline，即行的分隔符，即换行符，于是常规的替换是无法将换行符替换成其他分隔符的；于是，我们可以对每两行或以上的行进行换行符的替换，这样中间的换行符就能被替换，而最后的换行符保留。

1
$ sed ":a;N;s/\n/|/g;ta" ddd.txt  ## 替换 ddd.txt 文件的换行符为 |

在利用 sed 替换换行符 \n 时，上面的命令有点复杂，故这里做个说明：

  • 首先提供一个通用写法：sed ":label;N;s/\n/|/g;t label"; or sed ":label;N;s/\n/|/g;b label"
  • :label; — 这是一个标签，用来实现跳转处理，名字可任意取，如上上面的 :label 就是 a；只不过需要注意的就是，前后的 label 值需要保持一致
  • N; — 是 sed 的一个处理命令，追加文本流中的下一行到模式空间进行合并处理，也就以换行符 \n 分隔（我是这么理解的），这样 sed 替换的时候就可以识别到 \n 字符，从而实现替换
  • ;t — 即 test，测试的意思，与 label 搭配使用，实现跳转处理，跳转到指定的标签处
  • ;b — 即 branch，分支的意思，功能同 ;t；只不过是所代表的含义不同；
  • branch 是循环到文本结束；而 test 可以根据替换命令的完成是否成功来决定是否跳转

4.6 替换每一行第一个匹配值

1
2
$ sed 's/dd/aa/' a.txt 
## 也就是去掉 /g

4.7 替换第一行的第一个匹配值

当我们只需要替换匹配到的第一个匹配值时，就不能用 4.6 的方法了，因为这会将每一行的第一个匹配值进行替换，于是有了下面的方法

1
2
3
## 【0,/待替换内容/s/待替换内容/替换内容/】
$ sed "0,/:/s/:/null/"  a.txt
## 这里只会替换整个文件匹配到的第一个匹配值

4.8 删除匹配行

查找匹配含有特定字符的行，并删除

1
2
$ sed '/str/d' aaa.txt
## 删除文件 aaa.txt 中含有 str zi'fu'chu'a
1
2
## 待整理
sed 's/[A-Z]*\([0-9]\)\([0-9A-Za-z]\)/\1\2/g'

5. bc

bc 命令是任意精度计算器语言，通常在 Linux 下当计算器使用；类似基本的计算器，使用这个计算器可以做基本的数学运算

==采用 expr 计算数值或者字符串长度，获取更加合适==

==参数介绍==

  • -i：强制进入交互模式
  • -l：定义使用的标准数学库
  • -w：对 POSIX bc 的扩展给出警告信息
  • -q：不打印正常的 GNU bc 环境信息
  • -v：显示指令版本信息
  • -h：显示指令的帮助信息

5.1 通过管道符进行计算

1
2
3
4
5
$ echo "scale=2; 3066/1024"| bc ## scale 用来设定小数位
## out：2.99 
## 但是计算出来的值小于 1；则以 .* 表示；如 .9 == 0.9
## 所以可以替换一下
$ echo "scale=2; 3066/1024"| bc | sed 's/^\./0./g'  ## 可以避免出现没有 0 的qing'kaun

5.2 进行其他进制的计算

1
2
$ echo "ibase=2; 111" | bc  ## ibase 用来指定进制
## out：7

5.3 进制转换

1
2
3
4
5
6
7
8
#!/bin/bash

abc=192 
echo "obase=2;$abc" | bc  ## 将 10 进制转换成 2 进制
## out：11000000

abc=11000000 
echo "obase=10;ibase=2;$abc" | bc  ## 将 2 进制转换成 10 进制

5.4 计算平方与平方根

1
2
3
4
$ echo "10^10" | bc 
10000000000
$ echo "sqrt(100)" | bc
10

6. Sort

1
2
sort -k1 aaa.txt  ## 对文件 aaa.txt 的第一列进行重排；默认是升序（以 ASCII 码的次序进行排列）
# -n 表示按照数值的大小进行排序

7. 查询后台任务的运行绝对路径

通常我们通过 ps 或 top 命令来查看后台任务的部分信息，却查不到进程的详细信息，比如 运行进程的绝对路径 等，top 命令可以使用 c 来查看运行时投递的具体信息，但也没有运行进程所在的绝对路径

此外，我们需要知道的是 Linux 在启动一个进程时，系统会在 /proc 目录下创建一个以 PID 命名的文件夹，在该目录下会有我们创建进程的详细信息，其中：

  • cwd：链接的是进程运行目录
  • exe：链接的是执行程序的绝对路径
  • cmdline：程序运行时输入的命令
  • environ：记录了进程运行时的环境变量
  • fd：目录下为进程打开或使用的文件的符号链接

8. 获取操作系统名称

1
2
3
$ uname -s
## Linux

8.1 获取所有用户的登录情况

1
$ who -uH

9. ps

获取后台任务的详细信息

1
2
3
4
5
6
7
8
9
10
11
12
13
$ ps -ef | grep $yourname  ## 查询指定用户的所有后台任务
## 查询进程打开的文件
lsof -p [PID]
## 查询内存分配
lcat /proc/[PID]/maps  ## 没有权限，非 root 用户
## 查询后台任务的运行详情
ll /proc/[PID]  ## 其中 cwd --- 链接的是进程运行目录；exe --- 执行程序的绝对路径；cmdline --- 程序执行时输入的命令行命令；environ --- 记录了进程运行时的环境变量；fd --- 目录下是进程打开或使用的文件的符号链接
## 查看当前的后台任务
jobs
## 把后台任务拉到前台运行
fg %任务号  ## 默认为任务1
## 使用 CTRL+Z 是将任务暂停并挂载到后台
bg %任务号 ## 使暂停的任务在后台运行

==注意==

  • 后台任务的信息查询便捷命令
    1. 首先获得后台任务的[PID]
    2. pwdx [PID] — 获取对应进程的运行路径
    3. pgrep [进程名] — 这命令可以列出对应进程名的所有进程id - [PID]，

10. top

查询系统的详细信息，如内存，CPU，IO等

image-20220907102938349

==如上==

  • 第一行（top -）：系统当前时间 up 系统到目前为止运行的时间 ， 当前登录系统的用户数量（users），load average： 后面的 3 个数字分别标识距离现在 1min、5min、15min 的负载情况 — 这行的信息与命令 uptime 的输出结果一致
  • 第二行（Tasks：）：Tasks 表示任务（进程），total 表示总进程数，running 正在运行，sleeping 休眠（挂起）的任务数量，stopped 任务状态为暂停的数量，zombie 表示僵尸进程的数量
  • 第三行（%Cpu(s)：）：表示 CPU 的状态，us(user) 用户空间占用cpu的百分比；sy(system) 内核空间占用cpu的百分比；ni(niced) 改变过优先级的进程占用cpu的百分比；id 空闲CPU百分比；wa(IO wait) IO 等待占用cpu的百分比；hi(hardware IO) 硬中断占用cpu的百分比；si(software interrupts) 软中断占用cpu的百分比
  • 第四行（KiB Mem：）：内存状态，依次为物理内存总量，空闲内存总量，使用中的内存总量，缓冲内存量
  • 第五行（KiB Swap：）：swap 交换分区，依次为交换区总量，空闲交换区总量，使用中的交换区总量，可用交换区总量

（对于内存监控，在 top 里，我们要时刻关注 swap 交换分区中的 used，如果这个数值在不同的变换，说明内核在不断进行内存和交换区的数据交换，预示着内存不够用）

  • 第六行：空行
  • 第七行：各进程的监控
    • PID：进程 id
    • USER：进程所有者
    • PR：进程优先级
    • NI：nice值，负值表示高优先级，正值表示低优先级
    • VIRT：进程使用的虚拟内存总量，单位 kb；${VIRT = SWAP + RES}$
    • RES：进程使用的、未被换出的物理内存大小，单位 kb；${RES = CODE + DATA}$
    • SHR：共享内存大小，单位 kb
    • S：进程状态；D - 不可中断的休眠状态；R - 运行； S - 休眠； T - 跟踪/停止；Z - 僵尸进程
    • %CPU：上次更新到现在的cpu占用百分比
    • %MEM：进程使用的物理内存百分比
    • TIME+：进程所用的cpu时间总计，单位 0.01 秒
    • COMMAND：进程名称（top 命令运行中，键入 c，可以显示进程的详细信息）

11. watch

检测一些重复的操作，-n 参数指定间隔多长时间重新运行某个命令

1
2
3
$ watch --differences=permanent -n10 [cmd]
## 对发生变化的部分进行高亮
## 每隔 10s 运行后面的 cmd

12. xargs

这是个功能非常强大的命令，可以将标准输出作为参数传入某个命令中运行；特别是对于不能接收标准输入为参数的命令；如 echo（不能接受管道传递的标准输出为参数）

Link: https://ruanyifeng.com/blog/2019/08/xargs-tutorial.html

12.1 将标准输出通过管道符传递给某个命令作为参数运行

1
2
3
4
5
6
7
## echo 便是一个不能将标准输出通过管道符作为参数进入下一个命令的命令
$ echo "hello world"              ## output: hello world
$ echo "hello world" | echo		  ## output: null  ## 空行
$ echo "hello world" | xargs echo ## output: hello world
## 说明 xargs 的功能
## 此外还有一些命令需要 xargs 的辅助才能实现参数的读入
## 如：rm, mkdir, ls 等等

说明 xargs 的功能，便是为那些不能从管道符获取参数的命令服务的；但是 xargs 开发初衷是为 find 服务，所以更多便捷的使用，都可以从 find 中找到

12.2 默认分隔符

【-d】xargs 默认的分隔符是换行符和空格，从而将标准输入分隔成多个参数进行读取；同时也支持 -d 参数指定分隔符

1
2
3
$ echo -e "hello\tworld" | xargs -d '\t' echo
## output: hello world
## 等效于： $ echo hello world

12.3 打印最终执行的命令

【-p | -t】当我们不知道参数是否传递正确的情况下，可以通过这两个参数来确认；-t 参数便是将接下来需要执行的命令打印并输出标准输出结果；-p 参数则是在 -t 的基础上增加了一个询问功能，打印执行命令之后，会有一个 yes or no 的选择，需要用户键入 y or n ，大小写无所谓，来确认是否执行该命令；这种参数在设置敏感数据删除 rm 的情况下非常重要，防止命令参数的传入失误导致数据误删。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
$ echo -e "hello\tworld" | xargs -d '\t' -t echo
## output:
echo hello world
 
hello world

## 以上四行均为输出，但不清楚什么会有两个空行，
## 目前的猜测是 xargs 在存在参数 '-d' 的情况下，换行符 '\n' 保留; 而在打印时，本身就会自动添加换行符，所以这里就多了两个空行 
## 所以上面的传参应该是 $ echo hello world'\n'

$ echo -e "hello\nworld dd" | xargs -d ' ' -t echo
## output:
echo hello
world dd
 
hello
world dd

$ echo -e "hello\tworld" | xargs -d '\n' -p echo
## output:
echo hello	world ?...y
hello	world

12.4 指定传入几行数据传入参数

【-L】若标准输入包含多行，-L 参数指定多少行作为一个命令行参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
$ xargs -L 1 find -name
## output: ## -L 1 指定每次传入一行作为参数
"*.txt"
./foo.txt
./hello.txt
"*.md"
./README.md

## 再如
$ echo -e "hello\nworld"| xargs -t echo
## 这里 -L 参数，故直接默认换行符作为分隔符同时传入两个参数
## output:
echo hello world 
hello world

$ echo -e "hello\nworld"| xargs -L 1 -t echo
## 添加了 -L 参数，便每次只传入一行的数据进行参数传递；针对对每一行进行相同处理极为方便
## output：
echo hello 
hello
echo world 
world

12.5 指定传入几列数据作为参数

【-n】作用与 -L 类似，但是其是横向选定，在用户同一行键入多项时，需要利用 -n 参数指定每次传入多少项，作为命令行参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
$ xargs -t -n 1 find -name
## 上面命令指定将每一项（-n 1）标准输入作为命令行参数，分别执行一次命令（find -name）
## output:
"*.txt" "*.md"
find -name "*.txt"
./foo.txt
./hello.txt
find -name "*.md"
./README.md

## 再如
$ echo {0..9} | xargs -n 2 echo
## 每次传入 -n 2 个参数；便循环了 5 次 echo 输出
## output:
0 1
2 3
4 5
6 7
8 9

12.6 将命令行参数传递给多个命令

【-I】前面默认的都是在 xargs 后面的命令后直接添加参数，但是当我们需要向多个命令传递参数时，就需要用到 -I 参数，指定需要传递的参数

-I 指定每一项命令行参数的替代字符串

-i 同 -I，只不过是默认以占位符 {} 代替变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
$ echo -e "one\ntwo\nthree" | xargs -I num sh -c 'echo num; echo --num--'
## -I 参数对传入的参数重命名；也就是对传入的参数创建对应的变量
## output:
one
--one--
two
--two--
three
--three--

## 再如
$ echo -e "one\ntwo\nthree" | xargs -t -I {} sh -c 'echo {}; echo --{}--'
## output：
sh -c echo one; echo --one--   ## 正常运行应该是 sh -c 'echo one; echo --one--'
one
--one--
sh -c echo two; echo --two-- 
two
--two--
sh -c echo three; echo --three-- 
three
--three--

## 
## 需要注意的是，在给 sh -c 进行传参时，'$' 符号需要进行转义；即书写成 '\$1....'
$ echo -e "3\n17" | xargs -t -L 2 sh -c "echo exon\$0-exon\$1"
## 注意 sh -c chuan'can
## output：
sh -c echo exon$0-exon$1 3 17 
exon3-exon17

12.7 多进程执行命令

【--max-procs】xargs 命令默认只用一个进程执行命令，只有当执行结束上一个命令，才能执行下一个命令；当需要循环执行命令，且相互之间没有依赖关系的情况下，各个循环可独立运行，故这里可以采用参数 --max-procs 命令指定调用的进程数，从而实现同时进行 n 次命令执行；

--max-procs 参数指定同时调用多少个进行并执行命令；

--max-procs 2 – 表示同时最多调用两个进程

--max-procs 0 – 表示不限制进程数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
$ docker ps -q | xargs -n 1 --max-procs 0 docker kill
## 同时关闭尽可能多的 Docker 容器，这样运行速度会快很多；不懂

## 再如
$ echo -e "sleep 30 && echo hello\nsleep 10 && echo world" | xargs -t -I {} sh -c "{}"
## 单进程的情况下，只有在前一个命令执行结束之后，才能运行下一条命令；故这里先输出 hello；而后才能打印 world
## output: 
sh -c sleep 30 && echo hello 
hello
sh -c sleep 10 && echo world 
world

## 那提供两个进程呢？？？
$ echo -e "sleep 30 && echo hello\nsleep 10 && echo world" | xargs --max-procs 2 -t -I {} sh -c "{}"
## 这里由于提供了两个进程，于是，同时执行 echo hello 和 echo world 两条命令，但是因为 world 的睡眠时间较短，提前打印出来，而后才打印 hello
## output：
sh -c sleep 30 && echo hello 
sh -c sleep 10 && echo world 
world
hello

12.8 xargs 与 find 的搭伙

【-0】xargs 默认是将空格作为分隔符，在处理文件名时，若文件名中存在空格，则不会太方便；

find 命令有个特别的参数 -print0 ，指定输出的文件列表以 null 分隔，而 xargs 的 -0 参数表示用 null 当作分隔符

1
2
$ find /path -type f -print0 | xargs -0 rm
## 删除 /path 路径下的所有文件；由于分隔符是 null ，所以处理含有空格的文件名，也不会报错

还有一个原因，使得xargs特别适合find命令。有些命令（比如rm）一旦参数过多会报错”参数列表过长”，而无法执行，改用xargs就没有这个问题，因为它对每个参数执行一次命令。

1
2
$ find . -name "*.txt" | xargs grep "abc"
## 找出所有 TXT 文件以后，对每个文件搜索一次是否包含字符串abc。

12.9 xargs 与 sed 搭配

1
2
3
4
5
6
7
8
9
$ echo -e "MSFVAGVIRRLDETVVNRIAAGEVIQRPANAIKEMIENCLDAKSTSIQVIVKEGGLKLIQIQDNGTGIRKEDLDIVCERFTTSKLQSFEDLASISTYGFRGEALASISHVAHVTITTKTADGKCAYRASYSDGKLKAPPKPCAGNQGTQITVEDLFYNIATRRKALKNPSEEYGKILEVVGRYSVHNAGISFSVKKQGETVADVRTLPNASTVDNIRSIFGNAVSRELIEIGCEDKTLAFKMNGYISNANYSVKKCIFLLFINHRLVESTSLRKAIETVYAAYLPKNTHPFLYLSLEISPQNVDVNVHPTKHEVHFLHEESILERVQQHIESKLIAMTNT*" | sed "s/.\{10\}/& /g" | xargs -d ' ' -n 6 echo -e
## 作用，便是将长字符串以固定长度【10bp】空格分隔，方便查看
## output：
MSFVAGVIRR LDETVVNRIA AGEVIQRPAN AIKEMIENCL DAKSTSIQVI VKEGGLKLIQ
IQDNGTGIRK EDLDIVCERF TTSKLQSFED LASISTYGFR GEALASISHV AHVTITTKTA
DGKCAYRASY SDGKLKAPPK PCAGNQGTQI TVEDLFYNIA TRRKALKNPS EEYGKILEVV
GRYSVHNAGI SFSVKKQGET VADVRTLPNA STVDNIRSIF GNAVSRELIE IGCEDKTLAF
KMNGYISNAN YSVKKCIFLL FINHRLVEST SLRKAIETVY AAYLPKNTHP FLYLSLEISP
QNVDVNVHPT KHEVHFLHEE SILERVQQHI ESKLIAMTNT *

13. jobs

查看当前环境的后台任务

1
$ jobs -l ## 同时查看后台任务的 PID 号

14. ping

待整理

15. 用户输入传参

当我们需要通过用户输入进行传参，这里有两种可选方案：read 和 xargs

15.1 read - 是常规用到的，通过用户键入字符读取参数

。。。。。【待整理】

15.2 xargs - 其单独使用的情况下，默认是 echo 的效果；

1
2
3
4
5
$ xargs find -name
"*.txt" (用户键入，并 Ctrl+d 退出)

## 等效于
$ find -name "*.txt"

16. tr

用户转换或删除给定字符串中的某个字符

1
2
3
$ cat a.txt | tr [:lower:] [:upper:]
## 将所有的小写字母替换成大写字母
## link：https://linux.cn/article-11983-1.html

17. printf

printf 作用同 echo，但可以有更多花样可以玩；这还得多多尝试

比如，当我们需要输出打印 n 个相同字符时，总不能自己数数吧？？？当然是通过一定的语法来输出，如下：

1
2
3
4
$ printf %.s"-" {1..100}

## output：【默认不断行】
----------------------------------------------------------------------------------------------------

18. jq

一个轻量级的命令行 JSON 处理器

link1：https://linux.cmsblogs.cn/c/jq.html

link2：https://cloud.tencent.com/developer/article/1614025

link3：https://www.cnblogs.com/kevingrace/p/7565371.html

19. toilet && figlet

一对在 Linux 终端整花活的难兄难弟。

1
2
$ echo "$(date '+%D %T' | toilet -f term -F border --gay)"
## 彩色时钟打印

20. loginctl

返回当前登录情况

1
2
3
4
5
6
$ loginctl list-sessions
## 列出当前 sessions
$ loginctl list-users
## 列出当前登录用户
$ loginctl show-user majunwei
## 显示指定用户的信息

21. eval

了解指定的参数在一起成为一个单一的可执行命令

对后面的命令进行两次扫描；简单来说就是对输出的变量进行执行，具体看下面的示例

1
2
3
4
5
6
7
8
$ test='echo "hello"'
$ echo $test
## output
echo "hello"
$ eval $test
## output
hello
## 不难发现的是，eval $变量 的作用便是将变量当成ming'lin

22. set

set 命令可显示打印出当前用户所设置的所有变量名与对应的值