标签：学习 arr set console log value Js day14 var
ES5以及ES6
es表示ECMASCript ，他是从es3，es5，es6，es5是2009.12月发布的，es6是2015.6月发布的。vue2
完全支持es5的（vue3完全支持es6的），react完全支持es6
es5的新特性
严格模式（对应的相反的称为怪异模式）
‘use strict' //一般用于相关的设计 上面书写一个严格模式底下的代码就需要按照严格模式执行严格模式的特性
变量必须要带修饰符
’use strict‘
a = 10
console.log(a); //a is not defined函数里面this不能指向window
function sayHello(){
console.log(this); //undefined
}
sayHello()不允许在非函数的代码块内声明函数
禁止八进制方法
函数的arguments数组形参和实参不同步
对于数组和字符串都进行了加强
数组的高阶函数（以函数做的参数的函数 称为高阶函数）
forEach 遍历的
var arr = [1,2,3,4,5]
//forEach 遍历的 value表示里面的值 index表示里面的下标 array表示当前遍历的数组
var forEachObj = arr.forEach(function(value,index,array){
console.log(value); //打印里面的值 1,2,3,4,5
console.log(index) // 打印下标 0,1,2,3,4
console.log(array) //当前遍历的数组 [1,2,3,4,5]
})map 遍历
//map 遍历的 value表示里面的值 index表示下标 array表示当前的遍历的数组
var mapObj = arr.map(function(value,index,array){
console.log(value); //打印里面的值 1,2,3,4,5
console.log(index) // 打印下标 0,1,2,3,4
console.log(array) //当前遍历的数组 [1,2,3,4,5]
return value+1
})forEach和map的区别
- forEach没有返回值 里面没有return
- map有返回值 所以里面可以使用return关键词 他的返回值是一个数组
forEach和map的底层实现
// forEach
var arr = [1,2,3,4,5]
function forEach(fn){
for(var i=0;i<arr.length;i++){
fn(arr[i],arr)
}
}
forEach(function(value,index,arr){
console.log(index);
})
// map
function map(fn){
var res = []
for(var i=0;i<arr.length;i++){
res.push(fn(arr[i],i,arr))
}
return res
}
var mapArr = map(function(value,index,arr){
console.log(value);
return value+1
})
console.log(mapArr);
var arr = [1, 2, 3, 4, 5];
// forEach遍历的 函数作参数
// 没有返回值
arr.forEach(function (value, index, array) {
console.log("值：" + value + ", 下标：" + index + ", 数组：" + array);
});
// map有返回值，所以可以使用return 关键词
var arr = [1, 2, 3, 4, 5];
var newArr = arr.map(function (value, index, array) {
return value * 2;
});
console.log(arr); //[1,2,3,4,5]
console.log(newArr); //[2,4,6,8,10]reduce 从左到右计算的 reduceRight（从右到左计算）
//pre 前一个值 current 当前值 index 下标 array 数组
//reduce函数 利用前一个和后面值进行运算的操作 得出对应的值
var sum = arr.reduce(function(pre,current,index,arr){
return pre+current
})
console.log(sum);reduce底层实现
// 底层实现reduce
function reduce(fn){
//如果只有一个直接返回
if(arr.length==1) return arr[0]
var res = arr[0]
//如果有多个的情况
for(var i=1;i<arr.length;i++){
res = fn(res,arr[i],i,arr)
}
return res
}filter 过滤的
//filter返回的是一个数组 value index arr
var filterArr = arr.filter(function(value,index,arr){
return value>3
})
console.log(filterArr);filter的底层实现
//实现filter函数
function filter(fn){
var res = []
//遍历数组
for(var i=0;i<arr.length;i++){
if(fn(arr[i],i,arr)){
res.push(arr[i])
}
}
return res
}some 有一些满足就返回true 否则返回false
//some 一些 every 每一个
var value = arr.some(function(value,index,arr){
return value>4
})
console.log(value);//trueevery 每一个满足就返回true 否则返回false
var value = arr.every(function(value,index,arr){
return value>4
})
console.log(value);//false底层实现
//底层实现 some
function some(fn){
var isTrue = false
for(var i=0;i<arr.length;i++){
if(fn(arr[i],i,arr)){
isTrue = true
break
}
}
return isTrue
}
//底层实现 some
function every(fn){
var isTrue = true
for(var i=0;i<arr.length;i++){
if(!fn(arr[i],i,arr)){
isTrue = false
break
}
}
return isTrue
}indexOf 返回对应的下标
lastIndexOf 返回对应的下标
console.log(arr.indexOf(1,2));//从下标开始找 找这个1这个数字第一次出现的位置(左到右)
console.log(arr.lastIndexOf(1,5));//从下标5开始找 找1第一个次出现的位置(右到左)字符串加强 （模板字符串 ）
var a =
hello'
console.log(`${a} world`) //hello worldes5新增的改变this指向的方法
bind （不会自动执行）
call （自动调用函数）
apply （自动调用函数）
function say(name,password){
console.log(this);//指向window
console.log(name,password);
}
say()//打印window
//通过函数调用
var obj = {username:"jack"}
// bind把这个函数里面的this绑定对应的obj（不会自动执行 需要函数调用才可以执行）
say.bind(obj)('jack','123')//打印的this指向的是obj //jack 123
// call 将this指向和某个内容联系在一块 自动调用 一个一个的传参
say.call(obj,'tom','456')//tom 456
// apply 将this指向重新指向给对应的某个内容 自动调用 数组形式的传参
say.apply(obj,['haha','789'])//haha 789call和apply的区别
- call传递的参数是一个个的内容，使用,隔开
- apply传递的参数是一个整个数组
es6的新特性
概述：es6对应数组 字符串 对象及函数以及循环,值类型，修饰符等都有加强（es6以后的内容都称为
es6的内容）
数组的增强
var array = Array.of(1,2,3,4,5)
console.log(array);
var lis = document.querySelectorAll('li')
Array.from(lis).forEach(function(li){
console.log(li.innerText);
})
// find查找对应的元素 返回第一个找到的元素
var value = [1,2,3,4,5].find(function(value){
return value != 5
})
console.log(value);
var li = Array.from(lis).find(function(li,index,arr){
console.log(index);
console.log(arr);
return li.innerText == 5
})
console.log(li);var li = Array.from(lis).find(function(li){
return li.innerText == '5'
}) //找到对应匹配的元素
console.log(li);
//findIndex 查找对应的元素的下标 返回第一个找到的元素下标
var index = Array.from(lis).findIndex(function(li,index,arr){
return li.innerText == '5'
})
console.log(index);静态方法（使用类名.）
Array.of() 将一组数据转为数组
Array.from() 将伪数组转为数组
var array = Array.of(1,2,3,4,5)
console.log(array);
//具备某些数组的特性的对象称为伪数组 arguments NodeList HTMLCollection等
var lis = document.querySelectorAll('li')
// 伪数组是不具备数组的函数的
Array.from(lis).forEach(function(li){
console.log(li.innerText);
})字符的增强
// indexOf的基础上增强
// 是否包含 includes
console.log('abc'.includes('a'));//true
// endsWith 是否以这个字符串结尾
console.log('abc'.endsWith('abc'));
console.log('abc'.endsWith('c'));
// startsWith 是否以这个字符串开头
console.log('abc'.endsWith('a'));
console.log('abc'.endsWith('abc'));
// 平铺 平铺的次数 重复多次的写这个字符串
console.log('abc'.repeat(3));//重复写3次变量修饰符（增强）
var 关键词修饰的变量是伪全局变量（进行变量提升）
let 关键词 块状作用域 （变量名不能重复声明 避免变量名污染）
const 关键词 常量（常量不可变 也不能重复声明 声明一定要赋值（不能二次赋值））
// var 关键词修饰的变量是伪全局变量（进行变量提升）
// let 关键词块状作用域（变量名不能重复声明 避免变量名污染）
// const关键词 常量 （常量不可变 也不能重复声明 声明 一定要赋值）
var btns = document.querySelectorAll('button')
for(var i = 0;i<btns.length;i++){
btns[i].onclick = function(){//当前的事件是异步操作
console.log(i);//3,3,3
}
}
for(let i = 0;i<btns.length;i++){
btns[i].onclick = function(){//当前的事件是异步操作
console.log(i);//1,2,3
}
}
//let在同一作用域不能重复命名
// let a = 10
// let a = 5
// 报错
// 当省略对应的修饰符 默认就是以var关键词修饰
const a = 10
// a = 5 //错误
// const修饰的变量不允许修改
// const b const修饰的变量必须赋值
// bable.js可以把高版本变成低版本 写源码时不建议使用let和const新增的值类型
旧有值类型
number , String , boolean , null , undefined
新增的类型
symbol 独一无二的值 bigInt 大的整型
// symbol 独一无二的值
var sy = Symbol('这个值很重要')//里面的参数只是说明
console.log(sy);
console.log(sy.description);//获取里面的详细信息 也可以设置 当前这个详情是只读属性 description
// key是独一无二的 symbol可以当作对象的key值
var obj = {sy:'hello'}
console.log(obj.sy);
// bigInteresting大的整型（存储number存不了的数据）
// 传入字符串
var str = '12345678939842935912312324335456357646768'
var number = '1234567893256768'
console.log((Number(str)));
console.log(number);
var bigNumber = BigInt(str)
console.log(bigNumber);
//bigInt 大的整型(存储number存不了的数据) 实现的方式 字符串传入实现
// 传入字符串
var str = '123456789123456789'
console.log( Number(str));
var bigNumber = BigInt(str)
console.log(bigNumber);对象的增强
静态方法
is方法 Object.is() 判断俩个对象是否是一个（true或者false）
Object.assign 将后面对象合并当前前面 返回的是合并的对象
// 静态方法
// is方法 判断两个对象是否为一个
var obj ={}
var obj1 = {}
console.log(obj == obj1);//false
console.log(obj === obj1);//false
console.log(Object.is(obj,obj1));//false {}为对象
console.log(NaN == NaN);//false
console.log(Object.is(NaN , NaN));//true NaN为常量
console.log(Object.is({} , {}));//false {}为对象
// assign 目标对象 来源对象 将后面的合并到前面
var obj = {sex:'男'}
var res = Object.assign(obj,{name:'李月梦',age:38})
console.log(res);
console.log(obj);
console.log(Object.is(obj,res));//true 浅拷贝 函数增强
箭头函数
<body>
<button>1</button>
</body>
</html>
<script>
console.log(this);//window
// this函数谁调用 this指向谁 是在对应的普通函数的情况下
document.querySelector('button').onclick = function(){
console.log(this);
}
document.querySelector('button').onclick = ()=>{
console.log(this);//箭头函数里面没有this 根据作用域链的情况 向上找
}
var hello = ()=>{
console.log(this);//window
}
hello.call({age:18})
var obj = {
age:15,
say:()=>{
console.log(this);//window 因为箭头函数没有this
}
}
obj.say()
// 函数对象里面添加一个属性 say
/* function test(){
this.say = () =>{//这里this指向window
console.log(this);
}
}
test.say()//调用函数对象里面对应的方法 */
function test(){
console.log(this);
return ()=>{
console.log(this);
}
}
test()()//调用函数对象里面对应的方法
// test.call({username:'hello'})()//{username:'hello'} {username:'hello'}默认参数
// 初始化一个对象
function initObj(name,age=18,sex='boy'){
return {
name,age,sex
}
}
console.log(initObj('jack'));//没有传参会使用默认值
console.log(initObj('rose',19,'girl'));//传参后会覆盖默认值对象里面内容的简化
属性的简化
当你的属性值是一个变量的情况下，以及你向使用你的变量作为key的名，这个时候可以省略key
// Object的几个方法 可以用来实现对象的遍历
// keys方法
var obj = {age:18,name:'rose',sex:'girl'}
// 获取所有的key，作为迭代对象
var k = Object.keys(obj)
console.log(k);
for(var value of k){
console.log(value);
}
// 获取所有的value 拿到所有的值
var v = Object.values(obj)
console.log(v);
for(var value of v){
console.log(value);
}
// 获取所有的key-value对 所有的键值对
var e = Object.entries(obj)
console.log(e);
for(var value of e){
console.log(value);
}
// 新增的对应的迭代器类型（实现了迭代器
// set元素不重复的一个集合（天然去重
// set声明
var set = new Set()
var arr = [1,2,3,3,4,2,1,4]
var set = new Set(arr)
console.log(set);
// map基于set和array之上构建的一个集合
// 无参的形式
var set = new Set()
set.add(1)
set.add(2)
set.add(1)
// 获取对应的长度
console.log(set.size);//2
// 删除的方法 delete remove
set.delete(1)
console.log(set);
// set.clear()//清空
// console.log(set);
// 获取元素
set.keys()//获取所有的key 值是key key也是值
console.log(set);
var key = set.keys()//获取key
console.log(key);
var v = set.values()//获取值
console.log(v);
var kv = set.entries()//获取所有的键值对
console.log(kv);
set.forEach((v,k,set)=>{//三个参数分别为value，key，set
console.log(v);
})
console.log(set.has(2));//判断是否存在 返回boolean类型 true或者false
console.log(set);练习
// 1, 使用reduce求数组中所有元素的乘积， var arr = [2,3,4,5,6,7]
var arr = [2,3,4,5,6,7]
var res = arr.reduce((x,y)=>x*y)
console.log(res);
// 2, 使用reduce求数组中的最大数, var arr = [2,4,6,3,7,8,5]
var arr = [2,4,6,3,7,8,5]
arr.maxValue = arr.reduce(function(v1,v2){
return v1>v2?v1:v2
},0)
console.log('最大值',arr.maxValue);
// 3, 使用indexOf完成数组去重.
function unique(arr){
var newarr = [];
for(i=0;i<arr.length;i++){
if(newarr.indexOf(arr[i]) === -1){
newarr.push(arr[i]);
}
}
return newarr;
}
var arr1 = unique(['a','v','a']);
console.log(arr1)
// 4. 使用for-of求5! (1*2*3*4*5)
var arr = [1,2,3,4,5]
var sum = 1
for(let value of arr){
sum = sum*value
}
console.log(sum);
标签：学习,arr,set,console,log,value,Js,day14,var 来源： https://www.cnblogs.com/liu-2001/p/16577546.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。