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.}