Post on 22-Nov-2014
description
introduction of the shell scriptbasic sh and shell script usage2013 usagi@WonderRabbitProject.net CC0
what's the shell script?
● it's a language○ script language // like a C style
■ procedural model■ function is available■ variable is available■ type system is not available // so text based■ can call an external routine // system call
● it's as same the shell-self○ APIs are commands on the system
if you learned a C style language
● control statements○ loop
■ `for`■ `while` // and `until`
○ conditional branching■ `if`■ `case` // equiv switch
● function and variable○ `f(){}` // equiv `void f(void){}`
■ how to use input params and a return? --> next!○ `ABC=hoge` // equiv `char* ABC = "hoge"`
■ and more --> next!!
how to use function
● how to get input params?○ f(){ echo $1; echo $2; echo $3; }
■ it's equiv in C style:void f(char* a, char* b, char* c){ puts(a); puts(b); puts(c); }
● how to put return value?○ n/a // shell script has not C style return value!
■ but, it has return code as same the system call● how call function?
○ f hoge fuga piyo■ it's equiv in C style
f("hoge", "fuga", "piyo")
return value of function call
● n/a● but, can use static variables and a trick
○ trick# define // it's line comment use the char of `#`f(){ echo "it's return value!"; }# call and get return value trick with backquote '`'RETURN_VALUE = `f`# and printecho $RETURN_VALUE■ what's `$` token?
● --> it's a variable to next!
how to use a variable?
● define a variable○ HOGE=hogehogehoge
FUGA=fugafugafuganum_of_my_awesome_defition=123456
● reference a variable○ echo $HOGE
echo "$HOGE-$FUGA"echo $num_of_my_awesome_definition >> $hoge
variable tips-1
● a variable is only string type○ abc=1234 # quiv to abc="1234"
# it's not a number● writing rules
○ standard definition■ abc=hogehoge # it's ok■ abc = fugafuga # ERROR! it's a function call
# $1='=', $2='fugafuga'; hint is white-space.○ explicit value
■ def='#abc $abc @abc' # equiv: #abc $abc @abc■ def="#abc $abc @abc'
# equiv: #abc fugafuga @abc
variable tips-2
● implicit defined special values○ $1 $2 $3 ...
it's params by a function call or run a script with params.# f(){ echo $1; }// int main(int ac, char** params) { }
○ $#it's number of params# f(){ echo $#; }// int main(int ac, char** params) { }
○ $?it's a last result code (success or else)# echo $?
let's run a shell script
> pwd/home/myname> # it's comment line> my_awesome_variable=1234> echo $my_awesome_variable1234> my_awesome_function(){ echo $1; }> my_awesome_function hogehoge
save to file a shell script
> echo 'echo $1' > my_awesome.sh> cat my_awesome.shecho $1
you can write with the Vim or the other text editor as you like if you want to use.
> vim my_aersome2.sh
run a shell script from a file
● run the other process on the process> sh my_awesome.sh hogehoge> bash my_awesome.sh fugafuga
● run in the process> source my_awesome.sh piyopiyo
environment variable
● variable○ shell-variable
it's only visible from the shell process.> abc=hoge> sh <-- run a child process>> echo $abc <-- it's put the empty string>> exit> echo $abc <-- it's puts 'hoge'
○ environment-varialbeit's visible from the shell and child processes.> export abc=hoge> sh>> echo $abc <-- it's puts 'hoge'
shebang and executable-file
● shebang○ > vim hoge.sh
#!/bin/sh <-- it's shebang liineecho $1
● executable-file○ set the executable flag
> chmod +x hoge.sh○ run
> ./hoge.sh <-- don't forget path before filename!■ hint: see the $PATH environment variable. it's
search path for a command on your system. and think with a security policy.
shebang for any script-files
● shell script#!/bin/sh
● node.js script#!/usr/bin/node
● python script#!/usr/bin/python
● php script#!/usr/bin/php
● haskell script#!/usr/bin/runhaskell
hint: > file hoge.sh
`for` statement and an array like variable
# it's like an array separated by the space char
values='aaa bbb ccc'
# like the foreach in Java or for-in in JS
for value in $valuesdo echo $valuedone
`seq` command
> seq 812345678
`...` <-- it's the back-quote pair, not a single-quote pair('...')
# if use the single-quote pair> echo 'seq 512 64 768'seq 512 64 768# if use the back-quote pair> echo `seq 512 64 768`512 576 640 704 768 <-- it's like an array string
the back-quote pattern is like an eval() in JS. it's run a text as a script code. be cautious!
`for` statement with `seq` command and ` pattern
it's give a loop with a numeric sequence.
for value in `seq 0 15`do echo $valuedone
`while` and `until` statements
● while <-- if true then loopwhile truedo echo '\(^o^)/'done
● until <-- if false then loopuntil falsedo echo '/(^o^)\'done
`test` command for comparison
> test 3 -eq 4 <-- equiv (3 == 4)> echo $?1 <-- so false in shell-script> test 3 -ne 4 <-- equiv (3 != 4)> echo $?0 <-- so true in shell-script> test 3 -gt 4 <-- equiv (3 > 4)> echo $?1 <-- so false in shell-script
`test` command for file check
> test -f /proc/cpuinfo <-- is the file available> echo $?0> test -d /boot <-- is the directory available> echo $?0
`expr` command for calc a number from a string
# it's ng, not calc> echo 1 + 2 + 4
# it's ok, calc> echo `expr 1 + 2 + 4`7> expr 5 + \( 5 - 5 \) \* 5 / 5 % 55# note: ( ) * <-- need \ escape-sequence.
`until` statement with `test`, `expr` and ` pattern
it's give a loop with a numeric counter.
counter=15until `test $counter -eq 0`do echo $counter counter=`expr $counter - 1`done
`if` statement
# if.shf(){ if test $1 -lt 0 then echo 'negative' elif test $1 -gt 0 then echo 'positive' else echo 'zero' fi}
> source if.sh> f 0zero> f 1positive> f -1negative
`case` statement
# case.shf(){ case $1 in 0) echo 'zero';; 1) echo 'one';; [2-9]) echo 'two-nine';; default) echo '????' esac}
> source case.sh> f 0zerp> f 5two-nine> f -1????
where are more information?
all of the information is available on the man pages. see the man pages. man page is the best unified answerer for all GNU/Linux users.
> man sh