ผ่านอาร์เรย์เป็นพารามิเตอร์ในทุบตี

ฉันจะส่งผ่านอาร์เรย์เป็นพารามิเตอร์ไปยังฟังก์ชัน bash ได้อย่างไร

หมายเหตุ:หลังจากไม่พบคำตอบที่นี่ใน Stack Overflow ฉันโพสต์คำตอบที่ค่อนข้างหยาบของฉันเอง อนุญาตให้ส่งผ่านได้เพียงหนึ่งอาเรย์เท่านั้นและเป็นองค์ประกอบสุดท้ายของรายการพารามิเตอร์ ที่จริงแล้วมันไม่ได้ผ่านอาร์เรย์เลย แต่รายชื่อขององค์ประกอบของมันซึ่งถูกประกอบเข้าอีกครั้งในอาร์เรย์โดยเรียกว่า _function () แต่มันได้ผลสำหรับฉัน หากใครรู้วิธีที่ดีกว่าอย่าลังเลที่จะเพิ่มที่นี่

คุณสามารถส่งหลายอาร์เรย์เป็นอาร์กิวเมนต์โดยใช้สิ่งนี้:

takes_ary_as_arg()
{
    declare -a argAry1=("${!1}")
    echo "${argAry1[@]}"

    declare -a argAry2=("${!2}")
    echo "${argAry2[@]}"
}
try_with_local_arys()
{
    # array variables could have local scope
    local descTable=(
        "sli4-iread"
        "sli4-iwrite"
        "sli3-iread"
        "sli3-iwrite"
    )
    local optsTable=(
        "--msix  --iread"
        "--msix  --iwrite"
        "--msi   --iread"
        "--msi   --iwrite"
    )
    takes_ary_as_arg descTable[@] optsTable[@]
}
try_with_local_arys

จะสะท้อน:

sli4-iread sli4-iwrite sli3-iread sli3-iwrite  
--msix  --iread --msix  --iwrite --msi   --iread --msi   --iwrite

แก้ไข / หมายเหตุ: (จากความคิดเห็นด้านล่าง)

• descTableและoptsTableถูกส่งเป็นชื่อและถูกขยายในฟังก์ชัน ดังนั้นไม่$จำเป็นเมื่อกำหนดเป็นพารามิเตอร์
• โปรดทราบว่าสิ่งนี้ยังคงใช้ได้แม้กับdescTableฯลฯ ที่ถูกกำหนดด้วยlocalเพราะคนในท้องถิ่นสามารถมองเห็นได้จากฟังก์ชั่นที่พวกเขาเรียก
• !ใน${!1}การขยายตัวของตัวแปรหาเรื่อง 1
• declare -a เพียงแค่ทำให้อาร์เรย์ที่มีการจัดทำดัชนีชัดเจนไม่จำเป็นอย่างเคร่งครัด

หมายเหตุ:นี่เป็นคำตอบที่ค่อนข้างหยาบที่ฉันโพสต์ตัวเองหลังจากไม่พบคำตอบที่นี่ใน Stack Overflow อนุญาตให้ส่งผ่านได้เพียงหนึ่งอาเรย์เท่านั้นและเป็นองค์ประกอบสุดท้ายของรายการพารามิเตอร์ ที่จริงแล้วมันไม่ได้ผ่านอาร์เรย์เลย แต่รายชื่อขององค์ประกอบของมันซึ่งถูกประกอบเข้าอีกครั้งในอาร์เรย์โดยเรียกว่า _function () แต่มันได้ผลสำหรับฉัน ไม่นานเคนก็โพสต์คำตอบของเขา แต่ฉันเก็บไว้ที่นี่เพื่ออ้างอิง "ประวัติศาสตร์"

calling_function()
{
    variable="a"
    array=( "x", "y", "z" )
    called_function "${variable}" "${array[@]}"
}

called_function()
{
    local_variable="${1}"
    shift
    local_array=("${@}")
}

ปรับปรุงโดย TheBbean ขอบคุณ

แสดงความคิดเห็นในโซลูชัน Ken Bertelson และตอบ Jan Hettich:

มันทำงานอย่างไร

takes_ary_as_arg descTable[@] optsTable[@]บรรทัดในtry_with_local_arys()ฟังก์ชั่นส่ง:

1. นี่คือการสร้างสำเนาของdescTableและoptsTableอาร์เรย์ซึ่งสามารถเข้าถึงtakes_ary_as_argฟังก์ชันได้
2. takes_ary_as_arg()ฟังก์ชั่นได้รับdescTable[@]และoptsTable[@]เป็นสตริงหมายความว่าและ$1 == descTable[@]$2 == optsTable[@]

3. ในการเริ่มต้นของtakes_ary_as_arg()ฟังก์ชั่นการใช้${!parameter}ไวยากรณ์ซึ่งเรียกว่าการอ้างอิงทางอ้อมหรือบางครั้งอ้างถึงสองครั้งวิธีนี้แทนการใช้$1's คุ้มค่าเราจะใช้ค่าของการขยายมูลค่าของ$1ตัวอย่าง:

   baba=booba
   variable=baba
   echo ${variable} # baba
   echo ${!variable} # booba

   $2เช่นเดียวกันสำหรับ

4. วางสิ่งนี้ในการargAry1=("${!1}")สร้างargAry1เป็นอาร์เรย์ (วงเล็บตาม=) ด้วยการขยายdescTable[@]เช่นเดียวกับการเขียนargAry1=("${descTable[@]}")ตรงนั้น declareมีไม่จำเป็นต้องใช้

หมายเหตุ:มันเป็นมูลค่าการกล่าวขวัญว่าเริ่มต้น array โดยใช้แบบฟอร์มวงเล็บนี้เริ่มต้นแถวใหม่ตามIFSหรือภายในสนามแยกซึ่งเป็นค่าเริ่มต้นแท็บ , การขึ้นบรรทัดใหม่และพื้นที่ ในกรณีนั้นเนื่องจากมันใช้[@]สัญกรณ์แต่ละองค์ประกอบจะถูกมองด้วยตัวเองราวกับว่าเขาถูกยกมา (ตรงกันข้าม[*])

ฉันจองกับมัน

ในBASHขอบเขตตัวแปรท้องถิ่นเป็นฟังก์ชั่นปัจจุบันและฟังก์ชั่นเด็กทุกคนเรียกว่ามันtakes_ary_as_arg()ฟังก์ชั่นนี้ "เห็น" ฟังก์ชั่น "เห็น" เหล่านั้นdescTable[@]และoptsTable[@]อาร์เรย์จึงทำงาน (ดูคำอธิบายข้างต้น)

ถ้าเป็นอย่างนั้นทำไมไม่ลองดูตัวแปรเหล่านั้นโดยตรงล่ะ? มันเหมือนกับการเขียนที่นั่น:

argAry1=("${descTable[@]}")

ดูคำอธิบายข้างต้นซึ่งเป็นเพียงสำเนาค่าอาร์เรย์ตามปัจจุบันdescTable[@]IFS

สรุป

นี่คือการผ่านในสาระสำคัญไม่มีอะไรตามค่า - ตามปกติ

ฉันยังต้องการเน้นความคิดเห็นของ Dennis Williamson ด้านบน: sparse arrays (อาร์เรย์ที่ไม่มีคีย์ทั้งหมดกำหนด - ด้วย "hole" ในนั้น) จะไม่ทำงานตามที่คาดไว้ - เราจะคลายคีย์และ "ย่อ" อาร์เรย์

ที่ถูกกล่าวว่าฉันจะเห็นค่าสำหรับลักษณะทั่วไปฟังก์ชั่นจึงสามารถรับอาร์เรย์ (หรือคัดลอก) โดยไม่ทราบชื่อ

• สำหรับ ~ "copy": เทคนิคนี้ดีพอเพียงต้องระวังให้ดีว่าดัชนี (กุญแจ) หายไปแล้ว

• สำหรับสำเนาจริง: เราสามารถใช้ eval สำหรับกุญแจได้ตัวอย่างเช่น:

  eval local keys=(\${!$1})

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

• และแน่นอนถ้าเราจะผ่านdescTableและoptsTableสตริง (ไม่[@]) เราสามารถใช้อาร์เรย์ของตัวเอง (ในขณะที่โดยอ้างอิง) evalด้วย สำหรับฟังก์ชั่นทั่วไปที่ยอมรับอาร์เรย์

ปัญหาพื้นฐานที่นี่คือผู้พัฒนาทุบตี (s) ที่ออกแบบ / ใช้งานอาร์เรย์จริง ๆ เมาสุนัข พวกเขาตัดสินใจว่านั่น${array}เป็นแค่มือสั้น ๆ${array[0]}ซึ่งเป็นความผิดพลาดที่ไม่ดี โดยเฉพาะอย่างยิ่งเมื่อคุณพิจารณาว่า${array[0]}ไม่มีความหมายและประเมินเป็นสตริงว่างถ้าประเภทอาเรย์เป็นแบบเชื่อมโยงกัน

การกำหนดอาร์เรย์จะใช้รูปแบบarray=(value1 ... valueN)ที่ค่ามีไวยากรณ์[subscript]=stringจึงกำหนดค่าโดยตรงไปยังดัชนีเฉพาะในอาร์เรย์ สิ่งนี้ทำให้สามารถมีสองประเภทของอาร์เรย์ดัชนีและ hash ดัชนี (เรียกว่าเชื่อมโยงอาร์เรย์ใน bash parlance) นอกจากนี้ยังทำให้คุณสามารถสร้างอาร์เรย์ที่จัดทำดัชนีเป็นตัวเลขได้ การออกจาก[subscript]=ส่วนนั้นเป็นเพียงช่วงสั้น ๆ สำหรับอาเรย์ที่ทำดัชนีเป็นตัวเลขเริ่มต้นด้วยดัชนีลำดับที่ 0 และเพิ่มขึ้นด้วยค่าใหม่แต่ละค่าในคำสั่งการกำหนด

ดังนั้น${array}ควรประเมินทั้งอาร์เรย์ดัชนีและทั้งหมด มันควรจะประเมินค่าผกผันของคำสั่งที่ได้รับมอบหมาย CS ที่สำคัญในปีที่สามควรรู้สิ่งนั้น ในกรณีนี้รหัสนี้จะทำงานอย่างที่คุณคาดหวัง:

declare -A foo bar
foo=${bar}

จากนั้นการส่งผ่านอาร์เรย์ตามค่าให้กับฟังก์ชั่นและการกำหนดหนึ่งอาเรย์ให้กับอีกอันหนึ่งจะใช้งานได้เมื่อเชลล์ที่เหลือของไวยากรณ์เชลล์สั่งการ แต่เนื่องจากพวกเขาทำสิ่งนี้ไม่ถูกต้องผู้ดำเนินการที่ได้รับมอบหมาย=จึงไม่สามารถทำงานให้กับอาร์เรย์ได้และไม่สามารถส่งผ่านค่าอาร์เรย์ไปยังฟังก์ชันหรือไปยัง subshells หรือเอาต์พุตโดยทั่วไป ( echo ${array}) โดยไม่ต้องใช้รหัสเพื่อให้เคี้ยวทั้งหมด

ดังนั้นถ้ามันถูกต้องแล้วตัวอย่างต่อไปนี้จะแสดงให้เห็นว่าการใช้ประโยชน์ของอาร์เรย์ใน bash นั้นดีกว่ามาก:

simple=(first=one second=2 third=3)
echo ${simple}

ผลลัพธ์ที่ได้ควรเป็น:

(first=one second=2 third=3)

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

declare -A foo
read foo <file

อนิจจาเราได้รับการลดลงโดยทีมพัฒนาทุบตีสุดยอดเป็นอย่างอื่น

ดังนั้นการส่งอาเรย์ไปยังฟังก์ชั่นจึงมีเพียงตัวเลือกเดียวเท่านั้นและนั่นคือการใช้คุณสมบัติ nameref:

function funky() {
    local -n ARR

    ARR=$1
    echo "indexes: ${!ARR[@]}"
    echo "values: ${ARR[@]}"
}

declare -A HASH

HASH=([foo]=bar [zoom]=fast)
funky HASH # notice that I'm just passing the word 'HASH' to the function

จะส่งผลให้ผลลัพธ์ต่อไปนี้:

indexes: foo zoom
values: bar fast

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

funky "${!array[*]}" "${array[*]}"

จากนั้นเขียนโค้ดจำนวนมากไว้ในฟังก์ชั่นเพื่อประกอบอาร์เรย์อีกครั้ง

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

approuch ง่ายขึ้นจะเป็น

called_function()
{
  ...
  # do everything like shown by DevSolar
  ...

  # now get a copy of the positional parameters
  local_array=("$@")
  ...
}

function aecho {
  set "$1[$2]"
  echo "${!1}"
}

ตัวอย่าง

$ foo=(dog cat bird)

$ aecho foo 1
cat

วิธีง่ายๆในการผ่านหลายอาร์เรย์เนื่องจากพารามิเตอร์คือการใช้สตริงที่คั่นด้วยอักขระ คุณสามารถเรียกสคริปต์ของคุณเช่นนี้:

./myScript.sh "value1;value2;value3" "somethingElse" "value4;value5" "anotherOne"

จากนั้นคุณสามารถแยกมันในรหัสของคุณดังนี้:

myArray=$1
IFS=';' read -a myArray <<< "$myArray"

myOtherArray=$3
IFS=';' read -a myOtherArray <<< "$myOtherArray"

ด้วยวิธีนี้คุณสามารถผ่านหลาย ๆ อาร์เรย์เป็นพารามิเตอร์ได้และไม่จำเป็นต้องเป็นพารามิเตอร์สุดท้าย

อันนี้ใช้ได้แม้กับช่องว่าง:

format="\t%2s - %s\n"

function doAction
{
  local_array=("$@")
  for (( i = 0 ; i < ${#local_array[@]} ; i++ ))
    do
      printf "${format}" $i "${local_array[$i]}"
  done
  echo -n "Choose: "
  option=""
  read -n1 option
  echo ${local_array[option]}
  return
}

#the call:
doAction "${tools[@]}"

ด้วยเทคนิคเล็กน้อยคุณสามารถส่งพารามิเตอร์ที่มีชื่อไปยังฟังก์ชั่นพร้อมกับอาร์เรย์ได้

วิธีที่ฉันพัฒนาให้คุณเข้าถึงพารามิเตอร์ที่ส่งผ่านไปยังฟังก์ชันดังนี้:

testPassingParams() {

    @var hello
    l=4 @array anArrayWithFourElements
    l=2 @array anotherArrayWithTwo
    @var anotherSingle
    @reference table   # references only work in bash >=4.3
    @params anArrayOfVariedSize

    test "$hello" = "$1" && echo correct
    #
    test "${anArrayWithFourElements[0]}" = "$2" && echo correct
    test "${anArrayWithFourElements[1]}" = "$3" && echo correct
    test "${anArrayWithFourElements[2]}" = "$4" && echo correct
    # etc...
    #
    test "${anotherArrayWithTwo[0]}" = "$6" && echo correct
    test "${anotherArrayWithTwo[1]}" = "$7" && echo correct
    #
    test "$anotherSingle" = "$8" && echo correct
    #
    test "${table[test]}" = "works"
    table[inside]="adding a new value"
    #
    # I'm using * just in this example:
    test "${anArrayOfVariedSize[*]}" = "${*:10}" && echo correct
}

fourElements=( a1 a2 "a3 with spaces" a4 )
twoElements=( b1 b2 )
declare -A assocArray
assocArray[test]="works"

testPassingParams "first" "${fourElements[@]}" "${twoElements[@]}" "single with spaces" assocArray "and more... " "even more..."

test "${assocArray[inside]}" = "adding a new value"

กล่าวอีกนัยหนึ่งไม่เพียง แต่คุณสามารถเรียกพารามิเตอร์ของคุณตามชื่อของพวกเขา (ซึ่งประกอบไปด้วยแกนกลางที่อ่านได้มากขึ้น) คุณสามารถส่งผ่านอาร์เรย์ได้ (และการอ้างอิงถึงตัวแปร - คุณลักษณะนี้ใช้ได้เฉพาะในทุบตี 4.3)! นอกจากนี้ตัวแปรที่แมปนั้นอยู่ในขอบเขตของท้องถิ่นเช่นเดียวกับ $ 1 (และอื่น ๆ )

รหัสที่ทำให้งานนี้ค่อนข้างเบาและใช้ได้ทั้งใน bash 3 และ bash 4 (นี่เป็นรุ่นเดียวที่ฉันทดสอบด้วย) หากคุณสนใจเทคนิคเพิ่มเติมเช่นนี้ที่พัฒนาด้วย bash ที่ดีกว่าและง่ายกว่าคุณสามารถดูBash Infinity Frameworkของฉันได้รหัสด้านล่างนี้ได้รับการพัฒนาเพื่อจุดประสงค์นั้น

Function.AssignParamLocally() {
    local commandWithArgs=( $1 )
    local command="${commandWithArgs[0]}"

    shift

    if [[ "$command" == "trap" || "$command" == "l="* || "$command" == "_type="* ]]
    then
        paramNo+=-1
        return 0
    fi

    if [[ "$command" != "local" ]]
    then
        assignNormalCodeStarted=true
    fi

    local varDeclaration="${commandWithArgs[1]}"
    if [[ $varDeclaration == '-n' ]]
    then
        varDeclaration="${commandWithArgs[2]}"
    fi
    local varName="${varDeclaration%%=*}"

    # var value is only important if making an object later on from it
    local varValue="${varDeclaration#*=}"

    if [[ ! -z $assignVarType ]]
    then
        local previousParamNo=$(expr $paramNo - 1)

        if [[ "$assignVarType" == "array" ]]
        then
            # passing array:
            execute="$assignVarName=( \"\${@:$previousParamNo:$assignArrLength}\" )"
            eval "$execute"
            paramNo+=$(expr $assignArrLength - 1)

            unset assignArrLength
        elif [[ "$assignVarType" == "params" ]]
        then
            execute="$assignVarName=( \"\${@:$previousParamNo}\" )"
            eval "$execute"
        elif [[ "$assignVarType" == "reference" ]]
        then
            execute="$assignVarName=\"\$$previousParamNo\""
            eval "$execute"
        elif [[ ! -z "${!previousParamNo}" ]]
        then
            execute="$assignVarName=\"\$$previousParamNo\""
            eval "$execute"
        fi
    fi

    assignVarType="$__capture_type"
    assignVarName="$varName"
    assignArrLength="$__capture_arrLength"
}

Function.CaptureParams() {
    __capture_type="$_type"
    __capture_arrLength="$l"
}

alias @trapAssign='Function.CaptureParams; trap "declare -i \"paramNo+=1\"; Function.AssignParamLocally \"\$BASH_COMMAND\" \"\$@\"; [[ \$assignNormalCodeStarted = true ]] && trap - DEBUG && unset assignVarType && unset assignVarName && unset assignNormalCodeStarted && unset paramNo" DEBUG; '
alias @param='@trapAssign local'
alias @reference='_type=reference @trapAssign local -n'
alias @var='_type=var @param'
alias @params='_type=params @param'
alias @array='_type=array @param'

เพียงเพิ่มคำตอบที่ยอมรับเพราะฉันพบว่ามันไม่ได้ผลถ้าเนื้อหาอาเรย์เป็นที่ชอบ:

RUN_COMMANDS=(
  "command1 param1... paramN"
  "command2 param1... paramN"
)

ในกรณีนี้สมาชิกแต่ละคนของอาเรย์จะได้รับการแยกดังนั้นอาเรย์ที่ฟังก์ชั่นเห็นนั้นเทียบเท่ากับ

RUN_COMMANDS=(
    "command1"
    "param1"
     ...
    "command2"
    ...
)

เพื่อให้กรณีนี้ทำงานได้อย่างที่ฉันพบคือการส่งชื่อตัวแปรไปยังฟังก์ชันแล้วใช้ eval:

function () {
    eval 'COMMANDS=( "${'"$1"'[@]}" )'
    for COMMAND in "${COMMANDS[@]}"; do
        echo $COMMAND
    done
}

function RUN_COMMANDS

แค่ 2 ©ของฉัน

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

function passarray()
{
    eval array_internally=("$(echo '${'$1'[@]}')")
    # access array now via array_internally
    echo "${array_internally[@]}"
    #...
}

array=(0 1 2 3 4 5)
passarray array # echo's (0 1 2 3 4 5) as expected

ฉันแน่ใจว่าคนที่สามารถเกิดขึ้นกับการดำเนินงานของ clearner ความคิด แต่ฉันได้พบนี้จะเป็นทางออกที่ดีกว่าที่ผ่านอาร์เรย์เป็นแล้วการเข้าถึงภายในโดยใช้"{array[@]"} array_inside=("$@")สิ่งนี้จะซับซ้อนเมื่อมีตำแหน่ง / getoptsพารามิเตอร์อื่น ๆ ในกรณีเหล่านี้ฉันต้องพิจารณาก่อนแล้วจึงลบพารามิเตอร์ที่ไม่เกี่ยวข้องกับอาร์เรย์โดยใช้การรวมshiftและการกำจัดองค์ประกอบอาร์เรย์

มุมมองที่พิถีพิถันน่าจะมองว่าวิธีนี้เป็นการละเมิดภาษา แต่ในทางปฏิบัติวิธีการนี้ช่วยให้ฉันเศร้าใจมาก ในหัวข้อที่เกี่ยวข้องฉันยังใช้evalเพื่อกำหนดอาร์เรย์ที่สร้างขึ้นภายในให้กับตัวแปรที่ตั้งชื่อตามพารามิเตอร์ที่target_varnameฉันส่งไปยังฟังก์ชัน:

eval $target_varname=$"(${array_inside[@]})"

หวังว่านี่จะช่วยใครซักคน

สิ่งที่ต้องการ : ฟังก์ชั่นเพื่อค้นหาสตริงในอาร์เรย์
นี่เป็นวิธีแก้ปัญหาที่ง่ายขึ้นเล็กน้อยของ DevSolar โดยใช้อาร์กิวเมนต์ที่ส่งผ่านแทนที่จะคัดลอก

myarray=('foobar' 'foxbat')

function isInArray() {
  local item=$1
  shift
  for one in $@; do
    if [ $one = $item ]; then
      return 0   # found
    fi
  done
  return 1       # not found
}

var='foobar'
if isInArray $var ${myarray[@]}; then
  echo "$var found in array"
else
  echo "$var not found in array"
fi 

คำตอบสั้น ๆ ของฉันคือ:

function display_two_array {
    local arr1=$1
    local arr2=$2
    for i in $arr1
    do
       "arrary1: $i"
    done
    
    for i in $arr2
    do
       "arrary2: $i"
    done
}

test_array=(1 2 3 4 5)
test_array2=(7 8 9 10 11)

display_two_array "${test_array[*]}" "${test_array2[*]}"