save

Author: jcbhmr

content/my/docs/README.md

@@ -0,0 +1 @@
+# Go by Example

src/SUMMARY.md renamed to content/my/docs/SUMMARY.md

@@ -1,9 +1,6 @@
 # Summary
-
 [Go by Example](README.md)
-
 ---
-
 - [Hello World](hello-world.md)
 - [Values](values.md)
 - [Variables](variables.md)
@@ -14,23 +11,20 @@
 - [Arrays](arrays.md)
 - [Slices](slices.md)
 - [Maps](maps.md)
+- [Range](range.md)
 - [Functions](functions.md)
 - [Multiple Return Values](multiple-return-values.md)
 - [Variadic Functions](variadic-functions.md)
 - [Closures](closures.md)
 - [Recursion](recursion.md)
-- [Range over Built-in Types](range-over-built-in-types.md)
 - [Pointers](pointers.md)
 - [Strings and Runes](strings-and-runes.md)
 - [Structs](structs.md)
 - [Methods](methods.md)
 - [Interfaces](interfaces.md)
-- [Enums](enums.md)
 - [Struct Embedding](struct-embedding.md)
 - [Generics](generics.md)
-- [Range over Iterators](range-over-iterators.md)
 - [Errors](errors.md)
-- [Custom Errors](custom-errors.md)
 - [Goroutines](goroutines.md)
 - [Channels](channels.md)
 - [Channel Buffering](channel-buffering.md)
@@ -80,7 +74,6 @@
 - [Command-Line Flags](command-line-flags.md)
 - [Command-Line Subcommands](command-line-subcommands.md)
 - [Environment Variables](environment-variables.md)
-- [Logging](logging.md)
 - [HTTP Client](http-client.md)
 - [HTTP Server](http-server.md)
 - [Context](context.md)

content/my/docs/closures.md

@@ -0,0 +1,54 @@
+# Closures
+```go
+// Go က [_anonymous functions_](https://en.wikipedia.org/wiki/Anonymous_function) တွေကို support လုပ်ပါတယ်၊
+// ဒီ Anonymous (အမည်မပါသော) function တွေသုံးပီးတော့ <a href="https://en.wikipedia.org/wiki/Closure_(computer_science)"><em>closures</em></a> တွေကို
+// တည်ဆောက်တယ်။ Anonymous function တွေက function တွေကိုအမည်မပါဘဲသုံးချင်တဲ့အချိန်မှာအတော်လေးအသုံးဝင်တယ်။
+
+package main
+
+import "fmt"
+
+// ဒီ `intSeq` ဆိုတဲ့ function ကနောက်ထက် function တခုကို return ပြန်ထားတယ်၊
+// အဲ့ function က `intSeq` ရဲ့ body ထဲမှာအမည်မပါတဲ့ function တခုသတ်မှတ်ထားတယ်။
+// အဲ့မှာအမည်မပါဘဲသတ်မှတ်ထားတဲ့ function က `i` variable ကို _close over_ လုပ်ပီးတော့
+// closure တခုတည်ဆောက်လိုက်တယ်။
+// ဒါကဘာကိုဆိုလိုတာလဲဆိုရင် `intSeq` ကိုခေါ်ပီးတော့ Anonymous function ကို
+// return ပြန်ပီးတာတောင် return ပြန်လိုက်တဲ့ Anonymous function က `intSeq` ရဲ့ `i` variable ကို access
+// ရနေသေးတယ်ဆိုတာကိုပြောချင်တာပါ။
+
+func intSeq() func() int {
+	i := 0
+	return func() int {
+		i++
+		return i
+	}
+}
+
+func main() {
+
+	// ကျနော်တို့ `intSeq` ကိုခေါ်ပီးတော့ return ပြန်လိုက်တဲ့ Anonymous function ကို
+	// `nextInt` ဆိုတဲ့ variable ထဲမှာထည့်သွင်းထားတယ်၊ ဒီ function ကသူ့ထဲက value ဖြစ်တဲ့
+	// i ကို capture လုပ်ပီးတော့ `nextInt` ကိုခေါ်တိုင်း အဲ့ဒီ့ i တန်ဖိုးကို update လုပ်ပေးတယ်။
+	nextInt := intSeq()
+
+	// closure ရဲ့ကျိုးသတ်ရောက်မှူကိုမြင်ဖို့ `nextInt` ကိုအနည်းငယ်ခေါ်ကြည့်လိုက်ကြရအောင်
+	fmt.Println(nextInt())
+	fmt.Println(nextInt())
+	fmt.Println(nextInt())
+
+	// ဒီ function တခုထဲကိုဘဲဒီ state သတ်ရောက်နေတယ်ဆိုသေချာဖို့ရာအတွက်
+	// အသစ်တခုတည်ဆောက်ပီး စမ်းကြည့်လိုက်ကြရအောင်။
+	newInts := intSeq()
+	fmt.Println(newInts())
+}
+```
+```sh
+$ go run closures.go
+1
+2
+3
+1
+
+# The last feature of functions we'll look at for now is
+# recursion.
+```

content/my/docs/command-line-arguments.md

@@ -0,0 +1,43 @@
+# Command-Line Arguments
+```go
+// [_Command-line arguments_](https://en.wikipedia.org/wiki/Command-line_interface#Arguments)
+// သည် ပရိုဂရမ်များ၏ လုပ်ဆောင်မှုကို parameter ပေးရန် အသုံးများသော နည်းလမ်းတစ်ခုဖြစ်သည်။
+// ဥပမာ - `go run hello.go` သည် `go` ပရိုဂရမ်အတွက် `run` နှင့် `hello.go` arguments များကို အသုံးပြုသည်။
+
+package main
+
+import (
+	"fmt"
+	"os"
+)
+
+func main() {
+
+	// `os.Args` သည် ကနဦး command-line arguments များကို ရယူခွင့်ပေးသည်။
+	// ဤ slice ထဲရှိ ပထမဆုံးတန်ဖိုးသည် ပရိုဂရမ်၏ လမ်းကြောင်းဖြစ်ပြီး
+	// `os.Args[1:]` သည် ပရိုဂရမ်သို့ ပေးသော arguments များကို ကိုင်တွယ်(hold) သည်ကို သတိပြုပါ။
+	argsWithProg := os.Args
+	argsWithoutProg := os.Args[1:]
+
+	// သင်သည် ပုံမှန် indexing ဖြင့် တစ်ခုချင်းစီသော args များကို ရယူနိုင်သည်။
+	arg := os.Args[3]
+
+	fmt.Println(argsWithProg)
+	fmt.Println(argsWithoutProg)
+	fmt.Println(arg)
+}
+```
+```sh
+# Command-line arguments တွေကို စမ်းသပ်ဖို့အတွက် 
+# ပထမဆုံး `go build` နဲ့ binary ကို 
+# တည်ဆောက်တာ(build)က အကောင်းဆုံးဖြစ်ပါတယ်။
+$ go build command-line-arguments.go
+$ ./command-line-arguments a b c d
+[./command-line-arguments a b c d]       
+[a b c d]
+c
+
+# နောက်တစ်ဆင့်အနေနဲ့ ပိုပြီးအဆင့်မြင့်တဲ့ 
+# command-line processing ကို
+# flags တွေသုံးပြီး လေ့လာကြမှာ ဖြစ်ပါတယ်။
+```

content/my/docs/command-line-flags.md

@@ -0,0 +1,107 @@
+# Command-Line Flags
+```go
+// [_Command-line flags_](https://en.wikipedia.org/wiki/Command-line_interface#Command-line_option)
+// ကိုကွန်မန်းလိုင်းပရိုဂရမ်များအတွက် option များသတ်မှတ်ရန် အသုံးများသောနည်းလမ်းတစ်ခုဖြစ်သည်။
+// ဥပမာ `wc -l` တွင် `-l` သည် command-line flag တစ်ခုဖြစ်သည်။
+
+package main
+
+// Go သည် အခြေခံ command-line flag parsing ကို ထောက်ပံ့ပေးသော `flag` package ကို ပေးထားသည်။
+// ကျွန်ုပ်တို့သည် ဤ package ကို အသုံးပြု၍ ကျွန်ုပ်တို့၏ နမူနာ command-line program ကို အကောင်အထည်ဖော်မည်။
+import (
+	"flag"
+	"fmt"
+)
+
+func main() {
+
+	// အခြေခံ flag ကြေညာချက်များကို string, integer နှင့် boolean option များအတွက် ရရှိနိုင်သည်။
+	// ဤနေရာတွင် ကျွန်ုပ်တို့သည် `"foo"` မူလတန်ဖိုးနှင့် တိုတောင်းသော ဖော်ပြချက်ပါသော `word` string flag ကို ကြေညာသည်။
+	// ဤ `flag.String` function သည် string pointer တစ်ခု (string တန်ဖိုးမဟုတ်) ကို ပြန်ပေးသည်။
+	// ကျွန်ုပ်တို့သည် ဤ pointer ကို မည်သို့အသုံးပြုမည်ကို အောက်မှာတွေ့ရပါ့မယ်။
+	wordPtr := flag.String("word", "foo", "a string")
+
+	// ဤသည်မှာ `word` flag နှင့် ဆင်တူသောနည်းလမ်းကို အသုံးပြု၍ `numb` နှင့် `fork` flag များကို ကြေညာခြင်းဖြစ်သည်။
+	numbPtr := flag.Int("numb", 42, "an int")
+	forkPtr := flag.Bool("fork", false, "a bool")
+
+	// ပရိုဂရမ်၏ အခြားနေရာတွင် ကြေညာထားပြီးသား var ကို အသုံးပြုသော option ကိုလည်း ကြေညာနိုင်သည်။
+	// flag ကြေညာခြင်း function သို့ pointer တစ်ခုကို ပေးပို့ရန် လိုအပ်ကြောင်း သတိပြုပါ။
+	var svar string
+	flag.StringVar(&svar, "svar", "bar", "a string var")
+
+	// flag အားလုံးကြေညာပြီးနောက် command-line parsing ကို အကောင်အထည်ဖော်ရန် `flag.Parse()` ကို ခေါ်ပါ။
+	flag.Parse()
+
+	// ဤနေရာတွင် ကျွန်ုပ်တို့သည် parse လုပ်ထားသော option များနှင့် နောက်ဆက်တွဲ positional argument များကို dump လုပ်မည်။
+	// အမှန်တကယ် option တန်ဖိုးများကို ရရှိရန် `*wordPtr` စသည်ဖြင့် pointer များကို dereference လုပ်ရန် လိုအပ်ကြောင်း သတိပြုပါ။
+	fmt.Println("word:", *wordPtr)
+	fmt.Println("numb:", *numbPtr)
+	fmt.Println("fork:", *forkPtr)
+	fmt.Println("svar:", svar)
+	fmt.Println("tail:", flag.Args())
+}
+```
+```sh
+# command-line flags ပရိုဂရမ်ကို 
+# စမ်းသပ်ရန်အတွက်
+# ပထမဦးစွာ compile လုပ်ပြီး ထွက်လာသော 
+# binary ကို တိုက်ရိုက် run သင့်သည်။
+$ go build command-line-flags.go
+
+# flag အားလုံးအတွက် တန်ဖိုးများပေး၍ 
+# build လုပ်ထားသော ပရိုဂရမ်ကို စမ်းသပ်ကြည့်ပါ။
+$ ./command-line-flags -word=opt -numb=7 -fork -svar=flag
+word: opt
+numb: 7
+fork: true
+svar: flag
+tail: []
+
+# flag များကို ချန်လှပ်ထားပါက ၎င်းတို့သည် 
+# အလိုအလျောက် ၎င်းတို့၏ မူလ(default) တန်ဖိုးများကို 
+# ယူကြောင်း သတိပြုပါ။
+$ ./command-line-flags -word=opt
+word: opt
+numb: 42
+fork: false
+svar: bar
+tail: []
+
+# နောက်ဆက်တွဲ positional argument 
+# များကို flag များ၏နောက်တွင် ပေးနိုင်သည်။
+$ ./command-line-flags -word=opt a1 a2 a3
+word: opt
+...
+tail: [a1 a2 a3]
+
+# `flag` package သည် flag အားလုံးကို positional
+#  argument များ၏ရှေ့တွင် ပေါ်လာရန် 
+# လိုအပ်ကြောင်း သတိပြုပါ 
+# (သို့မဟုတ်ပါက flag များကို positional argument 
+# များအဖြစ် အဓိပ္ပာယ်ကောက်ယူမည်)။
+$ ./command-line-flags -word=opt a1 a2 a3 -numb=7
+word: opt
+numb: 42
+fork: false
+svar: bar
+tail: [a1 a2 a3 -numb=7]
+
+# command-line ပရိုဂရမ်အတွက် အလိုအလျောက်ထုတ်ပေးသော 
+# help စာသားကို ရရှိရန် `-h` သို့မဟုတ် `--help` 
+# flag များကို အသုံးပြုပါ။
+$ ./command-line-flags -h
+Usage of ./command-line-flags:
+ -fork=false: a bool
+ -numb=42: an int
+ -svar="bar": a string var
+ -word="foo": a string
+
+# `flag` package တွင် သတ်မှတ်မထားသော flag 
+# တစ်ခုကို ပေးပါက ပရိုဂရမ်သည် အမှားပြ message 
+# ကို ပုံနှိပ်ထုတ်ပေးပြီး help စာသားကို ထပ်ပြပေးမည်။
+$ ./command-line-flags -wat
+flag provided but not defined: -wat
+Usage of ./command-line-flags:
+...
+```

content/my/docs/command-line-subcommands.md

@@ -0,0 +1,79 @@
+# Command-Line Subcommands
+```go
+// `go` ကဲ့သို့သော command-line tools အချို့သည် မိမိတို့ပိုင် flag set များပါဝင်သော subcommand များစွာရှိသည်။
+// ဥပမာအားဖြင့် `go build` နှင့် `go get` တို့သည် `go` tool ၏ မတူညီသော subcommand နှစ်ခုဖြစ်သည်။
+// `flag` package သည် ရိုးရှင်းသော subcommand များကို လွယ်ကူစွာ သတ်မှတ်နိုင်စေပြီး ၎င်းတို့တွင် မိမိတို့ပိုင် flag များပါဝင်နိုင်သည်။
+
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+)
+
+func main() {
+
+	// `NewFlagSet` function ကိုအသုံးပြု၍ subcommand တစ်ခုကို ကြေညာပြီး
+	// ထို subcommand အတွက် သီးသန့် flag အသစ်များကို သတ်မှတ်သည်။
+	fooCmd := flag.NewFlagSet("foo", flag.ExitOnError)
+	fooEnable := fooCmd.Bool("enable", false, "enable")
+	fooName := fooCmd.String("name", "", "name")
+
+	// အခြား subcommand တစ်ခုအတွက် မတူညီသော flag များကို သတ်မှတ်နိုင်သည်။
+	barCmd := flag.NewFlagSet("bar", flag.ExitOnError)
+	barLevel := barCmd.Int("level", 0, "level")
+
+	// Subcommand ကို program ၏ ပထမဆုံး argument အဖြစ် မျှော်လင့်ထားသည်။
+	if len(os.Args) < 2 {
+		fmt.Println("expected 'foo' or 'bar' subcommands")
+		os.Exit(1)
+	}
+
+	// မည်သည့် subcommand ကို ခေါ်ယူထားသည်ကို စစ်ဆေးသည်။
+	switch os.Args[1] {
+	// Subcommand တစ်ခုချင်းစီအတွက် ၎င်း၏ flag များကို parse လုပ်ပြီး
+	// နောက်ဆက်တွဲ positional argument များကို အသုံးပြုနိုင်သည်။
+	case "foo":
+		fooCmd.Parse(os.Args[2:])
+		fmt.Println("subcommand 'foo'")
+		fmt.Println("  enable:", *fooEnable)
+		fmt.Println("  name:", *fooName)
+		fmt.Println("  tail:", fooCmd.Args())
+	case "bar":
+		barCmd.Parse(os.Args[2:])
+		fmt.Println("subcommand 'bar'")
+		fmt.Println("  level:", *barLevel)
+		fmt.Println("  tail:", barCmd.Args())
+	default:
+		fmt.Println("expected 'foo' or 'bar' subcommands")
+		os.Exit(1)
+	}
+}
+```
+```sh
+# ပထမဦးစွာ foo subcommand ကို ခေါ်ယူသည်။
+$ ./command-line-subcommands foo -enable -name=joe a1 a2
+subcommand 'foo'
+  enable: true
+  name: joe
+  tail: [a1 a2]
+
+# ယခု bar ကို စမ်းကြည့်သည်။
+$ ./command-line-subcommands bar -level 8 a1
+subcommand 'bar'
+  level: 8
+  tail: [a1]
+
+# သို့သော် bar သည် foo ၏ flag များကို လက်ခံမည်မဟုတ်ပါ။
+$ ./command-line-subcommands bar -enable a1
+flag provided but not defined: -enable
+Usage of bar:
+  -level int
+    	level
+
+# နောက်တစ်ဆင့်တွင် ကျွန်ုပ်တို့သည် environment variable 
+# များကို ကြည့်မည်ဖြစ်သည်။ 
+# ၎င်းသည် program များကို parameter ပေးရန် 
+# နောက်ထပ်နည်းလမ်းတစ်ခုဖြစ်သည်။
+```

content/my/docs/constants.md

@@ -0,0 +1,44 @@
+# Constants
+```go
+// Go က character, string, boolean, နှင့် numeric values
+// အမျိုးမျိုးအတွက် _constants_ ကိုအသုံးပြုနိုင်ပါတယ်။
+
+package main
+
+import (
+	"fmt"
+	"math"
+)
+
+// `const` ကိုသုံးပီး constant value ကိုဖန်တီးနိုင်ပါတယ်။
+const s string = "constant"
+
+func main() {
+	fmt.Println(s)
+
+	// `const` statement က `var` statement ကြေငြာလို့ရတဲ့
+	// ဘယ်နေရာမှာမဆို ကြောငြာနိုင်ပါတယ်။
+	const n = 500000000
+
+	// Constant အသုံးအနှုန်းက တိကျတဲ့ ဂဏန်းသင်္ချာ တွက်ချက်နိုင်ပါတယ်။
+	const d = 3e20 / n
+	fmt.Println(d)
+
+	// ဂဏန်း constant က သေချာ type မပြောင်းထားဘူးဆိုလျှင်
+	// type မရှိပါဘူး။
+	fmt.Println(int64(d))
+
+	// variable assignment သို့ function call မှာ
+	// ဂဏန်းသင်္ချာတွေကို လိုအပ်လျှင် လိုအပ်သလို
+	// အမျိုးအစားပြောင်းနိုင်ပါတယ်။
+	// ဥပမာအနေနဲ့ `math.Sin` က `float64` ကိုလိုအပ်ပါတယ်။
+	fmt.Println(math.Sin(n))
+}
+```
+```sh
+$ go run constant.go
+constant
+6e+11
+600000000000
+-0.28470407323754404
+```