I nā mahina i hala iho nei ua hoʻohana au iā Go no ka hoʻokō. (kokoke.: code e ho'āʻo ai i ka hana o kahi manaʻo) i kona manawa kūʻokoʻa, ma kekahi hapa e aʻo i ka ʻōlelo hoʻonohonoho ponoʻī. He mea maʻalahi loa nā papahana a ʻaʻole ia ke kumu o kēia ʻatikala, akā pono ka ʻike o ka hoʻohana ʻana iā Go iā ia iho i kekahi mau huaʻōlelo e pili ana. Ua hoʻohiki e hele (kokoke.: ʻatikala i kākau ʻia ma 2015) he ʻōlelo kaulana no ke code scalable koʻikoʻi. Ua hana ʻia ka ʻōlelo e Google, kahi i hoʻohana ikaika ʻia ai. ʻO ka laina lalo, manaʻo wau he hewa ka hoʻolālā ʻana o ka ʻōlelo Go no nā mea polokalamu akamai.
Hoʻolālā ʻia no nā polokalamu polokalamu nāwaliwali?
He mea maʻalahi loa ke aʻo ʻana, maʻalahi loa i lawe iaʻu i ka hoʻolauna i hoʻokahi ahiahi, a ma hope ua hiki iaʻu ke hoʻopaʻa inoa huahana. Ua kapa ʻia ka puke aʻu i aʻo ai ʻo Go (), loaʻa ia ma ka pūnaewele. ʻO ka puke, e like me ka Go source code ponoʻī, maʻalahi ka heluhelu ʻana, loaʻa nā hiʻohiʻona code maikaʻi, a aia ma kahi o 150 mau ʻaoʻao hiki ke heluhelu ʻia i ka noho hoʻokahi. He mea hōʻoluʻolu kēia maʻalahi i ka wā mua, ʻoi aku hoʻi i kahi honua papahana i piha i ka ʻenehana paʻakikī. Akā i ka hopena, ma hope a ma hope paha e ala mai ka manaʻo: "ʻOiaʻiʻo anei kēia?"
Ua ʻōlelo ʻo Google ʻo ka maʻalahi o Go ka mea kūʻai aku a ua hoʻolālā ʻia ka ʻōlelo no ka huahana kiʻekiʻe ma nā hui nui, akā kānalua wau. Aia nā hiʻohiʻona i nalowale a i ʻole kikoʻī loa. A no ka pau ʻole o ka hilinaʻi i nā mea hoʻomohala, me ka manaʻo ʻaʻole hiki iā lākou ke hana i kekahi mea kūpono. ʻO kēia makemake i ka maʻalahi he hoʻoholo noʻonoʻo e nā mea hoʻolālā o ka ʻōlelo, a no ka hoʻomaopopo piha ʻana i ke kumu e pono ai, pono mākou e hoʻomaopopo i ka manaʻo o nā mea hoʻomohala a me nā mea a lākou e hoʻāʻo nei e hoʻokō ma Go.
No laila, no ke aha i maʻalahi ai? Eia kekahi mau huaʻōlelo (kokoke.: kekahi o nā mea hana pū o ka ʻōlelo Go):
ʻO ka mea nui ma ʻaneʻi ʻo kā mākou mea papahana (kokoke.: ) ʻaʻole he mea noiʻi. ʻO lākou, ma ke ʻano he ʻōpio, hele mai iā mākou ma hope o ke aʻo ʻana, malia paha ua aʻo lākou iā Java, a i ʻole C/C++, a i ʻole Python. ʻAʻole hiki iā lākou ke hoʻomaopopo i ka ʻōlelo maikaʻi, akā i ka manawa like makemake mākou e hana lākou i nā polokalamu maikaʻi. ʻO ia ke kumu e maʻalahi ai kā lākou ʻōlelo iā lākou e hoʻomaopopo a aʻo.
Pono ʻo ia e kamaʻāina, ma ke ʻano like me C. Hoʻomaka ka poʻe papahana e hana ana ma Google i kā lākou ʻoihana a ʻike nui i nā ʻōlelo kaʻina hana, ʻo ia hoʻi ka ʻohana C. ʻO ke koi no ka hoʻohua wikiwiki ʻana i kahi ʻōlelo hoʻolālā hou, ʻaʻole pono ka ʻōlelo ʻino loa.
He aha? No laila ke ʻōlelo nei ʻo Rob Pike ʻaʻole maikaʻi nā mea hoʻomohala ma Google, ʻo ia ke kumu i hana ai lākou i ʻōlelo no ka poʻe lapuwale (kokoke.: pupule) i hiki iā lākou ke hana i kekahi mea. He aha ke ʻano o ka nānā haʻaheo i kāu mau hoa hana? Ua manaʻoʻiʻo mau wau ua koho lima ʻia nā mea hoʻomohala a Google mai nā mea ʻoi loa a maikaʻi loa ma ka Honua. ʻOiaʻiʻo hiki iā lākou ke mālama i kahi mea paʻakikī?
Nā mea hana o ka maʻalahi maʻalahi
ʻO ka maʻalahi ka pahuhopu kūpono i kēlā me kēia hoʻolālā, a paʻakikī ka hoʻāʻo e hana i kahi mea maʻalahi. Eia nō naʻe, i ka wā e hoʻāʻo ai e hoʻoponopono (a hōʻike paha) i nā pilikia paʻakikī, i kekahi manawa pono kahi mea paʻakikī. ʻO ka paʻakikī a me ka paʻakikī ʻaʻole nā hiʻohiʻona maikaʻi loa o ka ʻōlelo papahana, akā aia kahi kahua waena e hiki ai i ka ʻōlelo ke hana i nā abstract nani i maʻalahi ke hoʻomaopopo a hoʻohana.
ʻAʻole hōʻike nui
Ma muli o kāna kūpaʻa i ka maʻalahi, nele ʻo Go i nā hana i ʻike ʻia he kūlohelohe i nā ʻōlelo ʻē aʻe. He manaʻo maikaʻi paha kēia i ka wā mua, akā ma ka hoʻomaʻamaʻa ʻana e hopena i ka code verbose. Pono ke kumu o kēia - pono e maʻalahi ka heluhelu ʻana o nā mea hoʻomohala i nā code o nā poʻe ʻē aʻe, akā ʻo ka ʻoiaʻiʻo, ʻo kēia mau hoʻomaʻamaʻa wale nō e hōʻeha i ka heluhelu ʻana. ʻAʻohe pōkole ma Go: he nui a ʻaʻohe mea.
No ka laʻana, he mea hoʻohana console e heluhelu ana i ka stdin a i ʻole kahi faila mai nā manaʻo laina kauoha e like me kēia:
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)
}ʻOiai ke hoʻāʻo nei kēia code e like me ka mea hiki, hiki i ka verbosity koʻikoʻi ʻo Go i ke ala, a ʻo ka hopena, ʻo ka hoʻoponopono ʻana i kahi pilikia maʻalahi ka hopena i ka nui o ke code.
Eia, no ka laʻana, he hopena i ka pilikia like ma :
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);
}
}A ʻo wai ka mea hiki ke heluhelu ʻia i kēia manawa? E hāʻawi wau i kaʻu koho iā D. ʻOi aku ka maʻalahi o kāna code no ka mea ʻoi aku ka maopopo o kāna wehewehe ʻana i nā hana. Hoʻohana ʻo D i nā manaʻo paʻakikī (kokoke.: и ) ma mua o ka laʻana Go, akā ʻaʻohe mea paʻakikī e pili ana i ka hoʻomaopopo ʻana iā lākou.
Hell o ke kope kope
ʻO kahi manaʻo kaulana no ka hoʻomaikaʻi ʻana iā Go ʻo ka laulā. E kōkua kēia i ka pale ʻana i ke kope pono ʻole o ke code e kākoʻo i nā ʻano ʻikepili āpau. No ka laʻana, hiki ke hoʻokō ʻia kahi hana no ka hōʻuluʻulu ʻana i ka papa inoa o nā integer ma kahi ʻano ʻē aʻe ma ke kope ʻana i kāna hana kumu no kēlā me kēia ʻano integer; ʻaʻohe ala ʻē aʻe:
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))
}A ʻaʻole hoʻohana kēia laʻana no nā ʻano pūlima. ʻO kēia ala e hōʻole loa i ke kumu o ka hana ʻole ʻana iā ʻoe iho (), kekahi o nā loina kaulana a maopopo, me ka nānā ʻole i ke kumu o nā hewa he nui. No ke aha ʻo Go e hana ai i kēia? He ʻano weliweli kēia o ka ʻōlelo.
Laʻana like ma D:
import std.stdio;
import std.algorithm;
void main(string[] args)
{
[1, 2, 3, 4, 5].reduce!((a, b) => a + b).writeln;
}Maʻalahi, nani a pololei i ke kiko. ʻO ka hana i hoʻohana ʻia ma ʻaneʻi reduce no ke ʻano maʻamau a me ka predicate. ʻAe, ʻoi aku ka paʻakikī o kēia ma mua o ka mana Go, akā ʻaʻole paʻakikī i ka poʻe polokalamu polokalamu akamai ke hoʻomaopopo. ʻO wai ka laʻana i maʻalahi ke mālama a maʻalahi hoʻi ka heluhelu?
Kaalo ʻōnaehana ʻano maʻalahi
Ke noʻonoʻo nei au i ka heluhelu ʻana o nā mea hoʻolalelale ʻo Go i kēia e huāhuʻi ka waha me ka ʻuā ʻana, "Ke hana hewa nei ʻoe!" ʻAe, aia kekahi ala ʻē aʻe e hana ai i kahi hana maʻamau a me nā ʻano, akā e uhaʻi loa i ka ʻōnaehana ʻano!
E nānā i kēia hiʻohiʻona o ka hoʻoponopono ʻōlelo naʻaupō e hoʻoponopono i ka pilikia:
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)
}ʻO kēia hoʻokō Reduce ua ʻaiʻē ʻia mai ka ʻatikala (kokoke.: ʻAʻole hiki iaʻu ke loaʻa ka unuhi, e hauʻoli wau inā kōkua ʻoe i kēia). ʻAe, inā he idiomatic, inaina wau e ʻike i kahi laʻana non-idiomatic. Hoʻohana interface{} - he farce, a ma ka ʻōlelo e pono ai ke kāpae i ka paʻi ʻana. He ʻokoʻa kaʻawale kēia a hoʻokō nā ʻano āpau, e ʻae i ke kūʻokoʻa piha no kēlā me kēia. He ʻino loa kēia ʻano papahana, ʻaʻole ʻo ia wale nō. Pono nā hana Acrobatic e like me kēia i ka hoʻohana ʻana i ka noʻonoʻo runtime. ʻAʻole makemake ʻo Rob Pike i ka poʻe i hana ʻino i kēia, e like me kāna i ʻōlelo ai ma kekahi o kāna mau hōʻike.
He mea hana ikaika kēia e hoʻohana me ka akahele. Pono e pale ʻia inā ʻaʻole pono.
E lawe au i nā palapala D ma mua o kēia mea lapuwale. Pehea e ʻōlelo ai kekahi interface{} hiki ke heluhelu ʻia a i ʻole ke ʻano palekana?
ʻO nā pilikia o ka hoʻokele hilinaʻi
Loaʻa iā Go kahi ʻōnaehana hilinaʻi i kūkulu ʻia ma luna o nā mea hoʻolako kikowaena kaulana . ʻO nā mea hana e hele mai me Go e ʻike e pili ana i kēia mau lawelawe a hiki ke hoʻoiho, kūkulu, a hoʻokomo i nā code mai lākou i ka hāʻule hoʻokahi. ʻOiai maikaʻi kēia, aia kekahi hapa nui me ka hoʻololi ʻana! ʻAe, ʻoiaʻiʻo hiki iā ʻoe ke kiʻi i ke code kumu mai nā lawelawe e like me github a i ʻole bitbucket me ka hoʻohana ʻana i nā mea hana Go, akā ʻaʻole hiki iā ʻoe ke kuhikuhi i ka mana. A hou ka maʻalahi ma ka lilo o ka pono. ʻAʻole hiki iaʻu ke hoʻomaopopo i ke kumu o ia hoʻoholo.
Ma hope o ka nīnau ʻana i nā nīnau e pili ana i kahi hoʻonā i kēia pilikia, ua hana ka hui hoʻomohala Go , i hōʻike ʻia pehea lākou e hoʻoponopono ai i kēia pilikia. ʻO kā lākou manaʻo e kope wale i ka waihona holoʻokoʻa i kāu papahana i hoʻokahi lā a waiho iā ia "e like me." He aha kā lākou manaʻo? Loaʻa iā mākou nā ʻōnaehana mana mana me ka hōʻailona maikaʻi a me ke kākoʻo ʻana i ka manaʻo ʻole a ka poʻe hana Go Go a kope wale i ke code kumu.
Nā ukana moʻomeheu mai Xi
I koʻu manaʻo, ua hoʻomohala ʻia ʻo Go e ka poʻe i hoʻohana iā C i ko lākou ola a pau a me ka poʻe makemake ʻole e hoʻāʻo i kahi mea hou. Hiki ke wehewehe ʻia ka ʻōlelo e like me C me nā huila keu (orig.: ). ʻAʻohe manaʻo hou i loko, koe wale nō ke kākoʻo ʻana i ka parallelism (ʻo ia hoʻi, he mea kupanaha) a he mea hilahila kēia. Loaʻa iā ʻoe ka hoʻohālikelike maikaʻi loa i ka ʻōlelo ʻoʻopa.
ʻO kekahi pilikia creaking ʻo ia ʻo Go he ʻōlelo kaʻina hana (e like me ka weliweli leo o C). Hoʻopau ʻoe i ke kākau ʻana i ke code ma ke ʻano kaʻina hana i manaʻo ʻia he kahiko a kahiko. ʻIke wau ʻaʻole he pōkā kālā ka hoʻolālā ʻana i ka mea, akā maikaʻi ia e hiki ke hoʻokaʻawale i nā kikoʻī i nā ʻano a hāʻawi i ka encapsulation.
ʻO ka maʻalahi no kou pono pono'ī
Ua hoʻolālā ʻia ʻo Go e maʻalahi a kūleʻa i kēlā pahuhopu. Ua kākau ʻia no nā polokalamu polokalamu nāwaliwali, me ka hoʻohana ʻana i ka ʻōlelo kahiko ma ke ʻano he laʻana. Hele piha me nā mea hana maʻalahi e hana i nā mea maʻalahi. He maʻalahi ka heluhelu a maʻalahi hoʻi e hoʻohana.
He ʻōlelo ʻōlelo nui loa, ʻaʻohe manaʻo, a maikaʻi ʻole no nā polokalamu polokalamu akamai.
Спасибо no ka hooponopono ana
Source: www.habr.com