小编icz*_*cza的帖子

为了与大摇大摆进行交互，我需要制作一个自定义BigInt结构，该结构仅能绕过go's big.Int。

type BigInt struct {
    big.Int
}

...
type SpendTx struct {
    SenderID    string       `json:"sender_id,omitempty"`
    RecipientID string       `json:"recipient_id,omitempty"`
    Amount      utils.BigInt `json:"amount,omitempty"`
    Fee         utils.BigInt `json:"fee,omitempty"`
    Payload     string       `json:"payload,omitempty"`
    TTL         uint64       `json:"ttl,omitempty"`
    Nonce       uint64       `json:"nonce,omitempty"`
}

func (t SpendTx) JSON() (output []byte, err error) {
    return json.Marshal(t)
}

我希望SpendTx.JSON()最终会打来电话big.Int.MarshalJSON()，会回来的0。相反，我得到了以下输出：

{"sender_id":"alice","recipient_id":"bob","amount":{},"fee":{},"payload":"Hello World","ttl":10,"nonce":1}

但是我真正想要的是：

{"sender_id":"alice","recipient_id":"bob","amount":10,"fee":10,"payload":"Hello World","ttl":10,"nonce":1}

而且我必须添加以下代码BigInt来做到这一点：

func (b BigInt) MarshalJSON() ([]byte, error) {
    return b.Int.MarshalJSON()
}

但是根据Effective Go的关于嵌入结构的部分，这根本没有必要。为什么big.Int …

我正在使用第3方程序包，该程序包允许您通过导出功能创建某些非导出类型的结构。

package squirrel

type expr struct {
    sql string
    args []interface{}
}

func Expr(sql string, args ...interface{}) expr {
    return expr{sql: sql, args: args}
}

由于该库的其他功能接受数据的方式，我最终得到了这样的映射：

m := map[string]interface{} {
    "col1": 123,
    "col2": "a_string",
    "col3": Expr("now()"),
}

但是由于该库中的函数不同，我需要squirrel.expr从该地图中过滤掉所有内容。

显然，我无法通过以下方式直接声明类型：

filtered := make(map[string]interface{})
for k, v := range m {
    switch v.(type) {
    case squirrel.expr:
        continue
    default:
        filtered[k] = v
    }
}

还有另一种方法可以达到相同的结果吗？

根据下面的链接，我们可以使用>或其他结构从嵌套的xml中获取数据。

如何将嵌套的XML元素解组到数组中？

但是，在不使用这种结束标记的情况下，它不起作用。

码：

package main

import (
    "fmt"
    "encoding/xml"
)

func main() {

    container := Parent{}
    err := xml.Unmarshal([]byte(xml_data), &container)

    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Println(container)  
    }
}

var xml_data = `<Parent>
            <Val>Hello</Val>
                <Child Val="Hello"/>
                <Child Val="Hello"/>
                <Child Val="Hello"/>
        </Parent>`

type Parent struct {
    Val string
    Children Children
}

type Children struct {
    Child []Child
}

type Child struct {
    Val string
}

结果：

{Hello {[]}}

有什么办法吗？

有一个关于输入数据的示例。

{\n    "status": "OK",\n    "status_code": 100,\n    "sms": {\n        "79607891234": {\n            "status": "ERROR",\n            "status_code": 203,\n            "status_text": "\xd0\x9d\xd0\xb5\xd1\x82 \xd1\x82\xd0\xb5\xd0\xba\xd1\x81\xd1\x82\xd0\xb0 \xd1\x81\xd0\xbe\xd0\xbe\xd0\xb1\xd1\x89\xd0\xb5\xd0\xbd\xd0\xb8\xd1\x8f"\n        },\n        "79035671233": {\n            "status": "ERROR",\n            "status_code": 203,\n            "status_text": "\xd0\x9d\xd0\xb5\xd1\x82 \xd1\x82\xd0\xb5\xd0\xba\xd1\x81\xd1\x82\xd0\xb0 \xd1\x81\xd0\xbe\xd0\xbe\xd0\xb1\xd1\x89\xd0\xb5\xd0\xbd\xd0\xb8\xd1\x8f"\n        },\n        "79105432212": {\n            "status": "ERROR",\n            "status_code": 203,\n            "status_text": "\xd0\x9d\xd0\xb5\xd1\x82 \xd1\x82\xd0\xb5\xd0\xba\xd1\x81\xd1\x82\xd0\xb0 \xd1\x81\xd0\xbe\xd0\xbe\xd0\xb1\xd1\x89\xd0\xb5\xd0\xbd\xd0\xb8\xd1\x8f"\n        }\n    },\n    "balance": 2676.18\n}\n

{\n    "status": "OK",\n    "status_code": 100,\n    "sms": {\n        "79607891234": {\n            "status": "ERROR",\n            "status_code": 203,\n            "status_text": "\xd0\x9d\xd0\xb5\xd1\x82 \xd1\x82\xd0\xb5\xd0\xba\xd1\x81\xd1\x82\xd0\xb0 \xd1\x81\xd0\xbe\xd0\xbe\xd0\xb1\xd1\x89\xd0\xb5\xd0\xbd\xd0\xb8\xd1\x8f"\n        },\n        "79035671233": {\n            "status": "ERROR",\n            "status_code": 203,\n            "status_text": "\xd0\x9d\xd0\xb5\xd1\x82 \xd1\x82\xd0\xb5\xd0\xba\xd1\x81\xd1\x82\xd0\xb0 \xd1\x81\xd0\xbe\xd0\xbe\xd0\xb1\xd1\x89\xd0\xb5\xd0\xbd\xd0\xb8\xd1\x8f"\n        },\n        "79105432212": {\n            "status": "ERROR",\n            "status_code": …

我发现一个示例在 Windows 中无法正常工作。该程序演示了 Go 标准图像包的基本用法，我们将使用它来创建位图图像序列，然后将该序列编码为 GIF 动画。

package main

import (
    "image"
    "image/color"
    "image/gif"
    "io"
    "math"
    "math/rand"
    "os"
)

import (
    "log"
    "net/http"
    "time"
)

//!+main

var palette = []color.Color{color.White, color.Black}

const (
    whiteIndex = 0 // first color in palette
    blackIndex = 1 // next color in palette
)

func main() {
    //!-main
    // The sequence of images is deterministic unless we seed
    // the pseudo-random number generator using the current time.
    // Thanks to Randall McPherson for pointing …

我正在尝试使用sarama（管理员模式）创建主题。如果没有ConfigEntries，则可以正常运行。但是我需要定义一些配置。

我设置了主题配置（这里发生了错误）：

    tConfigs := map[string]*string{
        "cleanup.policy":      "delete",
        "delete.retention.ms": "36000000",
    }

但是然后我得到一个错误：

./main.go:99:28: cannot use "delete" (type string) as type *string in map value
./main.go:100:28: cannot use "36000000" (type string) as type *string in map value

我正在尝试使用这样的管理模式：

err = admin.CreateTopic(t.Name, &sarama.TopicDetail{
    NumPartitions:     1,
    ReplicationFactor: 3,
    ConfigEntries:     tConfigs,
}, false)

这是sarama模块中定义CreateTopic（）的代码行， 网址为https://github.com/Shopify/sarama/blob/master/admin.go#L18

基本上，我不了解指针字符串的映射是如何工作的:)

说我有下一个C程序：

#include <stdio.h>

int main(int args, char* argv[])
{
    enum RC {
        APPLE=0,
        ORANGE,
        PEAR,
        BANANA=99,
        GRAPE
    };

    printf("%d, %d, %d, %d, %d\n", APPLE, ORANGE, PEAR, BANANA, GRAPE);
}

输出为：

0、1、2、99、100

如果进行中，如何使用a more golang way来处理呢？

实际上，如果我只是想跳过一些值。例如print 0, 1, 2, 5, 6，那么我可以使用next跳过一些值，但是在这里我需要跳过96个值...

package main

import "fmt"

func main() {
    const (
        APPLE = iota
        ORANGE
        PEAR
        _
        _
        BANANA
        GRAPE
    )
    fmt.Println(APPLE, ORANGE, PEAR, BANANA, GRAPE)
}

并且，我也可以使用next，但是在GRAPE... 之后我仍然有很多const变量。

package main

import "fmt"

func main() {
    const …

我们都知道runtime.GOMAXPROCS默认设置为CPU核心数，如果这个属性设置过大怎么办？

1. 程序会有更多的上下文切换吗？
2. 垃圾收集器会更频繁地触发吗？

我目前正在学习Go编程语言，现在正在尝试原子包。

在此示例中，我产生了许多Goroutine，它们都需要增加包级变量。有几种避免竞争情况的方法，但是现在我想使用atomic软件包解决此问题。

在Windows PC（go run main.go）上运行以下代码时，结果不是我期望的结果（我希望最终结果是1000）。最终数字在900到1000之间。在Go Playground中运行代码时，该值为1000。

这是我正在使用的代码：https : //play.golang.org/p/8gW-AsKGzwq

var counter int64
var wg sync.WaitGroup

func main() {
    num := 1000
    wg.Add(num )
    for i := 0; i < num ; i++ {
        go func() {
            v := atomic.LoadInt64(&counter)
            v++
            atomic.StoreInt64(&counter, v)

            // atomic.AddInt64(&counter, 1)

            // fmt.Println(v)
            wg.Done()
        }()
    }
    wg.Wait()
    fmt.Println("final", counter)
}

go run main.go
final 931

go run main.go
final 960

go run main.go
final 918

我本来希望比赛检测器会给出错误，但是不会：

go run …

我正在阅读以下文章：https : //www.ribice.ba/golang-enums/

在其中一个代码示例中定义了一个函数：

func (lt *LeaveType) UnmarshalJSON(b []byte) error {
    // Define a secondary type to avoid ending up with a recursive call to json.Unmarshal
    type LT LeaveType;
    var r *LT = (*LT)(lt);
    err := json.Unmarshal(b, &r)
    if err != nil{
        panic(err)
    }
    switch *lt {
    case AnnualLeave, Sick, BankHoliday, Other:
        return nil
    }
    return errors.New("Inalid leave type")
}

var r *LT = (*LT)(lt);这个例子中的语法是做什么的？