5. Condiciones

Manejar condiciones es importante en todos los lenguajes de programación: sirven para controlar el flujo del programa (el título del próximo capítulo), y eso lo es prácticamente todo.

En UNIX, al contrario de lo que podría parecer, el valor entero que representa al valor verdadero booleano es el 0, y el valor entero que representa al falso es el 1. Esto es así por el convenio antes citado de los valores devueltos por los programas en UNIX.

5.1 La orden test

Para ello, en UNIX existe la orden test. Tiene una sintaxis alternativa, que es con mucho la más usada (es más clara), que es con corchetes ([]). Es importante darse cuenta de que la segunda sintaxis es también un programa (que se llama [, aunque suene raro, y que exige, supongo, que al final de la condición se ponga un ], más por estética que por otra cosa), así que necesita que lo que pongamos entre los corchetes esté separado por al menos un espacio (incluido el último corchete).

La orden test (con cualquiera de las dos sintaxis) acepta dos tipos de operadores: los unarios (que sólo tienen un parámetro) y los binarios (que necesitan dos parámetros). Si al principio de una condición ponemos un `!', separado por espacios de lo demás, como siempre, negaremos la condición que estemos poniendo en el test.

Operadores para el manejo de ficheros

Todos los operadores para el manejo de ficheros en la programación en shell son unarios. Cuando se utilizan los operadores unarios con la orden test, la sintaxis es la siguiente: test operador fichero. Los operadores de ficheros que acepta la orden test son los siguientes:

    Operador       Significado
       -f          Si fichero es un fichero ordinario
       -d          Si fichero es un directorio
       -r          Si el proceso tiene permiso de lectura sobre fichero
       -w          Si el proceso tiene permiso de escritura sobre fichero
       -x          Si el proceso tiene permiso de ejecución sobre fichero
       -s          Si fichero tiene una longitud mayor que cero

Operadores para el manejo de ristras

Los operadores para el manejo de ristras en la programación en shell son dos binarios, y la dos unarios (en realidad dan las condiciones contrarias). La sintaxis de test con operadores binarios, como era de esperar, es test operando1 operador operando2. La tabla de operadores de manejo de ristras es la siguiente:

         Operador           Significado
        = (binario)         Si operando1 es igual a operando2
       != (binario)         Si operando1 es distinto de operando2
       -z (unario)          Si operando es una ristra nula
       -n (unario)          Si operando es una ristra no nula

Operadores para el manejo de números

Vale, vale. Ya sé que he dicho que no existen los tipos en las variables del intérprete, pero aún así es posible que la ristra ``1'' o ``20'' sea tratada como un número, así que todavía son necesarios los operadores para el manejo de números. Los operadores de manejo de números son siempre binarios, y son los siguientes:

     Operador        Significado
        -eq          operando1 y operando2 son iguales
        -ne          operando1 y operando2 son distintos
        -gt          operando1 es mayor estricto que operando2
        -ge          operando1 es mayor o igual que operando2
        -lt          operando1 es menor que operando2
        -le          operando1 es menor o igual que operando2

Expresiones complicadas

Algunas veces vas a necesitar evaluar expresiones complicadas en un guión, como condiciones dobles (con y o con o), y puede que incluso condiciones triples (más lo dudo).

Este es un tema delicado en la programación de shell: la forma de hacerlo es con los operadores -a y -o (and y or respectivamente), con lo que una expresión doble puede quedar tal que así (de horrible):

        [ -w /home/zoso/.profile -a -n $MAIL ]

¿Feo, verdad? Esto comprueba si el proceso tiene permiso de escritura sobre el fichero /home/zoso/.profile y si la variable $MAIL tiene algún contenido.

Pues todavía no ha llegado lo peor: Si quisiésemos realizar condiciones dobles, y poner paréntesis, hay un problema añadido, y es que los paréntesis son caracteres especiales para el intérprete. Entonces, para que no los reconozca como paréntesis, y que coja los paréntesis literales, como texto, hay que escribirlos como \( y \) (sí, utilizando el símbolo \ como en C y en otros lenguajes de programación relacionados con el UNIX). Así, una condición doble quedaría en el lenguaje del intérprete así que ilegible:

        [ -d ~/Mail -o \( -f ~/mail -a $cont -ne 0 \) ]

Este ejemplo comprueba si existe el directorio ~/Mail o si existe el fichero -f ~/mail y además la variable $cont, interpretada como un número, es distinta de 0. Es importante acordarse de escribir espacios entre los paréntesis, todos los operadores y los corchetes, porque al fin y al cabo van a ser interpretados por un programa que espera que se presenten todos como parámetros diferentes.