Как передать массив имен переменных и дополнительно аргументы?

Что мешает не использовать параметры а объявить перед вызовом переменные и использовать их внутри?

Давай пример. А то я это всё понял так: объявляй глобальные переменные и внутри функции их используй

С телефона не буду, просто используешь в функции переменную и перед вызвом определяешь её.

Лучше ты кодом это покажи

Да, это плохо?

Для пятизвездочных регистрантов - это обычная практика :)

Ну делай из баша питон.

Кстати да, передавай жсон и парси.

Мы вывели все аргументы. Далее что?

Что удалил то, вот в структуре и передавай и данные и команды.

дам пример за 10 долларов в час.

Вместо echo ставьте то, что вам с ними делать нужно.

Джуны подсидят.

Это плохой вариант

Какой ужас. Если бы я не видел в удалённых про yaml я бы подумал, что ты сошёл с ума. Впрочем, всё равно плохо. Это баш, его не испортить использованием глобальных переменных. А вот простынёй нечитаемого жонглирования массивами - можно.

PS Я за бан. ТС намеренно неполно доносит решаемую задачу.

Хорошо, есть 10 функций, в которые попадает разное кол-во аргументов. Ты предлагаешь это делать вручную глобальными переменными?

да и это нормальный подход в большинстве скриптовых языков, в том числе питоне (ну для чистоты, там любят все обернуть в слово class и использовать self вместо глобальной переменной, но суть не меняется)

Это нормальный подход среди сеньоров-помидоров. У нас, джунов, так не принято. Моветон-с

Хаха, ну без шуток, конечно есть случаи когда функция используется действительно как функция, а не попытки в чистый код. То есть тебе реально нужно вызывать функцию с разными параметрами много раз, тогда параметризация нужна. Только джуны обычно используют функции просто чтобы функции были поменьше, в то время, когда синьоры пишут все в одной большой на 500 строк

Во-первых, шелл нужен для того, чтобы файлы двигать и программы запускать, а не парсить текст или делать сложную логику. Функции в дружелюбных шел-скриптах должны принимать немного тривиальных аргументов, или много одинаковых типа delete_n_first_lines 5 file1 file2 file3. Такая функция пишется и читается очень легко.

А во-вторых, если уж так сильно хочется сложные функкции и не запутаться в портянках, то я последний раз делал так (реальный код):

function get_battle_index()
{
    local usage='Usage: .. chapter piece'
    local chapter=${1:?$usage}
    local piece=${2:?$usage}
    for ((index=0;index<${#DATATABLE[@]}/8;++index)); do
        if [ "${DATATABLE[0+index*8]}" -eq "$chapter" ] && [ "${DATATABLE[1+index*8]}" -eq "$piece" ]; then
            echo $index
            return
        fi
    done
    return 1
}

И да, DATATABLE глобальная.

Плохой для других языков, на для bash вполне хороший. Приватные можно по номеру:

# не помню точно как, но примерно
local pVar_a="$4"
local pVar_normalnoename4tobybiloponyatno4toetotakoe="$6"

Если тебе не нравится использовать для каждой функции F переменные F_OPT_1 … F_OPT_N, то ты можешь использовать одну переменную F_OPT, значением которой сделать массив опций. Правда в этом случае тебе придётся держать в уме количество параметров и их порядок.

Кстати, раз уж ты всё равно держишь в уме количество параметров то можешь всё передавать в массиве позиционных переменных, отсчитав из них сколько нужно.

Впрочем, если мы не знаем заранее количество параметров то можно сделать разделитель: проверять текущую переменную и если она не совпадает со строкой-разделителем то использовать её как управляющую после чего использовать оставшиеся как данные. В этом случае можно даже передавать параметры парами, добавляя название.

А, можно поступить и по другому, можно в первой позиционной переменной передавать число опций. В остальном это предыдущий случай.

Но можно просто взять, например, какой нибудь питон или похапе. Или поискать утилиту которая решает имеющуюся задачу, возможно такая существует.

Зачем набаш?!

В Памплоне есть модули для синглтонизации состояния

То что фОнаты наворачивают через классы инкапсуляцию части глобального состояния - лингва франка проходимцев из всяких жаб

Вполне неплохо выглядит.

Даже проще

f() {
    eval local "$@"
    echo $x $y $z
}

С пробелами не работает.

Исправленный исходный вариант

$ cat args.sh 
#!/usr/bin/env bash

f() {
    for i in "$@"; do
        eval local "\"$i\""
    done
    echo $x $y $z
}

f x=lala y="baba '1'" "z=dada"

$ bash args.sh 
lala baba '1' dada

Исправление для кавычек

$ cat args.sh 
#!/usr/bin/env bash

f() {
    for i in "$@"; do
        eval "$(printf "local %q" "$i")"
    done
    echo $x $y $z
}

f x=lala y="baba '1'" "z=\"dada\""

$ bash args.sh 
lala baba '1' "dada"

Как передать массив имен переменных и дополнительно аргументы?

Что бы передать массив имён переменных передавай их в конце как отдельные аргументы, после дополнительных аргументов.

Нормальный вариант, но не в моем кейсе

Зачем набаш?!

Такой кейс

Такая конструкция подходит, когда в функцию передаются key=value, а если заранее объявлена переменная?

Не могу понять. Напиши, пожалуйста, идеальный вариант на знакомом языке, может так легче будет понять. C, C#, Go, Java, JS, Python, что-нибудь.

Какая цель? в функции run() создать в цикле локальные переменные, чтобы имена переменных совпадали с теми именами, которые в нее передаются

А он не может. Это секретные знания.

Эти секретные знания звучат как «как превратить позиционные аргументы передаваемые в функцию в именованные» и в шапке топика это явно видно

Это странная задача даже для других языков. Например, в питоне так нельзя.

def foo(bar):
    print(bar) # Идентификатор 'hurr' никак не передаётся

hurr=123
foo(hurr)

Но в баше она как раз решается через глобальные переменные.

FOO=4
BAR=6
BAZ=(all your base are belong to us)
function hurr() {
    printf '%s=%s\n' $1 ${!1}
    printf '%s=%s\n' $2 ${!2}
    array_ref=${3}[@]
    printf '%s=' $3
    printf '%s ' "${!array_ref}"
    printf '\n'
}
hurr FOO BAR BAZ

UPD: есть ещё один способ. Он буквально передаёт переменную вместе с именем и про него все знают хотя немногие, думаю, пользовались им с функциями:

function hurr() {
    set | grep '^xx[0-9a-zA-Z_]*='
    printf 'xxFOO=%s xxBAR=%s\n' "$xxFOO" "$xxBAR"
    printf 'xxBAZ='
    printf '[%s] ' ${xxBAZ[@]}
    printf '\n'
}
xxFOO=44 xxBAR=66 xxBAZ=(массивы так передать нельзя) hurr

В питоне нельзя, в лиспе можно:

CS> (defmacro foo (var)
      (format t "~a~%" var))
FOO
CS> (defvar *hurr* 123)
*HURR*
CS> *hurr*
123
CS> (foo *hurr*)
*HURR*
NIL

С макросами даже в Си можно, хехе.

Так напиши свое решение, кривое, косое, но свое. Что ж не напишешь?

Есть какой-то более элегантный способ работы с аргументами в функции?

Да, использовать более подходящий язык.

Шелл не для алгоритмов, он чтобы запустить по очереди несколько программ с тривиальной небольшой логикой связи между ними.

Так напиши свое решение, кривое, косое, но свое. Что ж не напишешь?

В шапке разве нет решения, нет?