برای بیان حالتِ خطا از اِرورها استفاده می‌کنیم. در زبان Go، می‌توان از دیتا تایپ error برای بیان حالت خطا استفاده کرد. در زبان Go هنگام بروز خطا، هر تابع می‌تواند مقدار error را به‌عنوان بخشی از خروجی خود برگرداند تا امکان مدیریت خطا توسط تابع فراخوان فراهم شود.

بنابراین از error برای وضعیت‌هایی که انتظار داریم ممکن است اشتباه پیش برود استفاده می‌شود. خطا در باز کردن فایل، یا ورودی نامعتبر از کاربر دو مورد از کاربردهای رایج برای ‍error هستند. در چنین مواقعی خطا جبران پذیر است و برنامه میتواند به درستی ادامه پیدا کند.

به عنوان مثال تابع ‍os.Open هنگامی که با خطا مواجهه می‌شود به عنوان پارامتر خروجی مقداری غیر nil از error برمی‌گرداند.

func Open(name string) (file *File, err error)

در مثال زیر با استفاده از تابع os.Open یک فایل را باز می‌کنیم و در صورتی که خطایی رخ دهد با استفاده از log.Fatal متن خطاها چاپ می‌کنیم و از برنامه خارج می‌شویم.

f, err := os.Open("filename.ext")
if err != nil {
    log.Fatal(err)
}

در حالتی که برنامه نمی‌تواند به درستی ادامه دهد یا خطای غیر قابل جبرانی رخ داده است ‌می‌توان خطا را با panic اعلام کرد. برای آشنایی با panic میتوانید محتوایی تحت عنوان Defer , Panic و Recover را مطالعه کنید.

بررسی دیتاتایپ error

دیتاتایپ error یک اینترفیس دارای یک متد Error() string است. یک متغیر از نوع error بیانگر هر مقداری است که بتواند خودش را به صورت متنی (string) توصیف کند! یعنی هر مقداری که بتوان با تابع Error() یک مقدار متنی متناسب با آن برگرداند.

type error interface {
    Error() string
}

دیتاتایپ error به عنوان یک built-in تایپ در اسکوپ universal تعریف شده است. بنابراین دیتاتایپ error در تمام یک برنامه‌ی Go قابل دسترس خواهد بود.

پکیج errors بخشی از استاندارد پکیج گولنگ است. پکیج errors یکسری تابع و دستورات اولیه را برای کارکردن با خطاها در اختیار ما قرار می‌دهد. این پکیج دارای یک پیاده سازی از اینترفیس error به صورت زیر است:

// errorString is a trivial implementation of error.
type errorString struct {
    s string
}

func (e *errorString) Error() string {
    return e.s
}

در پکیج errors یک تابع با نام errors.New وجود دارد که یک اشاره گر از errorString را به عنوان error برمی‌گرداند. پیاده سازی تابع errors.New همانند زیر است:

// New returns an error that formats as the given text.
func New(text string) error {
    return &errorString{text}
}

بنابراین با استفاده از تابع errors.New می‌توانیم در برنامه های خود error بسازیم!

package main

import (
    "fmt"
    "math"
    "errors"
)

func main() {
    if _, err := Sqrt(-1); err != nil {
        fmt.Println(err)
    }
}

func Sqrt(f float64) (float64, error) {
    if f < 0 {
        return 0, errors.New("math: square root of negative number")
    }

    // implementation
    return math.Sqrt(f), nil
}

در مثال بالا یک تابع با نام Sqrt داریم. در صورتی که پارامتر ورودی این تابع عددی کوچکتر از صفر باشد (منفی باشد) با استفاده از تابع errors.New یک خطا برگردانده می‌شود و در نهایت با استفاده از پکیج fmt مقدار خطا را در صفحه چاپ میکنیم. 

هر error وظیفه دارد به صورت مختصر توضیحاتی در مورد خطایی که رخ داده است ارائه دهد. پکیج fmt با اجرا کردن تابع Error() توضیحات مرتبط با خطا را دریافت می‌کند.

با استفاده از تابع fmt.Errorf نیز می‌توان یکسری توضیحات متنی را به error تبدیل کرد. مثال بالا را با استفاده از تابع ‍fmt.Errorf می‌توانیم به صورت زیر باز نویسی کنیم:

package main

import (
    "fmt"
    "math"
    "errors"
)

func main() {
    if _, err := Sqrt(-1); err != nil {
        fmt.Println(err)
    }
}

func Sqrt(f float64) (float64, error) {
    if f < 0 {
        return 0, fmt.Errorf("math: square root of negative number %g", f)
    }

    // implementation
    return math.Sqrt(f), nil
}

پیاده سازی اینترفیس error

در اکثر مواقع با استفاده از errors.New و یا fmt.Errof می‌توان خطاهای برنامه را به صورت error بیان کرد, اما ممکنه نیاز داشته باشیم جزئیات بیشتری را توسط ‍error انتقال دهیم! در چنین مواقعی می‌توانیم دیتا تایپی ایجاد کنیم که اینترفیس error را پیاده سازی می‌کند. برای پیاده سازی اینترفیس  error فقط کافیست تابع Error را پیاده سازی کنیم.

به عنوان مثال پکیج json سینتکس ارور را به صورت زیر پیاده سازی کرده است:

type SyntaxError struct {
    Offset int64  // error occurred after reading Offset bytes
}

func (e *SyntaxError) Error() string { return e.msg }

مقدار ‍Offset به صورت پیش فرض در خطا نمایش داده نمی‌شود اما می‌توان با استفاده از type assertion به آن دسترسی داشت:

if err := dec.Decode(&val); err != nil {
    if serr, ok := err.(*json.SyntaxError); ok {
        line, col := findLine(f, serr.Offset)
        return fmt.Errorf("%s:%d:%d: %v", f.Name(), line, col, err)
    }
    return err
}

به عنوان مثالی دیگر, در پکیج net اینترفیس Error به صورت زیر وجود دارد:

type Error interface {
	error
	Timeout() bool // Is the error a timeout?

	// Deprecated: Temporary errors are not well-defined.
	// Most "temporary" errors are timeouts, and the few exceptions are surprising.
	// Do not use this method.
	Temporary() bool
}

این اینترفیس علاوه بر متد Error دارای دو متد دیگر با نام‌های Timeout و Temporary نیز است. با توجه به net.Error میتونیم کدی به صورت زیر بنویسیم:

if nerr, ok := err.(net.Error); ok && nerr.Temporary() {
    time.Sleep(1e9)
    continue
}
if err != nil {
    log.Fatal(err)
}

بدین صورت میتوان برای خطاهایی که از قبل شناخته شده هستند دیتاتایپ داشت و سپس با استفاده از type assertion نوعِ هر خطا را بررسی کرد و به جزئیات بیشتری از آن خطا دسترسی داشت.

کد مربوط به Sqrt رو میتونیم به صورت زیر بازنویسی کنیم:

package main

import (
    "fmt"
    "math"
)

// NegativeSqrtError reflects an error can be caused by calculating Sqrt of a negative number.
type NegativeSqrtError float64

func (f NegativeSqrtError) Error() string {
    return fmt.Sprintf("math: square root of negative number %g", float64(f))
}

func main() {
    if _, err := Sqrt(-1); err != nil {
        fmt.Println(err)
    }
}

func Sqrt(f float64) (float64, error) {
    if f < 0 {
        return 0, NegativeSqrtError(f)
    }

    // implementation
    return math.Sqrt(f), nil
}

در مثال بالا یک دیتاتایپ با نام NegativeSqrtError تعریف کردیم. این دیتاتایپ اینترفیس error را پیاده سازی می‌کند.

قسمت قبل: معرفی پکیج استاندارد RPC | گولنگ به زبان ساده

قسمت بعد: پکیج و ماژول | گولنگ به زبان ساده