本文目录一览:
- 1、JS常用的静态方法
- 2、昭通java培训学校告诉你JavaScript编程开发技巧?
- 3、Web前端性能优化的实用技巧汇总
- 4、JS Array中的常用方法
- 5、js常用增删改查方法/js比较运算符 逻辑运算符 赋值运算符 算术运算符
- 6、Web前端工程师应该知道的JavaScript使用小技巧
JS常用的静态方法
静态方法属于整个类所有,因此调用它不用实例化,可以直接调用------ 类.静态方法() ====Array.from()/Array of(),Object.is(),Math.ceil().....,不难发现这些 静态方法都是类作为调用对象使用的
实例方法必须先实例化,创建一个对象,才能进行调用------ 对象.实例方法()
①Object.is()
用来比较两个值是 否严格相等 ,与严格比较运算符(===)的行为基本一致。
②Object.assign()
用于对象的 合并 ,将多个对象的所有可枚举属性复制到目标对象。
newObject:目标对象
object1,object2,object3…:源对象
添加属性
添加方法
③Object.keys()
返回值为对象的所有属性名组成的数组
④Object.values()
返回值为对象的所有值组成的数组
⑤Object.entries()
成员是参数对象自身的(不含继承的)所有可遍历属性的 键值对数组 。
①Array.from()
用于将两类对象转化为真正的数组: 类数组对象,和可遍历的对象
②Array.isArray()
用于判断一个对象是否为数组,如果是返回true,否则返回false
③Array.of()
用于将一组 数据 装进一个 数组 中。
Array(); // [ ]
Array(7); // [ , , , , , , ] 相当于数组长度为7
Array(1, 2, 3); // [1, 2, 3]
Array.of(); // [ ]
Array.of(7); // [7] 这里写7那就是数组中有一个7
Array.of(1, 2, 3); // [1, 2, 3]
Array.of() 方法不存在 Array() 由于参数个数不同而导致的重载,它的行为很稳定,所以一般用前者代替后者。
①Number.isFinite(), Number.isNaN()
Number.isFinite()用来检查一个 数值 是否为有限的(finite)
Number.isNaN()用来检查一个值是否为NaN 。
Number.isFinite()对于非数值一律返回false, Number.isNaN()只有对于NaN才返回true,非NaN一律返回false。
①Math.trunc()
Math.trunc方法用于 去除一个数的小数部分 , 返回整数部分。
②Math.sign()
Math.sign方法用来判断一个数到底是正数、负数、还是零。 对于非数值,会先将其转换为数值 。
它会返回五种值。
参数为正数,返回+1;
参数为负数,返回-1;
参数为 0,返回0;
参数为-0,返回-0;
其他值,返回NaN。
1)PI 取圆周率
2)abs() 取绝对值
3)ceil() 向上取整
4)floor() 向下取整
5)round() 四舍五入
6)max() 取最大值
7)min() 取最小值
8)pow() 取X的y次幂
9)random() 取随机数 =0 1
昭通java培训学校告诉你JavaScript编程开发技巧?
随着互联网的不断发展,关于JavaScript编程开发语言的使用也被广大程序员掌握。而今天我们就一起来了解一下,JavaScript编程开发的一些技巧都有哪些。
JSON.stringify
我们平时经常会用到JSON对象,比如当我们要实现对象的深拷贝时,我们可以用JSON对象的JSON.stringify和JSON.parse来拷贝一个完全一样的对象,而不会对原对象产生任何引用关系。在使用localStorage时,也会用到它,因为localStorage只能存储字符串格式的内容,所以,我们在存之前,将数值转换成JSON字符串,取出来用的时候,再转成对象或数组。
参数:
value:将要被序列化的变量的值
replacer:替代器。可以是函数或者是数组,如果是一个函数,则value每个属性都要经过这个函数的处理,该函数的返回值就是后被序列化后的值。如果是一个数组,则要求该数组的元素是字符串,且这些元素会被当做value的键(key)进行匹配,后序列化的结果,是只包含该数组每个元素为key的值。
space:指定输出数值的代码缩进,美化格式之用,可以是数字或者字符串。如果是数字(大为10)的话,代表每行代码的缩进是多少个空格。如果是字符串的话,该字符串(多前十个字符)将作显示在每行代码之前。
用Set来实现数组去重
在ES6中,引入了一个新的数据结构类型:Set。而Set与Array的结构是很类似的,且Set和Array可以相互进行转换。
数组去重,也算是一个比较常见的前端面试题了,方法有很多种,这里不多赘述。下面我们看看用Set和...(拓展运算符)可以很简单的进行数组去重。
用块级作用域避免命名冲突
在开发的过程中,通常会遇到命名冲突的问题,就是需要根据场景不同来定义不同的值来赋值给同一个变量。下面昭通IT培训介绍一个使用ES6中的块级作用域来解决这个问题的方法。
函数参数值校验
我们知道,在ES6中,为函数增加了参数默认值的特性,可以为参数设定一些默认值,可以让代码更简洁,可维护。
Web前端性能优化的实用技巧汇总
今天小编要跟大家分享的文章是关于Web前端性能优化的实用技巧汇总。javascript在浏览器中运行的性能,可以认为是开发者所面临的最严重的可用性问题。这个问题因为javascript的阻塞性而变得复杂,事实上,多数浏览器使用单一进程来处理用户界面和js脚本执行,所以同一时刻只能做一件事。js执行过程耗时越久,浏览器等待响应的时间越长。
一.提高加载性能
1.IE8,FF,3.5,Safari4和Chrome都允许并行下载js文件,当script下载资源时不会阻塞其他script的下载。但是js下载仍然会阻塞其他资源的下载,如图片。尽管脚本下载不会互相影响,但页面仍然必须等待所有js代码下载并执行完才能继续。因此仍然存在脚本阻塞问题.推荐将所有js文件放在body标签底部以减少对整个页面的影响。
2.减少页面外链脚本文件的数量将会提高页面性能:
http请求会带来额外的开销,因此下载单个300k的文件将比下载10个30k的文件效率更高。
3.动态脚本加载技术:
无论何时启动下载,文件的下载和执行都不会阻塞页面其他进程。
functionlaodScript(url,callback){
varscript=document.createElement('script');_
_cript.type='text/javascript';
__f(script.readyState){//ie
____cript.onreadystatechange=function(){_____
if(script.readyState=='loaded'||script.readyState=='complete'){_______
_cript.onreadystatechange=null;_______
callback()_____
____
__
}else{//其他浏览器___
script.onload=function(){_____
_allback()
___}_
}_
script.src=url;_
document.getElementsByTagName('head')[0].appendChild(script);
}
//使用
loadScript('./a.js',function(){_
loadScript('./b.js',function(){___
loadScript('./c.js',function(){_____
console.log('加载完成')___
})_
})
})
4.无阻塞加载类库——LABjs,使用方法如下:
//链式调用时文件逐个下载,.wait()用来指定文件下载并执行完毕后所调用的函数
$LAB.script('./a.js')_
.script('./b.js')_
.wait(function(){__
_pp.init();
})
//为了保证执行顺序,可以这么做,此时a必定在b前执行
$LAB.script('./a.js').wait()_
.script('./b.js')_
.wait(function(){___
_pp.init();
})
二.数据存取与JS性能
1.在js中,数据存储的位置会对代码整体性能产生重大影响。数据存储共有4种方式:字面量,变量,数组项,对象成员。他们有着各自的性能特点。
2.访问字面量和局部变量的速度最快,相反,访问数组和对象相对较慢
3.由于局部变量存在于作用域链的起始位置,因此访问局部变量的比访问跨域作用变量更快
4.嵌套的对象成员会明显影响性能,应尽量避免
5.属性和方法在原型链位置越深,访问他的速度越慢
6.通常我们可以把需要多次使用的对象成员,数组元素,跨域变量保存在局部变量中来改善js性能
三.DOM编程
1.访问DOM会影响浏览器性能,修改DOM则更耗费性能,因为他会导致浏览器重新计算页面的几何变化。
注:如过在一个对性能要求比较高的操作中更新一段HTML,推荐使用innerHTML,因为它在绝大多数浏览器中运行的都很快。但对于大多数日常操作而言,并没有太大区别,所以你更应该根据可读性,稳定性,团队习惯,代码风格来综合决定使用innerHTML还是createElement()
2.HTML集合优化
HTML集合包含了DOM节点引用的类数组对象,一直与文档保持连接,每次你需要最新的信息时,都会重复执行查询操作,哪怕只是获取集合里元素的个数。
①_优化一——集合转数组collToArr
functioncollToArr(coll){_
for(vari=0,a=[],len=coll.length;i
a._ush(coll[i]);
__
returna
}
②缓存集合length
③访问集合元素时使用局部变量(即将重复的集合访问缓存到局部变量中,用局部变量来操作)
3.遍历DOM
①使用只返回元素节点的API遍历DOM,因为这些API的执行效率比自己实现的效率更高:
td{border:1pxsolid#ccc;padding:5px;margin:auto;}
tdp{text-align:left;}
tdpspan{text-align:center;display:block;}
属性名
被替代属性
children
childNodes
childElementCount
childNodes.length
firstElementChild
firstChild
lastElementChild
lastChild
nextElementSibling
nextSibling
previousElementSibling
previousSibling
_谘≡衿_PI——querySelectorAll()
querySelectorAll()方法使用css选择器作为参数并返回一个NodeList——包含着匹配节点的类数组对象,该方法不会返回HTML集合,因此返回的节点不会对应实时文档结构,着也避免了HTML集合引起的性能问题。
let_rr=_ocument.querySelectorAll('div.warning,_iv.notice_')
4.重绘和重排
浏览器在下载完页面的所有组件——html,js,css,图片等之后,会解析并生成两个内部数据结构——_OM树,渲染树.一旦DOM树和渲染树构建完成,浏览器就开始绘制页面元素(paint).
①重排发生的条件:
添加或删除可见的DOM元素位置变化元素尺寸改变内容改变页面渲染器初始化浏览器窗口尺寸变化出现滚动条时会触发整个页面的重排_嘏疟囟ㄖ鼗
5.渲染树变化的排列和刷新
大多数浏览器通过队列化修改并批量执行来优化重排过程,然而获取布局信息的操作会导致队列强制刷新。
offsetTop,offsetWidth...
scrollTop,scrollHeight...
clientTop,clientHeight...
getComputedStyle()
一些优化建议:将设置样式的操作和获取样式的操作分开:
//设置样式
body.style.color='red';
body.style.fontSize='24px'
//读取样式
letcolor=body.style.color
let_ontSize=_ody.style.fontSize
另外,获取计算属性的兼容写法:
functiongetComputedStyle(el){_
varcomputed=(document.body.currentStyle?el.currentStyle:document.defaultView.getComputedStyle(el,'');_
returncomputed
}
6.最小化重绘和重排
①.批量改变样式
/*使用cssText
*/el.style.cssText='border-left:1px;_order-right:2px;_adding:20px';
②.批量修改dom的优化方案——使元素脱离文档流-对其应用多重改变-把元素带回文档
functionappendDataToEl(option){
vartargetEl=option.target||document.body,___
createEl,___
data=option.data||[];_//让容器脱离文档流,减少重绘重排_
vartargetEl_display=targetEl.style.display;_
targetEl.style.display='none';
_
//*****创建文档片段来优化Dom操作****_
varfragment=document.createDocumentFragment();_//给元素填充数据_
for(vari=0,max=data.length;i
createEl=
document.createElement(option.createEl);___
for(varitemindata[i]){_____
if(item.toString()==='text'){_______
createEl.appendChild(document.createTextNode(data[i][item]));________ontinue;___________
_f(item.toString()==='html'){_______
createEl.innerHTML=item,data[i][item];_______
continue;_____
}_____
_reateEl.setAttribute(item,data[i][item]);_______
//****将填充好的node插入文档片段****___
fragment.appendChild(createEl);___
//****将文档片段统一插入目标容器****_
targetEl.appendChild(fragment);_
//显示容器,完成数据填充_
targetEl.style.display=
targetEl_display;
}
//使用
varwrap=document.querySelectorAll('.wrap')[0];
vardata=[_
_name:'xujaing',text:'选景',title:'xuanfij'},_
{name:'xujaing',text:'选景',title:'xuanfij'},_
{name:'xujaing',text:'选景',title:'xuanfij'}];
appendDataToEl({_
target:wrap,_
createEl:'div',
_ata:data
});
上面的优化方法使用了文档片段:_蔽颐前盐牡灯尾迦氲浇诘阒惺保导噬媳惶砑拥闹皇歉闷蔚淖咏诘悖皇瞧伪旧怼?梢允沟_om操作更有效率。
②.缓存布局信息
//缓存布局信息
letcurrent=el.offsetLeft;
current++;
el.style.left=current+'px';
if(current300){_
stop();
}
④.慎用:hover
如果有大量元素使用:hover,那么会降低相应速度,CPU升高
⑤.使用事件委托(通过事件冒泡实现)来减少事件处理器的数量,减少内存和处理时间
functiondelegation(e,selector,callback){_
e=e||window.event;_
vartarget=e.target||e.srcElement;
_if(target.nodeName!==selector||
target.className!==selector||target.id!==selector){___
return;
_}_
if(typeofe.preventDefault==='function'){__
_.preventDefault();___
e.stopPropagation();
}else{___
e.returnValue=false;
e.cancelBubble=true;_
}
__allback()}
四.算法和流程控制
1.循环中减少属性查找并反转(可以提升50%-60%的性能)
//for循环
for(vari=item.length;i--){_
process(item[i]);
}
//while循环
varj=item.length;
while(j--){_
process(item[i]);
}
2.使用Duff装置来优化循环(该方法在后面的文章中会详细介绍)
3.基于函数的迭代(比基于循环的迭代慢)
items.forEach(function(value,index,array){__rocess(value);})
4.通常情况下switch总比if-else快,但是不是最佳方案
五.字符串和正则表达式
1.除了IE外,其他浏览器会尝试为表达式左侧的字符串分配更多的内存,然后简单的将第二个字符串拷贝到他的末尾,如果在一个循环中,基础字符串位于最左侧,就可以避免重复拷贝一个逐渐变大的基础字符串。2.使用[\s\S]来匹配任意字符串3.去除尾部空白的常用做法:
if(!String.prototype.trim){_
String.prototype.trim=function(){___
returnthis.replace(/^\s+/,'').replace(/\s\s*$/,'')_
}
}
六.快速响应的用户界面
1.浏览器的UI线程:用于执行javascript和更新用户界面的进程。
2.在windows系统中定时器分辨率为15毫秒,因此设置小于15毫秒将会使IE锁定,延时的最小值建议为25ms.
3.用延时数组分割耗时任务:
functionmultistep(steps,args,callback){_
vartasks=steps.concat();
__etTimeout(function(){___
vartask=tasks.shift();___
task.apply(null,args||[]);_//调用Apply参数必须是数组
___
if(tasks.length0){_____
setTimeout(arguments.callee,25);
___else{_____
_allback();___
__
},25);
}
4.记录代码运行时间批处理任务:
functiontimeProcessArray(items,process,callback){_
vartodo=item.concat();
__etTimeout(function(){___
varstart=+newDate();
__o{_____
_rocess(todo.shift());___
}while(todo.length0(+newDate()-start____f(todo.length0){_____
_etTimeout(arguments.callee,25);
___else{____
_allback(items);_
}_
_,25)
}
5.使用WebWorker:它引入了一个接口,能使代码运行且不占用浏览器UI线程的时间。一个Worker由如下部分组成:
①一个navigator对象,包括app
JS Array中的常用方法
在Js Array中的方法大致分为两类:方法改变原数组 方法生成新数组(不改变原数组)
1.push():向原数组的最后一位添加一个元素。返回数组长度
2.unshift():向原数组的最前添加一个元素。返回数组长度
3.pop():截取数组中最后一个元素。返回被截取的元素
4.shift():截取数组中第一个元素。返回被截取的元素
以上四个方法可以放在一起记忆,不要被方面名所误导。
5.splice():splice(index, howmany, item1,...itemX) 方法有多个参数可选,常用于分割数组。返回处理后的数组
第一个参数:从第n个元素的下标开始截取;
第二个参数:从第n个元素的下标开始截取多少个元素;
第三到n个参数:将截取的元素替换为什么
6.sort():sort(fn) 方法有一个参数可选,用于给数组排序。在不写参数的情况下会对数组中的元素进行从小到大的顺序排序。但不会识别数字(按照数字ACSLL编码表进行排序)
可选参数:参数返回一个函数,这个函数中有两个形参 .sort(function(a, b){}) 。形参中的a和b会类冒泡的访问数组中的元素;例:[1, 2, 3, 4] a b 分别会选择 1,2、 1,3 、 1,4 、 2,3 、 2,4 、 3,4。当a-b1时,交换ab的值;当a-b1时,不动。由此,可在此函数体中写出自定义的排序规则。返回排序后的数组
7.reverse():倒序排列整个数组。返回数组
1.concat():concat(arr)将两个数组拼接在一起。返回新数组
2.join():join('str')一个可选参数,返回以一个字符串将数组中的元素拼接成字符串。与str的split('str')方法相反,split()是将字符串以一个字符串拆分成数组。
3.toString():与join()函数不填写参数一样,返回一个一 逗号 ,拼接的字符串。
4.slice():选取数组中的第n个元素到第n个元素。返回新数组,也可不写参数返回数组的副本。
5.indexOf():index(item, start)方法有两个参数。返回指定元素在数组中的索引值;如果未找到指定元素,返回 -1
第一个参数:指定的元素
第二个参数:从填入的索引开始寻找
js常用增删改查方法/js比较运算符 逻辑运算符 赋值运算符 算术运算符
js数组遍历某个值求和
一、增
1、push()
可接收任意数量的参数,把它们逐个添加至数组末尾,并返回修改后数组的长度。例如:
2、unshift()
该方法与push()类似,也可接收任意数量的参数,只不过是将参数逐个添加至数组前端而已,同样返回新数组长度。咱们接着上面的例子:
3、concat()
该方法与push()方法有点类似,同样是将元素添加至数组末尾,只不过这个数组已经不是原来的那个数组了,而是其副本,所以concat()操作数组后会返回一个新的数组。具体用法如下:
① 不传参数,返回当前数组副本
② 传递一或多个数组,则该方法会将这些数组中的每一项都添加到结果数组中
③ 传递非数组参数,这些参数就会被直接添加到结果数组的末尾
继续接着上面的栗子:
例子中一目了然,原数组保持不变,新数组后面添加了4、5、6三个元素。
4、splice()
前面的三个方法都具有很大局限性,因为不是添加到数组前就是数组后,而splice()就不一样了,它非常灵活和强大。灵活是因为它可以添加元素到数组的任意位置,强大是因为它除了可以添加元素之外还具有删除和替换元素的功能(这个后面会陆续讲到)。
splice()可以向数组指定位置添加任意数量的元素,需要传入至少3个参数: 起始位置、0(要删除的元素个数)和要添加的元素。
依然接着上面的例子继续:
可以看出,splice()与push()和unshift()一样是直接在原数组上修改的。
二、删
1、pop()
与push()方法配合使用可以构成后进先出的栈,该方法可从数组末尾删除最后一项并返回该项。
接着上例:
2、shift()
与push()方法配合使用可以构成先进先出的队列,该方法可删除数组第一项并返回该项。
继续接着上例:
3、slice()
定义和用法
slice() 方法以新的数组对象,返回数组中被选中的元素。
slice() 方法选择从给定的 start 参数开始的元素,并在给定的 end 参数处结束,但不包括。
注释:slice() 方法不会改变原始数组。
该方法同concat()一样是返回一个新数组,不会影响原数组,只不过slice()是用来裁剪数组的,返回裁剪下来的数组,具体用法如下:
4、splice()
好,继续讲这个“万能”的方法。
上面讲到,该方法在添加数组元素的时候需要传入3个以上参数,而其中第2个参数就是用于指定要删除元素的个数的,那时我们传的是数字0。那么,如果单单只需删除元素,我们就只需给splice()传入两个参数,第1个参数用于指定要删除的第一项的位置,第2个参数用于指定要删除元素的个数。
继续上例~~
从索引项为2的位置开始删除4个元素,所以结果为 [-1, 0, 1, 2]。
三、改
这个其实最灵活的方式就是直接使用splice()这个强大的方法了,其实通过以上对该方法的了解,我们大致就能知道使用该方法修改数组元素的基本原理。
原理很简单,就是向指定位置插入任意数量的元素,且同时删除任意数量的元素。
依然继续上例~~
四、查
indexOf()和lastIndexOf()
这两个方法都接收两个参数:要查找的项和(可选的)表示查找起点位置的索引。其中,indexOf()从数组的开头(位置0)开始向后查找,lastIndexOf()方法则从数组的末尾开始向前查找。
例如:
当找不到该元素时,返回 -1 ,lastIndexOf()方法同理。
1 数据类型
script
2 引用数据类型
object 对象类型
3 number 数字类型
包含所有的数字(整数,浮点数,正数,负数,极大极小数),Infinity(分母为零),NaN(not a number)
4 string 字符串类型
引号包含的任意文本,单双引号都可以
输出展示
2 比较运算符
script
/*
1 比较运算符
比较两个值的大小 返回一个布尔值(true 或 false)
= = == != === !==
== 等于,只判断数值
===全等,绝对等于,即判断数据类型也判断数值
!= == 取反
!== ===取反
console.log(undefined == null);//true 都没有值
console.log(undefined === null);//false 数据类型不同undefined object
console.log(NaN == NaN); //false
console.log(NaN === NaN); //false
console.log(NaN != NaN); //true
console.log(NaN !== NaN); //true
/
/script
3 逻辑运算符
script
/
2 逻辑运算符
连接多个表达式,返回一个布尔值(true 或 false)
逻辑与 并且 所有的表达式都为true,结果才为true,有一个为false结果就为false
|| 逻辑或 或者 所有的表达式都为false,结果才为false,有一个为true结果就为true
! 逻辑非 取反 表达式为true取反就为true,反之亦然
注意: 逻辑与的优先级大于逻辑或
*/
/script
逻辑运算符演示
输出到控制台的结果
4 赋值运算符
script
/*
3 赋值运算符
= 等号右边的值赋值给左边
+= x += y x = x + y 下同
-=
*=
/=
%= 要的是余数
*/
/script
script
x = 7;
y = 3;
console.log(x/=y)
/script
5 算术运算符
script
/*
算术运算符
+ - * / %(取余,取模) ++(自增) --(自减)
%(取余,取模) 应用 判断奇偶数、倍数
++ 相当于自己加1 x++ 相当于 x = x + 1
-- 相当于自己加1 x-- 相当于 x = x - 1
+运算碰到字符串,直接进行字符串拼接,返回string类型
- * / %遇到字符串,都转换成number类型进行计算,如果不能转换成数字,则返回NaN,数据类型未number
true转换1 false转换为0
++ --
前++和后++,对于变量自己来说没有区别都是+1
前++ 先赋值 在加1
后++ 先加1 再赋值
/
/script
script
/ var x = 5;//number
var y = 2;//number
comsole.log(x + y);//7
comsole.log(x - y);//3
comsole.log(x * y);//10
comsole.log(x / y);//2.5
comsole.log(x % y);//1 */
Web前端工程师应该知道的JavaScript使用小技巧
今天小编要跟大家分享的文章是关于Web前端工程师应该知道的JavaScript使用小技巧。任何一门技术在实际中都会有一些属于自己的小技巧。同样的,在使用JavaScript时也有一些自己的小技巧,只不过很多时候有可能容易被大家忽略。而在互联网上,时不时的有很多同行朋友会总结(或收集)一些这方面的小技巧。
今天在这篇文章中,小编会整理一些大家熟悉或不熟悉的有关于JavaScript的小技巧,希望能够对大家的学习和工作有所帮助。
一、数组
先来看使用数组中常用的一些小技巧。
01、数组去重
ES6提供了几种简洁的数组去重的方法,但该方法并不适合处理非基本类型的数组。对于基本类型的数组去重,可以使用...new
Set()来过滤掉数组中重复的值,创建一个只有唯一值的新数组。
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:10
array.length=4
console.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:90
console.log(minInNumbers)
Result:-99
另外还可以使用ES6的...运算符来完成:
constnumbers=[1,2,3,4];
Math.max(...numbers)
Result:4
Math.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:true
06、检查某对象是否有某属性
当你需要检查某属性是否存在于一个对象,你可能会这样做:
varobj={
ame:'大漠'
}
if(obj.name){
console.l