پست‌های انتشارات گولنگ_پارسی

28.آموزش GO با مثال(زمان تأخیر)

Alireza Shamsi — Wed, 13 Mar 2019 08:29:53 +0330

زمان تأخیر برای برنامه هایی که به منابع خارجی وصل می شوند اهمیت دارد یا در غیر این صورت به زمان اجرای محدود نیاز پیدا میکنند. پیاده سازی این وقفه ها در زبان گو به لطف کانال ها و select راحت و عالی شده است.package main import "time" import "fmt" func main() {برای این مثال , فرض کنید ما یک ارجاع خارجی اجرا میکنیم که نتیجه آن را در کانال c1 بعد از 2 ثانیه برمیگرداند. c1 := make(chan string, 1) go func() { time.Sleep(2 * time.Second) c1 <- "result 1" }()در اینجا پیاده سازی select یک زمان تأخیر است. res := <-c1منتظر نتیجه میماند و <-Time.After منتظر یک مقدار میماند تا آن را پس از زمان تأخیر 1ثانیه ارسال کند. زمانی که select با اولین دریافتی ای که آماده است اقدام میکند،در حالتی که عملیات بیشتر از 1ثانیه زمان بگیرد ما مقدار تأخیر از آن میگیریم. select { case res := <-c1: fmt.Println(res) case <-time.After(1 * time.Second): fmt.Println("timeout 1") }اگر ما اجازه دهیم که زمان تأخیر از 3ثانیه بیشتر شود، در این صورت ما c2را با موفقیت دریافت میکنیم و آن را به عنوان نتیجه در خروجی چاپ میکنیم. c2 := make(chan string, 1) go func() { time.Sleep(2 * time.Second) c2 <- "result 2" }() select { case res := <-c2: fmt.Println(res) case <-time.After(3 * time.Second): fmt.Println("timeout 2") } }اجرای این برنامهاجرای این برنامه نشان میدهد که اولین و دومین عملیات زمان تأخیر با موفقیت اجرا میشود.$ go run timeouts.go timeout 1 result 2استفاده از الگوی انتخاب زمان تأخیر(select timeout) نیازمند برقراری ارتباط از طریق کانالهاست.به صورت عمومی این یک ایده خوب است چون مهمترین ویژگی های GO رو کانالها و select بنا شده اند. در آینده ما به دو مثال از این مورد خواهیم پرداخت: تایمرها و tickers. << دستور Select ---------------------------------- عملیات کانال غیر مسدود >>

27.آموزش GO با مثال(Select)

Alireza Shamsi — Sat, 09 Mar 2019 13:18:08 +0330

دستور select در GO این امکان را به شما میدهدکه روی عملیات کانال چندگانه بتوانید زمان گذاری کنید.ترکیب کردن goroutineها و کانالها با select یک ویژگی قدرتمند Go است.package main import "time" import "fmt" func main() {برای مثال ما select را بر روی دو کانالمان اعمال مکنیم. c1 := make(chan string) c2 := make(chan string)هر کانال یک مقدار را پس از گذری از زمان دریافت میکند , به عنوان مثال برای شبیه سازی . عملیات های مسدود سازی RPC در goroutine ها همزمان اجرا میشوند. go func() { time.Sleep(1 * time.Second) c1 <- "one" }() go func() { time.Sleep(2 * time.Second) c2 <- "two" }()ما از select برای منتظر گذاشتن هردوی این مقادیر به صورت همزمان استفاده میکنیم , هرکدام از آنها که نوبت آن میرسد را چاپ کنیم. for i := 0; i < 2; i++ { select { case msg1 := <-c1: fmt.Println("received", msg1) case msg2 := <-c2: fmt.Println("received", msg2) } } }اجرای این برنامهما ابتدا مقدار "one" و سپس "two" به صورت جداگانه دریافت میکنیم.$ time go run select.go received one received twoتوجه داشته باشید که زمان اجرای کل فقط~2 ثانیه است زیرا هر دو 1 و 2 ثانیه Sleeps همزمان اجرا میشوند.real 0m2.245s<<هدایت کانال----------------------------------------زمان تأخیر>>

26.آموزش GO با مثال(هدایت کانال)

Alireza Shamsi — Wed, 13 Feb 2019 09:40:10 +0330

وقتی شما از کانالها به عنوان پارامترهای تابعی استفاده میکنید،میتونید مشخص کنید که کانال برای ارسال و دریافت مقادیر است. این خاصیت نوع-ایمنی برنامه را افزایش میدهد .package main import "fmt"تابع ping تنها یک کانال برای ارسال مقادیر را قبول میکند. اگر بخواهیم سعی کنیم که دریافت را روی این کانال داشته باشیم میتونه یک خطای زمان اجرا رو پدید بیاره.func ping(pings chan<- string, msg string) { pings <- msg }تابع pong کانال اول برای دریافت مقادیر(pings) و کانال دوم را برای ارسال مقادیر (pongs) قبول میکند.func pong(pings <-chan string, pongs chan<- string) { msg := <-pings pongs <- msg } func main() { pings := make(chan string, 1) pongs := make(chan string, 1) ping(pings, "passed message") pong(pings, pongs) fmt.Println(<-pongs) }اجرای این برنامه$ go run channel-directions.go passed message<<هماهنگ سازی کانال-------------------------------------- Select >>

25.آموزش GO با مثال(هماهنگ سازی کانال)

Alireza Shamsi — Wed, 13 Feb 2019 09:09:37 +0330

ما از کانالها برای اجرایی کردن هماهنگ سازی ها در سرتا سر goroutineها استفاده میکنیم. اینجا یک مثال از استفاده اونها رو داریم که یک دریافت به حالت بلاک شده تا پایان کار یک goroutine صبر میکند.package main import "fmt" import "time"این تابعی است که در یک goroutine اجرا میشود. کانال doneبرای اعلان کردن goroutine دیگری استفاده میشود و این مفهوم را میرساند که این تابع کارش را به اتمام رسانده است.func worker(done chan bool) { fmt.Print("working...") time.Sleep(time.Second) fmt.Println("done")ارسال یک مقدار برای اینکه نشان دهیم ما این کار را انجام داده ایم. done <- true } func main() {یک goroutine به نام worker آغاز میشود, که یک اعلان روی آن پیاده شده است. done := make(chan bool, 1) go worker(done) تا زمانی که ما یک اعلان را از سمت worker که رو channelهست دریافت کنیم برنامه مسدود است. <-done }اجرای این برنامه$ go run channel-synchronization.go working...done اگر شما خط done-> را از این برنامه پاک کنید, برنامه قبل از این که رویداد worker شروع شود تمام خواهد شد.<<بافر کردن کانال---------------------------------- هدایت کانال>>

24.آموزش GO با مثال(بافر کردن کانال)

Alireza Shamsi — Wed, 06 Feb 2019 13:59:01 +0330

به صورت پیش فرض کانال ها بافر نشده هستند، به این معنی که ارسال ها را به وسیله (->chan) قبول میکنند ،اگر یک دریافت کننده مطابق با آن مثل (chan->) وجود داشته باشد آماده است تا مقدار های ارسال شده را دریافت کند.کاناهالهای بافر شده تعداد محدودی مقدار را بدون مطابقت دریافت کننده برای این مقادیر قبول میکنند. package main import "fmt" func main() {اینجا ما از تابع درونی make برای ساختن یک کانالی که 2 مقدار را در خود بافر میکند داریم. messages := make(chan string, 2)چون این کانال بافر شده است, ما میتونیم این مقادیر رو بدون یک دریافت همزمان تطبیقی به کانال ارسال کنیم . messages <- "buffered" messages <- "channel"و در بعد ما میتونیم به صورت معمول این دو مقدار را دریافت کنیم. fmt.Println(<-messages) fmt.Println(<-messages) }اجرای این برنامه $ go run channel-buffering.go buffered channel<<کانالها----------------------------------------------- هماهنگ سازی کانال >>

23.آموزش GO با مثال(کانالها)

Alireza Shamsi — Wed, 06 Feb 2019 13:27:03 +0330

کانالها لوله هایی هستند که به طور همزمان goroutine ها را به یکدیگر متصل میکنند. شما میتونید یک مقدار به وسیله کانالها از یک goroutine ارسال کنید و مقداررو از طریق یک goroutine دیگر دریافت کنید.package main import "fmt" func main() {یک کانال جدید رو به وسیله (make(chan val-typeمیسازند. نوع کانالها به وسیله نوع مقادیری که آنها حمل میکنند تعیین میشود. messages := make(chan string)به وسیله نحو ->channelما یک مقدار رو به یک کانال ارسال میکنیم. اینجا ما کلمه "ping" رو به کانال messages که بالا ساخته بودیم ارسال کردیم, از یک goroutineجدید. go func() { messages <- "ping" }()نحوchannel-> مقداری رو از کانال دریافت میکنه. اینجا ما پیغام "ping" که بالا ارسال کرده بودیم را دریافت میکنیم و آن را در خروجی چاپ میکنیم. msg := <-messages fmt.Println(msg) }اجرای این برنامهوقتی که ما برنامه "ping" را اجرا میکنیم پیغام با موفقیت از یک goroutineبه دیگری به وسیله کانال ما پاس میدهد. $ go run channels.go pingبه صورت پیش فرض ارسال ها و دریافت ها مسدودند تا زمانی که ارسال کننده و دریافت کننده آماده باشند. این ویژگی به ما اجازه میدهد که تا پایان برنامه ما برای پیغام "ping" صبر کنیم بدون اینکه از هماهنگ سازی های دیگر استفاده کنیم.<<(روالهای گو)Goroutines---------------------------------------- بافر کردن کانال>>

22.آموزش GO با مثال(Goroutines)

Alireza Shamsi — Wed, 06 Feb 2019 00:27:19 +0330

یک goroutine (روال گو) یک نخ سبک اجرایی است.package main import "fmt" func f(from string) { for i := 0; i < 3; i++ { fmt.Println(from, ":", i) } } func main() {فرض کنید ما یک تابع داریم که (f(sرا فراخوانی میکند. اینجا ما اون رو از راه معمول فراخوانی میکنیم، اجرای آن به صورت همگام. f("direct")برای فراخوانی این تابع در goroutine, از (go f(s استفاده کنید.این goroutineجدید میتونه به صورت همروند با یکبار فراخوانی اجرا بشه. go f("goroutine")شما همچنین میتونید یک goroutine رو برای فراخوانی یک تابع ناشناس شروع کنید . go func(msg string) { fmt.Println(msg) }("going") حالا فراخوانی هردوتابع ما به صورت ناهمگام در goroutineهای جدا اجرا میشه،بنابراین اجرا در اینجا اتفاق می افتد. این Scanln نیاز داره که ما یک کلید رو قبل از اجرای برنامه فشار بدهیم. fmt.Scanln() fmt.Println("done") }اجرای این برنامهوقتی ما این برنامه رو اجرا میکنیم, فراخوانی های بلوکه رو در اول میبینیم ،سپس خروجی ترکیبی از دو goroutineهامون رو مشاهده میکنیم. این ترکیب نشان میدهد که goroutineها به صورت همزمان به وسیله زمان اجرای زبان گو اجرا میشوند. $ go run goroutines.go direct : 0 direct : 1 direct : 2 goroutine : 0 going goroutine : 1 goroutine : 2 doneدر مبحث بعدی ما به مکمل goroutineها در همروندی برنامه های گو نگاه می اندازیم: کانالها.<<خطاها-----------------------------------------------کانالها>>

21.آموزش GO با مثال(خطاها)

Alireza Shamsi — Sun, 03 Feb 2019 09:51:27 +0330

در زبان گو برای ارتباط برقرار کردن با خطاها به صورت صریح از طریق یک مقدار بازگشتی روالی وجود دارد.این در مقابل استثنائاتی که در زبانهای جاوا و روبی و همچنین مقدار سربارهای نتیجه /خطا که گاهی در زبان سی دیده میشود استفاده میشود. گو خیلی مارو به این موضوع نزدیک میکنه که ببینیم کدام تابع خطاها رو برمیگردونه یا آنها را با استفاده از ساختارهای زبان مشابه که برای هر کدام استفاده می شه،برای وظایف غیر خطا رسیدگی میکنه.package main import "errors" import "fmt"طبق قرارداد, خطاها آخرین مقدار بازگشتی را دارند ، و نوع error,میپذیرند که یک اینترفیس داخلی است .func f1(arg int) (int, error) { if arg == 42 {نحو errors.New یک مقدار errorرا با پذیرفتن یک پیام خطا میسازد. return -1, errors.New("can't work with 42") }یک مقدار nil در موقعیت خطا نشون میده که این قسمت خطایی اتفاق نیوفتاده است. return arg + 3, nil }این امکان هست که ما خطاهای سفارشی شده مانند errorرا به وسیله متد ()Error روی اونها اجرا کنیم . اینجا یک مثال متفاوت از مثال بالا داریم که از نوع خطای سفارشی شده به عنوان آرگومان خطا استفاده میکند.type argError struct { arg int prob string } func (e *argError) Error() string { return fmt.Sprintf("%d - %s", e.arg, e.prob) } func f2(arg int) (int, error) { if arg == 42 {در این حالت ما از نحو argError& برای ساختن یک سازه جدید , ارائه مقادیر برای دو فیلد argو probاستفاده کرده ایم. return -1, &argError{arg, "can't work with it"} } return arg + 3, nil } func main() {دو حلقه زیر هر یک از توابع خطا-بازگشتی مارا تست میکنند. توجه داشته باشید که بررسی یک خطای درون خطی روی خط if یک کار رایج در کد نویسی گو میباشد. for _, i := range []int{7, 42} { if r, e := f1(i); e != nil { fmt.Println("f1 failed:", e) } else { fmt.Println("f1 worked:", r) } } for _, i := range []int{7, 42} { if r, e := f2(i); e != nil { fmt.Println("f2 failed:", e) } else { fmt.Println("f2 worked:", r) } }اگر می خواهید به صورت برنامه نویسی وار از داده ها در یک خطای سفارشی استفاده کنید، شما نیاز دارید تا خطا را به عنوان نمونه از نوع خطای سفارشی از طریق نوع اعلانی(type-assertion) دریافت کنید. _, e := f2(42) if ae, ok := e.(*argError); ok { fmt.Println(ae.arg) fmt.Println(ae.prob) } }اجرای این برنامه$ go run errors.go f1 worked: 10 f1 failed: can't work with 42 f2 worked: 10 f2 failed: 42 - can't work with it 42 can't work with itاین پست کامل را روی بلاگ گو برای اطلاعات بیشتر در مورد رسیدگی به خطاها بررسی کنید. <<اینترفیس ها-------------------------------------------(روال های گو)Goroutines>>

20.آموزش GO با مثال(اینترفیس ها)

Alireza Shamsi — Mon, 28 Jan 2019 14:10:25 +0330

اینترفیس ها کالکشن هایی نام گذاری شده از اثر متد ها هستند .package main import "fmt" import "math"اینجا یه اینترفیس اولیه برای شکل های هندسی داریم.type geometry interface { area() float64 perim() float64 }برای مثالمون ما این اینترفیس رو روی انواع rectو circle اجرا میکنیم.type rect struct { width, height float64 } type circle struct { radius float64 }برای اجرای یک اینترفیس در گو, ما فقط نیاز داریم که تمام متدهای داخل اینترفیس رو اجرا کنیم.اینجا ماgeometryرا روی rectها اجرا میکنیم.func (r rect) area() float64 { return r.width * r.height } func (r rect) perim() float64 { return 2*r.width + 2*r.height } پیاده سازی برای circleها.func (c circle) area() float64 { return math.Pi * c.radius * c.radius } func (c circle) perim() float64 { return 2 * math.Pi * c.radius }اگر یک متغییر یک نوع اینترفیس داشته باشد, ما میتوانیم متد هایی که در اینترفیس نام گذاری شده اند را فراخوانی بنماییم. اینجا یک تابع جنریک measure از این موضوع برای بهره گیری روی هر geometryاستفاده میکند.func measure(g geometry) { fmt.Println(g) fmt.Println(g.area()) fmt.Println(g.perim()) } func main() { r := rect{width: 3, height: 4} c := circle{radius: 5}سازه های circle و rectهردو میتونن اینترفیس geometry را اجرا کنند بنا براین ما میتوانیم نمونه ای از این سازه ها را به عنوان آرگومان های measureاستفاده کنیم. measure(r) measure(c) }اجرای این برنامه $ go run interfaces.go {3 4} 12 14 {5} 78.53981633974483 31.41592653589793برای یادگیری بیشتر در مورد اینترفیس ها این ، پست عالی بلاگ جردن را بررسی کنید. <<متد ها------------------------------------------ خطاها>>

19.آموزش GO با مثال(متدها)

Alireza Shamsi — Mon, 28 Jan 2019 08:36:29 +0330

گو از متدهای تعریف شده روی انواع سازه ها پشتیبانی میکند.package main import "fmt" type rect struct { width, height int }متد area یک دریافت کننده از نوع *rectدارد.func (r *rect) area() int { return r.width * r.height }روش ها برای هر نوع اشاره گر یا مقدار گیرنده می توانند تعریف شوند. اینجا یه مثال از مقدار گیرنده داریم.func (r rect) perim() int { return 2*r.width + 2*r.height } func main() { r := rect{width: 10, height: 5}اینجا ما 2 متد تعریف شده روی سازه خودمون رو فراخوانی میکنیم. fmt.Println("area: ", r.area()) fmt.Println("perim:", r.perim())گو به صورت خودکار تبدیل بین مقادیر و اشاره گرها را برای فراخوانی متدها انجام می دهد. شما ممکنه از یک نوع اشاره گر گیرنده برای جلوگیری از کپی کردن روی فراخوانی متدها استفاده کنید یا به متدها برای تغییر دادن سازه های دریافتی اجازه دهید. rp := &r fmt.Println("area: ", rp.area()) fmt.Println("perim:", rp.perim()) }اجرای این برنامه$ go run methods.go area: 50 perim: 30 area: 50 perim: 30در قسمت بعدی ما به مکانیزم گو برای گروه بندی و نامگذاری مجموعه های متفاوتی از متدها نگاهی میندازیم: اینترفیس ها.<<سازه ها----------------------------------اینترفیس ها>>

18.آموزش GO با مثال(سازه ها)

Alireza Shamsi — Sun, 27 Jan 2019 10:40:00 +0330

سازه ها در گو مجموعه ای از فیلدها را تایپ میکنند. اینها برای گروه بندی داده به فرم رکورد مفید هستند.package main import "fmt"این نوع سازه person دو فیلد name و age را دارد.type person struct { name string age int } func main() {این نحو یک سازه جدید را میسازد. fmt.Println(person{"Bob", 20})هنگام ایجاد یک سازه میتوانید فیلد ها را نام گذاری کنید. fmt.Println(person{name: "Alice", age: 30})فیلدهای حذف شده صفر-مقدار خواهند بود. fmt.Println(person{name: "Fred"})یک پیشوند &یک اشاره گر به یک ساختار میدهد. fmt.Println(&person{name: "Ann", age: 40})دسترسی به فیلدهای یک سازه با نقطه. s := person{name: "Sean", age: 50} fmt.Println(s.name)همچنین شما میتونید از نقطه ها در اشاره گرهای سازه استفاده کنید - اشاره گرها به صورت خودکار غیر ارجاعی میشوند. sp := &s fmt.Println(sp.age)سازه ها قابل تغییر هستند. sp.age = 51 fmt.Println(sp.age) }اجرای این برنامه$ go run structs.go {Bob 20} {Alice 30} {Fred 0} Sean 50 51<<اشاره گرها---------------------------------------متد ها >>

17.آموزش GO با مثال(اشاره گرها)

Alireza Shamsi — Sun, 27 Jan 2019 10:11:45 +0330

گو از اشاره گرها پشتیبانی میکند, اجازه میده تا ارجاعات رو به مقادیر و رکوردها درون برنامتون بدید.package main import "fmt"اینجا ما نشون میدیم که چگونه اشاره گرها در مقابل مقادیر کار میکنند با دو تابع: zeroval و zeroptr zeroval یک پارامتر intدارد, بنابراین آرگومان در اینجا ارجاع با مقدار میشود. zeroval یک کپی از ival را میگیرد و اون رو از فرم اصلی با ارجاع به تابع متمایز میکند.func zeroval(ival int) { ival = 0 }وzeroptr در مقابل *int یک پارامتر دارد, به این معنا که یک اشاره گر int را میگیرد. *iptr کدی است در بدنه تابع سپس اشاره گر را از آدرس حافظه خود به مقدار درست آن در حافظه برمیگرداند. اختصاص دادن یک مقدار به مقدار بازگردانده شده از ارجاع ،ارزش مقدار رو در آدرس ارجاع داده شده تغییر میدهد.func zeroptr(iptr *int) { *iptr = 0 } func main() { i := 1 fmt.Println("initial:", i) zeroval(i) fmt.Println("zeroval:", i)نحو i& آدرسی از حافظه را به i،میدهد به عنوان مثال یک اشاره گر به i. zeroptr(&i) fmt.Println("zeroptr:", i)همچنین اشاره گرها میتونن نمایش داده بشن. fmt.Println("pointer:", &i) }اجرای این برنامهتابعzeroval مقدار i را در mainتغییر نمیدهد، اما zeroptr این کار را انجام میدهد چون این یک ارجاع به حافظه را برای این متغییر را دارد. $ go run pointers.go initial: 1 zeroval: 1 zeroptr: 0 pointer: 0x42131100<<بازگشتی-------------------------------------سازه ها>>

16.آموزش GO با مثال(بازگشتی ها)

Alireza Shamsi — Sat, 26 Jan 2019 16:59:59 +0330

گو از توابع بازگشتی پشتیبانی میکند. اینجا یه مثال کلاسیک فاکتوریل رو بررسی میکنیم.package main import "fmt"مثال fact تابع خودش رو تا زمانی که به حالت (fact(0برسه فراخوانی میکند.func fact(n int) int { if n == 0 { return 1 } return n * fact(n-1) } func main() { fmt.Println(fact(7)) }اجرای این برنامه$ go run recursion.go 5040<<تابع بستار----------------------------------اشاره گرها>>

15.آموزش GO با مثال (تابع بستار)

Alireza Shamsi — Sat, 26 Jan 2019 16:58:36 +0330

گو از توابع بی نام پشتیبانی میکند، که میتونه به صورت تابع بستار پیاده سازی بشود.توابع بی نام زمانی که بخواهیم یک تابع خطی را به صورت بی نام معرفی کنیم مورد استفاده قرار میگیرند. package main import "fmt"این تابع intSeq یک تابع دیگر را بر میگرداند، که ما اون رو به طور بی نام در بدنه intSeq تعریف میکنیم. تابع بازگشتی متغیر i را به فرم بستار نزدیک میکند.func intSeq() func() int { i := 0 return func() int { i++ return i } } func main() {ما intSeqرا فراخوانی میکنیم،ونتیجه تابع را به nextInt.انتصاب میدهیم.این تابع مقدار خود i را ضبط میکند، که با هر بار به روز رسانی ما nextIntرا فراخوانی میکنیم. nextInt := intSeq() تاثیر بستار رو با فراخوانی چند باره تابع nextInt مشاهده کنید. fmt.Println(nextInt()) fmt.Println(nextInt()) fmt.Println(nextInt()) برای تایید اینکه ببینیم حالت تابع برای هر تابع خاص یکتاست , یه تابع جدید رو میسازیم و امتحان میکنیم. newInts := intSeq() fmt.Println(newInts()) }اجرای این برنامه$ go run closures.go 1 2 3 1 در مبحث بعدی ما به آخرین ویژگی از توابع یعنی بازگشتی ها میپردازیم.<<توابع متغییر------------------------------ بازگشتی ها >>

14.آموزش GO با مثال (توابع متغیر)

Alireza Shamsi — Sat, 26 Jan 2019 12:07:35 +0330

توابع متغیر میتونن با هر تعداد آرگومانی فراخوانی بشن. برای مثال،fmt.Printlnیک تابع متغیر رایج است.package main import "fmt" در اینجا یک تابع داریم که مقدار دلخواهی int را به عنوان آرگومان دریافت میکند.func sum(nums ...int) { fmt.Print(nums, " ") total := 0 for _, num := range nums { total += num } fmt.Println(total) } func main() { توابع متغیر به طور معمول با آرگومان های تکی فراخوانی میشود. sum(1, 2) sum(1, 2, 3)اگر شما چندین آرگومان در یک برش دارید، میتونید اونها رو در یک تابع متغیر شبیه (...func(slice اعمال کنید. nums := []int{1, 2, 3, 4} sum(nums...) }اجرای این برنامه $ go run variadic-functions.go [1 2] 3 [1 2 3] 6 [1 2 3 4] 10 یکی دیگر از جنبه های کلیدی توابع در گو توانایی آنها در ایجاد بستار است، که در آینده آن را مورد بررسی قرار میدهیم.<<چند بازگشتی مقادیر------------------------------------تابع بستار>>

13.آموزش GO با مثال(چند بازگشتی مقادیر)

Alireza Shamsi — Sat, 26 Jan 2019 08:58:45 +0330

به طور ذاتی زبان گو از چند بازگشتی مقادیر پشتیبانی میکند. از این گزینه برای بیان شفاف تر ساختار های تابعی گو استفاده میشود.به طور مثال برای بازگردانی هر دو مقدار نتیجه و خطا از یک تابع از این موضوع بهره میبریم.package main import "fmt"مثلا (int, int)در این تابع نشان میدهد که تابع دو int را برمیگرداند.func vals() (int, int) { return 3, 7 } func main() {در اینجا ما از دو مقدار بازگشتی متفاوت از تخصیص چندگانه را فراخوانی میکنیم. a, b := vals() fmt.Println(a) fmt.Println(b)اگر فقط یک زیر مجموعه از مقادیر بازگشتی را می خواهید، از شناسه خالی _ استفاده کنید. _, c := vals() fmt.Println(c) }اجرای این برنامه$ go run multiple-return-values.go 3 7 7پذیرش چند مقدار متغیر یکی دیگر از ویژگی های خوب توابع گو است. ما در آینده این موضوع را بررسی خواهیم کرد.<<توابع---------------------------------توابع متغییر>>

12.آموزش GO با مثال (توابع)

Alireza Shamsi — Sat, 26 Jan 2019 02:39:23 +0330

در زبان گو توابع نقطه مرکزی هستند.ما توابع رو با چند مثال مختلف یاد میگیریم:package main import "fmt"اینجا یک تابع داریم که دو تا intرو میگیره و مجموع اون ها رو به صورت یک int برمیگردونه.func plus(a int, b int) int {گو نیاز داره که در اون به طور واضح بازگشتی تابع مشخص بشه به عنوان مثال اون نمیتونه به صورت خودکار خودش یه عبارت رو برگردونه. return a + b }وقتی که شما چند تا پارامتر مشابه از یک نوع رو دارید ، میتونیدنوع پارامترها رو فقط در انتهای معرفی پارامتر ها در تابع بیان کنید و از معرفی نوع برای تک تک پارامترها جلوگیری کنید .func plusPlus(a, b, c int) int { return a + b + c } func main() {میتونید تابعتون رو همونطور که انتظار داشتید با (name(args "(آرگومانها)نام تابع"فراخوانی بکنید: res := plus(1, 2) fmt.Println("1+2 =", res) res = plusPlus(1, 2, 3) fmt.Println("1+2+3 =", res) }اجرای این برنامه$ go run functions.go 1+2 = 3 1+2+3 = 6چند ویژگی دیگر برای توابع گو وجود دارد. یکی از آنها مقادیر چند بازگشتی است که در آینده به آن میپردازیم.<<تکرار range-------------------------------چند بازگشتی مقادیر>>

11.آموزش GO با مثال (تکرار range)

Alireza Shamsi — Sat, 26 Jan 2019 02:11:39 +0330

رنج ها (range) به طور متوالی بر روی انواع مختلفی از عناصر یک آرایه تکرار میشن . بیایید با هم دیگه range رو روی ساختمان داده هایی که تا حالا یاد گرفتیم امتحان کنیم:package main import "fmt" func main() {چطور ما از rangeبرای اضافه کردن مقادیر عددی در آرایه های برشی استفاده میکنیم. آرایه ها هم همینطوری مثل برش ها استفاده میکنن. nums := []int{2, 3, 4} sum := 0 for _, num := range nums { sum += num } fmt.Println("sum:", sum)رنج range روی هر ورودی آرایه ها و برشها میتونه شاخص و مقدار اون عنصر رو پیدا کنن.در بالا ما به این شاخص نیاز نداریم، بنابراین ما آن را با شناسه خالی _ نادیده گرفتیم. بعضی اوقات ما واقعا شاخص ها را می خواهیم. for i, num := range nums { if num == 3 { fmt.Println("index:", i) } }و range روی جفت مقادیر کلید/مقدار مپ ها هم تکرار میتونه بشه: kvs := map[string]string{"a": "apple", "b": "banana"} for k, v := range kvs { fmt.Printf("%s -> %s\n", k, v) }حتی range فقط میتونه روی کلیدهای مپ تکرار بشه: for k := range kvs { fmt.Println("key:", k) }در گو range روی کد پوینت های یونیکدی رشته ها هم میتونه تکرار بشه. اولین مقدار اندیس rune مورد نظر و دومین مقدار خوده rune مورد نظر. for i, c := range "go" { fmt.Println(i, c) } }اجرای این برنامه$ go run range.go sum: 9 index: 1 a -> apple b -> banana key: a key: b 0 103 1 111<<آرایه map-------------------------------------------توابع>>

10.آموزش GO با مثال(آرایه maps)

Alireza Shamsi — Wed, 23 Jan 2019 12:49:24 +0330

مپ گونه ای از آرایه انجمی در زبان گو میباشد (در زبان های دیگر hashes یا dicts نامیده میشود).package main import "fmt" func main() {برای درست کردن یک مپ خالی از نحو زیر و تابع درونی make استفاده کنید:" make(map[key-type]val-type)." m := make(map[string]int)با استفاده از نحو name[key] = val تنظیمات کلید/مقدار را انجام دهید. m["k1"] = 7 m["k2"] = 13یه مپ رو میتونید با دستور fmt.Println نمایش بدید که هردو جفت کلید/مقدار رو نمایش میده. fmt.Println("map:", m) برای به دست آوردن مقدار یک کلید [name[key: v1 := m["k1"] fmt.Println("v1: ", v1) تابع درونی len تعداد جفت های کلید /مقدار را هنگامی که در مپ فراخوانی میشود را بر میگرداند. fmt.Println("len:", len(m)) تابع درونی delete جفت کلید/مقدار را از آرایه حذف میکند. delete(m, "k2") fmt.Println("map:", m) برگشتی اختیاری دوم مقداری را برمیگرداند وقتی که مقداری رو از مپ بگیره اگر کلیدش در مپ وجود داشته باشه.این میتونه برای رفع ابهام بین کلید های گم شده و کلید های صفر مقدار شبیه 0 یا "" استفاده گردد. در اینجا ما به مقدارش کاری نداریم بنابراین اون رو با شناسه خالی _نادیده میگیریم. _, prs := m["k2"] fmt.Println("prs:", prs) با این نحو شما میتونید یک مپ رو در یک خط تعریف و مقدار دهی اولیه کنید: n := map[string]int{"foo": 1, "bar": 2} fmt.Println("map:", n) }اجرای این برنامهتوجه داشته باشید که مپ ها به فرم [map[k:v k:vنمایش داده میشن وقتی که ما از دستور fmt.Printlnاستفاده کنیم.$ go run maps.go map: map[k1:7 k2:13] v1: 7 len: 2 map: map[k1:7] prs: false map: map[foo:1 bar:2]<<آرایه های برشی -------------------------------------تکرار range>>

9.آموزش GO با مثال(آرایه های برشی)

Alireza Shamsi — Tue, 22 Jan 2019 17:39:04 +0330

برش ها یک نوع داده کلیدی در زبان GO هستند ، که یک رابط قدرتمندتری را برای رشته ای از آرایه ها فراهم می کنند.package main import "fmt" func main() {بر خلاف آرایه ها، برش ها فقط توسط عناصر حاوی آنها (نه شماره عناصر آنها) تایپ می شوند. برای تولید یک برش غیر خالی با طول غیر صفر از تابع درونی make استفاده کنید. در اینجا ما یک آرایه برشی از نوع رشته و با طول سه با تابع درونی make میسازیم. s := make([]string, 3) fmt.Println("emp:", s) ما میتونیم شبیه دستورات "set" و "get" رو با آرایه ها بسازیم. s[0] = "a" s[1] = "b" s[2] = "c" fmt.Println("set:", s) fmt.Println("get:", s[2]) تابع len همونطور که انتظار داریم طول یک برش رو برای ما برمیگردونه. fmt.Println("len:", len(s)) علاوه این عملیات های پایه ساده , برشها چندین قابلیت اضافه تر نسبت به آرایه ها را پشتییبانی میکنند. یکی از این قابلیت ها استفاده از تابع درونی append است که باعث میشه بتونیم یک یا چند مقدار را به برش خود اضافه کنیم و برگردونیم. توجه کنید که مقداری که تابع append برمیگرداند را باید قبول کنیم چون یک برش جدید را به ما میدهد. s = append(s, "d") s = append(s, "e", "f") fmt.Println("apd:", s) همچنین برشها میتونن copy بشن.اینجا ما یک برش خالی c میسازیم که طولی برابر با طول s داره و محتویات s رو به c کپی میکنیم. c := make([]string, len(s)) copy(c, s) fmt.Println("cpy:", c) برشها یک جدا کننده به نحو[ slice[low:highرا پشتیبانی میکنند. برای مثال عبارت زیر عناصر [s[2], s[3], s[4. را جدا کرده و به دست میدهد l := s[2:5] fmt.Println("sl1:", l)مثال زیر از عنصر با اندیس صفر تا پنج را ادامه میدهد (به جز خوده 5) [s[5. l = s[:5] fmt.Println("sl2:", l)و این جدا کننده از عنصر با اندیس 2 تا آخرین عنصر اندیس را پوشش میدهد( عنصر اندیس 2 هم پوشش داده میشود) [s[2. l = s[2:] fmt.Println("sl3:", l)ما میتونیم متغیر هامون رو با برشها به خوبی تعریف و مقدار دهی اولیه نماییم. t := []string{"g", "h", "i"} fmt.Println("dcl:", t)برش ها میتونن به ساختمان داده های چند بعدی متصل شوند. طول برشها چند بعدی میتونه خیلی متفاوت تر از آرایه ها چند بعدی باشه. twoD := make([][]int, 3) for i := 0; i < 3; i++ { innerLen := i + 1 twoD[i] = make([]int, innerLen) for j := 0; j < innerLen; j++ { twoD[i][j] = i + j } } fmt.Println("2d: ", twoD) }اجرای این برنامهتوجه داشته باشید در حالی که برشها نوع متفاوتی از آرایه ها هستند ، اما آنها نیز به صورت مشابه با fmt.Println ارائه و نمایش داده میشن. $ go run slices.go emp: [ ] set: [a b c] get: c len: 3 apd: [a b c d e f] cpy: [a b c d e f] sl1: [c d e] sl2: [a b c d e] sl3: [c d e f] dcl: [g h i] 2d: [[0] [1 2] [2 3 4]]برای کسب اطلاعات بیشتر در مورد طراحی و اجرای برش ها در GO، این مقاله فوق العاده و جامع را که تیم Go تهیه کرده است بررسی کنید.تا اینجای کار ما با هم آرایه ها و برشها و رو بررسی کردیم در مبحث بعدی به سراغ ساختمان داده دیگری در گو میرویم : آرایه انجمنی map<<آرایه ها-----------------------------------------------آرایه map>>