Solutions fréquemment recherchées pour JavaScript

class CampingSpot {
  constructor(name, location) {
    this.name = name;
    this.location = location;
  }
    describeWater() {
      console.log("The water at " + this.name + " is very cold.");
    }
}

Nous pouvons maintenant créer des instances de CampingSpot objet à volonté :

let willowCreek = new CampingSpot("Willow Creek", "Big Sur");
let sunsetStateBeach = new CampingSpot(“Sunset State Beach”, “Santa Cruz”);

6. Utilisation d'API distantes

L'accès aux API hébergées sur des services est un autre besoin courant dans les programmes JavaScript. Les API permettent d'accéder à des données et fonctionnalités externes. Les développeurs recherchent souvent des solutions pour récupérer des données à partir d'API distantes, analyser les réponses et les intégrer dans leurs applications.

Heureusement, JavaScript moderne inclut l'API Fetch dans les environnements client et serveur. Il s'agit d'un moyen simple et direct de passer des appels HTTP. Par exemple, voici comment obtenir la liste des films Star Wars à partir du service SWAPI :

async function getStarWarsFilms() {
  try {
    const response = await fetch('https://swapi.dev/api/films');
    if (!response.ok) {
      throw new Error(`Error fetching Star Wars films: ${response.status}`);
    }
    const data = await response.json();
    console.log(data.results); 
  } catch (error) {
    console.error("Error:", error);
  }
}

getStarWarsFilms();

Comme il s’agit d’une requête GET, nous pouvons simplement utiliser fetch('https://swapi.dev/api/films'). Notez que nous utilisons awaitque j'ai présenté plus tôt. Cela nous permet de faire une pause pendant que la requête est envoyée et que la réponse revient.

Nous utilisons le response objet pour déterminer si la requête était bonne (une réponse HTTP 200), en utilisant response.ok.

7. Manipulation des chaînes

Les chaînes de caractères sont fondamentales et utilisées dans toutes sortes de situations. Considérez la chaîne suivante :

const taoTeChingVerse1 = 
  `The Tao that can be told is not the eternal Tao. 
  The name that can be named is not the eternal name. 
  The nameless is the beginning of heaven and earth. 
  The named is the mother of all things,`;

Disons que nous ne voulions que la première ligne du premier couplet :

const firstLine = taoTeChingVerse1.slice(0, 48);

Cela dit : Donnez-nous la sous-chaîne entre le premier caractère (0) jusqu'au 48e caractère, inclus.

Pour rechercher la première occurrence du mot « Tao », saisissez :

taoTeChingVerse1.indexOf("Tao"); // returns 4

Maintenant, si vous voulez remplacer des mots, vous utilisez une expression régulière simple. Ici, nous remplaçons toutes les occurrences de « told » par « spoken » :

const newText = text.replace(/told/g, "spoken");

Les barres obliques indiquent une expression régulière, que nous faisons correspondre à « told ». Le suffixe g indique « global », c'est-à-dire toutes les occurrences. Le deuxième argument de replace() est le jeton à échanger. (Nous terminons avec « Le Tao qui peut être parlé n’est pas le Tao éternel. »)

Si nous devons concaténer deux chaînes, un simple opérateur plus (+) fera l'affaire :

let fullVerse = taoTeChingVerse1 + “Having both but not using them, Think of them as the constant.”);

Et, vous pouvez toujours compter la longueur de la chaîne avec :

fullVerse.length; // return 261

8. Conversion d'objets JSON en chaînes

Un autre besoin courant est de prendre un objet JSON réel et d'en faire une chaîne, ou vice versa. Voici comment prendre un objet JSON réel et en faire une chaîne :

let website = {
  name: “InfoWorld”,
  url: “www.infoworld.com”
}

let myString = JSON.stringify(website);

Et voici comment prendre la chaîne et la renvoyer à un objet :

JSON.parse(myString);

9. Opérations de date simples

Il y a beaucoup de choses que vous pouvez faire (et devez faire) avec le JavaScript intégré Date objet.

Pour commencer, vous pouvez obtenir la date du jour comme ceci :

const today = new Date();

Et obtenez ses éléments constitutifs comme ceci :

console.log(today.getFullYear());  // Get the year (e.g., 2024)
console.log(today.getMonth());    // Get the month (0-indexed, e.g., 4 for May)
console.log(today.getDate());     // Get the day of the month (e.g., 21)
console.log(today.getHours());    // Get hours (e.g., 13 for 1 PM)
console.log(today.getMinutes());  // Get minutes (e.g., 27)
console.log(today.getSeconds());  // Get seconds (e.g., 46)

Voici comment obtenir sept jours dans le futur :

date.setDate(date.getDate() + 7);

10. Créer, trouver et compter des nombres

JavaScript est aujourd'hui assez bon avec les nombres. Il gère nativement la plupart des nombres et propose une bibliothèque intégrée, Math, pour plus de puissance.

Vous pouvez créer des nombres :

let age = 30;
let pi = 3.14159;
let billion = 1000000000;

Ou convertir à partir d'une chaîne :

let convertedNumber = Number(“42”);

Les opérations normales se comportent de manière évidente :

let addition = pi + 3; // addition now equals 6.14159

Vous pouvez arrondir les nombres rapidement :

Math.ceil(pi); // round to nearest upper integer (4)
Math.floor(pi); // round to lowest int (3)

Trouver le plus grand nombre :

Math.max(100, 5, 10, 73);  // returns 100

Si vous commencez avec un tableau, vous pouvez utiliser l'opérateur de propagation :

let numbers = (100, 5, 10, 73);
Math.max(...numbers); // returns 100

Enfin, voici comment vérifier la régularité :

let isEven = 10 % 2 === 0; // true (checks if remainder is 0)

---