Javascript数组问题

试试这个:

$('#id').click(function() {
    var arr = ['hello','hey'];
    var isExist = false;
    for (i = 0;i < arr[1].length; i++) {
        if(arr[0].toLowerCase().indexOf(arr[1][i].toLowerCase()) >= 0)
            isExist = true;
        else {
            isExist = false;
            break;
        }
    }
    if (isExist)
        alert('true');  // In case of all chars of 2nd present in 1st arr
});

您正在做的是，您正在将第一个元素转换为小写，然后试图在第一个数组中找到第二个元素。您的解决方案将适用于整个第二个元素作为子字符串存在于第一个元素中或两个元素完全相同的情况。例如，它将用于以下示例

['你好','你好']

['你好','字母l ']

['你好','他']

但是当第二个字符串中的字母被第一个字符串洗牌时，它将不起作用。对于以下示例，您的解决方案将失败。

[‘外星人’,‘线’]

("你好","值得信赖")

("你好"、"假日")

如果整个第二个单词不像第一个单词那样存在，你的解决方案将不起作用

让我知道这是否有帮助。如果你需要，我可以提供解决方案。

正如另一个答案正确指出的那样，您的代码不起作用，因为它在第一个字符串中查找第二个字符串，整个字符串中字母的顺序相同。相反，您需要单独查看第二个字符串中的每个字母，并检查它是否在第一个字符串中。

我们将采用"用英语编程，向后走"的策略。整个问题的英文是:

检查的每个字母是否都匹配?

在JavaScript中可以写成

letters_to_check . every(matches)

我们可以将letters_to_check计算为input[1].toLowerCase().split('')。

现在我们要写matches函数，它可以用英文表示为

是否在字符串中找到要检查的字母?

所以我们写

function matches(letter) { return string_to_heck_against.search(letter); }

string_to_check_against当然是input[0]。

整个程序如下:

function mutation(input) {
  // Check if a letter is in the string to be checked against.
  function matches(letter) { return string_to_check_against.search(letter); }
  var string_to_check_against = input[0].toLowerCase();
  var string_to_check         = input[1].toLowerCase();
  var letters_to_check        = string_to_check.split('');
  return letters_to_check . every(matches);
}

如果你在ES6中编程，这可以写成

function mutation([source, target]) {
  return target   .
    toLowerCase() .
    split('')     .
    every(letter => source.toLowerCase().search(letter));
}

根据您的输出，您必须检查数组第二个字符串与数组第一个字符串的所有字符。为此，您必须检查第一个字符串中所有字符是否可用，而不是使用直接字符串。如果我们直接使用字符串，它将查找整个字符串而不是字符。

尝试以下操作:

var arr =  ['Alien', 'line'];
var arr1 = ['hello','hey'];
var arr2 = ['hello','Hello'];
function mutation(arr) {
  var str1 = arr[0].toLowerCase();
  var str2 = arr[1].toLowerCase();
  var o = false;
  for (var i=0;i<str2.length;i++) {
    o = (str1.indexOf(str2[i]) !== -1);
    if (!o) break;
  }
  return o;
}
console.log('first arr : ', mutation(arr));
console.log('second arr :', mutation(arr1));
console.log('third arr :', mutation(arr2));

这是我的工作代码。你可以查一下。其思想是将数组中的两个字符串都转换为小写。然后比较两个字符串。

我从较短的字符串中取出每一个字母，然后使用indexOf函数检查它是否在较长的字符串中。每次有匹配，值no1或no2将增加。

如果no1或no2的值等于短字符串的长度，则表示短字符串中的所有字母都在长字符串中。

function mutation(arr) {
  // transfer both strings in the array to lower case
  var val1 = arr[0].toLowerCase();
  var val2 = arr[1].toLowerCase();
  // check if val2 is shorter than val1
  if(val1.length >= val2.length){
    var no1 = 0;
  // Check every if any letter in val2 is in val1
    for(var i = 0; i < val2.length; i++){
      if(val1.indexOf(val2[i]) != -1){
  // plus 1 if there is a match
        no1++;
      }
    }
    // check if the value of no1 equals to length of val2
    if(no1 == val2.length){
      return true;
    }else{
      return false;
    }
  }else if(val2.length > val1.length){
    var no2 = 0;
    for(var j = 0; j < val1.length; j++){
      if(val2.indexOf(val1[j]) != -1){
        no2++;
      }
    }
    if(no2 == val1.length){
      return true;
    }else{
      return false;
    }
  }        
}