Golang regelmäßiger Ausschluss

Golang ist heutzutage eine der beliebtesten Programmiersprachen. Sie wird aufgrund ihrer Einfachheit, einfachen Erlernbarkeit, Effizienz und Geschwindigkeit weithin begrüßt und verwendet. Unter ihnen sind reguläre Ausdrücke ein sehr wichtiger Teil und werden auch häufig in der Golang-Programmierung verwendet. Aber manchmal müssen wir beim Abgleich einige unerwünschte Ergebnisse ausschließen. In diesem Artikel wird erläutert, wie Sie reguläre Ausdrücke verwenden, um Vorgänge in Golang auszuschließen.

1. Grundlegende Syntax

Die Verwendung regulärer Ausdrücke in Golang ist sehr einfach. Zum Betrieb müssen wir nur die vom Paket regexp bereitgestellten Funktionen verwenden . Das Folgende ist ein einfaches Beispiel: regexp包提供的函数进行操作。下面是一个简单的例子：

package main

import (
    "fmt"
    "regexp"
)

func main() {
    str := "hello world, hello Golang"
    re := regexp.MustCompile("hello")
    result := re.FindAllString(str, -1)
    fmt.Println(result)
}

运行上面的代码，输出的结果是[hello hello]，也就是将字符串中所有匹配的字符串都打印出来。

但有时候我们并不需要所有的匹配结果，我们需要排除其中一部分。

二、在正则表达式中排除内容

在正则表达式中排除内容有两种方式：肯定后行断言和否定前行断言。

1.肯定后行断言

肯定后行断言表示只有在特定字符串后面的内容才会被匹配。例如，我们只需要排除字符串中所有以“Golang”结尾的单词，可以使用如下代码：

package main

import (
    "fmt"
    "regexp"
)

func main() {
    str := "hello world, hello Golang"
    re := regexp.MustCompile(`S+?(?=sGolang)`)
    result := re.FindAllString(str, -1)
    fmt.Println(result)
}

这段代码中，S+表示一个单词，(?=sGolang)表示该单词后面跟着一个空格和Golang单词结尾。该正则表达式使用了肯定后行断言，就是在匹配的时候只匹配Golang前面的单词。

运行上述代码，输出的结果是[hello world, hello]，即所有以“Golang”结尾的单词被排除。

2.否定前行断言

否定前行断言表示只有在特定字符串前面的内容才会被匹配。例如，我们只需要排除字符串中所有以“hello”开头的单词，可以使用如下代码：

package main

import (
    "fmt"
    "regexp"
)

func main() {
    str := "hello world, hello Golang"
    re := regexp.MustCompile(`(?<!hellos)S+`)
    result := re.FindAllString(str, -1)
    fmt.Println(result)
}

这段代码中，(?<!hellos)表示不匹配以“hello”开头的单词，S+表示一个单词。该正则表达式使用了否定前行断言，就是在匹配的时候只匹配不以“hello”开头的单词。

运行上述代码，输出的结果是[world, Golang]rrreee

Führen Sie den obigen Code aus. Das Ausgabeergebnis ist [hello hallo], dh alle übereinstimmenden Zeichenfolgen in der Zeichenfolge werden ausgegeben .

Aber manchmal brauchen wir nicht alle passenden Ergebnisse, sondern müssen einige davon ausschließen.

2. Inhalte in regulären Ausdrücken ausschließen #🎜🎜##🎜🎜# Es gibt zwei Möglichkeiten, Inhalte in regulären Ausdrücken auszuschließen: Bestätigen Sie die folgende Behauptung und negieren Sie die vorhergehende Behauptung. #🎜🎜##🎜🎜#1. Positive nachgestellte Behauptung #🎜🎜##🎜🎜# Positive nachgestellte Behauptung bedeutet, dass nur der Inhalt nach einer bestimmten Zeichenfolge abgeglichen wird. Beispielsweise müssen wir nur alle Wörter in der Zeichenfolge ausschließen, die mit „Golang“ enden, und können den folgenden Code verwenden: #🎜🎜#rrreee#🎜🎜#In diesem Code steht S+ für a Wort, (?=sGolang ) bedeutet, dass auf das Wort ein Leerzeichen und das Ende des Golang-Worts folgen. Dieser reguläre Ausdruck verwendet eine positive Zeilenzusicherung, was bedeutet, dass er beim Abgleich nur mit den Wörtern vor Golang übereinstimmt. #🎜🎜##🎜🎜#Führen Sie den obigen Code aus. Das Ausgabeergebnis ist [hello world, hallo], d. h. alle Wörter, die mit „Golang“ enden, werden ausgeschlossen. #🎜🎜##🎜🎜#2. Negative Lookahead-Behauptung #🎜🎜##🎜🎜# Negative Lookahead-Behauptung bedeutet, dass nur der Inhalt vor einer bestimmten Zeichenfolge abgeglichen wird. Beispielsweise müssen wir nur alle Wörter in der Zeichenfolge ausschließen, die mit „hello“ beginnen, und können den folgenden Code verwenden: #🎜🎜#rrreee#🎜🎜#In diesem Code ist (?<! hellos) code> bedeutet nicht übereinstimmende Wörter, die mit „Hallo“ beginnen, <code> S+ bedeutet ein Wort. Dieser reguläre Ausdruck verwendet eine negative Lookahead-Behauptung, was bedeutet, dass beim Abgleich nur Wörter abgeglichen werden, die nicht mit „Hallo“ beginnen. #🎜🎜##🎜🎜#Führen Sie den obigen Code aus. Das Ausgabeergebnis ist [world, Golang], d. h. alle Wörter, die mit „Hallo“ beginnen, werden ausgeschlossen. #🎜🎜##🎜🎜#3. Zusammenfassung#🎜🎜##🎜🎜#Die Verwendung regulärer Ausdrücke zum Ausführen von Ausschlussoperationen in Golang kann durch die Verwendung positiver Lookbehind-Behauptungen und negativer Lookahead-Behauptungen erreicht werden. Anhand einfacher Beispiele können wir feststellen, dass sich die Flexibilität regulärer Ausdrücke in Ausschlussoperationen widerspiegeln kann. Insbesondere bei der Behandlung einiger komplexer Zeichenfolgenprobleme sind reguläre Ausdrücke zweifellos eine sehr effiziente Lösung. Gleichzeitig müssen wir beim Schreiben regulärer Ausdrücke auch darauf achten, die vorhandenen Zeichenfolgenregeln und Ausdruckskombinationsmethoden sorgfältig zu berücksichtigen. #🎜🎜#

Das obige ist der detaillierte Inhalt vonGolang regelmäßiger Ausschluss. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!