Linux Command Line & Bash Scripting Mastery · Pelajaran

Membangun dan Memuat Pustaka Bash yang Dapat Digunakan Ulang

Atur helper bersama ke dalam file pustaka .sh yang dapat dimuat, lengkap dengan penjaga penyertaan dan awalan fungsi bernamespace.

Membangun dan Memuat Pustaka Bash yang Dapat Digunakan Ulang adalah pelajaran Linux Command Line & Bash Scripting Mastery gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Linux Command Line & Bash Scripting Mastery, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Linux Command Line & Bash Scripting Mastery mencakup 4 pelajaran total.

Apa Itu Pustaka Bash?

Dalam rekayasa perangkat lunak, pustaka adalah kumpulan fungsi yang dapat digunakan kembali dan dibagikan oleh beberapa program. Bash mendukung konsep yang sama melalui skrip shell yang dapat dimuat.

Daripada menyalin-tempel fungsi pembantu ke setiap skrip, Anda menempatkannya dalam berkas .sh khusus dan memuatnya dengan perintah source (atau bentuk singkatnya .). Fungsi, variabel, atau alias apa pun yang didefinisikan dalam berkas tersebut akan tersedia dalam sesi shell saat ini milik skrip pemanggil.

Mendorong prinsip DRY (Jangan Mengulang Diri Sendiri)
Memusatkan perbaikan bug — cukup perbaiki sekali, semua pemanggil mendapatkan manfaatnya
Membuat setiap skrip lebih singkat dan lebih mudah dibaca
Memungkinkan konsistensi di seluruh tim dalam pencatatan log, penanganan galat, dan logika utilitas

Proyek Bash yang terstruktur dengan baik biasanya memiliki direktori lib/ yang berisi berkas-berkas bersama ini, mengikuti konvensi bahasa tingkat tinggi.

Perintah source dan Operator Titik

Ada dua cara yang setara untuk memuat berkas pustaka ke dalam lingkungan shell saat ini:

source /path/to/lib.sh — bentuk eksplisit yang mudah dibaca
. /path/to/lib.sh — bentuk singkat yang kompatibel dengan POSIX

Keduanya menjalankan berkas tersebut dalam proses shell saat ini, bukan sub-shell, sehingga setiap fungsi dan variabel yang didefinisikan di dalamnya langsung menjadi bagian dari lingkungan skrip setelah pemanggilan.

Pola yang umum adalah menemukan lokasi pustaka secara relatif terhadap skrip pemanggil menggunakan $BASH_SOURCE, sehingga proyek tetap portabel di mana pun proyek tersebut dipasang.

#!/usr/bin/env bash
# main.sh — load a library relative to this script's own location

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
source "${SCRIPT_DIR}/lib/utils.sh"

echo "Library loaded. Calling greet..."
greet "World"

Membuat Berkas Pustaka Pertama Anda

Berkas pustaka adalah berkas .sh biasa yang hanya berisi definisi fungsi (dan terkadang konstanta). Berkas ini tidak boleh menjalankan kode yang menimbulkan efek samping pada tingkat teratas — berkas ini dimaksudkan untuk dimuat, bukan dieksekusi secara langsung.

Konvensi utama:

Awali dengan komentar shebang yang menjelaskan tujuan pustaka
Definisikan fungsi saja — jangan letakkan logika main pada tingkat teratas
Gunakan return di dalam fungsi (jangan pernah gunakan exit, yang akan menghentikan pemanggil)
Simpan berkas di subdirektori lib/ dalam proyek Anda

#!/usr/bin/env bash
# lib/utils.sh — General-purpose utility functions

# Print a greeting message
greet() {
    local name="${1:-stranger}"
    echo "Hello, ${name}!"
}

# Print a timestamped log line to stderr
log_info() {
    echo "[INFO]  $(date '+%Y-%m-%d %H:%M:%S')  $*" >&2
}

# Print an error message and return a failure code
log_error() {
    echo "[ERROR] $(date '+%Y-%m-%d %H:%M:%S')  $*" >&2
    return 1
}

Penjaga Penyertaan: Mencegah Pemuatan Ganda

Saat beberapa skrip memuat pustaka yang sama, atau saat sebuah pustaka memuat pustaka lain yang juga dimuat oleh skrip utama, fungsi dapat didefinisikan berkali-kali. Hal ini membuang waktu dan dapat menyebabkan bug yang sulit ditemukan jika isi fungsi diganti di tengah proses.

Solusinya adalah penjaga penyertaan — sebuah variabel yang berfungsi sebagai penanda. Pada pemuatan pertama, variabel tersebut belum ditetapkan sehingga berkas melanjutkan proses. Pada setiap pemuatan berikutnya, penjaga tersebut sudah ditetapkan sehingga berkas langsung mengembalikan hasil.

Ini adalah padanan Bash untuk #pragma once dalam C/C++ atau pola if not already imported dalam bahasa lain.

#!/usr/bin/env bash
# lib/utils.sh — with include guard

# Guard: if already sourced, do nothing
[[ -n "${_LIB_UTILS_LOADED:-}" ]] && return 0
_LIB_UTILS_LOADED=1

greet() {
    local name="${1:-stranger}"
    echo "Hello, ${name}!"
}

log_info() {
    echo "[INFO]  $(date '+%Y-%m-%d %H:%M:%S')  $*" >&2
}

log_error() {
    echo "[ERROR] $(date '+%Y-%m-%d %H:%M:%S')  $*" >&2
    return 1
}

Awalan Fungsi dengan Ruang Nama

Bash memiliki satu ruang nama global untuk fungsi. Jika dua pustaka masing-masing mendefinisikan fungsi bernama log atau init, definisi kedua akan diam-diam menimpa definisi pertama.

Pertahanan standarnya adalah awalan ruang nama: setiap fungsi dalam pustaka diawali nama singkat pustaka tersebut, diikuti dua titik dua (::) atau garis bawah. Misalnya, pustaka utilitas string menggunakan str::, sedangkan pustaka berkas menggunakan file::.

Benturan menjadi sangat kecil kemungkinannya
Kode pemanggil mendokumentasikan dirinya sendiri — str::trim memberi tahu Anda dengan tepat tempat fungsi tersebut berada
Kemampuan pencarian dengan grep meningkat: grep 'str::' main.sh langsung menampilkan semua pemanggilan pustaka string

#!/usr/bin/env bash
# lib/str.sh — String utility library (namespaced)

[[ -n "${_LIB_STR_LOADED:-}" ]] && return 0
_LIB_STR_LOADED=1

# Trim leading and trailing whitespace
str::trim() {
    local s="$1"
    s="${s#"${s%%[![:space:]]*}"}"
    s="${s%"${s##*[![:space:]]}"}"  
    echo "$s"
}

# Convert string to uppercase
str::upper() {
    echo "${1^^}"
}

# Convert string to lowercase
str::lower() {
    echo "${1,,}"
}

# Check if a string contains a substring
str::contains() {
    [[ "$1" == *"$2"* ]]
}

Menata Direktori lib/

Seiring berkembangnya proyek, satu utils.sh menjadi sulit dikelola. Pisahkan tanggung jawab ke dalam berkas pustaka yang berfokus pada tugas tertentu di dalam direktori lib/:

lib/log.sh — pembantu pencatatan log (log::info, log::warn, log::error)
lib/str.sh — manipulasi string (str::trim, str::upper)
lib/fs.sh — pembantu sistem berkas (fs::require_dir, fs::safe_rm)
lib/net.sh — pemeriksaan jaringan (net::wait_for_port, net::is_online)

Satu berkas pemuat bootstrap (lib/bootstrap.sh) dapat memuat semuanya dalam urutan yang benar, sehingga setiap skrip hanya memerlukan satu pemanggilan source.

#!/usr/bin/env bash
# lib/bootstrap.sh — Load all project libraries in dependency order

[[ -n "${_LIB_BOOTSTRAP_LOADED:-}" ]] && return 0
_LIB_BOOTSTRAP_LOADED=1

_BOOTSTRAP_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

source "${_BOOTSTRAP_DIR}/log.sh"
source "${_BOOTSTRAP_DIR}/str.sh"
source "${_BOOTSTRAP_DIR}/fs.sh"
source "${_BOOTSTRAP_DIR}/net.sh"

log::info "All libraries loaded."

Pustaka Logging Lengkap

Logging adalah perhatian bersama yang paling umum di antara berbagai skrip. lib/log.sh khusus memusatkan pemformatan keluaran, tingkat log, dan kode warna.

Dengan pustaka seperti ini, setiap skrip dalam proyek mencetak pesan yang konsisten, dilengkapi stempel waktu dan kode warna, tanpa menggandakan kode pemformatan.

#!/usr/bin/env bash
# lib/log.sh — Coloured, levelled logging library

[[ -n "${_LIB_LOG_LOADED:-}" ]] && return 0
_LIB_LOG_LOADED=1

# Colour codes (disabled when not writing to a terminal)
_LOG_RED=''; _LOG_YEL=''; _LOG_GRN=''; _LOG_RST=''
if [[ -t 2 ]]; then
    _LOG_RED='\033[0;31m'
    _LOG_YEL='\033[0;33m'
    _LOG_GRN='\033[0;32m'
    _LOG_RST='\033[0m'
fi

_log::_print() {
    local level="$1" colour="$2"; shift 2
    printf "%b[%s]%b %s  %s\n" \
        "$colour" "$level" "$_LOG_RST" \
        "$(date '+%H:%M:%S')" "$*" >&2
}

log::info()  { _log::_print 'INFO ' "$_LOG_GRN" "$@"; }
log::warn()  { _log::_print 'WARN ' "$_LOG_YEL" "$@"; }
log::error() { _log::_print 'ERROR' "$_LOG_RED" "$@"; return 1; }
log::fatal() { _log::_print 'FATAL' "$_LOG_RED" "$@"; exit 1; }

Pustaka Pembantu Sistem Berkas

Skrip yang memanipulasi berkas dan direktori sering mengulangi pemeriksaan defensif yang sama: apakah direktori ini ada? Apakah jalur ini dapat ditulisi? Apakah saya akan menghapus sesuatu yang penting?

Memusatkan pemeriksaan ini di lib/fs.sh membuat setiap skrip yang menggunakannya lebih aman dan mudah dibaca. Perhatikan bahwa setiap fungsi menggunakan return 1 saat gagal, bukan exit, sehingga pemanggil tetap dapat menangani kesalahan dengan baik.

#!/usr/bin/env bash
# lib/fs.sh — Filesystem helper library

[[ -n "${_LIB_FS_LOADED:-}" ]] && return 0
_LIB_FS_LOADED=1

# Ensure a directory exists; create it if not
fs::require_dir() {
    local dir="$1"
    if [[ ! -d "$dir" ]]; then
        mkdir -p "$dir" || { echo "[fs] Cannot create directory: $dir" >&2; return 1; }
    fi
}

# Remove a file only if it exists (no error on missing)
fs::safe_rm() {
    local target="$1"
    [[ -e "$target" ]] && rm -rf -- "$target"
    return 0
}

# Assert that a file exists and is readable
fs::require_file() {
    local file="$1"
    [[ -f "$file" && -r "$file" ]] || {
        echo "[fs] Required file missing or unreadable: $file" >&2
        return 1
    }
}

Membuat Versi Pustaka dengan Konstanta

Ketika pustaka Anda digunakan bersama oleh beberapa proyek atau didistribusikan kepada sebuah tim, penting untuk mengetahui versi mana dari pustaka yang dimuat saat runtime. Salah satu konvensi sederhana adalah mengekspor konstanta versi dari setiap pustaka.

Pemanggil kemudian dapat memastikan versi minimum saat memulai, sehingga ketidakcocokan terdeteksi lebih awal, alih-alih Anda harus menelusuri kegagalan yang membingungkan di kemudian hari. Variabel penjaga juga berfungsi sebagai string versi, sehingga satu variabel menjalankan dua tanggung jawab.

#!/usr/bin/env bash
# lib/str.sh — versioned example

# Guard doubles as the version identifier
[[ -n "${_LIB_STR_LOADED:-}" ]] && return 0
readonly _LIB_STR_LOADED='1.3.0'

# Caller can validate the version
str::version() { echo "$_LIB_STR_LOADED"; }

# ---- Utility functions ----
str::trim() {
    local s="$1"
    s="${s#"${s%%[![:space:]]*}"}"
    s="${s%"${s##*[![:space:]]}"}"  
    echo "$s"
}

str::repeat() {
    local str="$1" count="$2" result=''
    for (( i=0; i<count; i++ )); do result+="$str"; done
    echo "$result"
}

Demo Mandiri: Menggunakan Beberapa Pustaka

Adegan ini menunjukkan skrip realistis yang memuat sumber dua pustaka dan menggunakan fungsi dari masing-masing pustaka. Perhatikan bahwa skrip utama tetap bersih—skrip tersebut menyatakan maksud, sedangkan semua detail implementasi berada di dalam pustaka.

Skrip ini dapat dijalankan sebagai berkas mandiri karena mendefinisikan pustaka secara sebaris menggunakan dokumen-here yang ditulis ke berkas sementara. Dalam proyek nyata, setiap pustaka akan berada di berkasnya sendiri di bawah lib/.

#!/usr/bin/env bash
# Standalone demo: inline libs written to /tmp, then sourced
set -euo pipefail

# --- Create a temporary lib/log.sh ---
TMPDIR_LIBS="$(mktemp -d)"
trap 'rm -rf "$TMPDIR_LIBS"' EXIT

cat > "${TMPDIR_LIBS}/log.sh" <<'LIBEOF'
[[ -n "${_LIB_LOG_LOADED:-}" ]] && return 0
_LIB_LOG_LOADED=1
log::info()  { echo "[INFO]  $*"; }
log::error() { echo "[ERROR] $*" >&2; return 1; }
LIBEOF

cat > "${TMPDIR_LIBS}/str.sh" <<'LIBEOF'
[[ -n "${_LIB_STR_LOADED:-}" ]] && return 0
_LIB_STR_LOADED=1
str::upper() { echo "${1^^}"; }
str::trim()  { local s="$1"; s="${s#"${s%%[![:space:]]*}"}";
               s="${s%"${s##*[![:space:]]}"}"  ; echo "$s"; }
LIBEOF

# --- Source both libraries ---
source "${TMPDIR_LIBS}/log.sh"
source "${TMPDIR_LIBS}/str.sh"

# --- Main logic ---
log::info "Libraries loaded successfully."
raw_input="   hello from bash libraries   "
trimmed="$(str::trim "$raw_input")"
log::info "Trimmed: '${trimmed}'"
log::info "Uppercased: '$(str::upper "$trimmed")'"

Praktik Terbaik dan Kesalahan Umum

Sebelum merilis pustaka untuk digunakan oleh tim, periksa daftar berikut:

Penjaga penyertaan — setiap pustaka harus memilikinya; dokumentasikan nama variabel penjaga di bagian atas
Tanpa efek samping tingkat atas — jangan pernah menggunakan cd, echo, atau mengubah keadaan global di luar badan fungsi
Gunakan local untuk semua variabel di dalam fungsi — tanpa local, setiap penetapan akan memengaruhi lingkup pemanggil
Kembalikan nilai, jangan pernah keluar — exit di dalam berkas yang dimuat dengan source akan menghentikan seluruh shell pemanggil
Validasi masukan — periksa argumen yang diperlukan dan kembalikan kode kesalahan yang bermakna jika argumen tersebut tidak ada
Dokumentasikan dengan komentar — jelaskan apa yang dilakukan setiap fungsi, parameternya, dan nilai yang dikembalikannya
Hindari set -e di dalam berkas pustaka — pemanggil mungkin memiliki strategi penanganan kesalahannya sendiri; biarkan pemanggil yang menentukannya

Uji Pengetahuan: Penjaga Penyertaan

Bayangkan sebuah proyek yang main.sh-nya memuat sumber lib/bootstrap.sh dan lib/log.sh, sementara lib/bootstrap.sh juga memuat sumber lib/log.sh secara internal. Apa tujuan utama penjaga penyertaan di lib/log.sh?

Rangkuman Pelajaran: Pustaka Bash yang Tepat

Anda telah mempelajari semua teknik penting untuk membangun dan menggunakan pustaka Bash yang dapat digunakan kembali. Berikut hal-hal yang perlu Anda ingat:

Muat sumber dengan source atau . — memuat berkas ke dalam shell saat ini, sehingga fungsinya langsung tersedia
Gunakan $BASH_SOURCE untuk menentukan jalur pustaka relatif terhadap skrip pemanggil, sehingga proyek tetap portabel
Penjaga penyertaan ([[ -n "${_GUARD:-}" ]] && return 0) mencegah definisi ganda ketika beberapa berkas memuat sumber pustaka yang sama
Awalan ruang nama (log::, str::, fs::) menghilangkan benturan nama fungsi antar-pustaka
Direktori lib/ dengan berkas yang fokus dan memiliki satu tanggung jawab membuat proyek besar mudah dipelihara
Pemuat bootstrap (lib/bootstrap.sh) memberi setiap skrip satu pemanggilan sumber untuk memuat seluruh ekosistem
Jangan pernah menggunakan exit atau efek samping tingkat atas dalam berkas pustaka—hanya definisi fungsi dan konstanta yang boleh berada di sana

Terapkan pola-pola ini secara konsisten, dan skrip shell Anda akan sama modular serta mudah dipelihara seperti kode yang ditulis dalam bahasa tingkat tinggi mana pun.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Membangun dan Memuat Pustaka Bash yang Dapat Digunakan Ulang” gratis?

Ya — teks lengkap “Membangun dan Memuat Pustaka Bash yang Dapat Digunakan Ulang” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Linux Command Line & Bash Scripting Mastery, upgrade ke CoddyKit PRO. Kursus Linux Command Line & Bash Scripting Mastery mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Membangun dan Memuat Pustaka Bash yang Dapat Digunakan Ulang”?

Atur helper bersama ke dalam file pustaka .sh yang dapat dimuat, lengkap dengan penjaga penyertaan dan awalan fungsi bernamespace. Kamu berlatih Linux Command Line & Bash Scripting Mastery dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Linux Command Line & Bash Scripting Mastery?

Tidak diperlukan pengalaman sebelumnya. Linux Command Line & Bash Scripting Mastery di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “Membangun dan Memuat Pustaka Bash yang Dapat Digunakan Ulang” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Linux Command Line & Bash Scripting Mastery ini?

Ya. Setiap pelajaran Linux Command Line & Bash Scripting Mastery menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

Merancang Fungsi dengan Lingkup Lokal dan Kode Kembalian
Membangun dan Memuat Pustaka Bash yang Dapat Digunakan Ulang
Mengurai Bendera dan Argumen dengan getopts
Meneruskan Larik dan Peta Asosiatif antar Fungsi

← Kembali ke Linux Command Line & Bash Scripting Mastery