How to loop over every character of a filename?

Question

So, I've a simple nested loop where the outer for loops over all the files in a directory and the inner for loops over all characters of these filenames.

#!/bin/bash
if [ $# -lt 1 ]
then
        echo "Please provide an argument"
        exit
fi
for file in ls $1
do
        for ch in $file
        do
                echo $ch
        done
done

The script above doesn't work. The inner loop doesn't loop over all the characters in the filename but instead loops over the entire thing.

UPDATE:

Based on @ilkkachu's answer I was able to come up with the following script and it works as expected. But I was curious can we not use the for...in loop to iterate over strings?

#!/bin/bash
if [ $# -lt 1 ]
then
        echo "Please provide an argument"
        exit
fi
for file in ls $1; do
        for ((i=0; i<${#file}; i++)); do
                printf "%q\n" "${file:i:1}"
        done
done

Answer 1

Since you're using Bash:

#!/bin/bash
word=foobar
for ((i=0; i < ${#word}; i++)); do
   printf "char: %q\n" "${word:i:1}" 
done

${var:p:k} gives k characters of var starting at position p, ${#var} is the length of the contents of var. printf %q prints the output in an unambiguous format, so e.g. a newline shows as $'\n'.

Answer 2

When the strings become larger than a few hundred characters (yes, unlikely for filenames), using a for-loop over the string length and extracting the character at index i becomes very slow.

This answer uses advanced bash techniques:

while IFS= read -r -d "" -n 1 char; do
    # do something with char, like adding it to an array
    chars+=( "$char" )
done < <(printf '%s' "$string")
inspect the array
declare -p chars

That uses a Process Substitution to redirect the string into the while-read loop. I'm using printf to avoid adding a newline onto the end of the string. The main advantage of using a process substitution instead of printf ... | while read ... is the loop executes in the current shell, not a subshell.

I once got curious about the magnitude of the slowness and benchmarked it.

Answer 3

For completeness, even though the question is tagged bash, an alternative that uses POSIX shell features only:

#!/bin/sh
for fname
do
  while [ "${#fname}" -ge 1 ]
  do
    rest=${fname#?} char=${fname%"$rest"} fname=$rest
    printf '%s\n' "$char"       # Do something with the current character
  done
done

What the inner loop does:

• set rest to the value of fname minus its first character;

• assign the single character obtained by removing rest from the end of fname to char;

• set fname to the value of rest and repeat until all characters are processed.

Note the quotes in ${fname%"$rest"}, needed to prevent $rest's expansion from being used as a pattern.

As an aside, for file in `ls $1` should be avoided. The most obvious reason is that it breaks if a file name contains any character that happens to be in IFS. More on this at Bash Pitfall n. 1, including what you should do instead.

Answer 4

#!/bin/sh

for name do
    printf 'name="%s"\n' "$name"

    printf '%s\n' "$name" | fold -w 1 |
    while IFS= read -r character; do
        printf 'character="%s"\n' "$character"
    done
done

The outer loop here just loops over the arguments given to the script. Each argument is printed as is, and then passed through fold -w 1, which creates a stream of single characters separated by newline characters. This stream is then read by the inner loop, which prints each character in turn.

Testing:

$ sh script *
name="script"
character="s"
character="c"
character="r"
character="i"
character="p"
character="t"

$ sh script /*bin*
name="/bin"
character="/"
character="b"
character="i"
character="n"
name="/sbin"
character="/"
character="s"
character="b"
character="i"
character="n"

By changing the printf that prints the full pathnames into fold to basename "$name", you get only the filename portion of the pathnames in the inner loop:

$ sh script /sbin/l*
name="/sbin/ldattach"
character="l"
character="d"
character="a"
character="t"
character="t"
character="a"
character="c"
character="h"
name="/sbin/ldconfig"
character="l"
character="d"
character="c"
character="o"
character="n"
character="f"
character="i"
character="g"

Answer 5

Use the bash string slicing operator:

s="string"
for c in $(seq 0 $((${#s}-1)));  do echo "${s:c:1}"; done
s
t
r
i
n
g

Applied to your script can be:

#!/bin/bash
for f in *; do
    echo "Char in $f:"
    for i in $(seq 0 $((${#f}-1))); do
        echo "${f:i:1}"
    done
done

Answer 6

1. Loop over each filename in the current directory “*" (can be easily customised for specific needs “~/*.jpg” etc…) and populate string variable “ff” with each character composing the current filename in the loop (“$ff" can also be understood as an array of single characters with ${ff:10:1} being the single 10th character in the ff “string array”). Nota: if we wanted 2 characters rather from the 10th index we would write ${ff:10:2}
2. echo “➜ ${ff}” simply to check current filename in the loop
3. Loop over the “string array ${ff}” to echo each of its index values, from first (bash variable starts at index 0) to last (#ff gives total size of the array) - this is done by incrementing c by 1 (c++), from initial value of 0, and stop when it reaches #ff value
4. echo a blank space before shifting to the next filename

for ff in *; do 
  echo -e "--> $ff" ; 
  for ((c=0;c<${#ff};c++)); do echo -e "${ff:$c:1}"; done ; 
  echo -e ""; 
done

Steps 2) and 4) (“echo” statements) are obviously for cosmetic purposes only and may be skipped.