गो भाषा में,
[]string एक स्ट्रिंग सरणी है
और हम ...stringएक पैरामीटर के रूप में भी उपयोग करते हैं ।
अंतर क्या है?
कार्य की परिभाषा:
func f(args ...string) {}
क्या मैं नीचे इस फ़ंक्शन को कॉल कर सकता हूं?
args := []string{"a", "b"}
f(args)
गो भाषा में,
[]string एक स्ट्रिंग सरणी है
और हम ...stringएक पैरामीटर के रूप में भी उपयोग करते हैं ।
अंतर क्या है?
कार्य की परिभाषा:
func f(args ...string) {}
क्या मैं नीचे इस फ़ंक्शन को कॉल कर सकता हूं?
args := []string{"a", "b"}
f(args)
जवाबों:
[]stringएक स्ट्रिंग सरणी है
तकनीकी रूप से यह एक स्लाइस है जो एक अंतर्निहित सरणी को संदर्भित करता है
और हम
...stringएक पैरामीटर के रूप में भी उपयोग करते हैं ।अंतर क्या है?
संरचना के संबंध में, वास्तव में कुछ भी नहीं। दोनों सिंटैक्स से उत्पन्न डेटा प्रकार समान है।
...पैरामीटर वाक्य रचना एक variadic पैरामीटर बनाता है। यह शून्य या अधिक stringतर्कों को स्वीकार करेगा , और उन्हें एक स्लाइस के रूप में संदर्भित करेगा।
कॉलिंग के संबंध में f, आप निम्न सिंटैक्स के साथ वैरेडिक पैरामीटर में स्ट्रिंग्स का एक टुकड़ा पास कर सकते हैं:
func f(args ...string) {
fmt.Println(len(args))
}
args := []string{"a", "b"}
f(args...)
यह सिंटैक्स या तो शाब्दिक सिंटैक्स का उपयोग करके निर्मित स्लाइस के लिए उपलब्ध है, या वैरिएबल पैरामीटर का प्रतिनिधित्व करने वाले स्लाइस (क्योंकि उनके बीच वास्तव में कोई अंतर नहीं है) ।
[]stringसिंटैक्स का उपयोग करके बनाए गए अंतर के बारे में पूछा गया था । मैं इसे स्पष्ट करने के लिए अपने उत्तर में अधिक उद्धरण जोड़ूंगा। :-)
दोनों तार की एक सरणी बनाते हैं, लेकिन अंतर यह है कि इसे कैसे कहा जाता है।
func f(args ...string) {
}
// Would be called like this:
f("foo","bar","baz");
यह आपको एक चर संख्या के तर्कों को स्वीकार करने की अनुमति देता है (सभी एक ही प्रकार के)
इसका एक बड़ा उदाहरण है fmt.Printऔर दोस्तों, जो आप चाहते हैं के रूप में कुछ या के रूप में कई तर्क स्वीकार कर सकते हैं।
def fn(*args)निर्माण के लगभग समान है ।
यहाँ आप क्या चाहते हैं:
var args []string = []string{"A", "B", "C"}
func Sample(args ...string) {
for _, arg := range args {
fmt.Println(arg)
}
}
func main() {
Sample(args...)
}
यह आपके फ़ंक्शन मापदंडों को सरल करता है। यहाँ एक उदाहरण है ( https://play.golang.org/p/euMuy6IvaM ): विधि SampleEllipsis शून्य से एक ही प्रकार के कई मापदंडों के लिए, लेकिन विधि SampleArray में यह अनिवार्य है स्वीकार करता है आर्ग घोषित किया जाना है।
package main
import "fmt"
func SampleEllipsis(args ...string) {
fmt.Printf("Sample ellipsis : %+v\n",args)
}
func SampleArray(args []string) {
fmt.Println("Sample array ")
SampleEllipsis(args...)
}
func main() {
// Method one
SampleEllipsis([]string{"A", "B", "C"}...)
// Method two
SampleEllipsis("A", "B", "C")
// Method three
SampleEllipsis()
// Simple array
SampleArray([]string{"A", "B", "C"})
// Simple array
SampleArray([]string{})
}
रिटर्न:
Sample ellipsis : [A B C]
Sample ellipsis : [A B C]
Sample ellipsis : []
Sample array
Sample ellipsis : [A B C]
Sample array
Sample ellipsis : []
[]stringएक टुकड़ा है, एक सरणी नहीं है। एक सरणी और टुकड़ा के बीच अंतर सूक्ष्म लेकिन महत्वपूर्ण हैं।