小编icz*_*cza的帖子

在Python中,您可以这样做:

"File {file} had error {error}".format(file=myfile, error=err)

或这个:

"File %(file)s had error %(error)s" % {"file": myfile, "error": err}

在Go中,最简单的选项是:

fmt.Sprintf("File %s had error %s", myfile, err)

这不允许你交换格式字符串中的参数顺序,你需要为I18N做.Go 确实有这个template包,需要这样的东西:

package main

import (
    "bytes"
    "text/template"
    "os"
)

func main() {
    type Params struct {
        File string
        Error string
    }

    var msg bytes.Buffer

    params := &Params{
        File: "abc",
        Error: "def",
    }

    tmpl, _ := template.New("errmsg").Parse("File {{.File}} has error {{.Error}}")
    tmpl.Execute(&msg, params)
    msg.WriteTo(os.Stdout)
}

这似乎是一个很长的路要走错误信息.是否有更合理的选项允许我提供独立于订单的字符串参数？

在C++中,我可以使用memset初始化一个带有一些值的数组:

const int MAX = 1000000;
int is_prime[MAX]

memset(is_prime, 1, sizeof(is_prime))

什么memset做的,粗略地可以被描述为填充数组有一些价值,但这样做真的非常快.

我可以这样做is_prime := make([]int, 1000000),但这将创建一个全0的切片,以我可以使用的类似方式new([1000000]int),但没有任何东西可以让我创建一个包含所有1或任何其他非零元素的数组/切片.

当然我可以使用循环用稍后的值填充它,但主要目的memset是它比循环更快.

那么Go程序员是否有memset模拟(将数组初始化为某些非零值的快速方法)？

简单的问题:如何使用json包解析Go中的字符串(这是一个数组)？

type JsonType struct{
    Array []string
}

func main(){
    dataJson = `["1","2","3"]`
    arr := JsonType{}
    unmarshaled := json.Unmarshal([]byte(dataJson), &arr.Array)
    log.Printf("Unmarshaled: %v", unmarshaled)
}

可能是一个愚蠢的事情,但有点卡在它上面......

无法修剪"["字符串中的字符,我尝试输出的内容:

package main

import (
    "fmt"
    "strings"
)

func main() {
    s := "this[things]I would like to remove"
    t := strings.Trim(s, "[")

    fmt.Printf("%s\n", t)   
}

// output: this[things]I would like to remove

去操场

还尝试了所有这些,没有成功:

s := "this [ things]I would like to remove"
t := strings.Trim(s, " [ ")
// output: this [ things]I would like to remove


s := "this [ things]I would like to remove"
t := strings.Trim(s, "[")
// output: this [ things]I would …

我有一个包含要完成的工作的切片,以及在完成所有操作时将包含结果的切片.以下是我的一般过程的草图:

var results = make([]Result, len(jobs))
wg := sync.WaitGroup{}
for i, job := range jobs {
    wg.Add(1)
    go func(i int, j job) {
        defer wg.Done()
        var r Result = doWork(j)
        results[i] = r
    }(i, job)
}
wg.Wait()
// Use results

它似乎工作,但我没有彻底测试,我不确定它是否安全.一般来说,让多个goroutine写入任何内容都不会让我感觉良好,但在这种情况下,每个goroutine都限制在切片中自己的索引,这是预先分配的.

我想替代方案是通过渠道收集结果,但由于结果顺序很重要,这似乎相当简单.以这种方式写入切片元素是否安全？

在Go中,以下工作(注意一个地图的使用有一个返回,另一个有两个返回)

package main

import "fmt"

var someMap = map[string]string { "some key": "hello" }

func main() {
    if value, ok := someMap["some key"]; ok {
        fmt.Println(value)
    }

    value := someMap["some key"]
    fmt.Println(value)
}

但是,我不知道如何用自己的功能做同样的事情.是否有可能与可选的返回类似的行为map？

例如:

package main

import "fmt"

func Hello() (string, bool) {
    return "hello", true
}

func main() {
    if value, ok := Hello(); ok {
        fmt.Println(value)
    }

    value := Hello()
    fmt.Println(value)
}

不会编译(由于错误multiple-value Hello() in single-value context)...有没有办法使这个语法适用于该函数Hello()？

我一直在读Go,并且难以想到这个基本问题.

在Go中,很明显切片更灵活,当您需要一系列数据时,通常可以使用切片代替数组.

阅读大部分文档,他们似乎鼓励开发人员只使用切片而不是数组.我得到的印象就像创作者可以简单地设计数组来调整大小,并且没有整个切片部分.事实上,这样的设计会使语言更容易理解,甚至可能鼓励更多惯用的代码.

那么为什么创作者首先允许阵列呢？何时使用数组而不是切片？是否有过的情况下在片数组的使用将是引人注目的？

当我查阅官方文档(http://golang.org/doc/effective_go.html#arrays)时,我发现的唯一有用的部分是:

在规划内存的详细布局时,数组很有用,有时可以帮助避免分配,但主要是它们是切片的构建块.

他们接着讨论了数组如何作为值的昂贵,以及如何用指针模拟C风格的行为.即便如此,他们还是明确地推荐了阵列部分:

但即便是这种风格也不是惯用的Go.改为使用切片.

那么,什么是"规划内存的详细布局"或"帮助避免分配"这些切片不适合的一些真实示例？

我有一个字节数组,固定长度为4.

token := make([]byte, 4)

我需要将每个字节设置为一个随机字节.我怎么能这样做,在最有效的事情？math/rand就我而言,这些方法不提供随机字节功能.

也许有内置的方式,或者我应该生成随机字符串并将其转换为字节数组？

我知道打印int我们可以使用%d,string我们可以使用,%s 但我们仍然可以%v用来打印它们.那么如果我总是用它%v来打印呢？如果我这样做会发生什么问题？

我有以下测试方法,它使用从包导入的函数.

import x.y.z

func abc() {
    ...
    v := z.SomeFunc()
    ... 
}

是否有可能SomeFunc()在golang中嘲笑？