let da1 = { name: 'da1', age: 1 }let da2 = { name: 'da2', study: { title: 'web' } }let da3 = Object.assign(da1,da2); console.log(da3); // { // name: 'da2', // age: 1, // study: { title: 'web' } // } console.log( da1 === da3); // trueda2.name = 'da22'; da2.study.title = 'web2'; console.log(da2); // { // name: 'da22', // study: { title: 'web2' } // }console.log(da1); // { // age: 1, // name: 'da2', // study: { title: 'web2' } // }

如果源对象的属性值是一个指向对象的引用，它也只拷贝这个引用地址哦！

let da1 = { name: 'da1', age: 1 } let da2 = { a: Symbol('dadaqianduan'), b: null, c: undefined } let da3 = Object.assign(da1, da2); console.log(da3); // { // name: 'da1', // age: 1, // a: Symbol('dadaqianduan'), // b: null, // c: undefined // } console.log(da1 === da3); // true

let map = new Map([iterable]) // Map是用来实现字典的功能-Object键值对

// ES5 code var key1 = 'one', obj = { two: 2, three: 3 }; obj[key1] = 1; // obj.one = 1, obj.two = 2, obj.three = 3// ES6 code const key1 = 'one', obj = { [key1]: 1, two: 2, three: 3 }; // obj.one = 1, obj.two = 2, obj.three = 3// ES6 code const i = 1, obj = { ['i' + i]: i }; console.log(obj.i1); // 1

• css(布局，定位，移动端响应式）
• es(原型，原型链，作用域，闭包，异步，单线程）
• webapi(DOM BOM，Ajax跨域，事件存储）
• 开发环境（版本管理，调试抓包，打包构建）
• 运行环境（页面渲染，性能优化，web安全）
• 网络通讯

1. 布局（盒模型，BFC，float，flex）
2. 定位，图文样式，移动端响应式（rem,media query,vw/vh），动画、渐变
3. 变量类型和计算（值类型和引用类型，类型判断，逻辑运算）
4. 原型和原型链（class，继承，原型，原型链，instanceof）
5. 作用域和闭包（作用域，自由变量，闭包，this）
6. 异步（单线程，callback，应用场景，Promise，event-loop，async/await，微任务/宏任务）
7. 模块化（ES6 Module）
8. DOM(树形结构，节点操作，属性，树结构操作，性能）
9. BOM（navigator,screen,location,history）
10. 事件（绑定，冒泡，代理）
11. ajax(XMLHttpRequest,状态码,跨域）
12. 存储（cookie,localStorage,sessionStorage）
13. 开发环境（git,调试，webpack和babel，linux命令）
14. 运行环境（页面加载：加载，渲染。性能优化：加载资源优化，渲染优化。安全：xss，CSRF）
15. HTTP协议：状态码，Method，Restful API，headers，缓存策略

const module_string = `dadaqianduan`

1. 提供了定义多行字符串的语法；
2. 提供了一种简单的方法来插值字符串中的变量和表达式
3. 允许您使用模板标签创建DSL（领域特定的语言）

使用多行字符串

// 要创建跨越两行的字符串，必须\在行尾使用字符const dada = 'dada \ dadaqianduan'// 呈现效果：在两行上创建一个字符串，但是仅在一行上呈现

const string = 'dada 魔王哪吒\n \ dadaqianduan'

const dada = `dadaqianduan 魔王哪吒`

const da = `First Second`

const da = `dadaqianduan ${mydada}`${}里面可以添加任何东西const da1 = `dada ${1+2+3}` const da2 = `dada ${dafun() ? 'x' : 'y'}`

let da = ['hello', 'world'] let [firstName, surName] = da cosole.log(firstName, surName);

默认值

let [da1, da2] = []; console.log(da1); // undefined console.log(da2); // undefined

let [da1= 'da1', da2 = 'da2']=['dadaqianduan]console.log(da1); // dadaqianduan console..log(da2); // da2

解构分配

var myArray = ['a', 'b', 'c']; var one= myArray[0], two= myArray[1], three = myArray[2]; // one = 'a', two = 'b', three = 'c'

const [one, , three] = myArray; // one = 'a', three = 'c'

const [one, ...two] = myArray; // one = 'a', two = ['b, 'c']

const myObject = { one:'a', two:'b', three: 'c' }; // ES6 destructuring example const {one: first, two: second, three: third} = myObject; // first = 'a', second = 'b', third = 'c'

可变值交换

var a = 1, b = 2; // ES5 swap var temp = a; a = b; b = temp; // a = 2, b = 1// ES6 swap back [a, b] = [b, a]; // a = 1, b = 2[b, c, d, e, a] = [a, b, c, d, e];

function dada(param = {}) {

函数返回多个值（函数只能返回一个值，但可以是一个复杂的对象或多维数组）

function f() { return [1, 2, 3]; }const [a, b, c] = f(); // a = 1, b = 2, c = 3

ES6 JavaScript深度解构

var {da} = {bar: 'dada'} console.log(da) // undefined

var {da:{bar}} = {dada: 'dadaqianduan'} // Exception

var key = 'dadaqianduan' var { [key]: foo } = { dadaqianduan: 'bar' } console.log(foo) // 'bar'

var {da=3} = { da: 2 } console.log(da) // 2 var {da=3} = { da: undefined } console.log(da) // 3 var {da=3} = { bar: 2 } console.log(da) // 3var [a] = [] console.log(a) //undefined var [b=10] = [undefined] console.log(b) //10 var [c=10] = [] console.log(c) //10function da () { return { x: 1, y: 2 } } var {x, y} = da() console.log(x) // 1 console.log(y) // 2

function loadScript(src) { return new Promise((resolve, reject) => { let script = document.createElement('script') script.src = https://www.it610.com/article/src script.onload = () => resolve(src) script.onerror = (err) => reject(err) document.head.append(script) }) }

function loadScript(src) { let script = document.createElement('script'); script.src = https://www.it610.com/article/src; document.head.append(script) }

var promise = new Promise(function(resolve, reject){ resolve('传递给then的值') }) promise.then(function(value){ console.log(value) },function(error){ console.error(error) })

Promise对象是用于表示一个异步操作的最终完成（或失败），以及其结果值。

const promise = new Promise((resolve, reject) => { setTimeout(() => { resolve('da'); }, 200); }); promise.then((value) => { console.log(value); }); console.log(promise);

new Promise(function (resolve,reject){...});

1. pending，初始状态，既不是成功，也不是失败状态。
2. fulfilled，意味着操作成功完成。
3. rejected，意味着操作失败。

1. 返回一个新的promise对象
2. 在iterable参数对象里所有的promise对象都成功时，才会触发成功
3. 当任何一个iterable里面的promise对象失败，才会触发promise对象的失败
4. 成功状态会把一个包含iterable里所有promise返回值的数组作为成功回调的返回值，顺序和iterable的顺序一样
5. 如果这个新的promise对象触发了失败，会把iterable里的第一个触发失败的promise对象的错误信息作为它的失败信息
6. 场景，多用于处理多个promise对象的状态集合

1. 接收一个Promise对象的集合，当其中的一个promise成功，就返回那个成功的promise的值

1. 返回一个状态为失败的Promise对象，然后将失败信息传递给对应的处理方法

1. 返回一个状态由给定value决定的Promise对象

Promise原型

• Promise.prototype.catch(onRejected)
• Promise.prototype.then(onFulfilled,onRejected)
• Promise.prototype.finally(onFinally)

function myAsyncFunction(url) { return new Promise((resolve, reject) => { const xhr = new XMLHttpRequest(); xhr.open('GET',url); xhr.onload = () => resolve(xhr.responseText); xhr.onerror = () => reject(xhr.statusText); xhr.send(); }); }

1. 默认情况下，代理不执行任何操作

var target = {} var handler = {} var proxy = new Proxy(target, handler) proxy.a = 'b' console.log(target.a) // 'b' console.log(proxy.c === undefined) // true

var person = { name: "dada", age: 17 }; person = new Proxy(person, { set(target, property, value) { if (value =https://www.it610.com/article/== 18) { console.log("Congratulations! You are of legal age"); Reflect.set(target, property, value); return true; } } }); person.age = 18; if (value < 13 && value > 99) { throw new Error('The age should be between 13 and 99') } else { Reflect.set(target, property, value) }

let p = new Proxy(target, handler)

1. target 用Proxy包装的目标对象
2. handler 一个对象，其属性是当执行一个操作时定义代理的行为的函数

console.log(o.dada || '')

let o = { name： 'dada', age: 1 }let handler = { get(obj, key) { return Reflect.has(obj, key)?obj[key]:'' } }let p = new Proxy(o, handler)console.log(p.from)

for (let [key] of Object.entries(response.data)) { Object.defineProperty(response.data, key, { writable: false }) }

let data = https://www.it610.com/article/new Proxy(response.data, { set(obj, key, value) { return false } })

// Validator.jsexport default(obj, key, vlaue) => { if(Reflect.has(key) && value > 20) { obj[key] = value } }import Validator from './Validator'let data = https://www.it610.com/article/new Proxy(response.data, { set: Validator })

let validator = { set(target, key, value) { if(key === 'age') { if(typeof value !== 'number' || Number.isNaN(value)) { throw new TypeError('Age must be a number') } if(value<=0){ throw new TypeError('Age must be a positive number') } } return true } }const person = { age: 12 } const proxy = new Proxy(person,validator) proxy.age = 'dada' // TypeError number proxy.age = NaN proxy.age = 0 // positive number proxy.age = 3

class Component { constructor() { this.proxy = new Proxy({ id: Math.random().toString(36).slice(-8) }) } get id() { return this.proxy.id } }

function * dada() { for(let i=0; i<2; i++ { yield console.log(i); } }const da = dada() da.next() da.next()

function* dada() { console.log('dadaqianduan'); } dada(); // 没有执行函数 如需要输出，改为： var da = dada(); da.next();

var count_id = 0; function dada_id() { count_id ++; return count_id; }

方法

Generator.prototype.next() 返回一个由 yield表达式生成的值。Generator.prototype.return() 返回给定的值并结束生成器。Generator.prototype.throw() 向生成器抛出一个错误。

function *da() { }function* da(){ }

方法

function * da() { yield 1 yield 2 yield 3 } var d = da() console.log(d.next()) // {value:1,done:false} console.log(d.return()) // {value:undefined,done:true} console.log(d.next()) // {value:undefined,done:true}

function * da() { yield 1 yield 2 yield 3 } var d = da() console.log(d.nex()) // {value:1,done:false} console.log(d.return(100)) // {value:100,done:true} console.log(d.next()) // {value:undefined,done:true}

function* genFunc(){...} const genObj = genFunc();

const genFunc = function* () {...} const genObj = genFunc();

const obj = { * generatorMethod(){ ... } } const genObj = obj.generatorMethod();

class MyClass{ * generatorMethod(){ ... } } const myInst = new MyClass(); const genObj = myInst.generatorMethod();

authors[Symbol.iterator] = function(){ // this return { next(){ return{ done:false, value:1 } } } }

导出变量或者常量export const da = 'dadaqianduan' export let da1 = 'da1' export var da2 = 'da1'const name = 'dada' let name1 = 'dada1' export { name, name1 }导出函数 export function da(value){ console.log(value) }const da = (value) => { console.log(value); }export { da }导出Object export({ name: 'da1', message: 'dadaqianduan' })let da = { name: 'name1' } export { da }导出Class class Da { constructor(){ this.id = 1 } } export { Da }export class Da { constructor() { this.id = 1 } }修改导出名称 const name = 'da1' export { name as cname } export default name

// 直接导入 const name = 'dada' let name1 = 'dada1' var name2 = 'dada2' export { name as cname } export default name2import name2, {name1, name} from A

export const sqrt = Math.sqrt; export function square(x) { return x * x; } export function dada(x,y) { return sqrt(square(x) + square(y)); }import {square,da} from 'da'; console.log(square(11)); // 121 console.log();

export default function() {...} import myFunc from 'myFunc'; export default class{...} import MyClass from 'MyClass'; const inst = new MyClass();

require --lib.js-- function add(x,y){ return x + y } module.exports = { add: add, }; --main.js-- var add = require('lib').addd; console.log(add(1,2));

import --lib.js-- export function add(x,y) { return x + y } --main.js-- import {add} from 'lib'; console.log(add(1,2));

--lib.js-- export const sqrt = Math.sqrt; export function square(x) { return x * x; } export function da(x,y) { return sqrt(square(x)+square(y)); } --main.js-- import {square, da} from 'lib'--myFunc.js-- export default function() {...}; --main.js-- import myFunc from 'myFunc'; myFunc();

let da1 = [1,2,3]; console.log(da1.includes(2));

arr.find(function(item){ return item === 1; })arr.filter(function(item){ return item === 2; })Math.pow(2,3)->2**3

async function firstAsync(){ let promise = new Promise ((resolve,reject) => { setTimeout(function(){ resolve('dadaqianduan') },1000) }) console.log(await promise) console.log(await Promise.resolve(1)) console.log(2) return Promise.resolve(3) } firstAsync().then(val => { console.log(val) })

await后面是Promise对象

let da = { 'da': 1, 'da2': 2 } console.log(Object.value(da)) // [1,2]Object.values是在对象上找到可枚举的属性的值，所以只要这个对象是可枚举的就可以

Promise.resolve().then(()=>{ console.log(1) }).catch(()=>{ console.log(2) }).then(()=>{ console.log(3) })

Promise.resolve().then(()=>{ console.log(1) throw new Error('da') }).catch(()=>{ console.log(2) }).then(()=>{ console.log(3) })

Promise.resolve().then(()=>{ console.log(1) throw new Error('da') }).catch(()=>{ console.log(2) }).catch(()=>{ console.log(3) })

async function fn() { return 1 } (async function() { const a = fn() // ?? const b = await fn() // ?? })()

console.log(100) setTimeout( () => { console.log(200) }) Promise.resolve().then( ()=> { console.log(300) }) console.log(400)

async function async1() { console.log('async1 start') await async2() console.log('async1 end') }async function async2 () { console.log('async2') }console.log('script start')setTimeout(function(){ console.log('setTimeout') },0)async1()new Promise(function (resolve){ console.log('promise1') resolve() }).then(function(){ console.log('promise2') })console.log('script end')

// 加载 functionloadImg(src) { const p = new Promise( (resolve,reject) => { const img = document.createElement('img') img.onload = () =>{ resolve(img) } img.onerror = () =>{ const err = new Error('图片加载失败') reject(err) } img.src = https://www.it610.com/article/src } ) return p } const url ='https' const p = loadImg(url)p.then(img =>{ console.log(img.width) return img }).then(img =>{ console.log(img.height) }).catch(ex => { console.error(ex) })

async function async1() { console.log('async1 start') // 2 await async2() // undefined console.log('async1 end') // 5 } async function async2() { console.log('async2') // 3 } console.log('script start') // 1 async1() console.log('script end') // 4

for...of常用于异步的遍历

function add(num) { return new Promise(resolve => { setTimeout(()=>{ resolve(num*num) },1000) }) } const nums = [1,2,3] nums.forEach(async(i)=>{ const res = await add(i) })

function da(time) { return new Promise(function(resolve,reject){ setTimeout(function(){ resolve(time) },time) }) } async function test() { let arr = [da(2000),da(1000),da(3000)] for await (let item of arr) { console.log(Date.now(), item) } }

const input = { a: 1, b: 2 } const output = { ...input, c: 3 } console.log(output)const input = { a: 1, b: 2, c: 3 } let {a, ...rest } = input

const numbers = [1, 2, [3, 4, [5, 6]]]; // Considers default depth of 1 numbers.flat(); > [1, 2, 3, 4, [5, 6]]// With depth of 2 numbers.flat(2); > [1, 2, 3, 4, 5, 6]// Executes two flat operations numbers.flat().flat(); > [1, 2, 3, 4, 5, 6]// Flattens recursively until the array contains no nested arraysnumbers.flat(Infinity) > [1, 2, 3, 4, 5, 6]

const numbers = [1, 2, 3]; numbers.map(x => [x * 2]); > [[2], [4], [6]]numbers.flatMap(x => [x * 2]); > [2, 4, 6]

const records = [['name','da'], ['age', 32]]; const obj = Object.fromEntries(records); > { name: 'da', age: 32}Object.entries(obj); > [['name','Mathew'], ['age', 32]];

Symbol('desc').toString(); > "Symbol(desc)"Symbol('desc').description; > "desc"Symbol('').description; > ""Symbol().description; > undefined

推荐阅读

• 

  色母片是什么
• 

  mysql怎么查找递归 sql实现mysql递归查询
• 

  java数组基础详解
• 

  宝宝|婴幼儿意外伤害第一时间如何正确处置？
• 

  mysql服务层中解析器包含哪些功能 mysql解析器是什么
• 

  别出心裁的“烧南北”
• 

  真机|小米又站起来了！MIX 4真机屏幕曝光：这效果太好
• 

  水果拼盘常用水果 三种水果拼盘图片
• 

  品质分析方法,统计学分析方法有哪些
• 

  2023年北京郁金香文化节有几个展区参加 2023年北京郁金香文化节有几个展区
• 

  拍摄延时摄影用什么格式，延时摄影的图片格式
• 

  htcG13手机应该下个什么文件阅读器或者浏览器？一打开爱奇艺就自动把视频 图片查看器 音乐播放器全改成了爱奇艺万能播放器，
• 

  轻轨是地铁吗
• 

  mysql解压tar
• 

  百度导航下载导航，百度地图导航下载
• 

  go语言控制台输出 go语言控制台输入
• 

  预算在1500,如何配置一台玩DNF的电脑？
• 

  破晓色是什么颜色？
• 

  工程竣工验收需要哪些资料？ 工程竣工验收需要哪些资料
• 

  比亚迪s7报价多少 比亚迪s7报价多少?

• 焦点学习田源分享第267天《来访》
• 亲子日记257天
• 半周岁体检
• 日精进|日精进 第177天
• 回归匠心，做个价值投资者
• 为梦想而努力
• 贝哥哥21天拖延症88计划第3期第17天
• 参与设计20多个区块链经济系统，我总结出4个原则和7个陷阱
• 2019年6月6日坚持1000篇日志打卡第2轮第17天
• 阅读《精进》第7天