Dividir string por delimitador e obter o N-ésimo elemento

Eu tenho uma string:

one_two_three_four_five

Preciso salvar em um Avalor variável twoe em Bvalor variável fourda string acima

Use cutcom _como delimitador de campo e obtenha os campos desejados:

A="$(cut -d'_' -f2 <<<'one_two_three_four_five')"
B="$(cut -d'_' -f4 <<<'one_two_three_four_five')"

Você também pode usar echoe canalizar em vez da cadeia Here:

A="$(echo 'one_two_three_four_five' | cut -d'_' -f2)"
B="$(echo 'one_two_three_four_five' | cut -d'_' -f4)"

Exemplo:

$ s='one_two_three_four_five'

$ A="$(cut -d'_' -f2 <<<"$s")"
$ echo "$A"
two

$ B="$(cut -d'_' -f4 <<<"$s")"
$ echo "$B"
four

Usando apenas construções sh POSIX, é possível usar construções de substituição de parâmetro para analisar um delimitador por vez. Observe que esse código pressupõe que haja o número necessário de campos, caso contrário, o último campo será repetido.

string='one_two_three_four_five'
remainder="$string"
first="${remainder%%_*}"; remainder="${remainder#*_}"
second="${remainder%%_*}"; remainder="${remainder#*_}"
third="${remainder%%_*}"; remainder="${remainder#*_}"
fourth="${remainder%%_*}"; remainder="${remainder#*_}"

Como alternativa, você pode usar uma substituição de parâmetro sem aspas com a expansão de curinga desativada e IFSconfigurada para o caractere delimitador (isso só funciona se o delimitador for um caractere não-espaço em branco único ou se qualquer sequência de espaço em branco for um delimitador).

string='one_two_three_four_five'
set -f; IFS='_'
set -- $string
second=$2; fourth=$4
set +f; unset IFS

Isso derruba os parâmetros posicionais. Se você fizer isso em uma função, apenas os parâmetros posicionais da função serão afetados.

Ainda outra abordagem é usar o readbuiltin.

IFS=_ read -r first second third fourth trail <<'EOF'
one_two_three_four_five
EOF

Queria ver uma awkresposta, então aqui está uma:

A=$(awk -F_ '{print $2}' <<< 'one_two_three_four_five')
B=$(awk -F_ '{print $4}' <<< 'one_two_three_four_five')

A maneira mais simples (para cascas com <<<) é:

 IFS='_' read -r a second a fourth a <<<"$string"

Usando uma variável temporal em $avez de $_porque um shell reclama.

Em um script completo:

 string='one_two_three_four_five'
 IFS='_' read -r a second a fourth a <<<"$string"
 echo "$second $fourth"

Nenhuma alteração do IFS, nenhum problema com set -f(expansão do nome do caminho) Nenhuma alteração nos parâmetros posicionais ("$ @").

Para uma solução portátil para todos os shells (sim, todos os POSIX incluídos) sem alterar o IFS ou set -f, use o (um pouco mais complexo) equivalente heredoc:

string='one_two_three_four_five'

IFS='_' read -r a second a fourth a <<-_EOF_
$string
_EOF_

echo "$second $fourth"

Entenda que essas soluções (tanto o documento em questão quanto o uso de <<<removerão todas as novas linhas finais.
E isso foi desenvolvido para um conteúdo variável de "uma linha". As
soluções para várias linhas são possíveis, mas precisam de construções mais complexas.

Uma solução muito simples é possível na versão 4.4 do bash

readarray -d _ -t arr <<<"$string"

echo "array ${arr[1]} ${arr[3]}"   # array numbers are zero based.

Não há equivalente para shells POSIX, pois muitos shells POSIX não possuem matrizes.

Para shells com matrizes pode ser tão simples quanto:
(testado trabalhando em attsh, lksh, mksh, ksh e bash)

set -f; IFS=_; arr=($string)

Mas com muito encanamento adicional para manter e redefinir variáveis ​​e opções:

string='one_* *_three_four_five'

case $- in
    *f*) noglobset=true; ;;
    *) noglobset=false;;
esac

oldIFS="$IFS"

set -f; IFS=_; arr=($string)

if $noglobset; then set -f; else set +f; fi

echo "two=${arr[1]} four=${arr[3]}"

No zsh, as matrizes começam em 1 e não dividem a string por padrão.
Portanto, algumas alterações precisam ser feitas para que isso funcione no zsh.

Com zshvocê pode dividir a string (ativada _) em uma matriz:

elements=(${(s:_:)string})

e acesse cada elemento / qualquer via índice de matriz:

print -r ${elements[4]}

Tenha em mente que em zsh(ao contrário ksh/ bash) índices de matriz começam em 1 .

É permitida uma solução python?

# python -c "import sys; print sys.argv[1].split('_')[1]" one_two_three_four_five
two

# python -c "import sys; print sys.argv[1].split('_')[3]" one_two_three_four_five
four

Outro exemplo estranho; mais simples de entender.

A=\`echo one_two_three_four_five | awk -F_ '{print $1}'\`  
B=\`echo one_two_three_four_five | awk -F_ '{print $2}'\`  
C=\`echo one_two_three_four_five | awk -F_ '{print $3}'\`  
... and so on...  

Também pode ser usado com variáveis.
Suponha:
this_str = "one_two_three_four_five"
Então o seguinte funciona:
A = `echo $ {this_str} | awk -F_ '{print $ 1}' '
B = `eco $ {this_str} | awk -F_ '{print $ 2}' '
C = `eco $ {this_str} | awk -F_ '{print $ 3}' '
... e assim por diante ...