Utilitaires de saisie – Défis JavaScript

Introduction

La vérification des types est une pratique courante en JavaScript dans le codage quotidien et les entretiens techniques.

Vous pouvez trouver tout le code dans cet article sur Github.

Valeurs primitives

En JavaScript, tous les types sauf Object définissent des valeurs immuables représentées directement au niveau le plus bas du langage. Nous appelons les valeurs de ces types valeurs primitives.

Il existe 7 valeurs primitives :

1. Nul
2. Indéfini
3. Booléen
4. Numéro
5. BigInt
6. Chaîne
7. Symbole

Tous les types primitifs, sauf null, peuvent être testés par l'opérateur typeof. typeof null renvoie "object", il faut donc utiliser === null pour tester null.

Par conséquent, nous obtenons la fonction utilitaire de premier type.

function isBoolean(value) {
  return typeof value === 'boolean';
}

function isString(value) {
  return typeof value === 'string';
}

function isNumber(value) {
  return typeof value === 'number';
}

function isSymbol(value) {
  return typeof value === 'symbol';
}

function isBigInt(value) {
  return typeof value === 'bigint';
}

function isUndefined(value) {
  return typeof value === 'undefined';
}

function isNull(value) {
  return value === null;
}

// Usage example
console.log(isSymbol(Symbol('test'))); // => true
console.log(isNull(null)); // => true
console.log(isUndefined(undefined)); // => true
console.log(isNumber(1)); // => true
console.log(isString('')); // => true
console.log(isBoolean(true)); // => true
console.log(isBigInt(9007199254740991n)); // => true

Objets

Tout ce qui n'est pas un type primitif est un objet en JavaScript. Cela comprend :

• Objets simples
• Tableaux
• Fonctions
• Dates
• RegExps
• Autres types d'objets intégrés

Voici la deuxième fonction utilitaire pour les tableaux, fonctions, objets.

function isArray(value) {
  return Array.isArray(value);
}

function isFunction(value) {
  return typeof value === 'function';
}

function isObject(value) {
  // for null and undefined
  if (value == null) {
    return false;
  }

  return typeof value === 'object';
}

function isPlainObject(value) {
  // for null and undefined
  if (value == null) {
    return false;
  }

  const prototype = Object.getPrototypeOf(value);
  return prototype === Object.prototype || prototype === null;
}

// Usage example
console.log(isArray(new Array())); // => true
console.log(isObject(Object(null))); // => true
console.log(isFunction(Object.prototype.toString)); // => true
console.log(isPlainObject(Object.create(null))); // => true

Objet.prototype.toString.call()

Il existe plusieurs méthodes pour vérifier les types en JavaScript, notamment :

• typeof pour tous les types primitifs sauf null.
• instanceof détermine si un objet est une instance d'un constructeur ou d'une classe spécifique. Cela ne fonctionne pas avec les valeurs primitives.

Object.prototype.toString.call() est la méthode la plus fiable pour la vérification de type en JavaScript.

On peut extraire les types par :

function getType(value) {
  const type = typeof value;

  if (type !== 'object') {
    return type;
  }

  return Object.prototype.toString
    .call(value)
    .slice(8, -1)
    .toLowerCase();
}

// Usage example
console.log(getType(1)); // => number
console.log(getType('')); // => string
console.log(getType({})); // => object
console.log(getType(null)); // => null
console.log(getType(undefined)); // => undefined
console.log(getType(Symbol())); // => symbol
console.log(getType(BigInt(1234567890123456789012345))); // => bigint
console.log(getType(function () {})); // => function
console.log(getType(new Date())); // => date
console.log(getType(new Map())); // => map
console.log(getType(new Set())); // => set 
console.log(getType(new RegExp("cat", "i"))); // => regex

Référence

• Types de données et structures de données JavaScript - MDN
• Types de données - JavaScript.info
• Type de référence - JavaScript.info
• GreatFrontEnd

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!