गो: = और = ऑपरेटरों के बीच अंतर

Question

ऑपरेटरों =और :=ऑपरेटरों के बीच क्या अंतर है , और उनके लिए उपयोग के मामले क्या हैं? वे दोनों एक काम के लिए लग रहे हो?

Comments

इसके अलावा इस देखना : जाओ चर दृश्य गाइड । मैंने इसके बारे में एक लेख लिखा था।

— इनक गमूस

शब्दार्थ ...

— JustDave

यदि आप x := uint32(123)उदाहरण के लिए एक विशिष्ट प्रकार के कार्यों का उपयोग करना चाहते हैं । यह ज्यादातर लोगों के लिए स्पष्ट होना चाहिए, लेकिन मुझे कुछ मिनटों के लिए सोचना पड़ा ;-)

— केंजी नोगुची

Answer 1

केवल =असाइनमेंट ऑपरेटर है।

:=लघु चर घोषणा खंड के वाक्य विन्यास का एक हिस्सा है ।

Rules हालांकि कुछ नियम हैं। देखें इस दूसरे जवाब अधिक जानकारी के लिए।

Comments

तो इसका मतलब है कि बांझ प्रकार के साथ चर? सही?

— कृपाल शाह १५'१६

@KrupalShah डॉक्स के लिए लिंक का शाब्दिक अर्थ है कि - "यह प्रारंभिक अभिव्यक्तियों के साथ एक नियमित चर घोषणा के लिए आशुलिपि है, लेकिन कोई प्रकार नहीं:" golang.org/ref/spec#Short_variable_decifications

— akshaynagpal

ऐसा लगता है कि :=यहां ऑपरेटर के रूप में सूचीबद्ध हैं golang.org/ref/spec#Operators_and_punctuation , इसलिए मुझे यकीन नहीं है कि मैं सहमत हूं कि " :=वास्तव में ऑपरेटर नहीं है"

— Powers

Answer 2

गो में, :=घोषणा + असाइनमेंट के लिए है, जबकि =केवल असाइनमेंट के लिए है।

उदाहरण के लिए, के var foo int = 10 रूप में ही है foo := 10।

Comments

वहाँ के =रूप में विरोध के लिए एक उपयोग मामला है :=? क्या आपको हमेशा उपयोग करना चाहिए :=?

— केनी वर्डेन

@KennethWorden गो आपको :=पहले से घोषित किए गए वैरिएबल को असाइन करने के लिए उपयोग नहीं करने देगा , जब तक कि आप एक साथ कई वेरिएबल्स को असाइन नहीं कर रहे हैं, और कम से कम एक वैरिएबल नया है।

— केनी बनिया

intआवश्यक नहीं है, var foo = 10एक ही रूप हैfoo := 10

— गैरी लीन

@ केनीवरडेन, हाँ। आप उपयोग नहीं कर सकते: = एक फ़ंक्शन के बाहर।

— करुहांगा

Answer 3

जैसा कि दूसरों ने पहले ही समझाया है, :=घोषणा, असाइनमेंट और पुनर्वितरण दोनों के लिए है; और यह अनुमान लगाता है ( शिशुओं ) चर के प्रकार स्वचालित रूप से।

उदाहरण के लिए, foo := 32एक संक्षिप्त रूप है:

var foo int
foo = 32

// OR:
var foo int = 32

// OR:
var foo = 32

---

/ * कुछ नियम हैं: * /

★ पहला नियम:

आप उपयोग नहीं कर सकते :=से बाहर 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.
}

---

★ दूसरा नियम:

आप उन्हें दो बार ( एक ही दायरे में ) उपयोग नहीं कर सकते :

legal := 42
legal := 42 // <-- error

क्योंकि, "एक नया चर" का:= परिचय देता है , इसलिए दो बार इसका उपयोग करने से दूसरे चर का पुनर्वितरण नहीं होता है, इसलिए यह अवैध है।

---

★ तीसरा नियम:

आप उन्हें बहु-चर घोषणाओं और असाइनमेंट के लिए उपयोग कर सकते हैं:

foo, bar   := 42, 314
jazz, bazz := 22, 7

---

★ चौथा नियम (पुनर्वितरण):

यदि आप चर में से एक नया है , तो आप उन्हें दो बार "बहु-चर" घोषणाओं में उपयोग कर सकते हैं :

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()। 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खंड के अंतर्गत आता है और यह एक अलग दायरे में है।

---

इसलिए, एक सामान्य नियम के रूप में: यदि आप आसानी से एक चर घोषित कर सकते हैं जिसका आप उपयोग कर सकते हैं :=, या, यदि आप केवल मौजूदा चर को अधिलेखित करना चाहते हैं, तो आप उपयोग कर सकते हैं =।

संदर्भ:

• लघु चर घोषणा नियम

• एक दृश्य गाइड के लिए चर चर

Answer 4

:= घोषणा के लिए एक छोटा हाथ है।

a := 10
b := "gopher"

aके रूप में घोषित किया जाएगा intऔर मूल्य के साथ आरंभिक 10रूप में जहां bएक स्ट्रिंग के रूप में घोषित किया जाएगा और मूल्य के साथ आरंभ किया जाएगा gopher।

उनके समकक्षों का उपयोग =किया जाएगा

var a = 10
var b = "gopher"

=असाइनमेंट ऑपरेटर है। यह उसी तरह उपयोग किया जाता है जिस तरह से आप इसे किसी अन्य भाषा में उपयोग करेंगे।

जब आप वैरिएबल घोषित करते हैं तो आप टाइप को छोड़ सकते हैं और एक इनिशियलाइज़र मौजूद है ( http://tour.golang.org/#11 )।

Comments

«= असाइनमेंट ऑपरेटर है। यह उसी तरह उपयोग किया जाता है जैसे आप इसे किसी अन्य भाषा में उपयोग करते हैं। एडा को छोड़कर जहां =केवल तुलना के लिए और :=असाइनमेंट के लिए है ...

— एलेक्सिस विलके

Answer 5

: = का अर्थ है घोषणा करना और असाइन करना जबकि = का अर्थ केवल असाइन करना है।

Answer 6

:=घोषित करता है और असाइन करता है, =बस असाइन करता है

यह उपयोगी है जब आप अपने कोड को टाइप या स्ट्रक्चर डिक्लेरेशन से भरना नहीं चाहते हैं।

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

Answer 7

संदर्भ डॉक्टर से: ( tour.golang.org )

एक फ़ंक्शन के अंदर , :=लघु असाइनमेंट स्टेटमेंट का उपयोग निहित प्रकार के साथ एक var घोषणा के स्थान पर किया जा सकता है।

किसी फ़ंक्शन के बाहर , प्रत्येक निर्माण एक कीवर्ड (var, func, और इसी तरह) से शुरू होता है और: = निर्माण उपलब्ध नहीं है।

Answer 8

": =" एक ही समय में घोषणा और निष्कासन करने के लिए उपयोग करें, निम्नलिखित एक उदाहरण है।

"=" का उपयोग

var मैं int

मैं = १०

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

": =" का उपयोग

मैं: = १०

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

Answer 9

दोनों ही गो भाषा में परिवर्तनशील घोषणा की अलग तकनीक हैं।

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

तथा

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

एक लघु चर घोषणा एक प्रारंभिक चर अभिव्यक्ति के साथ एक नियमित चर घोषणा के लिए आशुलिपि है, लेकिन कोई प्रकार नहीं है।

विस्तार के लिए नीचे पढ़ें:

परिवर्तनशील घोषणाएँ

लघु चर घोषणाएं

Comments

मुझे लगता है कि आपका सिंटैक्स पहले उदाहरण के लिए गलत है। इसके बजाय: var firstName: = "John", यह होना चाहिए: var firstName = "John"

— गीनो