it-swarm.com.de

Wildcard-String-Vergleich in Javascript

Nehmen wir an, ich habe ein Array mit vielen Strings namens "birdBlue", "birdRed" und einige andere Tiere wie "pig1", "pig2").

Jetzt führe ich eine for-Schleife durch, die das Array durchläuft und alle Vögel zurückgeben soll. Welcher Vergleich wäre hier sinnvoll?

Animals == "bird*" war meine erste Idee, funktioniert aber nicht. Gibt es eine Möglichkeit, den Operator * zu verwenden (oder gibt es eine ähnliche Möglichkeit?)

40
xqz313

Ich denke, Sie meinten etwas wie "*" (Stern) als Platzhalter, zum Beispiel:

  • "a * b" => alles was mit "a" beginnt und mit "b" endet
  • "a *" => alles was mit "a" beginnt
  • "* b" => alles was mit "b" endet
  • "* a *" => alles, was ein "a" enthält
  • "* a * b *" => alles, was ein "a" enthält, gefolgt von irgendetwas, gefolgt von einem "b", gefolgt von irgendetwas

oder in deinem Beispiel: "bird *" => alles was mit bird beginnt

Ich hatte ein ähnliches Problem und schrieb eine Funktion mit RegExp:

//Short code
function matchRuleShort(str, rule) {
  var escapeRegex = (str) => str.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, "\\$1");
  return new RegExp("^" + rule.split("*").map(escapeRegex).join(".*") + "$").test(str);
}

//Explanation code
function matchRuleExpl(str, rule) {
  // for this solution to work on any string, no matter what characters it has
  var escapeRegex = (str) => str.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, "\\$1");

  // "."  => Find a single character, except newline or line terminator
  // ".*" => Matches any string that contains zero or more characters
  rule = rule.split("*").map(escapeRegex).join(".*");

  // "^"  => Matches any string with the following at the beginning of it
  // "$"  => Matches any string with that in front at the end of it
  rule = "^" + rule + "$"

  //Create a regular expression object for matching string
  var regex = new RegExp(rule);

  //Returns true if it finds a match, otherwise it returns false
  return regex.test(str);
}

//Examples
alert(
    "1. " + matchRuleShort("bird123", "bird*") + "\n" +
    "2. " + matchRuleShort("123bird", "*bird") + "\n" +
    "3. " + matchRuleShort("123bird123", "*bird*") + "\n" +
    "4. " + matchRuleShort("bird123bird", "bird*bird") + "\n" +
    "5. " + matchRuleShort("123bird123bird123", "*bird*bird*") + "\n" +
    "6. " + matchRuleShort("s[pe]c 3 re$ex 6 cha^rs", "s[pe]c*re$ex*cha^rs") + "\n" +
    "7. " + matchRuleShort("should not match", "should noo*oot match") + "\n"
);

Wenn Sie mehr über die verwendeten Funktionen erfahren möchten:

79
Spen

Sie sollten RegExp verwenden (sie sind fantastisch). Eine einfache Lösung ist:

if( /^bird/.test(animals[i]) ){
    // a bird :D
}
10
Davsket

Sie können die Teilzeichenfolge -Methode von Javascript verwenden. Beispielsweise:

var list = ["bird1", "bird2", "pig1"]

for (var i = 0; i < list.length; i++) {
  if (list[i].substring(0,4) == "bird") {
   console.log(list[i]);
  }
}

Welche Ausgänge:

bird1
bird2

Grundsätzlich überprüfen Sie jedes Element im Array, um festzustellen, ob die ersten vier Buchstaben "Vogel" sind. Dies setzt voraus, dass sich "Vogel" immer an der Spitze der Saite befindet.


Nehmen wir also an, Sie erhalten einen Pfadnamen von einer URL:

Nehmen wir an, Sie sind bei bird1? = Letsfly - Sie könnten diesen Code verwenden, um die URL zu überprüfen:

var listOfUrls = [
                  "bird1?=letsfly",
                  "bird",
                  "pigs?=dontfly",
                 ]

for (var i = 0; i < list.length; i++) {
  if (listOfUrls[i].substring(0,4) === 'bird') {
    // do something
  }
}

Das obige würde das erste URLs zuordnen, aber nicht das dritte (nicht das Schwein). Sie können url.substring(0,4) einfach durch einen regulären Ausdruck oder eine andere Javascript-Methode wie .contains () ersetzen.


Die Verwendung der .contains() -Methode ist möglicherweise etwas sicherer. Sie müssen nicht wissen, auf welchen Teil der URL 'bird' sich befindet. Zum Beispiel:

var url = 'www.example.com/bird?=fly'

if (url.contains('bird')) {
  // this is true
  // do something
}
2
Cody Reichert

Hier ist ein Ausschnitt mit Unterstützung für * und ? Platzhalter

let arr = ["birdBlue", "birdRed", "pig1", "pig2" ];
let wild = 'bird*';

let re = new RegExp('^'+wild.replace(/\*/g,'.*').replace(/\?/g,'.')+'$');
let result = arr.filter( x => re.test(x.toLowerCase()) );

console.log(result);
0
var searchArray = function(arr, str){
    // If there are no items in the array, return an empty array
    if(typeof arr === 'undefined' || arr.length === 0) return [];
    // If the string is empty return all items in the array
    if(typeof str === 'undefined' || str.length === 0) return arr;

    // Create a new array to hold the results.
    var res = [];

    // Check where the start (*) is in the string
    var starIndex = str.indexOf('*');

    // If the star is the first character...
    if(starIndex === 0) {

        // Get the string without the star.
        str = str.substr(1);
        for(var i = 0; i < arr.length; i++) {

            // Check if each item contains an indexOf function, if it doesn't it's not a (standard) string.
            // It doesn't necessarily mean it IS a string either.
            if(!arr[i].indexOf) continue;

            // Check if the string is at the end of each item.
            if(arr[i].indexOf(str) === arr[i].length - str.length) {                    
                // If it is, add the item to the results.
                res.Push(arr[i]);
            }
        }
    }
    // Otherwise, if the star is the last character
    else if(starIndex === str.length - 1) {
        // Get the string without the star.
        str = str.substr(0, str.length - 1);
        for(var i = 0; i < arr.length; i++){
            // Check indexOf function                
            if(!arr[i].indexOf) continue;
            // Check if the string is at the beginning of each item
            if(arr[i].indexOf(str) === 0) {
                // If it is, add the item to the results.
                res.Push(arr[i]);
            }
        }
    }
    // In any other case...
    else {            
        for(var i = 0; i < arr.length; i++){
            // Check indexOf function
            if(!arr[i].indexOf) continue;
            // Check if the string is anywhere in each item
            if(arr[i].indexOf(str) !== -1) {
                // If it is, add the item to the results
                res.Push(arr[i]);
            }
        }
    }

    // Return the results as a new array.
    return res;
}

var birds = ['bird1','somebird','bird5','bird-big','abird-song'];

var res = searchArray(birds, 'bird*');
// Results: bird1, bird5, bird-big
var res = searchArray(birds, '*bird');
// Results: somebird
var res = searchArray(birds, 'bird');
// Results: bird1, somebird, bird5, bird-big, abird-song

Es gibt eine lange Liste von Vorbehalten zu einer solchen Methode und eine lange Liste von „Was-wäre-wenn“, die nicht berücksichtigt werden, von denen einige in anderen Antworten erwähnt werden. Für eine einfache Verwendung der Sternsyntax kann dies jedoch ein guter Ausgangspunkt sein.

Geige

0
James Hay