Javascript 只读取嵌套 for 循环中的第一个元素（来自数组）

Question

我有以下问题。我有一个问题要解决。

Fruit or Vegetable Write a JS function to print "fruit" , "vegetable" or "unknown" depending on the input string.

Fruits are: banana, apple, kiwi, cherry, lemon, grapes, peach

Vegetable are: tomato, cucumber, pepper, onion, garlic, parsley

All others are unknown

The input comes as array of one string element, the name of the fruit. The output should be printed to the console.

Example: input ['banana'] output: fruit
Example: input ['cucumber'] output: vegetable
Example: input ['pizza'] output: unknown

我也试过类似的东西。

function fruitOrVegetable(inputArr) {
  var fruits = ['banana', 'apple', 'kiwi', 'cherry', 'lemon', 'grapes', 'peach'];
  var vegetables = ['tomato', 'cucumber', 'pepper', 'onion', 'garlic', 'parsley'];

  for (var i = 0; i < inputArr.length; i++) {
    for (var j = 0; j < fruits.length; j++) {
      for (var k = 0; k < vegetables.length; k++) {
        if (inputArr[i] === fruits[j]) {
          return ' fruit ';
        } else if (inputArr[i] === vegetables[k]) {
          return 'vegetable';
        } else {
          return 'unknown';
        }
      }
    }
  }
}

console.log(fruitOrVegetable(['tomato'])); //Returns vegetable
console.log(fruitOrVegetable(['banana'])); //Returns fruit
console.log(fruitOrVegetable(['cucumber'])); //Returns unknown
console.log(fruitOrVegetable(['pizza'])); // Returns unknown
console.log(fruitOrVegetable(['appple'])); //Returns unknown

不知道为什么，但它仅适用于数组的索引 0，例如，对于 'tomato' 它 returns 蔬菜，但如果我尝试对其他蔬菜使用它，它 returns 未知。如果我删除最后一条语句

else{
 return false;
}

然后，黄瓜变成了蔬菜，而苹果却变了？我有点困惑，所以如果有人向我解释为什么会这样，我会很高兴。谢谢。

Answer 1

function fruitOrVegetable(inputArr) {
  var fruits = ['banana', 'apple', 'kiwi', 'cherry', 'lemon', 'grapes', 'peach'];
  var vegetables = ['tomato', 'cucumber', 'pepper', 'onion', 'garlic', 'parsley'];
  
  if(inputArr === undefined || !inputArr.length) return 'unknown';

  if(fruits.indexOf(inputArr[0]) !== -1) return 'fruit';
  if(vegetables.indexOf(inputArr[0]) !== -1) return 'vegetable';
  return 'unknown';
}

console.log(fruitOrVegetable(['banana']));
console.log(fruitOrVegetable(['tomato']));
console.log(fruitOrVegetable(['xxx']));
console.log(fruitOrVegetable([]));
console.log(fruitOrVegetable());

Answer 2

你正在做大量不必要的嵌套 for loop。任务很简单

The input comes as array of one string element, the name of the fruit. The output should be printed to the console.

您只需获取第一个 inputArr 值，即 字符串 并检查它的值是否确实在您的 fruits、vegetables 或者 unknown.

有点像，

function fruitOrVegetable(inputArr) {
    var fruits = ['banana', 'apple', 'kiwi', 'cherry', 'lemon', 'grapes', 'peach'];
    var vegetables = ['tomato', 'cucumber', 'pepper', 'onion', 'garlic', 'parsley'];

    var val = inputArr[0];

    return fruits.indexOf(val) !== -1 ? 'fruit' : vegetables.indexOf(val) !== -1 ? 'vegetables' : 'unknown';
}

编辑：

我们来破解上面的代码，

// This is to grab the string from the first value in `inputArr` and store in `val`.
var val = inputArr[0];

和returning，

¹ fruits.indexOf(val) !== -1 ? 'fruit' :

² vegetables.indexOf(val) !== -1 ? 'vegetables' :

³ 'unknown';

检查val是否存在于fruits中，如果存在则return'fruit'否则运行²
检查val是否存在于vegetables中，如果存在则return'vegetables'否则运行³
Return 'undefined'

这个操作等于，

if (fruits.indexOf(val) !== -1) {
    return 'fruit';
}
else if (vegetables.indexOf(val) !== -1) {
    return 'vegetables';
}
else {
    return 'unknown';
}

更多信息：

?: 是条件（三元）运算符。 (Read more here)。评估 expression

非常方便

例如

var myval = 1;
console.log(myval ? 'true' : 'false'); // true

myval = false;
console.log(myval ? 'true' : 'false'); // false

indexOf是一个数组原生函数，可以查看数组中某个值的索引。 (Read more here)

例如

var myarr = ['test', 'tost', 'aww'];
console.log(myarr.indexOf('tost')); // returns 1
console.log(myarr.indexOf('tosts')); // returns -1 (value not found)

Answer 3

建议：

检查当前物品是否是水果，只有当你确定它不是水果时，才检查它是否是蔬菜。
Return unknown 只有在确认当前物品既不是水果也不是蔬菜后

function fruitOrVegetable(inputArr) {
  var fruits = ['banana', 'apple', 'kiwi', 'cherry', 'lemon', 'grapes', 'peach'];
  var vegetables = ['tomato', 'cucumber', 'pepper', 'onion', 'garlic', 'parsley'];

  var result = [];
  for (var i = 0; i < inputArr.length; i++) {

    var isFruit = false;
    var isVegetable = false;

    for (var j = 0; j < fruits.length; j++) {
      if (inputArr[i] === fruits[j]) {
        result.push('fruit');
        isFruit = true;
        break;
      }
    }

    if (isFruit) {
      // skip rest of the body of the loop as it is a Fruit
      continue;
    }

    for (var j = 0; j < vegetables.length; j++) {
      if (inputArr[i] === vegetables[j]) {
        result.push('vegetable');
        isVegetable = true;
        break;
      }
    }

    if (isVegetable === false) {
      // at this point we know its neither a fruit nor a vegetable
      result.push('unknown');
    }

  }
  return result;
}

console.log(fruitOrVegetable(['tomato', 'banana', 'cucumber', 'pizza', 'apple']));
// [ 'vegetable', 'fruit', 'vegetable', 'unknown', 'fruit' ]

Array#indexOf

的改进

JavaScript 数组有很多内置方法，可以帮助进行基本的排序和搜索。您可以使用 Array.prototype.indexOf 查找数组中元素的索引。如果找不到，它将 return -1。如果我们用这些信息重写，

function fruitOrVegetable(inputArr) {
  var fruits = ['banana', 'apple', 'kiwi', 'cherry', 'lemon', 'grapes', 'peach'];
  var vegetables = ['tomato', 'cucumber', 'pepper', 'onion', 'garlic', 'parsley'];

  var result = [];
  for (var i = 0; i < inputArr.length; i += 1) {
    if (fruits.indexOf(inputArr[i]) !== -1) {
      result.push('fruit');
    } else if (vegetables.indexOf(inputArr[i]) !== -1) {
      result.push('vegetable');
    } else {
      result.push('unknown');
    }
  }
  return result;
}

console.log(fruitOrVegetable(['tomato', 'banana', 'cucumber', 'pizza', 'apple']));
// [ 'vegetable', 'fruit', 'vegetable', 'unknown', 'fruit' ]

Array#indexOf 和 Array#map

的改进

现在，您可以使用函数式编程方法编写相同的代码。您可以使用 Array.prototype.map 将函数应用于 inputArr 的每个元素，就像这样

function fruitOrVegetable(inputArr) {
  var fruits = ['banana', 'apple', 'kiwi', 'cherry', 'lemon', 'grapes', 'peach'];
  var vegetables = ['tomato', 'cucumber', 'pepper', 'onion', 'garlic', 'parsley'];

  return inputArr.map(function(currentItem) {
    if (fruits.indexOf(currentItem) !== -1) {
      return 'fruit';
    } else if (vegetables.indexOf(currentItem) !== -1) {
      return 'vegetable';
    }
    return 'unknown';
  });
}

console.log(fruitOrVegetable(['tomato', 'banana', 'cucumber', 'pizza', 'apple']));
// [ 'vegetable', 'fruit', 'vegetable', 'unknown', 'fruit' ]

Answer 4

简答：你放错地方了return "unknown"。考虑一下：

function fruitOrVegetable(inputArr) {
 var fruits = ['banana', 'apple', 'kiwi', 'cherry', 'lemon', 'grapes', 'peach'];
 var vegetables = ['tomato', 'cucumber', 'pepper', 'onion', 'garlic', 'parsley'];

for (var i = 0; i < inputArr.length; i++) {
  for (var j = 0; j < fruits.length; j++) {
    for (var k = 0; k < vegetables.length; k++) {
      if (inputArr[i] === fruits[j]) {
        return ' fruit ';
      } else if (inputArr[i] === vegetables[k]) {
        return 'vegetable';}
      }
    }
  }
return "unknown";
}

根据评论更新答案

Don't know why , but it works only for the 0 index of the array

原因是您正在循环内部返回值。所以它永远不会跑到尽头。要解决此问题，请将 return "unknown"; 置于循环之外。

总的来说，你已经搞砸了循环，应该简化代码。每当您认为您的代码可以更好，但您不知道该怎么做时，您都可以请求 code review。

最好简化代码，以免混淆。例如你可以这样写：

 function isVegetable(inputArr)
 {
    var vegetables = ['tomato', 'cucumber', 'pepper', 'onion', 'garlic', 'parsley'];        

   for (var i = 0; i < inputArr.length; i++) {
     for (var k = 0; k < vegetables.length; k++) {
        if (inputArr[i] === vegetables[k]) {
          return true;
        }
      }
    }
  return false;
  }


 function isFruit(inputArr)
 {
      var fruits = ['banana', 'apple', 'kiwi', 'cherry', 'lemon', 'grapes', 'peach'];

    for (var i = 0; i < inputArr.length; i++) {
    for (var k = 0; k < fruits.length; k++) {
        if (inputArr[i] === fruits[k]) {
            return true;
            }
        }
     }
    return false;
 }

 function fruitOrVegetable(inputArr)
 {
     if(isVegetable(inputArr)) return "vegetable";  
     if(isFruit(inputArr)) return "fruit";
     return "unknown";
 }

Answer 5

首先，return vegetable 是它只对索引 0 起作用的原因。因为在第一次循环后它 returns 一个值和函数结束。相反，在开始时初始化 outputArray 并将值设置为该数组 outputArray[i] = 'veg' 并在结束时 return outputArray
接下来的事情是不要在彼此之间嵌套太多循环。而是在大 for 循环中分别检查蔬菜或水果：
for() {...} for() {...}
抱歉无法完成代码，因为我正在写我的 phone

Answer 6

您可以尝试这种方式，如果它更适合您：-

function fruitOrVegetable(inputArr) {
  var fruits = ['banana', 'apple', 'kiwi', 'cherry', 'lemon', 'grapes', 'peach'];
  var vegetables = ['tomato', 'cucumber', 'pepper', 'onion', 'garlic', 'parsley'];

  if ( fruits.indexOf( inputArr[0] ) > -1 ){
     return 'fruits';
  }else if ( vegetables.indexOf( inputArr[0] ) > -1 ){
     return 'vegetable';
  }else{
     return 'unknown';
  }
}

Answer 7

像这样修改你的代码，它将工作文件。

函数 fruitOrVegetable(inputArr) {

    var fruits = ['banana' , 'apple' , 'kiwi' , 'cherry' , 'lemon' , 'grapes' , 'peach'];
    var vegetables = ['tomato' , 'cucumber' , 'pepper' , 'onion' , 'garlic' , 'parsley'];

    for(var i = 0 ; i < inputArr.length ; i++)
    {
        for(var j = 0 ; j < fruits.length ; j++)
        {
            if(inputArr[i] === fruits[j]){
                    return ' fruit ';
                    }
        }
        for(var k = 0 ; k < vegetables.length ; k++)
        {

                 if(inputArr[i] === vegetables[k]){
                    return 'vegetable';
                }

        }

    }
                  return 'unknown';
}

结果：

水果或蔬菜(['tomato']); "vegetable" 水果或蔬菜（['banana']）； “水果”

水果或蔬菜(['qwe']); "unknown"

Javascript 只读取嵌套 for 循环中的第一个元素（来自数组）

Javascript reads only first elements(from array) in nested for loops

javascript

arrays

for-loop

statements