Es6

互联网时代越来越多的生存和办公条件失去了便当，特地是在即时通讯软件方面的倒退，更是让咱们从日常人际交往到工作交换都变得更加便捷。即时通讯为咱们办公发明了怎么的便当条件？ 1、即时通讯为办公带来了更加及时的信息反馈。在传统的通信联系形式上，特地是大量数据的剖析和回顾，须要通过电子邮件发送以及面对面交换或者电话通信等形式进行交换，这种沟通形式尽管保障了公务解决的可行性，然而工作效率和成果大打折扣。而即时通讯的产生，在通信联系上进行了更好的改善，可能便于工作对接更加及时和无效。 咱们在即时通讯软件上能够与上级领导和上级员工进行交换和沟通，条件须要的状况下能够把整个小组成员拉至同一分组，独特进行问题的探讨，无论间隔多远，只有有手机电脑等工具，就能够进行即时通讯，帮忙咱们更好的进行问题的探讨。 2、即时通讯为办公节约了各种资源。在互联网倒退时代，通信信息相干的资金节约是比拟显著的，尤其是网络通讯遍及和流量费用升高的状况下，即时通讯可能有比电话通信费用等更加实惠的劣势，让咱们在办公中很好的节约通信费用，更好的进行资金节约，将更多的资金运用到研发和生产当中去。 3、 即时通讯为办公发明了更加无效的条件。即时通讯的产生让办公更加高效的同时，也为咱们的工作交换进行了更好的调整，云办公这种办公形式逐步成为互联网时代的新办公形式。咱们能够通过即时通讯的形式缩小日常工作对接中因为见不到人而产生的各种问题，咱们能通过即时通讯让办公气氛趋于良好，相当一部分在办公室中容易呈现的人际交往问题，在即时通讯中容易防止，从而更加无效的进行工作。 4、即时通讯为互联网时代办公提供了良好的条件，这种条件不仅体现在办公形式和模式上的转变，更体现在即时通讯对网络时代办公中工作气氛的扭转。即时通讯条件下的办公是更加简洁高效的办公模式，在即时通讯条件下进行办公也会产生一些其余发展趋势。若理解即时通讯源码，可征询星动云IM。 在信息时代，想要持续倒退即时通讯的高效办公劣势，不仅须要咱们理解即时通讯为办公带来了怎么的便当。更须要咱们深刻的剖析在即时通讯条件下，办公须要什么样的条件，比方咱们常见的网络通讯稳定性，员工在线时长统计，通信揭示的及时和无效等等。 互联网时代中即时通讯是办公中一项重要的沟通条件，在即时通讯的环境下进行会议交换、数据传递以及小组讨论等，都让咱们的日常办公条件更加方便快捷，可能让即时通讯中的工作效率大大提高，即时通讯是互联网技术以及办公倒退的重要趋势。

纯函数和柯里化很容易写出洋葱代码 h(g(f(x)))。洋葱代码的嵌套问题使得咱们的保护更加艰难。这与咱们选用函数式编程的开发初衷是相违反的，在这种状况下函数组合的概念就应运而生。函数组合能够让咱们把细粒度的函数重新组合生成一个新的函数上面这张图示意程序中应用函数解决数据的过程，给 fn 函数输出参数 a，返回后果 b。能够想想 a 数据通过一个管道失去了 b 数据。当 fn 函数比较复杂的时候，咱们能够把函数 fn 拆分成多个小函数，此时多了两头运算过程产生的 m 和n。上面这张图中能够设想成把 fn 这个管道拆分成了3个管道 f1, f2, f3，数据 a 通过管道 f3 失去后果 m，m。再通过管道 f2 失去后果 n，n 通过管道 f1 失去最终后果 b fn = compose(f1, f2, f3)b = fn(a)函数组合函数组合 (compose)：如果一个函数要通过多个函数解决能力失去最终值，这个时候能够把两头过程的函数合并成一个函数。函数就像是数据的管道，函数组合就是把这些管道连接起来，让数据穿过多个管道造成最终函数组合默认是从右到左执行函数的组合要满足结合律 (associativity)：咱们既能够把 g 和 h 组合，还能够把 f 和 g 组合，后果都是一样的 lodash 中组合函数 flow() 或者 flowRight()，他们都能够组合多个函数flow() 是从左到右运行flowRight() 是从右到左运行，应用的更多一些 const _ = require('lodash')const toUpper = s => s.toUpperCase()const reverse = arr => arr.reverse()const first = arr => arr[0]const f = _.flowRight(toUpper, first, reverse)console.log(f(['one', 'two', 'three']))模仿实现 ...

ES6推出的模块化，应用形式有点相似 require.js，只须要引入一个入口文件即可，其余的js文件能够按性能创立及引入，export 导出办法属性，而后 import 引入应用，这个新个性可能在将来会引来原生开发的热潮，不须要三方框架（vue、react）即可自在应用模块化开发，而且目前浏览器市场快对立了，就连IE也放弃了本人的内核应用google webkit内核了，而且电脑也是默认装备了 IEAdge浏览器，想想就感觉爽。 PS：应用模块化加载，须要服务器环境，也就是得通过 localhost 拜访，而且 script 标签也得加上 type="module" 申明一、根本示例a.js export default function a1() { console.log('a1')}index.html <script type="module">import a1 from './a.js'a1() // a1</script>二、解构赋值c.js export function c1() { console.log('c1')}export function c2() { console.log('c2')}index.html <script type="module">import { c1, c2 } from './c.js'c1() // c1c2() // c2</script>三、js文件引入a.js export default function a1() { console.log('a1')}b.js import a1 from './a.js'export default function b1() { a1() console.log('b1')}index.html <script type="module">import b1 from './b.js'b1() // a1, b1</script>四、标签引入d.js ...

1、根本用法// 应用async/await获取胜利的后果// 定义一个异步函数，3秒后能力获取到值(相似操作数据库)function getSomeThing(){ return new Promise((resolve,reject)=>{ setTimeout(()=>{ resolve('获取胜利') },3000) })}async function test(){ let a = await getSomeThing(); console.log(a)}test(); // 3秒后输入：获取胜利2、async 前面能够跟任何函数，await后只有跟promise函数，期待才无效。否则有效（1）await后跟promise对象 var b=1; function time(){ return new Promise((resolve,reject) => { setTimeout(function(){ resolve(2) },1000) }) } async function a(){ b =b + await time(); console.log('b',b) } a() console.log('外',b)后果：（2）await后是非promise对象 var b=1; function time(){ setTimeout(function(){ b++; },1000) } async function a(){ await time(); console.log('b',b) } a() console.log('外',b) setTimeout(() => { console.log('外2',b) }, 2000);后果： ...

艰深点讲loader是转换，plugin是执行比转换更简单的工作，比方合并压缩等 loader:让webpack可能解决非js文件，而后你就能够利用 webpack 的打包能力，对它们进行解决。例如：css-loader、style-loader、postcss-loader、sass-loader plugins:从打包优化和压缩，始终到从新定义环境中的变量.例如：uglify-webpack-plugin、clean-webpack-plugin、babel-polyfill 绝对于loader转换指定类型的模块性能，plugins可能被用于执行更宽泛的工作比方打包优化、文件治理、环境注入等…… loader，它是一个转换器，将A文件进行编译成B文件，比方：将A.less转换为A.css，单纯的文件转换过程。 plugin是一个扩展器，它丰盛了webpack自身，针对是loader完结后，webpack打包的整个过程，它并不间接操作文件，而是基于事件机制工作，会监听webpack打包过程中的某些节点，执行宽泛的工作 原文链接：https://blog.csdn.net/tangdou...

如何遍历对象, 一般来说会想到 for-in let obj = { a: "Jane", b: "Kevin",};for (let k in obj) { console.log(k, obj[k]);}// 输入后果// a Jane// b Kevin然而for-in会遍历对象的原型链, 一些继承属性就被遍历进去了, 如果只想遍历对象本身的属性这时候就得加判断了 let obj = { a: "Jane", b: "Kevin",};let newObj = Object.create(obj);newObj.c = "Duke";newObj.e = "James";for (let k in newObj) { console.log(k, newObj[k]);}// 输入后果// c Duke// e James// a Jane// b Kevinfor (let k in newObj) if (newObj.hasOwnProperty(k)) { { console.log(k, newObj[k]); } }// 输入后果// c Duke// e James接下来咱们尝试一些其余的形式 ...

Javascript 虽博大精深，但如果只能同步运行，那么遇到 HTTP 网络申请、I/O 解决、事件、定时器等耗时操作就会卡到没法用。那么 js 是如何解决异步编程的? 回调函数在 js 中经常将函数作为参数传递，当工作执行有了后果就调用这个函数来进行下一步操作。假如咱们须要拿到前一个申请的后果来进行下一个申请，一旦申请多起来了，代码会显得十分俊俏。 http.get("url", param, (err, res1) => { console.log("res1: ", res1) http.get("url", res1, (err, res2) => { console.log("res2: ", res2) http.get("url", res2, (err, res3) => { console.log("res3: ", res3) ... }) }) })从下面代码能够看出，仅仅嵌套三次曾经有堆砌 山趋势了。。。 PromiseES6 引入了 js 异步编程新计划 Promise，通过 Promise 的链式调用最起码让代码看起来整齐划一了不少，一旦代码堆砌起来还是影响浏览和保护 function queryData(url, param) { return new Promise((resolve, reject) => { http.get(url, param, (err, data) => { resolve(data) }) })}queryData("/api/user", data) .then(res1 => queryData("/api/xx", res1)) .then(res2 => queryData("/api/xx", res2)) .then(res3 => queryData("/api/xx", res3)) .then(finalRes => console.log("finalRes: ", finalRes)) .catch(error => console.log("error: ", error))async/await最终咱们在 ES7 中迎来了青天大老爷——async\await，应用它们就能够从上到下逐行地编写咱们的异步代码，进而从视觉上达到同步成果，浏览起来相当难受，例如以上代码能够改写如下 ...

1.开发环境 vue2+es62.电脑系统 windows11专业版3.简略地说,对象解构就是应用于对象匹配的构造来实现对象属性赋值。上面的例子展现了两段等价的代码,首先是不应用对象解构的: //不应用对象解构let person={name:'Chen',age:23};let personName=person.name, personAge=person.age;console.log(personName); // Chenconsole.log(personAge); // 23还是下面的例子,应用对象解构是这样的:let person={ name:'Chen', age:23}let {name:personName,age:personAge}=person;console.log(personName); // Chenconsole.log(personAge); // 233.应用解构,能够在一个相似对象字面量的解构中,申明多个变量,同时执行多个赋值操作。如果想让变量间接说应用属性的名称,那么能够应用简写语法,比方: let person={ name:"Chen", age:23};let {name,age}=person;console.log(name); // Chenconsole(age); // 234.解构赋值不肯定与对象的属性匹配。赋值的时候能够疏忽某些属性,而如果援用的属性不存在,则该变量就是 undefined： let person={ name:"Chen", age:23}let {name,job}=person;console.log(name); // Chenconsole.log(job); // undefined5.也能够在解构赋值的同时定义默认值,这实用于后面刚提到的援用属性不存在源对象中的状况: let person={ name:"Chen", age:23}let {name,job="Web前端开发"}=person;console.log(name); // Chenconsole.log(job); // Web前端开发6.解构在外部应用函数 ToObject()(不能在运行时环境中间接拜访)把源数据结构转换为对象。这意味着在对象解构的高低问中,原始值会被都当成对象。这意味着(依据ToObject()的定义),null和undefined不能被解构,否则会抛出谬误。 let {length}='Chen';console.log(length); // 4let {constructor:c}=4;console.log(c===Number); // truelet { _ }=null; // TypeErrorlet { _ }=undefined; // TypeError7.解构并不要求变量必须在解构表达式中申明。不过,如果是当时申明的变量赋值,赋值值表达式必须蕴含在一堆括号中: let person={ name:"Chen", age:23}let personName,personAge;({name:personName,age:personAge}=person);console.log(personName,personAge); // Chen,238.嵌套解构解构对于用于援用嵌套的属性或赋值指标没有限度。为此,能够通过解构来复制对象属性: ...

模板字符串为ES6新引入的申明字符串的形式； 申明 let str = `这是一个字符串`console.log(str) //这是一个字符串内容能够字节应用换行符 let str = `<ul> <li>张三</li> <li>李四</li> <li>王五</li> </ul>`;变量拼接 let person = '张三';let csl = `法外狂徒${person}`console.log(csl) //法外狂徒张三

ES6提供了一个新的办法padStart()，具备字符串补全长度的性能。第一个参数用来指定字符串的最小长度，第二个参数是用来补全的字符串。例如： 1、字符串长度小于最小长度 'x'.padStart(5, 'ab') // 'ababx'将字符串x应用ab补全长度5位，当然这5蕴含自身字符串的长度。2、如果字符串长度大于最小长度，则返回字符串，如 "bacdef".padSatrt(3,"xxx") // "bacdef"3、如果用来补全的字符串与原字符串，两者的长度之和超过了指定的最小长度，则会截去超出位数的补全字符串。 'abc'.padStart(10, 'xxxxxxxx') // xxxxxxxabc看到这大家有没有想到，将工夫转换为年月日时分秒时，咱们会用if或者三元判断月、日、时、分、秒大于等于10和小于10的状况，针对小于10的前边会拼接"0"，这个办法能够省去咱们大量的判断了，代码如下： function formatData() { let now = new Date(); let year = now.getFullYear(); let month = (now.getMonth() + 1).toString().padStart(2, "0"); let date = (now.getDate()).toString().padStart(2, "0"); let hh = (now.getHours()).toString().padStart(2, "0"); let mm = (now.getMinutes()).toString().padStart(2, "0"); let ss = (now.getSeconds()).toString().padStart(2, "0"); return `${year}-${month}-${date} ${hh}:${mm}:${ss}`;}当前能够不必在大量写判断了，缩小代码量。 当然和padStart()对应的还有padEnd()办法，用法是一样的，对于padEnd()咱们平时用的最多的场景就是把身份证或者手机号显示后四位，其余数字用"*"代替，对用户是一种爱护。 function telFormat() { let tel = "13255557894"; return tel.slice(-4).padStart(tel.length, "*");}// telFormat() 后果： *******7894

记录一下Promise与其语法糖async、await的区别 // 例子1async function myAsyncFn() { return 'some values'}// 等价于function myAsyncFn() { return Promise.resolve('some values')}// 例子2async function myAsyncFn() { await 'something'}// 等价于function myAsyncFn() { return Promise.resolve('something').then(() => undefined)}

一、CONST不容许反复申明不属于顶层对象window不存在变量晋升暂时性死区（先申明后应用）块级作用域（块级作用域内有用）二、 Arrow Function（箭头函数）https://es6.ruanyifeng.com/#d... 三、 解构赋值const obj = { name: '张三', age: 30, hobby: ['篮球','足球'], school: { name: '北大附中', city: '北京' }}const { name: aliaName, // 别名 age, hobby, school: { name, city }} = objconsole.log(aliaName,age,hobby,name,city)打印： 张三，30，['篮球','足球']，北大附中，北京在我的项目中应用解构赋值// 当作函数参数传递形式一：const sum = ([a, b]) => { return a+b; // 5}sum([2,3])// 形式二：const foo = ({name, age}) => { console.log(name, age); // 张三， 30}foo({ name: '张三', age: 30})// 两个值替换let a = 1;let b = 2;[b,a] = [a,b]// Ajax申请（json格局）json:{ "name": "张三", "age": 30}axios.get('./data.json', (res) => { console.log(res); // {..., data:{name:张三',age:30}, ...}})axios.get('./data.json', ({data}) => { console.log(data); // {name:张三',age:30} })axios.get('./data.json', ({data:{name, age}}) => { console.log(name,age); // 张三, 30})

目录：1、事件机制概念2、注册事件监听的办法3、事件操作4、冒泡和捕捉1、事件机制 问题形容：1）事件机制是如何起作用的？它跟事件循环机制有何区别？答：事件机制辨别于事件循环，它是用户交互层面的，依附的是事件流。 Dom事件流分为 3 个阶段：事件捕捉、达到指标和事件冒泡。事件捕捉最先产生，为提前拦挡事件提供了可能。而后，理论的指标元素接管到事件。最初一个阶段是冒泡，最迟要在这个阶段响应事件。 所以是浏览器时刻监听用户操作，一旦触发了事件，就会触发对应的事件流，这时候如果注册了事件监听函数，就会被触发。如果有多个事件同时触发，就会顺次执行事件响应。 用户通过对固定元素注册事件监听的办法，来手动增加事件响应函数。 2、事件监听的办法 问题形容：1）几种办法？有何区别？2) addEventListner的第三个参数？1）有三种事件监听办法HTML事件处理办法：特定元素反对的每个事件都能够应用事件处理程序的名字以 HTML 属性的模式来指定。此时属性的值必须是可能执行的 JavaScript 代码，失常会绑定为事件处理函数。这种办法最大的缺点就是将HTML代码和JS代码混用，且当须要事件处理的元素十分多时，不实用。 <input type="button" value="Click Me" onclick="console.log('Clicked')"/>Dom0事件处理办法：把一个函数赋值给一个事件处理程序属性，它的最大局限是，一个事件只能绑定一个事件处理，若绑定多个，那么前面的会笼罩后面的。 let btn = document.getElementById("myBtn"); btn.onclick = function() { console.log(this.id); // "myBtn" };Dom2事件处理程序：定义了两个办法：addEventListener()和 removeEventListener()。这两个办法裸露在所有 DOM 节点上，它们接管 3 个参数：事件名、事件处理函数和一个布尔值，true 示意在捕捉阶段调用事件处理程序，false（默认值）示意在冒泡阶段调用事件处理程序。 与办法2不同，addEventListener 能够给一个事件注册多个listener。 let btn = document.getElementById("myBtn"); btn.addEventListener("click", () => { console.log(this.id); }, false);须要留神的是，removeEventListener的几个参数，必须与addEventListener的保留完全一致，才可能勾销监听。 let btn = document.getElementById("myBtn"); let handler = function() { console.log(this.id); }; btn.addEventListener("click", handler, false); // 勾销btn.removeEventListener("click", handler, false); // 有成果！2）addEventListener的第三个参数在旧版本的DOM规定中，第三个参数默认规定为设置以后事件监听是在冒泡（默认）/捕捉阶段执行，它是一个boolean值，默认为false。然而理论目前第三个参数曾经有更简单的配置，它设置为一个叫option的对象，可用选项如下： 3、事件操作 问题形容1）事件处理的event对象是什么？能获取哪些信息？答：无论是哪种监听办法，event是传给事件处理程序的惟一变量，称为事件对象。事件对象蕴含与特定事件无关的属性和办法，其内容视状况不同。然而event事件对象固定蕴含一些公共属性和办法。 ...

面向文档型数据库，一条数据就是一个文档，用json把文档序列化。关系数据库=elasticsearch数据库=索引表=类型行=文档列=字段交互能够用java api或http的restful api，插入一条记录就是对一个uri执行put PUT /megacorp/employee/1{ "name" : "John", "sex" : "Male", "age" : 25, "about" : "I love to go rock climbing", "interests": [ "sports", "music" ]}es的设计主旨：检索性能为了进步检索性能，要就义插入、更新的性能。插入时，会为每个字段建设倒排索引。 倒排索引Term：阳光posting list:12,23,45这样搜寻“阳光”，就能够马上找到有“阳光”的文档Term dictionary：把“阳光”“雨水”等term排序，二分法查找term，logn的查找效率。Term index：通过磁盘性能差，所以es通过内存查找term，term太多，term dictionary就会很大。term index是基于前缀的树状索引，能够找到term的offset从而定位到term。再联合fst压缩技术，term index就能够缓存到内存里了。 压缩技巧1.posting list有序step1 实在值存储变增量存储，step 2 分区，step 3 以字节模式存储 Roaring bitmaps将posting list依照65535为界线分块，用<商，余数>的组合示意每一组id，65535是一个经典值，因为它=2^16-1，正好是用2个字节能示意的最大数，一个short的存储单位。最初的block，如果超过4096个元素，用bitset存，否则用short[]存。65536个元素用bitmap存恒定8192bytes，用short[]存是2*nbytes。 联结索引多个field索引联结查问用跳表做疾速与运算，或者用bitset按位与跳表查问很快，所以对最短的posting list每个元素判断其余两个posting list里是否存在就行。用bitset就直观的按位与就行了。 总结和思考es的思路：1.能搬进内存的尽量搬进内存，缩小磁盘读取次数。2.能压缩的尽量压缩，严苛地应用内存。 留神点不须要索引的字段肯定要标出来，默认是建索引的不须要anayasis的string也要标出来，默认是analysis的选有法则的id很重要，晋升压缩效率和寻道效率

前言间隔上一篇js的继承系列曾经过来了四年，时不时还有新的读者评论和回复，开心之余也想着更新一下内容，因为过后的内容里没有波及到es6的 extend 实现，所以当初抽空补上。 当然，如果是0根底的同学或者对于根本的继承有些忘记的同学，能够先回顾一下前两篇： 详解js中的继承（一） 详解js中的继承（二） 注释根底回顾 & 准备常识为了使前面的学习过程更丝滑，在开始之前，一起再回顾一下这个构造函数-原型对象-实例模型： 当拜访 a 的属性时，会先从a自身的属性（或办法）去找，如果找不到，会沿着 __proto__ 属性找到原型对象A.prototype，在原型对象上查找对应的属性（或办法）；如果再找不到，持续沿着原型对象的__proto__ 持续找，这也就是最早咱们介绍过的原型链的内容。 function A (){ this.type = 'A'}const a = new A();当然，图上的原型链能够持续找，咱们晓得 A 尽管是函数，然而实质也是 Object ，沿着__proto__ 属性 一直上溯，最终会返回 null ; a.__proto__ === A.prototype; // truea.__proto__.__proto__ === Object.prototype; // truea.__proto__.__proto__.__proto__ === null; // trueextend实现源码解析进入正题， 学过 es6 的同学都晓得，能够通过关键字 extend 间接实现继承，比方： // 首先创立一个Animal类class Animal { name: string; constructor(theName: string) { this.name = theName; }; move(distanceInMeters: number = 0) { console.log(`Animal moved ${distanceInMeters}m.`); }}// 子类Dog继承于Animalclass Dog extends Animal { age: number; constructor(name: string, age: number) { super(name); this.age = age; } bark() { console.log('Woof! Woof!'); }}const dog = new Dog('wangwang', 12);dog.bark();// 'Woof! Woof!'dog.move(10);//`Animal moved 10m.`那么这个 extend 到底做了哪些事件呢? 这里借助装置 typescript 这个 npm 包，而后在本地运行 tsc [文件门路] ，把ts以及es6的代码转换成原生js的代码来进行钻研，（当然也有个毛病是转换的代码为了谋求代码极简 有时可能会影响可读性 比方 undefined 写作 void 0 之类的)，下面的代码转换之后长这样： ...

新增字段PUT 索引名称/_mapping/doc PUT activity_v1/_mapping/doc { "properties": { "effDate_fbda": { "type": "text" }, "expDate_fbda": { "type": "text" } }}对新增字段赋值POST 索引名称/_update_by_query POST activity_v1/_update_by_query{ "script": { "source": "ctx._source.expDate_fbda=ctx._source.expDate" }}

明天的知识点 (2021.12.17) —— 第976天 (我也要出题)[html] 应用canvas制作一个万圣节的简略动画[css] 应用css画一个圆圈，外面带一个x的图标[js] 在js中如何实现程序执行异步函数？[软技能] 你感觉领导的职责是什么？《论语》，曾子曰：“吾日三省吾身”（我每天屡次检查本人）。前端面试每日3+1题，以面试题来驱动学习，每天提高一点！让致力成为一种习惯，让奋斗成为一种享受！置信 保持 的力量！！！ 欢送在 Issues 和敌人们一起探讨学习！ 我的项目地址：前端面试每日3+1【举荐】欢送跟 jsliang 一起折腾前端，零碎整顿前端常识，目前正在折腾 LeetCode，打算买通算法与数据结构的任督二脉。GitHub 地址 微信公众号欢送大家前来探讨，如果感觉对你的学习有肯定的帮忙，欢送点个Star, 同时欢送微信扫码关注 前端剑解 公众号，并退出 “前端学习每日3+1” 微信群互相交换（点击公众号的菜单：交换）。 学习不打烊，充电加油只为遇到更好的本人，365天无节假日，每天早上5点纯手工公布面试题（死磕本人，愉悦大家）。心愿大家在这虚夸的前端圈里，放弃沉着，保持每天花20分钟来学习与思考。在这变幻无穷，类库层出不穷的前端，倡议大家不要等到找工作时，才狂刷题，提倡每日学习！（不忘初心，html、css、javascript才是基石！）欢送大家到Issues交换，激励PR，感激Star，大家有啥好的倡议能够加我微信一起交换探讨！ 心愿大家每日去学习与思考，这才达到来这里的目标！！！（不要为了谁而来，要为本人而来！）交换探讨欢送大家前来探讨，如果感觉对你的学习有肯定的帮忙，欢送点个[Star]

ts 中 extends 和 implementsts 中 extends 能够了解为 es6 class 对应的 extends能够实现类的继承 class Son extends Father {}能够实现和接口的继承 interface ISon extends IFather {sonValue: number; // ISon上除了从IFather继承的属性，还减少了sonValue}implements 了解为实现，A implements B，A 上要有 B 对应的属性和办法,不能用于两个 interface 之间类和类之间class Son implements Father {} // 用于类之间，此时没有继承的成果，而是要求Son上要有定义Father类的属性办法类和接口之间：class Son implements IFather {} // 用接口去标准class， 要求Son的属性和办法等要依照IFather接口中定义的来

明天的知识点 (2021.12.08) —— 第967天 (我也要出题)[html] 应用canvas实现同心圆环[css] 你有应用过box-reflect属性吗？说说你对它的了解[js] 手动实现一个compose函数[软技能] 你感觉上一家公司的工作流程有哪些须要改良的？《论语》，曾子曰：“吾日三省吾身”（我每天屡次检查本人）。前端面试每日3+1题，以面试题来驱动学习，每天提高一点！让致力成为一种习惯，让奋斗成为一种享受！置信 保持 的力量！！！ 欢送在 Issues 和敌人们一起探讨学习！ 我的项目地址：前端面试每日3+1【举荐】欢送跟 jsliang 一起折腾前端，零碎整顿前端常识，目前正在折腾 LeetCode，打算买通算法与数据结构的任督二脉。GitHub 地址 微信公众号欢送大家前来探讨，如果感觉对你的学习有肯定的帮忙，欢送点个Star, 同时欢送微信扫码关注 前端剑解 公众号，并退出 “前端学习每日3+1” 微信群互相交换（点击公众号的菜单：交换）。 学习不打烊，充电加油只为遇到更好的本人，365天无节假日，每天早上5点纯手工公布面试题（死磕本人，愉悦大家）。心愿大家在这虚夸的前端圈里，放弃沉着，保持每天花20分钟来学习与思考。在这变幻无穷，类库层出不穷的前端，倡议大家不要等到找工作时，才狂刷题，提倡每日学习！（不忘初心，html、css、javascript才是基石！）欢送大家到Issues交换，激励PR，感激Star，大家有啥好的倡议能够加我微信一起交换探讨！ 心愿大家每日去学习与思考，这才达到来这里的目标！！！（不要为了谁而来，要为本人而来！）交换探讨欢送大家前来探讨，如果感觉对你的学习有肯定的帮忙，欢送点个[Star]

前言本章介绍函数的扩大。有些不罕用的常识理解即可。本章原文链接：函数的扩大。 函数参数的默认值ES6 容许为函数的参数设置默认值，即间接写在参数定义的前面。当函数形参没有被赋值时，才会将默认值赋值给函数参数。 // 默认值间接写在行参前面function sampleFn(sample = 0, sample1 = 0) { return sample + sample1;}留神： 参数变量是默认申明的，所以不能用let或const再次申明。应用参数默认值时，函数不能有同名参数。参数默认值是惰性求值的。函数的默认值指定后，函数length属性返回的是没有指定默认值的参数的个数。参数的默认值一旦设定，函数进行申明初始化时，参数会造成一个独自的作用域（context）。// 默认值间接写在行参前面function sampleFn(sample = 0, sample1 = 0,sample = 1) { // 不能有同名参数 let sample = 1; // 不能再次申明 return sample + sample1;}留神：通常状况下，定义了默认值的参数，应该是函数的尾参数。也就是放在最初面。解构赋值默认值// 函数的默认值与构造赋值的默认值能够联合应用function sampleFn({ sample = 0, sample1 = 0 } = {}) { // 函数参数默认值 return sample + sample1;}console.log(sampleFn({ sample: 23, sample1: 33 })); // 56 参数需对应解构赋值的类型作用域当函数参数设置了默认值，函数进行申明初始化时，函数参数会生成一个独自的作用域，等到初始化完结，该作用域就会隐没。而且该行为只在函数参数指定了默认值才会呈现。 let sample = 1;/* 在申明的时候呈现独自作用域 在这个作用域中，变量没有定义，于是指向外层变量 函数调用时，函数外部变量影响不到默认值变量*/function sampleFn(sample1 = sample) { let sample = 2; console.log(sample1); return sample1;}sampleFn() // 1rest 参数ES6 引入 rest 参数 ，用于获取函数的多余参数。arguments 对象是类数组，rest 参数是真正的数组。模式为：...变量名，函数的最初一个命名参数以...为前缀。 ...

前言本章介绍数值的扩大。新增了很多办法，有些不罕用的办法理解即可。本章原文链接：数值的扩大 进制表示法ES6 提供了二进制和八进制数值的新的写法，别离用前缀0b（或0B）和0o（或0O）示意。八进制就不再容许应用前缀0示意。0b和0o前缀的字符串数值转为十进制，要应用Number办法。 console.log(Number('0b10')); // 二进制 2console.log(Number('0o10')); // 八进制 8数值分隔符ES2021，容许 JavaScript 的数值应用下划线（_）作为分隔符。数值分隔符次要为了书写数值时减少数值的可读性，不是为了解决内部输出的数据，对于 JavaScript 外部数值的存储和输入，并没有影响。 留神: 不能放在数值的最后面（leading）或最初面（trailing）。不能两个或两个以上的分隔符连在一起。小数点的前后不能有分隔符。迷信计数法外面，示意指数的e或E前后不能有分隔符。分隔符不能紧紧跟着进制的前缀字符串转数值的一些操作方法不反对数值分隔符其它进制也能应用数值分隔符 const sample10 = 1000_1000_1000;const sample2 = 0b1000_1000;const sample8 = 0o1000_1000;console.log(sample10); // 十进制 100010001000console.log(sample2); // 二进制 136console.log(sample8); // 八进制 2097664留神：Number()、parseInt()、parseFloat()不反对数字分隔符数值的办法Number.isFinite(), Number.isNaN()ES6 在Number对象上，新提供了Number.isFinite()和Number.isNaN()两个办法。 Number.isFinite()用来查看一个数值是否为无限的数字（finite），即不是Infinity。Number.isNaN()用来查看一个数值是否为NaN。留神：两个新办法与之前全局办法isFinite、isNaN有什么不同呢？ 而这两个新办法只对数值无效，传统办法先调用Number()将非数值的值转为数值，再进行判断，isFinite(25) // trueisFinite("25") // trueNumber.isFinite(25) // trueNumber.isFinite("25") // falseNumber.isFinite(Infinity); // falseNumber.isFinite(-Infinity); // falseisNaN(NaN) // trueisNaN("NaN") // trueNumber.isNaN(NaN) // trueNumber.isNaN("NaN") // falseNumber.parseInt(), Number.parseFloat()ES6 将全局办法parseInt()和parseFloat()，移植到Number对象下面，行为齐全放弃不变。次要是用于全局变量的模块化 parseInt() 函数解析字符串并返回整数。parseFloat() 函数解析字符串并返回浮点数。// ES5的全局办法const sampleInt = parseInt('11.11');const sampleFloat = parseFloat('1a2b3c');// ES6的Number办法const sampleInt1 = Number.parseInt('11.11');const sampleFloat1 = Number.parseFloat('1a2b3c');console.log(sampleInt, sampleFloat); // 11, 1console.log(sampleInt1, sampleFloat1); // 11, 1Number.isInteger()Number.isInteger()办法用来判断给定的参数是否为整数。 ...

前言本章介绍正则的扩大。有些不罕用的常识理解即可。本章原文链接：正则的扩大 RegExp 构造函数从 ES6 开始，如果RegExp构造函数第一个参数是一个正则对象，并且第二个标记存在且为标记参数，将不再抛出 TypeError ，将应用这些参数创立一个新的正则表达式。原有的正则表达式修饰符将被疏忽 const flag = new RegExp(/[0-9]/ig, 'i').flags; // 原有修饰符卫 ig ，被 i 给代替了console.log(flag); // i字符串无关正则表达式ES6将之前字符串上的四个对于正则表达式的办法全副更改为RegExp的实例办法，所以当初所有与正则表达式无关的办法，全副定义在RegExp对象上。 String.prototype.match 调用 RegExp.prototype[Symbol.match]String.prototype.replace 调用 RegExp.prototype[Symbol.replace]String.prototype.search调用 RegExp.prototype[Symbol.search]String.prototype.split调用 RegExp.prototype[Symbol.split]flags 属性RegExp.prototype.flags 属性 是ES6新增属性，会返回正则表达式的修饰符。 const SAMPLEREG = /abc/ig;console.log(SAMPLEREG.flags); // giu 修饰符在ES6中新增了 u修饰符，示意应用Unicode码的模式进行匹配。解决大于\uFFFF的 Unicode 字符 留神一旦加上u润饰符号，就会批改上面这些正则表达式的行为。 点字符对于码点大于0xFFFF的 Unicode 字符，点字符不能辨认，必须加上u修饰符。 **Unicode** 字符表示法新增了应用大括号示意 Unicode 字符，这种表示法在正则表达式中必须加上u修饰符，能力辨认当中的大括号，否则会被解读为量词。 量词应用u修饰符后，所有量词都会正确识别码点大于0xFFFF的 Unicode 字符。 预约义模式u修饰符也影响到预约义模式，是否正确识别码点大于0xFFFF的 Unicode 字符。 i 修饰符有些 Unicode 字符的编码不同，然而字型很相近，比方，\u004B与\u212A都是大写的K 本义没有u修饰符的状况下，正则中没有定义的本义（如逗号的本义\,）有效，而在u模式会报错。 unicode 属性RegExp.prototype.unicode 属性表明正则表达式带有"u" 标记。 unicode 是正则表达式独立实例的只读属性。 const SAMPLEREG = /abc/u;console.log(SAMPLEREG.flags); // uconsole.log(SAMPLEREG.unicode); // trueUnicode 属性类**Unicode property escapes**ES2018 引入了一种新的类的写法\p{...}和\`P{...}，用于解决 JavaScript 没有强无效的形式用匹配出不同文字问题。容许正则表达式匹配合乎 Unicode` 某种属性的所有字符。 ...

前言本章介绍字符串对象的新增办法。不罕用的办法不做重点笔记。本章原文链接：字符串的新增办法 includes()、startsWith()、endsWith()确定一个字符串是否蕴含在另一个字符串中。ES6 又提供了三种新办法。 includes() 办法用于判断一个字符串是否蕴含在另一个字符串中startsWith() 办法用来判断以后字符串是否以另外一个给定的子字符串结尾endsWith() 办法用来判断以后字符串是否是以另外一个给定的子字符串“结尾”的办法名返回值形容第二个参数 ： Numincludes()布尔值一个字符串是否蕴含参数字符串从第 Num 个地位直到字符串完结startsWith()布尔值一个字符串的结尾是否蕴含参数字符串从第 Num 个地位直到字符串完结endsWith()布尔值一个字符串的结尾是否蕴含参数字符串示意前 Num 个字符let sampleString = 'Hello world!';const sample1 = sampleString.includes('llo');const sample2 = sampleString.startsWith('H');const sample3 = sampleString.endsWith('d!');console.log(sample1, sample2, sample3); // true true true// 应用第二个参数const sample11 = sampleString.includes('llo', 1);const sample12 = sampleString.startsWith('H', 1);const sample13 = sampleString.endsWith('d!', 10);console.log(sample11, sample12, sample13); // true false falserepeat()repeat()办法返回一个新字符串，示意将原字符串反复n次。参数为小数就会向下取整，为正数和无穷(Infinity)则会报错. 参数解决小数向下取整字符串先转换成数字正数报错Infinity报错const SAMPLE = 'Ha';let sample1 = SAMPLE.repeat(4); // 反复四次console.log(sample1); // HaHaHaHalet sample2 = SAMPLE.repeat(1.8); // 参数为小书，向下取整console.log(sample2); // Halet sample3 = SAMPLE.repeat('3'); // 参数为字符串console.log(sample3); // HaHaHalet sample4 = SAMPLE.repeat(-4); // 参数为正数console.log(sample4); // 间接报错 Invalid count valuepadStart()，padEnd()ES2017 引入了字符串补全长度的性能。如果某个字符串不够指定长度，会在头部或尾部补全。 ...

前言本章次要是内容为是 ES6 对字符串的革新和加强。 本章记录字符串的扩大罕用重点局部，不罕用常识稍作记录。 本章原文链接： 字符串的扩大 模板字符串(template string)ES6字符串的扩大最罕用的就是模版字符串了模板字符串，都是用反引号示意。如果在模板字符串中须要应用反引号，则后面要用反斜杠本义。 模版字符串 保留空格和换行。模版字符串 是容许嵌入变量名或表达式。模版字符串 能够嵌套模版字符串。模版字符串 "标签模板"性能模版字符串保留空格和换行，间接在模版字符串中应用换行与空格就行 // 模版字符串保留空格和换行const SAMPLE = ` <ul> <li>list1</li> <li>list2</li> <li>list3</li> <li>list4</li> </ul>`;console.log(SAMPLE);// 输入后果为/* <ul> <li>list1</li> <li>list2</li> <li>list3</li> <li>list4</li> </ul>*/模版字符串应用变量与字符串须要写在${} 的大括号中，在大括号中也能够写字符串。 // 在模版字符串中应用变量与表达式let sampleName = "gssg";let sampleAge = 10;let sampleAge1 = 8;const SAMPLE = `My name is ${sampleName} and MY age is ${sampleAge + sampleAge1} years old`;console.log(SAMPLE);// 输入 My name is gssg and MY age is 18 years old在模版字符串中还能够写模版字符串，利用${}来嵌套。 ...

mmediate：配置watch属性是否立刻执行，值为 true 时，一旦运行就会立刻执行，值为false时，放弃惰性。deep：配置 watch 是否深度监听，值为 true 时，遴选公务员能够对象所有属性，值为 false 时放弃更加具体个性，必须指定到具体的属性上。 更加形象：应用时不须要具体指定监听的谁，回调函数内间接应用就能够。相比watch比拟难了解。不可拜访之前的值：只能拜访以后最新的值，拜访不到批改之前的值。咱们批改具体实现，遴选公务员而不用扭转依赖于它们的依赖类型。 ASP.NET Core 很器重依赖注入技术。ASP.NET Core 中内置的依赖注入提供功能模块，并不像 StructureMap 和 Ninject 等IoC（管制反转）容器那样功能丰富，但它速度快，易于配置，而且易于应用。咱们能够应用它在 ASP.NET Core 中注入框架服务和应用程序服务。http://lx.gongxuanwang.com/ss...

前言该篇笔记是第二篇 变量的解构赋值。 这一章原文链接： 变量的解构赋值 解构赋值ES6 容许依照肯定模式，从数组和对象中提取值，对变量进行赋值，这被称为解构（Destructuring）。 解构赋值是对赋值运算符的扩大。这是一种针对数组或者对象进行模式匹配，而后对其中的变量进行赋值。在代码书写上简洁且易读，语义更加清晰明了；也不便了简单对象中数据字段获取。 数组的解构赋值为变量赋值。 let sample1 = 1;let sample2 = 2;let sample3 = 3;下面代码应用ES6的数组解构赋值能够写成上面这样。从数组中提取值，依照对应地位，对变量赋值。 let [sample1, sample2, sample3] = [1, 2, 3]; console.log(sample1, sample2, sample3); // 1， 2， 3这种写法属于“模式匹配”，只有等号两边的模式雷同，右边的变量就会被赋予对应的值。下面代码在申明变量同时进行了赋值，ES6也能够先申明变量再进行解构赋值， let sample1, sample2, sample3; // 先申明[sample1, sample2, sample3] = [1, 2, 3];console.log(sample1, sample2, sample3); // 1， 2， 3数组解构有几种状况 胜利解构 齐全解构赋值不齐全解构赋值嵌套数组解构赋值变量申明并赋值解构先申明变量再进行解构赋值不胜利解构留神： 数组模式解构赋值 等号左边必须为可遍历构造，也就是说具备 Iterator 接口的数据结构。数组模式解构赋值 须要依照对应地位，对对象赋值。数组模式解构赋值 不胜利变量的值等于undefined。数组模式解构赋值 的数组能够是多维数组。数组模式解构赋值 不必将等号左边的数组全副解构进去。数组模式解构赋值 容许等号右边模式不全副匹配等号左边的数组。// 解构胜利let [sample1, [sample2, sample3]] = [1, [2, 3]]; console.log(sample1, sample2, sample3); // 1， 2， 3// 解构不胜利，变量的值就等于undefined。let [sample] = []; // sample 的值为 undefined let [sample1, sample2] = [1]; // sample2 的值为 undefined // 如果等号左边不是数组，也就是不可遍历构造，将会报错let [sample] = 1; // 间接报错，因为等号左边的值是个字面量不可遍历let sample1, sample2, sample3, sampleN; // 先申明变量再进行解构赋值[[sample1, sample2], sample3, ...sampleN] = [[1, 2], 3, 4, 5]; // 嵌套数组console.log(sample1, sample2, sample3, sampleN); // 1 2 3 [4, 5]let [sample11, sample12] = [1, 2, 3]; // 变量申明并赋值解构let [sample21, ,sample23] = [1, 2, 3];console.log(sample11, sample12); // 不齐全解构 1 2console.log(sample21, sample23); // 不齐全解构 1 3默认值当你不想从数组中解构出的值为undefined，解构赋值容许指定默认值。 ...

前言：最近开始看阮一峰老师的《ECMAScript 6 入门》(以下简称原文)学习ECMAScript 6(下文简称ES6)的常识，整顿出一些知识点加上我的了解来做成文章笔记。依照章节为单位一个章节一篇笔记。文章代码与目录构造和原文不同。 这一章原文链接 let 和 const 命令 。 letlet 是用来申明一个变量。不同与var会存在变量晋升(下文有介绍)，let所申明的变量值只在let命令所在的代码块内无效。同一个作用域(下文有介绍)不可应用 let 反复申明同一个变量。 留神： 申明变量没有变量晋升不可反复申明只在let命令所在代码块无效let sample = 1;sample = 2;let sample = 2; // 将会报错{ let sample = 1; console.log(sample); // 失常输入 1}console.log(sample); // 将会报错，因为只在let命令所在代码块无效constconst 是用来申明一个只读常量。一旦申明，常量的值就不能扭转。如果试着扭转常量的值会报错。并且const 在申明的时候就必须对其赋值，只申明不赋值，也会报错。同一个作用域不可应用 const 反复申明同一个常量。const 与let一样，都因为作用域起因，只能在所在代码块中无效。 const实际上保障的，并不是变量的值不得改变，而是变量指向的那个内存地址所保留的数据不得改变。留神： 申明常量申明后不能够扭转申明的时候必须对其赋值不可反复申明在const命令所在代码块无效const sample = 1;sample = 2; // 将会报错，const 申明的变量不能够从新赋值const sample; // 间接报错，const 申明的时候必须对其赋值let 与 const引入let后，曾经能够代替var了，在let与const之中能用const就尽量用const。 let 与 const 不同处let 与 const 的区别就是一个申明变量一个申明常量，变量能够从新赋值，常量不能从新赋值。 let sampleLet = 2;const sampleConst = 1;sampleLet = 3; // 失常sampleConst = 3; // 报错 let 与 const 雷同处都只能先申明后应用，不能变量晋升。都不能够在同一个作用域中反复申明都只在命令所在代码块无效{sampleLet; // 报错sampleConst; // 报错 let sampleLet = 2;const sampleConst = 1; let sampleLet = 3; // 报错const sampleConst = 3; // 报错}sampleLet; // 报错sampleConst; // 报错 变量晋升(Hoisting)在ES6之前，应用var申明变量时会产生一种叫做变量晋升的个性。无论是在代码的哪个中央申明的，都会晋升到以后作用域的最顶部，这种行为叫做变量晋升。为了纠正这种景象，let 命令扭转了语法行为，它所申明的变量肯定要在申明后应用，否则报错 ...

proxy的概念Proxy 能够了解成，在指标对象之前架设一层“拦挡”，外界对该对象的拜访，都必须先通过这层拦挡，因而提供了一种机制，能够对外界的拜访进行过滤和改写。Proxy 这个词的原意是代理，用在这里示意由它来“代理”某些操作，能够译为“代理器”。var proxy = new Proxy(target, handler); new Proxy()示意生成一个Proxy实例，target参数示意所要拦挡的指标对象，handler参数也是一个对象，用来定制拦挡行为Proxy 实例也能够作为其余对象的原型对象。 var proxy = new Proxy({}, { get: function(target, propKey) { return 35; }});let obj = Object.create(proxy);obj.time // 35下面代码中，proxy对象是obj对象的原型，obj对象自身并没有time属性，所以依据原型链，会在proxy对象上读取该属性，导致被拦挡。同一个拦截器函数，能够设置拦挡多个操作。 13 种Proxy 反对的拦挡操作:get(target, propKey, receiver) ：拦挡对象属性的读取，比方proxy.foo和proxy['foo']。set(target, propKey, value, receiver) ：拦挡对象属性的设置，比方proxy.foo = v或proxy['foo'] = v，返回一个布尔值。has(target, propKey) ：拦挡propKey in proxy的操作，返回一个布尔值。deleteProperty(target, propKey) ：拦挡delete proxy[propKey]的操作，返回一个布尔值。ownKeys(target) ：拦挡Object.getOwnPropertyNames(proxy)、Object.getOwnPropertySymbols(proxy)、Object.keys(proxy)、for...in循环，返回一个数组。该办法返回指标对象所有本身的属性的属性名，而Object.keys()的返回后果仅包含指标对象本身的可遍历属性。getOwnPropertyDescriptor(target, propKey) ：拦挡Object.getOwnPropertyDescriptor(proxy, propKey)，返回属性的形容对象。defineProperty(target, propKey, propDesc) ：拦挡Object.defineProperty(proxy, propKey, propDesc）、Object.defineProperties(proxy, propDescs)，返回一个布尔值。preventExtensions(target) ：拦挡Object.preventExtensions(proxy)，返回一个布尔值。getPrototypeOf(target) ：拦挡Object.getPrototypeOf(proxy)，返回一个对象。isExtensible(target) ：拦挡Object.isExtensible(proxy)，返回一个布尔值。setPrototypeOf(target, proto) ：拦挡Object.setPrototypeOf(proxy, proto)，返回一个布尔值。如果指标对象是函数，那么还有两种额定操作能够拦挡。apply(target, object, args) ：拦挡 Proxy 实例作为函数调用的操作，比方proxy(...args)、proxy.call(object, ...args)、proxy.apply(...)。construct(target, args) ：拦挡 Proxy 实例作为结构函数调用的操作，比方new proxy(...args)。 ...

ES6 及以上最新标准let 和 const在 ES6 之前，申明变量的关键字只有var，并且没有块级作用域，只有函数作用域和全局作用域。 let、const和var的区别 不容许申明晋升不容许反复申明不笼罩全局变量letlet 申明的变量，其申明语句不会再晋升。 console.log(outer);console.log(inner); // Uncaught ReferenceError: inner is not defined{ console.log(outer); // console.log(inner); // Uncaught ReferenceError: Cannot access 'inner' before initialization var outer = true; let inner = true; console.log(outer); // true console.log(inner); // true}console.log(outer); // trueconsole.log(inner); // Uncaught ReferenceError: inner is not defined长期死区（Temporal Dead Zone, TDZ），也叫暂时性死区。用let或const申明的变量，在申明前都会放到 TDZ 中，而申明前拜访这些变量就会触发运行时谬误。 其次，let 不容许反复申明同一个变量。这里有个限度：必须是在同一个作用域时，才不容许同一个变量反复申明。 最初是let在全局作用域中的个性。当用 var 在全局作用域中申明变量的时候，该变量岂但会成为全局变量，而且会成为全局对象（如浏览器中 window 对象）的一个属性。ES6 规定用 let 可将全局变量和全局对象断开分割。上面用两组代码别离演示断开分割（第一组）和笼罩已有属性（第二组），留神，在第二组代码中为了不便比照，疏忽了反复申明的谬误。 // group 1var global = true;console.log(window.global); // truelet whole = true;console.log(window.whole); // undefined// group 2var Math = true;console.log(window.Math); //truelet Math = true;console.log(window.Math);constconst 岂但领有下面所述的 let 的 3 个个性，并且还能申明一个常量。常量是指一个定义了初始值后固定不变的只读变量。const与let不同，申明时必须初始化（即赋值）。并且这设定后其值无奈更改。留神，const 限度的是变量与内存地址之间的绑定。也就是说const让变量无奈更改内存地址。如果是根本类型（如布尔值、数字等）的变量，那么对应的内存地址中保留的就是值；如果是援用类型（如对象）的变量，那么对应的内存地址中保留的是指向理论数据的一个指针。由此可知，当用 const 申明的变量，其初始化的值是对象时，能够批改对象中的属性或办法。 ...

数组去重的罕用办法1.利用ES6新增办法去重set()对象容许存储任何类型的惟一值，无论是原始值或者对象援用；set对象存储的值总是惟一的，所以须要判断两个值是否恒等。有几个非凡值须要非凡看待：+0与-0在存储判断唯一性的时候是恒等的，所以不反复；undefined与undefined是恒等的，所以不反复；NaN与NaN是不恒等的，然而在set中只能存一个，不反复 2.利用indexOf()去重indexOf()办法课返回某个指定的字符串中首次呈现的地位；如果没有找到匹配的字符串则返回-1 3.利用filter去重（办法与indexOf类似）利用下标 先得出原数组中的索引再与下标进行匹配；相等则返回true 增加到新数组newArr中 当循环呈现雷同元素不会与下标雷同 返回false疏忽filter()办法创立一个新数组，新数组中的元素是通过查看指定数组中符合条件的所有元素 4.利用双重for循环去重splice() 办法用于增加或删除数组中的元素;这种办法会扭转原始数组。返回值:如果仅删除一个元素，则返回一个元素的数组。 如果未删除任何元素，则返回空数组。 5.利用sort办法去除相邻反复元素，然而会扭转原数组的排序

代码如下： let arr = [2, 5, 1, 5, 3, 2, 'hello', '1', 4]let unique = (arr) => { // 第一层for循环 比拟数组前一项 for (i = 0; i < arr.length; i++) { //第二层for循环 比拟数组后一项 for (j = i + 1; j < arr.length; j++) { if (arr[i] === arr[j]) { arr.splice(j, 1); j--; } } } return arr}console.log(unique(arr)); //[ 2, 5, 1, 3, 'hello', '1', 4 ]//数组去重 第二种办法 indexOf 找到返回索引值 找不到返回-1let unique1 = (arr) => { // 申明一个新数组 let newArr = []; for (i = 0; i < arr.length; i++) { if (newArr.indexOf(arr[i]) === -1) { newArr.push(arr[i]) } } return newArr}console.log(unique1(arr)); //[ 2, 5, 1, 3, 'hello', '1', 4 ]// 数组去重 第三种办法let unique2 = (arr) => { // 申明一个新数组 let newArr = []; for (i = 0; i < arr.length; i++) { if (!newArr.includes(arr[i])) { newArr.push(arr[i]) } } return newArr}console.log(unique2(arr)); //[ 2, 5, 1, 3, 'hello', '1', 4 ]// Set相似于数组，然而成员的值都是惟一的，没有反复的值。Set 自身是一个构造函数，用来生成 Set 数据结构展。// Set 构造函数能够承受一个数组（或者具备 iterable 接口的其余数据结构）作为参数，用来初始化// 数组去重的第四种办法 let set = new Set(arr)let [...a] = set //数组解构的办法console.log(set); //Set(7) { 2, 5, 1, 3, 'hello', '1', 4 }console.log(a); //[ 2, 5, 1, 3, 'hello', '1', 4 ]

残缺高频题库仓库地址：https://github.com/hzfe/aweso... 残缺高频题库浏览地址：https://febook.hzfe.org/ 相干问题对于 ES5 和 ES6 的继承问题原型链概念答复关键点原型链继承 构造函数继承 ES6 类继承 继承是指子类型具备父类型的属性和行为，使代码得以复用，做到设计上的拆散。JavaScript 中的继承次要通过原型链和构造函数来实现。常见的继承办法有：ES6 中 class 的继承、原型链继承、寄生组合式继承等。 知识点深刻1. 原型链原型链的实质是拓展原型搜寻机制。每个实例对象都有一个公有属性 \_\_proto\_\_。该属性指向它的构造函数的原型对象 prototype。该原型对象的 \_\_proto\_\_ 也能够指向其余构造函数的 prototype。顺次层层向上，直到一个对象的 \_\_proto\_\_ 指向 null。依据定义，null 没有原型，并作为这个原型链中的最初一个环节。 当试图拜访一个对象的属性时，它不仅仅在该对象上搜查，还会搜查该对象的原型，以及该对象的原型的原型，顺次层层向上搜寻，直到找到一个名字匹配的属性或直到这个链表完结（Object.prototype.__proto__ === null）。 2. 原型链继承原型链继承的思维：一个援用类型继承另一个援用类型的属性和办法。 function SuperType() {  this.b = [1, 2, 3];}function SubType() {}SubType.prototype = new SuperType();SubType.prototype.constructor = SubType;var sub1 = new SubType();var sub2 = new SubType();// 这里对援用类型的数据进行操作sub1.b.push(4);console.log(sub1.b); // [1,2,3,4]console.log(sub2.b); // [1,2,3,4]console.log(sub1 instanceof SuperType); // true长处： 父类新增原型办法/原型属性，子类都能拜访到。简略、易于实现。毛病： 无奈实现多继承。因为原型中的援用值被共享，导致实例上的批改会间接影响到原型。创立子类实例时，无奈向父类构造函数传参。3. 构造函数继承构造函数继承的思维：子类型构造函数中调用父类的构造函数，使所有须要继承的属性都定义在实例对象上。 function SuperType(name) {  this.name = name;  this.b = [1, 2, 3];}SuperType.prototype.say = function () {  console.log("HZFE");};function SubType(name) {  SuperType.call(this, name);}var sub1 = new SubType();var sub2 = new SubType();// 传递参数var sub3 = new SubType("Hzfe");sub1.say(); // 应用构造函数继承并没有拜访到原型链，say 办法不能调用console.log(sub3.name); // Hzfesub1.b.push(4);// 解决了原型链继承中子类实例共享父类援用属性的问题console.log(sub1.b); // [1,2,3,4]console.log(sub2.b); // [1,2,3]console.log(sub1 instanceof SuperType); // false长处： 解决了原型链继承中子类实例共享父类援用属性的问题。能够在子类型构造函数中向父类构造函数传递参数。能够实现多继承（call 多个父类对象）。毛病： 实例并不是父类的实例，只是子类的实例。只能继承父类的实例属性和办法，不能继承原型属性和办法。无奈实现函数复用，每个子类都有父类实例函数的正本，影响性能。4. 组合继承（伪经典继承）组合继承的思维：应用原型链实现对原型属性和办法的继承，借用构造函数实现对实例属性的继承。 function SuperType(name) {  this.name = name;  this.a = "HZFE";  this.b = [1, 2, 3, 4];}SuperType.prototype.say = function () {  console.log("HZFE");};function SubType(name) {  SuperType.call(this, name); // 第二次调用 SuperType}SubType.prototype = new SuperType(); // 第一次调用 SuperTypeSubType.prototype.constructor = SubType;长处： 能够继承实例属性/办法，也能够继承原型属性/办法。不存在援用属性共享问题。可传参函数可复用毛病： 调用了两次父类构造函数（耗内存），生成了两份实例。5. 寄生组合式继承寄生组合式继承的思维：借用构造函数来继承属性，应用混合式原型链继承办法。 // 在函数外部，第一步创立父类原型的一个正本，第二部是为创立的正本增加 constructor 属性，// 从而补救因重写而失去的默认的 constructor 属性。最初一步，将新创建的对象（即正本）赋值给予类型的原型。function inheritPrototype(subType, superType) {  var prototype = Object.create(superType.prototype); // 创建对象  prototype.constructor = subType; // 加强对象  subType.prototype = prototype; // 指定对象}function SuperType(name) {  this.name = name;}SuperType.prototype.sayName = function () {  console.log(this.name);};function SubType(name, num) {  SuperType.call(this, name);  this.num = num;}inheritPrototype(SubType, SuperType);SubType.prototype.sayNum = function () {  console.log(this.num);};长处： 只调用了一次 SuperType 构造函数，防止了在 SubType.prototype 上创立不必要的属性。可能失常应用 instanceof 和 isPrototypeOf()。毛病： 实现较为简单6. ES6 中 class 的继承ES6 中引入了 class 关键字， class 能够通过 extends 关键字实现继承，还能够通过 static 关键字定义类的静态方法，这比 ES5 的通过批改原型链实现继承，要清晰和不便很多。须要留神的是：class 关键字只是原型的语法糖， JavaScript 继承依然是基于原型实现的。 ...

https://www.starpool.cn/index...

元素的数组num中查找最大值及其第一次呈现下标，别离通过指针nmax,nmaxindex返回。写函数void input(int num,int n)，输出数组num的n个数。星池科技 主函数输出数据，调用input, search, 输入最大值及其第一次呈现下标。若相邻两个元素是a/b 和c/d (a/b<c/d),则这两个数的差为1/bd, 这个差的最小值为1/(n(n-1)), 最大值为1/n, 在法雷数列的第一个元素（0/1）与其后继以及最初一个元素（1/1）与前驱之间的差取到最大值，而正中间的那个元素1/2 与其前驱和后继元素之间的差取次大值1/(n2).要求：子程序sub1.c 蕴含一个算术运算函数 float x2x（int a，int b），此函数性能为对两个输出整型参数做某个运算，将后果做浮点数返回；主程序main1.c，定义并赋值两整型变量，而后调用函数 x2x，将x2x的返回后果printf进去。 是否该迭代器所指向的元素类型的析构函数是无关痛痒的）。https://www.starpool.cn 如果是无关痛痒的，就什么都不做，如果该元素的类型领有比拟齐备的析构函数，则调用此类型的析构函数，将两个迭代器（指针）之间的值进行逐个析构。

如秒杀零碎，失常流程：先点击秒杀，而后往服务器发送申请，在页面期待响应，这样融入大量申请，服务器压力会特地大，搞不好服务器就会宕机。星池starpool 应用 MQ 音讯队列实现异步的步骤为：点击秒杀，返回请稍后查看后果，申请去 MQ 队列中排队，等排队执行实现后返回给用户信息。这样就能够大大减少服务器的压力，晋升用户体验度。 来搭建主从数据库服务，能够实现一主多从，https://www.starpool.cn 或者多主多从，来加重单个数据库的压力。能够依照每台数据库服务器的硬件条件，正当调配权重，配合 Mycat 达到负载平衡。5、高质量代码， 正当的应用循环和递归，不要为了速度丢了内存。

或者处于性能思考，防止多次重复渲染升高性能。而是心愿组件能够缓存下来,维持以后的状态。这时候就能够用到 keep-alive 组件。触发created钩子，星池starpool 用户体验不好。 在菜单存在多级关系，多见于列表页+详情页的场景，应用keep-alive组件会显著进步用户体验，如：商品列表页点击商品跳转到商品详情，返回后仍显示原有信息，订单列表跳转到订单详情，返回，等等场景。这和目前的业务逻辑不符。咱们想要的后果是A页面后退后返回，页面放弃不变，而不是退出后从新进入放弃不变。 的src只能是URL，如果是base64则导出来图片无奈显示。https://www.starpool.cn 如果须要导出的图片是base64，能够应用docx， npm i docx，该包性能很弱小，能够设置各种各样的款式、题目等等。

会间接调用constructor来初始化对象，那就大错特错了。new表达式执行的理论过程曾经在上文中介绍过了（四个步骤），其中用于初始化对象的是第三步，星池starpool 调用的初始化函数正是“类函数”自身，而不是constructor。如果没有思考过这个问题，这一点可能不太好了解，那就让咱们举个例子来阐明一下吧：当咱们获取输入框的值时咱们可能须要的时用户最初输出的内容，而不是输出一个字母就触发一次，这个时候咱们就须要应用防抖函数。 每个构造有本人的逻辑代码，有本人的作用域。https://www.starpool.cn 能够给其余作用域提供本人导出的变量，函数，对象。也能够导入其余作用域导出的变量，函数，对象

随着对于流量治理需要的晋升，七层负载平衡的重要性越来越高。星池starpool 很多公司都在增强七层负载平衡接入层的建设。而目前这方面的软件计划比拟多，应该如何选型呢？个应用十分宽泛的Web Server开源软件，起初也被用做反向代理。通过多年的倒退，在Nginx上积攒了大量的性能。为了解决Nginx性能开发成本高的问题，由章亦春在Nginx上减少了Lua执行模块，造成了OpenResty的生态。之后有一些软件基于OpenResty来开发，如APISIX。有一些性能可能不是必须的，如流量的镜像、执行脚本语言的反对等。具体抉择哪些性能来比拟，要看具体的应用场景。因为篇幅所限，本文只比照了基础性的性能。 层负载平衡应该具备很好的可运维性。https://www.starpool.cn 这方面可能包含零碎的可观测性和可监控性，可能很好的把握零碎的运行状态，及时发现零碎的异样；也包含在不停机状况下配置的加载能力，冀望可能不影响零碎的失常转发。

SELinux是 2.6 版本的 Linux内核中提供的强制访问控制(MAC）零碎。星池starpool对于目前可用的 Linux平安模块来说，SELinux是性能最全面，而且测试最充沛 的，它是在 20 年的 MAC钻研根底上建设的。SELinux在类型强制服务器中合并了多级安全性或一种可选的多类策略，并采纳了基于角色的访问控制。从世界各地发来的idea和意见让他感触到了社区的力量，这对他意义重大。他最后也放心商业组织会滥用代码，毁坏Linux的开源个性，但他感觉那又怎么样(“What the hell”)。预计有十五亿个激活的Android设施，你的软件就在每一个中。这太棒了。你必须有某个令人惊叹的软件总部驱动所有这所有。星池starpool这就是我的想法 - 当我看到它的照片时我感到震惊。我的意思是，这是 - 这是Linux世界总部。因为以这种形式工作，你可能运行这个宏大的技术帝国 - 它是一个帝国 - 所以这是对开源的力量的惊人证实。通知咱们您如何了解开源以及它如何促成Linux的开发。

ES6中的Map:无反复值且有序的键值对Map数据汇合，其中键能够是根本数据类型，也能够是对象数据类型，值能够是任意数据类型。罕用办法：1、创立Map实例：能够通过new Map（）来创立，用Map.set办法增加数据，也能够通过二维数组来创立。let map = new Map();map.set("name","Archer");map.set("age","30");console.log(map);//{"name" => "Archer", "age" => "30"}let data = [["name","archer"],["age",30]]let map2 = new Map(data);console.log(map2);//{"name" => "archer", "age" => 30}2、获取数据Map.get办法用来获取Map中的数据 console.log(map.get("name"));//"Archer"3、删除数据Map.delete办法用来删除Map中的数据 map.delete("name");console.log(map);//{"age" => "30"}4、查看是否存在Map.has办法用来查看Map中是否存在相应的数据 let h = map.has("age");console.log(h);//true5、革除所有Map.clear办法用来革除Map中所有数据 map.clear();console.log(map);//{}6、forEach办法Map.forEach办法用来遍历Map map2.forEach((val,key,self) =>{ console.log("val:" + val + " key:" + key);//val:archer key:name val:30 key:age})ES6中的Set:无反复值的有序列表。罕用办法：1、创立Set实例： let set = new Set();set.add("Archer");set.add("30");console.log(set);//{"Archer", "30"}let data2 = ["Archer","30",30,31,31]let set2 = new Set(data2);console.log(set2);//{"Archer", "30", 30, 31}将Set数据转换为数组： let [...array1] = set2;console.log(array1);//["Archer", "30", 30, 31]总结：同Map一样，Set同样有has、delete、clear办法。通过 size 属性来查看其中有多少个值。不同的是，Set没有get办法，Map中增加数据是通过Map.set办法增加。而Set数据是通过Set.add办法增加，还有一点不同的是，Set中也有forEach办法，但forEach的第二个参数并不是索引，而是和第一个参数雷同的以后数据项item。Map个别用于数据存储，而Set个别用于获取数据交加、并集、差集 ...

map和filter参数完全相同 array.filter(function(currentValue,index,arr), thisValue)currentValue：数组元素；index：索引arr：原数组；thisValue：作为该执行回调时应用，传递给函数，用作 "this" 的值用处不同：1、map办法返回的新数组是原数组的映射，何为映射？就是和原数组的长度雷同，数值做相应解决。2、filter办法返回的值是过滤原数组后的新数组，和原数组长度不同，数值不变。示例： let arr = ["1","2","3"];let a = arr.map((item,index,a) =>{ return item + 1});console.log(a);//["11", "21", "31"]let b = arr.filter((item,index,a) =>{ return item > 1})console.log(b);//["2", "3"]另外，filter可过滤NaN、null、undefined、0 let arr = [NaN,null,undefined,"0",0,1,2,3];let newArr = arr.filter(item => item);console.log(newArr);//["0", 1, 2, 3]

Array.form作用：将数组、类数组、带有索引和length属性的对象、Set对象、Map对象、字符串转换为实在数组参数：第一个参数为要转换的数据（必选）、第二个参数为function,相似map办法（可选）。返回值：返回解决后的新数组示例：let obj = { "0":"a", "1":"b", "2":"c", "length":3}console.log(Array.from(obj));//["a", "b", "c"]let arr = [0,1,2];let set = new Set(arr);console.log(Array.from(set));//[0, 1, 2]let map = new Map();map.set("name","Archer");map.set("age","18");console.log(Array.from(map));//[["name", "Archer"],["age", "18"]]let str = "Archer";console.log(Array.from(str));//["A", "r", "c", "h", "e", "r"]let Arr = [0,1,2,3];var Arr2 = Array.from(Arr);console.log(Arr2);//[0,1,2,3]console.log(Arr == Arr2);//falselet Arr3 = [0,1,2];let Arr4 = Array.from(Arr3,(item,index) =>{ return item + 1;})console.log(Arr4);//[1, 2, 3]

// 1function axiosGetList() { return new Promise((resolve, reject) => { console.log('axios') resolve(true) })}// 2async function getList() { const a = await axiosGetList() if (a) { console.log('申请胜利') }}// 执行c()// 3function c() { console.log('c start') async function dd() { const a = await getList() console.log('a:',a) } dd() console.log('c end')}// 4new Promise((r, j) => { console.log('promise1') r() // 如果没有这行，promise2 不会执行}).then(() => { console.log('promise2')})// 5setTimeout(() => { console.log('settimeout')}, 0)// 6console.log('window')输入后果（谷歌浏览器）： 1、c start2、axios3、c end4、promise15、window6、申请胜利7、promise28、a: undefined9、settimeout第一步： ...

promise是异步解决方案，解决回调天堂问题。promise从语法上来说是一个构造函数。从性能来说封装异步操作，并且能够获取其操作后果。1.根本用法 const p =new Promise((resolve,reject)=>{ setTimeout(()=>{ //异步操作 resolve(value) },100) })构造函数Promise的参数为一个执行器函数，执行器函数的参数为resolve与reject别离代表：第一个回调函数是Promise对象的状态变为resolved时调用，第二个回调函数是Promise对象的状态变为rejected时调用2.Promise构造函数的实现 Promise对象外部含有三种状态，初始值pending 已胜利 resolved 已失败 rejected外部的状态在执行过程中，状态只能扭转一次并且不可逆。 初始化 初始时候将status的状态为pending callbacks用来保留胜利的与失败的回调函数 self.status =PENDING self.data =undefined self.callbacks =[] //每个元素构造 {onResolved(){} onRejected(){} } function Promise(excutor){ const self =this self.status =PENDING self.data =undefined self.callbacks =[] //每个元素构造 {onResolved(){} onRejected(){} } function resolve(value){ // resolve函数的作用将promise状态变为resolved if(self.status!==PENDING){ //如果不是pending状态间接返回 return } self.status =RESOLVED self.data = value if(self.callbacks.length>0){ setTimeout(() => { self.callbacks.forEach(callbacksObj => { callbacksObj.onResolved(value) }); },0); } } function reject(reason){ if(self.status!==PENDING){ return } self.status =REJECTED self.data = reason if(self.callbacks.length>0){ setTimeout(() => { //遍历回调队列 self.callbacks.forEach(callbacksObj => { callbacksObj.onRejected(reason) }); }); } } //立刻同步执行ex try{ excutor(resolve,reject) }catch(err){ reject(err) } }3.promise实例的then办法 ...

箭头函数箭头函数：将原来函数的function关键字和函数名都删掉，并应用”=>”连贯参数列表和函数体。 箭头函数语法： (参数1,参数2)=>{ 函数体 } 留神点： 当参数有且只有一个，括号能够省略。没有参数或多个参数时，括号不能省略。如果函数体有且只有一个表达式时，能够省略花括号。箭头函数应用实例： window.onload = ()=>{ console.log('网页加载实现')}参数只有一个时，省略掉括号。函数体只有一个表达式，花括号也省略。如： let arr=[1,2,3,4]arr.forEach((item)=> console.log('item',item))This指向问题 1、在全局环境下，this始终指向全局对象，无论是否严格模式。 2、一般函数外部的this分严格模式和非严格模式。 严格模式下this为undefined。非严格模式下，this指向全局对象window。3、箭头函数的 this 是上下文的this。 箭头函数相当于匿名函数，并且简化了函数定义，但箭头函数和匿名函数有个显著的差别，箭头函数外部的this是词法作用域，上下文的this值作为本人的this值。 Call()、apply()、bind()办法对于箭头函数只是传入参数，对它的this毫无影响。思考到this是词法层面上的，严格模式中与this相干的规定都将被疏忽。放在setTimeout中的两个箭头函数返回的this举例。 function Person(name,age){ this.name = name; this.age = age; setTimeout(()=>{ console.log('this',this) //Person {name: "倩倩", age: 18} },100)}let p = new Person('倩倩',18)setTimeout(()=>{ console.log("this",this)//Window {window: Window, self: Window, document: document, name: "", location: Location, …}},1000)函数参数的默认值在ES6之前，不能间接为函数的参数指定默认值，只能采取变通措施。 实例：一般函数给参数设置默认值 function sum(a,b){ a = a | 12; b = b | 5; return a+b}console.log('相加等于',sum())// 17ES6容许函数参数设置默认值，即间接写在参数定义的前面。如 ...

模块化是一种将 JavaScript 程序拆分为可按需导入的独自模块的机制，随着现在JavaScript脚本体积越来越大、越来越简单，JavaScript的模块化机制也变得越来越重要，当初，简直所有最新浏览器都反对js原生模块化机制。 模块化的意义何在？js模块化机制将js代码拆分到不同的细小文件中，有以下长处： 每个文件都具备公有命名空间，防止全局净化、变量抵触。逻辑拆散，能够将不同逻辑代码放在不同的js文件中。进步代码的可复用性、可维护性和可读性基于对象、闭包的模块化基于对象的模块化在CommonJs、ES6Module呈现以前，为了防止全局变量净化，罕用的一种办法就是将一类变量放到一个对象中，这样每个对象里的属性（变量）就都是该对象公有的，防止了变量抵触的问题。 let a = { sayHello: 'hello1'}let b = { sayHello: 'hello2'}这样即便呈现雷同的变量名，也不会造成抵触，将每个逻辑点相干的变量放到一个对象中，尽量减少变量净化的状况。js内置对象Math也是由这种思路实现的。 基于闭包的模块化IIFE（立刻调用函数表达式） IIFE是一个定义时就会调用的函数，定义一个IIFE很简略，只须要写两个小括号，第一个括号里申明一个匿名函数，第二个括号里传入实参。 // IIFE有两种写法格调，两种都能够失常应用(function (arg) { console.log(arg)})(1); // IIFE前面必须要加分号，示意完结// 1(function (arg) { console.log(arg)}(2)); // IIFE前面必须要加分号，示意完结// 2立刻调用函数表达式（IIFE）具备以下长处： 函数内的变量不会造成全局净化。函数执行完后就会立刻销毁，不会造成资源节约。设想一下有一个工具，它能解析代码文件，将每个文件的内容包装成一个立刻调用函数表达式中，还能够跟踪每个函数的返回值，将所有内容拼装成一个大文件。 一些代码打包工具就是基于这种思维实现的。 两种形式的不足之处两种办法尽管都能实现公有命名空间，防止变量净化问题，然而依然存在一些显著的缺点。 对于基于对象实现的模块化而言： 申明变量就变成了申明对象的一个属性，没方法应用申明变量的一些有用机制，可能会导致反复命名属性造成属性笼罩的问题。对象之间可能呈现笼罩的状况代码仍在一个文件里，会导致文件代码量越来越大// 意外地笼罩了属性blet o = { b: 1}o.a = 1;o.b = 2; // 笼罩了属性b，并且js不会呈现任何提醒let a = 1;let b = 2;let b = 3; // js会报错，提醒不能反复申明对于基于闭包的模块化而言： IIFE中的变量和函数不可复用应用不不便难以测试，难以保护此外两种形式都并不是真正的现实下的模块化，都存在不能将代码拆分到不同文件中，难以保护，公有命名空间的实现有缺点等问题。 Node.js的模块化（CommonJs）现实中的模块化，应该是能够将不同代码拆分到不同的文件中，这样有利于可维护性和可读性，不同代码文件之间能够相互导入，有利于可复用性，每个代码文件都具备公有命名空间，这样能够防止变量抵触和净化。 CommonJs模块机制实现了以上要求，CommonJs是Nodejs内置的模块化机制。它能够将简单的程序拆分成任意多个代码文件，每个文件都是一个领有公有命名空间的独立模块，能够抉择导出其中一个或者所有的变量和函数，另一个代码文件能够导入到本人的文件中，实现变量及函数的复用。 node的导出node的导出有两种形式，一种是module.exports，另一种是exports。这两个对象都是全局内置的，能够间接应用，他们的用法如下 // 你能够将变量独自一个一个的导出exports.a = "a";exports.b = 123;exports.fn = function() { console.log('我是一个函数，而且还是匿名的')}// 切记，这样写是不行的，具体起因稍后解释exports = { a, b}// 也能够一起导出let c = true;let fn2 = function(){ console.log('我是一个函数，而且还是匿名的') }module.exports = { c, fn2}你可能会感觉module.exports和exports很像,事实上他们的确有关系，module.exports和exports援用的是同一个对象，也就是说exports.a等同于module.exports.a。 ...

ES6简介ES6是ECMAScript 6.0的简称，是javascript语言的下一代规范，曾经在2015年6月正式公布上线。目标就是为了对立javascript的语法规范，能够用来开发大型应用程序，称为企业级开发语言。 ES6与JavaScript的关系:ES6是JavaScript的标准规范，JavaScript是ES6的一种实现。 变量/赋值块级作用域{}ES5中作用域有：全局作用域、函数作用域，没有块作用域的概念。ES6新增了块级作用域，块作用域由{}包含，if语句外面的{}也属于块级作用域。 //通过定义的变量能够跨块作用域拜访到{ var a = 12; console.log("a",a)}console.log("a",a)//通过var定义的变量不能通过跨函数作用域拜访到(function(){ var b = 5;})()console.log("b",b) // not definedvar 与 let 和 const 区别： 类型定义变量类型作用域var能够反复定义是变量，不能限度批改没有块级作用域let不能反复定义是变量块级作用域，不能跨块拜访const不能反复定义是常量，初始化时必须赋值块级作用域，不能跨块拜访const定义的对象属性是否能够扭转？ 实例1：批改对象的属性值。 const per = { name:'倩倩'}per.name = "我是嘻哈"console.log("per.name",per.name) //打印出我是嘻哈通过上个实例，咱们发现对象的属性是能够批改的，这是什么起因呢？ 对象是援用类型的，per中保留的仅是对象的指针，意味着指针不会产生扭转，批改对象的属性不会扭转对象的指针，所以是容许批改的。 赋值：新增解构赋值，就是对数据拆解并赋值。解构赋值的两个规定： 左右两边模式必须统一必须让定义和赋值同步实现。实例2：正确的构造赋值 let [a,b,c] = [1,2,3]console.log("a",a)//1console.log("b",b)//2console.log("c",c)//3实例3：左右两边模式统一，数据长短不同时 let [bar, foo] = [1];console.log("bar",bar)//1console.log("foo",foo) // undefined上述解构不胜利，变量值等于undefined。 留神：对象也是能够解构的，然而须要留神的是对象和数组的解构有很大的区别，对象的属性没有秩序，变量必须与属性同名，能力取到正确的值。 实例4：对象的解构赋值 let { bar,foo } = { foo:'aaa', bar:'bbb'}console.log('bar',bar)console.log('foo',foo)console.log('baz',baz) // not defined

Oracle数据库创立awr基线，次要目标为数据库建设已报错的工作负载视图，以便当前用来与其余awr快照进行比照。 awr基线的性能统计信息寄存在数据库中，且不会主动删除。 Oracle数据库有两种类型的基线 固定基线和挪动基线 固定基线最常见的就是固定基线，这是一种独自的动态视图，代表规范零碎的工作负载。 手动创立基线 exec dbms_workload_reposwww.diuxie.comitory.create_baseline- (start_time>=to_date('2021/07/13 08:00:00','yyyy/mm/dd hh24:mi:ss'),- end_time=>to_date('2021/07/13 10:00:00','yyyy/mm/dd hh24:mi:ss'),- baseline_name=>'Baseline #1'); --如果为基线设置过期工夫，退出参数 expiration=30; --还能够依据已创立的awr快照id来创立execdbms_workload_repository.create_baseline(-start_snap_id=>xxx,end_snap_id=>xxx,baseline_name=>'Batch baseline #1',-expiration=>30);挪动基线挪动基线的度量值是基于整个AWR保存期来捕获的。 例如，默认awr保存期为8天，它会在整个8天的工夫窗口捕捉。默认的挪动基线是主动创立的， 基线会每天变动，因为给定手游的数据库的awr窗口会每天挪动。 --批改挪动窗口,不能超过awr保存期,默认8 能够抉择8exec dbms_workload_repository.modify_baseline_window_size(30);查看基线配置col baseline_name format a20col baseline_id formant 99 heading b_idcol start_id heading STAcol end_id heading ENDcol end_time for a25col start_time for a25col expiration heading EXPset lines 200select baseline_id,baseline_name,start_snap_id start_id,to_char(start_snap_time,'yyyy/mm/dd hh24:mi:ss') start_time, end_snap_id end_id,to_char(end_snap_time,'yyyy/mm/dd hh24:mi:ss') end_time,expirationfrom dba_hist_baseline order by baseline_id;

咱们可能在某些场景中须要复制图片 当不须要用户本人右键操作复制的时候，咱们能够应用clipboard来实现（不过clipboard的兼容性不是很敌对）以下为代码HTML:<div class="imgBox"></div> JS let imgBox = document.querySelector('.imgBox'); let img = new Image(); img.crossOrigin = "anonymous"; img.src = 'https://dummyimage.com/300.png' let canvas = document.createElement('canvas'); img.onload = function() { canvas.width = img.width; canvas.height = img.height; let context = canvas.getContext('2d'); context.drawImage(img, 0, 0); imgBox.appendChild(canvas) canvas.toBlob(function(blob) { if (window.ClipboardItem) { navigator.clipboard.write([ new ClipboardItem({ [blob.type]: blob }) ]); } else { //浏览器不反对 } }, 'image/png'); }

对象的扩大运算符对象中的扩大运算符(...)用于取出参数对象中的所有可遍历属性，拷贝到以后对象之中 let bar = { a: 1, b: 2 };let baz = { ...bar }; // { a: 1, b: 2 }如果用户自定义的属性，放在扩大运算符前面，则扩大运算符外部的同名属性会被笼罩掉。 let bar = {a: 1, b: 2};let baz = {...bar, ...{a:2, b: 4}}; // {a: 2, b: 4}例子 let obj1 = { a: 1, b: 2};let obj2 = { ...obj1, b: '2-edited'};console.log(obj1); // {a: 1, b: 2}console.log(obj2); // {a: 1, b: "2-edited"}下面这个例子扩大运算符拷贝的对象是根底数据类型，因而对obj2的批改并不会影响obj1，如果改成这样： let obj1 = { a: 1, b: 2, c: {nickName: 'd'}};let obj2 = { ...obj1};obj2.c.nickName = 'd-edited';console.log(obj1); // {a: 1, b: 2, c: {nickName: 'd-edited'}}console.log(obj2); // {a: 1, b: 2, c: {nickName: 'd-edited'}}这里能够看到，对obj2的批改影响到了被拷贝对象obj1，起因下面曾经说了，因为obj1中的对象c是一个援用数据类型，拷贝的时候拷贝的是对象的援用。 ...

箭头函数中的this箭头函数自身没有this箭头函数中的this在向外层作用域中，一层层查找this，直到有this的定义 const obj = { aaa() { setTimeout(function () { console.log(this); //window }) setTimeout(() => { console.log(this); //obj对象 }) } } setTimeout(function () { console.log(this); //window },1000) console.log(this) //箭头函数相当于在这里找this所以是window setTimeout(() => { console.log(this); //window },1000) const obj = { aaa() { setTimeout(function() { setTimeout(function() { console.log(this); //window }) setTimeout(() => { console.log(this); //window }) }) setTimeout(() => { setTimeout(function() { console.log(this); //window }) setTimeout(() => { console.log(this); //obj 往上找没有，最初在aaa找到this }) }) } } obj.aaa()

在 application.properties 增加一句配置logging.level.org.flowable.ui.modeler.domain.Model=debug1.2. 游戏中的logback.xml<?xml version="1.0" encoding="UTF-8" ?> <configuration><!--定义日志文件的存储地址 勿在 LogBack 的配置中应用相对路径 fhadmin.org--> <property name="LOG_HOME" value="${catalina.base}/logs/" /> <!-- 控制台输入 fhadmin.org --> <appender name="Stdout" class="ch.qos.logback.core.ConsoleAppender"> <!-- 日志输入编码 fhadmin.org --> <layout class="ch.qos.logback.classic.PatternLayout"> <!--格式化输入：%d示意日期，%thread示意线程名，%www.sangpi.com-5level：级别从左显示5个字符宽度%msg：日志音讯，%n是换行符--> <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n </pattern> </layout> </appender> 游戏中的sql如何示意？ <!-- 依照每天生成日志文件 fhadmin.org --> <appender name="RollingFile" class="ch.qos.logback.core.rolling.RollingFileAppender"> <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy"> <!--日志文件输入的文件名--> <FileNamePattern>${LOG_HOME}/fhserver.%d{yyyy-MM-dd}.log</FileNamePattern> <MaxHistory>30</MaxHistory> </rollingPolicy> <layout class="ch.qos.logback.classic.PatternLayout"> <!--格式化输入：%d示意日期，%thread示意线程名，%-5level：级别从左显示5个字符宽度%msg：日志音讯，%n是换行符--> <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n </pattern> </layout> <!--日志文件最大的大小 fhadmin.org--> <triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy"> <MaxFileSize>10MB</MaxFileSize> </triggeringPolicy></appender> <!-- 日志输入级别 fhadmin.org --><root level="error"> <appender-ref ref="Stdout" /> <appender-ref ref="RollingFile" /> </root> </configuration> ...

Map、Set参考https://www.runoob.com/w3cnot...MapMap是一组键值对的构造，具备极快的查找速度。举个例子，假如要依据同学的名字查找对应的问题，如果用Array实现，须要两个Array： var names = ['Michael', 'Bob', 'Tracy'];var scores = [95, 75, 85];给定一个名字，要查找对应的问题，就先要在names中找到对应的地位，再从scores取出对应的问题，Array越长，耗时越长。如果用Map实现，只须要一个“名字”-“问题”的对照表，间接依据名字查找问题，无论这个表有多大，查找速度都不会变慢。用JavaScript写一个Map如下： var m = new Map([['Michael', 95], ['Bob', 75], ['Tracy', 85]]);m.get('Michael'); // 95初始化Map须要一个二维数组，或者间接初始化一个空Map。Map具备以下办法： var m = new Map(); // 空Mapm.set('Adam', 67); // 增加新的key-valuem.set('Bob', 59);m.has('Adam'); // 是否存在key 'Adam': truem.get('Adam'); // 67m.delete('Adam'); // 删除key 'Adam'm.get('Adam'); // undefined因为一个key只能对应一个value，所以，屡次对一个key放入value，前面的值会把后面的值冲掉：var m = new Map();m.set('Adam', 67);m.set('Adam', 88);m.get('Adam'); // 88SetSet和Map相似，也是一组key的汇合，但不存储value。因为key不能反复，所以，在Set中，没有反复的key。要创立一个Set，须要提供一个Array作为输出，或者间接创立一个空Set： var s1 = new Set(); // 空Setvar s2 = new Set([1, 2, 3]); // 含1, 2, 3反复元素在Set中主动被过滤： ...

　WEB根本攻打大抵能够分为三大类—— “资源枚举”、“参数操纵” 和 “其它攻打” 1623814361431941.png 资源枚举：遍历站点所有可拜访的目录，而后把一些常见的备胎文件名(比方“sql.bak”、“index-正本.html”)一个个都枚举一下，如果运气好枚举到了就间接下载。 参数操纵：包含了SQL注入、XPath注入、cgi命令执行，还有XXS和会话劫持等，xxs攻打指的是歹意攻击者往Web页面里插入歹意html代码，当用户浏览该页之时，嵌入的歹意html代码会被执行，从而达到歹意用户的非凡目标。 cookie劫持：通过获取页面的权限，在页面中写一个简略的到歹意站点的申请，并携带用户的www.sangpi.comcookie，获取cookie后通过cookie 就能够直以被盗用户的身份登录站点。 解决方案： 永远不要置信客户端传来的任何信息，对这些信息都应先进行编码或过滤解决 审慎返回用户输出的信息 应用黑名单和白名单解决(即“不容许哪些敏感信息”或“只容许哪些信息”，白名单的成果更好但局限性高) 查看、验证申请起源，对每一个重要的操作都进行游戏从新验证 应用SSL避免第三方监听通信(但无奈阻止XSS、CSRF、SQL注入攻打) 不要将重要文件、备份文件寄存在公众可拜访到的中央 会话ID无序化 对用户上传的文件进行验证(不单单是格局验证，比如一张gif图片还应将其转为二进制并验证其每帧色彩值<无符号8位>和宽高值<无符号16位>) WSDL文档该当要求用户注册后能力获取

　数据类型在计算机语言外面，是对内存地位的一个形象表达方式，能够了解为针对内存的一种形象的表达方式。接触每种语言的时候，都会存在数据类型的意识，有简单的、简略的，各种数据类型都须要在学习初期去理解，Java是强类型语言，所以Java对于数据类型的标准会绝对严格。 数据类型是语言的形象原子概念，能够说是语言中根本的单元定义，Java语言提供了八种根本类型。六种数字类型(四个整数型(默认是int 型)，两个浮点型(默认是double 型))，一种字符类型，还有一种布尔型。 图片1 一、整数类型： byte、short、int、long都是示意整数的，只不过他们的取值范畴不一样。 1、byte： byte数据类型是8位、有符号的，以二进制补码示意的整数;(256个数字)，占1字节。最小值是-128(-2^7);最大值是127(2^7-1);默认值是0; byte类型用在大型数组中节约空间，次要代替整数，因为byte变量占用的空间只有int类型的四分之一; 例子：byte a = 100，byte b = -50。 2、short： short数据类型是16位、有符号的以二进制补码示意的整数，占2字节。最小值是-32768(-2^15);最大值是32767(2^15 - 1); Short数据类型也能够像byte那样节俭空间。一个short变量是int型变量所占空间的二分之一; 默认值是0; 例子：short s = 1000，short r = -20000。 3、int： int数据类型是32位、有符号的以二进制补码示意的整数;占3字节。最小值是-2,147,483,648(-2^31);最大值是2,147,485,647(2^31 - 1);个别地整型变量默认为www.sangpi.comint类型;默认值是0; 例子：int a = 100000, int b = -200000。 4、long： long数据类型是64位、有符号的以二进制补码示意的整数;占4字节。最小值是-9,223,372,036,854,775,808(-2^63);最大值是9,223,372,036,854,775,807(2^63 -1);这种类型次要应用在须要比拟大整数的零碎上;默认值是0L。 能够看到byte和short的游戏取值范畴比拟小，而long的取值范畴太大，占用的空间多，基本上int能够满足咱们的日常的计算了，而且int也是应用的最多的整型类型了。在通常状况下，如果JAVA中呈现了一个整数数字比方35，那么这个数字就是int型的，如果咱们心愿它是byte型的，能够在数据后加上大写的 B：35B，示意它是byte型的，同样的35S示意short型，35L示意long型的，示意int咱们能够什么都不必加，然而如果要示意long型的，就肯定要在数据前面加“L”。 二、浮点型： 浮点型包含单精度浮点型(float)和双精度浮点型(double)。double型比float型存储范畴更大，精度更高，所以通常的浮点型的数据在不申明的状况下都是double型的。 ...

package com.fh.util;import java.awt.Color;import java.awt.Font;import java.awt.Graphics;import java.awt.Image;import java.awt.image.BufferedImage;import java.io.File;import javax.imageio.ImageIO;//import java.io.FileOutputStream;//import com.sun.image.codec.jpeg.JPEGCodec;//import com.sun.image.codec.jpeg.JPEGImageEncoder;/** 阐明：游戏图片水印解决类作者：FH Adminfrom：www fhadmin org */public class Watermark { private static String strFWATERM,strIWATERM; static{ strFWATERM = Tools.readTxtFile(Const.FWATERM); //读取文字水印配置 strIWATERM = Tools.readTxtFile(Const.IWATERM); //读取图片水印配置 } /** * 刷新 */ public static void fushValue(){ strFWATERM = Tools.readTxtFile(Const.FWATERM); //读取文字水印配置 strIWATERM = Tools.readTxtFile(Const.IWATERM); //读取图片水印配置 } /** * @param imagePath 图片全门路 */ public static void setWatemark(String imagePath){ //文字水印 if(null != strFWATERM && !"".equals(strFWATERM)){ String strFW[] = strFWATERM.split(",fh,"); if(strFW.length == 5){ if("yes".equals(strFW[0])){ pressText(strFW[1].toString(), imagePath, "", 1, Color.RED,Integer.parseInt(strFW[2]), Integer.parseInt(strFW[3]), Integer.parseInt(strFW[4])); //文字 } } } //图片水印 if(null != strIWATERM && !"".equals(strIWATERM)){ String strIW[] = strIWATERM.split(",fh,"); if(strIW.length == 4){ if("yes".equals(strIW[0])){ pressImage(PathUtil.getClasspath() + Const.FILEPATHIMG+strIW[1], imagePath, Integer.parseInt(strIW[2]), Integer.parseInt(strIW[3])); } } } } /** * 把图片印刷到图片上 * * @param pressImg -- * 水印文件 * @param targetImg -- * 游戏指标文件 * @param x * --x坐标 * @param y * --y坐标 */ public final static void pressImage(String pressImg, String targetImg, int x, int y) { try { //指标文件 File _file = www.sangpi.comnew File(targetImg); Image src = ImageIO.read(_file); int wideth = src.getWidth(null); int height = src.getHeight(null); BufferedImage image = new BufferedImage(wideth, height, BufferedImage.TYPE_INT_RGB); Graphics g = image.createGraphics(); g.drawImage(src, 0, 0, wideth, height, null); //水印文件 File _filebiao = new File(pressImg); Image src_biao = ImageIO.read(_filebiao); int wideth_biao = src_biao.getWidth(null); int height_biao = src_biao.getHeight(null); //g.drawImage(src_biao, (wideth - wideth_biao) / 2,(height - height_biao) / 2, wideth_biao, height_biao, null); g.drawImage(src_biao, x, y, wideth_biao, height_biao, null); //水印文件完结 g.dispose(); /*FileOutputStream out = new FileOutputStream(targetImg); JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out); encoder.encode(image); out.close();*/ String formatName = targetImg.substring(targetImg.lastIndexOf(".") + 1); ImageIO.write(image, /*"GIF"*/ formatName /* format desired */ , new File(targetImg) /* target */ ); } catch (Exception e) { e.printStackTrace(); } } /** * 打印文字水印图片 * * @param pressText * --文字 * @param targetImg -- * 指标图片 * @param fontName -- * 字体名 * @param fontStyle -- * 字体款式 * @param color -- * 字体色彩 * @param fontSize -- * 字体大小 * @param x -- * 偏移量 * @param y */ public static void pressText(String pressText, String targetImg, String fontName, int fontStyle, Color color, int fontSize, int x,int y) { try { File _file = new File(targetImg); Image src = ImageIO.read(_file); int wideth = src.getWidth(null); int height = src.getHeight(null); BufferedImage image = new BufferedImage(wideth, height, BufferedImage.TYPE_INT_RGB); Graphics g = image.createGraphics(); g.drawImage(src, 0, 0, wideth, height, null); g.setColor(color); g.setFont(new Font(fontName, fontStyle, fontSize)); g.drawString(pressText, x, y); g.dispose(); /*FileOutputStream out = new FileOutputStream(targetImg); JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out); encoder.encode(image); out.close();*/ String formatName = targetImg.substring(targetImg.lastIndexOf(".") + 1); ImageIO.write(image, /*"GIF"*/ formatName /* format desired */ , new File(targetImg) /* target */ ); } catch (Exception e) { System.out.println(e); } }

Apache Flink 是大数据畛域又一新兴框架。它与 Spark 的不同之处在于，它是应用流式解决来模仿批量解决的，因而可能提供亚秒级的、合乎 Exactly-once 语义的实时处理能力。Flink 的应用场景之一是构建实时的数据通道，在不同的存储之间搬运和转换数据。本文将介绍如何应用 Flink 开发实时 ETL 程序，并介绍 Flink 是如何保障其 Exactly-once 语义的。 让咱们来编写一个从 Kafka 抽取数据到 HDFS 的程序。数据源是一组事件日志，其中蕴含了事件产生的工夫，以工夫戳的形式存储。咱们须要将这些日志按事件工夫别离寄存到不同的目录中，即按日分桶。工夫日志示例如下： {"timestamp":1545184226.432,"event":"page_view","uuid":"ac0e50bf-944c-4e2f-bbf5-a34b22718e0c"} {"timestamp":1545184602.640,"event":"adv_click","uuid":"9b220808-2193-44d1-a0e9-09b9743dec55"} {"timestamp":1545184608.969,"event":"thumbs_up","uuid":"b44c3137-4c91-4f36-96fb-80f56561c914"} 产生的目录构造为：/user/flink/event_log/dt=20181219/part-0-1 /user/flink/event_log/dt=20181220/part-1-9 创立我的项目Flink 应用程序须要应用 Java 8 编写，咱们能够应用 Maven 模板创立我的项目：mvn archetype:generate \ -DarchetypeGroupId=org.apache.flink \ -DarchetypeArtifactId=flink-quickstart-java \ -DarchetypeVersion=1.7.0 将生成好的代码导入到 IDE 中，能够看到名为 StreamingJob 的文件，咱们由此开始编写程序。Kafka 数据源Flink 对 Kafka 数据源提供了原生反对，咱们须要抉择正确的 Kafka 依赖版本，将其增加到 POM 文件中：<dependency> <groupId>org.apache.flink</groupId> <artifactId>flink-connector-kafka-0.10_${scala.binary.version}</artifactId> <version>${flink.version}</version> </dependency> 测试过程中，咱们须要一个可能运行的 Kafka 服务，读者能够参照官网文档 搭建本地服务。在 Flink 中初始化 Kafka 数据源时，传入服务器名和主题名就能够了：Properties props = new Properties(); props.setProperty("bootstrap.servers", "localhost:9092"); FlinkKafkaConsumer010<String> consumer = new FlinkKafkaConsumer010<>( ...

forEach终止循环谬误用法一:应用break(会报错) var array = ["第一","第二","第三","第四"]; // 间接就报错了array.forEach(function(item,index){ if (item == "第三") { break; } alert(item);});谬误用法二:应用return false(会跳过以后项,持续循环) 相当于for 循环中的continuevar array = ["第一","第二","第三","第四"]; // 会遍历数组所有元素，只是执行跳过"第三"，return false上面的代码不再执行而已array.forEach(function(item,index){ if (item == "第三") { return false; } console.log(item);// "第一" "第二" "第四"});console.log("以下代码")// 以下代码正确用法:使用try catch(抛出异样) try { var array = ["第一","第二","第三","第四"]; // 执行到第3次，完结循环 array.forEach(function(item,index){ if (item == "第三") { throw new Error("第三"); } console.log(item);// 第一 第二 });} catch(e) { if(e.message!="第三") throw e;};// 上面的代码不影响继续执行console.log("下方代码");//下方代码参考原文

promise原理Promise.all()办法用于将多个 Promise 实例，包装成一个新的 Promise 实例。 const p = Promise.all([p1, p2]);状态响应状况p的状态由p1、p2决定，分成两种状况。 （1）只有p1、p2的状态都变成fulfilled，p的状态才会变成fulfilled，此时p1、p2、p3的返回值组成一个数组，传递给p的回调函数。 （2）只有p1、p2之中有一个被rejected，p的状态就变成rejected，此时第一个被reject的实例的返回值，会传递给p的回调函数。 不同之处p1、p2实例的.catch办法与 .promise.all()办法的.catch const p1 = new Promise((reslove) => { reslove('胜利回调')}).then(res => res).catch(err => err)const p2 = new Promise((reslove, reject) => { reject('报错了')}).then(res => res).catch(err => err)export default function() { return Promise.all([p1, p2]).then((res) => { console.log(res) ["胜利回调", "报错了"] }).catch((err) => { console.log(err) })}const p1 = new Promise((reslove) => { reslove('胜利回调')}).then(res => res)const p2 = new Promise((reslove, reject) => { reject('报错了')}).then(res => res)export default function() { return Promise.all([p1, p2]).then((res) => { console.log(res) }).catch((err) => { console.log(err) 报错了 })}

Render渲染(Update阶段)同Mount阶段一样，也是有“递”和“归”两个阶段"递阶段"同Mount阶段不同的是，在beginWork办法中会进入 if (current !== null)这一条件分支，外面会对此次构建的Fibre和上次的Fibre节点进行比拟 if ( oldProps !== newProps || hasLegacyContextChanged() || (__DEV__ ? workInProgress.type !== current.type : false) ) 会给didReceiveUpdate字段赋值，用于断定是否发生变化如果Fiber节点前后无变动，则进入bailoutOnAlreadyFinishedWork办法若没有满足条件，则进入switch语句，依据不同的case条件，执行不同的操作"递阶段图解"“归阶段”后续更新...

python介绍 谈及python，波及两层意思， 一层代表的是python这门语言的语法格调， 另外一层代表的则是专门用来解释该语法格调的应用程序：python解释器。 python的创始人为吉多·范罗苏姆(Guido van Rossum)。Python这个名字，来自Guido所挚爱的电视剧Monty Python’s Flying Circus，他心愿这个新的叫做Python的语言，能合乎他的现实：发明一种C和shell之间，语法可能像shell一样简洁，易学易用、可拓展性强，同时兼顾C的弱小性能。于是Guido在1989年的圣诞节期间，开始编写可能解释Python语言语法的解释器。 Python崇尚柔美、清晰、简略，是一个优良并宽泛应用的语言。最新的游戏TIOBE排行榜http://www.sangpi.com/，Python已飙升至世界第二。 python解释器品种官网的Python解释器实质就是基于C语言开发的一个软件，该软件的性能就是读取以.py结尾的文件内容，而后依照Guido定义好的语法和规定去翻译并执行相应的代码。这种用C实现的解释器称为CPython，它是python畛域性能最好，利用最宽泛的一款解释器，咱们在前面提到的解释器指的都是Cpython解释器。但其实解释器作为一款应用软件，齐全能够采纳其余语言来开发，只有能解释python这门语言的语法即可。Python解释器的一些品种如下，简略理解即可 JythonJPython解释器是用JAVA编写的python解释器，能够间接把Python代码编译成Java字节码并执行，它岂但使基于java的我的项目之上嵌入python脚本成为可能，同时也能够将java程序引入到python程序之中。# IPythonIPython是基于CPython之上的一个交互式解释器，也就是说，IPython只是在交互方式上有所加强，然而执行Python代码的性能和CPython是齐全一样的。这就好比很多国产浏览器尽管外观不同，但内核其实都是调用了IE。CPython用>>>作为提示符，而IPython用In [序号]:作为提示符。# PyPyPyPy是Python开发者为了更好地Hack Python而用Python语言实现的Python解释器。PyPy提供了JIT编译器和沙盒性能，对Python代码进行动静编译(留神不是解释)，因而运行速度比CPython还要快。# IronPythonIronPython和Jython相似，只不过IronPython是运行在微软.Net平台上的Python解释器，能够间接把装置Cpython解释器自行百度，此处略 运行python的两种形式 第一个python程序形式一：交互式模式 形式二：脚本文件关上一个文本编辑工具，写入下述代码，并保留文件，此处文件门路为F:\test.py 强调：python解释器执行程序是解释执行，解释的根本就是关上文件读内容，因而文件的后缀名没有硬性限度，但通常定义为.py结尾print('hello world')关上cmd，运行命令，如下图 总结 1、交互式模式下能够即时失去代码执行后果，调试程序非常不便 2、若想将代码永恒保留下来，则必须将代码写入文件中 3、咱们当前次要就是在代码写入文件中，偶然须要关上交互式模式调试某段代码、验证后果 “ 一个python程序运行须要通过三个步骤“ 以python程序为列(运行a.py) 1.首先启动python解释器2.解释器发送零碎调用，操作系统将a.py的内容读入内存，此时内容全为一般字符，没有任何意义3.解释器开始逐行执行内存中的a.py内容，并且开始辨认语法 #不同点文本编辑操作(a.txt) 1.首先也是启动文本编辑器2.文本编辑器发送零碎调用，操作系统a.txt的内容读入内存3.文本编辑器会将刚刚读入内存的内容画到屏幕上，并没有语法结构 #不同点IDE工具pycharm应用什么是IDE？为何要有IDE 在编写第一个python程序时，存在以下问题，重大影响开发效率 问题一：咱们理解到一个python程序从开发到运行须要操作至多两个软件 1、关上一个软件：文本编辑器，创立文原本编写程序2、关上cmd，而后输出命令执行pyton程序问题二：在开发过程中，并没代码提醒以及纠错性能 综上，如果能有一款工具可能集成n个软件的性能，同时又代码提醒以及纠错等性能，那么将会极大地晋升程序员的开发效率，这就是IDE的由来，IDE全称Integrated Development Environment，即集成开发环境，最好的开发Python程序的IDE就是PyCharm。 pychram装置 此处略，破解教程链接：http://www.sangpi.com/ “ IDE集成开发环境Pycharm就是一个IDE 其实就是一个多功能集成的一个文本编辑器 在理论开发中,除了编译器是必须的工具,咱们往往还须要很多其余辅助软件 比方 : 编辑器, 调试器, 图形用户界面,这些性能打包在一起, 咱们就能够称这是一个集成开发环境

Ubuntu 能搞得像 Mac 和 Windows 一样难看的桌面环境吗，而且要简略疾速，不折腾。笔者在往年将零碎更新成 Ubuntu18.04 后，每每有闲工夫，就想着折腾一番，因为在应用过程中，有个实用且丑陋的桌面环境，真的工作起来很舒心，千万不要想着关了灯全都一个样，而后就开始将就。 因为丑化桌面环境，其实对于生产力，真的没有多大晋升，而且，不同的 Linux distribution，不同的桌面环境，比方 KDE、gnome、unity，折腾起来又不一样，教训无奈迁徙，不小心还可能把零碎搞坍方，而且，在 Linux 下，更多的还是依附命令，所以笔者也认为，折腾的价值真的不大。奈何看着丑丑的界面，忍不住就搞上一番。 最近，终于把桌面搞得称心了，分享进去，我感觉应该能满足少数人的需要了，先看几张图： Ubuntu18.04 默认的桌面环境是 gnome3，相比拟 unity 和 KDE，笔者更喜爱 gnome，unity 看起来有点楞，KDE 又有些简单，游戏不够简洁。 1 装置 gnome-tweaks在 Ubuntu 的利用商店中搜寻 gnome-tweaks，装置即可。装置实现后关上 gnome-tweaks，Appearance 标签下的 shell 选项是 disable 的，参见 这里自行解决。 2 dash-to-panel 插件装置我感觉，插件有这一个就够了。genome 桌面顶部会有个状态栏，而后还会有个任务栏，对于不大的屏幕来说，几乎是节约空间，而且丑逼。相较而言，Windows 的解决形式，我就感觉很好，而 dash-to-panel 插件，就做了这样一件事，合并两栏。 好，咱们分两步走 2.1 下载在 这里 下载相应版本的插件。 2.2 装置而后解压，解压后将文件夹的名字改为 dash-to-panel@jderose9.github.com 这个模式， 而后放到 ~/.local/share/gnome-shell/extensions/ 门路下，这个时候，关上 gnome-tweaks 后，就能够在 Extensions 的标签下看到看到该插件了，enable 就能够了。 3 装置 vimix 主题这里 提供了各种装置形式，依照文档装置就好了，这个没啥问题。 装置实现后，关上 gnome-tweaks 的 Appearance 标签下，别离在 Applications 和 Shell 选项里抉择 vimix 相干的主题就好了，笔者选的是 Vimix-Laptop。 ...

1.获取的json数据是这样的 data:[ { 'Id': '1', 'Phone': '123456', 'Name': '张三', }, { 'Id': '2', 'Phone': '78945', 'Name': '李四', }, { 'Id': '3', 'Phone': '123789', 'Name': '王五', }]将数组中的每个对象的Name取出来，产生一个新的数组 let results = data.map(data => n.name);//['张三','李四','王五']判断数组中是否存在某个值 let results = data.filter(item => item.Name==='王五' );去掉空数组空字符串、undefined、null var arr = ['1','2',undefined, '3.jpg',undefined]var newArr = arr.filter(item => item)过滤不合乎项 var arr = ['10','12','23','44','42']var newArr = arr.filter(item => item.indexOf('2')<0) 数组去重 办法1：var arr = [1, 2, 2, 3, 4, 5, 5, 6, 7, 7,8,8,0,8,6,3,4,56,2];var arr2 = arr.filter((x, index,self)=>self.indexOf(x)===index) 办法2：var arr = [1,2,3,4,3,4]; var arr2 = [...new Set(arr)];替换两个变量的值 ...

前言 (介绍 ECMAScript)最后 JavaScript 语言有 2 份规范： ECMA-262：主规范，由 ECMA 国内组织（Ecma International）负责管理（为了让最后的JavaScript 与最后的 JScript 能遵循同一套规范倒退而诞生的 ECMAScript ，正好排到了作为 Ecma 的 262 号规范，所以失去 ECMA-262 编号。） ISO/IEC 16262：第二规范，由国际标准化组织（ISO，International Organization for Standardization）和国内电子技术委员会（IEC，International Electrotechnical Commission）负责管理 出于商标版权的起因，标准规范中将这门语言称为 ECMAScript ，所以原则上 JavaScript 与 ECMAScript 指的是同一个货色，但有时也会加以辨别： JavaScript：指语言及其实现ECMAScript：指语言规范及语言版本，比方 ES6 示意语言（规范）的第 6 版ECMAScript 倒退历史ECMAScript 1（1997 年 6 月）：标准第一版ECMAScript 2（1998 年 6 月）：为了同步 ISO 规范，引入了一些小更新ECMAScript 3（1999 年 12 月）：减少了正则表达式、字符串解决、管制语句（do-while、switch）、异样解决（try-catch）等泛滥外围个性ECMAScript 4（2008 年 7 月破除)：原本是一次大规模降级（动态类型、模块、命名空间等），但跨度过大，呈现了一致，最终没能推广应用ECMAScript 5（2009 年 12 月）：变动不大，加了一些规范库个性和严格模式ECMAScript-5.1（2011 年 6 月）：又一次小更新，为了同步 ISO 规范ECMAScript 6（2015 年 6 月）：一大波更新，实现了当年 ES4 的许多构想，并正式改为按年份命名标准版本ECMAScript 2016（2016 年 6 月）：第一个年度版本，与 ES6 相比，公布周期较短，新个性也绝对少些ECMAScript 2017（2017 年 6 月）：第二个年度版本...当前的 ECMAScript 版本（ES2018、ES2019、ES2020 等）都在 6 月正式获准失效开始 （聚焦 ES6）这里援用 阮一峰 老师的 ES6规范入门 一书中的总结：ES6 既是一个历史名词，也是一个泛指，含意是 5.1 版本当前的 JavaScript 的下一代规范，涵盖了 ES2015、ES2016、ES2017 等，而 ES2015 则是正式名称，特指当年公布的正式版本的语言规范 市面上提到的 ES6 个别是指 ES2015 规范，但有时也是泛指 下一代 JavaScript ...

Symbol("haha"), 避免属性抵触；根底数据类型，标识惟一值 不能new创立 Symbol()能够加形容 Symbol("name")能够作为对象属性名魔术字符串（比拟有用）switchconst shapeType = { triangle: Symbol()};switch(a) { case shapeType.triangle: ... // 确保shapeType外面的值的唯一性}属性名遍历 Object.getOwnPropertySymbolsfor in 不能拜访到Reflect.ownKeys (返回全副)定义相等Symbol值, Symbol.for Symbol.for("1") === Symbol.for(1) // trueSymbol.for("1") === Symbol.for(2) // falseSymbol("bar") === Symbol("bar") // falseSymbol.keyFor(s2) Symbol.for定义的symbol能够被 Symbol.keyFor获取key原生Symbol 通过Symbol.keyFor(s2)失去 undefined单例模式 const FOO_KEY = Symbol("foo")class A {}if (!global[FOO_KEY]) { global[FOO_KEY] = new A();}module.exports = global[FOO_KEY];内置Symbol值，11个 Symbol.hasInstance （instanceof ）Symbol.isConcatSpreadable （concat 数组操作时，是否开展）Symbol.speciesSymbol.matchSymbol.replaceSymbol.searchSymbol.splitSymbol.iteratorSymbol.toPrimitiveSymbol.toStringTagSymbol.unscopables

数据汇合【Array,Object,Map,Set】的对立遍历数据结构机制 Iterator 遍历过程创建对象指针，指向起始地位第一次调用next，拜访第一个对象一直调用next办法，直至终止{ value: undefined, done: true }var it = makeIterator(['a', 'b']);function makeIterator(array) { var index = 0; return { next: function() { return index < array.length ? { value: array[index++], done: false }: { value: void 0, done: true } } }}object自身不能被遍历，ES6规定实现Symbol.iterator 能够反对遍历 var obj = { name: "ranck", massgage: "hahah", level: "t3"}for(let value of obj) { console.log(value) // Uncaught TypeError: obj is not iterable}obj[Symbol.iterator] = function () { // 这样不报错，然而不失效 return { next: function () { return { value: 1, done: false }; } }}obj[Symbol.iterator] = function () { const attrs = Object.getOwnPropertyNames(this) let index = 0 return { next: () => { return index < attrs.length ? { value: this[attrs[index++]], done: false }: { value: void 0, done: true } } }}

const varMethod = "varMethod"class Page{ current = 1 pageSize = 10 #dd = "dd" // 公有属性 constructor (props) { this.data = props.data; // 默认返回Page的对象实例，然而能够自定义返回对象 } static target = "target attr" // 动态属性 static method() { // 静态方法 return "static method" } [varMethod ] () { return "varMethod" } get current1() { // 如果和current反复，则自身不失效 return "haha" + this.current } set current1 (value) { if(value < 0) { console.log("current 不能") return false } this.current = value } valueOf() { // 数值转换时后调用，隐式调用也会 return 9527 } toString () { return `[object Page]` } }

Proxy 批改操作的默认行为 const obj = { name: "ranck", message: "hello"}const handler = {}const proxy = new Proxy(obj, handler)一个对象的操作方法有13种 getsetdeletePropertydefinePropertyapply (call)constructorsetPrototypeOfgetPrototypeOfownKeys (枚举)has （in， 包含原型链）getOwnPropertyDescriptorisExtensiblepreventExtensions勾销Proxy代理Proxy.revocable()办法返回一个可勾销的 Proxy 实例。 const {proxy, revoke} = Proxy.revocable(obj,handler);revoke() // 这个函数调用后，proxy就不能失效了this代理对象种this，指向的是proxy，而不是target自身 Proxy利用做一些操作的时候，同时做其余事件 数据驱动function proxyFn(obj, fn) { var handler = { get(obj, prop) { fn(); Reflect.get(obj, prop) } } return new Proxy(obj, handler)}间接拜访变量拜访变量的过程代理申请http接口的行为 function createServe(baseUrl) { return new Proxy({}, { get (target, prop) { return fetch( `${baseUrl}/${prop}` ) }})}const serverProxy = createServe("/v1")serverProxy.dd.then(console.log,console.log)

SetSet的成员惟一 const set = new Set([1,2,4,6,4,1,2,4])set.add("ff")数组去重 const arr = [2,5,5,5,1,12,31,1,2][...new Set(arr)]Array.from(arr)addcleardeletehasvalueskeysentries (数组键值)forEachWeakSet只能接管援用类型 Map

函数参数设置默认值 参数解构参数默认值地位 undefinedrestname属性箭头函数 () => {}可省 （a, b）=> a + bthis 的作用域是定义时所在的对象（非凡）不可当作构造函数应用new实例化对象不可最为生成器函数，yield报错toString (返回函数定义)

js中定义变量形式如下三种常见形式 var foo = 1;let data = 2;const arr = [];非凡形式 function aa () {}import aa from "aa"class AA {}变量晋升和函数晋升函数晋升会被优先晋升到最前，然而前面的变量名字和函数名统一的话，赋值会笼罩掉后面的函数 var aa = 1 function aa() {}aa // 1var 定义变量的步骤 第一阶段，变量到作用域中,申明变量，未赋值，所以是undefined第二阶段，赋值，aa = 1第三阶段，变量回收，标记回收法块级作用域foo // undefined{ let foo = "dd"}长期死区let 和 const 没有变量晋升，必须先定义后应用；否则会报错 不容许反复申明let a = 1;{ a = 2}let a = 5 // 报错const 定义时候必须赋值const变量指向的那个内存地址所保留的数据不得改变；援用类型指向的对象能够批改 const arr = [];arr.push(1)arr.d = 2arr = {} // error

需要形容有一数组，数组中的每一项搁置的是一个个的对象，构造如下： let arr = [ { name: "孙悟空", age: 500, home: "花果山" }, { name: "猪八戒", age: 88, home: "高老庄" }, { name: "沙和尚", age: 1000, home: "通天河" }, ]想加工数据当前，使得每一项的home属性都不要，只留name和age属性。 形式一（map映射，指定属性不映射过来） let newArr = arr.map((item) => { let obj = { name: item.name, age: item.age } return obj }) console.log(newArr);形式二（过滤遍历并delete删除指定属性） let newArr = arr.filter((item, index) => { return delete item.home // 留神：打印一下delete item.home返回的是true }); console.log(newArr);形式三（一般遍历间接删除指定属性） // forEach遍历 arr.forEach((item) => { delete item.home }); console.log(arr); // for in 遍历 for (let key in arr) { delete arr[key].home } console.log(arr); // 等...记录一下......

前言传统的字符串模板在传统的Javascript中，如果咱们对DOM进行操作，字符串模板通常采纳加号( + )进行字符串拼接。 ES6模板字符串反引号( ` )示意一般的字符串，也能够示意多行字符串(随便换行)，同时还能够插入变量（代替传统的加号拼接）。 简介模板字符串应用反引号 (``) 来代替一般字符串中的用双引号和单引号。模板字符串能够蕴含特定语法（${expression}）的占位符。占位符中的表达式和四周的文本会一起传递给一个默认函数，该函数负责将所有的局部连接起来。 如果一个模板字符串由表达式结尾，则该字符串被称为带标签的模板字符串，该表达式通常是一个函数，它会在模板字符串解决后被调用，在输入最终后果前，你都能够通过该函数来对模板字符串进行操作解决。在模版字符串内应用反引号（`）时，须要在它后面加本义符（\）。 留神：模板字符串中的换行和空格会被保留，并且如果模板字符串中的变量没有申明，将报错。 后续，咱们所有实例都采纳比照传统的字符串进行演示。 根本用法// 传统字符串拼接var str1 = "我是：";var str2 = "学生";window.alert(str1 + "一名" + str2);//我是：一名学生// ES6模板字符串拼接var str1 = "我是：";var str2 = "学生";window.alert(`${str1}一名${str2}`);//我是：一名学生能够看到，模板字符串拼接更加简洁直观。 你也能够轻松取得多行字符串： // 传统写法var str1 = "我是：";var str2 = "学生";console.log(str1+'\n'+str2);/*我是：学生*/// ES6模板字符串写法var str1 = "我是：";var str2 = "学生";console.log(`${str1}${str2}`);/*我是：学生*/在新行中插入的任何字符都是模板字符串中的一部分。 如果大括号外部是一个字符串，将会原样输入： console.log(`hello ${'ES6'} !`)// hello ES6 !插入表达式 在一般字符串中嵌入表达式(任意表达式或对象属性等)，传统办法略显臃肿，字符串模板更优雅。 // 传统写法var n1 = 10;var n2 = 20;console.log("n1+n2="+(n1+n2));//n1+n2=30// ES6模板字符串写法var n1 = 10;var n2 = 20;console.log(`n1+n2=${n1+n2}`);//n1+n2=30能够看到，不仅层次分明，还有较强的直观性。 ...

前言在我的项目开发的过程中，一些共用的数据、办法、类等能够封装成模块进行输入，咱们在须要的中央加载该模块，就省去了大量的重复性代码。如何模块化开发就用到了ES6的常识：export和import。 export相对输入就是肯定要有变量名或者办法名，能力进行输入。 export function test () {} //正确的export function () {} //谬误的能够间接在变量、办法前进行exportexport var test = "123"export var test = function () {} export var test = function test1 () {} //输入test变量export function test () {}在任意地位进行export输入变量必须给输入的变量名或者办法名加括号{} var test = "123"export {test}var test1 = function () {} export {test1}应用规定一个文件中能够屡次应用export并且export也能够一次输入多个变量 var test = "123"export {test}var test1 = function () {} export {test1}export {test,test1}export default默认输入就是不搞绝对化了，我默认输入一个变量或者办法（匿名办法也能够），你援用的时候能够用任意变量名进行援用。从实质上来说 export default就是输入一个定义为default的变量或办法，所以它前面不能跟变量申明语句 export default function () {} //也是正确的export default var test = function () {} //谬误的能够间接在变量、办法前进行export defaultexport default function () {} export default function test () {} 在任意地位进行export default输入变量不须要给输入的变量名或者办法名加{} ...

什么是Promise？为什么要应用Promise？当咱们应用js的异步调用时通常习惯应用回调函数，这样的代码简略便于了解，然而当回调嵌套的时候就会造成代码凌乱，不好梳理，比方： function fun1(arg1,function(){// dosomething })这样简略的嵌套天然是没问题，还便于了解。然而当有多层嵌套的时候： 咱们只晓得Promise是最大的益处是为了防止“回调天堂”，就是多层的回调 function fun1(arg1,function(data1){ function fun1(arg2, function(data2){ function fun1(arg3, function(data3){ //..... }) })})像下面这样，三层嵌套就曾经很麻烦了，更何况更多层的嵌套，所以为了让回调更显著，代码更容易了解，应用Promise能够很优雅的解决这个问题： var p = new Promise(function(resolve，reject){}).then(function(data){}).then(function(data){}).then…… 下面就是Promise的根本用法，Promise承受一个回调函数，回调函数接管两个参数，resolve（将Promise的状态从pending变为fulfilled，在异步操作胜利时调用，并将异步操作的后果传递进来）、reject（将Promise的状态从pending变为rejected，在异步操作失败时调用，将异步操作的谬误作为参数传递进来）这两个都是函数，示意胜利和失败的处理函数。then中承受的是上一次回调返回的后果，所以这样的链式调用就能够齐全清晰的实现多层调用。 Promise对象有两个特点：①，对象的状态不受外界的影响，Promise有三种状态：Pending（进行中）、fulfilled（已胜利）、rejected（失败），只用异步操作的后果能够决定以后是哪一种状态，其余任何操作都无奈扭转这个操作。 ②.一旦状态扭转之后就不会再扭转。任何时候都能够失去这个后果。状态变动只有两种可能：从pending到fulfilled和从pending到rejected。只有扭转就曾经定型了。 Promise的毛病： ① 一旦创立就无奈勾销，一旦新建就会立刻执行 ② 如果不设置回调函数，它的外部谬误就不会反映到内部。 ③ 当处于pending状态时，无奈判断停顿到哪一阶段（刚开始还是快实现）。 接下来讲一下Promise的根本语法，先看一下Promise打印进去的后果 从上图能够看到Promise.prototype上有catch、then、constructor办法。所以这几个办法能够被实例继承。 Promise本身会有Promise.all()、Promise.race()、Promise.resolve()、Promise.reject()一些罕用的办法。 1.Promise.prototype.then() let promise = new Promise(function(resolve,reject){ console.log("promise"); resolve();});setTimeout(function(){ console.log("setTimeout");},0)promise.then(function(){ console.log("resolved");})console.log("hi");// promise hi resolved setTimeout下面的代码很好的验证了，promise是创立之后立刻执行，then办法指定的脚本在以后的所有同步工作实现之后再执行,setTimeout是在下一轮“工夫循环”开始时执行，then在本轮事件循环完结时执行。 2.Promise.prototype.catch()当Promise对象执行胜利时应用的是resolve回调函数，进而在then办法中进一步解决，当promise对象失败时在那儿进行解决？ 有两种办法：①在then办法承受第二个函数参数，用来处理错误。（不举荐） ② 在catch中进行解决。（举荐） 先看第一种： let promise = new Promise(function(resolve,reject){ reject();});promise.then(function(){ console.log("resolved");},function(){ console.log("rejected")})输入 rejected应用catch let promise = new Promise(function(resolve,reject){ reject();});promise.then(function(){ console.log("resolved");}).catch(function(){ console.log("catch the reject")})输入 catch the rejectreject的作用就相当于抛出谬误，catch或者then的第二个函数参数进行捕捉，再resolve之后再抛出谬误是没有用的，因为状态一旦产生就无奈扭转。 ...

CityU CS2311 2020/21 Sem B Assignment 2 due on 30 April 20211CS2311 Computer Programming2020/21 Semester BDepartment of Computer ScienceCity University of Hong KongAssignment TwoDue Date: 30 April 2021 (Friday) 23:59All questions should be submitted in Canvas. Note that all solutions will be assessed by (1)correctness, (2) programming styles (including comments), (3) non-redundancy in expressingsolutions, and (4) efficiency, if applicable. In particular, Question 4 will consider the efficiency aspectin marking.This assignment contains 5 questions named as Q1 to Q5. Q5 has 10% bonus.Your solutions are forbidden to INCLUDE any library other than <iostream>, <iomanip>,<cstring>, <fstream>, and/or <cmath>. Each solution using any function/facility in otherlibraries will receive 0 mark. If possible, not using <cstring> in your solution.Solution Submission Instruction:• You only need to submit the content of .cpp files of your solutions for the five questions.• In Canvas, there are 5 submission links, one for each question.o Submit your C++ code for Question 1 to the submission link for Question 1,o Submit your C++ code for Question 2 to the submission link for Question 2,o Submit your C++ code for Question 3 to the submission link for Question 3,o Submit your C++ code for Question 4 to the submission link for Question 4,o Submit your C++ code for Question 5 to the submission link for Question 5.Submission Example.Copy and Paste Your Code developed for Question 1 into “Submission for Q1” and then press[submit assignment]. Repeat the procedure for each question. Remember to submit throughdifferent submission links.CityU CS2311 2020/21 Sem B Assignment 2 due on 30 April 2021Q1. Sum Matrix Game [20%]Sum Matrix is a number placement game.In this game, an n x n matrix is filled with numbers such that (1) the sum of the numbers in each row oreach column is all same, and (2) all the numbers from 1 to n*n should be placed in the matrix. Theprogram should develop the matrix based on the following given rules. ...

DivisionofAppliedScienceandTechnology,CommunityCollegeofCityUniversityAST20201 Web Programming1AST20201 Web ProgrammingGroup ProjectA. ObjectivesBy working on this project, a number of Course Intended Learning Outcomes would beachieved, particularly on the last item. Apply HTML5 and Java Enterprise Technology to e-Business applications; Create interactive Web using JavaServer Pages and an appropriate database server; Manage Java Servlet and Filter concepts on advanced Web application development; Apply appropriate technology to handle Web application security; Evaluate Java-based Content Management Systems for building Web-based EnterpriseResource Planning (ERP) application.B. Overview of Technologies Being Used ...

简介正则表达式是咱们做数据匹配的时候罕用的一种工具，尽管正则表达式的语法并不简单，然而如果多种语法组合起来会给人一种无从下手的感觉。 于是正则表达式成了程序员的噩梦。明天咱们来看一下如何在ES9中玩转正则表达式。 Numbered capture groups咱们晓得正则表达式能够分组，分组是用括号来示意的，如果想要获取到分组的值，那么就叫做capture groups。 通常来说，咱们是通过序号来拜访capture groups的，这叫做Numbered capture groups。 举个例子： const RE_DATE = /([0-9]{4})-([0-9]{2})-([0-9]{2})/;const matchObj = RE_DATE.exec('1999-12-31');const year = matchObj[1]; // 1999const month = matchObj[2]; // 12const day = matchObj[3]; // 31下面的正则表达式要匹配年月日，而后通过exec办法，返回match的数组。这个数组存储的是匹配的groups信息。 因为咱们有三个括号，所以能够匹配三个group。而后通过1，2，3来拜访特定的group。 咱们把下面的matchObj输入看一下其中的内容： [ '1999-12-31', '1999', '12', '31', index: 0, input: '1999-12-31', groups: undefined]能够看到matchObj是一个数组，index 0存储的是要匹配的字符串。这里咱们看到matchObj还有一个groups是undefined，这个groups就是命名groups。 Named capture groups下面讲到了numbered capture groups是通过序列号来拜访到匹配的数据。然而匹配到的group是没有名字的。 咱们看下怎么才可能给这些groups起个名字： const RE_DATE = /(?<year>[0-9]{4})-(?<month>[0-9]{2})-(?<day>[0-9]{2})/;const matchObj = RE_DATE.exec('1999-12-31');const year = matchObj.groups.year; // 1999const month = matchObj.groups.month; // 12const day = matchObj.groups.day; // 31看下matchObj的内容： ...

数据类型ES 数据类型浅析，及与 mysql 类型的映射 DSL 应用DSL 根底查问语法介绍DSL 聚合查问用法

简介ES9是ECMA协会在2018年6月发行的一个版本，因为是ECMAScript的第九个版本，所以也称为ES9. 明天咱们解说一下ES9的新个性。 ES9引入了3大个性和2个小的个性，咱们接下来一一解说。 异步遍历在ES6中，引入了同步iteration的概念，随着ES8中的Async操作符的援用，在ES9中引入了异步遍历的新个性Async iteration。 具体的内容能够参考我之前的文章 [ES9的新个性:异步遍历Async iteration]() Rest/Spread操作符和对象构建Rest和Spread的操作符都是 ... , 只不过应用的场景和目标不一样。 rest次要用在对象的解构，目前只反对对象的解构和不确定的参数形容。 Spread次要用在字面量对象的构建上。 上面咱们别离来介绍： Rest如果用在对象的解构中，除了曾经手动指定的属性名之外，rest将会拷贝对象其余的所有可枚举（enumerable）的属性。 const obj = {foo: 1, bar: 2, baz: 3};const {foo, ...rest} = obj; // Same as: // const foo = 1; // const rest = {bar: 2, baz: 3};如果用在参数中，rest示意的是所有剩下的参数： function func({param1, param2, ...rest}) { // rest operator console.log('All parameters: ', {param1, param2, ...rest}); // spread operator return param1 + param2;}留神，在Obj字面量中，rest运算符只能放在obj的最顶层，并且只能应用一次，还要放在最初。 const {...rest, foo} = obj; // SyntaxErrorconst {foo, ...rest1, ...rest2} = obj; // SyntaxError当然你还能够嵌套应用rest运算符： ...

官网文档给的是this.$refs.tree.setCheckedKeys([]);然而这样会革除所有的选中状态我的需要是通过如下图：通过右边选中，左边显示选中的数据，左边删除，右边勾销选中状态后盾返回数据如下：点击左边删除事件，传以后行的id,而后循环树形控件的整个数据，如果id对应，就勾销选中状态

简介ES8引入了SharedArrayBuffer和Atomics，通过共享内存来晋升workers之间或者worker和主线程之间的消息传递速度。 本文将会具体的解说SharedArrayBuffer和Atomics的理论利用。 Worker和Shared memory在nodejs中，引入了worker_threads模块，能够创立Worker. 而在浏览器端，能够通过web workers来应用Worker(）来创立新的worker。 这里咱们次要关注一下浏览器端web worker的应用。 咱们看一个常见的worker和主线程通信的例子，主线程： var w = new Worker("myworker.js")w.postMessage("hi"); // send "hi" to the workerw.onmessage = function (ev) { console.log(ev.data); // prints "ho"}myworker的代码： onmessage = function (ev) { console.log(ev.data); // prints "hi" postMessage("ho"); // sends "ho" back to the creator}咱们通过postMessage来发送音讯，通过onmessage来监听音讯。 音讯是拷贝之后，通过序列化之后进行传输的。在解析的时候又会进行反序列化，从而升高了音讯传输的效率。 为了解决这个问题，引入了shared memory的概念。 咱们能够通过SharedArrayBuffer来创立Shared memory。 思考下下面的例子，咱们可把音讯用SharedArrayBuffer封装起来，从而达到内存共享的目标。 //发送音讯var sab = new SharedArrayBuffer(1024); // 1KiB shared memoryw.postMessage(sab)//接管音讯var sab;onmessage = function (ev) { sab = ev.data; // 1KiB shared memory, the same memory as in the parent}下面的这个例子中，音讯并没有进行序列化或者转换，都应用的是共享内存。 ...

ES6介绍ES6， 全称 ECMAScript 6.0 ，2015.06 发版。 let 和 const命令let命令let 命令，用来申明变量。它的用法相似于var，区别在于var申明的变量全局无效，let 申明的变量只在它所在的代码块内无效。 应用var申明： var a = [];for (var i = 0; i < 10; i++) { a[i] = function () { console.log(i); };}a[6](); // 10应用闭包解决： var a = [];for (var i = 0; i < 10; i++) { (function(i){ a[i] = function () { console.log(i); }; })(i); }a[6](); // 6应用let： var a = [];for (let i = 0; i < 10; i++) { a[i] = function () { console.log(i); };}a[6](); // 6let 不存在变量晋升，必须先申明后应用，否则报错；var存在变量晋升，未声明前应用输入 undefined。let 存在暂时性死区，在代码块内，应用let命令申明变量之前，该变量都是不可用的。let 不容许反复申明。const 命令const 申明一个只读的常量。一旦申明，常量的值就不能扭转。不能只申明不赋值。 ...

年货节来了，你女朋友下单了吗？ 观看直播曾经成为人们日常上网的习惯之一，直播购物作为其中的重要我的项目，销售额屡翻新高。最近，天猫年货节刚刚揭幕，淘宝直播中就涌入了不少的用户前来抢购，毕竟足不出户就能够买到全国甚至寰球的年货，对热衷买买买的消费者们来说切实太不便了。 那么，直播抢购背地到底蕴藏着哪些技术？平台在开发网络直播零碎时为什么如此看重CDN？在高并发直播的当下，CDN的技术人员都须要关注什么？阿里云Edge Plus的第3期云话题，边缘酱将为你讲讲对于直播抢购与CDN的那些事。 你关怀的，就是云话题接下来进入正题 云话题 | 第3期 对于直播抢购与CDN的那些事特邀专家：卢日 阿里云高级技术专家，GRTN网络总设计和布道师，目前负责阿里云视频直播产品和流媒体实时减速平台研发。 一、互联网直播最要害的技术指标是什么？想必大家都晓得，“直播”曾经是十分广泛的一种娱乐模式了，直播的及时性和互动性成为信息触达、互动沟通的新媒介。随着5G、超高清、VR等技术的倒退，主播与观众的互动须要更加实时，“延时”这个指标愈发的重要。高延时影响了直播互动体验，妨碍了直播在一些场景的落地，特地在电商直播，直播间的评论发问是观众和主播互动的一个重要伎俩，主播的实时互动反馈对直播间的活跃度和交易达成至关重要。 二、直播中的那几秒延时都散布在哪里？咱们分析直播延时的散布，在直播全链路能够分为7个步骤：别离是采集、编码、发送、散发、接管、解码和渲染。其中采集+编码，解码+渲染总体延时比拟固定，共100ms左右，变动比拟大的局部是散发和接管，从数十毫秒到数秒不等，次要取决链路时延抖动、协定栈的优化状况，以及CDN资源的笼罩状况。 所以，互联网上的直播的“延时”，次要是受限于不同地区、简单的网络状况、传输速度等以上的起因。 三、技术人员如何能力在延时上有所突破？为了帮忙直播零碎突破瓶颈，技术人员通常须要深刻以上7个环节中进行优化。比方，编码器须要思考发送时的拥塞状况，来实时调整码率进而缓解拥塞，从而升高延时；再比方传统的流媒体传输中媒体数据发送和底层的传输是互相独立的，底层TCP传输的拥塞控制算法是个通用算法，不会思考媒体的个性，这样的分层构造是很难造成即时反馈系统的，为了保障晦涩度，缓存区的大小设计会绝对激进，从而就义了端到端的时延，如果传输层和应用层是一体化的，QoS管制针对媒体个性来专门设计，同时配合编码侧的码率管制，就能通过组合拳的形式，大大地升高延时。在传统的架构里，这个7个环节互相独立，这样做的益处是团队分工比拟明确，但问题就是优化伎俩很难做到跨界交融，导致无奈做到零碎级优化。 目前，国内常见的直播场景包含1对N广播式直播和N对N互动式直播，其中1对N广播式直播大部分采纳RTMP、HLS或FLV协定，尽管具备集成不便、兼容性较好、反对大规模并发等长处，但延时最低也须要3-6秒；而N对N互动直播个别采纳WebRTC/RTC协定，延时能够管制在800毫秒之内，然而无奈反对大规模并发直播。所以，作为凋谢视频云服务的云计算厂商，阿里云推出了超低延时直播计划RTS（Real-time Streaming）。这个低延时直播计划是通过嵌入直播推流端与播放端SDK，或集成阿里云基于WebRTC的凋谢的自研协定，最终实现端到端毫秒级直播能力。 四、直播零碎开发人员为什么如此看重CDN？很多人会把CDN的存在比喻成网络系统中的“快递小哥”，其实它的工作原理就是在简单的互联网传输链路上，首先确保大量的边缘节点笼罩，复用节点和网络资源，在接入老本、资源笼罩、承载能力上实现了最优均衡；而后，再通过一系列的负载平衡、分布式存储、智能调度、抗弱网优化、缓冲策略、网络申请的重定向和内容治理等技术优化伎俩，为终端申请的内容寻找一条最快、最优的传输门路。 所以，对于直播零碎来说，CDN作为基础设施的资源储备非常重要。尤其是在大型流动期间业务流量突发，弹性、灵便的CDN能够在零碎安稳方面施展关键作用。 五、直播延时，还能进一步升高吗？想要进一步升高直播延时，是流媒体开发人员的独特指标。卢日所率领的团队联结手淘技术、达摩院XG实验室在先后从直播、短延时直播拓展到RTC畛域，并在QoS和AAA方面发力，最终胜利构建了GRTN寰球实时传输网。它的定位是基于核心云和边缘云的异构节点，构建超低延时、全分布式下沉的通信级流媒体传输网络。 目前，GRTN交融了互联网直播和RTC等多种业务场景的音视频流传输和替换。基于GRTN的短延时直播RTS能够反对规范H5 WebRTC推播，在千万级并发状况下延时能够管制在1s以内；RTC端到端延时能够管制在250ms左右。在2020双十一期间，淘宝首次启用了GRTN寰球实时传输网络。数据显示，在启用了GRTN后，直播端到端的延时相较于传统的HTTPFLV/RTMP形式，升高了83%。将来GRTN会在节点资源笼罩和QoS上持续鼎力投入，在超大规模直播场景下将时延进一步压缩20%。 作者：樰篱原文链接本文为阿里云原创内容，未经容许不得转载

简介： 数据库是什么？将来的数据会被存在DNA里？数据库里的数据湖是什么？ 1月16日，扫地僧做了一场直播，请到我的共事——数据库资深专家封神，和来自帝国理工的高级讲师Thomas Heinis（托马斯·海尼斯），2人就数据库这个话题做了比拟深刻的探讨，老僧印象比拟深的是一些前沿的DNA贮存大数据等概念。在此老僧奉上单方谈话的全部内容，因为英国学者应用英文解说，所以对全文进行了中英文的翻译。心愿这个速记能帮忙对前沿科学有趣味的同好。 1月16日，扫地僧做了一场直播，请到我的共事——数据库资深专家封神，和来自帝国理工的高级讲师Thomas Heinis（托马斯·海尼斯），2人就数据库这个话题做了比拟深刻的探讨，老僧印象比拟深的是一些前沿的DNA贮存大数据等概念。在此老僧奉上单方谈话的全部内容，因为英国学者应用英文解说，所以对全文进行了中英文的翻译。心愿这个速记能帮忙对前沿科学有趣味的同好。 主持人：大家好，欢送来到阿里达摩院扫地僧的直播间，我是扫地僧的小助理。明天，咱们的主动驾驶机器人小蛮驴带大家逛了一下阿里云飞天园区，一路没人讲话，不晓得盆友们有没有看急了，那接下来咱们就聊聊天。 Moderator: Hello everyone. Welcome to the live streaming studio of the sweeper monks of Alibaba DAMO Academy. I am the assistant to the sweeper monks. This morning, our autonomous robot Xiaomanlv (Little Competent Donkey) took you guys on a tour in Alibaba Cloud Apsara Park without saying anything. I wonder if you felt anxious or not. Now let’s have a good chat. ...

1、如何暗藏所有指定元素？ const hide = (...el) => [...el].forEach(e => (e.style.display = "none"));// Examplehide(document.querySelectorAll("img")); // 暗藏页面上所有<img />元素2、如何确认元素是否具备指定的类？ const hasClass = (el, className) => el.classList.contains(className); // Example hasClass(document.querySelector("p.special"), "special"); // true3、如何切换元素的类？ const toggleClass = (el, className) => el.classList.toggle(className); // Example toggleClass(document.querySelector( p.special ), special ); // 该段不再有 "special" 类4、如何获取以后页面的滚动地位？ const getScrollPosition = (el = window) => ({ x: el.pageXOffset !== undefined ? el.pageXOffset : el.scrollLeft, y: el.pageYOffset !== undefined ? el.pageYOffset : el.scrollTop }); // Example getScrollPosition(); // {x: 0, y: 200}5、如何评估滚动到页面顶部？ ...

set汇合概念：一个无 反复元素的列表次要利用场景：检测给定值的某个汇合是否存在map汇合概念：汇合内含多组键值对次要利用场景：缓存 频繁取用的数据，获取已存的信息ES5用对象模仿set汇合和map汇合存在以下限度:对象属性必须是字符串对象作为属性名存在问题属性值是假值ES6中set和map1、set创立set汇合 new Set()向汇合中增加数据 set.add()size属性获取汇合元素数量 set.sizeset的个性1、不会对存值强制类型转换2、屡次调用add办法并传入雷同的值作为参数，后续调用将被疏忽3、可用数组初始化Set汇合，会过滤反复值，保障汇合元素惟一留神：Set构造函数可承受所有可迭代的对象作为参数，数组、set汇合、map汇合都是可迭代的 办法has() 检测Set汇合是否存在某个值delete() 移除Set汇合中某一个元素clear() 一处汇合中所有元素forEach办法forEach回调函数接管3个参数 set汇合中下一个索引的地位与第一个参数一样的值被遍历的set汇合自身forEach办法第二个参数与数组一样，须要在回调函数中应用this,可将它作为第二个参数传入forEach办法若应用箭头函数，无需将this作为参数传入回调。 set汇合转为数组数组转set let set = new Set([1,2,3])set 转数组 array = [...set]可利用场景：过滤反复值，最初输入无反复的新数组 2、weakSet3、map4、weakMap

函数的扩大咱们能够从三个方面来理解与意识： 参数的默认值箭头函数对于尾调用的优化参数的默认值在 ES6 之前，咱们不能间接为函数的参数指定默认值，只能采纳变通的办法。而 ES6 中容许咱们间接为函数的参数设置默认值，通过等号 = 间接在小括号中给参数赋值。 示例：function log(name, age = 18) { console.log(name, age);}console.log('xkd'); // 输入: xkdconsole.log('summer', 20); // 输入: summer 20console.log('mark', ''); // 输入: mark如果函数带有某一个参数，则示意这个参数变量曾经默认申明，咱们不能够应用 let 或者 const 再次申明这个变量。 function xkd(a = 1) { let a = 2;}// 报错：SyntaxError: Identifier 'a' has already been declared还须要留神的是，在应用函数默认参数时，不容许有同名参数： function week(a, a, b = 100) { /* ... */}// 报错信息: SyntaxError: Duplicate parameter name not allowed in this context参数默认值是惰性求值： ...

本文同步发表在 Github 集体博客：ES6 系列之 Proxy前言前几天模仿实现了 MobX 的两个函数 —— 手写实现 MobX 的 observable 和 autorun 办法，其中用到了 Proxy，所以打算再对 Proxy 深刻理解一下，做个笔记。 Proxy 是什么Proxy 对象用于创立一个对象的代理，从而实现基本操作的拦挡和自定义（如属性查找、赋值、枚举、函数调用等）。能够了解成，在指标对象之前架设一层“拦挡”，外界对该对象的拜访，都必须先通过这层拦挡，因而提供了一种机制，能够对外界的拜访进行过滤和改写。 const p = new Proxy(target, handler)target: 应用 Proxy 包装的指标对象（能够是任何类型的 JavaScript 对象，包含原生数组，函数，甚至另一个代理）。handler: 一个通常以函数作为属性的对象，用来定制拦挡行为。在反对 Proxy 的浏览器环境中，Proxy 是一个全局对象，能够间接应用。Proxy(target, handler)是一个构造函数，target是被代理的对象，最终返回一个代理对象。 为什么须要 Proxy学习一样货色之前咱们先要想想为什么须要它，在我看来，个别几种状况。 被代理的对象不想间接被拜访管制和批改被代理对象的行为（调用属性、属性赋值、办法调用等等），使之能够进行访问控制和减少性能。APIAPI 概览如下： get(target, propKey, receiver)：拦挡对象属性的读取，比方 proxy.foo 和 proxy['foo'] 。set(target, propKey, value, receiver)：拦挡对象属性的设置，比方 proxy.foo = v 或 proxy['foo'] = v ，返回一个布尔值。has(target, propKey)：拦挡 propKey in proxy 的操作，返回一个布尔值。deleteProperty(target, propKey)：拦挡 delete proxy[propKey]的操作，返回一个布尔值。ownKeys(target)：拦挡 Object.getOwnPropertyNames(proxy) 、 Object.getOwnPropertySymbols(proxy) 、 Object.keys(proxy) 、 for...in 循环，返回一个数组。该办法返回指标对象所有本身的属性的属性名，而 Object.keys() 的返回后果仅包含指标对象本身的可遍历属性。getOwnPropertyDescriptor(target, propKey)：拦挡 Object.getOwnPropertyDescriptor(proxy, propKey) ，返回属性的形容对象。defineProperty(target, propKey, propDesc)：拦挡 Object.defineProperty(proxy, propKey, propDesc） 、Object.defineProperties(proxy, propDescs)，返回一个布尔值。preventExtensions(target)：拦挡 Object.preventExtensions(proxy) ，返回一个布尔值。getPrototypeOf(target)：拦挡 Object.getPrototypeOf(proxy)，返回一个对象 。isExtensible(target)：拦挡 Object.isExtensible(proxy) ，返回一个布尔值。setPrototypeOf(target, proto)：拦挡 Object.setPrototypeOf(proxy, proto) ，返回一个布尔值。如果指标对象是函数，那么还有两种额定操作能够拦挡。apply(target, object, args)：拦挡 Proxy 实例作为函数调用的操作，比方 proxy(...args)、proxy.call(object, ...args)、proxy.apply(...)`。construct(target, args)：拦挡 Proxy 实例作为结构函数调用的操作，比方 new proxy(...args) 。最罕用的办法就是get和set ...

一、先理解下overflow-wrap属性 CSS overflow-wrap属性其实就是以前的word-wrap属性，MDN当初间接把word-wrap的文档页跳转到overflow-wrap属性的文档页了。 因为overflow-wrap属性IE浏览器不反对，而其余古代浏览器仍然反对老的word-wrap属性语法，因而，没有任何理由应用overflow-wrap属性。 直到有一天overflow-wrap属性忽然反对了一个新的属性值anywhere，overflow-wrap属性就有了应用的理由了。 overflow-wrap属性的正式语法如下： overflow-wrap: normal | break-word | anywhere 二、anywhere有什么用在开展技术属性值anywhere的作用之前，先给大家科普一个概念，对于“硬换行”和“软换行”。 硬换行在文本的换行点处插入了理论换行符，而软换行的文本实际上仍在同一行，但看起来它被分成了几行，例如word-break:break-all让长英文单词就属于软换行。 anywhere和break-word的异同在失常状态下，anywhere和break-word的体现是一样的，即如果行中没有其余可承受的断点，则能够在任何点断开本来不可断开的字符串（如长单词或URL），并且在断点处不插入连字符。 用人话解释就是间断的英文字符如果能够不必断就一直，如果切实不行，就断开，因而相比break-all可能会留白。如下图所示： 具体可参见这篇文章：“word-break:break-all和word-wrap:break-word的区别”。 上面讲下不同反对，anywhere和break-word的不同之处在于，在overflow-wrap:anywhere计算最小内容尺寸的时候会思考软换行，而overflow-wrap:break-word不会思考软换行。 例如上面这个例子： <p class="anywhere">I'm zhangxinxu.</p><p class="break-word">I'm zhangxinxu.</p> p { display: inline-block;width: min-content;padding: 10px;border: solid deepskyblue;vertical-align: top;}.anywhere { overflow-wrap: anywhere; }.break-word { overflow-wrap: break-word;} 后果在Chrome浏览器下的成果就像下图这样： 能够看到，利用了overflow-wrap:anywhere申明的元素的最小宽度是把每一个英文单词都破开后的宽度，而利用了overflow-wrap:break-word申明的元素还是依照默认的最小宽度规定进行计算。 有此可见，overflow-wrap:anywhere就像是overflow-wrap:break-word和word-break:break-all申明的混合体，次要用在弹性布局中，即元素尺寸足够的时候单词尽量实现显示，不轻易中断，如果尺寸不够，那就能断则断。 三、兼容性和结语overflow-wrap:anywhere申明目前兼容性还不算乐观，目前（2020年3月）Safari浏览器还不反对，Chrome浏览器也是刚刚反对，具体信息参见表： 的兼容性（数据源自MDN） IE Edge Firefox Chrome Safari iOSSafari AndroidBrowser ✘ ✘ 65+ ✔ 80+ ✔ 13+ ✘ 13.3+ ✘ 80+ ✔ 因而目前还不适宜在理论我的项目中应用，大家理解即可。 而且，惯例的文字排版大家也不会用到这个属性，就算晓得这个属性值，也不会想到应用。 注定是一个日后被人忘记的CSS个性。 就说这么多，带大家简略理解一个新个性。

12月28日音讯，微软曾经确认Windows 10在下一次更新时将主动删除Flash Player，这意味着Flash Player将正式成为历史。 Flash曾是互联网的一段传奇，它对立了互联网的内容创作模式，做到了真正的一次编写，到处运行，让每个人都有可能成为动画师和艺术家。 然而，随着挪动互联时代的到来，Flash也逐步暴露出越来越多的技术短板，耗电、运行速度慢以及安全隐患甚至一度让乔布斯对其彻底失去了信念。2017年7月25日， Adobe官网申明：2020年12月31日，将进行更新和发行Flash Player（EOL），这意味着 Flash Player在这一刻终于成为了历史： 自终止日期之后，Adobe不会持续公布Flash Player更新或安全补丁从2021年1月12日开始禁止Flash内容在Flash Player中运行次要的浏览器供应商也将在EOL日期之后禁止Flash Player运行Flash Player前世：因带宽限度而兴 在2000年前后，互联网曾经开始在国内遍及，受带宽的限度（当年支流拨号是56K的modem，有个128K的ISDN就算是土豪了），网页内容大多以动态形式出现，网速慢到下载一首MP3须要十多分钟甚至二十分钟工夫，看一段清晰度很差的视频得等上20分钟，还必须先装置一个微软的MediaPlayer插件。 为了解决上述问题，Adobe 推出了一种矢量动画的格局，通过占用大量的空间，提供动画的有限放大和保真度，同时能够边下边播，这对低带宽的用户来说几乎就是福音，于是Flash也牵强附会的火了起来，这就是 Flash 倒退的雏形。 因为空间占用小，意味着用户能够更快的关上，互联网页面的出现形式首次以动画成果示人，因为能够有限放大，意味着用户能够看到更加清晰的动画，而不必忍耐GIF为了体积而放大、增色（真彩色缩减为256色）。 Flash的火爆好像就在情理之中，在很短的工夫内便倒退成为了嵌入网页中的小游戏、动画、广告载体以及图形用户界面最罕用的格局。围绕着 Flash 而生的产业链也如雨后春笋般涌现，如以 “2144”、“4399”、“7k7k”等为代表的网页游戏，以优酷网、土豆网等为代表的在线视频门户网站，就连当年的中学计算机课也把制作一个Flash动画作为考试的题目。 大家兴许还记得那些曾用Flash制作的动画短视频作品。 例如“新长征路上的摇滚”  （图片来源于网络） “西南人都是活雷锋”   （图片来源于网络） “大学自习曲（室）”   （图片来源于网络） 以及点歌台的常客，“大话三国”   （图片来源于网络） Flash Player今生：因视频播放而盛 不过互联网的用户带宽不会始终窄着，随着用户带宽的逐渐放宽，视频播放的需要也一劳永逸，从Flash Player 6开始，Macromedia 给Flash退出了反对播放视频的能力，能够在SWF格局的文件中嵌入视频数据，仍然反对流播放。以至于起初赫赫有名的FLV格局，也是从Flash Player 7的文件格式中提取进去的。 FLV的呈现引爆了视频流媒体的整个行业，此时 Flash播放器的装机率曾经超过95%，用Flash做一个几十KB的小播放器，而后用这个小播放器来流式播放FLV视频文件，便能够迅速搭建出一个在线视频点播网站！Youtube、优酷、土豆正是借此先后衰亡。   （图片来源于网络） 在之后，随着社交网络的衰亡，Flash也反对了AS 3，Flash的交互能力也失去了更强的晋升，各种基于Flash的网页游戏相继与用户见面。 例如：开心农场   （图片来源于网络） 挖金子  （图片来源于网络） 那时，好像所有与用户无关的娱乐活动都离不开Flash。 Flash Player将来：因HTML5衰亡而衰  在HTML5中，Flash简直所有的性能都能够实现，而与Flash不同的是，HTML5是一个凋谢的规范，而Flash是属于Adobe公司的。因而，无论是苹果、谷歌，还是微软，都不心愿被一家公司所左右，它们更喜爱一个门户开放的货色。 即使在初期，Flash身上的故障HTML5同样存在，甚至更重大（在比照测试中HTML5的性能更差，能耗更高），然而当微软、苹果、谷歌三大巨头的浏览器都反对HTML5的时候，这个规范事实上就建设起来了，也就意味着发表了Flash的“死刑”。 之后产生的事大家都看到了，各个网站都开始从Flash转向HTML5，Flash也全面走向了边缘化。2014年10月29日,万维网联盟发表,通过8年的艰苦致力,HTML5标准规范终于最终制订实现了,并公开公布。 HTML5封神的那一刻，Flash便注定大势已去。2017年7月26日，Adobe发表打算终结Flash Player插件，并在 2020年年底前进行开发和散发。而其之所以做出这个决定，次要起因在于Flash长久以来被人诟病的性能和平安问题，Flash自公布以来就被曝存在大量重大安全漏洞，即使多次更新也难以彻底解决。 ...

属性的简洁表示法咱们晓得对象是由键值对组成的，在 ES6 中容许在对象的大括号内间接写入变量和函数，此时属性名是变量名，属性值是变量值。 示例：例如咱们定义两个变量 name 和 age，将这两个变量赋值给对象 person ： const name = "xkd";const age = 3;const person = {name: name,age: age}console.log(person);能够简写为： const person = {name, age}; // 简写而后咱们输入 person 对象，输入内容如下所示： { name: 'xkd', age: 3 }办法名简写除了属性，办法也能够简写，例如咱们看上面这段代码： const content = { show:function(){ console.log("你好，侠课岛!"); }};content.show(); // 输入：你好，侠课岛!咱们能够简写成： const content = { show() { console.log("你好，侠课岛!"); }};content.show(); // 输入：你好，侠课岛!这种写法用于函数的返回值，将会十分不便。 function show() { const a = 10; const b = 20; return {a, b};}console.log(show()); // 输入：{ a: 10, b: 20 }属性名表达式ES6 容许用表达式作为属性名，然而要留神肯定要将表达式放在方括号内。 ...

一天，楼主和隔壁小男孩一起坐电梯，中途进来一位高挑的美女，她牵着一条银白的贵宾犬 小男孩看着这条银白的贵宾犬，甚是喜爱，说道：阿姨，我能摸下这个狗狗吗？ 美女：叫姐姐 小男孩抬头看了下贵宾犬，虽说有点不乐意，但还是说道：阿姨，我能摸下这个姐姐吗？ 楼主想忍住，但切实是忍不住了，哈哈哈... 初识 HAVING　对于 SQL 中的 HAVING，置信大家都不生疏，它往往与 GROUP BY 配合应用，为聚合操作指定条件 说到指定条件，咱们最先想到的往往是 WHERE 子句，但 WHERE 子句只能指定行的条件，而不能指定组的条件（这外面有个“阶”的概念，能够查阅：神奇的 SQL 之层级 → 为什么 GROUP BY 之后不能间接援用原表中的列），因而就有了 HAVING 子句，它用来指定组的条件。咱们来看个具体示例就分明了。 咱们有 学生班级表（tbl_student_class） 以及 数据如下 ： DROP TABLE IF EXISTS tbl_student_class; CREATE TABLE tbl_student_class ( id int(8) unsigned NOT NULL AUTO_INCREMENT COMMENT '自增主键', sno varchar(12) NOT NULL COMMENT '学号', cno varchar(5) NOT NULL COMMENT '班级号', cname varchar(50) NOT NULL COMMENT '班级名', PRIMARY KEY (id)) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='学生班级表'; -- ---------------------------- -- Records of tbl_student_class -- ----------------------------INSERT INTO tbl_student_class(sno, cno, cname) VALUES ('20190607001', '0607', '影视7班'); INSERT INTO tbl_student_class(sno, cno, cname) VALUES ('20190607002', '0607', '影视7班'); INSERT INTO tbl_student_class(sno, cno, cname) VALUES ('20190608003', '0608', '影视8班'); INSERT INTO tbl_student_class(sno, cno, cname) VALUES ('20190608004', '0608', '影视8班'); INSERT INTO tbl_student_class(sno, cno, cname) VALUES ('20190609005', '0609', '影视9班'); INSERT INTO tbl_student_class(sno, cno, cname) VALUES ('20190609006', '0609', '影视9班'); INSERT INTO tbl_student_class(sno, cno, cname) VALUES ('20190609007', '0609', '影视9班'); ...

Map需要：依据同学的名字查找对应的问题 思考：数组实现（略） var m = new Map([['小程', 95], ['老赵', 75], ['两开花', 85]]); m.get('两开花'); 或者： var m = new Map(); // 空Map m.set('小鱼', 67); // 增加新的key-value 其余操作： m.has('小鱼'); // 是否存在key '小鱼': true m.get('小鱼'); // 67 m.delete('小鱼'); // 删除key '小鱼' m.size; //汇合元素数量 _@猜一猜@_：如果key值呈现反复？ var m = new Map([['小程', 95], ['小程', 75], ['两开花', 85]]); @想一想@：这样好不好？ 数组解构赋值var [name, age, female] = ['飞哥', 38, true]; if (female) { alert(${age}岁的${name}真汉子); } Set 不能反复，反复的值会被主动过滤掉 ...

ZAO最近火爆，成为景象级产品之一，引起大家的宽泛关注，ATA下面曾经有同学做了一些阐明剖析，链接如下： https://www.atatech.org/articles/148375?spm=ata.13269325.0.0.27ad49fa0Vr2gG 下面文章介绍了ZAO是基于deep fake算法演变进去的一种产品，并提供了deepFake lab的下载地址，计算机硬件的要求等等。本文从更底层的算法角度登程，带大家深刻到算法实质，去了解ZAO到底是如何基于GAN来进行换脸的。 首先，咱们给出一张换脸的整体流程图： 图片起源：Exposing DeepFake Videos By Detecting FaceWarping Artifacts 上图展现了基于deepFake换脸算法的个别流程，首先对于输出图片（a）原图做人脸检测（b），检测出人脸后进行关键点检测（c）。之后（c）通过变换矩阵（d）来实现人脸摆正，之后将摆正后的人脸进入DeepFake（GAN/CycleGAN）来实现人脸替换，之后将替换后的人脸（g）通过变换矩阵的反变换来做关键点对齐，最初替换回原图进行交融最终失去（i）和（h）。 这里咱们给出的是图像上人脸替换的个别流程，那对于短视频而言，就须要先对视频进行截帧，而后逐帧进行人脸替换，在视频帧替换过程中要有人脸识别的网络来保障替换的对象放弃统一性（具体了解就是比方咱们要替换一段视频中小燕子的脸，那就要辨认出检测的人脸是不是小燕子的，不能将紫薇的人脸也替换了），当然因为是视频逐帧的替换，那么在其中为了保障视频随工夫前后帧替换的人脸的天然和连贯性，就须要对前后帧的人脸进行转移平滑操作，从而保障较强的视觉效果。 以上就是图像换脸，视频换脸的通用流程，当然对于ZAO而言，咱们发现它的换脸成果要好于咱们个别的换脸算法，尤其是在头部旋转的（抬头，回头，仰头）下面，成果很是不错，所以咱们有理由置信，ZAO的算法外部应该是应用3D人脸关键点的检测，这样在替换的过程中就会换的更为天然。 好的，当初咱们理解了流程，上面咱们更加细节的介绍下面说的DeepFake（GAN/CycleGAN）的算法工作原理。为了简化大家对于GAN/CycleGAN的了解，咱们同样以图的形式展示： 首先，上图示意了最简略的人脸替换网络，对于输入人脸（右边），通过神经网络编码失去中间状态（往往是一个向量或者很小的图像），之后再进入解码器还原失去重建的人脸（左边）。咱们留神，两头的编码态相当于保留的人脸的全副信息。在上图咱们并没有做人脸替换的相干操作，即A脸编码后解码的还是A脸，B脸编码后解码的还是B脸。 上面，如果咱们将B脸编码的向量用A脸的解码去解，会产生什么呢？是的，B的脸会呈现在本来A的脸的地位，但面部的表情和一些细节会保留A的。这样就实现了换脸。 从上图还有一点须要留神，因为编码的可替换要求，咱们必须让所有脸的编码器放弃一致性，也就是所有替换前的人脸用对立的编码器去编码（上图对立的红色编码器），但对于每个不同的人脸要实用不同的解码器去解码（上图不同的蓝色和绿色解码器），这样能力实现换脸。 然而如果仅仅应用下面的算法构造，生成的人脸会比拟假，能够看出相当显著的人为替换痕迹，而为了让替换产生的更为实在，CycleGan应运而生，还是简略的一张图去了解CycleGan的算法实质： 咱们能够看出，说到底，CycleGan不过在换脸后生成的假脸和真脸的之间多减少了一个损失来减小两者的差距，同时让相较于之前的A-->B, CycleGan还同时实现了B-->A的生成和缩小差距，而这整个过程出现了一个闭环，故而名为Cycle。 CycleGan的循环训练能够显著的放大间接将B脸用A解码器解码所产生的不真实性。 当然，在实在场景中，在实现换脸后可能还须要一些后处理来保障后果更加平滑天然，比方在换脸边缘做一些含糊解决，在人脸区域做一些和原脸的格调迁徙等等。而这些就是实现技术代差的关键技术了，咱们明天只是浅析一下ZAO的算法，更深刻的一些产品算法设计细节咱们这里不做更深的探讨了。 最初面对ZAO，尽管他有着霸王条款，单但从技术角度看，我认为ZAO的确做的很好，技术上值得咱们学习，但换脸自身是否合乎道德，到底是不是一件有意义有价值的事件，还须要工夫给出咱们最终的答案。 感谢您浏览，心愿对您有所帮忙。 --溪鹤 原文链接本文为阿里云原创内容，未经容许不得转载。

关注微信公众号「松宝写代码」，精选好文，每日面试题 退出咱们一起学习，day day up 作者：saucxs ｜ songEagle起源：原创 一、前言2020.12.23日刚立的flag，每日一题，题目类型不限度。 点击上面图片，查看第1道「一道面试题是如何引发深层次的灵魂拷问？」 或者集体站点链接： 一道面试题是如何引发深层次的灵魂拷问 接下来是第2道：ES6中为什么要应用Symbol？ 二、ES6中为什么要应用Symbol？1、简述ES6中Symbol的概念ES6中曾经有6种数据类型： UndefinedNull布尔值字符串数值对象然而在ES6种新退出一种新的数据类型Symbol。 Symbol示意举世无双的值。 // 没有参数的状况var s1 = Symbol();var s2 = Symbol();s1 === s2 // false// 有参数的状况var s1 = Symbol('saucxs');var s2 = Symbol('saucxs');s1 === s2 // false 须要阐明一下：这里的字符'saucxs'是该Symbol的一个形容，然而并非两个参数都是'saucxs'。 2、简述Symbol的个性个性1：Symbol 值通过 Symbol 函数生成，应用 typeof，后果为 "symbol"var a = Symbol();console.log(typeof a); // "symbol"个性2：Symbol 函数前不能应用 new 命令，否则会报错。这是因为生成的 Symbol 是一个原始类型的值，不是对象。个性3：instanceof 的后果为 falsevar a = Symbol('foo');console.log(a instanceof Symbol); // false个性4：Symbol 函数能够承受一个字符串作为参数，示意对 Symbol 实例的形容，次要是为了在控制台显示，或者转为字符串时，比拟容易辨别。var a = Symbol('saucxs');console.log(a); // Symbol(saucxs)个性5：如果 Symbol 的参数是一个对象，就会调用该对象的 toString 办法，将其转为字符串，而后才生成一个 Symbol 值。const obj = { toString() { return 'abc'; }};const a = Symbol(obj); // Symbol(abc)个性6：如果 Symbol 的参数是一个对象，就会调用该对象的 toString 办法，将其转为字符串，而后才生成一个 Symbol 值。// 没有参数的状况var s1 = Symbol();var s2 = Symbol();s1 === s2 // false// 有参数的状况var s1 = Symbol('saucxs');var s2 = Symbol('saucxs');s1 === s2 // false个性7：Symbol 值不能与其余类型的值进行运算，会报错。var a = Symbol('saucxs');console.log(`I am ${a}`); // TypeError: can't convert symbol to string个性8：Symbol 值能够显式转为字符串。const f = Symbol('saucxs')f.toString() // "Symbol(saucxs)"String(f) // "Symbol(saucxs)"个性9：Symbol 值能够作为标识符，用于对象的属性名，能够保障不会呈现同名的属性。var mySymbol = Symbol();// 第一种写法var a = {};a[mySymbol] = 'Hello!';// 第二种写法var a = { [mySymbol]: 'Hello!'};// 第三种写法var a = {};Object.defineProperty(a, mySymbol, { value: 'Hello!' });// 以上写法都失去同样后果console.log(a[mySymbol]); // "Hello!"个性10：Symbol 作为属性名，该属性不会呈现在 for...in、for...of 循环中，也不会被 Object.keys()、Object.getOwnPropertyNames()、JSON.stringify() 返回。然而，它也不是公有属性，有一个 Object.getOwnPropertySymbols 办法，能够获取指定对象的所有 Symbol 属性名。var obj = {};var a = Symbol('a');var b = Symbol('b');obj[a] = 'Hello';obj[b] = 'World';var objectSymbols = Object.getOwnPropertySymbols(obj);console.log(objectSymbols);// [Symbol(a), Symbol(b)]个性11：应用同一个 Symbol 值，能够应用 Symbol.for。它承受一个字符串作为参数，而后搜寻有没有以该参数作为名称的 Symbol 值。如果有，就返回这个 Symbol 值，否则就新建并返回一个以该字符串为名称的 Symbol 值。var s1 = Symbol.for('saucxs');var s2 = Symbol.for('saucxs');console.log(s1 === s2); // true个性12： Symbol.keyFor 办法返回一个已登记的 Symbol 类型值的 key。var s1 = Symbol.for("saucxs");console.log(Symbol.keyFor(s1)); // "saucxs"var s2 = Symbol("saucxs");console.log(Symbol.keyFor(s2) ); // undefined3、为什么要应用Symbol？比方有这样一种场景，咱们想辨别两个属性，其实咱们并不在意，这两个属性值到底是什么，咱们在意的是，这两个属性相对要辨别开来！例如: ...

本节咱们来学习 ES6 中字符串类型的扩大，包含一些字符串对象的新增办法的应用等。 字符的 Unicode 表示法ES6 增强了对 Unicode 的反对，JavaScript 中能够采纳 \\uxxx 模式示意一个字符，其中 xxxx 示意字符的码点。例如： console.log("\u0075"); // u然而这种表示法只限于码点在 \\u0000~\\uFFFF 之间的字符。超出这个范畴的字符，必须用两个双字节的模式示意。 console.log("\uD842\uDFB7"); // ????console.log("\u20BB8"); // 8这示意，如果间接在 \\u 前面跟上超过 0xFFFF 的数值，例如 \\u20BB8，JavaScript 会了解成 \\u20BB+8。因为 \\u20BB 是一个不可打印字符，所以只会显示一个空格，前面跟着一个 8。 ES6 对这一点做出了改良，只有将码点放入大括号，就能正确解读该字符。 console.log("\u{20BB7}"); // ????console.log("\u{41}\u{42}\u{43}"); // ABClet hello = 123;console.log(hell\u{6F}); // 123console.log('\u{1F680}' === '\uD83D\uDE80'); // true下面代码中，最初一个例子表明，大括号表示法与四字节的 UTF-16 编码是等价的。 有了这种表示法之后，JavaScript共有6种办法能够示意一个字符。 '\z' === 'z' // true'\172' === 'z' // true'\x7A' === 'z' // true'\u007A' === 'z' // true'\u{7A}' === 'z' // true遍历器接口ES6 为字符串增加了遍历器接口，使得字符串能够被 for...of 循环遍历。 ...

在 ES2018 中，函数曾经是一个很简单的体系了，整顿如下。 第一种，一般函数：用 function 关键字定义的函数。第二种，箭头函数：用 => 运算符定义的函数。第三种，办法：在 class 中定义的函数。第四种，生成器函数：用 function * 定义的函数。第五种，类：用 class 定义的类，实际上也是函数。第六 / 七 / 八种，异步函数：一般函数、箭头函数和生成器函数加上 async 关键字。key1: this 是执行上下文中很重要的一个组成部分。同一个函数调用形式不同，失去的 this 值也不同. 调用函数时应用的援用，决定了函数执行时刻的 this 值。一般函数的 this 值由“调用它所应用的援用”决定，其中神秘就在于：咱们获取函数的表达式，它实际上返回的并非函数自身，而是一个 Reference 类型（记得咱们在类型一章讲过七种规范类型吗，正是其中之一）。Reference 类型由两局部组成：一个对象和一个属性值。不难理解 o.showThis 产生的 Reference 类型，即由对象 o 和属性“showThis”形成。 key2: 箭头函数和异步箭头函数，无论用什么援用来调用它，都不影响他的this值。因为，箭头函数没有 prototype (原型)，所以箭头函数自身没有this.箭头函数没有本人的this，箭头函数的this指向在定义（留神：是定义时，不是调用时）的时候继承自外层第一个一般函数的this key3: call/apply/bind 无奈扭转箭头函数的this指向，但能够传参 key4: 箭头函数不绑定arguments，取而代之用rest参数...代替arguments对象，来拜访箭头函数的参数列表 key5: new 的执行过程，咱们再来看一下：以结构器的 prototype 属性（留神与公有字段[[prototype]]的辨别）为原型，创立新对象；将 this 和调用参数传给结构器，执行；如果结构器返回的是对象，则返回，否则返回第一步创立的对象。

2020年双11，云原生实时数仓首次在阿里巴巴双11外围数据场景落地，实现商业全链路实时化，毫秒级海量数据处理能力。搜寻举荐业务数据开发效率晋升4倍，菜鸟物流包裹数据链路从小时级优化到3分钟，考拉分钟及小时业务1分钟内实现，实时数据仓库的建设在瞬息万变的市场竞争中成为了标品！DataWorks独享数据集成资源组（反对实时同步）首月5折>> 实时同步-实时数仓第一步实时数仓的建设，第一步就须要将数据同步到大数据计算引擎，个别客户的RDS/MySQL业务数据库在理论生产中都是实时不停的进行着数据变动，如何及时将这些数据同步到数据仓库中是一个难题，同时实际上，只有极少数客户的RDS业务数据库是全新建设的，对接数据仓库时只须要进行实时同步。他们大多数都有历史既有的数据，只有在这些数据上云之后的实时数据变更才有业务意义。 传统实时同步形式的艰难点传统的实现形式是客户先手工建设离线全量数据同步工作，并进行实现历史全量数据的搬迁。尔后再进行手工建设实时同步工作。然而个别客户都是有十分多的数据库，每个库中有十分多的表，对这些表一一建设离线和实时同步工作，是一个很繁琐和容易出错脱漏的过程。同时实时同步工作启动的机会也难以把握，尤其是对于没有关键字段做主键去重时，提前启动容易造成数据反复，滞后启动容易造成数据脱漏。 DataWorks数据集成实时同步高效解决方案DataWorks数据集成提供了 “RDS/MySQL一键实时同步至MaxCompute” 的解决方案，能够将RDS/MySQL中的数据库，通过一次性的简略配置，全增量一体化同步到MaxCompute中，主动实现先全量数据迁徙，而后实时增量放弃更新。并反对对于实时同步到MaxCompute的数据，依照指定分区主动建设和Base表的merge工作并执行。整套流程齐全自动化，无需人工干预，用户只需关注最终的业务后果表即可。 实时同步性能与性价比DataWorks数据集成采纳自研高性能引擎，在雷同的机器规格状况下，RDS实时同步性能最高为 其余数据同步计划的2倍 ，而 价格只有其4分之1 。以一台24核48G内存的机器举例，DataWorks数据集成RDS实时同步最大QPS为3.5万，比其余数据同步计划 QPS高1倍 ，能够运行18条实时同步链路，而这个规格的机器，每月仅需3000元（以杭州的为例）。详见： 《独享数据集成资源组性能和计费规范》 实时同步性能劣势针对RDS/MySQL能够整库全副表或者局部表、批量的大规模导入MaxCompute与Hologres历史存量数据自动化全量导入，目标MaxCompute、Hologres表能够主动建设，也能够应用已有，反对精细化配置。实时最新数据在全量同步后主动启动导入，保证数据既不反复也不失落。白屏化简略配置整个计划，轻松几步向导即可实现。反对整个计划级别的运维管控，更高level来操盘，防止繁琐的底层运维。原文链接本文为阿里云原创内容，未经容许不得转载。

（一）let和const1.letlet 定义变量，变量不能够再次定义，但能够扭转其值代码举栗： let name = 'zhangsan';name = 'lisi';console.log(name); // lisilet name = 'wangwu'; // 再次定义，报错：Identifier 'name' has already been declared 具备块级作用域。（即大括号）代码举栗： { let age = 18; console.log(age); // 18}console.log(age); // 报错，此作用域中没有age的定义for (let i = 0; i < 10; i++) { // i 只能在此范畴内应用，因为有块级作用域}console.log(i); // 报错，此作用域中没有i的定义 没有变量晋升，必须先定义再应用代码举栗： console.log(gender); // 报错，此时还没有定义genderlet gender = '男'; let申明的变量不会压到window对象中，是独立的代码举栗： let hobby = '吃饭';console.log(window.hobby); // undefined 如果应用var申明了变量，也不能再次用let申明了，反之也是不行的。起因也是这个变量曾经被申明过了。 2.const应用const关键字定义常量常量是不可变的，一旦定义，则不能批改其值代码举栗： // 1. 应用const关键字定义常量，常量名个别大写// 2. 常量是不可变的，一旦定义，则不能批改其值const PI = 3.1415926；PI = 3.14; // 报错，罕用一旦被初始化，则不能被批改 初始化常量时，必须给初始值代码举栗： ...