Traitement des chaînes et expressions régulières en langage Go

Traitement des chaînes et expressions régulières dans le langage Go

Le langage Go est un langage fortement typé, dans lequel la chaîne est un type de données couramment utilisé. Dans le processus de développement d’un programme, le traitement des chaînes est une partie très importante. Cet article présentera les opérations de base du traitement des chaînes et l'utilisation des expressions régulières dans le langage Go.

1. Traitement des chaînes

Le type de chaîne du langage Go est une séquence d'octets immuable, c'est-à-dire qu'une fois créée, sa valeur ne peut pas être modifiée. Les chaînes peuvent être représentées à l’aide de guillemets doubles ou de backticks. Les séquences d'échappement peuvent être utilisées dans des chaînes entre guillemets, telles que
pour représenter un caractère de nouvelle ligne. Les chaînes backtick peuvent contenir n’importe quel caractère, y compris du texte multiligne et des caractères d’échappement.

1. Concaténation de chaînes

Vous pouvez utiliser l'opérateur + en langage Go pour connecter deux chaînes, par exemple :

str1 := "Hello"
str2 := "world"
str3 := str1 + " " + str2
fmt.Println(str3) // output: Hello world

2. Séparation de chaînes

Vous pouvez utiliser la fonction Split() dans le package de chaînes pour diviser la chaîne . Par exemple :

str := "Hello world"
arr := strings.Split(str, " ")
fmt.Println(arr) // output: [Hello world]

3. Remplacement de chaîne

Vous pouvez utiliser la fonction Replace() dans le package strings pour remplacer des chaînes. Par exemple :

str := "Hello world"
newStr := strings.Replace(str, "world", "Go", 1)
fmt.Println(newStr) // output: Hello Go

4. Recherche de chaînes

Vous pouvez utiliser la fonction Index() ou Contains() dans le package de chaînes pour rechercher des chaînes. Par exemple :

str := "Hello world"
index := strings.Index(str, "world")
fmt.Println(index) // output: 6
isContains := strings.Contains(str, "Hello")
fmt.Println(isContains) // output: true

5. Conversion de casse de chaîne

Vous pouvez utiliser les fonctions ToUpper() et ToLower() dans le package strings pour convertir la casse d'une chaîne. Par exemple :

str := "Hello WORLD"
newStr1 := strings.ToUpper(str)
newStr2 := strings.ToLower(str)
fmt.Println(newStr1) // output: HELLO WORLD
fmt.Println(newStr2) // output: hello world

2. Expressions régulières

L'expression régulière est un outil utilisé pour décrire des chaînes et peut déterminer si une chaîne correspond à un certain modèle. Le langage Go possède un package d'expressions régulières intégré qui peut utiliser des expressions régulières pour faire correspondre et manipuler des chaînes.

1. Métacaractères de base des expressions régulières

• . : correspond à n'importe quel caractère
• d : correspond à des nombres, équivalent à [0-9]
• D : correspond à n'importe quel caractère à l'exception des nombres, équivalent à ¹
• w : Correspond aux lettres et aux chiffres, équivalent à [a-zA-Z0-9]
• W : Correspond à tous les caractères qui ne sont pas des lettres et des chiffres, équivalent à ²
• s : Correspond aux caractères d'espacement tels que les espaces ou tabulations
• S : correspond aux caractères autres que les espaces
• ^ : correspond au début de la chaîne
• $ : correspond à la fin de la chaîne
• [] : correspond à n'importe quel caractère entre crochets
• [^] : correspond à n'importe quel caractère caractère à l'exception des caractères entre crochets

2. Fonction d'expression régulière

• MatchString(pattern string, s string) bool : Détermine si la chaîne s correspond à l'expression régulière du modèle Le modèle
• FindString(pattern string, s string) string : recherche la première sous-chaîne qui correspond au modèle d'expression régulière du modèle dans la chaîne s et renvoie la sous-chaîne
• FindAllString(pattern string, s string, n int ) []string : recherche toutes les sous-chaînes correspondant au modèle d'expression régulière du modèle dans la chaîne s et renvoie une tranche de chaîne. n représente le nombre maximum de correspondances
• ReplaceAllString(pattern string, s string, repl string) string : utilisez la chaîne repl pour remplacer toutes les sous-chaînes de la chaîne s qui correspondent au modèle d'expression régulière du modèle et renvoie la chaîne remplacée

3. Exemples des expressions régulières

package main

import (
    "fmt"
    "regexp"
)

func main() {
    str1 := "abc123"
    str2 := "Hello world"
    pattern1 := `d+`
    pattern2 := `wo..d`
    isMatch1, _ := regexp.MatchString(pattern1, str1)
    isMatch2, _ := regexp.MatchString(pattern2, str2)
    fmt.Println(isMatch1) // output: true
    fmt.Println(isMatch2) // output: true
    
    re := regexp.MustCompile(pattern1)
    match1 := re.FindString(str1)
    fmt.Println(match1) // output: 123
    
    matchAll1 := re.FindAllString(str1, -1)
    fmt.Println(matchAll1) // output: [123]
    
    repl := re.ReplaceAllString(str1, "456")
    fmt.Println(repl) // output: abc456
    
    re2 := regexp.MustCompile(pattern2)
    match2 := re2.FindString(str2)
    fmt.Println(match2) // output: world
}

Résumé

Cet article présente l'utilisation du traitement des chaînes et des expressions régulières dans le langage Go. Le traitement des chaînes comprend des opérations de base telles que la concaténation, le fractionnement, le remplacement, la recherche et la conversion de casse. Les expressions régulières peuvent être utilisées pour faire correspondre et manipuler des chaînes qui correspondent à un certain modèle. La maîtrise de ces opérations peut faciliter le traitement des chaînes et améliorer l'efficacité du développement des programmes.

---

1. 0-9 ↩
2. a-zA-Z0-9 ↩

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!