Linux Desk Reference (2nd Edition) - page 49

Aliases

Aliases are a popular method of customizing your shell environment. The idea behind aliases is to select a couple of keystrokes to stand for a much longer typed sequence. Collections of alias commands are typically stored in a file called .alias in the user's home directory. From there, they can be sourced at shell startup time. The following command is used:

alias la 'ls -al'

alias

[name [wordlist]]

Without arguments, displays all aliases. With name, displays the alias for name. With name and wordlist, assigns wordlist as the alias of name.

Example: To create an alias such that the command sequence "ls -a" will be run when the user types "la", use

alias la 'ls -a'

unaliaspattern

Without arguments, removes all aliases. Removes all aliases whose name matches the pattern.

Example: To remove the alias ls from the alias list, use

unalias la

Shell Programming

Calling this section "Shell Programming" is sort of misleading. Strictly speaking, any command that works with the shell can be part of a shell script. The commands are featured here because they are rarely used outside of a script.

The commands covered in this section deal primarily with the flow of control statements, for example, -if, case, while, and foreach. Also covered are statements such as eval, which deal with the evaluation of arguments.

First Line

By convention, UNIX shell scripts should all begin with a line like the following:

#!/bin/tcsh

The first two characters (#!) tell the operating system that the contents of this file are intended to be a shell script. The remaining characters are the absolute path of the shell under which that script is intended to run.

Note that the topic of shell scripting is fairly vast, much too large to cover in a single chapter. A number of good books have been written on the topic.

Also by convention, the file in which the script is saved should have an extension, indicating the shell under which it is to be run. In the case of the TC shell, that extension is .tc, for example,

shellscript.tc

The relevant commands are as follows :

@

@ name = expr

@ name[index] = expr

@ name--

@ name[index]--

Display or assign the value of shell variables .

Example: To increment the shell variable n, use

@n++;

break

Causes execution to resume after the end of the nearest enclosing foreach or while.

Example: To interrupt the following while loop when the value of $good is not 1, use

while (1)
        # Actual commands go here


        if ($good != 1) break;
end

breaksw

The breaksw statement is used in conjunction with the switch and case statements. The idea is that when a switch statement finds a match and executes the corresponding case statement block, you put the breaksw statement at the end of the block to tell the switch statement to stop looking for more matches.

Example: To terminate the execution of a switch statement when a match is found, use the following breaksw statement:

switch($value)

case 1:
        # Do stuff
        breaksw
case 2:
        # Do other stuff
        breaksw
default:
        # Do default stuff
        breaksw
endsw

case

label::

The case statement is used in conjunction with a switch statement to test a single variable against a range of possible values. After the switch statement has been used to specify the variable, a sequence of case statements is used to spell out the range of possible values. The variable in the switch statement will be tested against the values in the case statement. When matches are found, the corresponding statements are executed.

Example: The following switch statement will test the value of the variable a and print out a message indicating at which level a match was found:

switch($a)
        case 1:
                echo "Match found a value = 1"
                breaksw
case 2:
                echo "Match found at value = 1"
                breaksw
default:
                echo "Match found at default"
endsw

continue

Continues execution of the nearest enclosing while or foreach. The rest of the commands on the current line are executed.

Example: Let's pretend for a moment that the command "statement1" is a real statement instead of a syntax error. To execute statement 1, but skip the execution of statements 2, 3, and 4 when the value of $a is not equal to 1, use a continue statement as shown here:

while(a!=b)
        statement1; # Executed
        set a=1;
        if($a!=1) continue;
        statement2; # Skipped
        statement3; # Skipped
        statement4; # Skipped
end;

default

Labels the default case in a switch statement. It should come after all case labels. Although syntactically permissible, it is a terrible idea to omit the use of the default statement.

Example: See the example provided in the aforementioned case command.

eval arg …

Treats the arguments as input to the shell and executes the resulting command(s) in the context of the current shell. This is usually used to execute commands generated as the result of command or variable substitution, since parsing occurs before these substitutions.

Example: To evaluate and execute the command sequence 'ls -a', use

eval ls -a

foreach name (( wordlist ))

…

end

Successively sets the variable name to each member of wordlist and executes the sequence of commands between this command and the matching end.

Example: To display the contents of all the files in the current working directory, use

foreach fn ('ls')
       cat $fn
end

Note that the single quote used in this example is the one that, when shifted, becomes a tilde "~". If you use the other single quote, the one which, when shifted, becomes a double quote, it won't work.

filetest -op file …

Applies one of the following operators to each file and returns the results as a space-separated list. The result is 1 if the specified property exists, 0 otherwise .

Similar products