如何检查字符串中的一个或多个符号

Question

我正在努力寻找一种方法来检查字符串是否包含一个或多个如下所示的符号：#}{&*"(£)虽然检查一个或多个这些符号相当简单，但我不打算构建和维护列表或可能条目的字典。有没有一种方法可以检查一个字符串是否包含一个或多个任何非标准符号，最好使用标准库？具体来说，我正在寻找任何不是a-zA-Z0-9根据我的问题将被视为非标准符号的东西。

Answer 1

在 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(`#}{&*"(£)`))

}

游乐场：https://play.golang.org/p/Y2KjDcHSupH

输出：

true
false

---

Go 编程语言规范

开关语句

“Switch”语句提供多路执行。将表达式或类型说明符与“开关”内的“案例”进行比较，以确定要执行的分支。

表情开关

在表达式 switch 中，switch 表达式被求值，case 表达式不需要是常量，从左到右和从上到下求值；第一个等于 switch 表达式的触发执行关联案例的语句；其他情况被跳过。如果没有匹配的案例并且存在“默认”案例，则执行其语句。最多可以有一个 default case，它可以出现在“switch”语句的任何地方。

switch 表达式之前可以有一个简单的语句，该语句在计算表达式之前执行。

失败声明

“fallthrough”语句将控制转移到表达式“switch”语句中下一个 case 子句的第一条语句。它只能用作此类子句中的最终非空语句。

switch b := s[i]; {

    // ...

}

相当于

switch b := s[i]; true {

    // ...

}

相当于

{

    b := s[i]

    switch true {

        // ...

    } 

}

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

评估案例表达式并与 进行比较true。如果没有一个是真的，则default采取。

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

    }

}

Answer 2

由于白名单可以很容易地定义为正则表达式，因此使用regexp.MatchString：

package main

import (

    "fmt"

    "regexp"

)

var (

    whitelist  = "A-Za-z0-9"

    disallowed = regexp.MustCompile(fmt.Sprintf("[^%s]+", whitelist))

)

func main() {

    fmt.Println(IsValid("foobar007"))

    fmt.Println(IsValid("foo%bar&007"))

}

func IsValid(s string) bool {

    return !disallowed.MatchString(s)

}