{"id":6138,"date":"2018-04-11T20:40:43","date_gmt":"2018-04-11T20:40:43","guid":{"rendered":"http:\/\/putridparrot.com\/blog\/?p=6138"},"modified":"2018-04-11T20:40:43","modified_gmt":"2018-04-11T20:40:43","slug":"shell-scripting-linux","status":"publish","type":"post","link":"https:\/\/putridparrot.com\/blog\/shell-scripting-linux\/","title":{"rendered":"Shell scripting (Linux)"},"content":{"rendered":"

The shell script file<\/strong><\/p>\n

By default we name a script file with the .sh extension and the first line is usually (although not strictly required) to be one of the following<\/p>\n

\r\n#!\/bin\/sh\r\n\r\nOR\r\n\r\n#!\/bin\/bash\r\n<\/pre>\n
The use of sh<\/em> tells Linux we want to run the script with the default shell script . Note that this might be dash, bash, bourne or any other shell available, hence when using sh<\/em> the developer of the script needs to be aware that they cannot expect bash (for example) capabilities to exist and therefore if bash specific code exists within the script the #!\/bin\/bash<\/em> line should be used.<\/p>\n
Note: #! is known as the sha-bang<\/em><\/p>\n
What shell am I running?<\/strong><\/p>\n
You can use $SHELL<\/em> in your scripts or from the command line, for example<\/p>\n
\r\necho $SHELL\r\n<\/pre>\n
Making the script executable<\/strong><\/p>\n
\r\nchmod 777 myscript.sh\r\n<\/pre>\n
Comments<\/strong><\/p>\n
Comments are denoted by #. Anything after the # until a new line, will be seen as a comment, i.e.<\/p>\n
\r\necho "Some text" # write to stdout "Some text"\r\n<\/pre>\n
Variables<\/strong><\/p>\n
We can create variables, which are case-sensitive, like this<\/p>\n
\r\nVARIABLE1="Hello"\r\nvariable2="World"\r\n\r\necho $VARIABLE1 $variable2\r\n<\/pre>\n
Note: You should not have spaces between the = operator or the command may not found. So for example this will fail VARIABLE1 = “Hello”<\/em><\/p>\n
Whilst we can use variables that are not strings, underneath they’re stored as strings and only converted to numerical values when used with numerical functions etc.<\/p>\n
So for example<\/p>\n
\r\ni=0\r\n$i=$i+1\r\n<\/pre>\n
will fail with 0=0+1: command not found<\/em>. To increment a variable (for example) we need to use the following syntax<\/p>\n
\r\nlet "i=i+1"\r\n#OR\r\ni=$((i+1))\r\n<\/pre>\n
we can also use postfix operators, i.e. ++ or += such as <\/p>\n
\r\nlet "i++"\r\n#OR\r\n((i++))\r\n#OR\r\nlet "i+=1"\r\n#OR\r\n((i+=1))\r\n<\/pre>\n
We can also create arrays using the following syntax<\/p>\n
\r\na=("a" "b" "c")\r\n<\/pre>\n
and an example of indexing into this array is as follows<\/p>\n
\r\necho "Array element at index 1 is ${array[1]}"\r\n# outputs Array element at index 1 is b\r\n<\/pre>\n
We can also remove or unset<\/em> a variables like this<\/p>\n
\r\nunset i\r\n<\/pre>\n
Logic operations<\/strong><\/p>\n
IF, THEN, ELSE, ELIF…<\/p>\n
As our scripts become more capable\/complex it’s likely we’ll want to use some logic and branching code, i.e. IF, THEN, ELSE, ELIF code. Let’s look at an example of IF, THEN syntax<\/p>\n
\r\nif [ $i = 6 ] \r\nthen \r\n   echo "i is correctly set to 6" \r\nfi\r\n<\/pre>\n
Note: after the space after the [ and before ] without this the script will error with command not found.<\/em><\/p>\n
The [ ] syntax is the way you’ll often see this type of operation, from my understanding this is actual an alternate syntax to test i=6<\/em>, so for example<\/p>\n
\r\ntest i=6; echo "i is correctly set to 6"\r\n<\/pre>\n
Note: the example above shows the test on a single line, in this case the ; is used to denote the end of the line.<\/em><\/p>\n
We can use = or -eq<\/em> along with less than, greater than etc. however these standard operators are to be set to use a string comparisons, i.e. we do not use <, instead we use -lt<\/em> for non-strings, like wise = will do a string comparisons whereas -eq<\/em> will handle numerical comparisons. <\/p>\n
We can also use ELSE for example<\/p>\n
\r\nif [ ! -d "BAK" ]\r\nthen\r\n   echo "BAK does not exist"\r\nelse   \r\n   echo "BAK exists"\r\nfi\r\n<\/pre>\n
and finally ELIF<\/p>\n
\r\nif [ -d "BAK" ]\r\nthen\r\n   echo "BAK exists"\r\nelif [ -d "BACK" ]\r\n   echo "BACK exists"\r\nfi\r\n<\/pre>\n
Checkout If Statements!<\/a> which has a list of the operators in more depth.<\/p>\n
[[ ]] vs [ ]<\/strong><\/p>\n
The [ ] is actually just an alias for test<\/em> as mentioned above. BASH and some other shells also support [[ ]] syntax which is more powerful. See What is the difference between test, [ and [[ ?<\/a> for more information.<\/p>\n
Case (switch)<\/strong><\/p>\n
Extending the IF, THEN, ELSE, ELIF we also have a switch style comparison capability, for example<\/p>\n
\r\ncase $response in\r\n   y|Y) echo "Executing script" ;;\r\n   *) exit ;;\r\nesac\r\n<\/pre>\n
The syntax for y|Y)<\/em> is pattern matching and ) terminates the pattern. This is followed by one or more statements to be executed followed by the ;;<\/em> terminator. The *)<\/em> means match against anything else (or default condition). We then terminate the case block with esac<\/em>. So in this example we’ll output “Executing script” if the response<\/em> variable is either y<\/em> or Y<\/em>.<\/p>\n
Loops<\/strong><\/p>\n
We can run commands in loops such as for<\/em>, while<\/em> and until<\/em>.<\/p>\n
While and Until are very similar except that while keeps looping whilst a condition is true whereas until loops, until a condition is true. Here’s a couple of simple examples<\/p>\n
\r\ni=0\r\nwhile [ $i -lt 10 ]\r\ndo\r\n   echo $i\r\n   ((i++))\r\ndone\r\n\r\nuntil [ $i -lt 0 ]\r\ndo\r\n   echo $i\r\n   ((i--))\r\ndone\r\n<\/pre>\n
for<\/em> loops using a similar syntax again, except they use the in<\/em> keyword, for example<\/p>\n
\r\narray=("a" "b" "c")\r\nfor item in ${array[@]}\r\ndo\r\n  echo $item\r\ndone\r\n<\/pre>\n
This example demonstrates looping through an array, but we can also loop through items returned by shell commands, for example<\/p>\n
\r\nfor item in $(ls -a)\r\ndo\r\n   echo $item\r\ndone\r\n<\/pre>\n
In this example we’re looping through the results of the command ls -a<\/em>. Although a better solution to this might be<\/p>\n
\r\nfor item in ${PWD}\/*\r\ndo\r\n   echo $item\r\ndone\r\n<\/pre>\n
The ls<\/em> version returns multiple items for a file name with spaces, so not too useful if we want each file name including spaces.<\/p>\n
Here’s a final example using using the back tick (`) which can be used to enclose commands, for example in this instance we execute the command seq 1 10<\/em><\/p>\n
\r\nfor item in `seq 1 10`;\r\ndo\r\n   echo $item\r\ndone   \r\n<\/pre>\n
Passing arguments to your shell script<\/strong><\/p>\n
Arguments are passed into your script via the command line as you’d normal do, i.e. in this example my shell script (myscript.sh) takes two arguments Hello<\/em> and World<\/em><\/p>\n
\r\n.\/myscript.sh Hello World \r\n<\/pre>\n
To reference the arguments in the script we simply use $1<\/em> and $2<\/em>. i.e.<\/p>\n
\r\necho $1 # Should be Hello\r\necho $2 # Should be World\r\n<\/pre>\n
There also there’s also the $@ which denotes all arguments, i.e. <\/p>\n
\r\necho "$@" \r\n<\/pre>\n
Will output all the arguments passed into the script or function.<\/p>\n
Functions<\/strong><\/p>\n
We can create functions inside our shell scripts and\/or include other script files which have functions etc. within.<\/p>\n
You need to declare the function before usage and writing a function is pretty simple, i.e.<\/p>\n
\r\nsay_hello()\r\n{\r\n    echo "say_hello called"\r\n}\r\n\r\nsay_hello\r\n<\/pre>\n
To include arguments\/parameters we use the same system as passing arguments via the command line, so for example<\/p>\n
\r\nsay_something()\r\n{\r\n    echo "say_something says $1 $2"\r\n}\r\n\r\nsay_something Hello World\r\n# outputs say_something says Hello World\r\n<\/pre>\n
here we see the arguments are turned into the $1 and $2 variables, but of course local to our function.<\/p>\n
STDIN\/STDOUT\/STDERR<\/strong><\/p>\n
We’ve already seen that echo<\/em> is the equivalent of output to STDOUT in it’s default usage, although in can be used to output to STDERR, see Illustrated Redirection Tutorial<\/a>.<\/p>\n
We can use read<\/a><\/em> to read input from the user\/command line via STDIN. <\/p>\n
In it’s most basic use we can write the following<\/p>\n
\r\nread input \r\n<\/pre>\n
Where input<\/em> is a variable name.<\/p>\n
We can also use it in slightly more powerful ways, such as <\/p>\n
\r\nread -n1 -p "Are you sure you wish to continue (y\/n)?" input\r\n<\/pre>\n
In this case we read a single character (-n1<\/em>) with the prompt (-p<\/em>) “Are you sure you wish to continue (y\/n)?” into the variable named input<\/em>.<\/p>\n
The read<\/em> function can also be used to read data from a file by using a file descriptor and the argument -u<\/em>.<\/p>\n
References<\/strong><\/p>\n
Loops for, while and until<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
The shell script file By default we name a script file with the .sh extension and the first line is usually (although not strictly required) to be one of the following #!\/bin\/sh OR #!\/bin\/bash The use of sh tells Linux we want to run the script with the default shell script . Note that this […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[212],"tags":[],"class_list":["post-6138","post","type-post","status-publish","format-standard","hentry","category-shell-script"],"jetpack_sharing_enabled":true,"jetpack_featured_media_url":"","_links":{"self":[{"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/posts\/6138","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/comments?post=6138"}],"version-history":[{"count":23,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/posts\/6138\/revisions"}],"predecessor-version":[{"id":6165,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/posts\/6138\/revisions\/6165"}],"wp:attachment":[{"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/media?parent=6138"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/categories?post=6138"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/putridparrot.com\/blog\/wp-json\/wp\/v2\/tags?post=6138"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}