Go Lang එහෙමත් නැත්නම් Go Language ගැන ඕනෙම කෙනෙක් අහල ඇති. මේක google විසින් නිර්මාණය කරපු language එකක්. නමුත් GoLang use කරපු කෙනෙක් නම් හොයාගන්න එක ලංකාවේ ලේසි නෑ. ලෝකයේ හොඳම programming languages 10 අතරෙත් මේ කතා කරන GO language එක තියනව.
ඉතින් අපි මේ ලිපියන් කතා කරමු මේ ගැන.
Go මූලික වශයෙන් server / system language එකක් විදියට තමයි හඳුන්වන්නෙ.
“Go will be the server language of the future.” — Tobias Lütke, Shopify
මේ තියෙන්නෙ Go ගැන කියල තියන ප්‍රකාශයක්. මේ list එක දැකපුවම ඒකෙ ඇත්තක් තියනව කියල තේරෙනව නේද?
Go කියන්නෙ ප්‍රබල, සංකීර්ණ නොවන, කාර්යක්ෂම programming language එකක් කිව්වොත් නිවැරදියි. Go වල තියන concurrency mechanism එක නිසා multicore සහ network machine එක්ක සාර්ථක ලෙස වැඩ කරගැනීමට හැකියාවක් තියනවා.
Go compiler එක මගින් code එක ඉතා ඉක්මනින් machine code එකක් බවට convert කරන නිසා process එක තවත් වේගවත් වෙනවා.
Go compiler එක ගැන අපි කතා කරමු.
අපි Go use කරනවානම් compiler එක මුලින්ම install කරගන්න සිදු වෙනවා. ඒ කියන්නෙ මේක compiled programming language එකක්. Compiler එකෙන් කරන්නෙ source code එක computer එකට් තේරෙන විදියට convert කරන එක.
Go compiler එක download කරල install කරගත්තම අපිට පුලුවන් Go එක්ක වැඩ කරන්න පටන් ගන්න. Setup කරගන්න එක අමාරු නෑ.
මුලින්ම මේ link එකට ගිහින් compiler එක download කරල install කරගන්න.
install කරගෙන ඉවරනම් දැන් තියෙන්නෙ වැඩ පටන් ගන්න.
මුලින්ම command prompt එක open කරගන්න.
Go වල install කරල තියන version එක “go version” කියන් command එකෙන් බලාගන්න පුලුවන්.
ඒ වගේම තමයි Go වලට අදාල commands / sub commands බලාගන්න පුලුවන් cmd prompt එකේ “go help” කියන command එක run කරල.
Go සමඟ පලමු program එක.
ඕනෙම programming language එකක් මුලින්ම පටන් ගන්නකොට “Hello world” print කරලනෙ පටන් ගන්නෙ. ඉතින් අපි බලමු Go වලින් hello world print කරන්නෙ කොහොමද කියල.
මුලින්ම කැමති තැනකින් folder එකක් හදාගෙන ඒක ඇතුලෙ file එකක් හදාගන්න “main.go” කියන නමින්. Extension එක තමයි “.go”
මීලගට මේ code lines ටික type කරල save කරගන්න.
package main
import "fmt"
// this is a comment
func main() {
fmt.Println("Hello World")
}
දැන් main.go file එක save කරපු folder එකෙන් command prompt එක open කරගන්න.
“go run main.go” කියන command එකෙන් program එක compile කරල run කරගන්න පුලුවන්.
එතකොට මේ වගේ output එක display කරයි.
දැන් අපි මේ code එක ගැන කතා කරමු.
package main
code එකේ මේ කොටස package declaration කියල හඳුන්වනවා. ඕනෑම Go program එකක මේ කොටස ඇතුලත් වෙන්න ඕනෙ. මෙතනදි කරල තියෙන්නෙ package එක declare කරල තියන එක.
අපි package ගැන ටිකක් කතා කරමු. Packages අපි use කරන්නෙ code එක organize කරන්න වගේම code reuse කරන්න. Go පිලිබඳ කතා කරන විට අපිට හමු වෙනව program වර්ග දෙකක්.
Executables
Libraries
මෙතනදි executable programs අපිට terminal එක use කරල directly run කරන්න පුලුවන්. Libraries කියන්නෙ කලින් code කරල තියන programs. අපිට අවශ්‍ය ලෙස මේ libraries අපේ program එකට use කරන්න පුලුවන්.
import "fmt"
“fmt” (format) package එකෙන් වෙන්නෙ input සහ output වල format එක implement කරන එක. මෙතනදි import කරන package එක “ ” ඇතුලෙ තමයි type කරන්න ඕනෙ.
Comments
බොහොමයක් programming languages වගේම // සහ /* */ මගින් comments යොදන්න පුලුවන්.
Function declaration
func main() {
fmt.Println("Hello World")
}
මේ තියෙන්නෙ program එකේ main function එක. Program එක execute කරද්දි මුලින්ම run වෙන්නෙ මේ කියපු main function එක තමයි.
fmt.Println("Hello World") කියන කොටසින් තමයි දීල තියන text එක print කරන්නෙ.
මේ methods ගැන ගැටලුවක් තියනවනන් මේ command එක use කරල ඒ ගැන දැන ගන්න පුලුවන්.
“godoc fmt Println”
අපිට දැන ගන්න ඕනෙ කරන method එකේ name එක වෙනස් කරල කැමති method එකකින් වෙන දේ දැන ගන්න පුලුවන්.
Variables
Go වලදි අපිට Variable declare කරන්න ආකාර දෙකක් තියනව.
එකක් තමයි “var” කියන keyword එකත් එක්ක.
අපි දන්නවනන් හරියටම data type එක මොකක්ද කියල අපිට මේ ආකාරය භාවිතා කරන්න පුලුවන්.
var x string = “hello”
ඒ වගේම තමයි variable එකේ value එක නැවත program එක run කරන විට change වෙන්නෙ නැතිනම් “var” වෙනුවට “const” කියන keyword එක use කරන්න පුලුවන්.
අනිත් ආකාරය භාවිතා කරන්නෙ data type එකක් specify කරන්නෙ නැත්නම්.
x := 5
x := “Hello world”
හැකි හැම වෙලාවකම මේ ආකාරයට variables declare කරන්න.
ඒ වගේම තමයි variable එකකට වඩා වැඩි ප්‍රමාණයක් declare කරගන්න අවශ්‍යනම් පහත ආකාරයට මෙය සිදු කර ගත හැකියි.
var (
a = 5
b = 10
c = 15
)
User Inputs
package main
import "fmt"
func main() {
fmt.Print("Enter a number: ")
var input float64
fmt.Scanf("%f", &input)
fmt.Println(input)
}
මේ තියෙන්නෙ userගෙන් input එකක් ගන්න ආකාරය. බොහෝ දුරට C වලට සමානයි නේද?
control flow statements
අනිත් programming language එක්ක සලකන විට ඉතා කුඩා syntax වෙනස්කම් ටිකක් තමයි මෙතනදි අපිට දකින්න පුලුවන් වෙන්නෙ.
ඉතින් අපි බලමු control flow statements කොහොමද යොදාගන්නෙ කියන එක.
අපි දැන් control flow statements කිහිපයක් සඳහා sample programs ටිකක් බලමු.
For
package main
import "fmt"
func main() {
i := 1 for i <= 10 {
fmt.Println(i)
i = i + 1
}
}
package main
import "fmt"
func main() {
for i := 1; i <= 10; i++ {
fmt.Println(i)
}
}
If
package main
import "fmt"
func main() {
for i := 1; i <= 10; i++ {
if i % 2 == 0 {
fmt.Println(i, "even")
}
else {
fmt.Println(i, "odd")
}
}
}
Else If
package main
import "fmt"
func main() {
var i int = 4
if i == 0 {
fmt.Println("Zero") }
else if i == 1 {
fmt.Println("One")
}
else if i == 2 {
fmt.Println("Two")
} else if i == 3 {
fmt.Println("Three")
} else if i == 4 {
fmt.Println("Four")
} else if i == 5 {
fmt.Println("Five")
}
}
Switch
package main
import "fmt"
func main() {
var I int = 2
switch i {
case 0: fmt.Println("Zero")
case 1: fmt.Println("One")
case 2: fmt.Println("Two")
case 3: fmt.Println("Three")
case 4: fmt.Println("Four")
case 5: fmt.Println("Five")
default: fmt.Println("Unknown Number")
}
}
Arrays
Go වල arrays ගත්තත් බොහොමයක් සමානකම් තියනව අනිත් languages වලට.
මේ තියෙන්නෙ array එකක් declare කරගන්න ආකාරය.
var x [5]int
මේ code එකෙන් අවබෝධයක් ගන්න පුලුවන් කොහොමද array එකක් use කරන්නෙ කියන එක පිලිබඳව.
package main
import "fmt"
func main() {
var x [5]int
x[1] = 100
x[4] = 100
fmt.Println(x)
}
මේ code එක run කරල බැලුවොත් output එක එන්නෙ මේ වගේ.
අපි මෙතනදි array එක print කරන්න loop එකක් භාවිත නොකර array එකේ name එක ලබා දීල තියනව.
අපි දැන් Go language එක තෝරගත යුත්තේ කුමන හේතූන් නිසාද කියන එක සලකා බලමු.
Concurrency vs Straight code
මේ පිලිබඳ සලකන විට Go මේ අවශ්‍යතා දෙකම සපුරනව. Concurrency කියන්නෙ එක විට කාර්‍යයන් එකකට වඩා වැඩි ප්‍රමාණයක් සිදු කිරීම. ඒ සමගම readability එක වැඩි code එකක් Go වලින් ලබා ගන්න පුලුවන්.
අපි මේ කාරණා අනෙක් programming languages සමඟ සසදා බලමු. මේ image එක මගින් මේ පිලිබඳ වඩාත් පැහැදිලි වෙයි.
Code එකේ maintainability එක ඉහළ වීම
Go වල අනෙක් programming languages මෙන් අව්ල් සහගත syntax නොමැත. එමෙන්ම ඉතාමත් පැහැදිලි ලෙස භාවිත කල හැකි syntax නිසා code එකේ readability එක ඉතා ඉහලය.
Classes නොමැති වීම.
මෙහිදී classes භාවිතයක් නොමැත. එමෙන්ම සියලුම දේ packages වලට වෙන් කර ගැනීම තුලින් classes වල අවශ්‍යතාව සපුරාගනී. එමෙන්ම කෙනෙකුට මේ දේ අඩුපාඩුවක් ලෙස සිතෙන්නට පුලුවන්. නමුත් inheritance, encapsulation, polymorphism එක්ක වැඩ කරනවට වඩා මේ දේ ඉතාමත්ම පහසුයි.
ඒ වගේම තමයි struct භාවිත කිරීමේ හැකියාව මෙහිදී පවතිනවා.
type person struct {
name string
age int
}
ඒ වගේම තමයි Go වලදි අපිට exception හමුවන්නෙ නෑ. Try catch කියල අපි හඳුන්වන්නෙ exceptions. මීට අමතරව multiple return values අපිට Go වලදි හමු වෙනව.
func vals( ) (int, int) {
return 3, 7
}
මේ තියෙන්නෙ අනිත් වැදගත්ම දේ.
Language එකේ වේගවත් බව හා කාර්යක්ෂම බව
මේ graph එක බලන්න. එතකොට තේරෙයි Go මොන තරම් ඉදිරියෙන්ද ඉන්නෙ කියල.
ඉතින් මේ තමයි Go. මේ ලිපියෙන් කතා කරන්න පුලුවන් උන කොටස ඉතා කුඩා වුනත් මෙතනින් එහාට දිග ගමනක් තියනව. ඉතින් අතාරින්න එපා. මොකද කියනවනන් මේ language එක follow කරන කෙනෙකුට ලංකාව ඇතුලෙ වගේම අනිත් රටවල් වලත් opportunities ඕනෙ තරම් තියනව. පොඩි effort එකක් දාන්න මේ වැඩේට.
ඉතින් අපි තවත් ලිපියකින් හමු එමු. මේ page එකත් එක්කම එකතු වෙලා ඉන්න.
Find us on Facebook : Tech Seekers
Facebook page එක ඔයාලගෙ යාලුවො අතරෙත් share කරන්න, තවත් කෙනෙකුට මේ දේ දැනගන්න ඒ අවස්තාව හදල දෙන්න.
References :