[펌]All about Variables in Bash | Shell Scripting

This section we will describe the following:

• Variable assignment

• Variable substitution

• Built-in shell variables

• Other shell variables

Variable Assignment

Variable names consist of any number of letters, digits, or underscores. Upper- and lowercase letters are distinct, and names may not start with a digit.

Variables are assigned values using the = operator. There may not be any whitespace between the variable name and the value. You can make multiple assignments on the same line by separating each one with whitespace:

firstname=Arnold lastname=Robbins numkids=4 numpets=1

By convention, names for variables used or set by the shell have all uppercase letters; however, you can use uppercase names in your scripts if you use a name that isn’t special to the shell. By default, the shell treats variable values as strings, even if the value of the string is all digits. However, when a value is assigned to an integer variable (created via declare -i), Bash evaluates the righthand side of the assignment as an ｅxpression.

For example:

$ i=5+3 ; echo $i

5+3

$ declare -i jj ; jj=5+3 ; echo $jj

8

The += operator allows you to add or append the righthand side of the assignment to an existing value. Integer variables treat the righthand side as an ｅxpression, which is evaluated and added to the value. Arrays add the new elements to the array.

For example:

$ name=Arnold

$ name+=” Robbins” ; echo $name #String variable

Arnold Robbins

$ declare -i jj ; jj=3+5 ; echo $jj #Integer variable

8

$ jj+=2+4 ; echo $jj

14

$ pets=(blacky rusty) #Array variable

$ echo ${pets[*]}

blacky rusty

$ pets+=(raincloud sophie)

$ echo ${pets[*]}

blacky rusty raincloud sophie

Variable Substitution

No spaces should be used in the following ｅxpressions. The colon (:) is optional; if it’s included, var must be nonnull as well as set.

var=value … Set each variable var to a value.

${var} Use value of var; braces are optional if var is separated from the following text. They are required for array variables.

${var:-value} Use var if set; otherwise, use value.

${var:=value} Use var if set; otherwise, use value and assign value to var.

${var:?value} Use var if set; otherwise, print value and exit (if not interactive). If value isn’t supplied, print the phrase parameter null or not set.

${var:+value} Use value if var is set; otherwise, use nothing.

${#var} Use the length of var.

${#*} Use the number of positional parameters.

${#@} Same as previous.

${var#pattern} Use value of var after removing text matching pattern from the left. Remove the shortest matching piece.

${var##pattern} Same as #pattern, but remove the longest matching piece.

${var%pattern} Use value of var after removing text matching pattern from the right. Remove the shortest matching piece.

${var%%pattern} Same as %pattern, but remove the longest matching piece.

${var^pattern} Convert the case of var to uppercase. The pattern is evaluated as for filename matching. If the first letter of var matches the pattern, it is converted to uppercase. var can be * or @, in which case the positional parameters are modified. var can also be an array subscripted by * or @, in which case the substitution is applied to all the elements of the array.

${var^^pattern} Same as ^pattern, but apply the match to every letter in the string.

${var,pattern} Same as ^pattern, but convert matching characters to lower case. Applies only to the first character in the string.

${var,,pattern} Same as ,pattern, but apply the match to every letter in the string.

${!prefix*},${!prefix@} List of variables whose names begin with prefix.

${var:pos},${var:pos:len} Starting at position pos (0-based) in variable var, extract len characters, or extract rest of string if no len. pos and len may be arithmetic ｅxpressions.When var is * or @, the expansion is performed upon the positional parameters. If pos is zero, then $0 is included in the resulting list. Similarly, var can be an array indexed by * or @.

${var/pat/repl} Use value of var, with first match of pat replaced with repl.

${var/pat} Use value of var, with first match of pat deleted.

${var//pat/repl} Use value of var, with every match of pat replaced with repl.

${var/#pat/repl} Use value of var, with match of pat replaced with repl. Match must occur at beginning of the value.

${var/%pat/repl} Use value of var, with match of pat replaced with repl. Match must occur at end of the value.

${!var} Use value of var as name of variable whose value should be used (indirect reference).

Bash provides a special syntax that lets one variable indirectly reference another:

$ greet=”hello, world” Create initial variable

$ friendly_message=greet Aliasing variable

$ echo ${!friendly_message} Use the alias

hello, world

Examples

$ u=up d=down blank= Assign values to 3 variables (last is null)

$ echo ${u}root Braces are needed here uproot

$ echo ${u-$d} Display value of u or d; u is set, so print it up

$ echo ${tmp-`date`} If tmp not set, execute date

Mon Apr 12 14:33:16 EDT 2010

$ echo ${blank=”no data”} blank is set, so it is printed (blank line)

$ echo ${blank:=”no data”} blank is set but null, print string

no data

$ echo $blank blank now has a new value

no data

# Take the current directory name and remove the longest

# character string ending with /, which removes the

# leading pathname and leaves the tail

$ tail=${PWD##*/}

# Use a famous word

$ word=supercalifragilisticexpialidocious

# Modify the case of the first character

$ echo ${word^[r-t]}

Supercalifragilisticexpialidocious

# Modify the case of all matching characters

$ echo ${word^^[r-t]}

SupeRcalifRagiliSTicexpialidociouS

Built-in Shell Variables

Built-in variables are automatically set by the shell and are typically used inside shell scripts. Built-in variables can make use of the variable substitution patterns shown previously. Note that the $ is not actually part of the variable name, although the variable is always referenced this way. The following are

available in any Bourne-compatible shell:

$# Number of command-line arguments.

$- Options currently in effect (supplied on command line or to set). The shell sets some options automatically.

$? Exit value of last executed command.

$$ Process number of the shell.

$! Process number of last background command.

$0 First word; that is, the command name. This will have the full pathname if it was found via a PATH search.

$n Individual arguments on command line (positional parameters).

The Bourne shell allows only nine parameters to be referenced directly (n = 1–9); Bash allows n to be greater than 9 if specified as ${n}.

$*, $@ All arguments on command line ($1 $2 …).

“$*” All arguments on command line as one string (“$1 $2…”). The values are separated by the first character in $IFS.

“$@” All arguments on command line, individually quoted (“$1″ “$2″ …).

Bash automatically sets the following additional variables:

$_ Temporary variable; initialized to pathname of script or program being executed. Later, stores the last argument of previous command. Also stores name of matching MAIL file during mail checks.

BASH The full pathname used to invoke this instance of Bash.

BASHOPTS A read-only, colon-separated list of shell options that are currently enabled. Each item in the list is a valid option for shopt -s. If this variable exists in the environment when Bash starts up, it sets the indicated options before executing any startup files.

BASHPID The process ID of the current Bash process. In some cases, this can differ from $$.

BASH_ALIASES Associative array variable. Each element holds an alias defined with the alias command. Adding an element to this array creates a new alias; removing an element removes the corresponding alias.

BASH_ARGC Array variable. Each element holds the number of arguments for the corresponding function or dot-script invocation. Set only in extended debug mode, with shopt –s extdebug. Cannot be unset.

BASH_ARGV An array variable similar to BASH_ARGC. Each element is one of the arguments passed to a function or dot-script. It functions as a stack, with values being pushed on at each call. Thus, the last element is the last argument to the most recent function or script invocation. Set only in extended debug

mode, with shopt -s extdebug. Cannot be unset.

BASH_CMDS Associative array variable. Each element refers to a command in the internal hash table maintained by the hash command. The index is the command name and the value is the full path to the command. Adding an element to this array adds a command to the hash table; removing an element removes the corresponding entry.

BASH_COMMAND The command currently executing or about to be executed. Inside a trap handler, it is the command running when the trap was invoked.

BASH_EXECUTION_STRING The string argument passed to the –c option.

BASH_LINENO Array variable, corresponding to BASH_SOURCE and FUNCNAME. For any given function number i (starting at zero), ${FUNCNAME[i]} was invoked in file ${BASH_SOURCE[i]} on line ${BASH_LINENO[i]}. The information is stored with the most recent function invocation first. Cannot be unset.

BASH_REMATCH Array variable, assigned by the =~ operator of the [[ ]] construct. Index zero is the text that matched the entire pattern. The other

indices are the text matched by parenthesized subｅxpressions. This variable is read-only.

BASH_SOURCE Array variable, containing source filenames. Each element corresponds to those in FUNCNAME and BASH_LINENO. Cannot be unset.

BASH_SUBSHELL This variable is incremented by one each time a subshell or subshell environment is created.

BASH_VERSINFO[0] The major version number, or release, of Bash.

BASH_VERSINFO[1] The minor version number, or version, of Bash.

BASH_VERSINFO[2] The patch level.

BASH_VERSINFO[3] The build version.

BASH_VERSINFO[4] The release status.

BASH_VERSINFO[5] The machine type; same value as in $MACHTYPE.

BASH_VERSION A string describing the version of Bash.

COMP_CWORD For programmable completion. Index into COMP_WORDS, indicating the current cursor position.

COMP_KEY For programmable completion. The key, or final key in a sequence, that caused the invocation of the current completion function.

COMP_LINE For programmable completion. The current command line.

COMP_POINT For programmable completion. The position of the cursor as a character index in $COMP_LINE.

COMP_TYPE For programmable completion. A character describing the type of programmable completion. The character is one of Tab for normal completion, ? for a completions list after two Tabs, ! for the list of alternatives on partial word completion, @ for completions if the word is modified, or % for menu completion.

COMP_WORDBREAKS For programmable completion. The characters that the readline library treats as word separators when doing word completion.

COMP_WORDS For programmable completion. Array variable containing the individual words on the command line.

COPROC Array variable that holds the file descriptors used for communicating with an unnamed coprocess.

DIRSTACK Array variable, containing the contents of the directory stack as displayed by dirs. Changing existing elements modifies the stack, but only pushd and popd can add or remove elements from the stack.

EUID Read-only variable with the numeric effective UID of the current user.

FUNCNAME Array variable, containing function names. Each element corresponds to those in BASH_SOURCE and BASH_LINENO.

GROUPS Array variable, containing the list of numeric group IDs in which the current user is a member.

HISTCMD The history number of the current command.

HOSTNAME The name of the current host.

HOSTTYPE A string that describes the host system.

LINENO Current line number within the script or function.

MACHTYPE A string that describes the host system in the GNU cpu-company-system format.

MAPFILE Default array for the mapfile and readarray commands.

OLDPWD Previous working directory (set by cd).

OPTARG Value of argument to last option processed by getopts.

OPTIND Numerical index of OPTARG.

OSTYPE A string that describes the operating system.

PIPESTATUS Array variable, containing the exit statuses of the commands in the most recent foreground pipeline.

PPID Process number of this shell’s parent.

PWD Current working directory (set by cd).

RANDOM[=n] Generate a new random number with each reference; start with integer n, if given.

READLINE_LINE For use with bind -x. The contents of the editing buffer are available in this variable.

READLINE_POINT For use with bind -x. The index in $READLINE_LINE of the insertion point.

REPLY Default reply; used by select and read.

SECONDS[=n] Number of seconds since the shell was started, or, if n is given, number of seconds since the assignment + n.

SHELLOPTS A read-only, colon-separated list of shell options (for set -o). If set in the environment at startup, Bash enables each option present in the list before reading any startup files.

SHLVL Incremented by one every time a new Bash starts up.

UID Read-only variable with the numeric real UID of the current user.

Other Shell Variables

The following variables are not automatically set by the shell, although many of them can influence the shell’s behavior. You typically use them in your .bash_profile or .profile file, where you can define them to suit your needs. Variables can be assigned values by issuing commands of the form:

variable=value

This list includes the type of value expected when defining these variables:

BASH_ENV If set at startup, names a file to be processed for initialization commands. The value undergoes parameter expansion, command substitution, and arithmetic expansion before being interpreted as a filename.

BASH_XTRACEFD=n File descriptor to which Bash writes trace output (from set -x).

CDPATH=dirs Directories searched by cd; allows shortcuts in changing directories; unset by default.

COLUMNS=n Screen’s column width; used in line edit modes and select lists.

COMPREPLY=(words …) Array variable from which Bash reads the possible completions generated by a completion function.

EMACS If the value starts with t, Bash assumes it’s running in an Emacs buffer and disables line editing.

ENV=file Name of script that is executed at startup in POSIX mode or when Bash is invoked as /bin/sh; useful for storing alias and function definitions. For example, ENV=$HOME/.shellrc.

FCEDIT=file Editor used by fc command. The default is /bin/ed when Bash is in POSIX mode. Otherwise, the default is $EDITOR if set, vi if unset.

FIGNORE=patlist Colon-separated list of patterns describing the set of filenames to ignore when doing filename completion.

GLOBIGNORE=patlist Colon-separated list of patterns describing the set of filenames to ignore during pattern matching.

HISTCONTROL=list Colon-separated list of values controlling how commands are saved in the history file. Recognized values are ignoredups, ignorespace, ignoreboth, and erasedups.

HISTFILE=file File in which to store command history.

HISTFILESIZE=n Number of lines to be kept in the history file. This may be different from the number of commands.

HISTIGNORE=list A colon-separated list of patterns that must match the entire command line. Matching lines are not saved in the history file. An unescaped & in a pattern matches the previous history line.

HISTSIZE=n Number of history commands to be kept in the history file.

HISTTIMEFORMAT=string A format string for strftime(3) to use for printing timestamps along with commands from the history command. If set (even if null), Bash saves timestamps in the history file along with the commands.

HOME=dir Home directory; set by login (from /etc/passwd file).

HOSTFILE=file Name of a file in the same format as /etc/hosts that Bash should use to find hostnames for hostname completion.

IFS=’chars’ Input field separators; default is space, Tab, and newline.

IGNOREEOF=n Numeric value indicating how many successive EOF characters must be typed before Bash exits. If null or nonnumeric value, default is 10.

INPUTRC=file Initialization file for the readline library. This overrides the default value of ~/.inputrc.

LANG=locale Default value for locale; used if no LC_* variables are set.

LC_ALL=locale Current locale; overrides LANG and the other LC_* variables.

LC_COLLATE=locale Locale to use for character collation (sorting order).

LC_CTYPE=locale Locale to use for character class functions.

LC_MESSAGES=locale Locale to use for translating $”…” strings.

LC_NUMERIC=locale Locale to use for the decimal-point character.

LC_TIME=locale Locale to use for date and time formats.

LINES=n Screen’s height; used for select lists.

MAIL=file Default file to check for incoming mail; set by login.

MAILCHECK=n Number of seconds between mail checks; default is 600 (10 minutes).

MAILPATH=files one or more files, delimited by a colon, to check for incoming mail. Along with each file, you may supply an optional message that the shell prints when the file increases in size. Messages are separated from the filename by a ? character, and the default message is You have mail in $_. $_ is replaced with the name of the file. For example, you might have MAIL PATH=”$MAIL?Candygram!:/etc/motd?New Login Message” OPTERR=n When set to 1 (the default value), Bash prints error messages from the built-in getopts command.

PATH=dirlist one or more pathnames, delimited by colons, in which to search for commands to execute. The default for many systems is /bin:/usr/bin. on Solaris, the default is /usr/bin:. However, the standard startup scripts change it to /usr/bin:/usr/ucb:/etc:.

POSIXLY_CORRECT=string When set at startup or while running, Bash enters POSIX mode, disabling behavior and modifying features that conflict with the POSIX standard.

PROMPT_COMMAND=command If set, Bash executes this command each time before printing the primary prompt.

PROMPT_DIRTRIM=n Indicates how many trailing directory components to retain for the \w or \W special prompt strings. Elided components are replaced with an ellipsis.

PS1=string Primary prompt string; default is $.

PS2=string Secondary prompt (used in multiline commands); default is >.

PS3=string Prompt string in select loops; default is #?.

PS4=string Prompt string for execution trace (bash –x or set -x); default is +.

SHELL=file Name of user’s default shell (e.g., /bin/sh). Bash sets this if it’s not in the environment at startup.

TERM=string Terminal type.

TIMEFORMAT=string A format string for the output from the time keyword.

TMOUT=n If no command is typed after n seconds, exit the shell. Also affects the read command and the select loop.

TMPDIR=directory Place temporary files created and used by the shell in directory.

auto_resume=list Enables the use of simple strings for resuming stopped jobs. With a value of exact, the string must match a command name exactly. With a value of substring, it can match a substring of the command name.

histchars=chars Two or three characters that control Bash’s csh-style history expansion. The first character signals a history event, the second is the “quick substitution” character, and the third indicates the start of a comment. The default value is !^#.

Related Posts:

• Bash Shell Built-in Shell Variables For Scripting
• How To match a pattern in a string in Bash
• Reading a File in bash | Shell script

Related posts:

1. Bash Shell Built-in Shell Variables For Scripting
2. How To match a pattern in a string in Bash
3. How To Use Arrays In Bash Scripting | Linux
4. Basic Shell Scripting/Programming Steps And Use Of Shell Commands
5. Reading a File in bash | Shell script

출처:http://www.techpaste.com/2013/01/variables-bash-shell-scripting/