Bestimmen Sie, ob die Zeichenfolge mindestens zwei gleiche Elemente aus einem Array enthält

Ich möchte feststellen, ob der String mindestens zwei gleiche Elemente aus dem Array enthält

const array = ["!", "?"];

const string1 = "!hello"; // should return false
const string2 = "!hello?"; // should return false
const string3 = "!hello!"; // should return true
const string4 = "hello ??"; // should return true
const string5 = "hello ?test? foo"; // should return true
const string6 = "hello ?test ?? foo"; // should return true

Ich bin mir nicht sicher, was besser sein wird: ein Regex oder eine Funktion? Jeder wäre in Ordnung.

Ich habe es versucht:

const array = ["!", "?"];
const string = "test!";

array.every(ar => !string.includes(ar));

Es wird jedoch nur erkannt, ob mindestens 1 Element aus dem Array vorhanden ist, nicht 2.

Sie können es verwenden Array#someund String#splittun:

const check=(array,string)=>array.some(char=>(string.split(char).length-1)>=2)

const array = ["!", "?"];

console.log(check(array,"!hello"))
console.log(check(array,"!hello?"))
console.log(check(array,"!hello!"))
console.log(check(array,"hello ??"))
console.log(check(array,"hello ?test? foo"))
console.log(check(array, "hello ?test ?? foo"))

Wie funktioniert es?

Lass uns trennen (ich meine auf split())!

const check=(array,string)=>
  array.some(char=>
    (
      string.split(char)
      .length-1
    )>=2
  )

• Verwenden Sie zunächst Array#some, um zu testen, ob mindestens ein Element des Arrays bestanden werden soll (dh entweder ?oder !).
• charTeilen Sie die Zeichenfolge auf und zählen Sie, wie viele Teile wir haben
  • Wenn wir nTeile haben, bedeutet dies, dass wir n-1Orte haben, an denen die charÜbereinstimmungen stattfinden. (zB 2 - |Splits eine Zeichenkette in 3 Teile: a|b|c)
• Testen Sie abschließend, ob wir zwei oder mehr Trennzeichen haben

Eine andere Möglichkeit besteht darin, ein Muster mit einer Erfassungsgruppe und einer dynamisch erstellten Zeichenklasse für [!?]und eine Rückreferenz \1auf das zu verwenden, was in Gruppe 1 erfasst wird, um sicherzustellen, dass 2 der gleichen Zeichen vorhanden sind.

([!?]).*\1

Regex-Demo

Zum Beispiel

const array = ["!", "?"];
const regex = new RegExp("([" + array.join(("")) + "]).*\\1");
[
  "!hello",
  "!hello?",
  "!hello!",
  "hello ??",
  "hello ?test? foo",
  "hello ?test ?? foo"
].forEach(str => console.log(str + ": " + regex.test(str)));

Sie können Zeichenfolgen splitund Arrays lengthwie folgt verwenden :

const array = ["!", "?"];
const string6 = "hello ?test ?? foo"; 
var len1 = string6.split(array[0]).length;
var len2 = string6.split(array[1]).length;

if (len>2)||(len2>2)
 return true;

BEARBEITEN : Verwenden der for-Schleife

for (let i=0;i<array.length;i++){
 var len = string6.split(array[i]).length;
 if (len>2)
  return true;
}
return false;

Sie können einer sehr einfachen Lösung wie unten folgen. Teilen Sie die Zeichenfolge mit dem Zeichen im Array. Überprüfen Sie die linke Seite des Split-Vorgangs. Wenn die Länge mindestens 2 beträgt, geben Sie true zurück, andernfalls false.

Hier ist ein Beispiel für jsFiddle: https://jsfiddle.net/sagarag05/qk8f2Lz7/

const array = ["!", "?"];
var str = "How are you!! doing !today?";

function isFound(arr, str){
  var isPresent = false;
  for(var i=0; i < arr.length; i++){
      var res = str.split(arr[i]);
      if(res.length-1 >= 2){
          isPresent = true;
          break;
      }
  }
  return isPresent;
}
isFound(array, str);

Erstellen Sie eine Funktion, die für die nAnzahl der zu findenden Vorkommen nützlich sein kann

const arrayData = ["!", "?"];
const strData = "test!";

function checkElements(arr, str, occNum) {
   var ctr = 0;
   arr.forEach(function (elem) { if(str.includes(elem)) ctr++});

   return ctr >= occNum
}

checkElements(arrayData, strData, 2)

Verwenden Sie Loop-over-Array und zählen Sie das Auftreten und prüfen Sie, ob das Auftreten größer als 1 ist.

function has2(string1, array)
{
    for(let i=0;i<array.length;i++)
    {
        if (string1.split('').reduce(function(n, val) {
                return n + (val === array[i]);
            }, 0) > 1) 
        {
                return true;
        }
    }
    return false;
}

console.log(has2("!hello!", ["!", "?"])); // true
console.log(has2("!hello?", ["!", "?"])); // false

Hier ist ein Regex-Trick-Ansatz. Wir können versuchen, alle Zeichen aus der Eingabe zu entfernen, die nicht Teil der zu findenden Zeichenklasse sind. Stellen Sie dann sicher, dass mindestens zwei verschiedene Zeichen in der Eingabe verbleiben.

var input = "!hello?";
input = input.replace(/[^!?]+/g, "");
if (/(.).*(?!\1)./.test(input)) {
    console.log("MATCH");
}
else {
    console.log("NO MATCH");
}

Die Logik hier ist ziemlich einfach. Am Beispiel der Eingabe !hello?entfernen wir zuerst alle Nicht-Markierungszeichen und lassen uns mit !?. Dann verwenden wir einen regulären Ausdruck, um zu behaupten, dass noch mindestens zwei verschiedene Zeichen übrig sind. Dies gilt für diese Eingabe, daher drucken wir MATCH.

Bearbeiten:

Verwenden Sie Folgendes, um die Regex-Abwechslung aus Ihrem Eingabearray zu erstellen join:

const array = ["!", "?"];
var regex = "[^" + array.join("") + "]+";

Hierfür gibt es eine viel einfachere Lösung:

var a = ["!", "?"], s = "!hello!";
a.some(v=>s.split(v).length>2) // (returns true if multiples are found)

Wir können daraus eine Funktion zum Testen machen:

const a = ["!", "?"];
function Test(s) { return a.some(v => s.split(v).length > 2) }
const string1 = "!hello"; // should return false
const string2 = "!hello?"; // should return false
const string3 = "!hello!"; // should return true
const string4 = "hello ??"; // should return true
const string5 = "hello ?test? foo"; // should return true
const string6 = "hello ?test ?? foo"; // should return true

console.log(Test(string1), Test(string2), Test(string3), Test(string4), 
  Test(string5), Test(string6));

> false false true true true true

Hinweis: Mein Code hat sich einige Male geändert und war am Ende nahe an der akzeptierten Antwort und ich habe es nicht bemerkt. Das heißt, Sie müssen nichts subtrahieren, so dass dieser Teil unnötig ist.