Linux Command Line & Bash Scripting Mastery · บทเรียน

การสร้างและโหลดไลบรารี Bash ที่นำกลับมาใช้ซ้ำได้

จัดระเบียบตัวช่วยที่ใช้ร่วมกันไว้ในไฟล์ไลบรารี .sh ที่โหลดได้ พร้อมตัวป้องกันการรวมซ้ำและคำนำหน้าฟังก์ชันแบบมีเนมสเปซ

การสร้างและโหลดไลบรารี Bash ที่นำกลับมาใช้ซ้ำได้ เป็นบทเรียน Linux Command Line & Bash Scripting Mastery ฟรีบน CoddyKit นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Linux Command Line & Bash Scripting Mastery และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Linux Command Line & Bash Scripting Mastery มีบทเรียนทั้งหมด 4 บทเรียน

ไลบรารี Bash คืออะไร

ในวิศวกรรมซอฟต์แวร์ ไลบรารี คือชุดฟังก์ชันที่นำกลับมาใช้ใหม่ได้ ซึ่งหลายโปรแกรมสามารถใช้ร่วมกันได้ Bash รองรับแนวคิดเดียวกันผ่าน สคริปต์เชลล์ที่โหลดด้วย source ได้

แทนที่จะคัดลอกฟังก์ชันช่วยเหลือไปไว้ในทุกสคริปต์ คุณสามารถเก็บฟังก์ชันเหล่านั้นไว้ในไฟล์ .sh โดยเฉพาะ แล้วโหลดด้วยคำสั่ง source (หรือรูปแบบย่อคือ .) ฟังก์ชัน ตัวแปร หรือชื่อแทนใด ๆ ที่กำหนดไว้ในไฟล์นั้นจะพร้อมใช้งานในเซสชันเชลล์ปัจจุบันของสคริปต์ผู้เรียก

ส่งเสริมหลักการ DRY (อย่าทำซ้ำตัวเอง)
รวมการแก้ไขข้อบกพร่องไว้ที่เดียว — แก้ครั้งเดียว ผู้เรียกทุกตัวก็ได้รับประโยชน์
ทำให้สคริปต์แต่ละไฟล์สั้นลงและอ่านง่ายขึ้น
ช่วยให้การบันทึกเหตุการณ์ การจัดการข้อผิดพลาด และตรรกะยูทิลิตีมีความสอดคล้องกันทั้งทีม

โดยทั่วไป โครงการ Bash ที่จัดโครงสร้างอย่างดีจะมีไดเรกทอรี lib/ ซึ่งเก็บไฟล์ที่ใช้ร่วมกันเหล่านี้ โดยทำตามแนวทางของภาษาระดับสูง

คำสั่ง source และตัวดำเนินการจุด

มีสองวิธีที่ให้ผลเหมือนกันในการโหลดไฟล์ไลบรารีเข้าสู่สภาพแวดล้อมของเชลล์ปัจจุบัน:

source /path/to/lib.sh — รูปแบบที่เขียนชัดเจนและอ่านเข้าใจง่าย
. /path/to/lib.sh — รูปแบบย่อที่เข้ากันได้กับ POSIX

ทั้งสองวิธีจะเรียกใช้ไฟล์ ภายในกระบวนการเชลล์ปัจจุบัน ไม่ใช่เชลล์ย่อย ดังนั้นฟังก์ชันและตัวแปรทุกตัวที่กำหนดไว้ภายในไฟล์จะกลายเป็นส่วนหนึ่งของสภาพแวดล้อมสคริปต์ทันทีหลังการเรียกใช้

รูปแบบที่ใช้กันทั่วไปคือค้นหาไลบรารีโดยอ้างอิงจากตำแหน่งของสคริปต์ผู้เรียกด้วย $BASH_SOURCE ซึ่งทำให้โครงการทำงานได้ไม่ว่าจะติดตั้งไว้ที่ใด

#!/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"

การสร้างไฟล์ไลบรารีไฟล์แรก

ไฟล์ไลบรารีคือไฟล์ .sh ธรรมดาที่มีเฉพาะการนิยามฟังก์ชัน (และบางครั้งมีค่าคงที่) ไฟล์นี้ไม่ควร เรียกใช้โค้ดที่ก่อให้เกิดผลข้างเคียงในระดับบนสุด แต่มีไว้สำหรับโหลดด้วย source ไม่ใช่เรียกใช้โดยตรง

แนวทางสำคัญ:

เริ่มต้นด้วยความเห็นแบบ shebang ที่อธิบายจุดประสงค์ของไลบรารี
นิยามเฉพาะฟังก์ชัน — ไม่มีตรรกะของ main ในระดับบนสุด
ใช้ return ภายในฟังก์ชัน (ไม่ใช้ exit เด็ดขาด เพราะจะทำให้ผู้เรียกสิ้นสุดการทำงาน)
เก็บไฟล์ไว้ในไดเรกทอรีย่อย lib/ ของโครงการ

#!/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
}

ตัวป้องกันการรวมไฟล์: ป้องกันการโหลดด้วย source ซ้ำ

เมื่อมีหลายสคริปต์โหลดไลบรารีเดียวกันด้วย source หรือเมื่อไลบรารีหนึ่งโหลดไลบรารีอีกตัวที่สคริปต์หลักโหลดไว้แล้ว ฟังก์ชันอาจถูกนิยามซ้ำหลายครั้ง ซึ่งเสียเวลาและอาจทำให้เกิดข้อบกพร่องที่ตรวจพบได้ยาก หากเนื้อหาของฟังก์ชันถูกแทนที่ระหว่างการทำงาน

วิธีแก้คือใช้ตัวป้องกันการรวมไฟล์ — ตัวแปรที่ทำหน้าที่เป็นแฟล็ก ในการโหลดครั้งแรก ตัวแปรจะยังไม่ถูกกำหนดค่า ไฟล์จึงทำงานต่อไป ส่วนการโหลดครั้งถัดไป ตัวป้องกันจะถูกกำหนดค่าแล้ว ไฟล์จึงส่งคืนทันที

นี่คือแนวทางเทียบเท่าของ Bash กับ #pragma once ใน C/C++ หรือรูปแบบ if not already imported ในภาษาอื่น

#!/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
}

คำนำหน้าฟังก์ชันตามขอบเขตชื่อ

Bash มีขอบเขตชื่อส่วนกลางเพียงหนึ่งเดียวสำหรับฟังก์ชัน หากไลบรารีสองตัวต่างก็นิยามฟังก์ชันชื่อ log หรือ init การนิยามครั้งที่สองจะเขียนทับครั้งแรกโดยไม่แจ้งให้ทราบ

วิธีป้องกันมาตรฐานคือใช้คำนำหน้าขอบเขตชื่อ: ฟังก์ชันทุกตัวในไลบรารีจะขึ้นต้นด้วยชื่อย่อของไลบรารี ตามด้วยเครื่องหมายโคลอนสองตัว (::) หรือขีดล่าง ตัวอย่างเช่น ไลบรารียูทิลิตีสำหรับสตริงใช้ str:: ส่วนไลบรารีสำหรับไฟล์ใช้ file::

โอกาสที่ชื่อจะซ้ำกันลดลงอย่างมาก
โค้ดที่เรียกใช้จะอธิบายตัวเองได้ — str::trim บอกได้ทันทีว่าฟังก์ชันอยู่ที่ใด
ค้นหาด้วย Grep ได้สะดวกขึ้น: grep 'str::' main.sh จะแสดงการเรียกใช้ไลบรารีสตริงทั้งหมดทันที

#!/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"* ]]
}

การจัดระเบียบไดเรกทอรี lib/

เมื่อโครงการเติบโตขึ้น utils.sh เพียงไฟล์เดียวจะจัดการได้ยาก ควรแยกหน้าที่ออกเป็นไฟล์ไลบรารีที่มีจุดประสงค์เฉพาะภายในไดเรกทอรี lib/:

lib/log.sh — ตัวช่วยสำหรับการบันทึกเหตุการณ์ (log::info, log::warn, log::error)
lib/str.sh — การจัดการสตริง (str::trim, str::upper)
lib/fs.sh — ตัวช่วยระบบไฟล์ (fs::require_dir, fs::safe_rm)
lib/net.sh — การตรวจสอบเครือข่าย (net::wait_for_port, net::is_online)

ไฟล์ตัวโหลดเริ่มต้นไฟล์เดียว (lib/bootstrap.sh) สามารถโหลดไฟล์ทั้งหมดด้วย source ตามลำดับที่ถูกต้อง ทำให้แต่ละสคริปต์ต้องเรียกใช้ 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."

ไลบรารีการบันทึกข้อมูลฉบับสมบูรณ์

การบันทึกข้อมูลเป็นข้อกังวลร่วมที่พบได้บ่อยที่สุดในสคริปต์ต่าง ๆ lib/log.sh ที่จัดทำขึ้นโดยเฉพาะจะรวมการจัดรูปแบบผลลัพธ์ ระดับการบันทึกข้อมูล และรหัสสีไว้ในที่เดียว

เมื่อมีไลบรารีเช่นนี้ สคริปต์ทุกตัวในโครงการจะพิมพ์ข้อความที่มีรูปแบบสอดคล้องกัน พร้อมประทับเวลาและกำหนดสี โดยไม่ต้องทำซ้ำโค้ดจัดรูปแบบใด ๆ

#!/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; }

ไลบรารีตัวช่วยระบบไฟล์

สคริปต์ที่จัดการไฟล์และไดเรกทอรีมักทำการตรวจสอบเพื่อป้องกันข้อผิดพลาดซ้ำ ๆ กัน เช่น ไดเรกทอรีนี้มีอยู่หรือไม่ เส้นทางนี้เขียนได้หรือไม่ หรือกำลังจะลบสิ่งสำคัญหรือไม่

การรวมการตรวจสอบเหล่านี้ไว้ใน lib/fs.sh ทำให้สคริปต์ที่เรียกใช้ปลอดภัยและอ่านง่ายขึ้น โปรดสังเกตว่าแต่ละฟังก์ชันใช้ return 1 เมื่อล้มเหลว แทนที่จะใช้ exit เพื่อคงความสามารถของผู้เรียกในการจัดการข้อผิดพลาดอย่างเหมาะสม

#!/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
    }
}

การกำหนดเวอร์ชันไลบรารีด้วยค่าคงที่

เมื่อมีการใช้ไลบรารีร่วมกันในหลายโครงการหรือแจกจ่ายให้ทีม สิ่งสำคัญคือการทราบว่า ไลบรารีเวอร์ชันใดถูกโหลดขณะทำงาน รูปแบบที่เรียบง่ายคือส่งออกค่าคงที่เวอร์ชันจากแต่ละไลบรารี

จากนั้นผู้เรียกสามารถตรวจสอบยืนยันเวอร์ชันขั้นต่ำเมื่อเริ่มต้นโปรแกรมได้ ทำให้พบความไม่ตรงกันตั้งแต่เนิ่น ๆ แทนที่จะต้องแก้ไขข้อผิดพลาดลึกลับในภายหลัง ตัวแปรป้องกันจะทำหน้าที่เป็นสตริงเวอร์ชันด้วย จึงรวมความรับผิดชอบสองอย่างไว้ในตัวแปรเดียว

#!/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"
}

ตัวอย่างสาธิตแบบในตัว: การใช้หลายไลบรารี

ฉากนี้แสดงสคริปต์ที่สมจริง ซึ่งโหลดไลบรารีสองรายการและใช้ฟังก์ชันจากแต่ละรายการ โปรดสังเกตว่าสคริปต์หลักยังคงสะอาด — สคริปต์แสดงเจตนาของการทำงาน ส่วนรายละเอียดการนำไปใช้อยู่ในไลบรารีทั้งหมด

สคริปต์นี้ทำงานเป็นไฟล์เดี่ยวได้ เพราะกำหนดไลบรารีไว้ภายในโดยใช้เอกสาร here-document ที่เขียนลงไฟล์ชั่วคราว ในโครงการจริง ไลบรารีแต่ละรายการจะอยู่ในไฟล์ของตนเองภายใต้ 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")'"

แนวทางปฏิบัติที่ดีและข้อผิดพลาดที่พบบ่อย

ก่อนนำไลบรารีไปใช้ภายในทีม โปรดตรวจสอบรายการต่อไปนี้:

ตัวป้องกันการรวมไฟล์ — ไลบรารีทุกตัวต้องมีตัวป้องกัน และควรระบุชื่อตัวแปรป้องกันไว้ด้านบน
ไม่มีผลข้างเคียงระดับบนสุด — ห้ามใช้ cd, echo หรือแก้ไขสถานะส่วนกลางนอกส่วนเนื้อความของฟังก์ชัน
ใช้ local กับตัวแปรทั้งหมดภายในฟังก์ชัน — หากไม่มี local การกำหนดค่าทุกครั้งจะไหลไปยังขอบเขตของผู้เรียก
ใช้ return ไม่ใช้ exit — exit ภายในไฟล์ที่โหลดด้วย source จะยุติเชลล์ที่เรียกทั้งหมด
ตรวจสอบข้อมูลนำเข้า — ตรวจสอบอาร์กิวเมนต์ที่จำเป็น และส่งคืนรหัสข้อผิดพลาดที่สื่อความหมายเมื่อไม่มีข้อมูลเหล่านั้น
จัดทำเอกสารด้วยความคิดเห็น — อธิบายว่าแต่ละฟังก์ชันทำอะไร รับพารามิเตอร์ใด และส่งคืนค่าใด
หลีกเลี่ยง set -e ในไฟล์ไลบรารี — ผู้เรียกอาจมีกลยุทธ์จัดการข้อผิดพลาดของตนเอง ให้ผู้เรียกเป็นผู้ตัดสินใจ

ตรวจสอบความรู้: ตัวป้องกันการรวมไฟล์

สมมติว่าโครงการหนึ่งมี main.sh โหลดทั้ง lib/bootstrap.sh และ lib/log.sh และ lib/bootstrap.sh ก็โหลด lib/log.sh ภายในด้วย จุดประสงค์หลักของตัวป้องกันการรวมไฟล์ใน lib/log.sh คืออะไร

สรุปบทเรียน: ใช้ไลบรารี Bash อย่างถูกต้อง

คุณได้เรียนรู้เทคนิคสำคัญทั้งหมดสำหรับการสร้างและใช้งานไลบรารี Bash ที่นำกลับมาใช้ใหม่ได้แล้ว ต่อไปนี้คือประเด็นสำคัญ:

โหลดด้วย source หรือ . — โหลดไฟล์เข้าสู่เชลล์ปัจจุบัน ทำให้ฟังก์ชันในไฟล์พร้อมใช้งานทันที
ใช้ $BASH_SOURCE เพื่อแก้ไขเส้นทางไลบรารีให้สัมพันธ์กับสคริปต์ที่เรียก ทำให้โครงการใช้งานได้หลายสภาพแวดล้อม
ตัวป้องกันการรวมไฟล์ ([[ -n "${_GUARD:-}" ]] && return 0) ป้องกันการประกาศซ้ำเมื่อหลายไฟล์โหลดไลบรารีเดียวกัน
คำนำหน้าพื้นที่ชื่อ (log::, str::, fs::) ป้องกันชื่อฟังก์ชันชนกันระหว่างไลบรารี
ไดเรกทอรี lib/ ที่มีไฟล์ซึ่งแต่ละไฟล์มุ่งรับผิดชอบเพียงเรื่องเดียว ช่วยให้โครงการขนาดใหญ่ดูแลรักษาได้
ตัวโหลดเริ่มต้น (lib/bootstrap.sh) ทำให้ทุกสคริปต์มีการเรียกโหลดเพียงครั้งเดียวเพื่อโหลดระบบทั้งหมด
ห้ามใช้ exit หรือผลข้างเคียงระดับบนสุด ในไฟล์ไลบรารี — ให้มีเฉพาะการประกาศฟังก์ชันและค่าคงที่เท่านั้น

ใช้รูปแบบเหล่านี้อย่างสม่ำเสมอ แล้วสคริปต์เชลล์ของคุณจะมีโครงสร้างแยกส่วนและดูแลรักษาได้ไม่ต่างจากโค้ดที่เขียนด้วยภาษาระดับสูงกว่า

คำถามที่พบบ่อย

บทเรียน “การสร้างและโหลดไลบรารี Bash ที่นำกลับมาใช้ซ้ำได้” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การสร้างและโหลดไลบรารี Bash ที่นำกลับมาใช้ซ้ำได้” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Linux Command Line & Bash Scripting Mastery ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Linux Command Line & Bash Scripting Mastery มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การสร้างและโหลดไลบรารี Bash ที่นำกลับมาใช้ซ้ำได้”

จัดระเบียบตัวช่วยที่ใช้ร่วมกันไว้ในไฟล์ไลบรารี .sh ที่โหลดได้ พร้อมตัวป้องกันการรวมซ้ำและคำนำหน้าฟังก์ชันแบบมีเนมสเปซ คุณปฏิบัติ Linux Command Line & Bash Scripting Mastery ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Linux Command Line & Bash Scripting Mastery หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Linux Command Line & Bash Scripting Mastery บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน

บทเรียน “การสร้างและโหลดไลบรารี Bash ที่นำกลับมาใช้ซ้ำได้” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Linux Command Line & Bash Scripting Mastery นี้ได้ไหม

ได้ บทเรียน Linux Command Line & Bash Scripting Mastery ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

การออกแบบฟังก์ชันด้วยขอบเขตภายในและรหัสส่งคืน
การสร้างและโหลดไลบรารี Bash ที่นำกลับมาใช้ซ้ำได้
การแยกแฟล็กและอาร์กิวเมนต์ด้วย getopts
การส่งอาร์เรย์และแผนที่เชื่อมโยงระหว่างฟังก์ชัน

← กลับไปที่ Linux Command Line & Bash Scripting Mastery