【操作系统笔记十二】Linux常用基础命令

Linux 常用快捷键

1. Tab 命令或路径等的补全键，特别常用的快捷键
2. Ctrl + insert 复制命令行内容（常用可提高效率）
3. Shift + insert 粘贴命令行内容（常用可提高效率）
4. Ctrl + C 中断当前任务（退出）
5. Ctrl + Z 暂停当前任务
6. Ctrl + I 清除屏幕所有的内容
7. Ctrl + A 光标迅速回到行首
8. Ctrl + E 光标迅速回到行尾
9. Ctrl + F 光标向右移动一个字符
10. Ctrl + B 光标向左移动一个字符
11. Ctrl + K 剪切（删除）光标处到行尾的所有字符
12. Ctrl + U 剪切（删除）光标处到行首的所有字符
13. Ctrl + W 剪切（删除）光标前的一个字符
14. Ctrl + Y 粘贴 Ctrl + K、Ctrl + U、Ctrl + W 删除的字符
15. Ctrl + H 删除光标前的一个字符（相当于退格键）
16. Ctrl + D 退出当前shell命令行，如果是切换过来的用户，则执行这个命令回退到原用户（相当于exit）
17. Ctrl + R 搜索命令行使用过的历史命令记录 （history命令可以查看历史命令）
18. Ctrl + G 从 Ctrl + R 的搜索历史命令模式中退出
19. Ctrl + S 锁定终端，使任何人无法输入
20. Ctrl + Q 解锁 Ctrl + S 的锁定状态
21. ↑、↓ 切换之前输入的历史命令

Linux 常用命令

帮助命令 man、help、info

在 Linux 的操作系统中我们基本都是使用命令的方式来操作的，比如我们前面看到的 ls、cd、vi 等都是命令，各个命令都是有自己的用法的，我们不可能全部记住每一个命令的用法的，所以每次碰到新的命令的时候，我们可以借助 Linux 提供的帮助命令来查看这个命令的用法。

Linux 提供了三种帮助命令：

1. man
2. help
3. info

对于不了解的命令我们也可以通过网络搜索去学习其用法。接下来我们分别介绍下上面三种帮助命令。

man

man 是 manual 的缩写，可以帮助我们查找一个命令的用法。比如：

man ls
1

man 本来就是一个命令，上面的命令的意思是查看 ls 这个命令的用法。

man 也是一个命令，我们想知道这个命令的用法，可以通过下面的命令来获取 man 这个命令的帮助：

man man
1

man 一共分为 9 章，为什么要分为 9 章呢？这个主要是解决命令重名的问题，比如系统中有两个 passwd，一个是命令，一个是 /etc/passwd 配置文件，那么我们可以通过下面的命令分别查询 passwd 的用法：

## 查询命令的 passwd 的用法帮助
man 1 passwd

## 查询配置文件的 passwd 的帮助
man 5 passwd
1
2
3
4
5

man 默认的情况下是查询第 1 章的帮助。

如果我们不知道一个字符串是命令还是配置文件，我们可以这样来查看它的帮助文档：

man -a passwd
1

这样我们就能查询出所有的 passwd 的帮助文档。

help

Linux 中有两种命令：

• shell (命令解释器) 自带的命令称为内部命令，
• 其他的是外部命令

内部命令通过 man 是获取不到帮助的，比如 cd 这个命令，这个时候我们可以尝试使用 help 命令来获取帮助。

如果是内部命令的话，我们可以这样使用 help 帮助：

ls --help
1

我们可以使用 type 命令来查看一个命令是内部命令还是外部命令：

type cd
1

输出：

cd is a shell builtin
1

说明 cd 这个命令是内部命令。

type ls
1

输出：

ls is aliased to `ls --color=auto'
1

这里 ls 是一个别名，所以这里没有直接说 ls 是一个外部命令，但是 ls 确实是一个外部命令。

info

info 帮助比 help 帮助更详细，作为 help 帮助的补充，如下：

info ls
1

文件目录查看命令 ls 和 cd

ls 命令

• ls ：查看当前目录下的文件，ls 后面可以跟文件或者文件目录名称，比如：

ls /      # 查看根目录下有多少文件
ls /root  # 查看 /root 目录下有多少文件
1
2

我们通过 man 中查看到 ls 的用法如下：

ls [OPTION]... [FILE]...
1

我们看到 FILE 后面带有 ... 表示 ls 后面可以跟多个文件或者文件目录：

ls /root /   # 同时输出 / 目录和 /root 目录下的文件信息
1

通过 man ls 可以知道ls语法是： ls [选项, 选项…] [文件或者目录…]

这里的选项参数主要有：

• -a 显示所有文件及目录 (. 开头的隐藏文件也会列出)
• -d 只列出目录（不递归列出目录内的文件）
• -l 以长格式显示文件和目录信息，包括权限、所有者、大小、创建时间等
• -r 倒序显示文件和目录
• -t 将按照修改时间排序，最新的文件在最前面
• -A 同 -a ，但不列出 “.” (目前目录) 及 “…” (父目录)
• -h 列出文件大小 (例如 1K 234M 2G)
• -F 在列出的文件名称后加一符号；例如可执行档则加 “*”, 目录则加 “/”
• -R 递归显示目录中的所有文件和子目录

我们没必要记住所有的选项的含义，只需要记住几个常见的选项即可。

• ls -l：表示长格式显示 ls 出来的结果，

  如果 ls -l 命令后面没有跟文件名，那么默认的就是显示当前的文件目录中的文件，实际上和 ls -l . 命令是相等的，其中 . 表示当前的文件目录，为了简洁，我们可以将 . 省略掉。

• ls -a：全称 ls -all，查看所有文件，包括当前文件目录中的隐藏文件和隐藏文件目录。

  在 Linux 中，在文件名或者文件目录前面加上 . 表示是隐藏的文件或者文件目录。
  隐藏文件的作用是防止用户在日常操作中不会误操作到隐藏文件，隐藏文件在系统启动以及日常用户操作当中都起着特殊的管理功能。

• ls -r：表示以逆向的顺序进行排序显示，

  一般单独使用的话和 ls 没啥区别，需要配合 ls -l使用如：ls -l -r
  默认情况下是按照文件名称进行逆序排列的，如果想按照时间进行逆序排序的话，我们可以：ls -l -r -t /etc/sysconfig 也可以简化为：ls -lrt /etc/sysconfig

• ls -R：表示递归显示文件夹中的文件。

  注意在 Linux 中的命令的选项是区分大小写的，所以 ls -R 和 ls -r 的功能是不一样的。
  我们可以将 -R 选项和前面的选项进行组合：ls -lartR /etc/sysconfig 该命令的作用就是列出 /etc/sysconfig 目录中的所有的文件以及子文件夹中的子文件

• ls -lh：以长格式的形式查看当前目录下所有可见文件的详细属性，并且显示此时文件大小。

cd 命令

• cd： 更改当前的操作目录，如 cd /root表示进入 /root 目录下
• cd ..：回到上一级目录
• cd - ：用于两个目录相互切换，哪来的，就回到哪儿
• cd /path/to/... ：绝对路径
• cd ./path/to/... ：相对路径
• cd ../path/to/... ：相对路径

pwd 命令

• pwd ：显示当前的工作目录名称，如果不知道 pwd 的用法的话，可以使用 man pwd 来查看。

创建和删除目录命令 mkdir 和 rm

mkdir 命令

作用是创建一个空的文件目录，功能和 windows 中的新建文件夹是一样的。

mkdir /a      # 在根目录下创建一个名字为 a 的文件目录
mkdir ./a     # 在当前目录下创建一个名字为 a 的文件目录
mkdir a       # 同上，可以省略 ./ 
mkdir b c d   # 在当前目录下创建多个文件，如果目录已经存在的话，则创建不了文件目录
mkdir /a/b/c  # 创建多级目录，如果在不存在的文件目录中则创建不了子目录
1
2
3
4
5

rm 命令

rm -r /a  # 删除非空目录a，无法递归删除，需要逐级确认
rm -rf /a # 删除非空目录a，递归删除，不需要确认（慎用，删除之前一定要三思而后行）
rmdir /a  # 只能删除空目录
1
2
3

复制和移动文件命令 cp 和 mv

cp 命令

copy 的缩写，用于文件的复制

cp /root/a /tmp 
cp -r /root/a /tmp   # cp 是用来复制文件的，默认情况下复制目录会报错，需要加上 -r 参数来复制目录
ls /tmp
1
2
3

touch /filea      # 先创建一个文件：
cp /filea /tmp    # 复制文件
ls /tmp

cp -v /filea /tmp   # 显示复制时候的进度
1
2
3
4
5
6

默认情况下，复制后的文件的时间和原先文件的时间不一致，如果我们想保持时间一样的话，可以：

cp -p /filea /tmp
1

mv 命令

move 的缩写，有两个功能：

1. 文件移动功能
2. 文件重命名

mv /filea.txt /fileb.txt     ## 重命名
mv /fileb.txt /tmp           ## 文件移动
ls /tmp

mv /tmp/fileb.txt /filec.txt  ### 文件移动加重命名

## 移动目录
mkdir /dirc
mv /dirc /tmp
1
2
3
4
5
6
7
8
9

通配符

• * 表示匹配多个字符
• ? 表示匹配单个字符

cd /tmp
touch filea fileb filec

mkdir -p dira dirb dirc

## 复制以 file 开头的文件
cp -v file* /

touch fileaa fileabc
cp -v file* /
1
2
3
4
5
6
7
8
9
10

touch fileaa fileabc filea fileb filec

## 显示以 file 开头的文件
ls file*

## 匹配单个字符
cp file? /

ls file?
1
2
3
4
5
6
7
8
9

文件内容查看命令 cat、head、tail、more、less

• cat 文本内容显示到终端，用于文本中行数较少的场景
• head 查看文件开头
• tail 查看文件结尾，常用参数 -f 表示文件内容更新后，显示信息同步更新
• wc 统计文本的行数
• more 和 less 命令用于翻页和搜索

cat 命令

## 我们先创建一个名为 test 的空文件：
touch test

### 查看文本
cat test

### 往文件 test 中追加内容
echo "this is an example" > test

cat test

## 再次执行往 test 中追加内容
echo "this is another example" > test

## 再次 cat 查看文件内容，发现之前的数据被覆盖了
cat test

## 如果在往文件中写内容的时候，不覆盖原先的内容的话，可以这样：
echo "this is an example" >> test
echo "this is another example" >> test

cat test
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

echo 就和 Java 中的 System.out.println() 功能差不多

我们继续往文件中不断的追加内容：

echo "this is another example 1" >> test
echo "this is another example 2" >> test
echo "this is another example 3" >> test
echo "this is another example 4" >> test
echo "this is another example 5" >> test
echo "this is another example 6" >> test
echo "this is another example 7" >> test
echo "this is another example 8" >> test
echo "this is another example 9" >> test
echo "this is another example 10" >> test
echo "this is another example 11" >> test
echo "this is another example 12" >> test
echo "this is another example 13" >> test
echo "this is another example 14" >> test
echo "this is another example 15" >> test
echo "this is another example 16" >> test
echo "this is another example 17" >> test
echo "this is another example 18" >> test
echo "this is another example 19" >> test
echo "this is another example 20" >> test

cat test
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

head 和 tail 命令

• head 命令用于查看文件内容的前面内容：

## 默认的话是查看文件的前 10 行
head test

## 如果想指定查看前 3 行的话可以：
head -n3 test

## 可以直接简写成：
head -3 test
1
2
3
4
5
6
7
8

• tail 命令用于查看文件的后面的内容：

## 默认的话是查看文件的后 10 行
tail test

## 如果想指定查看后 3 行的话可以：
tail -n3 test

## 可以直接简写成：
tail -3 test

## 我们可以查看动态的文件内容，即当文件增加内容的时候，就实时的打印出来，使用 -f 选项
tail -f test

## 这个时候我们向 test 文件中追加内容
echo "this is another example 21" >> test
echo "this is another example 22" >> test
echo "this is another example 23" >> test

## 上面的 tail -f 会实时的打印数据出来
## tail -f 默认是一开始查询后面的 10 行数据，如果想一开始查询文件的后面的 15 行数据的话，可以：
tail -fn15 test
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

tail -fn 文件名，一般用来实时查看日志文件

wc 命令

上面我们可以看出，如果文件的行数不多的话，可以使用 cat 命令来查看文件内容，如果文件行数太多的话，我们可以选择使用 head 和 tail 了。

那么怎么知道一个文件的行数到底有多少呢？我们可以通过 wc 这个命令来查询一个文件的行数：

## 查看文件 test 的行数
wc -l test

wc -l /etc/man_db.conf
1
2
3
4

more 和 less 命令

more 和 less 也是用于查看文件，只是这两个命令在查看文件内容的时候是允许翻页的。

• more 一页一页的显示文件内容：

more /etc/man_db.conf

## 向下翻一页：空白键(space) 
## 向下翻一行：回车键(Enter)
## 向上翻一页：字母键(b)
## 向下搜索指定的字符串：/字符串，比如 /path 表示向下搜索 path 
## 退出 more 命令：字母键(q)
1
2
3
4
5
6
7

• less 一页一页的显示文件内容，搜索的时候比 more 更加灵活

less /etc/man_db.conf

## 向下翻一页：空白键(space) 或者 [PgDn] 键
## 向下翻一行：回车键(Enter)
## 向上翻一页：[PgUp] 键
## 向下搜索指定的字符串：/字符串，比如 /path 表示向下搜索 path 
## 向上搜索指定的字符串：?字符串，比如 ?path 表示向上搜索 path 
## 重复前一个搜索：字母键 n
## 反向重复前一个搜索：字母键 N
## 翻到文件的第一页 ：字母键 g
## 翻到文件的最后一页：字母键 G
## 退出 less 命令 ：字母键 q
1
2
3
4
5
6
7
8
9
10
11
12

打包压缩和解压缩命令

打包 tar

在 Linux 中对文件进行备份的时候，一般先使用 tar 命令进行打包，比如我们接下来对 /etc 目录进行打包：

## /etc 下的文件是系统中常用的配置文件，是我们常见的备份目录
ls /etc

## 打包 /etc 成一个文件
## 选项 c 是表示执行打包操作
## 选项 f 是表示打包成一个文件
tar cf /tmp/etc-backup.tar /etc

## 查看打包后的文件的大小：
ls -l /tmp/etc-backup.tar

## 文件大小以 MB、GB 等显示
ls -lh /tmp/etc-backup.tar
1
2
3
4
5
6
7
8
9
10
11
12
13

一般的情况下，打完包之后会进行压缩，将文件的内容压缩下，使得占用磁盘空间变少。

Linux 中压缩一般使用 gzip 和 bzip2 来进行压缩，但是 tar 命令已经集成了这两种压缩方式，如下：

## 使用 gzip 压缩打包后的文件，在 tar 命令中增加 z 选项
## 压缩后的文件名一般使用 .gz 来表明这个文件是使用 gzip 来压缩的
tar czf /tmp/etc-backup.tar.gz /etc

## 使用 bzip2 压缩打包后的文件，在 tar 命令中增加 j 选项
## 压缩后的文件名一般使用 .bz2 来表明这个文件是使用 bzip 来压缩的
tar cjf /tmp/etc-backup.tar.bz2 /etc

## 执行上面的命令会报错
## 这个是因为我们安装的最小化的 centos 7 默认没有安装 bzip2
## 可以通过下面的命令来安装下 bzip2
yum -y install bzip2

## 然后就可以使用 bzip2 来压缩：
tar cjf /tmp/etc-backup.tar.bz2 /etc

## 但是我们发现使用 bzip2 压缩需要的时间比 gzip 的要慢一些
## 这个是因为 bzip2 压缩的程度比 gzip 要大
## 我们可以看下压缩后的文件的大小：
ls -lh /tmp/etc-backup.tar*

## 可以发现，使用 bzip2 压缩的文件的大小最小，也就是压缩的程度最大了
## 选择使用 bzip2 压缩还是使用 gzip 压缩，这个取决于你的需求了
## 如果你想要压缩速度的话，那么选择使用 gzip
## 如果你想要大的压缩比的话，那么选择使用 bzip2 
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

.tar.gz 有的时候会缩写成 .tgz
.tar.bz2 有的时候会缩写成 .tbz2

解压缩

如果我们拿到一个打包并且压缩后的文件，我们想解压缩的话，我们仍然可以使用 tar 命令了。

## 解包
## x 表示执行的是解包
## f 表示的是解包文件
## -C 表示将解包后的文件放在指定的文件目录下，如果不加 -C 选项的话，则表示将解包之后的文件放在当前的目录中
tar xf /tmp/etc-backup.tar -C /root

## 如果我们想对压缩后的文件进行解压缩，可以使用：
## gzip 压缩的使用：
tar zxf /tmp/etc-backup.tar.gz -C /root

## bzip2 压缩的使用：
tar jxf /tmp/etc-backup.tar.bz2 -C /root
1
2
3
4
5
6
7
8
9
10
11
12

vi 的四种模式

我们知道 windows 可以对文本文件内容进行编辑、删除、复制、粘贴等，Linux 中的 vi 命令也提供了强大的文本编辑功能，我们可以使用 vi 对 Linux 上的文件内容进行编辑、删除、复制、粘贴等。

为了使得文本编辑的功能变的很强大，vi 支持了 4 种模式：

1. 正常模式（Normal Mode）
2. 插入模式（Insert Mode）
3. 命令模式（Command Mode）
4. 可视模式（Visual Mode）

每种模式下都可以完成不同的文件操作功能。我们在 Linux 中输入 vi ，得到如下的界面：

从上可以看出 vim 是 vi 命令的扩展，在 vi 的基础之上做了很多的扩展。

以上进入的界面就是以正常模式。我们在正常模式中输入小写的字母 i 就可以进入插入模式，如下：

在插入模式按 ESC 键就可以转换到正常模式，在正常模式下面输出冒号(:) 就可以进入命令模式，如下：

在命令模式中按 ESC 就可以进行正常模式，在正常模式下输出字母 v 就可以进入可视模式，如下：

vi 的正常模式

打开 vim 编辑器：

## 可以直接执行 vi 打开 vi 编辑器
vi

## 也可以在 vi 后面加上需要编辑的文件
vi test
1
2
3
4
5

当我们通过上面的命令是进入到 vi 的正常模式，我们可以使用下面的方式进入到插入模式：

1. 输入字母 i ：表示在光标当前的位置进入到插入模式
2. 输入字母 I ：表示进入插入模式，只是光标定位到了所在行的开头
3. 输入字母 a ：表示进入插入模式，只是光标定位到之前光标所在位置下一个位置
4. 输入字母 A ：表示进入插入模式，只是光标定位到所在行的结尾
5. 输入字母 o ：表示进入插入模式，只是光标定位到所在行的下一行
6. 输入字母 O ：表示进入插入模式，只是光标定位到所在行的上一行

在正常模式下的操作：

1. 控制光标的上下左右
   H 表示向左
   L 表示向右
   J 表示向下
   K 表示向上
   键盘中的上下左右键也可以控制光标，但是有的时候不能，所以建议还是熟练使用 HJKL 来控制光标
2. 复制 (y 命令)
   yy 表示复制一行
   p 表示粘贴，多次输入 p 则是多次粘贴
   3 yy 表示复制 3 行
   y$ 表示复制光标开始到结尾的内容
3. 剪切 (d 命令)
   dd 表示剪切一行 (也可以用于删除一行)
   d$ 表示剪切光标开始到结尾的内容
4. 撤销命令 ：输入字母 u
5. 重做命令 ：输入 ctrl + r
6. 单个字符删除的命令：输入字母 x
7. 替换字符的命令：输入字母 r
8. 切入到命令模式，然后输入 set nu，就会显示文本内容中的行号，我们可以通过 数字+G 快速使得光标跳到指定的行
9. 快速使光标移动到第一行：输入字母 g
10. 快速使光标移动到最后一行：输入字母 G
11. 快速使光标移动到当前行的开头：输入字母
12. 快速使光标移动到当前行的结尾：输入字母 $

vi 的命令模式

在插入模式中对文件做了修改后，我们想对文件进行保存的话，我们需要输入 ESC 键进入正常模式，然后输入 : 进入命令模式，然后我们在 : 的后面输入：

## w 表示保存的意思
w /root/a.txt

## 保存当前文件并退出，可以输入
wq

## 使用 vi 打开指定文件
vi /root/a.txt

## 保存退出
:wq 

## 不保存但是退出
:q!
1
2
3
4
5
6
7
8
9
10
11
12
13
14

在命令模式下还可以执行其他的命令，比如我们在命令模式下想执行查看 ip 的命令，我们可以在 : 后面输出：!ifconfig

命令行模式还可以查找和替换：

1. 查找：
   在正常模式中输出 / 进入搜索界面，在 / 后面输入需要查找的字符串
   输入字母 n 将光标定位到下一个查找到的字符串，字母 N 将光标定位到上一个
2. 替换：
   语法 :s/old/new ，比如将小写的 x 替换成大写的 X ，:s/x/X。:s只是针对光标所在的行进行替换
   语法 :%s/old/new，这个是对全文进行替换，这里默认只会替换一次
   替换多次的话，可以 :%s/x/X/g
:3,5s/x/X 表示在第 3 行到第 5 行之间进行单词替换
3. 对 vi 设置
   设置行号：set nu
   取消行号：set nonu

vi 的可视模式

从正常模式进入到可视模式的三种方式：

1. 输入小写的 v ，这个叫做字符可视模式，光标是以字符为单位移动的
2. 输入大写的 V ，这个叫做行可视模式，光标是以行为单位移动的，移动光标的时候是对行进行选定
3. 输入 ctr l+ v 的时候，这个叫做块可视模式，这个是用的最多的模式，当光标移动的时候是选中块的，我们现在可以：
   1）在选定的块之前插入内容，可以输入大写的 I，来插入内容，然后按两下 ESC 即可
   2）删除选定的块，先选定块，然后按字母 d 就可以删除块

命令别名和历史命令

别名

在 cmd 中我们可以使用 cls 命令来清屏，而在 linux 中，则使用 clear 来清屏，我们发现 clear 比 cls 更长，书写起来没有 cls 方便，那么我们可以在 linux 中使用 cls 来作为清屏的命令吗？答案是可以的，可以使用 alias 命令将 clear 命令别名为 cls 即可，如下：

alias cls=clear

## 使用 cls 来进行清屏
cls
1
2
3
4

我们可以通过下面的命令来查看所有的别名：

alias

## 输出所有的别名
alias cls='clear'
alias cp='cp -i'
alias egrep='egrep --color=auto'
alias fgrep='fgrep --color=auto'
alias grep='grep --color=auto'
alias l.='ls -d .* --color=auto'
alias ll='ls -l --color=auto'
alias ls='ls --color=auto'
alias mv='mv -i'
alias rm='rm -i'
alias which='alias | /usr/bin/which --tty-only --read-alias --show-dot --show-tilde'
1
2
3
4
5
6
7
8
9
10
11
12
13
14

以上输出包括我们自己定义的别名，和系统事先定义好的别名，有几个别名我们需要来看下：

• ls 是 ls --color=auto 的别名，可以通过 man 来查看 --color 有多少个取值
• ll 是 ls -l --color=auto 的别名

如果我们想删除别名的话，使用 unalias ：

## 删除 cls 别名
unalias cls

## 查询所有的命令
alias
1
2
3
4
5

历史命令

我们可以使用命令 history 来查询我们曾经执行过的命令。

## 1. 列出所有的历史命令
history

## 2. 列出目前最近的 3 条历史命令
history 3

## 在默认的情况下，在服务器注销的时候，会将历史记录写入 ~/.bash_history 文件中
## 我们也可以强制将历史命令写到文件中
history -w

## 默认的话是保留 1000 条历史命令的。
1
2
3
4
5
6
7
8
9
10
11

我们除了可以查询历史命令外，还可以执行历史命令，如下：

## 执行第 784 个历史命令
!784

## 执行最近的以 ls 开头的历史命令
!ls

## 执行上一个命令 
!!
1
2
3
4
5
6
7
8

用户管理常用命令

Linux 是一个多用户多任务的系统，多而用户可以同时登录到同一个 Linux 服务器中，并且同时操作系统。

那么在 Linux 中有两种用户：

1. root 用户，这个用户就是上帝，拥有一切权限，可以访问系统的任何地方
2. 普通用户，除了 root 用户之外的所有用户，普通用户的权限是受限的

在实际的应用当中，我们一般不建议使用 root 用户登录服务器，因为它的权限太大了，可以删除任何东西，这样太危险了，如果不小心删除了什么东西的话，那就会导致系统瘫痪了。

在平时工作中我们都是以普通用户登录到 Linux 服务器的，在系统刚刚安装的时候是没有普通用户的，那么可以通过 useradd 命令来创建一个普通用户：

useradd user1
1

那么当我们执行了创建用户的操作之后，系统都做了哪些操作呢？

1. 系统为每一个用户分配了一个唯一的 id ：

## root 用户的 id 是 0
id root

id user1

id abc
1
2
3
4
5
6

2. 创建了这个用户的家目录(或者说主目录)，比如 root 用户的主目录是 /root，user1 用户的家目录是 /home/user1，这个文件目录默认是空的，但是存在隐藏文件，这些隐藏文件就是这个用户的相关配置文件
3. 创建的这个用户的信息还会记录到 /etc/passwd 这个配置文件中，可以通过 tail -10 /etc/passwd 来查看
4. 创建的这个用户的信息还会记录到 /etc/shadow 这个配置文件中，可以通过 tail -10 /etc/shadow 来查看，这个配置文件是用户的密码配置

注意：只有 root 用户才可以创建普通用户

接下来我们需要为创建好的用户设置密码，可以使用 passwd 命令：

passwd user1

## 直接修改当前 root 用户的密码，可以：
passwd
1
2
3
4

这个时候我们可以通过客户端 xshell 去连接这个 user1 用户了。

有些情况下下，我们需要给用户分组，相同组的用户可以享受相同的权限、配置等。

我们使用 id user1 可以看出来，默认情况下，在创建用户的时候，也会创建一个名为用户名的组，那么创建的这个用户就是属于这个用户组的。

我们也可以自己使用命令 groupadd 来创建一个新的用户组：

groupadd group1
1

然后通过 usermod 命令来修改用户 user1 属于 group1 这个组：

usermod -g group1 user1

id user1
## 可以看出用户 user1 所属的组就被改成 group1 了
1
2
3
4

我们也可以在创建用户的时候直接指定这个用户所属的组：

useradd -g group1 user2

id user2
1
2
3

我们可以通过 userdel 的命令删除一个用户：

## 通过下面的命令删除 user1 用户，但是 user1 的家目录还是保留着
userdel user1

ls /home

## 如果我们想删除用户的时候也将这个用户的家目录删除的话，需要：
userdel -r user2

ls /home
1
2
3
4
5
6
7
8
9

我们可以通过 groupdel 命令删除一个用户组：

groupdel group1
1

su 命令

可以直接从 root 用户切换到其他的普通用户下面，如下：

## 先建一个名为 bigdata 的用户，并设置密码
useradd bigdata
passwd

## 从 root 用户直接切换到 bigdata 用户下
su - bigdata 
## 切换到 bigdata 用户，并且进入到了 bigdata 的家目录
pwd

## 这个时候访问 root 的家目录是没有权限的，如下
cd /root

## 如果 su 后面不跟 - 的话，那么就不会进入到 bigdata 的家目录
su bigdata

pwd

## 这个时候直接访问当前的目录是没有权限的
ls

## 需要切换目录才能来到自己的家目录
cd /home/bigdata

## 没有带 - 不是很方便，一般的话都会使用 su - 来切换用户
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

sudo 命令

在 Linux 中有一个名为 shutdown 的命令是用来关机的，这个命令只有 root 用户可以执行，默认情况下，其他的用户是执行不了的。比如我们在 root 用户下执行：

## 命令系统 30 分钟后执行关机
shutdown -h 30

## 我们也可以通过下面的命令取消上面的关机计划
shutdown -c
1
2
3
4
5

当然，上面的两条命令默认都是只能在 root 账号下执行的，假设我们现在想在 bigdata 用户下执行 shutdown -c 命令的话，我们该怎么办呢？其实呢，有两种方案：

1. 我们在 bigdata 用户下使用 su 来切换到 root 用户，然后执行命令，这种方案有一个缺点：普通用户知道了 root 的密码，这个是非常危险的，所以我们在实际的生产环境中是不建议这么做的
2. 使用 sudo 命令来执行，接下来我们详细讲解怎么使用 sudo 命令

我们要完成上面的需求，只需要让 root 用户将执行 shutdown -c 这条命令的权限给 bigdata 用户即可，我们可以在 root 用户下执行：

## 设置执行指定命令的权限给指定的用户或者用户组
visudo 

## 在最后加上配置
bigdata ALL=/sbin/shutdown -c
1
2
3
4
5

然后我们重新进入 bigdata 用户，执行：

sudo /sbin/shutdown -c 
1

就完成了上面的需求了。

有的时候，在练习的时候，我们一般喜欢把一个普通用户的权限设置的和 root 权限一样，因为这样很方便，可以在 visudo 中添加：

## 使用 sudo 的时候不需要输入密码
## 这样 bigdata 的权限和 root 的一样
## 只是执行的时候需要使用 sodu 来执行
bigdata ALL=(ALL) NOPASSWD: ALL
1
2
3
4

用户(组)配置文件

和用户(组)相关的配置文件有 3 个：

1. /etc/passwd 用户相关的配置文件
2. /etc/shadow 用户密码相关的配置文件
3. /etc/group 用户组相关的配置文件

1. /etc/passwd

执行如下的命令：

vi /etc/passwd
1

输出如下：

这个配置文件的每一行表示一个用户，每个用户有 7 个字段，意义分别如下：

1. 用户名
2. x 表示登录的时候需要进行密码验证，每过不写的话，则表示不需要密码验证
3. 用户的唯一 id，Linux 系统中是通过这个 id 来识别用户的
4. 用户所属组的唯一 id
5. 表示对用户的注释
6. 用户的家目录
7. 用户登录的命令解释器，就是用户登录成功后，用来解释用户输入的命令，现在通用的命令解释器就是 /bin/bash，/sbin/nologin 则表示禁止这个用户登录

2. /etc/shadow

执行如下的命令：

cat /etc/shadow
1

输出如下：

这个文件主要是存储用户设置的密码的，密码都是经过了加密的，并且相同的密码经过加密后也是不一样的。

我们主要是掌握如下两个字段：

1. 用户名
2. 用户密码

3. /etc/group

这个文件主要是存储用户组的配置信息的，执行如下的命令：

vi /etc/group
1

输出如下：

字段的含义：

1. 用户组的名字
2. 登录的时候是否需要验证密码
3. 用户组 id ，即 gid
4. 属于这个组的用户，这个组是这个用户的其他组 id postfix

更改文件的属主和属组

在 Linux 中，不管是文件还是文件目录都有自己所属的用户和自己所属的用户组，如下：

以上：

• 1 就是文件所属的用户，我们也称为属主
• 2 就是文件所属的用户组，我们也称为属组

我们可以通过命令 chown 来修改属主和属组，如下：

## 修改文件目录的属主为 bigdata
chown bigdata /root/test 

## 修改文件目录的属组为 bigdata
chown :bigdata /root/test

## 现在新增一个用户组
groupadd group1

## 修改文件目录的属组为 group1
chgrp group1 /root/test
1
2
3
4
5
6
7
8
9
10
11

文件和目录的权限

在 Linux 中的文件和文件目录都有自己的权限控制：

下面详细介绍：

第一个字符表示文件的类型：

• - 表示普通文件
• d 表示文件目录
• b 表示块特殊文件
• c 表示字符特殊文件
• l 表示符号链接，和 windows 中的快捷方式类似
• f 表示命名管道
• s 表示套接字文件

后面 9 个字符表示的是对应文件的权限，文件权限的表示和文件类型有关，我们分别来了解下普通文件和文件目录权限的表达。

我们先创建 2 个用户组：

groupadd group1
groupadd group2
1
2

然后再创建 3 个用户并指定所属的用户组：

useradd -g group1 user1
useradd -g group1 user2
useradd -g group2 user3
1
2
3

普通文件的权限表达

• r 表示可读权限
• w 表示可写权限
• x 表示可执行权限

也可以使用数字来表达上面的权限：

• r = 4
• w = 2
• x = 1

我们先来看下权限的修改，可以使用 chmod 命令来修改文件的权限：

touch testfile
ls -l testfile

## 默认的权限是  rw-r--r--，表示属主对这个文件具有可读可写权限，属组对这个文件具有可读权限，其他用户对这个文件具有可读权限
## 需求一：修改属主的权限为 rwx
chmod u+x testfile
ls -l testfile

## 需求二：修改属主的权限为 -wx
chmod u-r testfile
ls -l testfile

## 需求三：修改属主权限为 ---
chmod u-wx testfile
ls -l testfile

## 需求四：修改属主权限为 rw- 权限
chmod u+rw testfile
ls -l testfile

## 需求五：修改属主权限为 x 权限
chmod u=x testfile
ls -l testfile

## 需求六：修改属主权限为 rwx
chmod u=rwx testfile
ls -l testfile

## 需求七：修改属组权限为 rw-
chmod g+w testfile
ls -l testfile

## 需求八：修改属组权限为 ---
chmod g-rw testfile
ls -l testfile

## 需求九：修改属组权限为 rwx
chmod g=rwx testfile
ls -l testfile

## 需求十：修改其他用户权限为 rw
chmod o+w testfile
ls -l testfile

## 需求十一：修改其他用户权限为 ---
chmod o-rw testfile
ls -l testfile

## 需求十二：修改其他用户权限为 rwx
chmod o=rwx testfile
ls -l testfile

## 需求十三：修改属主的权限为 rw- 属组的权限为 r-x 其他用户的权限为 r--
chmod u=rw testfile
chmod g=rx testfile
chmod o=r testfile

## 我们可以使用数字来表达：
chmod 654 testfile

## 需求十三：修改属主的权限为 rwx 属组的权限为 --x 其他用户的权限为 r-x
chmod 715 testfile
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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

我们先在 root 用户下创建一个文件：

touch /tmp/afile

ls -l /tmp/afile
## 创建的文件的默认的属主是 root，属组也是 root，而且还有默认的权限 rw-r--r--

## 修改文件的属主为 user1，属组为 group1
chown user1:group1 /tmp/aflie

## 设置文件只能被属主查看
chmod 400 /tmp/afile
ls -l /tmp/afile

## 在 root 用户下将数据写入到文件中
echo 123 > /tmp/afile

cat afile

## 切换到 user1 用户
## 可以查看文件
cat /tmp/afile
## 但是不能写入文件，下面的命令没有权限执行
echo 345 > /tmp/afile

## 相同属组的用户和其他用户都没有任何权限
exit
su - user2
cat /tmp/afile

exit
su - user3
cat /tmp/afile

## 测试文件的写权限
exit
chmod 200 /tmp/afile
ls -l /tmp/afile

su - user1
## 可写
echo 456 > /tmp/afile
## 但是不能查看
cat /tmp/afile 

## 相同属组的用户和其他用户都没有任何权限
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
31
32
33
34
35
36
37
38
39
40
41
42
43
44

上面我们进行的属主的权限设置，接下来看下属组的权限设置：

exit
touch /tmp/bfile
ls -l /tmp/bfile

## 修改属主和属组
chown user1:group1 /tmp/bfile
ls -l /tmp/bfile

## 现在修改文件的权限为：----w----，即同一属组的用户具有可写权限
chmod 020 /tmp/bfile
ls -l /tmp/bfile

## 进入到 user1 
## 对文件没有写的权限，因为这个文件的属主对这个文件没有任何的权限
echo 111 > /tmp/bfile

## 进入到属于 group1 组的 user2 用户，可以写成功，因为这个文件允许属于 group1 组的用户进行写文件
exit
su - user2
echo 111 > /tmp/bfile

## 进入到 user3 是不能写入文件的
exit
su - user3
echo 111 > /tmp/bfile

## 切换到 root 用户，修改文件的其他用户的权限为 rw-
exit
chmod o=rw /tmp/bfile

## 那么进入 user3 用户，是可以写文件的
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
31

文件目录的权限表达

• x 表示可进入目录
• rx 表示可以进入到目录，并且查看目录内的文件名
• wx 表示可以进入到目录，并且修改目录的文件名

我们来看一下文件目录的权限控制：

## 进入到 root 用户，创建一个文件目录
mkdir /test
ls -ld /test

## 修改目录的属主和属组
chown user1:group1 /test
ls -ld /test

## 在 /test 目录下创建两个文件
touch /test/afile
touch /test/bfile
ls -l /test

## 修改目录的权限为 r--------
chmod 400 /test
ls -ld /test

## 进入到 user1，然后尝试进入 /test 目录，发现权限不够
su - user1
ls -l /test
## 只能看到这个目录中的文件名，其他的信息都看不到
## cd 也进不去，说没有权限
cd /test
exit

## 说明对于目录，r 权限并不是表示可读的权限，如果我们需要能进入文件目录的权限，需要将权限设置为 x 权限

## 修改目录的权限为--x------
chmod u=x /test
su - user1
## 可进入目录
cd /test
## 但是不能看出目录中的文件，下面的命令会报错
ls 
exit

## 如果我们想能进入目录并且可以查看文件目录中的文件的话，需要设置权限为 rx
chmod u=rx /test
su - user1
## 可进入目录
cd /test
## 可以查看这个目录下的文件
ls
## 但是却不能对文件进行修改，下面的命令会报错
mv afile cfile
exit

## 想要对目录中的文件进行修改的话，需要设置权限 wx
chmod u=wx /test
su - user1
## 可进入目录
cd /test
## 但是不能查看这个目录下的文件
ls 
## 可以对文件进行修改
mv afile cfile
exit

## 如果相对文件目录技能进入，查看里面的文件，并且进行修改的话，需要将权限设置维 rwx
chmod u=rwx /test
su - user1
## 可进入目录
cd /test
## 能查看这个目录下的文件
ls 
## 可以对文件进行修改
mv cfile afile
exit
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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

最后看一个和文件以及目录权限都相关的一个场景

## 将文件 /test/afile 的权限设置为 可读可写可执行
chmod 777 /test/afile
ls -l /test/afile

su - user2
## 不能对文件 /test/afile 进行修改，下面的命令报权限不足的错
ls -l /test/afile

## 这个是因为，user2 对文件目录 /test 都没有进入的权限
## 修改 /test 的权限为 rwxr-x---
exit
chmod g=rx /test

su - user2
## 有查看权限
ls -l /test/afile
## 也可以修改文件了
echo 123 > /test/afile
exit

su - user3
## 使用 vi 的时候提示没有权限，只是一个可读的文件
vi /test/afile
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

进程管理命令

ps 命令

进程就是正在运行的程序，是资源分配的单位。

你如果想知道在 Linux 系统中有多少进程在运行的话，我们可以通过如下的命令来查询：

## ps 命令是 process status 的缩写，表示进程的状态
ps
1
2

输出如下：

ps 命令用来查询当前终端有多少个进程在运行，从上可以看出有 2 个进程在运行。

以上的输出中，我们一般会关心第一个和第四个字段：

• PID 表示一个进程的唯一 ID，用来唯一标识一个进程的，所以说，以后我们想查询具体某个进程的话，就需要通过 PID 来查询了
• CMD 表示该进程运行的命令，也就是进程的名字
• 不同进程的 PID 一定是不同的，但是名字可以是一样的

如果我们想查询这台服务器中所有的进程的话，可以通过下面的命令查询：

ps -e
1

执行上面的命令就可以显示这台服务器上所有的进程了。

我们也可以使用 man ps 来查看 ps 更多的选项。那么我们经常用的选项除了 -e 外，还有一个是 -ef，如下：

ps -ef
1

输出如下：

可以发现显示的进程的信息更加的丰富了，我们对我们关心的字段做个说明：

• UID 表示启动该进程的用户
• PPID 表示该进程的父进程 ID，在这里我们需要注意的是所有的进程都是有父进程的，都需要从父进程中继承一些属性的

第一个进程是 0 号进程，也成为 idle 进程，它是所有进程的祖先，后面的 1 号进程就是它启动的。系统的空闲时间，其实就是指 idle 进程的"运行时间"

从上面可以看出，每个进程都有自己的父进程，当然 0 号进程除外，所以进程实际上是以树状的结构组织起来的。这个我们可以通过命令 pstree 来验证：

## 先下载安装 pstree
yum -y install psmisc

## 执行
pstree
1
2
3
4
5

输出如下：

top 命令

top 命令用来查看每个进程消耗的资源等信息

执行如下的命令：

top
1

输出如下：

输出分为两大块：上面部分是系统状态信息、下面部分是每个进程状态信息

在系统状态信息中分别解释：

• 第一行：开机时间、系统运行了多少时间、有几个用户在用、平均负载用于衡量系统的繁忙程度的
• 第二行：进程任务的个数、运行任务的个数、睡觉任务的个数
• 第三行：CPU 的使用情况，%CPU(s) 表示多个 CPU 的平均值，我们可以按数字 1 查看每一个 CPU 的状态信息。us 表示用于对 CPU 的使用率，sy 表示系统对 CPU 的使用率
• 第四行：内存的使用情况
• 第五行：交换分区(相当于 Windows 中的虚拟内存)的使用情况

在每个进程状态信息中，对于开发人员会非常关心两个字段：

• %CPU 表示该进程使用 CPU 的占比
• %MEN 表示该进程使用内存的占比

默认情况下，每 3 秒会更新一次每个进程状态信息，我们可以按字母 s ，然后输入你想多长时间更新一次

输入字母 q 可以退出 top 命令。

kill 命令

有的时候进程间需要进行通讯，比如我们在终端想去停止掉一个进程，这就需要和需要停止的进程进行通讯，在 Linux 中可以使用信号来进行进程之间的通讯。

下面我们就来看看如何 kill 一个进程，我们可以通过下面的命令查看下 kill 到底有多少中信号：

kill -l
1

输出为：

可以看出，总共有 64 个信号。我们常用的两个信号是：

• 2 号名为 SIGINT 的信号，实际上当我们执行 ctrl + c 来停止进程的时候，实际上就是发送的 2 号信号
• 9 号名为 SIGKILL 的信号，当发送这个信号的话，那么进程会立马停止进程
• 两者的区别是：
  2 号信号程序在结束之前,能够保存相关数据,然后再退出
  9 号信号直接强制结束程序，有可能会丢失数据

我们现在在终端启动一个 nc 服务：

nc -l -p 5001
1

然后启动另一个终端，使用 ps -ef 可以查看到这个进程的状态信息：

这个 nc 进程的 PID 是 11603，知道这个 PID 之后，我们就可以使用 kill 命令来停止这个进程，如下：

kill -2 11603

## 或者
kill -9 11603
1
2
3
4

当然，我们也可以在启动 nc 的终端使用 ctrl + c 来停止这个 nc 进程

进程的启动方式

到现在为止，我们都是直接在终端上启动一个进程的，如下启动 nc 服务进程：

## 先创建一个文件
touch /root/test.txt

## 然后动态的查看这个文件中的数据
tail -f /root/test.txt
1
2
3
4
5

但是这种启动方式有一个严重的问题，那就是当我们关闭当前的终端的时候，这个进程也会停止了，这个不是我们想要的，我们可以通过如下的两种方式：

1. nohup 与 & 配合
2. screen

nohup 与 & 配合

我们可以先在上面的命令后面加上 & 字符，表示控制进程在后台运行，如下：

tail -f /root/test.txt &
1

这样，当关闭终端的时候，这个进程还在的，但是这种方式有个缺点就是查询的数据你看不到了，这个时候我们可以通过 nohup 命令来记录查询到的数据，如下：

## 关闭上面启动的进程
## 先查询 PID
ps -ef | grep tail
## 然后根据 PID 来停止进程
kill -9 12657

## 使用 nohup 和 & 配合来启动命令
nohup tail -f /root/test.txt &
1
2
3
4
5
6
7
8

执行上面的命令的话，就会在当前目录中创建一个名为 nohup.out 的文件，那么 tail 动态查询的数据都是放在这个文件中了。

screen

先要安装 screen ：

yum -y install screen
1

然后在终端上输入：

## 进入 screen
screen

## 在 screen 中输入需要执行的命令
tail -f /root/test.txt

## 退出 screen
## ctrl + a，然后输入字母 d
1
2
3
4
5
6
7
8

现在就可以关闭终端了，不会影响命令的执行，当我们开起另一个终端的时候，可以通过下面的命令来恢复 screen ：

## 先查看有哪些 screen 正在运行
screen -ls

## 输出如下：
There is a screen on:
 11920.pts-1.master	(Detached)
1 Socket in /var/run/screen/S-root.

## 然后恢复
screen -r 11920

## 可以 ctrl + c 停止进程

## 再退出
exit
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

内存查看命令

我们可以使用下面的命令查看服务器的内存使用情况：

free
1

输出为：

以上看到的内存大小是以字节为单位显示的，我们可以以 MB 来显示：

free -m
1

输出如下：

字段说明：

• total 表示总的内存大小
• used 表示使用了的内存大小
• free 表示空闲的内存大小
• buff/cache 表示缓存了的内存大小
• available 表示可用的内存大小，一般的话，我们要知道你的服务器还剩多少内存的话，一般就是看这个字段了。

Swap 就是交换分区，可以理解为虚拟内存，当真正的内存真的不够用的时候，就会使用这个交换分区，交换分区本质上是磁盘。

除了使用 free 命令外，我们还可以使用 top 命令动态的查看内存使用情况。

文件大小查看命令 du

## 查看当前目录的大小，以及递归查看当前目录下的子目录或者子文件的大小
du

## 可读性更强
du -h

## 查看指定文件的大小
du -h /root/test.txt

## 查看指定文件目录的大小，并且查看这个目录下的子目录的大小
du -h /

## 查看指定文件目录的大小
du -hs /

## 查看指定层数的子目录大小
du -h -d 1 /
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17