Javascript 如何查找数组中匹配的字符串？

我想从一个数组中获取完整的string元素，该数组不按特定顺序匹配多个子字符串。如果有多个匹配项，则应引发异常

var thisArray = [ '/something_else/', '/and_something_else/', '/and_something_else_here/'];
var thisMatch = [ 'some', 'and', 'here'];

var matchingElement = new RegExp(thisArray , thisMatch); // Not sure about this

---

我想让

matchineElement

在正则表达式执行后包含字符串“和其他东西”如下所示。

与包含所有子字符串的字符串匹配的regexp如下所示：

^(?=.*?string1)(?=.*?string2)(?=.*?string3).*$

所以您只需要将

thisMatch

数组转换为这样一个正则表达式

var regexp = new RegExp('^' + thisMatch.map(function(x) {
    return '(?=.*?' + x + ')';
}).join('') + '.*$');

然后，您可以通过以下方式找到所有匹配项：

var matchingElements = thisArray.filter(function(x) {
    return regexp.test(x);
});

if (matchingElements.length != 1) {
    throw new Error('Single match not found');
} else {
    matchingElement = matchingElements[0];
}

---

匹配包含所有子字符串集的字符串的regexp如下所示：

^(?=.*?string1)(?=.*?string2)(?=.*?string3).*$

所以您只需要将

thisMatch

数组转换为这样一个正则表达式

var regexp = new RegExp('^' + thisMatch.map(function(x) {
    return '(?=.*?' + x + ')';
}).join('') + '.*$');

然后，您可以通过以下方式找到所有匹配项：

var matchingElements = thisArray.filter(function(x) {
    return regexp.test(x);
});

if (matchingElements.length != 1) {
    throw new Error('Single match not found');
} else {
    matchingElement = matchingElements[0];
}

---

匹配包含所有子字符串集的字符串的regexp如下所示：

^(?=.*?string1)(?=.*?string2)(?=.*?string3).*$

所以您只需要将

thisMatch

数组转换为这样一个正则表达式

var regexp = new RegExp('^' + thisMatch.map(function(x) {
    return '(?=.*?' + x + ')';
}).join('') + '.*$');

然后，您可以通过以下方式找到所有匹配项：

var matchingElements = thisArray.filter(function(x) {
    return regexp.test(x);
});

if (matchingElements.length != 1) {
    throw new Error('Single match not found');
} else {
    matchingElement = matchingElements[0];
}

---

匹配包含所有子字符串集的字符串的regexp如下所示：

^(?=.*?string1)(?=.*?string2)(?=.*?string3).*$

所以您只需要将

thisMatch

数组转换为这样一个正则表达式

var regexp = new RegExp('^' + thisMatch.map(function(x) {
    return '(?=.*?' + x + ')';
}).join('') + '.*$');

然后，您可以通过以下方式找到所有匹配项：

var matchingElements = thisArray.filter(function(x) {
    return regexp.test(x);
});

if (matchingElements.length != 1) {
    throw new Error('Single match not found');
} else {
    matchingElement = matchingElements[0];
}

---

在这些数组中，去掉字符串两侧的斜杠。然后使用下面的

arrayMatch

函数，循环索引以获得

thisArray

的结果，如：

function arrayMatch(yourArray, wordMatchArray){
  var ix = [], c = wordMatchArray.length;
  for(var i=0,l=yourArray.length; i<l; i++){
    var m = 0;
    for(var n=0; n<c; n++){
      if(yourArray[i].match(new RegExp(wordMatchArray[n])))m++;
      if(c === m)ix.push(i);
    }
  }
  if(!ix[0]){
    return false;
  }
  return ix;
}
var indexes = arrayMatch(thisArray, thisMatch);
for(var i=0,l=indexes.length; i<l; i++){
  var getMatch = thisArray[indexes[i]];
}

函数数组匹配（yourArray，wordMatchArray）{
var ix=[]，c=wordMatchArray.length；
对于（var i=0，l=yourArray.length；i在这些数组中去掉字符串两侧的斜杠。然后使用下面的
arrayMatch
函数，循环索引以获得
thisArray
的结果，如：

function arrayMatch(yourArray, wordMatchArray){
  var ix = [], c = wordMatchArray.length;
  for(var i=0,l=yourArray.length; i<l; i++){
    var m = 0;
    for(var n=0; n<c; n++){
      if(yourArray[i].match(new RegExp(wordMatchArray[n])))m++;
      if(c === m)ix.push(i);
    }
  }
  if(!ix[0]){
    return false;
  }
  return ix;
}
var indexes = arrayMatch(thisArray, thisMatch);
for(var i=0,l=indexes.length; i<l; i++){
  var getMatch = thisArray[indexes[i]];
}

函数数组匹配（yourArray，wordMatchArray）{
var ix=[]，c=wordMatchArray.length；
对于（var i=0，l=yourArray.length；i在这些数组中去掉字符串两侧的斜杠。然后使用下面的
arrayMatch
函数，循环索引以获得
thisArray
的结果，如：

function arrayMatch(yourArray, wordMatchArray){
  var ix = [], c = wordMatchArray.length;
  for(var i=0,l=yourArray.length; i<l; i++){
    var m = 0;
    for(var n=0; n<c; n++){
      if(yourArray[i].match(new RegExp(wordMatchArray[n])))m++;
      if(c === m)ix.push(i);
    }
  }
  if(!ix[0]){
    return false;
  }
  return ix;
}
var indexes = arrayMatch(thisArray, thisMatch);
for(var i=0,l=indexes.length; i<l; i++){
  var getMatch = thisArray[indexes[i]];
}

函数数组匹配（yourArray，wordMatchArray）{
var ix=[]，c=wordMatchArray.length；
对于（var i=0，l=yourArray.length；i在这些数组中去掉字符串两侧的斜杠。然后使用下面的
arrayMatch
函数，循环索引以获得
thisArray
的结果，如：

function arrayMatch(yourArray, wordMatchArray){
  var ix = [], c = wordMatchArray.length;
  for(var i=0,l=yourArray.length; i<l; i++){
    var m = 0;
    for(var n=0; n<c; n++){
      if(yourArray[i].match(new RegExp(wordMatchArray[n])))m++;
      if(c === m)ix.push(i);
    }
  }
  if(!ix[0]){
    return false;
  }
  return ix;
}
var indexes = arrayMatch(thisArray, thisMatch);
for(var i=0,l=indexes.length; i<l; i++){
  var getMatch = thisArray[indexes[i]];
}

函数数组匹配（yourArray，wordMatchArray）{
var ix=[]，c=wordMatchArray.length；
对于（var i=0，l=yourray.length；i您可以执行以下操作：

var thisArray = [ '/something_else/', '/and_something_else/', '/and_something_else_here/'];
var thisMatch = [ 'some', 'and', 'here'];

function matchElements(arr, arrMatch) {
    var tmpArr;
    arrMatch.forEach(function(el, i, a) {
        tmpArr = arr.filter(function(str) {
            return str.indexOf(el) !== -1;
        });
    });
    if (tmpArr.length > 1) {
        throw ("Hey, too many matches");
    } else {
        return tmpArr[0];   
    }
}

console.log(matchElements(thisArray, thisMatch));

JSFiddle：

说明：

函数遍历包含子字符串的数组中的每个元素，并筛选主数组，只保留匹配的字符串。循环完成后，数组应仅包含匹配所有必需子字符串的字符串。
您可以执行以下操作：

var thisArray = [ '/something_else/', '/and_something_else/', '/and_something_else_here/'];
var thisMatch = [ 'some', 'and', 'here'];

function matchElements(arr, arrMatch) {
    var tmpArr;
    arrMatch.forEach(function(el, i, a) {
        tmpArr = arr.filter(function(str) {
            return str.indexOf(el) !== -1;
        });
    });
    if (tmpArr.length > 1) {
        throw ("Hey, too many matches");
    } else {
        return tmpArr[0];   
    }
}

console.log(matchElements(thisArray, thisMatch));

JSFiddle：

说明：

函数遍历包含子字符串的数组中的每个元素，并筛选主数组，只保留匹配的字符串。循环完成后，数组应仅包含匹配所有必需子字符串的字符串。
您可以执行以下操作：

var thisArray = [ '/something_else/', '/and_something_else/', '/and_something_else_here/'];
var thisMatch = [ 'some', 'and', 'here'];

function matchElements(arr, arrMatch) {
    var tmpArr;
    arrMatch.forEach(function(el, i, a) {
        tmpArr = arr.filter(function(str) {
            return str.indexOf(el) !== -1;
        });
    });
    if (tmpArr.length > 1) {
        throw ("Hey, too many matches");
    } else {
        return tmpArr[0];   
    }
}

console.log(matchElements(thisArray, thisMatch));

JSFiddle：

说明：

函数遍历包含子字符串的数组中的每个元素，并筛选主数组，只保留匹配的字符串。循环完成后，数组应仅包含匹配所有必需子字符串的字符串。
您可以执行以下操作：

var thisArray = [ '/something_else/', '/and_something_else/', '/and_something_else_here/'];
var thisMatch = [ 'some', 'and', 'here'];

function matchElements(arr, arrMatch) {
    var tmpArr;
    arrMatch.forEach(function(el, i, a) {
        tmpArr = arr.filter(function(str) {
            return str.indexOf(el) !== -1;
        });
    });
    if (tmpArr.length > 1) {
        throw ("Hey, too many matches");
    } else {
        return tmpArr[0];   
    }
}

console.log(matchElements(thisArray, thisMatch));

JSFiddle：

说明：

函数遍历包含子字符串的数组中的每个元素，并筛选主数组，只保留匹配的字符串。循环完成后，数组应仅包含匹配所有必需子字符串的字符串。
请重试

var matchingElement = thisArray.filter(function(val, key) {
 var value = val.split(/[^a-z]/).filter(String).join(" ");
 // if `.test()` returns `true` three times at `value`
 return new RegExp(this[0]).test(value) 
        && new RegExp(this[1]).test(value) 
        && new RegExp(this[2]).test(value) 
        ? val
        : null
}.bind(thisMatch))[0].replace(/\//g,"");)


var thisArray=['/something_else/'、'/和_something_else/'、'/和_something_else_here/']；
var thisMatch=['some'，'and'，'here']；
var matchingElement=thisrarray.filter（函数（val，键）{
var value=val.split（/[^a-z]/）.filter（String）.join（“”）；
//if`.test（）`在`value处返回`true`三次`
返回新的RegExp（此[0]）。测试（值）
&&新RegExp（此[1]）。测试（值）
&&新RegExp（此[2]）。测试（值）
？瓦尔
：null
}.bind（thisMatch））[0]。替换（//\//g，”）；
document.write（匹配元素）
尝试


var thisArray=['/something_else/'、'/和_something_else/'、'/和_something_else_here/']；
var thisMatch=['some'，'and'，'here']；
var matchingElement=thisrarray.filter（函数（val，键）{
var value=val.split（/[^a-z]/）.filter（String）.join（“”）；
//if`.test（）`在`value处返回`true`三次`
返回新的RegExp（此[0]）。测试（值）
&&新RegExp（此[1]）。测试（值）
&&新RegExp（此[2]）。测试（值）
？瓦尔
：null
}.bind（thisMatch））[0]。替换（//\//g，”）；
document.write（匹配元素）
尝试


var thisArray=['/something_else/'、'/和_something_else/'、'/和_something_else_here/']；
var thisMatch=['some'，'and'，'here']；
var matchingElement=thisrarray.filter（函数（val，键）{
var value=val.split（/[^a-z]/）.filter（String）.join（“”）；
//if`.test（）`在`value处返回`true`三次`
返回新的RegExp（此[0]）。测试（值）
&&新RegExp（此[1]）。测试（值）
&&新RegExp（此[2]）。测试（值）
？瓦尔
：null
}.bind（thisMatch））[0]。替换（//\//g，”）；
document.write（匹配元素）
尝试


var thisArray=['/something_else/'、'/和_something_else/'、'/和_something_else_here/']；
var thisMatch=['some'，'and'，'here']；
var matchingElement=thisrarray.filter（函数（val，键）{
var value=val.split（/[^a-z]/）.filter（String）.join（“”）；
//if`.test（）`在`value处返回`true`三次`
雷图