Table of Contents

1. search string in files from current directory (use more to view the result)
2. Creating a Script
3. Making a Script Executable
4. Shell Syntax
   1. Variables: strings, numbers, environments, and parameters
      1. Quoting
      2. Environment Variables
      3. Parameter Variables
   2. Conditions: shell Booleans
      1. [The test or Command
   3. Program Control Structures: if, elif, for, while, until, case
      1. if, elif
      2. for
      3. while
      4. until
      5. case
      6. Lists
   4. Functions
      1. break
      2. The : Command (colon)
      3. continue
      4. The . Command
      5. echo
      6. eval
      7. exec
      8. exit n
      9. export
      10. expr
      11. printf
      12. return
      13. set
      14. shift
      15. trap
      16. unset
   5. Commands built into the shell
      1. find
      2. grep (general regular expression parser)
   6. Getting the result of a command
      1. Arithmetic Expansion
      2. Parameter Expansion
   7. Here documents

search string in files from current directory (use more to view the result)

• grep -l STRING * # replace STRING with the string you want to match
• more `grep -l STRING *`
• more $(grep -l STRING *)
• grep -l STRING * | more

Creating a Script

• # as comment
• first line: #!/bin/bash #! is special, which tellls the system that the argument that follows on the line is the program to be used to execute this file
• example: for file in * do if grep -q STRING $file then echo$file fi done exit 0 # zero denotes success in shell programming
• script can contain any Linux commands referenced by PATH environment variable
• script filename doesn't have to be ".sh", use file command to check the type of the file

Making a Script Executable

• /bin/bash xxx.sh
• chmod +x xxx.sh
• put the script in /home/yang/yangbin, add yangbin to PATH, then you can use the script
• add script to /usr/local/bin to let other users use it

Shell Syntax

Variables: strings, numbers, environments, and parameters

• create variables by using them, don't usually declare variables before using them
• by default, all variables are considered and stored as strings (even they are assigned numeric values)
• case-sensitive
• a string must be delimited by quote marks "" if it contains spaces, say "Yang Shen"
• there can't be any spaces on either side of the equals sign myname = "Yang Shen" -> wrong myname="Yang Shen" -> correct
• assign user input to a variable by using read command: $read name who's yang?$ echo $name who's yang?

Quoting

• white characters (e.g., a space, a tab, or a newline character)
• if you want a parameter to contain one or more whitespace characters, you must quote the parameter
• the behavior of variables such as $foo inside quotes depends on the type of quotes you use: double quotes: "$foo", it's replaced with its value single quotes: '$foo', no substitution takes place, just '$foo' remove special meaning of $symbol by prefacing it with a \\: \\$

Environment Variables

Parameter Variables

If no parameters are passed, $# still exists but has a value of 0.

• example: IFS='' set foo bar bam echo "$@" # foo bar bam echo "$*" # foobarbam unset IFS echo "$@" # foo bar bam

Conditions: shell Booleans

The test or [ Command

check whether a file exists

• if test -f xxx.c then … fi
• if [ -f xxx.c ] # you must put spaces between [ braces and the condition being checked then … fi

• # use semicolon if [ -f xxx.c ]; then …; fi

• Condition types: string comparison, arithmetic comparison, and file conditionals

  str for string, exp for expression

  String Comparison	Result
  str1 = str2
  str1 != str2
  -n str	True if str is not null
  -z str	True if string is null (an empty string)
  Arithmetic Comparison	Result
  exp1 -eq exp2	True if expressions are equal
  exp1 -ne exp2	True if expressions are not equal
  exp1 -gt exp2	greater than
  exp1 -ge exp2	greater than or equal
  exp1 -lt exp2	less than
  exp1 -le exp2	less than or equal
  ! exp
  File Conditional	Result
  -d file	True if file is a directory
  -e file	True if file exists (not portable, -f usually used)
  -f file	True if file is a regular file
  -g file	True if set-group-id (set-gid) is set on file
  -r file	True if file is readable
  -s file	True if file has nonzero size
  -u file	True if set-user-id (set-uid) is set on file
  -w file	True if file is writable
  -x file	True if file is executable

Program Control Structures: if, elif, for, while, until, case

if, elif

if condition then statements # you can use extra white space to indent, shell ignores the additional white space elif statements else statements fi

1. A Problem with Variables

   • example: if [ $answer = "yes" ] it's not a valid condition, use if [ "$answer" = "yes" ]

2. echo command to delete the trailing new line

   bash allows "echo -n" to suppress the new line

for

for variable in values do statements done

1. example 1

   for foo in bar fud 43 do echo $foo done exit 0

   ---

   output: bar fud 43

2. example 2

   for file in $(ls f\*.sh); do lpr$file done exit 0

while

while condition do statements done

until

until condition do statements done

• if a loop should always execute at least once, use while loop; if it may not need to execute at all, use an until loop

case

case variable in pattern [ | pattern] …) statements;; # end with ;; pattern [ | pattern] …) statements;; … esac

• case executes the first match it finds, not the best match, so put the most explicit matches first and the most general match last
• example

case "$input" in [yY] | [Yy][Ee][Ss]) echo "powerful match";; yes) echo "entered yes";; no ) echo "entered no";; y ) echo "entered y";; n ) echo "entered n";; Y | Yes | YES) echo "hahaha";; echo "you typed Y or Yes or YES" ;; n* | N*) echo "jajaja";;

• ) echo "please type yes(y) or no(n)" exit 1 ;; # optional

esac exit 0

• ;; before esac is optional

Lists

• example 1:

if [ -f this_file ]; then if [ -f that_file ]; then if [ -f the_otherfile ]; then echo “All files present, and correct” fi fi fi

• example 2:

if [ -f this_file ]; then foo=”True” elif [ -f that_file ]; then foo=”True” elif [ -f the_otherfile ]; then foo=”True” else foo=”False” fi if [ “$foo” = “True” ]; then echo “One of the files exists” fi

1. The AND List

   statement1 && statement2 && statement3 && …

2. The OR List

   statement1 || statement2 || statement3 || …

3. Statement Blocks

   enclosing statements in braces {} to make a statement block, for example: get_confirm && { grep -v "$cdcatnum"$track_file > $temp_file cat$temp_file > $tracks_file echo add_recordtracks }

Functions

function_name () { statements }

• example:

#!/bin/bash foo() { echo "Function foo is executing" } echo "script starting" foo echo "script ended" exit 0

• always define a function before invoking it
• use return to return numeric values
• use echo to return strings
• declare local variables within shell functions by using the local keyword (only in scope within the function)

#!/bin/bash sample_text="global variable" foo() { local sample_text="local variable" echo "Function foo is executing" echo $sample_text } echo "script starting" echo$sample_text foo echo "script ended" echo $sample_text exit 0

break

• Use break for escaping from an enclosing for, while, or until loop before the controlling condition has been met.
• You can give break an additional numeric parameter, which is the number of loops to break out of (not suggested)

The : Command (colon)

• The colon command is a null command. It's occasionally useful to simplify the logic of conditions, being an alias for true.
• Since : is built-in, : runs faster than true. For example, while : implements an infinite loop (while true)

• The : construct is also useful in the conditional setting of variables. For example,

  ${var:=value}

Without the :, the shell would try to evaluate $var as a command.

continue

• similar to break

The . Command

• The dot(.) command executes the command in the current shell: . ./shell_script
• works a little like #include in C/C++

echo

• echo -n
• echo -e

eval

• evaluate arguments, it's built into the shell and doesn't normally exist as a separate command.
• example

foo=10 x=foo y='$'$x echo $y #$foo eval y='$'$x echo $y # 10

• eval is a bit like an extra $
• eval command is very useful, enabling code to be generated and run on-the-fly

exec

two different uses

1. typical use is to replace the current shell with a different program

   exec wall "Thanks for all the fish" in a script will replace the current shell with the wall command. No lines in the script after exec will be processed, because the shell that was executing the script no longer exists.

2. second use is to modify the current file descriptors

   exec 3< afile This causes file descriptor three to be opened for reading from file afile. It's rarely used.

exit n

• exit command causes the script to exit with exit code n
• in shell script programming, exit code

Using 0 as success may seem a little unusual to C/C++. The big advantage in scripts is that they enable you to use 125 user-defined error codes without the need for a global error code variable.

• example

#!/bin/bash if [ -f .profile ]; then exit 0 fi exit 1

export

The export command makes the variable named as its parameter available in subshells. By default, variables created in a shell are not available in further (sub)shells invoked from that shell.

• example

export2.sh #!/bin/bash echo "$foo" echo "$bar" export1.sh #!/bin/bash foo="hello" export bar="hola" export2 The output is:

hola

expr

The expr command evaluates its arguments as an expression. It's most commonly used for simple arithmetic in the following form: x=`expr $x + 1`

1. Expression Evaluation

   • | & = > >= < <= != + - * / %
   • the use of expr is normally replaced with the more efficient $((…)) syntax

printf

• syntax

printf "format string" parameter1 parameter2 …

• very similar to C/C++, floating point is not supported (all arithmetic in the shell is performed as integers)

return

• return takes a single numeric parameter that is available to the script calling the function
• if no parameter is specified, then return defaults to the exit code of the last command

set

• The set command sets the parameter variables for the shell. It can be a useful way of using fields in commands that output space-separated values.
• example

#!/bin/bash echo the date is $(date) # Tue Feb 6 21:24:31 CST 2018 set$(date) echo The month is $2 # Feb exit 0

• set -x

makes a script display a trace of its currently executing command

shift

The shift command moves all the parameter variables down by one, so that $2 becomes$1, $3 becomes$2, and so on. The previous value of $1 is discarded, while$0 remains unchanged. If a numeric parameter is specified in the call to shift, the parameters move that many spaces. The other variables, $\*,$@, and $#, are also modified in line with the new arrangement of parameter variables.

• shift is often useful for scanning through parameters passed into a script
• if your script requires 10 or more parameters, you'll need shift to access the tenth and beyond
• example

#!/bin/bash while [ "$1" != "" ]; do echo "$1" shift done exit 0

trap

The trap command is used to specify the actions to take on receipt of signals. A common use is to tidy up a script when it is interrupted.

unset

The unset command removes variables or functions from the environment. It can't do this to read-only variables defined by the shell itself, such as IFS. It's not often used.

Commands built into the shell

find

search for files, syntax: find [path] [options] [tests] [actions] for example, find ~/ -name test -print

• find . -newer file2 -type f -exec ls -l {} \;

grep (general regular expression parser)

search files for strings, syntax: grep [options] PATTERN [FILES] If no filenames are given, it searches standard input.

• grep in words.txt # find lines with "in" in words.txt

• Regular Expressions

  Character	Meaning
  ^	Anchor to the beginning of a line
  $	Anchor to the end of a line
  .	Any single character
  [ ]	A range of characters, any one of which may be matched.
  Match Pattern	Meaning
  [:alnum:]	Alphanumeric characters
  [:alpha:]	Letters
  [:ascii:]	ASCII characters
  [:blank:]	Space or tab
  [:cntrl:]	ASCII control characters
  [:digit:]	Digits
  [:graph:]	Noncontrol, nonspace characters
  [:lower:]	Lowercase letters
  [:print:]	Printable characters
  [:punct:]	Punctuation characters
  [:space:]	Whitespace characters, including vertical tab
  [:upper:]	Uppercase letters
  [:xdigit:]	Hexadecimal digits

  If -E is specified,

  Option	Meaning
  ?	Match is optional but maybe matched at most once
  *	Must be matched zero or more times
  +	Must be matched one or more times
  {n}	Must be matched n times
  {n,}	Must be matched n or more times
  {n,m}	Must be matched between n or m times, inclusive

  • grep "e$" myfile.txt # list lines end with "e"
  • grep "^aa" myfile.txt # list lines start with "aa"
  • grep "a[ [:blank:] ]" myfile.txt # lines with "a " or "a TAB"
  • grep ysh. myfile.txt # lines with "ysh.", "." match any single character
  • grep -E [a-z]\{10\} myfile.txt # lines with a range of characters to match a to z, and a reptition of 10 matches, i.e., string [a-z] with length 10

Getting the result of a command

Use $(command) syntax.

• example

#!/bin/bash echo pwd is $PWD # PWD is shell environment variable, no need to use () echo current user is$(whoami) # need () exit 0

Arithmetic Expansion

• using expr mentioned above, but it's quite slow because a new shell is invoked to process the expr command
• a newer and better alternative is $((&#x2026;)) expansion, by enclosing the expression you wish to evaluate in$((…))
• example

#!/bin/bash x=0 while [ "$x" -ne 10 ]; do echo$x x=$(($x+1)) done exit 0

Parameter Expansion

• example

#!/bin/bash unset foo echo ${foo:-bar} foo=fud echo${foo:-bar} foo=/usr/bin/X11/startx echo ${foo#\*/} echo${foo##*/} bar=/usr/local/etc/local/networks echo ${bar%local\*} echo${bar%%local*} exit 0

Here documents