Question

我想过滤掉老虎机的模式，在这种情况下，如果它们具有相同的值，我希望选择以下索引。

如果应输出索引0,2和6具有相同的值。我在想像函数调用这样的东西

if (win_filter([0, 2, 6] == "slot-2") {
    console.log("You won");
}

我的代码如下。

var final_score = new Array();

$(".shoot").click(function() {

  //var numbers_array = ["slot-1", "slot-1", "slot-1", "slot-1", "slot-1", "slot-2", "slot-2", "slot-2", "slot-2", "slot-3", "slot-3", "slot-3", "slot-4", "slot-4", "slot-5"];
  var numbers_array = ["slot-1", "slot-2", "slot-3", "slot-4", "slot-5"];
  var target = $("div.window table");

  target.find("tr td > div").each(function() {
    $(this).fadeOut(function() {
      $(this).removeAttr('class');
      $(this).addClass(numbers_array[Math.floor(Math.random() * numbers_array.length)]);
      $(this).fadeIn();
      final_score.push($(this).attr("class"));
    });
  });

  function filterResults(arr) {
    return final_score.filter(function(el) {
      return arr.some(function(e) {
        return el.timeframe == e;
      });
    });
  }

  var result = filterResults(['0','2','6']);
  console.log(result);

  $.each(numbers_array, function(index, value) {
    if (result == value) {
      $(".notice").html("You have won.").addClass("success").show();
      console.log("You won!");
    }
  });
  console.log(final_score);
});

修改

如果不清楚我的意思是数组中的索引，如果我从这个生成的数组中选择索引0,2和6，那么它们的值将是（即使它们不相同）。

0 => "slot-2", 2 => "slot-5", 6 => "slot-1"

目标是检查所选索引是否具有相同的值输出。并且索引的数量不应该是硬编码的，它可以是从3个索引搜索到5个索引搜索的任何内容。

jsFiddle.net

Array[0]
0 : "slot-2"
1 : "slot-3"
2 : "slot-5"
3 : "slot-5"
4 : "slot-4"
5 : "slot-3"
6 : "slot-1"
7 : "slot-4"
8 : "slot-1"
9 : "slot-2"
10 : "slot-2"
11 : "slot-4"
12 : "slot-5"
13 : "slot-1"
14 : "slot-4"

Answer 1

首先，我避免对您的代码进行任何重大修改，因此在jsfiddle中我将验证写入了您期望的位置（在on('click')内）。

我做了什么：

在计算任何内容之前，我们需要插槽数据。您已将其保存在final_score内，但正在执行此操作的功能是回调。是否值得等待回调？ - 我不这么认为，因为它是一个简单的css（fadeOut）动画。

const classVal = numbers_array[Math.floor(Math.random() * numbers_array.length)];
$(this.fadeOut(function() { // Rest of your code }
final_score.push(classVal);

计算每一行的长度，你知道它们都是相等的长度，并且你将所有这些都放在一个数组（final_score）中，所以按行数进行简单的除法就足够了。

const lines = 3;
const lineLength = final_score.length/lines;

对于每一行，我们检查其他行值是否与此行相同。假设您的数组顺序不是基于显示顺序而是基于您生成它们的顺序，我们可以简单地检查具有相同索引的顺序（但迭代每行）。

final_score[i] === final_score[i+lineLength] && final_score[i] === final_score[i+lineLength*2]

导致：

  const lineLength = final_score.length/3;
  for(let i=0; i<lineLength; i++) {
    if (final_score[i] === final_score[i+lineLength] && final_score[i] === final_score[i+lineLength*2]) {
      console.info(`win col ${i}`);
    }
  }

如果您需要，可以轻松n-ify。

  const lineLength = final_score.length/3;
  for(let i=0; i<lineLength; i++) {
    const lineOneSlot = final_score[i];
    let allEqual = true;
    for (let j=1; j<lines; j++) {
        console.info(`Comparing ${i} ${i+lineLength*j}`);
        if (lineOneSlot !== final_score[i+lineLength*j]) {
        allEqual = false;
        break;
      }
    }
    if (allEqual) {
      console.info(`win col ${i}`);
    }
  }

既然您要求进行对角线检查，它看起来像这样：

但是，您必须确保网格是正方形才能获得预期结果。否则，您将不得不重新定义在这些情况下要做的事情。

final_score[i] === final_score[i+1+lineLength] && final_score[i] === final_score[i+line+lineLength*line]

https://jsfiddle.net/qjp7g0qL/3/

Answer 2

阅读您的简历和评论，了解您正在尝试创建一些老虎机，其中中心行用于匹配评估。因此，在代码中更改了几行以完成它。 JS FIDDLE DEMO

注意：对于WINNER状态，我尝试了两种方法 1. CENTER ROW的所有项目都应该相同。
2. CENTER ROW的所有项目都应与PATTERN相同仅供参考：JS中注释了第21行，以便于测试...

/* checks if selected items are matching the winning pattern ... */
function areItemsMatchingWinningPattern(selectedItems, winningItemsPattern) {
  return !!selectedItems && !!winningItemsPattern && (selectedItems.length == winningItemsPattern.length) && selectedItems.every(function (elm, idx) { 
    return elm === winningItemsPattern[idx]; 
  })
}

/* checks if all selected items are same ....  */
function areAllItemsMatching(source) {
  return !!source && source.length > 0 && source.every(function (elm, idx, array) { 
    return idx === 0 || array[idx - 1] == elm; 
  });
}

Answer 3

该方案可以在给定非空任意长度的有效索引列表的情况下检查获胜条件。这是工作JSFiddle。

var win_filter = function(indexes, allValues) {
    // assumes all indexes are valid

    // gather all the values from the slot machine by index.
    var values = [];
    for (var i = 0; i < indexes.length; i++)
        values.push(allValues[indexes[i]]);

    // if every value matches the others, then all values match the first
    if (values.every(function(x) { return x == values[0]; }))
        return values[0];  // return the value that was the same

    // No match found, return null to signify that no winning condition was found.
    return null;
}

$(".shoot").on('click', function() {
    var final_score = [];
    var numbers_array = ["slot-1", "slot-2", "slot-3", "slot-4", "slot-5"];

    // ...

    // Instead of iterating through the possible winning values, if there was any match, it means they won, and winningMatch will contain that matching value. ie 'slot-1'
    var winningMatch = win_filter([0, 2, 6], final_score);
    if (winningMatch) {
        $(".notice").html("You have won.").addClass("success").show();
    }
});

请注意，如果任何可用类名的任何匹配集获胜，那么我们不必遍历可能的获胜案例列表以确定游戏是否赢了，因为任何比赛都不会赢？

Answer 4

你要求比较功能，这里是：

function compareMultiple(sourceArray, indexesArray, compareToValue){ 

    for (let i = 0; i < indexesArray.length; i++){ 

        let index = indexesArray[i]

        if (!sourceArray[index] || sourceArray[index] !== compareToValue) {
            return false
        }
    } 

    return true
}

它接受三个参数：值数组，选择项的索引数组和匹配条件的值。函数返回true / false。你可以这样称呼它：

let isWin = compareMultiple(
    ['slot-1','slot-2','slot-1','slot-3','slot-4', 'slot-2', 'slot-1'], 
    [0, 2, 6], 
    'slot-1'
)

console.log(isWin); // true

Here is an example（我减少了number_array以增加赢得和重写一些代码的机会，仅用于演示）。在这个例子中，我还使用promises等待jquery fadeOut动画完成，我们可以检查新的插槽组合是否胜利（因为你只在final_score上放了新值fadeOut完成异步回调，但在$ .each你的小提琴不能按预期工作后立即检查。

Answer 5

小提琴：https://jsfiddle.net/q3eh0n9f/4/

var options = [
    "slot-2",
    "slot-3",
    "slot-5",
    "slot-5",
    "slot-4",
    "slot-3",
    "slot-1",
    "slot-4",
    "slot-1",
    "slot-2",
    "slot-2",
    "slot-4",
    "slot-5",
    "slot-1",
    "slot-4"
];

// convert selections to usable values and filter unique elements
function buildResults (arr) {
    return arr.map(function (index) {
        return options[index];
    }).filter(function (value, i, arr) {
        return arr.indexOf(value) === i;
    });
}

// if array has been reduced to the length of 1 it is a winner
function checkResults (results) {
    if (results.length === 1) return true;
    if (results.length !== 1) return false;
}

var result = checkResults(buildResults([0, 2, 3]));

console.log(result); // false

按索引和匹配值过滤数组

5 个答案: