Go语言切片元素访问复杂度深度解析：O(1)的原理与性能优化实践

package main

import (
    "bytes"
    "fmt"
    "io/ioutil"
    "testing"
)

var (
    Words    [][]byte
    ShortLen = 2
)

// IndexWord 函数用于执行基准测试的核心逻辑
func IndexWord(b *testing.B, words [][]byte) {
    b.ResetTimer() // 重置计时器，排除初始化代码的耗时
    b.StartTimer() // 开始计时
    var char byte
    for i := 0; i < b.N; i++ { // b.N 是基准测试框架确定的迭代次数
        for _, word := range words {
            char = word[len(word)-1] // 访问切片的最后一个元素
        }
    }
    _ = char // 避免编译器优化掉 char 变量的赋值
}

// BenchmarkIndexWordLong 测试访问长切片尾部元素的性能
func BenchmarkIndexWordLong(b *testing.B) {
    words := make([][]byte, len(Words))
    for i, word := range Words {
        words[i] = word // 使用完整的长单词切片
    }
    IndexWord(b, words)
}

// BenchmarkIndexWordShort 测试访问短切片尾部元素的性能
func BenchmarkIndexWordShort(b *testing.B) {
    words := make([][]byte, len(Words))
    for i, word := range Words {
        if len(word) > ShortLen {
            word = word[:ShortLen] // 将单词截断为短切片
        }
        words[i] = word
    }
    IndexWord(b, words)
}

// init 函数在包加载时执行，用于准备测试数据
func init() {
    // 加载一个大型文本文件，例如莎士比亚全集
    text, err := ioutil.ReadFile(`/home/peter/pg100.txt`) // 替换为你的文件路径
    if err != nil {
        panic(err)
    }
    var n, short, long int64
    Words = bytes.Fields(text) // 将文本分割成单词切片
    for i, word := range Words {
        word = bytes.Repeat(word, 600) // 将每个单词重复600次，制造更长的切片以占用更多内存
        Words[i] = word
        n++
        long += int64(len(word))
        shortLen := ShortLen
        if len(word) < ShortLen {
            shortLen = len(word)
        }
        short += int64(shortLen)
    }
    fmt.Println(n, float64(short)/float64(len(Words)), float64(long)/float64(len(Words)))
}

$ go test -bench=IndexWord

904061 2 2690.8131199111563
testing: warning: no tests to run
PASS
BenchmarkIndexWordLong       100      13460864 ns/op
BenchmarkIndexWordShort      100      13439773 ns/op
ok      bench   7.814s

func hasSuffix(s, suffix []byte) bool {
    lenSMinusOne      := len(s)      - 1
    lenSuffixMinusOne := len(suffix) - 1

    var lastSB byte = s[lenSMinusOne]
    var lastSuffixB byte = suffix[lenSuffixMinusOne]

    if lenSMinusOne < lenSuffixMinusOne {
        return false
    } else if lastSB != lastSuffixB {
        return false
    } else {
        for i := 0; i < lenSuffixMinusOne ; i++ {
               if suffix[i] != s[lenSMinusOne-lenSuffixMinusOne+i] {
                        return false
               }
        }
    }
    return true
}

func hasSuffix(s, suffix []byte) bool {
    if len(s) < len(suffix) {
        return false
    }
    // 将 s 截取为其末尾与 suffix 等长的部分
    s = s[len(s)-len(suffix):]
    // 遍历 suffix，并与截取后的 s 进行比较
    for i, x := range suffix {
        if x != s[i] {
            return false
        }
    }
    return true
}

import "bytes"

// bytes.HasSuffix 函数签名
// func HasSuffix(s, suffix []byte) bool

// 使用示例
func checkSuffixWithStdLib(s, suffix []byte) bool {
    return bytes.HasSuffix(s, suffix)
}