bash - divide substrings entre aspas delimitadas por espaços em uma matriz

Se a entrada for tão simples quanto mostrada na pergunta e você realmente quiser evitar a geração de um subshell em cada invocação, como você declarou:

... no entanto, isso ... invocará um novo subprocesso em cada chamada. Eu gostaria de ver uma solução melhor do que isso

então você poderia usar um loop isolando cada '...'substring e armazenando-a em uma matriz:

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

string=" 'f o o' 'f oo' 'fo o' "
re="('[^']*')(.*)"
array=()
while [[ "$string" =~ $re ]]; do
    array+=( "${BASH_REMATCH[1]}" )
    string="${BASH_REMATCH[2]}"
done

declare -p array

$ ./tst.sh
declare -a array=([0]="'f o o'" [1]="'f oo'" [2]="'fo o'")

Se você não se importar com um subshell, você pode usar o GNU grep para -oapenas imprimir as substrings entre aspas simples e então lê-las em um array:

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

string=" 'f o o' 'f oo' 'fo o' "

readarray -t array < <(grep -o "'[^']*'" <<<"$string")

declare -p array

$ ./tst.sh
declare -a array=([0]="'f o o'" [1]="'f oo'" [2]="'fo o'")

ou se você não tiver um grep que suporte isso, -ovocê pode usar qualquer sed para remover espaços em branco iniciais/finais e alterar tudo ' 'para '<newline>'então ler o resultado em uma matriz:

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

string=" 'f o o' 'f oo' 'fo o' "

readarray -t array < <(sed -E "s/^ +| +$//g; s/' +'/'\n'/g" <<<"$string")

declare -p array

$ ./tst.sh
declare -a array=([0]="'f o o'" [1]="'f oo'" [2]="'fo o'")

Se você quiser se livrar do 's do resultado, basta alterar o sedcomando para sed -E "s/^ +'|' +$//g; s/' +'/\n/g".

Se o objetivo é fazer a tokenização da sintaxe da linguagem shell, mas sem remover aspas e sem executar nenhum código, então você pode alternar para zsho que tem operadores apenas para isso: o z sinalizador de expansão de parâmetro e sua Z[tuning]variante para personalizar o que acontece com relação a novas linhas e comentários.

Com um exemplo mais complexo:

string="
  'f o o' 'f oo' 'fo o'
  \"bar
baz\" ''
  $'a\'\nb'
  'foo'\''bar'
  # comment
  >>file
  \$(echo foo bar)
"

Com apenas z:

$ array=(${(z)string})
$ typeset -p1 array
typeset -a array=(
  ';'
  \''f o o'\'
  \''f oo'\'
  \''fo o'\'
  ';'
  $'"bar\nbaz"'
  \'\'
  ';'
  '$'\''a\'\''\nb'\'
  ';'
  \''foo'\''\'\'\''bar'\'
  ';'
  '#'
  comment
  ';'
  '>>'
  file
  ';'
  '$(echo foo bar)'
  ';'
)

A nova linha é tratada como delimitador de comando, assim como ;(e tokenizada como ;) e #não é tratada como introdutor de comentário.

$ array=(${(Z[n])string})
$ typeset -p1 array
typeset -a array=(
  \''f o o'\'
  \''f oo'\'
  \''fo o'\'
  $'"bar\nbaz"'
  \'\'
  '$'\''a\'\''\nb'\'
  \''foo'\''\'\'\''bar'\'
  '#'
  comment
  '>>'
  file
  '$(echo foo bar)'
)

Com Z[n], a nova linha sem aspas é tratada apenas como outro delimitador de token, como espaço ou tabulação.

$ array=(${(Z[nc])string})
$ typeset -p1 array
typeset -a array=(
  \''f o o'\'
  \''f oo'\'
  \''fo o'\'
  $'"bar\nbaz"'
  \'\'
  '$'\''a\'\''\nb'\'
  \''foo'\''\'\'\''bar'\'
  '# comment'
  '>>'
  file
  '$(echo foo bar)'
)

Com c, #introduz um comentário, e os comentários compõem o token retornado.

$ array=(${(Z[nC])string})
$ typeset -p1 array
typeset -a array=(
  \''f o o'\'
  \''f oo'\'
  \''fo o'\'
  $'"bar\nbaz"'
  \'\'
  '$'\''a\'\''\nb'\'
  \''foo'\''\'\'\''bar'\'
  '>>'
  file
  '$(echo foo bar)'
)

Com C, o mesmo, exceto que os comentários são removidos.

Se você tiver que usar bash, já que o bash não pode armazenar NULs em suas variáveis ​​de qualquer maneira, você pode fazer o bash obter o zsh para fazer a tokenização e imprimir o resultado delimitado por NUL, que o bash pode ler de volta em uma matriz readarray -td ''(assumindo o bash 4.4 ou mais recente):

bash-5.2$ readarray -td '' array < <(zsh -c 'print -rNC1 -- ${(Z[Cn])1}' zsh "$string")
bash-5.2$ typeset -p array
declare -a array=([0]="'f o o'" [1]="'f oo'" [2]="'fo o'")

Ou se em um sistema com a implementação GNU grepcom suporte para PCRE/PCRE2 habilitado, você poderia fazer um processamento de aspas simples, aspas duplas e barras invertidas semelhante ao feito por shells do tipo Bourne, como o bash, com:

readarray -td '' array < <(
  printf '%s\0' "$string" |
    grep -zPo "(?s:'.*?'|\"(?:\\\\.|[^\\\\\"])*?\"|\\\\.|\S)+"
)

No exemplo "mais complexo" acima, isso dá:

bash-5.2$ typeset -p array
declare -a array=(
  [0]="'f o o'"
  [1]="'f oo'"
  [2]="'fo o'"
  [3]=$'"bar\nbaz"'
  [4]="''"
  [5]="\$'a\\'\\nb'"
  [6]="'foo'\\''bar'"
  [7]="#"
  [8]="comment"
  [9]=">>file"
  [10]="\$(echo"
  [11]="foo"
  [12]="bar)"
)

Note que ele não faz tokenização de sintaxe de shell completa, apenas processa aspas. Veja como ele divide $(echo foo bar), ele também dividiria $'foo\' bar'or "$(echo '"' foo)".

Para melhor portabilidade, você pode usar o perl (o Pin grep -P) que, ao contrário do GNU, grepdeve ser instalado na maioria dos sistemas:

readarray -td '' array < <(
  printf '%s\0' "$string" |
    perl -C -0lne "print for /(?s:'.*?'|\"(?:\\\\.|[^\\\\\"])*?\"|\\\\.|\S)+/g"
)

O mais próximo que posso chegar é isso

# Example data line
s=" 'f o o' 'f oo' 'fo o' "

# Read parts into temporary array t
readarray -td "'" t <<<"$s"

# Extract relevant parts of t into array a, re-adding the quote marks as we go
a=()
for ((n=1; n<"${#t[@]}"; n+=2)); do a+=("'${t[$n]}'"); done

# Print the result
for x in "${a[@]}"; do echo ">> $x <<"; done

Saída do seu exemplo simples

>> 'f o o' <<
>> 'f oo' <<
>> 'fo o' <<

Especificamente para seu exemplo, observe que "${a[0]}"contém sete caracteres 'f o o'(incluindo as aspas)

Saída do seu exemplo estendido

>> 'magic1' <<
>> 'some text' <<
>> 'another simple text' <<
>> 'some t£xt' <<

>> 'magic2' <<
>> 'another line with simple text' <<
>> 'foo bar' <<
>> 'yeah another substring' <<

>> 'magic3' <<
>> 'so@m{e$%& te+=*&' <<
>> 'another substring' <<
>> 'here is the substring' <<

>> 'magic4' <<
>> 'why not another line !' <<
>> 'yeah I like that' <<
>> 'the substring yeah !!!' <<

Você pode converter suas aspas simples em novas linhas para construir uma matriz:

mapfile -t array <<< "${string//\'/$'\n'}"

Isso criará alguns elementos vazios que podem ou não ser um problema para você:

$ declare -p array
declare -a array=([0]=" " [1]="f o o" [2]=" " [3]="f oo" [4]=" " [5]="fo o" [6]=" ")

para que você possa removê-los:

for i in ${!array[@]}; do [[  ${array["i"]} == " " || -z "${array["i"]}" ]] && unset 'array[i]'; done

Agora você ainda não tem suas aspas simples, que, como argumentei nos comentários, você provavelmente não precisa, por exemplo:

$ set -x
+ set -x
$ foo='f o o'
+ foo='f o o'
$ bar="'b a r'"
+ bar=''\''b a r'\'''
$ baz=baz
+ baz=baz
$ echo "$foo" "$bar" "$baz" 'bing'
+ echo 'f o o' ''\''b a r'\''' baz bing
f o o 'b a r' baz bing

Observe como aspas simples armazenadas literalmente em uma variável não são as mesmas que aspas simples interpretadas pelo shell.

Entretanto, se você realmente quiser que eles voltem, você pode fazer isso (em vez do loop acima que só remove os elementos " "):

for i in ${!array[@]}; do 
  if [[  ${array["i"]} == " " || -z "${array["i"]}" ]]; then
    unset 'array[i]'
  else
    array["$i"]="'${array["$i"]}'"
  fi
done