Shulou(Shulou.com)06/03 Report--

How to deal with shell input parameters, many novices are not very clear about this, in order to help you solve this problem, the following editor will explain in detail for you, people with this need can come to learn, I hope you can gain something.

Parameter handling-handling of Shell input parameters

1. $# number of parameters passed to the script

2. $* displays all parameters passed to the script in a single string. Unlike location variables, this option can have more than 9 parameters

3.

The current process that the script is running is ID number 4. $! The process number 5. $@ of the last process running in the background is the same as $#, but use it in quotation marks and return each parameter 6. $- displays the current option used by shell, which is the same as the set command function Displays the exit status of the last command. 0 indicates that there is no error, and any other value indicates an error. Variable meaning $0 script name $1 location parameter # 1 $2-$9 position parameter # 2-# 9 ${10} position parameter # 10 $# number of position parameter "$*" all position parameters (as a single string) * "$@" all position parameters (each as a separate string) ${# *} is passed to the command line in the script The number of arguments ${# @} the number of command line arguments passed to the script $? Return value

The process of the script ID (PID)

$- Flag passed to the script (using set)

The last parameter of the $_ previous command

$! The process ID (PID) of the last job running in the background

When using shell processing, parameter processing is a basic module, so today we find an easy-to-understand article for reference, as a template for future shell parameter processing, it is recommended to use getOpts form for parameter processing.

0. Introduction

When writing a program, you often have to deal with command-line parameters. This article describes the command-line processing method under Bash.

Options and parameters:

The following command line:

. / test.sh-f config.conf-v-- prefix=/home

We call-f an option, and it requires a parameter, that is, config.conf, and-v is also an option, but it does not require an argument.

-- prefix we call it a long option, that is, the option itself is more than one character, and it also requires a parameter, which is connected with an equal sign. Of course, the equal sign is not required. / home can be written directly after-- prefix, that is,-- prefix/home. More restrictions will be discussed later.

In bash, you can handle command-line arguments in three ways, each with its own application scenario.

* manual processing

* getopts

* getopt

Let's discuss these three processing methods in turn.

1. Manual processing method

In manual processing, you first need to know a few variables, or do you want to use the above command behavior example:

* $0:. / test.sh, that is, the command itself, which is equivalent to the argv in Cmax Cure + [0]

* $1:-f, the first parameter.

* $2: config.conf

* $3, $4.: and so on.

The number of * $# parameters, excluding the command itself. In the above example, $# is 4.

* $@: the list of parameters themselves, excluding the command itself, such as-f config.conf-v-- prefix=/home in the above example

* $*: same as $@, but unlike "$*" and "$@" (in quotation marks), "$*" interprets all parameters as a string, while "$@" is an array of parameters. As shown in the following example:

1 #! / bin/bash

two

3 for arg in "$*"

4 do

5 echo $arg

6 done

seven

8 for arg in "$@"

9 do

10 echo $arg

11 done

twelve

Execute. / test.sh-f config.conf-n 10 to print:

-f config.conf-n 10 # this is the output of "$*"

-f # below is the output of $@

Config.conf

-n

ten

Therefore, the way of manual processing is the processing of these variables. Because manual processing is highly dependent on the position of the parameters you pass on the command line, it is generally only used to deal with simpler parameters. Such as

. / test.sh 10

The option of. / test-n 10 is rarely used. Typical usage is:

#! / bin/bash

If [Xero1! = x]

Then

#... Have parameters

Else

Then

#... No parameters

Fi

Why would you compare it in such a way as xmatch 1! = x? Imagine this way of comparing:

If [- n $1] # $1 is not empty

However, if the user does not pass a parameter, $1 is empty, which becomes [- n], so you need to add an auxiliary string for comparison.

Manual processing can meet most simple requirements, and it can also be used with shift to construct powerful features, but the following two methods are recommended when dealing with complex options.

2. Getopts/getopt

Dealing with command line arguments is a similar and complicated thing. For this reason, C provides functions such as getopt/getopt_long

C++ 's boost provides the Options library, and in shell, it is getopts and getopt.

Getopts and getopt are similar but not identical in function, where getopt is a separate executable and getopts is built-in by Bash.

Let's take a look at the typical use of parameter passing:

*. / test.sh-a-b-c: short options, no parameters are required for each option

*. / test.sh-abc: short options, which have the same effect as the previous method, but write all the options together.

*. / test.sh-an args-b-c: short option, where-a requires parameters and-b-c does not.

*. / test.sh-- a-long=args-- b-long: long option

Let's take a look at getopts, which does not support long options.

Using getopts is very simple:

Code

# test.sh

#! / bin/bash

The colon after the while getopts "a:bc" arg # option indicates that the option requires an argument

Do

Case $arg in

a)

The echo "asides arg:$OPTARG" # parameter is stored in $OPTARG

b)

Echo "b"

c)

Echo "c"

?) # what is arg when there is an unrecognized option?

Echo "unkonw argument"

Exit 1

Esac

Done

You can use it now:

. / test.sh-an arg-b-c

Or

. / test.sh-an arg-bc

To load.

It should be said that most scripts use this function, and if you need to support long options and optional parameters, you need to use getopt.

Here is an example that comes with getopt:

#! / bin/bash

# A small example program for using the new getopt (1) program.

# This program will only work with bash (1)

# An similar program using the tcsh (1) script language can be found

# as parse.tcsh

# Example input and output (from the bash prompt):

#. / parse.bash-a par1 'another arg'-- c-long 'wowworth savings beat'-cmore-b "very long"

# Option a

# Option c, no argument

# Option c, argument `more'

# Option b, argument `very long'

# Remaining arguments:

#-- > `par1'

#-- > `another arg'

#-- > `wowfloor pocket pocket

# Note that we use `"$@"'to let each command-line parameter expand to a

# separate word. The quotes around `$ @ 'are essential!

# We need TEMP as the `eval set-- 'would nuke the return value of getopt.

#-o indicates a short option, and two colons indicate that the option has an optional parameter, which must be close to the option

# such as-carg but not-carg

#-long indicates long option

# "$@" explained above

#-n: information in case of error

# -: it is easier to understand by giving an example:

# what will you do if we create a directory named "- f"?

# mkdir-f # is not successful because-f will be parsed by mkdir as an option, so you can use the

# mkdir-- f so that-f will not be used as an option.

TEMP= `getopt-o ab:c::-- long Amuri longline bMULYLINGRAPHY recorder cMYLINGRAPH: /

-n 'example.bash'-- "$@" `

If [$?! = 0]; then echo "Terminating..." > & 2; exit 1; fi

# Note the quotes around `$TEMP': they are essential!

# set rearranges the order of the parameters, that is, changing the value of $1, which has been rearranged in getopt.

Eval set-"$TEMP"

# after the processing of getopt, the specific options are dealt with below.

While true; do

Case "$1" in

-a |-a-long) echo "Option a"; shift

-b |-- b-long) echo "Option b, argument / `$ 2'"; shift 2

-c |-- c-long)

# c has an optional argument. As we are in quoted mode

# an empty parameter will be generated if its optional

# argument is not found.

Case "$2" in

"") echo "Option c, no argument"; shift 2

*) echo "Option c, argument / `$ 2'"; shift 2

Esac

--) shift; break

*) echo "Internal error!"; exit 1

Esac

Done

Echo "Remaining arguments:"

For arg do

Echo'-->'"/ `$ arg'"

Done

For example, we use

. / test-a-b arg arg1-c

You can see that the command line has an extra arg1 parameter, and after going through getopt and set, the command line becomes:

-a-b arg-c-- arg1

$1 points to-a recording 2 points to-b recording 3 points to arg,$4, points to-c recording 5 points to--, while the extra arg1 is put at the end.

3. Summary

In general, manual processing of small scripts may be enough, getopts can handle the vast majority of cases, getopt is more complex and more powerful.

*

Shift is actually very simple, which is to move the parameter list to the left. Shift moves the leftmost parameter $1 out at once, and then

The original $2 is now $1.

Shift can also be followed by a number indicating how many parameters to remove (only one by default), such as

Shift 3 simply removes three parameters, and then the original $4 becomes the current $1.

Eval simply executes the following parameters, doing all necessary permutations, and then executes the command. For example:

MYFILE= "cat myfile"

Echo $MYFILE # output: cat myfile

Eval $MYFILE # output: contents of myfile

Let me give you a more detailed example:

#! / bin/bash

# evalit

Echo "Total number of arguments passed: $#"

Echo "The process ID:

"echo" Lastargument: "$(evalecho/

#)

Run the script:

$. / evalit alpha bravo charlie

Output as follows:

Total number of arguments passed: 3

The process ID: 780

Last argument: charlie

Read a file

For i in `cat abc.txt`

Do

Echo $I

Done

Is it helpful for you to read the above content? If you want to know more about the relevant knowledge or read more related articles, please follow the industry information channel, thank you for your support.

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.