Go:
การจัดการกับข้อผิดพลาด

วิธีการ:

ใน Go การจัดการข้อผิดพลาดถูกจัดการอย่างชัดเจนโดยใช้แบบ error ฟังก์ชันที่อาจล้มเหลวจะคืนค่าข้อผิดพลาดเป็นค่าคืนท้ายสุด การตรวจสอบว่าค่าข้อผิดพลาดนี้เป็น nil จะบอกคุณว่าเกิดข้อผิดพลาดหรือไม่

package main

import (
    "errors"
    "fmt"
)

func Compute(value int) (int, error) {
    if value > 100 {
        return 0, errors.New("value must be 100 or less")
    }
    return value * 2, nil
}

func main() {
    result, err := Compute(150)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Result:", result)
    }
    
    // การจัดการข้อผิดพลาดอย่างสง่างาม
    anotherResult, anotherErr := Compute(50)
    if anotherErr != nil {
        fmt.Println("Error:", anotherErr)
    } else {
        fmt.Println("Result:", anotherResult)
    }
}

ผลลัพธ์ตัวอย่างสำหรับโค้ดข้างต้น:

Error: value must be 100 or less
Result: 100

ในตัวอย่างนี้ ฟังก์ชัน Compute จะคืนค่าที่คำนวณได้หรือข้อผิดพลาด ผู้เรียกใช้จัดการข้อผิดพลาดโดยการตรวจสอบว่า err ไม่เป็น nil

ละเอียดยิ่งขึ้น

วิธีการจัดการข้อผิดพลาดของ Go มีความตรงไปตรงมาและปลอดภัยตามประเภทอย่างเจตนา ต้องการการตรวจสอบข้อผิดพลาดอย่างชัดเจน แนวคิดนี้แตกต่างจากการจัดการข้อผิดพลาดที่ใช้การยกเว้นในภาษาเช่น Java และ Python ที่ข้อผิดพลาดถูกส่งผ่านขึ้นไปในสแต็คการเรียกเว้นแต่จะถูกจับโดยตัวจัดการข้อยกเว้น ทีม Go บอกว่าการจัดการข้อผิดพลาดอย่างชัดเจนนำไปสู่โค้ดที่เข้าใจง่ายและเชื่อถือได้มากขึ้น เนื่องจากมันบังคับให้โปรแกรมเมอร์จัดการกับข้อผิดพลาดทันทีที่มันเกิดขึ้น

อย่างไรก็ตาม บางคำวิจารณ์กล่าวว่ารูปแบบนี้อาจนำไปสู่โค้ดที่เขียนยาว โดยเฉพาะในฟังก์ชันที่ซับซ้อนด้วยการดำเนินการที่มีโอกาสเกิดข้อผิดพลาดมากมาย ตอบสนองต่อสิ่งนี้ รุ่นใหม่ของ Go ได้นำเสนอคุณสมบัติการจัดการข้อผิดพลาดที่ซับซ้อนยิ่งขึ้น เช่น การห่อข้อผิดพลาด เพื่อให้ง่ายขึ้นในการให้บริบทกับข้อผิดพลาดโดยไม่สูญเสียข้อมูลข้อผิดพลาดเดิม ชุมชนยังได้เห็นข้อเสนอสำหรับกลไกการจัดการข้อผิดพลาดใหม่ เช่น check/handle แม้ว่าเหล่านี้จะยังคงอยู่ระหว่างการหารือจากข้อมูลล่าสุดของฉัน

ปรัชญาการจัดการข้อผิดพลาดของ Go ย้ำการเข้าใจและวางแผนสำหรับข้อผิดพลาดในฐานะส่วนหนึ่งของกระแสการทำงานปกติของโปรแกรม วิธีการนี้สนับสนุนการพัฒนาซอฟต์แวร์ที่มีความเสถียรและคาดเดาได้มากขึ้น แม้ว่าจะมีการเพิ่มขึ้นของโค้ดประเภทโบรเมอร์ รูปแบบและไลบรารีทางเลือกมีอยู่เพื่อทำให้การจัดการข้อผิดพลาดง่ายขึ้นสำหรับกรณีที่ซับซ้อนโดยเฉพาะ แต่แบบ error ที่มีอยู่ในภาษา Go ยังคงเป็นรากฐานของการจัดการข้อผิดพลาดในภาษา