bash, Notas de estudo de Cultura

Baixe bash e outras Notas de estudo em PDF para Cultura, somente na Docsity!

Bash Reference Manual

Reference Documentation for Bash Edition 4.1, for Bash Version 4.1. December 2009

Chet Ramey, Case Western Reserve University

Brian Fox, Free Software Foundation

This text is a brief description of the features that are present in the Bash shell (version 4.1, 23 December 2009).

This is Edition 4.1, last updated 23 December 2009, of The GNU Bash Reference Manual, for Bash, Version 4.1.

Copyright ©c 1988–2009 Free Software Foundation, Inc.

Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies.

Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, with the Front-Cover texts being “A GNU Manual”, and with the Back-Cover Texts as in (a) below. A copy of the license is included in the section entitled “GNU Free Documentation License”. (a) The FSF’s Back-Cover Text is: You are free to copy and modify this GNU manual. Buying copies from GNU Press supports the FSF in developing GNU and promoting software freedom.”

Published by the Free Software Foundation 59 Temple Place, Suite 330, Boston, MA 02111- USA

• 1 Introduction Table of Contents
  • 1.1 What is Bash?
  • 1.2 What is a shell?
• 2 Definitions
• 3 Basic Shell Features
  • 3.1 Shell Syntax
    • 3.1.1 Shell Operation
    • 3.1.2 Quoting
      • 3.1.2.1 Escape Character
      • 3.1.2.2 Single Quotes
      • 3.1.2.3 Double Quotes
      • 3.1.2.4 ANSI-C Quoting
      • 3.1.2.5 Locale-Specific Translation.
    • 3.1.3 Comments
  • 3.2 Shell Commands
    • 3.2.1 Simple Commands
    • 3.2.2 Pipelines
    • 3.2.3 Lists of Commands
    • 3.2.4 Compound Commands
      • 3.2.4.1 Looping Constructs
      • 3.2.4.2 Conditional Constructs
      • 3.2.4.3 Grouping Commands
    • 3.2.5 Coprocesses
  • 3.3 Shell Functions
  • 3.4 Shell Parameters
    • 3.4.1 Positional Parameters
    • 3.4.2 Special Parameters
  • 3.5 Shell Expansions
    • 3.5.1 Brace Expansion
    • 3.5.2 Tilde Expansion
    • 3.5.3 Shell Parameter Expansion
    • 3.5.4 Command Substitution
    • 3.5.5 Arithmetic Expansion
    • 3.5.6 Process Substitution
    • 3.5.7 Word Splitting
    • 3.5.8 Filename Expansion
      • 3.5.8.1 Pattern Matching
    • 3.5.9 Quote Removal.
  • 3.6 Redirections
    • 3.6.1 Redirecting Input
    • 3.6.2 Redirecting Output ii Bash Reference Manual
    • 3.6.3 Appending Redirected Output
    • 3.6.4 Redirecting Standard Output and Standard Error
    • 3.6.5 Appending Standard Output and Standard Error
    • 3.6.6 Here Documents
    • 3.6.7 Here Strings
    • 3.6.8 Duplicating File Descriptors
    • 3.6.9 Moving File Descriptors
    • 3.6.10 Opening File Descriptors for Reading and Writing
  • 3.7 Executing Commands
    • 3.7.1 Simple Command Expansion
    • 3.7.2 Command Search and Execution
    • 3.7.3 Command Execution Environment.
    • 3.7.4 Environment
    • 3.7.5 Exit Status
    • 3.7.6 Signals
  • 3.8 Shell Scripts
• 4 Shell Builtin Commands
  • 4.1 Bourne Shell Builtins
  • 4.2 Bash Builtin Commands
  • 4.3 Modifying Shell Behavior.
    • 4.3.1 The Set Builtin
    • 4.3.2 The Shopt Builtin
  • 4.4 Special Builtins
• 5 Shell Variables
  • 5.1 Bourne Shell Variables
  • 5.2 Bash Variables
• 6 Bash Features
  • 6.1 Invoking Bash
  • 6.2 Bash Startup Files
  • 6.3 Interactive Shells
    • 6.3.1 What is an Interactive Shell?
    • 6.3.2 Is this Shell Interactive?
    • 6.3.3 Interactive Shell Behavior
  • 6.4 Bash Conditional Expressions
  • 6.5 Shell Arithmetic
  • 6.6 Aliases
  • 6.7 Arrays
  • 6.8 The Directory Stack
    • 6.8.1 Directory Stack Builtins
  • 6.9 Controlling the Prompt
  • 6.10 The Restricted Shell
  • 6.11 Bash POSIX Mode.
• 7 Job Control iii
  • 7.1 Job Control Basics
  • 7.2 Job Control Builtins
  • 7.3 Job Control Variables
• 8 Command Line Editing
  • 8.1 Introduction to Line Editing
  • 8.2 Readline Interaction.
    • 8.2.1 Readline Bare Essentials
    • 8.2.2 Readline Movement Commands
    • 8.2.3 Readline Killing Commands
    • 8.2.4 Readline Arguments
    • 8.2.5 Searching for Commands in the History.
  • 8.3 Readline Init File
    • 8.3.1 Readline Init File Syntax
    • 8.3.2 Conditional Init Constructs
    • 8.3.3 Sample Init File
  • 8.4 Bindable Readline Commands
    • 8.4.1 Commands For Moving
    • 8.4.2 Commands For Manipulating The History
    • 8.4.3 Commands For Changing Text
    • 8.4.4 Killing And Yanking
    • 8.4.5 Specifying Numeric Arguments
    • 8.4.6 Letting Readline Type For You
    • 8.4.7 Keyboard Macros
    • 8.4.8 Some Miscellaneous Commands
  • 8.5 Readline vi Mode
  • 8.6 Programmable Completion
  • 8.7 Programmable Completion Builtins
• 9 Using History Interactively
  • 9.1 Bash History Facilities
  • 9.2 Bash History Builtins
  • 9.3 History Expansion
    • 9.3.1 Event Designators
    • 9.3.2 Word Designators
    • 9.3.3 Modifiers
• 10 Installing Bash
  • 10.1 Basic Installation
  • 10.2 Compilers and Options.
  • 10.3 Compiling For Multiple Architectures
  • 10.4 Installation Names
  • 10.5 Specifying the System Type
  • 10.6 Sharing Defaults
  • 10.7 Operation Controls
  • 10.8 Optional Features

Chapter 1: Introduction 1

1 Introduction

1.1 What is Bash?

Bash is the shell, or command language interpreter, for the gnu operating system. The name is an acronym for the ‘Bourne-Again SHell’, a pun on Stephen Bourne, the author of the direct ancestor of the current Unix shell sh, which appeared in the Seventh Edition Bell Labs Research version of Unix.

Bash is largely compatible with sh and incorporates useful features from the Korn shell ksh and the C shell csh. It is intended to be a conformant implementation of the ieee posix Shell and Tools portion of the ieee posix specification (ieee Standard 1003.1). It offers functional improvements over sh for both interactive and programming use.

While the gnu operating system provides other shells, including a version of csh, Bash is the default shell. Like other gnu software, Bash is quite portable. It currently runs on nearly every version of Unix and a few other operating systems − independently-supported ports exist for ms-dos, os/2, and Windows platforms.

1.2 What is a shell?

At its base, a shell is simply a macro processor that executes commands. The term macro processor means functionality where text and symbols are expanded to create larger expres- sions.

A Unix shell is both a command interpreter and a programming language. As a com- mand interpreter, the shell provides the user interface to the rich set of gnu utilities. The programming language features allow these utilities to be combined. Files containing com- mands can be created, and become commands themselves. These new commands have the same status as system commands in directories such as ‘/bin’, allowing users or groups to establish custom environments to automate their common tasks.

Shells may be used interactively or non-interactively. In interactive mode, they accept input typed from the keyboard. When executing non-interactively, shells execute commands read from a file.

A shell allows execution of gnu commands, both synchronously and asynchronously. The shell waits for synchronous commands to complete before accepting more input; asyn- chronous commands continue to execute in parallel with the shell while it reads and executes additional commands. The redirection constructs permit fine-grained control of the input and output of those commands. Moreover, the shell allows control over the contents of commands’ environments.

Shells also provide a small set of built-in commands (builtins) implementing function- ality impossible or inconvenient to obtain via separate utilities. For example, cd, break, continue, and exec) cannot be implemented outside of the shell because they directly manipulate the shell itself. The history, getopts, kill, or pwd builtins, among others, could be implemented in separate utilities, but they are more convenient to use as builtin commands. All of the shell builtins are described in subsequent sections.

While executing commands is essential, most of the power (and complexity) of shells is due to their embedded programming languages. Like any high-level language, the shell provides variables, flow control constructs, quoting, and functions.

2 Bash Reference Manual

Shells offer features geared specifically for interactive use rather than to augment the pro- gramming language. These interactive features include job control, command line editing, command history and aliases. Each of these features is described in this manual.

4 Bash Reference Manual

return status A synonym for exit status.

signal A mechanism by which a process may be notified by the kernel of an event occurring in the system.

special builtin A shell builtin command that has been classified as special by the posix stan- dard.

token A sequence of characters considered a single unit by the shell. It is either a word or an operator.

word A sequence of characters treated as a unit by the shell. Words may not include unquoted metacharacters.

Chapter 3: Basic Shell Features 5

3 Basic Shell Features

Bash is an acronym for ‘Bourne-Again SHell’. The Bourne shell is the traditional Unix shell originally written by Stephen Bourne. All of the Bourne shell builtin commands are available in Bash, The rules for evaluation and quoting are taken from the posix specification for the ‘standard’ Unix shell.

This chapter briefly summarizes the shell’s ‘building blocks’: commands, control struc- tures, shell functions, shell parameters, shell expansions, redirections, which are a way to direct input and output from and to named files, and how the shell executes commands.

3.1 Shell Syntax

When the shell reads input, it proceeds through a sequence of operations. If the input indicates the beginning of a comment, the shell ignores the comment symbol (‘#’), and the rest of that line.

Otherwise, roughly speaking, the shell reads its input and divides the input into words and operators, employing the quoting rules to select which meanings to assign various words and characters.

The shell then parses these tokens into commands and other constructs, removes the special meaning of certain words or characters, expands others, redirects input and output as needed, executes the specified command, waits for the command’s exit status, and makes that exit status available for further inspection or processing.

3.1.1 Shell Operation

The following is a brief description of the shell’s operation when it reads and executes a command. Basically, the shell does the following:

1. Reads its input from a file (see Section 3.8 [Shell Scripts], page 33), from a string supplied as an argument to the ‘-c’ invocation option (see Section 6.1 [Invoking Bash], page 71), or from the user’s terminal.
2. Breaks the input into words and operators, obeying the quoting rules described in Section 3.1.2 [Quoting], page 6. These tokens are separated by metacharacters. Alias expansion is performed by this step (see Section 6.6 [Aliases], page 79).
3. Parses the tokens into simple and compound commands (see Section 3.2 [Shell Com- mands], page 7).
4. Performs the various shell expansions (see Section 3.5 [Shell Expansions], page 17), breaking the expanded tokens into lists of filenames (see Section 3.5.8 [Filename Ex- pansion], page 24) and commands and arguments.
5. Performs any necessary redirections (see Section 3.6 [Redirections], page 26) and re- moves the redirection operators and their operands from the argument list.
6. Executes the command (see Section 3.7 [Executing Commands], page 29).
7. Optionally waits for the command to complete and collects its exit status (see Section 3.7.5 [Exit Status], page 32).

Chapter 3: Basic Shell Features 7

\f form feed

\n newline

\r carriage return

\t horizontal tab

\v vertical tab

\ backslash

\’ single quote

" double quote

\nnn the eight-bit character whose value is the octal value nnn (one to three digits)

\xHH the eight-bit character whose value is the hexadecimal value HH (one or two hex digits)

\cx a control-x character

The expanded result is single-quoted, as if the dollar sign had not been present.

3.1.2.5 Locale-Specific Translation

A double-quoted string preceded by a dollar sign (‘$’) will cause the string to be translated according to the current locale. If the current locale is C or POSIX, the dollar sign is ignored. If the string is translated and replaced, the replacement is double-quoted.

Some systems use the message catalog selected by the LC_MESSAGES shell variable. Others create the name of the message catalog from the value of the TEXTDOMAIN shell variable, possibly adding a suffix of ‘.mo’. If you use the TEXTDOMAIN variable, you may need to set the TEXTDOMAINDIR variable to the location of the message catalog files. Still others use both variables in this fashion: TEXTDOMAINDIR/LC_MESSAGES/LC MESSAGES/TEXTDOMAIN.mo.

3.1.3 Comments

In a non-interactive shell, or an interactive shell in which the interactive_comments option to the shopt builtin is enabled (see Section 4.3.2 [The Shopt Builtin], page 55), a word beginning with ‘#’ causes that word and all remaining characters on that line to be ignored. An interactive shell without the interactive_comments option enabled does not allow comments. The interactive_comments option is on by default in interactive shells. See Section 6.3 [Interactive Shells], page 75, for a description of what makes a shell interactive.

3.2 Shell Commands

A simple shell command such as echo a b c consists of the command itself followed by arguments, separated by spaces.

More complex shell commands are composed of simple commands arranged together in a variety of ways: in a pipeline in which the output of one command becomes the input of a second, in a loop or conditional construct, or in some other grouping.

8 Bash Reference Manual

3.2.1 Simple Commands

A simple command is the kind of command encountered most often. It’s just a sequence of words separated by blanks, terminated by one of the shell’s control operators (see Chapter 2 [Definitions], page 3). The first word generally specifies a command to be executed, with the rest of the words being that command’s arguments.

The return status (see Section 3.7.5 [Exit Status], page 32) of a simple command is its exit status as provided by the posix 1003.1 waitpid function, or 128+n if the command was terminated by signal n.

3.2.2 Pipelines

A pipeline is a sequence of simple commands separated by one of the control operators ‘|’ or ‘|&’.

The format for a pipeline is [time [-p]] [!] command1 [ [| or |&] command2 ...]

The output of each command in the pipeline is connected via a pipe to the input of the next command. That is, each command reads the previous command’s output. This connection is performed before any redirections specified by the command.

If ‘|&’ is used, the standard error of command1 is connected to command2’s standard input through the pipe; it is shorthand for 2>&1 |. This implicit redirection of the standard error is performed after any redirections specified by the command.

The reserved word time causes timing statistics to be printed for the pipeline once it finishes. The statistics currently consist of elapsed (wall-clock) time and user and system time consumed by the command’s execution. The ‘-p’ option changes the output format to that specified by posix. The TIMEFORMAT variable may be set to a format string that specifies how the timing information should be displayed. See Section 5.2 [Bash Variables], page 61, for a description of the available formats. The use of time as a reserved word per- mits the timing of shell builtins, shell functions, and pipelines. An external time command cannot time these easily.

If the pipeline is not executed asynchronously (see Section 3.2.3 [Lists], page 8), the shell waits for all commands in the pipeline to complete.

Each command in a pipeline is executed in its own subshell (see Section 3.7.3 [Command Execution Environment], page 30). The exit status of a pipeline is the exit status of the last command in the pipeline, unless the pipefail option is enabled (see Section 4.3.1 [The Set Builtin], page 51). If pipefail is enabled, the pipeline’s return status is the value of the last (rightmost) command to exit with a non-zero status, or zero if all commands exit successfully. If the reserved word ‘!’ precedes the pipeline, the exit status is the logical negation of the exit status as described above. The shell waits for all commands in the pipeline to terminate before returning a value.

3.2.3 Lists of Commands

A list is a sequence of one or more pipelines separated by one of the operators ‘;’, ‘&’, ‘&&’, or ‘||’, and optionally terminated by one of ‘;’, ‘&’, or a newline.

Of these list operators, ‘&&’ and ‘||’ have equal precedence, followed by ‘;’ and ‘&’, which have equal precedence.

10 Bash Reference Manual

Execute consequent-commands as long as test-commands has an exit status of zero. The return status is the exit status of the last command executed in consequent-commands, or zero if none was executed.

for The syntax of the for command is:

for name [ [in [words ...] ] ; ] do commands; done Expand words, and execute commands once for each member in the resultant list, with name bound to the current member. If ‘in words’ is not present, the for command executes the commands once for each positional parameter that is set, as if ‘in "$@"’ had been specified (see Section 3.4.2 [Special Parameters], page 16). The return status is the exit status of the last command that executes. If there are no items in the expansion of words, no commands are executed, and the return status is zero. An alternate form of the for command is also supported: for (( expr1 ; expr2 ; expr3 )) ; do commands ; done First, the arithmetic expression expr1 is evaluated according to the rules de- scribed below (see Section 6.5 [Shell Arithmetic], page 78). The arithmetic expression expr2 is then evaluated repeatedly until it evaluates to zero. Each time expr2 evaluates to a non-zero value, commands are executed and the arith- metic expression expr3 is evaluated. If any expression is omitted, it behaves as if it evaluates to 1. The return value is the exit status of the last command in list that is executed, or false if any of the expressions is invalid. The break and continue builtins (see Section 4.1 [Bourne Shell Builtins], page 35) may be used to control loop execution.

3.2.4.2 Conditional Constructs

if The syntax of the if command is:

if test-commands; then consequent-commands; [elif more-test-commands; then more-consequents;] [else alternate-consequents;] fi The test-commands list is executed, and if its return status is zero, the consequent-commands list is executed. If test-commands returns a non-zero status, each elif list is executed in turn, and if its exit status is zero, the corresponding more-consequents is executed and the command completes. If ‘else alternate-consequents’ is present, and the final command in the final if or elif clause has a non-zero exit status, then alternate-consequents is executed. The return status is the exit status of the last command executed, or zero if no condition tested true.

case The syntax of the case command is:

case word in [ [(] pattern [| pattern]...) command-list ;;]... esac case will selectively execute the command-list corresponding to the first pattern that matches word. If the shell option nocasematch (see the description of

Chapter 3: Basic Shell Features 11

shopt in Section 4.3.2 [The Shopt Builtin], page 55) is enabled, the match is performed without regard to the case of alphabetic characters. The ‘|’ is used to separate multiple patterns, and the ‘)’ operator terminates a pattern list. A list of patterns and an associated command-list is known as a clause. Each clause must be terminated with ‘;;’, ‘;&’, or ‘;;&’. The word under- goes tilde expansion, parameter expansion, command substitution, arithmetic expansion, and quote removal before matching is attempted. Each pattern undergoes tilde expansion, parameter expansion, command substitution, and arithmetic expansion. There may be an arbitrary number of case clauses, each terminated by a ‘;;’, ‘;&’, or ‘;;&’. The first pattern that matches determines the command-list that is executed. Here is an example using case in a script that could be used to describe one interesting feature of an animal: echo -n "Enter the name of an animal: " read ANIMAL echo -n "The $ANIMAL has " case $ANIMAL in horse | dog | cat) echo -n "four";; man | kangaroo ) echo -n "two";; *) echo -n "an unknown number of";; esac echo " legs." If the ‘;;’ operator is used, no subsequent matches are attempted after the first pattern match. Using ‘;&’ in place of ‘;;’ causes execution to continue with the command-list associated with the next clause, if any. Using ‘;;&’ in place of ‘;;’ causes the shell to test the patterns in the next clause, if any, and execute any associated command-list on a successful match. The return status is zero if no pattern is matched. Otherwise, the return status is the exit status of the command-list executed.

select

The select construct allows the easy generation of menus. It has almost the same syntax as the for command: select name [in words ...]; do commands; done The list of words following in is expanded, generating a list of items. The set of expanded words is printed on the standard error output stream, each preceded by a number. If the ‘in words’ is omitted, the positional parameters are printed, as if ‘in "$@"’ had been specified. The PS3 prompt is then displayed and a line is read from the standard input. If the line consists of a number corresponding to one of the displayed words, then the value of name is set to that word. If the line is empty, the words and prompt are displayed again. If EOF is read, the select command completes. Any other value read causes name to be set to null. The line read is saved in the variable REPLY. The commands are executed after each selection until a break command is executed, at which point the select command completes.

Chapter 3: Basic Shell Features 13

array variable BASH_REMATCH. The element of BASH_REMATCH with index 0 is the portion of the string matching the entire regular expression. The element of BASH_REMATCH with index n is the portion of the string matching the nth parenthesized subexpression. Expressions may be combined using the following operators, listed in decreasing order of precedence:

( expression ) Returns the value of expression. This may be used to override the normal precedence of operators.

! expression True if expression is false.

expression1 && expression True if both expression1 and expression2 are true.

expression1 || expression True if either expression1 or expression2 is true.

The && and || operators do not evaluate expression2 if the value of expression is sufficient to determine the return value of the entire conditional expression.

3.2.4.3 Grouping Commands

Bash provides two ways to group a list of commands to be executed as a unit. When com- mands are grouped, redirections may be applied to the entire command list. For example, the output of all the commands in the list may be redirected to a single stream.

()

( list ) Placing a list of commands between parentheses causes a subshell environment to be created (see Section 3.7.3 [Command Execution Environment], page 30), and each of the commands in list to be executed in that subshell. Since the list is executed in a subshell, variable assignments do not remain in effect after the subshell completes.

{}

{ list; } Placing a list of commands between curly braces causes the list to be executed in the current shell context. No subshell is created. The semicolon (or newline) following list is required.

In addition to the creation of a subshell, there is a subtle difference between these two constructs due to historical reasons. The braces are reserved words, so they must be separated from the list by blanks or other shell metacharacters. The parentheses are operators, and are recognized as separate tokens by the shell even if they are not separated from the list by whitespace.

The exit status of both of these constructs is the exit status of list.

14 Bash Reference Manual

3.2.5 Coprocesses

A coprocess is a shell command preceded by the coproc reserved word. A coprocess is executed asynchronously in a subshell, as if the command had been terminated with the ‘&’ control operator, with a two-way pipe established between the executing shell and the coprocess.

The format for a coprocess is: coproc [NAME] command [redirections]

This creates a coprocess named NAME. If NAME is not supplied, the default name is COPROC. NAME must not be supplied if command is a simple command (see Section 3.2. [Simple Commands], page 8); otherwise, it is interpreted as the first word of the simple command.

When the coproc is executed, the shell creates an array variable (see Section 6.7 [Arrays], page 80) named NAME in the context of the executing shell. The standard output of command is connected via a pipe to a file descriptor in the executing shell, and that file descriptor is assigned to NAME[0]. The standard input of command is connected via a pipe to a file descriptor in the executing shell, and that file descriptor is assigned to NAME[1]. This pipe is established before any redirections specified by the command (see Section 3. [Redirections], page 26). The file descriptors can be utilized as arguments to shell commands and redirections using standard word expansions.

The process id of the shell spawned to execute the coprocess is available as the value of the variable NAME PID. The wait builtin command may be used to wait for the coprocess to terminate.

The return status of a coprocess is the exit status of command.

3.3 Shell Functions

Shell functions are a way to group commands for later execution using a single name for the group. They are executed just like a "regular" command. When the name of a shell function is used as a simple command name, the list of commands associated with that function name is executed. Shell functions are executed in the current shell context; no new process is created to interpret them.

Functions are declared using this syntax: [ function ] name () compound-command [ redirections ] This defines a shell function named name. The reserved word function is optional. If the function reserved word is supplied, the parentheses are optional. The body of the function is the compound command compound-command (see Section 3.2.4 [Compound Commands], page 9). That command is usually a list enclosed between { and }, but may be any compound command listed above. compound-command is executed whenever name is specified as the name of a command. Any redirections (see Section 3.6 [Redirections], page 26) associated with the shell function are performed when the function is executed.

A function definition may be deleted using the ‘-f’ option to the unset builtin (see Section 4.1 [Bourne Shell Builtins], page 35).

The exit status of a function definition is zero unless a syntax error occurs or a readonly function with the same name already exists. When executed, the exit status of a function is the exit status of the last command executed in the body.