Special symbols in the shell

There are a lot of special symbols in the Linux shell, which we should pay special attention to when we write shell scripts: On the one hand, we need to know the use of these special symbols, which can achieve a multiplier effect, but on the other hand, avoid the overuse of these special symbols, which makes the script difficult to debug and difficult to read.

These special symbols are listed roughly as follows:

# ; ;; . ,//' String ' |! $ ${} $? $$ $* "String" * * *? : ^ $# [email protected] ' command ' {} [] [[]] () (()) | | && {Xx,yy,zz,...} ~ ~+ ~-&/+–%= = = =

Output/Input re-orientation:

> >> < <<: > &> 2&> 2<>>& >&2

Here is a description of the meaning and usage of these special symbols ...

# pound (comments)
It's almost a symbol of the full field.
#!/bin/bash
The pound sign also often appears at the beginning of a line, or after the complete instruction, which indicates that the symbol is followed by the annotation text and will not be executed.
# This is comments.
echo "a = $a" # a = 0
Because of this feature, when you temporarily do not want to execute a line of instruction, simply add # at the beginning of the line. This is often used in the writing process.
#echo "a = $a" # a = 0
If used in a directive, or surrounded by double quotation marks, or behind a slash, then he becomes a general symbol without the special function described above.

~ Account's Home directory
is a common symbol, representing the user's home directory: cd ~; You can also add the name of an account directly after the symbol: CD ~user
Or as a part of the path: ~/bin;~+ Current working directory, this symbol represents the current working directory, she and the built-in command pwd function is the same.
# echo ~+/var/log
~-Last working directory, this symbol represents the last working directory.
# echo ~-/etc/httpd/logs

; Semicolon (Command separator)
In the shell, the symbol that functions as a "continuous instruction" is the semicolon. such as the following example: CD ~/backup; mkdir startup; CP ~/.* startup/.

;; Continuous semicolon (Terminator)
Dedicated in case options, assume the role of Terminator.
Case "$FOP" Inhelp) echo "usage:command-help-version filename";; Version) echo "version 0.1″;; Esac

. Period (dot)
In the shell, the user should be aware that a dot represents the current directory, and two dots represent the upper-level directory.
Cdpath=.:~:/home:/home/web:/var:/usr/local
In the upstream Cdpath setting, the dot after the equals sign represents the meaning of the current directory.
If the file name starts with Dot, the file is a special file, and the LS command must be added with the-a option to display. In addition, in regular expression, a dot represents a match to a character.

' String ' single quotation mark (quote)
The enclosed quotation marks are treated as a single string. The $ sign that represents the variable within the quotation marks does not work, that is, he is treated as a general symbol and prevents any variable substitution.
Heyyou=homeecho ' $heyyou ' # We get $heyyou

"string" double quotation mark (doubles quote)
The content enclosed in double quotes is treated as a single string. It prevents wildcard expansion, but allows variable expansion. This is different from the way a single argument is handled.
Heyyou=homeecho "$heyyou" # We get Home
' Command ' inverted quotation marks (backticks)
In the preceding single double quotation mark, enclose the string, but what if the string is a list of command columns? The answer is no execution. To deal with this situation, we have to use a single quotation mark.
fdv= ' Date +%f ' echo "Today $FDV"
The date +%f in the inverted quotation marks is treated as an instruction, and the result of execution is taken into the FDV variable.

, comma (comma)
This symbol is often used in operations as a "partition" use. The following example
#!/bin/bashlet "T1 = ((A = 5 + 3, B = 7–1, c = 15/3))" echo "T1 = $t 1, a = $a, B = $b"

/slash (forward slash)
Represents the directory when the path is represented.
CD/ETC/RC.DCD. /.. CD/
Usually single/represents the root root directory meaning; in arithmetic, a symbol representing division.
Let "NUM1 = ((a = 10/2, B = 25/5))"

\ inverted slash (escape)
The escape character in interactive mode has several functions; before the instruction, there is the function of canceling the aliases, and before the special symbol, the function of the special symbol disappears; placed at the very end of the instruction, indicating that the command joins the next line.
# type RM
RM is aliased to ' rm-i '
# \RM. \*.log
In the example above, I add the escape character to the RM directive, which is the function of temporarily canceling the alias and restoring the RM instruction.
# Bkdir=/home
# echo "Backup dir, \ $bkdir = $bkdir"
Backup dir, $bkdir =/Home
In the above example, the \ $bkdir in echo, Escape will be the function of the $ variable is canceled, therefore, the output $bkdir, and the second $bkdir will output the contents of the variable/home.

| Pipe (Pipeline)
Pipeline is a basic and important concept of UNIX systems. Connect the standard output of the previous command as the standard input for the next instruction.
W.H.O. | Wc-l
The use of this concept is very helpful in streamlining script.

! Exclamation point (negate or reverse)
Usually it represents the function of anti-logic, such as conditional detection, in! = to represent "not equal"
If ["$?"! = 0]thenecho "executes error" Exit 1fi
She acts as a "counter-logical" role in regular expressions.
LS A[!0-9]
In the example above, the representative shows other files except A0, A1 ... A9 these several files.

: Colon
In bash, this is a built-in directive: "Nothing is done", but returns the status value of 0.
:
echo $? # response is 0
: > f.$$
The above line, equivalent to Cat/dev/null > f.$$. Not only is the writing brief, but also the implementation of a lot of efficiency.
Sometimes, the following uses of this kind are also present
: ${hostname?} ${user?} ${mail?}
The purpose of this line is to check if these environment variables are set and the error messages will be displayed with standard errors if they are not set. Such checks, like test or if, can basically be dealt with, but not as simple and efficient as the example above.
In addition to the above, there is a place where you must use a colon
Path= $PATH: $HOME/fbin: $HOME/fperl:/usr/local/mozilla
In the user's own home directory, in the. bash_profile or any feature-like file, set the "path" for the occasion, we use colons to do the partition.

? Question mark (wild card)
The role played on the filename extension (filename expansion) is to match an arbitrary character, but does not contain a null character.
# ls A?A1
Make use of her characteristics, you can do more accurate file name matching.

* asterisk (wild card)
A fairly common symbol. On the file name extension (filename expansion), she is used to represent any character, including the null character.
# ls a*a A1 Access_log
It represents "multiplication" when it is being operated on.
Let "Fmult=2*3″
In addition to the built-in instruction let, there is also an instruction expr about the operation, where the asterisk also acts as the "multiplication" role. But be careful in use, he must precede the escape character.

* * Sub-square operation
Two asterisks represent the meaning of the "sub-square" during operation.
Let "sus=2**3″echo" sus = $sus "# sus = 8

$ money (dollar sign)
variable substitution (Variable Substitution).
Vrs=123echo "VRS = $vrs" # VRS = 123
In addition, the Regular Expressions is defined as the end of the line (End-of-line). This is commonly used in grep, SED, awk, and Vim (vi).

The regular expression
bash for the

${} variable defines a number of usages for ${}. The following is a table column taken from the online description
${parameter:-word} ${parameter:=word} ${parameter:?word} ${parameter:+word} ${parameter:offset} ${ Parameter:offset:length} ${!prefix*} ${#parameter} ${parameter#word} ${parameter# #word} ${parameter%word} ${ Parameter%%word} ${parameter/pattern/string} ${parameter//pattern/string}

$* references the execution reference variable of the script, The algorithm that references the parameter is the same as the general instruction, the instruction itself is 0, followed by 1, and so on. The reference variable is represented as follows:
$ $, $ $, $ $, $ $4, $ $6, $7, $8, $9, ${10}, ${11} ...
Single digit, you can use the number directly, but more than two digits, you must use the {} symbol to enclose. The
$* is the symbol that represents all reference variables. When used, you have to add double quotes as appropriate.
echo "$*"
also has a symbol that has the same effect as $*, but with a slightly different effect from the way it is handled.

[email protected]
[email protected] has the same symbolic effect as $*, but they have a different point. The
Symbol $* treats all reference variables as a whole. However, the symbol [email protected] still retains the concept of the section of each reference variable.
$#
This is also the symbol associated with the reference variable, and her role is to tell you how much the total number of reference variables is.
echo "$#"

$? state value (status variable)
Generally speaking, the process of a UNIX (Linux) system ends with the execution of a system call exit (). This callback value is the status value. Passed back to the parent process to check the execution status of the child process.
General Instruction If the execution succeeds, its callback value is 0; the failure is 1.
Tar cvfz dfbackup.tar.gz/home/user >/dev/nullecho "$?" $$
Because the ID of a process is unique, it is not possible to have a repetitive PID at the same time. Sometimes, script will need to generate temporary files to hold the necessary information. This script may also be used by users at the same time. In this case, the fixed file name is not reliable in the notation. Only a dynamic file name can be generated to meet the needs. Symbolic $$ may be able to meet this requirement. It represents the PID of the current shell.
Echo $HOSTNAME, $USER, $MAIL > ftmp.$$
uses it as part of the file name to avoid overwriting the same file name at the same time.
PS: Basically, the system will recycle the completed PID and then allocate it again as needed. So script even if the temporary file is written using a dynamic file name, there are other problems if the script is not cleared after execution. The
() command group
encloses a sequence of consecutive instructions in parentheses, which is called a command group for the shell. As the following example: (CD ~; vcgh= ' pwd '; echo $vcgh), the instruction group has an attribute, and the shell executes the set of instructions in order to generate Subshell. Therefore, the variables defined therein are used only for the instruction group itself. Let's take a look at the example
# cat Ftmp-01#!/bin/basha=fsh (A=INCG; echo-e "/n $a/n") echo $a #./FTMP-01INCGFSH
In addition to the preceding instruction group, parentheses are used in the array variable As well as other occasions where you might need to add escape characters, such as an expression.

(())
This set of symbols acts like a let directive, and is used in arithmetic operations as a built-in feature of Bash. Therefore, it is much better to perform efficiently than to use the Let command.
#!/bin/bash ((a = ten)) echo-e "inital value, a = $a/n" ((a++)) echo "After a++, a = $a"

{} curly braces (Block of code)
Sometimes the script appears, and the curly braces hold a paragraph or paragraphs of instructions or variable settings that end with a "semicolon".
# cat FTMP-02#!/BIN/BASHA=FSH{A=INBC; ECHO-E "/n $a/n"}echo $a #./FTMP-02INBCINBC
This usage is very similar to the instruction group described above, but with a different point, It executes in the current shell and does not produce subshell. The
curly braces are also applied to functions of the function. Broadly speaking, simply using curly braces acts like a function that does not have a specified name. So writing script like this is a pretty good thing. This approach, especially for output input redirection, streamlines the complexity of the script.
In addition, the curly braces have another use, as follows
{Xx,yy,zz,...}
This combination of curly braces, commonly used in the combination of strings, see an example
mkdir {usera,userb,userc}-{home,bin,data}
We get Usera-home, Usera-bin, Usera-data, Userb-home, Userb-bin, Userb-data, Userc-home, Userc-bin, Userc-data, these few directories. This set of symbols is quite extensive in applicability. If we can make good use of it, the payoff is streamlining and efficiency. Like the following example
Chown Root/usr/{ucb/{ex,edit},lib/{ex?.? *,HOW_EX}}
If it is not for the support of this usage, we have to write a few lines to repeat several times!

[] Brackets
Often appear in the process control, play the role of the surrounding judgment. If ["$?"! = 0]thenecho "executes error" Exit 1fi
This symbol acts like a "scope" or "set" in a regular expression
Rm-r 200[1234]
The above example, represents the deletion of 2001, 2002, 2003, 2004 and so on the meaning of the directory.

[[]]
This set of symbols is basically the same as the previous [] symbol, but she allows it to be used directly in it | | and && logic and other symbols.
#!/bin/bashread Akif [[$ak > 5 | | $ak < 9]]thenecho $AKFI | | Logical symbols This is often seen, representing the or logical symbols. && logical Symbols This is also often seen, representing and logical symbols. & Background Work order A & symbol, placed at the end of the complete instruction column, means that the instruction column is put into the background to work. Tar cvfz data.tar.gz data >/dev/null &
/Word boundaries
This set of symbols is defined as the meaning of "boundary" in the regular expression. For example, when we want to find the word, if we use
grep the FileA
You will find that words such as there are also considered to be matching words. Because the coincidence is part of the there. If we want to avoid this, we have to add the "border" symbol.
grep '/' FileA

+ PLUS sign (plus)
In an expression, she is used to denote "addition".
Expr 1 + 2 + 3
Also in the rule expression, the meaning of the front character used to denote "many".
# grep ' 10/+9′fileb109100910000910000931010009# This symbol must be preceded by escape characters when used.

-Minus (dash)
In an expression, she is used to denote "subtraction."
Expr 10–2
It is also an option symbol for system directives.
ls-expr 10–2
In the GNU directive, if the-symbol is used alone, the meaning of "standard input" is represented by the addition of any file name. This is a common option for the GNU directive. such as the following example
Tar XPVF-
Here – the symbol, which represents both reading data from the standard input.
However, in the CD instructions are more special
CD-
This represents changing the working directory to the "last" working directory.

% Division (Modulo)
In an expression, it is used to denote "division".
Expr 10% 2
In addition, the following are used in the regular expressions about variables
${parameter%word}${parameter%%word}
A% represents the shortest word match, and both represent the longest word match.

= Equals (equals)
A symbol that is often seen when a variable is set.
Vara=123echo "Vara = $vara"
Or it is like the setting of PATH, even applied to such uses as arithmetic or judgment.

= = equals (equals)
Often seen in conditional judgments, representing the meaning of "equals".
if [$vara = = $varb]
... Slightly lower
! = does not equal
Often seen in conditional judgments, representing "not equal" meaning.
if [$vara! = $varb]
... Slightly lower

^
This symbol represents the "start" position of the line in the regular expression.

Special symbols in the shell