shell - srtf - ¿Cómo puedo negar el valor de retorno de un proceso?

planificacion de procesos ejemplos

Question

Estoy buscando un proceso de negación simple pero multiplataforma que niegue el valor que devuelve un proceso. ¡Debería mapear 0 a algún valor! = 0 y cualquier valor! = 0 a 0, es decir, el siguiente comando debería devolver "sí, nonexistingpath no existe":

 ls nonexistingpath | negate && echo "yes, nonexistingpath doesn''t exist."

Los ! - El operador es excelente, pero desafortunadamente no es independiente de la carcasa.

Answer 1

En Bash, usa el! operador antes del comando. Por ejemplo:

! ls nonexistingpath && echo "yes, nonexistingpath doesn''t exist"

Answer 2

Tu podrías intentar:

ls nonexistingpath || echo "yes, nonexistingpath doesn''t exist."

o solo:

! ls nonexistingpath

Answer 3

! ls nonexistingpath && echo "yes, nonexistingpath doesn''t exist."

o

ls nonexistingpath || echo "yes, nonexistingpath doesn''t exist."

Answer 4

Si de alguna manera ocurre que no tienes a Bash como tu caparazón (por ejemplo: scripts de git o pruebas de títere), puedes ejecutar:

echo ''! ls notexisting'' | bash

-> retcode: 0

echo ''! ls /'' | bash

-> retcode: 1

Answer 5

^{Anteriormente, la respuesta se presentaba con lo que ahora es la primera sección como la última sección.}

POSIX Shell incluye un ! operador

Buscando en la especificación de shell para otros problemas, recientemente (septiembre de 2015) noté que el shell POSIX admite un ! operador. Por ejemplo, aparece como una palabra reservada y puede aparecer al comienzo de una canalización , donde un comando simple es un caso especial de ''canalización''. Por lo tanto, puede utilizarse en sentencias if y while or until loops también - en shells conformes a POSIX. En consecuencia, a pesar de mis reservas, es probable que esté más ampliamente disponible de lo que me di cuenta en 2008. ¡Una comprobación rápida de POSIX 2004 y SUS / POSIX 1997 muestra que ! estuvo presente en ambas versiones.

Tenga en cuenta que el ! el operador debe aparecer al comienzo de la tubería y niega el código de estado de toda la tubería (es decir, el último comando). Aquí hay unos ejemplos.

# Simple commands, pipes, and redirects work fine.
$ ! some-command succeed; echo $?
1
$ ! some-command fail | some-other-command fail; echo $?
0
$ ! some-command < succeed.txt; echo $?
1

# Environment variables also work, but must come after the !.
$ ! RESULT=fail some-command; echo $?
0

# A more complex example.
$ if ! some-command < input.txt | grep Success > /dev/null; then echo ''Failure!''; recover-command; mv input.txt input-failed.txt; fi
Failure!
$ ls *.txt
input-failed.txt

Respuesta portátil: funciona con conchas antiguas

En una secuencia de comandos Bourne (Korn, POSIX, Bash), uso:

if ...command and arguments...
then : it succeeded
else : it failed
fi

Esto es tan portátil como se pueda. El ''comando y argumentos'' puede ser una tubería u otra secuencia compuesta de comandos.

Un comando not

Los ''!'' El operador, ya sea incorporado a su shell o provisto por el o / s, no está disponible universalmente. Aunque no es terriblemente difícil de escribir, el código de abajo data de al menos 1991 (aunque creo que escribí una versión anterior incluso hace más tiempo). Sin embargo, no tiendo a usar esto en mis scripts porque no está disponible de manera confiable.

/*
@(#)File:           $RCSfile: not.c,v $
@(#)Version:        $Revision: 4.2 $
@(#)Last changed:   $Date: 2005/06/22 19:44:07 $
@(#)Purpose:        Invert success/failure status of command
@(#)Author:         J Leffler
@(#)Copyright:      (C) JLSS 1991,1997,2005
*/

#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include "stderr.h"

#ifndef lint
static const char sccs[] = "@(#)$Id: not.c,v 4.2 2005/06/22 19:44:07 jleffler Exp $";
#endif

int main(int argc, char **argv)
{
    int             pid;
    int             corpse;
    int             status;

    err_setarg0(argv[0]);

    if (argc <= 1)
    {
            /* Nothing to execute. Nothing executed successfully. */
            /* Inverted exit condition is non-zero */
            exit(1);
    }

    if ((pid = fork()) < 0)
            err_syserr("failed to fork/n");

    if (pid == 0)
    {
            /* Child: execute command using PATH etc. */
            execvp(argv[1], &argv[1]);
            err_syserr("failed to execute command %s/n", argv[1]);
            /* NOTREACHED */
    }

    /* Parent */
    while ((corpse = wait(&status)) > 0)
    {
            if (corpse == pid)
            {
                    /* Status contains exit status of child. */
                    /* If exit status of child is zero, it succeeded, and we should
                       exit with a non-zero status */
                    /* If exit status of child is non-zero, if failed and we should
                       exit with zero status */
                    exit(status == 0);
                    /* NOTREACHED */
            }
    }

    /* Failed to receive notification of child''s death -- assume it failed */
    return (0);
}

Esto devuelve ''éxito'', lo contrario de la falla, cuando falla al ejecutar el comando. Podemos debatir si la opción ''no hacer nada con éxito'' fue correcta; tal vez debería informar un error cuando no se le pide que haga nada. El código en '' "stderr.h" '' proporciona facilidades simples para reportar errores, lo uso en todas partes. Código fuente bajo pedido - ver mi página de perfil para contactarme.