Di mehên borî de min Go ji bo pêkanînan bikar tîne. (approx.: koda ceribandina fonksiyona ramanek) di dema xwe ya vala de, hinekî jî ji bo xwendina zimanê bernamesaziyê bixwe. Bername bixwe pir hêsan in û ne mebesta vê gotarê ne, lê ezmûna karanîna Go bixwe çend peyvan li ser wê heq dike. Go soz dide ku bibe (approx.: gotara ku di sala 2015-an de hatî nivîsandin) zimanek populer a ji bo koda girankirî ya giran. Ziman ji hêla Google ve hatî çêkirin, ku ew bi awayekî çalak tê bikaranîn. Rêzeya jêrîn, ez bi dilpakî difikirim ku sêwirana zimanê Go ji bo bernamenûsên zîrek xirab e.
Ji bo bernamenûsên qels hatine sêwirandin?
Fêrbûna Go pir hêsan e, ew qas hêsan e ku danasînê êvarekê ez girtim, piştî ku min berê dikaribû bi rengek hilberî kod bike. Pirtûka ku min berê fêrî Go dikir jê re tê gotin (), li serhêl heye. Pirtûk, mîna koda çavkaniya Go bixwe, hêsan e ku tê xwendin, mînakên kodên baş hene, û nêzîkî 150 rûpelan hene ku dikarin bi yek gavê bêne xwendin. Ev sadebûn di destpêkê de nûjen e, nemaze di cîhanek bernamesaziyê de ku bi teknolojiya zêde tevlihev dagirtî ye. Lê di dawiyê de, zû an dereng fikir derdikeve holê: "Ma bi rastî wusa ye?"
Google îdîa dike ku sadebûna Go xala firotanê ye û ziman ji bo hilberîna herî zêde di tîmên mezin de hatî sêwirandin, lê ez jê guman dikim. Taybetmendî hene ku an winda ne an jî pir berfireh in. Û hemî ji ber nebaweriya pêşdebiran, bi texmîna ku ew nekarin tiştek rast bikin. Ev daxwaza sadebûnê ji hêla sêwiranerên ziman ve biryarek hişmend bû, û ji bo ku em bi tevahî fêm bikin ka çima hewce bû, divê em motîvasyona pêşdebiran û ya ku ew hewl didin ku di Go de bi dest bixin fam bikin.
Ji ber vê yekê çima ew qas hêsan hate çêkirin? Li vir çend gotin hene (approx.: yek ji hev-afirînerên zimanê Go):
Li vir xala sereke ev e ku bernamenûsên me (approx.: ) ne lêkolîner in. Ew, bi gelemperî, pir ciwan in, piştî xwendinê têne cem me, dibe ku wan Java, an C/C++, an Python xwendin. Ew nikarin zimanek mezin fam bikin, lê di heman demê de em dixwazin ku ew nermalava baş çêbikin. Ji ber vê yekê jî divê zimanê wan ji bo fêmkirin û fêrbûna wan hêsan be.
Pêdivî ye ku ew nas be, bi gelemperî mîna C. Bernamesazên ku li Google dixebitin zû dest bi kariyera xwe dikin û bi piranî bi zimanên prosedurê, nemaze malbata C-yê nas dikin. Pêdiviya hilberîna bilez a di zimanek bernamesaziya nû de tê vê wateyê ku divê ziman ne pir radîkal be.
Çi? Ji ber vê yekê Rob Pike bi bingehîn dibêje ku pêşdebirên Google ne ew qas baş in, ji ber vê yekê wan zimanek ji bo ehmeqan afirandin (approx.: lal kirin) da ku karibin tiştekî bikin. Çawa bi quretî li hevkarên xwe dinêre? Min her gav bawer kir ku pêşdebirên Google ji yên herî geş û çêtirîn ên li ser Erdê bi destan têne hilbijartin. Bê guman ew dikarin tiştek dijwartir bikin?
Artifacts ji sadebûna zêde
Di her sêwiranê de sadebûn armancek hêja ye, û hewldana çêkirina tiştek hêsan dijwar e. Lêbelê, gava ku meriv hewl dide ku pirsgirêkên tevlihev çareser bike (an jî diyar bike), carinan amûrek tevlihev hewce dike. Tevlihevî û tevlihevî ne taybetmendiyên çêtirîn ên zimanek bernamekirinê ne, lê zemînek navîn heye ku tê de ziman dikare abstraksyonên xweşik ên ku hêsan têne famkirin û bikar anîn biafirîne.
Ne pir diyarker
Ji ber pabendbûna xwe ya bi sadebûnê, Go kêmasiya avahiyên ku di zimanên din de wekî xwezayî têne hesibandin tune. Dibe ku ev di destpêkê de wekî ramanek baş xuya bike, lê di pratîkê de ew di kodek devkî de encam dide. Sedema vê yekê divê diyar be - pêdivî ye ku ji bo pêşdebiran xwendina koda kesên din hêsan be, lê di rastiyê de ev hêsankirin tenê zirarê didin xwendinê. Di Go de kurtenivîs tune: an pir an tiştek.
Mînakî, amûrek konsolê ku stdin an pelek ji argumanên rêza fermanê dixwîne dê bi vî rengî xuya bike:
package main
import (
"bufio"
"flag"
"fmt"
"log"
"os"
)
func main() {
flag.Parse()
flags := flag.Args()
var text string
var scanner *bufio.Scanner
var err error
if len(flags) > 0 {
file, err := os.Open(flags[0])
if err != nil {
log.Fatal(err)
}
scanner = bufio.NewScanner(file)
} else {
scanner = bufio.NewScanner(os.Stdin)
}
for scanner.Scan() {
text += scanner.Text()
}
err = scanner.Err()
if err != nil {
log.Fatal(err)
}
fmt.Println(text)
}Her çend ev kod di heman demê de hewl dide ku bi qasî ku gengaz be gelemperî be jî, lêkera zorê ya Go rê li ber digire, û wekî encamek, çareserkirina pirsgirêkek hêsan hejmareke mezin ji kodê encam dide.
Li vir, bo nimûne, çareseriyek heman pirsgirêkê ye :
import std.stdio, std.array, std.conv;
void main(string[] args)
{
try
{
auto source = args.length > 1 ? File(args[1], "r") : stdin;
auto text = source.byLine.join.to!(string);
writeln(text);
}
catch (Exception ex)
{
writeln(ex.msg);
}
}Û niha kî bêtir tê xwendin? Ez ê dengê xwe bidim D. Koda wî pirtir tê xwendin ji ber ku ew kiryaran zelaltir vedibêje. D têgehên pir tevlihevtir bikar tîne (approx.: и ) ji mînaka Go, lê bi rastî di têgihîştina wan de tiştek tevlihev tune.
Dojeha kopîkirinê
Pêşniyarek populer ji bo baştirkirina Go gelemperî ye. Ev ê bi kêmanî ji kopîkirina nehewce ya kodê dûr bixe da ku hemî celebên daneyê piştgirî bike. Mînakî, fonksiyonek ji bo berhevkirina navnîşek jimareyan ji bilî kopîkirina fonksiyona wê ya bingehîn ji bo her cûreyek jimaran bi tu awayî nayê bicîh kirin; rêyek din tune:
package main
import "fmt"
func int64Sum(list []int64) (uint64) {
var result int64 = 0
for x := 0; x < len(list); x++ {
result += list[x]
}
return uint64(result)
}
func int32Sum(list []int32) (uint64) {
var result int32 = 0
for x := 0; x < len(list); x++ {
result += list[x]
}
return uint64(result)
}
func int16Sum(list []int16) (uint64) {
var result int16 = 0
for x := 0; x < len(list); x++ {
result += list[x]
}
return uint64(result)
}
func int8Sum(list []int8) (uint64) {
var result int8 = 0
for x := 0; x < len(list); x++ {
result += list[x]
}
return uint64(result)
}
func main() {
list8 := []int8 {1, 2, 3, 4, 5}
list16 := []int16{1, 2, 3, 4, 5}
list32 := []int32{1, 2, 3, 4, 5}
list64 := []int64{1, 2, 3, 4, 5}
fmt.Println(int8Sum(list8))
fmt.Println(int16Sum(list16))
fmt.Println(int32Sum(list32))
fmt.Println(int64Sum(list64))
}Û ev nimûne ji bo celebên îmzekirî jî naxebite. Ev nêzîkatî bi tevahî prensîba dubare nekirina xwe binpê dike (), yek ji prensîbên herî navdar û eşkere ye, paşguhkirina ku çavkaniya gelek xeletiyan e. Çima Go vê yekê dike? Ev aliyekê zimanî yê tirsnak e.
Heman mînak li ser D:
import std.stdio;
import std.algorithm;
void main(string[] args)
{
[1, 2, 3, 4, 5].reduce!((a, b) => a + b).writeln;
}Hêsan, elegant û rasterast li ser xalê. Fonksiyona ku li vir tê bikar anîn ev e reduce ji bo cureyê şablonê û pêşdarazê. Erê, ev dîsa ji guhertoya Go tevlihevtir e, lê ne ew qas dijwar e ku meriv bernamenûsên jîr fam bike. Kîjan nimûne ji bo parastin û xwendina hêsantir e?
Derbaskirina pergala tîpa hêsan
Ez xeyal dikim ku bernamenûsên Go ku vê yekê dixwînin dê ji devê xwe kef bikin û biqîrin, "Tu xelet dikî!" Welê, rêyek din heye ku meriv fonksiyon û celebek gelemperî çêbike, lê ew pergala celebê bi tevahî dişkîne!
Ji bo ku li dora pirsgirêkê bixebite, li vê nimûneya rastkirina zimanek ehmeqî binêre:
package main
import "fmt"
import "reflect"
func Reduce(in interface{}, memo interface{}, fn func(interface{}, interface{}) interface{}) interface{} {
val := reflect.ValueOf(in)
for i := 0; i < val.Len(); i++ {
memo = fn(val.Index(i).Interface(), memo)
}
return memo
}
func main() {
list := []int{1, 2, 3, 4, 5}
result := Reduce(list, 0, func(val interface{}, memo interface{}) interface{} {
return memo.(int) + val.(int)
})
fmt.Println(result)
}Ev pêkanîn Reduce ji gotarê hatibû deyn kirin (approx.: Min nikaribû werger bibînim, ez ê kêfxweş bibim ku hûn bi vê yekê re bibin alîkar). Welê, heke ew bi îdyomatîk be, ez nefret dikim ku mînakek ne-îdyomatîk bibînim. Bikaranîna interface{} - farsek, û di ziman de ew tenê ji bo derbaskirina nivîsandinê hewce ye. Ev navgînek vala ye û hemî celeb wê bicîh dikin, ji bo her kesî azadiya bêkêmasî dihêle. Ev şêwaza bernamesaziyê pir xerab e, û ev ne hemî ye. Serkeftinên akrobatîk ên mîna van hewceyê karanîna refleksa dema xebatê hewce dike. Tewra Rob Pike ji kesên ku vê yekê xirab dikin hez nake, wekî ku wî di yek ji raporên xwe de behs kir.
Ev amûrek hêzdar e ku divê bi hişyarî were bikar anîn. Pêdivî ye ku ji wê bê dûrxistin heya ku bi hişkî hewce nebe.
Ez ê li şûna vê bêaqiliyê şablonên D bigirim. Kesek çawa dikare wisa bibêje interface{} bêtir xwendin an jî bi ewle binivîsin?
Xemgîniyên Rêveberiya Xweseriyê
Go xwedan pergalek pêwendiyê ya çêkirî ye ku li ser pêşkêşkerên mêvandariyê yên populer hatî çêkirin . Amûrên ku bi Go re têne li ser van karûbaran dizanin û dikarin kodê ji wan bi yek gavê dakêşînin, ava bikin û saz bikin. Dema ku ev pir mezin e, di guhertoyê de xeletiyek mezin heye! Erê, rast e ku hûn dikarin koda çavkaniyê ji karûbarên wekî github an bitbucket bi karanîna amûrên Go bistînin, lê hûn nikarin guhertoyê diyar bikin. Û dîsa sadebûn li ser hesabê kêrhatîbûnê. Ez nikarim mantiqa biryareke wiha fam bikim.
Piştî ku pirsan li ser çareseriya vê pirsgirêkê pirsî, tîmê pêşveçûna Go çêkir , ku diyar kir ku ew ê çawa li dora vê pirsgirêkê bisekinin. Pêşniyara wan ew bû ku hûn rojekê tenê depoyê di projeya xwe de kopî bikin û wê "wek ku heye" bihêlin. Ma ew çi difikirin? Me pergalên kontrolkirina guhertoya ecêb bi nîşankirin û piştgirîya guhertoya mezin heye ku afirînerên Go paşguh dikin û tenê koda çavkaniyê kopî dikin.
bagajê çandî ji Xi
Bi dîtina min, Go ji hêla kesên ku hemî jiyana xwe C bikar anîn û ji hêla kesên ku nexwestin tiştek nû biceribînin ve hate pêşve xistin. Ziman dikare wekî C bi çerxên zêde were binav kirin(orig.: ). Di wê de ji bilî piştgirîkirina paralelîzmê (ku, bi awayê, ecêb e) ramanên nû tune ne û ev şerm e. Di zimanekî ku bi zehmetî nayê bikar anîn û lal de paralelîzma we ya hêja heye.
Pirsgirêkek din a diqewime ev e ku Go zimanek prosedurî ye (mîna tirsa bêdeng a C). Hûn bi şêwazek prosedurî ku xwe kevnar û kevnar hîs dike kodê dinivîsin. Ez dizanim ku bernamesaziya xwerû ne guleyek zîv e, lê dê pir baş be ku meriv hûrguliyan li celeban veqetîne û encapsulasyonê peyda bike.
Sadebûn ji bo berjewendiya xwe
Go ji bo hêsan hatî çêkirin û ew di wê armancê de bi ser dikeve. Ew ji bo bernamenûsên qels, zimanek kevn wekî şablonek hate nivîsandin. Ew bi amûrên hêsan tê tije kirin ku tiştên hêsan bikin. Xwendina wê hêsan e û karanîna wê hêsan e.
Ew ji bo bernamenûsên zîrek zehf bi devkî, bêbandor û xirab e.
Sipî ji bo guhertinan
Source: www.habr.com