गो स्लाइस, गतिशील सरणियाँ जो लचीले डेटा हेरफेर प्रदान करती हैं, में सीधा “हटाएँ” फ़ंक्शन नहीं होता है। तत्वों को हटाने के लिए एक अलग दृष्टिकोण की आवश्यकता होती है। यह लेख कुशल तकनीकों का विवरण देता है, इष्टतम प्रदर्शन के लिए उप-स्लाइसिंग पर ध्यान केंद्रित करता है।
विषयवस्तु की तालिका
एकल तत्व को हटाना
एकल तत्व को हटाने का सबसे कुशल तरीका लक्ष्य तत्व को छोड़कर एक नया स्लाइस बनाना है। यह गो की स्लाइसिंग क्षमताओं का लाभ उठाता है, पूर्ण सरणी प्रतिलिपि के बिना अंतर्निहित सरणी में एक दृश्य बनाता है। यह अपेंडिंग या व्यक्तिगत तत्व प्रतिलिपि से जुड़े तरीकों की तुलना में काफी तेज़ है, खासकर बड़े स्लाइस के लिए।
package main
import "fmt"
func main() {
mySlice := []int{10, 20, 30, 40, 50}
indexToDelete := 2 // इंडेक्स 2 (मान 30) पर तत्व हटाएँ
newSlice := append(mySlice[:indexToDelete], mySlice[indexToDelete+1:]...)
fmt.Println("मूल स्लाइस:", mySlice)
fmt.Println("हटाने के बाद स्लाइस:", newSlice)
}
यह कोड newSlice को दो उप-स्लाइस जोड़कर बनाता है: mySlice[:indexToDelete] (लक्ष्य से पहले के तत्व) और mySlice[indexToDelete+1:] (लक्ष्य के बाद के तत्व)। एलिप्सिस ऑपरेटर (…) दूसरे स्लाइस को जोड़ने के लिए अनपैक करता है। मूल mySlice अपरिवर्तित रहता है।
एक से अधिक तत्वों को हटाना
एक से अधिक तत्वों को हटाने के लिए उप-स्लाइसिंग दृष्टिकोण का विस्तार करना कम सरल है लेकिन बड़े स्लाइस के लिए पुनरावृति अपेंडिंग की तुलना में अभी भी अधिक कुशल है। जबकि एकल, संक्षिप्त उप-स्लाइस ऑपरेशन संभव नहीं है, हम आवंटनों को कम करने के लिए प्रक्रिया को अनुकूलित कर सकते हैं।
package main
import "fmt"
func main() {
mySlice := []int{10, 20, 30, 40, 50}
indicesToDelete := []int{1, 3} // हटाए जाने वाले इंडेक्स
newSlice := make([]int, 0, len(mySlice)-len(indicesToDelete)) // दक्षता के लिए पूर्व-आवंटित करें
for i, val := range mySlice {
shouldDelete := false
for _, index := range indicesToDelete {
if i == index {
shouldDelete = true
break
}
}
if !shouldDelete {
newSlice = append(newSlice, val)
}
}
fmt.Println("मूल स्लाइस:", mySlice)
fmt.Println("हटाने के बाद स्लाइस:", newSlice)
}
यह बेहतर उदाहरण अपेंडिंग के दौरान आवंटनों को कम करने के लिए newSlice को पूर्व-आवंटित करता है, जिससे दक्षता बढ़ती है। यह पुनरावृति करता है, indicesToDelete के विरुद्ध जांच करता है, और केवल बनाए रखने के लिए तत्वों को जोड़ता है।
एक शर्त के आधार पर तत्वों को हटाना
एक शर्त के आधार पर तत्वों को हटाने के लिए अक्सर पुनरावृत्ति की आवश्यकता होती है। जबकि एकल विलोपन के लिए उप-स्लाइसिंग की तुलना में कम कुशल है, यह सशर्त निष्कासन के लिए आवश्यक है।
package main
import "fmt"
func main() {
mySlice := []int{10, 20, 30, 40, 50}
newSlice := make([]int, 0, len(mySlice)) //दक्षता के लिए पूर्व-आवंटित करें
for _, val := range mySlice {
if val != 30 { // 30 के बराबर तत्वों को हटाएँ
newSlice = append(newSlice, val)
}
}
fmt.Println("मूल स्लाइस:", mySlice)
fmt.Println("हटाने के बाद स्लाइस:", newSlice)
}
यह उदाहरण val != 30 शर्त के आधार पर तत्वों को फ़िल्टर करता है। newSlice का पूर्व-आवंटन प्रदर्शन में सुधार करता है। बड़े स्लाइस और लगातार सशर्त विलोपन के लिए, एक अलग फ़ंक्शन के साथ फ़िल्टरिंग या एक अलग डेटा संरचना का उपयोग करने जैसी अधिक उन्नत तकनीकों पर विचार करें।
प्रदर्शन पर विचार
एकल-तत्व हटाने के लिए, उप-स्लाइसिंग सबसे कुशल दृष्टिकोण बना रहता है। एकाधिक या सशर्त विलोपन को अक्सर पुनरावृत्ति की आवश्यकता होती है, लेकिन परिणामी स्लाइस को पूर्व-आवंटित करने से प्रदर्शन में गिरावट काफी कम हो जाती है। इष्टतम प्रदर्शन के लिए, विशेष रूप से बड़े डेटासेट के साथ, जब भी लागू हो, उप-स्लाइसिंग को प्राथमिकता दें।