golang 二种字符串的连天格局

作者:ca88编程

go语言中支持的字符串拼接的不二诀要有诸五种,这里就来罗列一下

1. 一直运用运算符

  1. func BenchmarkAddStringWithOperator(b *testing.B) {
  2. hello := "hello"
  3. world := "world"
  4. for i := 0; i < b.N; i {
  5. _ = hello "," world
  6. }
  7. }

golang 里面包车型客车字符串都以不可变的,每一遍运算都会生出三个新的字符串,所以会时有产生相当的多临时的不算的字符串,不唯有未有用,还或然会给 gc 带来额外的承负,所以质量非常不好

金玉锦绣格局

判别文件是或不是存在

fs.exists("test", function (exists) {
    console.log(exists);
    // 如果存在回调为TRUE,反之为FALSE
});

结论

一般对于一丢丢的字符串拼接能够一向用 来连接,不过最棒的措施也许Builder。

4. buffer.WriteString()

  1. func BenchmarkAddStringWithBuffer(b *testing.B) {
  2. hello := "hello"
  3. world := "world"
  4. for i := 0; i < 1000; i {
  5. var buffer bytes.Buffer
  6. buffer.WriteString(hello)
  7. buffer.WriteString(",")
  8. buffer.WriteString(world)
  9. _ = buffer.String()
  10. }
  11. }

这么些比较优良,能够算作可变字符使用,对内部存款和储蓄器的增长也可以有优化,假诺能预估字符串的长短,还是能够用 buffer.Grow() 接口来安装 capacity

3. strings.Join()

func BenchmarkAddStringWithJoin(b *testing.B) {
    hello := "hello"
    world := "world"
    for i := 0; i < b.N; i   {
        _ = strings.Join([]string{hello, world}, ",")
    }
}

join会先依据字符串数组的内容,总计出三个拼凑之后的尺寸,然后申请对应大小的内部存款和储蓄器,贰个一个字符串填入,在已有二个数组的情景下,这种频率会异常高,可是本来从没,去社团那一个数指标代价也十分的大

1、完毕目的的原型承袭

var util = require("util");
function Parent(name, age) {
    this.name = name;
    this.age = age;
    this.sayHello = function () {
        console.log("hello");
    }
}
Parent.prototype.sayName = function () {
    console.log(this.name);
}
function Child(name, age) {
    // 构造函数继承
    Parent.apply(this, arguments);
}
util.inherits(Child, Parent); // 对象的原型继承
var dad = new Parent("老爸", 48);
var son = new Child("儿子", 28);
son.sayHello();
son.sayName();

常用的字符串拼接方法

1.最常用的方法自然是 连接五个字符串。那与python类似,可是由于golang中的字符串是不可变的品种,由此用 连接会时有产生三个新的字符串对作用有影响。

s1 := "字符串"s2 := "拼接"s3 := s1   s2fmt.Print //s3 = "打印字符串"

2.次之种办法运用sprintf函数,即便不会像直接使用 那样产生不经常字符串。不过成效也不高

s1 := "字符串"s2 := "拼接"s3 := fmt.Sprintf("%s%s", s1, s2) //s3 = "打印字符串"

3.第三种方法是用Join函数,这里大家须求先引进strings包工夫调用Join函数。Join函数会先依据字符串数组的开始和结果,总结出二个凑合之后的长度,然后申请对应大小的内部存储器,多个贰个字符串填入,在已有二个数组的场地下,这种频率会非常高,若无的话成效也不高。

//需要先导入strings包s1 := "字符串"s2 := "拼接"//定义一个字符串数组包含上述的字符串var str []string = []string{s1, s2}//调用Join函数s3 := strings.Join(str, "")fmt.Print

4.第二个办法是调用buffer.WriteString函数,这种办法的习性就要大大优于上边的了。

//需要先导入bytes包s1 := "字符串"s2 := "拼接"//定义Buffer类型var bt bytes.Buffer向bt中写入字符串bt.WriteStringbt.WriteString//获得拼接后的字符串s3 := bt.String()

5.第5个措施是用buffer.Builder,那么些主意和下面的大概,可是官方提出用这几个,使用情势和地点基本同样

//需要先导入Strings包s1 := "字符串"s2 := "拼接"var build strings.Builderbuild.WriteStringbuild.WriteStrings3 := build.String()

参照链接

go语言字符串拼接品质剖析: 

转发请阐明出处 
正文链接:http://hatlonely.github.io/2018/057%4/golang字符串的二种连接格局/

不久前在做品质优化,有个函数里面包车型地铁耗费时间特别长,看里面包车型客车操作多数是局地字符串拼接的操作,而字符串拼接在 golang 里面其实有很各个贯彻。

修改文件名

fs.rename("test", "newTest", function (err) {
    if (err) {
        console.error(err);
    } else {
        console.log("重命名成功");
    }
});

落到实处格局

参照链接

go语言字符串拼接品质解析: http://herman.asia/efficient-string-concatenation-in-go

转发请申明出处
正文链接:http://hatlonely.github.io/2018/055%4/golang字符串的二种连接格局/

node.js的一对常用模块

近年在做质量优化,有个函数里面包车型客车耗费时间专程长,看当中的操作很多是有个别字符串拼接的操作,而字符串拼接在 golang 里面其实有很各类落成。

2. fmt.Sprintf()

func BenchmarkAddStringWithSprintf(b *testing.B) {
    hello := "hello"
    world := "world"
    for i := 0; i < b.N; i   {
        _ = fmt.Sprintf("%s,%s", hello, world)
    }
}

其中选拔 []byte 完结,不像直接运算符这种会发出相当多有的时候的字符串,然而在那之中的逻辑比较复杂,有许多外加的判断,还用到了 interface,所以品质亦非很好

发出事件

emit

要害结论

  1. 在已有字符串数组的场地,使用 strings.Join() 能有比较好的品质
  2. 在一部分性格供给较高的场合,尽量利用 buffer.WriteString() 以博取更加好的性质
  3. 属性须求不太高的地方,直接动用运算符,代码更轻巧清晰,能取得相比好的可读性
  4. 要是急需拼接的不只是字符串,还会有数字之类的别的部需要求的话,能够考虑 fmt.Sprintf

着重结论

  1. 在已有字符串数组的地方,使用 strings.Join() 能有比较好的性质
  2. 在有个别性格须要较高的场子,尽量选拔 buffer.WriteString() 以博取越来越好的习性
  3. 属性须要不太高的场合,直接选拔运算符,代码更简短清晰,能获取相比较好的可读性
  4. 若是须求拼接的不可是字符串,还应该有数字之类的别的需要的话,能够设想 fmt.Sprintf

实例

var events = require("events"); 
var util = require("util");
// 创建事件的发布者以及事件的观察者
function Girl () {
    // 假设女孩饿了
};

function Boy (name, response) {
    this.name = name;
    this.response = response;
};

util.inherits(Girl, events);  // 继承来自于events原型上的方法

var goddess = new Girl();
var boy1 = new Boy("男生1", function () {
    console.log("点饿了么");
});
var boy2 = new Boy("男生2", function () {
    console.log("上美团点外卖");
});
var boy3 = new Boy("男生3", function () {
    console.log("带你去吃饭");
});
// 绑定事件监听者
goddess.on("ele", boy1.response);
goddess.addListener("ele", boy3.response); // on和addListener是等价的
goddess.once("ele", boy3.response);        // once 只绑定一次 
goddess.emit("ele");  // emit 表示发出事件

2. fmt.Sprintf()

  1. func BenchmarkAddStringWithSprintf(b *testing.B) {
  2. hello := "hello"
  3. world := "world"
  4. for i := 0; i < b.N; i {
  5. _ = fmt.Sprintf("%s,%s", hello, world)
  6. }
  7. }

里面使用 []byte 完成,不像直接运算符这种会发生许多一时的字符串,然则里面包车型大巴逻辑相比复杂,有广大相当的决断,还用到了 interface,所以品质亦非很好

1. 一向利用运算符

func BenchmarkAddStringWithOperator(b *testing.B) {
    hello := "hello"
    world := "world"
    for i := 0; i < b.N; i   {
        _ = hello   ","   world
    }
}

golang 里面包车型客车字符串都是不可变的,每一趟运算都会产生一个新的字符串,所以会发出比相当多前段时间的失效的字符串,不止未有用,还有或然会给 gc 带来特其余负责,所以品质很差

文本操作

3. strings.Join()

  1. func BenchmarkAddStringWithJoin(b *testing.B) {
  2. hello := "hello"
  3. world := "world"
  4. for i := 0; i < b.N; i {
  5. _ = strings.Join([]string{hello, world}, ",")
  6. }
  7. }

join会先依照字符串数组的剧情,总括出叁个拼凑之后的长短,然后申请对应大小的内部存款和储蓄器,一个一个字符串填入,在已有二个数组的情况下,这种频率会异常高,不过本来从没,去组织这几个数量的代价也相当大

测量检验结果

BenchmarkAddStringWithOperator-8            50000000             30.3 ns/op
BenchmarkAddStringWithSprintf-8             5000000              261  ns/op
BenchmarkAddStringWithJoin-8                30000000             58.7 ns/op
BenchmarkAddStringWithBuffer-8              2000000000           0.00 ns/op

其一是在自家的团结 Mac 上面跑的结果,go 版本 go version go1.8 darwin/amd64,这么些结果仅供参照他事他说加以考察,依然要以实际生产条件的值为准,代码在:https://github.com/hatlonely/hellogolang/blob/master/internal/buildin/string_test.go

ca88编程,写入文件

// writeFile中的参数类似readFile
// 其中第三个参数为配置参数:flag表示的是一个读取的模式 不写默认是w为写入,a是追加写入,r为读取
fs.writeFile("test.txt", "我是写入进去的内容", {flag: "a"}, function (err) {
    if (err) {
        console.error(err);
    }
    console.log("写入成功了");
});

测量检验结果

  1. BenchmarkAddStringWithOperator-8 50000000 30.3 ns/op
  2. BenchmarkAddStringWithSprintf-8 5000000 261 ns/op
  3. BenchmarkAddStringWithJoin-8 30000000 58.7 ns/op
  4. BenchmarkAddStringWithBuffer-8 2000000000 0.00 ns/op

本条是在笔者的友善 Mac 上面跑的结果,go 版本 go version go1.8 darwin/amd64,这几个结果仅供参照他事他说加以考察,依旧要以实际生产条件的值为准,代码在:

4. buffer.WriteString()

func BenchmarkAddStringWithBuffer(b *testing.B) {
    hello := "hello"
    world := "world"
    for i := 0; i < 1000; i   {
        var buffer bytes.Buffer
        buffer.WriteString(hello)
        buffer.WriteString(",")
        buffer.WriteString(world)
        _ = buffer.String()
    }
}

本条相比特出,能够算作可变字符使用,对内部存款和储蓄器的加强也可能有优化,固然能预估字符串的长度,还足以用 buffer.Grow() 接口来安装 capacity

个人博客搭建实现,接待我们来拜会哦
黎默丶lymoo的博客

通过字符串创制

var buff = new Buffer("我是缓存区");

本文由ca88发布,转载请注明来源

关键词: ca88网址 程序员 技术 字符串 golang