Variable Assignment In Unix

@slm has already included the POSIX docs - which are very helpful - but they don't really expand on how these parameters can be combined to affect one another. There is not yet any mention here of this form:

This is an excerpt from another answer of mine, and I think it demonstrates very well how these work:

Another example from same:

The above example takes advantage of all 4 forms of POSIX parameter substitution and their various or tests. There is more information in the link above, and here it is again.

Another thing that people often don't consider about is how very useful it can be in a here-document. Here's another excerpt from a different answer:


Here you'll set some defaults and prepare to print them when called...


This is where you define other functions to call on your print function based on their results...


You've got it all setup now, so here's where you'll execute and pull your results.


I'll go into why in a moment, but running the above produces the following results:

first run:

I went to your mother's house and saw Disney on Ice.

If you do calligraphy you will succeed.


I went to the cemetery and saw Disney on Ice.

If you do remedial mathematics you will succeed.


I went to the cemetery and saw Disney on Ice.

If you do remedial mathematics you will regret it.


The key feature here is the concept of You can set a variable to a value only if it is unset or null using the form:


If instead you wish to set only an unset variable, you would omit the and null values would remain as is.


You might notice that in the above example and get changed when set via even though has already been called, presumably setting them when it's run. The reason this works is that is a function - I enclosed it in rather than the used for the others. Because it is called in a subshell, every variable it sets is and as it returns to its parent shell those values disappear.

But when sets it is so it affects second evaluation of because sets only via

Learn how you can use variables and parameters in Korn shell to store values. You will also see how the Korn shell supports data types and arrays.

This chapter is from the book 

Special Parameters
Variable Expansion
Array Variables
Compound Variables

Variables and parameters are used by the Korn shell to store values. Like other high-level programming languages, the Korn shell supports data types and arrays. This is a major difference with the Bourne, C shell, and other scripting languages, which have no concept of data types.

The Korn shell supports four data types: string, integer, float, and array. If a data type is not explicitly defined, the Korn shell will assume that the variable is a string.

By default, all variables are global in scope. However, it is possible to declare a local variable within a function. This is discussed in more detail later in this chapter.


Korn shell variable names can begin with an alphabetic (a–Z) or underscore character, followed by one or more alphanumeric (a–Z, 0–9) or underscore characters. Other variable names that contain only digits (0–9) or special characters (!, @, #, %, *, ?, $) are reserved for special parameters set directly by the Korn shell.

To assign a value to a variable, you can simply name the variable and set it to a value. For example, to assign abc to variable X:

$ X=abc

The typeset command can also be used to assign values, but unless you are setting attributes, it's a lot more work for nothing. If a value is not given, the variable is set to null. Here, X is reassigned the null value:

$ X=

This is not the same as being undefined. As we'll see later, accessing the value of an undefined variable may return an error, while accessing the value of a null variable returns the null value.

Accessing Variable Values

To access the value of a variable, precede the name with the $ character. There can be no space between $ and the variable name. In this example, CBIN is set to /usr/ccs/bin.

$ CBIN=/usr/ccs/bin

Table 3.1. Assigning Values to Variables


declare variable and set it to null


declare variable and set it to null


assign value to variable


assign value to variable

Now you can just type $CBIN instead of the long pathname:

$ cd $CBIN$ pwd/usr/ccs/bin

Here is a new command to go along with this concept: print. It displays its arguments on your terminal, just like echo.

$ print Hello world!Hello world!

Here we use print to display the value of CBIN:

$ print $CBIN/usr/ccs/bin

Variable Attributes

Korn shell variables can have one or more attributes that specify their internal representation, access or scope, or the way they are displayed. This concept is similar to a data type in other high-level programming languages, except that in the Korn shell it is not as restrictive. Variables can be set to integer type for faster arithmetic operations, read-only so that the value cannot be changed, left/right justified for formatting purposes, and more. To assign a value and/or attribute to a Korn shell variable, use the following format with the typeset command:

typeset–attribute variable=value


typeset–attribute variable

Except for readonly, variable attributes can be set before, during, or after assignment. Functionally it makes no difference. Just remember that the attribute has precedence over the value. This means that if you change the attribute after a value has been assigned, the value may be affected.

Lowercase (–l) and Uppercase (–u) Attributes

These attributes cause the variable values to be changed to lower or uppercase. For example, the lowercase attribute and uppercase value ASPD are assigned to variable MYSYS:

$ typeset —l MYSYS=ASPD

Despite the fact that MYSYS was assigned uppercase ASPD, when accessed, the value is displayed in lowercase:

$ print $MYSYSaspd

This is because the attribute affects the variable value, regardless of the assignment. Variable attributes can also be changed after assignment. If we wanted to display variable MYSYS in uppercase, we could just reset the attribute:

$ typeset —u MYSYS$ print $MYSYSASPD

Table 3.2. Assigning Values/Attributes to Variables

typeset– attribute variable=value

assign attribute and value to variable

typeset–attribute variable

assign attribute to variable

typeset+attribute variable

remove attribute from variable

Readonly (–r) Attribute

Once the readonly attribute is set, a variable cannot be assigned another value. Here, we use it to set up a restricted PATH:

$ typeset —r PATH=/usr/rbin

If there is an attempt to reset PATH, an error message is generated:

$ PATH=$PATH:/usr/bin:/bin/ksh: PATH: is read only

We'll come back to this in a few pages. Unlike other variable attributes, once the readonly attribute is set, it cannot be removed.

The readonly command can also be used to specify a readonly variable.

Integer (–i) Attribute

The integer attribute (–i) is used to explicitly declare integer variables. Although it is not necessary to set this attribute when assigning integer values, there are some benefits to it. We'll cover this later in Chapter 6. In the meantime, NUM is set to an integer-type variable and assigned a value:

$ typeset —i NUM=1$ print $NUM1

We could also assign NUM the number of users on the system using command substitution like this:

$ typeset —i NUM=$(who | wc —l)$ print $NUM3

There is one restriction on integer variables. Once a variable is set to integer type, it can't be assigned a non-integer value:

$ typeset —i NUM=abc/bin/ksh: NUM: bad number

Float (–E, –F) Attribute

The float attributes (–E, –F) are used to declare float variables. The –E is used to specify the number of significant digits, while –F is used to specify the precision. We'll cover this later in Chapter 6. In the following example, X is set to a float variable and assigned a value using both formats:

$ typeset —E5 X=123.456$ print $X123.46$ typeset —F5 X=123.456$ print $X123.45600

The float command can also be used to declare a float variable, but does not allow for specifying the precision.

Right (–R) and Left (–L) Justify Attributes

The right and left justify attributes cause variable values to be justified within their width and are be used to format data. Here, variables A and B are set to right-justify with a field width of 7 characters. Notice that integer values are used, even though the integer attribute is not set.

$ typeset —R7 A=10 B=10000$ print :$A:: 10:$ print :$B:: 10000:

If the field width is not large enough for the variable assignment, the value gets truncated. Variable X is assigned a seven-character wide value, but the field width is set to 3, so the first four characters are lost:

$ typeset —R3 X=ABCDEFG$ print $XEFG

If a field width is not given, then it is set with the first variable assignment. Variable Y is assigned a three-character wide value, so the field width is set to 3.

$ typeset —L Y=ABC$ print $YABC

Without explicitly resetting the field width, a subsequent assignment would be restricted to a three-character wide value:

$ Y=ZYXWVUT$ print $YZYX

Autoexport (–x) Attribute

This is another useful attribute. It allows you to set and export a variable in one command. Instead of

$ typeset X=abc$ export X

you can do this:

$ typeset —x X=abc

We could use this attribute to add the /lbin directory to the PATH variable and export it all in one command:

$ typeset —x PATH=$PATH:/lbin

Table 3.3. Some Variable Attributes

typeset –ivar

Set the type of var to be integer

typeset –lvar

Set var to lower case

typeset –Lvar

Left justify var; the field width is specified by the first assignment

typeset –Ln var

Left justify var; set field width to n

typeset –LZn var

Left justify var; set field width to n and strip leading zeros

typeset –rvar

Set var to be readonly (same as the readonly command)

typeset –Rvar

Right justify var; the field width is specified by the first assignment

typeset –Rn var

Right justify var; set field width to n

typeset –RZn var

Right justify var; set field width to n and fill with leading zeros

typeset –tvar

Set the user-defined attribute for var. This has no meaning to the Korn shell.

typeset –uvar

Set var to upper case

typeset –xvar

Automatically export var to the environment (same as the export command)

typeset –Zvar

Same as typeset –RZ

Removing Variable Attributes

Except for readonly, variable attributes are removed with the typeset +attribute command. Assuming that the integer attribute was set on the NUM variable, we could remove it like this:

$ typeset +i NUM

and then reassign it a non-integer value:

$ NUM=abc

Once the readonly attribute is set, it cannot be removed. When we try to do this with the PATH variable that was previously set, we get an error message:

$ typeset +r PATH/bin/ksh: PATH: is read only

The only way to reassign a readonly variable is to unset it first, then assign a value from scratch.

Multiple Attributes

Multiple attributes can also be assigned to variables. This command sets the integer and autoexport attributes for TMOUT:

$ typeset —ix TMOUT=3000

To set and automatically export ORACLE_SID to uppercase prod:

$ typeset —ux ORACLE_SID=prod$ print $ORACLE_SIDPROD

Obviously, some attributes like left and right justify are mutually exclusive, so they shouldn't be set together.

Checking Variable Attributes

Attributes of Korn shell variables are listed using the typeset –attribute command. For example, to list all the integer type variables and their values:


To list only the names of variables with a specific attribute, use the typeset + attribute command.

More with Variables

You can do other things with variables, such as assign them the value of another variable, the output of a command, or even the contents of a file. Here Y is assigned the value of variable X:

$ X=$HOME$ Y=$X$ print $Y/home/anatole

Variables can be assigned command output using this format:




The second format is provided for compatibility with the Bourne shell. Here, UCSC is set to its internet ID by assigning the output of the grep and cut commands:

$ UCSC=$(grep UCSC /etc/hosts | cut —f1 —d" ")$ print $UCSC128.114.129.1

Variables can also be assigned the contents of files like this:



variable=`cat file`

The first format is equivalent to variable=$(catfile). The second format is much slower, but is provided for compatibility with the Bourne shell. Here, the FSYS variable is set to the contents of the /etc/fstab file:

$ FSYS=$(</etc/fstab)$ print $FSYS/dev/roota / /dev/rootg /usr

Notice that the entries were displayed all on one line, instead of each on separate lines as in the file. We'll talk about this in the Quoting section later in this chapter.

A nameref variable is a synonym for another variable and will always have the same value as its associated variable They are created using the following formats:




For example:

$ X=abc$ nameref Y=X$ print $Xabc$ print $Yabc

Unsetting Variables

Variable definitions are removed using the unset command. The TMOUT variable is not being used, so let's unset it:

$ unset TMOUT

Now to check and see:

$ print $TMOUT$

This is not the same as being set to null. As we'll see later in this chapter, variable expansion may be performed differently, depending on whether the variable value is set to null.

Unsetting either the base or nameref variable will unset both variables.

$ unset Y$ print $X$ print $Y$

0 thoughts on “Variable Assignment In Unix”


Leave a Comment

Your email address will not be published. Required fields are marked *