How can I get the size of a variable, string, or array in bytes?

Question

For example, if I build an array:

$ array1=($(find /etc -mindepth 1 -maxdepth 1 -type d))
$ echo ${#array[@]}
105
$ for each in ${array1[@]}; do echo $each ; done
/etc/alternatives
/etc/apache2
/etc/apparmor
/etc/apparmor.d
... so on and so forth, you get the idea.

is there a way to use bash to print the size in bytes, not the length? Or do i just have to do the math, manually, based on a count of characters?

I've tried something like this:

$ var2="a"
$ echo $var2 | wc -c
2
$ echo $var2
a

but then this:

$ var2=""
$ echo $var2 | wc -c
1
$ echo $var2

it seems to be that a blank variables existence is 1 byte. but a character count of 1 letter is also 2 characters.

$ echo a | wc -c
2
$ echo a | wc -m
2
$ echo aa | wc -c
3
$ echo aa | wc -m
3

looks like a new line is one byte, each character is one byte. It seems difficult to take an array, count the new lines, count the characters, then do math. Am i over thinking this or is there a utility that gives me an accurate number, already?

Answer 1

array1=($(find /etc -mindepth 1 -maxdepth 1 -type d))

Is wrong as it performs split+glob on the output of find to get the list (and the output of find without -print0 is not post-processable anyway). The correct syntax in bash (4.4+) would be:

readarray -td '' array1 < <(find /etc -mindepth 1 -maxdepth 1 -type d -print0)

Or in zsh:

array1=(/etc/*(ND/))

In echo $var | wc -c

You're counting the number of bytes in the output of echo. That's not the number of bytes in $var for several reasons:

• you forgot to quote $var so it's subject to split+glob
• echo does some transformations. Some implementations expand \x escape sequences, some treat values like -n as options
• finally, echo append a newline character to the output (-n can skip that with some echo implementations).

Here, to use wc to count the bytes, you'd do:

printf %s "$var" | wc -c

In bash, ${#var} expands to the number of characters in the variable¹. For it to be the number of bytes, you can fix the locale to C:

LC_ALL=C
echo "${#var}"

To get the sum of the length in byte of all the elements of an array, you could concatenate them and then get the length of the resulting string:

printf %s "${array[@]}" | wc -c

Or:

IFS=
concat="${array[*]}"
LC_ALL=C
echo "${#concat}"

With zsh, you could do:

() { set -o localoptions +o multibyte
  echo ${#${(j[])array}}
}

Where the j[sep] parameter expansion flag is used to join the elements of the array instead of using "${array[*]}" which uses the global $IFS. Instead of fixing the locale to C we can just disable the multibyte option to get character ≍ byte (which we do here locally in an anonymous function).

Note that to see the difference between byte and character, you need a locale that uses a multibyte encoding as its charmap (such as UTF-8, GB18030, BIG5...) and characters encoded on more than one byte. a is typically encoded on one byte, so you won't see a difference. € is encoded on 3 bytes in UTF-8 and one byte in ISO8859-15 for instance.

An example (here from zsh):

$ a=($'\xe2\x82\xac20' '$25' $'\xa420')
$ locale charmap
UTF-8
$ typeset -p a
typeset -a a=( €20 '$25' $'\M-$20' )
$ printf %s "${a[@]}" | wc -c
11
$ printf %s "${a[@]}" | wc -m
8
$ echo ${#${(j[])a}}
9
$ (){set -o localoptions +o multibyte; echo ${#${(j[])a}}}
11

And if I switch to a locale where the charmap is ISO8859-15:

$ locale charmap
ISO-8859-15
$ a=($'\xe2\x82\xac20' '$25' $'\xa420')
$ typeset -p a
typeset -a a=( â¬20 '$25' €20 )
$ printf %s "${a[@]}" | wc -c
11                           
$ printf %s "${a[@]}" | wc -m
11
$ echo ${#${(j[])a}}
11
$ (){set -o localoptions +o multibyte; echo ${#${(j[])a}}}
11

ISO8859-15 is a single byte character encoding, so character ≍ byte there.

More reading:

• When is double-quoting necessary?
• Why is printf better than echo?
• Why is looping over find's output bad practice?

---

^{¹ similar to what wc -m does except that bash (or zsh) will also count bytes that can't be decoded into a character as one character each.}