문서의 각 단락이 어느 리비전에서 마지막으로 수정되었는지 확인할 수 있습니다. 왼쪽의 정보 칩을 통해 작성자와 수정 시점을 파악하세요.

JSON | |
이름 | JSON |
공식 명칭 | JavaScript Object Notation |
파일 확장자 | .json |
발표 연도 | 2001년 |
표준 | ECMA-404, RFC 8259 |
주요 용도 | |
인터넷 미디어 타입 | application/json |
기술적 상세 | |
개발자 | |
파생 언어 | |
데이터 타입 | 문자열, 숫자, 불리언, null, 객체, 배열 |
주요 특징 | 가독성, 경량성, 언어 독립성 |
관련 기술 | |
보안 고려사항 | |
대체 형식 | |
편집 도구 | 텍스트 편집기, JSON 편집기, 온라인 검증기 |

JSON은 자바스크립트 객체 표기법(JavaScript Object Notation)의 약자로, 경량의 데이터 교환 형식이다. 사람이 읽고 쓰기 쉽고, 기계가 분석하고 생성하기도 쉬운 텍스트 기반의 개방형 표준이다. 주로 서버와 웹 애플리케이션 간에 데이터를 전송하는 데 사용되며, API 응답의 표준 형식으로 널리 채택되었다.
이 형식은 완전히 언어 독립적이지만, 자바스크립트의 객체 리터럴 문법을 기반으로 한다. 이로 인해 자바스크립트 환경에서 특히 자연스럽게 사용될 수 있다. JSON은 이름/값 쌍의 컬렉션 또는 순서가 있는 값의 리스트 형태로 구조화된 데이터를 표현한다.
JSON의 주요 설계 목표는 간결성과 효율성이다. XML과 같은 다른 데이터 교환 형식에 비해 불필요한 태그와 중복된 마크업이 없어 데이터 크기가 작고, 네트워크 대역폭 사용을 줄일 수 있다. 이러한 특징 덕분에 모바일 애플리케이션과 같이 제한된 환경에서도 효율적으로 사용된다.
현재 JSON은 ECMAScript 표준의 일부이며, IETF에 의해 RFC 8259로 표준화되어 있다. 웹 서비스, 설정 파일, NoSQL 데이터베이스 등 현대 소프트웨어 개발의 다양한 분야에서 핵심적인 데이터 형식으로 자리 잡았다.

JSON은 키-값 쌍으로 구성된 경량의 데이터 교환 형식이다. 기본 구조는 객체와 배열 두 가지로 구분되며, 이들을 중첩하여 복잡한 계층적 데이터를 표현할 수 있다.
주요 데이터 타입으로는 문자열, 숫자, 불리언, null, 객체, 배열이 지원된다. 문자열은 반드시 큰따옴표(")로 감싸야 하며, 숫자는 정수 또는 부동소수점 형식을 취한다. 불리언은 true 또는 false 리터럴 값을 사용한다.
문법 규칙은 다음과 같다.
* 객체는 중괄호({})로 감싸며, 내부는 쉼표(,)로 구분된 키-값 쌍의 목록으로 구성된다. 키는 반드시 문자열이어야 하고, 키와 값은 콜론(:)으로 구분한다.
* 배열은 대괄호([])로 감싸며, 내부는 쉼표로 구분된 값들의 순서 있는 목록이다.
* 모든 텍스트는 유니코드를 기반으로 하며, 특수문자는 이스케이프 시퀀스를 사용하여 표현한다(예: \n, \", \\).
구조 유형 | 표기법 | 설명 | 예시 |
|---|---|---|---|
객체 |
| 키-값 쌍의 비순서적 집합 |
|
배열 |
| 값들의 순서적 목록 |
|
키-값 쌍 |
| 객체를 구성하는 기본 단위 |
|
이러한 간결하고 명확한 구조 덕분에 JSON은 사람이 읽고 쓰기 쉬우면서도 기계가 파싱하고 생성하는 데도 효율적이다.
JSON은 제한된 수의 기본 데이터 타입을 지원한다. 이는 자바스크립트의 데이터 타입에서 영향을 받았지만, 그보다 더 간소화된 집합을 제공한다.
지원하는 데이터 타입은 다음과 같다.
타입 | 설명 | JSON 예시 |
|---|---|---|
문자열(String) | 큰따옴표(")로 둘러싸인 유니코드 문자 시퀀스이다. |
|
숫자(Number) | 정수 또는 부동소수점 수이다. 지수 표기법도 사용 가능하다. |
|
불리언(Boolean) | 참(true) 또는 거짓(false) 값을 나타낸다. |
|
null | 빈 값 또는 '없음'을 의미하는 특별한 값이다. |
|
객체(Object) | 순서가 없는 키-값 쌍의 집합이다. 중괄호({})로 감싸며, 키는 반드시 문자열이어야 한다. |
|
배열(Array) | 값의 순서 있는 목록이다. 대괄호([])로 감싼다. |
|
이러한 타입들은 중첩이 가능하여 복잡한 데이터 구조를 표현할 수 있다. 예를 들어, 객체의 값으로 배열이, 배열의 요소로 또 다른 객체가 올 수 있다. JSON은 자바스크립트의 undefined, 함수(Function), 날짜(Date) 객체, 심볼(Symbol) 등의 타입을 직접적으로 지원하지 않는다. 이러한 값은 일반적으로 문자열이나 숫자 등 지원되는 타입으로 변환하여 표현해야 한다[1].
JSON에서 가장 핵심적인 데이터 구조는 객체와 배열이다. 객체는 순서가 없는 키-값 쌍의 집합이며, 배열은 순서가 있는 값들의 목록이다. 이 두 구조를 중첩하여 복잡한 계층적 데이터를 표현할 수 있다.
객체는 중괄호({})로 감싸서 표현한다. 객체 내부는 쉼표로 구분된 여러 멤버로 구성되며, 각 멤버는 콜론(:)으로 연결된 문자열 키와 값으로 이루어진다. 키는 반드시 큰따옴표(")로 묶어야 한다. 값은 JSON 데이터 타입 중 하나가 될 수 있다. 다음은 두 개의 멤버를 가진 객체의 예시이다.
```json
{
"name": "Kim",
"age": 30
}
```
배열은 대괄호([])로 감싸서 표현한다. 배열 내부의 값들은 쉼표로 구분되며, 인덱스로 접근할 수 있다. 배열의 요소 역시 모든 JSON 데이터 타입이 될 수 있으며, 객체나 다른 배열을 포함할 수 있다. 다음은 다양한 타입의 요소를 포함하는 배열의 예시이다.
```json
["apple", "banana", 100, true, null]
```
객체와 배열은 자유롭게 중첩되어 트리 구조의 데이터를 모델링한다. 예를 들어, 객체의 값이 배열이 될 수 있고, 그 배열의 요소가 다시 객체가 될 수 있다. 아래 예제는 사용자 정보와 그 사용자의 주문 목록을 표현한 중첩 구조이다.
```json
{
"user": {
"id": 1,
"name": "Lee"
},
"orders": [
{"product": "book", "quantity": 2},
{"product": "pen", "quantity": 5}
]
}
```
JSON의 문법은 ECMAScript의 객체 리터럴 문법의 부분 집합을 기반으로 하며, 엄격한 규칙을 가진다. 모든 JSON 텍스트는 유효한 자바스크립트 표현식이지만, 그 역은 성립하지 않는다. 예를 들어, JSON은 함수나 undefined 같은 자바스크립트 특정 값을 표현할 수 없다.
가장 중요한 규칙은 키-값 쌍을 표현하는 방식이다. 객체를 나타내는 중괄호({}) 내부의 모든 키는 반드시 큰따옴표(")로 감싸야 한다. 값이 문자열인 경우에도 큰따옴표를 사용해야 하며, 작은따옴표(')는 허용되지 않는다. 키와 값은 콜론(:)으로 구분하며, 각 키-값 쌍은 쉼표(,)로 구분한다. 배열은 대괄호([])로 표현하며, 요소 역시 쉼표로 구분한다.
JSON 문서의 최상위(root) 구조는 반드시 객체({}) 또는 배열([])이어야 한다. 단일 문자열이나 숫자 값만으로는 유효한 JSON 문서가 될 수 없다. 공백(스페이스, 탭, 줄바꿈)은 키, 값, 구분 기호 사이에 삽입되어 가독성을 높일 수 있지만, 문자열 값 내부의 공백을 제외하고는 구문 분석에 영향을 미치지 않는다. 주석은 공식 표준에 포함되어 있지 않아 허용되지 않는다.
규칙 | 올바른 예 | 잘못된 예 |
|---|---|---|
키 따옴표 |
|
|
문자열 따옴표 |
|
|
최상위 구조 |
|
|
마지막 쉼표 |
|
|
숫자 표현 |
|
|
마지막 요소 뒤에 쉼표를 사용하는 트레일링 콤마(trailing comma)는 문법 오류로 간주된다. 숫자는 10진수 형식으로 표현해야 하며, 선행 0(예: 012)이나 16진수 표기는 허용되지 않는다. 특수 문자는 문자열 내에서 이스케이프 시퀀스를 사용해야 하며, 예를 들어 줄바꿈은 \n, 큰따옴표는 \"로 표현한다.

JSON의 개발은 2000년대 초반, XML을 대체할 수 있는 경량의 데이터 교환 형식에 대한 필요성에서 비롯되었다. 당시 AJAX 기술의 등장으로 웹 브라우저와 서버 간의 비동기적 데이터 교환이 활발해지면서, 복잡하고 무거운 XML 구문을 처리하는 데 따른 오버헤드가 문제로 지적되었다. 이에 더글러스 크록포드를 비롯한 개발자들은 자바스크립트의 객체 리터럴 표기법을 기반으로 한 간단한 텍스트 형식을 고안했으며, 2001년에 공식적으로 JSON을 정의하였다[2]. JSON은 인간과 기계 모두 읽고 쓰기 쉽도록 설계되었으며, XML에 비해 구문이 훨씬 간결하고 파싱 속도가 빠르다는 장점으로 빠르게 인기를 얻었다.
JSON의 표준화는 ECMA 인터내셔널을 통해 진행되었다. 2013년에 공표된 ECMA-404 표준은 JSON 데이터 교환 형식에 대한 최초의 공식 표준이었다. 이 표준은 JSON의 문법과 허용되는 데이터 타입을 엄격하게 정의했지만, 파싱이나 생성 방법과 같은 구현 세부사항은 규정하지 않았다. 이후 2017년에는 ECMAScript 2017 (ES8) 명세의 일부로 JSON이 공식적으로 포함되면서, 웹의 핵심 언어인 자바스크립트와의 통합이 더욱 공고해졌다.
연도 | 주요 사건 | 설명 |
|---|---|---|
2001년 | JSON 공식 발표 | 더글러스 크록포드가 json.org를 통해 명세 공개 |
2005-2006년 | AJAX와의 결합 | |
2013년 | ECMA-404 표준 제정 | JSON 형식에 대한 최초의 국제 표준이 됨 |
2017년 | ECMAScript 표준 편입 | ECMAScript 2017 명세에 JSON이 공식 포함됨 |
이러한 표준화 과정을 거치며 JSON은 특정 프로그래밍 언어나 플랫폼에 종속되지 않는 보편적인 데이터 교환 형식으로 자리 잡았다. 오늘날 대부분의 현대 프로그래밍 언어는 JSON을 생성하고 파싱할 수 있는 네이티브 또는 표준 라이브러리를 제공한다.
JSON의 개발은 2000년대 초반, 더글라스 크록포드와 치프 모리스가 어도비 시스템즈에서 일하던 시절에 시작되었다. 당시 웹 브라우저와 서버 간에 데이터를 교환하는 데 널리 사용되던 XML은 문법이 복잡하고 무거워 파싱 속도가 느리다는 단점이 있었다. 특히 AJAX 기술의 등장으로 비동기 데이터 교환이 활발해지면서, 더 가볍고 빠른 대안에 대한 필요성이 대두되었다.
크록포드는 자바스크립트의 객체 리터럴 표기법에서 영감을 얻어 새로운 데이터 형식을 고안했다. 그는 ECMAScript 표준의 일부였던 이 문법을 분리하여, 언어 독립적인 간단한 데이터 교환 형식으로 재정의했다. 이 형식은 2001년에 처음 공개되었으며, 공식적으로 "JSON"이라는 이름이 붙은 것은 2002년이었다[3].
초기에는 자바스크립트의 eval() 함수를 이용해 간단히 파싱할 수 있어 빠르게 주목을 받았다. 그러나 보안 문제로 인해 전용 파서의 필요성이 제기되었고, 이후 대부분의 언어에서 네이티브 JSON 파싱 라이브러리를 지원하게 되었다. JSON의 설계 철학은 최소주의에 있었으며, 그 단순함과 가독성 덕분에 XML을 빠르게 대체하며 웹 API의 사실상 표준 데이터 형식으로 자리 잡았다.
JSON의 표준화는 ECMAScript 표준의 일부로 진행되었다. 초기에는 자바스크립트 객체 리터럴 문법의 부분집합으로 비공식적으로 사용되었으나, 2013년에 발표된 ECMAScript 5.1판(ECMA-262 5.1판)의 부록에서 공식적으로 규격이 정의되었다[4]. 이로써 JSON은 언어 독립적인 데이터 교환 형식으로서의 지위를 공식적으로 부여받았다.
표준화 과정에서 JSON의 문법은 자바스크립트 객체 리터럴과 몇 가지 중요한 차이점을 명확히 하였다. 가장 큰 차이는 문자열 키와 문자열 값 모두 반드시 큰따옴표(")로 감싸야 한다는 점이다. 또한, 후행 쉼표를 허용하지 않으며, 숫자 앞에 0을 붙이는 것을 금지하는 등 더 엄격한 규칙을 적용하여 파싱의 모호성을 제거하고 상호운용성을 높였다.
이후 JSON은 ECMAScript 2019(ES10)에서 JSON.stringify()가 잘못된 서로게이트 쌍(surrogate pair)을 출력할 수 있는 문제를 수정하는 등 지속적으로 개선되었다. 현재 JSON의 공식 인터넷 미디어 타입은 application/json이며, 파일 확장자는 .json이다. ECMAScript 표준 외에도 IETF에서 발표한 RFC 8259 문서에서도 JSON 텍스트 형식에 대한 인터넷 표준으로 명시되어 있다[5].
연도 | 표준/버전 | 주요 내용 |
|---|---|---|
2011 | ECMAScript 5.1 (ECMA-262 5.1) | 부록에서 JSON 객체( |
2017 | IETF RFC 8259 | JSON 데이터 교환 형식을 인터넷 표준으로 정의함. 이전 RFC 7159를 대체함. |
2019 | ECMAScript 2019 (ES10) |
|

JSON은 경량의 데이터 교환 형식으로, 특히 웹 개발 분야에서 API 통신을 위한 데이터 포맷으로 널리 사용된다. HTTP 요청과 응답의 페이로드로 가장 일반적으로 활용되며, AJAX 기술과 결합하여 서버와 클라이언트 간의 비동기 데이터 교환을 가능하게 한다. 대부분의 현대 웹 API와 RESTful API는 데이터를 주고받을 때 JSON 형식을 표준으로 채택하고 있다.
설정 파일로써의 활용도 두드러진다. Node.js의 package.json, ESLint의 .eslintrc.json과 같이 많은 개발 도구와 프레임워크가 설정 정보를 저장하는 데 JSON을 사용한다. 이는 사람과 기계 모두 읽기 쉬운 구조를 제공하며, 프로그래밍 언어에 내장된 파서를 통해 쉽게 로드하고 처리할 수 있기 때문이다. JSON은 XML에 비해 불필요한 태그가 없어 더 간결하며, YAML에 비해 주석을 지원하지 않지만 구문이 엄격하여 파싱 오류 가능성이 낮다는 장점이 있다.
데이터 저장 및 교환 포맷으로도 광범위하게 사용된다. NoSQL 데이터베이스 중 하나인 MongoDB는 내부 문서 저장 형식으로 BSON(Binary JSON)을 사용한다. 또한 애플리케이션의 상태 저장, 로그 데이터 구조화, 서로 다른 시스템 간의 메시지 전송 등 다양한 데이터 교환 시나리오에서 중간 형식으로 자주 채택된다. 그 간결성과 범용성 덕분에 모바일 앱 개발, 데스크톱 소프트웨어, 심지어 IoT 디바이스 간 통신에서도 표준 데이터 형식으로 자리 잡았다.
활용 분야 | 주요 예시 | 특징 |
|---|---|---|
웹 개발 (API 통신) | RESTful API, GraphQL 응답, AJAX | 서버-클라이언트 간 데이터 교환의 사실상 표준 |
설정 파일 |
| 도구 및 프로젝트 설정 정보 저장 |
데이터 저장 및 교환 | MongoDB (BSON), 애플리케이션 상태, 로그 데이터 | 구조화된 데이터의 지속성 보장과 시스템 간 호환성 제공 |
JSON은 웹 API에서 데이터를 교환하기 위한 사실상의 표준 형식으로 자리 잡았다. 클라이언트-서버 아키텍처에서 서버는 데이터를 JSON 형식으로 직렬화하여 응답하고, 클라이언트(주로 웹 브라우저)는 이를 파싱하여 사용한다. 대부분의 현대 프로그래밍 언어는 JSON을 생성하고 처리하는 네이티브 또는 표준 라이브러리를 제공한다.
RESTful API나 GraphQL과 같은 현대 웹 서비스는 거의 예외 없이 JSON을 데이터 교환 포맷으로 채택한다. HTTP 요청의 본문(POST, PUT 요청 시)이나 응답 본문에 JSON 데이터가 담겨 전송된다. 특히 자바스크립트 기반의 웹 애플리케이션에서는 fetch() API나 AJAX를 통해 JSON 데이터를 쉽게 주고받을 수 있어 상호 운용성이 매우 높다.
주요 활용 패턴은 다음과 같다.
패턴 | 설명 | 예시 |
|---|---|---|
API 응답 | 서버가 요청 결과를 구조화된 데이터로 반환 |
|
API 요청 | 클라이언트가 생성/수정할 데이터를 서버로 전송 |
|
실시간 통신 | WebSocket이나 Server-Sent Events를 통해 스트리밍되는 데이터 포맷 |
|
이러한 광범위한 채택은 JSON이 가진 인간이 읽기 쉬운 텍스트 기반 구조, 언어 중립성, 그리고 자바스크립트와의 자연스러운 호환성 덕분이다. 모바일 앱과 데스크톱 애플리케이션 역시 백엔드 서버와 통신할 때 JSON을 주로 사용하며, 이는 플랫폼 간 데이터 교환을 단순화한다.
JSON은 구조화된 데이터를 표현하기 위한 경량의 텍스트 형식으로, 설정 파일 작성에 널리 사용된다. 인간이 읽기 쉬운 문법과 계층적 구조 덕분에 애플리케이션, 서버, 개발 도구의 설정을 정의하는 데 적합하다.
주요 설정 파일 형식으로는 .json 확장자를 가지며, 일반적으로 config.json, settings.json, package.json(Node.js 프로젝트)과 같은 이름으로 사용된다. 설정은 키-값 쌍으로 구성된 JSON 객체 내에 중첩되어 저장되며, 이를 통해 복잡한 설정 구조를 명확하게 표현할 수 있다. 예를 들어, 웹 서버의 설정은 포트 번호, 데이터베이스 연결 문자열, 로깅 레벨 등을 하나의 객체로 묶어 관리할 수 있다.
다른 설정 형식과 비교했을 때 JSON의 장점과 단점은 다음과 같다.
형식 | 장점 | 단점 |
|---|---|---|
JSON | 기계 파싱이 쉽고, 대부분의 프로그래밍 언어에서 기본 지원, 구조 명확 | 주석을 공식적으로 지원하지 않음[6], 쉼표나 따옴표 등 문법에 엄격 |
가독성이 높고, 주석 지원, 다중 라인 문자열 표현 용이 | 들여쓰기에 민감하여 복잡한 구조에서 오류 가능성, JSON보다 파싱이 느릴 수 있음 | |
매우 강력한 스키마 검증(XSD) 지원, 메타데이터 표현에 유리 | 문법이 장황하고 파일 크기가 커짐, 가독성이 떨어짐 | |
매우 단순하고 가벼움 | 계층적 데이터 표현에 한계가 있음, 데이터 타입 지원이 제한적 |
이러한 특성 때문에 JSON은 특히 자바스크립트 생태계와 웹 개발 환경에서 설정 파일의 사실상 표준으로 자리 잡았다. Node.js의 package.json 파일은 프로젝트 메타데이터, 의존성, 실행 스크립트를 정의하는 핵심 파일이며, 비주얼 스튜디오 코드의 settings.json은 에디터의 모든 구성을 저장한다. 그러나 주석을 공식적으로 허용하지 않아 설정 옵션에 대한 설명을 추가하기 어렵다는 점은 종종 JSONC(JSON with Comments) 같은 확장 형식을 사용하거나, 설정 값 옆에 설명용 키를 추가하는 방식으로 우회하여 해결한다.
JSON은 경량의 텍스트 기반 형식으로, 구조화된 데이터를 저장하고 시스템 간에 교환하는 데 널리 사용됩니다. 이 형식의 간결함과 언어 독립적 특성은 다양한 저장 및 교환 시나리오에 적합하게 만듭니다.
데이터 교환 측면에서, JSON은 특히 웹 API와 마이크로서비스 아키텍처에서 사실상의 표준 데이터 교환 형식입니다. 서버와 클라이언트(예: 웹 브라우저, 모바일 앱) 간에 데이터를 주고받을 때, HTTP 요청과 응답의 본문에 JSON 형식의 데이터를 담아 전송합니다. 이는 SOAP와 같은 복잡한 XML 기반 프로토콜에 비해 훨씬 간단하고 가독성이 높습니다. 또한 NoSQL 데이터베이스 중 하나인 MongoDB는 내부 문서 저장 형식으로 BSON(Binary JSON)을 사용하여 JSON과 유사한 구조로 데이터를 저장하고 쿼리합니다.
데이터 저장용으로는 애플리케이션 설정 파일이나 간단한 데이터 지속성(persistence)을 위해 자주 활용됩니다. 많은 현대 소프트웨어 도구와 프레임워크는 구성 옵션을 config.json이나 package.json(Node.js 및 npm 생태계에서) 같은 파일에 저장합니다. 이러한 파일은 사람이 읽고 수정하기 쉬우며, 기계가 파싱하기에도 용이합니다. 복잡한 관계형 데이터보다는 계층적 구조의 데이터를 저장하는 데 더 적합합니다.
다음은 데이터 저장 및 교환에서 JSON의 주요 사용처를 비교한 표입니다.
사용 분야 | 주요 예시 | 특징 |
|---|---|---|
구성 관리 |
| 설정값을 구조화하여 저장하고, 버전 관리 시스템으로 추적하기 용이함 |
API 통신 | RESTful API의 요청/응답 본문 | XML에 비해 간결하며, JavaScript 환경에서 네이티브로 처리 가능 |
데이터 지속성 | 로컬 스토리지, 간단한 백업 파일 | 관계형 데이터베이스보다 가볍고, 특정 애플리케이션에 맞춘 구조 설계 가능 |
메시지 큐/이벤트 스트림 | Apache Kafka나 RabbitMQ의 메시지 페이로드 | 시스템 간 비동기 통신에서 구조화된 이벤트 데이터를 전달하는 표준 형식으로 사용됨 |
그러나 대규모 데이터셋이나 매우 빈번한 쓰기 연산이 필요한 경우, 전용 데이터베이스 시스템에 비해 성능과 안정성 면에서 제한적일 수 있습니다. 또한 스키마가 명시적으로 정의되지 않아 데이터 무결성을 검증하려면 JSON 스키마와 같은 추가 도구가 필요합니다.

JSON은 데이터 교환 형식으로 널리 사용되지만, XML, YAML, CSV 등 다른 인기 있는 형식과는 구조, 가독성, 용도 면에서 차이점을 보인다.
형식 | 주요 특징 | 장점 | 단점 | 주요 사용 사례 |
|---|---|---|---|---|
태그 기반의 마크업 언어, 스키마(DTD, XSD) 정의 가능 | 구조 검증이 강력함, 네임스페이스와 메타데이터 지원이 풍부함 | 문법이 장황하고 파일 크기가 큼, 파싱이 복잡함 | 엄격한 문서 구조가 필요한 웹 서비스(SOAP), 문서 중심 데이터 | |
들여쓰기 기반의 인간 친화적(human-readable) 형식 | 가독성이 매우 높음, 주석 지원, 복잡한 데이터 구조 표현에 유리함 | 들여쓰기에 민감하여 오류 가능성이 있음, 파싱 속도가 상대적으로 느릴 수 있음 | 설정 파일(예: Docker Compose, Kubernetes), 데이터 직렬화 | |
쉼표로 구분된 단순한 텍스트 형식 | 매우 단순하고 경량임, 스프레드시트 프로그램과 호환성이 좋음 | 계층적 데이터 표현이 불가능함, 데이터 타입 정보가 없음, 특수문자 이스케이프 필요 | 스프레드시트 데이터 내보내기/가져오기, 간단한 테이블 형식 데이터 교환 |
JSON은 XML에 비해 문법이 간결하고 파싱이 용이하여 웹 API에서 사실상의 표준으로 자리 잡았다. 그러나 XML은 문서의 구조와 타입을 엄격하게 정의해야 하는 엔터프라이즈 환경이나 SGML 계열의 복잡한 마크업이 필요한 경우에 여전히 사용된다. YAML은 설정 파일 분야에서 JSON을 대체하는 경우가 많다. YAML은 주석을 지원하고 가독성이 뛰어나지만, 형식의 유연성 때문에 파싱 표준이 JSON보다 덜 엄격할 수 있다는 단점이 있다. CSV는 구조가 단순한 테이블 데이터를 교환할 때 가장 효율적이지만, 중첩된 객체나 배열을 표현할 수 없다는 근본적인 한계가 있다.
JSON은 XML과 함께 구조화된 데이터 교환 형식으로 자주 비교된다. 두 형식 모두 계층적 데이터를 표현할 수 있지만, 설계 철학과 구문에서 뚜렷한 차이를 보인다.
XML은 SGML의 단순화된 하위 집합으로 개발되었으며, 문서 중심의 마크업 언어에서 출발했다. 따라서 태그와 속성을 사용하여 데이터와 메타데이터를 모두 포함하는 복잡한 문서 구조를 표현하는 데 강점을 가진다. DTD나 XML 스키마를 통해 문서 구조를 엄격하게 정의하고 검증할 수 있으며, XPath와 XSLT 같은 강력한 쿼리 및 변환 언어를 지원한다. 반면, JSON은 자바스크립트 객체 표기법에서 유래했기 때문에 프로그래밍 언어, 특히 웹 환경에서 데이터 객체를 직렬화하는 데 최적화되어 있다. 구문이 간결하고 가독성이 높으며, 파싱 속도가 일반적으로 XML보다 빠르다.
다음 표는 두 형식의 주요 차이점을 요약한다.
특성 | JSON | XML |
|---|---|---|
출처 | 자바스크립트 객체 표기법 | SGML(표준 일반화 마크업 언어) |
데이터 타입 | 문자열, 숫자, 불리언, null, 객체, 배열 등 기본 타입 지원 | 모든 데이터가 문자열로 표현되며, 스키마를 통해 타입 정의 가능 |
구문 | 중괄호( | 여는 태그( |
가독성 | 일반적으로 더 간결하고 가독성이 높음 | 태그 반복으로 인해 장황할 수 있음 |
파싱 복잡도 | 파싱이 간단하고 빠름(대부분의 언어에 내장 파서 존재) | 파싱이 상대적으로 복잡하고 무거울 수 있음 |
주요 용도 | 프로그램 간 데이터 교환, API 응답, 설정 파일 | 문서 마크업, 복잡한 엔터프라이즈 데이터 교환, SOAP 프로토콜 |
결론적으로, XML은 구조 검증과 문서 중심의 복잡한 데이터에, JSON은 간결함과 빠른 처리 속도가 요구되는 애플리케이션 간 데이터 교환에 더 적합하다. 현대 웹 API와 마이크로서비스 아키텍처에서는 JSON이 사실상의 표준 형식으로 자리 잡았다.
YAML(YAML Ain't Markup Language)은 JSON과 마찬가지로 사람이 쉽게 읽고 쓸 수 있는 데이터 직렬화 형식이다. 주로 구성 파일, 데이터 교환, 문서화에 사용되며, 들여쓰기를 통해 계층 구조를 표현하는 것이 특징이다.
YAML은 JSON보다 더 풍부한 기능과 표현력을 제공한다. 주석을 지원하며, 여러 줄의 문자열을 표현할 수 있고, 참조와 앵커를 통해 데이터 중복을 제거할 수 있다. 또한, 스칼라 데이터 타입 외에 매핑(객체)과 시퀀스(배열)을 정의할 수 있어 복잡한 구조를 명확하게 기술할 수 있다. 다음은 간단한 YAML 문서의 예시이다.
```yaml
# 주석을 사용할 수 있음
서버_설정:
호스트: "example.com"
포트: 8080
기능_사용: true
지원_프로토콜:
"http"
"https"
환경_변수:
개발: &dev
데이터베이스: "dev_db"
스테이징:
<<: *dev # dev 설정을 상속받음
데이터베이스: "stage_db"
```
특성 | JSON | YAML |
|---|---|---|
주석 지원 | 지원하지 않음 | 지원함 |
문자열 따옴표 | 필수 | 선택적 |
구문 | 중괄호 | 들여쓰기, 하이픈 |
데이터 타입 자동 추론 | 제한적 | 강력함 (예: |
참조/앵커 | 지원하지 않음 | 지원함 |
기본 사용처 | API 통신, 프로그래밍 언어 간 교환 | 설정 파일, 복잡한 데이터 정의 |
그러나 YAML의 유연성은 복잡성과 함께 온다. 들여쓰기에 민감하며, 탭 문자를 사용할 수 없고 공백만 허용한다. 또한, 자동 타입 추론은 때때로 의도치 않은 결과를 초래할 수 있다[7]. 따라서 JSON이 기계 간 통신에 더 간결하고 예측 가능하다면, YAML은 사람이 직접 작성하고 유지보수하는 설정 파일에 더 적합한 경우가 많다.
CSV(Comma-Separated Values)는 표 형식의 데이터를 저장하고 교환하기 위한 오래된 텍스트 파일 형식이다. 각 줄은 하나의 레코드(행)을 나타내며, 레코드 내의 각 필드(열)는 쉼표(,)와 같은 구분 문자로 분리된다. 첫 번째 줄은 종종 헤더 행으로 사용되어 각 열의 이름을 정의한다. CSV는 구조가 단순하고 사람이 직접 읽고 편집하기 쉬우며, 스프레드시트 소프트웨어나 데이터베이스 시스템에서 널리 지원된다.
JSON과 CSV는 모두 구조화된 데이터를 표현하지만, 그 방식과 표현력에서 근본적인 차이를 보인다. JSON은 계층 구조와 중첩된 객체 및 배열을 표현하는 데 적합한 반면, CSV는 기본적으로 2차원의 평면적인 표 데이터를 표현하는 데 특화되어 있다. 이로 인해 CSV는 복잡한 관계나 트리 구조의 데이터를 표현하기 어렵다. 또한 CSV는 데이터 타입을 명시적으로 정의하지 않아 모든 값이 문자열로 해석될 수 있으며, 이는 파싱 시 추가적인 변환 작업이 필요할 수 있음을 의미한다.
다음은 두 형식의 주요 차이점을 비교한 표이다.
특성 | JSON | CSV |
|---|---|---|
구조 | 계층적(중첩 가능) | 평면적(2차원 표) |
데이터 타입 | 문자열, 숫자, 불리언, null, 객체, 배열 명시적 지원 | 암묵적(모든 값이 문자열로 처리됨) |
가독성 | 기계 해석에 최적화, 사람이 읽기에는 다소 복잡 | 사람이 읽고 편집하기 쉬움 |
용량 | 필드 이름 반복 및 구조적 태그로 인해 상대적으로 큼 | 구조 정보가 없어 동일 데이터 기준으로 더 작은 경향 |
표준화 | 엄격한 RFC 8259 표준 존재 | 공식 표준은 없으나 RFC 4180이 관행적 기준으로 사용됨 |
결론적으로, CSV는 로깅, 데이터 내보내기/가져오기, 단순한 표 형식의 데이터 교환에 유용하다. 반면, 웹 API나 구성 파일처럼 복잡하고 중첩된 구조를 필요로 하는 현대적인 애플리케이션에서는 JSON이 더 풍부한 표현력과 명확성을 제공한다.

JSON 문자열을 프로그래밍 언어가 이해할 수 있는 자료 구조로 변환하는 과정을 파싱(Parsing) 또는 역직렬화(Deserialization)라고 한다. 반대로, 메모리 상의 데이터 구조를 JSON 형식의 문자열로 변환하는 과정을 직렬화(Serialization) 또는 문자열화(Stringification)라고 한다. 대부분의 현대 프로그래밍 언어는 이러한 변환을 위한 네이티브 라이브러리나 표준 라이브러리를 제공한다.
웹 브라우저의 자바스크립트에서는 JSON.parse()와 JSON.stringify()라는 두 가지 전역 메서드가 핵심이다. JSON.parse() 메서드는 유효한 JSON 문자열을 인수로 받아 해당하는 자바스크립트 객체나 배열, 값으로 변환한다. 반대로 JSON.stringify() 메서드는 자바스크립트 값이나 객체를 받아 JSON 문자열로 변환한다. 이 메서드들은 선택적으로 리바이버(Reviver) 함수나 리플레이서(Replacer) 함수, 공백(Indent) 인수를 사용하여 변환 과정을 세밀하게 제어할 수 있다[8].
다른 주요 프로그래밍 언어들도 유사한 기능을 표준 라이브러리나 널리 사용되는 서드파티 라이브러리를 통해 지원한다. 아래 표는 몇 가지 언어에서의 대표적인 JSON 처리 방식을 보여준다.
프로그래밍 언어 | 파싱 (JSON 문자열 → 객체) | 직렬화 (객체 → JSON 문자열) | 주요 라이브러리/모듈 |
|---|---|---|---|
|
|
| |
|
| Google Gson, Jackson | |
|
|
| |
|
| JSON 확장 (기본 내장) |
파싱 과정에서 JSON 문자열의 문법이 올바르지 않으면 (예: 따옴표 누락, 콤마 오류) 대부분의 파서는 구문 오류(SyntaxError)를 발생시킨다. 또한, 일부 언어의 파서는 JSON 표준에 정의되지 않은 확장 문법(예: 자바스크립트의 undefined나 주석)을 기본적으로 지원하지 않을 수 있어 호환성에 주의해야 한다.
JSON 문자열을 자바스크립트 객체로 변환하는 과정을 파싱 또는 역직렬화라고 하며, 이는 주로 JSON.parse() 메서드를 통해 수행된다. 이 메서드는 유효한 JSON 문자열을 입력받아 해당하는 자바스크립트 값(객체, 배열, 문자열, 숫자 등)으로 변환한다. 파싱 과정에서 문자열이 JSON 문법을 위반하면 SyntaxError가 발생한다. 또한, 선택적으로 두 번째 매개변수로 리바이버 함수를 전달하여 변환 과정을 사용자 정의할 수 있다. 이 함수는 각 키-값 쌍을 변환하기 전에 호출되어 원본 값을 수정하거나 필터링하는 데 사용된다.
반대로, 자바스크립트 값(객체나 배열 등)을 JSON 문자열로 변환하는 과정을 직렬화라고 하며, JSON.stringify() 메서드가 이 역할을 담당한다. 이 메서드는 자바스크립트 객체를 표준 JSON 형식의 문자열로 변환한다. 변환 과정에서 함수, 심볼, undefined 값은 객체의 속성일 경우 생략되며, 배열의 요소일 경우 null로 변환된다. JSON.stringify() 메서드는 두 번째와 세 번째 매개변수를 통해 변환 방식을 세밀하게 제어할 수 있다. 두 번째 매개변수는 직렬화에 포함시킬 속성을 선택하는 리플레이서 함수나 배열이 될 수 있으며, 세 번째 매개변수는 가독성을 높이기 위한 들여쓰기 공백 수나 문자열을 지정한다.
이 두 메서드는 함께 사용되어 데이터의 안전한 전송과 저장을 가능하게 한다. 예를 들어, 서버와 클라이언트 간 데이터를 교환할 때, 객체는 JSON.stringify()로 문자열화되어 네트워크를 통해 전송된 후, 수신측에서 JSON.parse()를 사용해 다시 객체로 복원된다. 이 과정은 웹 API 통신의 핵심 메커니즘이다. 주요 사용 패턴은 아래 표와 같다.
메서드 | 입력 | 출력 | 주요 용도 |
|---|---|---|---|
| JSON 형식의 문자열 | 자바스크립트 객체/값 | API 응답, 설정 파일 등 외부에서 받은 JSON 데이터를 프로그램에서 사용 가능한 형태로 변환 |
| 자바스크립트 객체/값 | JSON 형식의 문자열 | API 요청 데이터 전송, 로컬 스토리지([9])에 객체 저장, 객체의 깊은 복사 보조 |
이러한 직렬화와 역직렬화 과정에서 순환 참조(객체가 자기 자신을 참조하는 경우)가 존재하면 JSON.stringify()는 오류를 발생시킨다. 또한, Date 객체는 JSON.stringify()에 의해 ISO 8601 형식의 문자열로 변환되며, JSON.parse()는 이를 다시 문자열로만 인식하여 자동으로 Date 객체로 복원하지는 않는다.
대부분의 현대 프로그래밍 언어는 JSON 데이터를 처리하기 위한 네이티브 또는 표준 라이브러리를 제공한다. 일반적으로 JSON 텍스트를 해당 언어의 기본 데이터 구조(객체, 배열, 문자열, 숫자 등)로 변환하는 파싱 기능과, 반대로 언어의 데이터 구조를 JSON 문자열로 변환하는 직렬화 기능을 포함한다.
자바스크립트에서는 JSON 처리가 언어의 일부로 내장되어 있다. JSON.parse() 메서드를 사용하여 JSON 문자열을 자바스크립트 객체로 변환하고, JSON.stringify() 메서드를 사용하여 자바스크립트 값을 JSON 문자열로 변환한다[10]. 파이썬은 표준 라이브러리인 json 모듈을 제공하며, json.loads(), json.dumps() 함수를 통해 파싱과 직렬화를 수행한다. 자바에서는 org.json 라이브러리나 Jackson, Gson과 같은 널리 사용되는 서드파티 라이브러리를 통해 JSON을 처리한다.
다른 언어들의 지원 현황은 아래 표와 같다.
언어 | 주요 라이브러리/모듈 | 기본 파싱 함수 | 기본 직렬화 함수 |
|---|---|---|---|
|
|
| |
|
|
| |
|
|
| |
|
|
| |
|
|
|
이러한 광범위한 언어 지원 덕분에 JSON은 이기종 시스템 간 데이터 교환의 사실상 표준 포맷으로 자리 잡았다. 서로 다른 프로그래밍 언어로 작성된 애플리케이션도 JSON 형식을 통해 손쉽게 데이터를 주고받을 수 있다.

JSON은 구조가 단순하고 파싱이 용이하지만, 잘못된 사용은 보안 취약점을 초래할 수 있다. 주된 위험은 JSON 인젝션과 신뢰할 수 없는 데이터의 무분별한 실행이다.
JSON 인젝션은 공격자가 악의적인 데이터를 JSON 문자열에 삽입하여 애플리케이션의 동작을 변조하는 공격이다. 예를 들어, JSON 데이터를 문자열 결합 방식으로 생성할 때, 사용자 입력값에 따옴표나 제어 문자가 포함되어 있으면 JSON 구조가 깨질 수 있다. 이로 인해 데이터 변조, 정보 유출, 또는 크로스 사이트 스크립팅(XSS)으로 이어질 수 있다[11]. 항상 신뢰할 수 없는 출처의 JSON 데이터를 처리할 때는 적절한 검증과 이스케이프 처리가 필요하다.
신뢰할 수 없는 데이터를 처리할 때는 eval() 함수를 사용하여 JSON을 실행하는 것을 절대 피해야 한다. eval()은 문자열을 자바스크립트 코드로 실행하기 때문에 악성 코드가 포함될 경우 심각한 보안 문제를 일으킨다. 대신, JSON.parse()와 같은 안전한 표준 파서를 사용해야 한다. 또한, 서버에서 받은 JSON 데이터를 사용하기 전에 JSON 스키마 등을 이용해 구조와 데이터 타입을 검증하는 것이 좋다. 네트워크를 통해 전송되는 JSON에는 민감한 정보가 포함되지 않도록 하고, 필요시 HTTPS를 사용하여 전송 중 도청을 방지해야 한다.
JSON 인젝션은 애플리케이션이 신뢰할 수 없는 JSON 데이터를 적절히 검증하거나 이스케이프 처리하지 않고 파싱하거나 처리할 때 발생하는 보안 취약점이다. 공격자는 악의적인 데이터를 JSON 객체에 삽입하여 애플리케이션의 의도된 로직을 우회하거나, 데이터를 변조하거나, 심지어 임의 코드 실행을 유발할 수 있다. 이는 주로 클라이언트 사이드 자바스크립트에서 eval() 함수를 사용해 JSON을 파싱하는 오래된 방식에서 비롯되었지만, 서버 측에서도 데이터 구조를 조작하는 공격 경로로 이어질 수 있다.
일반적인 공격 시나리오는 다음과 같다. 애플리케이션이 사용자 입력을 받아 JSON 문자열을 구성한 후, 안전하지 않은 방법으로 파싱할 때 문제가 발생한다. 예를 들어, 문자열 연결을 통해 JSON을 생성하고 eval() 또는 기능이 비슷한 함수로 평가하면, 입력에 포함된 자바스크립트 코드가 실행될 수 있다. 또한, 서버 측에서 파싱된 JSON 데이터의 속성 값을 신뢰하고 데이터베이스 쿼리나 시스템 명령어 생성에 사용할 경우, SQL 인젝션이나 명령어 인젝션으로 이어질 위험이 있다.
공격 유형 | 설명 | 예방 방법 |
|---|---|---|
클라이언트 측 코드 실행 |
| 반드시 |
서버 측 로직 조작 | 파싱된 객체의 예상치 못한 속성을 악용해 비즈니스 로직 우회 | 데이터 스키마 검증(예: JSON 스키마) 및 허용 목록 기반 필터링 |
프로토타입 오염 |
| 입력 객체의 프로토타입 속성을 비활성화하거나 깊은 복사 사용 |
이를 방지하기 위한 핵심 원칙은 신뢰할 수 없는 모든 JSON 데이터를 검증하고, 안전한 표준 파서(예: JSON.parse())만을 사용하며, 파싱 결과를 사용하기 전에 데이터의 구조와 타입을 엄격히 검사하는 것이다. 또한, JSON 데이터를 다른 시스템(예: 데이터베이스, 쉘)에 전달할 때는 해당 컨텍스트에 맞는 적절한 이스케이프 또는 매개변수화된 인터페이스를 사용해야 한다.
신뢰할 수 없는 소스(예: 사용자 입력, 제3자 API 응답)에서 받은 JSON 데이터를 처리할 때는 주의가 필요하다. 악의적으로 조작된 데이터는 애플리케이션의 파싱 과정에서 예상치 못한 오류를 발생시키거나, 보안 취약점을 통해 시스템에 악영향을 미칠 수 있다.
가장 기본적인 방어 수단은 데이터를 파싱하기 전에 유효성 검증을 수행하는 것이다. JSON 스키마를 사용하여 데이터의 구조, 필드의 타입, 허용되는 값의 범위 등을 엄격하게 정의하고 검증할 수 있다. 또한, 파싱 과정에서 발생할 수 있는 예외(예: 잘못된 형식으로 인한 구문 오류)를 반드시 처리하여 애플리케이션이 비정상적으로 종료되는 것을 방지해야 한다.
신뢰할 수 없는 JSON을 평가(eval)하는 것은 절대 피해야 한다. 초기 자바스크립트에서는 eval() 함수를 사용해 JSON 문자열을 객체로 변환하기도 했으나, 이는 문자열 내에 포함된 임의의 코드를 실행시킬 수 있어 심각한 보안 위협이 된다. 반드시 안전한 표준 파서(예: JSON.parse())만을 사용해야 한다. 서버 측에서는 파싱된 객체를 사용할 때, 객체의 프로퍼티에 접근하거나 순회하는 과정에서도 의도하지 않은 프로토타입 체인 오염 등의 위험이 있을 수 있으므로 주의가 필요하다[12].

JSON의 사용이 보편화되면서 데이터 구조를 정의, 검색, 검증 및 효율적으로 처리하기 위한 여러 도구와 확장 사양이 개발되었다. 이 중 가장 대표적인 것은 JSON 스키마이다. JSON 스키마는 JSON 문서의 구조, 데이터 타입, 허용 범위 등을 정의하는 선언적 언어로, 데이터 유효성 검증, 문서화, 상호작용 코드 생성 등에 활용된다. 이를 통해 API의 요청과 응답 형식을 명확히 규정하거나, 설정 파일이 정해진 형식을 따르는지 확인할 수 있다.
JSON 데이터 내에서 특정 요소에 접근하거나 필터링하기 위한 쿼리 언어도 등장했다. JSONPath는 XPath에서 영감을 받아 JSON 구조를 탐색하고 원하는 값을 추출하기 위한 표현식을 제공한다. 반면, JSONPointer는 RFC 6901로 표준화된 더 간단한 표기법으로, 슬래시(/)로 구분된 경로 문자열을 사용해 JSON 문서 내의 특정 위치를 가리킨다. 이들은 주로 API 테스트나 복잡한 JSON 데이터 처리 시 특정 필드에 접근할 때 유용하다.
개발 과정에서 JSON 문서의 가독성을 높이거나 문법 오류를 방지하기 위한 도구들도 널리 사용된다. JSON 포맷터(또는 프리티 프린터)는 압축된 JSON 문자열을 적절한 들여쓰기와 줄 바꿈으로 정리하여 보기 쉽게 만든다. JSON 검증기는 주어진 문자열이 올바른 JSON 문법을 따르는지, 또는 특정 JSON 스키마를 준수하는지 검사한다. 이러한 도구들은 대부분 온라인 웹 서비스로 제공되거나, 주요 코드 편집기 및 통합 개발 환경(IDE)에 내장되어 있다.
도구/확장 명 | 주요 목적 | 설명 |
|---|---|---|
구조 정의 및 검증 | JSON 데이터의 형식, 타입, 제약 조건을 정의하는 스키마 언어 | |
데이터 쿼리 및 추출 | JSON 구조체 내에서 특정 조건을 만족하는 노드를 찾기 위한 쿼리 언어 | |
특정 위치 참조 | JSON 문서 내의 하나의 특정 값을 가리키기 위한 단순한 문자열 표기법 | |
JSON 포맷터 | 가독성 향상 | 압축된 JSON을 읽기 쉬운 형식으로 자동 정렬해주는 도구 |
JSON 검증기 | 문법 검사 | JSON 문자열의 문법적 오류를 찾아내는 도구 |
JSON 스키마는 JSON 문서의 구조와 내용을 정의하고 검증하기 위한 선언적 형식 언어이다. 이는 XML의 XML 스키마나 DTD와 유사한 역할을 하지만, JSON의 경량 특성을 반영하여 JSON 형식 자체로 작성된다. JSON 스키마는 데이터의 예상 타입, 허용 범위, 필수 속성, 기본값, 종속성 등을 기술하여, 데이터가 특정 계약 또는 규격을 준수하는지 자동으로 검증하는 데 사용된다.
JSON 스키마의 주요 구성 요소는 키워드로, 이를 통해 다양한 제약 조건을 표현한다. 예를 들어, "type" 키워드는 속성이 문자열, 숫자, 객체, 배열 등 어떤 데이터 타입이어야 하는지 지정한다. "properties" 키워드는 객체 내에 포함되어야 하는 속성들을 정의하고, "required" 키워드는 그 중 필수 항목을 명시한다. 또한 "minimum", "maximum", "pattern"(정규식), "items"(배열 요소 정의) 등의 키워드를 통해 세밀한 유효성 검사 규칙을 설정할 수 있다.
키워드 | 설명 | 예시 |
|---|---|---|
| 사용된 JSON 스키마 버전을 지정한다. |
|
| 데이터의 기본 타입을 정의한다. |
|
| 객체의 속성들을 정의한다. |
|
| 객체에서 필수로 포함되어야 하는 속성명의 배열이다. |
|
| 배열의 모든 요소가 따라야 할 스키마를 정의한다. |
|
JSON 스키마는 주로 API 설계 및 문서화, 설정 파일 검증, 데이터 파이프라인에서의 입력 데이터 검사 등에 활용된다. 개발자는 API 요청과 응답의 형식을 JSON 스키마로 정의함으로써, 클라이언트와 서버 간 데이터 교환의 정확성을 보장할 수 있다. 또한, JSON 스키마 문서 자체를 기반으로 자동으로 API 문서를 생성하거나, 사용자 인터페이스 폼을 렌더링하는 도구들도 존재한다[13]. 이는 데이터 모델과 그 검증 로직을 중앙에서 관리하고 일관성을 유지하는 데 큰 장점을 제공한다.
JSONPath와 JSONPointer는 JSON 문서 내에서 특정 데이터를 효율적으로 찾고 참조하기 위해 설계된 경로 표현 언어이다. 둘 다 JSON 데이터를 탐색하는 도구이지만, 목적과 문법, 기능 면에서 차이점을 보인다.
JSONPath는 XPath에서 영감을 받아 JSON 구조를 탐색하기 위한 쿼리 언어이다. 주로 복잡한 JSON 객체에서 특정 조건을 만족하는 하나 이상의 노드를 선택하는 데 사용된다. 점(.) 표기법이나 대괄호([]) 표기법을 사용하며, 와일드카드(*), 재귀적 하강(..), 배열 슬라이스, 필터 표현식 등의 강력한 기능을 제공한다. 예를 들어, $.store.book[*].author와 같은 표현식은 모든 책의 저자 목록을 추출한다. 이는 데이터 추출, 변환, 검증 등 다양한 프로그래밍 시나리오에서 널리 활용된다.
반면, JSONPointer는 RFC 6901로 표준화된, JSON 문서 내의 특정 값을 가리키는 단순한 문자열 식별자이다. 주로 JSON 패치(JSON Patch) 같은 작업에서 수정할 대상을 지정하거나, 하이퍼미디어 API에서 링크의 대상을 참조하는 데 사용된다. 슬래시(/)로 구분된 경로 토큰을 사용하며, 배열 인덱스는 숫자로 직접 지정한다. 예를 들어, /store/book/0/title은 첫 번째 책의 제목을 정확히 가리킨다. JSONPath와 달리 필터링이나 복수 노드 선택 기능은 없고, 단일 노드에 대한 절대 경로를 제공하는 것이 주목적이다.
다음 표는 두 기술의 주요 차이점을 요약한다.
특성 | JSONPath | JSONPointer |
|---|---|---|
주요 목적 | 조건부 쿼리와 다중 노드 선택 | 특정 단일 노드 참조 |
표준 | 커뮤니티 주도 (공식 IETF 표준 아님) | 공식 IETF 표준 (RFC 6901) |
문법 |
|
|
반환 | 0개, 1개 또는 여러 개의 노드 | 정확히 1개의 노드 (또는 오류) |
사용 예시 | 데이터 추출, 복잡한 필터링 | JSON 패치(JSON Patch) 대상 지정, 링크 참조 |
이러한 도구들은 JSON 스키마 (JSON Schema) 검증, API 응답 처리, 설정 파일 관리 등에서 상호 보완적으로 사용되어 JSON 데이터를 효과적으로 다루는 데 기여한다.
JSON 문서의 가독성을 높이고 문법 오류를 검사하기 위한 다양한 도구가 존재합니다. 이들은 주로 개발자와 시스템 관리자가 JSON 데이터를 효율적으로 작성, 검증 및 디버깅하는 데 도움을 줍니다.
JSON 포맷터(또는 프리티 프린터)는 압축된(minified) JSON 문자열을 읽기 쉬운 형태로 재구성합니다. 일반적으로 들여쓰기(인덴트)와 줄 바꿈을 추가하여 계층 구조를 명확히 보여줍니다. 반대로, 공백을 제거하여 데이터 크기를 최소화하는 압축(Minify) 기능도 제공합니다. 대부분의 현대 텍스트 에디터와 통합 개발 환경(IDE)에는 기본적으로 JSON 포맷팅 기능이 내장되어 있습니다. 또한, 온라인 웹 기반 도구나 명령줄 유틸리티(예: jq, python -m json.tool)도 널리 사용됩니다.
JSON 검증기는 주어진 데이터가 JSON 표준 문법을 정확히 준수하는지 확인합니다. 일반적인 검증 항목은 다음과 같습니다.
검증 항목 | 설명 |
|---|---|
구문 오류 | 쉼표 누락, 중괄호/대괄호 불일치, 잘못된 문자열 인용 등 |
데이터 타입 | 값이 올바른 JSON 데이터 타입인지 확인 |
인코딩 | 유효한 유니코드 및 이스케이프 시퀀스 사용 여부 |
많은 검증기는 오류 발생 위치를 정확히 지적해주며, 일부는 JSON 스키마(JSON Schema)를 참조하여 데이터 구조와 내용까지 검증하는 고급 기능을 제공합니다. 이러한 도구들은 API 개발 및 데이터 통합 과정에서 오류를 사전에 방지하는 데 필수적입니다.