小编Vol*_*ker的帖子

在go中构建一个简单的对象时,这些替代方案之间有什么区别？

func NewGender(value string) Gender {
    return Gender{strings.TrimSpace(value)}
}

func NewGender(value string) *Gender {
    return &Gender{strings.TrimSpace(value)}
}

我正在尝试使用 Google OAuth2，并且在我的刷新令牌到期时遇到了这个问题。它来自 2018-10-15 15:42:37.5989253 +1100 AEDT m=+3610.688917401

我知道这是一种时间格式，但我找不到任何有关m=+任何地方的信息。是否由 Google 内部使用？我试图用它来解析它，time.RFC3339但你可以猜到，它忽略了m=+. 它说

解析时间“2018-10-15 15:42:37.5989253 +1100 AEDT m=+3610.688917401”为“2006-01-02T15:04:05Z07:00”：无法解析：“15.AE+07:00”：35.AE+1059210DT1001 3610.688917401" 为 "T"

那么m=+ 时间字符串中的这个是什么？

我一直认为好的单元测试,是独立的测试.通过'独立',我的意思是当函数'A'使用'B',并且我们测试函数'A'时,我们模拟/存根'B'以防'B'不能正常工作它不会失败'A' .

但是当我们检查golang包的来源时,原则是不受尊重的.

例如,让我们在url包中检查url.go和url_test.go:

url.go:

func parseQuery(m Values, query string) (err error) {
    for query != "" {
    ...
    key, err1 := QueryUnescape(key)
    ...

url_test.go:

func TestParseQuery(t *testing.T) {
    for i, test := range parseTests {
        form, err := ParseQuery(test.query)
        ...

我们可以看到parseQuery使用QueryUnescape.在测试QueryUnescape中没有以任何方式存根.因此,如果QueryUnescape工作错误,parseQuery测试将失败.

所以包的作者并不总是满足'独立'单元测试的要求.在这种情况下不理解这个原则的原因是什么,是否有一些规则允许程序员接受这种形式的单元测试？

在python中编写独立测试之后,我对编写完美测试(这对golang设计代码影响很大)和结果之间的平衡感到困惑.

我想开发 Go 使用 pycharm。我的golang版本是1.4.2。我的pycharm版本是4.5.2。我的操作系统是Mac OSX 10.10.3。我在我的Mac上配置了GOROOT和GOPATH。如图：

我从这个url下载了 golang 插件。但是当我安装插件并重新启动 pycharm 时，IDE 显示没有 gopath 和 goroot。消息：

怎么了？

package main

import (
    "fmt"
    "log"
)

func main() {
    a := []string{"abc", "edf"}
    log.Println(fmt.Sprint(a))
}

上面的Go程序将打印以下输出,切片值在方括号内"[]".

2009/11/10 23:00:00 [abc edf]

我想知道在源代码中[]添加到格式化字符串中的位置.

我检查了源代码src/fmt/print.go文件,但找不到执行此操作的确切代码行.

任何人都可以提供一个提示吗？

在Golang中进行转换[]uint32和转换的最有效方式(性能)是[]byte什么？

例如:

func main() {
   source := []uint32{1,2,3}
   dest := make([]byte, 4 * len(source))
   // source to dest
   // ?
   check := len(dest)/4
   // dest to check
   // ?
}

我有一个解决方案,但它包括div,mod和multiply

package main
import (
    "fmt"
)
func main() {
    source := []uint32{1,2,3}
    dest := make([]byte, 4*len(source))
    fmt.Println(source)
    for start, v := range source {
       dest[start*4+0] = byte(v % 256)
       dest[start*4+1] = byte(v / 256 % 256)
       dest[start*4+2] = byte(v / 256 / 256 …

我正在尝试按照最新版本（v2.2.1）使用 Fabric 测试网络教程进行操作，一切正常，直到我尝试使用./network.sh deployCC.

我得到以下输出：

deploying chaincode on channel 'mychannel'
executing with the following
- CHANNEL_NAME: mychannel
- CC_NAME: basic
- CC_SRC_PATH: NA
- CC_SRC_LANGUAGE: go
- CC_VERSION: 1.0
- CC_SEQUENCE: 1
- CC_END_POLICY: NA
- CC_COLL_CONFIG: NA
- CC_INIT_FCN: NA
- DELAY: 3
- MAX_RETRY: 5
- VERBOSE: false
Determining the path to the chaincode
asset-transfer-basic
Vendoring Go dependencies at ../asset-transfer-basic/chaincode-go/
~/fabric-samples/asset-transfer-basic/chaincode-go ~/fabric-samples/test-network
~/fabric-samples/test-network
Finished vendoring Go dependencies
Using organization 1
+ peer lifecycle chaincode package …

众所周知，以大写字母开头的字段是公共字段，非大写字母开头的字段是私有字段。但Golang也支持匿名字段。例如：

type myType struct {
  string
}

这些字段是为Embedding设计的。但这个领域是公共的还是私有的？

关于select渠道声明的简短程序.

package main

import "fmt"

func fibonacci(c, quit chan int) {
    x, y := 0, 1
    for {
        select {
        case c <- x:
            x, y = y, x+y
        case s := <-quit:
            fmt.Println("quit =",s)
            return
        }
    }
}

func main() {
    c := make(chan int)
    quit := make(chan int)
    go func() {
        for i := 0; i < 10; i++ {
            fmt.Println(<-c)
        }
        quit <- 9
    }()
    fibonacci(c, quit)
}

上面代码的结果:

0
1
1
2
3
5 …

我正在学习Go编程并尝试测试以下average函数:

func average(xs []float64) float64 {
    total := 0.0
    for _, v := range xs {
        total += v
    }
    return total / float64(len(xs))
}

我尝试通过以下方式生成一片随机浮点数:

var xs []float64
for n := 0; n < 10; n++ {
    xs[n] = rand.Float64()
}

但是,我得到了

panic: runtime error: index out of range

题:

1. 如何在Golang中生成一片随机数？
2. 是表达式还是函数调用,就像xs := []float64 { for ... }切片文字中允许的一样？

这个main()功能是goroutine吗？例如,我已经看到了如下所示的崩溃堆栈跟踪,这让我问:

goroutine 1 [running]: main.binarySearch(0x0, 0x61, 0x43,
0xc420043e70, 0x19, 0x19, 0x10)
     /home/---/go/src/github.com/----/sumnum.go:22 +0x80 main.main()
     /home/---/go/src/github.com/---/sumnum.go:13 +0xc1 exit status 2

考虑以下代码 gopl.io/ch2/echo4

package main

import (
    "flag"
    "fmt"
    "strings"
)

var n = flag.Bool("n", false, "omit trailing newline")
var sep = flag.String("s", " ", "separator")

func main() {
    flag.Parse()
    fmt.Print(strings.Join(flag.Args(), *sep))
    if !*n {
        fmt.Println()
    }
}

我感兴趣的是为什么变量n和sep是指向标志变量的指针，而不是普通的变量类型。

回购/通用/logger.go

package common
var once sync.Once
var Logger *logrus.Logger
func InitLogger() {
   once.Do(func() {
        Logger = logrus.New()
        Logger.Out = filename // file opened and *file assigned here for logging
    })

    return Logger
}

回购/setup_test.go

package main
func setUp() {
    common.InitLogger()
    fmt.Println(common.Logger) // prints some pointer related things which means logger is initialized
}
func TestMain(m *testing.M) {
    fmt.Println("Starting Test...")
    setUp()
    code := m.Run()
    common.APILog.Println("Finishing Main...")
    os.Exit(code)
}

回购/车辆/品牌/马鲁蒂/汽车/mycar_test.go

package car
func TestMyFunc(t *testing.T) {
    **t.Log(common.Logger)               // When i run go …