Coincidencia usando expresiones regulares en GoLang

Regexp es la forma abreviada de expresiones regulares. La gente generalmente confunde regexp con regex, y eso es obvio porque otros lenguajes de programación como Python usan el término regex para su biblioteca de expresiones regulares, pero Go usa regexp y es importante recordarlo como regexp ya que es el nombre del paquete de expresiones regulares disponible. en Go con funciones preconstruidas.

Coincidencia – ¿Qué es?

Bueno, independientemente del origen, todos los niños pueden haber experimentado al menos una situación en sus vidas en la que pueden haber usado ropa a juego o accesorios a juego y han dicho: «Oye, amigo, usamos ropa a juego», «mismo pellizco», etc. ¿Cómo decidieron exactamente esos niños si algo coincide con lo otro? ¡Es simple! Cuando dos cosas son exactamente iguales, o una parte de una es exactamente igual a otra cosa, decimos que esas dos cosas son una coincidencia o una subcoincidencia, respectivamente. Entonces, profundicemos en el concepto de coincidencia en GoLang.

Coincidencia usando expresiones regulares en GoLang

regexp (expresiones regulares) tiene que ver con la coincidencia de strings/patrones. Cada función, cada parte de las funciones de expresión regular en algún lugar requiere una coincidencia de texto. Veamos algunas funciones que son importantes para emparejar directa o indirectamente. 

Consulte la Tabla 1.1 para obtener más información sobre los métodos utilizados para compilar y almacenar un objeto regex. Consulte la Tabla 1.2 para obtener más información sobre las funciones que implementan directamente la interfaz Match y nada más. Consulte la Tabla 1.3 . para obtener más información sobre los otros métodos predefinidos de expresiones regulares que realizan operaciones como buscar, reemplazar, etc., que implementan indirectamente la interfaz Match primero y luego realizan su operación. 

¿Dudas de cómo lo hacen? Bien, considere este ejemplo: si su madre le pide que busque algo en la cocina con solo proporcionar una descripción del objeto, ¿qué hará? Irás a la cocina y luego buscarás objetos que coincidan con la descripción de tu madre y luego los recogerás y se los darás. Esto significa que simplemente coincidiste con la descripción primero y le informaste a tu madre (aunque tu enfoque principal era encontrarlo, indirectamente tenías que coincidir para encontrarlo). ¿Entiendo? Ahora echemos un vistazo más profundo a estas funciones.
 

Tabla 1.1. Métodos de compilación

Tabla 1.2. Funciones de coincidencia directa que implementan la interfaz Match.

Tabla 1.3. Otras funciones que realizan diferentes operaciones pero implementan indirectamente la interfaz Match para sus respectivas operaciones.

Nota:Hemos estado mencionando una copia de ____, modificada y no modificada ___. Esto se debe a que los cambios no se realizan directamente en la string de origen. En su lugar, se pasa una copia de forma predeterminada y se realizan modificaciones en la copia.

Como mencionamos anteriormente, la expresión regular en sí misma es un conjunto de operaciones que se ocupan de la coincidencia de strings. Entonces, directa o indirectamente, casi todas las funciones en el paquete regexp se ocupan de la coincidencia. No hay necesidad de entrar en pánico ya que todas estas operaciones son completamente en tiempo real y fáciles de entender.

Ejemplos:

Código 1: Implementación directa de métodos Match

package main
  
import (
    f "fmt"
    "regexp"
)
  
func main() {
    f.Println("--------Reference strings--------\n")
  
    name := "My name is Geeks for geeks."
    f.Println(name)
  
    profession := "I am a computer science portal for geeks."
    f.Println(profession)
  
    message := "You can find anything here, if not tell us and we'll add it for you!"
    f.Println(message)
  
    //---------------------------------------------------
    f.Println("\n--------Match functions--------")
    //-------------------------------------------
  
    obj, err := regexp.Match("[gG]e*k.*", []byte(name))
    f.Println("\nregex.Match returns ->", obj,
        "and error(if any) --->", err)
  
    //-------------------------------------------
    obj, err = regexp.Match("[gG]e*k.*", []byte(profession))
    f.Println("\nregex.Match returns ->", obj,
        "and error(if any) --->", err)
  
    //-------------------------------------------
    obj, err = regexp.MatchString("Geek.*", message)
    f.Println("\nregex.MatchString returns ->", obj,
        "and error(if any) --->", err)
  
    //-------------------------------------------
}

Comando para ejecutar en el símbolo del sistema:

:/Directory where the go file is present/> go run (file_name).go

Producción:

--------Reference strings--------

My name is Geeks for geeks.
I am a computer science portal for geeks.
You can find anything here, if not tell us and we'll add it for you!

--------Match functions--------

regex.Match returns -> true and error(if any) ---> <nil>

regex.Match returns -> true and error(if any) ---> <nil>

regex.MatchString returns -> false and error(if any) ---> <nil>

Código 2: Implementación directa de los métodos Match

package main
  
import (
    f "fmt"
    "io"
    "regexp"
)
  
func main() {
    obj := regexp.MustCompile("ee")
    var r io.RuneReader
    s := []byte("Hello GeekS, 1234")
    f.Println("Initial byte array -----> ", s)
    f.Println("Initial string ---------> ", string(s))
    f.Println("MatchReader ------------> ", obj.MatchReader(r))
    ex := []byte("NEW")
    f.Println("ReplaceAllFunc( ) work in progress...")
    s = obj.ReplaceAllFunc(s, func(s []byte) []byte {
        if true {
            return ex
        }
        return s
    })
    f.Println("Final string -----------> ", string(s))
    f.Println("Final byte array -------> ", s)
}

Comando para ejecutar en el símbolo del sistema:

:/Directory where the go file is present/> go run (file_name).go

Producción:

Array de bytes inicial —–> [72 101 108 108 111 32 71 101 101 107 83 44 32 49 50 51 52]
String inicial ———> Hello GeekS, 1234
MatchReader ————> false
ReplaceAllFunc( ) trabajo en progreso…
Final string ———–> Hola GNEWkS, 1234
Conjunto de bytes final ——-> [72 101 108 108 111 32 71 78 69 87 107 83 44 32 49 50 51 52]

Código 3: Implementación indirecta de métodos Match

package main
  
import (
    f "fmt"
    "regexp"
)
  
func main() {
    f.Println("--------Reference strings--------\n")
  
    name := "My name is Geeks for geeks."
    f.Println(name)
  
    profession := "I am a computer science portal for geeks."
    f.Println(profession)
  
    message := "You can find anything here, if not tell us and we'll add it for you!"
    f.Println(message)
    //---------------------------------------------------------
    f.Println("\n--------Compiling functions--------\n")
    //-------------------------------------------
  
    musComp := regexp.MustCompile("[gG]ee.?")
    f.Println("Initialized the regexp object to musComp...")
  
    //---------------------------------------------------------
    f.Println("\n--------Find functions--------\n")
    //-------------------------------------------
  
    f.Println("mustCompile.Find -----------------------> ",
        musComp.Find([]byte(name)))
  
    f.Println("mustCompile.FindString -----------------> ",
        musComp.FindString(name))
  
    f.Println("mustCompile.FindSubmatch ---------------> ",
        musComp.FindSubmatch([]byte(name)))
  
    f.Println("mustCompile.FindStringSubmatch ---------> ",
        musComp.FindStringSubmatch(name))
    //-------------------------------------------
    f.Println("mustCompile.FindAll --------------------> ",
        musComp.FindAll([]byte(name), -1))
  
    f.Println("mustCompile.FindAllString --------------> ",
        musComp.FindAllString(name, -1))
  
    f.Println("mustCompile.FindAllSubmatch ------------> ",
        musComp.FindAllSubmatch([]byte(name), -1))
  
    f.Println("mustCompile.FindAllStringSubmatch ------> ",
        musComp.FindAllStringSubmatch(name, -1))
    //-------------------------------------------
    f.Println("mustCompile.FindIndex ------------------> ",
        musComp.FindIndex([]byte(name)))
  
    f.Println("mustCompile.FindStringIndex ------------> ",
        musComp.FindStringIndex(name))
  
    f.Println("mustCompile.FindSubmatchIndex ----------> ",
        musComp.FindSubmatchIndex([]byte(name)))
  
    f.Println("mustCompile.FindStringSubmatchIndex ----> ",
        musComp.FindStringSubmatchIndex(name))
    //-------------------------------------------
    f.Println("mustCompile.FindAllIndex ---------------> ",
        musComp.FindAllIndex([]byte(name), -1))
  
    f.Println("mustCompile.FindAllStringIndex ---------> ",
        musComp.FindAllStringIndex(name, -1))
  
    f.Println("mustCompile.FindAllSubmatchIndex -------> ",
        musComp.FindAllSubmatchIndex([]byte(name), -1))
  
    f.Println("mustCompile.FindAllStringSubmatchIndex -> ",
        musComp.FindAllStringSubmatchIndex(name, -1))
    //------------------------------------------------------------
    f.Println("\n--------Replace functions--------\n")
    //-------------------------------------------
  
    f.Println("mustCompile.ReplaceAll -----------------> ",
        musComp.ReplaceAll([]byte(name), []byte("Bow bow!")))
  
    f.Println("mustCompile.ReplaceAllStirng -----------> ",
        musComp.ReplaceAllString(name, "Bow bow!"))
  
    f.Println("mustCompile.ReplaceAllLiteral ----------> ",
        musComp.ReplaceAllLiteral([]byte(name), []byte("T")))
  
    f.Println("mustCompile.ReplaceAllLiteralString ----> ",
        musComp.ReplaceAllLiteralString(name, "T"))
    //------------------------------------------------------------
}

Comando para ejecutar en el símbolo del sistema:

:/Directory where the go file is present/> go run (file_name).go

Producción:

——–Strings de referencia——–

Mi nombre es Frikis para frikis.
Soy un portal de informática para geeks.
¡Puedes encontrar cualquier cosa aquí, si no, dínoslo y lo agregaremos por ti!

——–Funciones de compilación——–

Inicializó el objeto regexp a musComp…

——–Encontrar funciones——–

mustCompile.Find ———————–> [71 101 101 107]
mustCompile.FindString —————–> Geek
mustCompile.FindSubmatch —————> [[71 101 101 107]]
mustCompile.FindStringSubmatch — ——> [Geek]
mustCompile.FindAll ——————–> [[71 101 101 107] [103 101 101 107]]
mustCompile.FindAllString ————–> [Geek geek]
mustCompile.FindAllSubmatch ——— —> [[[71 101 101 107]] [[103 101 101 107]]]
mustCompile.FindAllStringSubmatch ——> [[Geek] [geek]]
mustCompile.FindIndex ——————> [11 15]
mustCompile. FindStringIndex ————> [11 15]
mustCompile.FindSubmatchIndex ———-> [11 15]
mustCompile.FindStringSubmatchIndex —-> [11 15]
mustCompile.FindAllIndex —————> [[11 15] [21 25] ]
mustCompile.FindAllStringIndex ———> [[11 15] [21 25]]
mustCompile.FindAllSubmatchIndex ——-> [[11 15] [21 25]]
mustCompile.FindAllStringSubmatchIndex -> [[11 15] [21 25]]

——–Reemplazar funciones——–

debe sercompile.replaceAll —————> [77 121 32 110 97 109 101 32 105 115 32 66 111 119 32 98 111 119 33 115 32 102 111 114 32 66 111 111 119 32 98 111 119 33 115 46]
Debe competir . ———–> Mi nombre es Bow bow!s para Bow bow!s.
mustCompile.ReplaceAllLiteral ———-> [77 121 32 110 97 109 101 32 105 115 32 84 115 32 102 111 114 32 84 115 46]
mustCompile.ReplaceAllLiteralString —-> Mi nombre es Ts por Ts.