ความแตกต่างระหว่าง: = และ = ตัวดำเนินการใน Go

อะไรคือความแตกต่างระหว่างตัวดำเนินการ=และ:=ตัวดำเนินการและกรณีการใช้งานสำหรับพวกเขาคืออะไร พวกเขาทั้งสองดูเหมือนจะเป็นงานที่มอบหมายหรือไม่?

เพียง แต่=เป็นผู้ประกอบการที่ได้รับมอบหมาย

:=เป็นส่วนหนึ่งของไวยากรณ์ของที่สั้นการประกาศตัวแปรข้อ

though มีกฎบางอย่าง ดูนี้คำตอบอื่น ๆสำหรับรายละเอียดเพิ่มเติม

ใน Go ใช้:=สำหรับการประกาศ + การมอบหมายขณะที่=สำหรับการมอบหมายเท่านั้น

ยกตัวอย่างเช่นเป็นเช่นเดียวกับvar foo int = 10 foo := 10

ตามที่คนอื่นได้อธิบายไปแล้วมีไว้:=สำหรับการประกาศการมอบหมายและการประกาศซ้ำ และมันจะเดา ( infers ) ชนิดของตัวแปรโดยอัตโนมัติ

ตัวอย่างเช่นfoo := 32เป็นรูปแบบย่อของ:

var foo int
foo = 32

// OR:
var foo int = 32

// OR:
var foo = 32

/ * มีกฎบางอย่าง: * /

★กฎข้อที่ 1:

คุณไม่สามารถใช้ออกจาก:= funcsเป็นเพราะจาก func ใด ๆ คำสั่งควรเริ่มต้นด้วยคำหลัก

// 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

สิ่งนี้ถูกกฎหมายเพราะคุณไม่ได้ประกาศตัวแปรทั้งหมดคุณเพียงกำหนดค่าใหม่ให้กับตัวแปรที่มีอยู่แล้วและประกาศตัวแปรใหม่ในเวลาเดียวกัน นี้เรียกว่าredeclaration

★กฎข้อที่ 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 = 314foo

★กฎข้อที่ 6:

คุณสามารถประกาศชื่อเดียวกันในบล็อกคำสั่งสั้น ๆ เช่น: ถ้า , 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ในขณะที่จะได้รับการประกาศให้เป็นสตริงและเริ่มต้นได้ด้วยค่าbgopher

การใช้เทียบเท่าของพวกเขา=จะเป็น

var a = 10
var b = "gopher"

=เป็นผู้ประกอบการที่ได้รับมอบหมาย มันใช้วิธีเดียวกับที่คุณใช้ในภาษาอื่น

คุณสามารถละเว้นประเภทเมื่อคุณประกาศตัวแปรและมี initializer แสดงอยู่ ( 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 กับประเภทโดยปริยาย

ภายนอกฟังก์ชั่นการสร้างทุกอย่างเริ่มต้นด้วยคำหลัก (var, func และอื่น ๆ ) และ: = การสร้างไม่สามารถใช้ได้

“: =” ใช้เพื่อประกาศและเริ่มต้นในเวลาเดียวกันต่อไปนี้เป็นตัวอย่าง

การใช้“ =”

var i int

ฉัน = 10

https://play.golang.org/p/RU88ty_SGa

การใช้“: =”

ฉัน: = 10

https://play.golang.org/p/XBdjBh-DQB

ทั้งสองเป็นเทคนิคที่แตกต่างกันของการประกาศตัวแปรในภาษาโก

var firstName = "John" // is a variable declaration 

และ

firstName := "John"   // is a short variable declaration. 

การประกาศตัวแปรแบบสั้นคือการจดชวเลขสำหรับการประกาศตัวแปรปกติด้วยนิพจน์เริ่มต้น แต่ไม่มีประเภท

อ่านรายละเอียดด้านล่าง:

ประกาศตัวแปร

การประกาศตัวแปรแบบสั้น