Aesthetics and Philosophy in Linux Bash script programming language

I confess that I once again became the title party. But admittedly, this must be an essential essay. In this article, I'll explore the aesthetics and philosophy of the Bash scripting language. This is not a tutorial for bash scripting, but it gives you a more in-depth look at Bash scripting programming and faster learning of bash scripting. Reading this essay does not require you to have experience with bash programming, but be as passionate about exploring the nature of programming languages as I do, and feeling their charms.

I wanted to write something about bash long ago. We usually like to classify programming languages, such as process-oriented programming languages, object-oriented programming languages, functional programming languages, and so on. In my mind, I think bash is a string-oriented programming language. The nature of the Bash scripting language: Everything is a string. All the philosophies of the Bash scripting language revolve around strings: Where do they come from? Where to? What is the mission? All the aesthetics of the Bash scripting language originate from strings: almost all the symbols on the keyboard "$ ~!" # & () [] {} | > <-. , ; * @ ' ' \ ^ ' is a combination of very visually appealing, extremely complex strings.

Linux Bash Shell Getting Started tutorial http://www.linuxidc.com/Linux/2013-08/8848.htm

First, everything is a string

Bash is a Shell,shell the original intention is to glue the various tools in the system together, so its most fundamental function is to invoke various commands. But Bash also offers rich programming features. We often classify programming languages, such as process-oriented languages, object-oriented languages, function-oriented languages, and so on. You can think of the Bash scripting language as a string-oriented language. The essence of the Bash language is that everything is a string. Look at the variables in these:

Is some of the demos I did in the Interactive Bash command line. In, I assign a value to the variable, whether the right side of the equal sign is a string without quotation marks, a string with quotation marks, or even a number, or a mathematical expression, the final result is that the variables are stored in strings. I use a For loop to show all the variables, and I can see that the mathematical expression is stored as a string and is not evaluated.

Two, references and metacharacters

If everything is a trivial string with no special features, it cannot form a programming language. In bash, there are a number of symbols with special meanings, such as the "$" symbol being used for string expansion, and the "&" symbol for the command to execute in the background, "|" Use as a pipe, > < for input and output redirection, and so on. So in bash, although it's also a string, the quoted string is not the same as the string enclosed by quotation marks, and the string enclosed in quotation marks is not the same as the string surrounded by double quotes.

What is the difference between a quoted string and a string without a quoted number? Are some of the more typical examples I've built:

In, I showed 7 ways to generate a string in bash: Curly brace expansion, tilde expansion, parameter expansion, command substitution, arithmetic expansion, word segmentation, and file path expansion. There are also two ways to generate strings that are not spoken (Process substitution and History commands are expanded). When you're programming with bash scripting, it's enough to understand how the 7 types of strings are generated. When you use the Bash command line interactively, you also need to know the history command to expand, skilled use of the history of command deployment can make people more effective.

As you can see in the above picture, there are some unwinding methods that are not working in a string surrounded by double quotes, such as curly brace expansion, tilde expansion, word segmentation, and file path expansion, but only parameter expansion, command substitution, and arithmetic expansion work. As you can see from the picture, parameter expansion, command substitution, and arithmetic expansion in a string are guided by the "$" symbol, and command substitution can also be guided by "'". Therefore, it can be further summed up that in a string surrounded by double quotes, only the "$, ', \" Three characters have special meanings.

If you want any one character to have no special meaning, enclose the string in single quotation marks. For example, when using regular expressions, such as when using tools such as SED or awk, the commands of SED and awk tend to be surrounded by single quotes because they often contain many special characters. For example, using the awk command to display the user name and full name of each user in the/etc/passwd file, you can use this command awk-e ' {print$ 1, $5} ', where the command passed to Awk is surrounded by single quotes, stating that bash does not perform any substitution or expansion.

Another special character is "\", which is also a reference. It can remove the special meaning (reference) of a special character immediately following it. The need for "\" exists because in bash, some characters are called metacharacters, and once they occur, a string is split into multiple substrings. If you need to include these metacharacters in a string, you must refer to them. Such as:

The most common meta characters are spaces. As can be seen from the above pictures, if you want to assign a string containing a space to a variable, either enclose the string in double quotation marks, or use "\" to reference the space. As you can see, there are only 9 metacharacters in bash, each of which is "| & (); < > Space tab ", while in other programming languages often appear metacharacters". {} [] "and subtraction as a mathematical operation, are not metacharacters in bash.

Three, where does the string come from, where to go

After describing the string, describing the references and metacharacters, the next goal is to explore the philosophical question: Where does the string come from and where to go? Through the discussion of this philosophical question, we can deduce the whole syntax of the Bash scripting language. Where does the string come from? Obviously, one of the very direct sources is that we knocked on the keyboard. In addition, the 789 kinds of string expansion methods I mentioned earlier.

The process of string expansion is as follows:

1. First use the meta-character to divide a string into substrings;

2. If the string is used to assign a value to a variable, it is considered to be surrounded by double quotes, regardless of whether it is surrounded by double quotes;

3. If the string is not enclosed in quotation marks and double quotes, the curly brace expands, and the {a,b}c expands to AB AC;

The above three processes can be proven by:

4. If the string is not enclosed in quotation marks or double quotes, the tilde is expanded, the ~/is expanded to the user's home directory, ~+/is expanded to the current working directory (PWD), ~-/is expanded to the previous working directory (OLDPWD);

5. If the string is not enclosed in quotation marks, the arguments and variables are expanded; This type of expansion begins with " $ ", which is the most complex of the entire bash string expansion, including user-defined variables, including all environment variables, both of which are "  $  "followed by variable name, also includes position variable"  $ 1,  $ 2, ...,  $ 9, ... ", other special variables:"  $ @,  $ *,  $ #,  $ -,  $ !,  $ 0,  $ &NBSP,?,  $ _ ", even the array:"  $ {var[i]} ", you can also perform various complex operations on strings during the unfolding process, such as:"  $ {parameter:- Word},  ${parameter:=word},  $ {parameter:+word},;  $ {parameter:?word},  $ { Parameter:offset},  ${parameter:offset:length},  $ {!prefix*},  $ {[email protected ]},  $ {name[@]},  $ {!name[*]},  $ {#parameter},  ${parameter#word},  $  {parameter# #word},  $ {parameter%word},  $ {parameter%%word},  ${parameter/pattern /string},  $ {parameter^pattern},  $ {parameter^^pattern},  $ {parameter,pattern},  ${parameter,,pattern} ";

6. If the string is not enclosed in quotation marks, the command substitution is made, and the command substitution has two formats, one is $ (...), the other is ' ... '; that is, the output of the command as the content of the string;

7. If the string is not enclosed in quotation marks, the arithmetic expansion is performed, and the format of the arithmetic expansion is $ (...). ；

8. If the string is not enclosed in quotation marks or double quotes, the word is split;

9. If the string is not enclosed in quotation marks or double quotation marks, the file path is expanded;

10. When the above process is complete, the quotation marks (if any) outside the string are finally removed. The above process is done only once in the order above. For example, you do not expand the curly brace after the variable is expanded, and do not perform any of the preceding steps after the 10th step of removing the reference. If you need to go through the process again, please use Eval.

After discussing where the string came from, let's see where the string goes. That is how to use these strings. There are several ways to use the string:

1. Take it as a command execution; This is the most fundamental use of bash, after all, the shell exists to glue the various commands. If a string appears where the command should appear (such as at the beginning of a line, or after the keyword then, do, etc.), it will be executed as a command, and if it is not a valid command, it will be an error;

2. Take it as an expression; there is no expression in bash, but there is ((...)) and [[...]], there is an expression; ((...)) You can think of the string in it as an arithmetic expression, and [[...]] It will take the string inside it as a logical expression, only these two special cases;

3. Assigning a value to a variable; this is also a special case that undermines the integrity of the syntax philosophy of the Bash programming language. Why do you say that? Because "=" is not a meta-character, there are no spaces on either side, and only the 1th equals sign is treated as an assignment operator.

The following image gives evidence for the above view:

• This article is from: Linux Learning Network

Aesthetics and Philosophy in Linux Bash script programming language