文档

• 1: 主页
• 2: 学习shell
• 2.1: 什么是 "Shell"?
• 2.2: 导航
• 2.3: 四处浏览
• 2.4: 导览
• 2.5: 操作文件
• 2.6: 使用命令
• 2.7: 输入/输出重定向
• 2.8: 扩展
• 2.9: 权限
• 2.10: 作业控制
• 3: 编写shell脚本
• 3.1: 编写我们的第一个脚本并使其正常工作
• 3.2: 编辑我们已有的脚本
• 3.3: here 脚本
• 3.4: 变量
• 3.5: 命令替换和常量
• 3.6: shell函数
• 3.7: 一些真正的工作
• 3.8: 流程控制 - 第一部分
• 3.9: 远离麻烦
• 3.10: 键盘输入和算术
• 3.11: 流程控制 - 第二部分
• 3.12: 位置参数
• 3.13: 流程控制 - 第三部分
• 3.14: 错误、信号和陷阱（噢，我的天！）- 第一部分
• 3.15: 错误、信号和陷阱（哦，我的天！）- 第二部分
• 4: 参考
• 5: Adventures
• 5.1: Midnight Commander
• 5.2: Terminal Multiplexers
• 5.3: Less Typing
• 5.4: More Redirection
• 5.5: tput
• 5.6: dialog
• 5.7: AWK
• 5.8: Other Shells
• 5.9: Power Terminals
• 5.10: Vim, with Vigor
• 5.11: source
• 5.12: Coding Standards Part 1: Our Own
• 5.13: Coding Standards Part 2: new_script
• 5.14: SQL
• 6: Books

1 - 主页

现在怎么办？Now what?

https://linuxcommand.org/index.php

You have Linux installed and running. The GUI is working fine, but you are getting tired of changing your desktop themes. You keep seeing this “terminal” thing.

​ 你已经安装和运行了Linux。图形用户界面（GUI）运行良好，但你对于更改桌面主题感到厌倦。你一直看到这个"终端"的东西。

Don’t worry, we’ll show you what to do.

​ 别担心，我们会告诉你该做什么。

2 - 学习shell

为什么要费心？Why Bother?

https://linuxcommand.org/lc3_learning_the_shell.php

Why do you need to learn the command line anyway? Well, let me tell you a story. Many years ago we had a problem where I worked. There was a shared drive on one of our file servers that kept getting full. I won’t mention that this legacy operating system did not support user quotas; that’s another story. But the server kept getting full and it stopped people from working. One of our software engineers spent a couple of hours writing a C++ program that would look through all the user’s directories and add up the space they were using and make a listing of the results. Since I was forced to use the legacy OS while I was on the job, I installed a Linux-like command line environment for it. When I heard about the problem, I realized I could perform this task with this single line:

​ 你为什么需要学习命令行？好吧，让我给你讲个故事。很多年前，我工作的地方遇到一个问题。我们的一个文件服务器上有一个共享驱动器，空间总是被占满。我不会提及这个遗留操作系统不支持用户配额的事实，那是另一个故事了。但服务器一直被占满，导致人们无法正常工作。我们的一位软件工程师花了几个小时编写了一个C++程序，用于查找所有用户目录并计算它们使用的空间，并生成一个结果列表。由于我在工作期间被迫使用这个遗留操作系统，我为其安装了一个类似Linux的命令行环境。当我听说这个问题时，我意识到我可以用一行命令来完成这个任务：

1

du -s * | sort -nr > $HOME/user_space_report.txt

Graphical user interfaces (GUIs) are helpful for many tasks, but they are not good for all tasks. I have long felt that most computers today are not powered by electricity. They instead seem to be powered by the “pumping” motion of the mouse. Computers were supposed to free us from manual labor, but how many times have you performed some task you felt sure the computer should be able to do but you ended up doing the work yourself by tediously working the mouse? Pointing and clicking, pointing and clicking.

​ 图形用户界面（GUI）对许多任务很有帮助，但并非对所有任务都适用。我一直觉得现在的大多数计算机不是靠电力驱动，而是靠鼠标的“点击”运动驱动。计算机本应该使我们从体力劳动中解放出来，但你有多少次尝试让计算机完成某项任务，但最终却发现自己不得不费力地操作鼠标来亲自完成工作？指指点点，指指点点。

I once heard an author say that when you are a child you use a computer by looking at the pictures. When you grow up, you learn to read and write. Welcome to Computer Literacy 101. Now let’s get to work.

​ 我曾经听过一位作者说，当你还是个孩子时，你通过看图来使用计算机。当你长大后，你学会了阅读和写作。欢迎来到计算机素养101课程。现在让我们开始工作吧。

2.1 - 什么是 "Shell"?

什么是"Shell"？ What is “the Shell”?

https://linuxcommand.org/lc3_lts0010.php

Simply put, the shell is a program that takes commands from the keyboard and gives them to the operating system to perform. In the old days, it was the only user interface available on a Unix-like system such as Linux. Nowadays, we have graphical user interfaces (GUIs) in addition to command line interfaces (CLIs) such as the shell.

​ 简而言之，Shell是一个程序，它从键盘接收命令并将其传递给操作系统执行。在早期，它是类Unix系统（如Linux）上唯一可用的用户界面。如今，除了Shell，我们还有图形用户界面（GUI），例如命令行界面（CLI）。

On most Linux systems a program called bash (which stands for Bourne Again SHell, an enhanced version of the original Unix shell program, sh, written by Steve Bourne) acts as the shell program. Besides bash, there are other shell programs available for Linux systems. These include: ksh, tcsh and zsh.

​ 在大多数Linux系统中，一个名为bash的程序（代表Bourne Again SHell，是原始Unix shell程序sh的增强版本，由Steve Bourne编写）充当Shell程序。除了bash，Linux系统还有其他可用的Shell程序，包括：ksh、tcsh和zsh。

什么是"终端"？What’s a “Terminal?”

It’s a program called a terminal emulator. This is a program that opens a window and lets you interact with the shell. There are a bunch of different terminal emulators we can use. Some Linux distributions install several. These might include gnome-terminal, konsole, xterm, rxvt, kvt, nxterm, and eterm.

​ 它是一个被称为终端仿真器的程序。它打开一个窗口，让你与Shell进行交互。我们可以使用许多不同的终端仿真器。一些Linux发行版会安装多个终端仿真器。它们可能包括gnome-terminal、konsole、xterm、rxvt、kvt、nxterm和eterm。

启动终端 Starting a Terminal

Window managers usually have a way to launch a terminal from the menu. Look through the list of programs to see if anything looks like a terminal emulator. While there are a number of different terminal emulators, they all do the same thing. They give us access to a shell session. You will probably develop a preference for one, based on the different bells and whistles it provides.

​ 窗口管理器通常有一种从菜单启动终端的方法。浏览程序列表，看看是否有类似终端仿真器的选项。虽然有许多不同的终端仿真器，但它们都具有相同的功能。它们给我们提供了访问Shell会话的途径。你可能会根据它们提供的不同特性和功能，对其中的某个终端仿真器有所偏好。

测试键盘输入 Testing the Keyboard

OK, let’s try some typing. Bring up a terminal window. The first thing we should see is a shell prompt that contains our user name and the name of the machine followed by a dollar sign. Something like this:

​ 好的，让我们试着输入一些内容。打开一个终端窗口。我们应该首先看到一个包含我们的用户名和计算机名称后面跟着一个美元符号的Shell提示符。类似这样：

1

[me@linuxbox me]$

Excellent! Now type some nonsense characters and press the enter key.

​ 太棒了！现在输入一些无意义的字符，然后按回车键。

1

[me@linuxbox me]$ kdkjflajfks

If all went well, we should have gotten an error message complaining that it cannot understand the command:

​ 如果一切正常，我们应该会收到一个错误消息，说明它无法理解该命令：

1
2

[me@linuxbox me]$ kdkjflajfks
bash: kdkjflajfks: command not found

Wonderful! Now press the up-arrow key. Watch how our previous command “kdkjflajfks” returns. Yes, we have command history. Press the down-arrow and we get the blank line again.

​ 太好了！现在按向上箭头键。注意我们之前的命令"kdkjflajfks"会重新出现。是的，我们有命令历史记录。按向下箭头键，我们又回到了空白行。

Recall the “kdkjflajfks” command using the up-arrow key if needed. Now, try the left and right-arrow keys. We can position the text cursor anywhere in the command line. This allows us to easily correct mistakes.

​ 如果需要，可以使用向上箭头键来重新调用"kdkjflajfks"命令。现在，试试左右箭头键。我们可以将文本光标定位在命令行的任何位置。这使我们可以轻松纠正错误。

你没有以root用户身份操作，对吗？ You’re not operating as root, are you?

If the last character of your shell prompt is # rather than $, you are operating as the superuser. This means that you have administrative privileges. This can be dangerous, since you are able to delete or overwrite any file on the system. Unless you absolutely need administrative privileges, do not operate as the superuser.

​ 如果你的Shell提示符的最后一个字符是#而不是$，那么你正在以超级用户的身份操作。这意味着你拥有管理员特权。这可能是危险的，因为你可以删除或覆盖系统上的任何文件。除非你绝对需要管理员特权，否则不要以超级用户身份操作。

使用鼠标 Using the Mouse

Even though the shell is a command line interface, the mouse is still handy.

​ 虽然Shell是一个命令行界面，但鼠标仍然很方便。

Besides using the mouse to scroll the contents of the terminal window, we can can use it to copy text. Drag the mouse over some text (for example, “kdkjflajfks” right here on the browser window) while holding down the left button. The text should highlight. Release the left button and move the mouse pointer to the terminal window and press the middle mouse button (alternately, press both the left and right buttons at the same time when working on a touch pad). The text we highlighted in the browser window should be copied into the command line.

​ 除了使用鼠标滚动终端窗口的内容，我们还可以使用它来复制文本。按住左键，拖动鼠标在一些文本上（例如，在浏览器窗口中的"kdkjflajfks"），文本将被突出显示。释放左键，将鼠标指针移动到终端窗口上，并按下中间鼠标按钮（或者在触摸板上同时按下左键和右键）。我们在浏览器窗口中突出显示的文本将被复制到命令行中。

关于焦点的一些说明… A few words about focus…

When you installed your Linux system and its window manager (most likely Gnome or KDE), it was configured to behave in some ways like that legacy operating system.

​ 当你安装Linux系统及其窗口管理器（很可能是Gnome或KDE）时，它会配置成某种程度上与那个遗留操作系统类似的行为。

In particular, it probably has its focus policy set to “click to focus.” This means that in order for a window to gain focus (become active) you have to click in the window. This is contrary to traditional X Window behavior. You should consider setting the focus policy to “focus follows mouse”. You may find it strange at first that windows don’t raise to the front when they get focus (you have to click on the window to do that), but you will enjoy being able to work on more than one window at once without having the active window obscuring the other. Try it and give it a fair trial; I think you will like it. You can find this setting in the configuration tools for your window manager.

​ 特别是，它可能将其焦点策略设置为"点击获取焦点"。这意味着为了使窗口获得焦点（变为活动状态），你必须在窗口中点击。这与传统的X Window行为相反。你应该考虑将焦点策略设置为"焦点跟随鼠标"。起初，窗口不会在获得焦点时自动提到前台可能会让你感到奇怪（你必须点击窗口才能做到），但你将享受到能够同时在多个窗口上工作而不会被活动窗口遮挡的便利。尝试一下并进行充分试用；我相信你会喜欢它的。你可以在窗口管理器的配置工具中找到此设置。

进一步阅读 Further Reading

• The Wikipedia entry for Steve Bourne, developer of the original Bourne shell
• The Wikipedia article on the Unix shell, the place where all this fun got started
• The “Power Terminals” Adventure
• Steve Bourne的维基百科页面，原始Bourne shell的开发者
• Unix Shell的维基百科文章，这就是所有这些有趣的东西开始的地方
• “Power Terminals” 探险

2.2 - 导航

导航 Navigation

https://linuxcommand.org/lc3_lts0020.php

In this lesson, we will introduce our first three commands: pwd (print working directory), cd (change directory), and ls (list files and directories).

​ 在本课程中，我们将介绍我们的前三个命令：pwd（打印当前工作目录）、cd（切换目录）和ls（列出文件和目录）。

Those new to the command line will need to pay close attention to this lesson since the concepts will take some getting used to.

​ 对于命令行不熟悉的人来说，需要特别注意这节课，因为这些概念需要一些时间来适应。

文件系统组织 File System Organization

Like Windows, the files on a Linux system are arranged in what is called a hierarchical directory structure. This means that they are organized in a tree-like pattern of directories (called folders in other systems), which may contain files and subdirectories. The first directory in the file system is called the root directory. The root directory contains files and subdirectories, which contain more files and subdirectories and so on and so on.

​ 与Windows一样，Linux系统上的文件以所谓的分层目录结构进行排列。这意味着它们以一种类似树状的模式组织在目录中（其他系统中称为文件夹），这些目录中可能包含文件和子目录。文件系统中的第一个目录称为根目录。根目录包含文件和子目录，这些子目录又包含更多的文件和子目录，以此类推。

Most graphical environments include a file manager program used to view and manipulate the contents of the file system. Often we will see the file system represented like this:

​ 大多数图形界面都包含一个文件管理器程序，用于查看和操作文件系统的内容。通常，我们会看到文件系统以这样的方式表示：

One important difference between Windows and Unix-like operating systems such as Linux is that Linux does not employ the concept of drive letters. While Windows drive letters split the file system into a series of different trees (one for each device), Linux always has a single tree. Different storage devices may be different branches of the tree, but there is always just a single tree.

​ Windows和Linux等类Unix操作系统之间一个重要的区别是，Linux不使用驱动器字母的概念。而Windows的驱动器字母将文件系统分割为一系列不同的树（每个设备对应一个树），Linux始终只有一棵树。不同的存储设备可能是树的不同分支，但始终只有一棵树。

pwd

Since the command line interface cannot provide graphic pictures of the file system structure, we must have a different way of representing it. To do this, think of the file system tree as a maze, and that we are standing in it. At any given moment, we are located in a single directory. Inside that directory, we can see its files and the pathway to its parent directory and the pathways to the subdirectories of the directory in which we are standing.

​ 由于命令行界面无法提供文件系统结构的图形图片，我们必须采用不同的方式来表示它。为此，将文件系统树视为一个迷宫，并且我们正在其中。在任何给定的时刻，我们位于单个目录中。在该目录中，我们可以看到其文件以及到其父目录和所处目录的子目录的路径。

The directory we are standing in is called the working directory. To see the name of the working directory, we use the pwd command.

​ 我们所处的目录称为工作目录。要查看工作目录的名称，我们使用pwd命令。

1
2

[me@linuxbox me]$ pwd
/home/me

When we first log on to our Linux system, the working directory is set to our home directory. This is where we put our files. On most systems, the home directory will be called /home/user_name, but it can be anything according to the whims of the system administrator.

​ 当我们首次登录到Linux系统时，工作目录设置为我们的主目录。这是我们放置文件的地方。在大多数系统上，主目录将被称为/home/user_name，但根据系统管理员的喜好，它可以是任何名称。

To list the files in the working directory, we use the ls command.

​ 要列出工作目录中的文件，我们使用ls命令。

1
2
3

[me@linuxbox me]$ ls
Desktop    Downloads         foo.txt  Pictures  Templates
Documents  examples.desktop  Music    Public    Videos

We will come back to ls in the next lesson. There are a lot of fun things you can do with it, but we have to talk about pathnames and directories a bit first.

​ 我们将在下一课中回到ls命令。你可以用它做很多有趣的事情，但首先我们需要讨论路径名和目录的一些内容。

cd

To change the working directory (where we are standing in the maze) we use the cd command. To do this, we type cd followed by the pathname of the desired working directory. A pathname is the route we take along the branches of the tree to get to the directory we want. Pathnames can be specified two different ways; absolute pathnames or relative pathnames. Let’s look with absolute pathnames first.

​ 要更改工作目录（我们在迷宫中的位置），我们使用cd命令。为此，我们输入cd，然后输入所需工作目录的路径名。路径名是我们沿树的分支行进以到达所需目录或文件的路径。路径名可以用两种不同的方式指定：绝对路径名或相对路径名。让我们首先看一下绝对路径名。

An absolute pathname begins with the root directory and follows the tree branch by branch until the path to the desired directory or file is completed. For example, there is a directory on your system in which most programs are installed. The pathname of the directory is /usr/bin. This means from the root directory (represented by the leading slash in the pathname) there is a directory called “usr” which contains a directory called “bin”.

​ 绝对路径名以根目录开始，沿树的每个分支一直到完成到达所需目录或文件的路径。例如，你的系统上有一个大多数程序安装在其中的目录。该目录的路径名为/usr/bin。这意味着从根目录（路径名中的前导斜杠表示根目录）开始，有一个名为"usr"的目录，其中包含一个名为"bin"的目录。

Let’s try this out:

​ 让我们试一下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

me@linuxbox me]$ cd /usr/bin
me@linuxbox bin]$ pwd
/usr/bin
me@linuxbox bin]$ ls
'['                                   mshortname
 2to3-2.7                             mshowfat
 411toppm                             mtools
 a2ps                                 mtoolstest
 a2ps-lpr-wrapper                     mtr
 aa-enabled                           mtrace
 aa-exec                              mtr-packet
 aclocal                              mtvtoppm
 aclocal-1.15                         mtype
 aconnect                             mutter
 acpi_listen                          mxtar
 add-apt-repository                   mzip
 addpart                              namei

and many more...

Now we can see that we have changed the current working directory to /usr/bin and that it is full of files. Notice how the shell prompt has changed? As a convenience, it is usually set up to display the name of the working directory.

​ 现在我们可以看到我们已经将当前工作目录更改为/usr/bin，而且它充满了文件。注意到shell提示符已经改变了吗？作为方便起见，它通常设置为显示工作目录的名称。

Where an absolute pathname starts from the root directory and leads to its destination, a relative pathname starts from the working directory. To do this, it uses a couple of special notations to represent relative positions in the file system tree. These special notations are “.” (dot) and “..” (dot dot).

​ 绝对路径名从根目录开始并导向目标目录，而相对路径名从工作目录开始。为此，它使用两个特殊符号来表示文件系统树中的相对位置。这些特殊符号是"."（点）和".."（点点）。

The “.” notation refers to the working directory itself and the “..” notation refers to the working directory’s parent directory. Here is how it works. Let’s change the working directory to /usr/bin again:

​ “.“符号表示工作目录本身，”..“符号表示工作目录的父目录。以下是它的工作原理。让我们再次将工作目录更改为/usr/bin：

1
2
3

me@linuxbox me]$ cd /usr/bin
me@linuxbox bin]$ pwd
/usr/bin

O.K., now let’s say that we wanted to change the working directory to the parent of /usr/bin which is /usr. We could do that two different ways. First, with an absolute pathname:

​ 好了，现在假设我们想将工作目录更改为/usr/bin的父目录，即/usr。我们可以用两种不同的方式来做到这一点。首先，使用绝对路径名：

1
2
3

me@linuxbox bin]$ cd /usr
me@linuxbox usr]$ pwd
/usr

Or, with a relative pathname:

或者，使用相对路径名：

1
2
3

me@linuxbox bin]$ cd ..
me@linuxbox usr]$ pwd
/usr

Two different methods with identical results. Which one should we use? The one that requires the least typing!

​ 两种方法得到相同的结果。我们应该使用哪个方法呢？使用输入最少的那个！

Likewise, we can change the working directory from /usr to /usr/bin in two different ways. First using an absolute pathname:

​ 同样地，我们可以用两种不同的方式将工作目录从/usr更改为/usr/bin。首先使用绝对路径名：

1
2
3

me@linuxbox usr]$ cd /usr/bin
me@linuxbox bin]$ pwd
/usr/bin

Or, with a relative pathname:

或者，使用相对路径名：

1
2
3

me@linuxbox usr]$ cd ./bin
me@linuxbox bin]$ pwd
/usr/bin

Now, there is something important that we must point out here. In most cases, we can omit the “./”. It is implied. Typing:

​ 现在，这里有一些重要的事情要指出。在大多数情况下，我们可以省略”./"，它会被默认添加。输入：

1

me@linuxbox usr]$ cd bin

would do the same thing. In general, if we do not specify a pathname to something, the working directory will be assumed. There is one important exception to this, but we won’t get to that for a while.

​ 将会产生相同的效果。通常情况下，如果我们没有指定路径名，那么将假定为工作目录。但有一个重要的例外，不过我们要等一会儿再讨论它。

一些快捷方式 A Few Shortcuts

If we type cd followed by nothing, cd will change the working directory to our home directory.

​ 如果我们只输入cd而不跟任何内容，cd命令将会将工作目录切换为我们的主目录。

A related shortcut is to type cd ~user_name. In this case, cd will change the working directory to the home directory of the specified user.

​ 相关的快捷方式是输入cd ~user_name。这种情况下，cd将会将工作目录切换为指定用户的主目录。

Typing cd - changes the working directory to the previous one.

​ 输入cd -将工作目录切换为上一个目录。

文件名的重要事实 Important facts about file names

1. File names that begin with a period character are hidden. This only means that ls will not list them unless we say ls -a. When your account was created, several hidden files were placed in your home directory to configure things for your account. Later on we will take a closer look at some of these files to see how you can customize our environment. In addition, some applications will place their configuration and settings files in your home directory as hidden files.
2. 以句点字符开头的文件名是隐藏的。这仅意味着除非我们使用ls -a命令，否则ls不会列出它们。在创建您的帐户时，系统会在主目录中放置一些隐藏文件来为您的帐户配置一些东西。稍后我们将仔细查看其中的一些文件，了解如何自定义我们的环境。此外，一些应用程序会将它们的配置和设置文件作为隐藏文件放置在您的主目录中。
3. File names in Linux, like Unix, are case sensitive. The file names “File1” and “file1” refer to different files.
4. Linux中的文件名（如Unix）区分大小写。文件名"File1"和"file1"表示不同的文件。
5. Linux has no concept of a “file extension” like Windows systems. You may name files any way you like. However, while Linux itself does not care about file extensions, many application programs do.
6. Linux没有类似于Windows系统的"文件扩展名"的概念。您可以按任意方式命名文件。但是，尽管Linux本身不关心文件扩展名，但许多应用程序程序则关心。
7. Though Linux supports long file names which may contain embedded spaces and punctuation characters, limit the punctuation characters to period, dash, and underscore. Most importantly, do not embed spaces in file names. If you want to represent spaces between words in a file name, use underscore characters. You will thank yourself later.
8. 虽然Linux支持长文件名，可以包含嵌入的空格和标点符号字符，但标点符号字符应限制为句点、破折号和下划线。最重要的是，不要在文件名中嵌入空格。如果要表示文件名中的单词之间的空格，请使用下划线字符。以后您会感谢自己这么做。

2.3 - 四处浏览

四处浏览 Looking Around

https://linuxcommand.org/lc3_lts0030.php

Now that we know how to move from working directory to working directory, we’re going to take a tour of our Linux system and, along the way, learn some things about what makes it tick. But before we begin, we have to learn about some tools that will come in handy during our journey. These are:

​ 现在我们知道如何从一个工作目录移动到另一个工作目录了，我们将在 Linux 系统中进行一次浏览，并在此过程中了解一些关于 Linux 运行的原理的知识。但在开始之前，我们必须学习一些在我们的旅程中会派上用场的工具。它们是：

• ls (list files and directories)
• less (view text files)
• file (classify a file’s contents)
• ls（列出文件和目录）
• less（查看文本文件）
• file（对文件进行分类）

ls

The ls command is used to list the contents of a directory. It is probably the most commonly used Linux command. It can be used in a number of different ways. Here are some examples:

​ ls 命令用于列出目录的内容。它可能是最常用的 Linux 命令之一。它可以以多种不同的方式使用。以下是一些示例：

These examples also point out an important concept about commands. Most commands operate like this:

​ 这些示例还指出了关于命令的一个重要概念。大多数命令的操作方式类似于：

command -options arguments

where command is the name of the command, -options is one or more adjustments to the command’s behavior, and arguments is one or more “things” upon which the command operates.

​ 其中 command 是命令的名称，-options 是对命令行为进行的一个或多个调整，arguments 是命令操作的一个或多个"东西"。

In the case of ls, we see that ls is the name of the command, and that it can have one or more options, such as -a and -l, and it can operate on one or more files or directories.

​ 在 ls 的情况下，我们可以看到 ls 是命令的名称，它可以有一个或多个选项，比如 -a 和 -l，并且可以操作一个或多个文件或目录。

更详细的长格式 A Closer Look at Long Format

If we use the -l option with ls, you will get a file listing that contains a wealth of information about the files being listed. Here’s an example:

​ 如果我们在 ls 命令中使用 -l 选项，将会得到一个包含有关所列出文件的丰富信息的文件列表。这里有一个示例：

-rw-------   1 me       me            576 Apr 17  2019 weather.txt
drwxr-xr-x   6 me       me           1024 Oct  9  2019 web_page
-rw-rw-r--   1 me       me         276480 Feb 11 20:41 web_site.tar
-rw-------   1 me       me           5743 Dec 16  2018 xmas_file.txt

----------     -------  -------  -------- ------------ -------------
    |             |        |         |         |             |
    |             |        |         |         |         File Name
    |             |        |         |         |
    |             |        |         |         +---  Modification Time
    |             |        |         |
    |             |        |         +-------------   Size (in bytes)
    |             |        |
    |             |        +-----------------------        Group
    |             |
    |             +--------------------------------        Owner
    |
    +----------------------------------------------   File Permissions

• 文件名 File Name

  The name of the file or directory.

  文件或目录的名称。

• 修改时间 Modification Time

  The last time the file was modified. If the last modification occurred more than six months in the past, the date and year are displayed. Otherwise, the time of day is shown.

  文件最后一次修改的时间。如果最后一次修改是在六个月以上之前，将显示日期和年份。否则，显示具体时间。

• 大小 Size

  The size of the file in bytes.

  文件的大小（以字节为单位）。

• 组 Group

  The name of the group that has file permissions in addition to the file’s owner.

  除了文件所有者外，具有文件权限的组的名称。

• 所有者 Owner

  The name of the user who owns the file.

  文件的所有者的用户名。

• 文件权限 File Permissions

  A representation of the file’s access permissions. The first character is the type of file. A “-” indicates a regular (ordinary) file. A “d” indicates a directory. The second set of three characters represent the read, write, and execution rights of the file’s owner. The next three represent the rights of the file’s group, and the final three represent the rights granted to everybody else. We’ll discuss this in more detail in a later lesson.

  文件访问权限的表示形式。第一个字符表示文件的类型。"-" 表示普通文件，“d” 表示目录。接下来的三个字符表示文件所有者的读取、写入和执行权限。接下来的三个字符表示文件所属组的权限，最后的三个字符表示授予其他人的权限。我们将在以后的课程中详细讨论这个。

less

less is a program that lets us view text files. This is very handy since many of the files used to control and configure Linux are human readable.

​ less 是一个用于查看文本文件的程序。这非常方便，因为用于控制和配置 Linux 的许多文件都是可读的。

什么是"文本"？ What is “text”?

There are many ways to represent information on a computer. All methods involve defining a relationship between the information and some numbers that will be used to represent it. Computers, after all, only understand numbers and all data is converted to numeric representation.

​ 在计算机上表示信息有许多方式。所有的方法都涉及将信息与一些数字之间的关系定义起来，这些数字将用于表示它。毕竟，计算机只能理解数字，所有的数据都被转换为数字表示。

Some of these representation systems are very complex (such as compressed multimedia files), while others are rather simple. One of the earliest and simplest is called ASCII text. ASCII (pronounced “As-Key”) is short for American Standard Code for Information Interchange. This is a simple encoding scheme that was first used on Teletype machines to map keyboard characters to numbers.

​ 其中一些表示系统非常复杂（例如压缩的多媒体文件），而其他一些则相当简单。其中一种最早和最简单的表示系统被称为 ASCII 文本。ASCII（发音为"As-Key"）是美国信息交换标准代码的缩写。这是一种简单的编码方案，最初在电传打字机上用于将键盘字符映射到数字。

Text is a simple one-to-one mapping of characters to numbers. It is very compact. Fifty characters of text translates to fifty bytes of data. Throughout a Linux system, many files are stored in text format and there are many Linux tools that work with text files. Even Windows systems recognize the importance of this format. The well-known NOTEPAD.EXE program is an editor for plain ASCII text files.

​ 文本是字符与数字之间的简单一对一映射。它非常紧凑。五十个字符的文本转换为五十个字节的数据。在 Linux 系统中，许多文件都以文本格式存储，并且有许多 Linux 工具可以处理文本文件。即使在 Windows 系统中，也认识到这种格式的重要性。著名的 NOTEPAD.EXE 程序就是用于编辑纯 ASCII 文本文件的编辑器。

The less program is invoked by simply typing:

​ 通过简单地键入以下命令即可调用 less 程序：

less text_file

This will display the file.

​ 这将显示文件内容。

控制 less - Controlling less

Once started, less will display the text file one page at a time. We can use the Page Up and Page Down keys to move through the text file. To exit less, we type “q”. Here are some commands that less will accept:

​ 启动后，less 将逐页显示文本文件。我们可以使用 Page Up 和 Page Down 键在文本文件中进行导航。要退出 less，我们输入 “q”。以下

file

As we wander around our Linux system, it is helpful to determine what kind of data a file contains before we try to view it. This is where the file command comes in. file will examine a file and tell us what kind of file it is.

​ 在我们浏览 Linux 系统时，在尝试查看文件之前，确定文件包含的数据类型很有帮助。这就是 file 命令的用处。file 命令将检查一个文件并告诉我们它是什么类型的文件。

To use the file program, we just type:

​ 要使用 file 程序，只需键入：

file name_of_file

The file program can recognize most types of files, such as:

​ file 程序可以识别大多数类型的文件，例如：

While it may seem that most files cannot be viewed as text, a surprising number can be. This is especially true of the important configuration files. During our adventure we will see that many features of the operating system are controlled by text configuration files and shell scripts. In Linux, there are no secrets!

​ 虽然看起来大多数文件都不能作为文本查看，但实际上有相当多的文件可以。这在重要的配置文件中尤其如此。在我们的探险中，我们将看到操作系统的许多功能都由文本配置文件和 shell 脚本控制。在 Linux 中，没有秘密！

2.4 - 导览

导览 - A Guided Tour

https://linuxcommand.org/lc3_lts0040.php

It’s time to take our tour. The table below lists some interesting places to explore. This is by no means a complete list, but it should prove to be an interesting adventure. For each of the directories listed below, do the following:

​ 是时候开始我们的导览了。下面的表格列出了一些有趣的探索地点。这并不是一个完整的列表，但应该会是一次有趣的冒险。对于下面列出的每个目录，执行以下操作：

• cd into each directory.
• 使用 cd 进入每个目录。
• Use ls to list the contents of the directory.
• 使用 ls 列出目录的内容。
• If there is an interesting file, use the file command to determine its contents.
• 如果有一个有趣的文件，请使用 file 命令确定其内容。
• For text files, use less to view them.
• 对于文本文件，使用 less 查看它们。

​ A weird kind of file…

​ 一种奇怪的文件…

During your tour, you probably noticed a strange kind of directory entry, particularly in the /lib directory. When listed with ls -l, you might have seen something like this:

​ 在你的导览中，你可能注意到了一种奇怪的目录条目，尤其是在 /lib 目录中。当用 ls -l 列出时，你可能会看到像这样的东西：

lrwxrwxrwx     25 Jul  3 16:42 System.map -> /boot/System.map-4.0.36-3
-rw-r--r-- 105911 Oct 13  2018 System.map-4.0.36-0.7
-rw-r--r-- 105935 Dec 29  2018 System.map-4.0.36-3
-rw-r--r-- 181986 Dec 11  2019 initrd-4.0.36-0.7.img
-rw-r--r-- 182001 Dec 11  2019 initrd-4.0.36.img
lrwxrwxrwx     26 Jul  3 16:42 module-info -> /boot/module-info-4.0.36-3
-rw-r--r--  11773 Oct 13  2018 module-info-4.0.36-0.7
-rw-r--r--  11773 Dec 29  2018 module-info-4.0.36-3
lrwxrwxrwx     16 Dec 11  2019 vmlinuz -> vmlinuz-4.0.36-3
-rw-r--r-- 454325 Oct 13  2018 vmlinuz-4.0.36-0.7
-rw-r--r-- 454434 Dec 29  2018 vmlinuz-4.0.36-3

Notice the files, System.map, module-info and vmlinuz. See the strange notation after the file names?

注意文件 System.map、module-info 和 vmlinuz。看到文件名后面的奇怪符号了吗？

Files such as this are called symbolic links. Symbolic links are a special type of file that points to another file. With symbolic links, it is possible for a single file to have multiple names. Here’s how it works: Whenever the system is given a file name that is a symbolic link, it transparently maps it to the file it is pointing to.

​ 此类文件称为 符号链接。符号链接是一种特殊类型的文件，它指向另一个文件。通过符号链接，一个文件可以有多个名称。它的工作原理如下：每当系统获得一个符号链接的文件名时，它会自动地将其映射到指向的文件。

Just what is this good for? This is a very handy feature. Let’s consider the directory listing above (which is the /boot directory of an old system). This system has had multiple versions of the Linux kernel installed. We can see this from the files vmlinuz-4.0.36-0.7 and vmlinuz-4.0.36-3. These file names suggest that both version 4.0.36-0.7 and 4.0.36-3 are installed. Because the file names contain the version it is easy to see the differences in the directory listing. However, this would be confusing to programs that rely on a fixed name for the kernel file. These programs might expect the kernel to simply be called "vmlinuz". Here is where the beauty of the symbolic link comes in. By creating a symbolic link called vmlinuz that points to vmlinuz-4.0.36-3, we have solved the problem.

​ 这有什么用呢？这是一个非常方便的功能。让我们来看看上面的目录列表（这是一个旧系统的 /boot 目录）。该系统安装了多个版本的 Linux 内核，我们可以从文件 vmlinuz-4.0.36-0.7 和 vmlinuz-4.0.36-3 看出这一点。这些文件名表明安装了版本 4.0.36-0.7 和 4.0.36-3。由于文件名包含版本信息，因此很容易在目录列表中看到它们之间的差异。然而，对于依赖于固定名称的内核文件的程序来说，这可能会造成困惑。这些程序可能期望内核简单地称为 "vmlinuz"。这就是符号链接的优点所在。通过创建一个名为 vmlinuz 的符号链接，它指向 vmlinuz-4.0.36-3，我们解决了这个问题。

To create symbolic links, we use the ln command.

​ 要创建符号链接，我们使用 ln 命令。

进一步阅读 Further Reading

• To learn more about the organization of the Linux filesystem, consult the Filesystem Hierarchy Standard
• 要了解更多关于 Linux 文件系统组织的信息，请参阅文件系统层次结构标准（Filesystem Hierarchy Standard）。

2.5 - 操作文件

操作文件 Manipulating Files

https://linuxcommand.org/lc3_lts0050.php

This lesson will introduce the following commands:

​ 本课程将介绍以下命令：

• cp - copy files and directories
• mv - move or rename files and directories
• rm - remove files and directories
• mkdir - create directories
• cp - 复制文件和目录
• mv - 移动或重命名文件和目录
• rm - 删除文件和目录
• mkdir - 创建目录

These four commands are among the most frequently used Linux commands. They are the basic commands for manipulating both files and directories.

​ 这四个命令是最常用的 Linux 命令之一。它们是用于操作文件和目录的基本命令。

Now, to be frank, some of the tasks performed by these commands are more easily done with a graphical file manager. With a file manager, you can drag and drop a file from one directory to another, cut and paste files, delete files, etc. So why use these old command line programs?

​ 说实话，其中一些命令执行的任务可以更容易地通过图形文件管理器完成。使用文件管理器，您可以将文件从一个目录拖放到另一个目录，剪切和粘贴文件，删除文件等等。那么为什么要使用这些老旧的命令行程序呢？

The answer is power and flexibility. While it is easy to perform simple file manipulations with a graphical file manager, complicated tasks can be easier with the command line programs. For example, how would you copy all the HTML files from one directory to another, but only copy files that did not exist in the destination directory or were newer than the versions in the destination directory? Pretty hard with with a file manager. Pretty easy with the command line:

​ 答案是权力和灵活性。虽然使用图形文件管理器可以执行简单的文件操作，但使用命令行程序可以更容易地处理复杂的任务。例如，如何将一个目录中的所有 HTML 文件复制到另一个目录，但只复制目标目录中不存在或比目标目录中的版本更新的文件？使用文件管理器可能会很困难，但使用命令行却很简单：

1

[me@linuxbox me]$ cp -u *.html destination

通配符 Wildcards

Before we begin with our commands, we’ll first look at a shell feature that makes these commands so powerful. Since the shell uses filenames so much, it provides special characters to help you rapidly specify groups of filenames. These special characters are called wildcards. Wildcards allow you to select filenames based on patterns of characters. The table below lists the wildcards and what they select:

​ 在开始使用这些命令之前，我们首先来看一下使这些命令如此强大的一个 shell 特性。由于 shell 经常使用文件名，它提供了一些特殊字符，可以帮助您快速指定文件名的组。这些特殊字符称为 通配符。通配符允许您根据字符模式选择文件名。下表列出了通配符及其选择的内容：

Using wildcards, it is possible to construct very sophisticated selection criteria for filenames. Here are some examples of patterns and what they match:

​ 使用通配符，可以构造非常复杂的文件名选择条件。以下是一些模式示例及其匹配的内容：

We can use wildcards with any command that accepts filename arguments.

​ 我们可以在接受文件名参数的任何命令中使用通配符。

cp

The cp program copies files and directories. In its simplest form, it copies a single file:

​ cp 程序用于复制文件和目录。在最简单的形式中，它可以复制单个文件：

1

[me@linuxbox me]$ cp file1 file2

It can also be used to copy multiple files (and/or directories) to a different directory:

​ 它还可以用于将多个文件（和/或目录）复制到不同的目录：

1

[me@linuxbox me]$ cp file... directory

A note on notation: … signifies that an item can be repeated one or more times.

​ 关于符号的说明： … 表示一个项目可以重复一次或多次。

Other useful examples of cp and its options include:

​ cp 和其选项的其他有用示例包括：

mv

The mv command moves or renames files and directories depending on how it is used. It will either move one or more files to a different directory, or it will rename a file or directory. To rename a file, it is used like this:

​ mv 命令根据使用方式的不同，可以移动或重命名文件和目录。要重命名文件，可以使用以下方式：

1

[me@linuxbox me]$ mv filename1 filename2

To move files (and/or directories) to a different directory:

​ 要将文件（和/或目录）移动到另一个目录：

1

[me@linuxbox me]$ mv file... directory

Examples of mv and its options include:

​ mv 和其选项的示例包括：

rm

The rm command removes (deletes) files and directories.

​ rm 命令用于删除文件和目录。

1

[me@linuxbox me]$ rm file...

Using the recursive option (-r), rm can also be used to delete directories:

​ 使用递归选项（-r），rm 还可以用于删除目录：

1

[me@linuxbox me]$ rm -r directory...

Examples of rm and its options include:

​ rm 和其选项的示例包括：

在使用 rm 时要小心！ Be careful with rm!

Linux does not have an undelete command. Once you delete something with rm, it’s gone. You can inflict terrific damage on your system with rm if you are not careful, particularly with wildcards.

​ Linux 没有恢复命令。一旦使用 rm 删除了某个东西，它就消失了。如果不小心使用 rm，特别是使用通配符，可能会对系统造成严重的破坏。

*Before you use rm with wildcards, try this helpful trick:* construct your command using ls instead. By doing this, you can see the effect of your wildcards before you delete files. After you have tested your command with ls, recall the command with the up-arrow key and then substitute rm for ls in the command.

​ 在使用带有通配符的 rm 之前，试试这个有用的技巧： 使用 ls 构建命令。这样，您可以在删除文件之前查看通配符的效果。在使用 ls 测试过命令后，可以使用上箭头键召回命令，然后在命令中将 ls 替换为 rm。

mkdir

The mkdir command is used to create directories. To use it, you simply type:

​ mkdir 命令用于创建目录。只需键入：

1

[me@linuxbox me]$ mkdir directory...

使用通配符的命令 Using Commands with Wildcards

Since the commands we have covered here accept multiple file and directories names as arguments, you can use wildcards to specify them. Here are a few examples:

​ 由于我们在这里介绍的命令接受多个文件和目录名称作为参数，您可以使用通配符来指定它们。以下是一些示例：

进一步阅读 Further Reading

• Chapter 4 of The Linux Command Line covers this topic in more detail
• Linux 命令行第 4 章对这个主题进行了更详细的讨论。

2.6 - 使用命令

使用命令 - Working with Commands

https://linuxcommand.org/lc3_lts0060.php

Up until now, we have seen a number of commands and their mysterious options and arguments. In this lesson, we will try to remove some of that mystery. We will introduce the following commands.

​ 到目前为止，我们已经看到了许多命令及其神秘的选项和参数。在本课程中，我们将尝试消除其中的一些神秘感。我们将介绍以下命令。

• type - Display information about command type
• which - Locate a command
• help - Display reference page for shell builtin
• man - Display an on-line command reference
• type - 显示命令类型的信息
• which - 定位一个命令
• help - 显示内置shell命令的参考页面
• man - 显示在线命令参考

什么是"命令"? What are “Commands?”

Commands can be one of 4 different kinds:

​ 命令可以是以下4种不同类型之一：

1. An executable program like all those files we saw in /usr/bin. Within this category, programs can be compiled binaries such as programs written in C and C++, or programs written in scripting languages such as the shell, Perl, Python, Ruby, etc.
2. 可执行程序，如我们在 /usr/bin 中看到的所有文件。在此类别中，程序可以是编译的二进制文件，例如用 C 和 C++ 编写的程序，或者是用脚本语言（如Shell、Perl、Python、Ruby等）编写的程序。
3. A command built into the shell itself. bash provides a number of commands internally called shell builtins. The cd command, for example, is a shell builtin.
4. 内置于shell本身的命令。bash 提供了许多称为shell内置命令的内部命令。例如，cd 命令就是一个内置命令。
5. A shell function. These are miniature shell scripts incorporated into the environment. We will cover configuring the environment and writing shell functions in later lessons, but for now, just be aware that they exist.
6. shell函数。这些是嵌入到环境中的小型shell脚本。我们将在后面的课程中介绍配置环境和编写shell函数，但现在只需要知道它们的存在即可。
7. An alias. Commands that we can define ourselves, built from other commands. This will be covered in a later lesson.
8. 别名。我们可以自定义的由其他命令构建的命令。这将在后面的课程中介绍。

识别命令 Identifying Commands

It is often useful to know exactly which of the four kinds of commands is being used and Linux provides a couple of ways to find out.

​ 通常，了解正在使用的四种命令类型中的哪一种非常有用，Linux 提供了几种方法来找到答案。

type

The type command is a shell builtin that displays the kind of command the shell will execute, given a particular command name. It works like this:

​ type 命令是一个内置于shell的命令，它显示给定命令名称的命令类型。它的使用方法如下：

1

type command

where “command” is the name of the command we want to examine. Here are some examples:

​ 其中 “command” 是我们想要检查的命令的名称。下面是一些示例：

1
2
3
4
5
6

[me@linuxbox me]$ type type
type is a shell builtin
[me@linuxbox me]$ type ls
s is aliased to `ls --color=auto`
[me@linuxbox me]$ type cp
cp is /bin/cp

Here we see the results for three different commands. Notice that the one for ls and how the ls command is actually an alias for the ls command with the “– color=auto” option added. Now we know why the output from ls is displayed in color!

​ 这里我们看到了三个不同命令的结果。注意 ls 命令的结果，ls 实际上是 ls 命令的一个别名，并添加了 --color=auto 选项。现在我们知道为什么 ls 命令的输出显示为彩色了！

which

Sometimes there is more than one version of an executable program installed on a system. While this is not very common on desktop systems, it’s not unusual on large servers. To determine the exact location of a given executable, the which command is used:

​ 有时在系统上安装了一个可执行程序的多个版本。尽管在桌面系统上这种情况并不常见，但在大型服务器上并不罕见。为了确定给定可执行程序的确切位置，可以使用 which 命令：

1
2

[me@linuxbox me]$ which ls
/bin/ls

which only works for executable programs, not builtins nor aliases that are substitutes for actual executable programs.

​ which 仅适用于可执行程序，而不适用于内置命令或替代实际可执行程序的别名。

获取命令文档 Getting Command Documentation

With this knowledge of what a command is, we can now search for the documentation available for each kind of command.

​ 有了对命令的了解，我们现在可以搜索每种类型命令可用的文档。

help

bash has a built-in help facility available for each of the shell builtins. To use it, type “help” followed by the name of the shell builtin. Optionally, we can add the -m option to change the format of the output. For example:

​ bash 为每个shell内置命令提供了一个内置的帮助功能。要使用它，键入“help”，然后是shell内置命令的名称。我们还可以添加 -m 选项以更改输出的格式。例如：

 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

[me@linuxbox me]$ help -m cd
NAME
    cd - Change the shell working directory.

SYNOPSIS
    cd [-L|-P] [dir]

DESCRIPTION
    Change the shell working directory.
    
    Change the current directory to DIR.  The default DIR is the value of the
    HOME shell variable.
    
    The variable CDPATH defines the search path for the directory containing
    DIR.  Alternative directory names in CDPATH are separated by a colon (:).
    A null directory name is the same as the current directory.  If DIR begins
    with a slash (/), then CDPATH is not used.
    
    If the directory is not found, and the shell option `cdable_vars' is set,
    the word is assumed to be  a variable name.  If that variable has a value,
    its value is used for DIR.
    
    Options:
        -L  force symbolic links to be followed
        -P  use the physical directory structure without following symbolic
      links
    
    The default is to follow symbolic links, as if `-L' were specified.
    
    Exit Status:
    Returns 0 if the directory is changed; non-zero otherwise.

SEE ALSO
    bash(1)

IMPLEMENTATION
    GNU bash, version 4.1.5(1)-release (i486-pc-linux-gnu)
    Copyright (C) 2009 Free Software Foundation, Inc.

A note on notation: When square brackets appear in the description of a command’s syntax, they indicate optional items. A vertical bar character indicates mutually exclusive items. In the case of the cd command above:

​ 关于符号的说明： 当命令语法的描述中出现方括号时，表示这些是可选项。竖线字符表示互斥的选项。对于上面的 cd 命令：

1

cd [-L|-P] [dir]

This notation says that the command cd may be followed optionally by either a “-L” or a “-P” and further, optionally followed by the argument “dir”.

​ 这个符号说明表示 cd 命令后面可以选择跟着“-L”或者“-P”，然后再可选地跟着参数“dir”。

--help

Many executable programs support a “--help” option that displays a description of the command’s supported syntax and options. For example:

​ 许多可执行程序支持“--help”选项，它会显示命令的支持语法和选项的描述。例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

[me@linuxbox me]$ mkdir --help
Usage: mkdir [OPTION] DIRECTORY...
Create the DIRECTORY(ies), if they do not already exist.
Mandatory arguments to long options are mandatory for short options
too.

   -Z, --context=CONTEXT (SELinux) set security context to CONTEXT
   -m, --mode=MODE   set file mode (as in chmod), not a=rwx – umask
   -p, --parents     no error if existing, make parent directories as
                     needed
   -v, --verbose     print a message for each created directory
   --help            display this help and exit
   --version         output version information and exit

Some programs don’t support the “–help” option, but try it anyway. Often it results in an error message that will reveal similar usage information.

​ 有些程序不支持“--help”选项，但还是可以尝试一下。通常会显示出一个错误消息，其中包含类似的使用信息。

man

Most executable programs intended for command line use provide a formal piece of documentation called a manual or man page. A special paging program called man is used to view them. It is used like this:

​ 大多数用于命令行的可执行程序都提供了一份正式的文档，称为手册或man页。用于查看它们的特殊分页程序称为 man。使用方法如下：

1

man program

where “program” is the name of the command to view. Man pages vary somewhat in format but generally contain a title, a synopsis of the command’s syntax, a description of the command’s purpose, and a listing and description of each of the command’s options. Man pages, however, do not usually include examples, and are intended as a reference, not a tutorial. Let’s try viewing the man page for the ls command:

​ 其中“program”是要查看的命令的名称。Man页的格式有所不同，但通常包含标题、命令语法的概述、命令目的的描述以及每个命令选项的列表和描述。不过，Man页通常不包含示例，并且旨在作为参考而不是教程。让我们尝试查看 ls 命令的 man 页：

1

[me@linuxbox me]$ man ls

On most Linux systems, man uses less to display the manual page, so all of the familiar less commands work while displaying the page.

​ 在大多数Linux系统上，man 使用 less 来显示手册页，因此在显示页面时可以使用所有熟悉的 less 命令。

README和其他文档文件 - README and Other Documentation Files

Many software packages installed on your system have documentation files residing in the /usr/share/doc directory. Most of these are stored in plain text format and can be viewed with less. Some of the files are in HTML format and can be viewed with a web browser. We may encounter some files ending with a “.gz” extension. This indicates that they have been compressed with the gzip compression program. The gzip package includes a special version of less called zless that will display the contents of gzip-compressed text files.

​ 安装在系统上的许多软件包在 /usr/share/doc 目录中有文档文件。其中大多数以纯文本格式存储，并可以使用 less 查看。其中一些文件是HTML格式的，可以使用Web浏览器查看。可能会遇到一些以“.gz”扩展名结尾的文件。这表示它们已使用gzip压缩程序进行了压缩。gzip软件包包含一个名为zless的特殊版本的less，可以显示gzip压缩的文本文件的内容。

2.7 - 输入/输出重定向

输入/输出重定向 - I/O Redirection

https://linuxcommand.org/lc3_lts0070.php

In this lesson, we will explore a powerful feature used by command line programs called input/output redirection. As we have seen, many commands such as ls print their output on the display. This does not have to be the case, however. By using some special notations we can redirect the output of many commands to files, devices, and even to the input of other commands.

​ 在这个课程中，我们将探索命令行程序中使用的一项强大功能，称为输入/输出重定向。正如我们所见，许多命令（如 ls）将它们的输出打印到显示器上。但是，情况并非总是如此。通过使用一些特殊的符号，我们可以将许多命令的输出重定向到文件、设备，甚至其他命令的输入。

标准输出 Standard Output

Most command line programs that display their results do so by sending their results to a facility called standard output. By default, standard output directs its contents to the display. To redirect standard output to a file, the “>” character is used like this:

​ 大多数命令行程序将它们的结果显示出来是通过将结果发送到一个称为标准输出的设备。默认情况下，标准输出将其内容定向到显示器上。要将标准输出重定向到文件，可以使用 “>” 符号，像这样：

1

[me@linuxbox me]$ ls > file_list.txt

In this example, the ls command is executed and the results are written in a file named file_list.txt. Since the output of ls was redirected to the file, no results appear on the display.

​ 在这个例子中，执行了 ls 命令，并将结果写入名为 file_list.txt 的文件中。由于 ls 的输出被重定向到文件，所以在显示器上没有显示任何结果。

Each time the command above is repeated, file_list.txt is overwritten from the beginning with the output of the command ls. To have the new results appended to the file instead, we use “>>” like this:

​ 每次重复执行上述命令时，file_list.txt 将被从头开始覆盖为 ls 命令的输出。如果要将新结果追加到文件而不是覆盖，可以使用 “>>"，像这样：

1

[me@linuxbox me]$ls >> file_list.txt

When the results are appended, the new results are added to the end of the file, thus making the file longer each time the command is repeated. If the file does not exist when we attempt to append the redirected output, the file will be created.

​ 当结果被追加时，新的结果会添加到文件的末尾，从而使得文件每次重复执行命令时都会变长。如果在尝试追加重定向输出时文件不存在，文件将会被创建。

标准输入 Standard Input

Many commands can accept input from a facility called standard input. By default, standard input gets its contents from the keyboard, but like standard output, it can be redirected. To redirect standard input from a file instead of the keyboard, the “<” character is used like this:

​ 许多命令可以从一个称为标准输入的设备接受输入。默认情况下，标准输入从键盘获取内容，但是像标准输出一样，它也可以被重定向。要将标准输入从文件而不是键盘重定向，可以使用 “<” 符号，像这样：

1

[me@linuxbox me]$ sort < file_list.txt

In the example above, we used the sort command to process the contents of file_list.txt. The results are output on the display since the standard output was not redirected. We could redirect standard output to another file like this:

​ 在上面的例子中，我们使用了 sort 命令来处理 file_list.txt 的内容。由于没有重定向标准输出，结果会输出到显示器上。我们可以像这样将标准输出重定向到另一个文件：

1

[me@linuxbox me]$ sort < file_list.txt > sorted_file_list.txt

As we can see, a command can have both its input and output redirected. Be aware that the order of the redirection does not matter. The only requirement is that the redirection operators (the “<” and “>”) must appear after the other options and arguments in the command.

​ 如我们所见，一个命令可以同时重定向其输入和输出。需要注意的是，重定向的顺序不重要。唯一的要求是重定向操作符（"<” 和 “>"）必须出现在命令中其他选项和参数之后。

管道 Pipelines

The most useful and powerful thing we can do with I/O redirection is to connect multiple commands together to form what are called pipelines. With pipelines, the standard output of one command is fed into the standard input of another. Here is a very useful example:

​ 使用I/O重定向最有用和强大的功能之一是将多个命令连接在一起，形成所谓的管道。通过管道，一个命令的标准输出被发送到另一个命令的标准输入。下面是一个非常有用的例子：

1

[me@linuxbox me]$ ls -l | less

In this example, the output of the ls command is fed into less. By using this "| less" trick, we can make any command have scrolling output.

​ 在这个例子中，ls 命令的输出被发送到 less 命令。通过使用这个 "| less" 的技巧，我们可以使任何命令都具有滚动输出。

By connecting commands together, we can accomplish amazing feats. Here are some examples to try:

​ 通过将命令连接在一起，我们可以完成令人惊奇的任务。以下是一些可以尝试的例子：

过滤器 Filters

One kind of program frequently used in pipelines is called a filter. Filters take standard input and perform an operation upon it and send the results to standard output. In this way, they can be combined to process information in powerful ways. Here are some of the common programs that can act as filters:

​ 在管道中经常使用的一种程序称为过滤器。过滤器接受标准输入并对其进行操作，然后将结果发送到标准输出。通过这种方式，它们可以结合在一起以强大的方式处理信息。以下是一些常见的可以作为过滤器的程序：

使用管道执行任务 Performing tasks with pipelines

1. Printing from the command line. Linux provides a program called lpr that accepts standard input and sends it to the printer. It is often used with pipes and filters. Here are a couple of examples:

2. 从命令行打印。 Linux提供了一个名为lpr的程序，可以接受标准输入并将其发送到打印机。它经常与管道和过滤器一起使用。以下是一些示例：

   1 2 3

   cat poorly_formatted_report.txt | fmt | pr | lpr cat unsorted_list_with_dupes.txt | sort | uniq | pr | lpr

   In the first example, we use cat to read the file and output it to standard output, which is piped into the standard input of fmt. fmt formats the text into neat paragraphs and outputs it to standard output, which is piped into the standard input of pr. pr splits the text neatly into pages and outputs it to standard output, which is piped into the standard input of lpr. lpr takes its standard input and sends it to the printer.

   在第一个示例中，我们使用cat读取文件并将其输出到标准输出，然后通过管道将其传递给fmt的标准输入。fmt将文本格式化为整齐的段落，并将其输出到标准输出，然后通过管道将其传递给pr的标准输入。pr将文本整齐地分页，并将其输出到标准输出，然后通过管道将其传递给lpr的标准输入。lpr接受标准输入并将其发送到打印机。

   The second example starts with an unsorted list of data with duplicate entries. First, cat sends the list into sort which sorts it and feeds it into uniq which removes any duplicates. Next pr and lpr are used to paginate and print the list.

   第二个示例以一个包含重复条目的未排序数据列表开始。首先，cat将列表发送到sort，sort对其进行排序并将其传递给uniq，uniq删除任何重复项。然后使用pr和lpr进行分页和打印列表。

3. Viewing the contents of tar files Often you will see software distributed as a gzipped tar file. This is a traditional Unix style tape archive file (created with tar) that has been compressed with gzip. You can recognize these files by their traditional file extensions, “.tar.gz” or “.tgz”. You can use the following command to view the directory of such a file on a Linux system:

4. 查看tar文件的内容 经常会看到软件以gzipped tar文件的形式分发。这是一个传统的Unix风格的磁带归档文件（使用tar创建），经过gzip压缩。你可以通过文件的传统扩展名”.tar.gz"或".tgz"来识别这些文件。你可以使用以下命令在Linux系统上查看此类文件的目录：

   1	tar tzvf name_of_file.tar.gz | less

进一步阅读 Further Reading

• Chapter 6 of The Linux Command Line covers this topic in more detail.
• The Linux Command Line的第6章更详细地介绍了这个主题。
• Chapters 19 through 21 of The Linux Command Line provide an in-depth look at the text processing tools available in Linux.
• 《The Linux Command Line》的第19至21章深入介绍了Linux中可用的文本处理工具。
• To learn more about the AWK programming language, consider the AWK adventure.
• 如果想更多了解AWK编程语言，请参考AWK adventure。

2.8 - 扩展

扩展 Expansion

https://linuxcommand.org/lc3_lts0080.php

Each time we type a command line and press the enter key, bash performs several processes upon the text before it carries out our command. We have seen a couple of cases of how a simple character sequence, for example “*”, can have a lot of meaning to the shell. The process that makes this happen is called expansion. With expansion, we type something and it is expanded into something else before the shell acts upon it. To demonstrate what we mean by this, let’s take a look at the echo command. echo is a shell builtin that performs a very simple task. It prints out its text arguments on standard output:

​ 每次我们在命令行中输入命令并按下回车键时，bash在执行我们的命令之前会对文本进行几个处理过程。我们已经看到了一些简单字符序列（例如"*"）对于shell来说具有很多意义的情况。使这种情况发生的过程被称为扩展。通过扩展，我们在键入某些内容时，shell会在对其执行操作之前将其扩展为其他内容。为了演示我们所说的，让我们来看一下echo命令。echo是一个shell内置命令，执行一个非常简单的任务，即在标准输出上打印出其文本参数：

1
2

[me@linuxbox me]$ echo this is a test
this is a test

That’s pretty straightforward. Any argument passed to echo gets displayed. Let’s try another example:

​ 这很简单明了。任何传递给echo的参数都会被显示出来。让我们尝试另一个示例：

1
2

[me@linuxbox me]$ echo *
Desktop Documents ls-output.txt Music Pictures Public Templates Videos

So what just happened? Why didn’t echo print “*”? As we recall from our work with wildcards, the “*“character means match any characters in a filename, but what we didn’t see in our original discussion was how the shell does that. The simple answer is that the shell expands the “*” into something else (in this instance, the names of the files in the current working directory) before the echo command is executed. When the enter key is pressed, the shell automatically expands any qualifying characters on the command line before the command is carried out, so the echo command never saw the “*”, only its expanded result. Knowing this, we can see that echo behaved as expected.

​ 发生了什么？为什么echo没有打印出”*"？从我们之前使用通配符的工作中，我们记得”*“字符表示匹配文件名中的任意字符，但是我们在原始讨论中没有看到shell是如何实现的。简单的答案是，shell在执行echo命令之前将”*“扩展为其他内容（在这种情况下是当前工作目录中文件的名称）。当按下回车键时，shell会自动在执行命令之前展开命令行上的任何限定字符，因此echo命令从未看到”*"，只看到其扩展后的结果。了解这一点，我们可以看到echo的行为符合预期。

路径名扩展 Pathname Expansion

The mechanism by which wildcards work is called pathname expansion. If we try some of the techniques that we employed in our earlier lessons, we will see that they are really expansions. Given a home directory that looks like this:

​ 通配符起作用的机制被称为路径名扩展。如果我们尝试一些我们之前在课程中使用的技术，我们会发现它们实际上是扩展。给定一个如下所示的主目录：

1
2
3
4
5
6
7
8

[me@linuxbox me]$ ls
Desktop
ls-output.txt
Documents Music
Pictures
Public
Templates
Videos

we could carry out the following expansions:

​ 我们可以进行以下扩展：

1
2

[me@linuxbox me]$ echo D*
Desktop Documents

and:

以及：

1
2

[me@linuxbox me]$ echo *s
Documents Pictures Templates Videos

or even:

甚至是：

1
2

[me@linuxbox me]$ echo [[:upper:]]*
Desktop Documents Music Pictures Public Templates Videos

and looking beyond our home directory:

并且可以查看超出主目录的内容：

1
2

[me@linuxbox me]$ echo /usr/*/share
/usr/kerberos/share /usr/local/share

波浪号扩展 Tilde Expansion

As we recall from our introduction to the cd command, the tilde character ("~") has a special meaning. When used at the beginning of a word, it expands into the name of the home directory of the named user, or if no user is named, the home directory of the current user:

​ 正如我们在介绍cd命令时所记得的，波浪号（"~"）具有特殊的含义。当在单词的开头使用时，它会扩展为命名用户的主目录，如果没有指定用户，则扩展为当前用户的主目录：

1
2

[me@linuxbox me]$ echo ~
/home/me

If user “foo” has an account, then:

​ 如果用户"foo"有一个帐户，则：

1
2

[me@linuxbox me]$ echo ~foo
/home/foo

算术扩展 Arithmetic Expansion

The shell allows arithmetic to be performed by expansion. This allow us to use the shell prompt as a calculator:

​ Shell允许通过扩展执行算术运算。这使我们可以将Shell提示符用作计算器：

1
2

[me@linuxbox me]$ echo $((2 + 2))
4

Arithmetic expansion uses the form:

​ 算术扩展使用以下形式：

1

$((expression))

where expression is an arithmetic expression consisting of values and arithmetic operators.

其中，表达式是由值和算术运算符组成的算术表达式。

Arithmetic expansion only supports integers (whole numbers, no decimals), but can perform quite a number of different operations.

​ 算术扩展仅支持整数（无小数），但可以执行许多不同的操作。

Spaces are not significant in arithmetic expressions and expressions may be nested. For example, to multiply five squared by three:

​ 在算术表达式中，空格不重要，表达式可以嵌套。例如，要将五的平方乘以三：

1
2

[me@linuxbox me]$ echo $(($((5**2)) * 3))
75

Single parentheses may be used to group multiple subexpressions. With this technique, we can rewrite the example above and get the same result using a single expansion instead of two:

​ 可以使用单括号来分组多个子表达式。使用这种技术，我们可以重写上面的例子，并使用单个扩展而不是两个来获得相同的结果：

1
2

[me@linuxbox me]$ echo $(((5**2) * 3))
75

Here is an example using the division and remainder operators. Notice the effect of integer division:

​ 下面是一个使用除法和取余运算符的示例。注意整数除法的效果：

1
2
3
4

[me@linuxbox me]$ echo Five divided by two equals $((5/2))
Five divided by two equals 2
[me@linuxbox me]$ echo with $((5%2)) left over.
with 1 left over.

大括号扩展 Brace Expansion

Perhaps the strangest expansion is called brace expansion. With it, we can create multiple text strings from a pattern containing braces. Here’s an example:

​ 也许最奇怪的扩展被称为大括号扩展。使用它，我们可以从包含大括号的模式创建多个文本字符串。以下是一个示例：

1
2

[me@linuxbox me]$ echo Front-{A,B,C}-Back
Front-A-Back Front-B-Back Front-C-Back

Patterns to be brace expanded may contain a leading portion called a preamble and a trailing portion called a postscript. The brace expression itself may contain either a comma-separated list of strings, or a range of integers or single characters. The pattern may not contain embedded whitespace. Here is an example using a range of integers:

​ 要扩展的模式可以包含称为preamble的前导部分和称为postscript的尾随部分。大括号表达式本身可以包含逗号分隔的字符串列表，或者是整数或单个字符的范围。模式不得包含嵌入的空格。以下是使用整数范围的示例：

1
2

[me@linuxbox me]$ echo Number_{1..5}
Number_1 Number_2 Number_3 Number_4 Number_5

A range of letters in reverse order:

​ 以相反顺序的字母范围：

1
2

[me@linuxbox me]$ echo {Z..A}
Z Y X W V U T S R Q P O N M L K J I H G F E D C B A

Brace expansions may be nested:

​ 大括号扩展可以嵌套：

1
2

[me@linuxbox me]$ echo a{A{1,2},B{3,4}}b
aA1b aA2b aB3b aB4b

So what is this good for? The most common application is to make lists of files or directories to be created. For example, if we were a photographer and had a large collection of images we wanted to organize into years and months, the first thing we might do is create a series of directories named in numeric “Year-Month” format. This way, the directory names will sort in chronological order. we could type out a complete list of directories, but that’s a lot of work and it’s error-prone too. Instead, we could do this:

​ 那么这有什么好处？最常见的应用是创建要创建的文件或目录的列表。例如，如果我们是摄影师，有很多图像要按年份和月份组织，我们可能首先要做的是创建以数字"年份-月份"格式命名的一系列目录。这样，目录名称将按照时间顺序排序。我们可以输入完整的目录列表，但那是很麻烦的工作，而且容易出错。相反，我们可以这样做：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

[me@linuxbox me]$ mkdir Photos
[me@linuxbox me]$ cd Photos
[me@linuxbox Photos]$ mkdir {2017..2019}-{01..12}
[me@linuxbox Photos]$ ls
2017-01 2017-07 2018-01 2018-07 2019-01 2019-07
2017-02 2017-08 2018-02 2018-08 2019-02 2019-08
2017-03 2017-09 2018-03 2018-09 2019-03 2019-09
2017-04 2017-10 2018-04 2018-10 2019-04 2019-10
2017-05 2017-11 2018-05 2018-11 2019-05 2019-11
2017-06 2017-12 2018-06 2018-12 2019-06 2019-12

Pretty slick!

​ 很漂亮！

参数扩展 Parameter Expansion

We’re only going to touch briefly on parameter expansion in this lesson, but we’ll be covering it more later. It’s a feature that is more useful in shell scripts than directly on the command line. Many of its capabilities have to do with the system’s ability to store small chunks of data and to give each chunk a name. Many such chunks, more properly called variables, are available for our examination. For example, the variable named “USER” contains our user name. To invoke parameter expansion and reveal the contents of USER we would do this:

​ 在本课程中，我们只会简要涉及参数扩展，但我们将在后面对其进行更详细的介绍。这是一个在Shell脚本中比在命令行直接使用更有用的功能。它的许多功能与系统存储小数据块和为每个块命名有关。我们可以检查许多这样的块，更准确地称为变量。例如，名为"USER"的变量包含我们的用户名。要调用参数扩展并显示USER的内容，我们可以这样做：

1
2

[me@linuxbox me]$ echo $USER
me

To see a list of available variables, try this:

​ 要查看可用变量的列表，请尝试以下命令：

1

[me@linuxbox me]$ printenv | less

With other types of expansion, if we mistype a pattern, the expansion will not take place and the echo command will simply display the mistyped pattern. With parameter expansion, if we misspell the name of a variable, the expansion will still take place, but will result in an empty string:

​ 与其他类型的扩展不同，如果我们拼写错误的模式，扩展将不会发生，echo命令将只显示错误拼写的模式。但是，对于参数扩展，如果我们拼写变量名称错误，扩展仍将发生，但结果将为空字符串：

1
2

[me@linuxbox me]$ echo $SUER
[me@linuxbox ~]$

命令替换 Command Substitution

Command substitution allows us to use the output of a command as an expansion:

​ 命令替换 允许我们将命令的输出作为扩展使用：

1
2

[me@linuxbox me]$ echo $(ls)
Desktop Documents ls-output.txt Music Pictures Public Templates Videos

A clever one goes something like this:

​ 一个巧妙的例子如下：

1
2

[me@linuxbox me]$ ls -l $(which cp)
-rwxr-xr-x 1 root root 71516 2007-12-05 08:58 /bin/cp

Here we passed the results of which cp as an argument to the ls command, thereby getting the listing of of the cp program without having to know its full pathname. We are not limited to just simple commands. Entire pipelines can be used (only partial output shown):

​ 在这里，我们将 which cp 的结果作为 ls 命令的参数传递，从而获取 cp 程序的列表，而无需知道其完整路径名。我们不仅仅限于简单的命令，还可以使用整个流水线（仅显示部分输出）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

[me@linuxbox me]$ file $(ls /usr/bin/* | grep bin/zip)
/usr/bin/bunzip2:
/usr/bin/zip:      ELF 32-bit LSB executable, Intel 80386, version 1 
(SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.15, stripped
/usr/bin/zipcloak: ELF 32-bit LSB executable, Intel 80386, version 1
(SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.15, stripped
/usr/bin/zipgrep:  POSIX shell script text executable
/usr/bin/zipinfo:  ELF 32-bit LSB executable, Intel 80386, version 1
(SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.15, stripped
/usr/bin/zipnote:  ELF 32-bit LSB executable, Intel 80386, version 1
(SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.15, stripped
/usr/bin/zipsplit: ELF 32-bit LSB executable, Intel 80386, version 1
(SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.15, stripped

In this example, the results of the pipeline became the argument list of the file command. There is an alternate syntax for command substitution in older shell programs which is also supported in bash. It uses back-quotes instead of the dollar sign and parentheses:

​ 在此示例中，流水线的结果成为 file 命令的参数列表。在旧的 shell 程序中，还有一种替代的命令替换语法，也在 bash 中支持。它使用反引号而不是美元符号和括号：

1
2

[me@linuxbox me]$ ls -l `which cp`
-rwxr-xr-x 1 root root 71516 2007-12-05 08:58 /bin/cp

引号 Quoting

Now that we’ve seen how many ways the shell can perform expansions, it’s time to learn how we can control it. Take for example:

​ 现在我们已经了解了 shell 执行扩展的多种方式，是时候学习如何控制它了。例如：

1
2

[me@linuxbox me]$ echo this is a     test
this is a test

or:

或者：

1
2

[me@linuxbox me]$ [me@linuxbox ~]$ echo The total is $100.00
The total is 00.00

In the first example, word-splitting by the shell removed extra whitespace from the echo command’s list of arguments. In the second example, parameter expansion substituted an empty string for the value of “$1” because it was an undefined variable. The shell provides a mechanism called quoting to selectively suppress unwanted expansions.

​ 在第一个示例中，Shell 的词分割功能删除了 echo 命令参数列表中的额外空格。在第二个示例中，参数扩展将一个空字符串替换为"$1“的值，因为它是一个未定义的变量。Shell 提供了一种称为引号的机制，可以选择性地抑制不需要的扩展。

双引号 Double Quotes

The first type of quoting we will look at is double quotes. If we place text inside double quotes, all the special characters used by the shell lose their special meaning and are treated as ordinary characters. The exceptions are “$”, “\” (backslash), and “`” (back- quote). This means that word-splitting, pathname expansion, tilde expansion, and brace expansion are suppressed, but parameter expansion, arithmetic expansion, and command substitution are still carried out. Using double quotes, we can cope with filenames containing embedded spaces. Imagine we were the unfortunate victim of a file called two words.txt. If we tried to use this on the command line, word-splitting would cause this to be treated as two separate arguments rather than the desired single argument:

​ 我们将首先看一下的引号类型是双引号。如果我们将文本放在双引号内，Shell 中使用的所有特殊字符都失去了它们的特殊含义，被视为普通字符。例外的是 “$"、"\"（反斜杠）和 “`"（反引号）。这意味着词分割、路径名扩展、波浪线扩展和大括号扩展被抑制，但参数扩展、算术扩展和命令替换仍然会进行。使用双引号，我们可以处理包含空格的文件名。假设我们是一个不幸的two words.txt文件的受害者。如果我们尝试在命令行上使用它，词分割将使其被视为两个独立的参数，而不是所需的单个参数：

1
2
3

[me@linuxbox me]$ ls -l two words.txt
ls: cannot access two: No such file or directory
ls: cannot access words.txt: No such file or directory

By using double quotes, we can stop the word-splitting and get the desired result; further, we can even repair the damage:

​ 通过使用双引号，我们可以阻止词分割并获得所需的结果；此外，我们甚至可以修复损坏：

1
2
3

[me@linuxbox me]$ ls -l "two words.txt"
-rw-rw-r-- 1 me me 18 2020-02-20 13:03 two words.txt
[me@linuxbox me]$ mv "two words.txt" two_words.txt

There! Now we don’t have to keep typing those pesky double quotes. Remember, parameter expansion, arithmetic expansion, and command substitution still take place within double quotes:

​ 现在！我们不再需要不断输入那些烦人的双引号。请记住，参数扩展、算术扩展和命令替换仍然会在双引号内进行：

1
2
3
4
5
6
7
8
9

[me@linuxbox me]$ echo "$USER $((2+2)) $(cal)"
me 4
February 2020
Su Mo Tu We Th Fr Sa
                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

We should take a moment to look at the effect of double quotes on command substitution. First let’s look a little deeper at how word splitting works. In our earlier example, we saw how word-splitting appears to remove extra spaces in our text:

​ 我们应该花点时间来看一下双引号对命令替换的影响。首先，让我们更深入地了解词分割是如何工作的。在我们之前的示例中，我们看到词分割似乎删除了文本中的额外空格：

1
2

[me@linuxbox me]$ echo this is a     test
this is a test

By default, word-splitting looks for the presence of spaces, tabs, and newlines (linefeed characters) and treats them as delimiters between words. This means that unquoted spaces, tabs, and newlines are not considered to be part of the text. They only serve as separators. Since they separate the words into different arguments, our example command line contains a command followed by four distinct arguments. If we add double quotes:

​ 默认情况下，词分割会查找空格、制表符和换行符（换行字符），并将它们视为单词之间的分隔符。这意味着未加引号的空格、制表符和换行符不被视为文本的一部分。它们只是分隔符。由于它们将单词分隔为不同的参数，我们的示例命令行包含一个命令和四个不同的参数。如果我们添加双引号：

1
2

[me@linuxbox me]$ echo "this is a     test"
this is a     test

word-splitting is suppressed and the embedded spaces are not treated as delimiters, rather they become part of the argument. Once the double quotes are added, our command line contains a command followed by a single argument. The fact that newlines are considered delimiters by the word-splitting mechanism causes an interesting, albeit subtle, effect on command substitution. Consider the following:

​ 词分割被抑制，嵌入的空格不再被视为分隔符，而是成为参数的一部分。一旦添加了双引号，我们的命令行包含一个命令和一个单独的参数。换行符被词分割机制视为分隔符，对命令替换产生了一个有趣但微妙的影响。考虑以下示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

[me@linuxbox me]$ echo $(cal)
February 2020 Su Mo Tu We Th Fr Sa 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
[me@linuxbox me]$  echo "$(cal)"
February 2020
Su Mo Tu We Th Fr Sa
                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

In the first instance, the unquoted command substitution resulted in a command line containing thirty-eight arguments. In the second, a command line with one argument that includes the embedded spaces and newlines.

​ 在第一个示例中，未加引号的命令替换导致一个包含三十八个参数的命令行。在第二个示例中，命令行只有一个参数，其中包含嵌入的空格和换行符。

单引号 Single Quotes

When we need to suppress all expansions, we use single quotes. Here is a comparison of unquoted, double quotes, and single quotes:

​ 当我们需要抑制所有扩展时，我们使用单引号。以下是未加引号、双引号和单引号的比较：

1
2
3
4
5
6

[me@linuxbox me]$ echo text ~/*.txt {a,b} $(echo foo) $((2+2)) $USER
text /home/me/ls-output.txt a b foo 4 me
[me@linuxbox me]$ echo "text ~/*.txt {a,b} $(echo foo) $((2+2)) $USER"
text ~/*.txt {a,b} foo 4 me
[me@linuxbox me]$ echo 'text ~/*.txt {a,b} $(echo foo) $((2+2)) $USER'
text ~/*.txt {a,b} $(echo foo) $((2+2)) $USER

As we can see, with each succeeding level of quoting, more and more of the expansions are suppressed.

​ 正如我们所看到的，随着引号层次的增加，越来越多的扩展被抑制。

转义字符 Escaping Characters

Sometimes we only want to quote a single character. To do this, we can precede a character with a backslash, which in this context is called the escape character. Often this is done inside double quotes to selectively prevent an expansion:

​ 有时我们只想引用一个单个字符。为此，我们可以在字符前加上反斜杠，这在这个上下文中称为转义字符。通常，这是在双引号内部选择性地阻止扩展的方法：

1
2

[me@linuxbox me]$ echo "The balance for user $USER is: \$5.00"
The balance for user me is: $5.00

It is also common to use escaping to eliminate the special meaning of a character in a filename. For example, it is possible to use characters in filenames that normally have special meaning to the shell. These would include “$”, “!”, “&”, " “, and others. To include a special character in a filename we can to this:

​ 在文件名中，使用转义通常是为了消除字符的特殊含义。例如，可以在文件名中使用通常对shell具有特殊含义的字符，包括”$"、"!"、"&"、” “和其他字符。要在文件名中包含特殊字符，我们可以这样做：

1

[me@linuxbox me]$ mv bad\&filename good_filename

To allow a backslash character to appear, escape it by typing “\”. Note that within single quotes, the backslash loses its special meaning and is treated as an ordinary character.

​ 要允许反斜杠字符出现，通过键入”\“来转义它。请注意，在单引号内部，反斜杠失去了其特殊含义，被视为普通字符。

更多反斜杠技巧 More Backslash Tricks

If we look at the man pages for any program written by the GNU project, we will see that in addition to command line options consisting of a dash and a single letter, there are also long option names that begin with two dashes. For example, the following are equivalent:

​ 如果我们查看由GNU项目编写的任何程序的man页，我们会看到除了由破折号和单个字母组成的命令行选项外，还有以两个破折号开头的长选项名。例如，下面两者是等价的：

1
2

ls -r
ls --reverse

Why do they support both? The short form is for lazy typists on the command line and the long form is mostly for scripts though some options may only be available in long form. Sometimes it is better to use a long option when the option is obscure or we want to document more clearly what an option is. This is especially useful when writing scripts where maximum readability is desired, and besides, anytime we can save ourselves a trip to the man page is a good thing.

​ 为什么它们都被支持？短格式适用于命令行上的懒惰打字者，而长格式主要用于脚本，尽管某些选项可能仅在长格式中可用。当选项晦涩难懂或者我们想更清楚地记录选项是什么时，使用长选项可能更好。这在编写希望最大可读性的脚本时特别有用，而且，任何时候我们能够节省一次访问man页都是一件好事。

As we might suspect, using the long form options can make a single command line very long. To combat this problem, we can use a backslash to get the shell to ignore a newline character like this:

​ 正如我们所猜测的，使用长格式选项可能会使单个命令行非常长。为了解决这个问题，我们可以使用反斜杠来使shell忽略换行符，像这样：

1
2
3
4

ls -l \
   --reverse \
   --human-readable \
   --full-time

Using the backslash in this way allows us to embed newlines in our command. Note that for this trick to work, the newline must be typed immediately after the backslash. If we put a space after the backslash, the space will be ignored, not the newline. Backslashes are also used to insert special characters into our text. These are called backslash escape characters. Here are the common ones:

​ 以这种方式使用反斜杠可以在命令中插入换行符。请注意，为使此技巧生效，换行符必须紧跟在反斜杠后面输入。如果在反斜杠后面加上空格，则空格将被忽略，而不是换行符。反斜杠还用于在文本中插入特殊字符。这些特殊字符称为反斜杠转义字符。以下是常见的转义字符：

The use of the backslash escape characters is very common. This idea first appeared in the C programming language. Today, the shell, C++, Perl, python, awk, tcl, and many other programming languages use this concept. Using the echo command with the -e option will allow us to demonstrate:

​ 使用反斜杠转义字符非常常见。这个概念最初出现在C编程语言中。如今，Shell、C++、Perl、Python、Awk、Tcl和许多其他编程语言都使用了这个概念。使用带有-e选项的echo命令可以让我们进行演示：

1
2
3
4
5
6
7
8
9

[me@linuxbox me]$ echo -e "Inserting several blank lines\n\n\n"
Inserting several blank lines

[me@linuxbox me]$ echo -e "Words\tseparated\tby\thorizontal\ttabs."
Words separated   by  horizontal  tabs
[me@linuxbox me]$ echo -e "\aMy computer went \"beep\"."
My computer went "beep".
[me@linuxbox me]$ echo -e "DEL C:\\WIN2K\\LEGACY_OS.EXE"
DEL C:\WIN2K\LEGACY_OS.EXE

2.9 - 权限

权限 Permissions

https://linuxcommand.org/lc3_lts0090.php

The Unix-like operating systems, such as Linux differ from other computing systems in that they are not only multitasking but also multi-user.

​ 类Unix操作系统（如Linux）与其他计算系统的不同之处在于它们不仅支持多任务，还支持多用户。

What exactly does this mean? It means that more than one user can be operating the computer at the same time. While a desktop or laptop computer only has one keyboard and monitor, it can still be used by more than one user. For example, if the computer is attached to a network, or the Internet, remote users can log in via ssh (secure shell) and operate the computer. In fact, remote users can execute graphical applications and have the output displayed on a remote computer. The X Window system supports this.

​ 这到底意味着什么呢？这意味着多个用户可以同时操作计算机。虽然桌面或笔记本电脑只有一个键盘和显示器，但它仍然可以被多个用户使用。例如，如果计算机连接到网络或互联网，远程用户可以通过ssh（安全外壳）登录并操作计算机。实际上，远程用户可以执行图形应用程序，并在远程计算机上显示输出。X Window系统支持此功能。

The multi-user capability of Unix-like systems is a feature that is deeply ingrained into the design of the operating system. If we remember the environment in which Unix was created, this makes perfect sense. Years ago before computers were “personal,” they were large, expensive, and centralized. A typical university computer system consisted of a large mainframe computer located in some building on campus and terminals were located throughout the campus, each connected to the large central computer. The computer would support many users at the same time.

​ 类Unix系统的多用户能力是操作系统设计中根深蒂固的特性。如果我们记得Unix创建的环境，这是完全合理的。多年前，在计算机成为“个人电脑”之前，它们是庞大、昂贵和集中化的。典型的大学计算机系统由位于校园某个建筑物中的大型主机计算机组成，而终端则分布在整个校园，每个终端连接到大型中央计算机。计算机可以同时支持多个用户。

In order to make this practical, a method had to be devised to protect the users from each other. After all, we wouldn’t want the actions of one user to crash the computer, nor would we allow one user to interfere with the files belonging to another user.

​ 为了使这种情况变得实际可行，必须设计一种方法来保护用户免受彼此的干扰。毕竟，我们不希望一个用户的操作导致计算机崩溃，也不希望一个用户干扰其他用户的文件。

This lesson will cover the following commands:

​ 本课程将涵盖以下命令：

• chmod - modify file access rights
• su - temporarily become the superuser
• sudo - temporarily become the superuser
• chown - change file ownership
• chgrp - change a file’s group ownership
• chmod - 修改文件访问权限
• su - 临时成为超级用户
• sudo - 临时成为超级用户
• chown - 更改文件所有者
• chgrp - 更改文件所属组

文件权限 File Permissions

On a Linux system, each file and directory is assigned access rights for the owner of the file, the members of a group of related users, and everybody else. Rights can be assigned to read a file, to write a file, and to execute a file (i.e., run the file as a program).

​ 在Linux系统上，每个文件和目录都分配了对文件所有者、相关用户组的成员以及其他所有人的访问权限。可以分配的权限包括读取文件、写入文件和执行文件（即将文件作为程序运行）。

To see the permission settings for a file, we can use the ls command. As an example, we will look at the bash program which is located in the /bin directory:

​ 要查看文件的权限设置，可以使用ls命令。例如，我们将查看位于/bin目录中的bash程序：

1
2

[me@linuxbox me]$ ls -l /bin/bash
-rwxr-xr-x 1 root root 1113504 Jun  6  2019 /bin/bash

Here we can see:

​ 在这里我们可以看到：

• The file “/bin/bash” is owned by user “root”
• The superuser has the right to read, write, and execute this file
• The file is owned by the group “root”
• Members of the group “root” can also read and execute this file
• Everybody else can read and execute this file
• 文件“/bin/bash”归属于用户“root”
• 超级用户具有读取、写入和执行此文件的权限
• 文件归属于组“root”
• 组“root”的成员也可以读取和执行此文件
• 其他所有人可以读取和执行此文件

In the diagram below, we see how the first portion of the listing is interpreted. It consists of a character indicating the file type, followed by three sets of three characters that convey the reading, writing and execution permission for the owner, group, and everybody else.

​ 在下面的图表中，我们可以看到如何解释列表的第一部分。它由一个表示文件类型的字符组成，后面跟着三组三个字符，分别表示所有者、组和其他所有人的读取、写入和执行权限。

chmod

The chmod command is used to change the permissions of a file or directory. To use it, we specify the desired permission settings and the file or files that we wish to modify. There are two ways to specify the permissions. In this lesson we will focus on one of these, called the octal notation method.

​ chmod命令用于更改文件或目录的权限。要使用它，我们指定所需的权限设置以及要修改的文件或文件夹。有两种方法可以指定权限。在本课程中，我们将重点介绍其中之一，称为八进制表示法方法。

It is easy to think of the permission settings as a series of bits (which is how the computer thinks about them). Here’s how it works:

​ 将权限设置视为一系列位（计算机对其的思考方式）是很容易的。它的工作原理如下：

rwx rwx rwx = 111 111 111
rw- rw- rw- = 110 110 110
rwx --- --- = 111 000 000

and so on...

rwx = 111 in binary = 7
rw- = 110 in binary = 6
r-x = 101 in binary = 5
r-- = 100 in binary = 4

Now, if we represent each of the three sets of permissions (owner, group, and other) as a single digit, we have a pretty convenient way of expressing the possible permissions settings. For example, if we wanted to set some_file to have read and write permission for the owner, but wanted to keep the file private from others, we would:

​ 现在，如果我们将每组权限（所有者、组和其他所有人）表示为一个数字，我们就有了一种非常方便的表达可能的权限设置的方法。例如，如果我们希望将some_file的所有者权限设置为读取和写入，但希望将文件保密不让其他人看到，我们可以执行以下命令：

1

[me@linuxbox me]$ chmod 600 some_file

Here is a table of numbers that covers all the common settings. The ones beginning with “7” are used with programs (since they enable execution) and the rest are for other kinds of files.

​ 下表列出了涵盖所有常见设置的数字。以“7”开头的数字用于程序（因为它们允许执行），其余数字用于其他类型的文件。

目录权限 Directory Permissions

The chmod command can also be used to control the access permissions for directories. Again, we can use the octal notation to set permissions, but the meaning of the r, w, and x attributes is different:

​ chmod命令也可以用于控制目录的访问权限。同样，我们可以使用八进制表示法来设置权限，但是r、w和x属性的含义有所不同：

• r - Allows the contents of the directory to be listed if the x attribute is also set.
• w - Allows files within the directory to be created, deleted, or renamed if the x attribute is also set.
• x - Allows a directory to be entered (i.e. cd dir).
• r - 如果也设置了x属性，则允许列出目录的内容。
• w - 如果也设置了x属性，则允许在目录中创建、删除或重命名文件。
• x - 允许进入目录（即cd dir）。

Here are some useful settings for directories:

​ 以下是一些有用的目录设置：

暂时成为超级用户 Becoming the Superuser for a Short While

It is often necessary to become the superuser to perform important system administration tasks, but as we know, we should not stay logged in as the superuser. In most distributions, there is a program that can give you temporary access to the superuser’s privileges. This program is called su (short for substitute user) and can be used in those cases when you need to be the superuser for a small number of tasks. To become the superuser, simply type the su command. You will be prompted for the superuser’s password:

​ 经常需要成为超级用户执行重要的系统管理任务，但我们知道，不应该作为超级用户保持登录状态。在大多数发行版中，有一个程序可以让您暂时获得超级用户权限。该程序称为su（替代用户的简称），可以在需要成为超级用户执行一小部分任务的情况下使用。要成为超级用户，只需输入su命令。您将被要求输入超级用户的密码：

1
2
3

[me@linuxbox me]$ su
Password:
[root@linuxbox me]#

After executing the su command, we have a new shell session as the superuser. To exit the superuser session, type exit and we will return to your previous session.

​ 执行su命令后，我们将获得一个新的超级用户shell会话。要退出超级用户会话，输入exit，然后将返回到以前的会话。

In most modern distributions, an alternate method is used. Rather than using su, these systems employ the sudo command instead. With sudo, one or more users are granted superuser privileges on an as needed basis. To execute a command as the superuser, the desired command is simply preceded with the sudo command. After the command is entered, the user is prompted for the their own password rather than the superuser’s:

​ 在大多数现代发行版中，使用了另一种方法。这些系统使用sudo命令而不是su。使用sudo，一个或多个用户被授予根据需要的超级用户权限。要以超级用户身份执行命令，只需在所需的命令之前加上sudo命令。输入命令后，用户将被要求输入自己的密码，而不是超级用户的密码：

1
2
3

[me@linuxbox me]$ sudo some_command
Password for me:
[me@linuxbox me]$

In fact, modern distributions don’t even set the root account password thus making it impossible to log in as the root user. A root shell is still possible with sudo by using the “-i” option:

​ 实际上，现代发行版甚至不设置root帐户密码，因此无法作为root用户登录。通过使用"-i"选项，仍然可以使用sudo命令获得完全的root shell：

1
2
3

[me@linuxbox me]$ sudo -i
Password for me:
root@linuxbox:~#

更改文件所有者 Changing File Ownership

We can change the owner of a file by using the chown command. Here’s an example: Suppose we wanted to change the owner of some_file from “me” to “you”. We could:

​ 我们可以使用chown命令来更改文件的所有者。下面是一个例子：假设我们想将some_file的所有者从"me"改为"you"，我们可以执行以下命令：

1

[me@linuxbox me]$ sudo chown you some_file

Notice that in order to change the owner of a file, we must have superuser privileges. To do this, our example employed the sudo command to execute chown.

​ 请注意，为了更改文件的所有者，我们必须具有超级用户权限。在这个例子中，我们使用sudo命令来执行chown命令。

chown works the same way on directories as it does on files.

​ chown命令对目录的操作方式与对文件的操作方式相同。

更改所属组 Changing Group Ownership

The group ownership of a file or directory may be changed with chgrp. This command is used like this:

​ 可以使用chgrp命令来更改文件或目录的所属组。命令的使用方法如下：

1

[me@linuxbox me]$ chgrp new_group some_file

In the example above, we changed the group ownership of some_file from its previous group to “new_group”. We must be the owner of the file or directory to perform a chgrp.

​ 在上面的示例中，我们将some_file的所属组从原来的组更改为"new_group"。执行chgrp命令时，我们必须是文件或目录的所有者。

进一步阅读 Further Reading

• Chapter 9 of The Linux Command Line covers this topic in much more detail.
• The Linux Command Line的第9章详细介绍了这个主题。

2.10 - 作业控制

作业控制 - Job Control

https://linuxcommand.org/lc3_lts0100.php

In the previous lesson, we looked at some of the implications of Linux being a multi-user operating system. In this lesson, we will examine the multitasking nature of Linux, and how it is controlled with the command line interface.

​ 在前面的课程中，我们了解了Linux作为多用户操作系统的一些含义。在本课程中，我们将探讨Linux的多任务性质，以及如何使用命令行界面来控制它。

As with any multitasking operating system, Linux executes multiple, simultaneous processes. Well, they appear simultaneous, anyway. Actually, a single processor core can only execute one process at a time but the Linux kernel manages to give each process its turn at the processor and each appears to be running at the same time.

​ 与任何多任务操作系统一样，Linux可以执行多个并发进程。虽然它们看起来是同时执行的，但实际上，单个处理器核心一次只能执行一个进程，但Linux内核设法让每个进程轮流使用处理器，每个进程看起来都在同时运行。

There are several commands that are used to control processes. They are:

​ 有几个命令用于控制进程。它们是：

• ps - list the processes running on the system
• kill - send a signal to one or more processes (usually to “kill” a process)
• jobs - an alternate way of listing your own processes
• bg - put a process in the background
• fg - put a process in the foreground
• ps - 列出系统上正在运行的进程
• kill - 向一个或多个进程发送信号（通常用于"终止"一个进程）
• jobs - 列出您自己的进程的另一种方法
• bg - 将一个进程放入后台运行
• fg - 将一个进程放到前台运行

一个实际的例子 A Practical Example

While it may seem that this subject is rather obscure, it can be very practical for the average user who mostly works with the graphical user interface. Though it might not be apparent, most (if not all) graphical programs can be launched from the command line. Here’s an example: there is a small program supplied with the X Window system called xload which displays a graph representing system load. We can execute this program by typing the following:

​ 虽然这个主题可能看起来相当晦涩，但对于大多数主要使用图形用户界面的普通用户来说，它可以非常实用。虽然可能不明显，但大多数（如果不是全部）图形程序都可以从命令行启动。这里有一个例子：X Window系统中提供了一个名为xload的小程序，它显示表示系统负载的图形。我们可以通过键入以下命令来执行此程序：

1

[me@linuxbox me]$ xload

Notice that the small xload window appears and begins to display the system load graph. On systems where xload is not available, try gedit instead. Notice also that our prompt did not reappear after the program launched. The shell is waiting for the program to finish before control returns. If we close the xload window, the xload program terminates and the prompt returns.

​ 请注意，会出现一个小的xload窗口，并开始显示系统负载图。在不可用xload的系统上，可以尝试使用gedit代替。还要注意，程序启动后我们的提示符没有重新出现。Shell在控制权返回之前等待程序完成。如果关闭xload窗口，xload程序将终止并返回提示符。

将程序放入后台 Putting a Program into the Background

Now, in order to make life a little easier, we are going to launch the xload program again, but this time we will put it in the background so that the prompt will return. To do this, we execute xload like this:

​ 现在，为了让生活变得更轻松，我们将再次启动xload程序，但这次我们将把它放在后台，以便提示符会返回。为此，我们执行以下命令来启动xload：

1
2
3

[me@linuxbox me]$ xload &
[1] 1223
[me@linuxbox me]$

In this case, the prompt returned because the process was put in the background.

​ 在这种情况下，提示符返回，因为进程被放入了后台。

Now imagine that we forgot to use the “&” symbol to put the program into the background. There is still hope. We can type Ctrl-z and the process will be suspended. We can verify this by seeing that the program’s window is frozen. The process still exists, but is idle. To resume the process in the background, type the bg command (short for background). Here is an example:

​ 现在想象一下，我们忘记使用"&“符号将程序放入后台。还有希望。我们可以输入Ctrl-z，该进程将被挂起。我们可以通过查看程序的窗口是否被冻结来验证这一点。该进程仍然存在，但是处于空闲状态。要在后台恢复该进程，请键入bg命令（缩写为background）。以下是一个例子：

1
2
3
4
5

[me@linuxbox me]$ xload
[2]+ Stopped xload

[me@linuxbox me]$ bg
[2]+ xload &

列出正在运行的进程 Listing Running Processes

Now that we have a process in the background, it would be helpful to display a list of the processes we have launched. To do this, we can use either the jobs command or the more powerful ps command.

​ 现在，我们有一个后台进程，显示正在运行的进程列表将会很有帮助。为此，我们可以使用jobs命令或更强大的ps命令。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

[me@linuxbox me]$ jobs
[1]+ Running xload&

[me@linuxbox me]$ ps
PID  TTY   TIME     CMD
1211 pts/4 00:00:00 bash
1246 pts/4 00:00:00 xload
1247 pts/4 00:00:00 ps

[me@linuxbox me]$

终止进程 Killing a Process

Suppose that we have a program that becomes unresponsive; how do we get rid of it? We use the kill command, of course. Let’s try this out on xload. First, we need to identify the process we want to kill. We can use either jobs or ps, to do this. If we use jobs we will get back a job number. With ps, we are given a process id (PID). We will do it both ways:

​ 假设我们有一个程序变得无响应，我们该如何摆脱它呢？我们当然可以使用kill命令。让我们在xload上试一试。首先，我们需要确定要终止的进程。我们可以使用jobs或ps来完成。如果我们使用jobs，我们将得到一个作业号。使用ps，我们会得到一个进程ID（PID）。我们将两种方式都演示一下：

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

[me@linuxbox me]$ xload &
[1] 1292

[me@linuxbox me]$ jobs
[1]+ Running xload&

[me@linuxbox me]$ kill %1

[me@linuxbox me]$ xload &
[2] 1293
[1] Terminated xload

[me@linuxbox me]$ ps
PID  TTY   TIME     CMD
1280 pts/5 00:00:00 bash
1293 pts/5 00:00:00 xload
1294 pts/5 00:00:00 ps

[me@linuxbox me]$ kill 1293
[2]+ Terminated xload

[me@linuxbox me]$

关于kill的更多信息 A Little More About kill

While the kill command is used to “kill” processes, its real purpose is to send signals to processes. Most of the time the signal is intended to tell the process to go away, but there is more to it than that. Programs (if they are properly written) listen for signals from the operating system and respond to them, most often to allow some graceful method of terminating. For example, a text editor might listen for any signal that indicates that the user is logging off, or that the computer is shutting down. When it receives this signal, it could save the work in progress before it exits. The kill command can send a variety of signals to processes. Typing:

​ 尽管kill命令用于"终止"进程，但它的真正目的是向进程们发送信号。大多数时候，这个信号是告诉进程离开，但其中还有更多内容。程序（如果它们编写正确）会监听来自操作系统的信号并对其作出响应，通常是为了允许一些优雅的终止方法。例如，文本编辑器可能会监听任何指示用户注销或计算机关闭的信号。当它收到这个信号时，它可以在退出之前保存正在进行的工作。kill命令可以向进程们发送各种信号。键入：

1

kill -l

will print a list of the signals it supports. Many are rather obscure, but several are handy to know:

​ 将打印出它支持的信号列表。其中许多信号相当晦涩，但有几个很方便：

Now let’s suppose that we have a program that is hopelessly hung and we want to get rid of it. Here’s what we do:

​ 现在假设我们有一个无望地挂起的程序，我们想摆脱它。下面是我们的做法：

1. Use the ps command to get the process id (PID) of the process we want to terminate.
2. 使用ps命令获取我们要终止的进程的进程ID（PID）。
3. Issue a kill command for that PID.
4. 发出针对该PID的kill命令。
5. If the process refuses to terminate (i.e., it is ignoring the signal), send increasingly harsh signals until it does terminate.
6. 如果进程拒绝终止（即忽略了信号），则发送越来越严厉的信号，直到它终止为止。

1
2
3
4
5
6
7

[me@linuxbox me]$ ps x | grep bad_program
PID  TTY   STAT TIME COMMAND
2931 pts/5 SN   0:00 bad_program

[me@linuxbox me]$ kill -SIGTERM 2931

[me@linuxbox me]$ kill -SIGKILL 2931

In the example above we used the ps command with the x option to list all of our processes (even those not launched from the current terminal). In addition, we piped the output of the ps command into grep to list only list the program we are interested in. Next, we used kill to issue a SIGTERM signal to the troublesome program. In actual practice, it is more common to do it in the following way since the default signal sent by kill is SIGTERM and kill can also use the signal number instead of the signal name:

​ 上面的示例中，我们使用了带有x选项的ps命令列出了我们的所有进程（即使它们不是从当前终端启动的）。此外，我们将ps命令的输出导入到grep中，以仅列出我们感兴趣的程序。接下来，我们使用kill发出SIGTERM信号给有问题的程序。在实际操作中，更常见的做法是以以下方式进行，因为kill发送的默认信号是SIGTERM，kill还可以使用信号编号而不是信号名称：

1

[me@linuxbox me]$ kill 2931

Then, if the process does not terminate, force it with the SIGKILL signal:

​ 然后，如果进程不终止，可以使用SIGKILL信号强制终止：

1

[me@linuxbox me]$ kill -9 2931

到此为止！ That’s It!

This concludes the “Learning the Shell” series of lessons. In the next series, “Writing Shell Scripts,” we will look at how to automate tasks with the shell.

​ 这就结束了“学习Shell”的一系列课程。在下一系列“编写Shell脚本”中，我们将讨论如何使用Shell自动化任务。

进一步阅读 Further Reading

• For a more in-depth treatment of the topic, see Chapter 10 in The Linux Command Line.
• 要对该主题进行更深入的处理，请参阅The Linux Command Line一书中的第10章。
• 1963 Timesharing: A Solution to Computer Bottlenecks, a fascinating YouTube video from the Computer History Museum describing the first timesharing operating system and how it works. It’s basically the same method used by all modern computers.
• 1963年分时共享：解决计算机瓶颈问题，这是一段引人入胜的YouTube视频，来自计算机历史博物馆，介绍了第一个分时共享操作系统及其工作原理。它基本上是所有现代计算机使用的相同方法。

3 - 编写shell脚本

这里是乐趣开始的地方 Here is Where the Fun Begins

https://linuxcommand.org/lc3_writing_shell_scripts.php

With the thousands of commands available to the command line user, how can we remember them all? The answer is, we don’t. The real power of the computer is its ability to do the work for us. To get it to do that, we use the power of the shell to automate things. We write shell scripts.

​ 对于命令行用户来说，有成千上万个可用命令，我们如何记住它们呢？答案是，我们不需要记住它们全部。计算机的真正力量在于它能够替我们完成工作。为了实现这一点，我们利用 shell 的力量来自动化任务。我们编写shell 脚本。

什么是 Shell 脚本？ What are Shell Scripts?

In the simplest terms, a shell script is a file containing a series of commands. The shell reads this file and carries out the commands as though they have been entered directly on the command line.

​ 简而言之，shell 脚本是包含一系列命令的文件。Shell 会读取该文件，并像直接在命令行上输入这些命令一样执行它们。

The shell is somewhat unique, in that it is both a powerful command line interface to the system and a scripting language interpreter. As we will see, most of the things that can be done on the command line can be done in scripts, and most of the things that can be done in scripts can be done on the command line.

​ Shell 在某种程度上是独特的，它既是一个强大的系统命令行接口，又是一种脚本语言解释器。正如我们将看到的，大多数可以在命令行上完成的事情也可以在脚本中完成，而大多数可以在脚本中完成的事情也可以在命令行上完成。

We have already covered many shell features, but we have focused on those features most often used directly on the command line. The shell also provides a set of features usually (but not always) used when writing programs.

​ 我们已经介绍了许多 shell 特性，但我们侧重于那些在命令行上直接使用的特性。Shell 还提供了一套通常（但并不总是）在编写程序时使用的特性。

Scripts unlock the power of our Linux machine. So let’s have some fun!

​ 脚本释放了我们 Linux 机器的力量。所以让我们来玩一玩吧！

3.1 - 编写我们的第一个脚本并使其正常工作

编写我们的第一个脚本并使其正常工作 Writing Our First Script and Getting It to Work

https://linuxcommand.org/lc3_wss0010.php

To successfully write a shell script, we have to do three things:

​ 要成功编写一个 shell 脚本，我们需要完成三件事情：

1. Write a script
2. Give the shell permission to execute it
3. Put it somewhere the shell can find it
4. 编写一个脚本
5. 给 shell 赋予执行权限
6. 将脚本放在 shell 能够找到的地方

编写脚本 Writing a Script

A shell script is a file that contains ASCII text. To create a shell script, we use a text editor. A text editor is a program, like a word processor, that reads and writes ASCII text files. There are many, many text editors available for Linux systems, both for the command line and GUI environments. Here is a list of some common ones:

​ Shell 脚本是一个包含 ASCII 文本的文件。为了创建一个 shell 脚本，我们使用一个文本编辑器。文本编辑器是一个程序，类似于文字处理器，用于读写 ASCII 文本文件。对于 Linux 系统，有许多文本编辑器可供选择，包括命令行和图形界面环境。以下是一些常见的文本编辑器列表：

Let’s fire up our text editor and type in our first script as follows:

​ 让我们启动我们的文本编辑器，并按照以下方式输入我们的第一个脚本：

1
2
3
4
5

#!/bin/bash

# My first script

echo "Hello World!"

Clever readers will have figured out how to copy and paste the text into the text editor ;-)

​ 聪明的读者已经知道如何将文本复制并粘贴到文本编辑器中 ;-)

This is a traditional “Hello World” program. Forms of this program appear in almost every introductory programming book. We’ll save the file with some descriptive name. How about hello_world?

​ 这是一个传统的“Hello World”程序。这种程序的形式几乎出现在每本入门编程书籍中。我们将文件保存为一些描述性的名称。比如 hello_world？

The first line of the script is important. It is a special construct, called a shebang, given to the system indicating what program is to be used to interpret the script. In this case, /bin/bash. Other scripting languages such as Perl, awk, tcl, Tk, and python also use this mechanism.

​ 脚本的第一行很重要。它是一个特殊的结构，称为shebang，告诉系统要使用哪个程序来解释脚本。在本例中是 /bin/bash。其他脚本语言如 Perl, awk, tcl, Tk 和 python 也使用这种机制。

The second line is a comment. Everything that appears after a “#” symbol is ignored by bash. As our scripts become bigger and more complicated, comments become vital. They are used by programmers to explain what is going on so that others can figure it out. The last line is the echo command. This command simply prints its arguments on the display.

​ 第二行是一个注释。bash 会忽略 “#” 符号后面的所有内容。随着我们的脚本变得越来越大和复杂，注释变得至关重要。程序员使用注释来解释正在发生的事情，以便其他人可以理解。最后一行是 echo 命令。该命令简单地将其参数打印到显示器上。

设置权限 Setting Permissions

The next thing we have to do is give the shell permission to execute our script. This is done with the chmod command as follows:

​ 接下来，我们需要给 shell 赋予执行脚本的权限。可以使用 chmod 命令执行以下操作：

1

[me@linuxbox me]$ chmod 755 hello_world

The “755” will give us read, write, and execute permission. Everybody else will get only read and execute permission. To make the script private, (i.e., only we can read and execute), use “700” instead.

​ “755” 将赋予我们读取、写入和执行权限，其他用户只能获取读取和执行权限。如果要使脚本私有（即只有我们自己能读取和执行），可以使用 “700”。

将其放在路径中 Putting It in Our Path

At this point, our script will run. Try this:

​ 此时，我们的脚本将可以运行。尝试运行以下命令：

1

[me@linuxbox me]$ ./hello_world

We should see “Hello World!” displayed.

​ 我们应该会看到 “Hello World!” 显示出来。

Before we go any further, we need to talk about paths. When we type the name of a command, the system does not search the entire computer to find where the program is located. That would take a long time. We see that we don’t usually have to specify a complete path name to the program we want to run, the shell just seems to know.

​ 在继续之前，我们需要讨论一下路径。当我们键入一个命令的名称时，系统不会搜索整个计算机来找到程序所在的位置。那样会花费很长时间。我们注意到，通常我们不需要指定要运行的程序的完整路径名称，shell 似乎自己就知道。

Well, that’s correct. The shell does know. Here’s how: the shell maintains a list of directories where executable files (programs) are kept, and only searches the directories on that list. If it does not find the program after searching each directory on the list, it will issue the famous command not found error message.

​ 是的，这是正确的。shell 确实知道。原因如下：shell 维护着一个包含可执行文件（程序）所在目录的列表，并且只搜索该列表中的目录。如果在列表中的每个目录中都找不到该程序，它将显示著名的command not found错误消息。

This list of directories is called our path. We can view the list of directories with the following command:

​ 这个目录列表被称为我们的路径。我们可以使用以下命令查看目录列表：

1

[me@linuxbox me]$ echo $PATH

This will return a colon separated list of directories that will be searched if a specific path name is not given when a command is entered. In our first attempt to execute our new script, we specified a pathname ("./") to the file.

​ 这将返回一个以冒号分隔的目录列表，如果在输入命令时没有指定特定路径名，系统将在这些目录中进行搜索。在我们尝试执行新脚本时，我们指定了一个路径名（"./"）。

We can add directories to our path with the following command, where directory is the name of the directory we want to add:

​ 我们可以使用以下命令将目录添加到我们的路径中，其中 directory 是要添加的目录名称：

1

[me@linuxbox me]$ export PATH=$PATH:directory

A better way would be to edit our .bash_profile file to include the above command. That way, it would be done automatically every time we log in.

​ 更好的方法是编辑我们的 .bash_profile 文件，将上述命令包含其中。这样，每次登录时都会自动执行该命令。

Most Linux distributions encourage a practice in which each user has a specific directory for the programs they personally use. This directory is called bin and is a subdirectory of our home directory. If we do not already have one, we can create it with the following command:

​ 大多数 Linux 发行版都鼓励每个用户为他们个人使用的程序创建一个特定的目录。这个目录称为 bin，是我们家目录的子目录。如果我们还没有这个目录，可以使用以下命令创建它：

1

[me@linuxbox me]$ mkdir ~/bin

If we move or copy our script into our new bin directory we’ll be all set. Now we just have to type:

​ 如果我们将脚本移动或复制到新的 bin 目录中，我们就准备好了。现在我们只需要输入：

1

[me@linuxbox me]$ hello_world

and our script will run. Most distributions will have the ~/bin directory already in the PATH, but on some distributions, most notably Ubuntu (and other Debian-based distributions), we may need to restart our terminal session before our newly created bin directory is added to our PATH.

​ 我们的脚本将运行。大多数发行版都已经将 ~/bin 目录添加到 PATH 中，但在某些发行版中，特别是 Ubuntu（和其他基于 Debian 的发行版），我们可能需要重新启动终端会话，以便我们新创建的 bin 目录被添加到 PATH 中。

3.2 - 编辑我们已有的脚本

编辑我们已有的脚本 Editing the Scripts We Already Have

https://linuxcommand.org/lc3_wss0020.php

Before we start writing new scripts, We’ll take a look at some scripts we already have. These scripts were put into our home directory when our account was created, and are used to configure the behavior of our sessions on the computer. We can edit these scripts to change things.

​ 在我们开始编写新脚本之前，我们先来看一下我们已经有的一些脚本。这些脚本在我们的账户创建时被放置在我们的主目录中，并用于配置我们在计算机上的会话行为。我们可以编辑这些脚本来进行更改。

In this lesson, we will look at a couple of these scripts and learn a few important new concepts about the shell.

​ 在本课程中，我们将查看其中一些脚本，并学习关于 shell 的一些重要的新概念。

During our shell session, the system is holding a number of facts about the world in its memory. This information is called the environment. The environment contains such things as our path, our user name, and much more. We can examine a complete list of what is in the environment with the set command.

​ 在我们的 shell 会话期间，系统会在内存中保存关于该世界的一些事实。这些信息被称为环境。环境包含诸如路径、用户名等等。我们可以使用 set 命令查看环境中的完整列表。

Two types of commands are often contained in the environment. They are aliases and shell functions.

​ 环境中经常包含两种类型的命令：别名和shell 函数。

环境是如何建立的？ How is the Environment Established?

When we log on to the system, the bash program starts, and reads a series of configuration scripts called startup files. These define the default environment shared by all users. This is followed by more startup files in our home directory that define our personal environment. The exact sequence depends on the type of shell session being started. There are two kinds: a login shell session and a non-login shell session. A login shell session is one in which we are prompted for our user name and password; when we start a virtual console session, for example. A non-login shell session typically occurs when we launch a terminal session in the GUI.

​ 当我们登录到系统时，bash 程序启动，并读取一系列的配置脚本，称为启动文件。这些启动文件定义了所有用户共享的默认环境。接下来是我们主目录中的更多启动文件，定义了我们个人的环境。确切的顺序取决于所启动的 shell 会话类型。有两种类型：登录 shell 会话和非登录 shell 会话。登录 shell 会话是指我们被提示输入用户名和密码的会话；例如，当我们启动一个虚拟控制台会话时。非登录 shell 会话通常发生在图形界面中启动终端会话时。

Login shells read one or more startup files as shown below:

​ 登录 shell 会读取一个或多个启动文件，如下所示：

Non-login shell sessions read the following startup files:

​ 非登录 shell 会话读取以下启动文件：

In addition to reading the startup files above, non-login shells also inherit the environment from their parent process, usually a login shell.

​ 除了读取上述启动文件，非登录 shell 会话还会从其父进程继承环境，通常是登录 shell。

Take a look at your system and see which of these startup files you have. Remember— since most of the file names listed above start with a period (meaning that they are hidden), you will need to use the “-a” option when using ls.

​ 查看系统，看看你有哪些启动文件。记住，由于上面列出的大多数文件名以句点开头（表示它们是隐藏文件），使用 ls 命令时需要使用 -a 选项。

The ~/.bashrc file is probably the most important startup file from the ordinary user’s point of view, since it is almost always read. Non-login shells read it by default and most startup files for login shells are written in such a way as to read the ~/.bashrc file as well.

​ ~/.bashrc 文件可能是普通用户来说最重要的启动文件，因为它几乎总是会被读取。非登录 shell 会话默认读取它，而大多数登录 shell 的启动文件也以这种方式编写，以便读取 ~/.bashrc 文件。

If we take a look inside a typical .bash_profile (this one taken from a CentOS system), it looks something like this:

​ 如果我们查看一个典型的 .bash_profile（这是从 CentOS 系统中获取的一个示例），它的内容如下所示：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# .bash_profile
# Get the aliases and functions 获取别名和函数 
if [ -f ~/.bashrc ]; then
  . ~/.bashrc
fi

# User specific environment and startup programs
# 用户特定的环境和启动程序
PATH=$PATH:$HOME/bin
export PATH

Lines that begin with a “#” are comments and are not read by the shell. These are there for human readability. The first interesting thing occurs on the fourth line, with the following code:

​ 以“#”开头的行是注释，不会被 shell 读取。这些注释是为了人类可读性。有趣的事情发生在第四行，具有以下代码：

1
2
3

if [ -f ~/.bashrc ]; then
  . ~/.bashrc
fi

This is called an if compound command, which we will cover fully in a later lesson, but for now we will translate:

​ 这被称为if 复合命令，我们将在后面的课程中详细介绍，但现在我们先翻译一下：

If the file "~/.bashrc" exists, then read the "~/.bashrc" file.

​ 如果文件 "~/.bashrc" 存在，则读取 "~/.bashrc" 文件。

We can see that this bit of code is how a login shell gets the contents of .bashrc. The next thing in our startup file does is set the PATH variable to add the ~/bin directory to the path.

​ 我们可以看到，这段代码是登录 shell 获取 .bashrc 的内容的方式。我们的启动文件中的下一个部分是将 PATH 变量设置为将 ~/bin 目录添加到路径中。

Lastly, we have:

​ 最后，我们有：

1

export PATH

The export command tells the shell to make the contents of the PATH variable available to child processes of this shell.

​ export 命令告诉 shell 将 PATH 变量的内容提供给该 shell 的子进程。

别名 Aliases

An alias is an easy way to create a new command which acts as an abbreviation for a longer one. It has the following syntax:

​ 别名是创建一个新命令的简单方式，该命令作为一个较长命令的缩写。它具有以下语法：

1

alias name=value

where name is the name of the new command and value is the text to be executed whenever name is entered on the command line.

​ 其中 name 是新命令的名称，value 是在命令行输入 name 时要执行的文本。

Let’s create an alias called “l” and make it an abbreviation for the command “ls -l”. We’ll move to our home directory and using our favorite text editor, open the file .bashrc and add this line to the end of the file:

​ 让我们创建一个名为 “l” 的别名，将其作为命令 “ls -l” 的缩写。我们切换到我们的主目录，并使用我们喜欢的文本编辑器打开 .bashrc 文件，并在文件末尾添加以下行：

1

alias l='ls -l'

By adding the alias command to the file, we have created a new command called “l” which will perform “ls -l”. To try out our new command, close the terminal session and start a new one. This will reload the .bashrc file. Using this technique, we can create any number of custom commands for ourselves. Here is another one to try:

​ 通过将 alias 命令添加到文件中，我们创建了一个名为 “l” 的新命令，该命令将执行 “ls -l”。要尝试我们的新命令，关闭终端会话并启动一个新的会话。这将重新加载 .bashrc 文件。使用这种技术，我们可以为自己创建任意数量的自定义命令。下面是另一个要尝试的示例：

1

alias today='date +"%A, %B %-d, %Y"'

This alias creates a new command called “today” that will display today’s date with nice formatting.

​ 该别名创建了一个名为 “today” 的新命令，它将以漂亮的格式显示今天的日期。

By the way, the alias command is just another shell builtin. We can create our aliases directly at the command prompt; however they will only remain in effect during the current shell session. For example:

​ 顺便说一下，alias 命令只是另一个 shell 内置命令。我们可以直接在命令提示符下创建别名；但是，它们只在当前的 shell 会话中有效。例如：

1

[me@linuxbox me]$ alias l='ls -l'

Shell 函数 Shell Functions

Aliases are good for very simple commands, but to create something more complex, we need shell functions. Shell functions can be thought of as “scripts within scripts” or little sub-scripts. Let’s try one. Open .bashrc with our text editor again and replace the alias for “today” with the following:

​ 别名适用于非常简单的命令，但是要创建更复杂的内容，我们需要使用shell 函数。可以将 shell 函数视为“脚本中的脚本”或小的子脚本。让我们尝试一个例子。再次用我们的文本编辑器打开 .bashrc，并用以下内容替换 “today” 的别名：

1
2
3
4

today() {
    echo -n "Today's date is: "
    date +"%A, %B %-d, %Y"
}

Believe it or not, () is a shell builtin too, and as with alias, we can enter shell functions directly at the command prompt.

​ 你可能不会相信，() 也是一个 shell 内置命令，就像 alias 一样，我们可以直接在命令提示符下输入 shell 函数。

1
2
3
4
5

[me@linuxbox me]$ today() {
> echo -n "Today's date is: "
> date +"%A, %B %-d, %Y"
> }
[me@linuxbox me]$

However, like alias, shell functions defined directly on the command line only last as long as the current shell session.

​ 然而，与 alias 类似，直接在命令行定义的 shell 函数只在当前 shell 会话中有效，持续的时间与当前 shell 会话相同。

3.3 - here 脚本

here 脚本 - Here Scripts

https://linuxcommand.org/lc3_wss0030.php

Beginning with this lesson, we will construct a useful application. This application will produce an HTML document that contains information about our system. As we construct our script, we will discover step by step the tools needed to solve the problem at hand.

​ 从这一课开始，我们将创建一个有用的应用程序。这个应用程序将生成一个包含关于我们系统信息的 HTML 文档。在编写脚本的过程中，我们将逐步发现解决问题所需的工具。

使用脚本编写 HTML 文件 Writing an HTML File with a Script

As we may be aware, a well formed HTML file contains the following content:

​ 如我们所知，一个格式正确的 HTML 文件包含以下内容：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

<html>
<head>
    <title>
    The title of your page
    </title>
</head>

<body>
    Your page content goes here.
</body>
</html>

Now, with what we already know, we could write a script to produce the above content:

​ 现在，根据我们已经了解的内容，我们可以编写一个脚本来生成上述内容：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

#!/bin/bash

# sysinfo_page - A script to produce an html file

echo "<html>"
echo "<head>"
echo "  <title>"
echo "  The title of your page"
echo "  </title>"
echo "</head>"
echo ""
echo "<body>"
echo "  Your page content goes here."
echo "</body>"
echo "</html>"

This script can be used as follows:

​ 这个脚本可以按以下方式使用：

1

[me@linuxbox me]$ sysinfo_page > sysinfo_page.html

It has been said that the greatest programmers are also the laziest. They write programs to save themselves work. Likewise, when clever programmers write programs, they try to save themselves typing.

​ 有人说最优秀的程序员也是最懒惰的。他们编写程序来减少工作量。同样地，聪明的程序员编写程序时，会尽量减少键入的次数。

The first improvement to this script will be to replace the repeated use of the echo command with a single instance by using quotation more efficiently:

​ 对于这个脚本的第一个改进是将重复使用的 echo 命令替换为一个单独的实例，通过更有效地使用引号：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

#!/bin/bash

# sysinfo_page - A script to produce an HTML file

echo "<html>
 <head>
   <title>
   The title of your page
   </title>
 </head>
 
 <body>
   Your page content goes here.
 </body>
 </html>"

Using quotation, it is possible to embed carriage returns in our text and have the echo command’s argument span multiple lines.

​ 使用引号，我们可以在文本中嵌入换行符，并且 echo 命令的参数可以跨多行。

While this is certainly an improvement, it does have a limitation. Since many types of markup used in HTML incorporate quotation marks themselves, it makes using a quoted string a little awkward. A quoted string can be used but each embedded quotation mark will need to be escaped with a backslash character.

​ 尽管这无疑是一个改进，但它也有局限性。由于在 HTML 中使用了许多引号，因此使用引号字符串会有些不方便。可以使用引号字符串，但是每个嵌入的引号都需要用反斜杠字符进行转义。

In order to avoid the additional typing, we need to look for a better way to produce our text. Fortunately, the shell provides one. It’s called a here script.

​ 为了避免额外的键入，我们需要寻找一种更好的方式来生成我们的文本。幸运的是，shell 提供了一种方式，它被称为here 脚本。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

#!/bin/bash

# sysinfo_page - A script to produce an HTML file

cat << _EOF_
<html>
<head>
    <title>
    The title of your page
    </title>
</head>

<body>
    Your page content goes here.
</body>
</html>
_EOF_

A here script (also sometimes called a here document) is an additional form of I/O redirection. It provides a way to include content that will be given to the standard input of a command. In the case of the script above, the standard input of the cat command was given a stream of text from our script.

​ here 脚本（有时也称为 here document）是一种附加的输入/输出重定向形式。它提供了一种将内容提供给命令的标准输入的方法。在上面的脚本中，cat 命令的标准输入接收了来自我们脚本的文本流。

A here script is constructed like this:

​ here 脚本的结构如下：

1
2
3

command << token
content to be used as command's standard input
token

token can be any string of characters. “_EOF_” (EOF is short for “End Of File”) is traditional, but we can use anything as long as it does not conflict with a bash reserved word. The token that ends the here script must exactly match the one that starts it, or else the remainder of our script will be interpreted as more standard input to the command which can lead to some really exciting script failures.

​ token 可以是任意字符字符串。"_EOF_"（EOF 是 “End Of File” 的缩写）是传统用法，但我们可以使用任何字符串，只要它不与 bash 的保留词冲突即可。结束 here 文档的标记必须与开始的标记完全匹配，否则我们脚本的其余部分将被解释为更多的命令标准输入，这可能导致一些令人激动的脚本失败。

There is one additional trick that can be used with a here script. Often, we might want to indent the content portion of the here script to improve the readability of the script. We can do this if we change the script as follows:

​ 还有一种可以与 here 脚本一起使用的额外技巧。通常，我们可能希望对 here 脚本的内容进行缩进，以提高脚本的可读性。如果我们将脚本更改如下所示，就可以实现这一点：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

#!/bin/bash

# sysinfo_page - A script to produce an HTML file

cat <<- _EOF_
    <html>
    <head>
        <title>
        The title of your page
        </title>
    </head>

    <body>
        Your page content goes here.
    </body>
    </html>
_EOF_

Changing the “<<” to “<<-” causes bash to ignore the leading tabs (but not spaces) in the here script. The output from the cat command will not contain any of the leading tab characters. This technique is a bit problematic, as many text editors are configured (and desirably so) to use sequences of spaces rather than tab characters.

​ 将 “<<” 改为 “<<-"，会让 bash 忽略 here 脚本中的前导制表符（但不包括空格）。cat 命令的输出将不包含任何前导制表符。这种技巧有些问题，因为许多文本编辑器被配置为（并且应该如此）使用一系列空格而不是制表符。

O.k., let’s make our page. We will edit our page to get it to say something:

​ 好的，让我们制作我们的页面。我们将编辑我们的页面，使其显示一些信息：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

#!/bin/bash

# sysinfo_page - A script to produce an HTML file

cat <<- _EOF_
    <html>
    <head>
        <title>
        My System Information
        </title>
    </head>

    <body>
    <h1>My System Information</h1>
    </body>
    </html>
_EOF_

In our next lesson, we will make our script produce some real information about the system.

​ 在我们的下一课中，我们将让我们的脚本生成一些关于系统的真实信息。

3.4 - 变量

变量 Variables

https://linuxcommand.org/lc3_wss0040.php

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

#!/bin/bash

# sysinfo_page - A script to produce an HTML file

cat <<- _EOF_
    <html>
    <head>
        <title>
        My System Information
        </title>
    </head>

    <body>
    <h1>My System Information</h1>
    </body>
    </html>
_EOF_

Now that we have our script working, let’s improve it. First off, we’ll make some changes because we want to be lazy. In the script above, we see that the phrase “My System Information” is repeated. This is wasted typing (and extra work!) so we’ll improve it like this:

​ 现在我们的脚本可以工作了，让我们对它进行改进。首先，我们想偷点懒。在上面的脚本中，我们发现短语 “My System Information” 是重复的。这是多余的键入（和额外的工作！），所以我们将对其进行改进：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

#!/bin/bash

# sysinfo_page - A script to produce an HTML file

title="My System Information"

cat <<- _EOF_
    <html>
    <head>
        <title>
        $title
        </title>
    </head>

    <body>
    <h1>$title</h1>
    </body>
    </html>
_EOF_

We added a line to the beginning of the script and replaced the two occurrences of the phrase “My System Information” with $title.

​ 我们在脚本的开头添加了一行，并将短语 “My System Information” 的两个出现替换为 $title。

变量 Variables

What we have done is to introduce a fundamental concept that appears in every programming language, variables. Variables are areas of memory that can be used to store information and are referred to by a name. In the case of our script, we created a variable called “title” and placed the phrase “My System Information” into memory. Inside the here script that contains our HTML, we use “$title” to tell the shell to perform parameter expansion and replace the name of the variable with the variable’s contents.

​ 我们所做的是引入了一种在每种编程语言中都出现的基本概念，变量。变量是用于存储信息的内存区域，并通过名称进行引用。在我们的脚本中，我们创建了一个名为 “title” 的变量，并将短语 “My System Information” 存储到内存中。在包含我们的 HTML 的 here 脚本中，我们使用 “$title” 来告诉 shell 执行参数展开，将变量的名称替换为变量的内容。

Whenever the shell sees a word that begins with a “$”, it tries to find out what was assigned to the variable and substitutes it.

​ 当 shell 遇到以 “$” 开头的单词时，它会尝试查找所分配给变量的内容并进行替换。

如何创建变量 How to Create a Variable

To create a variable, put a line in the script that contains the name of the variable followed immediately by an equal sign ("="). No spaces are allowed. After the equal sign, assign the information to store.

​ 要创建一个变量，在脚本中放置一行，其中包含变量名，紧跟着一个等号（"="）。不允许有空格。在等号后面，分配要存储的信息。

变量名从何而来？ Where Do Variable Names Come From?

We just make them up. That’s right; we get to choose the names for our variables. There are a few rules.

​ 我们只是自己编写。没错，我们可以选择变量的名称。有一些规则。

1. Names must start with a letter.
2. A name must not contain embedded spaces. Use underscores instead.
3. Punctuation marks are not permitted.
4. 名称必须以字母开头。
5. 名称不能包含空格。使用下划线代替。
6. 不允许使用标点符号。

这如何增加我们的懒惰程度？ How Does This Increase Our Laziness?

The addition of the title variable made our life easier in two ways. First, it reduced the amount of typing we had to do. Second and more importantly, it made our script easier to maintain.

​ 添加 title 变量以两种方式简化了我们的生活。首先，它减少了我们需要键入的量。更重要的是，它使我们的脚本更易于维护。

As we write more and more scripts (or do any other kind of programming), we will see that programs are rarely ever finished. They are modified and improved by their creators and others. After all, that’s what open source development is all about. Let’s say that we wanted to change the phrase “My System Information” to “Linuxbox System Information.” In the previous version of the script, we would have had to change this in two locations. In the new version with the title variable, we only have to change it in one place. Since our script is so small, this might seem like a trivial matter, but as scripts get larger and more complicated, it becomes very important.

​ 当我们编写越来越多的脚本（或进行任何其他类型的编程）时，我们会发现程序很少是完成的。它们会被其创建者和其他人进行修改和改进。毕竟，这就是开源开发的目的。假设我们想要将短语 “My System Information” 更改为 “Linuxbox System Information."。在以前版本的脚本中，我们需要在两个位置进行更改。而在具有 title 变量的新版本中，我们只需要在一个位置进行更改。由于我们的脚本非常小，这可能看起来像是一个琐碎的事情，但是随着脚本变得越来越大和更复杂，这变得非常重要。

环境变量 Environment Variables

When we start our shell session, some variables are already set by the startup files we looked at earlier. To see all the variables that are in the environment, use the printenv command. One variable in our environment contains the host name for the system. We will add this variable to our script like so:

​ 当我们启动 shell 会话时，一些变量已经由我们之前查看过的启动文件设置好了。要查看环境中的所有变量，请使用 printenv 命令。我们的环境中的一个变量包含系统的主机名。我们将像这样将此变量添加到我们的脚本中：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

#!/bin/bash

# sysinfo_page - A script to produce an HTML file

title="System Information for"

cat <<- _EOF_
    <html>
    <head>
        <title>
        $title $HOSTNAME
        </title>
    </head>

    <body>
    <h1>$title $HOSTNAME</h1>
    </body>
    </html>
_EOF_

Now our script will always include the name of the machine on which we are running. Note that, by convention, environment variables names are uppercase.

​ 现在我们的脚本将始终包含正在运行的计算机的名称。请注意，按照约定，环境变量名称是大写的。

3.5 - 命令替换和常量

命令替换和常量 Command Substitution and Constants

https://linuxcommand.org/lc3_wss0050.php

In the previous lesson, we learned how to create variables and perform parameter expansions with them. In this lesson, we will extend this idea to show how we can substitute the results from commands.

​ 在上一课中，我们学习了如何创建变量并对其进行参数展开。在本课中，我们将扩展这个概念，展示如何替换命令的结果。

When we last left our script, it could create an HTML page that contained a few simple lines of text, including the host name of the machine which we obtained from the environment variable HOSTNAME. Now, we will add a time stamp to the page to indicate when it was last updated, along with the user that did it.

​ 上次我们离开时，我们的脚本可以创建一个包含一些简单文本的 HTML 页面，其中包括从环境变量 HOSTNAME 获取的计算机的主机名。现在，我们将在页面上添加一个时间戳，以指示上次更新的时间，以及执行更新的用户。

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

#!/bin/bash

# sysinfo_page - A script to produce an HTML file

title="System Information for"

cat <<- _EOF_
    <html>
    <head>
        <title>
        $title $HOSTNAME
        </title>
    </head>

    <body>
    <h1>$title $HOSTNAME</h1>
    <p>Updated on $(date +"%x %r %Z") by $USER</p>
    </body>
    </html>
_EOF_

As we can see, another environment variable, USER, is used to get the user name. In addition, we used this strange looking thing:

​ 正如我们所看到的，另一个环境变量 USER 用于获取用户名。此外，我们使用了这样一个看起来奇怪的东西：

1

$(date +"%x %r %Z")

The characters “$( )” tell the shell, “substitute the results of the enclosed command,” a technique known as command substitution. In our script, we want the shell to insert the results of the command date +"%x %r %Z" which outputs the current date and time. The date command has many features and formatting options. To look at them all, try this:

​ 字符 “$( )” 告诉 shell，“替换封闭命令的结果”，这是一种称为命令替换的技术。在我们的脚本中，我们希望 shell 插入命令 date +"%x %r %Z" 的结果，该命令输出当前日期和时间。date 命令有许多功能和格式选项。要查看所有选项，请尝试执行以下命令：

1

[me@linuxbox me]$ date --help | less

Be aware that there is an older, alternate syntax for “$(command)” that uses the backtick character " ` “. This older form is compatible with the original Bourne shell (sh) but its use is discouraged in favor of the modern syntax. The bash shell fully supports scripts written for sh, so the following forms are equivalent:

​ 请注意，有一种较旧的，替代 “$(command)” 语法，它使用反引号字符 " `"。这种较旧的形式与原始 Bourne shell (sh) 兼容，但建议使用现代语法而不是它。Bash shell 完全支持为 sh 编写的脚本，因此以下形式是等价的：

1
2

$(command)
`command`

将命令的结果赋给变量 Assigning a Command’s Result to a Variable

We can also assign the results of a command to a variable:

​ 我们还可以将命令的结果赋给变量：

1

right_now="$(date +"%x %r %Z")"

We can even nest the variables (place one inside another), like this:

​ 我们甚至可以嵌套变量（将一个变量放在另一个变量内），如下所示：

1
2

right_now="$(date +"%x %r %Z")"
time_stamp="Updated on $right_now by $USER"

An important safety tip: when performing parameter expansions or command substitutions, it is good practice to surround them in double quotes to prevent unwanted word splitting in case the result of the expansion contains whitespace characters.

​ **一个重要的安全提示：**在进行参数展开或命令替换时，最好将其用双引号括起来，以防止展开的结果包含空格字符时发生意外的单词分割。

常量 Constants

As the name variable suggests, the content of a variable is subject to change. This means that it is expected that during the execution of our script, a variable may have its content modified by something the script does.

​ 正如变量的名称所暗示的，变量的内容是可变的。这意味着在脚本执行期间，变量的内容可能会被脚本执行的某些操作修改。

On the other hand, there may be values that, once set, should never be changed. These are called constants. This is a common idea in programming. Most programming languages have special facilities to support values that are not allowed to change. Bash also has this facility but it is rarely used. Instead, if a value is intended to be a constant, it is given an uppercase name to remind the programmer that it should be considered a constant even if it’s not being enforced.

​ 另一方面，可能存在一些一旦设置就不应该更改的值。这些被称为常量。这是编程中的一个常见概念。大多数编程语言都有特殊的功能来支持不允许更改的值。Bash 也有这样的功能，但很少被使用。相反，如果一个值被认为是常量，它会被赋予一个大写的名称，以提醒程序员它应该被视为常量，即使它没有被强制执行。

Environment variables are usually considered constants since they are rarely changed. Like constants, environment variables are given uppercase names by convention. In the scripts that follow, we will use this convention - uppercase names for constants and lowercase names for variables.

​ 环境变量通常被认为是常量，因为它们很少改变。与常量一样，按照约定，环境变量使用大写名称。在接下来的脚本中，我们将使用这个约定 - 常量使用大写名称，变量使用小写名称。

So, applying everything we know, our program looks like this:

​ 因此，根据我们所知，我们的程序如下所示：

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

#!/bin/bash

# sysinfo_page - A script to produce an HTML file

title="System Information for $HOSTNAME"
RIGHT_NOW="$(date +"%x %r %Z")"
TIME_STAMP="Updated on $RIGHT_NOW by $USER"

cat <<- _EOF_
    <html>
    <head>
        <title>
        $title
        </title>
    </head>

    <body>
    <h1>$title</h1>
    <p>$TIME_STAMP</p>
    </body>
    </html>
_EOF_

3.6 - shell函数

shell函数 Shell Functions

https://linuxcommand.org/lc3_wss0060.php

As programs get longer and more complex, they become more difficult to design, code, and maintain. As with any large endeavor, it is often useful to break a single, large task into a series of smaller tasks.

​ 随着程序变得越来越长和复杂，设计、编码和维护就变得更加困难。与任何大型任务一样，将一个单一的、庞大的任务拆分为一系列较小的任务通常是有用的。

In this lesson, we will begin to break our single monolithic script into a number of separate functions.

​ 在本课中，我们将开始将我们的单一的庞大脚本拆分为多个独立的函数。

To get familiar with this idea, let’s consider the description of an everyday task – going to the market to buy food. Imagine that we were going to describe the task to a man from Mars.

​ 为了熟悉这个概念，让我们考虑一个日常任务的描述 - 去市场买食物。想象一下，我们要将这个任务描述给来自火星的人。

Our first top-level description might look like this:

​ 我们的第一个顶层描述可能是这样的：

1. Leave house
2. Drive to market
3. Park car
4. Enter market
5. Purchase food
6. Drive home
7. Park car
8. Enter house
9. 离开房子
10. 开车去市场
11. 停车
12. 进入市场
13. 购买食物
14. 开车回家
15. 停车
16. 进入房子

This description covers the overall process of going to the market; however a man from Mars will probably require additional detail. For example, the “Park car” sub task could be described as follows:

​ 这个描述涵盖了去市场的整个过程；然而，来自火星的人可能需要额外的细节。例如，“停车”子任务可以描述如下：

1. Find parking space
2. Drive car into space
3. Turn off motor
4. Set parking brake
5. Exit car
6. Lock car
7. 寻找停车位
8. 将车开入停车位
9. 关闭发动机
10. 设置驻车制动器
11. 离开车辆
12. 锁车

Of course the task “Turn off motor” has a number of steps such as “turn off ignition” and “remove key from ignition switch,” and so on.

​ 当然，“关闭发动机”这个任务还有许多步骤，比如“关闭点火开关”和“取下点火开关上的钥匙”，等等。

This process of identifying the top-level steps and developing increasingly detailed views of those steps is called top-down design. This technique allows us to break large complex tasks into many small, simple tasks.

​ 这个确定顶层步骤并开发逐渐详细的视图的过程被称为自顶向下设计。这种技术使我们能够将大型复杂任务拆分为许多小而简单的任务。

As our script continues to grow, we will use top down design to help us plan and code our script.

​ 随着我们的脚本不断增长，我们将使用自顶向下设计来帮助我们规划和编码脚本。

If we look at our script’s top-level tasks, we find the following list:

​ 如果我们查看脚本的顶层任务，我们会发现以下列表：

1. Open page
2. Open head section
3. Write title
4. Close head section
5. Open body section
6. Write title
7. Write time stamp
8. Close body section
9. Close page
10. 打开页面
11. 打开头部部分
12. 写标题
13. 关闭头部部分
14. 打开正文部分
15. 写标题
16. 写时间戳
17. 关闭正文部分
18. 关闭页面

All of these tasks are implemented, but we want to add more. Let’s insert some additional tasks after task 7:

​ 所有这些任务都已经实现，但我们想要添加更多。让我们在任务 7 之后插入一些额外的任务：

1. Write time stamp
2. Write system release info
3. Write up-time
4. Write drive space
5. Write home space
6. Close body section
7. Close page
8. 写时间戳
9. 写系统发布信息
10. 写运行时间
11. 写驱动器空间
12. 写主目录空间
13. 关闭正文部分
14. 关闭页面

It would be great if there were commands that performed these additional tasks. If there were, we could use command substitution to place them in our script like so:

​ 如果有能够执行这些额外任务的命令就好了。如果有的话，我们可以使用命令替换将它们放在我们的脚本中，像这样：

 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

#!/bin/bash

# sysinfo_page - A script to produce a system information HTML file

##### Constants

TITLE="System Information for $HOSTNAME"
RIGHT_NOW="$(date +"%x %r %Z")"
TIME_STAMP="Updated on $RIGHT_NOW by $USER"

##### Main

cat <<- _EOF_
  <html>
  <head>
      <title>$TITLE</title>
  </head>

  <body>
      <h1>$TITLE</h1>
      <p>$TIME_STAMP</p>
      $(system_info)
      $(show_uptime)
      $(drive_space)
      $(home_space)
  </body>
  </html>
_EOF_

While there are no commands that do exactly what we need, we can create them using shell functions.

​ 虽然没有确切满足我们需求的命令，但我们可以使用shell 函数来创建它们。

As we learned in lesson 2, shell functions act as “little programs within programs” and allow us to follow top-down design principles. To add the shell functions to our script, we’ll change it so:

​ 正如我们在第二课中学到的那样，shell 函数充当“程序中的小程序”，使我们能够遵循自顶向下的设计原则。为了将 shell 函数添加到我们的脚本中，我们将对它进行如下更改：

 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

#!/bin/bash

# sysinfo_page - A script to produce an system information HTML file

##### Constants

TITLE="System Information for $HOSTNAME"
RIGHT_NOW="$(date +"%x %r %Z")"
TIME_STAMP="Updated on $RIGHT_NOW by $USER"

##### Functions

system_info()
{

}


show_uptime()
{

}


drive_space()
{

}


home_space()
{

}

##### Main

cat <<- _EOF_
  <html>
  <head>
      <title>$TITLE</title>
  </head>

  <body>
      <h1>$TITLE</h1>
      <p>$TIME_STAMP</p>
      $(system_info)
      $(show_uptime)
      $(drive_space)
      $(home_space)
  </body>
  </html>
_EOF_

A couple of important points about functions: First, they must appear before we attempt to use them. Second, the function body (the portions of the function between the { and } characters) must contain at least one valid command. As written, the script will not execute without error, because the function bodies are empty. The simple way to fix this is to place a return statement in each function body. After we do this, our script will execute successfully again.

​ 关于函数有几点重要的要点：首先，它们必须出现在我们尝试使用它们之前。其次，函数体（花括号 { 和 } 之间的部分）必须包含至少一条有效命令。按照当前的编写方式，脚本将无法执行而出现错误，因为函数体是空的。修复这个问题的简单方法是在每个函数体中放置一个 return 语句。在我们这样做之后，脚本将再次成功执行。

保持脚本工作正常 Keep Your Scripts Working

When we develop a program, it is is often a good practice to add a small amount of code, run the script, add some more code, run the script, and so on. This way, if we introduce a mistake into the code, it will be easier to find and correct.

​ 当我们开发一个程序时，通常最好的做法是添加一小段代码，运行脚本，再添加一些代码，运行脚本，依此类推。这样，如果我们在代码中引入了错误，就会更容易找到和纠正它。

As we add functions to your script, we can also use a technique called stubbing to help watch the logic of our script develop. Stubbing works like this: imagine that we are going to create a function called “system_info” but we haven’t figured out all of the details of its code yet. Rather than hold up the development of the script until we are finished with system_info, we just add an echo command like this:

​ 当我们向脚本添加函数时，我们还可以使用一种叫做存根的技术来帮助观察脚本逻辑的发展。存根的工作方式如下：假设我们要创建一个名为 “system_info” 的函数，但我们还没有弄清楚它的所有代码细节。与其等到我们完成 system_info 后再继续脚本的开发，我们只需添加一个 echo 命令，像这样：

1
2
3
4
5

system_info()
{
    # Temporary function stub
    echo "function system_info"
}

This way, our script will still execute successfully, even though we do not yet have a finished system_info function. We will later replace the temporary stubbing code with the complete working version.

​ 这样，即使我们还没有一个完整的 system_info 函数，我们的脚本仍然可以成功执行。稍后，我们将用完整的工作版本替换临时的存根代码。

The reason we use an echo command is so we get some feedback from the script to indicate that the functions are being executed.

​ 我们使用 echo 命令的原因是为了从脚本中获得一些反馈，以指示函数正在被执行。

Let’s go ahead and write stubs for our new functions and keep the script working.

​ 让我们继续为我们的新函数编写存根，保持脚本的正常工作。

 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

#!/bin/bash

# sysinfo_page - A script to produce an system information HTML file

##### Constants

TITLE="System Information for $HOSTNAME"
RIGHT_NOW="$(date +"%x %r %Z")"
TIME_STAMP="Updated on $RIGHT_NOW by $USER"

##### Functions

system_info()
{
    # Temporary function stub
    echo "function system_info"
}


show_uptime()
{
    # Temporary function stub
    echo "function show_uptime"
}


drive_space()
{
    # Temporary function stub
    echo "function drive_space"
}


home_space()
{
    # Temporary function stub
    echo "function home_space"
}


##### Main

cat <<- _EOF_
  <html>
  <head>
      <title>$TITLE</title>
  </head>

  <body>
      <h1>$TITLE</h1>
      <p>$TIME_STAMP</p>
      $(system_info)
      $(show_uptime)
      $(drive_space)
      $(home_space)
  </body>
  </html>
_EOF_

3.7 - 一些真正的工作

一些真正的工作 Some Real Work

https://linuxcommand.org/lc3_wss0070.php

In this lesson, we will develop some of our shell functions and get our script to produce some useful information.

​ 在本课中，我们将开发一些 shell 函数，并使我们的脚本生成一些有用的信息。

show_uptime

The show_uptime function will display the output of the uptime command. The uptime command outputs several interesting facts about the system, including the length of time the system has been “up” (running) since its last re-boot, the number of users and recent system load.

​ show_uptime 函数将显示 uptime 命令的输出结果。uptime 命令输出了系统的一些有趣信息，包括系统自上次重新启动以来的运行时间，用户数量以及最近的系统负载。

1
2

[me@linuxbox me]$ uptime
9:15pm up 2 days, 2:32, 2 users, load average: 0.00, 0.00, 0.00

To get the output of the uptime command into our HTML page, we will code our shell function like this, replacing our temporary stubbing code with the finished version:

​ 为了将 uptime 命令的输出添加到我们的 HTML 页面中，我们将编写如下的 shell 函数，将临时的存根代码替换为最终版本：

1
2
3
4
5
6
7

show_uptime()
{
    echo "<h2>System uptime</h2>"
    echo "<pre>"
    uptime
    echo "</pre>"
}

As we can see, this function outputs a stream of text containing a mixture of HTML tags and command output. When the command substitution takes place in the main body of the our program, the output from our function becomes part of the here script.

​ 正如我们所看到的，该函数输出了一个包含 HTML 标记和命令输出混合的文本流。当命令替换发生在我们程序的主体部分时，函数的输出将成为 here 脚本的一部分。

drive_space

The drive_space function will use the df command to provide a summary of the space used by all of the mounted file systems.

​ drive_space 函数将使用 df 命令提供所有已挂载文件系统使用空间的摘要信息。

1
2
3
4
5
6

[me@linuxbox me]$ df
Filesystem   1k-blocks      Used Available Use% Mounted on
/dev/hda2       509992    225772    279080  45% /
/dev/hda1        23324      1796     21288   8% /boot
/dev/hda3     15739176   1748176  13832360  12% /home
/dev/hda5      3123888   3039584     52820  99% /usr

In terms of structure, the drive_space function is very similar to the show_uptime function:

​ 在结构上，drive_space 函数与 show_uptime 函数非常相似：

1
2
3
4
5
6
7

drive_space()
{
    echo "<h2>Filesystem space</h2>"
    echo "<pre>"
    df
    echo "</pre>"
}

home_space

The home_space function will display the amount of space each user is using in his/her home directory. It will display this as a list, sorted in descending order by the amount of space used.

​ home_space 函数将显示每个用户在他/她的主目录中使用的空间量。它将按照使用空间的大小降序排列，以列表形式显示。

1
2
3
4
5
6
7
8

home_space()
{
    echo "<h2>Home directory space by user</h2>"
    echo "<pre>"
    echo "Bytes Directory"
    du -s /home/* | sort -nr
    echo "</pre>"
}

Note that in order for this function to successfully execute, the script must be run by the superuser, since the du command requires superuser privileges to examine the contents of the /home directory.

​ 请注意，为了使该函数成功执行，脚本必须以超级用户身份运行，因为 du 命令需要超级用户权限来检查 /home 目录的内容。

system_info

We’re not ready to finish the system_info function yet. In the meantime, we will improve the stubbing code so it produces valid HTML:

​ 我们还没有准备好完成 system_info 函数。与此同时，我们将改进存根代码，以生成有效的 HTML：

1
2
3
4
5

system_info()
{
    echo "<h2>System release info</h2>"
    echo "<p>Function not yet implemented</p>"
}

3.8 - 流程控制 - 第一部分

流程控制 - 第一部分 Flow Control - Part 1

https://linuxcommand.org/lc3_wss0080.php

In this lesson, we will look at how to add intelligence to our scripts. So far, our project script has only consisted of a sequence of commands that starts at the first line and continues line by line until it reaches the end. Most programs do much more than this. They make decisions and perform different actions depending on conditions.

​ 在这节课中，我们将学习如何在脚本中添加智能功能。到目前为止，我们的项目脚本只是由一系列命令组成，从第一行开始顺序执行，直到结束。大多数程序要做的事情比这要复杂得多。它们根据条件进行决策并执行不同的操作。

The shell provides several commands that we can use to control the flow of execution in our program. In this lesson, we will look at the following:

​ Shell 提供了几个命令，我们可以用它们来控制程序的执行流程。在本课中，我们将学习以下内容：

• if
• test
• exit

if

The first command we will look at is if. The if command is fairly simple on the surface; it makes a decision based on the exit status of a command. The if command’s syntax looks like this:

​ 我们首先学习的是 if 命令。if 命令在表面上很简单，它根据一个命令的 退出状态 做出决策。if 命令的语法如下：

1
2
3
4
5
6
7

if commands; then
    commands
[elif commands; then
    commands...]
[else
    commands]
fi

where commands is a list of commands. This is a little confusing at first glance. But before we can clear this up, we have to look at how the shell evaluates the success or failure of a command.

​ 其中 commands 是一系列命令。乍一看可能有点困惑。但在我们澄清这一点之前，我们必须了解 Shell 如何评估命令的成功或失败。

退出状态 Exit Status

Commands (including the scripts and shell functions we write) issue a value to the system when they terminate, called an exit status. This value, which is an integer in the range of 0 to 255, indicates the success or failure of the command’s execution. By convention, a value of zero indicates success and any other value indicates failure. The shell provides a parameter that we can use to examine the exit status. Here we see it in action:

​ 命令（包括我们编写的脚本和 Shell 函数）在终止时向系统发出一个值，称为退出状态。这个值是一个在 0 到 255 范围内的整数，表示命令执行的成功或失败。按照惯例，零表示成功，任何其他值表示失败。Shell 提供了一个参数，我们可以使用它来检查退出状态。下面是一个示例：

1
2
3
4
5
6
7
8

[me@linuxbox ~]$ ls -d /usr/bin
/usr/bin
[me@linuxbox ~]$ echo $?
0
[me@linuxbox ~]$ ls -d /bin/usr
ls: cannot access /bin/usr: No such file or directory
[me@linuxbox ~]$ echo $?
2

In this example, we execute the ls command twice. The first time, the command executes successfully. If we display the value of the parameter $?, we see that it is zero. We execute the ls command a second time, producing an error and examine the parameter $? again. This time it contains a 2, indicating that the command encountered an error. Some commands use different exit status values to provide diagnostics for errors, while many commands simply exit with a value of one when they fail. Man pages often include a section entitled “Exit Status,” describing what codes are used. However, a zero always indicates success.

​ 在这个示例中，我们执行了两次 ls 命令。第一次，命令成功执行。如果我们显示参数 $? 的值，会发现它是零。我们第二次执行 ls 命令，产生一个错误，并再次检查参数 $?。这次它包含了 2，表示命令遇到了一个错误。有些命令使用不同的退出状态值来提供错误的诊断信息，而许多命令在失败时只是退出状态为 1。手册页面通常包含一个名为“Exit Status”的部分，描述了使用了哪些代码。然而，零总是表示成功。

The shell provides two extremely simple builtin commands that do nothing except terminate with either a zero or one exit status. The true command always executes successfully and the false command always executes unsuccessfully:

​ Shell 提供了两个非常简单的内置命令，它们除了以零或一的退出状态终止外什么都不做。true 命令始终成功执行，而 false 命令始终执行失败：

1
2
3
4
5
6

[me@linuxbox~]$ true
[me@linuxbox~]$ echo $?
0
[me@linuxbox~]$ false
[me@linuxbox~]$ echo $?
1

We can use these commands to see how the if statement works. What the if statement really does is evaluate the success or failure of commands:

​ 我们可以使用这些命令来了解 if 语句的工作原理。if 语句的真正作用是评估命令的成功或失败：

1
2
3
4

[me@linuxbox ~]$ if true; then echo "It's true."; fi
It's true.
[me@linuxbox ~]$ if false; then echo "It's true."; fi
[me@linuxbox ~]$

The command echo "It's true." is executed when the command following if executes successfully, and is not executed when the command following if does not execute successfully.

​ 当 if 后面的命令成功执行时，会执行 echo "It's true." 命令，当 if 后面的命令执行失败时，不会执行 echo "It's true." 命令。

test

The test command is used most often with the if command to perform true/false decisions. The command is unusual in that it has two different syntactic forms:

​ test 命令最常与 if 命令一起使用以进行真/假判断。该命令有两种不同的语法形式：

1
2
3
4
5
6
7

# First form

test expression

# Second form

[ expression ]

The test command works simply. If the given expression is true, test exits with a status of zero; otherwise it exits with a status of 1.

​ test 命令的工作很简单。如果给定的表达式为真，则 test 以零状态退出；否则，它以 1 的状态退出。

The neat feature of test is the variety of expressions we can create. Here is an example:

​ test 的好处是我们可以创建多种表达式。以下是一个示例：

1
2
3
4
5

if [ -f .bash_profile ]; then
    echo "You have a .bash_profile. Things are fine."
else
    echo "Yikes! You have no .bash_profile!"
fi

In this example, we use the expression “-f .bash_profile “. This expression asks, “Is .bash_profile a file?” If the expression is true, then test exits with a zero (indicating true) and the if command executes the command(s) following the word then. If the expression is false, then test exits with a status of one and the if command executes the command(s) following the word else.

​ 在这个示例中，我们使用表达式 “-f .bash_profile"。该表达式询问：“.bash_profile 是否是一个文件？”如果表达式为真，则 test 以零状态退出（表示为真），并且 if 命令执行紧随 then 之后的命令。如果表达式为假，则 test 以状态 1 退出，并且 if 命令执行紧随 else 之后的命令。

Here is a partial list of the conditions that test can evaluate. Since test is a shell builtin, use “help test” to see a complete list.

​ 以下是 test 命令可以评估的一部分条件列表。由于 test 是一个内置命令，使用 “help test” 可以查看完整列表。

Before we go on, We need to explain the rest of the example above, since it also reveals more important ideas.

​ 在我们继续之前，我们需要解释上面示例的剩余部分，因为它还揭示了更重要的思想。

In the first line of the script, we see the if command followed by the test command, followed by a semicolon, and finally the word then. Most people choose to use the [ *expression* ] form of the test command since it’s easier to read. Notice that the spaces required between the “[” and the beginning of the expression are required. Likewise, the space between the end of the expression and the trailing “]”.

​ 在脚本的第一行中，我们看到 if 命令后面跟着 test 命令，后面是一个分号，最后是单词 then。大多数人选择使用 [ *expression* ] 形式的 test 命令，因为它更容易阅读。请注意，在 “[” 与表达式开头之间需要的空格。同样，表达式的结尾和尾随的 “]” 之间的空格也是必需的。

The semicolon is a command separator. Using it allows us to put more than one command on a line. For example:

​ 分号是一个命令分隔符。使用分号允许我们在一行上放置多个命令。例如：

1

[me@linuxbox me]$ clear; ls

will clear the screen and execute the ls command.

将清除屏幕并执行 ls 命令。

We use the semicolon as we did to allow us to put the word then on the same line as the if command, because it’s easier to read that way.

​ 我们像这样使用分号是为了让 then 这个词与 if 命令在同一行上，因为这样更容易阅读。

On the second line, there is our old friend echo. The only thing of note on this line is the indentation. Again for the benefit of readability, it is traditional to indent all blocks of conditional code; that is, any code that will only be executed if certain conditions are met. The shell does not require this; it is done to make the code easier to read.

​ 在第二行中，我们看到了我们的老朋友 echo。这行中值得注意的是缩进。为了可读性，传统上对所有的条件代码块进行缩进，也就是只有在满足特定条件时才会执行的代码块。Shell 并不要求这样做，但这样做是为了让代码更容易阅读。

In other words, we could write the following and get the same results:

​ 换句话说，我们可以编写以下代码并获得相同的结果：