गो में, मैं एक स्ट्रिंग बेस प्रकार वाले प्रकार के लिए "कन्स्ट्रक्टर" कैसे बना सकता हूं?

Question

एक प्रकार Char टाइप करने का प्रयास कर रहा है जो एक string एक वर्ण लंबा है। जो मैं करने में असमर्थ हूं वह "कन्स्ट्रक्टर" बना रहा है। मुझे पता है कि मैं कुछ पूरी तरह से याद कर रहा हूँ।

Char प्रकार की घोषणा

 
    type Char string 

एक घोषणा

 
    var c1 Char("abc") 
    var c2 Char = "abc" 

इन गलत हैं के साथ उस प्रकार का उपयोग कर सकते हैं: c1 और c2 होने के लिए "एक" की जरूरत है, नहीं "abc"

जो मैं वास्तव में चाहता हूं वह चार से एक वर्ण को सीमित करने के लिए "कन्स्ट्रक्टर" है

 
func Char(s string) Char { 
    var ch string = s[0] 
    return ch 
} 

पाठ्यक्रम type Char और func Char होने के

जिस तरह से यह

 
type.go:8: Char redeclared in this block 

वहाँ एक निर्माता के माध्यम से type आरंभीकरण के लिए मजबूर करने के लिए किसी भी तरह से है करने के लिए नहीं है? या मैं भी सही सवाल पूछ रहा हूँ?

मुझे राज्य को अलग ढंग से करते हैं: उपयोगकर्ता कहते हैं अगर var c Char = "abc" वे प्रकार Char लिए एक अमान्य मान होगा - वहाँ func NewChar(string) CharChar के रूप में के ही मान्य निर्माता में उपयोगकर्ता के लिए मजबूर करने के लिए किसी भी तरीका है?

Answer 1

यह char पैकेज है।अप्रत्याशित Charstruct फ़ील्ड c पर ध्यान दें।

package char 

type Char struct { 
    c rune 
} 

func New(c rune) *Char { 
    return &Char{c} 
} 

func (c *Char) Char() rune { 
    return c.c 
} 

func (c *Char) String() string { 
    return string(c.c) 
} 

यहां char पैकेज का उपयोग करने का उदाहरण दिया गया है।

package main 

import (
    "char" 
    "fmt" 
) 

func main() { 
    var c = char.New('z') 
    var d = c.Char() 
    hello := "Hello, world; or สวัสดีชาวโลก" 
    h := []rune(hello) 
    ก := char.New(h[len(h)-1]) 
    fmt.Println(c, "a-"+c.String(), '0' <= d && d <= '9', ก) 
} 

आउटपुट:

z a-z false ก 

Answer 2

पहले, निम्न उदाहरण देखें।

package main 

func main() { 
    s := "hello 世界" 
    //for getting characters from string 

    cells := []int(s) 
    for _, c := range cells { 
     println(c, string(c)) 
     // You'll get 
     // 104 h 
     // 101 e 
     // 108 l 
     // 108 l 
     // 111 o 
     // 32 
     // 19990 世 
     // 30028 界 
    } 

    bytes := []byte(s) 
    for _, b := range bytes { 
     println(b, string(b)) 
     // 104 
     // 101 
     // 108 
     // 108 
     // 111 
     // 32 
     // 228 
     // 184 
     // 150 
     // 231 
     // 149 
     // 140 
    } 
} 

[] int का अर्थ "यूनिकोड वर्णों में डाला गया" है। [] बाइट्स का अर्थ "बाइट्स पर डाला गया" है।

और, गो में कंस्ट्रक्टर नहीं है। गो की शैली में, पैकेज XXX ऑब्जेक्ट के लिए फ़ंक्शन न्यूXXएक्स() प्रदान करता है।

type Client struct { 
    // ... 
} 

func NewClient() *Client { 
    return &Client{/* ... */} 
} 

अद्यतन:

आप "स्ट्रिंग का 1 तत्व" के रूप में चार मतलब हैं, तो आप निम्नलिखित के रूप में परिभाषित करना चाहिए।

type Char int 

या

type Char byte 

आपकी परिभाषा

type Char string 

है "स्ट्रिंग" की फिर से परिभाषित। फिर यह स्ट्रिंग स्टोर कर सकते हैं।

Answer 3

जाओ में एक एकल यूनिकोड चरित्र एक uint32 आप निम्न कर सकता का प्रतिनिधित्व करती है:

type Char uint32 
var a Char = 'a' 

एक निर्माता के लिए कोई ज़रूरत नहीं है, क्योंकि आप सिर्फ चरित्र शाब्दिक उपयोग कर सकते हैं।

Answer 4

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

type Char string 

func NewChar(s string) Char { 
    if len(s) == 0 { 
     return Char("") 
    } 
    return Char(s[:1]) 
}