1
votes

Comment vérifier si une chaîne contient un MOT en javascript?

Ainsi, vous pouvez facilement vérifier si une chaîne contient une sous-chaîne particulière en utilisant la méthode .includes ().

Je souhaite savoir si une chaîne contient un mot.

Par exemple, si j'applique une recherche sur "on" pour la chaîne, "les téléphones sont bons", elle doit renvoyer false. Et, il devrait renvoyer vrai pour "le garder sur la table".

javascript string split

1 commentaires

Par exemple. laissez simplement un espace blanc de chaque côté du mot , ou utilisez \ bword \ b

9 Réponses :

1
votes

Vous pouvez utiliser .includes () et vérifier le mot. Pour vous assurer qu'il s'agit d'un mot et qu'il ne fait pas partie d'un autre mot, vérifiez que l'endroit où vous l'avez trouvé est suivi d'un espace, d'une virgule, d'un point, etc.

2 commentaires

ou mieux utiliser regex

@Aarif aussi un bon moyen de le faire.

8
votes

Vous devez d'abord le convertir en tableau en utilisant split () puis utiliser includes()

string.split(" ").includes("on")

Il suffit de passer d'espaces "" à split () pour obtenir tous les mots

13 commentaires

Et si les mots sont séparés par une virgule?

Cela ne fonctionnera pas si le mot est suivi d'une virgule

.includes () fonctionne aussi bien sur les chaînes que sur les tableaux, donc .split () n'est pas nécessaire.

@adiga OP n'a pas demandé la séparation de ,

@Scott Marcus oui ça marche sur les cordes mais il veut faire correspondre le mot entier. Et inclut sur la chaîne ne correspond pas au mot entier

Il le fait si la chaîne de recherche a des séparateurs d'espace: string.includes ("on") ou string.includes ("on.") . Comme d'autres l'ont mentionné, RegExp serait le meilleur.

Non, cela posera des problèmes si le on est en dernier ou en début

Voir mon commentaire modifié. Parce que string.split ("") a les mêmes problèmes.

@Scott Marcus Je sais mais je ne voulais pas utiliser regex, j'aimerais connaître ces problèmes, donnez des exemples où cela échouerait.

Cela échouerait si les mots n'étaient pas délimités par des espaces.

@Scott Marcus signifie plus d'un espace?

Non, je veux dire: var theString = "pomme, orange-banane; pamplemousse"

@Scott Marcus mais OP n'a pas demandé que sa chaîne soit séparée par , -;

2
votes

Vous pouvez diviser et essayer de trouver:

const str = 'keep it on the table';
const res =  str.split(/[\s,\?\,\.!]+/).some(f=> f === 'on');
console.log(res);

De plus, certaines méthodes sont très efficaces car elles retournent vrai si un prédicat est vrai.

2 commentaires

et quand c'est le cas!,.,; etc?

@epascarello merci pour ce bon commentaire! J'ai modifié ma réponse.

0
votes

Une version simple pourrait simplement être divisée sur l'espace blanc et regarder dans le tableau résultant pour le mot:

"Phones are good, aren't they? They are. Yes!".split(/[\s,\?\,\.!]+/)

Cela se divise simplement par espace, lorsque vous avez besoin d'analyser le texte (en fonction de votre input), vous rencontrerez plus de délimiteurs de mots que d'espaces. Dans ce cas, vous pouvez utiliser une expression régulière pour rendre compte de ces caractères. Quelque chose comme:

"phones are good".split(" ").find(word => word === "on") // undefined

"keep it on the table".split(" ").find(word => word === "on") // "on"

0 commentaires

-2
votes

J'irais avec les hypothèses suivantes:

Les mots au début d'une phrase ont toujours un espace à la fin.
Les mots à la fin d'une phrase sont toujours précédés d'un espace.
Les mots au milieu d'une phrase sont toujours précédés d'un espace.

Par conséquent, j'écrirais mon code comme suit:

function containsWord(word, sentence) {
    return (
       sentence.startsWith(word.trim() + " ") ||
       sentence.endsWith(" " + word.trim()) ||
       sentence.includes(" " + word.trim() + " "));
}

console.log(containsWord("test", "This is a test of the containsWord function."));

0 commentaires

-2
votes

Utilisez Array.prototype.includes https://developer.mozilla.org/ fr-FR / docs / Web / JavaScript / Reference / Global_Objects / Array / includes

console.log("keep it on the table".toLowerCase().split(" ").includes("on")); // true
console.log("phones are good".toLowerCase().split(" ").includes("on")); // false

Ou vous pouvez utiliser une expression régulière.

2 commentaires

Cela ne fonctionne pas pour les mots au début ou à la fin d'une phrase.

Merci pour le commentaire. Je l'ai édité. Le meilleur moyen sera cependant d'utiliser une expression régulière

-2
votes

Essayez ce qui suit -

var mainString = 'codehandbook'
var substr = /hand/
var found = substr.test(mainString)
if(found){
  console.log('Substring found !!')
} else {
  console.log('Substring not found !!')
}

0 commentaires

3
votes

Ceci s'appelle une regex - expression régulière

Vous pouvez utiliser 101regex lorsque vous devez les contourner (cela aide) . Des mots avec des séparateurs personnalisés également.

const regex = /(^.*\son$)|(^on\s.*)|(^on$)|(^.*\son\s.*$)/i;

console.log(regex.test('phones are good'));
console.log(regex.test('keep it on the table'));
console.log(regex.test('on'));
console.log(regex.test('keep iton the table'));
console.log(regex.test('keep it on'));
console.log(regex.test('on the table'));

Explication :

Je crée ici plusieurs groupes de capture pour chaque possibilité:

(^. * \ son $) on est le dernier mot

(^ on \ s. *) on est le premier mot

(^ on $) on est le seul mot

(^. * \ son \ s. * $) on est un mot intermédiaire p>

\ s signifie un espace ou une nouvelle ligne

function checkWord(word, str) {
  const allowedSeparator = '\\\s,;"\'|';

  const regex = new RegExp(
    `(^.*[${allowedSeparator}]${word}$)|(^${word}[${allowedSeparator}].*)|(^${word}$)|(^.*[${allowedSeparator}]${word}[${allowedSeparator}].*$)`,

    // Case insensitive
    'i',
  );
  
  return regex.test(str);
}

[
  'phones are good',
  'keep it on the table',
  'on',
  'keep iton the table',
  'keep it on',
  'on the table',
  'the,table,is,on,the,desk',
  'the,table,is,on|the,desk',
  'the,table,is|the,desk',
].forEach((x) => {
  console.log(`Check: ${x} : ${checkWord('on', x)}`);
});

0 commentaires

2
votes

Vous pouvez .split () votre chaîne d'espaces ( \ s + ) dans un tableau, puis utiliser .includes () pour vérifier si le tableau de chaînes contient votre mot:

const hasWord = (str, word) => 
  str.replace(/[.,\/#!$%\^&\*;:{}=\-_`~()]/g,"").split(/\s+/).includes(word);
  
console.log(hasWord("phones are good son!", "on"));
console.log(hasWord("keep it on, the table", "on"));

Si vous êtes préoccupé par la ponctuation, vous pouvez d'abord la supprimer en utilisant .replace () (comme indiqué dans cette réponse), puis split () :

const hasWord = (str, word) => 
  str.split(/\s+/).includes(word);
  
console.log(hasWord("phones are good", "on"));
console.log(hasWord("keep it on the table", "on"));

3 commentaires

Cela me semble une bonne réponse. Je ne sais pas pourquoi les gens votent contre cela sans donner leurs 2 cents. Donnez-lui un vote favorable.

@MarciaOng merci :) content de ne pas être le seul à penser que le -1 était injustifié

@NickParsons excellente réponse. Les gens doivent lire et comprendre avant de voter. C'était exactement ce que je cherchais.