Shulou(Shulou.com)05/31 Report--

This article introduces the knowledge of "how to use functions in Shell scripts". In the operation of actual cases, many people will encounter such a dilemma, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

What is the function in the Shell script?

A function is a set of commands that are given a name that acts like a handle to that set of commands. To execute the set of commands defined in the function, simply call the function with the name you provide.

In some cases, you need to execute a code block that performs specific procedures multiple times at different locations in the shell script. Shell functions are similar to subroutines, procedures, and functions in other programming languages.

Why are functions in Shell scripts?

It helps us reuse code.

Improve the readability of the program.

Use variables effectively within the program.

Allow us to test programs one by one.

Displays the program as a series of substeps.

The syntax to use: Syntax1: function function_name {# Command set} Syntax2: function name () {# Command set} function is the key to declaring function definitions. Function_name is the name of the declared function. Curly braces {} acts as a delimiter that contains the function code. A command set is the code to be executed when a function is called. Therefore, declare a function first, and then call it when needed.

In the first syntax, you must use the keyword function, followed by the function name, and open and close parentheses and curly braces to separate the contents of the function from the main routine.

In the second syntax, it consists of function names, opening and closing parentheses, and curly braces.

We have some examples of shell scripts:

In this example, we will write a very small function to print a line with "-"

Let's see how it works:

Line 1: declare the function print_line.

Lines 2 and 4: {} curly braces used to separate the body of the function.

Line 3: the only statement in the function body: use the echo command to print a line of "- -" characters.

Line 5: call the print_line function.

Line 6: print the supplied parameter $1.

Line 7: print_line calls the function again.

Note: $1 in the above example, "" will take the following values, and you will give the parameters when you execute the script.

1) print "Welcome to the Automation Lab" (it will print the entire statement in double quotes) 2) print "Welcome" (it will display only the "recipient" statement) 3) print "Welcome" (it will print Welcome only). / function.sh "To Automation Laboratories"

. / function.sh To Automation Laboratories

. / function.sh (without any argument)

Let's look at another example:

After creating the function myfunction, it then calls our main program by calling the name of its calling function. The main routine will be anywhere in our script and is not defined as part of our function. #! / Bin / Celebration MyFunction () {echo "Oh! actually how it works"} MyFunction now let's rearrange our code to test whether the function can be declared anywhere in our script. #! / Bin / Celebration Echo "used to test" MyFunction's MyFunction () {Echo "Oh! actually, how it works" Line 3 returns a command that does not find an error in the code snippet above. This only means: this feature only applies if it is previously declared by your main program. If you declare your functionality after the main program, the interpreter will return an error. Passing parameters on a function you can pass parameters in the bash function and process the data. The following code shows how to pass a value in a shell script: #! / Bin / Celebration MyFunction () {echo "the first parameter is $1" echo "and the second parameter is $2"} myfunction "Hello"World"

Let's understand the above:

After we call, we add the values "Hello" and "World" myfunction.

These values are passed as parameters to myfunction and stored in local variables.

The interpreter stores the passed values in predefined variables named according to the order in which the parameters are passed, with 1 as the starting name until the order in which they are passed.

Notice that the word "Hello" is stored in variable 1 and the value "World" is stored in variable 2.

Note: the 1 and 2 above are local variables, so no other part of the script can access them except the function that passes the parameters.

Let's identify the above precautions through the following example: #! / Bin / Celebration MyFunction () {echo "the first parameter is $1" echo "the second parameter is $2"} myfunction "Hello"World" echo $1 echo $2

The last two lines of our script in echo $1 and echo $2 are not shown because the explanation does not recognize these two variables because they are both locally given to myFunction.

Let's understand this more clearly by giving another example:

We will write a function to estimate the length of the string. The string is supplied to the function as an argument. Let's see what it looks like.

Yes. Until then, why don't we enhance some useful commands in Linux?

"wc-l": counts the number of rows

"wc-w": count words

"wc-m": count the number of characters

Line 2: declare and initialize the variable length.

Line 3: define the function string_length.

Lines 4 and 6: functional code block delimiters.

Line 5: the only line of code within the function:

Length = `echo-n $1 | wc-m`

The arguments passed to function $1 are printed using the echo command, which option-n prevents echo from inserting line breaks at the end.

The output of the command echo is transmitted through the-n $1 pipeline to the command's input stream wc-m (which counts the characters in the input).

The result of the above compound statement is echo-n $1 | wc-m is assigned (by using backquotes') to a variable length.

Line 7: read the input string from the user and assign it to the variable STR.

Line 8: call the string_length function and pass the variable STR to it. The result of calling this function is to estimate the length of the STR and store the calculated length in a variable length.

Line 9: print the result to the user.

Bash function returns

The Bash function can use the keyword return to pass the value of the function's local variable to the main routine. Then store the returned value in the default variable $? Let's give an example:

We pass the parameters int1 and int2 to the add function. Next, the add function processes it as sum=$ (($1 destroy 2)) through this line. The value of the sum variable is then passed to the main program return $sum through this line. By default, the value of $sum is stored in the default variable $? Finally, line echo "The result is:" $? Displays the results.

Note: Shell scripts can only return a single value.

A recursive function means that within the function definition and within the code of the function, the calling statement can appear in the calling function (defined) itself. This should be controlled by test conditions to ensure that functionality will converge. If no condition is specified, or if the wrong condition is used, the function will always call itself.

Now use a factor example to enhance this recursive function:

Result=1: this line initializes the variable result to 1

Factorial_function.: declare factorial functions.

Function body Staring delimiter {

If [$1-gt1]; then check to see if the argument supplied to the function is greater than 1.

If so, execute the following two lines:

Let "result * = $1": this multiplies the current value of the result by the parameters passed to the function.

Factorial $(($1-1)): this calls the factorial function recursively and passes it as an argument of $1-1.

The function body closes the delimiter}

After the function is declared, this is the main script code:

Factorial $1

The main script calls the factorial function and passes it the command-line arguments passed to the script $1. Don't confuse $1, which represents the first command-line argument, with $1, which represents the first argument passed to the function.

The last line prints the result to the user.

1. First, set the result variable to 1. 0.

two。 The interpreter encountered a function definition.

3. Call the function with argument 4. Control is transferred to a function that works in the following ways:

A) if the parameter is greater than 1 (this is case), check the parameter (now 4). If so, execute the following two lines:

I) complete the usual cumulative multiplication: the result is multiplied by the parameter $1, and the result is stored in the variable result.

Ii) the factorial function is called "recursive" and is passed as a parameter 3. Control is transferred again to the factorial function, whose argument is now 3.

B) if parameter "3" is greater than 1 (this is case), check parameter "3". If so, perform the above two steps (I and ii). Step ii calls the factorial function again, where 2 is a parameter.

C) this continues until the factorial function is called with parameter 1. At this point, the if condition fails and the function terminates.

4. Control returns the main script and executes the first line after the function call (the echo command that prints the result to the user).

This is the end of the content of "how to use functions in Shell scripts". Thank you for reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.