Wie überprüfe ich, ob eine Zeichenfolge Text aus einem Array von Teilzeichenfolgen in JavaScript enthält?

Ziemlich einfach. In Javascript muss ich überprüfen, ob eine Zeichenfolge Teilzeichenfolgen enthält, die in einem Array enthalten sind.

Es gibt nichts Eingebautes, das das für Sie erledigt. Sie müssen eine Funktion dafür schreiben.

Wenn Sie wissen, dass die Zeichenfolgen keine der Zeichen enthalten, die in regulären Ausdrücken besonders sind, können Sie ein bisschen schummeln, wie folgt:

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

... wodurch ein regulärer Ausdruck erstellt wird, der eine Reihe von Abwechslungen für die gesuchten Teilzeichenfolgen (z. B. one|two) darstellt und prüft, ob Übereinstimmungen für eine der Teilzeichenfolgen vorhanden sind, ob jedoch eine der Teilzeichenfolgen spezielle Zeichen enthält in regulären Ausdrücke ( *, [usw.), dann würden Sie sie zuerst entkommen müssen und du bist besser dran , nur die langweilige Schleife stattdessen tun.

Live-Beispiel:

var substrings = ["one", "two", "three"];
var str;

// Setup
console.log("Substrings: " + substrings.join(","));

// Try it where we expect a match
str = "this has one";
if (new RegExp(substrings.join("|")).test(str)) {
    console.log("Match using '" + str + "'");
} else {
    console.log("No match using '" + str + "'");
}

// Try it where we DON'T expect a match
str = "this doesn't have any";
if (new RegExp(substrings.join("|")).test(str)) {
    console.log("Match using '" + str + "'");
} else {
    console.log("No match using '" + str + "'");
}

In einem Kommentar zur Frage fragt Martin nach der neuen Array.prototype.mapMethode in ECMAScript5. mapist nicht allzu viel Hilfe, aber es someist:

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

Live-Beispiel:

var substrings = ["one", "two", "three"];
var str;

// Setup
console.log("Substrings: " + substrings.join(","));

// Try it where we expect a match
str = "this has one";
if (substrings.some(function(v) { return str.indexOf(v) >= 0; })) {
    console.log("Match using '" + str + "'");
} else {
    console.log("No match using '" + str + "'");
}

// Try it where we DON'T expect a match
str = "this doesn't have any";
if (substrings.some(function(v) { return str.indexOf(v) >= 0; })) {
    console.log("Match using '" + str + "'");
} else {
    console.log("No match using '" + str + "'");
}

Sie haben es nur in ECMAScript5-kompatiblen Implementierungen, obwohl es für Polyfill trivial ist.

Update im Jahr 2020 : Das someBeispiel kann mit einer Pfeilfunktion (ES2015 +) einfacher sein, und Sie verwenden möglicherweise includeseher als indexOf:

if (substrings.some(v => str.includes(v))) {
    // There's at least one
}

Live-Beispiel:

const substrings = ["one", "two", "three"];
let str;

// Setup
console.log("Substrings: " + substrings.join(","));

// Try it where we expect a match
str = "this has one";
if (substrings.some(v => str.includes(v))) {
    console.log("Match using '" + str + "'");
} else {
    console.log("No match using '" + str + "'");
}

// Try it where we DON'T expect a match
str = "this doesn't have any";
if (substrings.some(v => str.includes(v))) {
    console.log("Match using '" + str + "'");
} else {
    console.log("No match using '" + str + "'");
}

Oder sogar darauf werfen bind, obwohl für mich die Pfeilfunktion viel besser lesbar ist:

if (substrings.some(str.includes.bind(str))) {
    // There's at least one
}

Live-Beispiel:

const substrings = ["one", "two", "three"];
let str;

// Setup
console.log("Substrings: " + substrings.join(","));

// Try it where we expect a match
str = "this has one";
if (substrings.some(str.includes.bind(str))) {
    console.log("Match using '" + str + "'");
} else {
    console.log("No match using '" + str + "'");
}

// Try it where we DON'T expect a match
str = "this doesn't have any";
if (substrings.some(str.includes.bind(str))) {
    console.log("Match using '" + str + "'");
} else {
    console.log("No match using '" + str + "'");
}

var yourstring = 'tasty food'; // the string to check against


var substrings = ['foo','bar'],
    length = substrings.length;
while(length--) {
   if (yourstring.indexOf(substrings[length])!=-1) {
       // one of the substrings is in yourstring
   }
}

Einzeilige Lösung

substringsArray.some(substring=>yourBigString.includes(substring))

Gibt true\falseif-Teilzeichenfolge zurückexists\does'nt exist

Benötigt ES6-Unterstützung

function containsAny(str, substrings) {
    for (var i = 0; i != substrings.length; i++) {
       var substring = substrings[i];
       if (str.indexOf(substring) != - 1) {
         return substring;
       }
    }
    return null; 
}

var result = containsAny("defg", ["ab", "cd", "ef"]);
console.log("String was found in substring " + result);

Für Leute, die googeln,

Die solide Antwort sollte sein.

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

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: Wenn die Reihenfolge der Tests keine Rolle spielt, können Sie dies verwenden (mit nur einer Schleifenvariablen):

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]
    }
}

Wenn das Array nicht groß ist, können Sie die Zeichenfolge einfach mit jedem Teilstring einzeln schleifen und überprüfen indexOf(). Alternativ können Sie einen regulären Ausdruck mit Teilzeichenfolgen als Alternativen erstellen, die möglicherweise effizienter sind oder nicht.

Javascript-Funktion zum Durchsuchen eines Arrays von Tags oder Schlüsselwörtern mithilfe einer Suchzeichenfolge oder eines Arrays von Suchzeichenfolgen. (Uses ES5 einige Array - Verfahren und ES6 Pfeil Funktionen )

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

Anwendungsbeispiel:

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

Nicht, dass ich vorschlagen würde, dass Sie gehen und erweitern / ändern String Prototyp , aber Folgendes habe ich getan:

String.prototype.includes ()

String.prototype.includes = function (includes) {
    console.warn("String.prototype.includes() has been modified.");
    return function (searchString, position) {
        if (searchString 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

Ausgehend von der Lösung von TJ Crowder habe ich einen Prototyp erstellt, um dieses Problem zu lösen:

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

substringsArray.every(substring=>yourBigString.indexOf(substring) === -1)

Für volle Unterstützung;)

Die beste Antwort ist hier: Auch hier wird die Groß- und Kleinschreibung nicht berücksichtigt

    var specsFilter = [.....];
    var yourString = "......";

    //if found a match
    if (specsFilter.some((element) => { return new RegExp(element, "ig").test(yourString) })) {
        // do something
    }

Mit underscore.js oder lodash.js können Sie Folgendes für ein Array von Zeichenfolgen tun:

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']

Und an einer einzigen Saite:

var contact = 'Billy';
var filters = ['Bill', 'Sarah'];

_.every(filters, function(filter) { return (contact.indexOf(filter) >= 0); });

// true

Das ist super spät, aber ich bin gerade auf dieses Problem gestoßen. In meinem eigenen Projekt habe ich Folgendes verwendet, um zu überprüfen, ob sich eine Zeichenfolge in einem Array befindet:

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

Auf diese Weise können Sie ein vordefiniertes Array nehmen und prüfen, ob es eine Zeichenfolge enthält:

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

Aufbauend auf der Antwort von TJ Crowder

Verwenden von RegExp mit Escapezeichen, um zu testen, ob mindestens eine der Teilzeichenfolgen "mindestens einmal" vorkommt.

function buildSearch(substrings) {
  return new RegExp(
    substrings
    .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 ...'));

Wenn Sie mit einer langen Liste von Teilzeichenfolgen arbeiten, die aus vollständigen "Wörtern" bestehen, die durch Leerzeichen oder andere gemeinsame Zeichen getrennt sind, können Sie bei Ihrer Suche ein wenig klug sein.

Teilen Sie Ihre Zeichenfolge zuerst in Gruppen von X, dann X + 1, dann X + 2, ... bis zu Y. X und Y sollten die Anzahl der Wörter in Ihrer Teilzeichenfolge mit den wenigsten bzw. den meisten Wörtern sein. Wenn beispielsweise X 1 und Y 4 ist, wird "Alpha Beta Gamma Delta" zu:

"Alpha" "Beta" "Gamma" "Delta"

"Alpha Beta" "Beta Gamma" "Gamma Delta"

"Alpha Beta Gamma" "Beta Gamma Delta"

"Alpha Beta Gamma Delta"

Wenn X 2 und Y 3 wäre, würden Sie die erste und letzte Zeile weglassen.

Jetzt können Sie diese Liste schnell durchsuchen, wenn Sie sie in ein Set (oder eine Map) einfügen, viel schneller als durch einen Zeichenfolgenvergleich.

Der Nachteil ist, dass Sie nicht nach Teilzeichenfolgen wie "ta Gamm" suchen können. Natürlich können Sie dies berücksichtigen, indem Sie nach Zeichen anstatt nach Wörtern aufteilen, aber dann müssen Sie häufig ein umfangreiches Set erstellen, und die dafür aufgewendete Zeit / Speicher überwiegt die Vorteile.

Für volle Unterstützung (zusätzlich zu den Versionen von @ricca ).

wordsArray = ['hello', 'to', 'nice', 'day']
yourString = 'Hello. Today is a nice day'.toLowerCase()
result = wordsArray.every(w => yourString.includes(w))
console.log('result:', result)

Sie können dies überprüfen:

<!DOCTYPE html>
<html>
   <head>
      <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.4.1/jquery.min.js"></script>
      <script>
         $(document).ready(function(){
         var list = ["bad", "words", "include"] 
         var sentence = $("#comments_text").val()

         $.each(list, function( index, value ) {
           if (sentence.indexOf(value) > -1) {
                console.log(value)
            }
         });
         });
      </script>
   </head>
   <body>
      <input id="comments_text" value="This is a bad, with include test"> 
   </body>
</html>

let obj = [{name : 'amit'},{name : 'arti'},{name : 'sumit'}];
let input = 'it';

Filter verwenden:

obj.filter((n)=> n.name.trim().toLowerCase().includes(input.trim().toLowerCase()))