¿Sabías que el corchete '[' es un comando real en Linux

Introducción

En el día a día dentro de la terminal de Ubuntu, solemos dar por sentado que los corchetes [ son simples elementos de puntuación sintáctica propios del shell. Sin embargo, detrás de este símbolo se oculta una utilidad ejecutable por derecho propio. En este artículo desglosaremos la verdadera naturaleza del comando [, su mecanismo de evaluación lógica y la forma adecuada de interpretar el código de estado devuelto en $? para construir scripts robustos.

1. Descubriendo la identidad de ‘[’ y localizando su binario en el sistema

Para comprobar si el corchete de apertura reside efectivamente como un ejecutable dentro de nuestro entorno, lanzamos la consulta mediante which [:

Al ejecutarlo, la consola devuelve la ruta /usr/bin/[. Este hallazgo confirma que no estamos ante un artificio meramente visual del intérprete, sino frente a un archivo binario independiente alojado en el sistema de archivos.

⚙️ [Parámetros y comprobaciones esenciales]

-f : Verifica si la ruta apunta a un fichero regular.
-d : Determina si el objetivo analizado corresponde a un directorio.
-e : Comprueba la existencia física del elemento (archivo o carpeta).
-z : Devuelve verdadero cuando la longitud de la cadena de texto es igual a cero (cadena vacía).
-n : Evalúa positivamente si la cadena de texto contiene caracteres (longitud distinta de cero).
= : Contrasta la igualdad exacta entre dos cadenas de caracteres.
-eq : Valida la equivalencia numérica entre dos números enteros.
-ne : Confirma si dos valores enteros son diferentes entre sí.

![Ruta del binario con which

A continuación, inspeccionamos la resolución interna del comando dentro del contexto de Bash mediante type -a [:

La salida evidencia una dualidad técnica muy interesante: el shell lo prioriza como una función integrada nativa (shell builtin), pero al mismo tiempo expone su contraparte binaria compilada en /usr/bin/[ y /bin/[.

![Resolución del comando con type -a

Para profundizar en sus metadatos, recurrimos a ls -l /usr/bin/[ y revisamos sus atributos en disco:

El listado ratifica que se trata de un archivo ordinario con permisos de ejecución (-rwxr-xr-x), preparado para ser invocado por cualquier usuario del sistema operativo.

![Inspección de permisos con ls -l /usr/bin/

2. Sintaxis básica y validación del código de retorno ($?)

Iniciamos una comparación relacional numérica ejecutando [ 10 -gt 5 ], la cual contrasta si diez supera cuantitativamente a cinco (-gt, greater than):

Fiel a la filosofía Unix, la operación concluye de forma silenciosa sin arrojar texto por la salida estándar, limitándose a comunicar su veredicto mediante el código de salida del proceso.

Procedemos a interrogar el valor de retorno inmediato del procesador mediante echo $?:

El terminal imprime el dígito 0, lo que en entornos Unix/Linux certifica un estado de éxito absoluto o una evaluación evaluada como “Verdadero” (True).

Probemos ahora el escenario opuesto formulando la condición [ 10 -lt 5 ], donde se cuestiona si diez es menor que cinco (-lt, less than):

Nuevamente, el comando no genera mensajes directos en pantalla; la resolución lógica queda almacenada internamente para la siguiente instrucción.

Revisamos nuevamente el estado resultante disparando echo $?:

En esta ocasión recibimos un código distinto de cero (1), lo que permite a cualquier pipeline o script detectar de inmediato que la premisa analizada resultó falsa o insatisfecha.

3. Práctica de verificación de ficheros y directorios (-f, -d, -s)

Con el fin de experimentar con validaciones sobre el árbol de archivos, preparamos un entorno de pruebas controlado ejecutando mkdir -p /tmp/bracket_test && touch /tmp/bracket_test/sample.txt:

Validamos la presencia del archivo ordinario invocando [ -f /tmp/bracket_test/sample.txt ] && echo "파일이 정상적으로 존재합니다":

Al cumplirse positivamente el test, el operador lógico && transfiere el control a la segunda instrucción, visualizándose el mensaje confirmatorio sin contratiempos.

Seguidamente, confirmamos la estructura del directorio con [ -d /tmp/bracket_test ] && echo "디렉터리가 맞습니다":

Dado que la ruta analizada corresponde fehacientemente a un directorio válido, el comando finaliza con código cero y el texto descriptivo se proyecta en la consola.

Ahora comprobamos si el fichero contiene datos reales mediante [ -s /tmp/bracket_test/sample.txt ] || echo "파일 크기가 0(비어있음)입니다":

Debido a que creamos el fichero con touch, su tamaño en bytes es exactamente cero. La condición evaluada resulta falsa, activando la rama del operador || para advertir sobre el archivo vacío.

4. Integración en sentencias condicionales (if) y evaluación en entornos Bash reales

Para simular un flujo condicional con contenido efectivo, inyectamos una cadena dentro del documento mediante echo "Ubuntu Shell Test" > /tmp/bracket_test/sample.txt:

Articulamos una estructura clásica de control en Bash lanzando if [ -s /tmp/bracket_test/sample.txt ]; then echo "내용 확인: $(cat /tmp/bracket_test/sample.txt)"; fi:

El flag -s detecta que el archivo ya no está vacío, validando el bloque if como verdadero y ejecutando las sentencias internas dentro del bloque then para imprimir el texto almacenado.

Concluidas las demostraciones prácticas, liberamos el espacio temporal utilizado corriendo rm -rf /tmp/bracket_test:

Comprender que [ opera como un comando estructurado —y no como un mero adorno del teclado— transforma por completo la forma en que depuramos y escribimos scripts en GNU/Linux. Con este dominio sobre los códigos de salida y la sintaxis posicional, podrás diagnosticar fallos lógicos con total naturalidad y diseñar automatizaciones mucho más confiables.