对于测试非空字符串(在Go中)，哪种方法是最好的(最常用的)?
if len(mystring) > 0 { }
Or:
if mystring != "" { }
还是别的什么?
当前回答
检查长度是一个很好的答案，但您也可以解释一个“空”字符串，它也只是空白。严格来说不是空的，但如果你愿意检查:
package main
import (
"fmt"
"strings"
)
func main() {
stringOne := "merpflakes"
stringTwo := " "
stringThree := ""
if len(strings.TrimSpace(stringOne)) == 0 {
fmt.Println("String is empty!")
}
if len(strings.TrimSpace(stringTwo)) == 0 {
fmt.Println("String two is empty!")
}
if len(stringTwo) == 0 {
fmt.Println("String two is still empty!")
}
if len(strings.TrimSpace(stringThree)) == 0 {
fmt.Println("String three is empty!")
}
}
其他回答
我认为== ""更快，更易读。
package main
import(
"fmt"
)
func main() {
n := 1
s:=""
if len(s)==0{
n=2
}
fmt.Println("%d", n)
}
当DLV调试操场。go cmp与len(s)和==""我明白了 S == ""情况
playground.go:6 0x1008d9d20 810b40f9 MOVD 16(R28), R1
playground.go:6 0x1008d9d24 e28300d1 SUB $32, RSP, R2
playground.go:6 0x1008d9d28 5f0001eb CMP R1, R2
playground.go:6 0x1008d9d2c 09070054 BLS 56(PC)
playground.go:6 0x1008d9d30* fe0f16f8 MOVD.W R30, -160(RSP)
playground.go:6 0x1008d9d34 fd831ff8 MOVD R29, -8(RSP)
playground.go:6 0x1008d9d38 fd2300d1 SUB $8, RSP, R29
playground.go:7 0x1008d9d3c e00340b2 ORR $1, ZR, R0
playground.go:7 0x1008d9d40 e01f00f9 MOVD R0, 56(RSP)
playground.go:8 0x1008d9d44 ff7f05a9 STP (ZR, ZR), 80(RSP)
playground.go:9 0x1008d9d48 01000014 JMP 1(PC)
playground.go:10 0x1008d9d4c e0037fb2 ORR $2, ZR, R0
len (s) = = 0的情况
playground.go:6 0x100761d20 810b40f9 MOVD 16(R28), R1
playground.go:6 0x100761d24 e2c300d1 SUB $48, RSP, R2
playground.go:6 0x100761d28 5f0001eb CMP R1, R2
playground.go:6 0x100761d2c 29070054 BLS 57(PC)
playground.go:6 0x100761d30* fe0f15f8 MOVD.W R30, -176(RSP)
playground.go:6 0x100761d34 fd831ff8 MOVD R29, -8(RSP)
playground.go:6 0x100761d38 fd2300d1 SUB $8, RSP, R29
playground.go:7 0x100761d3c e00340b2 ORR $1, ZR, R0
playground.go:7 0x100761d40 e02300f9 MOVD R0, 64(RSP)
playground.go:8 0x100761d44 ff7f06a9 STP (ZR, ZR), 96(RSP)
playground.go:9 0x100761d48 ff2700f9 MOVD ZR, 72(RSP)
playground.go:9 0x100761d4c 01000014 JMP 1(PC)
playground.go:10 0x100761d50 e0037fb2 ORR $2, ZR, R0
playground.go:10 0x100761d54 e02300f9 MOVD R0, 64(RSP)
playground.go:10 0x100761d58 01000014 JMP 1(PC)
playground.go:6 0x104855d2c 09070054 BLS 56(PC)
引用
这似乎是不成熟的微优化。编译器可以为这两种情况或至少为这两种情况生成相同的代码
if len(s) != 0 { ... }
and
if s != "" { ... }
因为语义显然是相等的。
只是补充更多的评论
主要是关于如何做性能测试。
我用以下代码进行了测试:
import (
"testing"
)
var ss = []string{"Hello", "", "bar", " ", "baz", "ewrqlosakdjhf12934c r39yfashk fjkashkfashds fsdakjh-", "", "123"}
func BenchmarkStringCheckEq(b *testing.B) {
c := 0
b.ResetTimer()
for n := 0; n < b.N; n++ {
for _, s := range ss {
if s == "" {
c++
}
}
}
t := 2 * b.N
if c != t {
b.Fatalf("did not catch empty strings: %d != %d", c, t)
}
}
func BenchmarkStringCheckLen(b *testing.B) {
c := 0
b.ResetTimer()
for n := 0; n < b.N; n++ {
for _, s := range ss {
if len(s) == 0 {
c++
}
}
}
t := 2 * b.N
if c != t {
b.Fatalf("did not catch empty strings: %d != %d", c, t)
}
}
func BenchmarkStringCheckLenGt(b *testing.B) {
c := 0
b.ResetTimer()
for n := 0; n < b.N; n++ {
for _, s := range ss {
if len(s) > 0 {
c++
}
}
}
t := 6 * b.N
if c != t {
b.Fatalf("did not catch empty strings: %d != %d", c, t)
}
}
func BenchmarkStringCheckNe(b *testing.B) {
c := 0
b.ResetTimer()
for n := 0; n < b.N; n++ {
for _, s := range ss {
if s != "" {
c++
}
}
}
t := 6 * b.N
if c != t {
b.Fatalf("did not catch empty strings: %d != %d", c, t)
}
}
结果是:
% for a in $(seq 50);do go test -run=^$ -bench=. --benchtime=1s ./...|grep Bench;done | tee -a log
% sort -k 3n log | head -10
BenchmarkStringCheckEq-4 150149937 8.06 ns/op
BenchmarkStringCheckLenGt-4 147926752 8.06 ns/op
BenchmarkStringCheckLenGt-4 148045771 8.06 ns/op
BenchmarkStringCheckNe-4 145506912 8.06 ns/op
BenchmarkStringCheckLen-4 145942450 8.07 ns/op
BenchmarkStringCheckEq-4 146990384 8.08 ns/op
BenchmarkStringCheckLenGt-4 149351529 8.08 ns/op
BenchmarkStringCheckNe-4 148212032 8.08 ns/op
BenchmarkStringCheckEq-4 145122193 8.09 ns/op
BenchmarkStringCheckEq-4 146277885 8.09 ns/op
有效变体通常不会达到最快时间，不同变体的最高速度之间只有最小的差异(约0.01ns/op)。
如果我看完整的日志，try之间的差异大于benchmark函数之间的差异。
而且似乎没有任何可测量的差异之间 BenchmarkStringCheckEq和BenchmarkStringCheckNe 或BenchmarkStringCheckLen和BenchmarkStringCheckLenGt 即使后面的变体应该inc c 6次而不是2次。
通过添加带有修改过的测试或内循环的测试，您可以尝试获得对相同性能的信心。这样更快:
func BenchmarkStringCheckNone4(b *testing.B) {
c := 0
b.ResetTimer()
for n := 0; n < b.N; n++ {
for _, _ = range ss {
c++
}
}
t := len(ss) * b.N
if c != t {
b.Fatalf("did not catch empty strings: %d != %d", c, t)
}
}
这并不是更快:
func BenchmarkStringCheckEq3(b *testing.B) {
ss2 := make([]string, len(ss))
prefix := "a"
for i, _ := range ss {
ss2[i] = prefix + ss[i]
}
c := 0
b.ResetTimer()
for n := 0; n < b.N; n++ {
for _, s := range ss2 {
if s == prefix {
c++
}
}
}
t := 2 * b.N
if c != t {
b.Fatalf("did not catch empty strings: %d != %d", c, t)
}
}
这两种变体通常比主要测试之间的差异更快或更慢。
使用具有相关分布的字符串生成器生成测试字符串(ss)也很好。长度也是可变的。
所以我对go中测试空字符串的主要方法之间的性能差异没有任何信心。
我可以有信心地说，不测试空字符串比测试空字符串更快。而且测试空字符串比测试一个字符字符串(前缀变体)更快。
假设空格和所有前导和后面的空格都应该被删除:
import "strings"
if len(strings.TrimSpace(s)) == 0 { ... }
因为: Len("") //为0 Len(" ") //一个空格为1 Len(" ") //两个空格为2
这两种样式都在Go的标准库中使用。
if len(s) > 0 { ... }
可以在strconv包中找到:http://golang.org/src/pkg/strconv/atoi.go
if s != "" { ... }
可以在encoding/json包中找到:http://golang.org/src/pkg/encoding/json/encode.go
两者都是惯用的，而且都足够清楚。这更多的是个人品味和清晰度的问题。
Russ Cox在golang-nuts的帖子中写道:
使代码清晰的那个。 如果我要查看元素x，我通常会写 len(s) >x，即使x == 0，但如果我关心 "是这个特定的字符串"我倾向于写s == "" 假设一个成熟的编译器会编译是合理的 Len (s) == 0和s == ""变成了同样高效的代码。 .．. 使代码清晰。
正如Timmmm的回答所指出的，在这两种情况下，Go编译器确实生成了相同的代码。
