The Bourne shell (\/bin\/sh) is present on all Unix installations and scripts written in this language are (quite) portable; man 1 sh is a good reference.
\nBasics<\/p>\n
Variables and arguments<\/p>\n
Assign with variable=value and get content with $variable
\nMESSAGE=”Hello World” # Assign a string
\nPI=3.1415 # Assign a decimal number
\nN=8
\nTWON=`expr $N * 2` # Arithmetic expression (only integers)
\nTWON=$(($N * 2)) # Other syntax
\nTWOPI=`echo “$PI * 2” | bc -l` # Use bc for floating point operations
\nZERO=`echo “c($PI\/4)-sqrt(2)\/2” | bc -l`
\nThe command line arguments are
\n$0, $1, $2, … # $0 is the command itself
\n$# # The number of arguments
\n$* # All arguments (also $@)
\nSpecial Variables<\/p>\n
$$ # The current process ID
\n$? # exit status of last command
\ncommand
\nif [ $? != 0 ]; then
\necho “command failed”
\nfi
\nmypath=`pwd`
\nmypath=${mypath}\/file.txt
\necho ${mypath##*\/} # Display the filename only
\necho ${mypath%%.*} # Full path without extention
\nfoo=\/tmp\/my.dir\/filename.tar.gz
\npath = ${foo%\/*} # Full path without extention
\nvar2=${var:=string} # Use var if set, otherwise use string
\n# assign string to var and then to var2.
\nsize=$(stat -c%s “$file”) # get file size in bourne script
\nfilesize=${size:=-1}
\nConstructs<\/p>\n
for file in `ls`
\ndo
\necho $file
\ndone<\/p>\n
count=0
\nwhile [ $count -lt 5 ]; do
\necho $count
\nsleep 1
\ncount=$(($count + 1))
\ndone<\/p>\n
myfunction() {
\nfind . -type f -name “*.$1” -print # $1 is first argument of the function
\n}
\nmyfunction “txt”
\nGenerate a file<\/p>\n
MYHOME=\/home\/colin
\ncat > testhome.sh << _EOF
\n# All of this goes into the file testhome.sh
\nif [ -d “$MYHOME” ] ; then
\necho $MYHOME exists
\nelse
\necho $MYHOME does not exist
\nfi
\n_EOF
\nsh testhome.sh
\nBourne script example<\/p>\n
As a small example, the script used to create a PDF booklet from this xhtml document:
\n#!\/bin\/sh
\n# This script creates a book in pdf format ready to print on a duplex printer
\nif [ $# -ne 1 ]; then # Check the argument
\necho 1>&2 “Usage: $0 HtmlFile”
\nexit 1 # non zero exit if error
\nfi<\/p>\n
file=$1 # Assign the filename
\nfname=${file%.*} # Get the name of the file only
\nfext=${file#*.} # Get the extension of the file<\/p>\n
prince $file -o $fname.pdf # from www.princexml.com
\npdftops -paper A4 -noshrink $fname.pdf $fname.ps # create postscript booklet
\ncat $fname.ps |psbook|psnup -Pa4 -2 |pstops -b “2:0,1U(21cm,29.7cm)” > $fname.book.ps<\/p>\n
ps2pdf13 -sPAPERSIZE=a4 -sAutoRotatePages=None $fname.book.ps $fname.book.pdf
\n# use #a4 and #None on Windows!
\nexit 0 # exit 0 means successful
\nSome awk commands<\/p>\n
Awk is useful for field stripping, like cut in a more powerful way. Search this document for other examples. See for example gnulamp.com and one-liners for awk for some nice examples.
\nawk ‘{ print $2, $1 }’ file # Print and inverse first two columns
\nawk ‘{printf(“%5d : %s\\n”, NR,$0)}’ file # Add line number left aligned
\nawk ‘{print FNR “\\t” $0}’ files # Add line number right aligned
\nawk NF test.txt # remove blank lines (same as grep ‘.’)
\nawk ‘length > 80’ # print line longer than 80 char)
\nSome sed commands<\/p>\n
Here is the one liner gold minehttp:\/\/student.northpark.edu\/pemente\/sed\/sed1line.txt. And a good introduction and tutorial to sedhttp:\/\/www.grymoire.com\/Unix\/Sed.html.
\nsed ‘s\/string1\/string2\/g’ # Replace string1 with string2
\nsed -i ‘s\/wroong\/wrong\/g’ *.txt # Replace a recurring word with g
\nsed ‘s\/\\(.*\\)1\/\\12\/g’ # Modify anystring1 to anystring2
\nsed ‘\/<\/p>\n
\/,\/<\\\/p>\/d’ t.xhtml # Delete lines that start with<\/p>\n
# and end with<\/p>\n
sed ‘\/ *#\/d; \/^ *$\/d’ # Remove comments and blank lines
\nsed ‘s\/[ \\t]*$\/\/’ # Remove trailing spaces (use tab as \\t)
\nsed ‘s\/^[ \\t]*\/\/;s\/[ \\t]*$\/\/’ # Remove leading and trailing spaces
\nsed ‘s\/[^*]\/[&]\/’ # Enclose first char with [] top->[t]op
\nsed = file | sed ‘N;s\/\\n\/\\t\/’ > file.num # Number lines on a file
\nRegular Expressions<\/p>\n
Some basic regular expression useful for sed too. See Basic Regex Syntaxhttp:\/\/www.regular-expressions.info\/reference.html for a good primer.
\n[\\^$.|?*+() # special characters any other will match themselves
\n\\ # escapes special characters and treat as literal
\n* # repeat the previous item zero or more times
\n. # single character except line break characters
\n.* # match zero or more characters
\n^ # match at the start of a line\/string
\n$ # match at the end of a line\/string
\n.$ # match a single character at the end of line\/string
\n^ $ # match line with a single space
\n[^A-Z] # match any line beginning with any char from A to Z
\nSome useful commands<\/p>\n
The following commands are useful to include in a script or as one liners.
\nsort -t. -k1,1n -k2,2n -k3,3n -k4,4n # Sort IPv4 ip addresses
\necho ‘Test’ | tr ‘[:lower:]’ ‘[:upper:]’ # Case conversion
\necho foo.bar | cut -d . -f 1 # Returns foo
\nPID=$(ps | grep script.sh | grep bin | awk ‘{print $1}’) # PID of a running script
\nPID=$(ps axww | grep [p]ing | awk ‘{print $1}’) # PID of ping (w\/o grep pid)
\nIP=$(ifconfig $INTERFACE | sed ‘\/.*inet addr:\/!d;s\/\/\/;s\/ .*\/\/’) # Linux
\nIP=$(ifconfig $INTERFACE | sed ‘\/.*inet \/!d;s\/\/\/;s\/ .*\/\/’) # FreeBSD
\nif [ `diff file1 file2 | wc -l` != 0 ]; then […] fi # File changed?
\ncat \/etc\/master.passwd | grep -v root | grep -v \\*: | awk -F”:” \\ # Create http passwd
\n‘{ printf(“%s:%s\\n”, $1, $2) }’ > \/usr\/local\/etc\/apache2\/passwd<\/p>\n
testuser=$(cat \/usr\/local\/etc\/apache2\/passwd | grep -v \\ # Check user in passwd
\nroot | grep -v \\*: | awk -F”:” ‘{ printf(“%s\\n”, $1) }’ | grep ^user$)
\n:(){ :|:& };: # bash fork bomb. Will kill your machine
\ntail +2 file > file2 # remove the first line from file
\nI use this little trick to change the file extension for many files at once. For example from .cxx to .cpp. Test it first without the | sh at the end. You can also do this with the command rename if installed. Or with bash builtins.
\n# ls *.cxx | awk -F. ‘{print “mv “$0” “$1″.cpp”}’ | sh
\n# ls *.c | sed “s\/.*\/cp & &.$(date “+%Y%m%d”)\/” | sh # e.g. copy *.c to *.c.20080401
\n# rename .cxx .cpp *.cxx # Rename all .cxx to cpp
\n# for i in *.cxx; do mv $i ${i%%.cxx}.cpp; done # with bash builtins<\/p>\n
Bourne Shell Reference:<\/p>\n
This file contains short tables of commonly used items in this shell. In
\nmost cases the information applies to both the Bourne shell (sh) and the
\nnewer bash shell.<\/p>\n
Tests (for ifs and loops) are done with [ ] or with the test command.<\/p>\n
Checking files:<\/p>\n
-r file Check if file is readable.
\n-w file Check if file is writable.
\n-x file Check if we have execute access to file.
\n-f file Check if file is an ordinary file (as opposed to a directory,
\na device special file, etc.)
\n-s file Check if file has size greater than 0.
\n-d file Check if file is a directory.
\n-e file Check if file exists. Is true even if file is a directory.<\/p>\n
Example:
\nif [ -s file ]
\nthen
\nsuch and such
\nfi<\/p>\n
Checking strings:<\/p>\n
s1 = s2 Check if s1 equals s2.
\ns1 != s2 Check if s1 is not equal to s2.
\n-z s1 Check if s1 has size 0.
\n-n s1 Check if s2 has nonzero size.
\ns1 Check if s1 is not the empty string.<\/p>\n
Example:
\nif [ $myvar = “hello” ]
\nthen
\necho “We have a match”
\nfi<\/p>\n
Checking numbers:<\/p>\n
Note that a shell variable could contain a string that represents a number.
\nIf you want to check the numerical value use one of the following:<\/p>\n
n1 -eq n2 Check to see if n1 equals n2.
\nn1 -ne n2 Check to see if n1 is not equal to n2.
\nn1 -lt n2 Check to see if n1 < n2.
\nn1 -le n2 Check to see if n1 <= n2.
\nn1 -gt n2 Check to see if n1 > n2.
\nn1 -ge n2 Check to see if n1 >= n2.<\/p>\n
Example:
\nif [ $# -gt 1 ]
\nthen
\necho “ERROR: should have 0 or 1 command-line parameters”
\nfi<\/p>\n
Boolean operators:<\/p>\n
! not
\n-a and
\n-o or<\/p>\n
Example:
\nif [ $num -lt 10 -o $num -gt 100 ]
\nthen
\necho “Number $num is out of range”
\nelif [ ! -w $filename ]
\nthen
\necho “Cannot write to $filename”
\nfi<\/p>\n
Note that ifs can be nested. For example:
\nif [ $myvar = “y” ]
\nthen
\necho “Enter count of number of items”
\nread num
\nif [ $num -le 0 ]
\nthen
\necho “Invalid count of $num was given”
\nelse
\n… do whatever …
\nfi
\nfi<\/p>\n
The above example also illustrates the use of read to read a string from
\nthe keyboard and place it into a shell variable. Also note that most UNIX
\ncommands return a true (nonzero) or false (0) in the shell variable status
\nto indicate whether they succeeded or not. This return value can be checked.
\nAt the command line echo $status. In a shell script use something like this:<\/p>\n
if grep -q shell bshellref
\nthen
\necho “true”
\nelse
\necho “false”
\nfi<\/p>\n
Note that -q is the quiet version of grep. It just checks whether it is true
\nthat the string shell occurs in the file bshellref. It does not print the
\nmatching lines like grep would otherwise do.<\/p>\n
I\/O Redirection:<\/p>\n
pgm > file Output of pgm is redirected to file.
\npgm < file Program pgm reads its input from file.
\npgm >> file Output of pgm is appended to file.
\npgm1 | pgm2 Output of pgm1 is piped into pgm2 as the input to pgm2.
\nn > file Output from stream with descriptor n redirected to file.
\nn >> file Output from stream with descriptor n appended to file.
\nn >& m Merge output from stream n with stream m.
\nn <& m Merge input from stream n with stream m.
\n<< tag Standard input comes from here through next tag at start of line.<\/p>\n
Note that file descriptor 0 is normally standard input, 1 is standard output,
\nand 2 is standard error output.<\/p>\n
Shell Built-in Variables:<\/p>\n
$0 Name of this shell script itself.
\n$1 Value of first command line parameter (similarly $2, $3, etc)
\n$# In a shell script, the number of command line parameters.
\n$* All of the command line parameters.
\n$- Options given to the shell.
\n$? Return the exit status of the last command.
\n$$ Process id of script (really id of the shell running the script)<\/p>\n
Pattern Matching:<\/p>\n
* Matches 0 or more characters.
\n? Matches 1 character.
\n[AaBbCc] Example: matches any 1 char from the list.
\n[^RGB] Example: matches any 1 char not in the list.
\n[a-g] Example: matches any 1 char from this range.<\/p>\n
Quoting:
\n\\c Take character c literally.
\n`cmd` Run cmd and replace it in the line of code with its output.
\n“whatever” Take whatever literally, after first interpreting $, `…`, \\
\n‘whatever’ Take whatever absolutely literally.<\/p>\n
Example:
\nmatch=`ls *.bak` Puts names of .bak files into shell variable match.
\necho \\* Echos * to screen, not all filename as in: echo *
\necho ‘$1$2hello’ Writes literally $1$2hello on screen.
\necho “$1$2hello” Writes value of parameters 1 and 2 and string hello.<\/p>\n
Grouping:<\/p>\n
Parentheses may be used for grouping, but must be preceded by backslashes
\nsince parentheses normally have a different meaning to the shell (namely
\nto run a command or commands in a subshell). For example, you might use:<\/p>\n
if test \\( -r $file1 -a -r $file2 \\) -o \\( -r $1 -a -r $2 \\)
\nthen
\ndo whatever
\nfi<\/p>\n
Case statement:<\/p>\n
Here is an example that looks for a match with one of the characters a, b, c.
\nIf $1 fails to match these, it always matches the * case. A case statement
\ncan also use more advanced pattern matching.<\/p>\n
case “$1” in
\na) cmd1 ;;
\nb) cmd2 ;;
\nc) cmd3 ;;
\n*) cmd4 ;;
\nesac<\/p>\n
Shell Arithmetic:<\/p>\n
In the original Bourne shell arithmetic is done using the expr command as in:
\nresult=`expr $1 + 2`
\nresult2=`expr $2 + $1 \/ 2`
\nresult=`expr $2 \\* 5` (note the \\ on the * symbol)<\/p>\n
With bash, an expression is normally enclosed using [ ] and can use the
\nfollowing operators, in order of precedence:
\n* \/ % (times, divide, remainder)
\n+ – (add, subtract)
\n< > <= >= (the obvious comparison operators)
\n== != (equal to, not equal to)
\n&& (logical and)
\n|| (logical or)
\n= (assignment)
\nArithmetic is done using long integers.<\/p>\n
Example:
\nresult=$[$1 + 3]<\/p>\n
In this example we take the value of the first parameter, add 3, and place
\nthe sum into result.<\/p>\n
Order of Interpretation:<\/p>\n
The bash shell carries out its various types of interpretation for each line
\nin the following order:<\/p>\n
brace expansion (see a reference book)
\n~ expansion (for login ids)
\nparameters (such as $1)
\nvariables (such as $var)
\ncommand substitution (Example: match=`grep DNS *` )
\narithmetic (from left to right)
\nword splitting
\npathname expansion (using *, ?, and [abc] )<\/p>\n
Other Shell Features:<\/p>\n
$var Value of shell variable var.
\n${var}abc Example: value of shell variable var with string abc appended.
\n# At start of line, indicates a comment.
\nvar=value Assign the string value to shell variable var.
\ncmd1 && cmd2 Run cmd1, then if cmd1 successful run cmd2, otherwise skip.
\ncmd1 || cmd2 Run cmd1, then if cmd1 not successful run cmd2, otherwise skip.
\ncmd1; cmd2 Do cmd1 and then cmd2.
\ncmd1 & cmd2 Do cmd1, start cmd2 without waiting for cmd1 to finish.
\n(cmds) Run cmds (commands) in a subshell.<\/p>\n
See a good reference book for information on traps, signals, exporting of
\nvariables, functions, eval, source, etc.<\/p>\n","protected":false},"excerpt":{"rendered":"
The Bourne shell (\/bin\/sh) is present on all Unix installations and scripts written in this language are (quite) portable; man 1 sh is a good reference. Basics<\/p>\n
Variables and arguments<\/p>\n
Assign with variable=value and get content with $variable MESSAGE=”Hello World” # Assign a string PI=3.1415 # Assign a decimal number N=8 TWON=`expr $N * 2` […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[47],"tags":[],"_links":{"self":[{"href":"https:\/\/mohan.sg\/index.php?rest_route=\/wp\/v2\/posts\/3405"}],"collection":[{"href":"https:\/\/mohan.sg\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/mohan.sg\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/mohan.sg\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/mohan.sg\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=3405"}],"version-history":[{"count":3,"href":"https:\/\/mohan.sg\/index.php?rest_route=\/wp\/v2\/posts\/3405\/revisions"}],"predecessor-version":[{"id":4695,"href":"https:\/\/mohan.sg\/index.php?rest_route=\/wp\/v2\/posts\/3405\/revisions\/4695"}],"wp:attachment":[{"href":"https:\/\/mohan.sg\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=3405"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/mohan.sg\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=3405"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/mohan.sg\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=3405"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}