| Functions |
foo(a b)
echo a=$a b=$b
foo one two
|
f() {
local a="${1}" b="${2}"
echo a="${a}" b="${b}"
}
foo one two
|
| Variable/Array-ish arguments |
foo(a b @extra)
echo a=$a b=$b
if set? extra
echo first: $extra[0]
echo all: $extra[@]
foo one two a b c
|
foo() {
{
local a b;
declare -a extra
[ $# -ge 1 ] && a="${1}"
[ $# -ge 2 ] && b="${2}"
[ $# -ge 3 ] && extra=( "${@:3}" )
}
echo a="${a}" b="${b}"
if set? extra; then
echo first: "${extra[0]}"
echo all: "${extra[@]}"
fi
}
foo 1 2 foo bar flop
|
| Switch statement |
switch $foo
case [0-9]*
echo "bar"
case *
echo "foo"
|
case "${foo}" in
[0-9]*)
echo "bar"
;;
*)
echo "foo"
;;
esac
|
| Easy if statements |
if $i is "foo"
echo "foo"
else
echo "bar"
if not false and true
if true or false
echo "foo"
if $x > $y
echo "bar"
elif $a < $b
echo "baz"
|
if [[ "$i" == "foo" ]]; then
echo "foo"
else
echo "bar"
fi
if ! false && true; then
if true || false; then
echo 10
fi
fi
if [[ "$x" -gt "$y" ]]; then
echo "bar"
elif [[ "$a" -lt "$b" ]]; then
echo "baz"
fi
|
| Associative arrays |
foo={}
foo["bar"]="a value"
for k,v of foo
echo k=$k
echo v=$v
echo $foo["bar"]
|
declare -A foo
foo["bar"]="a value"
for k in "${!foo[@]}"; do
v="${foo[$k]}"
echo k="$k"
echo v="$v"
done
echo "${foo["bar"]}"
|
| Indexed array |
bla=[]
bla[0]="foo"
bla@="push value"
for i of bla
echo bla=$i
echo $bla[0]
|
declare -a bla
bla[0]="foo"
bla[${#bla}]="push value"
for i in "${bla[@]}"; do
echo bla="$i"
done
echo "${bla[0]}"
|
| Read file line by line (shared scope) |
for line from $selfpath/foo.txt
echo "->"$line
|
while IFS="" read -r line; do
echo "->"$line
done < $1
|
| Regex |
if $f match ^([f]oo)
echo "foo found!"
|
# extended pattern matching
# (google 'extglob' for more)
if [[ "$f" =~ ^([f]oo) ]]; then
echo "foo found!"
fi
|
| Requiring modules |
# compile and include
# powscript file
require 'mymodule.pow'
# source works at runtime
source foo.bash
|
|
| empty / isset checks |
bar()
if empty $1
echo "no argument given"
if isset $1
echo "string given"
foo "$@"
|
foo(){
if [ -z "${1}" ]; then
echo "no argument given"
fi
if [ -n "${#1}" ]; then
echo "string given"
fi
}
foo "$@"
|
| mappipe unwraps a pipe |
fn()
echo "value=$1"
echo -e "a\nb\n" | mappipe fn
|
# outputs: value=a
# value=b
|
| Easy math |
math (9 / 2)
math (9 / 2) 4
|
# outputs: '4' and '4.5000'
# NOTE: floating point math
# requires bc
|
| Easy async |
fn()
sleep 1s
echo "one"
await fn 123 then
echo "async done"
|
# outputs: one
# async done
|
| Easy async pipe |
fn()
sleep 1s
echo "one"
await fn 123 then |
cat -
when done
echo "async done"
|
# outputs: one
# async done
|
| Easy async pipe (per line) |
fn()
sleep 1s
echo "one"
echo "two"
await fn 123 then for line
echo "line: $*"
when done
echo "async done"
|
# outputs: line: one
# line: two
# async done
|
| JSON parsing |
obj={}
json='{"a": {"b": "c"}}'
json_parse obj "$json"
json_print obj a b
|
|
| FP: curry |
fn(a b)
echo "1=$a 2=$b"
curry fnc a
echo -e "b\nc\n" | mappipe fnc
|
# outputs: 1=a 2=b
# 1=a 2=c
|
| FP: array values, keys |
foo={}
foo["one"]="foo"
foo["two"]="bar"
map foo keys
map foo values
|
# outputs: one
# two
# foo
# bar
|
| FP: map |
printitem(k v)
echo "key=$k value=$v"
foo={}
foo["one"]="foo"
foo["two"]="bar"
map foo printitem
|
|
| FP: pick |
foo={}
bar={}
foo["one"]="foo"
bar["foo"]="123"
map foo values |\
mappipe pick bar
|
|
| FP: compose |
fnA(x)
echo "($x)"
fnB(x)
echo "|$x|"
compose decorate fnA fnB
decorate "foo"
|
|