خط فرمان لینوکسlinuxcommandline.ir
فهرست مطالب
فارسی
PDFدریافت PDF
Esc
    بخش چهارم: نگارش اسکریپت‌های پوسته

    فصل ۳۵: آرایه‌ها (Arrays)

    • زمان مطالعه: ۳۰ دقیقه
    • فصل ۳۵ از ۳۶

    در فصل پیشین، شیوه‌های مدیریت و پردازش رشته‌ها و اعداد را در پوسته بررسی کردیم. انواع داده‌هایی که تاکنون با آن‌ها سروکار داشته‌ایم، در ادبیات علوم کامپیوتر تحت عنوان متغیرهای اسکالر (Scalar Variables) شناخته می‌شوند؛ یعنی متغیرهایی که در هر لحظه تنها یک مقدار واحد را در خود ذخیره می‌کنند.

    در این فصل، به بررسی ساختار داده‌ دیگری به نام آرایه (Array) می‌پردازیم که قابلیت نگهداری چندین مقدار را به‌طور هم‌زمان داراست. آرایه‌ها یکی از ویژگی‌های بنیادین در تقریباً تمامی زبان‌های برنامه‌نویسی محسوب می‌شوند. پوسته Bash نیز از این ساختار پشتیبانی می‌کند، هرچند این پشتیبانی در مقایسه با زبان‌های سطح بالا تا حدودی محدودتر است. با این حال، آرایه‌ها ابزاری بسیار کارآمد برای حل الگوهای خاصی از مسائل برنامه‌نویسی هستند.

    تعریف و مفهوم آرایه #

    آرایه‌ها متغیرهایی هستند که بیش از یک مقدار را در قالب یک ساختار واحد سازماندهی می‌کنند. برای درک بهتر، می‌توان یک آرایه را مشابه یک جدول در نظر گرفت. یک صفحه‌گسترده (Spreadsheet) را تصور کنید؛ این صفحه مانند یک آرایه دوبعدی عمل می‌کند که دارای سطرها و ستون‌های مشخصی است و هر سلول آن با استفاده از مختصات سطر و ستون قابل دسترسی است. آرایه‌ها نیز سازوکار مشابهی دارند؛ آن‌ها از خانه‌هایی به نام عنصر (Element) تشکیل شده‌اند که هر کدام قطعه‌ای از داده را در خود جای می‌دهد.

    بسیاری از زبان‌های برنامه‌نویسی از آرایه‌های چندبعدی پشتیبانی می‌کنند؛ برای مثال، یک صفحه گسترده نمونه‌ای از آرایه دوبعدی با مؤلفه‌های طول و عرض است. برخی زبان‌ها حتی ابعاد بیشتری را نیز پوشش می‌دهند، هرچند آرایه‌های دو و سه‌بعدی رایج‌ترین انواع آن‌ها هستند.

    در پوسته Bash، آرایه‌ها تنها به صورت یک‌بعدی (One-dimensional) پشتیبانی می‌شوند. می‌توان آن‌ها را مشابه یک صفحه گسترده در نظر گرفت که تنها شامل یک ستون است. با وجود این محدودیت، آرایه‌ها همچنان کاربردهای گسترده‌ای در اسکریپت‌نویسی دارند. لازم به ذکر است که پشتیبانی از آرایه‌ها نخستین بار در نسخه ۲ پوسته Bash معرفی شد؛ در حالی که پوسته‌ی اصلی یونیکس (sh) اساساً فاقد چنین قابلیتی بود.

    ایجاد آرایه #

    نام‌گذاری متغیرهای آرایه در Bash تابع همان قواعد متغیرهای معمولی است. این متغیرها به محض ارجاع یا مقداردهی، به‌صورت خودکار ایجاد می‌شوند. به مثال زیر توجه کنید:

    [me@linuxbox ~]$ a[1]=foo
    [me@linuxbox ~]$ echo ${a[1]}
    foo

    در این نمونه، ابتدا مقدار "foo" به عنصر شماره 1 از آرایه a تخصیص یافته است. در دستور دوم، مقدار ذخیره‌شده در این عنصر بازخوانی و چاپ می‌شود. استفاده از آکولاد { } در عبارت دوم الزامی است؛ زیرا در غیر این صورت، پوسته نام متغیر را با عملیات بسط مسیر (Pathname Expansion) اشتباه گرفته و خروجی نادرستی ارائه می‌دهد.

    علاوه بر مقداردهی مستقیم، می‌توان یک آرایه را با استفاده از دستور داخلی declare نیز تعریف کرد:

    [me@linuxbox ~]$ declare -a a

    در اینجا، گزینه -a به پوسته اعلام می‌کند که متغیر a باید به عنوان یک آرایه (یک‌بعدی) در نظر گرفته شود.

    مقداردهی آرایه #

    در پوسته Bash، تخصیص مقادیر به آرایه به دو روش کلی انجام می‌شود. روش نخست، مقداردهی انفرادی عناصر است که از نحو (Syntax) زیر پیروی می‌کند:

    name[subscript]=value

    در این الگو، name نام آرایه و subscript یک عدد صحیح (یا یک عبارت محاسباتی) بزرگ‌تر یا مساوی صفر است. نکته‌ای که باید به خاطر داشت این است که در Bash، آرایه‌ها صفر-اندیس (Zero-indexed) هستند؛ یعنی اندیس نخستین عنصر آرایه صفر است و نه یک. value نیز می‌تواند یک رشته متنی یا یک عدد صحیح باشد که در آن عنصر ذخیره می‌گردد.

    روش دوم، انتساب مرکب (Compound Assignment) است که به شما اجازه می‌دهد چندین مقدار را به‌طور هم‌زمان تعریف کنید:

    name=(value1 value2 ...)

    در این ساختار، مقادیر به ترتیب از اندیس صفر به بعد در آرایه قرار می‌گیرند. برای مثال، جهت ذخیره مخفف نام روزهای هفته در آرایه days، می‌توان به این صورت عمل کرد:

    [me@linuxbox ~]$ days=(Sun Mon Tue Wed Thu Fri Sat)

    علاوه بر این، Bash این انعطاف‌پذیری را دارد که برای هر مقدار، اندیس مشخصی را تعیین کنید. این قابلیت برای ایجاد آرایه‌های پراکنده (Sparse Arrays) بسیار مفید است:

    [me@linuxbox ~]$ days=([0]=Sun [1]=Mon [2]=Tue [3]=Wed [4]=Thu [5]=Fri [6]=Sat)

    فراخوانی و پیمایش عناصر آرایه #

    آرایه‌ها چه کاربرد عملی در اسکریپت‌نویسی دارند؟ همان‌طور که بسیاری از فرآیندهای مدیریت داده در نرم‌افزارهای صفحه‌گسترده (Spreadsheet) انجام می‌شود، آرایه‌ها نیز در برنامه‌نویسی برای دسته‌بندی و تحلیل حجم زیادی از داده‌ها به کار می‌روند.

    برای درک بهتر، اسکریپتی به نام hours را بررسی می‌کنیم. وظیفه این اسکریپت، تحلیل زمان آخرین تغییرات (Modification Time) فایل‌ها در یک دایرکتوری خاص است. از این داده‌ها، اسکریپت ما جدولی تولید می‌کند که نشان می‌دهد فایل‌ها در کدام ساعت از شبانه‌روز آخرین بار تغییر یافته‌اند؛ ابزاری کارآمد برای شناسایی بازه‌های زمانی اوج فعالیت سیستم. خروجی این برنامه به شرح زیر است:

    [me@linuxbox ~]$ hours .
    Hour  Files  Hour  Files
    ----  -----  ----  -----
    00    0      12    11
    01    1      13    7
    02    0      14    1
    03    0      15    7
    04    1      16    6
    05    1      17    5
    06    6      18    4
    07    3      19    4
    08    1      20    1
    09    14     21    0
    10    2      22    0
    11    5      23    0
    
    Total files = 80

    در این مثال، ما برنامه hours را اجرا کرده و دایرکتوری جاری را به عنوان هدف مشخص نموده‌ایم. این برنامه جدولی را نمایش می‌دهد که برای هر ساعت از روز (۰ تا ۲۳)، تعداد فایل‌هایی را که در آن بازه زمانی آخرین تغییر را داشته‌اند، شمارش کرده است.

    منطق پیاده‌سازی این اسکریپت به شرح زیر است:

    #!/bin/bash
    
    # hours: script to count files by modification time
    
    usage () {
        echo "usage: ${0##*/} directory" >&2
    }
    
    # Check that argument is a directory
    if [[ ! -d "$1" ]]; then
        usage
        exit 1
    fi
    
    # Initialize array
    for i in {0..23}; do hours[i]=0; done
    
    # Collect data
    for i in $(stat -c %y "$1"/* | cut -c 12-13); do
        j="${i#0}"
        ((++hours[j]))
        ((++count))
    done
    
    # Display data
    echo -e "Hour\tFiles\tHour\tFiles"
    echo -e "----\t-----\t----\t-----"
    for i in {0..11}; do
        j=$((i + 12))
        printf "%02d\t%d\t%02d\t%d\n" \
            "$i" \
            "${hours[i]}" \
            "$j" \
            "${hours[j]}"
    done
    printf "\nTotal files = %d\n" "$count"

    این اسکریپت از یک تابع راهنما (usage) و یک بدنه اصلی شامل چهار بخش مجزا تشکیل شده است. در بخش اول، اعتبار آرگومان ارسالی در خط فرمان بررسی می‌شود تا اطمینان حاصل شود که ورودی حتماً یک دایرکتوری معتبر است؛ در غیر این صورت، دستورالعمل استفاده نمایش داده شده و اجرای برنامه متوقف می‌گردد.

    در بخش دوم، آرایه hours مقداردهی اولیه (Initialize) می‌شود. این فرآیند با اختصاص عدد صفر به هر یک از عناصر آرایه صورت می‌پذیرد. اگرچه در Bash الزامی برای تعریف پیش‌فرض آرایه‌ها وجود ندارد، اما برای اطمینان از صحت محاسبات و جلوگیری از وجود عناصر تهی (Null)، این گام ضروری است. نکته حائز اهمیت، بهره‌گیری از بسط آکولاد ({0..23}) در حلقه for است که روشی بهینه برای تولید توالی اعداد فراهم می‌کند.

    در بخش سوم، جمع‌آوری داده‌ها با اجرای دستور stat بر روی تمامی فایل‌های دایرکتوری هدف آغاز می‌شود. ساعت دو رقمی مربوط به زمان تغییر فایل با استفاده از دستور cut استخراج می‌گردد. در داخل حلقه، حذف صفرهای پیشین (Leading Zeros) از مقدار ساعت الزامی است؛ چرا که پوسته Bash اعدادی را که با صفر شروع می‌شوند (مانند 00 تا 09) به عنوان اعداد هشت‌تایی (Octal) تفسیر می‌کند و در مواجهه با مقادیری نظیر 08 یا 09 دچار خطای محاسباتی می‌شود. پس از این اصلاح، شمارنده مربوط به آن ساعت در آرایه و همچنین متغیر count برای محاسبه مجموع فایل‌ها افزایش می‌یابد.

    در بخش چهارم و نهایی، محتویات آرایه سازماندهی و چاپ می‌شوند. پس از درج عناوین ستون‌ها، یک حلقه تکرار خروجی را در قالب یک جدول چهارستونی مرتب می‌کند. در انتها نیز تعداد کل فایل‌های پردازش شده نمایش داده می‌شود.

    مدیریت و پیمایش آرایه‌ها #

    در برنامه‌نویسی پوسته، عملیات متعددی بر روی آرایه‌ها انجام می‌شود که برای مدیریت بهینه داده‌ها ضروری هستند. کارهایی نظیر حذف آرایه، تعیین طول آن و مرتب‌سازی عناصر، از جمله ابزارهای کلیدی در کیت اسکریپت‌نویسی محسوب می‌شوند.

    استخراج کامل محتویات آرایه

    برای دسترسی هم‌زمان به تمامی عناصر یک آرایه، از اندیس‌های ویژه * و @ استفاده می‌شود. رفتاری که این دو نماد از خود بروز می‌دهند، شباهت بسیاری به پارامترهای موقعیتی (Positional Parameters) دارد. در اکثر سناریوهای فنی، استفاده از نماد @ به دلیل حفظ ساختار داده‌ها ترجیح داده می‌شود. به مثال زیر برای درک تفاوت این دو توجه کنید:

    [me@linuxbox ~]$ animals=("a dog" "a cat" "a fish")
    [me@linuxbox ~]$ for i in ${animals[*]}; do echo $i; done
    a
    dog
    a
    cat
    a
    fish
    [me@linuxbox ~]$ for i in ${animals[@]}; do echo $i; done
    a
    dog
    a
    cat
    a
    fish
    [me@linuxbox ~]$ for i in "${animals[*]}"; do echo $i; done
    a dog a cat a fish
    [me@linuxbox ~]$ for i in "${animals[@]}"; do echo $i; done
    a dog
    a cat
    a fish

    در این نمونه، آرایه‌ای به نام animals شامل سه عنصر (که هر کدام دو کلمه هستند) تعریف شده است. با اجرای چهار حلقه فوق، تأثیر تفکیک کلمات (Word Splitting) بر خروجی به وضوح مشاهده می‌شود:

    • هنگامی که عبارات محصور در کوتیشن نباشند (طبق نمونه‌ی ${animals[*]} و ${animals[@]})، هر دو به یک شکل عمل کرده و تمام کلمات را به صورت جداگانه نمایش می‌دهند.
    • عبارت "${animals[*]}" کل محتوای آرایه را به صورت یک رشته واحد ادغام می‌کند.
    • عبارت "${animals[@]}" محتوای واقعی آرایه را حفظ کرده و هر عنصر را به صورت یک موجودیت مجزا (سه رشته دوکلمه‌ای) بازمی‌گرداند. این روش دقیق‌ترین راه برای پیمایش عناصر آرایه در حلقه‌ها است.

    محاسبه تعداد عناصر آرایه

    با بهره‌گیری از تکنیک بسط پارامتر (Parameter Expansion)، می‌توان تعداد کل عناصر یک آرایه را مشابه روشِ تعیین طولِ یک رشته استخراج کرد. به مثال زیر توجه کنید:

    [me@linuxbox ~]$ a[100]=foo
    [me@linuxbox ~]$ echo ${#a[@]}  # number of array elements
    1
    [me@linuxbox ~]$ echo ${#a[100]}  # length of element 100
    3

    در این نمونه، آرایۀ a تعریف شده و رشته "foo" به عنصر شمارۀ 100 آن تخصیص یافته است. با استفاده از نماد # در کنار @ (یا *)، تعداد کل عناصر موجود در آرایه شمارش می‌شود. سپس با ارجاع مستقیم به اندیس 100، طولِ محتوای آن عنصر (رشتۀ سه حرفی foo) محاسبه می‌گردد.

    نکتۀ فنی حائز اهمیت این است که علی‌رغم تخصیص مقدار به اندیس 100، پوسته Bash تعداد عناصر را تنها «1» گزارش می‌دهد. این رفتار با بسیاری از زبان‌های برنامه‌نویسی سنتی متفاوت است؛ در آن زبان‌ها، عناصرِ مابینِ 0 تا 99 نیز به‌صورت خودکار ایجاد و شمرده می‌شوند. در Bash، عناصر آرایه مستقل از شمارۀ اندیسشان، تنها زمانی «موجود» تلقی می‌شوند که مقداری به آن‌ها تخصیص یافته باشد.

    استخراج اندیس‌های فعال آرایه

    با توجه به اینکه Bash اجازه می‌دهد آرایه‌ها دارای شکاف (Gap) در شماره‌گذاری باشند (معروف به آرایه‌های پراکنده یا Sparse Arrays)، گاهی ضرورت دارد بدانیم دقیقاً کدام اندیس‌ها دارای مقدار هستند. این عمل با ساختار زیر در بسط پارامتر امکان‌پذیر است:

    ${!array[*]}
    ${!array[@]}

    در این الگو، array نام متغیر مورد نظر است. همانند رفتاری که پیش‌تر برای استخراج محتوا دیدیم، استفاده از نماد @ در داخل کوتیشن توصیه می‌شود؛ زیرا این فرم اندیس‌ها را به‌صورت کلمات مجزا و تفکیک‌شده بازمی‌گرداند. به تفاوت خروجی در مثال زیر دقت کنید:

    [me@linuxbox ~]$ foo=([2]=a [4]=b [6]=c)
    [me@linuxbox ~]$ for i in "${foo[@]}"; do echo $i; done
    a
    b
    c
    [me@linuxbox ~]$ for i in "${!foo[@]}"; do echo $i; done
    2
    4
    6

    در حلقۀ نخست، مقادیرِ ذخیره‌شده در عناصر چاپ می‌شوند، اما در حلقۀ دوم (با استفاده از علامت تعجب !)، تنها شماره‌های اندیس (2، 4 و 6) که دارای مقدار هستند، استخراج و نمایش داده می‌شوند.

    مقداردهی آرایه با دستور read -a

    دستور داخلی read از گزینه تخصصی -a پشتیبانی می‌کند که به جای توزیع کلمات ورودی در چندین متغیر مجزا، آن‌ها را به‌صورت مستقیم در قالب یک آرایه اندیس‌دار (Indexed Array) ذخیره می‌کند. در مثال زیر، این سازوکار نمایش داده شده است:

    [me@linuxbox ~]$ declare -a foo
    [me@linuxbox ~]$ read -a foo <<< "0th 1st 2nd 3rd 4th"
    [me@linuxbox ~]$ for i in "${foo[@]}"; do echo "$i"; done
    0th
    1st
    2nd
    3rd
    4th

    الحاق عناصر به انتهای آرایه

    در آرایه‌های Bash، صرفاً دانستن تعداد کل عناصر لزوماً به یافتن موقعیت انتهایی برای درج داده‌های جدید کمکی نمی‌کند؛ چرا که نمادهای * و @ لزوماً بزرگترین اندیس در حال استفاده را منعکس نمی‌کنند (به‌ویژه در آرایه‌های پراکنده). برای رفع این چالش، پوسته راهکاری هوشمندانه ارائه می‌دهد: با بهره‌گیری از عملگر انتساب ترکیبی += می‌توان مقادیر جدید را به‌صورت خودکار به انتهای آرایه الحاق (Append) کرد. در نمونه زیر، ابتدا سه مقدار به آرایه foo تخصیص یافته و سپس سه مقدار دیگر به انتهای آن افزوده می‌شود:

    [me@linuxbox ~]$ foo=(a b c)
    [me@linuxbox ~]$ echo ${foo[@]}
    a b c
    [me@linuxbox ~]$ foo+=(d e f)
    [me@linuxbox ~]$ echo ${foo[@]}
    a b c d e f

    خواندن فایل درون آرایه

    نسخه‌های جدید bash شامل یک دستور داخلی جدید به نام mapfile هستند که می‌تواند محتوای ورودی استاندارد (Standard Input) را مستقیماً در یک آرایه‌ی اندیس‌دار (Indexed Array) بخواند. نحو آن به‌صورت زیر است:

    mapfile -options array

    دستور داخلی mapfile (که با نام مستعار readarray نیز شناخته می‌شود)، ابزاری قدرتمند برای انتقال مستقیم محتوای متنی به آرایه‌ها است. این دستور از گزینه‌های عملیاتی متنوعی پشتیبانی می‌کند که کنترل دقیقی بر فرآیند خواندن داده‌ها فراهم می‌آورند. ویژگی‌های کلیدی این ابزار در جدول زیر خلاصه شده است:

    جدول ۱-۳۵: گزینه‌های کاربردی دستور mapfile

    گزینه شرح عملکرد
    -d delim
    نویسه‌ی delim را به‌عنوان جداکننده‌ی خطوط (به‌جای نویسه‌ی پیش‌فرض خط جدید یا Newline) در نظر می‌گیرد.
    -n count
    فرآیند خواندن را به تعداد مشخصی از خطوط، برابر با count، محدود می‌کند.
    -O origin
    نقطه‌ی آغازین اندیس‌گذاری را تعیین می‌کند؛ به این ترتیب، درج عناصر در آرایه به‌جای اندیس 0، از اندیس origin آغاز می‌شود.
    -s count
    از ابتدای ورودی، به تعداد count خط را نادیده می‌گیرد و از روی آن‌ها رد می‌شود.
    -t
    نویسه‌ی جداکننده (مانند \n) را از انتهای هر عنصر، پیش از درج آن در آرایه، حذف می‌کند.

    به منظور نمایش توانمندی‌های دستور mapfile در یک سناریوی واقعی، اسکریپتی طراحی می‌کنیم که «عبارات عبور» (Passphrases) تصادفیِ چهارکلمه‌ای تولید می‌کند. این عبارات جایگزینی ایده‌آل برای گذرواژه‌های سنتی هستند؛ چرا که با وجود طول زیاد، به‌خاطر سپردن آن‌ها برای انسان آسان و در عین حال شکستن آن‌ها برای ماشین دشوار است.

    #!/bin/bash
    
    # array-mapfile - demonstrate mapfile builtin
    
    DICTIONARY=/usr/share/dict/words
    WORDLIST=~/wordlist.txt
    declare -a words
    
    # create filtered word list
    grep -v \' < "$DICTIONARY" \
        | grep -v "[[:upper:]]" \
        | shuf > "$WORDLIST"
    
    # read WORDLIST into array
    mapfile -t -n 32767 words < "$WORDLIST"
    
    # create four word passphrase
    while [[ -z $REPLY ]]; do
        echo "${words[$RANDOM]}" \
             "${words[$RANDOM]}" \
             "${words[$RANDOM]}" \
             "${words[$RANDOM]}"
        read -r -p "Enter to continue, q to quit > "
        echo
    done

    این اسکریپت با بهره‌گیری از فایل مرجع /usr/share/dict/words آغاز به کار می‌کند. در فرآیند فیلترسازی، کلماتی که دارای آپاستروف یا حروف بزرگ هستند حذف می‌شوند تا خروجی یکدست باشد. سپس، با استفاده از دستور shuf، لیست کلمات به‌طور کامل درهم‌ریخته می‌شود تا از توزیع تصادفی مناسب اطمینان حاصل گردد.

    در بخش اصلی، دستور mapfile با گزینه -t (برای حذف کاراکتر خط جدید از انتهای کلمات) و -n 32767 (برای محدود کردن تعداد کلمات ورودی به سقف تعیین شده)، داده‌ها را مستقیماً در آرایه words بارگذاری می‌کند. در نهایت، با استفاده از متغیر داخلی $RANDOM به عنوان اندیس آرایه، چهار کلمه به‌صورت تصادفی انتخاب و به عنوان عبارت عبور به کاربر پیشنهاد داده می‌شوند.

    در مرحله بعد، تعداد ۳۲,۷۶۷ کلمه نخست از فایل فیلترشده را در آرایه words بارگذاری می‌کنیم. انتخاب عدد ۳۲,۷۶۷ تصادفی نیست؛ در واقع این مقدار متناظر با بیشینه ظرفیت متغیر داخلی $RANDOM در پوسته Bash است. این متغیر در هر بار فراخوانی، یک عدد صحیح تصادفی در بازه [0,32767] بازمی‌گرداند که ما از آن به عنوان اندیس (Index) برای انتخاب عناصر آرایه استفاده می‌کنیم.

    خروجی اجرای اسکریپت به صورت زیر خواهد بود:

    [me@linuxbox ~]$ ./array-mapfile
    conversions slumbers appendages metastasizing
    
    Enter to continue, q to quit >
    
    kettles rhinestones unused demagnetizes
    
    Enter to continue, q to quit >
    
    wear conveys characterizing extrusion
    
    Enter to continue, q to quit > q

    همان‌طور که در خروجی مشاهده می‌شود، با هر بار فشردن کلید Enter، اسکریپت با مراجعه به آرایه و انتخاب چهار اندیس تصادفی، یک عبارت عبور جدید تولید می‌کند. این فرآیند تا زمانی که کاربر کلید q را برای خروج وارد نکند، ادامه خواهد داشت.

    برش‌دهی آرایه‌ها (Array Slicing) #

    با استفاده از قابلیتی در بسط پارامتر (Parameter Expansion)، می‌توان گروهی از عناصر متوالی یک آرایه را تحت عنوان بُرش (Slice) استخراج کرد. این تکنیک به شما اجازه می‌دهد تا بدون تغییر در آرایه اصلی، بخش خاصی از داده‌های آن را استخراج کنید.

    [me@linuxbox ~]$ arr=(0th 1st 2nd 3rd 4th)
    [me@linuxbox ~]$ echo "${arr[@]:2:3}"
    2nd 3rd 4th

    در مثال فوق، ابتدا آرایه‌ای با پنج عنصر تعریف شده است. سپس با استفاده از نحو بالا، تعداد 3 عنصر متوالی از آرایه، با شروع از اندیس 2، استخراج شده‌اند.

    همچنین، با استفاده از مقادیر منفی برای اندیس، می‌توان عملیات استخراج را از انتهای آرایه (به جای ابتدا) مدیریت کرد. در نمونه زیر، دو عنصر نهایی آرایه استخراج شده‌اند. نکته مهم این است که وجود یک فضای خالی (Space) پیش از علامت منفی الزامی است تا پوسته آن را با عملگرهای پیش‌فرض اشتباه نگیرد.

    [me@linuxbox ~]$ echo "${arr[@]: -2:2}"
    3rd 4th

    علاوه بر نمایش ساده، می‌توان خروجی حاصل از یک برش را مستقیماً برای ایجاد و مقداردهی یک آرایه جدید به کار برد:

    [me@linuxbox ~]$ arr2=("${arr[@]:2:3}")
    [me@linuxbox ~]$ echo "${arr2[@]}"
    2nd 3rd 4th

    در این بخش، آرایه جدیدی به نام arr2 تعریف شده و با سه عنصری که از آرایه arr برش داده شده بود، مقداردهی شده است.

    مرتب‌سازی آرایه‌ها #

    همانند نرم‌افزارهای صفحه‌گسترده، در اسکریپت‌نویسی نیز اغلب با سناریوهایی مواجه می‌شویم که نیازمند مرتب‌سازی (Sorting) مقادیر یک ستون داده یا عناصر یک آرایه هستند. اگرچه پوسته Bash فاقد یک تابع داخلی مستقیم برای این کار است، اما می‌توان با بهره‌گیری از ابزارهای استاندارد لینوکس و ترکیب آن‌ها، این قابلیت را به‌سادگی پیاده‌سازی کرد.

    #!/bin/bash
    
    # array-sort: Sort an array
    
    a=(f e d c b a)
    
    echo "Original array: " "${a[@]}"
    a_sorted=($(for i in "${a[@]}"; do echo "$i"; done | sort))
    echo "Sorted array:   " "${a_sorted[@]}"

    پس از اجرا، خروجی اسکریپت به صورت زیر خواهد بود:

    [me@linuxbox ~]$ array-sort
    Original array: f e d c b a
    Sorted array:   a b c d e f

    این اسکریپت با استفاده از مکانیزم جایگزینی فرمان (Command Substitution)، محتویات آرایه اصلی (a) را استخراج کرده و به کمک یک حلقه، هر عنصر را در یک خط مجزا به ابزار استاندارد sort ارسال می‌کند. در نهایت، خروجی مرتب‌شده مجدداً در قالب یک آرایه جدید (a_sorted) ذخیره می‌شود. این تکنیکِ بنیادی را می‌توان با تغییر در طراحی پایپ‌لاین (Pipeline)، برای انجام انواع عملیات پردازشی پیچیده بر روی آرایه‌ها تعمیم داد.

    حذف آرایه و عناصر آن #

    برای حذف کامل یک آرایه، از دستور داخلی unset استفاده می‌شود. در مثال زیر، ابتدا آرایه‌ای تعریف شده و سپس به‌طور کامل حذف می‌گردد:

    [me@linuxbox ~]$ foo=(a b c d e f)
    [me@linuxbox ~]$ echo ${foo[@]}
    a b c d e f
    [me@linuxbox ~]$ unset foo
    [me@linuxbox ~]$ echo ${foo[@]}
    
    [me@linuxbox ~]$

    دستور unset علاوه بر حذف کل آرایه، برای حذف عناصر انفرادی نیز کاربرد دارد. به نمونه زیر توجه کنید:

    [me@linuxbox ~]$ foo=(a b c d e f)
    [me@linuxbox ~]$ echo ${foo[@]}
    a b c d e f
    [me@linuxbox ~]$ unset 'foo[2]'
    [me@linuxbox ~]$ echo ${foo[@]}
    a b d e f

    در این سناریو، عنصر سوم آرایه (که دارای اندیس 2 است) حذف شده است. یادآوری این نکته ضروری است که در Bash، شمارش اندیس‌ها از صفر آغاز می‌شود. همچنین، هنگام استفاده از unset برای یک عنصر خاص، قرار دادن عبارت در کوتیشن (Quotation) الزامی است تا از تفسیر اشتباه کروشه‌ها توسط پوسته و بروز خطای بسط مسیر (Pathname Expansion) جلوگیری شود.

    نکته فنی و حائز اهمیت این است که تخصیص یک مقدار خالی به نام آرایه، منجر به پاکسازی کل محتوای آن نمی‌شود:

    [me@linuxbox ~]$ foo=(a b c d e f)
    [me@linuxbox ~]$ foo=
    [me@linuxbox ~]$ echo ${foo[@]}
    b c d e f

    دلیل این رفتار آن است که در Bash، هرگونه ارجاع به نام آرایه بدون تعیین اندیس، به‌صورت پیش‌فرض به عنصر صفرم اشاره دارد. بنابراین، دستور foo= تنها مقدار موجود در اندیس 0 را به یک رشته تهی تبدیل می‌کند و سایر عناصر دست‌نخورده باقی می‌مانند:

    [me@linuxbox ~]$ foo=(a b c d e f)
    [me@linuxbox ~]$ echo ${foo[@]}
    a b c d e f
    [me@linuxbox ~]$ foo=A
    [me@linuxbox ~]$ echo ${foo[@]}
    A b c d e f

    همان‌طور که مشاهده می‌شود، مقدار جدید (A) جایگزین مقدار قبلی در اندیس صفر شده است، بدون آنکه ساختار کلی آرایه تغییری کند.

    آرایه‌های انجمنی (Associative Arrays) #

    نسخه‌های ۴.۰ و بالاتر پوسته Bash از قابلیت آرایه‌های انجمنی پشتیبانی می‌کنند. این نوع آرایه‌ها برخلاف مدل‌های سنتی که از اعداد صحیح برای اندیس‌گذاری (Indexing) استفاده می‌کردند، رشته‌های متنی را به عنوان اندیس (Key) می‌پذیرند. این ویژگی منجر به ایجاد ساختار جفت‌های کلید-مقدار (Key-Value Pairs) می‌شود که در علوم کامپیوتر با عناوینی همچون «دیکشنری» (Dictionary) یا «جدول هش» (Hash Table) شناخته می‌شوند. آرایه‌های انجمنی رویکردهای نوین و منعطفی را برای مدیریت داده‌ها فراهم می‌سازند؛ برای نمونه، می‌توان آرایه‌ای به نام colors تعریف کرد و نام رنگ‌ها را مستقیماً به عنوان کلید به کار برد:

    declare -A colors
    colors["red"]="#ff0000"
    colors["green"]="#00ff00"
    colors["blue"]="#0000ff"

    برخلاف آرایه اندیس‌دار (Indexed Arrays) که صرفاً با ارجاع به یک عنصر ایجاد می‌شوند، آرایه‌های انجمنی لزوماً باید با استفاده از دستور declare و گزینه -A به‌صورت صریح تعریف شوند. دسترسی به عناصر این آرایه‌ها نیز با روشی مشابه آرایه‌های اندیس‌دار صورت می‌گیرد:

    echo ${colors["blue"]}

    یکی از کاربردی‌ترین مزایای ساختار جفت کلید-مقدار، بهینه‌سازی عملیات جستجو (Lookup) است. آرایه‌های انجمنی امکان دسترسی مستقیم به داده را فراهم می‌کنند و نیاز به جستجوی خطی (Linear Search) در کل عناصر را از میان می‌برند. در اسکریپت زیر، نام تمامی فایل‌های دایرکتوری /usr/bin/ به همراه حجم آن‌ها در یک آرایه انجمنی بارگذاری شده و سپس بر اساس ورودی کاربر، عملیات جستجوی سریع انجام می‌شود:

    #!/bin/bash
    
    # array-lookup - demonstrate lookup using associative array
    
    declare -A cmds
    
    # fill array with commands and file sizes
    cd /usr/bin || exit 1
    echo "Loading commands..."
    for i in ./*; do
        cmds["$i"]=$(stat -c "%s" "$i")
    done
    echo "${#cmds[@]} commands loaded"
    
    # perform lookup
    while true; do
        read -r -p "Enter command (empty to quit) -> "
        [[ -z $REPLY ]] && break
        if [[ -x $REPLY ]]; then
            echo "$REPLY" "${cmds[./$REPLY]}" "bytes"
        else
            echo "No such command '$REPLY'."
        fi
    done

    هنگام اجرای برنامه، تعامل کاربر با سیستم به صورت زیر خواهد بود:

    [me@linuxbox ~]$ ./array-lookup
    Loading commands...
    2329 commands loaded
    Enter command (empty to quit) -> ls
    ls 138216 bytes
    Enter command (empty to quit) -> cp
    cp 141832 bytes
    Enter command (empty to quit) -> mv
    mv 137752 bytes
    Enter command (empty to quit) -> rm
    rm 59912 bytes
    Enter command (empty to quit) ->
    [me@linuxbox ~]$

    در فصل آتی، اسکریپت پیشرفته‌تری را بررسی خواهیم کرد که با بهره‌گیری بهینه از آرایه‌های انجمنی، گزارش‌های تحلیلی دقیقی تولید می‌کند.

    شبیه‌سازی آرایه‌های چندبعدی (Multi-dimensional Arrays) #

    اگرچه پوسته Bash به‌صورت بومی تنها از آرایه‌های یک‌بعدی پشتیبانی می‌کند، اما می‌توان با استفاده از آرایه‌های انجمنی، ساختارهای چندبعدی را به‌سادگی شبیه‌سازی کرد. تکنیک اصلی در این روش، ایجاد رشته‌های ترکیبی برای اندیس‌هاست که نقش «آدرس» عناصر را در یک فضای چندبعدی ایفا می‌کنند. به مثال زیر توجه کنید:

    #!/bin/bash
    
    # array-multi - simulate a multi-dimensional array
    
    declare -A multi_array
    
    # Load array with a sequence of numbers
    counter=1
    for row in {1..10}; do
        for col in {1..5}; do
            address="$row, $col"
            multi_array["$address"]=$counter
            ((counter++))
        done
    done
    
    # Output array contents
    for row in {1..10}; do
        for col in {1..5}; do
            address="$row, $col"
            echo -ne "${multi_array["$address"]}" "\t"
        done
        echo
    done

    اجرای این اسکریپت خروجی ماتریسی زیر را تولید می‌کند:

    [me@linuxbox ~]$ ./array-multi
    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
    26	27	28	29	30
    31	32	33	34	35
    36	37	38	39	40
    41	42	43	44	45
    46	47	48	49	50

    در این اسکریپت، ما با ترکیب متغیرهای row و col و جدا کردن آن‌ها با یک نویسه (در اینجا ویرگول)، کلید منحصربه‌فردی برای هر خانه از ماتریس ایجاد کردیم. این رویکرد به ما اجازه می‌دهد داده‌ها را در قالب سطر و ستون سازماندهی کنیم، گویی با یک آرایه دو‌بعدی واقعی سروکار داریم.

    جمع‌بندی #

    با جست‌وجوی واژه array در صفحات راهنمای Bash، به موارد متعددی برمی‌خوریم که این پوسته از متغیرهای آرایه‌ای استفاده می‌کند. اگرچه بسیاری از این کاربردها تخصصی و در موارد خاصی راهگشا هستند، اما واقعیت این است که استفاده از آرایه‌ها در دنیای اسکریپت‌نویسی پوسته، کمتر از پتانسیل واقعی آن‌هاست. ریشه این موضوع عمدتاً به نبودِ پشتیبانی از آرایه‌ها در پوسته‌های سنتی یونیکس (مانند sh) بازمی‌گردد. این عدم محبوبیت جای تأسف دارد؛ چرا که آرایه‌ها در سایر زبان‌های برنامه‌نویسی جایگاهی بنیادین دارند و ابزاری فوق‌العاده قدرتمند برای حل چالش‌های پیچیده مهندسی نرم‌افزار فراهم می‌کنند.

    آرایه‌ها و حلقه‌ها رابطه‌ای تنگاتنگ و ارگانیک با یکدیگر دارند. در میان انواع مختلف ساختارها، فرم خاصی از حلقه‌ی for (با نحوی مشابه زبان C) برای پیمایش و محاسبه‌ی اندیس‌های آرایه‌های اندیس‌دار (Indexed Arrays) بسیار کارآمد است:

    for ((expr; expr; expr))

    منابع مطالعه تکمیلی #

    چند مقاله از ویکی‌پدیا پیرامون ساختارهای داده (data structures) مطرح‌شده در این فصل: