Validador Regex de GUID en Go

Use el Validador Regex de GUID en Go para asegurarse de que sus identificadores únicos sigan la estructura correcta. Pruebe y depure su regex en el Probador de Regex en Go o valide datos asociados como correos electrónicos, URLs y contraseñas para un flujo de trabajo completo de calidad de datos.

Validador Regex de GUID en Go - Documentación

Introducción: ¿Qué es GUID Regex?

En Go (Golang), un GUID (Identificador Único Global), también conocido como UUID (Identificador Único Universal), se utiliza para identificar recursos de forma única en sistemas distribuidos. Garantiza que no haya dos valores iguales, lo que lo hace esencial para el seguimiento, el versionado y la referencia.

Un GUID tiene este aspecto:

3f2504e0-4f89-11d3-9a0c-0305e82c3301

Contiene 32 caracteres hexadecimales organizados en 5 grupos separados por guiones, siguiendo el patrón:

8-4-4-4-12

La forma más confiable de validar formatos GUID en Go es usando expresiones regulares (regex). Regex permite hacer coincidir y verificar esta estructura antes de almacenar o procesar los datos.

Patrón Regex GUID (con Desglose)

Este es el patrón regex que usamos para validar un GUID:

^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$

Explicación:

[0-9a-fA-F]{8}: primer grupo de 8 dígitos hexadecimales
-: separador de guión
[0-9a-fA-F]{4}: segundo grupo de 4 dígitos
[1-5][0-9a-fA-F]{3}: dígito de versión (1-5) + 3 dígitos hexadecimales adicionales
[89abAB][0-9a-fA-F]{3}: dígito de variante (comienza con 8, 9, a o b) + 3 dígitos hexadecimales
[0-9a-fA-F]{12}: últimos 12 dígitos hexadecimales

¿Se Permiten Llaves en los GUIDs?

Aunque el formato GUID estándar usa guiones para separar sus cinco grupos, también puede encontrar GUIDs encerrados entre llaves, especialmente en entornos de Microsoft y Windows. Por ejemplo:

Con llaves: {3f2504e0-4f89-11d3-9a0c-0305e82c3301}
Sin llaves: 3f2504e0-4f89-11d3-9a0c-0305e82c3301

El patrón regex proporcionado es lo suficientemente robusto para manejar ambos escenarios. Las llaves { y } son opcionales al inicio y al final del patrón. Esto significa que su GUID puede validarse tanto si está entre llaves como si no, lo que garantiza compatibilidad con herramientas, APIs y bibliotecas que puedan esperar cualquiera de los dos estilos.

Complejidad de Espacio Auxiliar

Validar un GUID con una expresión regular en Go es altamente eficiente en cuanto al uso de memoria. La complejidad de espacio auxiliar es O(1): verificar si una cadena coincide con el patrón GUID solo requiere una cantidad fija y constante de memoria adicional, independientemente de la longitud de la cadena. Todas las operaciones ocurren en el lugar y no se crean estructuras de datos adicionales durante la validación.

Rendimiento: Complejidad de Tiempo en la Validación de GUID

Cuando valida un GUID usando una expresión regular, el proceso generalmente escanea la cadena una vez de inicio a fin para verificar el cumplimiento del patrón. Esto significa que la complejidad de tiempo es lineal con respecto a la longitud de la cadena de entrada, o O(N), donde N es el número de caracteres en el GUID candidato.

En resumen: las verificaciones de GUID basadas en regex son eficientes, rara vez notará algún retraso, incluso a escala.

Cómo Validar GUIDs en Go Usando Regex

Puede validar GUIDs usando el paquete regexp en Go. Aquí está el código completo en Go:

package main
import (
"fmt"
"regexp"
)
func isValidGUID(guid string) bool {
pattern := ^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$
regex := regexp.MustCompile(pattern)
return regex.MatchString(guid)
}
func main() {
samples := []string{
"3f2504e0-4f89-11d3-9a0c-0305e82c3301", // valid
"3F2504E0-4F89-11D3-9A0C-0305E82C3301", // valid uppercase
"123e4567e89b12d3a456426614174000",     // invalid (no hyphens)
"3f25-04e0-4f89-11d3-9a0c-0305e82c3301", // invalid (group mismatch)
}
for _, guid := range samples {
    fmt.Printf("GUID: %s | Valid: %t\n", guid, isValidGUID(guid))
}

}

Casos de Uso del Mundo Real

Claves Primarias de Base de Datos: Útiles para identificar registros en bases de datos distribuidas.
Identificadores de Recursos de API: Los servicios RESTful usan GUIDs para recursos como /user/3f2504e0-4f89-11d3-9a0c-0305e82c3301.
Tokens de Sesión: Las aplicaciones web usan frecuentemente UUIDs para rastrear sesiones seguras.
IDs de Dispositivos o Archivos: Muchos servicios de almacenamiento en la nube usan GUIDs para referenciar archivos de forma única.

Consejos Pro

Use siempre minúsculas o mayúsculas de forma consistente al mostrar GUIDs.
Regex valida solo el formato, no si el GUID es verdaderamente único.
Nunca exponga GUIDs relacionados con recursos sensibles en URLs no seguras.
Use regex para la validación pero bibliotecas como github.com/google/uuid para la generación.
Para pruebas en lote, use el Probador de Regex en Go para probar diferentes formatos rápidamente.

Cómo Validar GUIDs en JavaScript

Si necesita asegurarse de que sus cadenas se ajusten al formato GUID estándar en JavaScript, puede usar una expresión regular para una verificación rápida. Aquí hay una función directa para validar GUIDs en JavaScript:

function isValidGUID(input) {
// Regex matches an optional opening brace, 8 hex digits, 3 groups of 4 hex digits, then 12 hex digits, ending with an optional closing brace.
Const guidPattern = /^[{]?[0-9a-fA-F]{8}(-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}[}]?$/;
return guidPattern.test(input);
}

Validar GUIDs en Python

Al igual que en Go, a menudo necesitará asegurarse de que sus GUIDs estén en el formato correcto dentro de sistemas basados en Python. El módulo re de Python hace que la validación con regex sea simple y confiable:

import re
def is_valid_guid(guid):
pattern = r'^[0-9a-fA-F]{8}-(?:[0-9a-fA-F]{4}-){3}[0-9a-fA-F]{12}$'
return bool(re.match(pattern, guid))

Implementar la Validación de GUID en Java

Si trabaja en Java y necesita validar GUIDs, puede usar expresiones regulares de manera similar a Go. Las clases integradas Pattern y Matcher de Java facilitan esta tarea:

import java.util.regex.Pattern;
public class GuidValidator {
private static final Pattern GUID_PATTERN = Pattern.compile(
"^[{]?[0-9a-fA-F]{8}(-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}[}]?$"
);
public static boolean isValidGuid(String guid) {
    return guid != null &amp;&amp; GUID_PATTERN.matcher(guid).matches();
}

}