Número de caracteres na saída de um comando shell

Estou escrevendo um script que precisa calcular o número de caracteres na saída de um comando em uma única etapa .

Por exemplo, o uso do comando readlink -f /etc/fstabdeve retornar 10porque a saída desse comando tem 10 caracteres.

Isso já é possível com variáveis ​​armazenadas usando o seguinte código:

variable="somestring";
echo ${#variable};
# 10

Infelizmente, o uso da mesma fórmula com uma sequência gerada por comando não funciona:

${#(readlink -f /etc/fstab)};
# bash: ${#(readlink -f /etc/fstab)}: bad substitution

Entendo que é possível fazer isso primeiro salvando a saída em uma variável:

variable=$(readlink -f /etc/fstab);
echo ${#variable};

Mas eu gostaria de remover a etapa extra.

Isso é possível? É preferível a compatibilidade com o shell Almquist (sh) usando apenas utilitários embutidos ou padrão.

Com o GNU expr :

$ expr length + "$(readlink -f /etc/fstab)"
10

O +há uma característica especial do GNU exprpara garantir que o próximo argumento é tratado como uma string, mesmo se ele passa a ser um exproperador como match, length, +...

O exemplo acima eliminará qualquer nova linha de saída posterior. Para contornar isso:

$ expr length + "$(readlink -f /etc/fstab; printf .)" - 2
10

O resultado foi subtraído para 2 porque a nova linha final de readlinke o personagem .que adicionamos.

Com a string Unicode, exprparece não funcionar, pois retorna o comprimento da string em bytes, em vez da contagem de caracteres (consulte a linha 654 )

$ LC_ALL=C.UTF-8 expr length ăaa
4

Então, você pode usar:

$ printf "ăaa" | LC_ALL=C.UTF-8 wc -m
3

POSIXAMENTE:

$ expr " $(readlink -f /etc/fstab; printf .)" : ".*" - 3
10

O espaço antes da substituição do comando evita que o comando seja travado com o início da string -, portanto, precisamos subtrair 3.

Não tenho certeza de como fazer isso com os shell builtins (o Gnouc é embora ), mas as ferramentas padrão podem ajudar:

1. Você pode usar o wc -mque conta caracteres. Infelizmente, ele também conta a nova linha final, então você precisa se livrar disso primeiro:

   readlink -f /etc/fstab | tr -d '\n' | wc -m

2. Você pode, é claro, usar awk

   readlink -f /etc/fstab | awk '{print length($0)}'

3. Ou Perl

   readlink -f /etc/fstab | perl -lne 'print length'

Eu costumo fazer assim:

$ echo -n "$variable" | wc -m
10

Para executar comandos, eu o adaptaria assim:

$ echo -n "$(readlink -f /etc/fstab)" | wc -m
10

Essa abordagem é semelhante ao que você estava fazendo em suas duas etapas, exceto que as estamos combinando em uma única linha.

Você pode ligar para utilitários externos (veja outras respostas), mas eles tornarão seu script mais lento e é difícil acertar o encanamento.

Zsh

No zsh, você pode escrever ${#$(readlink -f /etc/fstab)}para obter o tamanho da substituição do comando. Observe que esse não é o tamanho da saída do comando, é o comprimento da saída sem nenhuma nova linha à direita.

Se você deseja o comprimento exato da saída, produza um caractere extra não-nova linha no final e subtrai um.

$((${#$(readlink -f /etc/fstab; echo .)} - 1))

Se o que você deseja é a carga útil na saída do comando, é necessário subtrair duas aqui, porque a saída de readlink -fé o caminho canônico mais uma nova linha.

$((${#$(readlink -f /etc/fstab; echo .)} - 2))

Isso difere do ${#$(readlink -f /etc/fstab)}caso raro, mas possível, em que o próprio caminho canônico termina em uma nova linha.

Para este exemplo específico, você não precisa de nenhum utilitário externo, porque o zsh possui uma construção interna equivalente a ela readlink -f, através do modificador de histórico A.

echo /etc/fstab(:A)

Para obter o comprimento, use o modificador de histórico em uma expansão de parâmetro:

${#${:-/etc/fstab}:A}

Se você tiver o nome do arquivo em uma variável filename, seria ${#filename:A}.

Conchas tipo Bourne / POSIX

Nenhum dos shells Bourne / POSIX puros (Bourne, ash, mksh, ksh93, bash, yash ...) tem qualquer extensão semelhante que eu conheça. Se você precisar aplicar uma substituição de parâmetro na saída de uma substituição de comando ou aninhar substituições de parâmetro, use estágios sucessivos.

Você pode inserir o processamento em uma função, se desejar.

command_output_length_sans_trailing_newlines () {
  set -- "$("$@")"
  echo "${#1}"
}

ou

command_output_length () {
  set -- "$("$@"; echo .)"
  echo "$((${#1} - 1))"
}

mas geralmente não há benefício; exceto com ksh93, isso faz com que um fork adicional seja capaz de usar a saída da função, tornando o script mais lento e raramente há benefícios de legibilidade.

Mais uma vez, a saída de readlink -fé o caminho canônico mais uma nova linha; se você quiser o comprimento do caminho canônico, subtraia 2 em vez de 1 pol command_output_length. O uso command_output_length_sans_trailing_newlinesfornece o resultado certo apenas quando o caminho canônico em si não termina em uma nova linha.

Bytes vs caracteres

${#…}deve ter o comprimento em caracteres, não em bytes, o que faz a diferença nos códigos de idioma multibyte. Versões razoavelmente atualizadas do ksh93, bash e zsh calculam o comprimento em caracteres de acordo com o valor LC_CTYPEno momento em que a ${#…}construção é expandida. Muitos outros shells comuns realmente não suportam localizações multibyte: a partir do traço 0.5.7, mksh 46 e posh 0.12.3, ${#…}retorna o comprimento em bytes. Se você deseja que o tamanho dos caracteres seja confiável, use o wcutilitário:

$(readlink -f /etc/fstab | wc -m)

Desde que $LC_CTYPEdesigne um código de idioma válido, você pode ter certeza de que isso ocorrerá erro (em uma plataforma antiga ou restrita que não suporta códigos de idioma com vários bytes) ou retornará o tamanho correto em caracteres. (Para Unicode, "comprimento em caracteres" significa o número de pontos de código - o número de glifos é mais uma história, devido a complicações como a combinação de caracteres.)

Se você deseja o comprimento em bytes, defina LC_CTYPE=Ctemporariamente ou use em wc -cvez de wc -m.

A contagem de bytes ou caracteres com wcinclui qualquer nova linha à direita do comando. Se você deseja o comprimento do caminho canônico em bytes, é

$(($(readlink -f /etc/fstab | wc -c) - 1))

Para obtê-lo em caracteres, subtraia 2.

Isso funciona, dashmas exige que o var direcionado esteja definitivamente vazio ou não definido. É por isso que na verdade são dois comandos - eu esvazio explicitamente $lno primeiro:

l=;printf '%.slen is %d and result is %s\n' \
    "${l:=$(readlink -f /etc/fstab)}" "${#l}" "$l"

RESULTADO

len is 10 and result is /etc/fstab

Isso é tudo embutido no shell - não incluindo o readlinkclaro -, mas avaliá-lo no shell atual dessa maneira implica que você deve fazer a atribuição antes de obter o len, e é por isso que eu %.silencio o primeiro argumento na printfstring de formato e o adiciono novamente para o valor literal no printffinal da lista de argumentos.

Com eval:

l=$(readlink -f /etc/fstab) eval 'l=${#l}:$l'
printf %s\\n "$l"

RESULTADO

10:/etc/fstab

Você pode se aproximar da mesma coisa, mas em vez da saída em uma variável no primeiro comando, você a obtém no stdout:

PS4='${#0}:$0' dash -cx '2>&1' "$(readlink -f /etc/fstab)"

... que escreve ...

10:/etc/fstab

... para arquivar o descritor 1 sem atribuir nenhum valor a nenhum vars no shell atual.