In this chapter we are going to look at some of the “magic” that occurs on the command line when you press the enter key. While we will examine several interesting and complex features of the shell, we will do it with just one new command:
在這一章我們將看到，當你按下 enter 鍵後，發生在命令列中的一些“魔法”。儘管我們會 深入研究幾個複雜而有趣的 shell 特性，但我們只需要使用一個新命令：
echo - Display a line of text
echo － 顯示一行文字
Each time you type a command line and press the enter key, bash performs several processes upon the text before it carries out your 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, you 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:
每當你輸入一個命令並按下 enter 鍵，bash 會在執行你的命令之前對輸入 的字元完成幾個步驟的處理。我們已經見過幾個例子：例如一個簡單的字元序列”*”, 對 shell 來說有著多麼豐富的涵義。這背後的的過程叫做（字元）展開。透過展開， 你輸入的字元，在 shell 對它起作用之前，會展開成為別的字元。為了說明這一點 ，讓我們看一看 echo 命令。echo 是一個 shell 內建命令，可以完成非常簡單的任務。 它將它的文字引數列印到標準輸出中。
[me@linuxbox ~]$ 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 命令的任一個引數都會在（螢幕上）顯示出來。 讓我們試試另一個例子：
[me@linuxbox ~]$ echo *
Desktop Documents ls-output.txt Music Pictures Public Templates Videos
So what just happened? Why didn’t echo print “*”? As you 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 的行為符合預期。
The mechanism by which wildcards work is called pathname expansion. If we try some of the techniques that we employed in our earlier chapters, we will see that they are really expansions. Given a home directory that looks like this:
萬用字元所依賴的工作機制叫做路徑名展開。如果我們試一下在之前的章節中使用的技巧， 我們會看到它們實際上是展開。給定一個家目錄，它看起來像這樣：
[me@linuxbox ~]$ ls
Desktop ls-output.txt Pictures Templates
....
we could carry out the following expansions:
我們能夠執行以下的展開：
[me@linuxbox ~]$ echo D*
Desktop Documents
and:
和：
[me@linuxbox ~]$ echo *s
Documents Pictures Templates Videos
or even:
甚至是：
[me@linuxbox ~]$ echo [[:upper:]]*
Desktop Documents Music Pictures Public Templates Videos
and looking beyond our home directory:
檢視家目錄之外的目錄：
[me@linuxbox ~]$ echo /usr/*/share
/usr/kerberos/share /usr/local/share
Pathname Expansion Of Hidden Files
隱藏檔案路徑名展開
As we know, filenames that begin with a period character are hidden. Pathname expansion also respects this behavior. An expansion such as:
正如我們知道的，以圓點字元開頭的檔名是隱藏檔案。路徑名展開也尊重這種 行為。像這樣的展開：
echo *
does not reveal hidden files.
不會顯示隱藏檔案
It might appear at first glance that we could include hidden files in an expansion by starting the pattern with a leading period, like this:
直覺告訴我們，如果展開模式以一個圓點開頭，我們就能夠在展開中包含隱藏檔案， 就像這樣：
echo .*
It almost works. However, if we examine the results closely, we will see that the names “.” and “..” will also appear in the results. Since these names refer to the current working directory and its parent directory, using this pattern will likely produce an incorrect result. We can see this if we try the command:
它幾乎要起作用了。然而，如果我們仔細檢查一下輸出結果，我們會看到名字”.” 和”..”也出現在結果中。由於它們是指當前工作目錄和父目錄，使用這種 模式可能會產生不正確的結果。我們可以透過這個命令來驗證：
ls -d .* | less
To correctly perform pathname expansion in this situation, we have to employ a more specific pattern. This will work correctly:
為了在這種情況下正確地完成路徑名展開，我們應該使用一個更精確的模式。 這個模式會正確地工作：
ls -d .[!.]?*
This pattern expands into every filename that begins with a period, does not include a second period, contains at least one additional character and can be followed by any other characters. This will work correctly with most hidden files (though it still won’t include filenames with multiple leading periods). The ls command with the -A option (“almost all”) will provide a correct listing of hidden files:
這種模式展開成所有以圓點開頭，第二個字元不包含圓點，再包含至少一個字元， 並且這個字元之後緊接著任意多個字元的檔名。這個命令將正確列出大多數的隱藏檔案 （但仍不能包含以多個圓點開頭的檔名）。帶有 -A 選項（“幾乎所有”）的 ls 命令能夠提供一份正確的隱藏檔案清單：
ls -A
As you may 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 命令的介紹中回想起來，波浪線字元(“~”)有特殊的含義。當它用在 一個單詞的開頭時，它會展開成指定使用者的家目錄名，如果沒有指定使用者名稱，則展開成當前使用者的家目錄：
[me@linuxbox ~]$ echo ~
/home/me
If user “foo” has an account, then:
如果有使用者”foo”這個帳號，那麼：
[me@linuxbox ~]$ echo ~foo
/home/foo
The shell allows arithmetic to be performed by expansion. This allow us to use the shell prompt as a calculator:
shell 在展開中執行算數表示式。這允許我們把 shell 提示當作計算器來使用：
[me@linuxbox ~]$ echo $((2 + 2))
4
Arithmetic expansion uses the form:
算術表示式展開使用這種格式：
$((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. Here are a few of the supported operators:
算術表示式只支援整數（全部是數字，不帶小數點），但是能執行很多不同的操作。這裡是 一些它支援的運算子：
| Operator | Description |
|---|---|
| + | Addition |
| - | Subtraction |
| * | Multiplication |
| / | Division(but remember, since expansion only supports integer arithmetic, results are integers.) |
| % | Modulo, which simply means, "remainder". |
| ** | Exponentiation |
| 運算子 | 說明 |
|---|---|
| + | 加 |
| - | 減 |
| * | 乘 |
| / | 除（但是記住，因為展開只是支援整數除法，所以結果是整數。） |
| % | 取餘，只是簡單的意味著，“餘數” |
| ** | 取冪 |
Spaces are not significant in arithmetic expressions and expressions may be nested. For example, to multiply five squared by three:
在算術表示式中空格並不重要，並且表示式可以巢狀。例如，5的平方乘以3：
[me@linuxbox ~]$ 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:
一對括號可以用來把多個子表示式括起來。透過這個技術，我們可以重寫上面的例子， 同時用一個展開代替兩個，來得到一樣的結果：
[me@linuxbox ~]$ echo $(((5**2) * 3))
75
Here is an example using the division and remainder operators. Notice the effect of integer division:
這是一個使用除法和取餘運算子的例子。注意整數除法的結果：
[me@linuxbox ~]$ echo Five divided by two equals $((5/2))
Five divided by two equals 2
[me@linuxbox ~]$ echo with $((5%2)) left over.
with 1 left over.
Arithmetic expansion is covered in greater detail in Chapter 35.
在35章會更深入地討論算術表示式的內容。
Perhaps the strangest expansion is called brace expansion. With it, you can create multiple text strings from a pattern containing braces. Here’s an example:
可能最奇怪的展開是花括號展開。透過它，你可以從一個包含花括號的模式中 建立多個文字字串。這是一個例子：
[me@linuxbox ~]$ 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:
花括號展開模式可能包含一個開頭部分叫做報頭，一個結尾部分叫做附言。花括號表示式本身可 能包含一個由逗號分開的字串列表，或者一個整數區間，或者單個的字元的區間。這種模式不能 嵌入空白字元。這個例子中使用了一個整數區間：
[me@linuxbox ~]$ echo Number_{1..5}
Number_1 Number_2 Number_3 Number_4 Number_5
A range of letters in reverse order:
倒序排列的字母區間：
[me@linuxbox ~]$ 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:
花括號展開可以巢狀：
[me@linuxbox ~]$ 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 photographers and had a large collection of images that 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:
那麼這對什麼有好處呢？最常見的應用是，建立一系列的檔案或目錄列表。例如， 如果我們是攝影師，有大量的相片。我們想把這些相片按年月先後組織起來。首先， 我們要建立一系列以數值”年－月”形式命名的目錄。透過這種方式，可以使目錄名按照 年代順序排列。我們可以手動鍵入整個目錄列表，但是工作量太大了，並且易於出錯。 反之，我們可以這樣做：
[me@linuxbox ~]$ mkdir Pics
[me@linuxbox ~]$ cd Pics
[me@linuxbox Pics]$ mkdir {2007..2009}-0{1..9} {2007..2009}-{10..12}
[me@linuxbox Pics]$ ls
2007-01 2007-07 2008-01 2008-07 2009-01 2009-07
2007-02 2007-08 2008-02 2008-08 2009-02 2009-08
2007-03 2007-09 2008-03 2008-09 2009-03 2009-09
2007-04 2007-10 2008-04 2008-10 2009-04 2009-10
2007-05 2007-11 2008-05 2008-11 2009-05 2009-11
2007-06 2007-12 2008-06 2008-12 2009-06 2009-12
Pretty slick!
棒極了！
We’re only going to touch briefly on parameter expansion in this chapter, but we’ll be covering it extensively 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 your examination. For example, the variable named “USER” contains your user name. To invoke parameter expansion and reveal the contents of USER you would do this:
在這一章我們將會簡單介紹引數展開，但會在後續章節中進行詳細討論。這個特性在 shell 指令碼中比直接在命令列中更有用。 它的許多功能和系統儲存小塊資料，並給每塊資料命名的能力有關係。許多像這樣的小塊資料， 更恰當的稱呼應該是變數，可供你方便地檢查它們。例如，叫做”USER”的變數包含你的 使用者名稱。可以這樣做來呼叫引數，並檢視 USER 中的內容，：
[me@linuxbox ~]$ echo $USER
me
To see a list of available variables, try this:
要檢視有效的變數列表，可以試試這個：
[me@linuxbox ~]$ printenv | less
You may have noticed that with other types of expansion, if you mistype a pattern, the expansion will not take place and the echo command will simply display the mistyped pattern. With parameter expansion, if you misspell the name of a variable, the expansion will still take place, but will result in an empty string:
你可能注意到在其它展開型別中，如果你誤輸入一個模式，展開就不會發生。這時 echo 命令只簡單地顯示誤鍵入的模式。但在引數展開中，如果你拼寫錯了一個變數名， 展開仍然會進行，只是展開的結果是一個空字串：
[me@linuxbox ~]$ echo $SUER
[me@linuxbox ~]$
Command substitution allows us to use the output of a command as an expansion:
命令替換允許我們把一個命令的輸出作為一個展開模式來使用：
[me@linuxbox ~]$ echo $(ls)
Desktop Documents ls-output.txt Music Pictures Public Templates
Videos
One of my favorites goes something like this:
我最喜歡用的一行命令是像這樣的：
[me@linuxbox ~]$ 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 命令 完整路徑名的情況下得到它的檔案屬性列表。我們不只限制於簡單命令。也可以使用整個管道線 （只展示部分輸出）：
[me@linuxbox ~]$ file $(ls /usr/bin/* | grep zip)
/usr/bin/bunzip2: symbolic link to `bzip2'
....
In this example, the results of the pipeline became the argument list of the file command.
在這個例子中，管道線的輸出結果成為 file 命令的引數列表。
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:
在舊版 shell 程式中，有另一種語法也支援命令替換，可與剛提到的語法輪換使用。 bash 也支援這種語法。它使用倒引號來代替美元符號和括號：
[me@linuxbox ~]$ ls -l `which cp`
-rwxr-xr-x 1 root root 71516 2007-12-05 08:58 /bin/cp
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 有許多方式可以完成展開，現在是時候學習怎樣來控制展開了。 以下面例子來說明：
[me@linuxbox ~]$ echo this is a test
this is a test
or:
或者：
[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 的值替換為一個空字串，因為 1 是沒有定義的變數。shell 提供了一種
叫做引用的機制，來有選擇地禁止不需要的展開。
The first type of quoting we will look at is double quotes. If you 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. Say 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 檔案的受害者。如果我們試圖在命令列中使用這個 檔案，單詞分割機制會導致這個檔名被看作兩個獨自的引數，而不是所期望 的單個引數：
[me@linuxbox ~]$ 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 stop the word-splitting and get the desired result; further, we can even repair the damage:
使用雙引號，我們可以阻止單詞分割，得到期望的結果；進一步，我們甚至可以修復 破損的檔名。
[me@linuxbox ~]$ ls -l "two words.txt"
-rw-rw-r-- 1 me me 18 2008-02-20 13:03 two words.txt
[me@linuxbox ~]$ 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:
記住，在雙引號中，引數展開、算術表示式展開和命令替換仍然有效：
[me@linuxbox ~]$ echo "$USER $((2+2)) $(cal)"
me 4 February 2008
Su Mo Tu We Th Fr Sa
....
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:
我們應該花費一點時間來看一下雙引號在命令替換中的效果。首先仔細研究一下單詞分割 是怎樣工作的。在之前的範例中，我們已經看到單詞分割機制是怎樣來刪除文字中額外空格的：
[me@linuxbox ~]$ 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:
在預設情況下，單詞分割機制會在單詞中尋找空格，製表符，和換行符，並把它們看作 單詞之間的界定符。這意味著無引用的空格，製表符和換行符都不是文字的一部分， 它們只作為分隔符使用。由於它們把單詞分為不同的引數，所以在上面的例子中， 命令列包含一個帶有四個不同引數的命令。如果我們加上雙引號：
[me@linuxbox ~]$ 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:
事實上，單詞分割機制把換行符看作界定符，對命令替換產生了一個雖然微妙但有趣的影響。 考慮下面的例子：
[me@linuxbox ~]$ echo $(cal)
February 2008 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 ~]$ echo "$(cal)"
February 2008
....
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.
在第一個範例中，沒有引用的命令替換導致命令列包含38個引數。在第二個例子中， 命令列只有一個引數，引數中包括嵌入的空格和換行符。
If we need to suppress all expansions, we use single quotes. Here is a comparison of unquoted, double quotes, and single quotes:
如果需要禁止所有的展開，我們要使用單引號。以下例子是無引用，雙引號，和單引號的比較結果：
[me@linuxbox ~]$ echo text ~/*.txt {a,b} $(echo foo) $((2+2)) $USER
text /home/me/ls-output.txt a b foo 4 me
[me@linuxbox ~]$ echo "text ~/*.txt {a,b} $(echo foo) $((2+2)) $USER"
text ~/*.txt {a,b} foo 4 me
[me@linuxbox ~]$ 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.
正如我們所看到的，隨著引用程度加強，越來越多的展開被禁止。
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:
有時候我們只想引用單個字元。我們可以在字元之前加上一個反斜槓，在這裡叫做轉義字元。 經常在雙引號中使用轉義字元，來有選擇地阻止展開。
[me@linuxbox ~]$ 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 you can to this:
使用轉義字元來消除檔名中一個字元的特殊含義，是很普遍的。例如，在檔名中可能使用 一些對於 shell 來說有特殊含義的字元。這些字元包括”$”, “!”, “ “等字元。在檔名 中包含特殊字元，你可以這樣做：
[me@linuxbox ~]$ 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.
為了允許反斜槓字元出現，輸入”\“來轉義。注意在單引號中，反斜槓失去它的特殊含義，它 被看作普通字元。
Backslash Escape Sequences
反斜槓轉義字元序列
In addition to its role as the escape character, the backslash is also used as part of a notation to represent certain special characters called control codes. The first thirty-two characters in the ASCII coding scheme are used to transmit commands to teletype-like devices. Some of these codes are familiar (tab, backspace, linefeed, and carriage return), while others are not (null, end-of-transmission, and acknowledge).
反斜槓除了作為轉義字元外，也可以構成一種表示法，來代表某種 特殊字元，這些特殊字元叫做控制碼。ASCII 編碼表中前32個字元被用來把命令轉輸到電報機 之類別的裝置。一些編碼是眾所周知的（製表符，退格符，換行符，和回車符），而其它 一些編碼就不熟悉了（空值，傳輸結束碼，和確認）。
Escape Sequence Meaning \a Bell(“Alert”-causes the computer to beep) \b Backspace \n Newline. On Unix-like systems, this produces a linefeed. \r Carriage return \t Tab
轉義序列 含義 \a 響鈴（”警告”－導致計算機嘟嘟響） \b 退格符 \n 新的一行。在類別 Unix 系統中，產生換行。 \r 回車符 \t 製表符 The table above lists some of the common backslash escape sequences. The idea behind this representation using the backslash originated in the C programming language and has been adopted by many others, including the shell.
上表列出了一些常見的反斜槓轉義字元序列。這種利用反斜槓的表示法背後的思想來源於 C 程式語言， 許多其它語言也採用了這種表示方法，包括 shell。
Adding the ‘-e’ option to echo will enable interpretation of escape sequences. You may also place them inside $' '. Here, using the sleep command, a simple program that just waits for the specified number of seconds and then exits, we can create a primitive countdown timer:
echo 命令帶上 ‘-e’ 選項，能夠解釋轉義序列。你可以把轉義序列放在 $' ' 裡面。 以下例子中，我們可以使用 sleep 命令建立一個簡單的倒數計數器（ sleep 是一個簡單的程式， 它會等待指定的秒數，然後退出）：
sleep 10; echo -e "Time's up\a"
We could also do this: 我們也可以這樣做：
sleep 10; echo "Time's up" $'\a'
As we move forward with using the shell, we will find that expansions and quoting will be used with increasing frequency, so it makes sense to get a good understanding of the way they works. In fact, it could be argued that they are the most important subjects to learn about the shell. Without a proper understanding of expansion, the shell will always be a source of mystery and confusion, and much of it potential power wasted.
隨著我們繼續學習 shell，你會發現使用展開和引用的頻率逐漸多起來，所以能夠很好的 理解它們的工作方式很有意義。事實上，可以這樣說，它們是學習 shell 的最重要的主題。 如果沒有準確地理解展開模式，shell 總是神祕和混亂的源泉，並且 shell 潛在的能力也 浪費掉了。
The bash man page has major sections on both expansion and quoting which cover these topics in a more formal manner.
Bash 手冊頁有主要段落是關於展開和引用的，它們以更正式的方式介紹了這些題目。
The Bash Reference Manual also contains chapters on expansion and quoting:
Bash 參考手冊也包含章節，介紹展開和引用：