В чем разница между =
и :=
операторами, и каковы варианты использования для них? Они оба, кажется, для назначения?
x := uint32(123)
работает, например. Это должно быть очевидно для большинства людей, но мне пришлось подумать несколько минут ;-)
В чем разница между =
и :=
операторами, и каковы варианты использования для них? Они оба, кажется, для назначения?
x := uint32(123)
работает, например. Это должно быть очевидно для большинства людей, но мне пришлось подумать несколько минут ;-)
Ответы:
Только =
оператор присваивания.
:=
является частью синтаксиса объявлений переменных Short .
Though Есть несколько правил, хотя. Смотрите этот другой ответ для более подробной информации.
:=
здесь указан оператор golang.org/ref/spec#Operators_and_punctuation , поэтому я не уверен, что согласен с тем, что « :=
на самом деле не оператор»
В Go :=
- для объявления + присваивания, тогда =
как только для присваивания.
Например, так var foo int = 10
же, как foo := 10
.
=
в отличие от :=
? Вы должны просто всегда использовать :=
?
:=
назначать переменную, которая уже была объявлена, если только вы не присваиваете нескольким переменным одновременно, и хотя бы одна из этих переменных является новой.
int
не требуется, var foo = 10
так же , какfoo := 10
Как уже объяснили другие, :=
предназначен как для объявления, назначения, а также для повторного объявления; и он угадывает ( выводит ) тип переменной автоматически.
Например, foo := 32
это сокращенная форма:
var foo int
foo = 32
// OR:
var foo int = 32
// OR:
var foo = 32
/ * Есть несколько правил: * /
★ 1-е правило:
Вы не можете использовать :=
из funcs
. Это потому, что из любой функции оператор должен начинаться с ключевого слова.
// no keywords below, illegal.
illegal := 42
// `var` keyword makes this statement legal.
var legal = 42
func foo() {
alsoLegal := 42
// reason: it's in a func scope.
}
★ 2-е правило:
Вы не можете использовать их дважды ( в одной области ):
legal := 42
legal := 42 // <-- error
Потому что, :=
вводит «новую переменную» , следовательно, ее повторное использование не означает, что вторая переменная не будет объявлена повторно, поэтому это недопустимо.
★ 3-е правило:
Вы можете использовать их для объявления и назначения нескольких переменных:
foo, bar := 42, 314
jazz, bazz := 22, 7
★ 4-е правило (объявление):
Вы можете использовать их дважды в объявлениях с несколькими переменными , если одна из переменных является новой :
foo, bar := someFunc()
foo, jazz := someFunc() // <-- jazz is new
baz, foo := someFunc() // <-- baz is new
Это допустимо, потому что вы не объявляете все переменные, вы просто переназначаете новые значения существующим переменным и одновременно объявляете новые переменные. Это называется повторной рекламой .
★ 5-е правило:
Вы можете использовать краткое объявление, чтобы объявить переменную в более новой области видимости, даже если эта переменная уже была объявлена с тем же именем ранее:
var foo int = 34
func some() {
// because foo here is scoped to some func
foo := 42 // <-- legal
foo = 314 // <-- legal
}
Здесь, foo := 42
это законно, потому что это объявляется foo
в области действия some()
func. foo = 314
законно, потому что он просто присваивает новое значение foo
.
★ 6-е правило:
Вы можете объявить одно и то же имя в коротких блоках операторов, например: if , for , switch :
foo := 42
if foo := someFunc(); foo == 314 {
// foo is scoped to 314 here
// ...
}
// foo is still 42 here
Потому что, foo
в if foo := ...
, принадлежит только к этому if
предложению, и это в другой области.
Итак, как правило: если вы хотите легко объявить переменную, которую вы можете использовать
:=
, или, если вы хотите просто перезаписать существующую переменную, вы можете использовать=
.
Ссылки:
:=
это сокращение для объявления.
a := 10
b := "gopher"
a
будет объявлен как int
и инициализирован значением, 10
где as b
будет объявлен как строка и инициализирован значением gopher
.
Использование их эквивалентов =
будет
var a = 10
var b = "gopher"
=
является оператором присваивания. Он используется так же, как и на любом другом языке.
Вы можете опустить тип, когда объявляете переменную и присутствует инициализатор ( http://tour.golang.org/#11 ).
=
только для сравнения и :=
для назначения ...
Символ: = объявляет и присваивает, а символ = означает просто присваивать.
:=
объявляет и назначает, =
просто назначает
Это полезно, когда вы не хотите заполнять свой код объявлениями типа или структуры.
// Usage with =
var i int
var U, V, W float64
var k = 0
var x, y float32 = -1, -2
// Usage with :=
i, j := 0, 10
f := func() int { return 7 }
ch := make(chan int)
из справочного документа: ( tour.golang.org )
Внутри функции , то :=
оператор короткого назначения может быть использован вместо вара декларации с неявным типом.
Вне функции каждая конструкция начинается с ключевого слова (var, func и т. Д.), А конструкция: = недоступна.
«: =» Используется для одновременного объявления и инициализации, ниже приведен пример.
Использование «=»
Var I Int
я = 10
https://play.golang.org/p/RU88ty_SGa
Использование «: =»
я: = 10
Это разные методы объявления переменных в языке Go.
var firstName = "John" // is a variable declaration
И
firstName := "John" // is a short variable declaration.
Краткое объявление переменной является сокращением для объявления обычной переменной с выражениями инициализатора, но без типов.
Читайте ниже для деталей: