Команда печати путем чтения файла CSV с помощью AWK в массив bash

Кажется, я в итоге нашел решение... Это некрасиво, потому что использует eval, что само по себе может стать источником проблем.

Решение заключается в том, чтобы сначала открыть новый массив с правильными командами в каждой строке:

configs=()
for i in "${!first_column[@]}"; do
    echo "${first_column[i]}"
    echo "${second_column[i]}"
    echo "${command[i]}"
    
    configs+=( $(echo "execute_program_name --first "${first_column[i]}" --second "${second_column[i]}" "${command[i]}"") )

done

Затем запустите:

for i in "${configs[@]}"; do
    eval $i
done

Я не уверен, что одна строка вашего ввода работает неправильно, а следующая будет. Но на моем примере это сработало

Предположения:

• входную строку --command yes this is bad --other-command необходимо передать execute_program_name в следующем формате: --command 'yes this is bad' --other-command
• третий столбец состоит из вариантов длинной формы (т. е. варианты всегда начинаются с --)
• если третий столбец заполнен, первая строка всегда будет иметь длинную форму (т. е. строка всегда будет иметь формат --option)
• содержимое mycsv.csv нужно проанализировать только для этого одного for цикла; конечный результат: нам понадобится только один массив (args[]); (см. вторую половину ответа о подходе, который допускает одиночный анализ и многократное повторное использование)

Мы внесем некоторые изменения во входные данные OP, чтобы продемонстрировать варианты обработки с аргументами и без них:

$ cat mycsv.csv
love,hate,--command yes this is bad --other-command
fox,duck,--command yes this is bad --other-command single_string
turtle,rabbit 
sweet,sour,--new-command --newer-command

Простой скрипт для вывода списка входных параметров:

$ cat execute_program_name
#!/bin/bash

echo "### $0 $@"
cnt=0

for arg in "$@"
do
    ((cnt++))
    echo "arg #${cnt} : ${arg}"
done

Один bash подход

$ cat parse_n_run
#!/bin/bash

while IFS=, read -r c1 c2 c3
do
    printf "\n########### %s : %s : %s\n\n" "${c1}" "${c2}" "${c3}"

    args=( "--first" "${c1}" "--second" "${c2}" )       # store first 2 sets of options in array

    while read -r option string
    do
        [[ -z "${option}" ]] && continue                # skip first line (blank)
        args+=( "${option}" )                           # add "--option" to array
        [[ -n "${string}" ]] && args+=( "${string}" )   # if there's an argument then add to the array

    done <<< "${c3//--/$'\n'&}"                         # split c3 into lines by placing a "\n" before each "--"

    typeset -p args                                     # display contents of array
    echo ""
    execute_program_name "${args[@]}"
done < mycsv.csv

Берем на тест-драйв:

$ parse_n_run

########### love : hate : --command yes this is bad --other-command

declare -a args=([0] = "--first" [1] = "love" [2] = "--second" [3] = "hate" [4] = "--command" [5] = "yes this is bad" [6] = "--other-command")

### ./execute_program_name --first love --second hate --command yes this is bad --other-command
arg #1 : --first
arg #2 : love
arg #3 : --second
arg #4 : hate
arg #5 : --command
arg #6 : yes this is bad
arg #7 : --other-command

########### fox : duck : --command yes this is bad --other-command single_string

declare -a args=([0] = "--first" [1] = "fox" [2] = "--second" [3] = "duck" [4] = "--command" [5] = "yes this is bad" [6] = "--other-command" [7] = "single_string")

### ./execute_program_name --first fox --second duck --command yes this is bad --other-command single_string
arg #1 : --first
arg #2 : fox
arg #3 : --second
arg #4 : duck
arg #5 : --command
arg #6 : yes this is bad
arg #7 : --other-command
arg #8 : single_string

########### turtle : rabbit  :

declare -a args=([0] = "--first" [1] = "turtle" [2] = "--second" [3] = "rabbit ")

### ./execute_program_name --first turtle --second rabbit
arg #1 : --first
arg #2 : turtle
arg #3 : --second
arg #4 : rabbit

########### sweet : sour : --new-command --newer-command

declare -a args=([0] = "--first" [1] = "sweet" [2] = "--second" [3] = "sour" [4] = "--new-command" [5] = "--newer-command")

### ./execute_program_name --first sweet --second sour --new-command --newer-command
arg #1 : --first
arg #2 : sweet
arg #3 : --second
arg #4 : sour
arg #5 : --new-command
arg #6 : --newer-command

Если OP необходимо проанализировать mycsv.csv и (повторно) использовать несколько раз, и OP имеет доступ к bash 4.3+, я бы, вероятно, предпочел использовать nameref для управления массивами args_1[], args_2[], ..., args_n[].

Вносим несколько изменений в текущий скрипт:

$ cat parse_n_run
#!/bin/bash

cnt=0

##########
# parse and store

echo "Parsing ..."

while IFS=, read -r c1 c2 c3
do
    printf "\n########### %s : %s : %s\n\n" "${c1}" "${c2}" "${c3}"

    ((cnt++))
    declare -n _args = "args_${cnt}"                          # name ref

    _args=( "--first" "${c1}" "--second" "${c2}" )

    while read -r option string
    do
        [[ -z "${option}" ]] && continue
        _args+=( "${option}" )
        [[ -n "${string}" ]] && _args+=( "${string}" )
    done <<< "${c3//--/$'\n'&}"

    typeset -p "${!_args}"
done < mycsv.csv

### at this point we have 4 arrays: args_1[], args_2[], args_3[] and args_4[]

##########
# make use of arrays

printf "\n###########\n"
echo "Using ..."

for ((i=1; i<=cnt; i++))
do
    declare -n _args = "args_$i"

    printf "\n### %s\n\n" "${!_args}"

    execute_program_name "${_args[@]}"
done

Берем на тест-драйв:

ПРИМЕЧАНИЕ. Обратите внимание, что 4 строки declare -a ссылаются на наши 4 массива args_1[], args_2[], args_3[] и args_4[].

$ parse_n_run
Parsing ...

########### love : hate : --command yes this is bad --other-command

declare -a args_1=([0] = "--first" [1] = "love" [2] = "--second" [3] = "hate" [4] = "--command" [5] = "yes this is bad" [6] = "--other-command")

########### fox : duck : --command yes this is bad --other-command single_string

declare -a args_2=([0] = "--first" [1] = "fox" [2] = "--second" [3] = "duck" [4] = "--command" [5] = "yes this is bad" [6] = "--other-command" [7] = "single_string")

########### turtle : rabbit  :

declare -a args_3=([0] = "--first" [1] = "turtle" [2] = "--second" [3] = "rabbit ")

########### sweet : sour : --new-command --newer-command

declare -a args_4=([0] = "--first" [1] = "sweet" [2] = "--second" [3] = "sour" [4] = "--new-command" [5] = "--newer-command")

###########
Using ...

### args_1

### execute_program_name --first love --second hate --command yes this is bad --other-command
arg #1 : --first
arg #2 : love
arg #3 : --second
arg #4 : hate
arg #5 : --command
arg #6 : yes this is bad
arg #7 : --other-command

### args_2

### execute_program_name --first fox --second duck --command yes this is bad --other-command single_string
arg #1 : --first
arg #2 : fox
arg #3 : --second
arg #4 : duck
arg #5 : --command
arg #6 : yes this is bad
arg #7 : --other-command
arg #8 : single_string

### args_3

### execute_program_name --first turtle --second rabbit
arg #1 : --first
arg #2 : turtle
arg #3 : --second
arg #4 : rabbit

### args_4

### execute_program_name --first sweet --second sour --new-command --newer-command
arg #1 : --first
arg #2 : sweet
arg #3 : --second
arg #4 : sour
arg #5 : --new-command
arg #6 : --newer-command

Я думаю, что наиболее элегантно это решается с помощью awk и Bash с заменой процессов и циклом while.

Данный:

$ cat file.csv
love,hate,--command yes this is bad --other-command
fox,duck,--command yes this is bad --other-command
turtle,rabbit

Вы можете сделать это:

configs=()
while read fst sec cmd; do
    configs+=("execute_program_name --first $fst --second $sec $cmd")
done < <(awk -F, '{print $1, $2, $3}' file.csv)

Результат:

$ printf "%s\n" "${configs[@]}"
execute_program_name --first love --second hate --command yes this is bad --other-command
execute_program_name --first fox --second duck --command yes this is bad --other-command
execute_program_name --first turtle --second rabbit 

Вы можете видеть, что у вас есть массив из трех элементов:

$ declare -p configs
declare -a configs=([0] = "execute_program_name --first love --second hate --command yes this is bad --other-command" [1] = "execute_program_name --first fox --second duck --command yes this is bad --other-command" [2] = "execute_program_name --first turtle --second rabbit ")

Это работает только с полями без пробелов, но именно так написан ваш пример.

Если вы хотите, чтобы это было выполнено, вам вообще не нужен eval. Просто выполните каждую построенную строку. В этом случае я буду использовать echo в качестве заполнителя для execute_program_name, чтобы остальная часть построенной строки отображалась эхом:

while read fst sec cmd; do
    echo "--first ${fst} --second ${sec} ${cmd}"
done < <(awk -F, '{print $1, $2, $3}' file.csv)

Распечатки:

--first love --second hate --command yes this is bad --other-command
--first fox --second duck --command yes this is bad --other-command
--first turtle --second rabbit 

Тот же подход можно использовать с массивом построенных строк — пройдитесь по массиву, а затем просто передайте строку Bash. По умолчанию Bash, если ему передана строка, пытается выполнить эту строку.

Итак, это работает:

for i in "${configs[@]}"; do
    $i                       # look ma! no eval!!!
done

Предположим, что:

1. ваш формат CSV прост (нет полей в кавычках с запятыми, нет новых строк в полях...),
2. ваш bash достаточно новый, чтобы поддерживать сопоставление массивов и регулярных выражений (=~).

Вы можете попробовать:

while IFS=, read -r x y z; do
  read -r x <<< "$x"; read -r y <<< "$y"
  declare -a a=()
  while [[ $z =~ (.*)(--[^[:space:]]*)(.*) ]]; do
    read -r z <<< "${BASH_REMATCH[1]}"; read -r v <<< "${BASH_REMATCH[3]}"
    if [[ -n $v ]]; then a=("$v" "${a[@]}"); fi
    a=("${BASH_REMATCH[2]}" "${a[@]}")
  done
  if [[ -n $z ]]; then a=("$z" "${a[@]}"); fi
  execute_program_name --first "$x" --second "$y" "${a[@]}"
done < mycsv.csv

Примечание. read -r variable <<< "value" — это всего лишь способ обрезать начальные и конечные пробелы.

Идея состоит в том, чтобы создать массив параметров (a) и передать "${a[@]}" вашей команде так, чтобы все параметры и их значения были правильно разделены в отдельные слова.

IFS=, read -r x y z сохраняет значения первого и второго параметра в x и y. Остальная часть строки хранится в z. Затем мы обрабатываем z в цикле while, чтобы извлечь остальные параметры, начиная с последнего (потому что сопоставление регулярных выражений является жадным).