小编Kir*_*ril的帖子

当执行以下代码时，我在第一个循环完成时得到了我所期望的结果（从 0 到 9 的序列）。但是当第二个循环完成时，结果不是我所期望的（我期望与第一个循环中的结果相同，但它只打印“10”）：

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup

    for i := 0; i < 10; i++ {
        wg.Add(1)

        go func(j int) {
            defer wg.Done()

            fmt.Println(j)
        }(i)
    }

    wg.Wait()

    fmt.Println("done first")

    for i := 0; i < 10; i++ {
        wg.Add(1)

        go func() {
            defer wg.Done()

            fmt.Println(i)
        }()
    }

    wg.Wait()

    fmt.Println("done second")
}

输出：

0
1
2
3
4
5
6
7
8
9
done first
10
10
10
10
10 …

我正在解析命令行参数.我使用以下代码:

var flagB = flag.Bool("b", false, "boolflag")

func main() {
    flag.Parse()

    fmt.Println(flag.NArg())
    fmt.Println("-b", *flagB)
}

当我像这样执行二进制文件时:

> test -b "random"

我得到了预期的输出,因为有一个参数,并设置了标志:

1
-b true

但是,当我以相反的方式执行二进制文件时:

> test "random" -b

我明白了:

2
-b false

现在,该标志不再被重新标记为标志,而是另一个参数.

为什么会那样？是否有一个定义,首先是标志,然后是参数？我一直认为传递和解析参数的"GNU方式"是:二进制之后的第一个位置是为强制参数保留的.之后,您可以添加可选参数和标志.

我试图在nginx(0.7.67)上为静态文件配置Expires头.静态文件由Golang反向代理提供:

location /rev/ {
  proxy_pass http://localhost:8910/;
  proxy_redirect off;
  proxy_set_header  Host               $host;
  proxy_set_header  X-Real-IP          $remote_addr;
  proxy_set_header  X-Forwarded-For    $proxy_add_x_forwarded_for;
  proxy_set_header  X-Forwarded-Proto  https;

  # I am putting this here, because nginx only uses one location. Is this OK?
  location ~* \.(js|css|jpg|jpeg|gif|png|svg|ico|pdf|html|htm)$ {
    expires 30d;
  }
}

当我这样做时,重启nginx没有错误,但静态文件不再提供.

我已经尝试了以下星座,但它不起作用:

server {
  ...
  location /rev/ {
    proxy_pass http://localhost:8910/;
    proxy_redirect off;
    proxy_set_header  Host               $host;
    proxy_set_header  X-Real-IP          $remote_addr;
    proxy_set_header  X-Forwarded-For    $proxy_add_x_forwarded_for;
    proxy_set_header  X-Forwarded-Proto  https;
  }

  location ~* \.(js|css|jpg|jpeg|gif|png|svg|ico|pdf|html|htm)$ {
      expires 30d;
  }
}

问题:如何为反向代理后面的应用程序上的静态文件应用expires头？

我需要根据数据库中的数据创建固定长度的文本文件。数据导出没有问题，将数据加载到Go中也可以。如何以固定长度样式打印数据？

我有以下结构

type D struct {
  A10 string // Should be 10 characters in result file
  A20 string // Should be 20 characters in result file
  A50 string // Should be 50 characters in result file
}

var d := D{ "ten", "twenty", "fifty" }

所以，打印结构的结果应该是

|       ten|              twenty|                                   fifty|

我已经弄清楚，这fmt.Printf("%10s", "ten")将在前面添加 10 个前导空格，但我不知道如何阻止它溢出：fmt.Printf("%10s", "tenaaaaaaaa")将打印 11 个字符。

我想到了一个遍历每个字段并剪掉太长字符串的函数：

func trimTooLong(d *D) {
  d.A10 = d.A10[:10]
  d.A20 = d.A20[:20]
  d.A50 = d.A20[:50]
}

会有更好的方法吗？

xml文件由两个元素组成.除了一个元素名称外,这些元素具有相同的结构.我试图为XMLName属性设置一个值,但这不起作用.

XML:

<!-- first element -->
<PERSON>
  <ELEM1>...</ELEM1>
  <ELEM2>...</ELEM2>
  <ELEM3>...</ELEM3>
  <ELEM4>...</ELEM4>
</PERSON>


<!-- second element -->
<SENDER>
  <ELEM1>...</ELEM1>
  <ELEM2>...</ELEM2>
  <ELEM3>...</ELEM3>
  <ELEM4>...</ELEM4>
</SENDER>

是否可以定义一个结构,使元素名称是动态的？

type Person struct {
    XMLName string `xml:"???"` // How make this dynamic?
    e1 string `xml:"ELEM1"`
    e2 string `xml:"ELEM2"`
    e3 string `xml:"ELEM3"`
    e4 string `xml:"ELEM4"`
}

假设以下xml元素具有属性和浮点值:

<thing prop="1">
  1.23
</thing>
<thing prop="2">
  4.56
</thing>

为了解组它,我应该如何定义我的结构？

type ThingElem struct {
    Prop  int   `xml:"prop,attr"`
    Value float // ???
}

type ThingWrapper struct {
    T ThingElem `xml:"thing"`
}

// VS

type ThingElem struct {
    XMLName xml.Name `xml:"thing"` // Do I even need this?
    Prop    int      `xml:"prop,attr"`
    Value   float    // ???
}

XMLName属性的使用让我感到困惑.什么时候应该放在结构中,什么时候在包装器中作为标签？

我在处理时间戳时遇到了麻烦.我在Chrome 24.0.1312.56 m和Firefox 18.0.1控制台中调试以下完全相同的代码:

new Date(parseInt('2012'), parseInt('09') - 1, parseInt('30')).getTime()/1000

当我在Chrome中执行它时,我得到:

1348956000

当我在Firefox中执行它时,我得到:

1325199600

问题:这里有什么问题？

我正在尝试分析日志文件.我正在寻找一个正则表达式,它满足以下要求:

LOG: https://localhost/a
LOG: https://remotehost/x
LOG: https://localhost/b
LOG: https://localhost/c
LOG: https://remotehost/a

以上是日志文件的示例.问题:如何通过日志文件进行grep,这样我只得到不包含的行:

https://localhost

结果应该是:

LOG: https://remotehost/x
LOG: https://remotehost/a

我们有:

type A struct {
  Name  string
  Value string
}

type B struct {
  //
  First  *A
  Second A
}

首先:什么它更有效B,使用*A或A？

第二:实例化时B我会使用b := &B{ ... },因而有一个指针B.所有具有B接收器func (*B) ...用作签名的功能,因此仅在指针上操作.既然我总是有一个指针B,那真的很重要B吗？如果我总是使用指针,无论哪个字段B都有,我总是传递指针,B并且Second A在传递时永远不会复制值*B.或者我错过了什么？

我正在尝试评估信息检索方法.因此,我需要适合克兰菲尔德实验的数据:

1. 文件(D)
2. 查询(Q)
3. 相关性(Q,D)

不幸的是我没有找到任何可以免费获得的东西......

有多个文件:

1.csv
2.csv
...

有一些通用的内容,如:

[1.csv]
a
b
c

[2.csv]
d
e
f

我想将文件的内容连接成一个文件,但每行都有文件名.所以结果应该是这样的:

[concatenated.csv]
1.csv;a
1.csv;b
1.csv;c
2.csv;d
2.csv;e
2.csv;f