0Pricing
Go Academy · Lección

Consejos de rendimiento

Reutilice las expresiones regulares compiladas

Consejos de rendimiento es una lección gratuita de Go Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Go Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Go Academy incluye 4 lecciones en total.

Compilar tiene un coste

Convertir una cadena de patrón en una expresión regular utilizable requiere trabajo. Hacerlo en cada llamada desperdicia tiempo, especialmente en bucles o rutas críticas.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("[0-9]+")
    fmt.Println(re.MatchString("x9"))
}

Compile una vez y reutilice a menudo

La regla de oro es compilar un patrón una vez y reutilizar el *regexp.Regexp. Lo habitual es almacenarlo en una variable a nivel de paquete.

package main

import (
    "fmt"
    "regexp"
)

var numRe = regexp.MustCompile("[0-9]+")

func hasNumber(s string) bool {
    return numRe.MatchString(s)
}

func main() {
    fmt.Println(hasNumber("a1"))
    fmt.Println(hasNumber("abc"))
}

Evite compilar en bucles

No llame nunca a MustCompile dentro de un bucle. Compile antes del bucle y use el mismo valor en cada iteración.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("[a-z]+")
    inputs := []string{"go", "123", "rust"}
    for _, s := range inputs {
        fmt.Println(s, re.MatchString(s))
    }
}

Regexp se puede compartir de forma segura

Un *regexp.Regexp compilado es seguro para el uso concurrente por varias goroutines. Una sola instancia global puede servir para todas ellas.

package main

import (
    "fmt"
    "regexp"
)

var re = regexp.MustCompile("go")

func main() {
    fmt.Println(re.MatchString("golang"))
}

A veces strings es más rápido

Para una subcadena literal fija, strings.Contains es más rápido que una expresión regular. Use expresiones regulares solo cuando necesite la potencia real de los patrones.

package main

import (
    "fmt"
    "strings"
)

func main() {
    fmt.Println(strings.Contains("hello world", "world"))
}

Prefiera patrones anclados

Anclar el patrón con ^ permite que el motor falle rápidamente cuando el inicio no coincide, en lugar de explorar toda la cadena.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("^https?://")
    fmt.Println(re.MatchString("http://site"))
    fmt.Println(re.MatchString("see http://x"))
}

Limite la cantidad de coincidencias

Cuando solo necesite unas pocas coincidencias, pase un valor pequeño de n a los métodos Find-all en lugar de -1 para detener la búsqueda antes.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("[0-9]+")
    fmt.Println(re.FindAllString("1 2 3 4 5", 2))
}

Tenga cuidado con los patrones de retroceso

El motor RE2 de Go evita el retroceso catastrófico, pero los patrones demasiado amplios, como .*, aún pueden explorar más de lo necesario. Sea específico.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    broad := regexp.MustCompile(".*=.*")
    precise := regexp.MustCompile("[a-z]+=[0-9]+")
    fmt.Println(broad.MatchString("x=1"), precise.MatchString("x=1"))
}

Escape la entrada dinámica

Si un patrón incluye texto proporcionado por el usuario, escápelo con regexp.QuoteMeta para que los caracteres especiales se traten literalmente.

package main

import (
    "fmt"
    "regexp"
)

func main() {
    user := "a.b"
    re := regexp.MustCompile(regexp.QuoteMeta(user))
    fmt.Println(re.MatchString("a.b"))
    fmt.Println(re.MatchString("axb"))
}

Almacene en caché los patrones compilados

Si los patrones se generan en tiempo de ejecución, guarde los compilados en un mapa cuya clave sea la cadena del patrón para evitar recompilar el mismo patrón.

package main

import (
    "fmt"
    "regexp"
)

var cache = map[string]*regexp.Regexp{}

func get(p string) *regexp.Regexp {
    if re, ok := cache[p]; ok {
        return re
    }
    re := regexp.MustCompile(p)
    cache[p] = re
    return re
}

func main() {
    fmt.Println(get("[0-9]+").MatchString("7"))
}

Integrarlo todo

Un validador bien optimizado compila una sola vez, ancla el patrón y se comparte entre todas las llamadas.

package main

import (
    "fmt"
    "regexp"
)

var emailRe = regexp.MustCompile("^[a-z0-9]+@[a-z]+\\.[a-z]+$")

func main() {
    fmt.Println(emailRe.MatchString("me@site.com"))
}

Comprobación rápida

¿Cuál es el consejo más importante para mejorar el rendimiento de las expresiones regulares?

Repaso: consejos de rendimiento

Ha aprendido a usar expresiones regulares de forma eficiente:

  • Compile una vez con MustCompile y reutilice el resultado; es seguro para el uso concurrente.
  • Prefiera strings para subcadenas fijas; ancle los patrones y limite la cantidad de coincidencias.
  • Escape la entrada dinámica con QuoteMeta y almacene en caché los patrones generados en tiempo de ejecución.
package main

import (
    "fmt"
    "regexp"
)

var re = regexp.MustCompile("^\\d{4}$")

func main() {
    for _, s := range []string{"1234", "12"} {
        fmt.Println(s, re.MatchString(s))
    }
}

Preguntas frecuentes

¿La lección «Consejos de rendimiento» es gratis?

Sí — el texto completo de «Consejos de rendimiento» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Go Academy, actualiza a CoddyKit PRO. El curso de Go Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Consejos de rendimiento»?

Reutilice las expresiones regulares compiladas Practicas Go Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Go Academy?

No se requiere experiencia previa. Go Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Consejos de rendimiento»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Go Academy?

Sí. Cada lección de Go Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Conceptos básicos de regexp
  2. Búsqueda y extracción
  3. Reemplazo de texto
  4. Consejos de rendimiento
← Volver a Go Academy