it-swarm.com.de

Wie prü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.

99

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 Sonderzeichen für reguläre Ausdrücke enthalten, können Sie ein bisschen schummeln:

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

... erstellt einen regulären Ausdruck, der eine Reihe von Abänderungen für die gesuchten Teilzeichenfolgen (z. B. one|two) enthält, und prüft, ob Übereinstimmungen vorliegen Für jeden von ihnen, aber wenn einer der Teilstrings Zeichen enthält, die speziell für reguläre Ausdrücke sind (*, [, etc.), müssten Sie sie zuerst entziehen und Sie sind besser dran mache stattdessen einfach die langweilige Schleife.

Kostenloses Live-Beispiel


Update :

In einem Kommentar zur Frage fragt Martin nach der neuen Funktion Array#map in ECMAScript5. map ist nicht viel Hilfe, aber some ist:

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

Live-Beispiel (Funktioniert nur in modernen Browsern)

Wohlgemerkt, es bedeutet etwas Overhead, und Sie haben es nur bei ECMAScript5-kompatiblen Implementierungen (z. B. nicht IE7 oder früher; vielleicht auch nicht IE8), aber trotzdem, wenn Sie wirklich in diesen Programmierstil verliebt sind. (Und Sie könnten ein ECMAScript5-Shim verwenden, dieses oder eines von mehreren anderen.)

162
T.J. Crowder
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
   }
}
46
raveren
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);
18
Jim Blackler

Einzeilige Lösung

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

Gibt true\false zurück, wenn der Teilstring exists\does'nt exist

Braucht ES6-Unterstützung

11
Praveena

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`
}
11
halfcube
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]
    }
}
6
user

Wenn das Array nicht groß ist, können Sie die Zeichenfolge einzeln mit jedem Teilstring mit indexOf() in einer Schleife durchlaufen und prüfen. Alternativ können Sie einen regulären Ausdruck mit Teilstrings als Alternativen erstellen, die möglicherweise effizienter sind.

Javascript-Funktion zum Durchsuchen eines Arrays von Tags oder Schlüsselwörtern mithilfe einer Suchzeichenfolge oder eines Arrays von Suchstrings. (Verwendet ES5 einige - Arraymethode und ES6 Pfeilfunktionen)

// 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;
}

Verwendungsbeispiel:

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

Nicht dass ich vorschlage, dass Sie den Prototyp von String erweitern/modifizieren, aber dies ist, was ich getan habe:

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

1
akinuri

Wenn Sie mit einer langen Liste von Teilzeichenfolgen arbeiten, die aus vollständigen "Wörtern" bestehen, die durch Leerzeichen oder ein anderes gemeinsames Zeichen voneinander getrennt sind, können Sie Ihre Suche etwas cleverer gestalten.

Teilen Sie Ihre Zeichenfolge zunächst in Gruppen von X, dann X + 1, dann X + 2, ... bis Y auf. 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 in dieser Liste schnell suchen, wenn Sie sie in ein Set (oder eine Map) einfügen, viel schneller als durch einen Zeichenfolgenvergleich.

Der Nachteil ist, dass Sie nicht nach Unterzeichenfolgen wie "ta Gamm" suchen können. Natürlich können Sie dies durch Aufteilen nach Zeichen anstelle von Word berücksichtigen, aber dann müssen Sie häufig ein umfangreiches Set erstellen, und die dafür aufgewendete Zeit/der Speicher überwiegt die Vorteile.

0
Emil Norén

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 eine Zeichenfolge in einem Array enthalten ist:

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

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

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

Die beste Antwort ist hier: Dies ist auch case sensitive

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

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

aufbauend auf der Antwort von T.J Crowder

verwenden von Escape-RegExp, um das Auftreten von "mindestens einmal" mindestens einer der Teilzeichenfolgen zu testen.

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 ...'));

0
DhavalW

Mit underscore.js oder lodash.js können Sie Folgendes für ein Array von Strings ausführen:

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 auf einer einzigen Saite:

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

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

// true
0
BuffMcBigHuge

Zeichnung von T.J. Crowders Lösung: Ich habe einen Prototyp erstellt, um dieses Problem zu lösen:

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