标签：小结 which 技术 工作 现在 local 文件目录 ESS ffline
感谢参考原文-http://bjbsair.com/2020-04-01/tech-info/18440.html
你可能遇到一些棘手的问题，通过搜索得到想要的结果，但下次还是要通过搜索解决问题，这种低效的手段不是我们所想要的。典型的就是一个线上运维工程师，当问题来临时，不会给你留太多的现场学习时间。
为了达到更高效的训练，我们要做两件事情：第一，总结归纳；第二，触类旁通。Linux的命令也是如此，一个问题，通常会有多种解决方式，要通过变化找出其中的共性。
这涉及到一些设计者对于规范约定俗成的遵守。一般的，你只需要掌握一小部分命令，然后对大批命令达到了解的程度，就可以在命令行的世界里游刃有余。举个例子，你知道ls是列出文件目录，你就会联想到lscpu是列出cpu信息；lsmem是列出内存信息;lsblk是磁盘信息等。这种共性很多，比如top系列，stat系列。
在Linux上工作，是非常非常排斥二进制这种格式的，几乎什么都是可以读写的文本内容。大多数命令生成的结果，也都是文本文件。这些文件有一些特点，通常列与列都是通过空格或者
[root@localhost ~]# lsmem
RANGE SIZE STATE REMOVABLE BLOCK
0x0000000000000000-0x0000000007ffffff 128M online no 0
0x0000000008000000-0x000000000fffffff 128M online yes 1
0x0000000010000000-0x0000000017ffffff 128M online no 2
0x0000000018000000-0x0000000027ffffff 256M online yes 3-4
0x0000000028000000-0x000000004fffffff 640M online no 5-9
0x0000000050000000-0x000000005fffffff 256M online yes 10-11
0x0000000060000000-0x000000007fffffff 512M online no 12-15
Memory block size: 128M
Total online memory: 2G
Total offline memory: 0B
有一大批针对于行操作的命令，同样有一批针对于列操作的命令。然后，有两个集大成者，叫做sed、awk。由于这两个命令的内容非常多，我们将其列为单独的章节。
通常linux命令都十分简单，但是有些还是有些复杂度的。比如find，ps这种命令，如果要照顾到所有的场合，可能需要非常巨大的篇幅。但是，万一用到这种偏门的场合怎么办？
全面了解一下是非常有必要的，以便在使用的时候能够唤起记忆中最浅显的印象。然后剩下的，就可以交给类似于man的这种命令了。Linux上的每一个命令，都会有配套的帮助文件，这远比网络上那些转来转去的信息，正确的多。
正式介绍一下下面的两个命令：
注意：这些帮助信息，仅集中在命令的作用域本身。对于它的组合使用场景，并没有过多信息。也就是说，它教会了你怎么用，但并没有告诉你用它能够来做什么。
这些帮助命令，一般会通过高亮关键字，增加阅读的体验。但我们可以更近一步，把帮助文件变成彩色的。在root用户下，执行下面的命令。然后，重新登录虚拟机。
cat >> ~/.bashrc <<EOF
function man()
{
env \\
LESS_TERMCAP_mb=\$(printf "\e[1;31m") \\
LESS_TERMCAP_md=\$(printf "\e[1;31m") \\
LESS_TERMCAP_me=\$(printf "\e[0m") \\
LESS_TERMCAP_se=\$(printf "\e[0m") \\
LESS_TERMCAP_so=\$(printf "\e[1;44;33m") \\
LESS_TERMCAP_ue=\$(printf "\e[0m") \\
LESS_TERMCAP_us=\$(printf "\e[1;32m") \\
man "\$@"}
EOF
再次执行man命令，就可以看到彩色的信息了。
现在，在终端里，输入ca，然后快速按2次
[root@localhost ~]# ca
cacertdir_rehash cache_dump cache_repair cache_writeback ca-legacy capsh case catchsegv
cache_check cache_metadata_size cache_restore cal caller captoinfo cat catman
如果你对某个命令，只有模糊的印象，只记得前面的几个字母，这个功能是极好的，命令范围会一步步缩减。
为了开始下面的内容，我们首先介绍一下正则表达式。在前面的一些命令中，也可以使用这些正则表达式，比如less、grep等。
有些书籍，能够把正则表达式写成一本书，我们这里仅作简单的介绍，但足够用了。一般的，正则表达式能用在匹配上，还能够把匹配的内容拿来做二次利用。关于后者，我们在sed命令中介绍。
标志意义
^行首
$行尾
.任意单个字符
*匹配0个或者多个前面的字符
+1个或者多个匹配
?0个或者1个匹配
{m}前面的匹配重复m次
{m,n}前面的匹配重复m到n次
[]匹配一个指定范围内的字符
[^]匹配指定范围外的任意单个字符
\转义字符
[0-9]匹配括号中的任何一个字符,or的作用
``or，或者\b匹配一个单词。比如\blucky\b 只匹配单词lucky
使用下面的命令创建一个文件，我们练习一下grep命令加上E参数后的正则表现。
cat > 996 <<EOF
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
EOF
在终端执行下面命令，注意高亮的部分即为匹配到的字符串。
# 匹配996开头的行
[root@localhost ~]# cat 996 | grep -E ^996
996: 996 is a funcking thing . which make woman as man , man as ass .
# 匹配996结尾的行
[root@localhost ~]# cat 996 | grep -E 996$
we all on the bus , bus bus on the way . 996
# 匹配到icu和icuuuuuu
[root@localhost ~]# cat 996 | grep -E icu+
way to icu. icuuuuuu......
# 再次匹配到996
[root@localhost ~]# cat 996 | grep -E [0-9]
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
[root@localhost ~]# cat 996 | grep -E ^[\^0-9]
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有不包含996的行，良心命令，泪奔
[root@localhost ~]# cat 996 | grep -E -v [0-9]{3}
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配boss和icu
[root@localhost ~]# cat 996 | grep -E boss\|icu
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有行
[root@localhost ~]# cat 996 | grep -E .
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
正则表达式非常的重要，在一些sed脚本中，awk脚本中，甚至是vim编辑器中，都会简化你的操作。以上内容应该熟记，达到不需要查找文档的地步。
本小节是学习技巧方面的内容，但我们依然接触到一些硬核知识。这可能是除了正统的命令集合之外，最经常被使用的技巧了。接下来，我们介绍了一些简单的正则，这些正则可用用在很多命令中。我们还提供了一个把man命令变成彩色的小脚本，下面的文章中，会默认你已经把这一步给操作了。
彩色能够增加阅读效果（色盲除外）。
1、回过头去，执行一下man cat，是否发现了一个叫做tac的命令？它是干什么的？
2、上面提到的stat系列，你能想象iostat大体是干什么用的么？
3、grep -v是什么意思？
4、了解一下和mv非常像的rename命令来批量修改文件，看能否使用上面的正则。
5、有些命令如果拼写错误，如何快速修正？靠搜索么？了解一下fuck命令。我没有说错。
6、下面哪种写法表示如果cmd1成功执行，则执行cmd2命令？
咦？小王呢？
环顾四周，一片空空。别说罗马，小王都不见了。
你可能遇到一些棘手的问题，通过搜索得到想要的结果，但下次还是要通过搜索解决问题，这种低效的手段不是我们所想要的。典型的就是一个线上运维工程师，当问题来临时，不会给你留太多的现场学习时间。
为了达到更高效的训练，我们要做两件事情：第一，总结归纳；第二，触类旁通。Linux的命令也是如此，一个问题，通常会有多种解决方式，要通过变化找出其中的共性。
这涉及到一些设计者对于规范约定俗成的遵守。一般的，你只需要掌握一小部分命令，然后对大批命令达到了解的程度，就可以在命令行的世界里游刃有余。举个例子，你知道ls是列出文件目录，你就会联想到lscpu是列出cpu信息；lsmem是列出内存信息;lsblk是磁盘信息等。这种共性很多，比如top系列，stat系列。
在Linux上工作，是非常非常排斥二进制这种格式的，几乎什么都是可以读写的文本内容。大多数命令生成的结果，也都是文本文件。这些文件有一些特点，通常列与列都是通过空格或者
[root@localhost ~]# lsmem
RANGE SIZE STATE REMOVABLE BLOCK
0x0000000000000000-0x0000000007ffffff 128M online no 0
0x0000000008000000-0x000000000fffffff 128M online yes 1
0x0000000010000000-0x0000000017ffffff 128M online no 2
0x0000000018000000-0x0000000027ffffff 256M online yes 3-4
0x0000000028000000-0x000000004fffffff 640M online no 5-9
0x0000000050000000-0x000000005fffffff 256M online yes 10-11
0x0000000060000000-0x000000007fffffff 512M online no 12-15
Memory block size: 128M
Total online memory: 2G
Total offline memory: 0B
有一大批针对于行操作的命令，同样有一批针对于列操作的命令。然后，有两个集大成者，叫做sed、awk。由于这两个命令的内容非常多，我们将其列为单独的章节。
通常linux命令都十分简单，但是有些还是有些复杂度的。比如find，ps这种命令，如果要照顾到所有的场合，可能需要非常巨大的篇幅。但是，万一用到这种偏门的场合怎么办？
全面了解一下是非常有必要的，以便在使用的时候能够唤起记忆中最浅显的印象。然后剩下的，就可以交给类似于man的这种命令了。Linux上的每一个命令，都会有配套的帮助文件，这远比网络上那些转来转去的信息，正确的多。
正式介绍一下下面的两个命令：
注意：这些帮助信息，仅集中在命令的作用域本身。对于它的组合使用场景，并没有过多信息。也就是说，它教会了你怎么用，但并没有告诉你用它能够来做什么。
这些帮助命令，一般会通过高亮关键字，增加阅读的体验。但我们可以更近一步，把帮助文件变成彩色的。在root用户下，执行下面的命令。然后，重新登录虚拟机。
cat >> ~/.bashrc <<EOF
function man()
{
env \\
LESS_TERMCAP_mb=\$(printf "\e[1;31m") \\
LESS_TERMCAP_md=\$(printf "\e[1;31m") \\
LESS_TERMCAP_me=\$(printf "\e[0m") \\
LESS_TERMCAP_se=\$(printf "\e[0m") \\
LESS_TERMCAP_so=\$(printf "\e[1;44;33m") \\
LESS_TERMCAP_ue=\$(printf "\e[0m") \\
LESS_TERMCAP_us=\$(printf "\e[1;32m") \\
man "\$@"}
EOF
再次执行man命令，就可以看到彩色的信息了。
现在，在终端里，输入ca，然后快速按2次
[root@localhost ~]# ca
cacertdir_rehash cache_dump cache_repair cache_writeback ca-legacy capsh case catchsegv
cache_check cache_metadata_size cache_restore cal caller captoinfo cat catman
如果你对某个命令，只有模糊的印象，只记得前面的几个字母，这个功能是极好的，命令范围会一步步缩减。
为了开始下面的内容，我们首先介绍一下正则表达式。在前面的一些命令中，也可以使用这些正则表达式，比如less、grep等。
有些书籍，能够把正则表达式写成一本书，我们这里仅作简单的介绍，但足够用了。一般的，正则表达式能用在匹配上，还能够把匹配的内容拿来做二次利用。关于后者，我们在sed命令中介绍。
标志意义
^行首
$行尾
.任意单个字符
*匹配0个或者多个前面的字符
+1个或者多个匹配
?0个或者1个匹配
{m}前面的匹配重复m次
{m,n}前面的匹配重复m到n次
[]匹配一个指定范围内的字符
[^]匹配指定范围外的任意单个字符
\转义字符
[0-9]匹配括号中的任何一个字符,or的作用
``or，或者\b匹配一个单词。比如\blucky\b 只匹配单词lucky
使用下面的命令创建一个文件，我们练习一下grep命令加上E参数后的正则表现。
cat > 996 <<EOF
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
EOF
在终端执行下面命令，注意高亮的部分即为匹配到的字符串。
# 匹配996开头的行
[root@localhost ~]# cat 996 | grep -E ^996
996: 996 is a funcking thing . which make woman as man , man as ass .
# 匹配996结尾的行
[root@localhost ~]# cat 996 | grep -E 996$
we all on the bus , bus bus on the way . 996
# 匹配到icu和icuuuuuu
[root@localhost ~]# cat 996 | grep -E icu+
way to icu. icuuuuuu......
# 再次匹配到996
[root@localhost ~]# cat 996 | grep -E [0-9]
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
[root@localhost ~]# cat 996 | grep -E ^[\^0-9]
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有不包含996的行，良心命令，泪奔
[root@localhost ~]# cat 996 | grep -E -v [0-9]{3}
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配boss和icu
[root@localhost ~]# cat 996 | grep -E boss\|icu
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有行
[root@localhost ~]# cat 996 | grep -E .
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
正则表达式非常的重要，在一些sed脚本中，awk脚本中，甚至是vim编辑器中，都会简化你的操作。以上内容应该熟记，达到不需要查找文档的地步。
本小节是学习技巧方面的内容，但我们依然接触到一些硬核知识。这可能是除了正统的命令集合之外，最经常被使用的技巧了。接下来，我们介绍了一些简单的正则，这些正则可用用在很多命令中。我们还提供了一个把man命令变成彩色的小脚本，下面的文章中，会默认你已经把这一步给操作了。
彩色能够增加阅读效果（色盲除外）。
1、回过头去，执行一下man cat，是否发现了一个叫做tac的命令？它是干什么的？
2、上面提到的stat系列，你能想象iostat大体是干什么用的么？
3、grep -v是什么意思？
4、了解一下和mv非常像的rename命令来批量修改文件，看能否使用上面的正则。
5、有些命令如果拼写错误，如何快速修正？靠搜索么？了解一下fuck命令。我没有说错。
6、下面哪种写法表示如果cmd1成功执行，则执行cmd2命令？
咦？小王呢？
环顾四周，一片空空。别说罗马，小王都不见了。
你可能遇到一些棘手的问题，通过搜索得到想要的结果，但下次还是要通过搜索解决问题，这种低效的手段不是我们所想要的。典型的就是一个线上运维工程师，当问题来临时，不会给你留太多的现场学习时间。
为了达到更高效的训练，我们要做两件事情：第一，总结归纳；第二，触类旁通。Linux的命令也是如此，一个问题，通常会有多种解决方式，要通过变化找出其中的共性。
这涉及到一些设计者对于规范约定俗成的遵守。一般的，你只需要掌握一小部分命令，然后对大批命令达到了解的程度，就可以在命令行的世界里游刃有余。举个例子，你知道ls是列出文件目录，你就会联想到lscpu是列出cpu信息；lsmem是列出内存信息;lsblk是磁盘信息等。这种共性很多，比如top系列，stat系列。
在Linux上工作，是非常非常排斥二进制这种格式的，几乎什么都是可以读写的文本内容。大多数命令生成的结果，也都是文本文件。这些文件有一些特点，通常列与列都是通过空格或者
[root@localhost ~]# lsmem
RANGE SIZE STATE REMOVABLE BLOCK
0x0000000000000000-0x0000000007ffffff 128M online no 0
0x0000000008000000-0x000000000fffffff 128M online yes 1
0x0000000010000000-0x0000000017ffffff 128M online no 2
0x0000000018000000-0x0000000027ffffff 256M online yes 3-4
0x0000000028000000-0x000000004fffffff 640M online no 5-9
0x0000000050000000-0x000000005fffffff 256M online yes 10-11
0x0000000060000000-0x000000007fffffff 512M online no 12-15
Memory block size: 128M
Total online memory: 2G
Total offline memory: 0B
有一大批针对于行操作的命令，同样有一批针对于列操作的命令。然后，有两个集大成者，叫做sed、awk。由于这两个命令的内容非常多，我们将其列为单独的章节。
通常linux命令都十分简单，但是有些还是有些复杂度的。比如find，ps这种命令，如果要照顾到所有的场合，可能需要非常巨大的篇幅。但是，万一用到这种偏门的场合怎么办？
全面了解一下是非常有必要的，以便在使用的时候能够唤起记忆中最浅显的印象。然后剩下的，就可以交给类似于man的这种命令了。Linux上的每一个命令，都会有配套的帮助文件，这远比网络上那些转来转去的信息，正确的多。
正式介绍一下下面的两个命令：
注意：这些帮助信息，仅集中在命令的作用域本身。对于它的组合使用场景，并没有过多信息。也就是说，它教会了你怎么用，但并没有告诉你用它能够来做什么。
这些帮助命令，一般会通过高亮关键字，增加阅读的体验。但我们可以更近一步，把帮助文件变成彩色的。在root用户下，执行下面的命令。然后，重新登录虚拟机。
cat >> ~/.bashrc <<EOF
function man()
{
env \\
LESS_TERMCAP_mb=\$(printf "\e[1;31m") \\
LESS_TERMCAP_md=\$(printf "\e[1;31m") \\
LESS_TERMCAP_me=\$(printf "\e[0m") \\
LESS_TERMCAP_se=\$(printf "\e[0m") \\
LESS_TERMCAP_so=\$(printf "\e[1;44;33m") \\
LESS_TERMCAP_ue=\$(printf "\e[0m") \\
LESS_TERMCAP_us=\$(printf "\e[1;32m") \\
man "\$@"}
EOF
再次执行man命令，就可以看到彩色的信息了。
现在，在终端里，输入ca，然后快速按2次
[root@localhost ~]# ca
cacertdir_rehash cache_dump cache_repair cache_writeback ca-legacy capsh case catchsegv
cache_check cache_metadata_size cache_restore cal caller captoinfo cat catman
如果你对某个命令，只有模糊的印象，只记得前面的几个字母，这个功能是极好的，命令范围会一步步缩减。
为了开始下面的内容，我们首先介绍一下正则表达式。在前面的一些命令中，也可以使用这些正则表达式，比如less、grep等。
有些书籍，能够把正则表达式写成一本书，我们这里仅作简单的介绍，但足够用了。一般的，正则表达式能用在匹配上，还能够把匹配的内容拿来做二次利用。关于后者，我们在sed命令中介绍。
标志意义
^行首
$行尾
.任意单个字符
*匹配0个或者多个前面的字符
+1个或者多个匹配
?0个或者1个匹配
{m}前面的匹配重复m次
{m,n}前面的匹配重复m到n次
[]匹配一个指定范围内的字符
[^]匹配指定范围外的任意单个字符
\转义字符
[0-9]匹配括号中的任何一个字符,or的作用
``or，或者\b匹配一个单词。比如\blucky\b 只匹配单词lucky
使用下面的命令创建一个文件，我们练习一下grep命令加上E参数后的正则表现。
cat > 996 <<EOF
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
EOF
在终端执行下面命令，注意高亮的部分即为匹配到的字符串。
# 匹配996开头的行
[root@localhost ~]# cat 996 | grep -E ^996
996: 996 is a funcking thing . which make woman as man , man as ass .
# 匹配996结尾的行
[root@localhost ~]# cat 996 | grep -E 996$
we all on the bus , bus bus on the way . 996
# 匹配到icu和icuuuuuu
[root@localhost ~]# cat 996 | grep -E icu+
way to icu. icuuuuuu......
# 再次匹配到996
[root@localhost ~]# cat 996 | grep -E [0-9]
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
[root@localhost ~]# cat 996 | grep -E ^[\^0-9]
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有不包含996的行，良心命令，泪奔
[root@localhost ~]# cat 996 | grep -E -v [0-9]{3}
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配boss和icu
[root@localhost ~]# cat 996 | grep -E boss\|icu
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有行
[root@localhost ~]# cat 996 | grep -E .
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
正则表达式非常的重要，在一些sed脚本中，awk脚本中，甚至是vim编辑器中，都会简化你的操作。以上内容应该熟记，达到不需要查找文档的地步。
本小节是学习技巧方面的内容，但我们依然接触到一些硬核知识。这可能是除了正统的命令集合之外，最经常被使用的技巧了。接下来，我们介绍了一些简单的正则，这些正则可用用在很多命令中。我们还提供了一个把man命令变成彩色的小脚本，下面的文章中，会默认你已经把这一步给操作了。
彩色能够增加阅读效果（色盲除外）。
1、回过头去，执行一下man cat，是否发现了一个叫做tac的命令？它是干什么的？
2、上面提到的stat系列，你能想象iostat大体是干什么用的么？
3、grep -v是什么意思？
4、了解一下和mv非常像的rename命令来批量修改文件，看能否使用上面的正则。
5、有些命令如果拼写错误，如何快速修正？靠搜索么？了解一下fuck命令。我没有说错。
6、下面哪种写法表示如果cmd1成功执行，则执行cmd2命令？
咦？小王呢？
环顾四周，一片空空。别说罗马，小王都不见了。
你可能遇到一些棘手的问题，通过搜索得到想要的结果，但下次还是要通过搜索解决问题，这种低效的手段不是我们所想要的。典型的就是一个线上运维工程师，当问题来临时，不会给你留太多的现场学习时间。
为了达到更高效的训练，我们要做两件事情：第一，总结归纳；第二，触类旁通。Linux的命令也是如此，一个问题，通常会有多种解决方式，要通过变化找出其中的共性。
这涉及到一些设计者对于规范约定俗成的遵守。一般的，你只需要掌握一小部分命令，然后对大批命令达到了解的程度，就可以在命令行的世界里游刃有余。举个例子，你知道ls是列出文件目录，你就会联想到lscpu是列出cpu信息；lsmem是列出内存信息;lsblk是磁盘信息等。这种共性很多，比如top系列，stat系列。
在Linux上工作，是非常非常排斥二进制这种格式的，几乎什么都是可以读写的文本内容。大多数命令生成的结果，也都是文本文件。这些文件有一些特点，通常列与列都是通过空格或者
[root@localhost ~]# lsmem
RANGE SIZE STATE REMOVABLE BLOCK
0x0000000000000000-0x0000000007ffffff 128M online no 0
0x0000000008000000-0x000000000fffffff 128M online yes 1
0x0000000010000000-0x0000000017ffffff 128M online no 2
0x0000000018000000-0x0000000027ffffff 256M online yes 3-4
0x0000000028000000-0x000000004fffffff 640M online no 5-9
0x0000000050000000-0x000000005fffffff 256M online yes 10-11
0x0000000060000000-0x000000007fffffff 512M online no 12-15
Memory block size: 128M
Total online memory: 2G
Total offline memory: 0B
有一大批针对于行操作的命令，同样有一批针对于列操作的命令。然后，有两个集大成者，叫做sed、awk。由于这两个命令的内容非常多，我们将其列为单独的章节。
通常linux命令都十分简单，但是有些还是有些复杂度的。比如find，ps这种命令，如果要照顾到所有的场合，可能需要非常巨大的篇幅。但是，万一用到这种偏门的场合怎么办？
全面了解一下是非常有必要的，以便在使用的时候能够唤起记忆中最浅显的印象。然后剩下的，就可以交给类似于man的这种命令了。Linux上的每一个命令，都会有配套的帮助文件，这远比网络上那些转来转去的信息，正确的多。
正式介绍一下下面的两个命令：
注意：这些帮助信息，仅集中在命令的作用域本身。对于它的组合使用场景，并没有过多信息。也就是说，它教会了你怎么用，但并没有告诉你用它能够来做什么。
这些帮助命令，一般会通过高亮关键字，增加阅读的体验。但我们可以更近一步，把帮助文件变成彩色的。在root用户下，执行下面的命令。然后，重新登录虚拟机。
cat >> ~/.bashrc <<EOF
function man()
{
env \\
LESS_TERMCAP_mb=\$(printf "\e[1;31m") \\
LESS_TERMCAP_md=\$(printf "\e[1;31m") \\
LESS_TERMCAP_me=\$(printf "\e[0m") \\
LESS_TERMCAP_se=\$(printf "\e[0m") \\
LESS_TERMCAP_so=\$(printf "\e[1;44;33m") \\
LESS_TERMCAP_ue=\$(printf "\e[0m") \\
LESS_TERMCAP_us=\$(printf "\e[1;32m") \\
man "\$@"}
EOF
再次执行man命令，就可以看到彩色的信息了。
现在，在终端里，输入ca，然后快速按2次
[root@localhost ~]# ca
cacertdir_rehash cache_dump cache_repair cache_writeback ca-legacy capsh case catchsegv
cache_check cache_metadata_size cache_restore cal caller captoinfo cat catman
如果你对某个命令，只有模糊的印象，只记得前面的几个字母，这个功能是极好的，命令范围会一步步缩减。
为了开始下面的内容，我们首先介绍一下正则表达式。在前面的一些命令中，也可以使用这些正则表达式，比如less、grep等。
有些书籍，能够把正则表达式写成一本书，我们这里仅作简单的介绍，但足够用了。一般的，正则表达式能用在匹配上，还能够把匹配的内容拿来做二次利用。关于后者，我们在sed命令中介绍。
标志意义
^行首
$行尾
.任意单个字符
*匹配0个或者多个前面的字符
+1个或者多个匹配
?0个或者1个匹配
{m}前面的匹配重复m次
{m,n}前面的匹配重复m到n次
[]匹配一个指定范围内的字符
[^]匹配指定范围外的任意单个字符
\转义字符
[0-9]匹配括号中的任何一个字符,or的作用
``or，或者\b匹配一个单词。比如\blucky\b 只匹配单词lucky
使用下面的命令创建一个文件，我们练习一下grep命令加上E参数后的正则表现。
cat > 996 <<EOF
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
EOF
在终端执行下面命令，注意高亮的部分即为匹配到的字符串。
# 匹配996开头的行
[root@localhost ~]# cat 996 | grep -E ^996
996: 996 is a funcking thing . which make woman as man , man as ass .
# 匹配996结尾的行
[root@localhost ~]# cat 996 | grep -E 996$
we all on the bus , bus bus on the way . 996
# 匹配到icu和icuuuuuu
[root@localhost ~]# cat 996 | grep -E icu+
way to icu. icuuuuuu......
# 再次匹配到996
[root@localhost ~]# cat 996 | grep -E [0-9]
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
[root@localhost ~]# cat 996 | grep -E ^[\^0-9]
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有不包含996的行，良心命令，泪奔
[root@localhost ~]# cat 996 | grep -E -v [0-9]{3}
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配boss和icu
[root@localhost ~]# cat 996 | grep -E boss\|icu
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有行
[root@localhost ~]# cat 996 | grep -E .
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
正则表达式非常的重要，在一些sed脚本中，awk脚本中，甚至是vim编辑器中，都会简化你的操作。以上内容应该熟记，达到不需要查找文档的地步。
本小节是学习技巧方面的内容，但我们依然接触到一些硬核知识。这可能是除了正统的命令集合之外，最经常被使用的技巧了。接下来，我们介绍了一些简单的正则，这些正则可用用在很多命令中。我们还提供了一个把man命令变成彩色的小脚本，下面的文章中，会默认你已经把这一步给操作了。
彩色能够增加阅读效果（色盲除外）。
1、回过头去，执行一下man cat，是否发现了一个叫做tac的命令？它是干什么的？
2、上面提到的stat系列，你能想象iostat大体是干什么用的么？
3、grep -v是什么意思？
4、了解一下和mv非常像的rename命令来批量修改文件，看能否使用上面的正则。
5、有些命令如果拼写错误，如何快速修正？靠搜索么？了解一下fuck命令。我没有说错。
6、下面哪种写法表示如果cmd1成功执行，则执行cmd2命令？
咦？小王呢？
环顾四周，一片空空。别说罗马，小王都不见了。
你可能遇到一些棘手的问题，通过搜索得到想要的结果，但下次还是要通过搜索解决问题，这种低效的手段不是我们所想要的。典型的就是一个线上运维工程师，当问题来临时，不会给你留太多的现场学习时间。
为了达到更高效的训练，我们要做两件事情：第一，总结归纳；第二，触类旁通。Linux的命令也是如此，一个问题，通常会有多种解决方式，要通过变化找出其中的共性。
这涉及到一些设计者对于规范约定俗成的遵守。一般的，你只需要掌握一小部分命令，然后对大批命令达到了解的程度，就可以在命令行的世界里游刃有余。举个例子，你知道ls是列出文件目录，你就会联想到lscpu是列出cpu信息；lsmem是列出内存信息;lsblk是磁盘信息等。这种共性很多，比如top系列，stat系列。
在Linux上工作，是非常非常排斥二进制这种格式的，几乎什么都是可以读写的文本内容。大多数命令生成的结果，也都是文本文件。这些文件有一些特点，通常列与列都是通过空格或者
[root@localhost ~]# lsmem
RANGE SIZE STATE REMOVABLE BLOCK
0x0000000000000000-0x0000000007ffffff 128M online no 0
0x0000000008000000-0x000000000fffffff 128M online yes 1
0x0000000010000000-0x0000000017ffffff 128M online no 2
0x0000000018000000-0x0000000027ffffff 256M online yes 3-4
0x0000000028000000-0x000000004fffffff 640M online no 5-9
0x0000000050000000-0x000000005fffffff 256M online yes 10-11
0x0000000060000000-0x000000007fffffff 512M online no 12-15
Memory block size: 128M
Total online memory: 2G
Total offline memory: 0B
有一大批针对于行操作的命令，同样有一批针对于列操作的命令。然后，有两个集大成者，叫做sed、awk。由于这两个命令的内容非常多，我们将其列为单独的章节。
通常linux命令都十分简单，但是有些还是有些复杂度的。比如find，ps这种命令，如果要照顾到所有的场合，可能需要非常巨大的篇幅。但是，万一用到这种偏门的场合怎么办？
全面了解一下是非常有必要的，以便在使用的时候能够唤起记忆中最浅显的印象。然后剩下的，就可以交给类似于man的这种命令了。Linux上的每一个命令，都会有配套的帮助文件，这远比网络上那些转来转去的信息，正确的多。
正式介绍一下下面的两个命令：
注意：这些帮助信息，仅集中在命令的作用域本身。对于它的组合使用场景，并没有过多信息。也就是说，它教会了你怎么用，但并没有告诉你用它能够来做什么。
这些帮助命令，一般会通过高亮关键字，增加阅读的体验。但我们可以更近一步，把帮助文件变成彩色的。在root用户下，执行下面的命令。然后，重新登录虚拟机。
cat >> ~/.bashrc <<EOF
function man()
{
env \\
LESS_TERMCAP_mb=\$(printf "\e[1;31m") \\
LESS_TERMCAP_md=\$(printf "\e[1;31m") \\
LESS_TERMCAP_me=\$(printf "\e[0m") \\
LESS_TERMCAP_se=\$(printf "\e[0m") \\
LESS_TERMCAP_so=\$(printf "\e[1;44;33m") \\
LESS_TERMCAP_ue=\$(printf "\e[0m") \\
LESS_TERMCAP_us=\$(printf "\e[1;32m") \\
man "\$@"}
EOF
再次执行man命令，就可以看到彩色的信息了。
现在，在终端里，输入ca，然后快速按2次
[root@localhost ~]# ca
cacertdir_rehash cache_dump cache_repair cache_writeback ca-legacy capsh case catchsegv
cache_check cache_metadata_size cache_restore cal caller captoinfo cat catman
如果你对某个命令，只有模糊的印象，只记得前面的几个字母，这个功能是极好的，命令范围会一步步缩减。
为了开始下面的内容，我们首先介绍一下正则表达式。在前面的一些命令中，也可以使用这些正则表达式，比如less、grep等。
有些书籍，能够把正则表达式写成一本书，我们这里仅作简单的介绍，但足够用了。一般的，正则表达式能用在匹配上，还能够把匹配的内容拿来做二次利用。关于后者，我们在sed命令中介绍。
标志意义
^行首
$行尾
.任意单个字符
*匹配0个或者多个前面的字符
+1个或者多个匹配
?0个或者1个匹配
{m}前面的匹配重复m次
{m,n}前面的匹配重复m到n次
[]匹配一个指定范围内的字符
[^]匹配指定范围外的任意单个字符
\转义字符
[0-9]匹配括号中的任何一个字符,or的作用
``or，或者\b匹配一个单词。比如\blucky\b 只匹配单词lucky
使用下面的命令创建一个文件，我们练习一下grep命令加上E参数后的正则表现。
cat > 996 <<EOF
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
EOF
在终端执行下面命令，注意高亮的部分即为匹配到的字符串。
# 匹配996开头的行
[root@localhost ~]# cat 996 | grep -E ^996
996: 996 is a funcking thing . which make woman as man , man as ass .
# 匹配996结尾的行
[root@localhost ~]# cat 996 | grep -E 996$
we all on the bus , bus bus on the way . 996
# 匹配到icu和icuuuuuu
[root@localhost ~]# cat 996 | grep -E icu+
way to icu. icuuuuuu......
# 再次匹配到996
[root@localhost ~]# cat 996 | grep -E [0-9]
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
[root@localhost ~]# cat 996 | grep -E ^[\^0-9]
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有不包含996的行，良心命令，泪奔
[root@localhost ~]# cat 996 | grep -E -v [0-9]{3}
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配boss和icu
[root@localhost ~]# cat 996 | grep -E boss\|icu
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有行
[root@localhost ~]# cat 996 | grep -E .
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
正则表达式非常的重要，在一些sed脚本中，awk脚本中，甚至是vim编辑器中，都会简化你的操作。以上内容应该熟记，达到不需要查找文档的地步。
本小节是学习技巧方面的内容，但我们依然接触到一些硬核知识。这可能是除了正统的命令集合之外，最经常被使用的技巧了。接下来，我们介绍了一些简单的正则，这些正则可用用在很多命令中。我们还提供了一个把man命令变成彩色的小脚本，下面的文章中，会默认你已经把这一步给操作了。
彩色能够增加阅读效果（色盲除外）。
1、回过头去，执行一下man cat，是否发现了一个叫做tac的命令？它是干什么的？
2、上面提到的stat系列，你能想象iostat大体是干什么用的么？
3、grep -v是什么意思？
4、了解一下和mv非常像的rename命令来批量修改文件，看能否使用上面的正则。
5、有些命令如果拼写错误，如何快速修正？靠搜索么？了解一下fuck命令。我没有说错。
6、下面哪种写法表示如果cmd1成功执行，则执行cmd2命令？
咦？小王呢？
环顾四周，一片空空。别说罗马，小王都不见了。
你可能遇到一些棘手的问题，通过搜索得到想要的结果，但下次还是要通过搜索解决问题，这种低效的手段不是我们所想要的。典型的就是一个线上运维工程师，当问题来临时，不会给你留太多的现场学习时间。
为了达到更高效的训练，我们要做两件事情：第一，总结归纳；第二，触类旁通。Linux的命令也是如此，一个问题，通常会有多种解决方式，要通过变化找出其中的共性。
这涉及到一些设计者对于规范约定俗成的遵守。一般的，你只需要掌握一小部分命令，然后对大批命令达到了解的程度，就可以在命令行的世界里游刃有余。举个例子，你知道ls是列出文件目录，你就会联想到lscpu是列出cpu信息；lsmem是列出内存信息;lsblk是磁盘信息等。这种共性很多，比如top系列，stat系列。
在Linux上工作，是非常非常排斥二进制这种格式的，几乎什么都是可以读写的文本内容。大多数命令生成的结果，也都是文本文件。这些文件有一些特点，通常列与列都是通过空格或者
[root@localhost ~]# lsmem
RANGE SIZE STATE REMOVABLE BLOCK
0x0000000000000000-0x0000000007ffffff 128M online no 0
0x0000000008000000-0x000000000fffffff 128M online yes 1
0x0000000010000000-0x0000000017ffffff 128M online no 2
0x0000000018000000-0x0000000027ffffff 256M online yes 3-4
0x0000000028000000-0x000000004fffffff 640M online no 5-9
0x0000000050000000-0x000000005fffffff 256M online yes 10-11
0x0000000060000000-0x000000007fffffff 512M online no 12-15
Memory block size: 128M
Total online memory: 2G
Total offline memory: 0B
有一大批针对于行操作的命令，同样有一批针对于列操作的命令。然后，有两个集大成者，叫做sed、awk。由于这两个命令的内容非常多，我们将其列为单独的章节。
通常linux命令都十分简单，但是有些还是有些复杂度的。比如find，ps这种命令，如果要照顾到所有的场合，可能需要非常巨大的篇幅。但是，万一用到这种偏门的场合怎么办？
全面了解一下是非常有必要的，以便在使用的时候能够唤起记忆中最浅显的印象。然后剩下的，就可以交给类似于man的这种命令了。Linux上的每一个命令，都会有配套的帮助文件，这远比网络上那些转来转去的信息，正确的多。
正式介绍一下下面的两个命令：
注意：这些帮助信息，仅集中在命令的作用域本身。对于它的组合使用场景，并没有过多信息。也就是说，它教会了你怎么用，但并没有告诉你用它能够来做什么。
这些帮助命令，一般会通过高亮关键字，增加阅读的体验。但我们可以更近一步，把帮助文件变成彩色的。在root用户下，执行下面的命令。然后，重新登录虚拟机。
cat >> ~/.bashrc <<EOF
function man()
{
env \\
LESS_TERMCAP_mb=\$(printf "\e[1;31m") \\
LESS_TERMCAP_md=\$(printf "\e[1;31m") \\
LESS_TERMCAP_me=\$(printf "\e[0m") \\
LESS_TERMCAP_se=\$(printf "\e[0m") \\
LESS_TERMCAP_so=\$(printf "\e[1;44;33m") \\
LESS_TERMCAP_ue=\$(printf "\e[0m") \\
LESS_TERMCAP_us=\$(printf "\e[1;32m") \\
man "\$@"}
EOF
再次执行man命令，就可以看到彩色的信息了。
现在，在终端里，输入ca，然后快速按2次
[root@localhost ~]# ca
cacertdir_rehash cache_dump cache_repair cache_writeback ca-legacy capsh case catchsegv
cache_check cache_metadata_size cache_restore cal caller captoinfo cat catman
如果你对某个命令，只有模糊的印象，只记得前面的几个字母，这个功能是极好的，命令范围会一步步缩减。
为了开始下面的内容，我们首先介绍一下正则表达式。在前面的一些命令中，也可以使用这些正则表达式，比如less、grep等。
有些书籍，能够把正则表达式写成一本书，我们这里仅作简单的介绍，但足够用了。一般的，正则表达式能用在匹配上，还能够把匹配的内容拿来做二次利用。关于后者，我们在sed命令中介绍。
标志意义
^行首
$行尾
.任意单个字符
*匹配0个或者多个前面的字符
+1个或者多个匹配
?0个或者1个匹配
{m}前面的匹配重复m次
{m,n}前面的匹配重复m到n次
[]匹配一个指定范围内的字符
[^]匹配指定范围外的任意单个字符
\转义字符
[0-9]匹配括号中的任何一个字符,or的作用
``or，或者\b匹配一个单词。比如\blucky\b 只匹配单词lucky
使用下面的命令创建一个文件，我们练习一下grep命令加上E参数后的正则表现。
cat > 996 <<EOF
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
EOF
在终端执行下面命令，注意高亮的部分即为匹配到的字符串。
# 匹配996开头的行
[root@localhost ~]# cat 996 | grep -E ^996
996: 996 is a funcking thing . which make woman as man , man as ass .
# 匹配996结尾的行
[root@localhost ~]# cat 996 | grep -E 996$
we all on the bus , bus bus on the way . 996
# 匹配到icu和icuuuuuu
[root@localhost ~]# cat 996 | grep -E icu+
way to icu. icuuuuuu......
# 再次匹配到996
[root@localhost ~]# cat 996 | grep -E [0-9]
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
[root@localhost ~]# cat 996 | grep -E ^[\^0-9]
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有不包含996的行，良心命令，泪奔
[root@localhost ~]# cat 996 | grep -E -v [0-9]{3}
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配boss和icu
[root@localhost ~]# cat 996 | grep -E boss\|icu
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有行
[root@localhost ~]# cat 996 | grep -E .
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
正则表达式非常的重要，在一些sed脚本中，awk脚本中，甚至是vim编辑器中，都会简化你的操作。以上内容应该熟记，达到不需要查找文档的地步。
本小节是学习技巧方面的内容，但我们依然接触到一些硬核知识。这可能是除了正统的命令集合之外，最经常被使用的技巧了。接下来，我们介绍了一些简单的正则，这些正则可用用在很多命令中。我们还提供了一个把man命令变成彩色的小脚本，下面的文章中，会默认你已经把这一步给操作了。
彩色能够增加阅读效果（色盲除外）。
1、回过头去，执行一下man cat，是否发现了一个叫做tac的命令？它是干什么的？
2、上面提到的stat系列，你能想象iostat大体是干什么用的么？
3、grep -v是什么意思？
4、了解一下和mv非常像的rename命令来批量修改文件，看能否使用上面的正则。
5、有些命令如果拼写错误，如何快速修正？靠搜索么？了解一下fuck命令。我没有说错。
6、下面哪种写法表示如果cmd1成功执行，则执行cmd2命令？
咦？小王呢？
环顾四周，一片空空。别说罗马，小王都不见了。
你可能遇到一些棘手的问题，通过搜索得到想要的结果，但下次还是要通过搜索解决问题，这种低效的手段不是我们所想要的。典型的就是一个线上运维工程师，当问题来临时，不会给你留太多的现场学习时间。
为了达到更高效的训练，我们要做两件事情：第一，总结归纳；第二，触类旁通。Linux的命令也是如此，一个问题，通常会有多种解决方式，要通过变化找出其中的共性。
这涉及到一些设计者对于规范约定俗成的遵守。一般的，你只需要掌握一小部分命令，然后对大批命令达到了解的程度，就可以在命令行的世界里游刃有余。举个例子，你知道ls是列出文件目录，你就会联想到lscpu是列出cpu信息；lsmem是列出内存信息;lsblk是磁盘信息等。这种共性很多，比如top系列，stat系列。
在Linux上工作，是非常非常排斥二进制这种格式的，几乎什么都是可以读写的文本内容。大多数命令生成的结果，也都是文本文件。这些文件有一些特点，通常列与列都是通过空格或者
[root@localhost ~]# lsmem
RANGE SIZE STATE REMOVABLE BLOCK
0x0000000000000000-0x0000000007ffffff 128M online no 0
0x0000000008000000-0x000000000fffffff 128M online yes 1
0x0000000010000000-0x0000000017ffffff 128M online no 2
0x0000000018000000-0x0000000027ffffff 256M online yes 3-4
0x0000000028000000-0x000000004fffffff 640M online no 5-9
0x0000000050000000-0x000000005fffffff 256M online yes 10-11
0x0000000060000000-0x000000007fffffff 512M online no 12-15
Memory block size: 128M
Total online memory: 2G
Total offline memory: 0B
有一大批针对于行操作的命令，同样有一批针对于列操作的命令。然后，有两个集大成者，叫做sed、awk。由于这两个命令的内容非常多，我们将其列为单独的章节。
通常linux命令都十分简单，但是有些还是有些复杂度的。比如find，ps这种命令，如果要照顾到所有的场合，可能需要非常巨大的篇幅。但是，万一用到这种偏门的场合怎么办？
全面了解一下是非常有必要的，以便在使用的时候能够唤起记忆中最浅显的印象。然后剩下的，就可以交给类似于man的这种命令了。Linux上的每一个命令，都会有配套的帮助文件，这远比网络上那些转来转去的信息，正确的多。
正式介绍一下下面的两个命令：
注意：这些帮助信息，仅集中在命令的作用域本身。对于它的组合使用场景，并没有过多信息。也就是说，它教会了你怎么用，但并没有告诉你用它能够来做什么。
这些帮助命令，一般会通过高亮关键字，增加阅读的体验。但我们可以更近一步，把帮助文件变成彩色的。在root用户下，执行下面的命令。然后，重新登录虚拟机。
cat >> ~/.bashrc <<EOF
function man()
{
env \\
LESS_TERMCAP_mb=\$(printf "\e[1;31m") \\
LESS_TERMCAP_md=\$(printf "\e[1;31m") \\
LESS_TERMCAP_me=\$(printf "\e[0m") \\
LESS_TERMCAP_se=\$(printf "\e[0m") \\
LESS_TERMCAP_so=\$(printf "\e[1;44;33m") \\
LESS_TERMCAP_ue=\$(printf "\e[0m") \\
LESS_TERMCAP_us=\$(printf "\e[1;32m") \\
man "\$@"}
EOF
再次执行man命令，就可以看到彩色的信息了。
现在，在终端里，输入ca，然后快速按2次
[root@localhost ~]# ca
cacertdir_rehash cache_dump cache_repair cache_writeback ca-legacy capsh case catchsegv
cache_check cache_metadata_size cache_restore cal caller captoinfo cat catman
如果你对某个命令，只有模糊的印象，只记得前面的几个字母，这个功能是极好的，命令范围会一步步缩减。
为了开始下面的内容，我们首先介绍一下正则表达式。在前面的一些命令中，也可以使用这些正则表达式，比如less、grep等。
有些书籍，能够把正则表达式写成一本书，我们这里仅作简单的介绍，但足够用了。一般的，正则表达式能用在匹配上，还能够把匹配的内容拿来做二次利用。关于后者，我们在sed命令中介绍。
标志意义
^行首
$行尾
.任意单个字符
*匹配0个或者多个前面的字符
+1个或者多个匹配
?0个或者1个匹配
{m}前面的匹配重复m次
{m,n}前面的匹配重复m到n次
[]匹配一个指定范围内的字符
[^]匹配指定范围外的任意单个字符
\转义字符
[0-9]匹配括号中的任何一个字符,or的作用
``or，或者\b匹配一个单词。比如\blucky\b 只匹配单词lucky
使用下面的命令创建一个文件，我们练习一下grep命令加上E参数后的正则表现。
cat > 996 <<EOF
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
EOF
在终端执行下面命令，注意高亮的部分即为匹配到的字符串。
# 匹配996开头的行
[root@localhost ~]# cat 996 | grep -E ^996
996: 996 is a funcking thing . which make woman as man , man as ass .
# 匹配996结尾的行
[root@localhost ~]# cat 996 | grep -E 996$
we all on the bus , bus bus on the way . 996
# 匹配到icu和icuuuuuu
[root@localhost ~]# cat 996 | grep -E icu+
way to icu. icuuuuuu......
# 再次匹配到996
[root@localhost ~]# cat 996 | grep -E [0-9]
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
[root@localhost ~]# cat 996 | grep -E ^[\^0-9]
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有不包含996的行，良心命令，泪奔
[root@localhost ~]# cat 996 | grep -E -v [0-9]{3}
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配boss和icu
[root@localhost ~]# cat 996 | grep -E boss\|icu
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有行
[root@localhost ~]# cat 996 | grep -E .
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
正则表达式非常的重要，在一些sed脚本中，awk脚本中，甚至是vim编辑器中，都会简化你的操作。以上内容应该熟记，达到不需要查找文档的地步。
本小节是学习技巧方面的内容，但我们依然接触到一些硬核知识。这可能是除了正统的命令集合之外，最经常被使用的技巧了。接下来，我们介绍了一些简单的正则，这些正则可用用在很多命令中。我们还提供了一个把man命令变成彩色的小脚本，下面的文章中，会默认你已经把这一步给操作了。
彩色能够增加阅读效果（色盲除外）。
1、回过头去，执行一下man cat，是否发现了一个叫做tac的命令？它是干什么的？
2、上面提到的stat系列，你能想象iostat大体是干什么用的么？
3、grep -v是什么意思？
4、了解一下和mv非常像的rename命令来批量修改文件，看能否使用上面的正则。
5、有些命令如果拼写错误，如何快速修正？靠搜索么？了解一下fuck命令。我没有说错。
6、下面哪种写法表示如果cmd1成功执行，则执行cmd2命令？
咦？小王呢？
环顾四周，一片空空。别说罗马，小王都不见了。
你可能遇到一些棘手的问题，通过搜索得到想要的结果，但下次还是要通过搜索解决问题，这种低效的手段不是我们所想要的。典型的就是一个线上运维工程师，当问题来临时，不会给你留太多的现场学习时间。
为了达到更高效的训练，我们要做两件事情：第一，总结归纳；第二，触类旁通。Linux的命令也是如此，一个问题，通常会有多种解决方式，要通过变化找出其中的共性。
这涉及到一些设计者对于规范约定俗成的遵守。一般的，你只需要掌握一小部分命令，然后对大批命令达到了解的程度，就可以在命令行的世界里游刃有余。举个例子，你知道ls是列出文件目录，你就会联想到lscpu是列出cpu信息；lsmem是列出内存信息;lsblk是磁盘信息等。这种共性很多，比如top系列，stat系列。
在Linux上工作，是非常非常排斥二进制这种格式的，几乎什么都是可以读写的文本内容。大多数命令生成的结果，也都是文本文件。这些文件有一些特点，通常列与列都是通过空格或者
[root@localhost ~]# lsmem
RANGE SIZE STATE REMOVABLE BLOCK
0x0000000000000000-0x0000000007ffffff 128M online no 0
0x0000000008000000-0x000000000fffffff 128M online yes 1
0x0000000010000000-0x0000000017ffffff 128M online no 2
0x0000000018000000-0x0000000027ffffff 256M online yes 3-4
0x0000000028000000-0x000000004fffffff 640M online no 5-9
0x0000000050000000-0x000000005fffffff 256M online yes 10-11
0x0000000060000000-0x000000007fffffff 512M online no 12-15
Memory block size: 128M
Total online memory: 2G
Total offline memory: 0B
有一大批针对于行操作的命令，同样有一批针对于列操作的命令。然后，有两个集大成者，叫做sed、awk。由于这两个命令的内容非常多，我们将其列为单独的章节。
通常linux命令都十分简单，但是有些还是有些复杂度的。比如find，ps这种命令，如果要照顾到所有的场合，可能需要非常巨大的篇幅。但是，万一用到这种偏门的场合怎么办？
全面了解一下是非常有必要的，以便在使用的时候能够唤起记忆中最浅显的印象。然后剩下的，就可以交给类似于man的这种命令了。Linux上的每一个命令，都会有配套的帮助文件，这远比网络上那些转来转去的信息，正确的多。
正式介绍一下下面的两个命令：
注意：这些帮助信息，仅集中在命令的作用域本身。对于它的组合使用场景，并没有过多信息。也就是说，它教会了你怎么用，但并没有告诉你用它能够来做什么。
这些帮助命令，一般会通过高亮关键字，增加阅读的体验。但我们可以更近一步，把帮助文件变成彩色的。在root用户下，执行下面的命令。然后，重新登录虚拟机。
cat >> ~/.bashrc <<EOF
function man()
{
env \\
LESS_TERMCAP_mb=\$(printf "\e[1;31m") \\
LESS_TERMCAP_md=\$(printf "\e[1;31m") \\
LESS_TERMCAP_me=\$(printf "\e[0m") \\
LESS_TERMCAP_se=\$(printf "\e[0m") \\
LESS_TERMCAP_so=\$(printf "\e[1;44;33m") \\
LESS_TERMCAP_ue=\$(printf "\e[0m") \\
LESS_TERMCAP_us=\$(printf "\e[1;32m") \\
man "\$@"}
EOF
再次执行man命令，就可以看到彩色的信息了。
现在，在终端里，输入ca，然后快速按2次
[root@localhost ~]# ca
cacertdir_rehash cache_dump cache_repair cache_writeback ca-legacy capsh case catchsegv
cache_check cache_metadata_size cache_restore cal caller captoinfo cat catman
如果你对某个命令，只有模糊的印象，只记得前面的几个字母，这个功能是极好的，命令范围会一步步缩减。
为了开始下面的内容，我们首先介绍一下正则表达式。在前面的一些命令中，也可以使用这些正则表达式，比如less、grep等。
有些书籍，能够把正则表达式写成一本书，我们这里仅作简单的介绍，但足够用了。一般的，正则表达式能用在匹配上，还能够把匹配的内容拿来做二次利用。关于后者，我们在sed命令中介绍。
标志意义
^行首
$行尾
.任意单个字符
*匹配0个或者多个前面的字符
+1个或者多个匹配
?0个或者1个匹配
{m}前面的匹配重复m次
{m,n}前面的匹配重复m到n次
[]匹配一个指定范围内的字符
[^]匹配指定范围外的任意单个字符
\转义字符
[0-9]匹配括号中的任何一个字符,or的作用
``or，或者\b匹配一个单词。比如\blucky\b 只匹配单词lucky
使用下面的命令创建一个文件，我们练习一下grep命令加上E参数后的正则表现。
cat > 996 <<EOF
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
EOF
在终端执行下面命令，注意高亮的部分即为匹配到的字符串。
# 匹配996开头的行
[root@localhost ~]# cat 996 | grep -E ^996
996: 996 is a funcking thing . which make woman as man , man as ass .
# 匹配996结尾的行
[root@localhost ~]# cat 996 | grep -E 996$
we all on the bus , bus bus on the way . 996
# 匹配到icu和icuuuuuu
[root@localhost ~]# cat 996 | grep -E icu+
way to icu. icuuuuuu......
# 再次匹配到996
[root@localhost ~]# cat 996 | grep -E [0-9]
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
[root@localhost ~]# cat 996 | grep -E ^[\^0-9]
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有不包含996的行，良心命令，泪奔
[root@localhost ~]# cat 996 | grep -E -v [0-9]{3}
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配boss和icu
[root@localhost ~]# cat 996 | grep -E boss\|icu
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有行
[root@localhost ~]# cat 996 | grep -E .
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
正则表达式非常的重要，在一些sed脚本中，awk脚本中，甚至是vim编辑器中，都会简化你的操作。以上内容应该熟记，达到不需要查找文档的地步。
本小节是学习技巧方面的内容，但我们依然接触到一些硬核知识。这可能是除了正统的命令集合之外，最经常被使用的技巧了。接下来，我们介绍了一些简单的正则，这些正则可用用在很多命令中。我们还提供了一个把man命令变成彩色的小脚本，下面的文章中，会默认你已经把这一步给操作了。
彩色能够增加阅读效果（色盲除外）。
1、回过头去，执行一下man cat，是否发现了一个叫做tac的命令？它是干什么的？
2、上面提到的stat系列，你能想象iostat大体是干什么用的么？
3、grep -v是什么意思？
4、了解一下和mv非常像的rename命令来批量修改文件，看能否使用上面的正则。
5、有些命令如果拼写错误，如何快速修正？靠搜索么？了解一下fuck命令。我没有说错。
6、下面哪种写法表示如果cmd1成功执行，则执行cmd2命令？
咦？小王呢？
环顾四周，一片空空。别说罗马，小王都不见了。
你可能遇到一些棘手的问题，通过搜索得到想要的结果，但下次还是要通过搜索解决问题，这种低效的手段不是我们所想要的。典型的就是一个线上运维工程师，当问题来临时，不会给你留太多的现场学习时间。
为了达到更高效的训练，我们要做两件事情：第一，总结归纳；第二，触类旁通。Linux的命令也是如此，一个问题，通常会有多种解决方式，要通过变化找出其中的共性。
这涉及到一些设计者对于规范约定俗成的遵守。一般的，你只需要掌握一小部分命令，然后对大批命令达到了解的程度，就可以在命令行的世界里游刃有余。举个例子，你知道ls是列出文件目录，你就会联想到lscpu是列出cpu信息；lsmem是列出内存信息;lsblk是磁盘信息等。这种共性很多，比如top系列，stat系列。
在Linux上工作，是非常非常排斥二进制这种格式的，几乎什么都是可以读写的文本内容。大多数命令生成的结果，也都是文本文件。这些文件有一些特点，通常列与列都是通过空格或者
[root@localhost ~]# lsmem
RANGE SIZE STATE REMOVABLE BLOCK
0x0000000000000000-0x0000000007ffffff 128M online no 0
0x0000000008000000-0x000000000fffffff 128M online yes 1
0x0000000010000000-0x0000000017ffffff 128M online no 2
0x0000000018000000-0x0000000027ffffff 256M online yes 3-4
0x0000000028000000-0x000000004fffffff 640M online no 5-9
0x0000000050000000-0x000000005fffffff 256M online yes 10-11
0x0000000060000000-0x000000007fffffff 512M online no 12-15
Memory block size: 128M
Total online memory: 2G
Total offline memory: 0B
有一大批针对于行操作的命令，同样有一批针对于列操作的命令。然后，有两个集大成者，叫做sed、awk。由于这两个命令的内容非常多，我们将其列为单独的章节。
通常linux命令都十分简单，但是有些还是有些复杂度的。比如find，ps这种命令，如果要照顾到所有的场合，可能需要非常巨大的篇幅。但是，万一用到这种偏门的场合怎么办？
全面了解一下是非常有必要的，以便在使用的时候能够唤起记忆中最浅显的印象。然后剩下的，就可以交给类似于man的这种命令了。Linux上的每一个命令，都会有配套的帮助文件，这远比网络上那些转来转去的信息，正确的多。
正式介绍一下下面的两个命令：
注意：这些帮助信息，仅集中在命令的作用域本身。对于它的组合使用场景，并没有过多信息。也就是说，它教会了你怎么用，但并没有告诉你用它能够来做什么。
这些帮助命令，一般会通过高亮关键字，增加阅读的体验。但我们可以更近一步，把帮助文件变成彩色的。在root用户下，执行下面的命令。然后，重新登录虚拟机。
cat >> ~/.bashrc <<EOF
function man()
{
env \\
LESS_TERMCAP_mb=\$(printf "\e[1;31m") \\
LESS_TERMCAP_md=\$(printf "\e[1;31m") \\
LESS_TERMCAP_me=\$(printf "\e[0m") \\
LESS_TERMCAP_se=\$(printf "\e[0m") \\
LESS_TERMCAP_so=\$(printf "\e[1;44;33m") \\
LESS_TERMCAP_ue=\$(printf "\e[0m") \\
LESS_TERMCAP_us=\$(printf "\e[1;32m") \\
man "\$@"}
EOF
再次执行man命令，就可以看到彩色的信息了。
现在，在终端里，输入ca，然后快速按2次
[root@localhost ~]# ca
cacertdir_rehash cache_dump cache_repair cache_writeback ca-legacy capsh case catchsegv
cache_check cache_metadata_size cache_restore cal caller captoinfo cat catman
如果你对某个命令，只有模糊的印象，只记得前面的几个字母，这个功能是极好的，命令范围会一步步缩减。
为了开始下面的内容，我们首先介绍一下正则表达式。在前面的一些命令中，也可以使用这些正则表达式，比如less、grep等。
有些书籍，能够把正则表达式写成一本书，我们这里仅作简单的介绍，但足够用了。一般的，正则表达式能用在匹配上，还能够把匹配的内容拿来做二次利用。关于后者，我们在sed命令中介绍。
标志意义
^行首
$行尾
.任意单个字符
*匹配0个或者多个前面的字符
+1个或者多个匹配
?0个或者1个匹配
{m}前面的匹配重复m次
{m,n}前面的匹配重复m到n次
[]匹配一个指定范围内的字符
[^]匹配指定范围外的任意单个字符
\转义字符
[0-9]匹配括号中的任何一个字符,or的作用
``or，或者\b匹配一个单词。比如\blucky\b 只匹配单词lucky
使用下面的命令创建一个文件，我们练习一下grep命令加上E参数后的正则表现。
cat > 996 <<EOF
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
EOF
在终端执行下面命令，注意高亮的部分即为匹配到的字符串。
# 匹配996开头的行
[root@localhost ~]# cat 996 | grep -E ^996
996: 996 is a funcking thing . which make woman as man , man as ass .
# 匹配996结尾的行
[root@localhost ~]# cat 996 | grep -E 996$
we all on the bus , bus bus on the way . 996
# 匹配到icu和icuuuuuu
[root@localhost ~]# cat 996 | grep -E icu+
way to icu. icuuuuuu......
# 再次匹配到996
[root@localhost ~]# cat 996 | grep -E [0-9]
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
[root@localhost ~]# cat 996 | grep -E ^[\^0-9]
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有不包含996的行，良心命令，泪奔
[root@localhost ~]# cat 996 | grep -E -v [0-9]{3}
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配boss和icu
[root@localhost ~]# cat 996 | grep -E boss\|icu
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有行
[root@localhost ~]# cat 996 | grep -E .
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
正则表达式非常的重要，在一些sed脚本中，awk脚本中，甚至是vim编辑器中，都会简化你的操作。以上内容应该熟记，达到不需要查找文档的地步。
本小节是学习技巧方面的内容，但我们依然接触到一些硬核知识。这可能是除了正统的命令集合之外，最经常被使用的技巧了。接下来，我们介绍了一些简单的正则，这些正则可用用在很多命令中。我们还提供了一个把man命令变成彩色的小脚本，下面的文章中，会默认你已经把这一步给操作了。
彩色能够增加阅读效果（色盲除外）。
1、回过头去，执行一下man cat，是否发现了一个叫做tac的命令？它是干什么的？
2、上面提到的stat系列，你能想象iostat大体是干什么用的么？
3、grep -v是什么意思？
4、了解一下和mv非常像的rename命令来批量修改文件，看能否使用上面的正则。
5、有些命令如果拼写错误，如何快速修正？靠搜索么？了解一下fuck命令。我没有说错。
6、下面哪种写法表示如果cmd1成功执行，则执行cmd2命令？
咦？小王呢？
环顾四周，一片空空。别说罗马，小王都不见了。
你可能遇到一些棘手的问题，通过搜索得到想要的结果，但下次还是要通过搜索解决问题，这种低效的手段不是我们所想要的。典型的就是一个线上运维工程师，当问题来临时，不会给你留太多的现场学习时间。
为了达到更高效的训练，我们要做两件事情：第一，总结归纳；第二，触类旁通。Linux的命令也是如此，一个问题，通常会有多种解决方式，要通过变化找出其中的共性。
这涉及到一些设计者对于规范约定俗成的遵守。一般的，你只需要掌握一小部分命令，然后对大批命令达到了解的程度，就可以在命令行的世界里游刃有余。举个例子，你知道ls是列出文件目录，你就会联想到lscpu是列出cpu信息；lsmem是列出内存信息;lsblk是磁盘信息等。这种共性很多，比如top系列，stat系列。
在Linux上工作，是非常非常排斥二进制这种格式的，几乎什么都是可以读写的文本内容。大多数命令生成的结果，也都是文本文件。这些文件有一些特点，通常列与列都是通过空格或者
[root@localhost ~]# lsmem
RANGE SIZE STATE REMOVABLE BLOCK
0x0000000000000000-0x0000000007ffffff 128M online no 0
0x0000000008000000-0x000000000fffffff 128M online yes 1
0x0000000010000000-0x0000000017ffffff 128M online no 2
0x0000000018000000-0x0000000027ffffff 256M online yes 3-4
0x0000000028000000-0x000000004fffffff 640M online no 5-9
0x0000000050000000-0x000000005fffffff 256M online yes 10-11
0x0000000060000000-0x000000007fffffff 512M online no 12-15
Memory block size: 128M
Total online memory: 2G
Total offline memory: 0B
有一大批针对于行操作的命令，同样有一批针对于列操作的命令。然后，有两个集大成者，叫做sed、awk。由于这两个命令的内容非常多，我们将其列为单独的章节。
通常linux命令都十分简单，但是有些还是有些复杂度的。比如find，ps这种命令，如果要照顾到所有的场合，可能需要非常巨大的篇幅。但是，万一用到这种偏门的场合怎么办？
全面了解一下是非常有必要的，以便在使用的时候能够唤起记忆中最浅显的印象。然后剩下的，就可以交给类似于man的这种命令了。Linux上的每一个命令，都会有配套的帮助文件，这远比网络上那些转来转去的信息，正确的多。
正式介绍一下下面的两个命令：
注意：这些帮助信息，仅集中在命令的作用域本身。对于它的组合使用场景，并没有过多信息。也就是说，它教会了你怎么用，但并没有告诉你用它能够来做什么。
这些帮助命令，一般会通过高亮关键字，增加阅读的体验。但我们可以更近一步，把帮助文件变成彩色的。在root用户下，执行下面的命令。然后，重新登录虚拟机。
cat >> ~/.bashrc <<EOF
function man()
{
env \\
LESS_TERMCAP_mb=\$(printf "\e[1;31m") \\
LESS_TERMCAP_md=\$(printf "\e[1;31m") \\
LESS_TERMCAP_me=\$(printf "\e[0m") \\
LESS_TERMCAP_se=\$(printf "\e[0m") \\
LESS_TERMCAP_so=\$(printf "\e[1;44;33m") \\
LESS_TERMCAP_ue=\$(printf "\e[0m") \\
LESS_TERMCAP_us=\$(printf "\e[1;32m") \\
man "\$@"}
EOF
再次执行man命令，就可以看到彩色的信息了。
现在，在终端里，输入ca，然后快速按2次
[root@localhost ~]# ca
cacertdir_rehash cache_dump cache_repair cache_writeback ca-legacy capsh case catchsegv
cache_check cache_metadata_size cache_restore cal caller captoinfo cat catman
如果你对某个命令，只有模糊的印象，只记得前面的几个字母，这个功能是极好的，命令范围会一步步缩减。
为了开始下面的内容，我们首先介绍一下正则表达式。在前面的一些命令中，也可以使用这些正则表达式，比如less、grep等。
有些书籍，能够把正则表达式写成一本书，我们这里仅作简单的介绍，但足够用了。一般的，正则表达式能用在匹配上，还能够把匹配的内容拿来做二次利用。关于后者，我们在sed命令中介绍。
标志意义
^行首
$行尾
.任意单个字符
*匹配0个或者多个前面的字符
+1个或者多个匹配
?0个或者1个匹配
{m}前面的匹配重复m次
{m,n}前面的匹配重复m到n次
[]匹配一个指定范围内的字符
[^]匹配指定范围外的任意单个字符
\转义字符
[0-9]匹配括号中的任何一个字符,or的作用
``or，或者\b匹配一个单词。比如\blucky\b 只匹配单词lucky
使用下面的命令创建一个文件，我们练习一下grep命令加上E参数后的正则表现。
cat > 996 <<EOF
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
EOF
在终端执行下面命令，注意高亮的部分即为匹配到的字符串。
# 匹配996开头的行
[root@localhost ~]# cat 996 | grep -E ^996
996: 996 is a funcking thing . which make woman as man , man as ass .
# 匹配996结尾的行
[root@localhost ~]# cat 996 | grep -E 996$
we all on the bus , bus bus on the way . 996
# 匹配到icu和icuuuuuu
[root@localhost ~]# cat 996 | grep -E icu+
way to icu. icuuuuuu......
# 再次匹配到996
[root@localhost ~]# cat 996 | grep -E [0-9]
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
[root@localhost ~]# cat 996 | grep -E ^[\^0-9]
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有不包含996的行，良心命令，泪奔
[root@localhost ~]# cat 996 | grep -E -v [0-9]{3}
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配boss和icu
[root@localhost ~]# cat 996 | grep -E boss\|icu
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有行
[root@localhost ~]# cat 996 | grep -E .
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
正则表达式非常的重要，在一些sed脚本中，awk脚本中，甚至是vim编辑器中，都会简化你的操作。以上内容应该熟记，达到不需要查找文档的地步。
本小节是学习技巧方面的内容，但我们依然接触到一些硬核知识。这可能是除了正统的命令集合之外，最经常被使用的技巧了。接下来，我们介绍了一些简单的正则，这些正则可用用在很多命令中。我们还提供了一个把man命令变成彩色的小脚本，下面的文章中，会默认你已经把这一步给操作了。
彩色能够增加阅读效果（色盲除外）。
1、回过头去，执行一下man cat，是否发现了一个叫做tac的命令？它是干什么的？
2、上面提到的stat系列，你能想象iostat大体是干什么用的么？
3、grep -v是什么意思？
4、了解一下和mv非常像的rename命令来批量修改文件，看能否使用上面的正则。
5、有些命令如果拼写错误，如何快速修正？靠搜索么？了解一下fuck命令。我没有说错。
6、下面哪种写法表示如果cmd1成功执行，则执行cmd2命令？
咦？小王呢？
环顾四周，一片空空。别说罗马，小王都不见了。
你可能遇到一些棘手的问题，通过搜索得到想要的结果，但下次还是要通过搜索解决问题，这种低效的手段不是我们所想要的。典型的就是一个线上运维工程师，当问题来临时，不会给你留太多的现场学习时间。
为了达到更高效的训练，我们要做两件事情：第一，总结归纳；第二，触类旁通。Linux的命令也是如此，一个问题，通常会有多种解决方式，要通过变化找出其中的共性。
这涉及到一些设计者对于规范约定俗成的遵守。一般的，你只需要掌握一小部分命令，然后对大批命令达到了解的程度，就可以在命令行的世界里游刃有余。举个例子，你知道ls是列出文件目录，你就会联想到lscpu是列出cpu信息；lsmem是列出内存信息;lsblk是磁盘信息等。这种共性很多，比如top系列，stat系列。
在Linux上工作，是非常非常排斥二进制这种格式的，几乎什么都是可以读写的文本内容。大多数命令生成的结果，也都是文本文件。这些文件有一些特点，通常列与列都是通过空格或者
[root@localhost ~]# lsmem
RANGE SIZE STATE REMOVABLE BLOCK
0x0000000000000000-0x0000000007ffffff 128M online no 0
0x0000000008000000-0x000000000fffffff 128M online yes 1
0x0000000010000000-0x0000000017ffffff 128M online no 2
0x0000000018000000-0x0000000027ffffff 256M online yes 3-4
0x0000000028000000-0x000000004fffffff 640M online no 5-9
0x0000000050000000-0x000000005fffffff 256M online yes 10-11
0x0000000060000000-0x000000007fffffff 512M online no 12-15
Memory block size: 128M
Total online memory: 2G
Total offline memory: 0B
有一大批针对于行操作的命令，同样有一批针对于列操作的命令。然后，有两个集大成者，叫做sed、awk。由于这两个命令的内容非常多，我们将其列为单独的章节。
通常linux命令都十分简单，但是有些还是有些复杂度的。比如find，ps这种命令，如果要照顾到所有的场合，可能需要非常巨大的篇幅。但是，万一用到这种偏门的场合怎么办？
全面了解一下是非常有必要的，以便在使用的时候能够唤起记忆中最浅显的印象。然后剩下的，就可以交给类似于man的这种命令了。Linux上的每一个命令，都会有配套的帮助文件，这远比网络上那些转来转去的信息，正确的多。
正式介绍一下下面的两个命令：
注意：这些帮助信息，仅集中在命令的作用域本身。对于它的组合使用场景，并没有过多信息。也就是说，它教会了你怎么用，但并没有告诉你用它能够来做什么。
这些帮助命令，一般会通过高亮关键字，增加阅读的体验。但我们可以更近一步，把帮助文件变成彩色的。在root用户下，执行下面的命令。然后，重新登录虚拟机。
cat >> ~/.bashrc <<EOF
function man()
{
env \\
LESS_TERMCAP_mb=\$(printf "\e[1;31m") \\
LESS_TERMCAP_md=\$(printf "\e[1;31m") \\
LESS_TERMCAP_me=\$(printf "\e[0m") \\
LESS_TERMCAP_se=\$(printf "\e[0m") \\
LESS_TERMCAP_so=\$(printf "\e[1;44;33m") \\
LESS_TERMCAP_ue=\$(printf "\e[0m") \\
LESS_TERMCAP_us=\$(printf "\e[1;32m") \\
man "\$@"}
EOF
再次执行man命令，就可以看到彩色的信息了。
现在，在终端里，输入ca，然后快速按2次
[root@localhost ~]# ca
cacertdir_rehash cache_dump cache_repair cache_writeback ca-legacy capsh case catchsegv
cache_check cache_metadata_size cache_restore cal caller captoinfo cat catman
如果你对某个命令，只有模糊的印象，只记得前面的几个字母，这个功能是极好的，命令范围会一步步缩减。
为了开始下面的内容，我们首先介绍一下正则表达式。在前面的一些命令中，也可以使用这些正则表达式，比如less、grep等。
有些书籍，能够把正则表达式写成一本书，我们这里仅作简单的介绍，但足够用了。一般的，正则表达式能用在匹配上，还能够把匹配的内容拿来做二次利用。关于后者，我们在sed命令中介绍。
标志意义
^行首
$行尾
.任意单个字符
*匹配0个或者多个前面的字符
+1个或者多个匹配
?0个或者1个匹配
{m}前面的匹配重复m次
{m,n}前面的匹配重复m到n次
[]匹配一个指定范围内的字符
[^]匹配指定范围外的任意单个字符
\转义字符
[0-9]匹配括号中的任何一个字符,or的作用
``or，或者\b匹配一个单词。比如\blucky\b 只匹配单词lucky
使用下面的命令创建一个文件，我们练习一下grep命令加上E参数后的正则表现。
cat > 996 <<EOF
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
EOF
在终端执行下面命令，注意高亮的部分即为匹配到的字符串。
# 匹配996开头的行
[root@localhost ~]# cat 996 | grep -E ^996
996: 996 is a funcking thing . which make woman as man , man as ass .
# 匹配996结尾的行
[root@localhost ~]# cat 996 | grep -E 996$
we all on the bus , bus bus on the way . 996
# 匹配到icu和icuuuuuu
[root@localhost ~]# cat 996 | grep -E icu+
way to icu. icuuuuuu......
# 再次匹配到996
[root@localhost ~]# cat 996 | grep -E [0-9]
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
[root@localhost ~]# cat 996 | grep -E ^[\^0-9]
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有不包含996的行，良心命令，泪奔
[root@localhost ~]# cat 996 | grep -E -v [0-9]{3}
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配boss和icu
[root@localhost ~]# cat 996 | grep -E boss\|icu
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有行
[root@localhost ~]# cat 996 | grep -E .
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
正则表达式非常的重要，在一些sed脚本中，awk脚本中，甚至是vim编辑器中，都会简化你的操作。以上内容应该熟记，达到不需要查找文档的地步。
本小节是学习技巧方面的内容，但我们依然接触到一些硬核知识。这可能是除了正统的命令集合之外，最经常被使用的技巧了。接下来，我们介绍了一些简单的正则，这些正则可用用在很多命令中。我们还提供了一个把man命令变成彩色的小脚本，下面的文章中，会默认你已经把这一步给操作了。
彩色能够增加阅读效果（色盲除外）。
1、回过头去，执行一下man cat，是否发现了一个叫做tac的命令？它是干什么的？
2、上面提到的stat系列，你能想象iostat大体是干什么用的么？
3、grep -v是什么意思？
4、了解一下和mv非常像的rename命令来批量修改文件，看能否使用上面的正则。
5、有些命令如果拼写错误，如何快速修正？靠搜索么？了解一下fuck命令。我没有说错。
6、下面哪种写法表示如果cmd1成功执行，则执行cmd2命令？
咦？小王呢？
环顾四周，一片空空。别说罗马，小王都不见了。
你可能遇到一些棘手的问题，通过搜索得到想要的结果，但下次还是要通过搜索解决问题，这种低效的手段不是我们所想要的。典型的就是一个线上运维工程师，当问题来临时，不会给你留太多的现场学习时间。
为了达到更高效的训练，我们要做两件事情：第一，总结归纳；第二，触类旁通。Linux的命令也是如此，一个问题，通常会有多种解决方式，要通过变化找出其中的共性。
这涉及到一些设计者对于规范约定俗成的遵守。一般的，你只需要掌握一小部分命令，然后对大批命令达到了解的程度，就可以在命令行的世界里游刃有余。举个例子，你知道ls是列出文件目录，你就会联想到lscpu是列出cpu信息；lsmem是列出内存信息;lsblk是磁盘信息等。这种共性很多，比如top系列，stat系列。
在Linux上工作，是非常非常排斥二进制这种格式的，几乎什么都是可以读写的文本内容。大多数命令生成的结果，也都是文本文件。这些文件有一些特点，通常列与列都是通过空格或者
[root@localhost ~]# lsmem
RANGE SIZE STATE REMOVABLE BLOCK
0x0000000000000000-0x0000000007ffffff 128M online no 0
0x0000000008000000-0x000000000fffffff 128M online yes 1
0x0000000010000000-0x0000000017ffffff 128M online no 2
0x0000000018000000-0x0000000027ffffff 256M online yes 3-4
0x0000000028000000-0x000000004fffffff 640M online no 5-9
0x0000000050000000-0x000000005fffffff 256M online yes 10-11
0x0000000060000000-0x000000007fffffff 512M online no 12-15
Memory block size: 128M
Total online memory: 2G
Total offline memory: 0B
有一大批针对于行操作的命令，同样有一批针对于列操作的命令。然后，有两个集大成者，叫做sed、awk。由于这两个命令的内容非常多，我们将其列为单独的章节。
通常linux命令都十分简单，但是有些还是有些复杂度的。比如find，ps这种命令，如果要照顾到所有的场合，可能需要非常巨大的篇幅。但是，万一用到这种偏门的场合怎么办？
全面了解一下是非常有必要的，以便在使用的时候能够唤起记忆中最浅显的印象。然后剩下的，就可以交给类似于man的这种命令了。Linux上的每一个命令，都会有配套的帮助文件，这远比网络上那些转来转去的信息，正确的多。
正式介绍一下下面的两个命令：
注意：这些帮助信息，仅集中在命令的作用域本身。对于它的组合使用场景，并没有过多信息。也就是说，它教会了你怎么用，但并没有告诉你用它能够来做什么。
这些帮助命令，一般会通过高亮关键字，增加阅读的体验。但我们可以更近一步，把帮助文件变成彩色的。在root用户下，执行下面的命令。然后，重新登录虚拟机。
cat >> ~/.bashrc <<EOF
function man()
{
env \\
LESS_TERMCAP_mb=\$(printf "\e[1;31m") \\
LESS_TERMCAP_md=\$(printf "\e[1;31m") \\
LESS_TERMCAP_me=\$(printf "\e[0m") \\
LESS_TERMCAP_se=\$(printf "\e[0m") \\
LESS_TERMCAP_so=\$(printf "\e[1;44;33m") \\
LESS_TERMCAP_ue=\$(printf "\e[0m") \\
LESS_TERMCAP_us=\$(printf "\e[1;32m") \\
man "\$@"}
EOF
再次执行man命令，就可以看到彩色的信息了。
现在，在终端里，输入ca，然后快速按2次
[root@localhost ~]# ca
cacertdir_rehash cache_dump cache_repair cache_writeback ca-legacy capsh case catchsegv
cache_check cache_metadata_size cache_restore cal caller captoinfo cat catman
如果你对某个命令，只有模糊的印象，只记得前面的几个字母，这个功能是极好的，命令范围会一步步缩减。
为了开始下面的内容，我们首先介绍一下正则表达式。在前面的一些命令中，也可以使用这些正则表达式，比如less、grep等。
有些书籍，能够把正则表达式写成一本书，我们这里仅作简单的介绍，但足够用了。一般的，正则表达式能用在匹配上，还能够把匹配的内容拿来做二次利用。关于后者，我们在sed命令中介绍。
标志意义
^行首
$行尾
.任意单个字符
*匹配0个或者多个前面的字符
+1个或者多个匹配
?0个或者1个匹配
{m}前面的匹配重复m次
{m,n}前面的匹配重复m到n次
[]匹配一个指定范围内的字符
[^]匹配指定范围外的任意单个字符
\转义字符
[0-9]匹配括号中的任何一个字符,or的作用
``or，或者\b匹配一个单词。比如\blucky\b 只匹配单词lucky
使用下面的命令创建一个文件，我们练习一下grep命令加上E参数后的正则表现。
cat > 996 <<EOF
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
EOF
在终端执行下面命令，注意高亮的部分即为匹配到的字符串。
# 匹配996开头的行
[root@localhost ~]# cat 996 | grep -E ^996
996: 996 is a funcking thing . which make woman as man , man as ass .
# 匹配996结尾的行
[root@localhost ~]# cat 996 | grep -E 996$
we all on the bus , bus bus on the way . 996
# 匹配到icu和icuuuuuu
[root@localhost ~]# cat 996 | grep -E icu+
way to icu. icuuuuuu......
# 再次匹配到996
[root@localhost ~]# cat 996 | grep -E [0-9]
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
[root@localhost ~]# cat 996 | grep -E ^[\^0-9]
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有不包含996的行，良心命令，泪奔
[root@localhost ~]# cat 996 | grep -E -v [0-9]{3}
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配boss和icu
[root@localhost ~]# cat 996 | grep -E boss\|icu
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有行
[root@localhost ~]# cat 996 | grep -E .
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
正则表达式非常的重要，在一些sed脚本中，awk脚本中，甚至是vim编辑器中，都会简化你的操作。以上内容应该熟记，达到不需要查找文档的地步。
本小节是学习技巧方面的内容，但我们依然接触到一些硬核知识。这可能是除了正统的命令集合之外，最经常被使用的技巧了。接下来，我们介绍了一些简单的正则，这些正则可用用在很多命令中。我们还提供了一个把man命令变成彩色的小脚本，下面的文章中，会默认你已经把这一步给操作了。
彩色能够增加阅读效果（色盲除外）。
1、回过头去，执行一下man cat，是否发现了一个叫做tac的命令？它是干什么的？
2、上面提到的stat系列，你能想象iostat大体是干什么用的么？
3、grep -v是什么意思？
4、了解一下和mv非常像的rename命令来批量修改文件，看能否使用上面的正则。
5、有些命令如果拼写错误，如何快速修正？靠搜索么？了解一下fuck命令。我没有说错。
6、下面哪种写法表示如果cmd1成功执行，则执行cmd2命令？
咦？小王呢？
环顾四周，一片空空。别说罗马，小王都不见了。
你可能遇到一些棘手的问题，通过搜索得到想要的结果，但下次还是要通过搜索解决问题，这种低效的手段不是我们所想要的。典型的就是一个线上运维工程师，当问题来临时，不会给你留太多的现场学习时间。
为了达到更高效的训练，我们要做两件事情：第一，总结归纳；第二，触类旁通。Linux的命令也是如此，一个问题，通常会有多种解决方式，要通过变化找出其中的共性。
这涉及到一些设计者对于规范约定俗成的遵守。一般的，你只需要掌握一小部分命令，然后对大批命令达到了解的程度，就可以在命令行的世界里游刃有余。举个例子，你知道ls是列出文件目录，你就会联想到lscpu是列出cpu信息；lsmem是列出内存信息;lsblk是磁盘信息等。这种共性很多，比如top系列，stat系列。
在Linux上工作，是非常非常排斥二进制这种格式的，几乎什么都是可以读写的文本内容。大多数命令生成的结果，也都是文本文件。这些文件有一些特点，通常列与列都是通过空格或者
[root@localhost ~]# lsmem
RANGE SIZE STATE REMOVABLE BLOCK
0x0000000000000000-0x0000000007ffffff 128M online no 0
0x0000000008000000-0x000000000fffffff 128M online yes 1
0x0000000010000000-0x0000000017ffffff 128M online no 2
0x0000000018000000-0x0000000027ffffff 256M online yes 3-4
0x0000000028000000-0x000000004fffffff 640M online no 5-9
0x0000000050000000-0x000000005fffffff 256M online yes 10-11
0x0000000060000000-0x000000007fffffff 512M online no 12-15
Memory block size: 128M
Total online memory: 2G
Total offline memory: 0B
有一大批针对于行操作的命令，同样有一批针对于列操作的命令。然后，有两个集大成者，叫做sed、awk。由于这两个命令的内容非常多，我们将其列为单独的章节。
通常linux命令都十分简单，但是有些还是有些复杂度的。比如find，ps这种命令，如果要照顾到所有的场合，可能需要非常巨大的篇幅。但是，万一用到这种偏门的场合怎么办？
全面了解一下是非常有必要的，以便在使用的时候能够唤起记忆中最浅显的印象。然后剩下的，就可以交给类似于man的这种命令了。Linux上的每一个命令，都会有配套的帮助文件，这远比网络上那些转来转去的信息，正确的多。
正式介绍一下下面的两个命令：
注意：这些帮助信息，仅集中在命令的作用域本身。对于它的组合使用场景，并没有过多信息。也就是说，它教会了你怎么用，但并没有告诉你用它能够来做什么。
这些帮助命令，一般会通过高亮关键字，增加阅读的体验。但我们可以更近一步，把帮助文件变成彩色的。在root用户下，执行下面的命令。然后，重新登录虚拟机。
cat >> ~/.bashrc <<EOF
function man()
{
env \\
LESS_TERMCAP_mb=\$(printf "\e[1;31m") \\
LESS_TERMCAP_md=\$(printf "\e[1;31m") \\
LESS_TERMCAP_me=\$(printf "\e[0m") \\
LESS_TERMCAP_se=\$(printf "\e[0m") \\
LESS_TERMCAP_so=\$(printf "\e[1;44;33m") \\
LESS_TERMCAP_ue=\$(printf "\e[0m") \\
LESS_TERMCAP_us=\$(printf "\e[1;32m") \\
man "\$@"}
EOF
再次执行man命令，就可以看到彩色的信息了。
现在，在终端里，输入ca，然后快速按2次
[root@localhost ~]# ca
cacertdir_rehash cache_dump cache_repair cache_writeback ca-legacy capsh case catchsegv
cache_check cache_metadata_size cache_restore cal caller captoinfo cat catman
如果你对某个命令，只有模糊的印象，只记得前面的几个字母，这个功能是极好的，命令范围会一步步缩减。
为了开始下面的内容，我们首先介绍一下正则表达式。在前面的一些命令中，也可以使用这些正则表达式，比如less、grep等。
有些书籍，能够把正则表达式写成一本书，我们这里仅作简单的介绍，但足够用了。一般的，正则表达式能用在匹配上，还能够把匹配的内容拿来做二次利用。关于后者，我们在sed命令中介绍。
标志意义
^行首
$行尾
.任意单个字符
*匹配0个或者多个前面的字符
+1个或者多个匹配
?0个或者1个匹配
{m}前面的匹配重复m次
{m,n}前面的匹配重复m到n次
[]匹配一个指定范围内的字符
[^]匹配指定范围外的任意单个字符
\转义字符
[0-9]匹配括号中的任何一个字符,or的作用
``or，或者\b匹配一个单词。比如\blucky\b 只匹配单词lucky
使用下面的命令创建一个文件，我们练习一下grep命令加上E参数后的正则表现。
cat > 996 <<EOF
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
EOF
在终端执行下面命令，注意高亮的部分即为匹配到的字符串。
# 匹配996开头的行
[root@localhost ~]# cat 996 | grep -E ^996
996: 996 is a funcking thing . which make woman as man , man as ass .
# 匹配996结尾的行
[root@localhost ~]# cat 996 | grep -E 996$
we all on the bus , bus bus on the way . 996
# 匹配到icu和icuuuuuu
[root@localhost ~]# cat 996 | grep -E icu+
way to icu. icuuuuuu......
# 再次匹配到996
[root@localhost ~]# cat 996 | grep -E [0-9]
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
[root@localhost ~]# cat 996 | grep -E ^[\^0-9]
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有不包含996的行，良心命令，泪奔
[root@localhost ~]# cat 996 | grep -E -v [0-9]{3}
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配boss和icu
[root@localhost ~]# cat 996 | grep -E boss\|icu
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有行
[root@localhost ~]# cat 996 | grep -E .
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
正则表达式非常的重要，在一些sed脚本中，awk脚本中，甚至是vim编辑器中，都会简化你的操作。以上内容应该熟记，达到不需要查找文档的地步。
本小节是学习技巧方面的内容，但我们依然接触到一些硬核知识。这可能是除了正统的命令集合之外，最经常被使用的技巧了。接下来，我们介绍了一些简单的正则，这些正则可用用在很多命令中。我们还提供了一个把man命令变成彩色的小脚本，下面的文章中，会默认你已经把这一步给操作了。
彩色能够增加阅读效果（色盲除外）。
1、回过头去，执行一下man cat，是否发现了一个叫做tac的命令？它是干什么的？
2、上面提到的stat系列，你能想象iostat大体是干什么用的么？
3、grep -v是什么意思？
4、了解一下和mv非常像的rename命令来批量修改文件，看能否使用上面的正则。
5、有些命令如果拼写错误，如何快速修正？靠搜索么？了解一下fuck命令。我没有说错。
6、下面哪种写法表示如果cmd1成功执行，则执行cmd2命令？
咦？小王呢？
环顾四周，一片空空。别说罗马，小王都不见了。
你可能遇到一些棘手的问题，通过搜索得到想要的结果，但下次还是要通过搜索解决问题，这种低效的手段不是我们所想要的。典型的就是一个线上运维工程师，当问题来临时，不会给你留太多的现场学习时间。
为了达到更高效的训练，我们要做两件事情：第一，总结归纳；第二，触类旁通。Linux的命令也是如此，一个问题，通常会有多种解决方式，要通过变化找出其中的共性。
这涉及到一些设计者对于规范约定俗成的遵守。一般的，你只需要掌握一小部分命令，然后对大批命令达到了解的程度，就可以在命令行的世界里游刃有余。举个例子，你知道ls是列出文件目录，你就会联想到lscpu是列出cpu信息；lsmem是列出内存信息;lsblk是磁盘信息等。这种共性很多，比如top系列，stat系列。
在Linux上工作，是非常非常排斥二进制这种格式的，几乎什么都是可以读写的文本内容。大多数命令生成的结果，也都是文本文件。这些文件有一些特点，通常列与列都是通过空格或者
[root@localhost ~]# lsmem
RANGE SIZE STATE REMOVABLE BLOCK
0x0000000000000000-0x0000000007ffffff 128M online no 0
0x0000000008000000-0x000000000fffffff 128M online yes 1
0x0000000010000000-0x0000000017ffffff 128M online no 2
0x0000000018000000-0x0000000027ffffff 256M online yes 3-4
0x0000000028000000-0x000000004fffffff 640M online no 5-9
0x0000000050000000-0x000000005fffffff 256M online yes 10-11
0x0000000060000000-0x000000007fffffff 512M online no 12-15
Memory block size: 128M
Total online memory: 2G
Total offline memory: 0B
有一大批针对于行操作的命令，同样有一批针对于列操作的命令。然后，有两个集大成者，叫做sed、awk。由于这两个命令的内容非常多，我们将其列为单独的章节。
通常linux命令都十分简单，但是有些还是有些复杂度的。比如find，ps这种命令，如果要照顾到所有的场合，可能需要非常巨大的篇幅。但是，万一用到这种偏门的场合怎么办？
全面了解一下是非常有必要的，以便在使用的时候能够唤起记忆中最浅显的印象。然后剩下的，就可以交给类似于man的这种命令了。Linux上的每一个命令，都会有配套的帮助文件，这远比网络上那些转来转去的信息，正确的多。
正式介绍一下下面的两个命令：
注意：这些帮助信息，仅集中在命令的作用域本身。对于它的组合使用场景，并没有过多信息。也就是说，它教会了你怎么用，但并没有告诉你用它能够来做什么。
这些帮助命令，一般会通过高亮关键字，增加阅读的体验。但我们可以更近一步，把帮助文件变成彩色的。在root用户下，执行下面的命令。然后，重新登录虚拟机。
cat >> ~/.bashrc <<EOF
function man()
{
env \\
LESS_TERMCAP_mb=\$(printf "\e[1;31m") \\
LESS_TERMCAP_md=\$(printf "\e[1;31m") \\
LESS_TERMCAP_me=\$(printf "\e[0m") \\
LESS_TERMCAP_se=\$(printf "\e[0m") \\
LESS_TERMCAP_so=\$(printf "\e[1;44;33m") \\
LESS_TERMCAP_ue=\$(printf "\e[0m") \\
LESS_TERMCAP_us=\$(printf "\e[1;32m") \\
man "\$@"}
EOF
再次执行man命令，就可以看到彩色的信息了。
现在，在终端里，输入ca，然后快速按2次
[root@localhost ~]# ca
cacertdir_rehash cache_dump cache_repair cache_writeback ca-legacy capsh case catchsegv
cache_check cache_metadata_size cache_restore cal caller captoinfo cat catman
如果你对某个命令，只有模糊的印象，只记得前面的几个字母，这个功能是极好的，命令范围会一步步缩减。
为了开始下面的内容，我们首先介绍一下正则表达式。在前面的一些命令中，也可以使用这些正则表达式，比如less、grep等。
有些书籍，能够把正则表达式写成一本书，我们这里仅作简单的介绍，但足够用了。一般的，正则表达式能用在匹配上，还能够把匹配的内容拿来做二次利用。关于后者，我们在sed命令中介绍。
标志意义
^行首
$行尾
.任意单个字符
*匹配0个或者多个前面的字符
+1个或者多个匹配
?0个或者1个匹配
{m}前面的匹配重复m次
{m,n}前面的匹配重复m到n次
[]匹配一个指定范围内的字符
[^]匹配指定范围外的任意单个字符
\转义字符
[0-9]匹配括号中的任何一个字符,or的作用
``or，或者\b匹配一个单词。比如\blucky\b 只匹配单词lucky
使用下面的命令创建一个文件，我们练习一下grep命令加上E参数后的正则表现。
cat > 996 <<EOF
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
EOF
在终端执行下面命令，注意高亮的部分即为匹配到的字符串。
# 匹配996开头的行
[root@localhost ~]# cat 996 | grep -E ^996
996: 996 is a funcking thing . which make woman as man , man as ass .
# 匹配996结尾的行
[root@localhost ~]# cat 996 | grep -E 996$
we all on the bus , bus bus on the way . 996
# 匹配到icu和icuuuuuu
[root@localhost ~]# cat 996 | grep -E icu+
way to icu. icuuuuuu......
# 再次匹配到996
[root@localhost ~]# cat 996 | grep -E [0-9]
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
[root@localhost ~]# cat 996 | grep -E ^[\^0-9]
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有不包含996的行，良心命令，泪奔
[root@localhost ~]# cat 996 | grep -E -v [0-9]{3}
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配boss和icu
[root@localhost ~]# cat 996 | grep -E boss\|icu
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有行
[root@localhost ~]# cat 996 | grep -E .
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
正则表达式非常的重要，在一些sed脚本中，awk脚本中，甚至是vim编辑器中，都会简化你的操作。以上内容应该熟记，达到不需要查找文档的地步。
本小节是学习技巧方面的内容，但我们依然接触到一些硬核知识。这可能是除了正统的命令集合之外，最经常被使用的技巧了。接下来，我们介绍了一些简单的正则，这些正则可用用在很多命令中。我们还提供了一个把man命令变成彩色的小脚本，下面的文章中，会默认你已经把这一步给操作了。
彩色能够增加阅读效果（色盲除外）。
1、回过头去，执行一下man cat，是否发现了一个叫做tac的命令？它是干什么的？
2、上面提到的stat系列，你能想象iostat大体是干什么用的么？
3、grep -v是什么意思？
4、了解一下和mv非常像的rename命令来批量修改文件，看能否使用上面的正则。
5、有些命令如果拼写错误，如何快速修正？靠搜索么？了解一下fuck命令。我没有说错。
6、下面哪种写法表示如果cmd1成功执行，则执行cmd2命令？
咦？小王呢？
环顾四周，一片空空。别说罗马，小王都不见了。
你可能遇到一些棘手的问题，通过搜索得到想要的结果，但下次还是要通过搜索解决问题，这种低效的手段不是我们所想要的。典型的就是一个线上运维工程师，当问题来临时，不会给你留太多的现场学习时间。
为了达到更高效的训练，我们要做两件事情：第一，总结归纳；第二，触类旁通。Linux的命令也是如此，一个问题，通常会有多种解决方式，要通过变化找出其中的共性。
这涉及到一些设计者对于规范约定俗成的遵守。一般的，你只需要掌握一小部分命令，然后对大批命令达到了解的程度，就可以在命令行的世界里游刃有余。举个例子，你知道ls是列出文件目录，你就会联想到lscpu是列出cpu信息；lsmem是列出内存信息;lsblk是磁盘信息等。这种共性很多，比如top系列，stat系列。
在Linux上工作，是非常非常排斥二进制这种格式的，几乎什么都是可以读写的文本内容。大多数命令生成的结果，也都是文本文件。这些文件有一些特点，通常列与列都是通过空格或者
[root@localhost ~]# lsmem
RANGE SIZE STATE REMOVABLE BLOCK
0x0000000000000000-0x0000000007ffffff 128M online no 0
0x0000000008000000-0x000000000fffffff 128M online yes 1
0x0000000010000000-0x0000000017ffffff 128M online no 2
0x0000000018000000-0x0000000027ffffff 256M online yes 3-4
0x0000000028000000-0x000000004fffffff 640M online no 5-9
0x0000000050000000-0x000000005fffffff 256M online yes 10-11
0x0000000060000000-0x000000007fffffff 512M online no 12-15
Memory block size: 128M
Total online memory: 2G
Total offline memory: 0B
有一大批针对于行操作的命令，同样有一批针对于列操作的命令。然后，有两个集大成者，叫做sed、awk。由于这两个命令的内容非常多，我们将其列为单独的章节。
通常linux命令都十分简单，但是有些还是有些复杂度的。比如find，ps这种命令，如果要照顾到所有的场合，可能需要非常巨大的篇幅。但是，万一用到这种偏门的场合怎么办？
全面了解一下是非常有必要的，以便在使用的时候能够唤起记忆中最浅显的印象。然后剩下的，就可以交给类似于man的这种命令了。Linux上的每一个命令，都会有配套的帮助文件，这远比网络上那些转来转去的信息，正确的多。
正式介绍一下下面的两个命令：
注意：这些帮助信息，仅集中在命令的作用域本身。对于它的组合使用场景，并没有过多信息。也就是说，它教会了你怎么用，但并没有告诉你用它能够来做什么。
这些帮助命令，一般会通过高亮关键字，增加阅读的体验。但我们可以更近一步，把帮助文件变成彩色的。在root用户下，执行下面的命令。然后，重新登录虚拟机。
cat >> ~/.bashrc <<EOF
function man()
{
env \\
LESS_TERMCAP_mb=\$(printf "\e[1;31m") \\
LESS_TERMCAP_md=\$(printf "\e[1;31m") \\
LESS_TERMCAP_me=\$(printf "\e[0m") \\
LESS_TERMCAP_se=\$(printf "\e[0m") \\
LESS_TERMCAP_so=\$(printf "\e[1;44;33m") \\
LESS_TERMCAP_ue=\$(printf "\e[0m") \\
LESS_TERMCAP_us=\$(printf "\e[1;32m") \\
man "\$@"}
EOF
再次执行man命令，就可以看到彩色的信息了。
现在，在终端里，输入ca，然后快速按2次
[root@localhost ~]# ca
cacertdir_rehash cache_dump cache_repair cache_writeback ca-legacy capsh case catchsegv
cache_check cache_metadata_size cache_restore cal caller captoinfo cat catman
如果你对某个命令，只有模糊的印象，只记得前面的几个字母，这个功能是极好的，命令范围会一步步缩减。
为了开始下面的内容，我们首先介绍一下正则表达式。在前面的一些命令中，也可以使用这些正则表达式，比如less、grep等。
有些书籍，能够把正则表达式写成一本书，我们这里仅作简单的介绍，但足够用了。一般的，正则表达式能用在匹配上，还能够把匹配的内容拿来做二次利用。关于后者，我们在sed命令中介绍。
标志意义
^行首
$行尾
.任意单个字符
*匹配0个或者多个前面的字符
+1个或者多个匹配
?0个或者1个匹配
{m}前面的匹配重复m次
{m,n}前面的匹配重复m到n次
[]匹配一个指定范围内的字符
[^]匹配指定范围外的任意单个字符
\转义字符
[0-9]匹配括号中的任何一个字符,or的作用
``or，或者\b匹配一个单词。比如\blucky\b 只匹配单词lucky
使用下面的命令创建一个文件，我们练习一下grep命令加上E参数后的正则表现。
cat > 996 <<EOF
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
EOF
在终端执行下面命令，注意高亮的部分即为匹配到的字符串。
# 匹配996开头的行
[root@localhost ~]# cat 996 | grep -E ^996
996: 996 is a funcking thing . which make woman as man , man as ass .
# 匹配996结尾的行
[root@localhost ~]# cat 996 | grep -E 996$
we all on the bus , bus bus on the way . 996
# 匹配到icu和icuuuuuu
[root@localhost ~]# cat 996 | grep -E icu+
way to icu. icuuuuuu......
# 再次匹配到996
[root@localhost ~]# cat 996 | grep -E [0-9]
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
[root@localhost ~]# cat 996 | grep -E ^[\^0-9]
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有不包含996的行，良心命令，泪奔
[root@localhost ~]# cat 996 | grep -E -v [0-9]{3}
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配boss和icu
[root@localhost ~]# cat 996 | grep -E boss\|icu
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有行
[root@localhost ~]# cat 996 | grep -E .
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
正则表达式非常的重要，在一些sed脚本中，awk脚本中，甚至是vim编辑器中，都会简化你的操作。以上内容应该熟记，达到不需要查找文档的地步。
本小节是学习技巧方面的内容，但我们依然接触到一些硬核知识。这可能是除了正统的命令集合之外，最经常被使用的技巧了。接下来，我们介绍了一些简单的正则，这些正则可用用在很多命令中。我们还提供了一个把man命令变成彩色的小脚本，下面的文章中，会默认你已经把这一步给操作了。
彩色能够增加阅读效果（色盲除外）。
1、回过头去，执行一下man cat，是否发现了一个叫做tac的命令？它是干什么的？
2、上面提到的stat系列，你能想象iostat大体是干什么用的么？
3、grep -v是什么意思？
4、了解一下和mv非常像的rename命令来批量修改文件，看能否使用上面的正则。
5、有些命令如果拼写错误，如何快速修正？靠搜索么？了解一下fuck命令。我没有说错。
6、下面哪种写法表示如果cmd1成功执行，则执行cmd2命令？
咦？小王呢？
环顾四周，一片空空。别说罗马，小王都不见了。
你可能遇到一些棘手的问题，通过搜索得到想要的结果，但下次还是要通过搜索解决问题，这种低效的手段不是我们所想要的。典型的就是一个线上运维工程师，当问题来临时，不会给你留太多的现场学习时间。
为了达到更高效的训练，我们要做两件事情：第一，总结归纳；第二，触类旁通。Linux的命令也是如此，一个问题，通常会有多种解决方式，要通过变化找出其中的共性。
这涉及到一些设计者对于规范约定俗成的遵守。一般的，你只需要掌握一小部分命令，然后对大批命令达到了解的程度，就可以在命令行的世界里游刃有余。举个例子，你知道ls是列出文件目录，你就会联想到lscpu是列出cpu信息；lsmem是列出内存信息;lsblk是磁盘信息等。这种共性很多，比如top系列，stat系列。
在Linux上工作，是非常非常排斥二进制这种格式的，几乎什么都是可以读写的文本内容。大多数命令生成的结果，也都是文本文件。这些文件有一些特点，通常列与列都是通过空格或者
[root@localhost ~]# lsmem
RANGE SIZE STATE REMOVABLE BLOCK
0x0000000000000000-0x0000000007ffffff 128M online no 0
0x0000000008000000-0x000000000fffffff 128M online yes 1
0x0000000010000000-0x0000000017ffffff 128M online no 2
0x0000000018000000-0x0000000027ffffff 256M online yes 3-4
0x0000000028000000-0x000000004fffffff 640M online no 5-9
0x0000000050000000-0x000000005fffffff 256M online yes 10-11
0x0000000060000000-0x000000007fffffff 512M online no 12-15
Memory block size: 128M
Total online memory: 2G
Total offline memory: 0B
有一大批针对于行操作的命令，同样有一批针对于列操作的命令。然后，有两个集大成者，叫做sed、awk。由于这两个命令的内容非常多，我们将其列为单独的章节。
通常linux命令都十分简单，但是有些还是有些复杂度的。比如find，ps这种命令，如果要照顾到所有的场合，可能需要非常巨大的篇幅。但是，万一用到这种偏门的场合怎么办？
全面了解一下是非常有必要的，以便在使用的时候能够唤起记忆中最浅显的印象。然后剩下的，就可以交给类似于man的这种命令了。Linux上的每一个命令，都会有配套的帮助文件，这远比网络上那些转来转去的信息，正确的多。
正式介绍一下下面的两个命令：
注意：这些帮助信息，仅集中在命令的作用域本身。对于它的组合使用场景，并没有过多信息。也就是说，它教会了你怎么用，但并没有告诉你用它能够来做什么。
这些帮助命令，一般会通过高亮关键字，增加阅读的体验。但我们可以更近一步，把帮助文件变成彩色的。在root用户下，执行下面的命令。然后，重新登录虚拟机。
cat >> ~/.bashrc <<EOF
function man()
{
env \\
LESS_TERMCAP_mb=\$(printf "\e[1;31m") \\
LESS_TERMCAP_md=\$(printf "\e[1;31m") \\
LESS_TERMCAP_me=\$(printf "\e[0m") \\
LESS_TERMCAP_se=\$(printf "\e[0m") \\
LESS_TERMCAP_so=\$(printf "\e[1;44;33m") \\
LESS_TERMCAP_ue=\$(printf "\e[0m") \\
LESS_TERMCAP_us=\$(printf "\e[1;32m") \\
man "\$@"}
EOF
再次执行man命令，就可以看到彩色的信息了。
现在，在终端里，输入ca，然后快速按2次
[root@localhost ~]# ca
cacertdir_rehash cache_dump cache_repair cache_writeback ca-legacy capsh case catchsegv
cache_check cache_metadata_size cache_restore cal caller captoinfo cat catman
如果你对某个命令，只有模糊的印象，只记得前面的几个字母，这个功能是极好的，命令范围会一步步缩减。
为了开始下面的内容，我们首先介绍一下正则表达式。在前面的一些命令中，也可以使用这些正则表达式，比如less、grep等。
有些书籍，能够把正则表达式写成一本书，我们这里仅作简单的介绍，但足够用了。一般的，正则表达式能用在匹配上，还能够把匹配的内容拿来做二次利用。关于后者，我们在sed命令中介绍。
标志意义
^行首
$行尾
.任意单个字符
*匹配0个或者多个前面的字符
+1个或者多个匹配
?0个或者1个匹配
{m}前面的匹配重复m次
{m,n}前面的匹配重复m到n次
[]匹配一个指定范围内的字符
[^]匹配指定范围外的任意单个字符
\转义字符
[0-9]匹配括号中的任何一个字符,or的作用
``or，或者\b匹配一个单词。比如\blucky\b 只匹配单词lucky
使用下面的命令创建一个文件，我们练习一下grep命令加上E参数后的正则表现。
cat > 996 <<EOF
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
EOF
在终端执行下面命令，注意高亮的部分即为匹配到的字符串。
# 匹配996开头的行
[root@localhost ~]# cat 996 | grep -E ^996
996: 996 is a funcking thing . which make woman as man , man as ass .
# 匹配996结尾的行
[root@localhost ~]# cat 996 | grep -E 996$
we all on the bus , bus bus on the way . 996
# 匹配到icu和icuuuuuu
[root@localhost ~]# cat 996 | grep -E icu+
way to icu. icuuuuuu......
# 再次匹配到996
[root@localhost ~]# cat 996 | grep -E [0-9]
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
[root@localhost ~]# cat 996 | grep -E ^[\^0-9]
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有不包含996的行，良心命令，泪奔
[root@localhost ~]# cat 996 | grep -E -v [0-9]{3}
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配boss和icu
[root@localhost ~]# cat 996 | grep -E boss\|icu
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有行
[root@localhost ~]# cat 996 | grep -E .
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
正则表达式非常的重要，在一些sed脚本中，awk脚本中，甚至是vim编辑器中，都会简化你的操作。以上内容应该熟记，达到不需要查找文档的地步。
本小节是学习技巧方面的内容，但我们依然接触到一些硬核知识。这可能是除了正统的命令集合之外，最经常被使用的技巧了。接下来，我们介绍了一些简单的正则，这些正则可用用在很多命令中。我们还提供了一个把man命令变成彩色的小脚本，下面的文章中，会默认你已经把这一步给操作了。
彩色能够增加阅读效果（色盲除外）。
1、回过头去，执行一下man cat，是否发现了一个叫做tac的命令？它是干什么的？
2、上面提到的stat系列，你能想象iostat大体是干什么用的么？
3、grep -v是什么意思？
4、了解一下和mv非常像的rename命令来批量修改文件，看能否使用上面的正则。
5、有些命令如果拼写错误，如何快速修正？靠搜索么？了解一下fuck命令。我没有说错。
6、下面哪种写法表示如果cmd1成功执行，则执行cmd2命令？
咦？小王呢？
环顾四周，一片空空。别说罗马，小王都不见了。
你可能遇到一些棘手的问题，通过搜索得到想要的结果，但下次还是要通过搜索解决问题，这种低效的手段不是我们所想要的。典型的就是一个线上运维工程师，当问题来临时，不会给你留太多的现场学习时间。
为了达到更高效的训练，我们要做两件事情：第一，总结归纳；第二，触类旁通。Linux的命令也是如此，一个问题，通常会有多种解决方式，要通过变化找出其中的共性。
这涉及到一些设计者对于规范约定俗成的遵守。一般的，你只需要掌握一小部分命令，然后对大批命令达到了解的程度，就可以在命令行的世界里游刃有余。举个例子，你知道ls是列出文件目录，你就会联想到lscpu是列出cpu信息；lsmem是列出内存信息;lsblk是磁盘信息等。这种共性很多，比如top系列，stat系列。
在Linux上工作，是非常非常排斥二进制这种格式的，几乎什么都是可以读写的文本内容。大多数命令生成的结果，也都是文本文件。这些文件有一些特点，通常列与列都是通过空格或者
[root@localhost ~]# lsmem
RANGE SIZE STATE REMOVABLE BLOCK
0x0000000000000000-0x0000000007ffffff 128M online no 0
0x0000000008000000-0x000000000fffffff 128M online yes 1
0x0000000010000000-0x0000000017ffffff 128M online no 2
0x0000000018000000-0x0000000027ffffff 256M online yes 3-4
0x0000000028000000-0x000000004fffffff 640M online no 5-9
0x0000000050000000-0x000000005fffffff 256M online yes 10-11
0x0000000060000000-0x000000007fffffff 512M online no 12-15
Memory block size: 128M
Total online memory: 2G
Total offline memory: 0B
有一大批针对于行操作的命令，同样有一批针对于列操作的命令。然后，有两个集大成者，叫做sed、awk。由于这两个命令的内容非常多，我们将其列为单独的章节。
通常linux命令都十分简单，但是有些还是有些复杂度的。比如find，ps这种命令，如果要照顾到所有的场合，可能需要非常巨大的篇幅。但是，万一用到这种偏门的场合怎么办？
全面了解一下是非常有必要的，以便在使用的时候能够唤起记忆中最浅显的印象。然后剩下的，就可以交给类似于man的这种命令了。Linux上的每一个命令，都会有配套的帮助文件，这远比网络上那些转来转去的信息，正确的多。
正式介绍一下下面的两个命令：
注意：这些帮助信息，仅集中在命令的作用域本身。对于它的组合使用场景，并没有过多信息。也就是说，它教会了你怎么用，但并没有告诉你用它能够来做什么。
这些帮助命令，一般会通过高亮关键字，增加阅读的体验。但我们可以更近一步，把帮助文件变成彩色的。在root用户下，执行下面的命令。然后，重新登录虚拟机。
cat >> ~/.bashrc <<EOF
function man()
{
env \\
LESS_TERMCAP_mb=\$(printf "\e[1;31m") \\
LESS_TERMCAP_md=\$(printf "\e[1;31m") \\
LESS_TERMCAP_me=\$(printf "\e[0m") \\
LESS_TERMCAP_se=\$(printf "\e[0m") \\
LESS_TERMCAP_so=\$(printf "\e[1;44;33m") \\
LESS_TERMCAP_ue=\$(printf "\e[0m") \\
LESS_TERMCAP_us=\$(printf "\e[1;32m") \\
man "\$@"}
EOF
再次执行man命令，就可以看到彩色的信息了。
现在，在终端里，输入ca，然后快速按2次
[root@localhost ~]# ca
cacertdir_rehash cache_dump cache_repair cache_writeback ca-legacy capsh case catchsegv
cache_check cache_metadata_size cache_restore cal caller captoinfo cat catman
如果你对某个命令，只有模糊的印象，只记得前面的几个字母，这个功能是极好的，命令范围会一步步缩减。
为了开始下面的内容，我们首先介绍一下正则表达式。在前面的一些命令中，也可以使用这些正则表达式，比如less、grep等。
有些书籍，能够把正则表达式写成一本书，我们这里仅作简单的介绍，但足够用了。一般的，正则表达式能用在匹配上，还能够把匹配的内容拿来做二次利用。关于后者，我们在sed命令中介绍。
标志意义
^行首
$行尾
.任意单个字符
*匹配0个或者多个前面的字符
+1个或者多个匹配
?0个或者1个匹配
{m}前面的匹配重复m次
{m,n}前面的匹配重复m到n次
[]匹配一个指定范围内的字符
[^]匹配指定范围外的任意单个字符
\转义字符
[0-9]匹配括号中的任何一个字符,or的作用
``or，或者\b匹配一个单词。比如\blucky\b 只匹配单词lucky
使用下面的命令创建一个文件，我们练习一下grep命令加上E参数后的正则表现。
cat > 996 <<EOF
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
EOF
在终端执行下面命令，注意高亮的部分即为匹配到的字符串。
# 匹配996开头的行
[root@localhost ~]# cat 996 | grep -E ^996
996: 996 is a funcking thing . which make woman as man , man as ass .
# 匹配996结尾的行
[root@localhost ~]# cat 996 | grep -E 996$
we all on the bus , bus bus on the way . 996
# 匹配到icu和icuuuuuu
[root@localhost ~]# cat 996 | grep -E icu+
way to icu. icuuuuuu......
# 再次匹配到996
[root@localhost ~]# cat 996 | grep -E [0-9]
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
[root@localhost ~]# cat 996 | grep -E ^[\^0-9]
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有不包含996的行，良心命令，泪奔
[root@localhost ~]# cat 996 | grep -E -v [0-9]{3}
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配boss和icu
[root@localhost ~]# cat 996 | grep -E boss\|icu
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有行
[root@localhost ~]# cat 996 | grep -E .
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
正则表达式非常的重要，在一些sed脚本中，awk脚本中，甚至是vim编辑器中，都会简化你的操作。以上内容应该熟记，达到不需要查找文档的地步。
本小节是学习技巧方面的内容，但我们依然接触到一些硬核知识。这可能是除了正统的命令集合之外，最经常被使用的技巧了。接下来，我们介绍了一些简单的正则，这些正则可用用在很多命令中。我们还提供了一个把man命令变成彩色的小脚本，下面的文章中，会默认你已经把这一步给操作了。
彩色能够增加阅读效果（色盲除外）。
1、回过头去，执行一下man cat，是否发现了一个叫做tac的命令？它是干什么的？
2、上面提到的stat系列，你能想象iostat大体是干什么用的么？
3、grep -v是什么意思？
4、了解一下和mv非常像的rename命令来批量修改文件，看能否使用上面的正则。
5、有些命令如果拼写错误，如何快速修正？靠搜索么？了解一下fuck命令。我没有说错。
6、下面哪种写法表示如果cmd1成功执行，则执行cmd2命令？
咦？小王呢？
环顾四周，一片空空。别说罗马，小王都不见了。
你可能遇到一些棘手的问题，通过搜索得到想要的结果，但下次还是要通过搜索解决问题，这种低效的手段不是我们所想要的。典型的就是一个线上运维工程师，当问题来临时，不会给你留太多的现场学习时间。
为了达到更高效的训练，我们要做两件事情：第一，总结归纳；第二，触类旁通。Linux的命令也是如此，一个问题，通常会有多种解决方式，要通过变化找出其中的共性。
这涉及到一些设计者对于规范约定俗成的遵守。一般的，你只需要掌握一小部分命令，然后对大批命令达到了解的程度，就可以在命令行的世界里游刃有余。举个例子，你知道ls是列出文件目录，你就会联想到lscpu是列出cpu信息；lsmem是列出内存信息;lsblk是磁盘信息等。这种共性很多，比如top系列，stat系列。
在Linux上工作，是非常非常排斥二进制这种格式的，几乎什么都是可以读写的文本内容。大多数命令生成的结果，也都是文本文件。这些文件有一些特点，通常列与列都是通过空格或者
[root@localhost ~]# lsmem
RANGE SIZE STATE REMOVABLE BLOCK
0x0000000000000000-0x0000000007ffffff 128M online no 0
0x0000000008000000-0x000000000fffffff 128M online yes 1
0x0000000010000000-0x0000000017ffffff 128M online no 2
0x0000000018000000-0x0000000027ffffff 256M online yes 3-4
0x0000000028000000-0x000000004fffffff 640M online no 5-9
0x0000000050000000-0x000000005fffffff 256M online yes 10-11
0x0000000060000000-0x000000007fffffff 512M online no 12-15
Memory block size: 128M
Total online memory: 2G
Total offline memory: 0B
有一大批针对于行操作的命令，同样有一批针对于列操作的命令。然后，有两个集大成者，叫做sed、awk。由于这两个命令的内容非常多，我们将其列为单独的章节。
通常linux命令都十分简单，但是有些还是有些复杂度的。比如find，ps这种命令，如果要照顾到所有的场合，可能需要非常巨大的篇幅。但是，万一用到这种偏门的场合怎么办？
全面了解一下是非常有必要的，以便在使用的时候能够唤起记忆中最浅显的印象。然后剩下的，就可以交给类似于man的这种命令了。Linux上的每一个命令，都会有配套的帮助文件，这远比网络上那些转来转去的信息，正确的多。
正式介绍一下下面的两个命令：
注意：这些帮助信息，仅集中在命令的作用域本身。对于它的组合使用场景，并没有过多信息。也就是说，它教会了你怎么用，但并没有告诉你用它能够来做什么。
这些帮助命令，一般会通过高亮关键字，增加阅读的体验。但我们可以更近一步，把帮助文件变成彩色的。在root用户下，执行下面的命令。然后，重新登录虚拟机。
cat >> ~/.bashrc <<EOF
function man()
{
env \\
LESS_TERMCAP_mb=\$(printf "\e[1;31m") \\
LESS_TERMCAP_md=\$(printf "\e[1;31m") \\
LESS_TERMCAP_me=\$(printf "\e[0m") \\
LESS_TERMCAP_se=\$(printf "\e[0m") \\
LESS_TERMCAP_so=\$(printf "\e[1;44;33m") \\
LESS_TERMCAP_ue=\$(printf "\e[0m") \\
LESS_TERMCAP_us=\$(printf "\e[1;32m") \\
man "\$@"}
EOF
再次执行man命令，就可以看到彩色的信息了。
现在，在终端里，输入ca，然后快速按2次
[root@localhost ~]# ca
cacertdir_rehash cache_dump cache_repair cache_writeback ca-legacy capsh case catchsegv
cache_check cache_metadata_size cache_restore cal caller captoinfo cat catman
如果你对某个命令，只有模糊的印象，只记得前面的几个字母，这个功能是极好的，命令范围会一步步缩减。
为了开始下面的内容，我们首先介绍一下正则表达式。在前面的一些命令中，也可以使用这些正则表达式，比如less、grep等。
有些书籍，能够把正则表达式写成一本书，我们这里仅作简单的介绍，但足够用了。一般的，正则表达式能用在匹配上，还能够把匹配的内容拿来做二次利用。关于后者，我们在sed命令中介绍。
标志意义
^行首
$行尾
.任意单个字符
*匹配0个或者多个前面的字符
+1个或者多个匹配
?0个或者1个匹配
{m}前面的匹配重复m次
{m,n}前面的匹配重复m到n次
[]匹配一个指定范围内的字符
[^]匹配指定范围外的任意单个字符
\转义字符
[0-9]匹配括号中的任何一个字符,or的作用
``or，或者\b匹配一个单词。比如\blucky\b 只匹配单词lucky
使用下面的命令创建一个文件，我们练习一下grep命令加上E参数后的正则表现。
cat > 996 <<EOF
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
EOF
在终端执行下面命令，注意高亮的部分即为匹配到的字符串。
# 匹配996开头的行
[root@localhost ~]# cat 996 | grep -E ^996
996: 996 is a funcking thing . which make woman as man , man as ass .
# 匹配996结尾的行
[root@localhost ~]# cat 996 | grep -E 996$
we all on the bus , bus bus on the way . 996
# 匹配到icu和icuuuuuu
[root@localhost ~]# cat 996 | grep -E icu+
way to icu. icuuuuuu......
# 再次匹配到996
[root@localhost ~]# cat 996 | grep -E [0-9]
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
[root@localhost ~]# cat 996 | grep -E ^[\^0-9]
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有不包含996的行，良心命令，泪奔
[root@localhost ~]# cat 996 | grep -E -v [0-9]{3}
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配boss和icu
[root@localhost ~]# cat 996 | grep -E boss\|icu
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有行
[root@localhost ~]# cat 996 | grep -E .
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
正则表达式非常的重要，在一些sed脚本中，awk脚本中，甚至是vim编辑器中，都会简化你的操作。以上内容应该熟记，达到不需要查找文档的地步。
本小节是学习技巧方面的内容，但我们依然接触到一些硬核知识。这可能是除了正统的命令集合之外，最经常被使用的技巧了。接下来，我们介绍了一些简单的正则，这些正则可用用在很多命令中。我们还提供了一个把man命令变成彩色的小脚本，下面的文章中，会默认你已经把这一步给操作了。
彩色能够增加阅读效果（色盲除外）。
1、回过头去，执行一下man cat，是否发现了一个叫做tac的命令？它是干什么的？
2、上面提到的stat系列，你能想象iostat大体是干什么用的么？
3、grep -v是什么意思？
4、了解一下和mv非常像的rename命令来批量修改文件，看能否使用上面的正则。
5、有些命令如果拼写错误，如何快速修正？靠搜索么？了解一下fuck命令。我没有说错。
6、下面哪种写法表示如果cmd1成功执行，则执行cmd2命令？
咦？小王呢？
环顾四周，一片空空。别说罗马，小王都不见了。
你可能遇到一些棘手的问题，通过搜索得到想要的结果，但下次还是要通过搜索解决问题，这种低效的手段不是我们所想要的。典型的就是一个线上运维工程师，当问题来临时，不会给你留太多的现场学习时间。
为了达到更高效的训练，我们要做两件事情：第一，总结归纳；第二，触类旁通。Linux的命令也是如此，一个问题，通常会有多种解决方式，要通过变化找出其中的共性。
这涉及到一些设计者对于规范约定俗成的遵守。一般的，你只需要掌握一小部分命令，然后对大批命令达到了解的程度，就可以在命令行的世界里游刃有余。举个例子，你知道ls是列出文件目录，你就会联想到lscpu是列出cpu信息；lsmem是列出内存信息;lsblk是磁盘信息等。这种共性很多，比如top系列，stat系列。
在Linux上工作，是非常非常排斥二进制这种格式的，几乎什么都是可以读写的文本内容。大多数命令生成的结果，也都是文本文件。这些文件有一些特点，通常列与列都是通过空格或者
[root@localhost ~]# lsmem
RANGE SIZE STATE REMOVABLE BLOCK
0x0000000000000000-0x0000000007ffffff 128M online no 0
0x0000000008000000-0x000000000fffffff 128M online yes 1
0x0000000010000000-0x0000000017ffffff 128M online no 2
0x0000000018000000-0x0000000027ffffff 256M online yes 3-4
0x0000000028000000-0x000000004fffffff 640M online no 5-9
0x0000000050000000-0x000000005fffffff 256M online yes 10-11
0x0000000060000000-0x000000007fffffff 512M online no 12-15
Memory block size: 128M
Total online memory: 2G
Total offline memory: 0B
有一大批针对于行操作的命令，同样有一批针对于列操作的命令。然后，有两个集大成者，叫做sed、awk。由于这两个命令的内容非常多，我们将其列为单独的章节。
通常linux命令都十分简单，但是有些还是有些复杂度的。比如find，ps这种命令，如果要照顾到所有的场合，可能需要非常巨大的篇幅。但是，万一用到这种偏门的场合怎么办？
全面了解一下是非常有必要的，以便在使用的时候能够唤起记忆中最浅显的印象。然后剩下的，就可以交给类似于man的这种命令了。Linux上的每一个命令，都会有配套的帮助文件，这远比网络上那些转来转去的信息，正确的多。
正式介绍一下下面的两个命令：
注意：这些帮助信息，仅集中在命令的作用域本身。对于它的组合使用场景，并没有过多信息。也就是说，它教会了你怎么用，但并没有告诉你用它能够来做什么。
这些帮助命令，一般会通过高亮关键字，增加阅读的体验。但我们可以更近一步，把帮助文件变成彩色的。在root用户下，执行下面的命令。然后，重新登录虚拟机。
cat >> ~/.bashrc <<EOF
function man()
{
env \\
LESS_TERMCAP_mb=\$(printf "\e[1;31m") \\
LESS_TERMCAP_md=\$(printf "\e[1;31m") \\
LESS_TERMCAP_me=\$(printf "\e[0m") \\
LESS_TERMCAP_se=\$(printf "\e[0m") \\
LESS_TERMCAP_so=\$(printf "\e[1;44;33m") \\
LESS_TERMCAP_ue=\$(printf "\e[0m") \\
LESS_TERMCAP_us=\$(printf "\e[1;32m") \\
man "\$@"}
EOF
再次执行man命令，就可以看到彩色的信息了。
现在，在终端里，输入ca，然后快速按2次
[root@localhost ~]# ca
cacertdir_rehash cache_dump cache_repair cache_writeback ca-legacy capsh case catchsegv
cache_check cache_metadata_size cache_restore cal caller captoinfo cat catman
如果你对某个命令，只有模糊的印象，只记得前面的几个字母，这个功能是极好的，命令范围会一步步缩减。
为了开始下面的内容，我们首先介绍一下正则表达式。在前面的一些命令中，也可以使用这些正则表达式，比如less、grep等。
有些书籍，能够把正则表达式写成一本书，我们这里仅作简单的介绍，但足够用了。一般的，正则表达式能用在匹配上，还能够把匹配的内容拿来做二次利用。关于后者，我们在sed命令中介绍。
标志意义
^行首
$行尾
.任意单个字符
*匹配0个或者多个前面的字符
+1个或者多个匹配
?0个或者1个匹配
{m}前面的匹配重复m次
{m,n}前面的匹配重复m到n次
[]匹配一个指定范围内的字符
[^]匹配指定范围外的任意单个字符
\转义字符
[0-9]匹配括号中的任何一个字符,or的作用
``or，或者\b匹配一个单词。比如\blucky\b 只匹配单词lucky
使用下面的命令创建一个文件，我们练习一下grep命令加上E参数后的正则表现。
cat > 996 <<EOF
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
EOF
在终端执行下面命令，注意高亮的部分即为匹配到的字符串。
# 匹配996开头的行
[root@localhost ~]# cat 996 | grep -E ^996
996: 996 is a funcking thing . which make woman as man , man as ass .
# 匹配996结尾的行
[root@localhost ~]# cat 996 | grep -E 996$
we all on the bus , bus bus on the way . 996
# 匹配到icu和icuuuuuu
[root@localhost ~]# cat 996 | grep -E icu+
way to icu. icuuuuuu......
# 再次匹配到996
[root@localhost ~]# cat 996 | grep -E [0-9]
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
[root@localhost ~]# cat 996 | grep -E ^[\^0-9]
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有不包含996的行，良心命令，泪奔
[root@localhost ~]# cat 996 | grep -E -v [0-9]{3}
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配boss和icu
[root@localhost ~]# cat 996 | grep -E boss\|icu
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有行
[root@localhost ~]# cat 996 | grep -E .
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
正则表达式非常的重要，在一些sed脚本中，awk脚本中，甚至是vim编辑器中，都会简化你的操作。以上内容应该熟记，达到不需要查找文档的地步。
本小节是学习技巧方面的内容，但我们依然接触到一些硬核知识。这可能是除了正统的命令集合之外，最经常被使用的技巧了。接下来，我们介绍了一些简单的正则，这些正则可用用在很多命令中。我们还提供了一个把man命令变成彩色的小脚本，下面的文章中，会默认你已经把这一步给操作了。
彩色能够增加阅读效果（色盲除外）。
1、回过头去，执行一下man cat，是否发现了一个叫做tac的命令？它是干什么的？
2、上面提到的stat系列，你能想象iostat大体是干什么用的么？
3、grep -v是什么意思？
4、了解一下和mv非常像的rename命令来批量修改文件，看能否使用上面的正则。
5、有些命令如果拼写错误，如何快速修正？靠搜索么？了解一下fuck命令。我没有说错。
6、下面哪种写法表示如果cmd1成功执行，则执行cmd2命令？
咦？小王呢？
环顾四周，一片空空。别说罗马，小王都不见了。
你可能遇到一些棘手的问题，通过搜索得到想要的结果，但下次还是要通过搜索解决问题，这种低效的手段不是我们所想要的。典型的就是一个线上运维工程师，当问题来临时，不会给你留太多的现场学习时间。
为了达到更高效的训练，我们要做两件事情：第一，总结归纳；第二，触类旁通。Linux的命令也是如此，一个问题，通常会有多种解决方式，要通过变化找出其中的共性。
这涉及到一些设计者对于规范约定俗成的遵守。一般的，你只需要掌握一小部分命令，然后对大批命令达到了解的程度，就可以在命令行的世界里游刃有余。举个例子，你知道ls是列出文件目录，你就会联想到lscpu是列出cpu信息；lsmem是列出内存信息;lsblk是磁盘信息等。这种共性很多，比如top系列，stat系列。
在Linux上工作，是非常非常排斥二进制这种格式的，几乎什么都是可以读写的文本内容。大多数命令生成的结果，也都是文本文件。这些文件有一些特点，通常列与列都是通过空格或者
[root@localhost ~]# lsmem
RANGE SIZE STATE REMOVABLE BLOCK
0x0000000000000000-0x0000000007ffffff 128M online no 0
0x0000000008000000-0x000000000fffffff 128M online yes 1
0x0000000010000000-0x0000000017ffffff 128M online no 2
0x0000000018000000-0x0000000027ffffff 256M online yes 3-4
0x0000000028000000-0x000000004fffffff 640M online no 5-9
0x0000000050000000-0x000000005fffffff 256M online yes 10-11
0x0000000060000000-0x000000007fffffff 512M online no 12-15
Memory block size: 128M
Total online memory: 2G
Total offline memory: 0B
有一大批针对于行操作的命令，同样有一批针对于列操作的命令。然后，有两个集大成者，叫做sed、awk。由于这两个命令的内容非常多，我们将其列为单独的章节。
通常linux命令都十分简单，但是有些还是有些复杂度的。比如find，ps这种命令，如果要照顾到所有的场合，可能需要非常巨大的篇幅。但是，万一用到这种偏门的场合怎么办？
全面了解一下是非常有必要的，以便在使用的时候能够唤起记忆中最浅显的印象。然后剩下的，就可以交给类似于man的这种命令了。Linux上的每一个命令，都会有配套的帮助文件，这远比网络上那些转来转去的信息，正确的多。
正式介绍一下下面的两个命令：
注意：这些帮助信息，仅集中在命令的作用域本身。对于它的组合使用场景，并没有过多信息。也就是说，它教会了你怎么用，但并没有告诉你用它能够来做什么。
这些帮助命令，一般会通过高亮关键字，增加阅读的体验。但我们可以更近一步，把帮助文件变成彩色的。在root用户下，执行下面的命令。然后，重新登录虚拟机。
cat >> ~/.bashrc <<EOF
function man()
{
env \\
LESS_TERMCAP_mb=\$(printf "\e[1;31m") \\
LESS_TERMCAP_md=\$(printf "\e[1;31m") \\
LESS_TERMCAP_me=\$(printf "\e[0m") \\
LESS_TERMCAP_se=\$(printf "\e[0m") \\
LESS_TERMCAP_so=\$(printf "\e[1;44;33m") \\
LESS_TERMCAP_ue=\$(printf "\e[0m") \\
LESS_TERMCAP_us=\$(printf "\e[1;32m") \\
man "\$@"}
EOF
再次执行man命令，就可以看到彩色的信息了。
现在，在终端里，输入ca，然后快速按2次
[root@localhost ~]# ca
cacertdir_rehash cache_dump cache_repair cache_writeback ca-legacy capsh case catchsegv
cache_check cache_metadata_size cache_restore cal caller captoinfo cat catman
如果你对某个命令，只有模糊的印象，只记得前面的几个字母，这个功能是极好的，命令范围会一步步缩减。
为了开始下面的内容，我们首先介绍一下正则表达式。在前面的一些命令中，也可以使用这些正则表达式，比如less、grep等。
有些书籍，能够把正则表达式写成一本书，我们这里仅作简单的介绍，但足够用了。一般的，正则表达式能用在匹配上，还能够把匹配的内容拿来做二次利用。关于后者，我们在sed命令中介绍。
标志意义
^行首
$行尾
.任意单个字符
*匹配0个或者多个前面的字符
+1个或者多个匹配
?0个或者1个匹配
{m}前面的匹配重复m次
{m,n}前面的匹配重复m到n次
[]匹配一个指定范围内的字符
[^]匹配指定范围外的任意单个字符
\转义字符
[0-9]匹配括号中的任何一个字符,or的作用
``or，或者\b匹配一个单词。比如\blucky\b 只匹配单词lucky
使用下面的命令创建一个文件，我们练习一下grep命令加上E参数后的正则表现。
cat > 996 <<EOF
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
EOF
在终端执行下面命令，注意高亮的部分即为匹配到的字符串。
# 匹配996开头的行
[root@localhost ~]# cat 996 | grep -E ^996
996: 996 is a funcking thing . which make woman as man , man as ass .
# 匹配996结尾的行
[root@localhost ~]# cat 996 | grep -E 996$
we all on the bus , bus bus on the way . 996
# 匹配到icu和icuuuuuu
[root@localhost ~]# cat 996 | grep -E icu+
way to icu. icuuuuuu......
# 再次匹配到996
[root@localhost ~]# cat 996 | grep -E [0-9]
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
[root@localhost ~]# cat 996 | grep -E ^[\^0-9]
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有不包含996的行，良心命令，泪奔
[root@localhost ~]# cat 996 | grep -E -v [0-9]{3}
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配boss和icu
[root@localhost ~]# cat 996 | grep -E boss\|icu
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
# 匹配所有行
[root@localhost ~]# cat 996 | grep -E .
996: 996 is a funcking thing . which make woman as man , man as ass .
we all on the bus , bus bus on the way . 996
way to icu. icuuuuuu......
The greedy green boss rides on the pity programmer
正则表达式非常的重要，在一些sed脚本中，awk脚本中，甚至是vim编辑器中，都会简化你的操作。以上内容应该熟记，达到不需要查找文档的地步。
本小节是学习技巧方面的内容，但我们依然接触到一些硬核知识。这可能是除了正统的命令集合之外，最经常被使用的技巧了。接下来，我们介绍了一些简单的正则，这些正则可用用在很多命令中。我们还提供了一个把man命令变成彩色的小脚本，下面的文章中，会默认你已经把这一步给操作了。
彩色能够增加阅读效果（色盲除外）。
1、回过头去，执行一下man cat，是否发现了一个叫做tac的命令？它是干什么的？
2、上面提到的stat系列，你能想象iostat大体是干什么用的么？
3、grep -v是什么意思？
4、了解一下和mv非常像的rename命令来批量修改文件，看能否使用上面的正则。
5、有些命令如果拼写错误，如何快速修正？靠搜索么？了解一下fuck命令。我没有说错。
6、下面哪种写法表示如果cmd1成功执行，则执行cmd2命令？
咦？小王呢？
环顾四周，一片空空。别说罗马，小王都不见了。
[调教命令行06]条条大道通罗马,罗马罗马你在哪(学习技巧)
标签：小结 which 技术 工作 现在 local 文件目录 ESS ffline
原文地址：https://www.cnblogs.com/lihanlin/p/12619005.html
