អត្ថបទនេះត្រូវបានសរសេរជាការឆ្លើយតបទៅនឹងការបោះពុម្ពពីមុន អត្ថបទ antipodean.

ក្នុងរយៈពេលជាងពីរឆ្នាំកន្លងមកនេះ ខ្ញុំបានប្រើប្រាស់ Go ដើម្បីអនុវត្តម៉ាស៊ីនមេ RADIUS ឯកទេសជាមួយនឹងប្រព័ន្ធចេញវិក្កយបត្រ។ នៅតាមផ្លូវ ខ្ញុំកំពុងរៀនពីភាពស្មុគ្រស្មាញនៃភាសាខ្លួនឯង។ កម្មវិធីខ្លួនវាគឺសាមញ្ញណាស់ ហើយមិនមែនជាគោលបំណងនៃអត្ថបទនេះទេ ប៉ុន្តែបទពិសោធន៍នៃការប្រើប្រាស់ Go ខ្លួនវាសមនឹងទទួលបានពាក្យមួយចំនួនក្នុងការការពាររបស់វា។ Go កំពុងក្លាយជាភាសាពេញនិយមកាន់តែខ្លាំងឡើងសម្រាប់កូដដែលអាចធ្វើមាត្រដ្ឋានបាន។ ភាសានេះត្រូវបានបង្កើតឡើងដោយ Google ដែលវាត្រូវបានប្រើប្រាស់យ៉ាងសកម្ម។ ចំណុចខាងក្រោម ខ្ញុំគិតដោយស្មោះត្រង់ថាការរចនានៃភាសា Go គឺមិនល្អសម្រាប់អ្នកសរសេរកម្មវិធីដែលឆ្លាតវៃ។

រចនាសម្រាប់អ្នកសរសេរកម្មវិធីខ្សោយ?

អ្នកទន់ខ្សោយនិយាយអំពីបញ្ហា។ ការនិយាយខ្លាំងអំពីគំនិត និងក្តីសុបិន...

Go គឺងាយស្រួលរៀនណាស់ ដូច្នេះហើយអ្នកអាចអានកូដបានដោយស្ទើរតែគ្មានការបណ្តុះបណ្តាលទាល់តែសោះ។ លក្ខណៈពិសេសនៃភាសានេះត្រូវបានប្រើនៅក្នុងក្រុមហ៊ុនសកលជាច្រើន នៅពេលដែលលេខកូដត្រូវបានអានរួមគ្នាជាមួយអ្នកឯកទេសដែលមិនមែនជាស្នូល (អ្នកគ្រប់គ្រង អតិថិជន។ល។)។ នេះ​គឺ​ជា​ការ​ងាយ​ស្រួល​ខ្លាំង​ណាស់​សម្រាប់​វិធី​សា​ស្រ្ត​ដូច​ជា​ការ​រចនា​ជំរុញ​ការ​អភិវឌ្ឍ​។
សូម្បី​តែ​អ្នក​សរសេរ​កម្មវិធី​ថ្មីថ្មោង​ក៏​ចាប់​ផ្ដើម​ផលិត​កូដ​សមរម្យ​បន្ទាប់​ពី​មួយ​ឬ​ពីរ​សប្ដាហ៍។ សៀវភៅដែលខ្ញុំបានសិក្សាគឺ "Go Programming" (ដោយ Mark Summerfield)។ សៀវភៅនេះល្អណាស់ វាប៉ះលើភាពខុសប្លែកជាច្រើននៃភាសា។ បន្ទាប់ពីភាសាស្មុគស្មាញដែលមិនចាំបាច់ដូចជា Java, PHP ការខ្វះខាតវេទមន្តត្រូវបានធ្វើឱ្យស្រស់។ ប៉ុន្តែមិនយូរមិនឆាប់ អ្នកសរសេរកម្មវិធីដែលមានកម្រិតជាច្រើនមានគំនិតប្រើវិធីសាស្រ្តចាស់ក្នុងវិស័យថ្មីមួយ។ តើនេះពិតជាចាំបាច់មែនទេ?

Rob Pike (អ្នកមនោគមវិជ្ជាសំខាន់នៃភាសា) បានបង្កើតភាសា Go ជាភាសាឧស្សាហកម្មដែលងាយស្រួលយល់ និងមានប្រសិទ្ធភាពក្នុងការប្រើប្រាស់។ ភាសានេះត្រូវបានរចនាឡើងសម្រាប់ផលិតភាពអតិបរមានៅក្នុងក្រុមធំ ហើយគ្មានការសង្ស័យអំពីវាទេ។ អ្នកសរសេរកម្មវិធីថ្មីថ្មោងជាច្រើនត្អូញត្អែរថាមានមុខងារជាច្រើនដែលពួកគេបាត់។ បំណងប្រាថ្នាសម្រាប់ភាពសាមញ្ញនេះគឺជាការសម្រេចចិត្តដោយមនសិការរបស់អ្នករចនាភាសា ហើយដើម្បីយល់ច្បាស់ពីមូលហេតុដែលវាត្រូវការ យើងត្រូវយល់ពីការលើកទឹកចិត្តរបស់អ្នកអភិវឌ្ឍន៍ និងអ្វីដែលពួកគេកំពុងព្យាយាមសម្រេចបាននៅក្នុង Go ។

ដូច្នេះហេតុអ្វីបានជាវាត្រូវបានធ្វើឱ្យសាមញ្ញដូច្នេះ? នេះជាសម្រង់សម្ដីមួយចំនួនពី Rob Pike៖

ចំណុចសំខាន់នៅទីនេះគឺថា អ្នកសរសេរកម្មវិធីរបស់យើងមិនមែនជាអ្នកស្រាវជ្រាវទេ។ តាមក្បួនមួយ ពួកគេនៅក្មេងណាស់ មករកយើងបន្ទាប់ពីសិក្សា ប្រហែលជាពួកគេបានសិក្សា Java ឬ C/C++ ឬ Python ។ ពួកគេ​មិន​អាច​យល់​ភាសា​ដ៏​អស្ចារ្យ​មួយ​នោះ​ទេ ប៉ុន្តែ​ក្នុង​ពេល​ជាមួយ​គ្នា​នោះ យើង​ចង់​ឱ្យ​ពួកគេ​បង្កើត​កម្មវិធី​ល្អ​។ នោះហើយជាមូលហេតុដែលភាសាគួរតែងាយស្រួលយល់និងរៀន។

គាត់​គួរ​តែ​ស្គាល់​ប្រហែល​និយាយ​ស្រដៀង​នឹង C. អ្នកសរសេរកម្មវិធីដែលធ្វើការនៅ Google ចាប់ផ្តើមអាជីពដំបូងរបស់ពួកគេ ហើយភាគច្រើនស្គាល់ភាសានីតិវិធី ជាពិសេសគ្រួសារ C ។ តម្រូវការសម្រាប់ផលិតភាពរហ័សក្នុងភាសាសរសេរកម្មវិធីថ្មីមានន័យថា ភាសាមិនគួរមានលក្ខណៈរ៉ាឌីកាល់ពេកទេ។

ពាក្យ​ឆ្លាត​មែន​ទេ?

វត្ថុបុរាណនៃភាពសាមញ្ញ

ភាពសាមញ្ញគឺជាលក្ខខណ្ឌចាំបាច់សម្រាប់ភាពស្រស់ស្អាត។ លោក Lev Tolstoy ។

ការរក្សាវាឱ្យសាមញ្ញគឺជាគោលដៅសំខាន់បំផុតមួយនៅក្នុងការរចនាណាមួយ។ ដូចដែលអ្នកបានដឹងហើយថាគម្រោងដ៏ល្អឥតខ្ចោះមិនមែនជាគម្រោងដែលគ្មានអ្វីត្រូវបន្ថែមនោះទេ ប៉ុន្តែជាគម្រោងមួយដែលគ្មានអ្វីត្រូវដកចេញនោះទេ។ មនុស្សជាច្រើនជឿថា ដើម្បីដោះស្រាយបញ្ហាស្មុគ្រស្មាញ (ឬសូម្បីតែបញ្ចេញ) ឧបករណ៍ស្មុគស្មាញគឺត្រូវការជាចាំបាច់។ ទោះយ៉ាងណាក៏ដោយវាមិនមែនទេ។ ចូរយើងយកភាសា PERL ជាឧទាហរណ៍។ អ្នកមនោគមវិជ្ជាភាសាបានជឿថាអ្នកសរសេរកម្មវិធីគួរតែមានយ៉ាងហោចណាស់វិធីបីយ៉ាងផ្សេងគ្នាដើម្បីដោះស្រាយបញ្ហាមួយ។ អ្នកមនោគមវិជ្ជានៃភាសា Go បានដើរតាមផ្លូវផ្សេង ពួកគេបានសម្រេចចិត្តថាផ្លូវមួយ ប៉ុន្តែវិធីដ៏ល្អមួយគឺគ្រប់គ្រាន់ដើម្បីសម្រេចបាននូវគោលដៅ។ វិធីសាស្រ្តនេះមានមូលដ្ឋានគ្រឹះដ៏ធ្ងន់ធ្ងរ៖ វិធីតែមួយគត់គឺងាយស្រួលរៀន និងពិបាកបំភ្លេច។

ជនចំណាកស្រុកជាច្រើនត្អូញត្អែរថាភាសាមិនមានអរូបីឆើតឆាយទេ។ បាទ នេះជាការពិត ប៉ុន្តែនេះគឺជាគុណសម្បត្តិចម្បងមួយនៃភាសា។ ភាសាមានអប្បរមានៃវេទមន្ត - ដូច្នេះមិនចាំបាច់មានចំណេះដឹងជ្រៅជ្រះដើម្បីអានកម្មវិធីនោះទេ។ ចំពោះ​ការ​សរសេរ​កូដ​នេះ​មិន​មែន​ជា​បញ្ហា​អ្វី​ឡើយ។ កម្មវិធី Golang ដែលសរសេរបានល្អ អានបញ្ឈរ ដោយមានរចនាសម្ព័ន្ធតិចតួច ឬគ្មាន។ លើសពីនេះ ល្បឿននៃការអានកម្មវិធីយ៉ាងហោចណាស់មានលំដាប់នៃរ៉ិចទ័រធំជាងល្បឿននៃការសរសេរវា។ ប្រសិនបើអ្នកពិចារណាថាកូដទាំងអស់មានទម្រង់ឯកសណ្ឋាន (ធ្វើដោយប្រើពាក្យបញ្ជា gofmt ដែលមានស្រាប់) នោះការអានបន្ទាត់បន្ថែមមួយចំនួនមិនមែនជាបញ្ហាទាល់តែសោះ។

មិនបញ្ចេញមតិខ្លាំង

សិល្បៈ​មិន​អត់ឱន​ទេ​ពេល​សេរីភាព​របស់​ខ្លួន​ត្រូវ​បាន​រឹតត្បិត។ ភាពត្រឹមត្រូវមិនមែនជាការទទួលខុសត្រូវរបស់គាត់ទេ។

ដោយ​សារ​តែ​ការ​ចង់​បាន​ភាព​សាមញ្ញ Go ខ្វះ​ការ​សាង​សង់​ដែល​ជា​ភាសា​ផ្សេង​ទៀត​ត្រូវ​បាន​គេ​យល់​ឃើញ​ថា​ជា​អ្វី​ដែល​ធម្មជាតិ​ដោយ​មនុស្ស​ទម្លាប់​ឱ្យ​ពួក​គេ​។ ដំបូងវាប្រហែលជាមានការរអាក់រអួលបន្តិច ប៉ុន្តែបន្ទាប់មកអ្នកសម្គាល់ឃើញថាកម្មវិធីកាន់តែងាយស្រួល និងកាន់តែមិនច្បាស់ក្នុងការអាន។

ឧទាហរណ៍ ឧបករណ៍ប្រើប្រាស់កុងសូលដែលអាន stdin ឬឯកសារពីអាគុយម៉ង់បន្ទាត់ពាក្យបញ្ជានឹងមើលទៅដូចនេះ៖

package main

import (
    "bufio"
    "flag"
    "fmt"
    "log"
    "os"
)

func main() {

    flag.Parse()

    scanner := newScanner(flag.Args())

    var text string
    for scanner.Scan() {
        text += scanner.Text()
    }

    if err := scanner.Err(); err != nil {
        log.Fatal(err)
    }

    fmt.Println(text)
}

func newScanner(flags []string) *bufio.Scanner {
    if len(flags) == 0 {
        return bufio.NewScanner(os.Stdin)
    }

    file, err := os.Open(flags[0])

    if err != nil {
        log.Fatal(err)
    }

    return bufio.NewScanner(file)
}

ដំណោះស្រាយចំពោះបញ្ហាដូចគ្នានៅក្នុង D ទោះបីជាវាមើលទៅខ្លីជាងបន្តិចក៏ដោយ គឺមិនងាយស្រួលអានទេ។

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);
    }
}

នរកនៃការចម្លង

បុរសផ្ទុកនរកនៅក្នុងខ្លួន។ ម៉ាទីន លូធើ។

អ្នកចាប់ផ្តើមដំបូងតែងតែត្អូញត្អែរអំពី Go នៅក្នុងលក្ខខណ្ឌនៃការខ្វះខាតទូទៅ។ ដើម្បីដោះស្រាយបញ្ហានេះ ពួកគេភាគច្រើនប្រើការចម្លងកូដដោយផ្ទាល់។ ឧទាហរណ៍ មុខងារសម្រាប់បូកសរុបបញ្ជីចំនួនគត់ អ្នកជំនាញបែបនេះជឿថាមុខងារនេះមិនអាចត្រូវបានអនុវត្តតាមវិធីណាផ្សេងក្រៅពីការចម្លងបិទភ្ជាប់សាមញ្ញសម្រាប់ប្រភេទទិន្នន័យនីមួយៗនោះទេ។

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 main() {

    list32 := []int32{1, 2, 3, 4, 5}
    list64 := []int64{1, 2, 3, 4, 5}

    fmt.Println(int32Sum(list32))
    fmt.Println(int64Sum(list64))
}

ភាសាមានមធ្យោបាយគ្រប់គ្រាន់ដើម្បីអនុវត្តសំណង់បែបនេះ។ ឧទាហរណ៍ ការសរសេរកម្មវិធីទូទៅនឹងល្អ។

package main

import "fmt"

func Eval32(list []int32, fn func(a, b int32)int32) int32 {
    var res int32
    for _, val := range list {
        res = fn(res, val)
    }
    return res
}

func int32Add(a, b int32) int32 {
    return a + b
}

func int32Sub(a, b int32) int32 {
    return a + b
}

func Eval64(list []int64, fn func(a, b int64)int64) int64 {
    var res int64
    for _, val := range list {
        res = fn(res, val)
    }
    return res
}

func int64Add(a, b int64) int64 {
    return a + b
}

func int64Sub(a, b int64) int64 {
    return a - b
}

func main() {

    list32 := []int32{1, 2, 3, 4, 5}
    list64 := []int64{1, 2, 3, 4, 5}

    fmt.Println(Eval32(list32, int32Add))
    fmt.Println(Eval64(list64, int64Add))
    fmt.Println(Eval64(list64, int64Sub))
}

ហើយទោះបីជាកូដរបស់យើងប្រែទៅជាវែងជាងករណីមុនបន្តិចក៏ដោយ វាបានក្លាយទៅជាទូទៅ។ ដូច្នេះវានឹងមិនពិបាកសម្រាប់យើងក្នុងការអនុវត្តប្រតិបត្តិការនព្វន្ធទាំងអស់នោះទេ។

មនុស្សជាច្រើននឹងនិយាយថាកម្មវិធីនៅក្នុង D មើលទៅខ្លីជាង ហើយពួកគេនឹងត្រឹមត្រូវ។

import std.stdio;
import std.algorithm;

void main(string[] args)
{
    [1, 2, 3, 4, 5].reduce!((a, b) => a + b).writeln;
}

ទោះយ៉ាងណាក៏ដោយ វាខ្លីជាង ប៉ុន្តែមិនត្រឹមត្រូវជាងនេះទេ ដោយសារការអនុវត្ត D មិនអើពើនឹងបញ្ហានៃការដោះស្រាយកំហុសទាំងស្រុង។

នៅក្នុងជីវិតពិត នៅពេលដែលភាពស្មុគស្មាញនៃតក្កវិជ្ជាកើនឡើង គម្លាតនឹងរួមតូចយ៉ាងឆាប់រហ័ស។ គម្លាតកាន់តែបិទកាន់តែលឿននៅពេលដែលអ្នកត្រូវអនុវត្តសកម្មភាពដែលមិនអាចអនុវត្តដោយប្រើប្រតិបត្តិករភាសាស្តង់ដារ។

នៅក្នុងលក្ខខណ្ឌនៃការថែរក្សា ការពង្រីក និងការអានតាមគំនិតរបស់ខ្ញុំ ភាសា Go ឈ្នះ បើទោះបីជាវាចាញ់ដោយពាក្យសំដីក៏ដោយ។

ការសរសេរកម្មវិធីទូទៅនៅក្នុងករណីខ្លះផ្តល់ឱ្យយើងនូវអត្ថប្រយោជន៍ដែលមិនអាចប្រកែកបាន។ នេះត្រូវបានបង្ហាញយ៉ាងច្បាស់ដោយកញ្ចប់តម្រៀប។ ដូច្នេះ ដើម្បីតម្រៀបបញ្ជីណាមួយ យើងគ្រាន់តែត្រូវអនុវត្តចំណុចប្រទាក់ sort.Interface ។

import "sort"

type Names []string

func (ns Names) Len() int {
    return len(ns)
}

func (ns Names) Less(i, j int) bool {
    return ns[i] < ns[j]
}

func (ns Names) Swap(i, j int) {
    ns[i], ns[j] = ns[j], ns[i]
}

func main() {
    names := Names{"London", "Berlin", "Rim"}
    sort.Sort(names)
}

ប្រសិនបើអ្នកយកគម្រោងប្រភពបើកចំហណាមួយ ហើយដំណើរការពាក្យបញ្ជា grep “ចំណុចប្រទាក់{}” -R អ្នកនឹងឃើញថាតើចំណុចប្រទាក់ដែលច្រឡំត្រូវបានប្រើញឹកញាប់ប៉ុណ្ណា។ សមមិត្តជិតដិតនឹងនិយាយភ្លាមៗថាទាំងអស់នេះគឺដោយសារតែខ្វះទូទៅ។ ទោះជាយ៉ាងណាក៏ដោយនេះមិនមែនតែងតែជាករណីនោះទេ។ ចូរយក DELPHI ជាឧទាហរណ៍។ ទោះបីជាមានវត្តមាននៃប្រភេទដូចគ្នានេះក៏ដោយ វាមានប្រភេទ VARIANT ពិសេសសម្រាប់ប្រតិបត្តិការជាមួយប្រភេទទិន្នន័យបំពាន។ ភាសា Go ធ្វើដូចគ្នា។

ពីកាណុងបាញ់ទៅចាប

ហើយ straitjacket ត្រូវតែសមនឹងទំហំនៃការឆ្កួតនេះ។ Stanislav Lec ។

អ្នកគាំទ្រជ្រុលនិយមជាច្រើនប្រហែលជាអះអាងថា Go មានយន្តការមួយផ្សេងទៀតសម្រាប់បង្កើតលក្ខណៈទូទៅ - ការឆ្លុះបញ្ចាំង។ ហើយពួកគេនឹងត្រឹមត្រូវ ... ប៉ុន្តែមានតែក្នុងករណីកម្រប៉ុណ្ណោះ។

Rob Pike ព្រមានយើង៖

នេះគឺជាឧបករណ៍ដ៏មានឥទ្ធិពលដែលគួរប្រើដោយប្រុងប្រយ័ត្ន។ វាគួរតែត្រូវបានជៀសវាងលុះត្រាតែចាំបាច់។

វិគីភីឌាប្រាប់យើងដូចខាងក្រោមៈ

ការឆ្លុះបញ្ចាំង សំដៅលើដំណើរការដែលកម្មវិធីមួយអាចត្រួតពិនិត្យ និងកែប្រែរចនាសម្ព័ន្ធ និងអាកប្បកិរិយារបស់វាក្នុងអំឡុងពេលប្រតិបត្តិ។ ការឆ្លុះបញ្ចាំងពីមូលដ្ឋាននៃគំរូនៃការសរសេរកម្មវិធីត្រូវបានគេហៅថាកម្មវិធីឆ្លុះបញ្ចាំង។ នេះគឺជាប្រភេទនៃកម្មវិធីមេតា។

ទោះជាយ៉ាងណាក៏ដោយដូចដែលអ្នកបានដឹងហើយថាអ្នកត្រូវចំណាយសម្រាប់អ្វីគ្រប់យ៉ាង។ ក្នុងករណីនេះវាគឺ:

• ការលំបាកក្នុងការសរសេរកម្មវិធី
• ល្បឿនដំណើរការកម្មវិធី

ដូច្នេះ ការ​ឆ្លុះ​បញ្ចាំង​ត្រូវ​ប្រើ​ដោយ​ប្រុង​ប្រយ័ត្ន ដូច​ជា​អាវុធ​ដែល​មាន​ទំហំ​ធំ។ ការប្រើប្រាស់ការឆ្លុះបញ្ចាំងដោយមិនគិតនាំឱ្យកម្មវិធីមិនអាចអានបាន កំហុសថេរ និងល្បឿនទាប។ គ្រាន់តែជារឿងសម្រាប់អ្នកសរសេរកម្មវិធី snob ដើម្បីអាចបង្ហាញកូដរបស់គាត់នៅចំពោះមុខមិត្តរួមការងារដ៏ទៃទៀតប្រកបដោយប្រសិទ្ធភាព និងសុភាព។

អីវ៉ាន់វប្បធម៌ពីស៊ី? ទេ មកពីភាសាជាច្រើន!

ទន្ទឹម​នឹង​ទ្រព្យ​សម្បត្តិ បំណុល​ក៏​ត្រូវ​ទុក​ឲ្យ​អ្នក​ស្នង។

ទោះបីជាការពិតដែលថាមនុស្សជាច្រើនជឿថាភាសាគឺផ្អែកទាំងស្រុងលើបេតិកភណ្ឌ C នេះមិនមែនជាករណីនោះទេ។ ភាសារួមបញ្ចូលទិដ្ឋភាពជាច្រើននៃភាសាសរសេរកម្មវិធីល្អបំផុត។

វាក្យសម្ព័ន្ធ

ជាដំបូងវាក្យសម្ព័ន្ធនៃរចនាសម្ព័ន្ធវេយ្យាករណ៍គឺផ្អែកលើវាក្យសម្ព័ន្ធនៃភាសា C ។ ទោះយ៉ាងណាក៏ដោយ ភាសា DELPHI ក៏មានឥទ្ធិពលយ៉ាងសំខាន់ផងដែរ។ ដូច្នេះហើយ យើងឃើញថា វង់ក្រចកដែលលែងត្រូវការតទៅទៀត ដែលកាត់បន្ថយការអានកម្មវិធីបានយ៉ាងច្រើន ត្រូវបានដកចេញទាំងស្រុង។ ភាសានេះក៏មានប្រតិបត្តិករ ":=" ដែលមាននៅក្នុងភាសា DELPHI ផងដែរ។ គំនិតនៃកញ្ចប់ត្រូវបានខ្ចីពីភាសាដូចជា ADA ។ សេចក្តីប្រកាសនៃអង្គភាពដែលមិនប្រើត្រូវបានខ្ចីពីភាសា PROLOG ។

សេនទិច

កញ្ចប់ត្រូវបានផ្អែកលើអត្ថន័យនៃភាសា DELPHI ។ កញ្ចប់នីមួយៗបង្កប់នូវទិន្នន័យ និងកូដ ហើយមានអង្គភាពឯកជន និងសាធារណៈ។ វាអនុញ្ញាតឱ្យអ្នកកាត់បន្ថយចំណុចប្រទាក់កញ្ចប់ទៅអប្បបរមា។

ប្រតិបត្តិការអនុវត្តដោយវិធីសាស្រ្តប្រតិភូត្រូវបានខ្ចីពីភាសា DELPHI ។

ការចងក្រង

វាមិនមែនដោយគ្មានហេតុផលទេដែលមានរឿងកំប្លែងមួយ៖ Go ត្រូវបានបង្កើតឡើងខណៈពេលដែលកម្មវិធី C កំពុងត្រូវបានចងក្រង។ ចំណុចខ្លាំងមួយនៃភាសាគឺការចងក្រងលឿនជ្រុលរបស់វា។ គំនិតនេះត្រូវបានខ្ចីពីភាសា DELPHI ។ កញ្ចប់ Go នីមួយៗត្រូវគ្នាទៅនឹងម៉ូឌុល DELPHI ។ កញ្ចប់ទាំងនេះត្រូវបានចងក្រងឡើងវិញតែនៅពេលដែលពិតជាចាំបាច់។ ដូច្នេះហើយ បន្ទាប់ពីការកែសម្រួលលើកក្រោយ អ្នកមិនចាំបាច់ចងក្រងកម្មវិធីទាំងមូលទេ ប៉ុន្តែត្រូវចងក្រងឡើងវិញតែកញ្ចប់ដែលបានផ្លាស់ប្តូរ និងកញ្ចប់ដែលអាស្រ័យលើកញ្ចប់ដែលបានផ្លាស់ប្តូរទាំងនេះ (ហើយសូម្បីតែនៅពេលនោះ លុះត្រាតែចំណុចប្រទាក់កញ្ចប់បានផ្លាស់ប្តូរ)។

សំណង់កម្រិតខ្ពស់

ភាសានេះមានរចនាសម្ព័ន្ធកម្រិតខ្ពស់ខុសៗគ្នាជាច្រើនដែលមិនទាក់ទងនឹងភាសាកម្រិតទាបដូចជា C ។

• ខ្សែអក្សរ
• តារាងហាស
• ចំណិត
• ការវាយអក្សរទាត្រូវបានខ្ចីពីភាសាដូចជា RUBY (ជាអកុសល មនុស្សជាច្រើនមិនយល់ ឬប្រើពេញសមត្ថភាពរបស់វា)។

ការគ្រប់គ្រងអង្គចងចាំ

ការគ្រប់គ្រងអង្គចងចាំជាទូទៅសមនឹងទទួលបានអត្ថបទដាច់ដោយឡែកមួយ។ ប្រសិនបើនៅក្នុងភាសាដូចជា C ++ ការគ្រប់គ្រងត្រូវបានទុកចោលទាំងស្រុងចំពោះអ្នកអភិវឌ្ឍន៍ បន្ទាប់មកនៅក្នុងភាសាក្រោយៗទៀតដូចជា DELPHI គំរូរាប់យោងត្រូវបានប្រើ។ ជាមួយនឹងវិធីសាស្រ្តនេះ សេចក្តីយោងរង្វិលមិនត្រូវបានអនុញ្ញាតទេ ដោយសារចង្កោមកុមារកំព្រាត្រូវបានបង្កើតឡើង បន្ទាប់មក Go មានការរកឃើញចង្កោមបែបនេះ (ដូចជា C#)។ លើសពីនេះ អ្នកប្រមូលសំរាមមានប្រសិទ្ធភាពជាងការអនុវត្តដែលគេស្គាល់ភាគច្រើន ហើយអាចប្រើប្រាស់សម្រាប់កិច្ចការជាក់ស្តែងជាច្រើនរួចទៅហើយ។ ភាសាខ្លួនឯងទទួលស្គាល់ស្ថានភាពនៅពេលដែលតម្លៃសម្រាប់រក្សាទុកអថេរអាចត្រូវបានបែងចែកនៅលើជង់។ នេះកាត់បន្ថយការផ្ទុកនៅលើកម្មវិធីគ្រប់គ្រងអង្គចងចាំ និងបង្កើនល្បឿនកម្មវិធី។

ភាពស៊ីសង្វាក់គ្នា។

ភាពស្របគ្នា និងការប្រកួតប្រជែងនៃភាសាគឺហួសពីការសរសើរ។ គ្មានភាសាកម្រិតទាបអាចប្រកួតប្រជែងពីចម្ងាយជាមួយ Go បានទេ។ ដើម្បីឱ្យមានភាពយុត្តិធម៌ គួរកត់សម្គាល់ថាគំរូនេះមិនត្រូវបានបង្កើតឡើងដោយអ្នកនិពន្ធភាសានោះទេ ប៉ុន្តែត្រូវបានខ្ចីពីភាសា ADA ចាស់ដ៏ល្អ។ ភាសានេះមានសមត្ថភាពដំណើរការការតភ្ជាប់ប៉ារ៉ាឡែលរាប់លានដោយប្រើស៊ីភីយូទាំងអស់ ខណៈពេលដែលមានលំដាប់នៃបញ្ហាស្មុគស្មាញតិចជាមួយនឹងបញ្ហាជាប់គាំង និងលក្ខខណ្ឌប្រណាំងដែលជាតួយ៉ាងសម្រាប់កូដពហុខ្សែ។

អត្ថប្រយោជន៍បន្ថែម

ប្រសិនបើវាចំណេញ មនុស្សគ្រប់គ្នានឹងក្លាយទៅជាមនុស្សមិនគិតតែពីខ្លួនឯង។

ភាសាក៏ផ្តល់ឱ្យយើងនូវអត្ថប្រយោជន៍ដែលមិនគួរឱ្យសង្ស័យមួយចំនួនផងដែរ៖

• ឯកសារដែលអាចប្រតិបត្តិបានតែមួយបន្ទាប់ពីបង្កើតគម្រោងជួយសម្រួលដល់ការដាក់ឱ្យប្រើប្រាស់កម្មវិធី។
• ការ​វាយ​អក្សរ​និង​ការ​សន្និដ្ឋាន​ប្រភេទ​ឋិតិវន្ត​អាច​កាត់​បន្ថយ​ចំនួន​កំហុស​ក្នុង​កូដ​របស់​អ្នក​បាន​យ៉ាង​ខ្លាំង​ ទោះ​បី​ជា​គ្មាន​ការ​ធ្វើ​តេស្ត​សរសេរ​ក៏ដោយ។ ខ្ញុំស្គាល់អ្នកសរសេរកម្មវិធីមួយចំនួនដែលធ្វើដោយគ្មានការធ្វើតេស្តសរសេរអ្វីទាំងអស់ ហើយគុណភាពនៃកូដរបស់ពួកគេមិនរងទុក្ខខ្លាំងនោះទេ។
• ការចងក្រងឆ្លងកាត់ដ៏សាមញ្ញបំផុត និងការចល័តដ៏ល្អនៃបណ្ណាល័យស្តង់ដារ ដែលជួយសម្រួលដល់ការអភិវឌ្ឍន៍កម្មវិធីឆ្លងវេទិកា។
• កន្សោមធម្មតា RE2 គឺមានសុវត្ថិភាពខ្សែស្រឡាយ និងមានពេលវេលាប្រតិបត្តិដែលអាចព្យាករណ៍បាន។
• បណ្ណាល័យស្ដង់ដារដ៏មានឥទ្ធិពលដែលអនុញ្ញាតឱ្យគម្រោងភាគច្រើនធ្វើដោយគ្មានក្របខ័ណ្ឌភាគីទីបី។
• ភាសាមានថាមពលគ្រប់គ្រាន់ដើម្បីផ្តោតលើបញ្ហាជាជាងវិធីដោះស្រាយ ប៉ុន្តែកម្រិតទាបគ្រប់គ្រាន់ដែលបញ្ហាអាចដោះស្រាយបានយ៉ាងមានប្រសិទ្ធភាព។
• ប្រព័ន្ធអេកូ Go មានឧបករណ៍ដែលបានអភិវឌ្ឍរួចជាស្រេចចេញពីប្រអប់សម្រាប់គ្រប់ឱកាសទាំងអស់៖ ការធ្វើតេស្ត ឯកសារ ការគ្រប់គ្រងកញ្ចប់ ធុងសំរាមដ៏មានអានុភាព ការបង្កើតកូដ ឧបករណ៍ចាប់លក្ខខណ្ឌប្រណាំង។ល។
• Go កំណែ 1.11 បានណែនាំការគ្រប់គ្រងភាពអាស្រ័យតាមន័យដែលភ្ជាប់មកជាមួយ ដែលបង្កើតឡើងនៅលើកំពូលនៃការបង្ហោះ VCS ដ៏ពេញនិយម។ ឧបករណ៍ទាំងអស់ដែលបង្កើតជាប្រព័ន្ធអេកូ Go ប្រើប្រាស់សេវាកម្មទាំងនេះដើម្បីទាញយក បង្កើត និងដំឡើងកូដពីពួកវាក្នុងពេលតែមួយ។ ហើយនោះពិតជាអស្ចារ្យណាស់។ ជាមួយនឹងការមកដល់នៃកំណែ 1.11 បញ្ហាជាមួយនឹងកំណែកញ្ចប់ក៏ត្រូវបានដោះស្រាយទាំងស្រុងផងដែរ។
• ដោយសារតែគំនិតស្នូលនៃភាសាគឺដើម្បីកាត់បន្ថយវេទមន្ត ភាសានេះលើកទឹកចិត្តអ្នកអភិវឌ្ឍន៍ឱ្យធ្វើការដោះស្រាយកំហុសយ៉ាងច្បាស់។ ហើយនេះជាការត្រឹមត្រូវ ពីព្រោះបើមិនដូច្នេះទេ វានឹងភ្លេចអំពីការដោះស្រាយកំហុសទាំងស្រុង។ រឿងមួយទៀតគឺថា អ្នកអភិវឌ្ឍន៍ភាគច្រើនមិនអើពើនឹងការដោះស្រាយកំហុស ដោយចេតនា ជំនួសឱ្យការដំណើរការពួកវា ដើម្បីបញ្ជូនកំហុសឡើងលើ។
• ភាសានេះមិនអនុវត្តវិធីសាស្រ្ត OOP បុរាណទេ ព្រោះនៅក្នុងទម្រង់ដ៏បរិសុទ្ធរបស់វា មិនមាននិម្មិតនៅក្នុង Go ទេ។ ទោះជាយ៉ាងណាក៏ដោយនេះមិនមែនជាបញ្ហាទេនៅពេលប្រើចំណុចប្រទាក់។ អវត្ដមាននៃ OOP កាត់បន្ថយយ៉ាងខ្លាំងនូវឧបសគ្គក្នុងការចូលសម្រាប់អ្នកចាប់ផ្តើមដំបូង។

ភាពសាមញ្ញ ដើម្បីផលប្រយោជន៍សហគមន៍

វា​ងាយ​ស្រួល​ក្នុង​ការ​ស្មុគស្មាញ ពិបាក​ធ្វើ​ឲ្យ​សាមញ្ញ។

Go ត្រូវ​បាន​រចនា​ឡើង​ឱ្យ​សាមញ្ញ ហើយ​វា​ទទួល​បាន​ជោគជ័យ​តាម​គោលដៅ​នោះ។ វាត្រូវបានសរសេរសម្រាប់អ្នកសរសេរកម្មវិធីឆ្លាតវៃដែលយល់ពីអត្ថប្រយោជន៍នៃការធ្វើការងារជាក្រុម ហើយធុញទ្រាន់នឹងភាពប្រែប្រួលគ្មានទីបញ្ចប់នៃភាសាកម្រិតសហគ្រាស។ ការមានរចនាសម្ព័ន្ធវាក្យសម្ព័ន្ធតិចតួចនៅក្នុងឃ្លាំងអាវុធរបស់វា វាមិនមានលក្ខណៈប្រែប្រួលតាមពេលវេលានោះទេ ដូច្នេះអ្នកអភិវឌ្ឍន៍មានពេលច្រើនសម្រាប់ការអភិវឌ្ឍន៍ ហើយមិនមែនសម្រាប់ការសិក្សាការច្នៃប្រឌិតភាសាមិនចេះចប់នោះទេ។

ក្រុមហ៊ុនក៏ទទួលបានអត្ថប្រយោជន៍មួយចំនួនផងដែរ៖ របាំងចូលទាបអនុញ្ញាតឱ្យពួកគេស្វែងរកអ្នកឯកទេសយ៉ាងឆាប់រហ័ស ហើយភាពមិនអាចផ្លាស់ប្តូរបាននៃភាសាអនុញ្ញាតឱ្យពួកគេប្រើលេខកូដដូចគ្នាសូម្បីតែបន្ទាប់ពី 10 ឆ្នាំក៏ដោយ។

សេចក្តីសន្និដ្ឋាន

ទំហំ​ខួរក្បាល​ធំ​មិន​ដែល​ធ្វើ​ឱ្យ​ដំរី​ណា​មួយ​ឈ្នះ​រង្វាន់​ណូបែល​ទេ។

សម្រាប់អ្នកសរសេរកម្មវិធីទាំងនោះដែលអត្មាផ្ទាល់ខ្លួនមានអាទិភាពលើស្មារតីក្រុម ក៏ដូចជាអ្នកទ្រឹស្តីដែលចូលចិត្តការប្រកួតប្រជែងផ្នែកសិក្សា និង "ការកែលម្អខ្លួនឯង" មិនចេះចប់ ភាសាគឺពិតជាអាក្រក់ព្រោះវាជាភាសាសិល្បៈទូទៅដែលមិនអនុញ្ញាតឱ្យអ្នកទទួលបាន ភាពរីករាយនៃសោភ័ណភាពពីលទ្ធផលនៃការងាររបស់អ្នក និងបង្ហាញខ្លួនឯងប្រកបដោយវិជ្ជាជីវៈនៅចំពោះមុខមិត្តរួមការងារ (ផ្តល់ថាយើងវាស់ស្ទង់ភាពវៃឆ្លាតតាមលក្ខណៈវិនិច្ឆ័យទាំងនេះ និងមិនមែនដោយ IQ)។ ដូចអ្វីៗទាំងអស់ក្នុងជីវិត វាជាបញ្ហាអាទិភាពផ្ទាល់ខ្លួន។ ដូចជាការច្នៃប្រឌិតដ៏មានតម្លៃទាំងអស់ ភាសាបានមកដល់ផ្លូវឆ្ងាយរួចទៅហើយពីការបដិសេធជាសកលរហូតដល់ការទទួលយកយ៉ាងច្រើន។ ភាសាគឺមានភាពប៉ិនប្រសប់នៅក្នុងភាពសាមញ្ញរបស់វា ហើយដូចដែលអ្នកបានដឹងហើយថា អ្វីគ្រប់យ៉ាងដែលប៉ិនប្រសប់គឺសាមញ្ញ!

ប្រភព: www.habr.com