ES6语法篇

最新推荐文章于 2023-12-25 12:11:47 发布
最新推荐文章于 2023-12-25 12:11:47 发布
阅读量705 收藏
点赞数 1
分类专栏： ES6 文章标签： javascript 前端 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52519753/article/details/122026507
版权

Es6

第一章:ECMASript 相关介绍

1.1.什么是 ECMA

	ECMA（European Computer Manufacturers Association）中文名称为欧洲计算机制

	造商协会，这个组织的目标是评估、开发和认可电信和计算机标准。1994 年后该

	组织改名为 Ecma 国际。

1.2.什么是ECMAScript

	ECMAScript 是由 Ecma 国际通过 ECMA-262 标准化的脚本程序设计语言。

1.3.什么是 ECMA-262

	Ecma 国际制定了许多标准，而 ECMA-262 只是其中的一个，所有标准列表查看

	[http://www.ecma-international.org/publications/standards/Standard.htm](http://www.ecma-international.org/publications/standards/Standard.htm)

1.4.ECMA-262 历史

	ECMA-262（ECMAScript）历史版本查看网址

	[http://www.ecma-international.org/publications/standards/Ecma-262-arch.htm](http://www.ecma-international.org/publications/standards/Ecma-262-arch.htm)

1.5.谁在维护ECMA-262

 	TC39（Technical Committee 39）是推进 ECMAScript 发展的委员会。其会员都是

	公司（其中主要是浏览器厂商，有苹果、谷歌、微软、因特尔等）。TC39 定期

	召开会议，会议由会员公司的代表与特邀专家出席

1.6.学习ES6 的意义

	⚫ ES6 的版本变动内容最多，具有里程碑意义

	⚫ ES6 加入许多新的语法特性，编程实现更简单、高效

	⚫ ES6 是前端发展趋势，就业必备技能

第二章:ECMASript 6** 新特性

1. let

// 声明变量
 let a;
 let b, c, d;
 let e = 100;
 e = 45;
 let f = 521, g = 'love', h = []

 
 // 1.let变量不能够重复命名,否者会报错;var可以重复命名,不会报错
 // let star = 'lqc'
 // let star = 'lqz'
 
 // var g = 21;
 // var g = 21;
 
 // 2. 新增块级作用域,之前的es5只有全局作用域和函数作用域,es6新增了块级作用域
 // 	就是let与{}大括号配合使用形成块级作用域,块级作用域还有for ,if 
 		{
 			let name='路飞'
 		}
 		console.log(name);
 // 3. 不存在变量提升
 // console.log(song);
 // let song='童声'
 // 报错,显示未定义 
 // var 
 console.log(song1);
 var song1='童声'
  // 显示undefined
  // 4.不影响作用域链
  // 作用域就是在一定的空间里可以对数据进行读写操作，这个空间就是数据的作用域。

 // var a = "xiaoxujs";
 // function fun1(){
 //     function fun2(){
 //         console.log(a)
 //     }
 // }
 // 作用域链就是 当fun2调用a的时候，就会先在函数fun2中寻找，找不到就会去fun1中寻找，再找不到就会去全局里面寻找。

  let school="尚硅谷";
  function fn(){
 	 console.log(school);
  }
  fn()

实例:

<h3>切换颜色</h3>
 	<div class="item"></div>
 	<div class="item"></div>
 	<div class="item"></div>
 	<script type="text/javascript">
 		let items=document.getElementsByClassName('item'); // length是3
 		for(let i=0;i<items.length;i++){
 			items[i].onclick=function(){
 				items[i].style.background='pink';
 			}
 		}
 	</script>

2. const

const SCHOOl='尚硅谷'
 		
 		// 1.要初始值
 		// 2.常量名要大写
 		console.log(SCHOOl);
 		// 3.赋值之后不能修改
 		// SCHOOl="l"
 		{
 		const PLAYER='UZI';
 		}
 		// 4.报错,因为const也有块级作用域,应该放在大括号里面
 		console.log(PLAYER);
 		// 5.对数组和对象的元素的元素修改,不算对常量做修改,常量的地址是堆内存的地址
 		const TEAM=['UZI',"MXLG","Ming"];
 		TEAM.push('meiko')
 		console.log(TEAM);

3.解构赋值

 	const zong=['one','two','three','four']
 	let [a,b,c,d]=zong
 	console.log(a);
 	console.log(b);
 	
 	let zong0={
 		name:'lqc',
 		age:21,
 		height:function(){
 			console.log('gaodu');
 		}
 	}
 	
 	let {name,age,height}=zong0 //name要相对应
 	console.log(name,height);

4.模板字符串(多用于模板的定义dom元素)

 // 1.内容可以直接换行
 	let template=`
 	<div id="">
 		<li>java</li>
 		<li>C</li>
 	</div>
 	`

5.对象简化写法

一般我们都是把数据写到对象里面的,而这种写法是移至进来的

// 类似字面量的加强写法
 	let  name='lqc'
 	let change=function(){
 			console.log('我可以改变你');
 		}
 	const school={
 		name,
 		change,
 		improve:function(){
 			console.log('技能');
 		}
         //简化改为这种写法
         improve(){
 			console.log('技能');
 		}
 	}
 	console.log(school);

6. 箭头函数

// 1.写法
			let fn=function(){
				
			}
			let fn1=(a,b)=>{
				console.log(a+b);
			}
			
// 2.箭头函数的this是静态的,
		function getName(){
			console.log(this.name);
		}
		window.name="硅谷";
		
		let getName1=()=>{
			console.log(this.name);
		}
		const school={
			name:'ATGUIGU'
		}
		
		getName.call(school) // ATGUIGU
		getName1.call(school) //硅谷

// 3. 箭头函数不能进行实例化
		let Person=(name,age)=>{
			this.name=name
			this.age=age
		}
		let p=new Person('lqc',20)
// 4.箭头函数不可以使用arguments
		let a=function(){
			console.log(arguments[0]); //1
			// 对象类型,是一个伪数组
		}
		a(1,2,3,4)
		
		let b=()=>{
			console.log(arguments[0]); //报错
		}
		b(1,2,3,4,5)
// 5.箭头函数的简写
		// 当参数只有一个的时候,就不需要括号了
		// 当大括号只有一条语句的时候,就省略return和大括号了
		let mess=math=>
			 math*math;
		
		console.log(mess(2));

例子:

1.this的指向

<style type="text/css">
		#one{
			width: 40px;
			height: 40px;
			background-color: aqua;
		}
</style>	
	<div id="one">
			
	</div>
// js代码,版本一
let one=document.getElementById("one")
		one.addEventListener('click',function(){
			_this=this//这里的function是由one进行调用的
			window.setTimeout(function(){
				console.log(this);//window,因为setTimeout是在window里面的
				_this.style.background="red";
			},2000)
            //setTimeout(function(){},时间)
		})
//js代码版本二
let one=document.getElementById("one")
		one.addEventListener('click',function(){
			_this=this
			window.setTimeout(()=>{
				console.log(this);//one
				this.style.background="red";
			},2000)
		})

心得:使用function(){}的this,是看是谁调用了这个函数;

使用箭头函数则是看,箭头函数的上一级非箭头函数的this值

2.filter()方法的使用,求偶数

心得:1.filter()方法对数组是暂时性的修改,想要永久修改可以设置新的变量,进行保存

let arrs=[2,3,4,5,7,6,7,5,234,443,32]
		const list=arrs.filter(item=>
			item%2===0 
		)
        console.log(list);// [2, 4, 6, 234, 32]

let arrs=[2,3,4,5,7,6,7,5,234,443,32]
		const list=arrs.filter(function(item){
			if(item%2===0){
				return true
			}else{
				return false
			}
		})
		console.log(list);// [2, 4, 6, 234, 32]

两个都是一样的效果,因为item%2===0 这个语句返回的是true和false,所以可以替代return true和return false

7. 函数默认值

// 1.形参给初始值,给的值一般要靠后
			function a1(a,b,c=5){
				return a+b+c
			}
			const result=a1(1,2)
			console.log(result);

8. argument与args

function data(){
				console.log(arguments);
// arguments是指data()括号里面的数据
			}
data('java','c','tcp')
// argument是伪数组(可以用索引),原型链上是object(用的是object方法)

			function date(...args){
				console.log(args);
			}
			date('java','c','tcp')
			// ...args是放在最后的,语法限制
			function date1(a,b,...args){
				console.log(a);
				console.log(b);
				console.log(args);
			}
			date1(1,2,'java','c','ip')

9.扩展运算符

<script type="text/javascript">
		//扩展运算符号用在Object型上
		//...扩展运算符号,讲数组转换为逗号分隔符
			function mess(a,b,c){
				console.log(a,b,c);//java c ip
			}
			a=['java','c','ip']
			mess(...a)

实例:

// 1.数组合并
			let name=['java','c','c++']
			let name1=['ip','icp']
			let ht=name.concat(name1)
			console.log(ht);
			let ht1=[...name,...name1]
			console.log(ht1);
			i=Array(...name)
			console.log(i);
			// 2.数组克隆
			let name3=[...name]
			console.log(name3);
			// 3.数组与逗号分隔符相互转化
			let ht3=[...name]

10.symbol

//ES6 引入了一种新的原始数据类型 Symbol ，表示独一无二的值，最大的用法是用来定义对象的唯一属性名。

// ES6 数据类型除了 Number 、 String 、 Boolean 、 Object、 null 和 undefined ，还新增了 Symbol 。
			let a=Symbol()
			console.log(a);
			let b=Symbol('java')
			let b1=Symbol('java')
			console.log(b===b1);
			// Symbol.for()
			let c=Symbol.for('c');
			let c1=Symbol.for('c');
			console.log(c===c1);
			// let result=b+'la';
			// 不能与其他数据进行运算
			// console.log(result);
			// number string null undfind object boolean symbol 		
			
			let obj={
				name:'java',
				[Symbol('say')](){
					console.log('say');
				}
			}

11.迭代器

1.迭代器的基本知识

		// 1.迭代器是一种接口,为各种不同的数据提供统一的遍历操作,有一些数据没有原生的iterator
			// 接口,我们可以自己安装,这个接口就是和for...of搭配使用的,让for...of进行消费. 
			const op={
				a:Symbol('ab'),
			}
			console.log(op.a);//Symbol('ab')
		
			const xiyou=['tz','swk','sz']
			// 2. for ...of 是保存的是数组里面的数据,for...in 是保存索引
			for(let v of xiyou){
				console.log(v);
			}
			console.log(xiyou);//查看一个Symbol(Symbol.iterator)查看是否有这个东西
			// 3.工作原理
			// 创建一个指针对象,指向一个数据结构起始位置
			// 每调用一个next(),就会不断往后移动,直到最后一个成员
			//next()返回一个{value:值,done:false}
			
			let Iterator=xiyou[Symbol.iterator]() //{value: undefined, done: true}
			console.log(Iterator.next());
			console.log(Iterator.next());
			console.log(Iterator.next());
			console.log(Iterator.next());
			// done:true 表示遍历完成,如果为false会不停遍历下去的
			// next()返回一个done和value值

2.制造一个迭代器



// 1. 使用for ...of 是可以检查对象有没有iterator,没有的话使用for...of报错
			const banji={
				name:'一班',
				stus:['tz','swk','sz'],
				[Symbol.iterator](){
					let index=0;
					let _this=this
					return{
						next(){
							if(index<_this.stus.length){
								
								const result= {value:_this.stus[index],done:false}//超出范围value就是undifind
								index++;
								return result;//在这里可以控制返回的代码时间
						}else{
							return {value:undefined,done:true}
							
						}
						}	
					};
				}
			}
			for(let v of banji){
				console.log(v);
			}

12. Promise

node.js读取文件格式

const fs=require('fs')
 
// 2.调用方法读取文件
fs.readFile('./为学.md',(err,data)=>{
	  // 失败就抛出错误
	  if(err) throw err;
	  console.log(data.toString());
})

node.js与Promise一起使用


	const p=new Promise(function(resolve,reject){
		fs.readFile('./为学.md',(err,data)=>{
			if(err)reject(err);
			resolve(data);
	})})

	p.then(function(value){
				console.log(value.toString());
			},function(reason){
				console.log("读取失败");
			})


const p=new Promise((resolve,reject)=>{
	fs.readFile('./为学.md',(err,data)=>{
		resolve(data)
	})
	
})
p.then(value=>{
	// console.log(value.toString());
	return new Promise((resolve,reject)=>{
		fs.readFile('./李白.md',(err,data)=>{
			resolve([value,data])
		})
	})
	// value是数组,可以使用join变成string
}).then(value=>{
	return new Promise((resolve,reject)=>{
		fs.readFile('./python.md',(err,data)=>{
			value.push(data)
			resolve(value)
		})
	}).then(
	value=>{
		// join()是加入的意思,参数会在不同索引之间加入参数
		console.log(value.join("\r\n"));
		// console.log(value.toString());
	}
)
})



	const p=new Promise(function(resolve,reject){
		fs.readFile('./为学.md',(err,data)=>{
			if(err)reject(err);
			resolve(data);
	})})

	p.then(function(value){
				console.log(value.toString());
			},function(reason){
				console.log("读取失败");
			})


	const p=new Promise((resolve,reject)=>{
			// 1.创建对象
			// XMLHttpRequest是与服务器进行交互的
			const xhr=new XMLHttpRequest();
			// 2.初始化
			xhr.open("GET",'https://api.apiopen.top/getJoke',true);
			// 3.发送
			xhr.send()
			// 4.绑定时间,处理响应结果
			// 在 onreadystatechange 事件中，我们规定当服务器响应已做好被处理的准备时所执行的任务。
			xhr.onreadystatechange=function(){
				// 进入
				//  0 － （未初始化）还没有调用send()方法
				 // 1 － （载入）已调用send()方法，正在发送请求
				 // 2 － （载入完成）send()方法执行完成，已经接收到全部响应内容
				 // 3 － （交互）正在解析响应内容
				 // 4 － （完成）响应内容解析完成，可以在客户端调用了
				if(xhr.readyState===4){
					// 判断状态响应码在200至299之间
					if(xhr.status>=200&& xhr.status<300){
						// console.log(xhr.response);
						resolve(xhr.response)
					}else{
						// 如果失败
						// console.log(xhr.status);
						reject(xhr.status)
					}
				}
			}
			
			})
			
			p.then(function(value){	
				console.log(value);
				},function(reason){
				console.log(reason);
			
				
				
			})

13. ES6暴露语法

// 模块化的好处
// 1.不同模块的冲突 (不同模块出现相同变量名字,不会影响) 2.代码复用 3.高维护性(人员各自修改自己的文件)
// 2. es6有自己的模块化规范,之前有commonJs,AMD,CMD
// 3. ES6的模块化语法

// 分别暴露
 export let school='java';

 export function teach(){
	console.log('我们教学java');
 }


// 选择暴露
let school='java';
function teach(){
	console.log('我们教学java');
 }
 export {school,teach}
 
// 默认暴露
export default{
	school:'java',
	teach(){
		console.log('我们教学java');
	}
}

	<script type="module"> //这里是模块类型的引入,不是<script type="text/javascript"> </script>
			//1.通用导入形式
			import * as a from "./js1.js" //* 代表所有的引入的东西
			
			// // 2.解构赋值(一般都是js文件是   export {school,teach})之后才解构赋值
			import {school as pp,teach} from "./js1.js"
			import {school as guigu,teach} from "./js1.js"
				
			//3.默认暴露,使用在export default{},括号里面对象很多的时候的情况下
			import {default as m3} from './js1.js'
			conslo.log(a)
			console.log(a.default.school);
			
			// 4.默认暴露(针对export default 只有一个的时候)
			import m3 from './js1.js'
	</script>

14. Set对象

基本语法(可以在原型链看语法)

let s=new Set()
			console.log(s);
			 // 返回的是Set对象
			let s1=new Set([1,2,3,4,5,6,1,2,3])
			const s2=[12,45]
			console.log(s1);
			// console.log(s1);
			s1.add('lol')
			console.log(s1);
			s1.delete(1)
			console.log(s1);
			console.log(s1.has(2));//返回的是boolean类型
			// s1.clear()
			console.log(s1);
			for(var i of s2){
				console.log(i);
			}

例子:与filter()一起使用

let arr=[1,2,3,4,5,6,1,2,3,4]
			const p=new Set(arr);
			console.log([...p]);
			// 2.交集
			let arr2=[1,2,3,41,1]
			// filter()方法最终返回的元素,可以存储到数组之中
			let result=[...p].filter(item=>{
				const p1=new Set(arr2);
				if(p1.has(item)){
					// 用has()返回的是boolean,可以很快的判断一个元素是否在数组里面,
					// 之前都是拿一个元素与数组里面的元素一个一个遍历
					return true
				}else{
					return false
					}
				// return p1.has(item) 简洁的做法
			})
			console.log(result);
		// 3.并集
		let arrcount=[...arr2,...arr]
		console.log(arrcount);
		let arrcount1=new Set(arrcount)
		console.log(arrcount1);

14.Map()对象

// 1.key可以放任何类型. 
			// 声明元素
			let m=new Map();
			//添加元素
			console.log(m);
			m.set('name','硅谷')
			m.set("changge",function(){
				console.log('改变一切');
			})
			let key={
				school:'TGUIGU'
			}
			m.set(key,['北京','上海','深圳'])
			
			m.delete('name') //根据key值
			console.log(m);
			// m.clear()
			// Map()可以用的键值对可以用数组找到
			for(let v of m){
				console.log(v[1]);
			}

15.async函数

// async 函数和await函数让异步代码像同步代码一样
		// async返回的是promise类型,类型里面的数据是由返回值决定
		async function fn(){
// 这种是成功的情况,return 
			// resolve
			// return '12'
			// 返回的是promise,返回成功的的信息resolve和信息
// 失败的情况是 	throw new Error("")		
			// reject
			// throw new Error('出错啦!')    
			//返回的是promise类型,返回成功的的信息rejected和信息

			// 返回的是promise类型
			
			// 类似于
			new Promise((resolve,reject)=>{
			})
			
			return new Promise((resolve,reject)=>{
				reject('失败的数据')
			})//返回的是promise,返回成功的的信息rejected和信息
		}	
			
		const result=fn()
		
		result.then(value=>{ 
			console.log(value);
		},reason=>{console.log(reason);})

16. await函数


// 1.await 放在async函数里面;2.
			// 创建一个promise对象
			// promise对象是一个object类型
			const p=new Promise((resolve,reject)=>{
				resolve("success")
			})
			
			async function fn(){
				// return 'success1'\
				throw new Error('err')
			} 
			const o=fn()
			
			console.log(o);
			async function main(){
				try{
				let result=await o;
				//await是取得成功的值}
				console.log(result);	
			}catch(e){
				console.log(e);
			}
			}
			main()

17.async和await结合读取文件读取

运行的话在终端使用node 文件名.js

			const fs=require("fs")
			
			// resolve,reject 是一个Buff流
			function readweixue(){
			return new Promise((resolve,reject)=>{
				fs.readFile('./为学.md',(err,data)=>{
					if(err)reject(err);
					resolve(data);
				})
			})}
			
			function readweixue1(){
			return new Promise((resolve,reject)=>{
				fs.readFile('./李白.md',(err,data)=>{
					if(err)reject(err);
					resolve(data);
				})
			})}
			// 让每一个行数读取一个文件,彼此不相连,读取到的数据会让 await 提取出来,之后汇总
async function main(){
	let o=await readweixue();	
	let o1=await readweixue1()
	console.log(o.toString());
	console.log(o1.toString());
}
main()

结合ajax读取数据
思路:就是让函数去拿数据,之后在总函数提取数据,之后在总函数存起来,需要时用try包裹起来

function readAjax(url){
	return new Promise((resolve,reject)=>{
		const x=new XMLHttpRequest();
		x.open('get',url)
		x.send()
		x.onreadystatechange=function(){
			if(x.readyState==4){
				if(x.status>=200 && x.status<=300){
					resolve(x.response)
				}else{
					reject(x.status)
				}
			}
		}
	})
}


readAjax().then(value=>{
	
})

async function main(){
	// 因为result可能是报错的信息,用try{}catch{}包裹
	try{
	let result=await readAjax();
	// await是提取Promise的数据内容的,因为有了这个函数,所以外面要放async
	console.log(result);
	}catch(err){
		console.log(err);
	}
}

// 思路:就是让函数去拿数据,之后在总函数提取数据,之后在总函数存起来,需要时用try包裹起来
@追求卓越
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
ES6语法详解（三）
wmeng13的博客
10-28 319
一）集合对象 1） Set对象 Set对象是一组值的集合，这些值是不重复的，无序的，与我们在数学中学到的集合是一样的。我们可以往里面添加、删除、查询数据。 //先声明一个Set对象： var mySet = new Set();//创建Set对象 //往这个集合对象中添加元素： mySet.add(1); mySet.add("some text");;//在Set对象尾部添加一个元素。...
es6新语法及特性
weixin_62650212的博客
03-19 1万+
在现代前端开发中，JavaScript 已经成为了必不可少的一部分，而 ES6（ECMAScript 2015）则为 JavaScript 带来了一系列的新语法和特性，使得 JavaScript 更加现代化、高效和易用。作为开发者，掌握 ES6 是必不可少的，因为它可以提高我们的开发效率，减少代码冗余，并提高代码的可读性和可维护性。在本篇博文中，我们将介绍 ES6 中一些重要的新语法和特性，帮助读者更好地掌握这一新的 JavaScript 版本。
ES6新特性概览
weixin_33948416的博客
04-14 342
本文基于lukehoban/es6features ，同时参考了大量博客资料，具体见文末引用。 ES6（ECMAScript 6）是即将到来的新版本JavaScript语言的标准，代号harmony(和谐之意，显然没有跟上我国的步伐，我们已经进入中国梦版本了)。上一次标准的制订还是2009年出台的ES5。目前ES6的标准化工作正在进行中，预计会在14年12月份放出正式敲定的版本。但大部分标准已经...
ES6学习网站
最新发布
foreverhui的博客
12-25 986
W3Cschool ES6中文教程：https://www.w3cschool.cn/escript6/escript6-s4pc37et.html。菜鸟教程：https://www.runoob.com/w3cnote/es6-tutorial.html。阮一峰ES6学习电子书：https://es6.ruanyifeng.com/#docs/let。ES6官网：https://262.ecma-international.org/6.0/
ES6学习网址， http://es6.ruanyifeng.com/#docs/let
qq_24511933的博客
02-22 3256
ES6学习网址， http://es6.ruanyifeng.com/#docs/let
利用babel将es6语法转es5的简单示例
11-30
大家可以参考这篇文章：//www.jb51.net/article/90518.htm，这里介绍的非常详细。 文件目录结构 生成包管理配置文件package.json npm init -y 安装转换工具 npm i -g babel-cli npm i --save-dev babel-...
工作中常用到的ES6语法
10-18
ECMAScript 6是JavaScript语言的下一代标准，已经在2015年6月正式发布了。这篇文章主要介绍了工作中常用到的ES6语法,需要的朋友可以参考下
把JavaScript代码改成ES6语法不完全指南(分享)
10-19
下面小编就为大家带来一篇把JavaScript代码改成ES6语法不完全指南(分享)。小编觉得挺不错的，现在就想给大家，也给大家做个参考。一起跟随小编过来看看吧
详解Webstorm 新建.vue文件支持高亮vue语法和es6语法
08-29
本文将详细介绍如何在 Webstorm 中配置 Vue 文件高亮支持，包括支持高亮 Vue 语法和 ES6 语法。 一、配置 Vue 文件高亮支持 要配置 Vue 文件高亮支持，需要先安装 Vue 插件。首先，打开 Webstorm，点击右上角的 ...
ES6新语法
taptap1的博客
05-18 223
全局变量var var存在缺陷： 1.var可以重定义 例一 <script> var xxx=10; var xxx=11; console.log(xxx); </script> 结果: 例二 <button class="btn">按钮1</button> <button class="btn">按钮2</button> <button class="btn">按钮3</button
es6（一）
热门推荐
qq_36458203的博客
10-17 3万+
es6（一） ECMAScript 6.0（以下简称 ES6）是 JavaScript 语言的下一代标准，已经在2015年6月正式发布了。它的目标，是使得 JavaScript 语言可以用来编写复杂的大型应用程序，成为企业级开发语言。es6在2017年可谓是大火，被越来越多的人频频提及，在React、ReactNative开发中广泛使用。javascript在es6的推出后，是越来越健全，真不能
ES5、ES6、ES7 教程网址汇总
weixin_43254676的博客
12-31 2065
ES5电子教程 中文版：http://yanhaijing.com/es5/#58 英文版：https://people-mozilla.org/~jorendorff/es5.1-final.html ES6电子教程 中文版：http://es6.ruanyifeng.com/ 英文版：http://www.ecma-international.org/ecma-262/6.0/#sec-typ...
最新一期ES6特性，你值得了解！！！
weixin_33738555的博客
08-11 212
ES6的常用最佳特性及扩展  ES6（ECMAScript2015）的出现，无疑给前端开发人员带来了新的惊喜，它包含了一些很棒的新特性，可以更加方便的实现很多复杂的操作，提高开发人员的效率。 本文主要针对ES6做一个简要介绍。 主要译自：webapplog.com/ES6/comment…。也许你还不知道ES6是什么, 实际上, 它是一种新的javascript规范。在这个大家都很忙碌的时代，如...
【ES6】ES6超详讲解(＠_＠；)
weixin_46531416的博客
07-08 1622
JavaScript(浏览器端) = ECMAScript(语法 + API) + DOM + BOM
[JS]es6 @修饰器
chongqing2016的博客
06-16 96
@decorator class A {} // 等同于 class A {} A = decorator(A) || A; 转载于:https://my.oschina.net/u...
ES6语法基本使用
a846075506的博客
07-31 143
什么是ES6？ ECMAScript 6（以下简称ES6）是JavaScript语言的下一代标准，已经在2015年6月正式发布了。Mozilla公司将在这个标准的基础上，推出JavaScript 2.0。 ECMAScript是JavaScript语言的国际标准，JavaScript是ECMAScript的实现。 ES6的目标，是使得JavaScript语言可以用来编写大型的复...
ES6基础
jz1234_的博客
09-28 308
/ vue2响应式原理 Object.defineProperty 结合订阅发布模式 通过观察者连接视图与数据。异步: 同步是按顺序从上至下阻塞式执行代码上一行代码不执行完毕，下行是不会执行得。03 img onload加载 resolve img。迭代器 执行next方法 返回得就是yield生成内容。01 定义一个函数 返回一个promise。02 在promise创建一个img标签。需要通过 next()进行遍历。生成器执行完毕 返回的是迭代器。迭代器可以通过for of遍历。
ES6简介
秋城落叶的博客
03-31 326
ES6， 全称 ECMAScript 6.0 ，是 JavaScript 的下一个版本标准，2015.06 发版。 ES6 主要是为了解决 ES5 的先天不足，比如 JavaScript 里并没有类的概念 但是目前浏览器的 JavaScript 是 ES5 版本，大多数高版本的浏览器也支持 ES6，不过只实现了 ES6 的部分特性和功能,对 ES6 的支持可以查看kang...
ES6基本语法
qq_53582593的博客
05-27 699
ES6引入了很多新的语法和特性，包括箭头函数、let和const关键字、模板字符串、析构、类和模块
写一篇ES6 对象拓展笔记 附带代码
07-10
ES6 允许我们在对象字面量中使用简写语法来定义属性和方法。例如，如果属性名和变量名相同，我们可以省略冒号和变量名，只写属性名即可。 ```javascript const name = "John"; const age = 30; const person = { ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

@追求卓越

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值