数组的应用

一、买一赠一

lists:[{name: '苹果', pic: 2,  num: 1},
  { name: '梨子',pic: 3, num: 2,
  {name: '香蕉',pic: 4, num: 1 }]

let total = 0//商品总数
let freeCount = 0//赠送数量
let currentCount = 0//计算当前赠送的数量
let spliceIndex = -1//截取的索引值
let spliceNum=0//对特殊商品的原价的数量
lists.map(function(item){
    total+=item.num
})
freeCount = parseInt(total/2)
for(let i=0;i<lists.length;i++){
    if(currentCount<freeCount){
        currentCount+=lists[i].num
        spliceIndex = i
    }else{
    	spliceNum = currentCount-freeCount
    	break
    }
}
// -- 获取需要更改的对象如果含有特殊商品
if(spliceNum>0)
{
	let item= lists[spliceIndex]
	let newItem = {}
	Object.assign(newItem,item)
	newItem.num = spliceNum
	item.num = item.num-spliceNum
	lists.splice(spliceNum+1,0,newItem)
}

排序（根据单价排序）
1,获取数组里面所有的数量
2.计算数量的一半
3.拿到一半时的索引值
4.判断此索引值的数量是否刚好等于需要总数量的一半
5.移除索引值之前的(如果第4步，不是刚好一半，需添加该索引值下的商品，及计算数量)

二、合并数组中属性相同的项

  this.list = [//需要的进行合并的原数组]; 
  this.totallist = []
 var map = {}
for(var i = 0; i <  this.list.length; i++){
    var ai =  this.list[i];
    if(!map[ai.roomno]&&!map[ai.shopsid]){
        this.totallist.push({
            roomno: ai.roomno,
            shopsid: ai.shopsid,
             data: [ai]
        });
        map[ai.roomno] = ai;
    }else{
        for(var j = 0; j < this.totallist.length; j++){
            var dj = this.totallist[j];
            if(dj.roomno == ai.roomno&&dj.shopsid == ai.shopsid){
                dj.data.push(ai);
				dj.rate+= parseFloat(ai.rate);
				dj.YezhuFeiy+= parseFloat(ai.YezhuFeiy);
				dj.YezhuTich+= parseFloat(ai.YezhuTich);
                break;
            }
        }
    }
}

this.list是一个数组
根据这个数组里面的房间号roomno和shopid不一样进行合并分组

三、合并数组中属性相同的项，另外不同属性的值相加

let lists=[需要合并的数组]
that.lists=[]
for (let i = 0; i < lists.length; i++) {
	for (let j = lists.length - 1; j > i; j--) {
		if (lists[i].ItemNo == lists[j].ItemNo) {   
			lists[i].ItemCount = parseFloat(lists[i].ItemCount) + parseFloat(lists[j].ItemCount);
			that.lists.push(j);
		}
	}
}
that.lists.sort(function(a, b) {
	return b - a; //排序
});
for (let k = 0; k < that.lists.length; k++) {
	lists.splice(that.lists[k], 1);
}
that.lists=lists

1，将数组两次循环，得到相同的项的索引，
2，将索引从大到小排列
3，移除重复的索引项
四、根据数组中的某一个字段去重，数量+1

let lists =[需要处理的数组]
this.list=lists 
for (let i = 0; i < lists.length; i++) {
  	for (let j = lists.length - 1; j > i; j--) {
  		if (lists[i].collection_id == lists[j].collection_id) {   
  			lists[i].num =parseInt(lists[i].num)+1;
  			this.list.splice(j,1);
  		}
  	}
    }```

1,将数组两次循环，得到相同的项的索引，
2,根据某一字段判断,数量+1
3,利用splice将后面的删除

五、类似点单重组数组

var o={
	itemno:'12',
	itemcount:1,
	itemname:'香蕉',
	price:12
}
let sum = -1;
if (this.arry.length > 0) {
	for (var j = 0; j < this.arry.length; j++) {
		if (this.xzdcai[j].itemno == itemno) {
			sum = j;
			break;
		}
	}
}
if (sum != -1){
	for (var i = 0; i < this.arry.length; i++) {
		if (this.arry[i].itemno == itemno) {
			this.arry[i].itemcount=res.value
			break;
		}
	}
}else{
	this.arry.push(o)
}
this.getAllCount=0
this.sumPrice=0
this.arry.forEach((food) => {
	this.getAllCount += parseFloat(food.itemcount) 
	this.sumPrice += parseFloat(food.itemcount)*parseFloat(food.price)
})```

this.arry为重组数组
六、数组去重

1，根据某一个字段
  quchong (arr, val) {
	const res = new Map()
	  return arr.filter((item) => !res.has(item[val]) && res.set(item[val], 1))
 },
this.newarr=this.quchong(arr, "字段名")
2，整个对象相同去重
that.arr= [...new Set(that.arr)]

七、数组拷贝

var a=[]
var b=[{name:'11',age:'11'}]
//第一种:直接赋值
a=b   
//第二种:for循环
for(let i in b){
a.push(b[i])
}    
//第三种:concat方法
a=[].concat(b)
第四种:slice方法
a=b.slice(0)

a[0].age='22'
//此时以上四种方式赋值之后,a数组和b数组都将被改变
//因此以上四种方式只能对不包含引用对象的一维数组进行深拷贝
//使用JSON.stringify和JSON.parse实现深拷贝
方法五:
a=JSON.parse(JSON.stringify(b))
当a的某一项被改变时,b将保持原有数据