Construire un programme de redressement de mots avec JavaScript (partie 4)

Salut tout le monde ! ?

La dernière fois, je me suis lancé dans une mini-aventure à la recherche de la meilleure API, et après avoir testé plusieurs options, j'ai opté pour Wordnik. Il dispose d'une énorme base de données de mots, et même s'il a fallu une semaine pour obtenir les clés API, je les ai finalement obtenues. Il est maintenant temps de l'intégrer et de vérifier si les mots générés à partir de nos permutations sont réellement valides.

Le défi : valider les mots

Une chose que j'ai réalisé est que la plupart des API de dictionnaire, y compris Wordnik, n'ont pas de moyen direct de vérifier si un mot existe. Ils fournissent des définitions et des exemples mais pas une validation simple.
Pour contourner ce problème, j’ai utilisé le point final du score Scrabble de Wordnik. La logique est simple : si un mot a un score au Scrabble, il est considéré comme valide.

Voici le code pour implémenter cette validation :

async function isValidWord(word) {
    const apiKey = 'API_KEY'; // use your own API keys
    const url = `https://api.wordnik.com/v4/word.json/${word}/scrabbleScore?api_key=${apiKey}`;

    try {
        const response = await fetch(url);

        if (response.status === 200) {
            return true;  // Word is valid
        } else if (response.status === 404) {
            return false; // Word not found in dictionary
        } else {
            console.error(`Error: Received status ${response.status} for word "${word}"`);
            return false; 
        }
    } catch (error) {
        console.error('Error checking word validity:', error);
        return false;
    }
}

async function descrambleWords() {
    const input = document.getElementById('scrambledInput').value;
    const combinations = generatePermutations(input); 
    const validWords = [];

    // Check each word one by one for validity
    for (const word of combinations) {
        const isValid = await isValidWord(word);
        if (isValid) {
            validWords.push(word); // Only push valid words
        }
    }

    const categorizedWords = categorizeByLength(validWords); 
    displayResults(categorizedWords); 
}

Le décomposer

fonction asynchrone isValidWord (mot)

Cette fonction est chargée de vérifier si un mot donné existe dans l'API Wordnik en interrogeant son point final de score Scrabble.

1. Configuration de l'URL :

   • La fonction construit une requête API en utilisant le mot que nous voulons vérifier et l'ajoute à l'URL de base pour le point final du score Scrabble.
   • Exemple : Pour le mot "pomme", l'URL serait : https://api.wordnik.com/v4/word.json/apple/scrabbleScore?api_key=YOUR_API_KEY.

2. Demande API :

   • wait fetch(url) envoie une requête HTTP à l'API Wordnik.
   • Gestion des réponses :
     • 200 (OK) : Si l'API renvoie un statut 200, cela signifie que le mot existe et a un score au Scrabble. Nous traitons cela comme un mot valide et renvoyons vrai.
     • 404 (Not Found) : Si l'API renvoie un 404, le mot n'est pas trouvé dans le dictionnaire, et nous renvoyons false.
     • Tout autre code d'état est enregistré comme une erreur et nous renvoyons false pour indiquer que le mot n'est pas valide ou qu'il y a eu un problème.

fonction asynchrone descrambleWords()

C'est la fonction principale qui déchiffre le mot saisi et valide chaque permutation.

1. Obtenir des commentaires :

   • Il récupère d'abord le mot brouillé dans le champ de saisie en utilisant document.getElementById('scrambledInput').value.

2. Générer des permutations :

   • La fonction appelle generatePermutations(input) pour générer toutes les combinaisons possibles du mot brouillé.

3. Valider chaque mot :

   • Il parcourt ensuite chaque permutation et appelle isValidWord(word) pour vérifier si elle est valide.
   • Si le mot est valide (c'est-à-dire qu'il existe dans l'API Wordnik), il est ajouté au tableau validWords.

Je partagerai le lien en direct dès que j'aurai trouvé un moyen de sécuriser mes clés API avant de les envoyer vers GitHub.

Un autre obstacle était la limite de débit imposée par l'API de Wordnik. Lorsque j'ai dépassé la limite, le processus de validation a rencontré une erreur 429 (trop de demandes), interrompant tout. Une solution potentielle que j’envisage consiste à ajouter un délai lorsque la limite est atteinte pour éviter de surcharger l’API.

Si vous avez de meilleures idées ou suggestions, n'hésitez pas à les partager dans les commentaires ou à me contacter sur Twitter.

Ensuite : Je vais travailler sur l'optimisation des performances, trouver une solution à la limite de débit et m'assurer que l'entrée n'accepte que des chaînes, pas de chiffres.
Restez à l'écoute pour plus de mises à jour !

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!