Go에서 에러를 정의하는 방법은 무엇인가요?

Q1. Go에서 에러(error)란 무엇인가요?
A1.
- Go의 에러는 표준 인터페이스인 `error`를 통해 표현됩니다.
```go
type error interface {
Error() string
}
```
- 호출자에게 문제 발생 사실과 메시지를 전달하기 위한 값(value)이며, `nil`인 경우 에러 없음, `nil`이 아닌 경우 에러 존재로 간주합니다.

Q2. 가장 간단한 에러는 어떻게 정의하나요?
A2.
- 표준 패키지 `errors`의 `New` 함수를 사용해 고정 메시지를 갖는 에러를 만듭니다.
```go
import "errors"

var ErrNotFound = errors.New("resource not found")
```
- 또는 인라인으로:
```go
if condition {
return errors.New("something went wrong")
}
```

Q3. 에러 메시지에 변수를 포함하거나 포맷팅하려면 어떻게 하나요?
A3.
- `fmt.Errorf`를 사용해 포맷 문자열과 인자를 넣고, Go1.13부터는 `%w`로 기존 에러를 래핑(wrap)할 수 있습니다.
```go
import "fmt"

if err := doSomething(); err != nil {
return fmt.Errorf("failed to doSomething: %w", err)
}
```

Q4. 커스텀 에러 타입은 어떻게 만들고, 언제 쓰나요?
A4.
- 필드로 추가 정보를 담고 싶거나 타입별로 구분해서 처리하고 싶을 때 사용합니다.
```go
type MyError struct {
Code int
Details string
}

func (e *MyError) Error() string {
return fmt.Sprintf("code %d: %s", e.Code, e.Details) }

// 반환 예시
return &MyError{Code: 404, Details: "not found"}
```
- 호출 측에서 `errors.As`를 써서 타입 검사 후 추가 필드를 읽을 수 있습니다.

Q5. 에러 래핑(wrapping)과 언래핑(unwrapping)은 어떻게 하나요?
A5.
- 래핑: `fmt.Errorf("context: %w", err)`
- 언래핑: 표준 패키지 `errors`의 `Unwrap`, `Is`, `As`를 사용
```go
if errors.Is(err, ErrNotFound) { … }
var me *MyError
if errors.As(err, &me) {
fmt.Println("code:", me.Code)
}
```

Q6. Sentinel 에러란 무엇이고, 어떻게 정의하나요?
A6.
- 프로그램 전체에서 비교용으로 쓰는 전역 에러 변수(ex. `ErrEOF`)
- 보통 `var ErrX = errors.New("…")` 형태로 패키지 상단에 선언
- 호출자는 `errors.Is(err, ErrX)`로 검사

Q7. 에러 메시지 작성 시 주의할 점은?
A7.
1. 메시지는 소문자로 시작(패키지 이름 반복 금지)
2. 끝에 마침표나 개행문자 제외
3. 호출자에 충분한 상황 정보를 제공하되, 민감 정보는 제외
4. 컨텍스트를 추가할 때는 래핑(`%w`) 사용

Q8. 에러 처리를 위한 모범 사례(Best Practices)는 무엇인가요?
A8.
- 에러 발생 시 즉시 반환(early return)
- 반환 시 `%w`로 원본 에러 래핑
- 호출자는 `errors.Is`/`errors.As`로 분기 처리
- 필요할 때만 커스텀 에러 타입 정의
- 패키지 경계를 넘기며 포맷팅은 최소화하고, 상위(호출자) 레벨에서 메시지 보강

Q9. 외부 라이브러리와의 호환성은 어떻게 확보하나요?
A9.
- Go1.13+ 에러 인터페이스 표준(래핑·언래핑)을 따르면 대부분의 라이브러리와 자연스럽게 연동
- `golang.org/x/xerrors` 대신 표준 `errors`/`fmt` 사용 권장

―――
이상으로 Go에서 에러를 정의·생성·래핑·처리하는 주요 방법과 모범 사례를 FAQ 형식으로 정리했습니다.

Go 언어에서 에러를 정의하고 처리하는 방법은 간단하면서도 강력한 패턴을 따릅니다.

Go는 내장된 `error` 인터페이스를 통해 에러를 표현하며, 이를 통해 사용자 정의 에러를 만들 수 있습니다.

아래에서는 Go에서 에러를 정의하고 사용하는 방법에 대해 자세히 설명하겠습니다.

1. 기본 에러 인터페이스 Go의 `error` 인터페이스는 다음과 같이 정의되어 있습니다: ```go type error interface { Error() string } ``` 이 인터페이스는 `Error()` 메서드를 구현하는 타입을 에러로 간주합니다.

이 메서드는 에러에 대한 설명 문자열을 반환합니다.



2. 기본 에러 생성 Go에서는 기본적으로 `errors` 패키지를 사용하여 간단한 에러를 생성할 수 있습니다.

예를 들어: ```go import "errors" func doSomething() error { return errors.New("something went wrong") } ``` 위의 코드에서 `errors.New` 함수를 사용하여 새로운 에러를 생성하고 반환합니다.



3. 사용자 정의 에러 타입 Go에서는 사용자 정의 에러 타입을 만들 수 있습니다.

이를 통해 더 많은 정보를 포함하는 에러를 생성할 수 있습니다.

사용자 정의 에러 타입은 구조체를 정의하고 `error` 인터페이스를 구현하면 됩니다.

```go type MyError struct { Code int Message string } func (e *MyError) Error() string { return fmt.Sprintf("Error %d: %s", e.Code, e.Message) } func doSomething() error { return &MyError{Code: 404, Message: "Resource not found"} } ``` 위의 예제에서 `MyError` 구조체는 에러 코드와 메시지를 포함하고 있으며, `Error()` 메서드를 통해 에러 메시지를 포맷하여 반환합니다.



4. 에러 검사 및 처리 에러를 처리할 때는 일반적으로 `if` 문을 사용하여 에러가 발생했는지 확인합니다.

예를 들어: ```go func main() { err := doSomething() if err != nil { fmt.Println("Error occurred:", err) } } ```

5. 에러의 타입 검사 Go에서는 에러의 타입을 검사하여 특정 에러에 대한 처리를 할 수 있습니다.

이를 위해 `errors.As` 또는 `errors.Is` 함수를 사용할 수 있습니다.

```go if myErr, ok := err.(*MyError); ok { fmt.Printf("MyError occurred: %d - %s\n", myErr.Code, myErr.Message) } ```

6. 에러 래핑 Go 1.13부터는 에러 래핑 기능이 추가되어, 에러를 더 쉽게 추적하고 원인을 파악할 수 있습니다.

`fmt.Errorf` 함수를 사용하여 에러를 래핑할 수 있습니다.

```go if err != nil { return fmt.Errorf("doSomething failed: %w", err) } ``` 여기서 `%w`는 원래 에러를 래핑하는 데 사용됩니다.

나중에 `errors.Unwrap` 또는 `errors.Is`를 사용하여 원래 에러를 추출할 수 있습니다.



7. Go에서 에러를 정의하고 처리하는 방법은 매우 유연하고 강력합니다.

기본 에러 인터페이스를 사용하여 간단한 에러를 생성할 수 있으며, 사용자 정의 에러 타입을 통해 더 많은 정보를 포함할 수 있습니다.

에러 처리는 명확하고 직관적이며, 에러 래핑 기능을 통해 에러의 원인을 쉽게 추적할 수 있습니다.

이러한 특성 덕분에 Go는 에러 처리를 위한 강력한 도구를 제공합니다.