सूची को गो में बार-बार उपयोग क्यों किया जाता है?

Question 1

मैं गो के लिए नया हूं, और इसे लेकर काफी उत्साहित हूं। लेकिन, सभी भाषाओं में मैंने बड़े पैमाने पर काम किया है: डेल्फी, सी #, सी ++, पायथन - सूचियाँ बहुत महत्वपूर्ण हैं क्योंकि वे गतिशील रूप से आकार बदल सकते हैं, जैसा कि सरणियों के विपरीत है।

गोलंग में, वास्तव में एक list.Listसंरचना है, लेकिन मैं इसके बारे में बहुत कम दस्तावेज देखता हूं - चाहे गो बाय उदाहरण में हो या तीन गो पुस्तकें जो मेरे पास हैं - समरफील्ड, चिसनल और बालाबैर्ट - वे सभी सरणियों और स्लाइस पर बहुत समय बिताते हैं फिर नक्शे पर जाएं। Souce कोड उदाहरणों में मुझे भी कम या कोई फायदा नहीं मिला list.List।

यह भी प्रतीत होता है कि, पायथन के विपरीत, Rangeसूची के लिए समर्थित नहीं है - बड़ा दोष आईएमओ। क्या मैं कुछ भूल रहा हूँ?

स्लाइस निश्चित रूप से अच्छे हैं, लेकिन उन्हें अभी भी एक हार्ड कोडित आकार के साथ एक सरणी पर आधारित होने की आवश्यकता है। यही कारण है कि सूची में आता है। वहाँ एक हार्ड कोडित सरणी आकार के बिना जाओ में एक सरणी / टुकड़ा बनाने के लिए एक रास्ता है? सूची को अनदेखा क्यों किया गया है?

Question 2

हमेशा के बारे में जब आप एक सूची के बारे में सोच रहे हैं - गो के बजाय एक स्लाइस का उपयोग करें। स्लाइस गतिशील रूप से फिर से आकार में हैं। उन्हें समझना स्मृति का एक आकस्मिक टुकड़ा है जो आकार बदल सकता है।

यदि आप SliceTricks विकि पृष्ठ को पढ़ते हैं, तो वे बहुत लचीले हैं ।

यहाँ एक अंश है: -

प्रतिलिपि
b = make([]T, len(a))
copy(b, a) // or b = append([]T(nil), a...)
कट गया
a = append(a[:i], a[j:]...)
हटाएं
a = append(a[:i], a[i+1:]...) // or a = a[:i+copy(a[i:], a[i+1:])]
संरक्षण आदेश के बिना हटाएँ
a[i], a = a[len(a)-1], a[:len(a)-1]
पॉप
x, a = a[len(a)-1], a[:len(a)-1]
धक्का दें
a = append(a, x)

अपडेट : यहां गो टीम से स्लाइस के बारे में एक ब्लॉग पोस्ट का लिंक दिया गया है, जो स्लाइस और सरणियों और स्लाइस इंटर्नल के बीच संबंधों को समझाने का अच्छा काम करता है।

Question 3

मैंने यह सवाल कुछ महीने पहले पूछा था, जब मैंने पहली बार गो की जांच शुरू की थी। तब से, हर दिन मैं गो के बारे में पढ़ रहा हूं, और गो में कोडिंग कर रहा हूं।

क्योंकि मुझे इस प्रश्न का स्पष्ट उत्तर नहीं मिला (हालाँकि मैंने एक उत्तर को स्वीकार कर लिया था) अब मैं इसका उत्तर खुद देने जा रहा हूँ, जो मैंने सीखा है, उसके आधार पर:

क्या हार्ड कोडित सरणी आकार के बिना Go में एक सरणी / स्लाइस बनाने का एक तरीका है?

हाँ। स्लाइस के लिए कठोर कोडित सरणी की आवश्यकता नहीं है slice:

var sl []int = make([]int,len,cap)

यह कोड स्लाइस आवंटित करता है sl, lenजिसकी क्षमता है cap- lenऔर capवे चर हैं जिन्हें रनटाइम पर सौंपा जा सकता है।

क्यों list.Listनजरअंदाज किया जाता है?

ऐसा लगता है कि मुख्य कारणों list.Listमें गो पर थोड़ा ध्यान दिया जाता है:

जैसा कि @ निक क्रेग-वुड के उत्तर में बताया गया है, वस्तुतः कुछ भी नहीं है जो सूचियों के साथ किया जा सकता है जो स्लाइस के साथ नहीं किया जा सकता है, अक्सर अधिक कुशलता से और क्लीनर के साथ, अधिक सुरुचिपूर्ण वाक्यविन्यास। उदाहरण के लिए रेंज का निर्माण:
```
for i:=range sl {
  sl[i]=i
}
```
सूची के साथ उपयोग नहीं किया जा सकता है - लूप के लिए एक सी शैली की आवश्यकता है। और कई मामलों में, सी ++ संग्रह शैली वाक्यविन्यास का उपयोग सूचियों के साथ किया जाना चाहिए: push_backआदि।
शायद अधिक महत्वपूर्ण बात, list.Listदृढ़ता से टाइप नहीं किया गया है - यह पायथन की सूचियों और शब्दकोशों के समान है, जो संग्रह में विभिन्न प्रकारों को एक साथ मिलाने की अनुमति देते हैं। यह चीजों के लिए गो दृष्टिकोण के विपरीत चलता है। जाओ एक बहुत दृढ़ता से टाइप किया भाषा है - उदाहरण के लिए, अंतर्निहित प्रकार रूपांतरण, गो में अनुमति कभी नहीं से भी एक Upcast intको int64स्पष्ट किया जाना चाहिए। लेकिन सूची के लिए सभी तरीके हैं। खाली इंटरफेस लेते हैं - कुछ भी हो जाता है।

पायथन को छोड़ने और गो में चले जाने के कारणों में से एक पायथन के प्रकार प्रणाली में इस तरह की कमजोरी के कारण है, हालांकि पायथन "दृढ़ता से टाइप" होने का दावा करता है (आईएमओ यह नहीं है)। गो list.Listको एक तरह का "मोंगरेल" लगता है, जो कि C ++ के vector<T>और पायथन के जन्म का है List(), और शायद गो में ही एक जगह से थोड़ा बाहर है।

यह मुझे आश्चर्यचकित नहीं करेगा यदि बहुत दूर के भविष्य में कुछ बिंदु पर, हम सूची पाते हैं। जाओ में पदावनत, हालांकि शायद यह रहेगा, उन दुर्लभ स्थितियों को समायोजित करने के लिए , जहां अच्छी डिजाइन प्रथाओं का उपयोग करते हुए, एक समस्या को सबसे अच्छा हल किया जा सकता है। एक संग्रह के साथ जो विभिन्न प्रकारों को रखता है। या शायद यह सी परिवार के डेवलपर्स के लिए गो के साथ सहज होने के लिए "पुल" प्रदान करना है इससे पहले कि वे स्लाइस की बारीकियों को सीखें, जो गो, एएफएआईके के लिए अद्वितीय हैं। (कुछ मामलों में स्लाइस सी ++ या डेल्फी में स्ट्रीम कक्षाओं के समान हैं, लेकिन पूरी तरह से नहीं।)

हालाँकि, डेल्फी / सी ++ / पायथन बैकग्राउंड से आने के बाद, गो के अपने शुरुआती प्रदर्शन में मुझे list.Listगो के स्लाइस की तुलना में अधिक परिचित पाया गया, क्योंकि मैं गो के साथ अधिक सहज हो गया हूं, मैं वापस चला गया हूं और अपनी सभी सूचियों को स्लाइस में बदल दिया। मुझे अभी तक कुछ भी नहीं मिला है sliceऔर / या mapमुझे ऐसा करने की अनुमति नहीं है, जैसे मुझे उपयोग करने की आवश्यकता है list.List।

Question 4

मुझे लगता है कि क्योंकि उनके बारे में कहने के लिए बहुत कुछ नहीं है क्योंकि जब आप जेनेरिक डेटा के साथ काम करने के लिए प्रमुख गो मुहावरा होते हैं तो container/listपैकेज आत्म-व्याख्यात्मक होता है।

डेल्फी (जेनरिक के बिना) या सी में आप TObjectसूची में पॉइंटर्स या एस स्टोर करेंगे , और फिर सूची से प्राप्त करते समय उन्हें अपने वास्तविक प्रकारों में वापस डाल देंगे। C ++ में STL सूचियाँ टेम्प्लेट होती हैं और इसलिए प्रकार के द्वारा इन्हें मानकीकृत किया जाता है, और C # (इन दिनों) सूची में सामान्य हैं।

गो में, container/listप्रकारों के मूल्यों को संग्रहीत करता है interface{}जो एक विशेष प्रकार है जो किसी अन्य (वास्तविक) प्रकार के मानों को दर्शाने में सक्षम है - एक जोड़ी बिंदुओं को संचय करके: निहित मूल्य के प्रकार की जानकारी के लिए एक, और मूल्य के सूचक (या) मूल्य सीधे, अगर यह आकार एक सूचक के आकार से अधिक नहीं है)। इसलिए जब आप सूची में एक तत्व जोड़ना चाहते हैं, तो आप बस उस प्रकार के कार्य मानदंड interface{}मानों को किसी भी प्रकार से स्वीकार करते हैं। लेकिन जब आप सूची से मान निकालते हैं, और उनके वास्तविक प्रकारों के साथ काम करने के लिए आपको या तो उन्हें टाइप-एसर्ट करना होगा या उन पर एक प्रकार का स्विच करना होगा - दोनों दृष्टिकोण अनिवार्य रूप से एक ही काम करने के लिए बस अलग-अलग तरीके हैं।

यहाँ एक उदाहरण यहाँ से लिया गया है :

package main

import ("fmt" ; "container/list")

func main() {
    var x list.List
    x.PushBack(1)
    x.PushBack(2)
    x.PushBack(3)

    for e := x.Front(); e != nil; e=e.Next() {
        fmt.Println(e.Value.(int))
    }
}

यहां हम एक तत्व के मूल्य का उपयोग करते हुए प्राप्त करते हैं e.Value()और फिर इसे intमूल सम्मिलित मूल्य के एक प्रकार के रूप में टाइप करते हैं।

आप "प्रभावी गो" या किसी अन्य परिचय पुस्तक में टाइप अभिकथन और टाइप स्विच पर पढ़ सकते हैं। container/listपैकेज के दस्तावेज़ के सारांश सभी तरीकों सूचियों समर्थन करते हैं।

Question 5

ध्यान दें कि गो स्लाइस का निर्माण append()बेसिन फ़ंक्शन के माध्यम से किया जा सकता है। हालांकि इसे कभी-कभी बैकिंग ऐरे की प्रतिलिपि बनाने की आवश्यकता होगी, यह हर बार नहीं होगा, क्योंकि गो नए एरो को आकार देगा, जो रिपोर्ट की गई लंबाई से अधिक क्षमता का होगा। इसका मतलब यह है कि एक बाद के परिशिष्ट ऑपरेशन को किसी अन्य डेटा कॉपी के बिना पूरा किया जा सकता है।

जब आप लिंक किए गए सूचियों के साथ लागू किए गए समतुल्य कोड की तुलना में अधिक डेटा प्रतियों के साथ समाप्त करते हैं, तो आप सूची में तत्वों को अलग-अलग आवंटित करने और Nextसंकेत को अद्यतन करने की आवश्यकता को हटा देते हैं । कई उपयोगों के लिए सरणी आधारित कार्यान्वयन बेहतर या अच्छा प्रदर्शन प्रदान करता है, इसलिए भाषा में इस पर बल दिया जाता है। दिलचस्प है, पायथन का मानक listप्रकार भी सरणी समर्थित है और इसमें मानों को जोड़ते समय समान प्रदर्शन विशेषताएं हैं।

उस ने कहा, ऐसे मामले हैं जहां लिंक की गई सूची एक बेहतर विकल्प है (जैसे जब आपको लंबी सूची के प्रारंभ / मध्य से तत्वों को सम्मिलित करने या निकालने की आवश्यकता होती है), और इसीलिए एक मानक पुस्तकालय कार्यान्वयन प्रदान किया जाता है। मुझे लगता है कि वे अपने साथ काम करने के लिए कोई विशेष भाषा सुविधाएँ नहीं जोड़ते थे क्योंकि ये मामले उन लोगों की तुलना में कम होते हैं जहाँ स्लाइस का उपयोग किया जाता है।

Question 6

जब तक कि स्लाइस को बहुत बार अपडेट नहीं किया जाता है (हटाएं, यादृच्छिक स्थानों पर तत्वों को जोड़ें) स्लाइस की मेमोरी संयुक्ताक्षर लिंक्ड सूची की तुलना में उत्कृष्ट कैश हिट अनुपात की पेशकश करेगा।

कैश के महत्व पर स्कॉट मेयर की बात .. https://www.youtube.com/watch?v=WDIkqP4JbkE

Question 7

list.Listएक दोहरी लिंक की गई सूची के रूप में कार्यान्वित किया जाता है। एरे-आधारित सूचियाँ (C ++ में वैक्टर, या गोलैंग में स्लाइस) अधिकांश स्थितियों में लिंक की गई सूचियों की तुलना में बेहतर विकल्प हैं यदि आप अक्सर सूची के मध्य में सम्मिलित नहीं होते हैं। परिशिष्ट के लिए परिमित समय जटिलता O (1) है दोनों सरणी सूची और लिंक की गई सूची के लिए भले ही सरणी सूची में क्षमता का विस्तार करना और मौजूदा मूल्यों की प्रतिलिपि बनाना है। सरणी सूचियों में डेटा संरचना के अंदर कोई संकेत नहीं होने के कारण तेज़ रैंडम एक्सेस, छोटी मेमोरी फ़ुटप्रिंट, और अधिक महत्वपूर्ण रूप से कचरा कलेक्टर के अनुकूल है।

Question 8

प्रेषक: https://groups.google.com/forum/#/msg/golang-nuts/mPKCoYNwsoU/tLefhE7tQjMJ

यह आपकी सूचियों में तत्वों की संख्या पर बहुत कुछ निर्भर करता है,
 क्या एक सच्ची सूची या एक टुकड़ा अधिक कुशल होगा
 जब आपको सूची के 'मध्य' में कई विलोपन करने की आवश्यकता होती है।

# 1
अधिक तत्व, कम आकर्षक एक टुकड़ा बन जाता है। 

# 2
जब तत्वों का क्रम महत्वपूर्ण नहीं है,
 यह एक स्लाइस का उपयोग करने के लिए सबसे अधिक कुशल है और
 किसी तत्व को स्लाइस में अंतिम तत्व द्वारा बदलकर हटाना
 1 से लेन को सिकोड़ने के लिए स्लाइस को फिर से जोड़ना
 (जैसा कि स्लाइसट्रिक्स विकी में बताया गया है)

इसलिए
स्लाइस का उपयोग करें
। यदि सूची में तत्वों का क्रम महत्वपूर्ण नहीं है, और आपको हटाने की आवश्यकता है, तो
अंतिम तत्व के साथ हटाने के लिए सूची स्वैप तत्व का उपयोग करें, और तत्व (लंबाई -1)
2. फिर से जब तत्व अधिक हों ( जो कुछ और साधन)

There are ways to mitigate the deletion problem --
e.g. the swap trick you mentioned or
just marking the elements as logically deleted.
But it's impossible to mitigate the problem of slowness of walking linked lists.

तो
स्लाइस का उपयोग करें
1. यदि आपको ट्रैवर्सल में गति की आवश्यकता है