Xác định xem chuỗi có ít nhất 2 phần tử giống nhau từ một mảng không

Tôi muốn xác định xem chuỗi có ít nhất 2 phần tử giống nhau từ mảng không

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

Tôi không chắc điều gì sẽ tốt hơn: regex hay hàm? Bất kỳ sẽ tốt thôi.

Tôi đã thử điều này:

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

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

Nhưng nó chỉ phát hiện nếu có ít nhất 1 phần tử từ mảng chứ không phải 2.

Bạn có thể sử dụng Array#somevà String#splitđể làm điều đó:

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

Làm thế nào nó hoạt động?

Hãy chia tay (ý tôi là split()lên)!

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

• Đầu tiên, sử dụng Array#some, kiểm tra rằng ít nhất một phần tử của mảng sẽ vượt qua (nghĩa là ?hoặc! )
• Chia chuỗi bằng char và đếm xem chúng ta có bao nhiêu phần
  • Nếu chúng ta có ncác bộ phận, điều đó có nghĩa là chúng ta có n-1những nơi charphù hợp. (ví dụ: |chia 2 chuỗi thành 3 phần a|b|c:)
• Cuối cùng, kiểm tra xem chúng tôi có 2 dấu phân cách trở lên

Một cách khác là sử dụng một mẫu với một nhóm bắt và một lớp nhân vật được tạo động cho [!?]và phản hồi \1lại những gì được chụp trong nhóm 1 để đảm bảo có 2 nhân vật giống nhau.

([!?]).*\1

Bản demo Regex

Ví dụ

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

Bạn có thể sử dụng chuỗi splitvà mảng lengthnhư:

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;

EDIT : Sử dụng cho vòng lặp

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

Bạn có thể làm theo một giải pháp rất đơn giản như dưới đây. Tách chuỗi bằng ký tự trong mảng. kiểm tra bên trái của hoạt động phân chia. Nếu độ dài tối thiểu là 2, thì trả về true, ngược lại là false.

Dưới đây là một mẫu 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);

Tạo một chức năng có thể hữu ích cho nsố lần xuất hiện để tìm

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)

Sử dụng vòng lặp trên mảng và số lần xuất hiện sau đó kiểm tra xem sự xuất hiện có lớn hơn 1 không.

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

Đây là một cách tiếp cận thủ thuật regex. Chúng ta có thể thử xóa tất cả các ký tự khỏi đầu vào không phải là một phần của lớp ký tự cần tìm. Sau đó, khẳng định rằng có ít nhất hai ký tự riêng biệt còn lại trong đầu vào.

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

Logic ở đây khá đơn giản. Sử dụng đầu vào !hello?làm ví dụ, trước tiên chúng tôi xóa tất cả các ký tự không đánh dấu, để lại cho chúng tôi !?. Sau đó, chúng tôi sử dụng một biểu thức chính quy để khẳng định rằng có ít nhất hai ký tự riêng biệt còn lại. Điều này đúng với đầu vào này, vì vậy chúng tôi inMATCH .

Biên tập:

Để xây dựng luân phiên regex từ mảng đầu vào của bạn, hãy sử dụng join:

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

Có một giải pháp đơn giản hơn nhiều cho việc này:

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

Chúng ta có thể biến nó thành một hàm để kiểm tra:

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

Lưu ý: Mã của tôi đã thay đổi một vài lần và cuối cùng gần với câu trả lời được chấp nhận và tôi đã không nhận ra. Điều đó nói rằng, bạn không cần phải trừ đi bất cứ điều gì, vì vậy phần đó là không cần thiết.