eco que gera para stderr

Existe uma ferramenta Bash padrão que age como eco, mas gera stderr em vez de stdout?

Eu sei que posso fazer, echo foo 1>&2mas é meio feio e, suspeito, propenso a erros (por exemplo, é mais provável que seja editado errado quando as coisas mudam).

Você poderia fazer isso, o que facilita a leitura:

>&2 echo "error"

>&2copia o descritor de arquivo nº 2 para o descritor de arquivo nº 1. Portanto, depois que esse redirecionamento é realizado, os dois descritores de arquivo se referem ao mesmo arquivo: o descritor de arquivo nº 2 estava originalmente se referindo. Para obter mais informações, consulte o Tutorial de redirecionamento ilustrado do Bash Hackers .

Você pode definir uma função:

echoerr() { echo "$@" 1>&2; }
echoerr hello world

Isso seria mais rápido que um script e não terá dependências.

A sugestão específica do bash de Camilo Martin usa uma "string aqui" e imprime qualquer coisa que você passar, incluindo argumentos (-n) que o eco normalmente engoliria:

echoerr() { cat <<< "$@" 1>&2; }

A solução de Glenn Jackman também evita o problema da deglutição:

echoerr() { printf "%s\n" "$*" >&2; }

Como 1é a saída padrão, você não precisa nomeá-la explicitamente na frente de um redirecionamento de saída, >mas sim, simplesmente digitar:

eco Esta mensagem vai para stderr> & 2

Como você parece estar preocupado com a 1>&2dificuldade de digitar com segurança, a eliminação do redundante 1pode ser um pequeno incentivo para você!

Outra opção

echo foo >>/dev/stderr

Não, essa é a maneira padrão de fazer isso. Não deve causar erros.

Se você não se importa de registrar a mensagem também no syslog, a maneira not_so_ugly é:

logger -s $msg

A opção -s significa: "Envie a mensagem para o erro padrão e também para o log do sistema".

Essa é uma função STDERR simples, que redireciona a entrada do tubo para STDERR.

#!/bin/bash
# *************************************************************
# This function redirect the pipe input to STDERR.
#
# @param stream
# @return string
#
function STDERR () {

cat - 1>&2

}

# remove the directory /bubu
if rm /bubu 2>/dev/null; then
    echo "Bubu is gone."
else
    echo "Has anyone seen Bubu?" | STDERR
fi


# run the bubu.sh and redirect you output
tux@earth:~$ ./bubu.sh >/tmp/bubu.log 2>/tmp/bubu.err

Nota: Estou respondendo à pergunta pós-não-enganosa / vaga "eco que gera stderr" (já respondida pelo OP).

Use uma função para mostrar a intenção e obter a implementação que você deseja. Por exemplo

#!/bin/bash

[ -x error_handling ] && . error_handling

filename="foobar.txt"
config_error $filename "invalid value!"

output_xml_error "No such account"

debug_output "Skipping cache"

log_error "Timeout downloading archive"

notify_admin "Out of disk space!"

fatal "failed to open logger!"

E error_handlingsendo:

ADMIN_EMAIL=root@localhost

config_error() { filename="$1"; shift; echo "Config error in $filename: $*" 2>&1; }

output_xml_error() { echo "<error>$*</error>" 2>&1; }

debug_output() { [ "$DEBUG"=="1" ] && echo "DEBUG: $*"; }

log_error() { logger -s "$*"; }

fatal() { which logger >/dev/null && logger -s "FATAL: $*" || echo "FATAL: $*"; exit 100; }

notify_admin() { echo "$*" | mail -s "Error from script" "$ADMIN_EMAIL"; }

Razões que tratam das preocupações no OP:

• sintaxe mais agradável possível (palavras significativas em vez de símbolos feios)
• mais difícil cometer um erro (especialmente se você reutilizar o script)
• não é uma ferramenta Bash padrão, mas pode ser uma biblioteca shell padrão para você ou sua empresa / organização

Outras razões:

• clareza - mostra a intenção de outros mantenedores
• speed - as funções são mais rápidas que os scripts shell
• reutilização - uma função pode chamar outra função
• configurabilidade - não é necessário editar o script original
• depuração - é mais fácil encontrar a linha responsável por um erro (especialmente se você está lidando com uma tonelada de saída de redirecionamento / filtragem)
• robustez - se uma função estiver ausente e você não puder editar o script, poderá voltar a usar uma ferramenta externa com o mesmo nome (por exemplo, log_error pode ser um alias para o logger no Linux)
• alternando implementações - você pode alternar para ferramentas externas removendo o atributo "x" da biblioteca
• agnóstico de saída - você não precisa mais se preocupar se vai para STDERR ou outro local
• personalização - você pode configurar o comportamento com variáveis ​​de ambiente

Minha sugestão:

echo "my errz" >> /proc/self/fd/2

ou

echo "my errz" >> /dev/stderr

echo "my errz" > /proc/self/fd/2vai efetivamente saída para stderrporque /proc/selfé um link para o processo atual, e /proc/self/fddetém o processo aberto descritores de arquivo, e em seguida, 0, 1e 2representam stdin, stdoutestderr respectivamente.

O /proc/selflink não funciona no MacOS, no entanto, /proc/self/fd/*está disponível no Termux no Android, mas não /dev/stderr. Como detectar o SO de um script Bash? pode ajudar se você precisar tornar seu script mais portátil, determinando qual variante usar.

Não use, catpois alguns são mencionados aqui. caté um programa while echoe printfsão bash (shell) embutidos. Iniciar um programa ou outro script (também mencionado acima) significa criar um novo processo com todos os seus custos. Usando builtins, as funções de escrita são bastante baratas, porque não há necessidade de criar (executar) um processo (ambiente).

O opner pergunta "existe alguma ferramenta padrão para enviar ( pipe ) ao stderr", a resposta do schort é: NÃO ... por quê? ... rediredcting pipes é um conceito elemantário em sistemas como o unix (Linux ...) e o bash (sh) se baseia nesses conceitos.

Eu concordo com o abridor de que redirecionar com notações como esta: &2>1não é muito agradável para programadores modernos, mas isso é uma loucura. O Bash não teve a intenção de escrever programas enormes e robustos, mas sim ajudar os administradores a trabalhar com menos pressionamentos de tecla ;-)

E pelo menos, você pode colocar o redirecionamento em qualquer lugar da linha:

$ echo This message >&2 goes to stderr 
This message goes to stderr

Outra opção que encontrei recentemente é a seguinte:

    {
        echo "First error line"
        echo "Second error line"
        echo "Third error line"
    } >&2

Isso usa apenas os integrados do Bash e, ao mesmo tempo, torna a saída de erro de várias linhas menos propensa a erros (já que você não precisa se lembrar de adicionar &>2a todas as linhas).

read é um comando interno do shell que imprime no stderr e pode ser usado como eco sem executar truques de redirecionamento:

read -t 0.1 -p "This will be sent to stderr"

A -t 0.1é um tempo de espera que desactiva de funcionalidade principal ler, armazenar uma linha de entrada padrão para uma variável.

Faça um script

#!/bin/sh
echo $* 1>&2

essa seria sua ferramenta.

Ou crie uma função se você não quiser ter um script em arquivo separado.

Mac OS X: Tentei a resposta aceita e algumas outras respostas, e todas resultaram na criação de STDOUT e não de STDERR no meu Mac.

Aqui está uma maneira portátil de gravar em erro padrão usando o Perl:

echo WARNING! | perl -ne 'print STDERR'