indexof去重,JS 中常见的几种去重方法

indexof去重,JS 中常见的几种去重方法详细介绍

本文目录一览： 实例详解javascript数组去重的几种思路

数据去重的需求实际上像是lodash这些工具库已经有成熟完备的实现，并且可以成熟地运用于生产环境。但是这并不妨碍我们从思维拓展的角度出发，看看去重可以用几种思路去实现。本文主要和大家分享javascript数组去重的几种思路。首先是常规的双层循环比对的思路实现function doubleLoopUniq(arr) { let result = []; for (let i = 0, len = arr.length, isExist; i < len; i++) { // 定义一个变量表示当前元素在 result 中是否存在。 isExist = false; for (let j = 0, rLen = result.length; j < rLen; j++) { if (result[j] === arr[i]) { // 依次对result 中的元素 和 原数组元素进行比对。 isExist = true; break; } } // 最后判断如果不存在，则将此元素插入result !isExist && result.push(arr[i]); } return result;}借助 js内置的indexOf 进行去重function indexOfUniq(arr) { let result = []; for (let i = 0, len = arr.length; i < len; i++) { // 用indexOf 简化了二层循环的流程 if (result.indexOf(arr[i]) === -1) result.push(arr[i]); } return result;}排序后前后比对去重function sortUniq(arr) { let result = [], last; // 这里解构是为了不对原数组产生副作用 [ ...arr ].sort().forEach(item => { if (item != last) { result.push(item); last = item; } }); return result;}通过hashTable去重function hashUniq(arr) { let hashTable = arr.reduce((result, curr, index, array) => { result[curr] = true; return result; }, {}) return Object.keys(hashTable).map(item => parseInt(item, 10));}ES6 SET一行代码实现去重function toSetUniq(arr) { return Array.from(new Set(arr));}splice 去重（直接操作数组本身，带副作用）function inPlaceUniq(arr) { let idx = 0; while (idx < arr.length) { let compare = idx + 1; while (compare < arr.length) { if (arr[idx] == arr[compare]) { arr.splice(compare, 1); continue; } ++compare } ++idx; } return arr;}最后在nodejs下面简单跑个测试，看看哪个效率高~let data = [];for (var i = 0; i < 100000; i++) { data.push(Math.random())}// 实现一个性能测试的装饰器function performanceTest(fn, descript) { var a = new Date().getTime(); return function () { fn.apply(this, [].slice.call(arguments, 0)); console.log(descript, new Date().getTime() - a) }}performanceTest(hashUniq, "hashTable")(data)performanceTest(sortUniq, "sortUniq")(data)performanceTest(toSetUniq, "toSetUniq")(data)performanceTest(indexOfUniq, "indexOfUniq")(data)performanceTest(doubleLoopUniq, "doubleLoopUniq")(data)performanceTest(inPlaceUniq, "inPlaceUniq")(data)结果如下hashTable 168mssortUniq 332mstoSetUniq 80msindexOfUniq 4280msdoubleLoopUniq 13303msinPlaceUniq 9977ms延伸思考： 如果数组内的元素是对象该怎么去重呢？既然是引用类型，那么不免会使用到deepEqual，固然这种思路可以解答这道问题，但难免不够高效。从上面的测试中也可见通过new Set 和 hashTable 去重是最高效的。所以毫无疑问，我们要基于这两种方式去改造，我想用的是hashTable，另一方面，为了降低深度比较带来的耗时，我尝试用JSON.stringify 将引用类型转化为基本类型。function collectionUniq(collection) { let hashTable = {}; collection.forEach(item => { hashTable[JSON.stringify(item)] = true; }) return Object.keys(hashTable).map(item => JSON.parse(item))}那么问题来了，我们都知道对象的属性是无序的，假如数据是这种情况，那就GG了。let collection = [ { a: 1, b: 2, c: 3 }, { b: 2, c: 3, a: 1 } ]有一种toHash的思路，在对这个数组进行一次基本的去重之后，为了保证准确，先遍历JSON 字符串 =>通过 charCodeAt()拿到每个字符串 的 unicode 编码 =>相加得到一个总数，最后再两两进行比较，数值相等的就是重复的，这样就达到去重的效果了。function toHash(obj) { let power = 1; let res = 0; const string = JSON.stringify(obj, null, 2); for (let i = 0, l = string.length; i < l; i++) { switch (string[i]) { case '{': power *= 2 break case '}': power /= 2 break case ' ': case '\n': case '\r': case '\t': break default: res += string[i].charCodeAt(0) * power } } return res}这只是一个实现基本的思路，有很大的改进空间，为了减少hash碰撞的可能，可以对一些特殊字符进行权重的增减。重点是保证碰撞的几率小到比中大奖还小就可以了。相关推荐：JavaScript数组去重的几种方法分享PHP实现数组去重的方法代码JS简单实现数组去重的方法分析

js中数组去重方法总结

1.es6有了Set，可以通过成员唯一性去重

2.使用数组对象的lastIndexOf()方法。
(关于lastIndexOf():( https://www.jianshu.com/p/d75886bc6c75 )

3.定义新数组，存入原数组第一个元素，再将原数组元素和新数组元素比较，不同的继续push到新数组。

4.splice()方法从数组中添加/删除重复值。

5.使用includes()方法{ps:可搭配foreach()方法||filter()方法;}。

6.采用indexOf()获取索引查询去重

7.利用对象属性存在与否判断，这个方法没什么意思，但是也可行

JS删除数组重复元素有哪些方法

这次给大家带来JS删除数组重复元素有哪些方法，JS删除数组重复元素的注意事项有哪些，下面就是实战案例，一起来看一下。 这里就 js 如何实现数组去重整理出5种方法，并附上演示Demo 以及 源码。 1.遍历数组法 最简单的去重方法， 实现思路：新建一新数组，遍历传入数组，值不在新数组就加入该新数组中；注意点：判断值是否在数组的方法“indexOf”是ECMAScript5 方法，IE8以下不支持，需多写一些兼容低版本浏览器代码，源码如下：// 最简单数组去重法function unique1(array){ var n = []; //一个新的临时数组 //遍历当前数组 for(var i = 0; i < array.length; i++){ //如果当前数组的第i已经保存进了临时数组，那么跳过， //否则把当前项push到临时数组里面 if (n.indexOf(array[i]) == -1) n.push(array[i]); } return n;}// 判断浏览器是否支持indexOf ，indexOf 为ecmaScript5新方法 IE8以下（包括IE8， IE8只支持部分ecma5）不支持if (!Array.prototype.indexOf){ // 新增indexOf方法 Array.prototype.indexOf = function(item){ var result = -1, a_item = null; if (this.length == 0){ return result; } for(var i = 0, len = this.length; i < len; i++){ a_item = this[i]; if (a_item === item){ result = i; break; } } return result; }} 2.对象键值对法 该方法执行的速度比其他任何方法都快， 就是占用的内存大一些； 实现思路：新建一js对象以及新数组，遍历传入数组时，判断值是否为js对象的键，不是的话给对象新增该键并放入新数组。注意点： 判断是否为js对象键时，会自动对传入的键执行“toString()”，不同的键可能会被误认为一样；例如： a[1]、a["1"] 。解决上述问题还是得调用“indexOf”。// 速度最快， 占空间最多（空间换时间）function unique2(array){ var n = {}, r = [], len = array.length, val, type; for (var i = 0; i < array.length; i++) { val = array[i]; type = typeof val; if (!n[val]) { n[val] = [type]; r.push(val); } else if (n[val].indexOf(type) < 0) { n[val].push(type); r.push(val); } } return r;} 3.数组下标判断法 还是得调用“indexOf”性能跟方法1差不多， 实现思路：如果当前数组的第i项在当前数组中第一次出现的位置不是i，那么表示第i项是重复的，忽略掉。否则存入结果数组。function unique3(array){ var n = [array[0]]; //结果数组 //从第二项开始遍历 for(var i = 1; i < array.length; i++) { //如果当前数组的第i项在当前数组中第一次出现的位置不是i， //那么表示第i项是重复的，忽略掉。否则存入结果数组 if (array.indexOf(array[i]) == i) n.push(array[i]); } return n;} 4.排序后相邻去除法 虽然原生数组的”sort”方法排序结果不怎么靠谱，但在不注重顺序的去重里该缺点毫无影响。 实现思路：给传入数组排序，排序后相同值相邻，然后遍历时新数组只加入不与前一值重复的值。// 将相同的值相邻，然后遍历去除重复值function unique4(array){ array.sort(); var re=[array[0]]; for(var i = 1; i < array.length; i++){ if( array[i] !== re[re.length-1]) { re.push(array[i]); } } return re;} 5.优化遍历数组法 源自外国博文，该方法的实现代码相当酷炫； 实现思路：获取没重复的最右一值放入新数组。（检测到有重复值时终止当前循环同时进入顶层循环的下一轮判断）// 思路：获取没重复的最右一值放入新数组function unique5(array){ var r = []; for(var i = 0, l = array.length; i < l; i++) { for(var j = i + 1; j < l; j++) if (array[i] === array[j]) j = ++i; r.push(array[i]); } return r;}相信看了本文案例你已经掌握了方法，更多精彩请关注Gxl网其它相关文章！推荐阅读：用laravel5.3 vue做出收藏夹功能vue.js的数据传递与数据分发步骤详解

JS 中常见的几种去重方法

ES6 提供了新的数据结构 Set 。它类似于数组，但是成员的值都是唯一的，没有重复的值。 Set 本身是一个构造函数，用来生成 Set 数据结构。 利用的算法类似 '==='，与 '===' 的区别是 ‘===’ 认为 NaN != NaN ， set 的算法认为它们是相等的。 但 Set 不支持对象方法，认为对象都是不相等的。
原理： splice 会改变原数组
filter() 方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素 indexOf ( searchvalue, fromindex ) searchvalue ：必填值，规定需检索的字符串值 fromindex ：选填值，规定在字符串中开始检索的位置。它的合法取值是 0 到 stringObject.length - 1。 如省略该参数，则将从字符串的首字符开始检索。
原理：相邻元素对比法，若相等则去掉一个 注：array.sort( function ) 参数必须是函数，可选，默认升

jquery 多个字符串去重

var result = str.match(patten);//改为这样的for循环、因为那样的有浏览器不兼容。。。for(var i=0;i
<result.length;i++){ patten.lastindex="0;" reslut_a="patten.exec(result[i]);" array_count="reslut_a[2].split('、');" var map="{};" for(var j="0;j<array_count.length;j++){" aj="array_count[j];" 如果map中不存在这个字符串，就输出，然后再添加 以达到去重的效果 if(null="=" map[aj]){ document.write(aj); map[aj]="1;" } }}
方法1，用字符串截取substring()和字符位置查询indexOf()；

string.substring(start,end) 从string中截取一段字符串。

start:截取开始位置。

end：截取结束位置。

string.indexOf(findstr)，查找指定的字符串在string中的位置

findstr:要找的字符串

var str1="aaa@hotmail.com";//要截取@到.之间的内容

var str2=str1.substring(str1.indexOf("@")+1,str1.indexOf("."));

console.log(str2);

方法2，用正则表达式

[\@]匹配@

[\.]匹配.

.匹配任意字符

+匹配前面内容一次或多次

*匹配签名内容0次或多次

()中的内容可以被替换为$1,就是我们要找的部分

$1,$2,……可以匹配正则式中(),按顺序编号第一个括号为$1,第二个位$2,以此类推

var str1="aaa@hotmail.com";//要截取@到.之间的内容

var reg=new RegExp('.*[\@]+(.*)[\.]+.*');

var str2=str1.replace(reg,"$1");

console.log(str2);

如何使用es6实现去重（代码示例）

本篇文章给大家带来的内容是关于如何使用es6实现去重（代码示例），有一定的参考价值，有需要的朋友可以参考一下，希望对你有所帮助。以下是三种方法从数组里去重，并且返回唯一的值。我最喜欢的方式是使用Set，因为它是最短最简单的。const array = [5, 2, 4, 5, 3];console.log([...new Set(array)])console.log(array.filter((item, index) => array.indexOf(item) === index))console.log(array.reduce((unique, item) => unique.includes(item) ? unique: [...unique, item], []))// result: [5, 2, 4, 3]使用Set让我开始解释Set是什么吧：Set是由es6引入的一种新的数据对象，由于Set只允许你存储唯一值，所以当传递进去一个数组的时候，它将会移除任何重复的值。好啦，然我们回到我们的代码中来看下到底都发生了什么。实际上他进行了以下的操作：首先，我们创建了新的Set并且把数组当作入参传递了进去，由于Set仅仅允许唯一值，所以所有重复值将会被移除。现在重复值已经消失了，我们将会利用...把它重新转为数组。const array = [5, 2, 4, 5, 3];const set = new Set(array)const newArr = [...set]console.log(newArr)// result: [5, 2, 4, 3]使用Array.from()函数来吧Set转为数组另外呢，你也可以使用Array.from()来吧Set转为数组。const array = [5, 2, 4, 5, 3];const set = new Set(array)const newArr = Array.from(set)console.log(newArr)// result: [5, 2, 4, 3]使用filter为了理解这个选项，让我们来看看这两个方法都做了什么：indexOf和filterindexOf()indexOf()返回我们从数组里找到的第一个元素的索引。const array = [5, 2, 4, 5, 3];console.log(array.indexOf(5)) // 0console.log(array.indexOf(2)) // 1console.log(array.indexOf(8)) // -1filterfilter()函数会根据我们提供的条件创建一个新的数组。换一种说法，如果元素通过并且返回true，它将会包含在过滤后的数组中，如果有元素失败并且返回false，那么他就不会包含在过滤后的数组中。我们逐步看看在每次循环数组的时候都发生了什么。const array = [5, 2, 4, 5, 3];array.filter((item, index) => { console.log(item, index, array.indexOf(item), array.indexOf(item) === index) return array.indexOf(item) === index})//输出// 5 0 0 true// 2 1 1 true// 4 2 2 true// 5 3 0 false// 3 4 4 true上面输出的代码见注释。重复的元素不再于indexOf相匹配，所以在这些情况下，它的结果将会是false并且将不会被包含进过滤后的值当中。检索重复的值我们也可以在数组中利用filter()函数来检索重复的值。我们只需要像这样简单的调整下代码：const array = [5, 2, 4, 5, 3];array.filter((item, index) => { console.log(item, index, array.indexOf(item), array.indexOf(item) !== index) return array.indexOf(item) !== index})//输出// 5 0 0 false// 2 1 1 false// 4 2 2 false// 5 3 0 true// 3 4 4 false使用reduce()函数reduce()函数用于减少数组的元素并根据你传递过去的reducer函数，把他们最终合并到一个最终的数组中，在这种情况下，我们的reducer()函数我们最终的数组是否包含了这个元素，如果不包含，就吧他放进最终的数组中，反之则跳过这个元素，最后再返回我们最终的元素。reduce()函数理解起来总是有那么一点费劲，所以呢，咱们现在看下他是怎么运行的。const array = [5, 2, 4, 5, 3];array.reduce((unique, item) => { console.log(item, unique, unique.includes(item), unique.includes(item) ? unique: [...unique, item]) return unique.includes(item) ? unique: [...unique, item]}, [])//输出// 5 [] false [5]// 2 [5] false [5, 2]// 4 [5, 2] false [5, 2, 4]// 5 [5, 2, 4] true [5, 2, 4]// 3 [5, 2, 4] false [5, 2, 4, 3]

C#用那个正则表达式提取出来的数字，怎么去掉重复的数字

正则只能实现查找，不管他能实现多复杂的功能，其实都是实现查找功能。
他不能进行逻辑处理，如你说的去重。即便有些逻辑处理可以实现，也是很笨拙很庞大的正则。
所以，最好的方式是，用正则过滤出数字，然后用C#循环去重。
另，可用indexOf方法快速找到字符串中是否有重复数字。

js 中如何去掉数组中的重复的数据

需要准备的材料分别有：电脑、html编辑器、浏览器。
1、首先，打开html编辑器，新建html文件，例如：index.html。
2、在index.html中的标签，输入js代码：
var a = [1, 56, 24, 56, 67], b = [];
for (var i = 0; i < a.length; i++) {
if (b.indexOf(a[i]) === -1) {
b.push(a[i]);
}
}
document.body.innerText = b;
3、浏览器运行index.html页面，此时打印出了数组去重后的结果。
这就是数组去重了。。。
var str=['hello','node','element','node','hello','blue','red'];
var str1=[];
function first(args){
for(i=0;i<args.length;i++){
if(str1.indexOf(args[i])<0){
str1.push(args[i])
}
}
return str1;
}
first(str);
console.log(str1)
参考一下。。。从str数组中依次插入数据到str1数组中，str1.indexOf(args[i])这段是表示查询str1数组中是否存在str中要插入的数据。。返回false，即-1，表示没有，则将str中此数据插入到str1中，否则不执行，进行下一次循环。。
整理了网上的几种方法，并测试了性能效率问题，找了一个最优的贴出来供使用：
Js 高性能数组去重
JavaScript高性能数组去重
看了网上很多大神的写法，蠢蠢欲动，于是自己照着也写了几个，选出来最优的一个拿出来与大家分享一下。
具体的使用方法和代码详见：
Js 高性能数组去重
也可以写成str.indexOf(str[i])==i 。 indexOf 只要查询到首发就停， 后面的不找，所以首发的索引值与循环的索引值是一致的，由于indexof始终只找首发，首发的索引值肯定跟2发 3发的索引值对不上，就是false。初学我自己说一遍加深理解
let arr = [1,2,2,3,4,4,5];
let arr2 = [];
arr.map(item =>{
if(arr2.indexOf(item) <= -1)
{
arr2.push(item);
}
return arr2;
})
console.log(arr2)
可以使用js的for循环筛选实现去掉数组中的重复的数据。
具体步骤如下：
需要准备的材料分别是：电脑、浏览器、ultraedit。
1、在ue编辑器中新建一个空白的html文件，js文件。
2、在ue编辑器中输入以下html代码。
3、在ue编辑器中输入以下js代码。
4、编辑完成以后，在ue编辑器中点击保存，格式选择UTF8无BOM。
5、在浏览器中打开此html文件，可以看到最终想要实现的去掉数组中的重复的数据效果。

Web前端工程师应该知道的JavaScript使用小技巧

今天小编要跟大家分享的文章是关于Web前端工程师应该知道的JavaScript使用小技巧。任何一门技术在实际中都会有一些属于自己的小技巧。同样的，在使用JavaScript时也有一些自己的小技巧，只不过很多时候有可能容易被大家忽略。而在互联网上，时不时的有很多同行朋友会总结(或收集)一些这方面的小技巧。今天在这篇文章中，小编会整理一些大家熟悉或不熟悉的有关于JavaScript的小技巧，希望能够对大家的学习和工作有所帮助。一、数组先来看使用数组中常用的一些小技巧。01、数组去重ES6提供了几种简洁的数组去重的方法，但该方法并不适合处理非基本类型的数组。对于基本类型的数组去重，可以使用...newSet()来过滤掉数组中重复的值，创建一个只有唯一值的新数组。constarray=[1,1,2,3,5,5,1]constuniqueArray=[...newSet(array)];console.log(uniqueArray);>Result:(4)[1,2,3,5]这是ES6中的新特性，在ES6之前，要实现同样的效果，我们需要使用更多的代码。该技巧适用于包含基本类型的数组：undefined、null、boolean、string和number。如果数组中包含了一个object,function或其他数组，那就需要使用另一种方法。除了上面的方法之外，还可以使用Array.from(newSet())来实现：constarray=[1,1,2,3,5,5,1]Array.from(newSet(array))>Result:(4)[1,2,3,5]另外，还可以使用Array的.filter及indexOf()来实现：constarray=[1,1,2,3,5,5,1]array.filter((arr,index)=>array.indexOf(arr)===index)>Result:(4)[1,2,3,5]注意，indexOf()方法将返回数组中第一个出现的数组项。这就是为什么我们可以在每次迭代中将indexOf()方法返回的索引与当索索引进行比较，以确定当前项是否重复。02、确保数组的长度在处理网格结构时，如果原始数据每行的长度不相等，就需要重新创建该数据。为了确保每行的数据长度相等，可以使用Array.fill来处理：letarray=Array(5).fill('');console.log(array);>Result:(5)["","","","",""]03、数组映射不使用Array.map来映射数组值的方法。constarray=[{ame:'大漠',email:'w3cplus@#'},{ame:'Airen',email:'airen@#'}]constname=Array.from(array,({name})=>name)>Result:(2)["大漠","Airen"]04、数组截断如果你想从数组末尾删除值(删除数组中的最后一项)，有比使用splice()更快的替代方法。例如，你知道原始数组的大小，可以重新定义数组的length属性的值，就可以实现从数组末尾删除值：letarray=[0,1,2,3,4,5,6,7,8,9]console.log(array.length)>Result:10array.length=4console.log(array)>Result:(4)[0,1,2,3]这是一个特别简洁的解决方案。但是，slice()方法运行更快，性能更好：letarray=[0,1,2,3,4,5,6,7,8,9];array=array.slice(0,4);console.log(array);>Result:[0,1,2,3]05、过滤掉数组中的falsy值如果你想过滤数组中的falsy值，比如0、undefined、null、false，那么可以通过map和filter方法实现：constarray=[0,1,'0','1','大漠','#',undefined,true,false,null,'undefined','null',NaN,'NaN','1'+0]array.map(item=>{returnitem}).filter(Boolean)>Result:(10)[1,"0","1","大漠","#",true,"undefined","null","NaN","10"]06、获取数组的最后一项数组的slice()取值为正值时，从数组的开始处截取数组的项，如果取值为负整数时，可以从数组末属开始获取数组项。letarray=[1,2,3,4,5,6,7]constfirstArrayVal=array.slice(0,1)>Result:[1]constlastArrayVal=array.slice(-1)>Result:[7]console.log(array.slice(1))>Result:(6)[2,3,4,5,6,7]console.log(array.slice(array.length))>Result:[]正如上面示例所示，使用array.slice(-1)获取数组的最后一项，除此之外还可以使用下面的方式来获取数组的最后一项：console.log(array.slice(array.length-1))>Result:[7]07、过滤并排序字符串列表你可能有一个很多名字组成的列表，需要过滤掉重复的名字并按字母表将其排序。在我们的例子里准备用不同版本语言的JavaScript保留字的列表，但是你能发现，有很多重复的关键字而且它们并没有按字母表顺序排列。所以这是一个完美的字符串列表(数组)来测试我们的JavaScript小知识。varkeywords=['do','if','in','for','new','try','var','case','else','enum','null','this','true','void','with','break','catch','class','const','false','super','throw','while','delete','export','import','return','switch','typeof','default','extends','finally','continue','debugger','function','do','if','in','for','int','new','try','var','byte','case','char','else','enum','goto','long','null','this','true','void','with','break','catch','class','const','false','final','float','short','super','throw','while','delete','double','export','import','native','public','return','static','switch','throws','typeof','boolean','default','extends','finally','package','private','abstract','continue','debugger','function','volatile','interface','protected','transient','implements','instanceof','synchronized','do','if','in','for','let','new','try','var','case','else','enum','eval','null','this','true','void','with','break','catch','class','const','false','super','throw','while','yield','delete','export','import','public','return','static','switch','typeof','default','extends','finally','package','private','continue','debugger','function','arguments','interface','protected','implements','instanceof','do','if','in','for','let','new','try','var','case','else','enum','eval','null','this','true','void','with','await','break','catch','class','const','false','super','throw','while','yield','delete','export','import','public','return','static','switch','typeof','default','extends','finally','package','private','continue','debugger','function','arguments','interface','protected','implements','instanceof'];因为我们不想改变我们的原始列表，所以我们准备用高阶函数叫做filter，它将基于我们传递的回调方法返回一个新的过滤后的数组。回调方法将比较当前关键字在原始列表里的索引和新列表中的索引，仅当索引匹配时将当前关键字push到新数组。最后我们准备使用sort方法排序过滤后的列表，sort只接受一个比较方法作为参数，并返回按字母表排序后的列表。在ES6下使用箭头函数看起来更简单:constfilteredAndSortedKeywords=keywords.filter((keyword,index)=>keywords.lastIndexOf(keyword)===index).sort((a,b)=>a这是最后过滤和排序后的JavaScript保留字列表：console.log(filteredAndSortedKeywords);>Result:['abstract','arguments','await','boolean','break','byte','case','catch','char','class','const','continue','debugger','default','delete','do','double','else','enum','eval','export','extends','false','final','finally','float','for','function','goto','if','implements','import','in','instanceof','int','interface','let','long','native','new','null','package','private','protected','public','return','short','static','super','switch','synchronized','this','throw','throws','transient','true','try','typeof','var','void','volatile','while','with','yield']08、清空数组如果你定义了一个数组，然后你想清空它。通常，你会这样做：letarray=[1,2,3,4];functionemptyArray(){array=[];}emptyArray();但是，这有一个效率更高的方法来清空数组。你可以这样写:letarray=[1,2,3,4];functionemptyArray(){array.length=0;}emptyArray();09、拍平多维数组使用...运算符，将多维数组拍平：10、从数组中获取最大值和最小值可以使用Math.max和Math.min取出数组中的最大小值和最小值：constnumbers=[15,80,-9,90,-99]constmaxInNumbers=Math.max.apply(Math,numbers)constminInNumbers=Math.min.apply(Math,numbers)console.log(maxInNumbers)>Result:90console.log(minInNumbers)>Result:-99另外还可以使用ES6的...运算符来完成：constnumbers=[1,2,3,4];Math.max(...numbers)>Result:4Math.min(...numbers)>>Result:1二、对象在操作对象时也有一些小技巧。01、使用...运算符合并对象或数组中的对象同样使用ES的...运算符可以替代人工操作，合并对象或者合并数组中的对象。//合并对象constobj1={ame:'大漠',url:'#'}constobj2={ame:'airen',age:30}constmergingObj={...obj1,...obj2}>Result:{name:"airen",url:"#",age:30}//合并数组中的对象constarray=[{ame:'大漠',email:'w3cplus@#'},{ame:'Airen',email:'airen@#'}]constresult=array.reduce((accumulator,item)=>{return{...accumulator,[item.name]:item.email}},{})>Result:{大漠:"w3cplus@#",Airen:"airen@#"}02、有条件的添加对象属性不再需要根据一个条件创建两个不同的对象，以使它具有特定的属性。为此，使用...操作符是最简单的。constgetUser=(emailIncluded)=>{return{ame:'大漠',blog:'w3cplus',...emailIncluded&&{email:'w3cplus@#'}}}constuser=getUser(true)console.log(user)>Result:{name:"大漠",blog:"w3cplus",email:"w3cplus@#"}constuserWithoutEmail=getUser(false)console.log(userWithoutEmail)>Result:{name:"大漠",blog:"w3cplus"}03、解构原始数据你可以在使用数据的时候，把所有数据都放在一个对象中。同时想在这个数据对象中获取自己想要的数据。在这里可以使用ES6的Destructuring特性来实现。比如你想把下面这个obj中的数据分成两个部分：constobj={ame:'大漠',blog:'w3cplus',email:'w3cplus@#',joined:'2019-06-19',followers:45}letuser={},userDetails={}({name:user.name,email:user.email,...userDetails}=obj)>{name:"大漠",blog:"w3cplus",email:"w3cplus@#",joined:"2019-06-19",followers:45}console.log(user)>Result:{name:"大漠",email:"w3cplus@#"}console.log(userDetails)>Result:{blog:"w3cplus",joined:"2019-06-19",followers:45}04、动态更改对象的key在过去，我们首先必须声明一个对象，然后在需要动态属性名的情况下分配一个属性。在以前，这是不可能以声明的方式实现的。不过在ES6中，我们可以实现：constdynamicKey='email'letobj={ame:'大漠',blog:'w3cplus',[dynamicKey]:'w3cplus@#'}console.log(obj)>Result:{name:"大漠",blog:"w3cplus",email:"w3cplus@#"}05、判断对象的数据类型使用Object.prototype.toString配合闭包来实现对象数据类型的判断：constisType=type=>target=>`[object${type}]`===Object.prototype.toString.call(target)constisArray=isType('Array')([1,2,3])console.log(isArray)>Result:true上面的代码相当于：functionisType(type){returnfunction(target){return`[object${type}]`===Object.prototype.toString.call(target)}}isType('Array')([1,2,3])>Result:true或者：constisType=type=>target=>`[object${type}]`===Object.prototype.toString.call(target)constisString=isType('String')constres=isString(('1'))console.log(res)>Result:true06、检查某对象是否有某属性当你需要检查某属性是否存在于一个对象，你可能会这样做：varobj={ame:'大漠'}if(obj.name){console.l