Linux inventory

cd 是一个基本的 Linux 命令，用于切换当前工作目录。它的基本语法是 cd [options] [directory]，其中 directory 是你希望切换到的目录。以下是一些常见的 cd 命令的用法和示例：

1. 切换到具体目录：你可以通过提供目录的绝对路径或相对路径来切换到特定的目录。

   绝对路径示例：

   cd /home/user/documents

   这个命令将你的当前工作目录切换到 /home/user/documents。

   相对路径示例：
   假设当前工作目录是 /home/user，你可以使用以下命令切换到 documents 子目录：

   cd documents

2. 切换到上级目录：你可以使用 .. 来表示当前目录的父目录。

   示例：

   cd ..

   这个命令将你的当前工作目录切换到上级目录。

3. 切换到之前的工作目录：你可以使用 - 来切换回你之前的工作目录。

   示例：

   cd -

   假设你最初在 /home/user 目录，然后你切换到 /etc，再运行 cd - 会把你带回到 /home/user。

4. 切换到用户的家目录：你可以使用 ~ 或者不带任何参数的 cd 来切换到当前用户的家目录。

   示例：

   cd

   或

   cd ~

   这两个命令都会将你的当前工作目录切换到当前用户的家目录，通常是 /home/username。

5. 处理带有空格的目录名：如果目录名中包含空格，你需要在整个目录名周围加上引号，或者使用反斜杠 \ 来转义空格。

   示例：

   cd "directory with spaces"

   或

   cd directory\ with\ spaces

   这两个命令都将你的当前工作目录切换到名为 directory with spaces 的目录。

这就是 cd 命令的主要用法。它是 Linux 中最基本且常用的命令之一，学会有效地使用它可以提高你在命令行中的效率。

让我补充一下这两个参数的示例：

-a 和 -A 都用于列出目录中的所有文件，包括以 .（点）开头的隐藏文件。在 Unix 和类 Unix 系统（如 Linux）中，文件名以 . 开头的文件被视为隐藏文件。

这两个参数的主要区别在于 -a 参数会列出 . 和 ..，而 -A 参数则不会。在 Unix 和类 Unix 系统中，. 代表当前目录，.. 代表父目录。

ls -a 的使用示例：

ls -a

这个命令会列出当前目录中的所有文件，包括隐藏文件和 . 和 ..。

ls -A 的使用示例：

ls -A

这个命令会列出当前目录中的所有文件，包括隐藏文件，但不包括 . 和 ..。

在大多数情况下，你可能会更倾向于使用 ls -A，因为 . 和 .. 在列出目录内容时通常不太有用。

在 Unix 和 Unix-like 系统（如 Linux）中，. 和 .. 是两个特殊的目录名。

• .：代表当前目录。例如，如果你在 /home/user 目录中，那么 . 就代表 /home/user。

• ..：代表上一级（父）目录。如果你在 /home/user 目录中，那么 .. 就代表 /home。

这两个特殊的目录名在一些命令中非常有用。例如，cd .. 命令可以让你从当前目录切换到上一级目录。ls -a 命令则会列出当前目录中的所有文件，包括隐藏文件和 . 和 ..。

>, >>, <, 和 << 是在 Unix 和 Unix-like 系统（如 Linux）中常见的 shell 命令行重定向操作符。他们分别具有以下的含义和用途：

1. >：这个操作符用于将命令的输出重定向到文件。如果文件已存在，它会被覆盖；如果文件不存在，它会被创建。例如：

   echo "Hello, World!" > file.txt

   这个命令会将字符串 "Hello, World!" 输出到 file.txt。如果 file.txt 已存在，其原有内容会被删除。

2. >>：这个操作符和 > 类似，但是它会将命令的输出添加到现有文件的末尾，而不是覆盖现有文件。如果文件不存在，它会被创建。例如：

   echo "Hello, World!" >> file.txt

   这个命令会将字符串 "Hello, World!" 添加到 file.txt 的末尾。

3. <：这个操作符用于将文件的内容作为命令的输入。例如：

   sort < file.txt

   这个命令会将 file.txt 的内容作为 sort 命令的输入，对文件的内容进行排序，并将排序结果输出到屏幕。

4. <<：这是一个“Here Document”的标识，用于将输入重定向到一个运行中的程序，或者将多行字符串作为输入传递给一个命令。例如：

   cat << EOF
   Hello, 
   This is a sample text.
   EOF

   这个命令会打印出两行字符串。EOF（End Of File）是一个标识，你可以用任何文本来代替它，只要这个文本在开始和结束标识中是一样的。在开始标识和结束标识之间的所有行都会作为输入传递给 cat 命令。

这就是重定向操作符的主要用法。它们是在 Unix 和 Unix-like 系统中进行文件和命令输入/输出操作的重要工具。

less 是一个在 Unix-like 系统（如 Linux）中用于查看文件内容的命令。与 more 命令相比，less 提供了更多的功能和灵活性，它允许用户前后浏览文件，而 more 命令只允许向前浏览。这就是 "less is more" 这个短语的由来。

基本语法是 less [options] file。

以下是一些 less 命令的常见用法和示例：

1. 查看文件：最基本的用法是使用 less 命令查看文件的内容。例如：

   less file.txt

   这个命令会打开 file.txt 以供查看。在查看文件时，你可以使用上下箭头键或 Page Up/Page Down 键进行导航。

Page Up 和 Page Down 是计算机键盘上的两个键。在大多数键盘布局中，这两个键通常位于键盘的右上角，可能会被标记为 PgUp 和 PgDn。

在使用文本浏览或编辑软件时，这两个键的功能通常是：

• Page Up：向上滚动一屏的内容。也就是说，按下这个键将使你看到上一屏的内容。

• Page Down：向下滚动一屏的内容。也就是说，按下这个键将使你看到下一屏的内容。

在 less 命令中，这两个键的功能和上述描述相同：Page Up 将向上滚动一屏的内容，Page Down 将向下滚动一屏的内容。

例如，如果你打开了一个很大的文件，使用 less 命令浏览它，你可能会发现屏幕上只能显示文件的一部分内容。在这种情况下，你可以使用 Page Down 键向下浏览文件，使用 Page Up 键向上浏览文件。

2. 在文件中搜索：在查看文件时，你可以按 / 键然后输入一个搜索模式（可以是一个简单的字符串或一个正则表达式）进行搜索。例如，按 / 键然后输入 "hello" 会在文件中搜索 "hello"。按 n 键可以跳到下一个匹配项，按 N 键可以跳到上一个匹配项。

   less file.txt

3. 跳到文件的开头或末尾：在查看文件时，按 g 键可以跳到文件的开头，按 G 键可以跳到文件的末尾。

4. 查看行号：在查看文件时，按 = 键可以查看当前行的行号。

5. 退出 less：在查看文件时，按 q 键可以退出 less。

这就是 less 命令的一些基本用法。它有很多其他的选项和特性，可以通过 man less 命令查看详细的帮助信息。

cat 命令的设计是直接输出文件的全部内容到标准输出（通常是终端）。cat 不提供类似 less 或 more 的分页功能，也就是说，使用 cat 命令查看文件时，你不能使用 Page Up 或 Page Down 键向上或向下翻页。

这也是为什么在查看大型文件时，通常推荐使用 less 或 more 命令而不是 cat 命令。less 和 more 都提供分页功能，允许你使用 Page Up 或 Page Down 键（或它们的等价键盘操作，如 less 中的 b 和 space）在文件中向上或向下翻页。

如果你只是想快速查看或输出小文件的内容，cat 是一个非常好的工具。但是，如果你需要在大型文件中进行导航或搜索，那么 less 或 more 会是更好的选择。

more 是一个在 Unix-like 系统（如 Linux）中用于查看文件内容的命令。它的特点是分页显示文件内容，特别适合查看大文件。

基本语法是 more [options] file。

以下是一些 more 命令的常见用法和示例：

1. 查看文件：最基本的用法是使用 more 命令查看文件的内容。例如：

   more file.txt

   这个命令会打开 file.txt 以供查看。在查看文件时，你可以按空格键翻到下一页，按 b 键翻到上一页。

2. 在文件中搜索：在查看文件时，你可以按 / 键然后输入一个搜索模式（可以是一个简单的字符串或一个正则表达式）进行搜索。例如，按 / 键然后输入 "hello" 会在文件中搜索 "hello"。按 n 键可以跳到下一个匹配项。

3. 查看文件的某部分：如果你只想查看文件的某部分，可以使用 +n 参数，其中 n 是你想开始查看的行号。例如：

   more +10 file.txt

   这个命令会从 file.txt 的第 10 行开始显示文件内容。

这就是 more 命令的一些基本用法。虽然 more 命令的功能相对简单，但在查看大文件时它非常有用。然而，less 命令提供了更多的功能和灵活性，因此很多人更喜欢使用 less 命令。你可以通过 man more 命令查看 more 命令的详细帮助信息。

less 和 more 都是 Unix-like 系统（如 Linux）中用于查看文件内容的命令。然而，它们之间有几个重要的区别：

1. 导航：more 命令只允许你向前浏览文件，也就是从文件的开始到结束。相比之下，less 命令允许你向前向后浏览文件。你可以在 less 中使用上下箭头键或 Page Up/Page Down 键进行导航。

2. 搜索：less 和 more 都可以在文件中进行搜索，但 less 提供了更多的搜索选项。在 less 中，你可以使用正则表达式进行搜索，可以向前向后搜索，还可以查看所有的匹配项。

3. 性能：less 命令在处理大文件时比 more 更高效。more 命令需要一次性读取整个文件到内存中，而 less 只需要读取需要显示的部分。

4. 功能：less 命令提供了更多的功能，包括显示行号、跳到文件的开头或末尾等。

因为 less 提供了更多的功能和灵活性，所以很多人更喜欢使用 less 命令。这就是 "less is more" 这个短语的由来。

可以的，Linux的sort命令允许你降序（反向）排列文件中的行。具体来说，-r选项可以实现降序排列。

假设你有一个名为file.txt的文件，并且你希望根据每行的数值降序排列，你可以这样操作：

sort -rn file.txt

这里，-r选项表示“反向”（即降序），而-n选项表示“数值排序”。如果你不包含-n选项，sort命令将按照字符的字典顺序进行排序，这可能会导致数字10出现在数字2之前。

如果你想按字典顺序的反向排列，你可以省略-n选项，就像这样：

sort -r file.txt

在这两个命令中，排序结果会输出到控制台。如果你希望将结果保存到另一个文件中，你可以使用重定向操作，例如：

sort -rn file.txt > sorted_file.txt

在你提供的数据示例中，sort -n -k 1,2 dem.txt 已经按照你的期望对数据进行了排序。这是因为 -k 1,2 命令指定了排序应该基于第一和第二个字段，而 -n 指定了排序应该按照数值进行（这在这个特定的例子中并不重要，因为第一列的值都是唯一的）。

然而，如果你的实际数据与你提供的示例不同，可能会出现意外的结果。sort -n -k 1,2 将首先根据第一字段进行排序，然后在第一字段相同的行中根据第二字段进行排序。此外，第二字段的排序将是字典序，而不是数值排序，即使你使用了 -n 选项。

例如，如果你有以下数据：

1 z
1 y
1 x
2 a
2 b
2 c

sort -n -k 1,2 dem.txt 将产生以下结果：

1 x
1 y
1 z
2 a
2 b
2 c

这是因为，虽然第一字段相同（即都是1），但第二字段在字典序下是 x < y < z。

如果你需要第二字段以数值排序而非字典序，你可能需要使用更复杂的命令或不同的工具，例如 awk。如果你提供更具体的数据和你想要达到的结果，我可能可以给出更具体的建议。

base

在 jq 工具中，. 符号代表当前处理的 JSON 数据对象。当你要提取某个特定的属性时，需要使用 . 符号来指向当前对象，然后跟上你要提取的属性名。

例如，假设你有一个 JSON 对象如下：

{
  "name": "John",
  "age": 30,
  "city": "New York"
}

如果你想提取 name 属性的值，你就需要使用 .name 作为 jq 的参数：

echo '{"name":"John", "age":30, "city":"New York"}' | jq '.name'

这将输出 "John"。这里的 . 符号代表当前的 JSON 对象，name 就是我们想要提取的属性。

同样的，如果你的 JSON 对象包含嵌套的对象或数组，你可以使用 . 符号来访问这些嵌套的元素。例如，.person.name 将提取 person 对象中的 name 属性，.people[] 将提取 people 数组中的所有元素。

在 jq 工具中，. 符号是非常重要的，它代表了当前处理的 JSON 对象。你几乎在所有的 jq 表达式中都会看到这个符号。

嵌套

首先，假设我们有如下的 JSON 数据：

{
  "person": {
    "name": "John",
    "age": 30,
    "address": {
      "city": "New York",
      "country": "USA"
    }
  }
}

在这个 JSON 数据中，我们有一个 person 对象，这个对象中又包含了一个嵌套的 address 对象。我们可以使用 jq 提取这些嵌套的数据。

例如，如果我们想提取 name 属性，我们可以使用 .person.name：

echo '{"person":{"name":"John", "age":30, "address":{"city":"New York", "country":"USA"}}}' | jq '.person.name'

这将输出 "John"。

如果我们想提取 city 属性，我们可以使用 .person.address.city：

echo '{"person":{"name":"John", "age":30, "address":{"city":"New York", "country":"USA"}}}' | jq '.person.address.city'

这将输出 "New York"。

如果我们的 JSON 数据包含数组，我们可以使用 [] 符号来提取数组中的元素。例如，假设我们的 JSON 数据如下：

{
  "people": [
    {"name": "John", "age": 30},
    {"name": "Jane", "age": 25}
  ]
}

我们可以使用 .people[].name 来提取所有人的名字：

echo '{"people":[{"name":"John", "age":30},{"name":"Jane", "age":25}]}' | jq '.people[].name'

这将输出：

"John"
"Jane"

在 jq 工具中，. 符号和 [] 符号可以帮助我们处理复杂的 JSON 数据结构。你可以在 jq 的文档中找到更多关于这个工具的信息。

echo '{"people":[{"name":"John", "age":30},{"name":"Jane", "age":25}]}' | jq '.people[0]'

输出：

{
  "name": "John",
  "age": 30
}

可以，你可以使用管道（|）将 ls -l 的输出重定向到 grep 命令，并使用正则表达式来匹配多种文件后缀。具体来说，你可以使用竖线字符（|），在正则表达式中它表示“或”关系。

以下是一个例子，它匹配 .txt 或 .csv 文件：

ls -l | grep -E "\.(txt|csv)$"

在这个命令中，-E 选项告诉 grep 使用扩展的正则表达式。字符串 "\.(txt|csv)$" 是一个正则表达式，匹配以 .txt 或 .csv 结尾的行。

注意，正则表达式中的字符需要被适当地转义。例如，. 在正则表达式中表示任何字符，所以如果你想匹配实际的 . 字符，你需要写成 \.。同样，$ 在正则表达式中表示行的结束，所以 \.txt$ 只匹配以 .txt 结尾的行。

你可以添加更多的文件类型，只需在竖线字符后添加更多的后缀名即可，如："\.(txt|csv|jpg|png)$"。

可以的，你可以将 grep 的输出重定向到一个文件中。在 Linux 和 Unix 系统中，你可以使用 > 或 >> 这样的重定向运算符来实现。

下面是两个例子：

1. 使用 > 写入文件：这将会覆盖文件中已有的内容。例如，你可以使用以下命令将 grep 的结果写入一个文件：

   grep 'pattern' file.txt > output.txt

   在这个命令中，grep 'pattern' file.txt 将输出包含指定模式的行，> output.txt 将把这些行写入 output.txt 文件中。如果 output.txt 文件已经存在，这个命令将会覆盖文件中的内容。

2. 使用 >> 写入文件：这将会在文件的末尾添加内容，而不会覆盖已有的内容。例如：

   grep 'pattern' file.txt >> output.txt

   在这个命令中，>> output.txt 将把 grep 的结果追加到 output.txt 文件的末尾，而不是覆盖文件中的内容。

请注意，如果你没有写权限或者磁盘空间不足，这些命令可能会失败。在这种情况下，你需要检查你的权限或者磁盘空间，或者选择一个不同的目标文件。

让我通过一个例子来解释 "删除相邻的重复行" 这个概念。

假设我们有一个文件 file.txt，内容如下：

apple
banana
apple
banana
apple
pear
banana
pear
apple

如果我们直接使用 uniq 命令，结果将如下：

$ uniq file.txt

输出：

apple
banana
apple
banana
apple
pear
banana
pear
apple

你会发现，尽管 "apple" 和 "banana" 在文件中多次出现，但 uniq 命令并没有删除这些重复的行。这是因为 uniq 命令只删除相邻的重复行。

现在，如果我们先用 sort 命令将文件排序，再使用 uniq 命令，结果将如下：

$ sort file.txt | uniq

输出：

apple
banana
pear

在 sort 命令的作用下，所有相同的行（比如 "apple"、"banana"、"pear"）都被排列在一起，成为了相邻的行。然后 uniq 命令就能成功地删除这些重复的行。

这就是 "删除相邻的重复行" 的含义，也是为什么我们通常会在使用 uniq 命令之前先使用 sort 命令的原因。

当你使用 cp 命令复制文件或目录时，如果不指定 -p 选项，那么默认情况下，新复制的文件或目录将不会保留原始文件或目录的属性。

更具体地说：

• 所有权：新复制的文件或目录将被赋予当前用户和用户组的所有权，而不是原始文件或目录的所有权。

• 权限：新复制的文件或目录将根据当前用户的 umask 设置来确定权限，而不是保留原始文件或目录的权限。

• 时间戳：新复制的文件或目录将具有当前的时间戳，而不是原始文件或目录的时间戳。

如果你想在复制文件或目录时保留这些属性，你应该使用 -p 选项。例如：

cp -p source.txt destination.txt

这将复制 source.txt 文件到 destination.txt，并保留文件的所有权、权限和时间戳。

在 Linux 中，cp 命令后面跟随的特殊字符（*、[]、. 等）被称为通配符（wildcards），它们在匹配文件和目录时有特殊的含义：

1. *：匹配任意数量的任意字符。例如，*.txt 匹配所有以 .txt 结尾的文件。

2. ?：匹配任意一个字符。例如，?.txt 匹配所有单个字符的 .txt 文件，如 a.txt、b.txt 等。

3. []：匹配括号内的任意一个字符。例如，[abc].txt 匹配 a.txt、b.txt 和 c.txt。

4. {}：匹配大括号中的任何一个字符串。例如，{a,b,c}.txt 会匹配 a.txt、b.txt 和 c.txt。

5. .：在文件或目录名中，. 表示当前目录。在隐藏文件或目录的名称前，. 也表示隐藏属性。例如，.config 是一个隐藏文件。

注意，使用这些通配符时，你应确保它们正确地匹配到你希望操作的文件和目录。

这就是 Linux 中 cp 命令后面跟随的特殊字符的含义。在实际使用时，你可能需要根据具体情况调整命令的参数。

让我们通过一些具体的操作来更深入地理解这些通配符的作用。

首先，我们在当前目录下创建一个新的目录 testdir，然后在 testdir 下创建一些文件：

mkdir testdir
cd testdir
touch file123 file154 file180 apple180 banana130 cherry170 jenny239 jenny32

现在，我们已经创建了 file123、file154、file180、apple180、banana130、cherry170 这些文件。现在，我们可以尝试使用 cp 命令配合通配符来复制文件。

1. 复制以 1 后跟一个 2 到 7 之间的数字，再后跟一个任意数字结束的文件：

mkdir copy1
cp *1[2-7][0-9] copy1/  # 1 就是匹配数字开头，可以改成 2 自行测试

这条命令会将 file123 和 file154 复制到 copy1/ 目录，因为这两个文件名都匹配 *1[2-7][0-9] 的模式。

2. 复制以 180 结束的文件：

mkdir copy2
cp *180 copy2/

这条命令会将 file180 和 apple180 复制到 copy2/ 目录，因为这两个文件名都匹配 *180 的模式。

你可以通过 ls 命令来查看 copy1/ 和 copy2/ 目录，确认这些操作的结果：

ls copy1/
ls copy2/

cp 命令会覆盖目标目录中同名的文件。

如果你在命令行中使用 cp 命令复制文件，而目标目录中已经存在同名的文件，那么 cp 命令会直接覆盖目标目录中的同名文件，不会进行任何提示。

这是 cp 命令的默认行为。如果你希望在覆盖文件之前得到提示，可以使用 -i（interactive）选项，如：cp -i sourcefile targetfile。这样，在覆盖文件之前，系统会询问你是否确定要覆盖。

如果你想在复制文件的同时保留原始文件，你可以使用 cp 命令。cp 命令的基本操作就是在复制文件的同时保留源文件。换句话说，源文件在复制操作后仍然存在。示例如下：

cp source.txt destination.txt

这将创建 destination.txt 的一个副本，同时 source.txt 仍然保持不变。

但如果你的意思是在目标位置已有同名文件时，你想要保留那个原始的目标文件，那么你可以使用 cp 命令的 -b（或 --backup）选项。这将会在覆盖之前为目标文件创建一个备份。例如：

cp -b source.txt destination.txt

这将会在复制 source.txt 到 destination.txt 之前，为 destination.txt 创建一个备份文件，名为 destination.txt~。

注意，-b 选项可能并非所有系统的 cp 命令都支持。你可以通过 man cp 或 cp --help 来查看你的系统中的 cp 命令是否支持这个选项。

在 Linux 系统中，文件或目录的权限可以通过 ls -l 命令查看。ls -l 命令的输出包含了很多信息，其中第一列就是文件或目录的权限字符串。权限字符串总共有 10 个字符，它们的含义如下：

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

   • -：表示这是一个普通文件。
   • d：表示这是一个目录。
   • l：表示这是一个符号链接。
   • 其他的字符表示其他特殊类型的文件（如设备文件和管道文件）。

2. 接下来的三个字符表示文件拥有者的权限：

   • r：表示拥有者有读取权限。
   • w：表示拥有者有写入权限。
   • x：表示拥有者有执行权限。
   • -：表示相应的权限不存在。

3. 再接下来的三个字符表示用户组的权限：

   • 和文件拥有者的权限一样，这三个字符分别表示用户组的读取、写入和执行权限。

4. 最后三个字符表示所有其他用户的权限：

   • 和文件拥有者的权限一样，这三个字符分别表示所有其他用户的读取、写入和执行权限。

现在，让我们通过一些例子来看看这些权限是如何工作的。

例如，假设你运行了 ls -l 命令，得到了以下的输出：

drwxr-xr-x 2 root root 4096 May 30 16:34 directory
-rw-r--r-- 1 root root 1024 May 30 16:34 file

在这个例子中，directory 是一个目录，file 是一个普通文件。我们可以从权限字符串中看出它们的权限：

• 对于 directory，权限字符串是 drwxr-xr-x：

  • d 表示这是一个目录。
  • 第一组的 rwx 表示文件拥有者（在这个例子中是 root 用户）有读取、写入和执行权限。对于目录，执行权限表示可以列出目录的内容。
  • 第二组的 r-x 表示用户组（在这个例子中也是 root 用户组）有读取和执行权限，但没有写入权限。
  • 第三组的 r-x 表示所有其他用户也有读取和执行权限，但没有写入权限。

• 对于 file，权限字符串是 -rw-r--r--：

  • - 表示这是一个普通文件。
  • 第一组的 rw- 表示文件拥有者有读取和写入权限，但没有执行权限。对于普通文件，执行权限表示可以运行这个

文件作为程序。
- 第二组和第三组的 r-- 表示用户组和所有其他用户只有读取权限，没有写入和执行权限。

这就是 Linux 文件权限的基本原理。如果你想改变文件或目录的权限，你可以使用 chmod 命令。例如，如果你想让所有用户都有 file 的读取和写入权限，你可以运行 chmod 666 file 命令。在这个命令中，666 是一个八进制数字，表示所有用户都有读（4）和写（2）权限（4+2=6）。

在 Linux 中我们通常使用以下两个命令来修改文件或目录的所属用户与权限：

• chown (change owner) ： 修改所属用户与组。
• chmod (change mode) ： 修改用户的权限。

下图中通过 chown 来授权用户，通过 chmod 为用户设置可以开门的权限。

在 Linux 中我们可以使用 ll 或者 ls –l 命令来显示一个文件的属性以及文件所属的用户和组，如：

[root@www /]# ls -l
total 64
dr-xr-xr-x   2 root root 4096 Dec 14  2012 bin
dr-xr-xr-x   4 root root 4096 Apr 19  2012 boot
……

实例中，bin 文件的第一个属性用 d 表示。d 在 Linux 中代表该文件是一个目录文件。

在 Linux 中第一个字符代表这个文件是目录、文件或链接文件等等。

• 当为 d 则是目录
• 当为 - 则是文件；
• 若是 l 则表示为链接文档(link file)；
• 若是 b 则表示为装置文件里面的可供储存的接口设备(可随机存取装置)；
• 若是 c 则表示为装置文件里面的串行端口设备，例如键盘、鼠标(一次性读取装置)。

接下来的字符中，以三个为一组，且均为 rwx 的三个参数的组合。其中， r 代表可读(read)、 w 代表可写(write)、 x 代表可执行(execute)。 要注意的是，这三个权限的位置不会改变，如果没有权限，就会出现减号 - 而已。

每个文件的属性由左边第一部分的 10 个字符来确定（如下图）。

从左至右用 0-9 这些数字来表示。

第 0 位确定文件类型，第 1-3 位确定属主（该文件的所有者）拥有该文件的权限。

第4-6位确定属组（所有者的同组用户）拥有该文件的权限，第7-9位确定其他用户拥有该文件的权限。

其中，第 1、4、7 位表示读权限，如果用 r 字符表示，则有读权限，如果用 - 字符表示，则没有读权限；

第 2、5、8 位表示写权限，如果用 w 字符表示，则有写权限，如果用 - 字符表示没有写权限；第 3、6、9 位表示可执行权限，如果用 x 字符表示，则有执行权限，如果用 - 字符表示，则没有执行权限。

• -E：这个选项告诉grep使用扩展正则表达式（Extended Regular Expressions）。扩展正则表达式提供了更多的功能，比如"(..|..)"用于匹配多个模式，"+"表示匹配一个或多个指定字符等。

• -i：这个选项使得grep搜索时忽略大小写。例如，如果你搜索"search"，则会匹配"search"，"Search"，"SEARCH"等。

• -n：这个选项让grep输出匹配行的行号。例如，如果一行匹配了你的搜索模式，grep不仅会输出这行内容，还会在前面输出这行的行号。

让我们看一个例子：

echo -e "Hello\nworld" | grep -Ei "HELLO|WORLD"

这个命令会输出：

Hello
world

这是因为-E选项让我们可以使用"|"符号来匹配"HELLO"或"WORLD"，-i选项让我们可以忽略大小写。

再看一个例子：

echo -e "Hello\nworld" | grep -Ein "HELLO|WORLD"

这个命令会输出：

1:Hello
2:world

这是因为我们添加了-n选项，所以grep在输出每行内容的前面加上了行号。

这些都是使用grep命令和扩展正则表达式来搜索文本的例子。让我们一一解析：

1. grep -Ein "\bAlice.?.?.?.?.?.?.?!" alice.txt

   这条命令在文件alice.txt中查找所有包含"Alice"（注意大小写）后面紧跟着7个或更少任意字符并以感叹号"!"结束的行。"\b"表示单词边界，"."表示任意字符，而"?!"表示可选的一个感叹号。-E表示使用扩展正则表达式，-i表示忽略大小写，-n表示输出行号。

2. grep -Ein "alice.?.?.?.?.?.?.?!" alice.txt

   这条命令与第一条命令几乎相同，唯一的区别是它查找的是"alice"，而不是"Alice"。由于使用了-i选项，所以大小写不重要。

3. grep -Ein "alice.{0,7}!" alice.txt

   这条命令在文件alice.txt中查找所有包含"alice"后面紧跟着0到7个任意字符并以感叹号"!"结束的行。"{0,7}"表示匹配前面的元素0到7次，"."表示任意字符。

4. grep -Ein "alice.{,7}!" alice.txt

   这条命令与上一条命令相同，只是它使用了更简洁的语法。在扩展正则表达式中，如果你省略了花括号中的第一个数字，那么它默认为0。所以"{,7}"等价于"{0,7}"。

这四条命令都将匹配到"alice"后面跟有0到7个任意字符并以"!"结束的行，并且忽略大小写。这可能对于寻找"alice"的短句，例如"Alice!"或"Alice is here!"之类的句子非常有用。

在正则表达式中，.表示任意单个字符，而?表示前面的元素（在这里是.）是可选的，即它可能出现0次或1次。

所以，.?可以匹配0个或1个任意字符。

但是，如果你想要匹配0到7个任意字符，一个.?是不够的。因为它只能匹配0个或1个字符，无法达到匹配多个字符的效果。

在你的命令grep -Ein "\bAlice.?.?.?.?.?.?.?!" alice.txt中，.?.?.?.?.?.?.?.?就是为了匹配0到7个任意字符。每一个.?都可以匹配0个或1个字符，所以连续的7个.?可以匹配0到7个字符。

但是，这种写法确实有些冗余，你可以使用{}来指定匹配的次数，这样代码就会更简洁。所以，grep -Ein "Alice.{0,7}!" alice.txt和grep -Ein "\bAlice.?.?.?.?.?.?.?!" alice.txt是等效的，只是后者的写法更冗余一些。

echo 命令本身并不直接使用正则表达式，它主要用于在终端上打印字符串或变量的内容。然而，你可以将 echo 命令的输出配合管道 (|) 和支持正则表达式的其他命令一起使用，例如 grep、sed、awk 等。这里有一些例子：

1. 使用 grep 和正则表达式搜索特定模式：

echo "Hello World" | grep -o "World"

这将打印 "World"，因为 grep 用 "-o" 参数将只打印匹配到的部分，这里的正则表达式是 "World"。

2. 使用 sed 和正则表达式替换文本：

echo "Hello World" | sed 's/World/Everyone/'

这将打印 "Hello Everyone"，因为 sed 用 's/World/Everyone/' 替换了 "World" 为 "Everyone"。

3. 使用 awk 和正则表达式进行更复杂的文本处理：

echo -e "Hello World\nGoodbye World" | awk '/Hello/ {print $0}'

这将只打印 "Hello World"，因为 awk 命令只打印匹配到 /Hello/ 正则表达式的行。

请注意，这些例子都使用了管道操作符 |，这个操作符将前一个命令的输出作为下一个命令的输入。这是 Unix 和 Linux shell 中一个非常强大的特性，它允许你将多个命令组合在一起形成更复杂的操作。

在 Linux 中，正则表达式有两种形式：基础正则表达式 (BREs) 和扩展正则表达式 (EREs)。grep 和 sed 等工具默认使用的是基础正则表达式，而在这种模式下，一些特殊的元字符，例如 +、? 和 |，必须被转义（即前面加上 \）才能起作用。

例如，如果你想在 grep 中使用 + 字符来匹配一个或多个字符，你需要这样写：

echo "Hello" | grep 'l\+'

这将匹配所有包含一个或多个 'l' 的行。

如果你想使用扩展正则表达式，那么可以使用 grep -E 或 egrep，以及 sed -E。在这种模式下，+、? 和 | 等字符无需转义：

echo "Hello" | grep -E 'l+'

这同样会匹配所有包含一个或多个 'l' 的行，但是我们没有使用 \ 来转义 +。

请注意，尽管扩展正则表达式提供了更多的特性，但并不是所有的工具都支持。例如，awk 默认就使用扩展正则表达式，无需任何特殊选项。你应该查阅具体工具的手册来确定如何使用正则表达式。

当你使用 sed 对文件进行操作时，sed 默认的行为是将修改后的结果输出到标准输出（通常是你的终端或控制台），而不会改变原始的文件。这意味着你可以查看修改的结果，而不用担心会误改原始文件。

如果你想要保存 sed 的修改结果到原始文件中，你可以使用 -i 选项。例如：

sed -i 's/foo/bar/g' filename

这个命令将在文件 filename 中将所有的 "foo" 替换为 "bar"，并将修改的结果保存回 filename。

请注意，-i 选项会直接修改文件，这意味着原始的文件内容将会丢失。在使用 -i 选项之前，你应该确保你有备份，或者你确定你的 sed 命令是正确的。

另外，-i 选项在 GNU 版本的 sed（即在 Linux 上通常使用的版本）中是可用的，但在一些其他版本的 sed 中可能不可用，例如在 BSD 或 macOS 中的 sed。在那些系统中，你需要给 -i 选项提供一个扩展名，sed 将会创建一个带有该扩展名的备份文件。例如：

sed -i.bak 's/foo/bar/g' filename

这个命令会创建一个 filename.bak 的备份文件，然后将修改后的结果保存到 filename 中。

在 awk 中，双符号 && 用作逻辑 "AND" 运算符。也就是说，如果它左边和右边的表达式都为真，那么整个表达式就为真。

以下是一个 awk 使用 && 的例子：

awk '$1 > 5 && $2 > 5' filename

这个命令会从文件 filename 中选出第一列和第二列的值都大于 5 的行。

例如，如果 filename 文件的内容是：

1 2
3 4
6 7
8 9

那么 awk '$1 > 5 && $2 > 5' filename 命令的输出就会是：

6 7
8 9

因为只有最后两行的第一列和第二列的值都大于 5。

总的来说，&& 运算符在 awk 中用于连接需要同时满足的条件。

这个 awk 命令会打印 filename 文件中每一行的第一列。

在这个命令中，awk 是命令名，'{ print $1 }' 是传递给 awk 的脚本，而 filename 是输入文件的名字。

awk 命令读取输入文件（在这个例子中是 filename），一行一行地处理。对于每一行，它都会执行提供的脚本。

在脚本中，print $1 命令告诉 awk 打印每一行的第一列。在 awk 中，$1、$2、$3 等分别表示第一列、第二列、第三列，以此类推。$0 则表示整行。

默认情况下，awk 使用任何空格或者制表符作为字段的分隔符。这意味着，如果一行是 "Hello, world!"，那么 $1 就是 "Hello,"，而 $2 就是 "world!"。

因此，这个命令会打印 filename 文件中每一行的第一部分，部分之间由空格或制表符分隔。如果你想改变字段的分隔符，你可以使用 -F 选项。例如，awk -F: '{ print $1 }' filename 命令会使用冒号 : 作为字段的分隔符。

通过一个具体的例子来解释 awk '{ print $1 }' filename 这个命令。

假设我们有一个文件叫做 data.txt，内容如下：

Tom 23 Engineer
Jerry 25 Designer
Spike 30 Developer

这个文件中，每一行代表一个人，第一列是名字，第二列是年龄，第三列是职业。

现在，如果我们运行命令 awk '{ print $1 }' data.txt，awk 会读取文件 data.txt，然后对文件中的每一行执行 { print $1 } 这个脚本。

在这个脚本中，$1 指的是每一行的第一列，所以 { print $1 } 会打印出每一行的第一列，也就是每个人的名字。

运行这个命令后，你会看到如下的输出：

Tom
Jerry
Spike

这就是 awk '{ print $1 }' filename 命令的作用。它从文件中提取出了每一行的第一列。

如果你想同时打印多列，只需要在 print 语句中用逗号分隔各个列编号就可以了。例如，如果你想打印出第一列和第三列，你可以这样做：

awk '{ print $1, $3 }' filename

假设我们还是用上面的 data.txt 文件作为例子：

Tom 23 Engineer
Jerry 25 Designer
Spike 30 Developer

那么 awk '{ print $1, $3 }' data.txt 命令的输出就会是：

Tom Engineer
Jerry Designer
Spike Developer

你可以看到，输出中只包含了每一行的第一列（名字）和第三列（职业）。第二列（年龄）被省略了。

你还可以使用 $0 来打印整行。例如，awk '{ print $0 }' filename 将会打印文件的全部内容，这和 cat filename 命令的效果相同。

如果你想要在 awk 脚本中包含多个命令，你可以将它们放在不同的花括号 {} 中。每个 {} 中的部分都被称为一个 "动作"，并且可以包含一个或多个 awk 命令。

例如，让我们假设你有一个文件 numbers.txt，它的内容如下：

1
2
3
4
5

你想要计算所有数字的和（sum）和平均值（avg）。你可以使用以下的 awk 命令：

awk '{ sum += $1 } { avg = sum / NR } END { print "Sum: " sum ", Average: " avg }' numbers.txt

这个命令有三个动作：

1. { sum += $1 }：这个动作在每行执行时都会将第一列的值（也就是每一行的数字）加到 sum 中。

2. { avg = sum / NR }：这个动作在每行执行时都会计算到目前为止的平均值。它将 sum（到目前为止的总和）除以 NR（到目前为止的行数）。

3. END { print "Sum: " sum ", Average: " avg }：这个动作在读完所有输入之后执行，它打印 sum 和 avg 的值。

所以，对于这个 numbers.txt 文件，命令的输出会是：

Sum: 15, Average: 3

这表示文件中所有数字的和是 15，平均值是 3。

详细讲解：awk '{ sum += $1 } END { print sum / NR }' filename

这个 awk 命令的作用是计算文件 filename 中第一列数值的平均值。现在让我们详细解释一下这个命令的各个部分。

首先，这是一个 awk 命令，它会读取输入文件（在这里是 filename），然后对文件中的每一行执行给定的脚本。

脚本有两个部分：

1. { sum += $1 }：这部分在读取每一行时都会执行。$1 表示每一行的第一列，sum += $1 会将第一列的值添加到变量 sum 中。注意，awk 中的变量在使用之前不需要明确声明，并且如果没有赋值，它们的默认值是 0 或空字符串。

2. END { print sum / NR }：这部分在 awk 读完所有的输入之后执行。END 是一个特殊的模式，当 awk 结束输入时，会执行与其相关联的动作。在这个例子中，动作是 print sum / NR，其中 NR 是一个特殊的变量，它代表当前的行号，也就是已经读取的行数。所以，sum / NR 就计算了第一列值的平均数，然后 print 会将结果打印出来。

所以，整个命令的意思是：对于文件 filename 的每一行，将第一列的值加到 sum 中，然后在读完所有行之后，打印 sum 除以行数 NR 的结果，也就是第一列的平均值。

具体测试数据

假设我们有一个文件叫做 numbers.txt，其内容如下：

1
2
3
4
5

这个文件中的每一行都有一个数字。

现在，我们执行命令 awk '{ sum += $1 } END { print sum / NR }' numbers.txt。

这个命令首先会将文件 numbers.txt 中每一行的数字加到 sum 变量中。在这个例子中，sum 最终的值会是 1 + 2 + 3 + 4 + 5 = 15。

然后，当所有的行都被读取之后，命令会计算 sum 变量的值除以行数 NR 的结果。在这个例子中，因为文件有 5 行，所以 NR 的值是 5。所以，命令会打印出 15 / 5 = 3。

所以，这个命令的结果就是 3，这是文件 numbers.txt 中所有数字的平均值。

你可以在 Linux 命令行中使用以下命令来创建 numbers.txt 文件：

echo -e "1\n2\n3\n4\n5" > numbers.txt

然后，你就可以使用 awk '{ sum += $1 } END { print sum / NR }' numbers.txt 命令来测试了。

怎么输出 sum

如果你只想输出 sum 的值，你可以将输出的动作放在 END 块中。END 块中的代码会在 awk 读完所有输入后执行。例如：

awk '{ sum += $1 } END { print sum }' numbers.txt

这个命令会首先计算 numbers.txt 文件中所有数的和（就像之前的命令一样），然后在读完所有输入之后，打印 sum 的值。所以，这个命令的结果就是 numbers.txt 文件中所有数的和。

在我们之前的例子中，numbers.txt 文件的内容是：

1
2
3
4
5

所以，awk '{ sum += $1 } END { print sum }' numbers.txt 命令的结果会是 1 + 2 + 3 + 4 + 5 = 15。

首先，假设我们有一个名为 test.txt 的文本文件，其中包含以下内容：

bar
foobar
barbarian
barcode
arbitrary

我们想要找到所有含有 "bar" 的行。在这种情况下，我们可以使用 grep 命令，不带 \b：

grep 'bar' test.txt

这会返回以下结果：

bar
foobar
barbarian
barcode

如你所见，这返回了所有含有 "bar" 的行，无论 "bar" 是一个单独的单词还是其他词的一部分。

现在，假设我们只想找到那些 'bar' 作为独立单词出现的行。在这种情况下，我们可以使用 \b 来标识单词的边界：

grep '\bbar\b' test.txt

这会返回以下结果：

bar

只有 "bar" 这一行被返回，因为只有在这一行中，"bar" 是一个独立的单词。 "foobar"、"barbarian" 和 "barcode" 这些行没有被返回，因为在这些行中 "bar" 是其他词的一部分，而不是一个独立的单词。