डेनवर में अभी कुछ दिन पहले, अगली पंक्ति में पहले से ही 5, गो - गोफरकॉन पर सबसे बड़ा सम्मेलन समाप्त हो गया । इस पर, गो टीम ने एक महत्वपूर्ण बयान दिया - गो 2 में नई त्रुटि हैंडलिंग और जेनरिक की प्रारंभिक डिजाइन के ड्राफ्ट प्रकाशित किए जाते हैं, और सभी को चर्चा के लिए आमंत्रित किया जाता है।

मैं तीन आलेखों में इन मसौदों के सार को विस्तार से बताने की कोशिश करूंगा।

जैसा कि कई लोग जानते हैं, पिछले साल (गोफरकॉन में भी), गो टीम ने घोषणा की कि वह गो की मुख्य समस्याओं को हल करने के लिए रिपोर्ट ( अनुभव रिपोर्ट ) और सुझाव एकत्र कर रही थी - उन बिंदुओं की, जिनकी चुनावों में सबसे अधिक आलोचना हुई थी। वर्ष के दौरान, सभी प्रस्तावों और रिपोर्टों का अध्ययन और विचार किया गया था, और मसौदा डिजाइन बनाने में मदद की गई थी, जिस पर चर्चा की जाएगी।

तो, चलो नए त्रुटि हैंडलिंग तंत्र के ड्राफ्ट के साथ शुरू करते हैं।

शुरू करने के लिए, एक छोटा विषयांतर:

1. गो 2 एक सशर्त नाम है - सभी नवाचार गो संस्करण जारी करने की सामान्य प्रक्रिया का हिस्सा होंगे। इसलिए यह अभी भी अज्ञात है कि क्या यह गो 1.34 या गो 2 होगा। अजगर 2/3 लिपि का लोहा नहीं होगा।
2. डिजाइन के ड्राफ्ट भी प्रस्ताव नहीं हैं, जिसके साथ पुस्तकालय, ट्यूनिंग या गो भाषा में कोई भी बदलाव शुरू होता है। इन मुद्दों पर कई वर्षों के काम के बाद गो टीम द्वारा प्रस्तावित डिजाइन चर्चा के लिए यह शुरुआती बिंदु है। उच्च क्षमता वाले ड्राफ्ट में वर्णित सभी चीजों को बदल दिया जाएगा, और, सबसे अच्छे परिदृश्य में, कुछ रिलीज के बाद ही वास्तविकता बन जाएगी (मैं ~ 2 साल देता हूं)।

Go में त्रुटि से निपटने में क्या समस्या है?

गो ने शुरू में "स्पष्ट" त्रुटि जाँच का उपयोग करने का निर्णय लिया, जैसा कि अन्य भाषाओं में लोकप्रिय "निहित" जाँच के विपरीत है - अपवाद। अंतर्निहित त्रुटि जाँच के साथ समस्या यह है कि यह लेख "क्लीनर, अधिक सुरुचिपूर्ण और अधिक सही नहीं" में विस्तार से वर्णित है, जो कि कुछ त्रुटियों के मामले में प्रोग्राम सही ढंग से व्यवहार करता है, तो यह समझना बहुत मुश्किल है।

अपवाद के साथ एक काल्पनिक गो का उदाहरण लें:

func CopyFile(src, dst string) throws error {
    r := os.Open(src)
    defer r.Close()

    w := os.Create(dst)
    io.Copy(w, r)
    w.Close()
}

, . : io.Copy w.Close , .

, Go :

func CopyFile(src, dst string) error {
    r, err := os.Open(src)
    if err != nil {
        return err
    }
    defer r.Close()

    w, err := os.Create(dst)
    if err != nil {
        return err
    }
    defer w.Close()

    if _, err := io.Copy(w, r); err != nil {
        return err
    }
    if err := w.Close(); err != nil {
        return err
    }
}

, , , –  . , , – " ", - , , , .

, ( , , ..) , .

, Go . :

func CopyFile(src, dst string) error {
    r, err := os.Open(src)
    if err != nil {
        return fmt.Errorf("copy %s %s: %v", src, dst, err)
    }
    defer r.Close()

    w, err := os.Create(dst)
    if err != nil {
        return fmt.Errorf("copy %s %s: %v", src, dst, err)
    }

    if _, err := io.Copy(w, r); err != nil {
        w.Close()
        os.Remove(dst)
        return fmt.Errorf("copy %s %s: %v", src, dst, err)
    }

    if err := w.Close(); err != nil {
        os.Remove(dst)
        return fmt.Errorf("copy %s %s: %v", src, dst, err)
    }
}

, .

Go Go 2:

• , ,
• , ,
• –  ,
• Go ,

Go.

.

• check(x,y,z) check err
• handle – ,

check , handle ( handler, , . , return)

:

func CopyFile(src, dst string) error {
    handle err {
        return fmt.Errorf("copy %s %s: %v", src, dst, err)
    }

    r := check os.Open(src)
    defer r.Close()

    w := check os.Create(dst)
    handle err {
        w.Close()
        os.Remove(dst) // (  check )
    }

    check io.Copy(w, r)
    check w.Close()
    return nil
}

, ( main). :

func main() {
    hex, err := ioutil.ReadAll(os.Stdin)
    if err != nil {
        log.Fatal(err)
    }

    data, err := parseHexdump(string(hex))
    if err != nil {
        log.Fatal(err)
    }

    os.Stdout.Write(data)
}

:

func main() {
    handle err {
        log.Fatal(err)
    }

    hex := check ioutil.ReadAll(os.Stdin)
    data := check parseHexdump(string(hex))
    os.Stdout.Write(data)
}

, . :

func printSum(a, b string) error {
    x, err := strconv.Atoi(a)
    if err != nil {
        return err
    }
    y, err := strconv.Atoi(b)
    if err != nil {
        return err
    }
    fmt.Println("result:", x + y)
    return nil
}

:

func printSum(a, b string) error {
    handle err { return err }
    x := check strconv.Atoi(a)
    y := check strconv.Atoi(b)
    fmt.Println("result:", x + y)
    return nil
}

:

func printSum(a, b string) error {
    handle err { return err }
    fmt.Println("result:", check strconv.Atoi(x) + check strconv.Atoi(y))
    return nil
}

check handle.

Check

check ( ) , "" error, , . nil, check (handler), return .

:

v1, ..., vN := check <>

:

v1, ..., vN, vErr := <>
if vErr != nil {
    <error result> = handlerChain(vn)
    return
}

vErr error <error result> , .

,

foo(check <>)

:

v1, ..., vN, vErr := <>
if vErr != nil {
    <error result> = handlerChain(vn)
    return
}
foo(v1, ..., vN)

Check try

try check – /, , , Rust Swift try ( Rust ? ).

try :

data := try parseHexdump(string(hex))

:

data, err := parseHexdump(string(hex))
if err == ErrBadHex {
    ... special handling ...
}
try err

, try c . check/handle , check .

Handle

handle , "" (handler), , check. (return) . ( , return) ( func foo() (bar int, err error)).

, " " – , , , error , , . :

func handler(err error) error {...}

( , , –  ).

–  , . (check) , , . , , –  . :

func process(user string, files chan string) (n int, err error) {
    handle err { return 0, fmt.Errorf("process: %v", err)  }      // handler A
    for i := 0; i < 3; i++ {
        handle err { err = fmt.Errorf("attempt %d: %v", i, err) } // handler B
        handle err { err = moreWrapping(err) }                    // handler C

        check do(something())  // check 1: handler chain C, B, A
    }
    check do(somethingElse())  // check 2: handler chain A
}

check 1 C, B A – . check 2 A, C B for-.

, . if , (handle) ( ) , – , , :

type Error struct {
    Func string
    User string
    Path string
    Err  error
}

func (e *Error) Error() string

func ProcessFiles(user string, files chan string) error {
    e := Error{ Func: "ProcessFile", User: user}
    handle err { e.Err = err; return &e } // handler A
    u := check OpenUserInfo(user)         // check 1
    defer u.Close()
    for file := range files {
        handle err { e.Path = file }       // handler B
        check process(check os.Open(file)) // check 2
    }
    ...
}

, handle defer, , , . – , . , handler B –  defer , . Go defer/panic handle/check , , -.

– (.. return), - . .

(panic) , .

-

– (handle err {}). " -" (default handler). handle , , -, , check ( ; — zero values).

-:

func printSum(a, b string) error {
    x := check strconv.Atoi(a)
    y := check strconv.Atoi(b)
    fmt.Println("result:", x + y)
    return nil
}

Go , . - , , . , t.Helper() , :

func TestFoo(t *testing.T) {
    handle err {
        t.Helper()
        t.Fatal(err)
    }
    for _, tc := range testCases {
        x := check Foo(tc.a)
        y := check Foo(tc.b)
        if x != y {
            t.Errorf("Foo(%v) != Foo(%v)", tc.a, tc.b)
        }
    }
}

(shadowing)

check (:=), err. handle/check .

defer/panic

(defer/panic handle/check) . .

handle defer (, , , ), handle/check defer-. :

func Greet(w io.WriteCloser) error {
    defer func() {
        check w.Close()
    }()
    fmt.Fprintf(w, "hello, world\n")
    return nil
}

, .

Go –  , . - "", , defer, break goto. , goto, , .

try, catch, ? , . , Go , check handle .

, handle catch , ( , (keywords) ).

Go2?

. Go, 2-3 , – . , 2-3 .

, , Go2 –  . , Go – Go 1.20 . .

, ?

. / . , , , Go.

Go 2 – , if err != nil {} , handle/check?

, , if err , –  , . , .

?  , Go .

. , .

?

, , . , - . , , , , .

, ! ?

- Go2ErrorHandlingFeedback

• Go —  handle/check
• -
• , ,
• / ( defer/panic)

• ()
• Go
• Go 2

? ?

• Image credits: Gopher Artwork by Ashley McNamara