小编icz*_*cza的帖子

我在读回已序列化为十六进制格式的值时遇到问题。当我格式化一个整数时，下面的代码产生一个 0x14 的值。但是，当我尝试从字符串中读取该值时，得到的结果无效。有人可以帮我弄清楚我做错了什么吗？

我有预先存在的文本文件，我正在用包含这种格式的多行进行解析，因此序列化为不同的格式将不是一个可行的解决方案。我需要使用这种特定格式。

根据 go 文档，这应该有效：https : //golang.org/pkg/fmt/

动词的行为类似于 Printf 的动词。例如，%x 将扫描一个整数作为十六进制数，而 %v 将扫描该值的默认表示格式。Printf 动词 %p 和 %T 以及标志 # 和 + 未实现。对于浮点和复数值，所有有效的格式化动词（%b %e %E %f %F %g %G %x %X 和 %v）都是等价的，并且接受十进制和十六进制表示法（例如：“2.3 e+7", "0x4.5p-8") 和数字分隔下划线（例如：“3.14159_26535_89793”）。

package main

import (
    "fmt"
)

func main() {
    encode := 20
    fmt.Println(fmt.Sprintf("%#x", encode)) // 0x14

    var decode int
    numRead, err := fmt.Sscanf("0x14", "%#x", &decode)
    fmt.Println(decode, numRead, err) // 0 1 bad verb '%#' for integer

    numRead, err = fmt.Sscanf("0x14", "%x", &decode) …

我想知道如何将其转换uint64为big.Intgolang？最短的路.

我试过了new(big.Int).SetInt64(int64(a uint64 number)).

我不喜欢它导致它很长,嵌套转换太多,如果它存在,我宁愿使用内置函数.

在下一个代码中，第一个代码Println在构建时失败并出现错误slice of unaddressable value。其余的线条都很好。

package main

import "fmt"

func getSlice() [0]int {
   return [...]int{}
}

func getString() string {
   return "hola"
}

func main() {
    fmt.Println(getSlice()[:]) // Error: slice of unaddressable value

    var a = getSlice()
    fmt.Println(a[:])

    fmt.Println(getString()[:])

    var b = getString()
    fmt.Println(b[:])
}

试试这个代码

如果第一个Println被评论它就有效。 试试看

这是为什么？我在这里缺少什么？

考虑以下代码：

package main

import "fmt"
// 5
type I interface {
    Foo() string
}

type a struct {
    i int
}

func (s a) Foo() string {
    return "We are here!"
}

func (s a) Bar() string {
    return "Major Tom!"
}
// 20
func main() {
    var x I = &a{i: 42}
    fmt.Println(x.Foo())
    fmt.Println(x.(*a).Bar())
}

main 的最后一个语句给了我底层结构，但我需要导出这个结构才能返回它。

如果我在库中使用一个包，其中导出的唯一符号是接口（在上面的示例中，第 5-20 行之间是大 I，小 a），那么当我处于另一个包或文件。

由于原始结构存储在接口中，是否有一种简单的方法来获取其引用并使用尚未在接口中声明且仅附加到结构的方法。

我读了sync.Pool设计，但发现有两种逻辑，为什么我们需要localPool来解决锁竞争。我们可以使用chan来实现一个。

使用频道的速度是的4倍sync.pool！

除了池可以清除对象外，它还有什么优势？

这是池实现和基准测试代码：

package client

import (
    "runtime"
    "sync"
    "testing"
)

type MPool chan interface{}


type A struct {
    s        string
    b        int
    overflow *[2]*[]*string 

}

var p = sync.Pool{
    New: func() interface{} { return new(A) },
}

var mp MPool = make(chan interface{}, 100)

func get() interface{} {
    select {
    case r := <-mp:
        return r
    default:
        return new(A)
    }
}

func put(a interface{}) {
    select {
    case mp <- a:
    default:
    }
    return …

在mongodb中有一个用户数据已存储在集合中challange,数据似乎如下:

{
"_id" : 1,
 "name" : "puneet",
 "last" : "jindal",
 "email" : "puneet@g.com"
}
{
 "_id" : ObjectId("5b3af82cdb3aaa47792b5fd3"),
 "name" : "hardeep",
 "last" : "singh",
 "email" : "hardeep@g.com"
}
{ 
 "_id" : 3,
 "name" : "gaurav",
 "last" : "bansal",
 "email" : "gaurav@g.com"
}
{
 "_id" : ObjectId("5b3af87ddb3aaa47792b5fd4"),
 "name" : "manish",
 "last" : "jindal",
 "email" : "manish@g.com"
}

在上面的数据中有四个记录,其中两个具有整数形式的id,而另一个具有对象形式的id.我只想检索object idid字段中的所有记录.任何人都可以告诉我应该在代码中写什么查询,只会检索具有对象ID的记录.

更新:

我正在使用的代码:

type User struct {
 Id              bson.ObjectId    `json:"_id" bson:"_id,omitempty"`
 Name            string    `json:"name,omitempty" bson:"name,omitempty"`
 Last            string `json:"last,omitempty" …

我对rsync的创建路径有问题。

x := filepath.Join("home", "my_name", "need_folder", ".")
fmt.Println(x)

我得到了"home/my_name/need_folder"，但是需要"home/my_name/need_folder/."，没有concat怎么解决？在名称为“。”的linux文件夹中。不是不可能。

谢谢！

我正在探索使用固定密钥同时访问地图的可能性,而没有锁定以提高性能.我以前用切片探索过类似的东西,似乎有效:

func TestConcurrentSlice(t *testing.T) {
    fixed := []int{1, 2, 3}
    wg := &sync.WaitGroup{}
    for i := 0; i < len(fixed); i++ {
        idx := i
        wg.Add(1)
        go func() {
            defer wg.Done()
            fixed[idx]++
        }()
    }
    wg.Wait()
    fmt.Printf("%v\n", fixed)
}

上面的代码将通过-race测试.

这让我有信心用固定大小的地图(固定数量的键)实现同样的事情,因为我假设如果键的数量没有改变,那么下划线数组(在地图中)不需要扩展,所以它我们可以安全地访问不同的例行程序中的不同密钥(不同的内存位置).所以我写了这个测试:

type simpleStruct struct {
    val int
}

func TestConcurrentAccessMap(t *testing.T) {
    fixed := map[string]*simpleStruct{
        "a": {0},
        "b": {0},
    }
    wg := &sync.WaitGroup{}
    // here I use array instead of iterating the map to avoid read access
    keys := []string{"a", "b"} …

我想在 golang 中计算 100 阶乘。这是我正在使用的代码。

var fact big.Int
fact.MulRange(1, 100)

打印输出给出

30414093201713378043612608166064768844377641568960512000000000000

但是谷歌搜索100！给出9.332622e+157。我想这可能是因为我使用的数据类型（或者可能不是）。我该如何解决？提前致谢。

编辑：所以我在 go playground 中运行了这段代码，它给出了正确的答案。这是由于我的 PC 上的限制吗？另外，当我将其转换为字符串并对其进行迭代时，它会显示不同的数字

str := fact.String()
for _,val := range str{
    fmt.Print(val)
}

这是所有的代码

package main

import (
    "fmt"
    "math/big"
)

func main() {
    var fact big.Int
    fact.MulRange(1, 100)
    fmt.Println(fact)
    n := fact.String()
    fmt.Println(n) //printing 100!
    sum := 0
    for _, i := range n {
        sum += int(i) //sum of each digits in 100!
    }
    fmt.Println(sum)
}

这是 go env …

我使用页码和限制在 Go 中创建了分页。在哪里Limit & Page Number are INT

我创建了如下分页：

MONGO_SESSION.Find(nil).Skip(pageNumber*limit).Limit(limit).Sort("_id").All(&RETURN_STRUCT)

它工作正常。但是当我发送页码或限制为零时。默认情况下 mongo DB 返回所有记录，因为没有什么可以跳过和限制的。

所以我的问题是，在零限制和零页码的情况下什么是好的做法。

练习 1：发送所有数据。不要发送错误响应。

实践二：发送错误响应说“页数和限制不能为零”

注意：我不能硬编码限制或页码。

任何建议将不胜感激。