在javascript中的几个数组之间传输项目

Question

我有一个相当复杂的问题，我尝试了一切，它的工作不正常。所以这个概念是（我只是复制了它的有趣部分，否则它将会多出几百行）：

该程序是一款纸牌游戏和24张牌（4种不同的颜色，其中一种总是比较强壮， ADU）随机分配给4名玩家（4个阵列）。您放下卡片的表格由“asztal”数组表示。首先，人的牌手将一张牌，然后在计算机应达到顺序：

1. 如果他们有相同的颜色和更高的价值 - 挑选卡
2. 如果他们有相同的颜色和任何价值 - 挑选卡
3. 如果他们没有匹配的颜色，从特殊颜色设置的任何汽车（为简单起见，它的第一张卡片循环会在阵列中找到）
4. 如果他们没有匹配的颜色， ，比数组的第一个元素（player [0]）。

如果你运行我的代码，你会发现它并没有从每个数组中抓取1/1/1卡，但有时候更多。这些卡消失了，并没有进入asztal阵列。我的代码：（https://jsfiddle.net/daxa3pL2/）

function CardA(name,value,adu){ 
    this.name = name; 
    this.value = value; 
}; 
function CardB(name,value,adu){ 
    this.name = name; 
    this.value = value; 
}; 
function CardC(name,value,adu){ 
    this.name = name; 
    this.value = value; 
}; 
function CardD(name,value,adu){ 
    this.name = name; 
    this.value = value; 
}; 
CardA.prototype.adu = false; 
CardB.prototype.adu = false; 
CardC.prototype.adu = false; 
CardD.prototype.adu = false; 
var a9 = new CardA("Tök kilenc",0); 
var a10 = new CardA("Tök tíz",10); 
var aal = new CardA("Tök alsó",2); 
var afel = new CardA("Tök felső",3); 
var akir = new CardA("Tök király",4); 
var aasz = new CardA("Tök ász",11); 
var b9 = new CardB("Levél kilenc",0); 
var b10 = new CardB("Levél tíz",10); 
var bal = new CardB("Levél alsó",2); 
var bfel = new CardB("Levél felső",3); 
var bkir = new CardB("Levél király",4); 
var basz = new CardB("Levél ász",11); 
var c9 = new CardC("Makk kilenc",0); 
var c10 = new CardC("Makk tíz",10); 
var cal = new CardC("Makk alsó",2); 
var cfel = new CardC("Makk felső",3); 
var ckir = new CardC("Makk király",4); 
var casz = new CardC("Makk ász",11); 
var d9 = new CardD("Szív kilenc",0); 
var d10 = new CardD("Szív tíz",10); 
var dal = new CardD("Szív alsó",2); 
var dfel = new CardD("Szív felső",3); 
var dkir = new CardD("Szív király",4); 
var dasz = new CardD("Szív ász",11); 
CardC.prototype.adu = true; 
var player1 = [c9,b9,b10,d9,a9,d10]; 
var player2 = [a10,aal,dal,c10,cal,bal]; 
var player3 = [bfel,bkir,basz,dfel,dkir,dasz]; 
var player4 = [afel,akir,aasz,cfel,ckir,casz]; 
var asztal = []; 
asztal.push(player1.splice(0,1)[0]); 
var player2card1 = function() { 
for (i = 0; i < player2.length; i++) { 
    if (Object.getPrototypeOf(player2[i]) == Object.getPrototypeOf(asztal[0]) && player2[i].value > asztal[0].value) { 
     asztal.push(player2.splice(i,i+1)[0]) 
     return 
    } 
} 
if (asztal.length == 1) { 
for (i = 0; i < player2.length; i++) { 
    if (Object.getPrototypeOf(player2[i]) == Object.getPrototypeOf(asztal[0])) { 
     asztal.push(player2.splice(i,i+1)[0]) 
     return 
    } 
} 
} 
if (asztal.length == 1){ 
    for (i = 0; i < player2.length; i++) { 
    if (player2[i].adu == true) { 
     asztal.push(player2.splice(i,i+1)[0]) 
     return 
    } 
} 
} 
if (asztal.length == 1) { 
    asztal.push(player2.splice(0,1)[0]) 
    return 
} 
     }; 
var player3card1 = function() { 
for (i = 0; i < player3.length; i++) { 
    if (Object.getPrototypeOf(player3[i]) == Object.getPrototypeOf(asztal[0]) && player3[i].value > asztal[0].value) { 
     asztal.push(player3.splice(i,i+1)[0]) 
     return 
    } 
} 
if (asztal.length == 2) { 
for (i = 0; i < player3.length; i++) { 
    if (Object.getPrototypeOf(player3[i]) == Object.getPrototypeOf(asztal[0])) { 
     asztal.push(player3.splice(i,i+1)[0]) 
     return 
    } 
} 
} 
if (asztal.length == 2){ 
    for (i = 0; i < player3.length; i++) { 
    if (player3[i].adu == true) { 
     asztal.push(player3.splice(i,i+1)[0]) 
     return 
    } 
} 
} 
if (asztal.length == 2) { 
    asztal.push(player3.splice(0,1)[0]) 
    return 
} 
     }; 
var player4card1 = function() { 
for (i = 0; i < player4.length; i++) { 
    if (Object.getPrototypeOf(player4[i]) == Object.getPrototypeOf(asztal[0]) && player4[i].value > asztal[0].value) { 
     asztal.push(player4.splice(i,i+1)[0]) 
     return 
    } 
} 
if (asztal.length == 3) { 
for (i = 0; i < player4.length; i++) { 
    if (Object.getPrototypeOf(player4[i]) == Object.getPrototypeOf(asztal[0])) { 
     asztal.push(player4.splice(i,i+1)[0]) 
     return 
    } 
} 
} 
if (asztal.length == 3){ 
    for (i = 0; i < player4.length; i++) { 
    if (player4[i].adu == true) { 
     asztal.push(player4.splice(i,i+1)[0]) 
     return 
    } 
} 
} 
if (asztal.length == 3) { 
    asztal.push(player4.splice(0,1)[0]) 
    return 
} 
     }; 
player2card1(); 
player3card1(); 
player4card1(); 
console.log(player1); 
console.log(player2); 
console.log(player3); 
console.log(player4); 
console.log(asztal); 

Answer 1

所以我调试你的代码，并有我发现了两个根本性的错误：

1：当您使用拼接一个循环内，指数将改变。所以，当你比如

asztal.push(player2.splice(i,i+1)[0]) 

做，把它放在一个循环中，为符合条件player2指数将尽快你做剪接改变。所以你的循环的下一次迭代会给出错误的结果/错过应该删除的对象的索引。

一个可能的解决方案是，代替拼接，在for循环中，只需将元素插入asztal中，并且不要拼接父项。

var player2card1 = function() { 
for (i = 0; i < player2.length; i++) { 
    if (Object.getPrototypeOf(player2[i]) == Object.getPrototypeOf(asztal[0]) && player2[i].value > asztal[0].value) { 
     asztal.push({name: player2[i].name, value: player2[i].value, prototype: player2[i].prototype}); 
     player2[i].name = "delete"; 
     return 
    } 
} 
player2.filter((each)=>{return each.name!== "delete"}); 

2：然后将外循环，从玩家使用过滤功能如下它们接起来的第二个错误（我不认为这里的问题，但仍可能会导致麻烦）为您的使用“==”。在Javascript中，尽量使用'==='，因为它也会检查类型和平等。

Answer 2

稍微重构可以很长的路要清楚。

// define a card type class 
 
function CardType(type, adu) 
 
{ 
 
\t // This simply says that if ADU is undefined (not passed) then 
 
    // ADU should be set to false by default 
 
    this.adu = (typeof adu === 'undefined' ? false : adu); 
 
    this.type = type; 
 
} 
 

 
function Card(name, value, type) 
 
{ 
 
    this.name = name; 
 
    this.value = value; 
 
    this.type = type; 
 
} 
 

 
// Define our card types 
 
var CardA = new CardType("A"); 
 
var CardB = new CardType("B"); 
 
var CardC = new CardType("C", true);// set to be ADU 
 
var CardD = new CardType("D"); 
 

 
// Define our cards 
 
var a9 = new Card("Tök kilenc",0, CardA); 
 
var a10 = new Card("Tök tíz",10, CardA); 
 
var aal = new Card("Tök alsó",2, CardA); 
 
var afel = new Card("Tök felső",3, CardA); 
 
var akir = new Card("Tök király",4, CardA); 
 
var aasz = new Card("Tök ász",11, CardA); 
 
var b9 = new Card("Levél kilenc",0, CardB); 
 
var b10 = new Card("Levél tíz",10, CardB); 
 
var bal = new Card("Levél alsó",2, CardB); 
 
var bfel = new Card("Levél felső",3, CardB); 
 
var bkir = new Card("Levél király",4, CardB); 
 
var basz = new Card("Levél ász",11, CardB); 
 
var c9 = new Card("Makk kilenc",0, CardC); 
 
var c10 = new Card("Makk tíz",10, CardC); 
 
var cal = new Card("Makk alsó",2, CardC); 
 
var cfel = new Card("Makk felső",3, CardC); 
 
var ckir = new Card("Makk király",4, CardC); 
 
var casz = new Card("Makk ász",11, CardC); 
 
var d9 = new Card("Szív kilenc",0, CardD); 
 
var d10 = new Card("Szív tíz",10, CardD); 
 
var dal = new Card("Szív alsó",2, CardD); 
 
var dfel = new Card("Szív felső",3, CardD); 
 
var dkir = new Card("Szív király",4, CardD); 
 
var dasz = new Card("Szív ász",11, CardD); 
 

 
var player1 = [c9,b9,b10,d9,a9,d10]; 
 
var player2 = [a10,aal,dal,c10,cal,bal]; 
 
var player3 = [bfel,bkir,basz,dfel,dkir,dasz]; 
 
var player4 = [afel,akir,aasz,cfel,ckir,casz]; 
 
var asztal = []; 
 

 
// It doesn't really make sense to splice the array because 
 
// you are changing the array. 
 
// asztal.push(player1.splice(0,1)[0]); 
 
// This line can be replaced with a simple: 
 
asztal.push(player1[0]); 
 

 
// This function has lots of redundant code and we can simplify it greatly 
 
// as well as generalize it to work for each player 
 

 
function getNextCard(player, card){ 
 
\t // By default we take the first card unless we find a better one along the way. 
 
    var matchCase2 = null, // same type, any value 
 
     matchCase3 = null, // special set 
 
     matchCase4 = player[0]; // any card 
 
    for(i = 0; i < player.length; i++) 
 
    { 
 
    \t // Check our first case 
 
    \t if(player[i].type.type == card.type.type && 
 
     player[i].value > card.value){ 
 
    \t return player[i]; 
 
    } 
 
    
 
    if(matchCase2 === null && player[i].type.type == card.type.type){ 
 
    \t matchCase2 = player[i]; 
 
    } 
 
    
 
    if(matchCase3 === null && player[i].type.adu === true){ 
 
    \t matchCase3 = player[i]; 
 
    } 
 
    } 
 
    if(matchCase2 !== null) return matchCase2; 
 
    if(matchCase3 !== null) return matchCase3; 
 
    return matchCase4; 
 
} 
 

 
console.log(getNextCard(player2, asztal[0])); 
 
console.log(getNextCard(player3, asztal[0])); 
 
console.log(getNextCard(player4, asztal[0]));