Shell Variables   «Prev 

Using Positional Variables in a Unix Script

Question: What is the purpose of Positional Variables in a Unix Script?
Positional variables in a Unix script refer to the arguments that are passed to the script when it is executed. These variables allow the script to dynamically receive input data from the user or other scripts and use it to perform various operations. The purpose of positional variables is to provide flexibility and versatility to Unix scripts. By accepting input data as arguments, scripts can be used to perform a wide range of tasks, such as processing files, managing system resources, and automating repetitive tasks. In Unix scripts, positional variables are denoted by numbers starting from 1. $1 represents the first argument, $2 represents the second argument, and so on. The total number of arguments passed to the script can be determined using the $# variable. Using positional variables, Unix scripts can access and manipulate input data in a variety of ways. For example, a script that processes a file could use $1 to specify the input file, and then use other positional variables to specify additional parameters, such as the output file or the type of processing to be performed. Overall, the use of positional variables allows Unix scripts to be more flexible and adaptable, making them a powerful tool for automating complex tasks.

Difference between 1) Bourne Again Shell and 2) Korn Shell

When dealing with positional parameters or positional variables in Unix scripts, both the Bourne Again Shell (Bash) and the Korn Shell (ksh) are built on the fundamentals of the original Bourne shell, thus they share substantial syntax similarities, including the usage of positional parameters.
The positional parameters are variables ($0, $1, $2, $3, ..., $9) that hold the command-line arguments provided when a script is invoked. Here, $0 represents the name of the script itself, $1 is the first argument, $2 is the second argument, and so forth.
In both Bash and ksh:
  1. $* or $@ refers to all positional parameters, except for $0. Both $* and $@, when unquoted, will behave the same way, splitting positional parameters on whitespace.
  2. When quoted, "$*" creates a single string separated by the first character of IFS (by default space), which contains all positional parameters as a single word, while "$@" creates a separate string for each positional parameter, preserving whitespace within parameters.
  3. $# denotes the number of positional parameters, not including $0.

However, there are some differences between Bash and ksh related to array handling and how they work with more than 9 positional parameters:
  1. In Bash, if you have more than nine arguments, you can use the ${10}, ${11}, etc. to get the 10th, 11th, and so forth arguments. In ksh, however, if you want to access more than 9 parameters, you have to use shift to move all positional parameters down by one.
  2. Bash 4.0+ supports arrays and allows you to store and manipulate positional parameters in a more flexible manner than ksh. Although ksh also supports arrays, some versions may not include associative arrays, and the syntax and functionality can be different and less powerful compared to Bash.

In summary, positional parameters in Unix scripts are handled similarly in both Bash and ksh. However, differences do exist, particularly in how they deal with more than 9 positional parameters and their respective support for arrays. It's recommended to verify these features according to the specific versions of Bash or ksh being used, as there may be some variations.