golang regular exclusion

Golang is one of the most popular programming languages ​​today. It is widely welcomed and used because of its simplicity, ease of learning, efficiency and speed. Among them, regular expressions are a very important part and are also widely used in Golang programming. But sometimes we need to exclude some unwanted results when matching. This article will introduce how to use regular expressions to exclude operations in Golang.

1. Basic syntax

Using regular expressions in Golang is very simple. We only need to use the functions provided by the regexp package to operate. The following is a simple example:

package main

import (
    "fmt"
    "regexp"
)

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

Run the above code, the output result is [hello hello], that is, all matching strings in the string are printed out.

But sometimes we don’t need all the matching results, we need to exclude some of them.

2. Exclude content in regular expressions

There are two ways to exclude content in regular expressions: affirm the following assertion and negate the preceding assertion.

1. Positive follow-up assertion

Positive follow-up assertion means that only the content after a specific string will be matched. For example, we only need to exclude all words ending with "Golang" in the string, and we can use the following code:

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)
}

In this code, S represents a word, (?=sGolang ) means that the word is followed by a space and the end of the word Golang. This regular expression uses a positive line assertion, which means that it only matches the words before Golang when matching.

Run the above code, the output result is [hello world, hello], that is, all words ending with "Golang" are excluded.

2. Negative lookahead assertion

Negative lookahead assertion means that only the content in front of a specific string will be matched. For example, we only need to exclude all words starting with "hello" in the string, and we can use the following code:

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)
}

In this code, (? means Does not match words starting with "hello", <code> S represents a word. This regular expression uses a negative lookahead assertion, which means that it only matches words that do not start with "hello" when matching.

Run the above code, the output result is [world, Golang], that is, all words starting with "hello" are excluded.

3. Summary

Using regular expressions to perform exclusion operations in Golang can be achieved by using positive lookbehind assertions and negative lookahead assertions. Through simple examples, we can find that the flexibility of regular expressions can be reflected in exclusion operations. Especially when dealing with some complex string problems, regular expressions are undoubtedly a very efficient solution. At the same time, we also need to pay attention to carefully considering the existing string rules and expression combination methods when writing regular expressions.

The above is the detailed content of golang regular exclusion. For more information, please follow other related articles on the PHP Chinese website!