Faker

If built-in instances do not meet your requirements, you can instantiate a new Faker class. You can provide an array of locales to the locale option to define a fallback chain. Faker will check each locale in the order provided and use the first one that contains the requested data.

Common fallback patterns include:

• Custom Overwrites: Providing a LocaleDefinition object to override specific fields in existing locales.
• Regional Fallbacks: Using a specific regional locale (e.g., de_CH) before a generic one (e.g., de).
• Language Fallbacks: Using a generic language (e.g., en) to fill gaps in other locales.
• Base Locale: Including base at the end of the chain to provide universal data like emojis.

import type { LocaleDefinition } from '@faker-js/faker';
import { base, de, de_CH, en, Faker } from '@faker-js/faker';

const customLocale: LocaleDefinition = {
  title: 'My custom locale',
  internet: {
    domainSuffix: ['test'],
  },
};

export const customFaker = new Faker({
  locale: [customLocale, de_CH, de, en, base],
});

Starting with v9, FakerJS uses a 53-bit random value (via generateMersenne53Randomizer) by default instead of a 32-bit random value. This change provides:

• Improved distribution: Reduces the likelihood of duplicate values in large datasets. For example, the chance of duplicates in faker.number.int() dropped from 1 / 10,000 to less than 1 / 8,000,000.
• Subtle result differences: If you are using a fixed seed, the generated values will differ from v8 because the algorithm now consumes two seed values per step instead of one.

You can manually control the precision by providing a specific randomizer to SimpleFaker.

import {
  SimpleFaker,
  generateMersenne32Randomizer,
  generateMersenne53Randomizer,
} from '@faker-js/faker';

// < v9 default (32-bit)
const oldFaker = new SimpleFaker({
  randomizer: generateMersenne32Randomizer(),
});
oldFaker.seed(123);
const oldValue = oldFaker.helpers.multiple(() => oldFaker.number.int(10), {
  count: 10,
});

// > v9 default (53-bit)
const newFaker = new SimpleFaker({
  randomizer: generateMersenne53Randomizer(),
});
newFaker.seed(123);
const newValue = newFaker.helpers.multiple(() => newFaker.number.int(10), {
  count: 5,
});

Faker uses a systematic naming convention for locales based on international standards:

1. Language Code: The first two characters are a lowercase ISO 639-1 language code (e.g., ar for Arabic, en for English).
2. Country Code (Optional): An underscore followed by a two-letter uppercase ISO 3166-1 alpha-2 country code (e.g., en_US for English (United States), en_AU for English (Australia)).
3. Variant (Optional): An additional underscore followed by a variant for specific dialects or scripts (e.g., en_AU_ocker for Australian Ocker dialect, sr_RS_latin for Serbian in Latin script).

You can access prebuilt Faker instances or raw locale definitions using the allFakers and allLocales objects, where the locale codes serve as keys.

import { allFakers, allLocales } from '@faker-js/faker';

console.dir(allFakers['de_AT']); // the prebuilt Faker instance for de_AT
console.dir(allLocales['de_AT']); // the raw locale definitions for de_AT

// Example: Enumerating all locales
for (let key of Object.keys(allFakers)) {
  try {
    console.log(`In locale ${key}, a sample name is ${allFakers[key].person.fullName()}`);
  } catch (e) {
    console.log(`In locale ${key}, an error occurred: ${e}`);
  }
}

Faker integrates seamlessly with Vitest and Jest. For Vitest, ensure you import testing methods (like describe, it, expect) from vitest. For Jest, these are typically available globally or imported from @jest/globals.

To ensure deterministic results for snapshot testing, use faker.seed(number) to provide a static value. It is a best practice to use an afterEach hook to call faker.seed() without arguments to re-seed the instance with a new random value after each test, preventing side effects in other tests.

import { faker } from '@faker-js/faker/locale/en';
import { afterEach, describe, expect, it } from 'vitest';

// Re-seed after each test to ensure other tests remain random
afterEach(() => {
  faker.seed();
});

describe('reverse array', () => {
  it('should reverse the array', () => {
    // Seed with a static number for deterministic snapshot testing
    faker.seed(1234);
    const title = faker.person.jobTitle();
    const name = faker.person.fullName();
    const animal = faker.animal.bear();

    const array = [title, name, animal];

    expect(array.reverse()).toStrictEqual([animal, name, title]);
    expect(array.reverse()).toMatchSnapshot();
  });
});