如何检查字符串中是否有一个或多个符号

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"内的"cases"进行比较,以确定要执行的分支.

表情开关

在表达式开关中,将计算switch表达式,并且从左到右和从上到下计算不必是常量的case表达式; 第一个等于switch表达式的触发器触发相关情况的语句的执行; 其他案例被跳过.如果没有大小写匹配且存在"默认"大小写,则执行其语句.最多只能有一个默认情况,它可能出现在"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)
    }
}