我是 Go 编程语言的新手。
我在 Go 中注意到一些奇怪的东西：我认为它在 Python 中使用:=和替代，但是当我在 Go 中使用时它也可以工作。==
:=和 和有什么不一样=？
问问题
15780 次
8 回答
53
=是赋值。更多关于 Go 中的作业：作业
=和之间的细微差别:=是=在变量声明中使用时。
Go 中变量声明的一般形式是：
var name type = expression
上面的声明创建了一个特定类型的变量，为其附加了一个名称，并设置了它的初始值。thetype或 the= expression可以省略，但不能同时省略。
例如：
var x int = 1
var a int
var b, c, d = 3.14, "stackoverflow", true
:=被称为short variable declaration形式
name := expression
并且名称的类型由表达式的类型决定
注意：:=是一个声明，而是=一个赋值
因此，一个简短的变量声明必须至少声明一个新变量。这意味着一个简短的变量声明不一定在其左侧声明所有变量，当其中一些变量已经在同一个词法块中声明时，然后:=就像对这些变量的赋值一样
例如：
r := foo() // ok, declare a new variable r
r, m := bar() // ok, declare a new variable m and assign r a new value
r, m := bar2() //compile error: no new variables
此外，:=可能只出现在函数内部。在某些上下文中，例如“if”、“for”或“switch”语句的初始化器，它们可用于声明局部临时变量。
更多信息：
于 2016-04-09T05:47:33.573 回答
9
=只是任务
:=是函数块（非全局）内新变量（至少一个新变量）的声明和初始化构造：
var u1 uint32 //declare a variable and init with 0
u1 = 32 //assign its value
var u2 uint32 = 32 //declare a variable and assign its value at once
//declare a new variable with defining data type:
u3 := uint32(32) //inside the function block this is equal to: var u3 uint32 = 32
fmt.Println(u1, u2, u3) //32 32 32
//u3 := 20//err: no new variables on left side of :=
u3 = 20
fmt.Println(u1, u2, u3) //32 32 20
u3, str4 := 100, "str" // at least one new var
fmt.Println(u1, u2, u3, str4) //32 32 100 str
于 2016-04-09T05:30:34.717 回答
5
:=是声明和初始化变量的“简短声明形式”。它对您分配的值进行类型推断以设置变量的类型。
如果你试图用简短的声明形式给同一个作用域中的同一个变量赋值，编译器会抛出一个错误。
注意在封闭范围内“隐藏”相同变量的简短声明形式（尤其是有错误时）
=声明变量时需要 var 关键字，并且在变量名之后显式声明变量的类型。实际上，您可以将 = 放在声明之外，因为 Go 对所有类型都有一个初始值（字符串初始化为“”，整数为 0，切片为空切片）。它也可以仅用于重新分配一个值，即
var s string = "a string" // declared and initialized to "a string"
s = "something else" // value is reassigned
var n int // declared and initialized to 0
n = 3
于 2016-04-09T05:30:01.373 回答
3
在函数内部，:=可以使用简短的赋值语句代替隐式类型的 var 声明。
例如：
package main
import "fmt"
func main() {
var i, j int = 1, 2
k := 3
c, python, java := true, false, "no!"
fmt.Println(i, j, k, c, python, java)
}
注意：声明的变量:=只能在功能块内部使用。
于 2016-04-09T05:17:33.900 回答
1
我花了一些时间来找出我犯的一个错误，它可以帮助您澄清 和 之间的:=区别=。考虑以下代码：
type mystruct struct {
a int
arr []int
}
func main() {
m := mystruct{}
m.arr := make([]int, 5) //compilation error because m.arr is already declared.
m.arr = make([]int, 5) //compiles
}
于 2018-11-22T16:42:50.933 回答
0
= 用作静态类型。
:= 用作动态类型。
例子：
var a = 30 # statically typed and is a compile time check
b := 40 # dynamically checked.
于 2021-04-20T05:15:21.927 回答
0
还要注意子句in:=和=in的区别。range以下示例改编自规范。
迭代变量可以由“范围”子句使用短变量声明 (:=) 的形式来声明。在这种情况下，它们的类型被设置为各自迭代值的类型，它们的范围是“for”语句的块；它们在每次迭代中重复使用。如果迭代变量在“for”语句之外声明，则在执行后它们的值将是最后一次迭代的值。
= range ...：
i := 2
x = []int{3, 5, 7}
for i, x[i] = range x { // i,x[2] = 0,x[0]
break
}
// now i == 0 and x == []int{3, 5, 3}
var (key string; val interface{})
m := map[string]int{"mon":0, "tue":1, "wed":2, "thu":3, "fri":4, "sat":5, "sun":6}
for key, val = range m {
h(key, val)
}
// key == last map key encountered in iteration (note order of map iteration is random)
// val == map[key]
:= range ...：
var a [10]string
for i, s := range a {
// type of i is int, type of s is string
// s == a[i]
someFunction(i, s)
}
// i and s are no longer accessible here.
for i := range a { // roughly equivalent to `for i := 0; i < len(a); i++`
someFunction(i, a[i])
}
for _, s := range a {
anotherFunc(s)
}
// Above is roughly equivalent to:
{
var s string
for i := 0; i < len(a); i++ {
s = a[i]
anotherFunc(s)
}
}
// s not accessible here
于 2021-09-11T20:03:25.977 回答
0
在 Go 中声明变量最冗长的方法是使用var关键字、显式类型和赋值。
var x int = 10
Go 还支持简短的声明格式。当您在函数中时，可以使用 := 运算符替换使用类型推断的 var 声明。
var x = 10
x := 10
有一个限制:=。如果你在包级别声明一个变量，你必须使用 var 因为:= 在函数之外是不合法的。
函数中有一些你应该避免的情况:=
- 将变量初始化为零值时，请使用 var x int。这清楚地表明零值是有意的。
- 当将无类型常量或文字分配给变量并且常量或文字的默认类型不是您想要的变量类型时，请使用指定类型的 long var 形式。虽然使用类型转换来指定值的类型并用于
:=write是合法的x := byte(20)，但写 var 是惯用的x byte = 20。 - 因为
:=允许您同时分配新变量和现有变量，所以当您认为您正在重用现有变量时，它有时会创建新变量。在这些情况下，显式声明所有新变量以var明确哪些变量是新变量，然后使用赋值运算符(=)将值分配给新变量和旧变量。
虽然 var 和:=允许您在同一行上声明多个变量，但仅在分配从函数返回的多个值或逗号 ok 习惯用法时才使用此样式。
学习 Go Jon Bondner
于 2022-02-01T05:37:52.980 回答