L'oprateur typeof

console.log(typeof 42);
// Sortie attendue : "number"

console.log(typeof "blubber");
// Sortie attendue : "string"

console.log(typeof true);
// Sortie attendue : "boolean"

console.log(typeof undeclaredVariable);
// Sortie attendue : "undefined"

typeof operand

// Pour les nombres
typeof 37 === "number";
typeof 3.14 === "number";
typeof 42 === "number";
typeof Math.LN2 === "number";
typeof Infinity === "number";
typeof NaN === "number"; // Bien que littralement ce soit "Not-A-Number"
typeof Number("1") === "number"; // Number essaie de convertir l'argument en nombre
typeof Number("chaussure") === "number"; // cela vaut galement pour les valeurs qui ne peuvent pas tre converties

typeof 42n === "bigint";

// Les chanes de caractres
typeof "" === "string";
typeof "bla" === "string";
typeof `gabarit de chane` === "string";
typeof "1" === "string"; // on a ici un nombre crit sous forme d'une chane de caractres
typeof typeof 1 === "string"; // typeof retourne toujours une chane de caractres
typeof String(1) === "string"; // String convertit n'importe quelle valeur en chane de caractres

// Les boolens
typeof true === "boolean";
typeof false === "boolean";
typeof Boolean(1) === "boolean"; // Boolean convertit n'importe quelle valeur en son quivalent logique
typeof !!1 === "boolean"; // deux appels  l'oprateur ! (le NON logique) sont quivalents  Boolean()

// Les symboles
typeof Symbol() === "symbol";
typeof Symbol("toto") === "symbol";
typeof Symbol.iterator === "symbol";

// Indfini
typeof undefined === "undefined";
typeof variableDeclareeMaisIndefinie === "undefined";
typeof variableNonDeclaree === "undefined";

// Les objets
typeof { a: 1 } === "object";

// Utiliser la mthode Array.isArray ou Object.prototype.toString.call
// afin de diffrencier les objets des tableaux
typeof [1, 2, 4] === "object";

typeof new Date() === "object";
typeof /regex/ === "object";

// Les lments suivants sont source de confusion, dangereux et inutiles. vitez-les.
typeof new Boolean(true) === "object";
typeof new Number(1) === "object";
typeof new String("abc") === "object";

// Les fonctions
typeof function () {} === "function";
typeof class C {} === "function";
typeof Math.sin === "function";

// Cela est valable depuis les commencements de JavaScript
typeof null === "object";

const str = new String("String");
const num = new Number(100);

typeof str; // "object"
typeof num; // "object"

const func = new Function();

typeof func; // "function"

// Les parenthses peuvent tre utilises pour dterminer le type de donnes des expressions.
const uneDonnee = 99;

typeof uneDonnee + " toto"; // "number toto"
typeof (uneDonnee + " toto"); // "string"

typeof variableNonDeclaree; // "undefined"

typeof newLetVariable; // ReferenceError
typeof newConstVariable; // ReferenceError
typeof newClass; // ReferenceError

let newLetVariable;
const newConstVariable = "bonjour";
class newClass {}

typeof document.all === "undefined";

function type(value) {
  if (value === null) {
    return "null";
  }
  const baseType = typeof value;
  // Types primitifs
  if (!["object", "function"].includes(baseType)) {
    return baseType;
  }

  // Symbol.toStringTag dfinit souvent le "nom d'affichage" de la
  // classe de l'objet. Il est utilis dans Object.prototype.toString().
  const tag = value[Symbol.toStringTag];
  if (typeof tag === "string") {
    return tag;
  }

  // Si c'est une fonction dont le code source commence par le mot-cl "class"
  if (
    baseType === "function" &&
    Function.prototype.toString.call(value).startsWith("class")
  ) {
    return "class";
  }

  // Le nom du constructeur ; par exemple `Array`, `GeneratorFunction`,
  // `Number`, `String`, `Boolean` ou `MyCustomClass`
  const className = value.constructor.name;
  if (typeof className === "string" && className !== "") {
    return className;
  }

  //  ce stade, il n'existe pas de mthode robuste pour obtenir le type
  // de la valeur, donc nous utilisons l'implmentation de base.
  return baseType;
}