web-dev-qa-db-fra.com

Comparaison de chaînes génériques en Javascript

Disons que j'ai un tableau avec de nombreuses chaînes appelées "birdBlue", "birdRed" et quelques autres animaux comme "pig1", "pig2").

Maintenant, je lance une boucle for qui traverse le tableau et devrait renvoyer tous les oiseaux. Quelle comparaison aurait du sens ici?

Animals == "bird*" était ma première idée mais ne fonctionne pas. Existe-t-il un moyen d'utiliser l'opérateur * (ou existe-t-il quelque chose de similaire à utiliser?

javascriptstringcomparison
40
xqz313

Je pense que vous avez voulu dire quelque chose comme "*" (étoile) comme un joker, par exemple:

  • "a * b" => tout ce qui commence par "a" et se termine par "b"
  • "a *" => tout ce qui commence par "a"
  • "* b" => tout ce qui finit par "b"
  • "* a *" => tout ce qui a un "a" dedans
  • "* a * b *" => tout ce qui a un "a" dedans, suivi de n'importe quoi, suivi d'un "b", suivi de n'importe quoi

ou dans votre exemple: "bird *" => tout ce qui commence par bird

J'ai eu un problème similaire et écrit une fonction avec 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"
);

Si vous voulez en savoir plus sur les fonctions utilisées:

79
Spen

Vous devriez utiliser RegExp (ils sont géniaux) une solution simple est:

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

Vous pouvez utiliser la méthode sous-chaîne de Javascript. Par exemple:

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

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

Quelles sorties:

bird1
bird2

Fondamentalement, vous vérifiez chaque élément du tableau pour voir si les quatre premières lettres sont "oiseau". Cela suppose que "oiseau" sera toujours à l'avant de la chaîne.

Alors disons que vous obtenez un chemin d'accès depuis une URL:

Disons que votre at bird1? = Letfly - vous pouvez utiliser ce code pour vérifier l'URL:

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

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

Ce qui précède correspondrait à la première URL, mais pas à la troisième (pas au cochon). Vous pouvez facilement échanger url.substring(0,4) avec une regex, ou même une autre méthode javascript telle que .contains ()

L'utilisation de la méthode .contains() pourrait être un peu plus sûre. Vous n'aurez pas besoin de savoir à quelle partie de l'URL se trouve l'oiseau. Par exemple:

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

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

Voici un extrait de code avec support pour * et ? joker

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
Kamil Kiełczewski
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

Il existe une longue liste de réserves sur une méthode telle que celle-ci et une longue liste de solutions hypothétiques non prises en compte, dont certaines sont mentionnées dans d'autres réponses. Mais pour une utilisation simple de la syntaxe en étoile, cela peut constituer un bon point de départ.

violon

0
James Hay