Linux

Shell

What is Shell

Shell is a command line interpreter that receives application/user commands and then calls the operating system kernel

Shell is a program written in C language, it is a bridge for users to use Linux

Shell is also a programming language with very powerful functions, easy to write, easy to debug, and strong flexibility.

Shell programming is the same as java and php programming. It only takes a text editor that can write code and a script interpreter that can explain execution.

getting Started

There are many types of Linux shells, common ones include: cat /etc/shells

Bash is widely used in daily work due to its ease of use and free. At the same time, Bash is also the default shell for most Linux systems.

echo $SHELL

Output default shell

The script starts with #!/bin/bash (specify the parser)

Case

vim enters the following content in

 #!/bin/bash
 echo "helloworld"

"#!" is a conventional tag that tells the system what interpreter is needed to execute this script, that is, which shell is used

Common execution methods of scripts

The first type: adopt the relative or absolute path of bash or sh+ script (no need to give script +x permissions)

(1) The relative path of the sh+ script. sh ./

helloworld

(2) The absolute path of the sh+ script. sh /home/atguigu/

helloworld

(3) The relative path of bash+ script. bash ./

helloworld

(4) The absolute path of bash+ script. bash /home/atguigu/

helloworld

Note that you must write it as ./ instead of running other binary programs. Write it directly. The Linux system will search for any of the called . However, only /bin, /sbin, /usr/bin, /usr/sbin, etc. in PATH. Your current directory is usually not in PATH, so you will not be able to find the command when writing it. You should use ./ to tell the system that you are looking for it in the current directory.

The second type: execute the script using the absolute or relative path of the input script (must have executable permission + x)

(1) First, you must give the script +x permission chmod +x

(2) Execute the script

① Relative path. ./

helloworld

② Absolute path. /home/atguigu/

helloworld

Note: The first execution method is essentially the bash parser helps you execute scripts, so the script itself does not require execution permissions.

The second execution method is essentially that the script needs to be executed by itself, so it requires execution permissions.

variable

Syntax: $ variable name

There cannot be spaces between $ and variable names.

echo $HOME View the value of the system variable

Show all variables in the current shell env/set

Custom variables

grammar

(1) Define variables: variable name = variable value, note that there cannot be spaces before and after the = sign.

(2) Undo variable: unset variable name.

(3) Declare static variables: readonly variables, note: cannot be unset.

Define rules

(1) Variable names can be composed of letters, numbers and underscores, but they cannot start with numbers.Environmental variable name suggests capitalization。

(2) There cannot be spaces on both sides of the equal sign.

(3) In bash, the default types of variables are all string types, and numerical operations cannot be performed directly.

(4) If the value of a variable has spaces, it needs to be enclosed in double quotes or single quotes.

Case practice

1 Define variable A

A=5

echo $A

2 Reassign A

A=8

echo $A

3 Undo variable A

unset A

4 Declare static variable B

readonly B=2

echo $B

If the settings are done, it cannot be modified

5 In bash, the default types of variables are all string types, and numerical operations cannot be performed directly.

C=1+2

echo $C

6 If the value of a variable has spaces, it needs to be enclosed in double quotes or single quotes.

D="I love banzhang"

echo $D

7. Variables can be promoted to global environment variables

export B

Add echo $B to

Print Out

Special variables

(Function description: n is a number, $0 represents the name of the script, $1-$9 represents the first to ninth parameters, and parameters above ten need to be included in braces, such as ${10}.)

Case practice

vim

#!/bin/bash 
echo '==========$n==========' 
echo $0 
echo $1 
echo $2

chmod 777

 ./ cls xz 
 ==========$n========== 
./parameter
.sh
 cls

(Function description: Get the number of all input parameters, which is often used for loops, and determine whether the number of parameters is correct)

Add $# after the above

$*$@

$* (Function description: This variable represents all parameters in the command line, and $* treats all parameters as a whole.)

$@ (Function description: This variable also represents all parameters in the command line, but $@ treats each parameter differently.)

Add $*$@ after the above

echo $* $@

The difference between $* and $@ needs to be combined with loop explanation

Similarities: All references are all parameters.
 Difference: Only reflected in double quotes.  Assuming that three parameters 1, 2, 3 are written when the script is running, then " * " is equivalent to "1 2 3" (passed one parameter), and "@" is equivalent to "1" "2" "3" (passed three parameters)

(Function description: The return status of the last executed command. If the value of this variable is 0, it proves that the previous command was executed correctly; if the value of this variable is non-0 (which number is determined by the command itself), it proves that the previous command was executed incorrectly.)

Execute the above script

Enter echo $? to determine whether the script is executed correctly

atguigu@ubuntu:~$ ./
hello world
atguigu@ubuntu:~$ echo $?
0

Operators

Shell, like other programming languages, supports a variety of operators, including:

Arithmetic operator
Relational operators
Boolean operators
String operators
File test operator

Basic syntax

test condition

[ condition ] (Note that there must be spaces before and after condition)

Note: The condition is either empty, if true, [ atguigu ] returns true, [ ] returns false.

There are two: 1 is used to test with test. 2 is used to test with [ ]. There is no result value returned. Need to enter $? Let's see if the result is correct.

1 Arithmetic operator

The following table lists commonly used arithmetic operators, assuming that the variable a is 10 and the variable b is 20:

Operators	illustrate	Give an example
+	addition	`expr $a + $b`The result is 30.
-	Subtraction	`expr $a - $b`The result is -10.
*	multiplication	`expr $a \* $b`The result is 200.
/	division	`expr $b / $a`The result is 2.
%	Take the rest	`expr $b % $a`The result is 0.
=	Assignment	a=$b will assign the value of variable b to a.
==	equal. Used to compare two numbers, return true if the same.	[ $a == $b ] returns false.
!=	Not equal. Used to compare two numbers, return true if not the same.	[ $a != $b ] returns true.

Note: Conditional expressions should be placed between square brackets and spaces. For example: [$a==$b] is wrong and must be written as [$a == $b].

The multiplication sign (*) must be preceded by the backslash () to achieve multiplication operation

"$((operational equation))" or "$[operational equation]"
 1) Calculate the value of (2+3)*4
 (1)$[]
 atguigu@ubuntu:~$ S=$[(2+3)*4]
 atguigu@ubuntu:~$ echo $S
 (2)$(())
 atguigu@ubuntu:~$ unset S
 atguigu@ubuntu:~$ S=$(((2+3)*4))
 atguigu@ubuntu:~$ echo $S
 20

2 Relational operators

Relational operators only support numbers and do not support strings unless the value of the string is a number.

The following table lists commonly used relational operators, assuming that variable a is 10 and variable b is 20:

Operators	illustrate	Give an example
-eq	Detect whether two numbers are equal, equal returns true.	[ $a -eq $b ] returns false.
-ne	Detect whether two numbers are not equal, and return true.	[ $a -ne $b ] returns true.
-gt	Detects whether the number on the left is greater than the one on the right, and if so, returns true.	[ $a -gt $b ] returns false.
-lt	Detects whether the number on the left is smaller than the one on the right, and if so, returns true.	[ $a -lt $b ] returns true.
-ge	Detect whether the number on the left is greater than or equal to the one on the right, and if so, return true.	[ $a -ge $b ] returns false.
-le	Detects whether the number on the left is less than or equal to the one on the right, and if so, returns true.	[ $a -le $b ] returns true.

(1) Determine whether 23 is greater than or equal to 22
 1 test
  test 23 -ge 22
  echo $? 0
 2 [ condition ]
    [ 23 -ge 22 ]
    echo $?
    0

3 Boolean operators

The following table lists commonly used Boolean operators, assuming that the variable a is 10 and the variable b is 20:

Operators	illustrate	Give an example
!	Non-operation, if the expression is true, false will be returned, otherwise true will be returned.	[ ! false ] returns true.
-o	Or operation, if an expression is true, returns true.	[ $a -lt 20 -o $b -gt 100 ] Returns true.
-a	With operation, both expressions are true before returning true.	[ $a -lt 20 -a $b -gt 100 ] Returns false.

4 Logical operators

The following introduces the logical operator of Shell, assuming that the variable a is 10 and the variable b is 20:

Operators	illustrate	Give an example
&&	Logical AND	[[ $a -lt 100 && $b -gt 100 ]] Return false
\|\|	Logical OR	[[ $a -lt 100 \|\| $b -gt 100 ]] Return true

Multi-condition judgment (&& means that the next command is executed only when the previous command is executed successfully, || means that the next command is executed only after the previous command is executed failed)
 1 test condition
 test atguigu && echo OK || echo not OK OK
 test && echo OK || echo notOK notOK
  2 [ condition ]
 [ atguigu ] && echo OK || echo not OK OK
 [ ] && echo OK || echo notOK notOK

4 string operators

The following table lists commonly used string operators, assuming that the variable a is "abc" and the variable b is "efg":

Operators	illustrate	Give an example
=	Detect whether two strings are equal, and equal returns true.	[ $a = $b ] returns false.
!=	Detect whether two strings are equal, and return true if not equal.	[ $a != $b ] returns true.
-z	Detect whether the string length is 0, and returns true if it is 0.	[ -z $a ] returns false.
-n	Detect whether the string length is 0, and returns true if it is not 0.	[ -n $a ] returns true.
str	Detect whether the string is empty, and returns true if it is not empty.	[ $a ] returns true.

5 File test operators

Make a judgment according to file type

-e file exists (existence)
-f file exists and is a regular file (file)
The -d file exists and is a directory (directory)

3) Whether the file in the /home/atguigu/ directory exists
 1 test condition
   test -e /home/atguigu/
  echo
  $?
  1
 2
 [ condition ]
 [ -e /home/atguigu/ ]
 echo $?
 1

6 File permissions

Make judgments based on file permissions -r has read permissions (read) -w has write permissions (write) -x has execution permissions (execute)

Whether to have write permissions
 1 test
  -w
  echo $?
  0
 2 [ condition ]
  [ -w ]
 echo $?
 0

Process control

if

if judgement

Basic syntax

(1) Single branch if [conditional judgment formula];then
 Program fi
 or if [conditional judgment formula]
 Then
  fi
 (2) Multiple branches
 if [conditional judgment formula]
  Then
  program 
 elif [conditional judgment formula]
  Then
  program
  else program
  fi

Notes: ① [Conditional judgment formula], there must be spaces between brackets and conditional judgment formula. ② There must be spaces after if

Case practice Enter a number, if it is 1, then output banzhang zhen shuai, if it is 2, then output cls zhen mei, if it is something else, output nothing.

vim writes the following

#!/bin/bash
 if [ $1 -eq 1 ] 
then 
echo "banzhang zhen shuai" 
elif [ $1 -eq 2 ]
 then 
echo "cls zhen mei"
 fi

chmod 777     
 ./ 1 
banzhang zhen shuai 
./ 2 
cls zhen mei

case

case $ variable name in

"Value 1")
  If the value of the variable is equal to the value 1, then execute the program 1
 ;;
  "Value 2")
  If the value of the variable is equal to the value 2, then execute the program 2
 ;;
  …Omit other branches
 *)
 If none of the values of the variables are the above values, execute this program ;;
 esac

Notes:

(1) The end of the case line must be the word "in", and each pattern match must end with the closing bracket ")".

(2) Double semicolon ";;" means the end of the command sequence, which is equivalent to the break in C.

(3) The last ")" represents the default mode, which is equivalent to the default in C.

Case

Enter a number, if it is 1, output banzhang, if it is 2, output cls, if it is others, output renyao. vim

#!/bin/bash
case $1 in
"1")
 echo "banzhang"
;;
"2")
 echo "cls"
;;
*)
 echo "renyao"
;;
esac

chmod 777

./ 1

./ 2

./ 3

fore

1 for ((initial value; loop control conditions; variable changes))

do program

done

vim

#!/bin/bash
sum=0
for((i=0;i<=100;i++))
do
 sum=$[$sum+$i]
done
echo $sum

chmod 777

2 for variable in value 1 value 2 value 3…

program

done

vim

#!/bin/bash
 #Print numbers
 for i in cls mly wls
 do
  echo "ban zhang love $i"
 done
 zhuxiaoyi@zhuxiaoyi-virtual-machine:~/shell$ ./
 ban zhang love cls
 ban zhang love myl
 ban zhang love wls

3 Compare the difference between $* and $@ *

1 $and $@ both represent all parameters passed to a function or script. When not included in double quotes "", all parameters are output in the form of $1 $2 ...$n。

vim

#!/bin/bash
echo '=============$*============='
for i in $*
do
 echo "ban zhang love $i"
done
echo '=============$@============='
for j in $@
do 
 echo "ban zhang love $j"
done

zhuxiaoyi@zhuxiaoyi-virtual-machine:~/shell$ ./ 1 2 3
=========$*========
ban zhang love 1
ban zhang love 2
ban zhang love 3
========$@=========
ban zhang love 1
ban zhang love 2
ban zhang love 3

2 When they are included in double quotes "", $* will output all parameters as a whole in the form of "$1 $2 …$n"; $@ will separate each parameter and output all parameters in the form of "$1", "$2"…"$n"

vim

#!/bin/bash
 echo '=================$*==================='
 for i in "$*"
 All parameters in #$* are regarded as a whole, so this for loop will only be looped once
 do
  echo "ban zhang love $i"
 done
 echo '================$@==================='
 for j in "$@"
 Each parameter in #$@ is regarded as independent, so there are several parameters in "$@" and it will be cycled several times.
 do
  echo "ban zhang love $j"
 done

 zhuxiaoyi@zhuxiaoyi-virtual-machine:~/shell$ ./ cls mly wls
 ===========$*=============
 ban zhang love cls mly wls
 ========$@==============
 ban zhang love cls
 ban zhang love mly
 ban zhang love wls

while

Basic syntax

While
  [Conditional judgment formula]
 do program
  done

Case practice

vim

#!/bin/bash
sum=0
i=1
while [ $i -le 100 ]
do
 sum=$[$sum+$i]
 i=$[$i+1]
done
echo $sum

Exit the loop

Break out of the loop

During the loop, sometimes it is necessary to force the loop to break if the end of the loop condition is not reached. Shell uses two commands to implement this function: break and continue.

break command

The break command allows all loops to be jumped (deadly all loops after execution).

In the following example, the script enters a dead loop until the user enters a number greater than 5. To break out of this loop and return to the shell prompt, you need to use the break command.

#!/bin/bash
 While:
 do
     echo -n "Input a number between 1 and 5:"
     read aNum
     case $aNum in
         1|2|3|4|5) echo "The number you entered is $aNum!"
         ;;
         *) echo "The number you entered is not between 1 and 5! The game ends"
             break
         ;;
     esac
 done

Execute the above code and the output is:

Enter the number between 1 and 5:3
 The number you entered is 3!
 Enter the number between 1 and 5: 7
 The number you entered is not between 1 and 5! The game ends

continue

The continue command is similar to the break command, with only a little difference, it will not jump out of all loops, it will just jump out of the current loop.

Modify the above example:

#!/bin/bash
 While:
 do
     echo -n "Enter a number between 1 and 5: "
     read aNum
     case $aNum in
         1|2|3|4|5) echo "The number you entered is $aNum!"
         ;;
         *) echo "The number you entered is not between 1 and 5!"
             Continue continue
             echo "The end of the game"
         ;;
     esac
 done

Running the code shows that when entering a number greater than 5, the loop in this example will not end.echo "Game is over!"Never be executed.

read

Read console input and output

read

-p Specifies the prompt when reading the value

-t Specifies the time to wait when reading the value. If -t does not add it means that it is waiting all the time

Variable Specifies the variable name of the read value

Read the console input within 7 seconds

vim

#!/bin/bash
read -t 7 -p "Enter your name in 7 seconds :" NN
echo $NN
atguigu@ubuntu:~$ chmod 777 
atguigu@ubuntu:~$ ./
Enter your name in 7 seconds : atguigu
atguigu

function

Basic functions

basename

basename [string / pathname] [suffix] (Function Description: The basename command deletes all prefixes including the last ('/') character, and then displays the string.

basename can be understood as taking the file name in the path.

Options: suffix is the suffix. If suffix is specified, basename will remove suffix in pathname or string.

basename /home/atguigu/

basename /home/atguigu/ .txt
banzhang

dirname

dirname The absolute path of the file (Function Description: Removes the file name (non-directory part) from the given file name containing the absolute path, and returns the remaining path (part of directory).)

dirname can be understood as taking the absolute path name of the file path.

Get the absolute path under this folder

dirname /home/atguigu/
/home/atguigu

Custom functions

function

Basic syntax [ function ] funname[()]
 {
 Action;
 [return int;]
 }

Experience skills (1) The function must be declared before calling the function, and the shell script is run line by line. It will not be compiled first like other languages.

(2) The function returns the value, which can only be obtained through the $? system variable, and can be displayed as the addition: return Return. If not added, the result will be run with the last command as the return value. return is followed by the value n (0-255).

Calculate the sum of two input parameters

#!/bin/bash
 function sum()
 {
  s=0
  s=$[$1+$2]
  echo "$s"
 }
 read -p "Please input the number1: " n1;
 read -p "Please input the number2: " n2;
 sum $n1 $n2;
 Save and exit.
 atguigu@ubuntu:~$ chmod 777
 atguigu@ubuntu:~$ ./
 Please input the number1: 2
 Please input the number2: 5
 7

Function parameters

$#	Number of parameters passed to the script
$*	Display all parameters passed to the script as a single string

In the shell, a function can be called and the parameters can be passed to it. Inside the function body, the value of the parameter is obtained in the form of $n. For example, $1 represents the first parameter and $2 represents the second parameter...

Example of function with parameters:

#!/bin/bash
 funWithParam(){
     echo "The first parameter is $1!"
     echo "The second parameter is $2!"
     echo "The tenth parameter is $10!"
     echo "The tenth parameter is ${10}!"
     echo "The eleventh parameter is ${11}!"
     echo "The total number of parameters is $#!"
     echo "Output all parameters as a string $* !"
 }
 funWithParam 1 2 3 4 5 6 7 8 9 34 73

Output result:

The first parameter is 1!
 The second parameter is 2!
 The tenth parameter is 10!
 The tenth parameter is 34!
 The eleventh parameter is 73!
 There are 11 parameters in total!
 Output all parameters as a string 1 2 3 4 5 6 7 8 9 34 73 !

Shell Tools

cut

The ^ represents the beginning and $ represents the end

The job of cut is to "cut", specifically, it is responsible for cutting data in the file.

The cut command cuts bytes, characters, and fields from each line of the file and outputs those bytes, characters, and fields.

cut [Option Parameters]

-f Extract which column

-d separator Split columns by specified separator

-c After cutting by characters, add n to indicate which column

(1) Data preparation
 atguigu@ubuntu:~$ vim
 dong shen
 Guan Zhen
 wo wo1
 lai lai1
 le le1
 (2) Cut the first column
 atguigu@ubuntu:~$ cut -d " " -f 1
 dong
 guan
 wo
 lai
 le
 (3) Cut the second and third columns
 atguigu@ubuntu:~$ cut -d " " -f 2,3
 shen
 zhen
 wo1
 lai1
 le1
 (4) Cut out the guan in the file
 atguigu@ubuntu:~$ cat | grep guan | cut -d " " -f 1
 guan
 (5) Select the system PATH variable value, and all paths after the second ":" start:
 atguigu@ubuntu:~$ echo $PATH
 /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr:/usr:/usr
 /games:/usr/local/games:/snap/bin
 atguigu@ubuntu:~$ echo $PATH | cut -d ":" -f 3-
 3-Represents all the future 3 represents this one
 /usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/b
 in
 (6) The IP address printed after cutting ifconfig
 atguigu@ubuntu:~$ ifconfig ens33 | grep netmask | cut -d "i" -f 2
 | cut -d " " -f 2
 192.168.10.150

awk

A powerful text analysis tool, reads the file line by line, slices each line with spaces as the default separator, and then analyzes and processes it.

awk [Option Parameter] ‘/pattern1/{action1} /pattern2/{action2}...’ filename pattern:

awk -F : '//{}' file name Standard format

print output

-F Specifies the separator for the input file

-v Assign a user-defined variable

Indicates that the content that awk looks for in the data is the matching pattern.

action: A series of commands executed when the matching content is found.

BEGIN AND Add some content

Example 1

(1) Data preparation
 atguigu@ubuntu:~$ sudo cp /etc/passwd ./
 The meaning of passwd data
 Username: Password (encrypted): User id: Group id: Comment: User home directory: shell parser
 (2) Search for all rows starting with the root keyword in the passwd file and output the 7th column of the row.
 atguigu@ubuntu:~$ awk -F : '/^root/{print $7}' passwd
 /bin/bash
 (3) Search for all rows starting with the root keyword in the passwd file, and output columns 1 and 7 of the row.
 The middle is divided by the symbol ",".
 atguigu@ubuntu:~$ awk -F : '/^root/{print $1","$7}' passwd
 root,/bin/bash
 Note: Action will be performed only if the line that matches the pattern.
 (4) Only display the first and seventh columns of /etc/passwd, split by commas, and add column names before all rows
 user, shell add "dahaige, /bin/zuishuai" to the last line.
 atguigu@ubuntu:~$ awk -F : 'BEGIN{print "user, shell"} {print
 $1","$7} END{print "dahaige,/bin/zuishuai"}' passwd
 user, shell
 daemon,/usr/sbin/nologin
 bin,/usr/sbin/nologin
 .  .  .
 sunwukong,/bin/bash
 dahaige,/bin/zuishuai
 Note: BEGIN is executed before all data read lines; END is executed after all data is executed.
 (5) Increase the user id in the passwd file by 1 and output
 atguigu@ubuntu:~$ awk -v i=1 -F : '{print $3+i}' passwd

Built-in variables Variable Description

FILENAME file name

NR Number of records read (line number)

NF Number of fields in browsing records (number of columns after cutting)

Example 2

(1) Statistics the passwd file name, line number of each line, number of columns per line
 atguigu@ubuntu:~$ awk -F : '{print "filename:" FILENAME
 ",linenum:" NR ",col:"NF}' passwd
 filename:passwd,linenum:1,col:7
 filename:passwd,linenum:2,col:7
 filename:passwd,linenum:3,col:7
 .  .  .
 (2) Query the line number where the blank line in the output result of the ifconfig command is located
 atguigu@ubuntu:~$ ifconfig | awk '/^$/{print NR}'
 9
 18
 (3) Cut IP
 atguigu@ubuntu:~$ ifconfig ens33 | awk -F " " '/inet /{print $2}'
 192.168.10.150

Regular expressions

Regular expressions use a single string to describe and match a series of strings that conform to a certain syntax rule. In many text editors, regular expressions are often used to retrieve and replace text that conforms to a certain pattern. In Linux, grep, sed, awk and other commands support pattern matching through regular expressions.

^ Match the beginning of a line
$ Match the end of a row
^$ Match empty lines
.Match any character
*Not used alone, it is used in conjunction with the previous character to match the previous character 0 or more times
.* match any character
[ ] means matching characters in a range [a-z]-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Special characters \ means escape and are not used alone. Since all special characters have their specific matching patterns, when we want to match a particular special character itself (for example, I want to find out all the lines containing '$' )

10.4 Classic regular expressions

#Email Regular

^[1]+@[a-zA-Z0-9_-]+(.[a-zA-Z0-9_-]+)+$ #Mobile phone number regular

/^1((34[0-8])|(8\d{2})(([35][0-35-9]|4[579]|66|7[35678]|9[1389])\d{1}))\d{7}$

a-zA-Z0-9_- ↩︎

Linux

What is Shell

getting Started

Custom variables

Special variables

1 Arithmetic operator

2 Relational operators

3 Boolean operators

4 string operators

5 File test operators

6 File permissions

if

case

**fore **

while

Exit the loop

Break out of the loop

read

Basic functions

Custom functions

Function parameters

cut

awk

fore