उदाहरण और मुहावरे पर जाएं [बंद]

Question

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

मैं भी ढूंढ रहा हूं

• मुहावरों में जाने के लिए मुहावरेदार तरीके,
• जाने के लिए "पोर्टेड" सोचने की सी / सी ++ शैली,
• वाक्यविन्यास के बारे में सामान्य नुकसान,
• कुछ भी दिलचस्प, वास्तव में।

Comments

एआरएम जैसे 8-बिट या 16-बिट का समर्थन करता है। D भाषा अभी भी नहीं है।

लाइब्रेरी ( golang.org/pkg ) यह जानने के लिए एक उत्कृष्ट स्रोत है कि कैसे उपयोग किया जाता है। व्यक्तिगत रूप से, मुझे लगता है कि भाषा सीखने के लिए डेटा संरचना कैसे कार्यान्वित की जाती है, यह सीखना उपयोगी है।

— त्सुकसिह

Answer 1

बयान दर्ज करें

एक "डेफर" कथन एक फ़ंक्शन को लागू करता है जिसका निष्पादन आस-पास के फ़ंक्शन रिटर्न के क्षण को स्थगित कर दिया जाता है।

DeferStmt = "defer" अभिव्यक्ति।

अभिव्यक्ति एक फ़ंक्शन या विधि कॉल होनी चाहिए। हर बार "डिफर" कथन निष्पादित होता है, फ़ंक्शन कॉल के मापदंडों का मूल्यांकन किया जाता है और नए सिरे से बचाया जाता है लेकिन फ़ंक्शन को लागू नहीं किया जाता है। आस-पास के फ़ंक्शन रिटर्न से ठीक पहले LIFO ऑर्डर में डिफर्ड फ़ंक्शन कॉल निष्पादित की जाती हैं, लेकिन रिटर्न वैल्यू के बाद, यदि कोई हो, का मूल्यांकन किया गया है।

lock(l);
defer unlock(l);  // unlocking happens before surrounding function returns

// prints 3 2 1 0 before surrounding function returns
for i := 0; i <= 3; i++ {
    defer fmt.Print(i);
}

अपडेट करें:

deferअब panicएक अपवाद जैसे तरीके से निपटने के लिए मुहावरेदार तरीका भी है:

package main

import "fmt"

func main() {
    f()
    fmt.Println("Returned normally from f.")
}

func f() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered in f", r)
        }
    }()
    fmt.Println("Calling g.")
    g(0)
    fmt.Println("Returned normally from g.")
}

func g(i int) {
    if i > 3 {
        fmt.Println("Panicking!")
        panic(fmt.Sprintf("%v", i))
    }
    defer fmt.Println("Defer in g", i)
    fmt.Println("Printing in g", i)
    g(i+1)
}

Comments

अच्छा पुराना RAII (स्पष्ट किया गया) जैसा दिखता है।

— कोनराड रुडोल्फ

+1 जब से मैंने गो के बारे में बहुत कुछ पढ़ा है, लेकिन मैंने तब भी यह नहीं देखा (जब तक आपने मुझे नहीं दिखाया)!

— u0b34a0f6ae

चतुर, हालांकि यह मेरे लिए और अधिक समझ में आता है अगर बयानों को स्थगित कर दें जहां FIFO ऑर्डर में निष्पादित किया गया है (ऊपर से नीचे), लेकिन शायद यह सिर्फ मेरे लिए है ...

— माइक स्पॉस

ठंडा। डी से Scrop गार्ड की मुझे याद दिलाता है digitalmars.com/d/2.0/exception-safe.html

— Hasen

@ माइक: यदि आप "कोशिश: .. अंत:" के ब्लॉक से तुलना करते हैं, तो LIFO उसी तरह से घोंसला बनाता है। संसाधन ओपन / क्लोज पेयर आदि के लिए, इस तरह घोंसला बनाना केवल एक चीज है जो समझ में आता है (पहला खुला अंतिम बंद हो जाएगा)।

— u0b34a0f6ae

Answer 2

ऑब्जेक्ट ऑब्जेक्ट फ़ाइलों में वास्तव में एक स्पष्ट शीर्ष लेख शामिल होता है:

jurily@jurily ~/workspace/go/euler31 $ 6g euler31.go
jurily@jurily ~/workspace/go/euler31 $ cat euler31.6
amd64
  exports automatically generated from
  euler31.go in package "main"
    import

$$  // exports
  package main
    var main.coin [9]int
    func main.howmany (amount int, max int) (? int)
    func main.main ()
    var main.initdone· uint8
    func main.init ()

$$  // local types
  type main.dsigddd_1·1 struct { ? int }

$$

!
<binary segment>

Comments

यही कारण है कि अधिक एक मुहावरेदार उदाहरण की तुलना में एक छिपा सुविधा की तरह है

— Hasen

Answer 3

मैंने कुछ लोगों को फॉर-लूप के बारे में शिकायत करते हुए देखा है, "हमें i = 0; i < len; i++इस दिन और उम्र में क्यों कहना चाहिए ?" की तर्ज पर ।

मैं असहमत हूं, मुझे निर्माण पसंद है। आप चाहें तो लंबे संस्करण का उपयोग कर सकते हैं, लेकिन मुहावरेदार गो है

var a = []int{1, 2, 3}
for i, v := range a {
    fmt.Println(i, v)
}

for .. rangeसूचकांक - निर्माण सब कुछ खत्म हो तत्वों और आपूर्ति दो मानों लूप iऔर मूल्य v।

range नक्शे और चैनलों पर भी काम करता है।

फिर भी, यदि आप नापसंद करते हैं forकिसी भी रूप में, आप को परिभाषित कर सकते each, mapआदि कुछ लाइनों में:

type IntArr []int

// 'each' takes a function argument.
// The function must accept two ints, the index and value,
// and will be called on each element in turn.
func (a IntArr) each(fn func(index, value int)) {
    for i, v := range a {
        fn(i, v)
    }
}

func main() {
    var a = IntArr([]int{2, 0, 0, 9}) // create int slice and cast to IntArr
    var fnPrint = func(i, v int) {
        fmt.Println(i, ":", v)
    } // create a function

    a.each(fnPrint) // call on each element
}

प्रिंट

0 : 2
1 : 0
2 : 0
3 : 9

मुझे बहुत अच्छा लगने लगा है :)

Comments

हालांकि rangeयह केवल अच्छा है, अगर इसे उसी कोड के लिए संकलित किया जाता है जैसे कि -3 लूप।

— थॉमस अहले

Answer 4

जाओ और अपनी स्टैकओवरफ़्लो प्रतिष्ठा प्राप्त करें

यह इस उत्तर का अनुवाद है ।

package main

import (
    "json"
    "fmt"
    "http"
    "os"
    "strings"
)

func die(message string) {
    fmt.Printf("%s.\n", message);
    os.Exit(1);
}

func main() {
    kinopiko_flair := "https://stackoverflow.com/users/flair/181548.json"
    response, _, err := http.Get(kinopiko_flair)
    if err != nil {
        die(fmt.Sprintf("Error getting %s", kinopiko_flair))
    }

    var nr int
    const buf_size = 0x1000
    buf := make([]byte, buf_size)

    nr, err = response.Body.Read(buf)
    if err != nil && error != os.EOF {
        die(fmt.Sprintf("Error reading response: %s", err.String()))
    }
    if nr >= buf_size { die ("Buffer overrun") }
    response.Body.Close()

    json_text := strings.Split(string(buf), "\000", 2)
    parsed, ok, errtok := json.StringToJson(json_text[0])
    if ! ok {
        die(fmt.Sprintf("Error parsing JSON %s at %s", json_text, errtok))
    }

    fmt.Printf("Your stackoverflow.com reputation is %s\n", parsed.Get ("reputation"))
}

स्कॉट वेल्स की मदद के लिए धन्यवाद .Read ()

यह दो तारों और दो बफ़र्स के साथ अभी भी काफी भद्दा दिखता है, इसलिए यदि किसी भी गो विशेषज्ञों की सलाह है, तो मुझे बताएं।

Comments

मुझे यकीन नहीं है कि क्या स्वरूपण के साथ गलत होना चाहिए था; मैंने इसे बहाल कर दिया है।

गो लेखक gofmtआपके कोड को सुझाते हैं :-)

— authorsएफ़िंक

मैं इसे संकलित नहीं कर सकता: $ ../go/src/cmd/6g/6g SO.go SO.go: 34: अपरिभाषित: json.StringToJson

— inkएफ़िंक

@ संदर्भ: जब से मैंने इसे बनाया है, भाषा बदल गई है।

हाँ, क्या आप जानते हैं कि स्ट्रींगटोज़न के निकटतम समकक्ष क्या है? यह एक बिल्डर को आंतरिक रूप से स्थापित करने के लिए इस्तेमाल किया गया था, अब किसी को एक पूर्वनिर्धारित मूल संरचना के साथ अपने स्वयं को प्रदान करना है?

— मैकबर्डी

Answer 5

यहाँ Kinopiko पोस्ट से iota का एक अच्छा उदाहरण है :

type ByteSize float64
const (
    _ = iota;   // ignore first value by assigning to blank identifier
    KB ByteSize = 1<<(10*iota)
    MB
    GB
    TB
    PB
    YB
)

// This implicitly repeats to fill in all the values (!)

Comments

ध्यान दें कि अर्धविराम अनावश्यक हैं।

— mk12

Answer 6

आप समानांतर असाइनमेंट द्वारा चर स्वैप कर सकते हैं:

x, y = y, x

// or in an array
a[j], a[i] = a[i], a[j]

सामान्य लेकिन प्रभावी।

Answer 7

यहाँ प्रभावी गो पेज से एक मुहावरा है

switch {
case '0' <= c && c <= '9':
    return c - '0'
case 'a' <= c && c <= 'f':
    return c - 'a' + 10
case 'A' <= c && c <= 'F':
    return c - 'A' + 10
}
return 0

जब कोई अभिव्यक्ति नहीं दी जाती है तो स्विच स्टेटमेंट सही होता है। तो यह इसके बराबर है

if '0' <= c && c <= '9' {
    return c - '0'
} else if 'a' <= c && c <= 'f' {
    return c - 'a' + 10
} else if 'A' <= c && c <= 'F' {
    return c - 'A' + 10
}
return 0

फिलहाल, स्विच संस्करण मुझे थोड़ा साफ दिखता है।

Comments

वाह, पूरी तरह से वीबी से फट गया। ;-) ( Switch True…)

— कोनराड रूडोल्फ

@ कोनराड, मुझे हरा दो! :) मैंने उस मुहावरे का उपयोग VB6 कोड से पहले किया है और यह निश्चित रूप से कुछ स्थितियों में पठनीयता में मदद कर सकता है।

— माइक स्पॉस

'<=' क्या है? यह '<-' से संबंधित है?

— 32फिंक

@ छाप: कम-से-या-बराबर।

— पॉल रुआन

Answer 8

स्विच टाइप करें :

switch i := x.(type) {
case nil:
    printString("x is nil");
case int:
    printInt(i);  // i is an int
case float:
    printFloat(i);  // i is a float
case func(int) float:
    printFunction(i);  // i is a function
case bool, string:
    printString("type is bool or string");  // i is an interface{}
default:
    printString("don't know the type");
}

Answer 9

पैकेज आयात करते समय, आप किसी भी चीज़ को अपने नाम को फिर से परिभाषित कर सकते हैं:

package main

import f "fmt"

func main() {
    f.Printf("Hello World\n")
}

Comments

मैंने पहले ही इसका उपयोग कर लिया है: stackoverflow.com/questions/1726698/…

Answer 10

नाम दिया गया परिणाम पैरामीटर

गो फ़ंक्शन के "परिणाम" मापदंडों को आने वाले मापदंडों की तरह ही नाम दिया जा सकता है और नियमित चर के रूप में उपयोग किया जा सकता है। जब नाम दिया जाता है, तो वे फ़ंक्शन शुरू होने पर अपने प्रकारों के लिए शून्य मानों के लिए आरंभिक होते हैं; यदि फ़ंक्शन बिना किसी तर्क के रिटर्न स्टेटमेंट निष्पादित करता है, तो परिणाम पैरामीटर के वर्तमान मानों को लौटे मानों के रूप में उपयोग किया जाता है।

नाम अनिवार्य नहीं हैं, लेकिन वे कोड को छोटा और स्पष्ट कर सकते हैं: वे दस्तावेज हैं। अगर हम नेक्स्ट के नतीजों को नाम देते हैं तो यह स्पष्ट हो जाता है कि जो int वापस आ गया है वह कौन सा है।

func nextInt(b []byte, pos int) (value, nextPos int) {

चूँकि नामांकित परिणाम आरंभ होते हैं और एक अनियंत्रित रिटर्न से बंधे होते हैं, वे सरल होने के साथ-साथ स्पष्ट भी कर सकते हैं। यहाँ io.ReadFull का एक संस्करण है जो उन्हें अच्छी तरह से उपयोग करता है:

func ReadFull(r Reader, buf []byte) (n int, err os.Error) {
    for len(buf) > 0 && err == nil {
        var nr int;
        nr, err = r.Read(buf);
        n += nr;
        buf = buf[nr:len(buf)];
    }
    return;
}

Comments

मैं उत्सुक हूँ - क्या किसी अन्य भाषा में यह है?

— u0b34a0f6ae

मतलाब में भी कुछ ऐसा ही है।

— डैन लोरेंके

पास्कल एक मान लौटाने के लिए समान सिंटैक्स का उपयोग करता है।

— nes1983

@ nes1983 उन लोगों के लिए जो पास्कल में नहीं हैं, आप फ़ंक्शन नाम के लिए रिटर्न वैल्यू को शास्त्रीय रूप से असाइन करते हैं।

— फ़ूज

FORTRAN बहुत ज्यादा यह है।

— Hut8

Answer 11

से जेम्स Antill के जवाब :

foo := <-ch     // This blocks.
foo, ok := <-ch // This returns immediately.

इसके अलावा, एक संभावित नुकसान: ऑपरेटरों को भेजने और भेजने के बीच का सूक्ष्म अंतर :

a <- ch // sends ch to channel a
<-ch    // reads from channel ch

Comments

ऑपरेटर प्राप्त ही है अब, एक अवरुद्ध आपरेशन जाओ 1.0.3 के रूप में। युक्ति को संशोधित किया गया है: golang.org/ref/spec#Receive_operator । कृपया यहां अवरुद्ध व्यवहार (गतिरोध) का प्रयास करें: play.golang.org/p/0yurtWW4Q3

— Deleplace

Answer 12

/* 
 * How many different ways can £2 be made using any number of coins?
 * Now with 100% less semicolons!
 */

package main
import "fmt"


/* This line took me over 10 minutes to figure out.
 *  "[...]" means "figure out the size yourself"
 * If you only specify "[]", it will try to create a slice, which is a reference to an existing array.
 * Also, ":=" doesn't work here.
 */
var coin = [...]int{0, 1, 2, 5, 10, 20, 50, 100, 200}

func howmany(amount int, max int) int {
    if amount == 0 { return 1 }
    if amount < 0 { return 0 }
    if max <= 0 && amount >= 1 { return 0 }

    // recursion works as expected
    return howmany(amount, max-1) + howmany(amount-coin[max], max)
}


func main() {
    fmt.Println(howmany(200, len(coin)-1))
}

Comments

मैं समस्या निवारण साइट के नाम के साथ ही आईडी नंबर को हटाने का सुझाव दूंगा। हो सकता है कि इस सवाल का जवाब दें। के रूप में किसी को इस पर ठोकर खाने के लिए समस्या को खराब करने के लिए नहीं। या उस मामले के लिए नेट पर समस्या को खोजकर धोखा देने की कोशिश कर रहा है।

— मिजिपजोर

रिकॉर्ड के लिए: यह एल्गोरिथम से एल्गोरिथ्म है। Adex.php/ Coin_Change यह "सिक्का परिवर्तन" के लिए पहला Google परिणाम है।

— ग्योर्गी एंड्रेसेक

Answer 13

मुझे यह पसंद है कि आप प्रकारों को फिर से परिभाषित कर सकते हैं, जिसमें आदिम भी शामिल हैं, जैसे कि कई बार जब आप पसंद करते हैं और विभिन्न तरीकों को संलग्न करते हैं। रोमननुमरल प्रकार को परिभाषित करने की तरह:

package main

import (
    "fmt"
    "strings"
)

var numText = "zero one two three four five six seven eight nine ten"
var numRoman = "- I II III IV V VI VII IX X"
var aText = strings.Split(numText, " ")
var aRoman = strings.Split(numRoman, " ")

type TextNumber int
type RomanNumber int

func (n TextNumber) String() string {
    return aText[n]
}

func (n RomanNumber) String() string {
    return aRoman[n]
}

func main() {
    var i = 5
    fmt.Println("Number: ", i, TextNumber(i), RomanNumber(i))
}

जो प्रिंट करता है

Number:  5 five V

RomanNumber()कॉल अनिवार्य रूप से एक डाली है, यह पूर्णांक के अधिक विशिष्ट प्रकार के रूप में पूर्णांक प्रकार पुनर्परिभाषित। और परदे के पीछे Println()बुलाता है String()।

Answer 14

एक चैनल लौट रहा है

यह एक सच्चा मुहावरा है जो काफी महत्वपूर्ण है: एक चैनल में डेटा कैसे खिलाएं और बाद में इसे बंद करें। इसके साथ आप सरल पुनरावृत्तियों को बना सकते हैं (चूंकि सीमा एक चैनल को स्वीकार करेगी) या फ़िल्टर।

// return a channel that doubles the values in the input channel
func DoublingIterator(input chan int) chan int {
    outch := make(chan int);
    // start a goroutine to feed the channel (asynchronously)
    go func() {
        for x := range input {
            outch <- 2*x;    
        }
        // close the channel we created and control
        close(outch);
    }();
    return outch;
}

Comments

+1। इसके अलावा, आप चैनलों के माध्यम से भी चैनल पास कर सकते हैं।

— गॉर्गी एंडरसेक

लेकिन एक्स के लिए बाहर नहीं तोड़ने के लिए सावधान रहें: = रेंज चान {} लूप, आप गोरोइन का रिसाव करेंगे, और सभी मेमोरी के संदर्भ।

— जेफ एलन

@JeffAllen कैसे गोरोइन defer close(outch);के पहले बयान के बारे में?

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

— जेफ एलन

Answer 15

चैनल के लिए टाइमआउट पढ़ता है:

ticker := time.NewTicker(ns);
select {
    case v := <- chan_target:
        do_something_with_v;
    case <- ticker.C:
        handle_timeout;
}

डेविस लियू से चोरी ।

Answer 16

for {
    v := <-ch
    if closed(ch) {
        break
    }
    fmt.Println(v)
}

चूंकि सीमा किसी बंद चैनल के लिए स्वचालित रूप से जांच करती है, इसलिए हम इसे छोटा कर सकते हैं:

for v := range ch {
    fmt.Println(v)
}

Answer 17

एक मेक सिस्टम सेट है जिसे आप $ GOROOT / src में उपयोग कर सकते हैं

के साथ अपने मेकअप सेट करें

TARG=foobar           # Name of package to compile
GOFILES=foo.go bar.go # Go sources
CGOFILES=bang.cgo     # Sources to run cgo on
OFILES=a_c_file.$O    # Sources compiled with $Oc
                      # $O is the arch number (6 for x86_64)

include $(GOROOT)/src/Make.$(GOARCH)
include $(GOROOT)/src/Make.pkg

फिर आप मेक टेस्ट चलाकर स्वचालित परीक्षण उपकरण का उपयोग कर सकते हैं, या कॉगो से पैकेज और साझा किए गए ऑब्जेक्ट को मेक इनस्टॉल के साथ जोड़ सकते हैं।

Answer 18

गो में एक और दिलचस्प बात यह है कि godoc। आप इसका उपयोग करके अपने कंप्यूटर पर वेब सर्वर के रूप में चला सकते हैं

godoc -http=:8080

जहां 8080 पोर्ट नंबर है, और फिर golang.org पर पूरी वेबसाइट पर उपलब्ध है localhost:8080।

Comments

क्या यह एक नियमित कार्यक्रम या डेमॉन है?

— गॉर्गी एंडरसेक

यह एक नियमित कार्यक्रम है।

— जेरेमी

Answer 19

यह एक स्टैक का कार्यान्वयन है। यह एक प्रकार पर विधियों को जोड़कर दिखाता है।

मैं इसके स्लाइस के हिस्से को एक स्लाइस में बनाना चाहता था और स्लाइस के गुणों का उपयोग करना चाहता था, लेकिन यद्यपि मुझे इसके बिना काम करना था type, मैं एक के साथ एक स्लाइस को परिभाषित करने के लिए वाक्यविन्यास नहीं देख सकता था type।

package main

import "fmt"
import "os"

const stack_max = 100

type Stack2 struct {
    stack [stack_max]string
    size  int
}

func (s *Stack2) push(pushed_string string) {
    n := s.size
    if n >= stack_max-1 {
        fmt.Print("Oh noes\n")
        os.Exit(1)
    }
    s.size++
    s.stack[n] = pushed_string
}

func (s *Stack2) pop() string {
    n := s.size
    if n == 0 {
        fmt.Print("Underflow\n")
        os.Exit(1)
    }
    top := s.stack[n-1]
    s.size--
    return top
}

func (s *Stack2) print_all() {
    n := s.size
    fmt.Printf("Stack size is %d\n", n)
    for i := 0; i < n; i++ {
        fmt.Printf("%d:\t%s\n", i, s.stack[i])
    }
}

func main() {
    stack := new(Stack2)
    stack.print_all()
    stack.push("boo")
    stack.print_all()
    popped := stack.pop()
    fmt.Printf("Stack top is %s\n", popped)
    stack.print_all()
    stack.push("moo")
    stack.push("zoo")
    stack.print_all()
    popped2 := stack.pop()
    fmt.Printf("Stack top is %s\n", popped2)
    stack.print_all()
}

Comments

उपयोग करने के बजाय fmt.Printf(...); os.Exit();, आप उपयोग कर सकते हैं panic(...)।

— नॉटेनोप

यह एक स्टैक ट्रेस देता है, जो मुझे नहीं चाहिए।

यह सीमित क्यों है? गो एक प्रबंधित, gc'd भाषा है। आपका स्टैक जितना चाहें उतना गहरा हो सकता है। नए एपेंड () बिल्टिन का उपयोग करें, जो कि सी के रियललोक की तरह कुछ करेगा जब इसे करना होगा।

— जेफ एलन

"गो को जेनरिक की जरूरत नहीं है", उन्होंने कहा।

— 12us पर cubuspl42

Answer 20

गो से सी कोड कॉलिंग

सी रनटाइम का उपयोग करके गो के निचले स्तर तक पहुंचना संभव है।

C फ़ंक्शन फॉर्म में हैं

void package·function(...)

(ध्यान दें डॉट सेपरेटर एक यूनिकोड वर्ण है) जहां तर्क मूल गो प्रकार, स्लाइस, स्ट्रिंग्स आदि हो सकते हैं। वैल्यू कॉल वापस करने के लिए।

FLUSH(&ret)

(आप एक से अधिक मूल्य वापस कर सकते हैं)

उदाहरण के लिए, एक फंक्शन बनाने के लिए

package foo
bar( a int32, b string )(c float32 ){
    c = 1.3 + float32(a - int32(len(b))
}

C में आप उपयोग करते हैं

#include "runtime.h"
void foo·bar(int32 a, String b, float32 c){
    c = 1.3 + a - b.len;
    FLUSH(&c);
}

ध्यान दें कि आपको अभी भी फ़ंक्शन को एक गो फ़ाइल में घोषित करना चाहिए, और आपको स्वयं मेमोरी का ध्यान रखना होगा। मुझे यकीन नहीं है कि अगर इसका उपयोग करके बाहरी पुस्तकालयों को कॉल करना संभव है, तो कॉगो का उपयोग करना बेहतर हो सकता है।

रनटाइम में उपयोग किए गए उदाहरणों के लिए $ GOROOT / src / pkg / रनटाइम को देखें।

सी ++ कोड को गो के साथ लिंक करने के लिए यह उत्तर भी देखें ।

Comments

क्या यह "फ्लाइंग डॉट" का उपयोग करता है, वास्तव में? मैं संपादित करने की हिम्मत नहीं करता, लेकिन यह थोड़ा अप्रत्याशित और कट्टरपंथी लगता है।

— खोलना

हां, आपको 6 सी (या 8 सी, आदि) के साथ संकलन करने की आवश्यकता है। मुझे नहीं लगता कि जीसीसी यूनिकोड पहचानकर्ताओं को संभालता है।

— स्कॉट वेल्स

मुझे लगता है कि AltGr + पीरियड समान हैं। लेकिन यूनिकोड के साथ मुझे यकीन नहीं है। यह देखकर बहुत आश्चर्य हुआ कि मैंने जो स्रोत पढ़ा है .. उसमें कुछ का उपयोग क्यों नहीं किया गया ::?

— u0b34a0f6ae

चरित्र MIDDLE DOT U + 00B7 है। हो सकता है कि पार्सर को ठग लिया गया हो ताकि वह इसे एक वैध सी पहचानकर्ता बनाने के लिए एक चरित्र के रूप में देखता है, जो मुझे विश्वास है कि ::।

— स्कॉट वेल्स

'·' सिर्फ एक अस्थायी हैक है, यहां तक ​​कि लूट भी आश्चर्यचकित था कि यह अभी भी है, उन्होंने कहा कि इसे कुछ कम आइडियोस्पिरेटिक के साथ बदल दिया जाएगा।

— uriel

Answer 21

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

http://github.com/bikal/gosqlite-example

Answer 22

क्या आपने यह बात देखी ? यह आपके द्वारा किए जा सकने वाले बहुत अच्छे सामान को दिखाता है (बात का अंत)

Comments

हाँ, मैंने किया। यह "वहाँ बहुत अधिक है, चलो अगले विषय पर चलते हैं।"

— ग्योर्गी आंद्रेसेक

हां, जाहिरा तौर पर बहुत कम समय के साथ कहने के लिए

Answer 23

एक स्टैक अन्य उत्तर पर आधारित है, लेकिन स्लाइस का उपयोग करके कोई आकार सीमा नहीं है।

package main

import "fmt"
import "os"

type Stack2 struct {
        // initial storage space for the stack
        stack [10]string
        cur   []string
}

func (s *Stack2) push(pushed_string string) {
        s.cur = append(s.cur, pushed_string)
}

func (s *Stack2) pop() (popped string) {
        if len(s.cur) == 0 {
                fmt.Print("Underflow\n")
                os.Exit(1)
        }
        popped = s.cur[len(s.cur)-1]
        s.cur = s.cur[0 : len(s.cur)-1]
        return
}

func (s *Stack2) print_all() {
        fmt.Printf("Stack size is %d\n", len(s.cur))
        for i, s := range s.cur {
                fmt.Printf("%d:\t%s\n", i, s)
        }
}

func NewStack() (stack *Stack2) {
        stack = new(Stack2)
        // init the slice to an empty slice of the underlying storage
        stack.cur = stack.stack[0:0]
        return
}

func main() {
        stack := NewStack()
        stack.print_all()
        stack.push("boo")
        stack.print_all()
        popped := stack.pop()
        fmt.Printf("Stack top is %s\n", popped)
        stack.print_all()
        stack.push("moo")
        stack.push("zoo")
        stack.print_all()
        popped2 := stack.pop()
        fmt.Printf("Stack top is %s\n", popped2)
        stack.print_all()
}

Answer 24

const ever = true

for ever {
    // infinite loop
}

Comments

अहम। for { /* infinite loop */ }पर्याप्त है।

— u0b34a0f6ae

बेशक। ठीक वैसा ही यहां हो रहा है। मुझे सिर्फ foreverकीवर्ड पसंद है । यहां तक ​​कि Qt के लिए एक मैक्रो है।

— ग्योर्गी आंद्रसेक 22

लेकिन गो को ऐसा करने के लिए किसी मैक्रो या सच्चे उपनाम की जरूरत नहीं है।

— u0b34a0f6ae

@ kaizer.se: जुरी की बात यह है कि for ever(चर घोषित करने के बाद) कुछ प्यारा है जिसे आप गो में करना चाहते हैं। यह अंग्रेजी (मॉडुलो द ब्लैंक) जैसा दिखता है।

— फ्रैंक

यह कुछ प्यारा है जिसे आप C में भी कर सकते हैं .. :-)#define ever (;;)

— u0b34a0f6ae

Answer 25

testमुख्य निर्देशिका में बहुत सारे छोटे कार्यक्रम हैं । उदाहरण:

• peano.go गुटों को प्रिंट करता है।
• hilbert.go कुछ मैट्रिक्स गुणन है।
• iota.go अजीब बात है कोटा के उदाहरण हैं।