Verifique la existencia del argumento de entrada en un script de shell Bash

Necesito verificar la existencia de un argumento de entrada. Tengo el siguiente script

if [ "$1" -gt "-1" ]
  then echo hi
fi

yo obtengo

[: : integer expression expected

¿Cómo verifico primero el argumento de entrada1 para ver si existe?

Está:

if [ $# -eq 0 ]
  then
    echo "No arguments supplied"
fi

La $#variable le indicará la cantidad de argumentos de entrada que se pasó el script.

O puede verificar si un argumento es una cadena vacía o no:

if [ -z "$1" ]
  then
    echo "No argument supplied"
fi

El -zconmutador probará si la expansión de "$ 1" es una cadena nula o no. Si es una cadena nula, se ejecuta el cuerpo.

Es mejor demostrar de esta manera

if [[ $# -eq 0 ]] ; then
    echo 'some message'
    exit 1
fi

Normalmente necesita salir si tiene muy pocos argumentos.

En algunos casos, debe verificar si el usuario pasó un argumento al script y, de lo contrario, volver a un valor predeterminado. Como en el guión a continuación:

scale=${2:-1}
emulator @$1 -scale $scale

Aquí, si el usuario no ha pasado scalecomo segundo parámetro, ejecuto el emulador de Android -scale 1de forma predeterminada. ${varname:-word}Es un operador de expansión. También hay otros operadores de expansión:

• ${varname:=word}que establece lo indefinido en varnamelugar de devolver el wordvalor;
• ${varname:?message}que devuelve varnamesi está definido y no es nulo o imprime messagey aborta el script (como el primer ejemplo);
• ${varname:+word}que devuelve wordsolo si varnameestá definido y no es nulo; devuelve nulo de lo contrario.

Tratar:

 #!/bin/bash
 if [ "$#" -eq  "0" ]
   then
     echo "No arguments supplied"
 else
     echo "Hello world"
 fi

Otra forma de detectar si se pasaron argumentos al script:

((!$#)) && echo No arguments supplied!

Tenga en cuenta que (( expr ))hace que la expresión se evalúe según las reglas de Shell Arithmetic .

Para salir en ausencia de argumentos, se puede decir:

((!$#)) && echo No arguments supplied! && exit 1

Otra forma (análoga) de decir lo anterior sería:

let $# || echo No arguments supplied

let $# || { echo No arguments supplied; exit 1; }  # Exit if no arguments!

help let dice:

let: let arg [arg ...]

  Evaluate arithmetic expressions.

  ...

  Exit Status:
  If the last ARG evaluates to 0, let returns 1; let returns 0 otherwise.

A menudo uso este fragmento para secuencias de comandos simples:

#!/bin/bash

if [ -z "$1" ]; then
    echo -e "\nPlease call '$0 <argument>' to run this command!\n"
    exit 1
fi

Solo porque hay un punto más básico para señalar, agregaré que simplemente puede probar que su cadena es nula:

if [ "$1" ]; then
  echo yes
else
  echo no
fi

Del mismo modo, si está esperando un recuento de argumentos, solo pruebe su último:

if [ "$3" ]; then
  echo has args correct or not
else
  echo fixme
fi

y así sucesivamente con cualquier arg o var

Si desea verificar si el argumento existe, puede verificar si el número de argumentos es mayor o igual que su número de argumento objetivo.

El siguiente script demuestra cómo funciona esto

test.sh

#!/usr/bin/env bash

if [ $# -ge 3 ]
then
  echo script has at least 3 arguments
fi

produce la siguiente salida

$ ./test.sh
~
$ ./test.sh 1
~
$ ./test.sh 1 2
~
$ ./test.sh 1 2 3
script has at least 3 arguments
$ ./test.sh 1 2 3 4
script has at least 3 arguments

Como un pequeño recordatorio, los operadores numéricos de los análisis en Bash sólo funcionan en números enteros ( -eq, -lt, -ge, etc.)

Me gusta asegurarme de que mis $ vars son ints por

var=$(( var + 0 ))

antes de probarlos, solo para defenderme del error "[: se requiere argumento entero".

validación de una función bash de línea

myFunction() {

    : ${1?"forgot to supply an argument"}
    if [ "$1" -gt "-1" ]; then
        echo hi
    fi

}

agregar nombre de función y uso

myFunction() {

    : ${1?"forgot to supply an argument ${FUNCNAME[0]}() Usage:  ${FUNCNAME[0]} some_integer"}
    if [ "$1" -gt "-1" ]; then
        echo hi
    fi

}

agregar validación para verificar si es entero

para agregar validación adicional, por ejemplo para verificar si el argumento pasado es un número entero, modifique la línea de validación para llamar a una función de validación:

: ${1?"forgot to supply an argument ${FUNCNAME[0]}() Usage:  ${FUNCNAME[0]} some_integer"} && validateIntegers $1 || die "Must supply an integer!"

luego, construya una función de validación que valide el argumento, devolviendo 0 en caso de éxito, 1 en caso de error y una función de matriz que anule el script en caso de error

validateIntegers() {

    if ! [[ "$1" =~ ^[0-9]+$ ]]; then
        return 1 # failure
    fi
    return 0 #success

}

die() { echo "$*" 1>&2 ; exit 1; }

Aún más simple: solo use set -u

set -u se asegura de que cada variable referenciada se establezca cuando se usa, así que solo configúrela y olvídela

myFunction() {
    set -u
    if [ "$1" -gt "-1" ]; then
        echo hi
    fi

}