我正在努力寻找一种方法来检查字符串是否包含一个或多个如下所示的符号:#}{&*"(£)检查这些符号中的一个或多个我不希望构建和维护可能条目的列表或字典。有没有一种方法可以检查字符串是否包含一个或多个任何 go 中的非标准符号最好使用标准库？

具体来说，我正在寻找任何不是 a-zA-Z0-9 的东西，根据我的问题，这些东西将被视为非标准符号。

最佳答案

在 Go 中，编写一个简单的函数。例如，

package main

import (
    "fmt"
)

func isStandard(s string) bool {
    for i := 0; i < len(s); i++ {
        switch b := s[i]; {
        case b >= 'a' && b <= 'z':
            continue
        case b >= 'A' && b <= 'Z':
            continue
        case b >= '0' && b <= '9':
            continue
        default:
            return false
        }
    }
    return true
}

func main() {
    fmt.Println(isStandard(`ABCabc123`))
    fmt.Println(isStandard(`#}{&*"(£)`))
}

Playground :https://play.golang.org/p/Y2KjDcHSupH

输出:

true
false

The Go Programming Language Specification

Switch statements

"Switch" statements provide multi-way execution. An expression or type specifier is compared to the "cases" inside the "switch" to determine which branch to execute.

Expression switches

In an expression switch, the switch expression is evaluated and the case expressions, which need not be constants, are evaluated left-to-right and top-to-bottom; the first one that equals the switch expression triggers execution of the statements of the associated case; the other cases are skipped. If no case matches and there is a "default" case, its statements are executed. There can be at most one default case and it may appear anywhere in the "switch" statement.

The switch expression may be preceded by a simple statement, which executes before the expression is evaluated.

Fallthrough statements

A "fallthrough" statement transfers control to the first statement of the next case clause in an expression "switch" statement. It may be used only as the final non-empty statement in such a clause.

switch b := s[i]; {
    // ...
}

相当于

switch b := s[i]; true {
    // ...
}

相当于

{
    b := s[i]
    switch true {
        // ...
    } 
}

简单语句 b := s[i] 将 b 声明为 switch { } 语句 block 局部变量。

案例表达式被评估并与 true 进行比较。如果没有一个为真，则采用默认。

与 C 不同，Go 需要明确的 fallthrough。

ASCII 是 Unicode UTF-8 的一个子集。由于标准字符都是ASCII，我们可以简单地比较字节。

这是一个简单的基准。

输出:

$ go test standard_test.go -bench=. -benchmem
BenchmarkPeterSO-8    200000000       8.10 ns/op    0 B/op    0 allocs/op
BenchmarkJubobs-8      10000000     222 ns/op       0 B/op    0 allocs/op
$ 

standard_test.go:

package main

import (
    "regexp"
    "testing"
)

func isStandard(s string) bool {
    for i := 0; i < len(s); i++ {
        switch b := s[i]; {
        case b >= 'a' && b <= 'z':
            continue
        case b >= 'A' && b <= 'Z':
            continue
        case b >= '0' && b <= '9':
            continue
        default:
            return false
        }
    }
    return true
}

func BenchmarkPeterSO(b *testing.B) {
    std := `ABCabc123`
    for N := 0; N < b.N; N++ {
        isStandard(std)
    }
}

var (
    whitelist  = "A-Za-z0-9"
    disallowed = regexp.MustCompile("[^" + whitelist + " ]+")
)

func IsValid(s string) bool {
    return !disallowed.MatchString(s)
}

func BenchmarkJubobs(b *testing.B) {
    std := `ABCabc123`
    for N := 0; N < b.N; N++ {
        IsValid(std)
    }
}

关于string - 如何检查字符串中的一个或多个符号，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/54204625/