当前位置:首页 > Golang杂记 > 正文内容

NewReplacer使用技巧

7个月前 (01-22)Golang杂记463

        上次写博客至今有段时间了,这些日子,认真过,努力过,职场中不管有哪些让人失意或不快的事,终归到底,是自己不够强大。。。

好吧,新的一年,不磨磨唧唧了,一般处理xss漏洞使用正则匹配,再次分享一个golang strings包NewReplacer的方法。

我们先看一个简单的例子:

package main

import (
    "fmt"
    "strings"
)

func main() {
    var str= strings.NewReplacer("hello", "HELLO", "鸠摩智", "老鸠")
    s1 := str.Replace("hello")
    s2 := str.Replace("鸠摩智")
    fmt.Println(s1, s2)
}
//输出 HELLO 老鸠

通过上面的输出大家应该明眼看出来了。我们看下底层相关函数的应用:

// Replacer replaces a list of strings with replacements.
// It is safe for concurrent use by multiple goroutines.
type Replacer struct {
    once   sync.Once // guards buildOnce method
    r      replacer
    oldnew []string
}

// NewReplacer panics if given an odd number of arguments.
func NewReplacer(oldnew ...string) *Replacer {
    if len(oldnew)%2 == 1 {
        panic("strings.NewReplacer: odd argument count")
    }
    return &Replacer{oldnew: append([]string(nil), oldnew...)}
}

// Replace returns a copy of s with all replacements performed.
func (r *Replacer) Replace(s string) string {
    r.once.Do(r.buildOnce)
    return r.r.Replace(s)
}

代码分析

NewReplacer() 使用提供的多组old=>new的字符串,创建并返回一个*Replacer替换程序的指针,Replace() 是返回s的所有替换进行完成后的一个拷贝。

即strings.NewReplacer()是 Golang中的函数从以前的新字符串集列表中返回了新的Replacer。

我们再看个例子:

package main

import (
    "fmt"
    "strings"
)

func main() {
    r := strings.NewReplacer("?", "?", ">", ">")
    fmt.Println(r.Replace("just do it ?, one -> two"))
    // 试下这里输出啥 fmt.Println(r.Replace("鸠摩智")) 
}
//原样输出 just do it ?, one -> two

很容易理解,是吧?这里再说明下一个小注意事项:

替换是按照它们在目标字符串中显示的顺序进行,没有重叠的匹配项。旧的字符串比较按参数顺序进行。神马个意思?

存在重复替换字节

既然是替换,我们肯定也会好奇如果是用重复替换项例如("a","A","a","B")GO会如何处理?

package main

import (
    "fmt"
    "strings"
)

func main() {
    var str1 = strings.NewReplacer("a", "A", "a", "B") // 前面 a->A, 后面a=>B
    s1 := str1.Replace("abc")                          // 一个个字符匹配吧
    fmt.Println(s1)                                    //Abc

    var str2 = strings.NewReplacer("a", "B", "a", "A")
    s2 := str2.Replace("abc")
    fmt.Println(s2) //Bbc

    var str3 = strings.NewReplacer("李莫愁", "小李", "李莫愁", "小李子")
    s3 := str3.Replace("你莫愁啊,不是李莫愁,像是李莫愁")
    fmt.Println(s3)
}
//Abc
//Bbc
//你莫愁啊,不是小李,像是小李

通过上面的测试实例,大家应该发现GO在处理过程中会按照第一次的替换规则为准,也就是匹配规则不覆盖。为了确定 我们看下GO相关部分的源码:

func (b *Replacer) build() replacer {
    oldnew := b.oldnew
    if len(oldnew) == 2 && len(oldnew[0]) > 1 {
        return makeSingleStringReplacer(oldnew[0], oldnew[1])
    }

    allNewBytes := true
    for i := 0; i < len(oldnew); i += 2 {
        if len(oldnew[i]) != 1 {
            return makeGenericReplacer(oldnew)
        }
        if len(oldnew[i+1]) != 1 {
            allNewBytes = false
        }
    }
    //如果都是字节替换,会进入这个if条件
    if allNewBytes {
        r := byteReplacer{}
        for i := range r {
            r[i] = byte(i)
        }
        // The first occurrence of old->new map takes precedence
        // over the others with the same old string.
        for i := len(oldnew) - 2; i >= 0; i -= 2 {
            o := oldnew[i][0]
            n := oldnew[i+1][0]
            r[o] = n
        }
        return &r
    }

    r := byteStringReplacer{toReplace: make([]string, 0, len(oldnew)/2)}
    // The first occurrence of old->new map takes precedence
    // over the others with the same old string.
    //这里就是我们需要的地方,通过这个循环我们发现替换规则是倒序生成的
    //重复的靠前的会覆盖靠后的
    for i := len(oldnew) - 2; i >= 0; i -= 2 {
        o := oldnew[i][0]
        n := oldnew[i+1]
        // To avoid counting repetitions multiple times.
        if r.replacements[o] == nil {
            // We need to use string([]byte{o}) instead of string(o),
            // to avoid utf8 encoding of o.
            // E. g. byte(150) produces string of length 2.
            r.toReplace = append(r.toReplace, string([]byte{o}))
        }
        r.replacements[o] = []byte(n)

    }
    return &r
}

最后特别提醒:如果给定奇数个参数,请记住NewReplacer会抛出panic。

    扫描二维码推送至手机访问。

    版权声明:本文由周伯通的博客发布,如需转载请注明出处。

    本文链接:http://www.zhoubotong.site/post/34.html

    分享给朋友:

    相关文章

    Go 数组合并去重和排序

            Sort包实现了四种基本排序算法:插入排序、归并排序、堆排序和快速排序。 但是这四种排序方法是不公开的,...

    go协程全局变量和局部变量

    大家可能经常会用到类似如下代码片段:package main import (    "fmt"   ...

    Go map定义的几种方式以及修改技巧

    直入正题,我们看下以下代码:package main import (    "encoding/json"  ...

    Go channel 协程为什么是安全的

        Channel跟java/php的 thread不一样,首先channel是协程不是线程。channel不会产生新的线程,自然不会涉及到新的进程或者线程...

    windows下编译linux可执行程序

    开发中,我们可以在Windows下编译Linux 64位可执行程序,首先获取目标系统所支持的构架,比如x86/x64/arm64/arm 等等。在 linux 系统中,我们可以使用命令 uname -...

    发表评论

    访客

    看不清,换一张

    ◎欢迎参与讨论,请在这里发表您的看法和观点。