Shell script

A shell script is a computer program designed to be run by a Unix shell, a command-line interpreter.^[1] The various dialects of shell scripts are considered to be command languages. Typical operations performed by shell scripts include file manipulation, program execution, and printing text. A script which sets up the environment, runs the program, and does any necessary cleanup or logging, is called a wrapper.

The term is also used more generally to mean the automated mode of running an operating system shell. Different operating systems each use a particular name for these functions. All Unix-like systems include at least one POSIX shell, typically either bash or the zsh compatibility mode.^[2]

Capabilities

#!/bin/sh
LC_COLLATE=C ls -FCas "$@"

#!/bin/sh
clear
ls -al "$@"

#!/bin/sh
echo 'compiling...'
cc -c foo.c
cc -c bar.c
cc -c qux.c
cc -o myprog foo.o bar.o qux.o
echo 'done.'

#!/bin/sh
# set $img to each of the jpgs in the command arguments
for img in "$@"; do       # for each given image...
    # use ${img%.jpg} to get $img w/o the .jpg
    png=${img%.jpg}.png   # filename for successful PNG 
    tmp=tmp.png           # filename before sure it worked
    echo "converting '$img'..."
    # Use ImageMagick's "convert" to write our new PNG
    # image into our $tmp file - which may fail!
    if convert "$img" "$tmp" ; then  # if it works...
        # convert worked (since we're in here)
        # (this script assumes "mv" always succeeds)
        mv "$tmp" "$png"   # rename tmp file to target png
        echo "converted $jpg to $png"
    else
        # convert failed (since we're in here)
        # tell the user about it
        echo "conversion to $png failed, result in $tmp"
        exit 1   # exit, the 1 indicates an error
    fi           # the end of the "if" test construct
done             # the end of the "for" loop
echo 'all conversions successful'
# now the script exits with 0 (default) showing success

Typical shell languages

Other scripting languages

Many powerful scripting languages, such as Rexx, Python, Perl, and Tcl, have been introduced to address tasks that are too large, complex, or repetitive to be comfortably handled by traditional shell scripts, while avoiding the overhead associated with compiled languages like C or Java.^[14]

Although the distinction between scripting languages and general-purpose high-level programming languages is often debated, scripting languages are typically characterized by their interpreted nature, simplified syntax, and primary use in automating tasks, coordinating system operations, and writing "glue code" between components.^[15] Even when scripting languages such as Python, Rexx, or JavaScript support compilation to bytecode or use JIT to improve performance, they are still commonly referred to as "scripting languages" due to their historical association with automation, lightweight tooling, and scripting environments rather than standalone application development.

Scripting is a form of programming. While "scripting" may emphasize lightweight, task-oriented automation, the broader term "programming" encompasses both scripting and software development in compiled or structured languages. As such, scripting involves writing code to instruct a computer to perform specific tasks—meeting the fundamental definition of programming.^[16]

Life cycle

Shell scripts often serve as an initial stage in software development, and are often subject to conversion later to a different underlying implementation, most commonly being converted to Perl, Python, or C. The interpreter directive allows the implementation detail to be fully hidden inside the script, rather than being exposed as a filename extension, and provides for seamless reimplementation in different languages with no impact on end users.

While files with the ".sh" file extension are usually a shell script of some kind, most shell scripts do not have any filename extension.^{[17][18][19][20]}

Advantages and disadvantages

One of the biggest advantages of writing a shell script is that the commands and syntax are exactly the same as those directly entered at the command-line. The programmer does not have to switch to a totally different syntax, as they would if the script were written in a different language, or if a compiled language were used.

Often, writing a shell script is much quicker than writing the equivalent code in other programming languages. The many advantages include easy program or file selection, quick start, and interactive debugging. A shell script can be used to provide a sequencing and decision-making linkage around existing programs, and for moderately sized scripts the absence of a compilation step is an advantage. Interpretive running makes it easy to write debugging code into a script and re-run it to detect and fix bugs. Non-expert users can use scripting to tailor the behavior of programs, and shell scripting provides some limited scope for multiprocessing.

On the other hand, shell scripting is prone to costly errors. Inadvertent typing errors such as rm -rf * / (instead of the intended rm -rf */) are folklore in the Unix community; a single extra space converts the command from one that deletes all subdirectories contained in the current directory, to one which deletes everything from the file system's root directory.^[21] Similar problems can transform cp and mv into dangerous weapons, and misuse of the > redirect can delete the contents of a file.^[22]

Another significant disadvantage is the slow execution speed and the need to launch a new process for almost every shell command executed. When a script's job can be accomplished by setting up a pipeline in which efficient filter commands perform most of the work, the slowdown is mitigated, but a complex script is typically several orders of magnitude slower than a conventional compiled program that performs an equivalent task.

There are also compatibility problems between different platforms. Larry Wall, creator of Perl, famously wrote that "It's easier to port a shell than a shell script", referring to the inconsistent behavior of command-line programs across systems.^[23] (His specific example would have been fixed by POSIX standardization of grep.)

Similarly, more complex scripts can run into the limitations of the shell scripting language itself; the limits make it difficult to write quality code, and extensions by various shells to ameliorate problems with the original shell language can make problems worse.^[24]

Many disadvantages of using some script languages are caused by design flaws within the language syntax or implementation, and are not necessarily imposed by the use of a text-based command-line; there are a number of shells which use other shell programming languages or even full-fledged languages like Scsh (which uses Scheme).

Interoperability among scripting languages

Many scripting languages share similar syntax and features due to their adherence to the POSIX standard, and several shells provide modes to emulate or maintain compatibility with others. This allows scripts written for one shell to often run in another with minimal changes.

For example, Bash supports much of the original Bourne shell syntax and offers a POSIX-compliant mode to improve portability. However, Bash also includes a number of extensions not found in POSIX, commonly referred to as bashisms. While these features enhance scripting capabilities, they may reduce compatibility with other shells like Dash or ksh.

A script that uses features specific to a certain shell may use a matching shebang (#!) as the first line, so that the operating system will use the specified interpreter (e.g. /bin/bash) to run the script, though this will not be sufficient when a feature is added to a shell without changing its name, or when one manually runs the script (e.g. sh foo.sh).

A script can also check which shell it is being ran on and exit before the missing features are used, for example:

#!/bin/bash
die() { printf '%s\n' "$1" >&2; exit 1; }

if [ "$BASH_VERSINFO" -lt 4 ]; then
  die "Not bash 4 or above. Need bash 4 or above."
fi

# This is a bashism, specifically supported only by bash 4.0+.
declare -A dictionary
# ... rest of script

In the example above, the opening lines of the script is written in pure POSIX shell. When a non-bash shell run the script, $BASH_VERSINFO will not be set; this triggers the test and causes the script to exit before the incompatible line is reached. When a bash version prior to 4.x runs the script, the same test is triggered by numeric comparison (-lt). (declare -A declares an associative array, a feature new to bash 4.0 and not found on previous versions.)

Shell scripting on other operating systems

Interoperability software such as Cygwin, the MKS Toolkit, Interix (formerly part of Microsoft Windows Services for UNIX), Hamilton C shell, and UWIN (AT&T Unix for Windows) enables Unix shell programs to run on Windows NT-based systems, though some features may not be fully supported on the older MS-DOS/Windows 95 platforms. Earlier versions of the MKS Toolkit also provided support for OS/2.

Scripting languages are, by definition, able to be extended. On Unix and other POSIX-compliant systems, awk and sed are used to extend the string and numeric processing ability of shell scripts. Tcl, Perl, Rexx, and Python have graphics toolkits and can be used to code functions and procedures for shell scripts which pose a speed bottleneck (C, Fortran, assembly language &c are much faster still) and to add functionality not available in the shell language such as sockets and other connectivity functions, heavy-duty text processing, working with numbers if the calling script does not have those abilities, self-writing and self-modifying code, techniques like recursion, direct memory access, various types of sorting and more, which are difficult or impossible in the main script, and so on. Visual Basic for Applications and VBScript can be used to control and communicate with such things as spreadsheets, databases, scriptable programs of all types, telecommunications software, development tools, graphics tools and other software which can be accessed through the Component Object Model.

See also

• Glue code
• Interpreter directive
• Shebang symbol (#!)
• Unix shells
• PowerShell
• Windows Script Host

References

External links

Wikibooks has a book on the topic of: Shell Programming

• An Introduction To Shell Programming by Greg Goebel
• UNIX / Linux shell scripting tutorial by Steve Parker
• Shell Scripting Primer (Apple)
• What to watch out for when writing portable shell scripts by Peter Seebach
• Free Unix Shell scripting books
• Beginners/BashScripting, Ubuntu Linux