无法将[]字符串转换为[]接口{}

Question 1

我正在编写一些代码，并且我需要它来捕获参数并将它们传递给fmt.Println
我（我想要它的默认行为，编写由空格分隔并后跟换行符的参数）。但是它需要[]interface {}而flag.Args()返回[]string。
这是代码示例：

package main

import (
    "fmt"
    "flag"
)

func main() {
    flag.Parse()
    fmt.Println(flag.Args()...)
}

这将返回以下错误：

./example.go:10: cannot use args (type []string) as type []interface {} in function argument

这是一个错误吗？不应该fmt.Println接受任何数组吗？顺便说一句，我也尝试过这样做：

var args = []interface{}(flag.Args())

但出现以下错误：

cannot convert flag.Args() (type []string) to type []interface {}

有“解决方案”解决此问题吗？

Question 2

这不是错误。fmt.Println()需要一个[]interface{}类型。这意味着它必须是interface{}值的切片，而不是“任何切片”。为了转换切片，您将需要循环并复制每个元素。

old := flag.Args()
new := make([]interface{}, len(old))
for i, v := range old {
    new[i] = v
}
fmt.Println(new...)

您无法使用任何分片的原因是a[]string与a之间的转换[]interface{}需要更改内存布局，并且发生时间为O（n）。将类型转换为interface{}需要O（1）时间。如果他们不需要此for循环，则编译器仍将需要插入它。

Question 3

如果仅是要打印的字符串片段，则可以通过加入以下命令避免转换并获得完全相同的输出：

package main

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

func main() {
    flag.Parse()
    s := strings.Join(flag.Args(), " ")
    fmt.Println(s)
}

Question 4

在这种情况下，不需要类型转换。只需将flag.Args()值传递给fmt.Println。

题：

无法将[]字符串转换为[]接口{}

我正在编写一些代码，我需要它来捕获参数并将其传递给fmt.Println（我希望它的默认行为是，编写由空格分隔并后跟换行符的参数）。

这是代码示例：
package main

import (
    "fmt"
    "flag"
)

func main() {
    flag.Parse()
    fmt.Println(flag.Args()...)
}

包装标志

import "flag"

功能Args

func Args() []string

Args 返回非标志命令行参数。

软件包fmt

import "fmt"

功能印刷

func Println(a ...interface{}) (n int, err error)

Println格式使用其操作数的默认格式并写入标准输出。始终在操作数之间添加空格，并添加换行符。它返回已写入的字节数以及遇到的任何写入错误。

在这种情况下，不需要类型转换。只需将flag.Args()值传递给即可fmt.Println，后者使用反射将值解释为类型[]string。包reflect实现了运行时反射，从而允许程序处理任意类型的对象。例如，

args.go：

package main

import (
    "flag"
    "fmt"
)

func main() {
    flag.Parse()
    fmt.Println(flag.Args())
}

输出：

$ go build args.go
$ ./args arg0 arg1
[arg0 arg1]
$

Question 5

在Go中，函数只能接受函数定义的参数列表中指定的类型的参数。可变参数语言功能使这一点复杂化了一点，但是它遵循了明确定义的规则。

的功能签名为fmt.Println：

func Println(a ...interface{}) (n int, err error)

根据语言规范，

函数签名中的最终传入参数可以具有以...为前缀的类型。具有此类参数的函数称为可变参数（variadic），并且可以使用该参数的零个或多个参数来调用该函数。

这意味着您可以传递类型Println的参数列表interface{}。由于所有类型都实现了空接口，因此您可以传递任何类型的参数列表Println(1, "one", true)，例如，这是您可以无误调用的方式。请参阅语言规范的“将参数传递给...参数”部分：

传递的值是[] T类型的新切片，带有新的基础数组，其后续元素是实际参数，所有参数都必须可分配给T。

说明书中紧随其后的是给您带来麻烦的部分：

如果最后一个参数可分配给切片类型[] T，则如果参数后面跟有...，则可以将其不变地作为... T参数的值传递。在这种情况下，不会创建新的切片。

flag.Args()是type []string。由于T在Println是interface{}，[]T是[]interface{}。因此，问题在于字符串切片值是否可分配给接口切片类型的变量。通过尝试分配，您可以轻松地在go代码中对其进行测试，例如：

s := []string{}
var i []interface{}
i = s

如果您尝试进行此类分配，则编译器将输出以下错误消息：

cannot use s (type []string) as type []interface {} in assignment

因此，您不能在字符串切片之后使用省略号作为的参数fmt.Println。这不是错误，而是按预期工作。

您仍然可以flag.Args()使用多种方法进行打印Println，例如

fmt.Println(flag.Args())

（[elem0 elem1 ...]根据fmt软件包文档，其输出为）

要么

fmt.Println(strings.Join(flag.Args(), ` `)

（将输出字符串切片元素，每个字符串元素之间用一个空格分隔），例如，使用带有字符串分隔符的字符串包中的Join函数。

Question 6

我认为可以使用反射，但是我不知道这是否是一个好的解决方案

package main

import (
    "fmt"
    "reflect"
    "strings"
)

type User struct {
    Name string
    Age  byte
}

func main() {
    flag.Parse()
    fmt.Println(String(flag.Args()))
    fmt.Println(String([]string{"hello", "world"}))
    fmt.Println(String([]int{1, 2, 3, 4, 5, 6}))
    u1, u2 := User{Name: "John", Age: 30},
        User{Name: "Not John", Age: 20}
    fmt.Println(String([]User{u1, u2}))
}

func String(v interface{}) string {
    val := reflect.ValueOf(v)
    if val.Kind() == reflect.Array || val.Kind() == reflect.Slice {
        l := val.Len()
        if l == 0 {
            return ""
        }
        if l == 1 {
            return fmt.Sprint(val.Index(0))
        }
        sb := strings.Builder{}
        sb.Grow(l * 4)
        sb.WriteString(fmt.Sprint(val.Index(0)))
        for i := 1; i < l; i++ {
            sb.WriteString(",")
            sb.WriteString(fmt.Sprint(val.Index(i)))
        }
        return sb.String()
    }

    return fmt.Sprintln(v)
}

输出：

$ go run .\main.go arg1 arg2
arg1,arg2
hello,world
1,2,3,4,5,6
{John 30},{Not John 20}

Question 7

fmt.Println采用可变参数

func Println（a ... interface {}）（n int，错误）

flag.Args()无需转换即可打印[]interface{}

func main() {
    flag.Parse()
    fmt.Println(flag.Args())
}