music

�

OSdata.com

substitutions

summary

����This subchapter looks at substitutions in UNIX (and Linux).

free book on UNIX/Linux System Administration Teach Yourself UNIX/Linux System Administration and Shell Programming free computer programming text book project table of contents If you like the idea of this project, then please donate some money. more information on donating

substitutions

����This subchapter looks at substitutions in UNIX (and Linux).

• command substitutions
• arithmetic substitutions

command substitution

����Command substitution is used to assign the output of a command to a variable.

����Place the command in sideways ticks (`) around the command. Do not confuse these with regular single quotation marks (').

����You can place a simple command, a pipeline, or a command list inside the tick marks.

����An example of a simple command:

����$ DATE=`date`

����An example of a pipeline:

����$ CONSOLEUSER=`who | grep console`

����An example of a command list:

����$ FILEUSAGE=`date ; df`

����You can use command substitution to create parameters for other commands.

����In the following example, the user name is used for grep word search of the file named names:

����$ grep `id -un` names

����You can use $( ) as a replacement for ` `. If you nest backticks inside of each other, you need to escape the internal backticks. You do not need to escape nested $( ).

����$ DATEVAR=$(date)
����$ echo $DATEVAR
����$Mon Aug 26 19:35:47 PDT 2013
����$

����If there is only one level of nesting, some people use the convention of using $() for the outer expression adn backicks (``) fr the inner expression.

arithmetic substitution

����You can use arithmetic substitution for quick integer artihmetic.

����Place an integer arithmetic expression inside double parenthesis and place a dollar mark before the parenthesized expression (wow, that�s a lot of words), $(( expression )).

����$(( 5 + 3 ))

����You may use integer constants or integer variables:

����$(( 5 + $z ))

����You may post-increment, post-decrement, pre-increment, or pre-decrement variables:

����$(( --x + z++ ))

����You may use negative integers:

����$(( -1 * -2 ))

����You may use logical (!) and bitwise (~) negation:

����$(( !1 * ~2 ))

����The order of precedence (and complete list of possible operations):

operator	meaning
VAR++ VAR--	variable post-increment and pre-increment
++VAR --VAR	variable pre-increment and pre-decrement
- +	unary minus and plus
! ~	logical negation and bitwise negation
**	exponentiation
* / %	multiplication, division, and modulo
+ -	addition and subtraction
<< >>	left bitwise shift and right bitwise shift
<= >= < >	comparison operators
== !=	equality and inequality
&	bitwise AND
^	bitwise exclusive OR
|	bitwise OR
&&	logical AND
||	logical OR
expression ? expression : expression	C-style conditional evaluation
= *= /= %= += -= <<= >>= &= ^= !=	assignments
,	separator between expressions

����Applying the precedence rules:

����$(( ((3 + 5*2) -8) /2 ))

����The result for the above expression is 2. It is not 2.5 because this is integer arithmetic. It is not 4 because the multiplcation has a higher precedence than addition.

����You can have a raw expression, which is useful if it includes an assignment operator:

����$ n=1
����$ echo $n
����1
����$ (( n += 3 ))
����$ echo $n
����4
����$

---