ভাষাটি শেখার জন্য খুব বেশি কোড কোড নেই, এবং আমি নিশ্চিত যে এটির পরীক্ষার জন্য আমিই একমাত্র নই। সুতরাং, যদি আপনি ভাষা সম্পর্কে আকর্ষণীয় কিছু খুঁজে পেয়ে থাকেন তবে দয়া করে এখানে একটি উদাহরণ পোস্ট করুন।
আমিও খুঁজছি
উত্তর:
বিবৃতি স্থগিত করুন
একটি "মুলতুবি" বিবৃতি এমন একটি ফাংশনকে আহ্বান করে যার পার্শ্ববর্তী ফাংশনটি ফিরে আসার মুহুর্তে তার কার্যভার স্থগিত হয়।
DeferStmt = "মুলতুবি" এক্সপ্রেশন।
এক্সপ্রেশন অবশ্যই একটি ফাংশন বা পদ্ধতি কল হতে হবে। প্রতিবার "মুলতুবি" স্টেটমেন্ট কার্যকর করার সময়, ফাংশন কলের পরামিতিগুলি মূল্যায়ন করা হয় এবং নতুনভাবে সংরক্ষণ করা হয় তবে ফাংশনটি চালিত হয় না। আশেপাশের ফাংশন রিটার্নের আগেই ডিফার্ড ফাংশন কলগুলি 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)
}
গো অবজেক্ট ফাইলগুলিতে একটি ক্লিয়ারটেক্সট শিরোনাম অন্তর্ভুক্ত থাকে:
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>
"কয়েকজন লোককে" i = 0; i < len; i++এই দিন এবং যুগে আমাদের কেন বলতে হবে ? " এর পংক্তিতে" লুপ "সম্পর্কে অভিযোগ করতে দেখেছি ।
আমি দ্বিমত পোষণ করছি, আমি নির্মাণের জন্য পছন্দ করি। আপনি চাইলে লম্বা সংস্করণটি ব্যবহার করতে পারেন, তবে মুশকিল গো
var a = []int{1, 2, 3}
for i, v := range a {
fmt.Println(i, v)
}
for .. rangeসূচক - কনস্ট্রাক্ট সর্বাঙ্গে উপাদান এবং সরবরাহ দুটি মানের loops 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
আমি গো অনেক পছন্দ করতে শুরু করছি :)
rangeএটি দুর্দান্ত, যদি এটি -3 লুপের মতো একই কোডে সংকলিত হয়।
এই একটি অনুবাদ এই উত্তর ।
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"))
}
স্কট ওয়েলসকে সহায়তার জন্য ধন্যবাদ .পড়ুন ()।
দুটি স্ট্রিং এবং দুটি বাফার সহ এটি মোটামুটি আড়ষ্ট দেখাচ্ছে, সুতরাং যদি কোনও বিশেষজ্ঞ বিশেষজ্ঞদের পরামর্শ পান তবে আমাকে জানান।
gofmtআপনার
কিনোপিকোর পোস্ট থেকে আওতার একটি দুর্দান্ত উদাহরণ এখানে দেওয়া হয়েছে :
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 (!)
সমান্তরাল কার্যক্রমে আপনি ভেরিয়েবলগুলি অদলবদল করতে পারেন:
x, y = y, x
// or in an array
a[j], a[i] = a[i], a[j]
সহজ কিন্তু কার্যকর
এফেক্টিভ গো পৃষ্ঠার একটি প্রতিমা এখানে
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
এই মুহুর্তে, স্যুইচ সংস্করণটি আমার কাছে একটু ক্লিনার দেখাচ্ছে।
Switch True…)
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");
}
প্যাকেজগুলি আমদানি করার সময়, আপনি নিজের পছন্দের যে কোনও কিছুতে নামটি পুনরায় সংজ্ঞায়িত করতে পারেন:
package main
import f "fmt"
func main() {
f.Printf("Hello World\n")
}
নামযুক্ত ফলাফলের পরামিতি
গো ফাংশনের রিটার্ন বা ফলাফল "পরামিতি" দেওয়া যেতে পারে এবং আগত প্যারামিটারের মতো নিয়মিত ভেরিয়েবল হিসাবে ব্যবহার করা যেতে পারে। নামকরণ করা হলে, ফাংশন শুরু হলে এগুলি তাদের ধরণের শূন্য মানগুলিতে আরম্ভ করা হয়; যদি ফাংশনটি কোনও যুক্তি ছাড়াই একটি রিটার্ন বিবৃতি কার্যকর করে, ফলাফলের পরামিতিগুলির বর্তমান মানগুলি প্রত্যাবর্তিত মান হিসাবে ব্যবহৃত হয়।
নামগুলি বাধ্যতামূলক নয় তবে তারা কোডটি আরও সংক্ষিপ্ত এবং পরিষ্কার করতে পারে: তারা ডকুমেন্টেশন। আমরা যদি পরবর্তী ফলাফলগুলির নাম রাখি তবে এটি স্পষ্ট হয়ে ওঠে যা কোনটি প্রত্যাবর্তন করবে।
func nextInt(b []byte, pos int) (value, nextPos int) {
নামযুক্ত ফলাফলগুলির সূচনা এবং অবিচ্ছিন্ন রিটার্নের সাথে আবদ্ধ হওয়ার কারণে তারা সরলকরণের পাশাপাশি স্পষ্ট করতে পারে cla এখানে 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;
}
থেকে জেমস Antill এর উত্তর :
foo := <-ch // This blocks.
foo, ok := <-ch // This returns immediately.
এছাড়াও, একটি সম্ভাব্য ক্ষতি: প্রাপ্তি এবং প্রেরণ অপারেটরের মধ্যে সূক্ষ্ম পার্থক্য :
a <- ch // sends ch to channel a
<-ch // reads from channel ch
/*
* 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))
}
আমি পছন্দ করি যে আপনি বিভিন্ন ধরণের পুনঃনির্ধারণ করতে পারবেন, যেমন ইন্টের মতো আদিমগুলি, যতবার আপনি পছন্দ করেন এবং বিভিন্ন পদ্ধতি সংযুক্ত করেন। রোমান সংখ্যা সংক্রান্ত ধরণের সংজ্ঞা দেওয়ার মতো:
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()কল মূলত একটি নিক্ষেপ করা হয়, এটা int- এ একটি নির্দিষ্ট ধরনের যেমন int- এ টাইপ redefines। এবং পর্দার পিছনে Println()কল String()।
এটি একটি সত্য আইডিয়োম যা বেশ গুরুত্বপূর্ণ: কীভাবে কোনও চ্যানেলে ডেটা ফিড করা যায় এবং এটি পরে বন্ধ করে দেওয়া যায়। এটির সাহায্যে আপনি সাধারণ পুনরাবৃত্তি করতে পারেন (যেহেতু পরিসীমা কোনও চ্যানেল গ্রহণ করবে) বা ফিল্টারগুলি।
// 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;
}
চ্যানেল পড়ার সময়সীমা:
ticker := time.NewTicker(ns);
select {
case v := <- chan_target:
do_something_with_v;
case <- ticker.C:
handle_timeout;
}
ডেভিস লিউ থেকে চুরি ।
একটি মেক সিস্টেম সেট আপ করা হয়েছে যা আপনি $ 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
তারপরে আপনি মেক টেস্ট চালিয়ে অটোমেটেড টেস্টিং সরঞ্জামগুলি ব্যবহার করতে পারেন, বা মেক ইনস্টলের সাথে প্যাকেজটি এবং ভাগ objects
গো-তে আরও একটি আকর্ষণীয় বিষয় হ'ল godoc। আপনি এটি ব্যবহার করে এটি আপনার কম্পিউটারে একটি ওয়েব সার্ভার হিসাবে চালাতে পারেন
godoc -http=:8080
যেখানে 8080 হ'ল বন্দর নম্বর এবং golang.org- এ সম্পূর্ণ ওয়েবসাইটটি তখন পাওয়া যাবে localhost:8080।
এটি একটি স্ট্যাকের একটি বাস্তবায়ন। এটি একটি প্রকারের মধ্যে পদ্ধতি যুক্ত করার চিত্র তুলে ধরেছে।
আমি এর স্ট্যাকের অংশটি একটি টুকরো টুকরো করে তৈরি করতে চেয়েছিলাম এবং স্লাইসের বৈশিষ্ট্যগুলি ব্যবহার করতে চাই, তবে যদিও আমি এটিটি ছাড়া কাজ করতে পেলাম 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()
}
fmt.Printf(...); os.Exit();আপনি ব্যবহার করতে পারেন panic(...)।
গো কোড থেকে সি কোডিং করা হচ্ছে
সি রানটাইম ব্যবহার করে নীচের স্তরে যাওয়ার সুযোগ পাওয়া সম্ভব।
সি ফাংশন ফর্ম হয়
void package·function(...)
(নোট বিভাজকটি একটি ইউনিকোড অক্ষর নোট করুন) যেখানে আর্গুমেন্টগুলি মৌলিক গো প্রকার, টুকরোগুলি, স্ট্রিং ইত্যাদি হতে পারে a
FLUSH(&ret)
(আপনি একাধিক মান ফেরত দিতে পারেন)
উদাহরণস্বরূপ, একটি ফাংশন তৈরি করতে
package foo
bar( a int32, b string )(c float32 ){
c = 1.3 + float32(a - int32(len(b))
}
সি আপনি ব্যবহার
#include "runtime.h"
void foo·bar(int32 a, String b, float32 c){
c = 1.3 + a - b.len;
FLUSH(&c);
}
মনে রাখবেন যে আপনার এখনও একটি গো ফাইলে ফাংশনটি ঘোষণা করা উচিত, এবং আপনাকে নিজের স্মৃতির যত্ন নিতে হবে। আমি এটি নিশ্চিত না যে এটি ব্যবহার করে বাহ্যিক লাইব্রেরিগুলি কল করা সম্ভব কিনা, cgo ব্যবহার করা ভাল।
রানটাইমটিতে ব্যবহৃত উদাহরণগুলির জন্য OR GOROOT / src / pkg / রানটাইমটি দেখুন।
গো এর সাথে সি ++ কোড যুক্ত করার জন্য এই উত্তরটিও দেখুন ।
Sqlite3 প্যাকেজটি ব্যবহার করে এখানে যাওয়ার উদাহরণ example
তুমি কি এই আলোচনাটি দেখেছ ? এটি আপনি করতে পারেন এমন অনেক দুর্দান্ত জিনিস দেখায় (আলাপের শেষে)
অন্য উত্তরের উপর ভিত্তি করে একটি স্ট্যাক, তবে কোনও আকার সীমা নেই এটিকে যোগ করে স্লাইস ব্যবহার করা।
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()
}
const ever = true
for ever {
// infinite loop
}
for { /* infinite loop */ }যথেষ্ট।
foreverকীওয়ার্ডটি পছন্দ করি । এমনকি কিউটি এর জন্য ম্যাক্রো রয়েছে।
for ever(ভেরিয়েবল ঘোষণার পরে) আপনি চাইলে গো-তে কিছু সুন্দর করতে পারেন। এটি দেখতে ইংলিশের মতো (ফাঁকা ফাঁকা মডুলু)।
#define ever (;;)
testমূল ডিরেক্টরিতে অনেকগুলি ছোট প্রোগ্রাম রয়েছে । উদাহরণ:
peano.go মুদ্রণ ফ্যাকটোরিয়ালস।hilbert.go কিছু ম্যাট্রিক্স গুণ আছে।iota.go অদ্ভুত আইটা জিনিসের উদাহরণ রয়েছে।