Determine si la cadena tiene al menos 2 mismos elementos de una matriz

Quiero determinar si la cadena tiene al menos 2 mismos elementos de la matriz

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

No estoy seguro de qué va a ser mejor: ¿una expresión regular o una función? Cualquiera estaría bien.

Intenté esto:

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

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

Pero solo detecta si hay al menos 1 elementos de la matriz, no 2.

Puedes usar Array#somey String#splitpara hacerlo:

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"))

¿Como funciona?

¡Separemos (quiero decir split()arriba)!

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

• Primero, use Array#some, que prueba que al menos un elemento de la matriz debe pasar (es decir, ?o !)
• Divide la cadena chary cuenta cuántas partes tenemos
  • Si tenemos npartes, significa que tenemos n-1lugares donde charcoinciden. (por ejemplo, 2 |divide una cadena en 3 partes: a|b|c)
• Finalmente, pruebe si tenemos 2 o más delimitadores

Otra forma es utilizar un patrón con un grupo de captura y una dinámica creada clase de caracteres para [!?]y una referencia inversa \1a lo que se captura en el grupo 1 para asegurarse de que hay 2 de la misma caracteres presentes.

([!?]).*\1

Demo de expresiones regulares

Por ejemplo

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)));

Puede usar una cadena splity una matriz lengthcomo:

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;

EDITAR : Uso de for loop

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

Puede seguir una solución muy simple como a continuación. Divida la cadena usando el carácter en la matriz. verifique a la izquierda de la operación de división. Si la longitud es mínima 2, entonces devuelve verdadero, de lo contrario falso.

Aquí hay una muestra de 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);

Cree una función que pueda ser útil para la ncantidad de ocurrencias para encontrar

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)

Use el bucle sobre la matriz y cuente la ocurrencia, luego verifique si la ocurrencia es mayor que 1.

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

Aquí hay un enfoque de truco regex. Podemos intentar eliminar todos los caracteres de la entrada que no sean parte de la clase de caracteres de los caracteres a buscar. Luego, afirme que quedan al menos dos caracteres distintos en la entrada.

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

La lógica aquí es bastante sencilla. Usando la entrada !hello?como ejemplo, primero eliminamos todos los caracteres que no son marcadores, dejándonos con !?. Luego, usamos una expresión regular para afirmar que quedan al menos dos caracteres distintos. Esto es cierto para esta entrada, así que imprimimos MATCH.

Editar:

Para construir la alternancia regex desde su matriz de entrada use join:

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

Hay una solución mucho más simple para esto:

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

Podemos convertirlo en una función para probar:

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

Nota: Mi código cambió algunas veces y al final estuvo cerca de la respuesta aceptada y no me di cuenta. Dicho esto, no es necesario restar nada, por lo que esa parte es innecesaria.