What is “assert” in JavaScript?

Further elaboration on assert

Built-in assert() can't be taken for granted in JavaScript. Therefore, you must create your own or incorporate a version from a library. Its purpose is to signal when any assumption in your code's execution has violated, assisting significantly in detecting bugs or verifying that particular code sections remain unexecuted.

Browser-based assertions: console.assert

Browsers offer console.assert(). It writes an error message to the console if the assertion turns out to be false:

console.assert(array.length > 0, 'The array skipped breakfast. It’s empty!');


Keep in mind, it's non-blocking. Your code's execution isn't halted if the assertion fails.

Node.js assert module

For those preferring hardcore testing, especially in a Node.js environment, there's the assert module:

const assert = require('assert');

assert.strictEqual(1 + 1, 2, 'Even math has a hard day...');


It provides an array of assertion tests and goes as far as to stop execution by throwing an AssertionError if an assertion fails. Yeah, assert means serious business!

Custom assert utilities

Crafting custom assert functions is a great idea. They can be tweaked to verify not just truthiness, but type correctness too:

function assertType(type, value, message) {
  if (typeof value !== type) {
    throw new Error(message || `Expected type ${type}, got a fancy ${typeof value}`);
  }
}


The application is straightforward:

assertType('string', 123, 'Expected a string, not a teenage number');


This bypasses the need for static type checking in standard JavaScript without having to resort to TypeScript or Flow.

Debugging enablers: stack traces

By leveraging the Error object, custom assert functions also provide stack traces to pinpoint failure locations:

function assert(condition, message) {
  if (!condition) {
    throw new Error(message || 'Assertion failed');
  }
}


Initiating this error captures the call stack at that precise moment, thus streamlining the faulty piece's location.

Guidelines and good-to-knows

Applying assert effectively shields your codebase from errors propagating. It renders your assumptions loud and clear, making it simpler to spot incorrect logic when you're stuck in the depths of the coding universe.

Keeping input types in check

Rely assert to confirm that your functions receive inputs as expected, thus reducing type-related bugs' chances of creeping in:

function addNumbers(a, b) {
  assert(typeof a === 'number' && typeof b === 'number', 'Inputs must be number-crunchers');
  return a + b;
}


The Dev vs. Pro cauldrum

It’s important to note that assertions should be used mainly in development and testing. They should be kept on the sidelines in production code to avoid performance hits and unintentional revealings of your inner logic secrets.

Honing the assert functionality

Simple assertions have their charm, but occasionally you may want to check more high-level conditions.

Building complex conditions

The power of assert can be supercharged to handle complex conditions, and boolean logic can be roped in to assert multiple conditions:

function assertComplex(condition1, condition2, message) {
  assert(condition1 && condition2, message);
}


Assertion libraries to the rescue

In a scenario where you're not getting native support, you should try out well-maintained assertion libraries. These treasure troves offer a multitude of features and provide a more expressive syntax, like Chai or Jest's expect.

Customizing and analysing

Coming across an assert() in an unknown codebase calls for a detailed assessment of its implementation. Often, these are fine-tuned to align with the project's specific requirements and can reveal core assumptions that the development team harbored.

Asserting solid code quality

Assert methods are not merely debugging tools—they can pave the way to high-caliber code. They shape robust and developer-happy contracts in your libraries and implementations.