Wie durchsuchen Sie ein Array nach einer Teilzeichenfolgenübereinstimmung?

Ich muss ein Array in JavaScript durchsuchen. Die Suche würde nur nach einem Teil der übereinstimmenden Zeichenfolge erfolgen, da die Zeichenfolge zusätzliche Komponenten aufweisen würde. Ich müsste dann das erfolgreich abgeglichene Array-Element mit der vollständigen Zeichenfolge zurückgeben.

Beispiel:

const windowArray = [ "item", "thing", "id-3-text", "class" ];

Ich muss mit nach dem Array-Element suchen "id-" darin und ich muss auch den Rest des Textes in das Element ziehen (dh "id-3-text").

Wie mache ich das?

Wenn Sie verwenden können Unterstrich.js in ihrem projekt, die _.Filter() Die Array-Funktion macht dies zu einem Kinderspiel:

// find all strings in array containing 'thi'
var matches = _.filter(
    [ 'item 1', 'thing', 'id-3-text', 'class' ],
    function( s ) { return s.indexOf( 'thi' ) !== -1; }
);

Die Iteratorfunktion kann tun, was Sie wollen, solange sie für Übereinstimmungen true zurückgibt. Funktioniert super.

Aktualisierung 03.12.2017:

Dies ist jetzt eine ziemlich veraltete Antwort. Vielleicht nicht die leistungsfähigste Option in einem großen Stapel, aber es kann geschrieben werden Menge kürzer und verwenden Sie native ES6-Array/String-Methoden wie .filter() und .includes() jetzt:

// find all strings in array containing 'thi'
const items = ['item 1', 'thing', 'id-3-text', 'class'];
const matches = items.filter(s => s.includes('thi'));

Notiz: Es gibt keine <= IE11-Unterstützung für String.prototype.includes() (Edge funktioniert, wohlgemerkt), aber Sie sind mit einer Polyfill gut, oder greifen Sie einfach darauf zurück indexOf().

Die Leute hier machen das viel zu schwierig. Mach einfach folgendes…

myArray.findIndex(element => element.includes("substring"))

findIndex() ist eine ES6-Methode höherer Ordnung, die die Elemente eines Arrays durchläuft und den Index des ersten Elements zurückgibt, das bestimmten Kriterien entspricht (als Funktion bereitgestellt). In diesem Fall habe ich die ES6-Syntax verwendet, um die Funktion höherer Ordnung zu deklarieren. element ist der Parameter der Funktion (der ein beliebiger Name sein kann) und der fette Pfeil deklariert das Folgende als anonyme Funktion (die nicht in geschweifte Klammern eingeschlossen werden muss, es sei denn, sie nimmt mehr als eine Zeile ein).

Innerhalb findIndex() Ich habe das sehr einfache verwendet includes() -Methode, um zu prüfen, ob das aktuelle Element die gewünschte Teilzeichenfolge enthält.

Der einfachste Weg, das Substrings-Array aus dem gegebenen Array zu erhalten, ist die Verwendung von Filter und Includes:

myArray.filter(element => element.includes("substring"));

Der obige gibt ein Array von Teilstrings zurück.

myArray.find(element => element.includes("substring"));

Das obige gibt das erste Ergebniselement aus dem Array zurück.

myArray.findIndex(element => element.includes("substring"));

Der obige gibt den Index des ersten Ergebniselements aus dem Array zurück.

In Ihrem speziellen Fall können Sie dies einfach mit einem langweiligen alten Zähler tun:

var index, value, result;
for (index = 0; index < windowArray.length; ++index) {
    value = windowArray[index];
    if (value.substring(0, 3) === "id-") {
        // You've found it, the full text is in `value`.
        // So you might grab it and break the loop, although
        // really what you do having found it depends on
        // what you need.
        result = value;
        break;
    }
}

// Use `result` here, it will be `undefined` if not found

Aber wenn Ihr Array ist spärlichkönnen Sie es effizienter mit einem richtig gestalteten tun for..in Schleife:

var key, value, result;
for (key in windowArray) {
    if (windowArray.hasOwnProperty(key) && !isNaN(parseInt(key, 10))) {
        value = windowArray[key];
        if (value.substring(0, 3) === "id-") {
            // You've found it, the full text is in `value`.
            // So you might grab it and break the loop, although
            // really what you do having found it depends on
            // what you need.
            result = value;
            break;
        }
    }
}

// Use `result` here, it will be `undefined` if not found

Vorsicht naiv for..in Schleifen, die das nicht haben hasOwnProperty und !isNaN(parseInt(key, 10)) Schecks; hier ist der Grund.

Off-Topic:

Eine andere Art zu schreiben

var windowArray = new Array ("item","thing","id-3-text","class");

ist

var windowArray = ["item","thing","id-3-text","class"];

… was für Sie weniger Tippen bedeutet und vielleicht (dies ist subjektiv) etwas leichter zu lesen ist. Die beiden Anweisungen haben genau das gleiche Ergebnis: Ein neues Array mit diesem Inhalt.

Suchen Sie einfach nach der Zeichenfolge in Plain Old indexOf

arr.forEach(function(a){
    if (typeof(a) == 'string' && a.indexOf('curl')>-1) {
            console.log(a);
    }        
});

Der einfachste Vanille-Javascript-Code, um dies zu erreichen, ist

var windowArray = ["item", "thing", "id-3-text", "class", "3-id-text"];
var textToFind = "id-";

//if you only want to match id- as prefix 
var matches = windowArray.filter(function(windowValue){
  if(windowValue) {
      return (windowValue.substring(0, textToFind.length) === textToFind);
  }
}); //["id-3-text"]

//if you want to match id- string exists at any position
var matches = windowArray.filter(function(windowValue){
  if(windowValue) {
      return windowValue.indexOf(textToFind) >= 0;
  }
}); //["id-3-text", "3-id-text"]

Eine faszinierende Untersuchung einiger der Alternativen und ihrer Effizienz finden Sie in den letzten Beiträgen von John Resig:

• JavaScript Trie-Leistungsanalyse
• Überarbeitete JavaScript-Wörterbuchsuche

(Das dort diskutierte Problem ist etwas anders, da die Heuhaufen-Elemente Präfixe der Nadel sind und nicht umgekehrt, aber die meisten Lösungen sind einfach anzupassen.)