在Go中,a string是原始类型,这意味着它是只读的,并且对它的每次操作都将创建一个新字符串.
因此,如果我想在不知道结果字符串长度的情况下多次连接字符串,那么最好的方法是什么？
天真的方式是:
s := ""
for i := 0; i < 1000; i++ {
s += getShortStringFromSomewhere()
}
return s
但这似乎不是很有效.
如何指定unsigned整数类型可表示的最大值？
我想知道如何min在循环中初始化迭代计算某些结构的最小和最大长度.
var minLen uint = ???
var maxLen uint = 0
for _, thing := range sliceOfThings {
if minLen > thing.n { minLen = thing.n }
if maxLen < thing.n { maxLen = thing.n }
}
if minLen > maxLen {
// If there are no values, clamp min at 0 so that min <= max.
minLen = 0
}
这样第一次通过比较,minLen >= n.
我已经看到了三种将内容写入HTTP响应的方法:
func Handler(w http.ResponseWriter, req *http.Request) {
io.WriteString(w, "blabla.\n")
}
和:
func Handler(w http.ResponseWriter, r *http.Request) {
w.Write([]byte("blabla\n"))
}
还有:
fmt.Fprintf(w, "blabla")
他们之间有什么区别？哪一个更喜欢使用？
Go 1.7 beta 1今天早上发布,这是Go 1.7的发行说明草案.KeepAlive包中添加了一个新功能runtime.该文件runtime.KeepAlive给出了一个例子:
type File struct { d int }
d, err := syscall.Open("/file/path", syscall.O_RDONLY, 0)
// ... do something if err != nil ...
p := &FILE{d}
runtime.SetFinalizer(p, func(p *File) { syscall.Close(p.d) })
var buf [10]byte
n, err := syscall.Read(p.d, buf[:])
// Ensure p is not finalized until Read returns.
runtime.KeepAlive(p)
// No more uses of p after this point.
该文件runtime.SetFinalizer还给出了一个解释runtime.KeepAlive:
例如,如果p指向包含文件描述符d的结构,并且p具有关闭该文件描述符的终结器,并且如果函数中最后一次使用p是对syscall.Write的调用(pd,buf,size ),一旦程序进入syscall.Write,则p可能无法访问.终结器可能会在那一刻运行,关闭pd,导致syscall.Write失败,因为它正在写入一个已关闭的文件描述符(或者更糟糕的是,由一个不同的goroutine打开的完全不同的文件描述符).要避免此问题,请在调用syscall.Write之后调用runtime.KeepAlive(p).
令我感到困惑的是,变量 …
s := "some string"
b := []byte(s) // convert string -> []byte
s2 := string(b) // convert []byte -> string
Go string和[]byteGo 之间有什么区别？
何时使用"他"或"她"？
为什么？
bb := []byte{'h','e','l','l','o',127}
ss := string(bb)
fmt.Println(ss)
你好
输出只是"hello",缺乏127,有时我觉得这很奇怪.
我正在使用map [string] string优化代码，其中map的值仅为“ A”或“ B”。因此，我认为显然，map [string] bool更好，因为该地图可容纳约5000万个元素。
var a = "a"
var a2 = "Why This ultra long string take the same amount of space in memory as 'a'"
var b = true
var c map[string]string
var d map[string]bool
c["t"] = "A"
d["t"] = true
fmt.Printf("a: %T, %d\n", a, unsafe.Sizeof(a))
fmt.Printf("a2: %T, %d\n", a2, unsafe.Sizeof(a2))
fmt.Printf("b: %T, %d\n", b, unsafe.Sizeof(b))
fmt.Printf("c: %T, %d\n", c, unsafe.Sizeof(c))
fmt.Printf("d: %T, %d\n", d, unsafe.Sizeof(d))
fmt.Printf("c: %T, %d\n", c, …[]byte转换为的首选方式string是：
var b []byte
// fill b
s := string(b)
在此代码中复制字节片，这在性能很重要的情况下可能会出现问题。
当性能至关重要时，可以考虑执行不安全转换：
var b []byte
// fill b
s := *(*string)(unsafe.Pointer(&b))
我的问题是：使用不安全转换时会出现什么问题？我知道这string应该是不可变的，如果我们改变b，s它也会改变。但仍然：那又怎样？难道这一切都可能发生吗？
Go类型转换在内部如何工作？
类型转换的内存利用率是多少？例如：
var str1 string
str1 = "26MB string data"
byt := []byte(str1)
str2 := string(byt)
每当我键入转换任何变量时，它将消耗更多的内存吗？
我对此很担心，因为当我尝试解组时，会出现“ 致命错误：运行时：内存不足 ”
err = json.Unmarshal([]byte(str1), &obj)
str1值来自HTTP响应，但使用ioutils.ReadAll读取，因此它包含完整的响应。
例:
type MyString string
var s = "very long string"
var ms = MyString(s)
var s2 = string(s)
是(ms或将完成)s2的完整副本？或者它们只是一个字符串结构副本(它将实际值保存在指针中)？如果我们将它传递给函数怎么办？例如:s[]byte(s)
func foo(s MyString){
...
}
foo(ms(s)) // do we copy s here?
我很好奇为什么Golang没有提供[]byte(*string)方法.从性能的角度来看,不会[]byte(string)复制输入参数并增加更多的成本(虽然这看起来很奇怪,因为字符串是不可变的,为什么要复制它们)？
我是Go的新手,非常感谢任何澄清.
在下面的代码中：
c := "fool"
d := []byte("fool")
fmt.Printf("c: %T, %d\n", c, unsafe.Sizeof(c)) // 16 bytes
fmt.Printf("d: %T, %d\n", d, unsafe.Sizeof(d)) // 24 bytes
要确定从CloudFoundry接收JSON数据所需的数据类型，请测试上面的示例代码以了解[]bytevs string类型的内存分配。
string类型变量的预期大小c为1个字节x 4个ascii编码字母= 4个字节，但是大小显示为16个字节。
对于byte类型变量d，GO将字符串作为字符串文字嵌入到可执行程序中。它将在运行时使用该runtime.stringtoslicebyte函数将字符串文字转换为字节片。就像是...[]byte{102, 111, 111, 108}
byte类型变量的预期大小d再次为1字节x 4 ascii值= 4字节，但是变量的大小d显示为24字节，因为它是基础数组容量。
为什么两个变量的大小都不是4个字节？