Shell Scripting

Document Sample
Shell Scripting Powered By Docstoc
					Introduction to Shell
Script Programming
                   Objectives

• Understand the program development cycle
• Compare UNIX/Linux shells for creating scripts
• Use shell variables, operators, and wildcard
  characters




                                                   2
           Objectives (continued)

• Use shell logic structures
• Employ shell scripting to create a menu
• Use commands to help debug shell scripts




                                             3
           Objectives (continued)

• Explain ways to customize your personal
  environment
• Use the trap command




                                            4
         Previewing the Application

• Shell scripts can be used to customize your
  environment
• Will develop a simulated employee information
  system using shell scripts
• Will gain experience with shell variables, shell script
  operators, and logic structures




                                                            5
    The Program Development Cycle

• The program development cycle is the process of
  developing an application
   – First step is to create program specifications
   – Second step is to create the program design
   – Third step is developing the code, which is
     written, tested, and debugged




                                                      6
The Program Development Cycle




                                7
        Using High-Level Languages

• High-level languages are computer languages that use
  English-like expressions
• Examples are; COBOL, C, C++
• High-level language statements are stored in a source
  file, which programmers create using an editor




                                                          8
       Using High-Level Languages
               (continued)

• High-level source files must be converted into a low-level
  machine language file
• A compiler is a program that converts source files into
  executable machine-language files
• If a source file contains syntax errors, it cannot be
  converted into an executable file
   – A programmer must correct these errors before the
      program can be run


                                                           9
      Using UNIX/Linux Shell Scripts

• Unlike high-level language programs, shell scripts do not
  have to be converted into machine language
• The UNIX/Linux shell acts as an interpreter when
  reading script files
• Interpreters read statements in script files and
  immediately translate them into executable instructions
  and run them




                                                         10
       Using UNIX/Linux Shell Scripts
               (continued)
• After creating shell script, the OS is instructed that the
  file is an executable shell script via the chmod 755
  command.
• Script files can be run in several ways:
   – Set the path variable and type the script name at the
      command prompt
   – Type ./filename if script is in current directory
   – Type the script name preceded by the full path




                                                               11
          Prototyping an Application

• A prototype is a running model of your application
   – Less detail, less design time than a full application
   – Shows potential without full programming effort
• Shell scripts can be used to prototype applications that
  will later be moved to compiled languages




                                                             12
               Using Comments

• Comments are important!
• Provide useful documentation to both the programmer
  and to others who need to understand or debug the code
• To use, start comment line with a #




                                                      13
           The Programming Shell




All Linux versions use the Bash shell as the default
                                                       14
                    Variables
• Variables are symbolic names that represent values
  stored in memory
• Three types of variables:
   – Configuration variables store information about
     the setup of the OS
   – Environment variables hold information about
     your login session
   – Shell variables are created at the command
     prompt or in shell scripts and are used to
     temporarily store information


                                                   15
      Environment and Configuration
               Variables
• Environment and configuration variables can be used to
  set up and personalize your sessions
• The printenv command shows current environment and
  configuration variables




                                                       16
Environment and Configuration
     Variables (continued)


                      Use the printenv
                      variable to see a
                      list of environment
                      variables




                                     17
Environment and Configuration
     Variables (continued)




                                18
Environment and Configuration
     Variables (continued)




                                19
Environment and Configuration
     Variables (continued)




                                20
Environment and Configuration
     Variables (continued)




                                21
                 Shell Variables

• Variables that you can define and manipulate for use
  with program commands in a shell
• Observe basic guidelines for handling and naming shell
  variables




                                                           22
                  Shell Operators

• Bash shell operators are in four groups:
   – Defining
   – Evaluating
   – Arithmetic
   – Redirection




                                             23
                Defining Operators

•   Used to assign a value to a variable
•   Most common is = (equal sign)
•   Use quotation marks with strings
•   Backquote says execute the command inside the
    backquotes and store the result in the variable




                                                      24
             Evaluating Operators

• Used for determining the contents of a variable
• echo $variablename will show the value of variablename
• Double quotes can be used, but not single quotes




                                                       25
Arithmetic Operators




                       26
     Arithmetic Operators (continued)

• Regular mathematical precedence rules apply to
  arithmetic operators



 To store arithmetic
 values in a variable,
 use let statement




                                                   27
             Redirection Operators

• The > redirection operator overwrites an existing file
• -o noclobber option of set command will prevent
  overwriting




                                                           28
      Exporting Shell Variables to the
               Environment
• Shell scripts cannot automatically access variables
  created and assigned
   – On the command line
   – By other scripts
• Make variables global in your environment by using the
  export command




                                                           29
        Modifying the PATH Variable

• PATH variable controls where your shell will look for
  shell scripts
• You can add directories to your PATH
   – Special directories for scripts
   – Your current working directory




                                                          30
    More About Wildcard Characters
• Shell scripts often use wildcard characters
• Wildcard characters are called glob characters and
  are a part of glob patterns
• Glob patterns are intended to match filenames and
  words
   – Question mark (?) matches one character
   – Asterisk (*) matches zero or more characters
   – [chars] defines a class of characters, the glob
     pattern matches any character in the class



                                                       31
            Shell Logic Structures

• Four basic logic structures needed for program
  development are:
   – Sequential logic
   – Decision logic
   – Looping logic
   – Case logic




                                                   32
                 Sequential Logic

• Commands are executed in the order in which they
  appear in the script or program
• The only break in this sequence comes when a branch
  instruction changes the flow of execution by redirecting
  to another location in the script or program
• Used for simple, straightforward command sequences




                                                             33
                  Decision Logic

• Enables your script or program to execute a statement or
  series of statements only if a certain condition exists
• In many cases, the condition depends upon the result of
  a command or on a comparison
• The if statement is the primary decision-making control
  structure in this type of logic




                                                        34
                   Looping Logic

• A control structure repeats until some condition exists or
  some action occurs
• Two common looping mechanisms:
   – for loops cycle through a range of values until the last
     in a set of values is reached
   – The while loop cycles as long as a particular condition
     exists




                                                           35
Looping Logic (continued)



                   The for loop repeats
                   for however many
                   values there are in
                   the specified set of
                   values




                                    36
          Looping Logic (continued)

• Program control structures can be entered from the
  command line
• Wildcard characters can be used in loops
• The while loop is set up to test repeatedly for a matching
  condition
• The while loop is used when code must be repeatedly
  executed an undetermined number of times




                                                           37
                     Case Logic

• The case logic structure simplifies the selection from a
  list of choices
• It allows the script to perform one of many actions,
  depending on the value of a variable
• Two semicolons (;;) terminate the actions taken after the
  case matches what is being tested




                                                          38
Using Shell Scripting to Create a Menu

• Often useful to create a menu that branches to
  specific shell scripts
• The tput command is useful when creating menus
• Can initialize the terminal display to place text and
  prompts in specific locations and respond to the
  user




                                                          39
         Debugging a Shell Script
• A shell script will not execute if there is an error
  in one or more commands
• Running a shell script using sh enables quick
  debugging of problems
   – sh -v option displays lines of code in the script
     as they are read by the interpreter
   – sh -x option displays the command and its
     arguments line by line as they are run



                                                         40
              Customizing Your
            Personal Environment
• When programming and shell scripting, customizing
  your environment by modifying the initial settings in
  the login scripts provides many benefits
• Login scripts run just after logging in
• Setting up personal bin directories and modify editor
  defaults are common customizations




                                                      41
Customizing Your Personal Environment
             (continued)
• An alias is a name that represents another
  command
• The .bashrc file in your home directory is used to
  establish customizations that take effect at each
  login
• The .bashrc script is executed each time a shell is
  generated, such as when shell scripts are run




                                                        42
             The trap Command
• The trap command causes a shell program to
  automatically remove temporary files created when
  shell scripts run
• Programmers often set up a subdirectory to store
  temporary files, and when a script file exits, trap
  removes the files
• Having files removed from a temporary directory like
  this is considered “good housekeeping”




                                                     43
Putting It All Together in an Application
• Applications require you to:
   – Assign and manage variables
   – Use shell operators
   – Employ shell logic structures
   – Use additional wildcard characters
   – Use tput for managing screen initialization
   – Use trap to clean up temporary files




                                                   44
                  Summary
• A high-level language uses English-like
  expressions and must be converted into a low-
  level language before being executed
• The shell interprets shell scripts
• Linux shells are derived from the UNIX Bourne,
  Korn and C shells, and bash is the default




                                                   45
           Summary (continued)
• UNIX/Linux uses three types of variables:
  configuration, environment, and shell
• Shell operators include defining, evaluating,
  arithmetic, and redirection
• Wildcard characters are used in shell scripts
• The logic structures supported are: sequential,
  decision, looping and case




                                                    46
          Summary (continued)
• The tput command manages cursor placement on
  the screen
• Programmers and system administrators often
  customize the .bashrc file
• Aliases simplify common commands can be
  entered into the .bashrc
• Use the trap command to remove temporary files
  after the script exits



                                               47

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:0
posted:1/30/2013
language:English
pages:47