Y a-t-il une commande bash qui peut indiquer la taille d'une variable shell

Cela vous indique le nombre de caractères de la valeur d'une variable scalaire nommé "var":

echo ${#var}

Cela vous indique le nombre d'éléments dans un tableau appelé "tableau":

echo ${#array[@]}

Cela vous indique le nombre de caractères dans un élément d'un tableau:

echo ${#array[3]}

Si vous essayez d'obtenir la taille d'un tableau et vous laissez de côté le [@] index, vous obtenez la longueur de l'élément 0:

$ array=(1 22 333 4444)
$ echo ${#array}
1
$ echo ${#array[@]}
4
$ echo ${#array[2]}
3

Si vous souhaitez que la durée totale de tous les éléments d'un tableau, vous pouvez parcourir le tableau et les ajouter, vous pouvez utiliser IFS et certaines des étapes semblables à celles ci-dessous, ou vous pouvez:

$ tmp="${array[*]}"
$ echo $(( ${#tmp} - ${#array[@]} + 1 ))
10

Attention en utilisant le nombre d'éléments dans un tableau, l'indice du dernier élément, car Bash prend en charge matrices creuses:

$ array=(1 22 333 4444 55555)
$ echo ${#array[@]}
5
$ array[9]=999999999
$ echo ${#array[@]}
6
$ echo ${array[${#array[@]} - 1]}    # same as echo ${array[6 - 1]}

$ # only a newline is echoed since element 5 is empty (only if "nounset" option* is not set (default in most cases))
$ # when "nounset" option is set (possibly using command "set -u") then bash will print such error:
$ # bash: array[${#array[@]} - 1]: unbound variable
$ unset "array[1]"    # always quote array elements when you unset them
$ echo ${#array[@]}
5
$ echo ${array[${#array[@]} - 1]}    # same as echo ${array[5 - 1]}
55555

Qui n'est évidemment pas le dernier élément. Pour obtenir le dernier élément:

$ echo ${array[@]: -1}    # note the space before the minus sign
999999999

Note que, dans la prochaine Bash 4.2, vous pouvez le faire echo ${array[-1]} pour obtenir le dernier élément. Dans les versions antérieures à la version 4.2, vous obtenez un mauvais indice d'erreur pour les indices.

Pour obtenir l'index du dernier élément:

$ idx=(${!array[@]})
$ echo ${idx[@]: -1}
9

Alors vous pouvez faire:

$ last=${idx[@]: -1}
$ echo ${array[last]}
999999999

Pour parcourir un tableau fragmenté:

for idx in ${!array[@]}
do
    something_with ${array[idx]}
done

---

* Je vous recommande d'éviter nounset

Pour une variable scalaire, ${#VAR} vous donne la longueur en caractères. Dans un unibyte locale, c'est la longueur en octets. La taille en octets est la longueur du nom en octets, plus la longueur de la valeur en octets, plus une constante de frais généraux.

LC_ALL=C
name=VAR
size=$(($#name + $#VAR)) # plus a small overhead

Si la variable est exportée, la taille est à peu près le double.

LC_ALL=C
name=VAR
size=$((($#name + $#VAR) * 2)) # plus a small overhead

Pour une variable de tableau, vous devez additionner les longueurs (de nouveau, en octets) des éléments, et d'ajouter un surplus constant par élément, à une constante près de surcharge pour le tableau.

LC_ALL=C
name=VAR
size=$(($#name)) # plus a small overhead
for key in "${!VAR[@]}"; do
  size=$((size + ${#key} + ${#VAR[$key]})) # plus a small overhead
done

Voici un peu testé la fonction qui calcule la taille occupée par une variable. Les tableaux et les exportations sont pris en compte, mais pas les variables en lecture seule comme $RANDOM. Les tailles ont été observés sur le bash 4.2, les différentes versions peuvent avoir différents frais généraux. Vous devrez peut-être ajuster les constantes en fonction de votre système de types et malloc mise en œuvre.

_sizeof_pointer=4
_sizeof_int=4
_malloc_granularity=16
_malloc_overhead=16
## Usage: compute_size VAR
## Print the amount of memory (in bytes) used by VAR.
## The extra bytes used by the memory allocator are not taken into account.
add_size () {
  local IFS="+" this extra
  set $(($1 + _malloc_overhead))
  _size=$((_size + $1))
  set $(($1 % _malloc_granularity))
  [[ $1 -eq 0 ]] || _size=$((_size + _malloc_granularity - $1))
}
compute_size () {
  local LC_ALL=C _size=0 _key
  if eval "[ -z ${$1+1} ]"; then echo 0; return; fi
  add_size $((_sizeof_pointer*5 + _sizeof_int*2)) # constant overhead
  add_size ${#1} # the name
  case $(declare -p $1) in
    declare\ -x*)
      eval "add_size ${#$1}" # the value
      eval "add_size $((${#1} + ${#$1} + 2))" # the export string
      ;;
    declare\ -a*)
      eval 'for _key in "${!'$1'[@]}"; do
              add_size $_key
              add_size ${#'$1'[$_key]}
              add_size $((_sizeof_pointer*4))
            done'
      add_size $((_sizeof_pointer*2 + _sizeof_int*2))
      add_size $((_sizeof_pointer*4))
      ;;
    *)
      eval "add_size ${#$1}" # the value
      ;;
  esac
  echo $_size
}