ES6-ES11

最新推荐文章于 2024-06-13 02:48:16 发布
最新推荐文章于 2024-06-13 02:48:16 发布
阅读量589 收藏
点赞数
分类专栏： 笔记 文章标签： javascript 前端 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61726249/article/details/122751275
版权 
(function(){ //匿名函数自调用
	var a = 3
	console.log(a+3) //6
})()
var a = 4
console.log(a) //4

(function(){
	var a = 1
	function test(){
		console.log(++a)
}
window.$ = function(){
	return{
		test:test
	}
}
})()
$().test() //2

在这里插入图片描述

判断：
typeof：
可以区别：数值、字符串、布尔值、undefined、function
不能区别：null与对象，一般对象和数组
instanceid
专门用来判断对象数据的类型：
Object，Array与Function

===
可以判断：undefined和null
instanceof是如何判断的？
表达式：A instanceof B 实例对象 构造函数

实例对象的隐式原型等于构造函数的显式原型

执行上下文
1、先执行变量提升，再执行函数提升

内存、数据、变量
内存是用来存储数据的空间
变量是内存的标识
1.关于引用变量赋值的问题:
n个引用变量指向同一个对象，通过一个变量修改对象内部数据，其它所有变量看到的是修改之后的数据
两个引用变量指向同一个对象，让其中一个引用变量指向另一个对象，另一引用变量依然指向前一个对象
2.在js调用函数时传递变量参数时，是值传递还是引用传递
3.JS引擎如何管理内存？
①内存生命周期
分配小内存空间，得到它的使用权
存储数据，可以反复进行操作
释放小内存空间
②释放内存
局部变量：函数执行自动释放
对象：成为垃圾对象==>垃圾回收器回收

对象
如何确定this的值？
test（）:window
p.test: p
new test(): 新创建的对象
p.call(obj):obj

1.什么是对象
多个数据的封装体(集合体)
用来保存多个数据的容器
一个对象代表现实中的一个事物
2.为什么要用对象
统一管理多个数据
3.对象的组成
属性：代表现实事物的状态数据
由属性名（字符串）和属性值（任意值）组成
方法：代表现实事物的行为数据、一种特别的属性（属性值是函数）
4.如何访问对象内部数据
.属性名：编码简单，有时不能用
[‘属性名’]：编码简单，能通用
什么时候必须使用[‘属性名’]的方式？
①.属性名包含特殊字符：- 空格
②.属性名不确定

===========================
1.什么是函数？
具有特定功能的n条语句的封装体
只有函数是可以执行的，其他类型的数据不能执行
2.为什么要用函数？
提高代码复用
便于阅读交流
3.如何定义函数
函数声明
表达式
4.如何调用（执行）函数
直接调用test（）
通过对象调用obj.test()
new调用 new test()
临时让test成为obj的方法进行调用
test.call/apply(obj)

var obj5 = {}
			function test(){
				this.xxx = "你好"
			}
             //obj5.test() 不能直接调用，根本就没有此方法
			test.call(obj5)
			//可以让一个函数成为指定任意对象的方法进行调用
			console.log(obj5.xxx) //你好

=======================
什么函数才是回调函数？
1）你定义的
2）你没有调用
3）但最终执行了
常见的回调函数？
dom事件回调函数
定时器回调函数
ajax请求回调函数
生命周期回调函数

===============
IIFE（Immediately-Invoked Function Expression立即调用函数表达式）
别名：匿名函数自调用
作用
隐藏调用
隐藏内部实现
不会污染外部（全局）命名空间
用它来编码js模块

=================
1.this是什么？
任何函数本质上都是通过某个对象来调用的，如果没有直接指定就是window
所有函数内部都有一个变量this
它的值是调用函数的当前对象
如何确定this的值？
test（）:window
p.test: p
new test(): 新创建的对象
p.call(obj):obj

回调函数：异步执行
js单线程 也就是说只能有一个线程更新操作界面

箭头函数适合与this无关的问题，定时器，数组的方法回调
不适合与this相关的回调 比如dom事件回调、对象的方法
rest参数

for。。。in 键值
for。。。of键名

函数的prototype属性
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

1、每个函数都有一个protopype属性，它默认指向一个Object空对象（即称为：原型对象）
原型对象中有一个constructor，它指向函数对象

console.log(fun.prototype.constructor=fun)
2、给原型对象添加属性（一般是方法）=>实例对象可以访问

========
显式原型与隐式原型
1.每个函数function都有一个prototype，即显式原型（属性）
2.每个实例对象都有一个__proto__,可称为隐式原型
3.对象的隐式原型的值为其对应构造函数的显式原型的值
总结：
函数的prototype属性：在定义函数时自动添加的，默认值是一个空Object对象
对象的_proto_属性：创建对象时自动添加的，默认值为构造函数的prototype属性值
程序员能直接操作显式原型，但不能直接操作隐式原型（ES6之前）

1.读取对象的属性值时：会自动到原型链中查找
2.设置对象的属性值时：不会查找原型链，如果当前对象中没有此属性，直接添加此属性并设置其值
3.方法一般定义在原型中，属性一般通过构造函数定义在对象本身上

在这里插入图片描述
变量声明与提升
通过var 定义（声明）的变量，在语句之前就可以访问到
值：undefined
函数声明提升
通过function声明的函数，在之前就可以直接调用
值：函数定义（对象）

面试题：输出undefined
var a = 3
function fn(){
	console.log(a)
	var a = 4
}
fn()//undefined
=======================
console.log(b) //undefined 变量提升
fn2()//fn2() 函数提升 可调用
var b = 3
function fn2(){
	console.log('fn2()')
}
=======================

1.代码分类(位置)
全局代码
函数代码
2.全局执行上下文
在执行全局代码前将window确定为全局执行上下文
对全局数据进行预处理
var 定义的全局变量==>undefined，添加为window的属性
function声明的全局函数==>赋值（fun），添加为window的方法
this==>赋值（window）
开始执行全局代码
3.函数执行上下文
在调用函数，准备执行函数体之前，创建对应的函数执行上下文对象(虚拟的，存在于栈中)
对局部数据进行预处理
形参变量==>赋值（实参）>添加为执行上下文的属性
arguments>赋值(实参列表)，添加为执行上下文的属性
this==>赋值(调用函数的对象)
开始执行函数体代码

var a = 10
var bar = function(x){
	var b = 5
	foo(x + b)
}
var foo = function(y){
	var c = 5
	console.log(a + c + y)//30
}
bar(10)

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

// this是静态的，this始终指向函数声明时所在作用域下的this的值
			function getName(){
				console.log(this.name)
			}
			let getName2 = ()=>{
				console.log(this.name)
			}
			// 设置window对象的name属性
			window.name = '南风知我意'
			const school = {
				name:"ATGUIGU"
			}
			//普通调用方法
			getName()//南风知我意
			getName2()//南风知我意
			// call方法调用
			getName.call(school)//ATGUIGU
			getName2.call(school)//南风知我意
			// 不能作为构造实例化对象
			let Person = (name,age)=>{
				this.name = name;
				this.age = age;
			}
			// let Person = function(name,age){
			// 	this.name = name;
			// 	this.age = age;
			// }
			let me = new Person('xiaomi',18);
			console.log(me)
			//demo5.html:36 Uncaught TypeError: Person is //not a constructor
    //at demo5.html:36:13

箭头函数的简写
1）省略小括号，当形参有且只有一个的时候

let add = (n)=>{
	return n+n
}
console.log(add(9))//18
==========
let add = n=>{
	return n+n
}
console.log(add(9))//18
===========
let add = n=>n+n
console.log(add(9))//18

2)省略花括号，当代码体只有一条语句的时候，此时return必须省略、而且语句的执行结果就是函数的返回值

let pow = (n)=>n*n;
console.log(pow(8))//64

箭头函数适合与this无关的回调，定时器，数组的方法回调
箭头函数不适合与this有关的回调，事件回调，对象的方法

{
	name:'尚硅谷'，
	getName:()=>{
		this.name
	}
}

与结构赋值结合

function connect({host="127.0.0.1",username,password,port}){
	console.log(host)
	console.log(username)
	console.log(password)
	console.log(port)
}
connect({
	host:'atguigu.com',//这里不传值的话就用上边默认值，传的话就用传的值
	username:'root',
	password:'root',
	port:3306
})

ES6引入rest参数，用于获取函数的实参，用来代替arguments
ES5获取实参的方式

function date(){
	console.log(arguments)
}
date('黎明','郭富城','刘德华','张学友');
//Arguments(4) ['黎明', '郭富城', '刘德华', '张学友', callee: ƒ, Symbol(Symbol.iterator): ƒ]
//0: "黎明"
//1: "郭富城"
//2: "刘德华"
//3: "张学友"
=============
//rest参数
function date(...args){
	console.log(args)
}
date('黎明','郭富城','刘德华','张学友');
//['黎明', '郭富城', '刘德华', '张学友']

数组的合并

			const cat = ['橘猫','橘橘猫']
			const dog = ['拉布拉多','金毛']
			// const CatDog = cat.concat(dog)
			const CatDog = [...cat,...dog]
			console.log(CatDog)

数组的克隆

			const sanzhihua = ['E','G','M'];
			const sanyecao = [...sanzhihua]
			console.log(sanyecao)

将伪数组转为真正的数组

		<div></div>
		<div></div>
		<div></div>
		<div></div>
		<div></div>
const divs = document.querySelectorAll('div')
			const divArr = [...divs]
			console.log(divArr)
			//[div, div, div, div, div]

生成器其实就是一个特殊的函数
异步编程 纯回调函数 node fs ajax mongodb
函数代码的分隔符

function * gen(){
				console.log(111);
				yield '一直没有耳朵'
				console.log(222)
				yield '一直没有尾巴'
				console.log(333)
				yield '真奇怪'
				console.log(444)
			}
			let iterator = gen();
			console.log(iterator.next())
			console.log(iterator.next())
			console.log(iterator.next())
			console.log(iterator.next())
			// iterator.next()//111
			// iterator.next()//222
			// iterator.next()//333
			// iterator.next()//444
			
			// 遍历
			for(let v of gen()){
				console.log(v)
			}
111
 一直没有耳朵
222
一直没有尾巴
333
真奇怪
444
========================
生成器函数参数
		function * cat6(arg){
				console.log(arg);//AAA
				let one = yield 111;
				console.log(one);//BBB
				let two = yield 222;
				console.log(two);//CCC
				yield 333;
			}
			let iterator2 = cat6('AAA')
			console.log(iterator2.next()) //111
			// next方法可以传入实参
			console.log(iterator2.next('BBB'))
			console.log(iterator2.next('CCC'))

生成器函数实例

//一秒后输出111两秒后输出222，三秒后输出333
//回调地狱
		setTimeout(()=>{
				console.log(111)
				setTimeout(()=>{
					console.log(222)
					setTimeout(()=>{
						console.log(333)
					},3000)
				},2000)
			},1000)
========================
//生成器
function one(){
				setTimeout(()=>{
					console.log(111)
					iterator3.next()
				},1000)
			}
			
			function two(){
				setTimeout(()=>{
					console.log(222)
					iterator3.next()
				},2000)
			}
			
			function three(){
				setTimeout(()=>{
					console.log(333)
					iterator3.next()
				},3000)
			}
			
			function * gen6(){
				yield one();
				yield two();
				yield three();
			}
			let iterator3 = gen6()
			console.log(iterator3.next())

Set集合实践

let arr = [1,2,3,4,2,3,5]
			// set数组去重
			// let result = [...new Set(arr)]
			// console.log(result)//1,2,3,4,5
			// 2.交集
			let arr2 = [1,2,4,4,6]
			let result = [...new Set(arr)].filter(item=>{
				let s2 = new Set(arr2)
				if(s2.has(item)){
					return true
				}else{
					return false
				}
			})
			let result8 = [...new Set(arr)].filter(item=>new Set(arr2).has(item));
			console.log(result8)
			
			// 并集
			let union = [...new Set([...arr,...arr2])];
			console.log(union)//1,2,3,4,5,6
			// 差集
			let diff = [...new Set(arr)].filter(item=>!(new Set(arr2).has(item)));
			console.log(diff)//3,5

Map

let m = new Map()
			m.set('name','橘猫')
			m.set('age',3)
			m.set('change',function(){
				console.log('橘猫巨可爱')
			});
			let key = {
				school : 'ATGUIGU'
			};
			m.set(key,['北京','上海','深圳']);
			
			console.log(m)
			console.log(m.size)//4
			console.log(m.has('name'))//true
			console.log(m.get('age'))//3
			
			// 遍历
			for(let v of m){
				console.log(v)
			}

size 返回Map元素个数
set 添加一个新元素，返回当前Map
get 返回键名对象的键值
has 检查Map中是否包含某个元素，返回boolean值
clear清除集合，返回undefined

class类
1.class声明类
2.constructor定义构造函数初始化
3.extends继承父类
4.super调用父级构造函数
5.static定义静态方法和属性
6.父类方法可以重写

function Phone(brand,price){
				this.brand = brand
				this.price = price
			}
			//添加方法
			Phone.prototype.call = function(){
				console.log('我可以打电话')
			}
			// 实例化对象
			let Huawei = new Phone('华为',5999)
			Huawei.call()
			console.log(Huawei)
			=========
			class Shouji{
				// 构造方法,名字不能修改
				constructor(brand,price){
					this.brand = brand 
					this.price = price
				}
				// 方法必须使用该语法，不能使用ES5的对象完整形式
				call(){
					console.log('我可以打电话')
				}
			}
			let onePlus = new Shouji("1+",1999);
			console.log(onePlus)
=====================
//static标注的属性和方法 不能作为实例对象的属性和方法
class Phone1{
				// 静态属性
				static name = '手机';
				static change(){
					console.log("我可以改变世界");
				}
			}
			let nokia = new Phone1();
			console.log(nokia.name)//undefined
			console.log(Phone1.name)//手机
			================
			//类继承
			class Phone2{
				constructor(brand,price) {
				    this.brand = brand
					this.price = price
				}
				call(){
					console.log('我可以打电话')
				}
			}
			class SmartPhone2 extends Phone2{
				// 构造方法
				constructor(brand,price,color,size) {
				    super(brand,price)
					this.color = color
					this.size = size
				}
				photo(){
					console.log('拍照')
				}
				video(){
					console.log('视频')
				}
			}
			let xiaolingtong = new SmartPhone2('小灵通',999,'黑色','11inch')
			console.log(xiaolingtong)

get和set

// get和set
			class phone2{
				get price(){
					console.log('价格属性被读取了');
					return 'hhhh'
				}
				
				set price(newVal){
					console.log('价格属性被修改了')
				}
			}
			
			let s = new phone2();
			console.log(s.price) //价格属性被读取了
			s.price = 'free' //价格属性被修改了

数值扩展
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
对象方法扩展
1.Object.is判断两个值是否完全相等

console.log(Object.is(120,20)) //false
			console.log(Object.is(NaN,NaN)) //true 
			console.log(NaN===NaN)//false

2.Object.assin对象的合并

const config1 = {
				host:'localhost',
				port:3306,
				name:'root',
				pass:'root',
				test:'test'
			}
			
			const config2 = {
				host:'http://atguigu.com',
				port:33060,
				name:'jumaoleyuan.com',
				pass:'hhh',
				test2:'test2'
			}
			console.log(Object.assign(config1,config2))
			// host: "http://atguigu.com"
			// name: "jumaoleyuan.com"
			// pass: "hhh"
			// port: 33060
			// test: "test"
			// test2: "test2"

3.Object.setPrototypeOf设置原型对象 Object.getPrototypeof

const school2 = {
				name:'尚硅谷'
			}
			const cities = {
				xiaoqu:['北京','上海','深圳']
			}
			Object.setPrototypeOf(school2,cities);
			console.log(Object.getPrototypeOf(school2));//xiaoqu: (3) ['北京', '上海', '深圳']
//[[Prototype]]: Object

			console.log(school2) //{'name':'尚硅谷'}

ES7新特性
在这里插入图片描述

  1. async 函数的返回值为 promise 对象，
  2. promise 对象的结果由 async 函数执行的返回值决定
  3. await 必须写在 async 函数中
  4. await 右侧的表达式一般为 promise 对象
  5. await 返回的是 promise 成功的值
  6. await 的 promise 失败了, 就会抛出异常, 需要通过 try…catch 捕获处理
    在这里插入图片描述
// trim用来清除字符串的空白
			// trim
			let str = '     hhhh     '
			console.log(str);
			console.log(str.trimStart())
			console.log(str.trimEnd())

// flat
			// 将多维数组转化为低维数组
			const arr666 = [1,2,3,[4,5,[5,6]]]
			// 参数为深度，是一个数字 默认值是1，将三维转成二维 传2 将三维降低两个维度 成一维
			console.log(arr666.flat())
			// flatMap
			const arr777 = [1,2,3,4]
			const result999 = arr777.map(item=>item*10)
			console.log(result999)//10,20,30,40

allSettled

			// 声明两个promise对象
			const p1 = new Promise((resolve,reject)=>{
				setTimeout(()=>{
					resolve('商品数据 -1')
				},1000)
			});
			
			const p2 = new Promise((resolve,reject)=>{
				setTimeout(()=>{
					// resolve('商品数据 -2')
					reject('出错啦')
				},1000)
			});
			
			// 调用allsettled 方法（始终返回成功）
			const result0 = Promise.allSettled([p1,p2]);
			console.log(result0)
			// const res = Promise.all([p1,p2])==失败返回失败，成功返回成功
			// console.log(res)

在这里插入图片描述
在这里插入图片描述
但是不能使用浮点型转化
在这里插入图片描述

console.log(globalThis)
始终指向window 全局对象
在这里插入图片描述

橘猫敲代码
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ES6 模块
glenshappy的专栏
08-13 344
概述 在 ES6 前， 实现模块化使用的是 RequireJS 或者 seaJS（分别是基于 AMD 规范的模块化库， 和基于 CMD 规范的模块化库）。 ES6 引入了模块化，其设计思想是在编译时就能确定模块的依赖关系，以及输入和输出的变量。 ES6 的模块化分为导出（export） @与导入（import）两个模块。 特点 ES6 的模块自动开启严格模式，不管你有没有在模块头部加上use strict;。 模块中可以导入和导出各种类型的变量，如函数，对象，字符串，数字，布尔值，类等。 ..
Web前端 前端ES6教程 涵盖ES6-ES11
10-20
Web前端 前端ES6教程 涵盖ES6-ES11
ES6中，用import导入同一个文件夹下多个模块的简便写法
weixin_38203203的博客
09-15 5753
需求如下:在layout的index.vue中导入components下的文件 写法一：在components中新建index.js，里面引入各个文件，把每个文件中的默认接口改写为具名接口 1.写法源于ES6中： 2.最后在想要引入的地方使用如下的写法即可。（以下省略写法其实就是...from "./components/index.js"） 写法二：（待总结） const context = require.context('layout/components/', true,
ES6导入与导出(module)
Sapling
09-24 1371
在ES6之前JavaScript是没有真正性的模块化，导入与导出的，之前有common.Js，AMD，在ES6中引入了模块化概念,一个文件即是一个模块。
es6 module总结
qq_37016928的博客
09-26 252
CommonJS在运行时才能却确定输入和输出的变量和依赖关系，而es6则是在编译时就能确定。 let { stat } = require('fs'); // 等同于 let _fs = require('fs'); let stat = _fs.stat; 上面代码的是指是整体加载fs模块（加载fs所有方法）生成一个对象后再从这个对象读取的方法。这种加载称为‘运行时加载’，因为只有在运行...
ES6 import 引用文件夹/目录
热门推荐
hao像飘在外太空的博客
08-27 2万+
看redux的时候发现官网的教程里直接import了一个文件夹，我再三确定我没有看错， 是一个 文件夹 (Directory), 它直接 import了一个目录！ 这个 文件夹/目录底下还有一个index.js文件。我查了中文、英文、阮一峰、stackoverflow，我靠没查到，我郁闷了我纠结了， 我自己动手测试了下，随便新建了一个文件夹，写了点js，嘿嘿嘿嘿，居然真的可以， js文件只能
es6-es11学习之旅
11-08
es6-es11学习之旅
前端学习笔记-ES6-ES11
05-26
ES6-ES11学习笔记
ES6-ES11学习指南.zip
08-27
内容涵盖ES6-ES11，一份超详细的学习指南/笔记，能帮助初学者快速有效的掌握ES6体系知识点，帮助开发者快速查阅需要的知识点，内容全面
es6-shim:适用于旧版JS引擎的ECMAScript 6兼容性垫片
04-06
ES6垫片提供兼容性填充，以使旧式JavaScript引擎的行为与ECMAScript 6（Harmony）尽可能接近。安装如果要在浏览器中使用它： 只需在脚本之前包含es6-shim 。 包括尤其是在您的浏览器不支持ECMAScript 5的情况下-但每...
使用ES6模块在js文件里边引入其它js文件
6块腹肌的博客
05-31 1万+
使用ES6模块加载js文件的方法如下： 一： script标签需要加入type属性，值为：module. 示例index.html： <script type="module" src="./js/index.js"></script> 此时浏览器就知道这是一个ES6的模块，并且是异步加载的。script标签在没有添加async或者defer属性的情况下，默认是...
ES6 import 引用文件夹/目录及其处理过程
默茉的博客
04-11 3742
如果文件目录下有 package.json，就根据它的 main 字段找到 js 文件。如果没有 package.json，那就默认取文件夹下的 index.js。
es6模块循环引用的问题
醉逍遥neo的博客
02-11 7721
起因是开发时的一个报错信息：Cannot access '__WEBPACK_DEFAULT_EXPORT__' before initialization。 由于报错信息不明确，网上也搜不到明确的原因解释和解决方法，所以自行排查了很久才逐渐找到原因。要说怎么排查，就是最笨的也是最有效的“代码删除法”，即从入口文件开始一行行删代码，直到定位到具体出错位置，然后凭借自身知识和经验判断出问题原因。 原因就是import的循环引用导致webpack无法正确解析。 一、循环引用简介 最简单的 a 引用了 b，b 又
JavaScript中对象的 constructor 属性的介绍
六月心悸
06-02 2838
作者：傅智威 链接：https://www.zhihu.com/question/19951896/answer/102946428 来源：知乎 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 对于instanceof的检测：一般情况下，__proto__和prototype共享指针，给对象赋值实际上改变了它的指针，是它指向了新的对象，而给属性赋值就只是单纯的
javascript es6 属性 __proto__ prototype 原型链 简介
whatday的专栏
08-08 498
目录 prototype __proto__ 原型链 构造函数创建对象实例 今天同事小英童鞋问了我一个问题： function Foo(firstName, lastName){ this.firstName = firstName; this.lastName = lastName; } Foo.prototype.logName = function(){ Foo.combineName(); console.log(this.fullName); } F
javascript原型 原型链
gqk01的博客
08-20 858
1 一切都是对象 “一切都是对象”这句话的重点在于如何去理解“对象”这个概念。 ——当然，也不是所有的都是对象，值类型就不是对象。 首先咱们还是先看看javascript中一个常用的运算符——typeof <script type="text/javascript"> //1. 基本 // typeof返回数据类型的字符串表达 // <!-- // 1. 分类 // * 基本(值)类型 // * String: 任意字符串 // * Number
JS中一个dom元素能绑定多少事件
ggq53219的博客
06-10 550
在JavaScript中，一个DOM元素可以绑定的事件数量并没有明确的限制，这主要取决于浏览器的实现和内存限制。然而，在实际应用中，为同一个DOM元素绑定过多的事件监听器可能会导致性能问题，尤其是在事件处理函数执行复杂操作的情况下。总之，虽然JavaScript中DOM元素可以绑定的事件数量没有明确的限制，但在实际应用中应注意避免过度绑定和优化事件处理函数，以确保良好的性能和用户体验。
Harmony 开发的艺术 面向对象
最新发布
不懂先生的博客
06-13 1047
然后你可以创建多个子类，如“圆形”、“矩形”和“三角形”，它们都继承自“形状”类并实现了自己的“绘制”方法。尽管每个对象的类型可能不同（圆形、矩形、三角形等），但由于它们都继承了“形状”类并实现了相同的“绘制”方法，因此你可以通过父类引用来统一调用它们的方法。然后你可以创建一个“狗”类，它继承自“动物”类，并添加或覆盖一些特定的属性和方法（如“叫”和“摇尾巴”）。所以面向对象的三大特征（封装、继承、多态）在java语言中很容易实现的设计，搬到早期的JavaScript中，就变噩梦一样的存在。
尚硅谷es6-es11笔记
09-10
尚硅谷ES6-ES11笔记是关于ES6到ES11版本的学习笔记。其中包括了ES6引入的类的写法，实际上ES6的Class是一个语法糖，让我们写起来更像传统的类。 此外，ES6还引入了Symbol值，除了可以定义自己使用的Symbol值，还有11...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值