Environment variables and file lookups

Environment variables and file lookups Experiment Introduction

This section of the experiment introduces the role and usage of environment variables, and several methods of searching files. Learn these techniques to use Linux efficiently.

I. Environment variables 1. Variables

To explain the environment variables, you have to understand what the variables are, and exactly what they should be, the so-called variables are symbols that are used in a computer to record a value (not necessarily a numeric or a character or a string), and these symbols will be used in different arithmetic processing. Usually a variable is a one-to-many relationship with a value, you can assign a value to another variable by reading its value, or you can assign a value to any variable directly. For ease of operation and processing, most programming languages distinguish between the types of variables used to record data types, such as numeric values, characters, or strings. The variables in the Shell are basically the same, there are different types (but not specifically specifying the type name), you can participate in the operation, scoped.

The scope of a variable is the valid range of a variable (such as a function, a source file, or a global scope), where there can be only one variable with the same name. Once left, the variable is invalid, as if the variable does not exist in general.

How to create a variable in the Shell, how to assign a value to a variable, and how to read the value of a variable? This section is described in detail in the Bash scripting lesson, where I'll give you a quick example:

Use declare the command to create a variable named tmp:

declare tmp

In fact, you can also use the declare to pre-declare a variable, which is created directly, just to tell you the role of declare, which is used when creating other variables of the specified type (such as an array).

Use = the number assignment operator to assign a value of Shiyanlou to the variable tmp:

$ tmp=shiyanlou

Read the value of a variable, using echo commands and $ symbols (the $ symbol is used to denote a value that refers to a variable, and beginners often forget to enter it):

echo $tmp

Note: For variable names, not all variable names are available, the variable name can only be English letters, numbers, or underscores, and cannot begin with a number.

2. Environment variables

Simple understanding of the concept of variables, it is very good to explain the environment variables, environment variables are scoped than the custom variable, such as the shell environment variables acting on itself and its child process. In all Unix and Unix-like systems, each process has its own set of environment variables, and by default, when a process is created, it is explicitly specified in the process creation, and it inherits most of the environment settings of its parent process. The shell program also runs on the operating system as a process, and most of the commands we run in the shell will run as a child process of the shell.

There are three types of environment variables that we will typically relate to:

• The current shell process private user-defined variables, such as the TEMP variable we created above, are only valid in the current shell.
• The built-in variables of the Shell itself.
• An environment variable exported from a custom variable.

There are also three commands related to the above three environment variables,, set , env export . These three commands are similar and can be used to print related environment variables, except that they are related to different ranges of environment variables, as described in the following table:

Command	Description
set	Displays all environment variables for the current shell, including built-in environment variables (related to shell appearance, etc.), user-defined variables, and exported environment variables
env	Displays the environment variables that are relevant to the current user, and lets the command run in the specified environment
export	Displays variables that are exported from the Shell to an environment variable, and can also be exported to a custom variable as an environment variable

You can use the tools more intuitively to vimdiff compare the differences between them:

export temp_env=shiyanlou$ env|sort>env.txt$ export|sort>export.txt$ set|sort>set.txt

The above operation sorts the command output by using a pipe | sort command and then redirects to the object text file.

export.txt set.txt

Use vimdiff the tool to compare the contents of several exported files.

As for environment variables, it can be easily understood that the child processes in the current process are valid and valid as environment variables, otherwise (some people also refer to all variables collectively as environment variables, just to differentiate between global environment variables and local environment variables, so long as we understand their real differences). Let's take export a look at the command here, first set a variable in the shell temp=shiyanlou , and then create a new child shell to see temp the value of the variable:

Note: In order to differentiate from normal variables, it is often customary to set the environment variable name to uppercase

3. Search path and order of commands

You might have had a long question about it, and we entered a command in the shell, how did the shell know where to find the command and execute it? This is done through environment variables PATH , and users who are familiar with Windows may know that there is a PATH environment variable in Windows. This PATH saves the search path to the command executed in the shell.

PATHto view the contents of an environment variable:

echo $PATH

By default you will see the following output:

/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games

If you remember what we did in the Linux directory structure section, you should know what kind of files are being relegated to these directories. Usually this kind of directory is the executable file, when we execute a command in the Shell, the system will follow the path set in the order of the paths to the directory to find, if there is a command with the same name, then the first to find the one.

Below we will practice creating one of the simplest executable Shell scripts and a "Hello World" program created using the C language, if you have not studied these two parts before, then you can do an introductory study: C Language Primer Advanced Bash Scripting Programming Guide Linux Shel L Scripting Tutorial (LSST) v2.0

Create a Shell script file:

$ vim hello_shell.sh

Add the following in the script, save and exit ( Note that the first line is not omitted, this is not a comment, the forum has a user response to a syntax error, because there is no first line ):

#!/bin/zshfor ((i=0; i<10; i++));do echo "hello shell"doneexit 0

To add executable permissions to a file:

chmod 755 hello_shell.sh

Execute script

$ ./hello_shell.sh

Create a C language "Hello World" program:

$ vim hello_world.c

#include <stdio.h>int main(void){ printf("hello world!\n"); return 0;}

To generate an executable file using gcc:

$ gcc -o hello_world hello_world.c

GCC-generated binaries have executable permissions by default and do not need to be modified

Create a directory in the Shiyanlou home directory mybin and move the above hello_shell.sh and Hello_world files to it:

$ mkdir mybin$ mv hello_shell.sh hello_world mybin/

Now you can mybin run each of the two programs you just created in the directory:

$ cd mybin$ ./hello_shell.sh$ ./hello_world

Back to the top level of the directory, that is, the shiyanlou home directory, when you want to run the two programs, you will find the prompt command can not be found, unless the full path of the command, but it is inconvenient, how do you want to use the same system command to execute the script file or program you created? Then add the path to the environment variable that contains the command PATH .

4. Add a custom path to the "path" environment variable

In the front we should notice that PATH the path inside is ： as a delimiter, so we can add a custom path like this:

$ PATH=$PATH:/home/shiyanlou/mybin

Note that absolute paths must be used here

Now you can execute those two commands in any other directory. You may realize that this is not a good solution, because I have added a path to the PATH environment variable, it is only valid in the current Shell, once I exit the terminal, and then open it will be found to fail. Is there a way to make the added environment variable globally valid? Or do you automatically execute the commands above to add a custom path to path each time you start the Shell? So let's talk about the latter way--let it execute automatically.

In each user's home directory, there is a Shell that executes a configuration script by default each time it starts to initialize the environment, including adding some user-defined environment variables, and so on. Zsh profile is, the .zshrc corresponding Bash configuration file is .bashrc . They etc also have one or more global profiles, but generally we only modify the configuration files in the user directory.

We can simply use the following command to add content directly to the .zshrc :

$ echo "PATH=$PATH:/home/shiyanlou/mybin" >> .zshrc

The above command >> indicates that the standard output is redirected to a file in an append manner, noting that the previous use is to redirect to > a file in a way that is overwritten and must be distinguished when used. A new file will be created if the specified file does not exist.

5. Modifying and deleting existing variable variables

There are several ways to modify variables:

How variables are set	Description
${变量名#匹配字串}	Start the match from the back to delete the shortest data matching the matched string
${变量名##匹配字串}	Start the match from the back to delete the longest data matching the matched string
${变量名%匹配字串}	Match from tail forward to delete the shortest data matching string
${变量名%%匹配字串}	Match from tail forward to delete maximum data matching string
${变量名/旧的字串/新的字串}	Replace the first string that matches the old string with a new string
${变量名//旧的字串/新的字串}	Replace all strings that match the old string with a new string

For example, modify the environment variables we added to PATH earlier. In order to avoid errors that result in the command not being found, we first assign the path to a new custom variable path:

$ path=$PATH$ echo $path$ path=${path%/home/shiyanlou/mybin}# 或使用通配符,*表示任意多个任意字符$ path=${path%*/mybin}

Variable deletion

You can use the unset command to delete an environment variable:

unset temp

6. How to make environment variables effective immediately

After we have modified a configuration script file in the Shell (for example, in the home directory of the zsh configuration file .zshrc ), we have to exit the terminal to reopen or even restart the host computer before it can take effect, it is troublesome, we can use the source command to let it take effect immediately, such as:

source .zshrc

sourceThe command also has an alias, which is to note that the . Point area that represents the current path is separate, albeit in the same form, but in the same way that the above command, if replaced, . is

$ . ./.zshrc

Note that the first point is followed by a space, and the subsequent file must specify the complete absolute or relative pathname, which is not required by source.

Second, search documents

Search-related commands are commonly used in the following sections,,, whereis which find locate .

• whereisSimple and fast

$whereis who

You'll see that it finds three paths, two executable paths, and a path to a man's online Help file, and this search is quick because it's not looking from the hard drive, it's querying directly from the database. whereisonly Binary (-B), man Help file (-m), and source code file (-s) can be searched. You can use the command if you want to get a more comprehensive search result locate .

• locateFast and full

Through the "/var/lib/mlocate/mlocate.db" Database lookup, but this database is not updated in real-time, the system will use scheduled tasks to automatically perform the updatedb command update once a day, so sometimes you just add the file, it may not be found, you need to do it manually updatedbcommand (This command must be executed first in our environment). It can be used to find different file types under the specified directory, such as finding all files that start with SH under/etc:

$ locate /etc/sh

Note that it is not just looking in the ETC directory and will automatically recursively look up subdirectories

Find all JPG files under/usr/share/:

/usr/share/\*.jpg

Notice that you want to escape the backslash * before adding the number, otherwise you will not find

If you want only the number of statistics can be added -c parameters, -i parameters can be ignored case to find, Whereis, the -b -m -s same can be used.

• whichSmall and fine

whichitself is a shell built-in command that we typically use which to determine if a specified software is installed because it only PATH searches for the command from the path specified by the environment variable:

which man

• findFine and Thin

findShould be the most powerful of these commands, not only can be found by file type, file name and can be based on the properties of the file (such as the file's timestamp, file permissions, etc.) to search. The find command is strong, to make it clear that you need at least a few separate lessons, and we'll just cover some of the things we use most often.

Search for files of the specified file name under the specified directory:

/etc/ -name interfaces

Note the path to the Find command is the first parameter, and the basic command format is find [path] [option] [action]

Time-related command parameters:

Parameters	Description
-atime	Last Access time
-ctime	Creation time
-mtime	Last Modified Time

The following are -mtime examples of parameters:

• -mtime n: N is a number, expressed as a modified file "within one day" before N days
• -mtime +n: Lists files that have been modified before n days (not including the N-day itself)
• -mtime -n: Lists files that have been modified before n days (containing the N-day itself)
• newer file: File is an existing document, listing the new file name

List files in the home directory that have changed in the day (within 24 hours):

$ find ~ -mtime 0

List the new files in the user home directory than the code folder:

$ find ~ -newer /home/shiyanlou/Code

Homework

The "Digital Rain" in the "Matrix" movie full of screen code, you can easily achieve this effect in Linux, you only need a command cmatrix .

Need to be installed first, because Ubuntu is not preinstalled:

update;sudo apt-get install cmatrix

Installed after the first do not rush to implement, in order to see better results, we need to modify the theme of the terminal color, modified to black green, the method of change see:

Then press F11 to display in full screen.

Special Note:

Environment variables and file lookups