Mehrere Bedingungen für die JavaScript-Methode .includes ()

Ich frage mich nur, ob es eine Möglichkeit gibt, einer .includes-Methode mehrere Bedingungen hinzuzufügen, zum Beispiel:

    var value = str.includes("hello", "hi", "howdy");

Stellen Sie sich die Kommastaaten "oder" vor.

Es wird jetzt gefragt, ob die Zeichenfolge Hallo, Hallo oder Grüß dich enthält. Also nur wenn eine und nur eine der Bedingungen wahr ist.

Gibt es eine Methode dafür?

Das sollte funktionieren, auch wenn eine und nur eine der Bedingungen erfüllt ist:

var str = "bonjour le monde vive le javascript";
var arr = ['bonjour','europe', 'c++'];

function contains(target, pattern){
    var value = 0;
    pattern.forEach(function(word){
      value = value + target.includes(word);
    });
    return (value === 1)
}

console.log(contains(str, arr));

Sie können die Verwendung .someMethode verwiesen hier .

Die some()Methode testet, ob mindestens ein Element im Array den von der bereitgestellten Funktion implementierten Test besteht .

// test cases
var str1 = 'hi, how do you do?';
var str2 = 'regular string';

// do the test strings contain these terms?
var conditions = ["hello", "hi", "howdy"];

// run the tests against every element in the array
var test1 = conditions.some(el => str1.includes(el));
var test2 = conditions.some(el => str2.includes(el));

// display results
console.log(str1, ' ===> ', test1);
console.log(str2, ' ===> ', test2);

Mit includes(), nein, aber mit REGEX können Sie dasselbe erreichen über test():

var value = /hello|hi|howdy/.test(str);

Oder wenn die Wörter aus einer dynamischen Quelle stammen:

var words = array('hello', 'hi', 'howdy');
var value = new RegExp(words.join('|')).test(str);

Der REGEX-Ansatz ist eine bessere Idee, da Sie die Wörter als tatsächliche Wörter und nicht als Teilzeichenfolgen anderer Wörter abgleichen können . Sie brauchen nur die Wortbegrenzungsmarkierung \b, also:

var str = 'hilly';
var value = str.includes('hi'); //true, even though the word 'hi' isn't found
var value = /\bhi\b/.test(str); //false - 'hi' appears but not as its own word

Sie könnten auch so etwas tun:

const str = "hi, there"

const res = str.includes("hello") || str.includes("hi") || str.includes('howdy');

console.log(res);

Immer wenn eines Ihrer Includes true zurückgibt, ist der Wert true, andernfalls ist er false. Dies funktioniert einwandfrei mit ES6.

Dies kann mithilfe einiger / aller Methoden von Array und RegEx erfolgen.

So überprüfen Sie, ob ALLE Wörter aus der Liste (Array) in der Zeichenfolge vorhanden sind:

const multiSearchAnd = (text, searchWords) => (
  searchWords.every((el) => {
    return text.match(new RegExp(el,"i"))
  })
)

multiSearchAnd("Chelsey Dietrich Engineer 2018-12-11 Hire", ["cle", "hire"]) //returns false
multiSearchAnd("Chelsey Dietrich Engineer 2018-12-11 Hire", ["che", "hire"]) //returns true

So überprüfen Sie, ob in der Zeichenfolge beliebige Wörter aus der Liste (Array) vorhanden sind:

const multiSearchOr = (text, searchWords) => (
  searchWords.some((el) => {
    return text.match(new RegExp(el,"i"))
  })
)

multiSearchOr("Chelsey Dietrich Engineer 2018-12-11 Hire", ["che", "hire"]) //returns true
multiSearchOr("Chelsey Dietrich Engineer 2018-12-11 Hire", ["aaa", "hire"]) //returns true
multiSearchOr("Chelsey Dietrich Engineer 2018-12-11 Hire", ["che", "zzzz"]) //returns true
multiSearchOr("Chelsey Dietrich Engineer 2018-12-11 Hire", ["aaa", "1111"]) //returns false

Nicht die beste Antwort und nicht die sauberste, aber ich denke, es ist freizügiger. Zum Beispiel, wenn Sie für alle Ihre Prüfungen dieselben Filter verwenden möchten. Funktioniert tatsächlich .filter()mit einem Array und gibt ein gefiltertes Array zurück (was ich auch einfacher finde).

var str1 = 'hi, how do you do?';
var str2 = 'regular string';
var conditions = ["hello", "hi", "howdy"];

// Solve the problem
var res1 = [str1].filter(data => data.includes(conditions[0]) || data.includes(conditions[1]) || data.includes(conditions[2]));
var res2 = [str2].filter(data => data.includes(conditions[0]) || data.includes(conditions[1]) || data.includes(conditions[2]));

console.log(res1); // ["hi, how do you do?"]
console.log(res2); // []


// More useful in this case
var text = [str1, str2, "hello world"];

// Apply some filters on data
var res3 = text.filter(data => data.includes(conditions[0]) && data.includes(conditions[2]));
// You may use again the same filters for a different check
var res4 = text.filter(data => data.includes(conditions[0]) || data.includes(conditions[1]));

console.log(res3); // []
console.log(res4); // ["hi, how do you do?", "hello world"]

Hier ist eine kontroverse Option:

String.prototype.includesOneOf = function(arrayOfStrings) {
  if(!Array.isArray(arrayOfStrings)) {
    throw new Error('includesOneOf only accepts an array')
  }
  return arrayOfStrings.some(str => this.includes(str))
}

So können Sie Dinge tun wie:

'Hi, hope you like this option'.toLowerCase().includesOneOf(["hello", "hi", "howdy"]) // True

Noch einer!

let result

const givenStr = 'A, X' //values separated by comma or space.

const allowed  = ['A', 'B']
const given    = givenStr.split(/[\s,]+/).filter(v => v)

console.log('given (array):', given)

// given contains none or only allowed values:

result = given.reduce((acc, val) => {
  return acc && allowed.includes(val)
}, true)

console.log('given contains none or only allowed values:', result)

// given contains at least one allowed value:

result = given.reduce((acc, val) => {
  return acc || allowed.includes(val)
}, false)

console.log('given contains at least one allowed value:', result)

Native Prototyp von String erweitern:

if (!String.prototype.contains) {
    Object.defineProperty(String.prototype, 'contains', {
        value(patterns) {
            if (!Array.isArray(patterns)) {
                return false;
            }

            let value = 0;
            for (let i = 0; i < patterns.length; i++) {
                const pattern = patterns[i];
                value = value + this.includes(pattern);
            }
            return (value === 1);
        }
    });
}

So können Sie Dinge tun wie:

console.log('Hi, hope you like this option'.toLowerCase().contains(["hello", "hi", "howdy"])); // True

Wie wäre es mit ['hello', 'hi', 'howdy'].includes(str)?