---
sidebar_label: "인코딩 및 출력"
title: "Processor 출력 - CyberGo JSON | API"
description: "CyberGo JSON Processor 출력 메서드: Encode, EncodePretty, EncodeWithConfig, EncodeBatch/EncodeFields, Compact/Indent/HTMLEscape로 다양한 출력을 지원합니다."
sidebar_position: 5
---

# 출력 메서드

Processor 는 다양한 JSON 인코딩 출력 메서드를 제공합니다.

## 기본 출력

### Encode

시그니처: `func (p *Processor) Encode(value any, config ...Config) (string, error)`

임의의 값을 JSON 문자열로 인코딩합니다.

::: warning 더 이상 사용되지 않음
`Processor.Encode`는 직접 [`EncodeWithConfig`](#encodewithconfig)에 위임합니다. 대신 `EncodeWithConfig`를 사용하세요. `Encode`는 향후 메이저 버전에서 제거될 예정입니다.
:::

```go
result, err := p.Encode(map[string]any{"name": "CyberGo"})
if err != nil {
    panic(err)
}
fmt.Println(result)
```

### EncodePretty

시그니처: `func (p *Processor) EncodePretty(value any, config ...Config) (string, error)`

임의의 값을 포맷팅된 JSON 문자열로 인코딩합니다.

```go
result, err := p.EncodePretty(user)
if err != nil {
    panic(err)
}
```

## 고급 인코딩

### EncodeWithConfig

시그니처: `func (p *Processor) EncodeWithConfig(value any, cfg ...Config) (string, error)`

지정된 설정으로 값을 JSON 문자열로 인코딩합니다.

**매개변수**

| 이름 | 타입 | 필수 | 설명 |
|------|------|------|------|
| `value` | `any` | 예 | 인코딩할 값 |
| `cfg` | `Config` | 아니요 | 인코딩 설정 (선택) |

```go
// PrettyConfig 사용
result, err := p.EncodeWithConfig(data, json.PrettyConfig())

// SecurityConfig 사용
result, err = p.EncodeWithConfig(data, json.SecurityConfig())

// 커스텀 설정 사용
cfg := json.DefaultConfig()
cfg.Pretty = true
cfg.SortKeys = true
cfg.EscapeHTML = true
result, err = p.EncodeWithConfig(data, cfg)
```

### EncodeBatch

시그니처: `func (p *Processor) EncodeBatch(pairs map[string]any, cfg ...Config) (string, error)`

키 - 값 쌍을 JSON 객체로 배치 인코딩합니다.

```go
result, err := p.EncodeBatch(map[string]any{
    "name": "CyberGo",
    "version": "1.0.0",
})
```

### EncodeFields

시그니처: `func (p *Processor) EncodeFields(value any, fields []string, cfg ...Config) (string, error)`

지정된 필드만 인코딩합니다. 부분 직렬화에 자주 사용됩니다.

```go
type User struct {
    Name    string `json:"name"`
    Email   string `json:"email"`
    Private string `json:"private"`
}

user := User{Name: "CyberGo", Email: "test@example.com", Private: "secret"}
// name 과 email 필드만 인코딩
result, err := p.EncodeFields(user, []string{"name", "email"})
```

### EncodeStream

시그니처: `func (p *Processor) EncodeStream(values any, cfg ...Config) (string, error)`

여러 값을 JSON 배열 스트림 (array stream) 으로 인코딩합니다. `values`는 일반적으로 슬라이스나 열거 가능한 컬렉션이며, `[v1,v2,...]` 형태의 JSON 배열 문자열을 출력합니다.

```go
values := []any{"item1", "item2", "item3"}
result, err := p.EncodeStream(values)
```

## 인코딩/디코딩

### Marshal

시그니처: `func (p *Processor) Marshal(value any, cfg ...Config) ([]byte, error)`

Go 값을 JSON 바이트 슬라이스로 인코딩합니다. `encoding/json.Marshal`과 100% 호환됩니다.

```go
data, err := p.Marshal(map[string]any{"name": "CyberGo"})
if err != nil {
    panic(err)
}
fmt.Println(string(data)) // {"name":"CyberGo"}
```

### MarshalIndent

시그니처: `func (p *Processor) MarshalIndent(value any, prefix, indent string, cfg ...Config) ([]byte, error)`

Go 값을 포맷팅된 JSON 바이트 슬라이스로 인코딩합니다. `encoding/json.MarshalIndent`와 100% 호환됩니다.

```go
data, err := p.MarshalIndent(user, "", "  ")
if err != nil {
    panic(err)
}
fmt.Println(string(data))
```

### Unmarshal

시그니처: `func (p *Processor) Unmarshal(data []byte, value any, cfg ...Config) error`

JSON 바이트 슬라이스를 대상 변수로 파싱합니다. `encoding/json.Unmarshal`과 100% 호환됩니다.

```go
var user User
err := p.Unmarshal([]byte(`{"name":"Alice","age":30}`), &user)
if err != nil {
    panic(err)
}
```

## 포맷팅

### Prettify

시그니처: `func (p *Processor) Prettify(jsonStr string, cfg ...Config) (string, error)`

JSON 문자열을 들여쓰기 형식으로 포맷팅합니다.

```go
pretty, err := p.Prettify(`{"name":"Alice","age":30}`)
// 출력:
// {
//   "name": "Alice",
//   "age": 30
// }
```

### Print (제거됨)

:::warning API 변경 안내
Print, PrintE, PrintPretty, PrintPrettyE 는 라이브러리에서 제거되어 더 이상 제공되지 않습니다. 다음 대안을 사용하세요:

```go
// 컴팩트 출력
s, err := p.EncodeWithConfig(data)
if err != nil {
    log.Fatal(err)
}
fmt.Println(s)

// 포맷팅 출력
pretty, err := p.EncodePretty(data)
if err != nil {
    log.Fatal(err)
}
fmt.Println(pretty)
```
:::

### ValidateSchema

시그니처: `func (p *Processor) ValidateSchema(jsonStr string, schema *Schema, cfg ...Config) ([]ValidationError, error)`

JSON 데이터가 지정된 Schema 에 맞는지 검증합니다.

```go
schema := &json.Schema{
    Type:     "object",
    Required: []string{"name", "email"},
    Properties: map[string]*json.Schema{
        "name":  {Type: "string", MinLength: 1},
        "email": {Type: "string", Format: "email"},
    },
}

errors, err := p.ValidateSchema(jsonStr, schema)
if err != nil {
    panic(err)
}
for _, ve := range errors {
    fmt.Printf("경로 %s: %s\n", ve.Path, ve.Message)
}
```

## 포맷팅 작업

### Compact

시그니처: `func (p *Processor) Compact(jsonStr string, cfg ...Config) (string, error)`

JSON 문자열을 압축하여 모든 공백 문자를 제거합니다.

```go
compact, err := p.Compact(`{"name": "CyberGo"}`)
// 출력: {"name":"CyberGo"}
```

### CompactBuffer

시그니처: `func (p *Processor) CompactBuffer(dst *bytes.Buffer, src []byte, cfg ...Config) error`

JSON 을 압축하여 Buffer 에 씁니다.

```go
var buf bytes.Buffer
err := p.CompactBuffer(&buf, []byte(`{"name": "test"}`))
```

### Indent

시그니처: `func (p *Processor) Indent(dst *bytes.Buffer, src []byte, prefix, indent string, cfg ...Config) error`

JSON 을 포맷팅하여 Buffer 에 씁니다.

```go
var buf bytes.Buffer
err := p.Indent(&buf, []byte(`{"name":"test"}`), "", "  ")
```

### HTMLEscape

시그니처: `func (p *Processor) HTMLEscape(dst *bytes.Buffer, src []byte, cfg ...Config)`

JSON 을 HTML 이스케이프하여 Buffer 에 씁니다.

```go
var buf bytes.Buffer
p.HTMLEscape(&buf, []byte(`{"html":"<script>alert(1)</script>"}`))
```

## 관련 문서

- [Config](../config) - 설정 옵션
- [파싱 및 로드](./parse) - Parse/Load 메서드