Usando chaves para processar variáveis ​​separadas por dois pontos

O estilo ksh (e agora especificado pelo POSIX para sh) ${var#pattern}e ${var%pattern}(e variantes gananciosas com ##e %%) removem apenas o texto do início e do fim, respectivamente, do conteúdo da variável.

Para 200sair 100:200:300:400desses operadores, você precisaria aplicar ambos ${VAR#*:}para remover 100:do início e depois ${VAR%%:*}para remover :300:400do final.

Isso seria com ${${VAR#*:}%%:*}, mas embora isso funcione no zsh, não funciona no bash ou ksh, que não permitem encadear operadores de expansão de parâmetros.

Em zsh, você prefere usar $VAR[(ws[:])2]para obter a 2^segunda ordem : sseparada de ¹, ou usar para primeiro dividir a variável em uma matriz e depois obter o segundo elemento.w$var${${(s[:])VAR}[2]}

No ksh93, você pode fazer ${VAR/*:@(*):*:*/\1}, mas embora o bash (como o zsh²) tenha copiado o operador do ksh93 ${param/pattern/replacement}, ele não copiou a parte de captura e referência.

No bash (que ainda é amplamente utilizado apesar de todas as suas limitações, já que é o shell GNU, pré-instalado em praticamente todos os sistemas GNU/Linux, bem como em alguns sistemas não GNU), você pode fazer isso em duas etapas:

tmp=${VAR#*:}; printf '%s\n' "${tmp%%:*}"

O único operador de divisão interno do bash (a menos que você queira considerar o bash 4.4+, readarray -dque é mais para ler registros de algum fluxo de entrada em uma matriz; e o tipo de divisão que ele faz separando argumentos em sua sintaxe), que é a divisão IFS no estilo Bourne (estendida pelo Korn), que é executada em expansões sem aspas (você a usou por engano echo ${VAR%%:*}onde esqueceu as aspas) e por read.

readfunciona em uma linha, portanto, só pode ser usado para variáveis ​​que não contêm caracteres de quebra de linha. Usar split+glob (glob sendo o outro efeito colateral de deixar uma expansão sem aspas) é trabalhoso, pois precisamos desabilitar a parte glob e alterar um $IFSparâmetro global.

No bash 4.4+, você pode fazer assim:

nth() {
  local - # local - is to make the changes to option settings local to
          # the function like in the Almquist shell. The idea is that it
          # makes the $- special parameter local to the function. That's
          # equivalent to the set -o localoptions of zsh. In bash, that
          # only works for the set of option managed by set, not the ones
          # managed by shopt.
  local string="$1" n="$2" IFS="${3- }"
  set -o noglob # disable the glob part
  set -- $string''   # apply split+glob with glob disabled
  printf '%s\n' "${!n}" # dereference the parameter whose name is stored in $n
}
nth "$VAR" 2 :

Sem o '', 100::300:seria dividido em "100", "", "300" apenas, então, por exemplo, $#expandiria para 3, mesmo que a variável tivesse :um campo separado por 4. Atenção, porém, pois isso significa que uma variável vazia é dividida em 1 elemento vazio em vez de nenhum.

Para read(ou readarray), uma solução alternativa semelhante seria adicionar um delimitador extra ao final da entrada. Como as variáveis ​​bash (ao contrário das do zsh) não podem conter caracteres NUL, com readvalores de variáveis ​​arbitrários, você poderia fazer:

words=()
IFS=: LC_ALL=C read -rd '' -a words < <(printf '%s:\0' "$VAR") &&
  printf '%s\n' "${word[2 - 1]}"

( - 1porque readcomeça a preencher o array no índice 0, não 1; LC_ALL=Ccontorna alguns bugs para texto não codificado na codificação do usuário nas versões bash 5.0 a 5.2)

Com readarray(bash 4.4):

records=()
readarray -O1 -td : records < <(printf %s: "$VAR") &&
  printf '%s\n' "${records[2]}"

Novamente, :adicionado no final para evitar que um elemento vazio final seja descartado (mas novamente significa que uma entrada vazia resulta em um elemento vazio).

^{¹ Observe que ele se divide ::a:b::c:::em a, be csomente como a divisão IFS fazia no shell Bourne (mas não em shells modernos do tipo Bourne, exceto quando espaço, tabulação ou nova linha são usados ​​como separadores).}

^{² O zsh suporta isso, mas com uma sintaxe diferente e isso exige que a extendedglobopção seja habilitada:${VAR/(#b)*:(*):*:*/$match[1]}}

Não tento usar a sintaxe de substituição no valor da string separada por dois pontos. Em vez disso, uso a divisão para colocar as partes entre dois pontos em um array e, em seguida, realizar a substituição de variáveis ​​(e até mesmo o fatiamento do array) para retornar os elementos desejados do array:

#!/usr/bin/env bash
VAR='100:200:300:400'

IFS=: read -ra VAR2 <<<"$VAR"

echo "${VAR}"
echo "${VAR2[1]}"
echo "${VAR2[@]}"
echo "${VAR2[@]:1:2}"

produz a saída:

100:200:300:400
200
100 200 300 400
200 300

Isso pode não ter os efeitos precisos que você deseja se caracteres de espaço em branco também aparecerem entre dois pontos no valor original (você deve testar essas coisas cuidadosamente), mas seu exemplo não tinha nenhum.

Você pode usar IFS e definir para separar e acessar todos os quatro:

$ VAR=100:200:300:400
$ IFS=:
$ set -- $VAR
$ echo $1
100
$ echo $2
200
$ echo $3
300
$ echo $4
400

Por exemplo, uma maneira de obter apenas o que está entre o segundo e o terceiro dois pontos, especificamente no caso de haver mais de três dois pontos?

Isso exigiria muita expansão manual de parâmetros. Você poderia fazer um loop usando o delimitador, algo como

#!/bin/sh

counter=0
var='100:200:300:400'

while [ -n "$var" ]; do   ##: Test if $var is not empty.
  first="${var%%:*}"      ##: Extract the first string sep by a `:'
  rest=${var#*"$first"}   ##: Remove the first string sep by a `:'
  var="${rest#:}"         ##: Remove the first occurence of `:'
  counter=$((counter+1))  ##: Increment the counter by one

   case "$counter" in
     (2|3) printf '%s\n' "$first";;   ##: Counter reached the 2nd and 3rd field, print it
     (4) break ;;                     ##: Break the loop from the 4th field (if there are more)
   esac                               ##: Repeat the while loop until the condition is met.
 done                                 ##: which is until $var is empty.

Saída:

200
300

Com uma versão do Bash que tenha loadable builtinchamado dsvisso, é possível analisar uma string como o que cutestá sendo feito. Você pode tentar algo como:

#!/usr/bin/env bash

enable dsv || exit

var='1 00:20 0:300 : 4 0 0 '

dsv -a array -d':' "$var"
 
declare -p array

Saída:

declare -a array=([0]="1 00" [1]="20 0" [2]="300 " [3]=" 4 0 0 ")

Se alguns campos estiverem vazios, como abaixo:

var='1 00::200:300 : 4 0 0 '

A -gopção pode ser usada para ignorá-lo/removê-lo.

dsv -a array -gd':' "$var"

Em alguns casos, a entrada pode ter campos entre aspas duplas, como abaixo.

A análise entende e ignora strings entre aspas duplas.

var='1 00:"20:0":300 : 4 0 0 '

Saída:

declare -a array=([0]="1 00" [1]="20:0" [2]="300 " [3]=" 4 0 0 ")

• O builtins carregável é um pacote separado, mas, até onde basheu sei, não está incluído.

De acordo comhelp dsv

dsv: dsv [-a ARRAYNAME] [-d DELIMS] [-Sgp] string
    Read delimiter-separated fields from STRING.
    
    Parse STRING, a line of delimiter-separated values, into individual
    fields, and store them into the indexed array ARRAYNAME starting at
    index 0. The parsing understands and skips over double-quoted strings. 
    If ARRAYNAME is not supplied, "DSV" is the default array name.
    If the delimiter is a comma, the default, this parses comma-
    separated values as specified in RFC 4180.
    
    The -d option specifies the delimiter. The delimiter is the first
    character of the DELIMS argument. Specifying a DELIMS argument that
    contains more than one character is not supported and will produce
    unexpected results. The -S option enables shell-like quoting: double-
    quoted strings can contain backslashes preceding special characters,
    and the backslash will be removed; and single-quoted strings are
    processed as the shell would process them. The -g option enables a
    greedy split: sequences of the delimiter are skipped at the beginning
    and end of STRING, and consecutive instances of the delimiter in STRING
    do not generate empty fields. If the -p option is supplied, dsv leaves
    quote characters as part of the generated field; otherwise they are
    removed.
    
    The return value is 0 unless an invalid option is supplied or the ARRAYNAME
    argument is invalid or readonly.