Belajar Bash Scripting: Argument Parsing

Pada artikel kali ini, saya akan membahas mengenai Argument Parsing. Yakni adalah bagaimana cara agar setiap argumen yang diberikan pada suatu fungsi/script, bisa diinterpretasi sesuai posisinya (positional argument), atau sesuai ketentuan yang ditentukan nantinya.

Ini akan sangat bermanfaat jika Anda hendak membuat CLI tool dari bash script. Misalnya membuat tool seperti berikut:

1
2
3

./script.sh -u username -h host 
# or
./script.sh --username user --host hostname

Telah dibahas pada artikel yang telah lalu (Belajar Bash Scripting: Arguments) bahwa bash akan menginterpretasi setiap argumen yang diberikan dengan variabel $1, $2 dan seterusnya.

Positional Argument

Yang dimaksud dengan positional argument, secara umum adalah argumen yang ditentukan dari urutannya ($1 .. $n), dan secara khusus, yaitu argumen yang sudah ditetapkan tujuannya sesuai dengan urutan penyebutannya. Misalnya pada tool rsync:

1

rsync sourcefiles user@remote:/destination/

Bisa didapati bahwa argumen pertama merupakan spesifikasi untuk file sumber yang hendak ditransfer kemudian argumen terakhir adalah tujuannya, entah di lokal atau remote.

Sehingga, argumen pertama akan selalu menjadi sumber file dan argumen kedua akan selalu menjadi tujuannya. Jikalau dibalik, tidak bisa, destinasi tujuan didefinisikan pada argumen pertama dan seterusnya.

Atau pada utilitas mv atau cp, yang ketentuannya adalah jika diberikan 2 nama file, maka yang pertama menjadi sumber file dan yang kedua menjadi tujuan file (hasil salinan, atau hasil pindahan). Namun, jika diberikan lebih dari 2 file, maka argumen paling akhir akan menjadi tujuannya.

1
2

cp file1 file2 file3 target/
mv fileA fileB fileXYZ target/

Maka sudah menjadi ketentuan, bahwa file/folder yang disebutkan paling akhir, maka file/folder tersebut akan menjadi targetnya.

Inilah yang dimaksud dengan positional argument.

Optional Argument

Optional argument adalah argument yang tidak wajib untuk diberikan. Boleh diberikan dan boleh juga tidak. Ini berfungsi untuk mengubah sifat suatu tool berdasarkan flag/option yang diberikan. Misalkan pada rysnc:

1

rsync --dry-run --delete sourcefiles user@remote:/destination/

Lho, katanya argumen pertama itu untuk spesifikasi file/folder sumber dan argumen kedua untuk tujuannya? Bukankah pada contoh ini, argumen pertama ($1) adalah --dry-run? kemudian argumen kedua adalah --delete? dan yang ketiga dan keempat baru sumber dan tujuan?

Jawabannya, benar. Jika diruntut, memang terbaca seperti itu ($1 = '--dry-run' dan seterusnya). Ini karena argument parsing. Tiap argumen yang diberikan akan diproses satu-persatu menyesuaikan dengan pola argumen yang diberikan.

Tool rsync tersebut, diprogram sedemikian rupa sehingga ketika didapati ada argument yang berawalan -- atau - maka akan dianggap sebagai optional parameter, dan akan diproses berdasarkan string setelahnya. Misalnya pada contoh diatas, --dry-run maka rysnc akan berjalan pada mode dry run alias percobaan.

Argument Parsing

Argument parsing sebenarnya bisa dilakukan dengan built-in tool getopts. Namun, pada artikel ini saya hanya akan membahas argument parsing menggunakan while dan for loop yang dikombinasikan dengan kondisional case.

Contoh skenarionya adalah seperti ini:

1

./script.sh -a -b opt1 --xyz opt2 pos1 pos2

Maka akan didapatkan variabel $@ yang isinya:

1

-a -b opt1 --xyz opt2 pos1 pos2

dan $# yang bernilai 7.

Dengan demikian maka bisa diproses masing-masing argumennya dengan loop berikut:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#!/usr/bin/env bash

while [[ $# -ne 0 ]]; do
    case "$1" in
        -a)
            option_a="set"            
            shift
            ;;
        -b) 
            option_b="$2"
            shift 2
            ;;
        --xyz)
            option_xyz="$2" 
            shift 2
            ;;
        *)
            positional_arg+=( "$1" )
            shift
            ;;
    esac
done

printf '%s: %s\n' option_a "$option_a" option_b "$option_b" option_xyz "$option_xyz"
echo "Positional args: ${positional_arg[*]}"

Penjelasan

Bagian while [[ $# -ne 0 ]]; do akan melakukan loop selama $# tidak bernilai nol, alias selama masih ada argumen yang bisa diproses, pemrosesan akan terus berlanjut.

Kemudian case "$1" in akan mengecek argumen pertama dan akan mecocokkannya dengan case-case yang didefinisikan setelahnya. Kenapa hanya argumen pertama saja? Akan datang penjelasannya nanti.

Case-case yang dimaksud adalah seperti pada contoh, adalah -a, -b, --xyz dan *. Mari dibahas satu-persatu:

1
2
3
4

-a)
    option_a="set"            
    shift
    ;;

Nah, ketika $1 bernilai -a, maka kita akan definisikan variabel option_a dengan nilai set. Kemudian ada sintaks shift, yang berfungsi untuk menggser positional parameter yang diberikan. Maksudnya bagaimana?

Seperti yang sudah diketahui sebelumnya, bahwa pada contoh command sebelumnya, argumen-argumen yang diberikan adalah sebagai berikut:

1
2
3
4

-a -b opt1 --xyz opt2 pos1 pos2
$1 $2  $3    $4   $5   $6   $7

# $# = 7

Jika command shift dipanggil, maka penyematan argumen akan menjadi seperti ini:

1
2
3
4

-a -b opt1 --xyz opt2 pos1 pos2
   $1  $2    $3   $4   $5   $6

# $# = 6

Kemudian, jika shift dipanggil dan diberikan nilai padanya, maka pergeseran argumen akan dilakukan sebanyak nilai yang diberikan. Misalnya shift 2:

1
2
3
4

-a -b opt1 --xyz opt2 pos1 pos2
             $1   $2   $3   $4

# $# = 4

Karena positional argument-nya bergeser, maka jumlahnya ($#) juga berubah pula, sebagaimana pada contoh diatas.

Kembali ke pembahasan sebelumnya, karena kondisi $1 saat ini bernilai -a maka kita isikan variabel option_a dengan nilai set dan kita geser positional argumen selanjutnya menggunakan perintah shift. Sehingga kondisi $1 saat ini menjadi argumen setelahnya, tidak lagi -a.

Setelah shift diberlakukan, maka pengkondisian case selesai dan kembali kepada loop untuk melakukan iterasi berikutnya karena $# masih belum bernilai 0. Selanjutnya:

1
2
3
4

-b) 
    option_b="$2"
    shift 2
    ;;

dengan kondisi $@ yang saat ini adalah seperti berikut ini:

1
2

-b opt1 --xyz opt2 pos1 pos2
$1  $2    $3   $4   $5   $6

maka, karena $1 saat ini bernilai -b maka kita deklarasikan variabel option_b dengan memberikannya nilai sesuai dengan nilai variabel $2 yaitu opt1. Setelah itu kita geser kembali argumennya 2 kali. Sehingga, kondisi $@ saat ini menjadi:

1
2

--xyz opt2 pos1 pos2
  $1   $2   $3   $4

Untuk bagian dibawah ini, pembahasannya sama dengan -b:

1
2
3
4

--xyz)
    option_xyz="$2" 
    shift 2
    ;;

Kemudian yang terkahir adalah:

1
2
3
4

*)
    positional_arg+=( "$1" )
    shift
    ;;

Ini berarti, semua argumen yang bukan berupa option (diawali dengan -), maka akan teranggap sebagai positional argument dan akan dimasukkan ke array positional_arg yang akan diproses tersendiri nantinya.

Dengan demikian, output dari command berikut ini:

1

./script.sh -a -b opt1 --xyz opt2 pos1 pos2

adalah

1
2
3
4

option_a: set
option_b: opt1
option_xyz: opt2
Positional args: pos1 pos2

Parsing bentuk –opt=value dan -oValue

Setelah dijelaskan konsep dasar pemanfaatan WHILE loop dan CASE statement untuk argument parsing seperti pada contoh sebelumnya, saya akan jelaskan pula bagaimana cara untuk membuat parsing dengan model seperti ini:

1

./script.sh --opt1=value1 --flag1=value2 ...

Susunan WHILE loop sama seperti dengan contoh sebelumnya, namun bisa diperingkas seperti berikut agar mengurangi kedalaman indentasi:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

#!/usr/bin/env bash

while [[ $# -ne 0 ]]; do case "$1" in
    --flag1=*) var_flag1="${1#*=}";;
    --opt1=*)  var_opt1="${1#*=}" ;;
    *) echo "Opsi tidak dikenali."; exit 1;;
esac; shift; done

printf '%s: %s\n' \
    'Flag1' "$var_flag1" \
    'Opt1' "$var_opt1"

Nah, pada contoh diatas, saya memanfaatkan suatu fitur dari Bash yaitu parameter expansion yang akan dibahas lebih detail pada artikel lain nantinya.

Parameter expansion yang dimanfaatkan adalah ${variabel#*PATTERN} yang fungsinya adalah menghapus seluruh karakter dari awal hingga bertemu PATTERN. Pada contoh diatas adalah ${1#*=}.

Anggap saja nilai $1 saat ini adalah --flag1=hehe, fokus pada parameter #*=, maka bisa diartikan dengan “menghapus seluruh karakter dari awal hingga bertemu dengan karakter = (inklusif)”. Sehingga hasilnya adalah hehe.

Kemudian, contoh selanjutnya adalah argument parsing semisal pada command mysql:

1

mysql -uroot -hhostname -p

Hampir sama dengan contoh sebelumnya, hanya berbeda pada sintaks parameter expansion saja dan pada klausa CASEnya:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

#!/usr/bin/env bash

while [[ $# -ne 0 ]]; do case "$1" in
    -u*) username="${1#*-u}";;
    -h*) password="${1#*-h}";;
    -p)  prompt_password=1 ;;
    *) echo "Opsi tidak dikenali."; exit 1;;
esac; shift; done

printf '%s: %s\n' \
    'Username' "$username" \
    'Hostname' "$hostname"

if [[ -n "$prompt_password" ]]; then
    read -r -s -p "Kata sandi: " password
fi

Argument parsing dengan FOR loop

FOR loop juga bisa digunakan untuk melakukan argument parsing. Namun dengan batasan, bahwa argument parsing yang dilakukan tidak bisa berupa opsi/flag yang meminta value. Hanya bisa berupa opsi/flag yang bersifat toggle (alias, on/off) dan juga positional argument saja. Misal:

1

./script.sh --force --delete

1
2
3
4
5
6
7
8
9

#!/usr/bin/env bash

for arg in "$@"; do case "$arg" in
    --force)   force_enable=true ;;
    --delete) delete_enable=true ;;
    *) echo "Opsi tidak dikenali."; exit 1 ;;
esac; done

...

Pada model ini, kita memanfaatkan variabel $@ dan tidak perlu memanggil shift karena tiap iterasinya, FOR loop akan mengkonsumsi semua ekspansi $@ satu persatu. Bentuknya menjadi lebih ringkas namun kurang fleksibel.

Validasi

Tentunya, setiap pemberian opsi dan/atau positional argument perlu diberlakukan validasi terlebih dahulu. Misalnya script tidak memperbolehkan penggunaan flag/opsi yang sama lebih dari satu, atau jika opsi yang satu sudah diberikan maka opsi yang lain tidak boleh diberikan pula.

Strategi untuk mengatasi kondisi semacam itu beragam. Diantaranya bisa dengan misalnya opsi yang terakhir diberikan maka itu yang akan dipertimbangkan. Atau pemberian prioritas, atau bahkan script akan error jika bertemu kondisi-kondisi tersebut.

Hal ini bisa dilakukan langsung pada bagian kondisional CASE atau setelah argument parsing selesai.

Contohnya pada utilitas mv atau rm pada opsi -i dan -f-nya:

1

rm -i -f file2

Opsi -i berfungsi agar perintah rm memberikan prompt sebelum penghapusan file dilakukan. Sedangkan -f adalah opsi yang digunakan agar rm menghapus “paksa” suatu file tanpa menanyakan/memberitahukan terkait ada/tidaknya file yang dimaksud. Tentu keduanya bertentangan satu sama lain. Bagaimana rm menangani kondisi ini? Yaitu dengan memprioritaskan opsi yang paling akhir.

Sehingga bisa saja suatu script disusun seperti ini untuk meniru gaya argument parsing pada cp:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

...
while [[ $# -ne 0 ]]; do
    case "$1" in
        ...
        -i) option="interactive"; shift ;;
        -f) option="force"; shift ;;
        ...
    esac
done
...

dengan demikian, variabel option akan memiliki nilai sesuai dengan opsi yang ditentukan paling akhir.

Kemudian, suatu script dimana script tersebut memerlukan variabel tertentu agar diset oleh user, namun jika tidak diberikan, variabel tersebut akan terisi dengan nilai default. Misalnya pada tool iptables. Tool tersebut memerlukan ditentukannya nama tabel agar bisa menampilkan semua rules-nya dengan flag -L.

1

iptables -t nat -L

Jika, opsti -t nat tidak diberikan, maka secara asal, iptables akan menampilkan rules pada tabel filter. Contoh pada script:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

...
while [[ $# -ne 0 ]]; do
    case "$1" in
        ...
        -t) table="$2"; shift 2 ;;
        ...
    esac
done
...

if [[ -z "$table" ]]; then
    table=filter
fi

atau lebih sederhana, menggunakan parameter expansion:

1
2
3
4
5
6
7

...
case "$1" in
    ...
    -t) table="${2:-filter}"; shift 2 ;;
    ...
esac
...

Bagaimana dengan bentuk option/flag seperti contoh dibawah ini?

1
2
3
4
5
6
7
8

tar xvzf archive.tar.gz
# atau rsync
rsync -avznP source/ user@host:/dest/
# atau ps
ps aux
# atau ss/netstat
ss -ant
netstat -patlun

Saya serahkan pada pembaca untuk mencari tahu.

Semoga bermanfaat, barakallahufiikum.