Live Coding

Comment vérifier si un objet JavaScript est vide ?

Explication : Un objet est vide s'il n'a pas de propriétés énumérables propres. Nous pouvons utiliser Object.keys(obj) qui renvoie un tableau des noms de propriétés énumérables propres d'un objet donné. Si la longueur de ce tableau est 0, l'objet est vide.

function isEmpty(obj) {
  return Object.keys(obj).length === 0;
}

console.log(isEmpty({})); // true
console.log(isEmpty({ a: 1 })); // false

Écrire une fonction pour inverser une chaîne de caractères donnée.

Explication : Le moyen le plus simple est de convertir la chaîne en un tableau de caractères, d'utiliser la méthode reverse() intégrée pour les tableaux, puis de joindre les caractères pour reformer une chaîne.

function reverseString(str) {
  return str.split('').reverse().join('');
}

console.log(reverseString('hello')); // 'olleh'

Écrire une fonction qui vérifie si une chaîne de caractères donnée est un palindrome.

Explication : Un palindrome est un mot ou une phrase qui se lit de la même manière dans les deux sens. Nous pouvons le vérifier en inversant la chaîne (en ignorant la casse et les caractères non alphanumériques pour une vérification plus robuste, mais ici nous faisons une vérification simple) et en la comparant à l'originale.

function isPalindrome(str) {
  const reversed = str.split('').reverse().join('');
  return str === reversed;
}

console.log(isPalindrome('racecar')); // true
console.log(isPalindrome('hello')); // false

Écrire une fonction pour trouver le plus grand nombre dans un tableau de nombres.

Explication : Vous pouvez parcourir le tableau en gardant une trace du plus grand nombre trouvé jusqu'à présent. Alternativement, vous pouvez utiliser la fonction Math.max() avec l'opérateur de décomposition (...) pour passer les éléments du tableau comme arguments.

function findMaxNumber(arr) {
  if (arr.length === 0) return undefined; // Ou lancer une erreur
  return Math.max(...arr);
}

console.log(findMaxNumber([1, 5, 2, 9, 3])); // 9

Écrire un programme qui imprime les nombres de 1 à n. Mais pour les multiples de trois, imprimer 'Fizz' au lieu du nombre et pour les multiples de cinq, imprimer 'Buzz'. Pour les nombres qui sont des multiples de trois et de cinq, imprimer 'FizzBuzz'.

Explication : Ce problème classique teste la logique de base des boucles et des conditions. Vous devez itérer de 1 à n et utiliser l'opérateur modulo (%) pour vérifier la divisibilité par 3 et 5.

function fizzBuzz(n) {
  for (let i = 1; i <= n; i++) {
    if (i % 3 === 0 && i % 5 === 0) {
      console.log('FizzBuzz');
    } else if (i % 3 === 0) {
      console.log('Fizz');
    } else if (i % 5 === 0) {
      console.log('Buzz');
    } else {
      console.log(i);
    }
  }
}

fizzBuzz(15);

Écrire une fonction qui supprime les éléments en double d'un tableau.

Explication : Une façon moderne et concise d'y parvenir est d'utiliser un Set. Les ensembles ne stockent que des valeurs uniques. Vous pouvez convertir le tableau en un ensemble, puis le reconvertir en un tableau.

function removeDuplicates(arr) {
  return [...new Set(arr)];
}

console.log(removeDuplicates([1, 2, 2, 3, 4, 4, 5])); // [1, 2, 3, 4, 5]

Écrire une fonction pour vérifier si deux chaînes de caractères sont des anagrammes l'une de l'autre.

Explication : Les anagrammes sont des mots formés en réorganisant les lettres d'un autre mot. Pour vérifier, nous pouvons nettoyer, trier et comparer les chaînes. Le nettoyage implique la suppression des caractères non alphanumériques et la conversion dans une casse cohérente.

function isAnagram(str1, str2) {
  const clean = (str) => str.replace(/[^a-z0-9]/gi, '').toLowerCase();
  const sorted = (str) => clean(str).split('').sort().join('');
  
  return sorted(str1) === sorted(str2);
}

console.log(isAnagram('listen', 'silent')); // true
console.log(isAnagram('hello', 'world')); // false

Écrire une fonction pour calculer la factorielle d'un entier non négatif.

Explication : La factorielle (n !) d'un nombre est le produit de tous les entiers positifs inférieurs ou égaux à n. Nous pouvons le calculer de manière itérative en multipliant les nombres de 1 à n.

function factorial(n) {
  if (n < 0) return undefined; // La factorielle n'est pas définie pour les nombres négatifs
  if (n === 0) return 1;
  let result = 1;
  for (let i = 1; i <= n; i++) {
    result *= i;
  }
  return result;
}

console.log(factorial(5)); // 120

Écrire une fonction qui renvoie la somme de tous les nombres d'un tableau.

Explication : Vous pouvez utiliser la méthode reduce, qui est idéale pour accumuler une seule valeur à partir d'un tableau. Elle prend une fonction de rappel et une valeur initiale (0 pour la somme).

function sumArray(arr) {
  return arr.reduce((accumulator, currentValue) => accumulator + currentValue, 0);
}

console.log(sumArray([1, 2, 3, 4])); // 10

Écrire une fonction pour aplatir un tableau imbriqué. Pour simplifier, n'assurez qu'un seul niveau d'imbrication.

Explication : Pour un seul niveau d'imbrication, vous pouvez utiliser Array.prototype.concat() avec l'opérateur de décomposition ou la méthode flat() (ES2019).

function flattenArray(arr) {
  // Utilisation de flat() (plus simple si ES2019+ est acceptable)
  // return arr.flat();

  // Utilisation de reduce et concat
  return arr.reduce((acc, val) => acc.concat(val), []);
}

console.log(flattenArray([1, [2, 3], 4, [5]])); // [1, 2, 3, 4, 5]

Écrire une fonction qui compte le nombre de voyelles (a, e, i, o, u) dans une chaîne donnée.

Explication : Parcourir la chaîne (sans tenir compte de la casse) et vérifier si chaque caractère est une voyelle. Maintenir un compteur.

function countVowels(str) {
  const vowels = 'aeiou';
  let count = 0;
  for (let char of str.toLowerCase()) {
    if (vowels.includes(char)) {
      count++;
    }
  }
  return count;
}

console.log(countVowels('Hello World')); // 3

Écrire une fonction qui convertit une phrase en casse de titre (la première lettre de chaque mot est en majuscule).

Explication : Diviser la phrase en mots, puis parcourir chaque mot, en mettant la première lettre en majuscule et le reste en minuscule. Enfin, joindre les mots.

function titleCase(str) {
  return str.toLowerCase().split(' ').map(word => {
    return word.charAt(0).toUpperCase() + word.slice(1);
  }).join(' ');
}

console.log(titleCase('i am a little tea pot')); // 'I Am A Little Tea Pot'

Étant donné un tableau d'entiers nums et un entier target, renvoyer les indices des deux nombres dont la somme est égale à target.

Explication : Une approche courante consiste à utiliser une table de hachage (ou un objet JavaScript) pour stocker les nombres et leurs indices au fur et à mesure que vous itérez. Pour chaque nombre, vérifiez si target - current_number existe dans la table.

function twoSum(nums, target) {
  const map = {};
  for (let i = 0; i < nums.length; i++) {
    const complement = target - nums[i];
    if (map[complement] !== undefined) {
      return [map[complement], i];
    }
    map[nums[i]] = i;
  }
  return []; // Ou null, ou lancer une erreur si pas de solution
}

console.log(twoSum([2, 7, 11, 15], 9)); // [0, 1]

Créer une fonction qui renvoie une fonction de compteur. Chaque fois que la fonction renvoyée est appelée, elle doit incrémenter et renvoyer un compte.

Explication : Ceci démontre les fermetures (closures). La fonction interne a accès à la variable count de la portée de la fonction externe, même après que la fonction externe a terminé son exécution.

function createCounter() {
  let count = 0;
  return function() {
    count++;
    return count;
  };
}

const counter1 = createCounter();
console.log(counter1()); // 1
console.log(counter1()); // 2
const counter2 = createCounter();
console.log(counter2()); // 1

Écrire une fonction qui trouve le premier caractère non répété dans une chaîne.

Explication : Vous pouvez utiliser une table de hachage pour compter les fréquences des caractères. Tout d'abord, parcourez la chaîne pour construire la table de fréquences. Ensuite, parcourez à nouveau la chaîne et renvoyez le premier caractère avec un compte de 1.

function firstNonRepeatingChar(str) {
  const charCount = {};
  for (const char of str) {
    charCount[char] = (charCount[char] || 0) + 1;
  }
  for (const char of str) {
    if (charCount[char] === 1) {
      return char;
    }
  }
  return null; // Ou un indicateur si tous les caractères se répètent
}

console.log(firstNonRepeatingChar('aabbcdeeff')); // 'c'
console.log(firstNonRepeatingChar('swiss')); // 'w'

Écrire une fonction qui divise un tableau en groupes d'une taille spécifiée.

Explication : Parcourir le tableau, en prenant des tranches de la taille spécifiée et en les poussant dans un nouveau tableau. Gérer le cas où le dernier morceau pourrait être plus petit.

function chunkArray(arr, size) {
  const chunked = [];
  let index = 0;
  while (index < arr.length) {
    chunked.push(arr.slice(index, index + size));
    index += size;
  }
  return chunked;
}

console.log(chunkArray([1, 2, 3, 4, 5, 6, 7], 3)); // [[1, 2, 3], [4, 5, 6], [7]]

Écrire une fonction pour déterminer si un nombre donné est un nombre premier.

Explication : Un nombre premier est un nombre naturel supérieur à 1 qui n'a pas d'autres diviseurs positifs que 1 et lui-même. Itérer de 2 jusqu'à la racine carrée du nombre, en vérifiant la divisibilité. Gérer les cas limites comme 1 et 2.

function isPrime(num) {
  if (num <= 1) return false;
  if (num <= 3) return true;

  if (num % 2 === 0 || num % 3 === 0) return false;

  for (let i = 5; i * i <= num; i = i + 6) {
    if (num % i === 0 || num % (i + 2) === 0) return false;
  }

  return true;
}

console.log(isPrime(7)); // true
console.log(isPrime(10)); // false

Écrire une fonction qui trouve le mot le plus long dans une phrase.

Explication : Diviser la chaîne en un tableau de mots. Ensuite, parcourir le tableau, en gardant une trace du mot le plus long trouvé jusqu'à présent (ou de sa longueur).

function findLongestWord(str) {
  const words = str.split(' ');
  let longestWord = '';
  for (const word of words) {
    // Nettoyer les mots si nécessaire (par exemple, supprimer la ponctuation)
    if (word.length > longestWord.length) {
      longestWord = word;
    }
  }
  return longestWord;
}

console.log(findLongestWord('The quick brown fox jumped over the lazy dog')); // 'jumped'

Implémenter votre propre version de la fonction Array.prototype.map.

Explication : La fonction map prend une fonction de rappel et crée un nouveau tableau en appliquant la fonction de rappel à chaque élément du tableau original. Votre fonction doit parcourir le tableau et construire le nouveau tableau.

function myMap(arr, callback) {
  const mappedArray = [];
  for (let i = 0; i < arr.length; i++) {
    mappedArray.push(callback(arr[i], i, arr));
  }
  return mappedArray;
}

const numbers = [1, 4, 9];
const roots = myMap(numbers, Math.sqrt);
console.log(roots); // [1, 2, 3]

Implémenter votre propre version de la fonction Array.prototype.filter.

Explication : La fonction filter prend une fonction de rappel et crée un nouveau tableau avec tous les éléments qui réussissent le test implémenté par la fonction de rappel fournie.

function myFilter(arr, callback) {
  const filteredArray = [];
  for (let i = 0; i < arr.length; i++) {
    if (callback(arr[i], i, arr)) {
        filteredArray.push(arr[i]);
    }
  }
  return filteredArray;
}

const words = ['spray', 'limit', 'elite', 'exuberant', 'destruction', 'present'];
const result = myFilter(words, word => word.length > 6);
console.log(result); // ['exuberant', 'destruction', 'present']

Implémenter votre propre version de la fonction Array.prototype.reduce.

Explication : La fonction reduce exécute une fonction de rappel 'reducer' fournie par l'utilisateur sur chaque élément du tableau, en transmettant la valeur de retour du calcul sur l'élément précédent. Le résultat final de l'exécution du reducer sur tous les éléments du tableau est une seule valeur. Gérer l'argument de la valeur initiale.

function myReduce(arr, callback, initialValue) {
  let accumulator = initialValue;
  let startIndex = 0;

  if (initialValue === undefined) {
      if (arr.length === 0) throw new TypeError('Reduce of empty array with no initial value');
      accumulator = arr[0];
      startIndex = 1;
  }

  for (let i = startIndex; i < arr.length; i++) {
    accumulator = callback(accumulator, arr[i], i, arr);
  }
  return accumulator;
}

const array1 = [1, 2, 3, 4];
const sum = myReduce(array1, (acc, curr) => acc + curr, 0);
console.log(sum); // 10

Implémenter une fonction Fibonacci en utilisant la mémoïsation pour optimiser les performances.

Explication : La suite de Fibonacci implique des calculs répétés. La mémoïsation stocke les résultats des appels de fonction coûteux et renvoie le résultat mis en cache lorsque les mêmes entrées se produisent à nouveau.

function memoizedFib() {
  const cache = {};

  function fib(n) {
    if (n in cache) {
      return cache[n];
    }
    if (n <= 1) {
      return n;
    }
    const result = fib(n - 1) + fib(n - 2);
    cache[n] = result;
    return result;
  }
  return fib;
}

const fibonacci = memoizedFib();
console.log(fibonacci(10)); // 55
console.log(fibonacci(40)); // 102334155 (beaucoup plus rapide que sans mémoïsation)

Écrire une fonction pour vérifier si une chaîne contenant des crochets {}[]() est équilibrée.

Explication : Utiliser une pile. Lorsque vous rencontrez un crochet ouvrant, poussez-le sur la pile. Lorsque vous rencontrez un crochet fermant, vérifiez si la pile est vide ou si l'élément supérieur est le crochet ouvrant correspondant. S'il correspond, retirez-le de la pile. Sinon, ou si la pile est vide, elle est déséquilibrée. À la fin, une pile vide signifie qu'elle est équilibrée.

function isBalanced(str) {
  const stack = [];
  const map = { '(': ')', '{': '}', '[': ']' };

  for (let char of str) {
    if (map[char]) {
      stack.push(char);
    } else if (Object.values(map).includes(char)) {
      if (stack.length === 0) return false;
      const lastOpen = stack.pop();
      if (map[lastOpen] !== char) return false;
    }
  }
  return stack.length === 0;
}

console.log(isBalanced('({[]})')); // true
console.log(isBalanced('([)]')); // false

Implémenter une structure de données File d'attente avec les méthodes enqueue (ajouter à la fin) et dequeue (retirer du début).

Explication : Une file d'attente suit le principe du Premier entré, premier sorti (FIFO). Un tableau peut être utilisé, avec push pour enqueue et shift pour dequeue.

class Queue {
  constructor() {
    this.items = [];
  }

  enqueue(element) {
    this.items.push(element);
  }

  dequeue() {
    if (this.isEmpty()) return 'Underflow';
    return this.items.shift();
  }

  front() {
    if (this.isEmpty()) return 'No elements in Queue';
    return this.items[0];
  }

  isEmpty() {
    return this.items.length === 0;
  }
}

const q = new Queue();
q.enqueue(10);
q.enqueue(20);
console.log(q.dequeue()); // 10
console.log(q.front()); // 20

Implémenter une structure de données Pile avec les méthodes push (ajouter au sommet) et pop (retirer du sommet).

Explication : Une pile suit le principe du Dernier entré, premier sorti (LIFO). Un tableau peut être utilisé, avec les méthodes push et pop.

class Stack {
  constructor() {
    this.items = [];
  }

  push(element) {
    this.items.push(element);
  }

  pop() {
    if (this.isEmpty()) return 'Underflow';
    return this.items.pop();
  }

  peek() {
    return this.items[this.items.length - 1];
  }

  isEmpty() {
    return this.items.length === 0;
  }
}

const s = new Stack();
s.push(10);
s.push(20);
console.log(s.pop()); // 20
console.log(s.peek()); // 10

Étant donné un tableau contenant n nombres distincts pris de 0, 1, 2, ..., n, trouver celui qui manque dans le tableau.

Explication : La somme des nombres de 0 à n peut être calculée à l'aide de la formule n*(n+1)/2. La somme réelle des éléments du tableau peut être calculée. La différence entre ces deux sommes sera le nombre manquant.

function findMissingNumber(nums) {
  const n = nums.length;
  const expectedSum = n * (n + 1) / 2;
  const actualSum = nums.reduce((sum, num) => sum + num, 0);
  return expectedSum - actualSum;
}

console.log(findMissingNumber([3, 0, 1])); // 2
console.log(findMissingNumber([9, 6, 4, 2, 3, 5, 7, 0, 1])); // 8

Implémenter une fonction de démultiplication. La démultiplication garantit qu'une fonction n'est pas rappelée avant qu'un certain temps ne se soit écoulé sans qu'elle ne soit appelée.

Explication : Utiliser setTimeout et clearTimeout. Chaque fois que la fonction démultipliée est appelée, effacer le délai d'attente précédent et en définir un nouveau. L'appel de fonction réel ne se produit que lorsque le délai d'attente est terminé.

function debounce(func, delay) {
  let timeoutId;
  return function(...args) {
    clearTimeout(timeoutId);
    timeoutId = setTimeout(() => {
      func.apply(this, args);
    }, delay);
  };
}

// Exemple d'utilisation :
const sayHello = () => console.log('Hello!');
const debouncedHello = debounce(sayHello, 1000);
debouncedHello(); // Appelé après 1 sec (si non appelé à nouveau)
debouncedHello(); // Réinitialise le timer
debouncedHello(); // Réinitialise le timer, s'exécutera réellement 1 sec après cet appel.

Implémenter une fonction de limitation. La limitation garantit qu'une fonction est appelée au plus une fois dans un intervalle de temps spécifié.

Explication : Utiliser un drapeau pour indiquer si un appel est autorisé. Lorsqu'elle est appelée, si elle est autorisée, exécuter la fonction, mettre le drapeau à faux et utiliser setTimeout pour réinitialiser le drapeau après l'intervalle.

function throttle(func, limit) {
  let inThrottle = false;
  return function(...args) {
    if (!inThrottle) {
      func.apply(this, args);
      inThrottle = true;
      setTimeout(() => inThrottle = false, limit);
    }
  };
}

// Exemple d'utilisation :
const logScroll = () => console.log('Scrolling...');
const throttledScroll = throttle(logScroll, 1000);
// window.addEventListener('scroll', throttledScroll); // Se connectera au plus une fois par seconde.

Écrire une fonction qui prend une fonction avec deux arguments et renvoie une version curried de celle-ci.

Explication : Le currying transforme une fonction avec plusieurs arguments en une séquence de fonctions, chacune prenant un seul argument. f(a, b) devient f(a)(b).

function curry(fn) {
  return function(a) {
    return function(b) {
      return fn(a, b);
    };
  };
}

function add(a, b) {
  return a + b;
}

const curriedAdd = curry(add);
const add5 = curriedAdd(5);
console.log(add5(3)); // 8
console.log(curriedAdd(10)(20)); // 30

Écrire une fonction pour effectuer un clonage profond d'un objet JavaScript.

Explication : Un clonage superficiel ne copie que les propriétés de niveau supérieur. Un clonage profond copie récursivement toutes les propriétés, y compris les objets et les tableaux imbriqués. Un moyen simple (avec des limitations, par exemple, ne gère pas bien les fonctions, les dates, les expressions régulières) est d'utiliser JSON.parse(JSON.stringify(obj)). Une approche récursive est plus robuste.

function deepClone(obj) {
  // Version simple (avec des limitations)
  try {
      return JSON.parse(JSON.stringify(obj));
  } catch (e) {
      console.error("Le clonage a échoué :", e);
      return null;
  }
  
  // Récursive plus robuste (exemple de base) :
  /*
  if (obj === null || typeof obj !== 'object') {
      return obj;
  }
  let clone = Array.isArray(obj) ? [] : {};
  for (let key in obj) {
      if (Object.prototype.hasOwnProperty.call(obj, key)) {
          clone[key] = deepClone(obj[key]);
      }
  }
  return clone;
  */
}

const original = { a: 1, b: { c: 2 } };
const cloned = deepClone(original);
cloned.b.c = 3;
console.log(original.b.c); // 2 (prouve que c'est un clone profond)
console.log(cloned.b.c); // 3

Comment obtenir un tableau de clés à partir d'un objet ?

Explication : Utiliser Object.keys(obj).

function getKeys(obj) {
  return Object.keys(obj);
}
console.log(getKeys({a: 1, b: 2})); // ['a', 'b']

Comment obtenir un tableau de valeurs à partir d'un objet ?

Explication : Utiliser Object.values(obj).

function getValues(obj) {
  return Object.values(obj);
}
console.log(getValues({a: 1, b: 2})); // [1, 2]

Comment vérifier si un tableau contient une valeur spécifique ?

Explication : Utiliser Array.prototype.includes(value).

function checkIncludes(arr, val) {
  return arr.includes(val);
}
console.log(checkIncludes([1, 2, 3], 2)); // true

Comment fusionner deux tableaux en un seul ?

Explication : Utiliser l'opérateur de décomposition (...) ou Array.prototype.concat().

function mergeArrays(arr1, arr2) {
  return [...arr1, ...arr2];
}
console.log(mergeArrays([1, 2], [3, 4])); // [1, 2, 3, 4]

À quoi fait référence this dans la portée globale dans un navigateur ?

Explication : Dans le contexte d'exécution global (en dehors de toute fonction), this fait référence à l'objet global, qui est window dans les navigateurs web.

console.log(this === window); // true (dans un environnement de navigateur)

À quoi fait référence this lorsqu'il est utilisé à l'intérieur d'une méthode d'objet ?

Explication : Lorsqu'une fonction est appelée comme méthode d'un objet, this fait référence à l'objet sur lequel la méthode est appelée.

const myObject = {
  prop: 'Hello',
  greet() {
    return this.prop;
  }
};
console.log(myObject.greet()); // 'Hello'

Comment les fonctions fléchées gèrent-elles this ?

Explication : Les fonctions fléchées n'ont pas leur propre contexte this. Au lieu de cela, elles héritent de this de la portée englobante (lexicale) où elles sont définies.

function MyClass() {
  this.value = 42;
  setTimeout(() => {
    console.log(this.value); // Affiche 42 car 'this' est hérité
  }, 100);
}
new MyClass();

Quelles sont les principales différences entre let, const et var ?

Explication : var a une portée fonctionnelle et est remonté (hoisted). let et const ont une portée de bloc et sont remontés mais se trouvent dans une 'zone morte temporelle' jusqu'à la déclaration. const doit être initialisé et ne peut pas être réaffecté.

function scopeTest() {
  var a = 1;
  let b = 2;
  const c = 3;
  if (true) {
    var a = 10; // Redéclare et affecte le 'a' extérieur
    let b = 20; // Nouveau 'b' dans le bloc
    // const c = 30; // Serait un nouveau 'c'
    console.log(a, b, c); // 10, 20, 3
  }
  console.log(a, b, c); // 10, 2, 3
}
scopeTest();

Expliquer ce qu'est une Promesse en JavaScript.

Explication : Une Promesse est un objet représentant l'achèvement éventuel (ou l'échec) d'une opération asynchrone et sa valeur résultante. Elle peut être dans l'un des trois états : en attente (pending), résolue (fulfilled) ou rejetée (rejected).

const myPromise = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve('Succès !');
    // reject('Erreur !');
  }, 1000);
});

myPromise
  .then(result => console.log(result))
  .catch(error => console.error(error));

Comment async et await simplifient-ils le travail avec les Promesses ?

Explication : async/await fournit un sucre syntaxique sur les Promesses, rendant le code asynchrone plus proche du code synchrone. Une fonction async renvoie toujours une Promesse, et await interrompt l'exécution jusqu'à ce qu'une Promesse soit réglée.

function delay(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function run() {
  console.log('Démarrage...');
  await delay(1000);
  console.log('Attendu 1 seconde.');
  await delay(500);
  console.log('Attendu 0,5 seconde de plus.');
  return 'Terminé !';
}

run().then(console.log);

Comment convertir une chaîne de caractères en un nombre ?

Explication : Utiliser parseInt(), parseFloat() ou l'opérateur unaire plus (+).

const str = '123.45';
console.log(parseInt(str)); // 123
console.log(parseFloat(str)); // 123.45
console.log(+str); // 123.45

Comment convertir un nombre en chaîne de caractères ?

Explication : Utiliser String(), number.toString() ou la concaténation de chaînes.

const num = 123;
console.log(String(num)); // '123'
console.log(num.toString()); // '123'
console.log('' + num); // '123'

Que fait JSON.stringify ?

Explication : Il convertit un objet ou une valeur JavaScript en une chaîne JSON.

const obj = { name: 'Alice', age: 30 };
const jsonString = JSON.stringify(obj);
console.log(jsonString); // '{"name":"Alice","age":30}'

Que fait JSON.parse ?

Explication : Il analyse une chaîne JSON, construisant la valeur ou l'objet JavaScript décrit par la chaîne.

const jsonString = '{"name":"Alice","age":30}';
const obj = JSON.parse(jsonString);
console.log(obj.name); // 'Alice'

Comment l'opérateur de décomposition est-il utilisé avec les tableaux ?

Explication : Il permet d'étendre un itérable (comme un tableau) dans des endroits où zéro ou plusieurs arguments ou éléments sont attendus. Utile pour copier, fusionner et ajouter des éléments.

const arr1 = [1, 2];
const arr2 = [3, 4];
const combined = [...arr1, ...arr2]; // [1, 2, 3, 4]
const copy = [...arr1]; // [1, 2]

Comment l'opérateur de décomposition est-il utilisé avec les objets ?

Explication : Il permet de copier et de fusionner des propriétés d'objet.

const obj1 = { a: 1, b: 2 };
const obj2 = { b: 3, c: 4 };
const merged = { ...obj1, ...obj2 }; // { a: 1, b: 3, c: 4 }
const copy = { ...obj1 }; // { a: 1, b: 2 }

Expliquer la déstructuration de tableaux avec un exemple.

Explication : C'est une syntaxe qui permet de déballer des valeurs de tableaux dans des variables distinctes.

const [a, b] = [10, 20];
console.log(a); // 10
console.log(b); // 20

const [x, , z] = [1, 2, 3];
console.log(z); // 3

Expliquer la déstructuration d'objets avec un exemple.

Explication : Elle permet de déballer des propriétés d'objets dans des variables distinctes.

const person = { name: 'Bob', age: 25 };
const { name, age } = person;
console.log(name); // 'Bob'
console.log(age); // 25

const { name: personName } = person;
console.log(personName); // 'Bob'

Comment pourriez-vous implémenter une version de base de Function.prototype.call ?

Explication : call invoque une fonction avec une valeur this spécifiée et des arguments fournis individuellement. Vous pouvez attacher la fonction au contexte this, l'appeler, puis la supprimer.

Function.prototype.myCall = function(context, ...args) {
  context = context || window;
  const uniqueId = Symbol(); // Utiliser une clé unique
  context[uniqueId] = this;
  const result = context[uniqueId](...args);
  delete context[uniqueId];
  return result;
}

function greet(greeting, punctuation) {
  console.log(`${greeting}, ${this.name}${punctuation}`);
}

greet.myCall({ name: 'Charlie' }, 'Hi', '!'); // Salut, Charlie !

Comment pourriez-vous implémenter une version de base de Function.prototype.apply ?

Explication : apply est similaire à call, mais il accepte les arguments sous forme de tableau.

Function.prototype.myApply = function(context, argsArray) {
  context = context || window;
  const uniqueId = Symbol();
  context[uniqueId] = this;
  const result = context[uniqueId](...(argsArray || []));
  delete context[uniqueId];
  return result;
}

function greet(greeting, punctuation) {
  console.log(`${greeting}, ${this.name}${punctuation}`);
}

greet.myApply({ name: 'David' }, ['Hello', '.']); // Bonjour, David.

Expliquez brièvement la boucle d'événements JavaScript.

Explication : JavaScript est à thread unique, mais il réalise la concurrence en utilisant une boucle d'événements. La pile d'appels gère le code synchrone. Les API Web gèrent les opérations asynchrones (comme setTimeout, fetch). Lorsqu'une opération asynchrone est terminée, son rappel est placé dans la file d'attente des rappels (ou file d'attente des microtâches pour les Promesses). La boucle d'événements vérifie constamment si la pile d'appels est vide ; si c'est le cas, elle déplace le rappel suivant de la file d'attente vers la pile pour exécution.

console.log('Start');

setTimeout(() => {
  console.log('Timeout Callback'); // Va à la file d'attente des rappels
}, 0);

Promise.resolve().then(() => {
  console.log('Promise Resolved'); // Va à la file d'attente des microtâches
});

console.log('End');

// Ordre de sortie : Start, End, Promise Resolved, Timeout Callback
// (Les microtâches s'exécutent avant les macrotâches/rappels)

Implémenter une fonction de recherche binaire pour un tableau trié.

Explication : La recherche binaire trouve efficacement un élément dans un tableau trié en divisant à plusieurs reprises l'intervalle de recherche en deux. Si la valeur de la clé de recherche est inférieure à l'élément au milieu de l'intervalle, réduisez l'intervalle à la moitié inférieure. Sinon, réduisez-le à la moitié supérieure. Vous faites cela jusqu'à ce que la valeur soit trouvée ou que l'intervalle soit vide.

function binarySearch(sortedArray, key) {
  let start = 0;
  let end = sortedArray.length - 1;

  while (start <= end) {
    let middle = Math.floor((start + end) / 2);

    if (sortedArray[middle] === key) {
      return middle; // Trouvé
    } else if (sortedArray[middle] < key) {
      start = middle + 1; // Rechercher la moitié droite
    } else {
      end = middle - 1; // Rechercher la moitié gauche
    }
  }
  return -1; // Non trouvé
}

console.log(binarySearch([1, 3, 5, 7, 9, 11], 7)); // 3
console.log(binarySearch([1, 3, 5, 7, 9, 11], 2)); // -1

Implémenter l'algorithme de tri fusion.

Explication : Le tri fusion est un algorithme diviser pour régner. Il divise le tableau d'entrée en deux moitiés, s'appelle lui-même pour les deux moitiés, puis fusionne les deux moitiés triées. La fonction de fusion est cruciale ; elle combine deux sous-tableaux triés en un seul tableau trié.

function mergeSort(arr) {
  if (arr.length <= 1) return arr;

  const mid = Math.floor(arr.length / 2);
  const left = mergeSort(arr.slice(0, mid));
  const right = mergeSort(arr.slice(mid));

  return merge(left, right);
}

function merge(left, right) {
  let result = [];
  let leftIndex = 0;
  let rightIndex = 0;

  while (leftIndex < left.length && rightIndex < right.length) {
    if (left[leftIndex] < right[rightIndex]) {
      result.push(left[leftIndex]);
      leftIndex++;
    } else {
      result.push(right[rightIndex]);
      rightIndex++;
    }
  }

  return result.concat(left.slice(leftIndex)).concat(right.slice(rightIndex));
}

console.log(mergeSort([38, 27, 43, 3, 9, 82, 10])); // [3, 9, 10, 27, 38, 43, 82]

Implémenter l'algorithme de tri rapide.

Explication : Le tri rapide est également un algorithme diviser pour régner. Il choisit un élément comme pivot et partitionne le tableau donné autour du pivot choisi. Les éléments plus petits que le pivot vont à gauche, et les éléments plus grands vont à droite. Il trie ensuite récursivement les sous-tableaux.

function quickSort(arr) {
  if (arr.length <= 1) return arr;

  const pivot = arr[arr.length - 1];
  const left = [];
  const right = [];

  for (let i = 0; i < arr.length - 1; i++) {
    if (arr[i] < pivot) {
      left.push(arr[i]);
    } else {
      right.push(arr[i]);
    }
  }

  return [...quickSort(left), pivot, ...quickSort(right)];
}

console.log(quickSort([10, 8, 2, 1, 6, 3, 9, 4, 7, 5])); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Implémenter l'algorithme de tri à bulles.

Explication : Le tri à bulles est un algorithme de tri simple qui parcourt à plusieurs reprises la liste, compare les éléments adjacents et les échange s'ils sont dans le mauvais ordre. Le passage dans la liste est répété jusqu'à ce que la liste soit triée.

function bubbleSort(arr) {
  let n = arr.length;
  let swapped;
  do {
    swapped = false;
    for (let i = 0; i < n - 1; i++) {
      if (arr[i] > arr[i + 1]) {
        [arr[i], arr[i + 1]] = [arr[i + 1], arr[i]]; // Échange
        swapped = true;
      }
    }
    n--; // Optimisation : le dernier élément est déjà en place
  } while (swapped);
  return arr;
}

console.log(bubbleSort([64, 34, 25, 12, 22, 11, 90])); // [11, 12, 22, 25, 34, 64, 90]

Étant donné une chaîne de caractères, trouver la longueur de la plus longue sous-chaîne sans caractères répétés.

Explication : Utiliser la technique de la 'fenêtre glissante'. Maintenir une fenêtre (sous-chaîne) et un ensemble de caractères dans cette fenêtre. Étendre la fenêtre en déplaçant le pointeur droit. Si un caractère répété est trouvé, réduire la fenêtre par la gauche jusqu'à ce que le caractère répété soit supprimé.

function lengthOfLongestSubstring(s) {
  let maxLength = 0;
  let start = 0;
  const charMap = {};

  for (let end = 0; end < s.length; end++) {
    const char = s[end];
    if (charMap[char] >= start) {
        start = charMap[char] + 1;
    }
    charMap[char] = end;
    maxLength = Math.max(maxLength, end - start + 1);
  }
  return maxLength;
}

console.log(lengthOfLongestSubstring('abcabcbb')); // 3 ('abc')
console.log(lengthOfLongestSubstring('bbbbb')); // 1 ('b')
console.log(lengthOfLongestSubstring('pwwkew')); // 3 ('wke')

Implémenter une liste chaînée simple avec les méthodes add et print.

Explication : Une liste chaînée est une structure de données linéaire où les éléments ne sont pas stockés à des emplacements mémoire contigus. Chaque élément (nœud) pointe vers le suivant. Vous avez besoin d'une classe Node et d'une classe LinkedList pour gérer la tête et l'ajout de nouveaux nœuds.

class Node {
  constructor(data, next = null) {
    this.data = data;
    this.next = next;
  }
}

class LinkedList {
  constructor() {
    this.head = null;
  }

  add(data) {
    const newNode = new Node(data);
    if (!this.head) {
      this.head = newNode;
    } else {
      let current = this.head;
      while (current.next) {
        current = current.next;
      }
      current.next = newNode;
    }
  }

  print() {
    let current = this.head;
    let list = '';
    while (current) {
      list += current.data + ' -> ';
      current = current.next;
    }
    console.log(list + 'null');
  }
}

const list = new LinkedList();
list.add(10);
list.add(20);
list.add(30);
list.print(); // 10 -> 20 -> 30 -> null

Implémenter un arbre binaire de recherche avec les méthodes insert et find.

Explication : Un ABR est une structure de données d'arbre binaire basée sur les nœuds qui possède les propriétés suivantes : le sous-arbre gauche d'un nœud ne contient que des nœuds avec des clés inférieures à la clé du nœud. Le sous-arbre droit d'un nœud ne contient que des nœuds avec des clés supérieures à la clé du nœud. Les deux sous-arbres doivent également être des arbres binaires de recherche.

class Node {
  constructor(data) {
    this.data = data;
    this.left = null;
    this.right = null;
  }
}

class BST {
  constructor() {
    this.root = null;
  }

  insert(data) {
    const newNode = new Node(data);
    if (!this.root) {
      this.root = newNode;
      return;
    }
    this._insertNode(this.root, newNode);
  }

  _insertNode(node, newNode) {
    if (newNode.data < node.data) {
      if (!node.left) node.left = newNode;
      else this._insertNode(node.left, newNode);
    } else {
      if (!node.right) node.right = newNode;
      else this._insertNode(node.right, newNode);
    }
  }

  find(data) {
    return this._findNode(this.root, data);
  }

  _findNode(node, data) {
    if (!node) return null;
    if (data < node.data) return this._findNode(node.left, data);
    else if (data > node.data) return this._findNode(node.right, data);
    else return node;
  }
}

const bst = new BST();
bst.insert(10);
bst.insert(5);
bst.insert(15);
bst.insert(7);
console.log(bst.find(7)); // Node { data: 7, left: null, right: null }
console.log(bst.find(12)); // null

Écrire une fonction pour faire pivoter un tableau vers la droite de k étapes.

Explication : Faire pivoter un tableau signifie déplacer ses éléments. Pour une rotation à droite, le dernier élément devient le premier. Répéter cela k fois fonctionne mais est inefficace. Une meilleure façon est d'utiliser la manipulation de tableau ou de calculer les nouvelles positions.

function rotateArray(nums, k) {
  k = k % nums.length; // Gérer les cas où k > longueur
  if (k === 0) return nums;

  const partToMove = nums.splice(nums.length - k);
  nums.unshift(...partToMove);
  return nums;
}

console.log(rotateArray([1, 2, 3, 4, 5, 6, 7], 3)); // [5, 6, 7, 1, 2, 3, 4]

Étant donné deux tableaux, écrire une fonction pour calculer leur intersection (éléments communs aux deux).

Explication : Une bonne approche consiste à convertir un tableau en un Set pour des recherches en temps moyen de O(1). Ensuite, itérer sur le deuxième tableau et vérifier si chaque élément existe dans l'ensemble. Collecter les correspondances.

function intersection(nums1, nums2) {
  const set1 = new Set(nums1);
  const resultSet = new Set();

  for (const num of nums2) {
    if (set1.has(num)) {
      resultSet.add(num);
    }
  }

  return [...resultSet];
}

console.log(intersection([1, 2, 2, 1], [2, 2])); // [2]
console.log(intersection([4, 9, 5], [9, 4, 9, 8, 4])); // [9, 4]

Étant donné un tableau de chaînes de caractères, regrouper les anagrammes ensemble.

Explication : La clé est de trouver une signature unique pour chaque groupe d'anagrammes. Une façon courante est de trier chaque mot alphabétiquement. Les mots qui donnent la même chaîne triée sont des anagrammes. Utiliser une table de hachage où les clés sont des mots triés et les valeurs sont des tableaux de mots originaux.

function groupAnagrams(strs) {
  const map = {};
  for (const str of strs) {
    const sortedStr = str.split('').sort().join('');
    if (!map[sortedStr]) {
      map[sortedStr] = [];
    }
    map[sortedStr].push(str);
  }
  return Object.values(map);
}

console.log(groupAnagrams(['eat', 'tea', 'tan', 'ate', 'nat', 'bat'])); 
// Sortie : [['eat', 'tea', 'ate'], ['tan', 'nat'], ['bat']]

Étant donné un tableau nums, écrire une fonction pour déplacer tous les 0 à la fin de celui-ci tout en maintenant l'ordre relatif des éléments non nuls.

Explication : Utiliser une approche à 'deux pointeurs' ou 'boule de neige'. Un pointeur garde la trace de la position où le prochain élément non nul doit aller. Parcourir le tableau ; si un élément est non nul, placez-le à la position du pointeur et incrémentez le pointeur. Enfin, remplissez le reste avec des zéros.

function moveZeroes(nums) {
  let nonZeroIndex = 0;

  // Déplacer tous les éléments non nuls vers l'avant
  for (let i = 0; i < nums.length; i++) {
    if (nums[i] !== 0) {
      nums[nonZeroIndex] = nums[i];
      nonZeroIndex++;
    }
  }

  // Remplir le reste avec des zéros
  for (let i = nonZeroIndex; i < nums.length; i++) {
    nums[i] = 0;
  }

  return nums;
}

console.log(moveZeroes([0, 1, 0, 3, 12])); // [1, 3, 12, 0, 0]

Étant donné un tableau d'entiers nums, trouver le sous-tableau contigu (contenant au moins un nombre) qui a la plus grande somme et renvoyer sa somme.

Explication : L'algorithme de Kadane est un moyen efficace de résoudre ce problème. Parcourir le tableau en gardant la trace de la somme currentMax se terminant à la position actuelle et de la somme globalMax trouvée jusqu'à présent. Si currentMax devient négatif, réinitialisez-le à 0 (ou plutôt, à l'élément actuel).

function maxSubArray(nums) {
  let globalMax = -Infinity;
  let currentMax = 0;

  for (let i = 0; i < nums.length; i++) {
    currentMax = Math.max(nums[i], currentMax + nums[i]);
    if (currentMax > globalMax) {
      globalMax = currentMax;
    }
  }
  return globalMax;
}

console.log(maxSubArray([-2, 1, -3, 4, -1, 2, 1, -5, 4])); // 6 (de [4, -1, 2, 1])