Verifique se a matriz está vazia no Bash

Eu tenho uma matriz que é preenchida com diferentes mensagens de erro enquanto meu script é executado.

Eu preciso de uma maneira de verificar se está vazio ou não no final do script e executar uma ação específica, se estiver.

Eu já tentei tratá-lo como um VAR normal e usar -z para verificá-lo, mas isso não parece funcionar. Existe uma maneira de verificar se uma matriz está vazia ou não no Bash?

Supondo que sua matriz seja $errors, basta verificar se a contagem de elementos é zero.

if [ ${#errors[@]} -eq 0 ]; then
    echo "No errors, hooray"
else
    echo "Oops, something went wrong..."
fi

Eu geralmente uso expansão aritmética neste caso:

if (( ${#a[@]} )); then
    echo not empty
fi

Você também pode considerar a matriz como uma variável simples. Dessa forma, apenas usando

if [ -z "$array" ]; then
    echo "Array empty"
else
    echo "Array non empty"
fi

ou usando o outro lado

if [ -n "$array" ]; then
    echo "Array non empty"
else
    echo "Array empty"
fi

O problema com essa solução é que se uma matriz é declarada como este: array=('' foo). Essas verificações reportarão a matriz como vazia, enquanto claramente não é. (obrigado @musiphil!)

Usar [ -z "$array[@]" ]não é claramente uma solução também. Não especificar colchetes tenta interpretar $arraycomo uma sequência ( [@]nesse caso, é uma sequência literal simples) e, portanto, é sempre relatada como falsa: "a sequência literal está [@]vazia?" Claramente não.

Eu verifiquei com bash-4.4.0:

#!/usr/bin/env bash
set -eu
check() {
    if [[ ${array[@]} ]]; then
        echo not empty
    else
        echo empty
    fi
}
check   # empty
array=(a b c d)
check   # not empty
array=()
check   # empty

e bash-4.1.5:

#!/usr/bin/env bash
set -eu
check() {
    if [[ ${array[@]:+${array[@]}} ]]; then
        echo non-empty
    else
        echo empty
    fi
}
check   # empty
array=(a b c d)
check   # not empty
array=()
check   # empty

No último caso, você precisa da seguinte construção:

${array[@]:+${array[@]}}

para que não falhe na matriz vazia ou não configurada. Isso se você fizer set -eucomo eu costumo fazer. Isso fornece uma verificação de erro mais rigorosa. Dos documentos :

-e

Saia imediatamente se um pipeline (consulte Pipelines), que pode consistir em um único comando simples (consulte Comandos Simples), uma lista (consulte Listas) ou um comando composto (consulte Comandos Compostos) retornar um status diferente de zero. O shell não sai se o comando que falha faz parte da lista de comandos imediatamente após uma palavra-chave while ou while, parte do teste em uma instrução if, parte de qualquer comando executado em um && ou || list exceto o comando após o final && ou ||, qualquer comando em um pipeline, exceto o último, ou se o status de retorno do comando estiver sendo invertido com! Se um comando composto que não seja um subshell retornar um status diferente de zero porque um comando falhou enquanto -e estava sendo ignorado, o shell não sai. Uma interceptação no ERR, se definida, é executada antes da saída do shell.

Essa opção se aplica ao ambiente do shell e a cada ambiente de subshell separadamente (consulte Ambiente de execução de comando) e pode causar a saída de subshells antes de executar todos os comandos no subshell.

Se um comando composto ou função shell for executado em um contexto em que -e está sendo ignorado, nenhum dos comandos executados no comando ou corpo da função composto será afetado pela configuração -e, mesmo se -e estiver definido e um comando retornar um status de falha. Se um comando composto ou função de shell definir -e durante a execução em um contexto em que -e é ignorado, essa configuração não terá nenhum efeito até que o comando composto ou o comando que contém a chamada de função seja concluído.

-você

Trate variáveis ​​e parâmetros não configurados que não sejam os parâmetros especiais '@' ou '*' como um erro ao executar a expansão de parâmetros. Uma mensagem de erro será gravada no erro padrão e um shell não interativo será encerrado.

Se você não precisar disso, fique à vontade para omitir :+${array[@]}parte.

Observe também que é essencial usar o [[operador aqui, para [obter:

$ cat 1.sh
#!/usr/bin/env bash
set -eu
array=(a b c d)
if [ "${array[@]}" ]; then
    echo non-empty
else
    echo empty
fi

$ ./1.sh
_/1.sh: line 4: [: too many arguments
empty

Se você deseja detectar uma matriz com elementos vazios , comoarr=("" "") vazio, igual aarr=()

Você pode colar todos os elementos juntos e verificar se o resultado tem tamanho zero. (Construir uma cópia achatada do conteúdo da matriz não é ideal para desempenho, se a matriz puder ser muito grande. Mas espero que você não esteja usando o bash para programas como esse ...)

Mas se "${arr[*]}"expande com elementos separados pelo primeiro caractere de IFS. Portanto, você precisa salvar / restaurar o IFS e fazer IFS=''isso para funcionar, ou verifique se o comprimento da string == # dos elementos da matriz - 1. (Uma matriz de nelementos possui n-1separadores). Para lidar com isso de um por um, é mais fácil diminuir a concatenação em 1

arr=("" "")

## Assuming default non-empty IFS
## TODO: also check for ${#arr[@]} -eq 0
concat="${arr[*]} "      # n-1 separators + 1 space + array elements
[[ "${#concat}" -ne "${#arr[@]}" ]]  && echo not empty array || echo empty array

caso de teste com set -x

### a non-empty element
$ arr=("" "x")
  + arr=("" "x")
$ concat="${arr[*]} ";  [[ "${#concat}" -ne "${#arr[@]}" ]] && echo not empty array || echo empty array
  + concat=' x '
  + [[ 3 -ne 2 ]]
  + echo not empty array
not empty array

### 2 empty elements
$ arr=("" "")
  + arr=("" "")
$ concat="${arr[*]} ";  [[ "${#concat}" -ne "${#arr[@]}" ]] && echo not empty array || echo empty array
  + concat='  '
  + [[ 2 -ne 2 ]]
  + echo empty array
empty array

Infelizmente, este falhar por arr=(): [[ 1 -ne 0 ]]. Portanto, você precisa verificar as matrizes realmente vazias primeiro separadamente.

Ou comIFS='' . Provavelmente, você deseja salvar / restaurar o IFS em vez de usar um subshell, porque não é possível obter um resultado de um subshell facilmente.

# inside a () subshell so we don't modify our own IFS
(IFS='' ; [[ -n "${arr[*]}" ]] && echo not empty array || echo empty array)

exemplo:

$ arr=("" "")
$ (IFS='' ; [[ -n "${arr[*]}" ]] && echo not empty array || echo empty array)
   + IFS=
   + [[ -n '' ]]
   + echo empty array
empty array

se trabalhar com arr=()- ainda é apenas uma string vazia.

No meu caso, a segunda resposta não foi suficiente porque poderia haver espaços em branco. Eu vim junto com:

if [ "$(echo -ne ${opts} | wc -m)" -eq 0 ]; then
  echo "No options"
else
  echo "Options found"
fi

Eu prefiro usar colchetes duplos:

if [[ !${array[@]} ]]
then
    echo "Array is empty"
else
    echo "Array is not empty"
fi

Parênteses duplos: https://stackoverflow.com/questions/669452/is-preferable-over-in-bash