Comment vérifier si une chaîne contient du texte d’un tableau de sous-chaînes en JavaScript?

Assez simple. En javascript, je dois vérifier si une chaîne contient des sous-chaînes contenues dans un tableau.

Il n’y a rien de intégré qui fera cela pour vous, vous devrez écrire une fonction pour cela.

Si vous savez que les chaînes ne contiennent aucun des caractères spéciaux des expressions régulières, vous pouvez sortingcher un peu, comme ceci:

 if (new RegExp(subssortingngs.join("|")).test(ssortingng)) { // At least one match } 

… qui crée une expression régulière qui est une série d’ alternations pour les sous-chaînes que vous recherchez (par exemple, one|two ) et teste s’il y a des correspondances pour l’une d’entre elles, mais si l’une des sous-chaînes contient des caractères qui sont spéciales dans les regexes ( * , [ , etc.), vous devriez les échapper en premier et vous feriez mieux de simplement faire la boucle ennuyeuse à la place.

Exemple live gratuit


Mise à jour :

Dans un commentaire sur la question, Martin pose des questions sur la nouvelle fonction Array#map dans ECMAScript5. map n’est pas très utile, mais some sont:

 if (subssortingngs.some(function(v) { return str.indexOf(v) >= 0; })) { // There's at least one } 

Exemple Live (ne fonctionne que sur les navigateurs modernes)

Attention, cela signifie une surcharge, et vous ne l’utilisez que sur les implémentations compatibles ECMAScript5 (donc, pas IE7 ou version antérieure, par exemple, peut-être même pas IE8), mais si vous êtes vraiment dans ce style de programmation. (Et vous pouvez utiliser une cale ECMAScript5, celle-ci ou plusieurs autres.)

 var yourssortingng = 'tasty food'; // the ssortingng to check against var subssortingngs = ['foo','bar'], length = subssortingngs.length; while(length--) { if (yourssortingng.indexOf(subssortingngs[length])!=-1) { // one of the subssortingngs is in yourssortingng } } 
 function containsAny(str, subssortingngs) { for (var i = 0; i != subssortingngs.length; i++) { var subssortingng = subssortingngs[i]; if (str.indexOf(subssortingng) != - 1) { return subssortingng; } } return null; } var result = containsAny("defg", ["ab", "cd", "ef"]); console.log("Ssortingng was found in subssortingng " + result); 

Pour les gens Googling,

La réponse solide devrait être.

 const subssortingngs = ['connect', 'ready']; const str = 'disconnect'; if (subssortingngs.some(v => str === v)) { // Will only return when the `str` is included in the `subssortingngs` } 

Solution en ligne

 subssortingngsArray.some(subssortingng=>yourBigSsortingng.includes(subssortingng)) 

Retourne true\false si la sous-chaîne exists\does'nt exist

Besoin de support ES6

 var str = "texttexttext"; var arr = ["asd", "ghj", "xtte"]; for (var i = 0, len = arr.length; i < len; ++i) { if (str.indexOf(arr[i]) != -1) { // str contains arr[i] } } 

edit: Si l'ordre des tests n'a pas d'importance, vous pouvez l'utiliser (avec une seule variable de boucle):

 var str = "texttexttext"; var arr = ["asd", "ghj", "xtte"]; for (var i = arr.length - 1; i >= 0; --i) { if (str.indexOf(arr[i]) != -1) { // str contains arr[i] } } 

Si le tableau n’est pas volumineux, vous pouvez simplement effectuer une boucle et vérifier chaque chaîne individuellement avec indexOf() . Sinon, vous pouvez construire une expression régulière avec des sous-chaînes comme alternatives, ce qui peut être ou ne pas être plus efficace.

Fonction Javascript pour rechercher un tableau de balises ou de mots-clés en utilisant une chaîne de recherche ou un tableau de chaînes de recherche. (Utilise une méthode de tableau ES5 et des fonctions de flèche ES6 )

 // returns true for 1 or more matches, where 'a' is an array and 'b' is a search ssortingng or an array of multiple search ssortingngs function contains(a, b) { // array matches if (Array.isArray(b)) { return b.some(x => a.indexOf(x) > -1); } // ssortingng match return a.indexOf(b) > -1; } 

Exemple d’utilisation:

 var a = ["a","b","c","d","e"]; var b = ["a","b"]; if ( contains(a, b) ) { // 1 or more matches found } 

En utilisant underscore.js ou lodash.js, vous pouvez effectuer les opérations suivantes sur un tableau de chaînes:

 var contacts = ['Billy Bob', 'John', 'Bill', 'Sarah']; var filters = ['Bill', 'Sarah']; contacts = _.filter(contacts, function(contact) { return _.every(filters, function(filter) { return (contact.indexOf(filter) === -1); }); }); // ['John'] 

Et sur une seule chaîne:

 var contact = 'Billy'; var filters = ['Bill', 'Sarah']; _.every(filters, function(filter) { return (contact.indexOf(filter) >= 0); }); // true 

Ce n’est pas que je propose de prolonger / modifier le prototype de Ssortingng , mais c’est ce que j’ai fait:

Ssortingng.prototype.includes ()

 Ssortingng.prototype.includes = function (includes) { console.warn("Ssortingng.prototype.includes() has been modified."); return function (searchSsortingng, position) { if (searchSsortingng instanceof Array) { for (var i = 0; i < searchString.length; i++) { if (includes.call(this, searchString[i], position)) { return true; } } return false; } else { return includes.call(this, searchString, position); } } }(String.prototype.includes); console.log('"Hello, World!".includes("foo");', "Hello, World!".includes("foo") ); // false console.log('"Hello, World!".includes(",");', "Hello, World!".includes(",") ); // true console.log('"Hello, World!".includes(["foo", ","])', "Hello, World!".includes(["foo", ","]) ); // true console.log('"Hello, World!".includes(["foo", ","], 6)', "Hello, World!".includes(["foo", ","], 6) ); // false 

C’est super tard, mais je me suis juste heurté à ce problème. Dans mon propre projet, j’ai utilisé ce qui suit pour vérifier si une chaîne était dans un tableau:

 ["a","b"].includes('a') // true ["a","b"].includes('b') // true ["a","b"].includes('c') // false 

De cette façon, vous pouvez prendre un tableau prédéfini et vérifier s’il contient une chaîne:

 var parameters = ['a','b'] parameters.includes('a') // true 

s’appuyant sur la réponse de TJ Crowder

utiliser RegExp échappé pour tester l’occurrence “au moins une fois” d’au moins une des sous-chaînes.

 function buildSearch(subssortingngs) { return new RegExp( subssortingngs .map(function (s) {return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');}) .join('{1,}|') + '{1,}' ); } var pattern = buildSearch(['hello','world']); console.log(pattern.test('hello there')); console.log(pattern.test('what a wonderful world')); console.log(pattern.test('my name is ...')); 

À partir de la solution de TJ Crowder, j’ai créé un prototype pour résoudre ce problème:

 Array.prototype.check = function (s) { return this.some((v) => { return s.indexOf(v) >= 0; }); };