bash + como verificar se as pastas em um caminho específico terminam com número/s

Com zsh:

files=( /var/kafka/*[^0-9](ND) )
if (( $#files )); then
  print -rlu2 -- "There are files whose name doesn't end in an ASCII digit:" ' - '$^files
  exit 1
fi

O mesmo com bash:

shopt -s nullglob dotglob
shopt -u failglob
files=( /var/kafka/*[^0123456789] )
if (( ${#files[@]} )); then
  echo>&2 "There are files whose name doesn't end in an ASCII digit:"
  printf>&2 ' - %s\n' "${files[@]}"
  exit 1
fi

Para mostrar apenas o nome base / tail desses arquivos ( fooem vez de /var/kafka/foo), substitua $^filespor $^files:te "${files[@]}"por "${files[@]##*/}".

Observe que estritamente falando *[^0-9](ou *[^0123456789]em bash) corresponde a nomes de arquivos que terminam com um caractere diferente de um dígito, para nomes de arquivos que não terminam com um dígito, isso está ^*[0-9]em zsh (para o qual você precisa set -o extendedglobou !(*[0-9])em bash (para o qual você need shopt -s extglob), mas como o nome de um arquivo não pode estar vazio, isso deve ser equivalente.

Se você não precisar listar esses arquivos na mensagem de erro, em zsh, isso pode ser abreviado para:

if () (( $# )) /var/kafka/*[^0-9](NDY1); then
  print -ru2 "There are files whose name doesn't end in an ASCII digit"
  exit 1
fi

Where Y1para de olhar para a primeira correspondência e a lista de correspondências é passada para uma função anônima que retorna verdadeiro se for passado pelo menos um argumento ( $#não é zero).

Caso precise considerar apenas os arquivos do tipo directory , ainda em zsh, adicione /ao qualificador glob:

dirs=( /var/kafka/*[^0-9](ND/) )
if (( $#dirs )); then
  print -rlu2 -- "There are directories whose name doesn't end in an ASCII digit:" ' - '$^dirs
  exit 1
fi

bash não possui qualificadores glob, mas você pode recorrer a findpara relatar os arquivos do tipo diretório cujo nome não termina em dígitos:

Com bash4.4 ou mais recente e findcompatível com -print0:

readarray -td '' dirs < <(
  cd /var/kafka &&
    LC_ALL=C find . ! -name . -prune -type d ! -name '*[0-9]' -print0
)
if (( ${#dirs[@]} )); then
  echo>&2 "There are dirs whose name doesn't end in an ASCII digit:"
  printf>&2 ' - %s\n' "${dirs[@]}"
  exit 1
fi

Com versões mais antigas do bash, você sempre pode preencher o array em um loop:

dirs=()
while IFS= read -rd '' dir; do
  dirs=("${dirs[@]}" "$dir")
done < <(
  cd /var/kafka &&
    LC_ALL=C find . ! -name . -prune -type d ! -name '*[0-9]' -print0
)

Usamos LC_ALL=Capenas [0-9]correspondências em 0123456789 e não nos milhares de outros caracteres que geralmente classificam entre 0 e 9 em outras localidades, e também para que as *correspondências *[0-9]em 0 ou mais caracteres correspondam a 0 ou mais bytes.

Agora, tome cuidado, pois algumas localidades usam uma codificação de caracteres onde alguns caracteres adicionais, além de 0123456789, possuem uma codificação que termina no mesmo valor de byte que 0123456789. Por exemplo, no conjunto de caracteres GB18030 usado na China:

$ LC_ALL=zh_CN.gb18030 luit
$ locale charmap
GB18030
$ printf %s '¾' | LC_ALL=C od -tx1 -tc
0000000  81  30  86  36
        201   0 206   6
0000004

O ¾caractere geralmente é correspondido [0-9]independentemente de como é codificado, porque é classificado entre 0 e 9 por razões óbvias, mas também sua codificação GB18030 termina no byte 0x36, que também é a codificação do 6caractere de dígito ASCII.

Portanto, na localidade C, o caminho do arquivo composto pela codificação GB18030 /var/kafka/¾¾¾será considerado como terminando em um dígito ASCII e não será relatado. Se deveria ou não, é outra questão.

Usando find:

LC_ALL=C find /var/kafka -mindepth 1 -maxdepth 1 -type d -regex '.*[^0-9]$' | grep '^' \
&& echo "Error in folder name"

Estou "abusando" greppara obter um código de retorno sensato, se alguém souber de uma maneira melhor, por favor me avise.

Outra variante:

[ -z "$(LC_ALL=C find /var/kafka -mindepth 1 -maxdepth 1 -type d \( -name '*[0-9]' -o -print -quit \))" ]

Isso retorna verdadeiro ( $?é 0) se todos os nomes de diretório terminarem com um dígito