Go भाषा डेटा प्रकार का विस्तृत अध्ययन

1 गो भाषा में डेटा प्रकार का परिचय

गो भाषा में, डेटा प्रकार प्रोग्रामिंग का आधार होते हैं, जो चर जोकि रूप में परिभाषित डेटा को भंडारित कर सकते हैं। गो भाषा द्वारा प्रदत्त मूल डेटा प्रकारों को मुख्य रूप से निम्नलिखित श्रेणियों में विभाजित किया जाता है:

इन प्रकारों को विभिन्न आवश्यकताओं के अनुसार चुना जा सकता है, जैसे कि सांख्यिकीय गणना, पाठ प्रसंस्करण, या तार्किक नियंत्रण।

3.1 फ्लोटिंग प्वाइंट डेटा टाइप का अवलोकन

गो भाषा में, फ्लोटिंग प्वाइंट टाइप्स में float32 और float64 शामिल हैं, जो 32-बिट और 64-बिट फ्लोटिंग पॉइंट डेटा को संदर्भित करते हैं। सामान्य रूप से, float64 का उपयोग करना सुझावित है क्योंकि यह फ्लोटिंग पॉइंट की एक बड़ी रेंज और अधिक सटीक प्रेसिजन प्रदान करता है।

• float32 में लगभग 23 महत्वपूर्ण बिट होते हैं, जो लगभग 7 दशमलव अंकों की परिप्रेक्ष्य प्रदान करते हैं।
• float64 में लगभग 52 महत्वपूर्ण बिट होते हैं, जो लगभग 16 दशमलव अंकों की परिप्रेक्ष्य प्रदान करते हैं।

3.2 फ्लोटिंग प्वाइंट वेरिएबल का उपयोग

फ्लोटिंग प्वाइंट वेरिएबल सीधे मान देकर या var कीवर्ड का इस्तेमाल करके घोषित किए जा सकते हैं:

package main
import "fmt"

func main() {
    var f1 float32 = 3.14 // float32 टाइप को स्पष्ट रूप से निर्दिष्ट करें
    f2 := 3.14            // स्वचालित रूप से float64 टाइप के रूप में निर्धारित होता है
    fmt.Println(f1, f2)
}

3.3 फ्लोटिंग प्वाइंट अंकगणित और समस्याएँ

फ्लोटिंग-पॉइंट अंकगणित में सटीकता का हानि हो सकता है। खासकर जब दो बहुत करीबी संख्याओं को घटाने के समय, इस समस्या का सामना करना आम होता है।

package main
import "fmt"

func main() {
    f1 := .1
    f2 := .2
    f3 := f1 + f2
    fmt.Println(f3) // सटीकता समस्याओं के कारण अपेक्षित .3 नहीं हो सकता

    // सूचीत प्रिंटफ़ का उपयोग करके सटीकता समस्याओं को सुधारना 
    fmt.Printf("%.1f\n", f3) // आउटपुट को .3 में संशोधित किया गया
}

4 बूलियन डेटा टाइप

4.1 बूलियन डेटा टाइप का अवलोकन

बूलियन सबसे सरल डेटा टाइप है, और इसमें केवल दो मूल्य हो सकते हैं: true (सत्य) और false (झूठ)। यह शर्ती विवधान और लूप नियंत्रण संरचनाओं में एक बहुत महत्वपूर्ण स्थान धारण करता है।

4.2 बूलियन वेरिएबल का उपयोग

बूलियन वेरिएबल घोषित करना और उपयोग करना:

package main
import "fmt"

func main() {
    var success bool = true
    var fail bool = false
    fmt.Println("सफलतापूर्वक कार्रवाई:", success)
    fmt.Println("कार्रवाई विफल हुई:", fail)
}

बूलियन मान अक्सर शर्ती विवधानों में उपयोग किए जाते हैं:

package main
import "fmt"

func main() {
    a := 10
    b := 20
    fmt.Println("a == b:", a == b) // झूठ
    fmt.Println("a < b:", a < b)   // सच
}

5 स्ट्रिंग डेटा टाइप

5.1 स्ट्रिंग अवलोकन

एक स्ट्रिंग एक वर्णों का संग्रह होता है। गो भाषा में, स्ट्रिंग अपरिवर्तनीय होती हैं। प्रत्येक स्ट्रिंग में दो हिस्से होते हैं: परिष्करण बाइट ऐरे के लिए एक पॉइंटर और एक लंबाई। स्ट्रिंग में किसी भी डेटा को शामिल किया जा सकता है, जिसमें बाइट्स भी शामिल हैं।

5.2 स्ट्रिंग वेरिएबल का उपयोग

स्ट्रिंग वेरिएबल आमतौर पर डबल कोट्स " का उपयोग करके घोषित की जाती हैं, लेकिन आप बैकटिक्स ` का उपयोग करके बहु-लाइन स्ट्रिंग बना सकते हैं:

package main
import "fmt"

func main() {
    var s1 string = "नमस्ते"
    s2 := "दुनिया"
    s3 := `यह एक 
    बहु-लाइन
    स्ट्रिंग है`
    fmt.Println(s1)
    fmt.Println(s2)
    fmt.Println(s3)
}

एक बार स्ट्रिंग बना दि जाती है, उसकी सामग्री को बदला नहीं जा सकता। निम्नलिखित क्रिया अवैध है और एक संकलन त्रुटि का कारण बनेगी:

s := "नमस्ते"
s[] = 'H` // संकलन त्रुटि: स्ट्रिंग सामग्री बदल नहीं सकती

5.3 स्ट्रिंग ऑपरेशंस

स्ट्रिंगें कोडिंग में बहुत ही सामान्य और महत्वपूर्ण होती हैं। गो भाषा में स्ट्रिंग संशोधन के लिए बहुत सारे इनबिल्ट फ़ंक्शंस प्रदान करती है। यहां कुछ सामान्यत: स्ट्रिंग संशोधन के लिए उपयोग की जाने वाली ऑपरेशन हैं।

5.3.1 स्ट्रिंग संयोजन

गो भाषा में, आप स्ट्रिंग संयोजन के लिए प्लस साइन (+) ऑपरेटर का इस्तेमाल कर सकते हैं, जो सबसे सीधी विधि है। अतः, जब बहुत सारी स्ट्रिंगों का अक्सर संयोजन किया जाता है, तो बेहतर प्रदर्शन के लिए strings.Builder का इस्तेमाल करना सुझावित है।

package main

import (
    "fmt"
    "strings"
)

func main() {
    // प्लस साइन का इस्तेमाल करके स्ट्रिंग संयोजन
    hello := "नमस्ते, "
    world := "दुनिया!"
    result := hello + world
    fmt.Println(result) // आउटपुट: नमस्ते, दुनिया!

    // strings.Builder का इस्तेमाल करके स्ट्रिंग संयोजन
    var sb strings.Builder
    sb.WriteString("नमस्ते, ")
    sb.WriteString("दुनिया!")
    fmt.Println(sb.String()) // आउटपुट: नमस्ते, दुनिया!
}

5.3.2 स्ट्रिंग विभाजन

स्ट्रिंग विभाजन को निर्दिष्ट विभाजक के आधार पर स्लाइस में विभाजित करने के लिए strings.Split फंक्शन का उपयोग किया जा सकता है।

package main

import (
    "fmt"
    "strings"
)

func main() {
    // एक स्ट्रिंग को परिभाषित करें
    sentence := "Go एक ओपन सोर्स प्रोग्रामिंग भाषा है"

    // स्पेस के द्वारा स्ट्रिंग विभाजित करें
    words := strings.Split(sentence, " ")
    for _, word := range words {
        fmt.Printf("%s\n", word)
    }
    // आउटपुट:
    // Go
    // एक
    // ओपन
    // सोर्स
    // प्रोग्रामिंग
    // भाषा
    // है
}

5.3.3 इंडेक्स एक्सेस

Go में, एक स्ट्रिंग एक अपरिवर्तनीय बाइटों की अनुक्रमणिका होती है। आप एक स्ट्रिंग में विशिष्ट बाइट्स तक पहुंचने के लिए इंडेक्सिंग का उपयोग कर सकते हैं। हालांकि, महत्वपूर्ण है कि क्योंकि एक स्ट्रिंग में मल्टी-बाइट वर्ण हो सकते हैं (जैसे UTF-8 एन्कोडेड वर्ण), सीधे इंडेक्सिंग से अपेक्षित एकल वर्ण नहीं मिल सकता।

package main

import "fmt"

func main() {
    s := "हैलो, 世界"
    for i := 0; i < len(s); i++ {
        fmt.Printf("%d: %x\n", i, s[i])
    }
    // ध्यान दें: यह बाइट्स के हेक्साडेसिमल प्रतिनिधित्व को आउटपुट करेगा, वर्णों का नहीं
}

स्ट्रिंग को वर्ण द्वारा इटरेट करने के लिए, आप range लूप का उपयोग कर सकते हैं।

package main

import "fmt"

func main() {
    s := "हैलो, 世界"
    for index, runeValue := range s {
        fmt.Printf("%d: %U '%c'\n", index, runeValue, runeValue)
    }
    // आउटपुट: प्रत्येक वर्ण के लिए इंडेक्स, यूनिकोड एन्कोडिंग, और खुद वर्ण
}

5.3.4 लंबाई प्राप्त करना

len फंक्शन स्ट्रिंग की लंबाई, अर्थात अंतर्निहित बाइट सिरेन्स की लंबाई प्राप्त कर सकता है। UTF-8 स्ट्रिंग्स के लिए, यदि आपको वर्णों (रन्स) की संख्या प्राप्त करनी हो, तो आपको utf8.RuneCountInString फंक्शन का उपयोग करना चाहिए। यह मल्टी-बाइट वर्णों को सही तरीके से हैंडल कर सकता है।

package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    s := "हैलो, 世界"
    fmt.Println("बाइट्स लंबाई:", len(s)) // आउटपुट बाइटों की लंबाई
    fmt.Println("रन्स लंबाई:", utf8.RuneCountInString(s)) // वर्णों की लंबाई आउटपुट करें
}

उपरोक्त उदाहरण से, हम देख सकते हैं कि गो भाषा स्ट्रिंग संचालन कार्यों को पूरा करने के लिए समृद्ध पुस्तकालयीन फंक्शन प्रदान करती है। कोडिंग करते समय, बाइट्स और वर्णों के बीच भेद का ध्यान देना महत्वपूर्ण है, विशेष रूप से गैर-ASCII वर्ण समूहों के साथ निपटते समय।