iDoc.dev

한국어

English
简体中文
Español
Français
Português
Deutsch
Italiano
日本語
Русский
العربية

한국어

English
简体中文
Español
Français
Português
Deutsch
Italiano
日本語
Русский
العربية

테마

Assert ​

[Stable: 2 - Stable]

Stable: 2 Stability: 2 - Stable

소스 코드: lib/assert.js

node:assert 모듈은 불변식을 검증하기 위한 일련의 assertion 함수를 제공합니다.

엄격한 assertion 모드 ​

[History]

버전변경 사항
v15.0.0require('node:assert/strict')로 노출됨.
v13.9.0, v12.16.2일반적인 "엄격 모드"와의 혼동을 피하기 위해 "엄격 모드"를 "엄격 assertion 모드"로, "레거시 모드"를 "레거시 assertion 모드"로 변경함.
v9.9.0엄격 assertion 모드에 오류 diff 추가.
v9.9.0assert 모듈에 엄격 assertion 모드 추가.
v9.9.0추가됨: v9.9.0

엄격 assertion 모드에서는 비엄격 메서드가 해당하는 엄격 메서드처럼 동작합니다. 예를 들어, assert.deepEqual()는 assert.deepStrictEqual()처럼 동작합니다.

엄격 assertion 모드에서는 객체에 대한 오류 메시지에 diff가 표시됩니다. 레거시 assertion 모드에서는 객체에 대한 오류 메시지에 객체가 표시되며, 종종 잘립니다.

엄격 assertion 모드를 사용하려면 다음과 같이 합니다.

js
import { strict as assert } from 'node:assert'
js
const assert = require('node:assert').strict
js
import assert from 'node:assert/strict'
js
const assert = require('node:assert/strict')

예시 오류 diff:

js
import { strict as assert } from 'node:assert'

assert.deepEqual([[[1, 2, 3]], 4, 5], [[[1, 2, '3']], 4, 5])
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected ... Lines skipped
//
//   [
//     [
// ...
//       2,
// +     3
// -     '3'
//     ],
// ...
//     5
//   ]
js
const assert = require('node:assert/strict')

assert.deepEqual([[[1, 2, 3]], 4, 5], [[[1, 2, '3']], 4, 5])
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected ... Lines skipped
//
//   [
//     [
// ...
//       2,
// +     3
// -     '3'
//     ],
// ...
//     5
//   ]

색상을 비활성화하려면 NO_COLOR 또는 NODE_DISABLE_COLORS 환경 변수를 사용합니다. 이렇게 하면 REPL의 색상도 비활성화됩니다. 터미널 환경에서의 색상 지원에 대한 자세한 내용은 tty getColorDepth() 문서를 참조하십시오.

레거시 어서션 모드 ​

레거시 어서션 모드는 다음에서 == 연산자를 사용합니다.

레거시 어서션 모드를 사용하려면:

js
import assert from 'node:assert'
js
const assert = require('node:assert')

레거시 어서션 모드는 특히 assert.deepEqual()를 사용할 때 예상치 못한 결과를 초래할 수 있습니다.

js
// WARNING: 레거시 어서션 모드에서는 AssertionError를 throw하지 않습니다!
assert.deepEqual(/a/gi, new Date())

클래스: assert.AssertionError ​

어서션 실패를 나타냅니다. node:assert 모듈에서 throw되는 모든 에러는 AssertionError 클래스의 인스턴스입니다.

new assert.AssertionError(options) ​

추가됨: v0.1.21

  • options <Object>
    • message <string> 제공된 경우, 에러 메시지는 이 값으로 설정됩니다.
    • actual <any> 에러 인스턴스의 actual 속성입니다.
    • expected <any> 에러 인스턴스의 expected 속성입니다.
    • operator <string> 에러 인스턴스의 operator 속성입니다.
    • stackStartFn <Function> 제공된 경우, 생성된 스택 추적은 이 함수 이전의 프레임을 생략합니다.

Error의 서브클래스로, 어서션 실패를 나타냅니다.

모든 인스턴스는 내장 Error 속성(message 및 name)과 다음을 포함합니다.

  • actual <any> assert.strictEqual()과 같은 메서드의 actual 인수로 설정됩니다.
  • expected <any> assert.strictEqual()과 같은 메서드의 expected 값으로 설정됩니다.
  • generatedMessage <boolean> 메시지가 자동 생성되었는지(true) 여부를 나타냅니다.
  • code <string> 에러가 어서션 에러임을 나타내는 값은 항상 ERR_ASSERTION입니다.
  • operator <string> 전달된 연산자 값으로 설정됩니다.
js
import assert from 'node:assert'

// 나중에 에러 메시지를 비교하기 위해 AssertionError를 생성합니다.
const { message } = new assert.AssertionError({
  actual: 1,
  expected: 2,
  operator: 'strictEqual',
})

// 에러 출력 확인:
try {
  assert.strictEqual(1, 2)
} catch (err) {
  assert(err instanceof assert.AssertionError)
  assert.strictEqual(err.message, message)
  assert.strictEqual(err.name, 'AssertionError')
  assert.strictEqual(err.actual, 1)
  assert.strictEqual(err.expected, 2)
  assert.strictEqual(err.code, 'ERR_ASSERTION')
  assert.strictEqual(err.operator, 'strictEqual')
  assert.strictEqual(err.generatedMessage, true)
}
js
const assert = require('node:assert')

// 나중에 에러 메시지를 비교하기 위해 AssertionError를 생성합니다.
const { message } = new assert.AssertionError({
  actual: 1,
  expected: 2,
  operator: 'strictEqual',
})

// 에러 출력 확인:
try {
  assert.strictEqual(1, 2)
} catch (err) {
  assert(err instanceof assert.AssertionError)
  assert.strictEqual(err.message, message)
  assert.strictEqual(err.name, 'AssertionError')
  assert.strictEqual(err.actual, 1)
  assert.strictEqual(err.expected, 2)
  assert.strictEqual(err.code, 'ERR_ASSERTION')
  assert.strictEqual(err.operator, 'strictEqual')
  assert.strictEqual(err.generatedMessage, true)
}

클래스: assert.CallTracker ​

[히스토리]

버전변경 사항
v20.1.0assert.CallTracker 클래스는 더 이상 사용되지 않으며 향후 버전에서 제거될 예정입니다.
v14.2.0, v12.19.0추가됨: v14.2.0, v12.19.0

[안정성: 0 - 더 이상 사용되지 않음]

안정성: 0 안정성: 0 - 더 이상 사용되지 않음

이 기능은 더 이상 사용되지 않으며 향후 버전에서 제거될 예정입니다. mock 헬퍼 함수와 같은 대안을 고려하십시오.

new assert.CallTracker() ​

추가됨: v14.2.0, v12.19.0

함수가 특정 횟수만큼 호출되었는지 추적하는 데 사용할 수 있는 새로운 CallTracker 객체를 만듭니다. 검증을 수행하려면 tracker.verify()를 호출해야 합니다. 일반적인 패턴은 process.on('exit') 핸들러에서 호출하는 것입니다.

js
import assert from 'node:assert'
import process from 'node:process'

const tracker = new assert.CallTracker()

function func() {}

// callsfunc()는 tracker.verify() 전에 정확히 1회 호출되어야 합니다.
const callsfunc = tracker.calls(func, 1)

callsfunc()

// tracker.verify()를 호출하고 모든 tracker.calls() 함수가 정확한 횟수만큼 호출되었는지 확인합니다.
process.on('exit', () => {
  tracker.verify()
})
js
const assert = require('node:assert')
const process = require('node:process')

const tracker = new assert.CallTracker()

function func() {}

// callsfunc()는 tracker.verify() 전에 정확히 1회 호출되어야 합니다.
const callsfunc = tracker.calls(func, 1)

callsfunc()

// tracker.verify()를 호출하고 모든 tracker.calls() 함수가 정확한 횟수만큼 호출되었는지 확인합니다.
process.on('exit', () => {
  tracker.verify()
})

tracker.calls([fn][, exact]) ​

추가됨: v14.2.0, v12.19.0

래퍼 함수는 정확히 exact회 호출되어야 합니다. tracker.verify()가 호출될 때 함수가 정확히 exact회 호출되지 않은 경우 tracker.verify()는 오류를 throw합니다.

js
import assert from 'node:assert'

// 호출 추적기를 만듭니다.
const tracker = new assert.CallTracker()

function func() {}

// tracker.verify() 전에 정확한 횟수만큼 호출되어야 하는 func()를 래핑하는 함수를 반환합니다.
const callsfunc = tracker.calls(func)
js
const assert = require('node:assert')

// 호출 추적기를 만듭니다.
const tracker = new assert.CallTracker()

function func() {}

// tracker.verify() 전에 정확한 횟수만큼 호출되어야 하는 func()를 래핑하는 함수를 반환합니다.
const callsfunc = tracker.calls(func)

tracker.getCalls(fn) ​

추가됨: v18.8.0, v16.18.0

js
import assert from 'node:assert'

const tracker = new assert.CallTracker()

function func() {}
const callsfunc = tracker.calls(func)
callsfunc(1, 2, 3)

assert.deepStrictEqual(tracker.getCalls(callsfunc), [{ thisArg: undefined, arguments: [1, 2, 3] }])
js
const assert = require('node:assert')

// 호출 추적기를 생성합니다.
const tracker = new assert.CallTracker()

function func() {}
const callsfunc = tracker.calls(func)
callsfunc(1, 2, 3)

assert.deepStrictEqual(tracker.getCalls(callsfunc), [{ thisArg: undefined, arguments: [1, 2, 3] }])

tracker.report() ​

추가됨: v14.2.0, v12.19.0

예상된 횟수만큼 호출되지 않은 함수의 예상 및 실제 호출 횟수에 대한 정보를 포함하는 배열입니다.

js
import assert from 'node:assert'

// 호출 추적기를 생성합니다.
const tracker = new assert.CallTracker()

function func() {}

// tracker.verify() 전에 정확히 여러 번 호출되어야 하는 func()를 래핑하는 함수를 반환합니다.
const callsfunc = tracker.calls(func, 2)

// callsfunc()에 대한 정보가 포함된 배열을 반환합니다.
console.log(tracker.report())
// [
//  {
//    message: 'Expected the func function to be executed 2 time(s) but was
//    executed 0 time(s).',
//    actual: 0,
//    expected: 2,
//    operator: 'func',
//    stack: stack trace
//  }
// ]
js
const assert = require('node:assert')

// 호출 추적기를 생성합니다.
const tracker = new assert.CallTracker()

function func() {}

// tracker.verify() 전에 정확히 여러 번 호출되어야 하는 func()를 래핑하는 함수를 반환합니다.
const callsfunc = tracker.calls(func, 2)

// callsfunc()에 대한 정보가 포함된 배열을 반환합니다.
console.log(tracker.report())
// [
//  {
//    message: 'Expected the func function to be executed 2 time(s) but was
//    executed 0 time(s).',
//    actual: 0,
//    expected: 2,
//    operator: 'func',
//    stack: stack trace
//  }
// ]

tracker.reset([fn]) ​

추가됨: v18.8.0, v16.18.0

콜 추적기의 호출을 재설정합니다. 추적할 함수가 인수로 전달되면 해당 함수에 대한 호출이 재설정됩니다. 인수가 전달되지 않으면 모든 추적된 함수가 재설정됩니다.

js
import assert from 'node:assert'

const tracker = new assert.CallTracker()

function func() {}
const callsfunc = tracker.calls(func)

callsfunc()
// 추적기가 한 번 호출되었습니다.
assert.strictEqual(tracker.getCalls(callsfunc).length, 1)

tracker.reset(callsfunc)
assert.strictEqual(tracker.getCalls(callsfunc).length, 0)
js
const assert = require('node:assert')

const tracker = new assert.CallTracker()

function func() {}
const callsfunc = tracker.calls(func)

callsfunc()
// 추적기가 한 번 호출되었습니다.
assert.strictEqual(tracker.getCalls(callsfunc).length, 1)

tracker.reset(callsfunc)
assert.strictEqual(tracker.getCalls(callsfunc).length, 0)

tracker.verify() ​

추가됨: v14.2.0, v12.19.0

tracker.calls()에 전달된 함수 목록을 반복하고 예상 횟수만큼 호출되지 않은 함수에 대해 오류를 throw합니다.

js
import assert from 'node:assert'

// 콜 추적기를 만듭니다.
const tracker = new assert.CallTracker()

function func() {}

// tracker.verify() 전에 정확히 여러 번 호출해야 하는 func()를 래핑하는 함수를 반환합니다.
const callsfunc = tracker.calls(func, 2)

callsfunc()

// callsfunc()가 한 번만 호출되었으므로 오류가 발생합니다.
tracker.verify()
js
const assert = require('node:assert')

// 콜 추적기를 만듭니다.
const tracker = new assert.CallTracker()

function func() {}

// tracker.verify() 전에 정확히 여러 번 호출해야 하는 func()를 래핑하는 함수를 반환합니다.
const callsfunc = tracker.calls(func, 2)

callsfunc()

// callsfunc()가 한 번만 호출되었으므로 오류가 발생합니다.
tracker.verify()

assert(value[, message]) ​

추가됨: v0.5.9

assert.ok()의 별칭입니다.

assert.deepEqual(actual, expected[, message]) ​

[이력]

버전변경 사항
v22.2.0, v20.15.0오류 원인 및 오류 속성도 비교됩니다.
v18.0.0정규 표현식의 lastIndex 속성도 비교됩니다.
v16.0.0, v14.18.0레거시 어서션 모드에서, 상태가 Deprecated에서 Legacy로 변경되었습니다.
v14.0.0양쪽 모두 NaN인 경우 NaN은 동일하게 처리됩니다.
v12.0.0이제 형식 태그가 제대로 비교되며, 확인을 덜 놀랍게 만들기 위한 몇 가지 사소한 비교 조정이 있습니다.
v9.0.0Error 이름과 메시지가 이제 제대로 비교됩니다.
v8.0.0Set 및 Map 콘텐츠도 비교됩니다.
v6.4.0, v4.7.1이제 형식화된 배열 슬라이스가 올바르게 처리됩니다.
v6.1.0, v4.5.0이제 순환 참조가 있는 개체를 입력으로 사용할 수 있습니다.
v5.10.1, v4.4.3비 Uint8Array 형식화된 배열을 올바르게 처리합니다.
v0.1.21추가됨: v0.1.21

엄격한 어서션 모드

assert.deepStrictEqual()의 별칭입니다.

레거시 어서션 모드

[안정적: 3 - 레거시]

안정적: 3 안정성: 3 - 레거시: 대신 assert.deepStrictEqual()을 사용하십시오.

actual 및 expected 매개변수 간의 심층적 동등성을 테스트합니다. 대신 assert.deepStrictEqual()을 사용하는 것을 고려하십시오. assert.deepEqual()은 예상치 못한 결과를 가져올 수 있습니다.

심층적 동등성이란 자식 개체의 열거 가능한 "자체" 속성도 다음 규칙에 따라 재귀적으로 평가됨을 의미합니다.

비교 상세 정보 ​

  • 원시 값은 == 연산자를 사용하여 비교되며, NaN은 예외입니다. 양쪽 모두 NaN인 경우 동일한 것으로 처리됩니다.
  • 객체의 유형 태그는 같아야 합니다.
  • 열거 가능한 "자체" 속성만 고려됩니다.
  • Error 이름, 메시지, 원인 및 오류는 열거 가능한 속성이 아니더라도 항상 비교됩니다.
  • 객체 래퍼는 객체와 래핑되지 않은 값 모두로 비교됩니다.
  • Object 속성은 순서에 관계없이 비교됩니다.
  • Map 키와 Set 항목은 순서에 관계없이 비교됩니다.
  • 양쪽이 다르거나 양쪽 모두 순환 참조를 만나면 재귀가 중지됩니다.
  • 구현은 객체의 [[Prototype]]를 테스트하지 않습니다.
  • Symbol 속성은 비교되지 않습니다.
  • WeakMap 및 WeakSet 비교는 값이 아닌 인스턴스에만 의존합니다.
  • RegExp lastIndex, flags 및 source는 열거 가능한 속성이 아니더라도 항상 비교됩니다.

다음 예제는 원시 값이 == 연산자를 사용하여 비교되므로 AssertionError를 throw하지 않습니다.

js
import assert from 'node:assert'
// WARNING: This does not throw an AssertionError!

assert.deepEqual('+00000000', false)
js
const assert = require('node:assert')
// WARNING: This does not throw an AssertionError!

assert.deepEqual('+00000000', false)

"심층" 동등성은 자식 객체의 열거 가능한 "자체" 속성도 평가됨을 의미합니다.

js
import assert from 'node:assert'

const obj1 = {
  a: {
    b: 1,
  },
}
const obj2 = {
  a: {
    b: 2,
  },
}
const obj3 = {
  a: {
    b: 1,
  },
}
const obj4 = { __proto__: obj1 }

assert.deepEqual(obj1, obj1)
// OK

// Values of b are different:
assert.deepEqual(obj1, obj2)
// AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }

assert.deepEqual(obj1, obj3)
// OK

// Prototypes are ignored:
assert.deepEqual(obj1, obj4)
// AssertionError: { a: { b: 1 } } deepEqual {}
js
const assert = require('node:assert')

const obj1 = {
  a: {
    b: 1,
  },
}
const obj2 = {
  a: {
    b: 2,
  },
}
const obj3 = {
  a: {
    b: 1,
  },
}
const obj4 = { __proto__: obj1 }

assert.deepEqual(obj1, obj1)
// OK

// Values of b are different:
assert.deepEqual(obj1, obj2)
// AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }

assert.deepEqual(obj1, obj3)
// OK

// Prototypes are ignored:
assert.deepEqual(obj1, obj4)
// AssertionError: { a: { b: 1 } } deepEqual {}

값이 같지 않으면 message 속성이 message 매개변수의 값으로 설정된 AssertionError](/ko/api/assert#class-assertassertionerror)가 throw됩니다. message 매개변수가 정의되지 않은 경우 기본 오류 메시지가 할당됩니다. message 매개변수가 Error의 인스턴스인 경우 AssertionError 대신 throw됩니다.

assert.deepStrictEqual(actual, expected[, message]) ​

[히스토리]

버전변경 사항
v22.2.0, v20.15.0이제 오류 원인과 오류 속성도 비교합니다.
v18.0.0이제 정규 표현식 lastIndex 속성도 비교합니다.
v9.0.0이제 열거 가능한 심볼 속성을 비교합니다.
v9.0.0이제 NaN을 SameValueZero 비교를 사용하여 비교합니다.
v8.5.0이제 Error 이름과 메시지를 제대로 비교합니다.
v8.0.0Set 및 Map 콘텐츠도 비교합니다.
v6.1.0이제 순환 참조가 있는 객체를 입력으로 사용할 수 있습니다.
v6.4.0, v4.7.1이제 형식화된 배열 슬라이스를 올바르게 처리합니다.
v5.10.1, v4.4.3비Uint8Array 형식화된 배열을 올바르게 처리합니다.
v1.2.0추가됨: v1.2.0

actual 및 expected 매개변수 간의 심층적 동등성을 테스트합니다. "심층적" 동등성이란 자식 객체의 열거 가능한 "고유" 속성도 다음 규칙에 따라 재귀적으로 평가됨을 의미합니다.

비교 세부 정보 ​

  • 원시 값은 Object.is()를 사용하여 비교됩니다.
  • 객체의 유형 태그는 같아야 합니다.
  • 객체의 [[Prototype]]는 === 연산자를 사용하여 비교됩니다.
  • 열거 가능한 "고유" 속성만 고려됩니다.
  • Error 이름, 메시지, 원인 및 오류는 열거 가능한 속성이 아니더라도 항상 비교됩니다. errors도 비교됩니다.
  • 열거 가능한 고유 Symbol 속성도 비교됩니다.
  • 객체 래퍼는 객체와 래핑 해제된 값으로 모두 비교됩니다.
  • Object 속성은 순서에 관계없이 비교됩니다.
  • Map 키와 Set 항목은 순서에 관계없이 비교됩니다.
  • 양쪽이 다르거나 양쪽 모두 순환 참조를 만나면 재귀가 중지됩니다.
  • WeakMap 및 WeakSet 비교는 해당 값에 의존하지 않습니다. 자세한 내용은 아래를 참조하십시오.
  • RegExp lastIndex, 플래그 및 소스는 열거 가능한 속성이 아니더라도 항상 비교됩니다.
js
import assert from 'node:assert/strict'

// 1 !== '1'이므로 실패합니다.
assert.deepStrictEqual({ a: 1 }, { a: '1' })
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
//   {
// +   a: 1
// -   a: '1'
//   }

// 다음 객체에는 고유 속성이 없습니다.
const date = new Date()
const object = {}
const fakeDate = {}
Object.setPrototypeOf(fakeDate, Date.prototype)

// 다른 [[Prototype]]:
assert.deepStrictEqual(object, fakeDate)
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + {}
// - Date {}

// 다른 유형 태그:
assert.deepStrictEqual(date, fakeDate)
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + 2018-04-26T00:49:08.604Z
// - Date {}

assert.deepStrictEqual(NaN, NaN)
// Object.is(NaN, NaN)이 true이므로 정상입니다.

// 다른 래핑 해제된 숫자:
assert.deepStrictEqual(new Number(1), new Number(2))
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + [Number: 1]
// - [Number: 2]

assert.deepStrictEqual(new String('foo'), Object('foo'))
// 객체와 문자열이 래핑 해제될 때 동일하므로 정상입니다.

assert.deepStrictEqual(-0, -0)
// 정상입니다.

// 다른 0:
assert.deepStrictEqual(0, -0)
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + 0
// - -0

const symbol1 = Symbol()
const symbol2 = Symbol()
assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol1]: 1 })
// 두 객체에서 동일한 심볼이므로 정상입니다.

assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol2]: 1 })
// AssertionError [ERR_ASSERTION]: Inputs identical but not reference equal:
//
// {
//   [Symbol()]: 1
// }

const weakMap1 = new WeakMap()
const weakMap2 = new WeakMap([[{}, {}]])
const weakMap3 = new WeakMap()
weakMap3.unequal = true

assert.deepStrictEqual(weakMap1, weakMap2)
// 항목을 비교할 수 없으므로 정상입니다.

// weakMap3에는 weakMap1에 없는 속성이 있으므로 실패합니다.
assert.deepStrictEqual(weakMap1, weakMap3)
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
//   WeakMap {
// +   [items unknown]
// -   [items unknown],
// -   unequal: true
//   }
js
const assert = require('node:assert/strict')

// 1 !== '1'이므로 실패합니다.
assert.deepStrictEqual({ a: 1 }, { a: '1' })
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
//   {
// +   a: 1
// -   a: '1'
//   }

// 다음 객체에는 고유 속성이 없습니다.
const date = new Date()
const object = {}
const fakeDate = {}
Object.setPrototypeOf(fakeDate, Date.prototype)

// 다른 [[Prototype]]:
assert.deepStrictEqual(object, fakeDate)
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + {}
// - Date {}

// 다른 유형 태그:
assert.deepStrictEqual(date, fakeDate)
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + 2018-04-26T00:49:08.604Z
// - Date {}

assert.deepStrictEqual(NaN, NaN)
// Object.is(NaN, NaN)이 true이므로 정상입니다.

// 다른 래핑 해제된 숫자:
assert.deepStrictEqual(new Number(1), new Number(2))
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + [Number: 1]
// - [Number: 2]

assert.deepStrictEqual(new String('foo'), Object('foo'))
// 객체와 문자열이 래핑 해제될 때 동일하므로 정상입니다.

assert.deepStrictEqual(-0, -0)
// 정상입니다.

// 다른 0:
assert.deepStrictEqual(0, -0)
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + 0
// - -0

const symbol1 = Symbol()
const symbol2 = Symbol()
assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol1]: 1 })
// 두 객체에서 동일한 심볼이므로 정상입니다.

assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol2]: 1 })
// AssertionError [ERR_ASSERTION]: Inputs identical but not reference equal:
//
// {
//   [Symbol()]: 1
// }

const weakMap1 = new WeakMap()
const weakMap2 = new WeakMap([[{}, {}]])
const weakMap3 = new WeakMap()
weakMap3.unequal = true

assert.deepStrictEqual(weakMap1, weakMap2)
// 항목을 비교할 수 없으므로 정상입니다.

// weakMap3에는 weakMap1에 없는 속성이 있으므로 실패합니다.
assert.deepStrictEqual(weakMap1, weakMap3)
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
//   WeakMap {
// +   [items unknown]
// -   [items unknown],
// -   unequal: true
//   }

값이 같지 않으면 message 속성이 message 매개변수의 값과 같도록 설정된 AssertionError가 throw됩니다. message 매개변수가 정의되지 않은 경우 기본 오류 메시지가 할당됩니다. message 매개변수가 Error의 인스턴스인 경우 AssertionError 대신 throw됩니다.

assert.doesNotMatch(string, regexp[, message]) ​

[히스토리]

버전변경 사항
v16.0.0이 API는 더 이상 실험적이지 않습니다.
v13.6.0, v12.16.0추가됨: v13.6.0, v12.16.0

string 입력이 정규 표현식과 일치하지 않을 것으로 예상합니다.

js
import assert from 'node:assert/strict'

assert.doesNotMatch('I will fail', /fail/)
// AssertionError [ERR_ASSERTION]: The input was expected to not match the ...

assert.doesNotMatch(123, /pass/)
// AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.

assert.doesNotMatch('I will pass', /different/)
// OK
js
const assert = require('node:assert/strict')

assert.doesNotMatch('I will fail', /fail/)
// AssertionError [ERR_ASSERTION]: The input was expected to not match the ...

assert.doesNotMatch(123, /pass/)
// AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.

assert.doesNotMatch('I will pass', /different/)
// OK

값이 일치하거나 string 인수의 유형이 string이 아닌 경우 message 속성이 message 매개변수의 값으로 설정된 AssertionError가 throw됩니다. message 매개변수가 정의되지 않은 경우 기본 오류 메시지가 할당됩니다. message 매개변수가 Error의 인스턴스인 경우 AssertionError 대신 throw됩니다.

assert.doesNotReject(asyncFn[, error][, message]) ​

추가됨: v10.0.0

asyncFn promise를 기다리거나, asyncFn이 함수인 경우 함수를 즉시 호출하고 반환된 promise가 완료될 때까지 기다립니다. 그런 다음 promise가 거부되지 않았는지 확인합니다.

asyncFn이 함수이고 동기적으로 오류를 throw하는 경우 assert.doesNotReject()는 해당 오류가 포함된 거부된 Promise를 반환합니다. 함수가 promise를 반환하지 않으면 assert.doesNotReject()는 ERR_INVALID_RETURN_VALUE 오류가 포함된 거부된 Promise를 반환합니다. 두 경우 모두 오류 처리기는 건너뜁니다.

assert.doesNotReject()를 사용하는 것은 거부를 catch한 다음 다시 거부하는 데 거의 이점이 없기 때문에 실제로 유용하지 않습니다. 대신 거부해서는 안 되는 특정 코드 경로 옆에 주석을 추가하고 오류 메시지를 가능한 한 표현력 있게 유지하는 것을 고려하십시오.

error가 지정된 경우 Class, RegExp 또는 유효성 검사 함수가 될 수 있습니다. 자세한 내용은 assert.throws()를 참조하십시오.

완료를 기다리는 비동기 특성 외에는 assert.doesNotThrow()와 동일하게 동작합니다.

js
import assert from 'node:assert/strict'

await assert.doesNotReject(async () => {
  throw new TypeError('Wrong value')
}, SyntaxError)
js
const assert = require('node:assert/strict')

;(async () => {
  await assert.doesNotReject(async () => {
    throw new TypeError('Wrong value')
  }, SyntaxError)
})()
js
import assert from 'node:assert/strict'

assert.doesNotReject(Promise.reject(new TypeError('Wrong value'))).then(() => {
  // ...
})
js
const assert = require('node:assert/strict')

assert.doesNotReject(Promise.reject(new TypeError('Wrong value'))).then(() => {
  // ...
})

assert.doesNotThrow(fn[, error][, message]) ​

[히스토리]

버전변경 사항
v5.11.0, v4.4.5message 매개변수가 이제 적용됩니다.
v4.2.0error 매개변수가 이제 화살표 함수가 될 수 있습니다.
v0.1.21추가됨: v0.1.21

함수 fn이 오류를 발생시키지 않음을 단언합니다.

assert.doesNotThrow()를 사용하는 것은 실제로 유용하지 않습니다. 오류를 잡은 후 다시 throw하는 데 이점이 없기 때문입니다. 대신 오류를 throw하지 않아야 하는 특정 코드 경로 옆에 주석을 추가하고 오류 메시지를 최대한 표현력 있게 유지하는 것을 고려하십시오.

assert.doesNotThrow()가 호출되면 fn 함수를 즉시 호출합니다.

오류가 throw되고 error 매개변수에 지정된 것과 동일한 유형이면 AssertionError가 throw됩니다. 오류 유형이 다르거나 error 매개변수가 정의되지 않은 경우 오류는 호출자에게 다시 전파됩니다.

지정된 경우 error는 Class, RegExp 또는 유효성 검사 함수가 될 수 있습니다. 자세한 내용은 assert.throws()를 참조하십시오.

예를 들어, 다음은 일치하는 오류 유형이 단언에 없기 때문에 TypeError를 throw합니다.

js
import assert from 'node:assert/strict'

assert.doesNotThrow(() => {
  throw new TypeError('Wrong value')
}, SyntaxError)
js
const assert = require('node:assert/strict')

assert.doesNotThrow(() => {
  throw new TypeError('Wrong value')
}, SyntaxError)

그러나 다음은 'Got unwanted exception...' 메시지와 함께 AssertionError를 발생시킵니다.

js
import assert from 'node:assert/strict'

assert.doesNotThrow(() => {
  throw new TypeError('Wrong value')
}, TypeError)
js
const assert = require('node:assert/strict')

assert.doesNotThrow(() => {
  throw new TypeError('Wrong value')
}, TypeError)

AssertionError가 throw되고 message 매개변수에 값이 제공되면 message의 값이 AssertionError 메시지에 추가됩니다.

js
import assert from 'node:assert/strict'

assert.doesNotThrow(
  () => {
    throw new TypeError('Wrong value')
  },
  /Wrong value/,
  'Whoops'
)
// Throws: AssertionError: Got unwanted exception: Whoops
js
const assert = require('node:assert/strict')

assert.doesNotThrow(
  () => {
    throw new TypeError('Wrong value')
  },
  /Wrong value/,
  'Whoops'
)
// Throws: AssertionError: Got unwanted exception: Whoops

assert.equal(actual, expected[, message]) ​

[히스토리]

버전변경 사항
v16.0.0, v14.18.0레거시 어서션 모드에서 상태가 Deprecated에서 Legacy로 변경되었습니다.
v14.0.0양쪽 모두 NaN인 경우 NaN이 동일하게 취급됩니다.
v0.1.21추가됨: v0.1.21

엄격한 어서션 모드

assert.strictEqual()의 별칭입니다.

레거시 어서션 모드

[안정성: 3 - 레거시]

안정성: 3 안정성: 3 - 레거시: 대신 assert.strictEqual()을 사용하십시오.

== 연산자를 사용하여 actual 및 expected 매개변수 간의 얕은 강제적 동등성을 테스트합니다. NaN은 특별히 처리되며 양쪽 모두 NaN인 경우 동일하게 취급됩니다.

js
import assert from 'node:assert'

assert.equal(1, 1)
// OK, 1 == 1
assert.equal(1, '1')
// OK, 1 == '1'
assert.equal(NaN, NaN)
// OK

assert.equal(1, 2)
// AssertionError: 1 == 2
assert.equal({ a: { b: 1 } }, { a: { b: 1 } })
// AssertionError: { a: { b: 1 } } == { a: { b: 1 } }
js
const assert = require('node:assert')

assert.equal(1, 1)
// OK, 1 == 1
assert.equal(1, '1')
// OK, 1 == '1'
assert.equal(NaN, NaN)
// OK

assert.equal(1, 2)
// AssertionError: 1 == 2
assert.equal({ a: { b: 1 } }, { a: { b: 1 } })
// AssertionError: { a: { b: 1 } } == { a: { b: 1 } }

값이 같지 않으면 message 속성이 message 매개변수의 값과 같은 AssertionError가 throw됩니다. message 매개변수가 정의되지 않으면 기본 오류 메시지가 할당됩니다. message 매개변수가 Error의 인스턴스인 경우 AssertionError 대신 throw됩니다.

assert.fail([message]) ​

추가됨: v0.1.21

제공된 오류 메시지 또는 기본 오류 메시지와 함께 AssertionError를 throw합니다. message 매개변수가 Error의 인스턴스인 경우 AssertionError 대신 throw됩니다.

js
import assert from 'node:assert/strict'

assert.fail()
// AssertionError [ERR_ASSERTION]: Failed

assert.fail('boom')
// AssertionError [ERR_ASSERTION]: boom

assert.fail(new TypeError('need array'))
// TypeError: need array
js
const assert = require('node:assert/strict')

assert.fail()
// AssertionError [ERR_ASSERTION]: Failed

assert.fail('boom')
// AssertionError [ERR_ASSERTION]: boom

assert.fail(new TypeError('need array'))
// TypeError: need array

두 개 이상의 인수를 사용하여 assert.fail()을 사용할 수 있지만, 권장되지 않습니다. 자세한 내용은 아래를 참조하십시오.

assert.fail(actual, expected[, message[, operator[, stackStartFn]]]) ​

[이력]

버전변경 사항
v10.0.0하나 이상의 인수를 사용하여 assert.fail()을 호출하는 것은 권장되지 않으며 경고를 발생시킵니다.
v0.1.21추가됨: v0.1.21

[안정성: 0 - 더 이상 사용되지 않음]

안정성: 0 안정성: 0 - 더 이상 사용되지 않음: assert.fail([message]) 또는 다른 assert 함수를 대신 사용하십시오.

message가 거짓인 경우 오류 메시지는 제공된 operator로 구분된 actual 및 expected의 값으로 설정됩니다. actual 및 expected 두 인수만 제공되는 경우 operator는 '!='로 기본 설정됩니다. 세 번째 인수로 message가 제공되면 오류 메시지로 사용되고 다른 인수는 throw된 객체의 속성으로 저장됩니다. stackStartFn이 제공되면 해당 함수 위의 모든 스택 프레임이 스택 추적에서 제거됩니다(Error.captureStackTrace 참조). 인수가 제공되지 않으면 기본 메시지 Failed가 사용됩니다.

js
import assert from 'node:assert/strict'

assert.fail('a', 'b')
// AssertionError [ERR_ASSERTION]: 'a' != 'b'

assert.fail(1, 2, undefined, '>')
// AssertionError [ERR_ASSERTION]: 1 > 2

assert.fail(1, 2, 'fail')
// AssertionError [ERR_ASSERTION]: fail

assert.fail(1, 2, 'whoops', '>')
// AssertionError [ERR_ASSERTION]: whoops

assert.fail(1, 2, new TypeError('need array'))
// TypeError: need array
js
const assert = require('node:assert/strict')

assert.fail('a', 'b')
// AssertionError [ERR_ASSERTION]: 'a' != 'b'

assert.fail(1, 2, undefined, '>')
// AssertionError [ERR_ASSERTION]: 1 > 2

assert.fail(1, 2, 'fail')
// AssertionError [ERR_ASSERTION]: fail

assert.fail(1, 2, 'whoops', '>')
// AssertionError [ERR_ASSERTION]: whoops

assert.fail(1, 2, new TypeError('need array'))
// TypeError: need array

마지막 세 가지 경우 actual, expected 및 operator는 오류 메시지에 영향을 미치지 않습니다.

stackStartFn의 예시 사용은 예외의 스택 추적을 잘라냅니다.

js
import assert from 'node:assert/strict'

function suppressFrame() {
  assert.fail('a', 'b', undefined, '!==', suppressFrame)
}
suppressFrame()
// AssertionError [ERR_ASSERTION]: 'a' !== 'b'
//     at repl:1:1
//     at ContextifyScript.Script.runInThisContext (vm.js:44:33)
//     ...
js
const assert = require('node:assert/strict')

function suppressFrame() {
  assert.fail('a', 'b', undefined, '!==', suppressFrame)
}
suppressFrame()
// AssertionError [ERR_ASSERTION]: 'a' !== 'b'
//     at repl:1:1
//     at ContextifyScript.Script.runInThisContext (vm.js:44:33)
//     ...

assert.ifError(value) ​

[History]

버전변경 사항
v10.0.0원래 오류를 throw하는 대신 이제 전체 스택 추적을 포함하는 [AssertionError][]로 래핑됩니다.
v10.0.0이제 값은 undefined 또는 null만 가능합니다. 이전에는 모든 거짓 값이 null과 동일하게 처리되어 throw되지 않았습니다.
v0.1.97추가됨: v0.1.97

value가 undefined 또는 null이 아니면 value를 throw합니다. 이것은 콜백에서 error 인수를 테스트할 때 유용합니다. 스택 추적에는 ifError()에 전달된 오류의 모든 프레임과 ifError() 자체에 대한 잠재적인 새 프레임이 포함됩니다.

js
import assert from 'node:assert/strict'

assert.ifError(null)
// OK
assert.ifError(0)
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 0
assert.ifError('error')
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 'error'
assert.ifError(new Error())
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: Error

// Create some random error frames.
let err
;(function errorFrame() {
  err = new Error('test error')
})()

;(function ifErrorFrame() {
  assert.ifError(err)
})()
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: test error
//     at ifErrorFrame
//     at errorFrame
js
const assert = require('node:assert/strict')

assert.ifError(null)
// OK
assert.ifError(0)
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 0
assert.ifError('error')
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 'error'
assert.ifError(new Error())
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: Error

// Create some random error frames.
let err
;(function errorFrame() {
  err = new Error('test error')
})()

;(function ifErrorFrame() {
  assert.ifError(err)
})()
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: test error
//     at ifErrorFrame
//     at errorFrame

assert.match(string, regexp[, message]) ​

[히스토리]

버전변경 사항
v16.0.0이 API는 더 이상 실험적이지 않습니다.
v13.6.0, v12.16.0추가됨: v13.6.0, v12.16.0

string 입력이 정규 표현식과 일치해야 합니다.

js
import assert from 'node:assert/strict'

assert.match('I will fail', /pass/)
// AssertionError [ERR_ASSERTION]: The input did not match the regular ...

assert.match(123, /pass/)
// AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.

assert.match('I will pass', /pass/)
// OK
js
const assert = require('node:assert/strict')

assert.match('I will fail', /pass/)
// AssertionError [ERR_ASSERTION]: The input did not match the regular ...

assert.match(123, /pass/)
// AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.

assert.match('I will pass', /pass/)
// OK

값이 일치하지 않거나 string 인수가 string 이외의 유형인 경우, message 매개변수의 값과 동일하게 설정된 message 속성을 가진 AssertionError가 throw됩니다. message 매개변수가 정의되지 않은 경우 기본 오류 메시지가 할당됩니다. message 매개변수가 Error의 인스턴스인 경우 AssertionError 대신 throw됩니다.

assert.notDeepEqual(actual, expected[, message]) ​

[히스토리]

버전변경 사항
v16.0.0, v14.18.0레거시 어서션 모드에서 사용 중단 상태가 레거시로 변경되었습니다.
v14.0.0양쪽이 모두 NaN인 경우 NaN이 동일하게 취급됩니다.
v9.0.0Error 이름과 메시지는 이제 제대로 비교됩니다.
v8.0.0Set 및 Map 콘텐츠도 비교됩니다.
v6.4.0, v4.7.1이제 형식화된 배열 슬라이스가 올바르게 처리됩니다.
v6.1.0, v4.5.0이제 순환 참조가 있는 객체를 입력으로 사용할 수 있습니다.
v5.10.1, v4.4.3비Uint8Array 형식화된 배열을 올바르게 처리합니다.
v0.1.21추가됨: v0.1.21

엄격한 어서션 모드

assert.notDeepStrictEqual()의 별칭입니다.

레거시 어서션 모드

[Stable: 3 - 레거시]

Stable: 3 Stability: 3 - 레거시: 대신 assert.notDeepStrictEqual()을 사용하십시오.

심층 불일치를 테스트합니다. assert.deepEqual()의 반대입니다.

js
import assert from 'node:assert'

const obj1 = {
  a: {
    b: 1,
  },
}
const obj2 = {
  a: {
    b: 2,
  },
}
const obj3 = {
  a: {
    b: 1,
  },
}
const obj4 = { __proto__: obj1 }

assert.notDeepEqual(obj1, obj1)
// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }

assert.notDeepEqual(obj1, obj2)
// OK

assert.notDeepEqual(obj1, obj3)
// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }

assert.notDeepEqual(obj1, obj4)
// OK
js
const assert = require('node:assert')

const obj1 = {
  a: {
    b: 1,
  },
}
const obj2 = {
  a: {
    b: 2,
  },
}
const obj3 = {
  a: {
    b: 1,
  },
}
const obj4 = { __proto__: obj1 }

assert.notDeepEqual(obj1, obj1)
// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }

assert.notDeepEqual(obj1, obj2)
// OK

assert.notDeepEqual(obj1, obj3)
// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }

assert.notDeepEqual(obj1, obj4)
// OK

값이 심층적으로 같으면 message 속성이 message 매개변수의 값과 동일하게 설정된 AssertionError가 throw됩니다. message 매개변수가 정의되지 않은 경우 기본 오류 메시지가 할당됩니다. message 매개변수가 Error의 인스턴스인 경우 AssertionError 대신 throw됩니다.

assert.notDeepStrictEqual(actual, expected[, message]) ​

[히스토리]

버전변경 사항
v9.0.0-0과 +0은 더 이상 같다고 간주되지 않습니다.
v9.0.0NaN은 이제 SameValueZero 비교를 사용하여 비교됩니다.
v9.0.0Error 이름과 메시지는 이제 제대로 비교됩니다.
v8.0.0Set 및 Map 콘텐츠도 비교됩니다.
v6.1.0순환 참조가 있는 객체를 이제 입력으로 사용할 수 있습니다.
v6.4.0, v4.7.1이제 형식화된 배열 슬라이스가 올바르게 처리됩니다.
v5.10.1, v4.4.3Uint8Array가 아닌 형식화된 배열을 올바르게 처리합니다.
v1.2.0추가됨: v1.2.0

깊은 엄격한 불평등을 테스트합니다. assert.deepStrictEqual()의 반대입니다.

js
import assert from 'node:assert/strict'

assert.notDeepStrictEqual({ a: 1 }, { a: '1' })
// OK
js
const assert = require('node:assert/strict')

assert.notDeepStrictEqual({ a: 1 }, { a: '1' })
// OK

값이 깊고 엄격하게 같으면 message 매개변수의 값과 같은 message 속성이 설정된 AssertionError가 throw됩니다. message 매개변수가 정의되지 않으면 기본 오류 메시지가 할당됩니다. message 매개변수가 Error의 인스턴스이면 AssertionError 대신 throw됩니다.

assert.notEqual(actual, expected[, message]) ​

[히스토리]

버전변경 사항
v16.0.0, v14.18.0레거시 어설션 모드에서 상태가 Deprecated에서 Legacy로 변경되었습니다.
v14.0.0NaN은 양쪽 모두 NaN인 경우 동일하게 처리됩니다.
v0.1.21추가됨: v0.1.21

엄격한 어설션 모드

assert.notStrictEqual()의 별칭입니다.

레거시 어설션 모드

[안정적: 3 - 레거시]

안정적: 3 안정성: 3 - 레거시: 대신 assert.notStrictEqual()을 사용하십시오.

!= 연산자를 사용하여 얕은 강제 불평등을 테스트합니다. NaN은 특별히 처리되며 양쪽 모두 NaN인 경우 동일하게 처리됩니다.

js
import assert from 'node:assert'

assert.notEqual(1, 2)
// OK

assert.notEqual(1, 1)
// AssertionError: 1 != 1

assert.notEqual(1, '1')
// AssertionError: 1 != '1'
js
const assert = require('node:assert')

assert.notEqual(1, 2)
// OK

assert.notEqual(1, 1)
// AssertionError: 1 != 1

assert.notEqual(1, '1')
// AssertionError: 1 != '1'

값이 같으면 message 매개변수의 값과 같은 message 속성이 설정된 AssertionError가 throw됩니다. message 매개변수가 정의되지 않으면 기본 오류 메시지가 할당됩니다. message 매개변수가 Error의 인스턴스이면 AssertionError 대신 throw됩니다.

assert.notStrictEqual(actual, expected[, message]) ​

[히스토리]

버전변경 사항
v10.0.0엄격한 동등 비교가 Object.is()로 변경되었습니다.
v0.1.21추가됨: v0.1.21

Object.is()에 의해 결정된 대로 actual 및 expected 매개변수 간의 엄격한 불평등을 테스트합니다.

js
import assert from 'node:assert/strict'

assert.notStrictEqual(1, 2)
// OK

assert.notStrictEqual(1, 1)
// AssertionError [ERR_ASSERTION]: Expected "actual" to be strictly unequal to:
//
// 1

assert.notStrictEqual(1, '1')
// OK
js
const assert = require('node:assert/strict')

assert.notStrictEqual(1, 2)
// OK

assert.notStrictEqual(1, 1)
// AssertionError [ERR_ASSERTION]: Expected "actual" to be strictly unequal to:
//
// 1

assert.notStrictEqual(1, '1')
// OK

값이 엄격하게 같으면 message 매개변수의 값과 같은 message 속성이 설정된 AssertionError가 throw됩니다. message 매개변수가 정의되지 않은 경우 기본 오류 메시지가 할당됩니다. message 매개변수가 Error의 인스턴스인 경우 AssertionError 대신 throw됩니다.

assert.ok(value[, message]) ​

[히스토리]

버전변경 사항
v10.0.0assert.ok()(인수 없음)은 이제 미리 정의된 오류 메시지를 사용합니다.
v0.1.21추가됨: v0.1.21

value가 truthy인지 테스트합니다. assert.equal(!!value, true, message)와 같습니다.

value가 truthy가 아니면 message 매개변수의 값과 같은 message 속성이 설정된 AssertionError가 throw됩니다. message 매개변수가 undefined인 경우 기본 오류 메시지가 할당됩니다. message 매개변수가 Error의 인스턴스인 경우 AssertionError 대신 throw됩니다. 인수가 전혀 전달되지 않으면 message는 문자열 'No value argument passed to assert.ok()'로 설정됩니다.

repl에서는 파일에서 throw되는 오류 메시지와 다르다는 점에 유의하세요! 자세한 내용은 아래를 참조하십시오.

js
import assert from 'node:assert/strict'

assert.ok(true)
// OK
assert.ok(1)
// OK

assert.ok()
// AssertionError: No value argument passed to `assert.ok()`

assert.ok(false, "it's false")
// AssertionError: it's false

// In the repl:
assert.ok(typeof 123 === 'string')
// AssertionError: false == true

// In a file (e.g. test.js):
assert.ok(typeof 123 === 'string')
// AssertionError: The expression evaluated to a falsy value:
//
//   assert.ok(typeof 123 === 'string')

assert.ok(false)
// AssertionError: The expression evaluated to a falsy value:
//
//   assert.ok(false)

assert.ok(0)
// AssertionError: The expression evaluated to a falsy value:
//
//   assert.ok(0)
js
const assert = require('node:assert/strict')

assert.ok(true)
// OK
assert.ok(1)
// OK

assert.ok()
// AssertionError: No value argument passed to `assert.ok()`

assert.ok(false, "it's false")
// AssertionError: it's false

// In the repl:
assert.ok(typeof 123 === 'string')
// AssertionError: false == true

// In a file (e.g. test.js):
assert.ok(typeof 123 === 'string')
// AssertionError: The expression evaluated to a falsy value:
//
//   assert.ok(typeof 123 === 'string')

assert.ok(false)
// AssertionError: The expression evaluated to a falsy value:
//
//   assert.ok(false)

assert.ok(0)
// AssertionError: The expression evaluated to a falsy value:
//
//   assert.ok(0)
js
import assert from 'node:assert/strict'

// Using `assert()` works the same:
assert(0)
// AssertionError: The expression evaluated to a falsy value:
//
//   assert(0)
js
const assert = require('node:assert')

// Using `assert()` works the same:
assert(0)
// AssertionError: The expression evaluated to a falsy value:
//
//   assert(0)

assert.rejects(asyncFn[, error][, message]) ​

추가됨: v10.0.0

asyncFn promise를 기다리거나, asyncFn이 함수인 경우 함수를 즉시 호출하고 반환된 promise가 완료될 때까지 기다립니다. 그런 다음 promise가 reject되었는지 확인합니다.

asyncFn이 함수이고 동기적으로 오류를 throw하는 경우 assert.rejects()는 해당 오류가 포함된 rejected Promise를 반환합니다. 함수가 promise를 반환하지 않는 경우 assert.rejects()는 ERR_INVALID_RETURN_VALUE 오류가 포함된 rejected Promise를 반환합니다. 두 경우 모두 오류 처리기는 건너뜁니다.

완료를 기다리는 비동기 특성 외에는 assert.throws()와 동일하게 동작합니다.

지정된 경우 error는 Class, RegExp, 유효성 검사 함수, 각 속성이 테스트될 개체 또는 열거할 수 없는 message 및 name 속성을 포함하여 각 속성이 테스트될 오류 인스턴스일 수 있습니다.

지정된 경우 message는 asyncFn이 reject에 실패할 경우 AssertionError에서 제공하는 메시지가 됩니다.

js
import assert from 'node:assert/strict'

await assert.rejects(
  async () => {
    throw new TypeError('Wrong value')
  },
  {
    name: 'TypeError',
    message: 'Wrong value',
  }
)
js
const assert = require('node:assert/strict')

;(async () => {
  await assert.rejects(
    async () => {
      throw new TypeError('Wrong value')
    },
    {
      name: 'TypeError',
      message: 'Wrong value',
    }
  )
})()
js
import assert from 'node:assert/strict'

await assert.rejects(
  async () => {
    throw new TypeError('Wrong value')
  },
  err => {
    assert.strictEqual(err.name, 'TypeError')
    assert.strictEqual(err.message, 'Wrong value')
    return true
  }
)
js
const assert = require('node:assert/strict')

;(async () => {
  await assert.rejects(
    async () => {
      throw new TypeError('Wrong value')
    },
    err => {
      assert.strictEqual(err.name, 'TypeError')
      assert.strictEqual(err.message, 'Wrong value')
      return true
    }
  )
})()
js
import assert from 'node:assert/strict'

assert.rejects(Promise.reject(new Error('Wrong value')), Error).then(() => {
  // ...
})
js
const assert = require('node:assert/strict')

assert.rejects(Promise.reject(new Error('Wrong value')), Error).then(() => {
  // ...
})

error는 문자열일 수 없습니다. 두 번째 인수로 문자열을 제공하면 error는 생략된 것으로 간주되고 문자열이 대신 message로 사용됩니다. 이는 쉽게 간과할 수 있는 실수로 이어질 수 있습니다. 문자열을 두 번째 인수로 사용하는 경우 assert.throws()의 예제를 주의 깊게 읽으십시오.

assert.strictEqual(actual, expected[, message]) ​

[히스토리]

버전변경 사항
v10.0.0엄격한 동등 비교가 Object.is()로 변경되었습니다.
v0.1.21추가됨: v0.1.21

Object.is()에 의해 결정된 대로 actual 및 expected 매개변수 간의 엄격한 동등성을 테스트합니다.

js
import assert from 'node:assert/strict'

assert.strictEqual(1, 2)
// AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:
//
// 1 !== 2

assert.strictEqual(1, 1)
// OK

assert.strictEqual('Hello foobar', 'Hello World!')
// AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:
// + actual - expected
//
// + 'Hello foobar'
// - 'Hello World!'
//          ^

const apples = 1
const oranges = 2
assert.strictEqual(apples, oranges, `apples ${apples} !== oranges ${oranges}`)
// AssertionError [ERR_ASSERTION]: apples 1 !== oranges 2

assert.strictEqual(1, '1', new TypeError('Inputs are not identical'))
// TypeError: Inputs are not identical
js
const assert = require('node:assert/strict')

assert.strictEqual(1, 2)
// AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:
//
// 1 !== 2

assert.strictEqual(1, 1)
// OK

assert.strictEqual('Hello foobar', 'Hello World!')
// AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:
// + actual - expected
//
// + 'Hello foobar'
// - 'Hello World!'
//          ^

const apples = 1
const oranges = 2
assert.strictEqual(apples, oranges, `apples ${apples} !== oranges ${oranges}`)
// AssertionError [ERR_ASSERTION]: apples 1 !== oranges 2

assert.strictEqual(1, '1', new TypeError('Inputs are not identical'))
// TypeError: Inputs are not identical

값이 엄격하게 같지 않으면 message 속성이 message 매개변수의 값으로 설정된 AssertionError가 throw됩니다. message 매개변수가 정의되지 않은 경우 기본 오류 메시지가 할당됩니다. message 매개변수가 Error의 인스턴스인 경우 AssertionError 대신 throw됩니다.

assert.throws(fn[, error][, message]) ​

[히스토리]

버전변경 사항
v10.2.0error 매개변수는 정규 표현식을 포함하는 객체가 될 수 있습니다.
v9.9.0error 매개변수는 이제 객체가 될 수 있습니다.
v4.2.0error 매개변수는 이제 화살표 함수가 될 수 있습니다.
v0.1.21추가됨: v0.1.21

함수 fn이 오류를 throw할 것으로 예상합니다.

지정된 경우 error는 클래스, 정규 표현식, 유효성 검사 함수, 각 속성이 엄격한 심층 비교를 위해 테스트되는 유효성 검사 객체 또는 각 속성이 열거할 수 없는 message 및 name 속성을 포함하여 엄격한 심층 비교를 위해 테스트되는 오류 인스턴스가 될 수 있습니다. 객체를 사용하는 경우 문자열 속성에 대해 유효성을 검사할 때 정규 표현식을 사용하는 것도 가능합니다. 예제를 참조하십시오.

지정된 경우 fn 호출이 throw되지 않거나 오류 유효성 검사에 실패하는 경우 message가 AssertionError에서 제공하는 메시지에 추가됩니다.

사용자 지정 유효성 검사 객체/오류 인스턴스:

js
import assert from 'node:assert/strict'

const err = new TypeError('Wrong value')
err.code = 404
err.foo = 'bar'
err.info = {
  nested: true,
  baz: 'text',
}
err.reg = /abc/i

assert.throws(
  () => {
    throw err
  },
  {
    name: 'TypeError',
    message: 'Wrong value',
    info: {
      nested: true,
      baz: 'text',
    },
    // 유효성 검사 객체의 속성만 테스트됩니다.
    // 중첩 객체를 사용하려면 모든 속성이 있어야 합니다. 그렇지 않으면
    // 유효성 검사가 실패합니다.
  }
)

// 정규 표현식을 사용하여 오류 속성 유효성 검사:
assert.throws(
  () => {
    throw err
  },
  {
    // `name` 및 `message` 속성은 문자열이며 해당 속성에 정규 표현식을 사용하면 문자열과 일치합니다. 실패하면
    // 오류가 throw됩니다.
    name: /^TypeError$/,
    message: /Wrong/,
    foo: 'bar',
    info: {
      nested: true,
      // 중첩 속성에 정규 표현식을 사용할 수 없습니다!
      baz: 'text',
    },
    // `reg` 속성에는 정규 표현식이 포함되어 있으며 유효성 검사 객체에 동일한 정규 표현식이 포함되어 있는 경우에만
    // 통과합니다.
    reg: /abc/i,
  }
)

// 다른 `message` 및 `name` 속성으로 인해 실패합니다.
assert.throws(
  () => {
    const otherErr = new Error('Not found')
    // `err`에서 `otherErr`로 모든 열거 가능한 속성을 복사합니다.
    for (const [key, value] of Object.entries(err)) {
      otherErr[key] = value
    }
    throw otherErr
  },
  // 유효성 검사 객체로 오류를 사용하는 경우 오류의 `message` 및 `name` 속성도 확인됩니다.
  err
)
js
const assert = require('node:assert/strict')

const err = new TypeError('Wrong value')
err.code = 404
err.foo = 'bar'
err.info = {
  nested: true,
  baz: 'text',
}
err.reg = /abc/i

assert.throws(
  () => {
    throw err
  },
  {
    name: 'TypeError',
    message: 'Wrong value',
    info: {
      nested: true,
      baz: 'text',
    },
    // 유효성 검사 객체의 속성만 테스트됩니다.
    // 중첩 객체를 사용하려면 모든 속성이 있어야 합니다. 그렇지 않으면
    // 유효성 검사가 실패합니다.
  }
)

// 정규 표현식을 사용하여 오류 속성 유효성 검사:
assert.throws(
  () => {
    throw err
  },
  {
    // `name` 및 `message` 속성은 문자열이며 해당 속성에 정규 표현식을 사용하면 문자열과 일치합니다. 실패하면
    // 오류가 throw됩니다.
    name: /^TypeError$/,
    message: /Wrong/,
    foo: 'bar',
    info: {
      nested: true,
      // 중첩 속성에 정규 표현식을 사용할 수 없습니다!
      baz: 'text',
    },
    // `reg` 속성에는 정규 표현식이 포함되어 있으며 유효성 검사 객체에 동일한 정규 표현식이 포함되어 있는 경우에만
    // 통과합니다.
    reg: /abc/i,
  }
)

// 다른 `message` 및 `name` 속성으로 인해 실패합니다.
assert.throws(
  () => {
    const otherErr = new Error('Not found')
    // `err`에서 `otherErr`로 모든 열거 가능한 속성을 복사합니다.
    for (const [key, value] of Object.entries(err)) {
      otherErr[key] = value
    }
    throw otherErr
  },
  // 유효성 검사 객체로 오류를 사용하는 경우 오류의 `message` 및 `name` 속성도 확인됩니다.
  err
)

생성자를 사용한 instanceof 유효성 검사:

js
import assert from 'node:assert/strict'

assert.throws(() => {
  throw new Error('Wrong value')
}, Error)
js
const assert = require('node:assert/strict')

assert.throws(() => {
  throw new Error('Wrong value')
}, Error)

정규 표현식을 사용한 오류 메시지 유효성 검사:

정규 표현식을 사용하면 오류 객체에 .toString이 실행되므로 오류 이름도 포함됩니다.

js
import assert from 'node:assert/strict'

assert.throws(() => {
  throw new Error('Wrong value')
}, /^Error: Wrong value$/)
js
const assert = require('node:assert/strict')

assert.throws(() => {
  throw new Error('Wrong value')
}, /^Error: Wrong value$/)

사용자 지정 오류 유효성 검사:

함수는 모든 내부 유효성 검사가 통과되었음을 나타내는 true를 반환해야 합니다. 그렇지 않으면 AssertionError로 실패합니다.

js
import assert from 'node:assert/strict'

assert.throws(
  () => {
    throw new Error('Wrong value')
  },
  err => {
    assert(err instanceof Error)
    assert(/value/.test(err))
    // 유효성 검사 함수에서 `true` 이외의 값을 반환하지 마십시오.
    // 그렇지 않으면 유효성 검사의 어떤 부분이 실패했는지 명확하지 않습니다. 대신,
    // 실패한 특정 유효성 검사에 대한 오류를 throw하고(이 예제에서처럼) 가능한 한 많은 유용한 디버깅 정보를 해당 오류에 추가하십시오.
    return true
  },
  'unexpected error'
)
js
const assert = require('node:assert/strict')

assert.throws(
  () => {
    throw new Error('Wrong value')
  },
  err => {
    assert(err instanceof Error)
    assert(/value/.test(err))
    // 유효성 검사 함수에서 `true` 이외의 값을 반환하지 마십시오.
    // 그렇지 않으면 유효성 검사의 어떤 부분이 실패했는지 명확하지 않습니다. 대신,
    // 실패한 특정 유효성 검사에 대한 오류를 throw하고(이 예제에서처럼) 가능한 한 많은 유용한 디버깅 정보를 해당 오류에 추가하십시오.
    return true
  },
  'unexpected error'
)

error는 문자열이 될 수 없습니다. 두 번째 인수로 문자열을 제공하면 error가 생략된 것으로 간주되고 문자열이 대신 message로 사용됩니다. 이로 인해 쉽게 간과할 수 있는 실수가 발생할 수 있습니다. throw된 오류 메시지와 동일한 메시지를 사용하면 ERR_AMBIGUOUS_ARGUMENT 오류가 발생합니다. 두 번째 인수로 문자열을 사용하는 경우 아래 예제를 주의 깊게 읽으십시오.

js
import assert from 'node:assert/strict'

function throwingFirst() {
  throw new Error('First')
}

function throwingSecond() {
  throw new Error('Second')
}

function notThrowing() {}

// 두 번째 인수는 문자열이고 입력 함수가 Error를 throw했습니다.
// 첫 번째 경우는 입력 함수가 throw한 오류 메시지와 일치하지 않으므로 throw되지 않습니다!
assert.throws(throwingFirst, 'Second')
// 다음 예제에서는 메시지가 오류의 메시지보다 이점이 없으며 사용자가 실제로 오류 메시지와 일치하려고 했는지 명확하지 않으므로 Node.js는 `ERR_AMBIGUOUS_ARGUMENT` 오류를 throw합니다.
assert.throws(throwingSecond, 'Second')
// TypeError [ERR_AMBIGUOUS_ARGUMENT]

// 함수가 throw하지 않는 경우에만 문자열이 (메시지로) 사용됩니다.
assert.throws(notThrowing, 'Second')
// AssertionError [ERR_ASSERTION]: Missing expected exception: Second

// 오류 메시지와 일치하려는 의도였다면 이렇게 하십시오.
// 오류 메시지가 일치하므로 throw되지 않습니다.
assert.throws(throwingSecond, /Second$/)

// 오류 메시지가 일치하지 않으면 AssertionError가 throw됩니다.
assert.throws(throwingFirst, /Second$/)
// AssertionError [ERR_ASSERTION]
js
const assert = require('node:assert/strict')

function throwingFirst() {
  throw new Error('First')
}

function throwingSecond() {
  throw new Error('Second')
}

function notThrowing() {}

// 두 번째 인수는 문자열이고 입력 함수가 Error를 throw했습니다.
// 첫 번째 경우는 입력 함수가 throw한 오류 메시지와 일치하지 않으므로 throw되지 않습니다!
assert.throws(throwingFirst, 'Second')
// 다음 예제에서는 메시지가 오류의 메시지보다 이점이 없으며 사용자가 실제로 오류 메시지와 일치하려고 했는지 명확하지 않으므로 Node.js는 `ERR_AMBIGUOUS_ARGUMENT` 오류를 throw합니다.
assert.throws(throwingSecond, 'Second')
// TypeError [ERR_AMBIGUOUS_ARGUMENT]

// 함수가 throw하지 않는 경우에만 문자열이 (메시지로) 사용됩니다.
assert.throws(notThrowing, 'Second')
// AssertionError [ERR_ASSERTION]: Missing expected exception: Second

// 오류 메시지와 일치하려는 의도였다면 이렇게 하십시오.
// 오류 메시지가 일치하므로 throw되지 않습니다.
assert.throws(throwingSecond, /Second$/)

// 오류 메시지가 일치하지 않으면 AssertionError가 throw됩니다.
assert.throws(throwingFirst, /Second$/)
// AssertionError [ERR_ASSERTION]

혼란스럽고 오류가 발생하기 쉬운 표기법으로 인해 두 번째 인수로 문자열을 사용하지 않는 것이 좋습니다.

assert.partialDeepStrictEqual(actual, expected[, message]) ​

추가됨: v23.4.0

[안정적: 1 - 실험적]

안정적: 1 안정성: 1.0 - 초기 개발 단계

assert.partialDeepStrictEqual()은 심층 비교를 통해 actual 매개변수와 expected 매개변수 간의 동등성을 확인합니다. expected 매개변수의 모든 속성이 actual 매개변수에 동일한 값으로 존재하는지 확인하며, 형 변환은 허용하지 않습니다. assert.deepStrictEqual()과의 주요 차이점은 assert.partialDeepStrictEqual()은 actual 매개변수의 모든 속성이 expected 매개변수에 존재할 필요가 없다는 것입니다. 이 메서드는 항상 assert.deepStrictEqual()과 동일한 테스트 케이스를 통과해야 하며, 상위 집합으로 동작합니다.

js
import assert from 'node:assert'

assert.partialDeepStrictEqual({ a: 1, b: 2 }, { a: 1, b: 2 })
// OK

assert.partialDeepStrictEqual({ a: { b: { c: 1 } } }, { a: { b: { c: 1 } } })
// OK

assert.partialDeepStrictEqual({ a: 1, b: 2, c: 3 }, { a: 1, b: 2 })
// OK

assert.partialDeepStrictEqual(new Set(['value1', 'value2']), new Set(['value1', 'value2']))
// OK

assert.partialDeepStrictEqual(new Map([['key1', 'value1']]), new Map([['key1', 'value1']]))
// OK

assert.partialDeepStrictEqual(new Uint8Array([1, 2, 3]), new Uint8Array([1, 2, 3]))
// OK

assert.partialDeepStrictEqual(/abc/, /abc/)
// OK

assert.partialDeepStrictEqual([{ a: 5 }, { b: 5 }], [{ a: 5 }])
// OK

assert.partialDeepStrictEqual(new Set([{ a: 1 }, { b: 1 }]), new Set([{ a: 1 }]))
// OK

assert.partialDeepStrictEqual(new Date(0), new Date(0))
// OK

assert.partialDeepStrictEqual({ a: 1 }, { a: 1, b: 2 })
// AssertionError

assert.partialDeepStrictEqual({ a: 1, b: '2' }, { a: 1, b: 2 })
// AssertionError

assert.partialDeepStrictEqual({ a: { b: 2 } }, { a: { b: '2' } })
// AssertionError
js
const assert = require('node:assert')

assert.partialDeepStrictEqual({ a: 1, b: 2 }, { a: 1, b: 2 })
// OK

assert.partialDeepStrictEqual({ a: { b: { c: 1 } } }, { a: { b: { c: 1 } } })
// OK

assert.partialDeepStrictEqual({ a: 1, b: 2, c: 3 }, { a: 1, b: 2 })
// OK

assert.partialDeepStrictEqual([{ a: 5 }, { b: 5 }], [{ a: 5 }])
// OK

assert.partialDeepStrictEqual(new Set([{ a: 1 }, { b: 1 }]), new Set([{ a: 1 }]))
// OK

assert.partialDeepStrictEqual({ a: 1 }, { a: 1, b: 2 })
// AssertionError

assert.partialDeepStrictEqual({ a: 1, b: '2' }, { a: 1, b: 2 })
// AssertionError

assert.partialDeepStrictEqual({ a: { b: 2 } }, { a: { b: '2' } })
// AssertionError