技术栈知识点巩固——Js

Js 特点

弱类型语言：变量没有固定的数据类型。var a=0;a="hellow world!"
解释性语言：不同与c、java等语言需要先编译，有浏览器动态的解析与执行。
Js是面向对象的语言。
单线程：Js是单线程的。
跨平台：Js只依赖浏览器本身，实现跨平台。
垃圾自动回收：Js不需要主动回收内存，JS引擎自动垃圾回收。

Js 阻止默认事件

使用原生js元素 onclick方法中返回 false
或者addEventListener添加点击的监听，在方法体中是调用e.preventDefault();

<!DOCTYPE html>
<html><body><a href="https://www.baidu.com">百度</a><form action="https://www.baidu.com"><input type="submit" value="提交" name="sub" id="submit"></form><script>let a = document.querySelector('a')let input = document.getElementById('submit')a.onclick = function (e) {return true}input.addEventListener('click', function (e) {e.preventDefault();})</script></body>
</html>

Js 基本类型

数据类型	说明
`null`	空值，表示非对象
`undefined`	未定义的值，表示未赋值的初始化值
`number`	数字，数学运算的值
`string`	字符串，表示信息流
`boolean`	布尔值，逻辑运算的值
`object`	对象，表示复合结构的数据集

位运算

运算符	描述	运算规则
`&`	与	两个位都为1时，结果才为1
`	`	`
`^`	异或	两个位相同为0，相异为1
`~`	取反	0变1，1变0
`<<`	左移	各二进制位全部左移若干位，高位丢弃，低位补0
`>>`	右移	各二进制位全部右移若干位，正数左补0，负数左补1，右边丢弃

typeof与instanceof

typeof主要用来判断基础数据类型，instanceof则是用来判断引用数据类型。
typeof是根据数据在存储单元中的类型标签来判断数据的类型，instanceof则是根据函数的prototype属性值是否存在于对象的原型链上来判断数据的类型。
typeof判断数据类型共有8个值，它们分别是undefined、number、boolean、string、symbol、bigint、object和function

console.log(typeof 2);               // number
console.log(typeof true);            // boolean
console.log(typeof 'str');           // string
console.log(typeof []);              // object
console.log(typeof function(){});    // function
console.log(typeof {});              // object
console.log(typeof undefined);       // undefined
console.log(typeof null);            // objectconsole.log(2 instanceof Number);                    // false
console.log(true instanceof Boolean);                // false
console.log('str' instanceof String);                // false console.log([] instanceof Array);                    // true
console.log(function(){} instanceof Function);       // true
console.log({} instanceof Object);                   // true

Js 数组常用方法

push()：数组的末尾追加改变原有数组
unshift()：向数组的开头添加改变原有数组
splice()：向数组的指定index处插入返回的是被删除掉的元素的集合，会改变原有数组
pop()：从尾部删除一个元素改变原有数组
shift()：从头部删除一个元素改变原有数组
splice()：在index处删除多个个元素会改变原有数组
reverse()：反转，倒置改变原有数组
sort()：按指定规则排序改变原有数组

constructor(构造函数)

当一个函数被定义时，JS引擎会为函数添加prototype属性，然后在prototype属性上添加一个constructor属性，并让其指向该函数。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3FeRkqgs-1652746420784)(images/image-20220427201926235.png)]

当执行 let a = new method()时，method被当成了构造函数，a是method的实例对象，此时method原型上的constructor属性传递到了a上，所以a.constructor===method

Js 数据类型转换

转换为数字：Number()、parseInt()、parseFloat()
转换为字符串：.toString()、String()
转换为布尔值：Bollean()

new 操作符的执行过程

创建一个新的对象
设置原型，将对象的原型设置为函数的prototype对象
让函数的 this指向对象，执行构造函数的代码
判断函数的返回值类型，如果是值类型，返回创建的对象。如果是引用类型，返回引用类型的对象。

<script type="text/javascript">function Animal(name, age) {this.name = name;this.age = age;
}
function objectFactory() {let object = null;let constructor = Array.prototype.shift.call(arguments);let result = null;// 判断参数是否是一个函数if (typeof constructor != "function") {console.error("类型错误");return;}//  新建一个空对象，对象的原型为构造函数的 proptype 对象object = Object.create(constructor.prototype);// 将 this 指向新建对象，并执行函数result = constructor.apply(object, arguments);// 判断返回对象let flag =result &&(typeof result === "object" || typeof result === "function");// 判断返回结果return flag ? result : object;
}
const animal = objectFactory(Animal, "Ketty", 20);
console.log(animal);
</script>

let、var、const

用var声明的变量既是全局变量，也是顶层变量，使用var，我们能够对一个变量进行多次声明，后面声明的变量会覆盖前面的变量声明。
在函数中使用使用var声明变量时候，该变量是局部的。
let是ES6新增的命令，用来声明变量用法类似于var，但是所声明的变量，只在let命令所在的代码块内有效。不存在变量提升。
const声明一个只读的常量，一旦声明，常量的值就不能改变。

Promise

作用

主要用于异步计算
可以将异步操作队列化，按照期望的顺序执行，返回符合预期的结果
可以在对象之间传递和操作promise，帮助我们处理队列

Promise

promise是一个对象，对象和函数的区别就是对象可以保存状态，函数不可以（闭包除外）
并未剥夺函数return的能力，因此无需层层传递callback，进行回调获取数据
代码风格，容易理解，便于维护
多个异步等待合并便于解决

Promise 状态

pending[待定]初始状态
fulfilled[实现]操作成功
rejected[被否决]操作失败
当promise状态发生改变，就会触发then()里的响应函数处理后续步骤；
从pending变为fulfilled，从pending变为rejected。这两种情况只要发生，状态就凝固了，不会再变了。

示例代码1

<body><button type="button" onclick="method1()">测试方法1</button><script type="text/javascript">function method1(){new Promise(function (resolve, reject) {// 一段耗时的异步操作resolve('成功') // 数据处理完成// reject('失败') // 数据处理出错}).then((res) => {console.log(res)},  // 成功(err) => {console.log(err)} // 失败)}</script>
</body>

resolve：将Promise对象的状态从“未完成”变为“成功”（即从 pending 变为 resolved），在异步操作成功时调用，并将异步操作的结果，作为参数传递出去；
reject作用是，将Promise对象的状态从“未完成”变为“失败”（即从 pending 变为 rejected），在异步操作失败时调用，并将异步操作报出的错误，作为参数传递出去。

箭头函数

ES6 中引入了箭头函数。箭头函数允许我们编写更短的函数

// 原始写法
method1 = function (){alert("hellow world!")
}// Es6 箭头函数
method1 = ()=> alert("箭头函数写法！")

对this指向的影响

使用箭头函数没有对 this 的绑定。在常规函数中，关键字 this 表示调用该函数的对象，可以是窗口、文档、按钮或其他任何东西。
箭头函数可以访问this对象，但这个this对象指向在定义箭头函数时它时所处的对象(宿主对象),而不是运行时的对象。

 var name = 'lisi';
let obj = {name: 'zhangsan',f1 : () => {debuggerconsole.log(this); // window对象console.log(this.name); // lisi},f2 : function(){console.log(this); // objconsole.log(this.name); // zhangsan},f2 : function(){console.log(this); // objconsole.log(this.name); // zhangsan}
};
obj.f1();

Js 闭包

一个函数和对其周围状态（词法环境）的引用捆绑在一起（或者说函数被引用包围），这样的组合就是闭包。
闭包可以在一个内层函数中访问到其外层函数的作用域。
在 JavaScript 中，每当创建一个函数，闭包就会在函数创建的同时被创建出来。

词法作用域

method2创建的局部变量name，display函数也可以访问
display() 没有自己的局部变量。然而，因为它可以访问到外部函数的变量，所以 display() 可以使用父函数 method2() 中声明的变量 name 。

 method2 = function(){let name = "张三"// display 是内部函数，一个闭包display = function(){alert(name )}display();}

JavaScript中的函数会形成了闭包。闭包是由函数以及声明该函数的词法环境组合而成的。该环境包含了这个闭包创建时作用域内的任何局部变量.。
下面的示例代码中，内部函数 displayName() 在执行前，从外部函数返回。

function makeFunc() {var name = "Mozilla";function displayName() {alert(name);}return displayName;
}var myFunc = makeFunc();
myFunc();

使用场景

创建私有变量
延长变量的生命周期

优点

保护函数内变量的安全，实现封装，防止变量流入其他环境发生命名冲突，造成环境污染。
在适当的时候，可以在内存中维护变量并缓存，提高执行效率。

缺点

消耗内存：通常来说，函数的活动对象会随着执行上下文环境一起被销毁，但是，由于闭包引用的是外部函数的活动对象，因此这个活动对象无法被销毁，这意味着，闭包比一般的函数需要消耗更多的内存。
泄漏内存：在 IE9 之前，如果闭包的作用域链中存在 DOM 对象，则意味着该 DOM 对象无法被销毁，造成内存泄漏。

Js 变量提升

下面的代码输出结果为 2，JavaScript不是自上而下执行的语言

a = 2;
var a;
console.log(a);

上面的代码会变量提升

var a;
a = 2;
console.log(a);

js会将变量的声明提升到js顶部执行，对于var a = 2这种语句，会拆分开，将var a这步进行提升。
变量提升的本质其实是js引擎在编译的时候，就将所有的变量声明了，因此在执行的时候，所有的变量都已经完成声明。
当有多个同名变量的时候，函数声明会覆盖其他的声明。如果有多个函数声明，则由最后一个函数声明覆盖之前的所有声明。

Proxy

Proxy代理是一个共通的概念，可以起到拦截的作用。ES6里将Proxy标准化了，提供了Proxy构造函数，用来生成Proxy实例。

var myHandler = {get: function (target, name) {return name in target ? target[name] : "没有这个属性";},
};
//    proxy 测试
method4 = function () {var p = new Proxy({}, myHandler);p.a = 1;p.b = 2;console.log(p.a); // 1console.log(p.b); // 2console.log(p.c); // 没有这个属性
};

语法

 let p = new Proxy(target, handler);

target ：需要使用Proxy包装的目标对象（可以是任何类型的对象，包括原生数组，函数，甚至另一个代理）。
handler: 一个对象，其属性是当执行一个操作时定义代理的行为的函数(可以理解为某种触发器)。

Js 原型链

js以原型链的形式，保证函数或对象中的方法、属性可以让向下传递，按照面向对象的说法，这就是继承。而js通过原型链才得以实现函数或对象的继承。
JS的每个函数在创建的时候，都会生成一个属性prototype，这个属性指向一个对象，这个对象就是此函数的原型对象。该原型对象中有个属性为constructor，指向该函数。

// 构造函数
function Preson(name, age) {this.name = name;this.age = age;
}
// 所有实例共享的公共方法
Preson.prototype.say = function (word) {console.log(`${this.name}说：${word}`);
}const p1 = new Preson('张三', 18); // 创建一个Person实例对象
p1.hasOwnProperty('say') // false 说明不是定义在其本身上的
p1.say('hello world'); // 调用公共方法 打印：张三说：hello world

Proto和Prototype

prototype指向函数的原型对象，这是一个显式原型属性，只有函数才拥有该属性。
每个对象都有_proto_，它是隐式原型属性，指向了创建该对象的构造函数原型。由于js中是没有类的概念，而为了实现继承，通过 _proto_ 将对象和原型联系起来组成原型链，就可以让对象访问到不属于自己的属性。

Js 内存泄漏

全局变量

在非严格模式下当引用未声明的变量时，会在全局对象中创建一个新变量。在浏览器中，全局对象将是window
全局变量是根据定义无法被垃圾回收机制收集.需要特别注意用于临时存储和处理大量信息的全局变量。如果必须使用全局变量来存储数据，请确保将其指定为null或在完成后重新分配它。

function foo(arg) {bar = "this is a hidden global variable";
}
function foo() {this.variable = "potential accidental global";
}
// foo 调用自己，this 指向了全局对象（window）
foo();

垃圾回收机制

Javascript 具有自动垃圾回收机制（GC：Garbage Collecation），也就是说，执行环境会负责管理代码执行过程中使用的内存
原理：垃圾收集器会定期（周期性）找出那些不在继续使用的变量，然后释放其内存

标记清除

代码示例

var m = 0,n = 19 // 把 m,n,add() 标记为进入环境。
add(m, n) // 把 a, b, c标记为进入环境。
console.log(n) // a,b,c标记为离开环境，等待垃圾回收。
function add(a, b) {a++var c = a + breturn c
}

引用计数

代码示例

const arr = [1, 2, 3, 4];
console.log('hello world');

数组[1, 2, 3, 4]是一个值，会占用内存。变量arr是仅有的对这个值的引用，因此引用次数为1。尽管后面的代码没有用到arr，它还是会持续占用内存

防抖节流

防抖

在事件被触发n秒后再执行回调函数，如果在这n秒内又被触发，则重新计时。
维护一个计时器，规定在delay时间后触发函数，但是在delay时间内再次触发的话，都会清除当前的 timer 然后重新设置超时调用，即重新计时。这样一来，只有最后一次操作能被触发。

antiShake = function (func, wait, immediate) {let timeout;return function () {// 取消 setTimeout 的定时操作clearTimeout(timeout);if (immediate) {// 立即执行let callNow = !timeout;timeout = setTimeout(function () {timeout = null;}, wait);if (callNow) {func();}} else {timeout = setTimeout(func(), wait);}}
}
method1 = antiShake(function () {console.log('点击事件')
}, 5000, true);

节流

规定一个单位时间，在这个单位时间内，只能有一次触发事件的回调函数执行，如果在同一个单位时间内某事件被触发多次，只有一次能生效。
节流是通过判断是否到达一定时间来触发函数，若没到规定时间则使用计时器延后，而下一次事件则会重新设定计时器。

// 节流
throtter = function (cd, time = 3000) {var t = nullreturn function () {if (t) returnt = setTimeout(function () {cd.call(this)t = null}, time);}
}
method2 = throtter(function () {console.log('节流')
})

this 指向

this的指向和函数在哪里定义无关，和如何调用有关
在方法中，this 表示该方法所属的对象。
如果单独使用，this 表示全局对象。
在函数中，this 表示全局对象。
在函数中，在严格模式下，this 是未定义的(undefined)。
在事件中，this 表示接收事件的元素。
类似 call() 和 apply() 方法可以将 this 引用到任何对象。

JS 深浅拷贝

浅拷贝

原来的变量和新的变量指向同一个东西，彼此之间的操作会互相影响

深拷贝

如果是在堆中重新分配内存，拥有不同的地址，但是值是一样的，复制后的对象与原来的对象是完全隔离，互不影响，为深拷贝。
JOSN 对象中的 stringify 可以把一个 js 对象序列化为一个 JSON 字符串，parse 可以把 JSON 字符串反序列化为一个 js 对象，这两个方法实现的是深拷贝。

const cloneObj = JSON.parse(JSON.stringify(obj))

函数柯里化

就是将多变量函数拆解为单变量（或部分变量）的多个函数并依次调用。利用闭包，可以形成一个不销毁的私有作用域，把预先处理的内容都存在这个不销毁的作用域里面，并且返回一个函数，以后要执行的就是这个函数。

 // 获取 url
function url(param1){return function(param2,param3){return `${param1}${param2}${param3}`}
}
let myurl = url('test1');
let myurl1 = myurl('test2','test3')
let myurl2 = myurl('test4')

Ajax 请求

当程序执行到 Ajax 代码时，将 Ajax 代码交给另外一个线程来执行，不论执行结果如何，当前线程会继续向下执行。

工作原理

JavaScript 需要使用浏览器内置的 XMLHttpRequest 对象向服务器发送 HTTP 请求，并接收服务器响应的数据。

发送Ajax请求

原生的 Ajax请求

<!DOCTYPE html>
<html><body><div id="result"></div><button type="button" onclick="displayFullName()">点击发送请求</button><script type="text/javascript">displayFullName = function() {var request = new XMLHttpRequest();request.open('post', 'http://127.0.0.1:8000/test');// 监听 readyState 的变化request.onreadystatechange = function() {// 检查请求是否成功debuggerif(this.readyState === 4 && this.status === 200) {// 将来自服务器的响应插入当前页面document.getElementById("result").innerHTML = this.responseText;}else {document.getElementById("result").innerHTML = '请求失败';}};request.send()}</script></body>
</html>

Jquery提供的Ajax

displayFullName2 = function() {$.ajax({url: 'http://127.0.0.1:8000/test',type: 'post',dataType:'',data:{param1:'test1',param2:'test2'},success:function(){alert('成功')},error: function () {alert('失败')}})
}

参数说明

method：请求的类型（使用的 HTTP 方法），例如 GET、POST、PUT、HEAD、DELETE 等
url：请求的地址
async：可选参数，布尔类型，表示是否请求是否异步执行，默认值为 true
user：可选参数，表示用户名，主要用来认证，默认值为 null
password：可选参数，表示密码，同样用来认证，默认值为 null

Call、Apply、Bind

call、apply、bind作用是改变函数执行时的上下文，简而言之就是改变函数运行时的this指向

示例代码

var name = "lucy";
var obj = {name: "martin",say: function () {console.log(this.name);}
};
obj.say(); // martin，this 指向 obj 对象
setTimeout(obj.say,0); // lucy，this 指向 window 对象// 使用 bind 改变 this 指向
setTimeout(obj.say.bind(obj),0); //martin，this指向obj对象

区别

三者都可以改变函数的this对象指向。
三者第一个参数都是this要指向的对象，如果如果没有这个参数或参数为undefined或null，则默认指向全局window。
三者都可以传参，但是apply是数组，而call是参数列表，且apply和call是一次性传入参数，而bind可以分为多次传入。
bind 是返回绑定this之后的函数，便于稍后调用；apply 、call 则是立即执行。

Apply

fn.apply(obj,[1,2]); // this会变成传入的obj，传入的参数必须是一个数组；
fn(1,2) // this指向window

Call

fn.call(null,[1,2]); // this指向window
fn.call(undefined,[1,2]); // this指向window

Bind

bind方法和call很相似，第一参数也是this的指向，后面传入的也是一个参数列表(但是这个参数列表可以分多次传入)

改变this指向后不会立即执行，而是返回一个永久改变this指向的函数

Map、Set

var m = new Map(); // 空Map
m.set('Adam', 67); // 添加新的key-value
m.set('Bob', 59);
m.has('Adam'); // 是否存在key 'Adam': true
m.get('Adam'); // 67
m.delete('Adam'); // 删除key 'Adam'
m.get('Adam'); // undefinedvar s1 = new Set(); // 空Set
var s2 = new Set([1, 2, 3]); // 含1, 2, 3

foreach

var a = ['A', 'B', 'C'];
a.forEach(function (element, index, array) {// element: 指向当前元素的值// index: 指向当前索引// array: 指向Array对象本身alert(element);
});

== 和 === 区别

除了在比较对象属性为null或者undefined的情况下，我们可以使用相等操作符==，其他情况建议一律使用全等操作符===

等于操作符

两个都为简单类型，字符串和布尔值都会转换成数值，再比较
简单类型与引用类型比较，对象转化成其原始类型的值，再比较
两个都为引用类型，则比较它们是否指向同一个对象
null 和 undefined 相等
存在 NaN 则返回 false

全等操作符

全等操作符由 3 个等于号=== 表示，只有两个操作数在不转换的前提下相等才返回 true。即类型相同，值也需相同

事件循环

JavaScript是一门单线程的语言，意味着同一时间内只能做一件事，但是这并不意味着单线程就是阻塞，而实现单线程非阻塞的方法就是事件循环

同步任务

同步任务一般会直接进入到主线程中执行

异步任务

异步执行的任务，比如ajax网络请求，setTimeout定时函数等

async

async函数返回一个promise对象

test3 = function(){return Promise.resolve('test')
}
async function test4 (){return 'test'
}

await

正常情况下，await命令后面是一个 Promise对象，返回该对象的结果。如果不是 Promise对象，就直接返回对应的值
不管await后面跟着的是什么，await都会阻塞后面的代码

async function test5(){// 等同于 return 123return await 123
}
test5().then(res=>console.log(res))

JavaScript 实现继承

父类

function Animal(name){this.name = name;this.sayName = function() {window.alert(this.name);};
}

借用构造函数(经典继承)

使用call

function Cat(name,age){// 使用父类的构造函数Animal.call(this,name)this.age = age
}
// 创建一只猫
createcat = function(){let cat = new Cat('Ketty',16);cat.sayName();
}

对象冒充

function Dog(name,age){// 使用了对象冒充this.animal = Animalthis.animal(name)
}

组合继承

属性和方法是分开继承

function Car(name){this.name = name
}
Car.prototype = {sayName:function(){window.alert(this.name+'----'+this.sno)}
}
function Hongqi(name,sno){// 继承属性Car.call(this,name)this.sno = sno
}
// 继承方法
Hongqi.prototype = new Car();
createobject1 = function () {let hongqi = new Hongqi('hongqi',1001);hongqi.sayName();
}

回调函数

回调函数是一段可执行的代码段，它作为一个参数传递给其他的代码，其作用是在需要的时候方便调用这段（回调函数）代码。

回调函数

function sayHellow(msg, callback) {alert(msg)if (typeof callback === "function") {callback(msg);}
}
function one(msg){alert(msg)
}
sayHellow('你好',one);

匿名回调函数

function sayHellow(msg, callback) {alert(msg)if (typeof callback === "function") {callback();}
}
sayHellow('你好', function () {alert('匿名函数实现回调')
})

使用注意事项

不会立刻执行：传递的是函数的定义不会立即执行，回调函数在函调用函数中也要通过()运算符调用才会执行。
是个闭包：回调函数是一个闭包，也就是说它能访问到其外层定义的变量。
执行前类型判断：在执行回调函数前最好确认其是一个函数。
this使用：在回调函数调用时this的执行上下文并不是回调函数定义时的那个上下文，而是调用它的函数所在的上下文
允许传递多个回调函数

扩展运算符

扩展运算符对象实例的拷贝属于浅拷贝

method4 = function () {let item = { a: 1, b: 2, c: 3, d: 4 };let obj1 = { ...item };// 对象的合并let obj2 = Object.assign({}, item);
};

对象与数组的解构

解构是 ES6 提供的一种新的提取数据的模式，这种模式能够从对象或数组里有针对性地拿到想要的数值。

 // 数组
const [a,b,c] = [1,2,3]
// 对象
let item = {a:'test1',b:'test2'}
const {a,b} = item

# 技术栈知识点巩固——Js相关推荐

高级JAVA开发技术栈知识点总结
高级JAVA开发技术栈知识点总结写在前面 MQ Redis Dubbo 分布式系统 JVM Java基础写在前面 "金三银四"对于今年(2019)的互联网行业行情并不适用,面 ...
Linux 服务器开发学习路线总结（配图 c/c++ ）后台开发、Golang后台开发、后端技术栈
本文总结了目前互联网行业Linux c/c++ 后端岗位开发工程师.服务器开发架构师以及Golang开发工程师技术栈知识点.大家可以看看还有没有需要补充的. Linux后台开发工程师专栏一.算法与设 ...
【转】Node.js最新Web技术栈（2015年5月）
nodejs是比较简单的,只有你有前端js基础,那就按照我的办法来吧!一周足矣推荐技术栈 express 4.x (express最新版本,初学者先别去碰koa) mongoose(mongodb) ...
[推荐] 一个 Node.js 技术选型案例：使用 CARMEN 作为卡牌手游技术栈
作者 @超人张宝胜 ,原文地址:https://zhuanlan.zhihu.com/p/103724412,如需转载请联系作者授权. 前言本文介绍了在资金.人员.时间上全面告急.云服务提供商不确定 ...
大专java方向校招面试找工作知识点技术栈以及实习感受分享-简历分享
大专java方向校招面试找工作知识点技术栈以及实习感受分享专科生的Java学习以及校招面试先说一下我的编程历程开始求职之路第一次求职网上海投第二次面试第三次面试学校招聘会第四次面试 ...
迎难而上，2023Java面试突击指南手册。整合了各大技术栈常考知识点。
上周我接到一位粉丝的私信说目前互联网形势实在对他太不友好,感觉自己每个技术栈都会一点,但不是完全精通.基本二面三面的时候就挂了,已经完全不知道该朝哪个方向努力了,希望可以给他一些建议和方法指导.那么, ...
前端技术栈之html,css,js
目录 1.前端技术栈介绍 1.1.前端技术简介 1.2. 前端调试工具 1.2.1.HBuilder 1.2.2.webstorm 1.2.3.vscode 2. 静态页面HTML 2.1 概念 2. ...
Hive介绍与核心知识点--大数据技术栈12
回顾:大数据平台技术栈 (ps:可点击查看),今天就来说说其中的Hive! 作者:高广超,多年一线互联网研发与架构设计经验,擅长设计与落地高可用.高性能.可扩展的互联网架构.目前从事大数据相关研发与架 ...
后端技术栈入职培训感悟
6月份入职了新公司,并有幸参加了公司提供的技术栈培训. 虽然我这个人吧平时也不太热爱学习,技术底子比肾都虚,但毕竟也混了5年了,基本差不多的也都了解过或者经历过.所以一开始我是不慌的,但是从第一节课开 ...

# 技术栈知识点巩固——Js

技术栈知识点巩固——Js

Js 特点

Js 阻止默认事件

Js 基本类型

位运算

typeof与instanceof

Js 数组常用方法

constructor(构造函数)

Js 数据类型转换

new 操作符的执行过程

let、var、const

Promise

作用

Promise

Promise 状态

示例代码1

箭头函数

对this指向的影响

Js 闭包

词法作用域

使用场景

优点

缺点

Js 变量提升

Proxy

语法

Js 原型链

Proto和Prototype

Js 内存泄漏

全局变量

垃圾回收机制

标记清除

引用计数

防抖节流

防抖

节流

this 指向

JS 深浅拷贝

浅拷贝

深拷贝

函数柯里化

Ajax 请求

工作原理

发送Ajax请求

参数说明

Call、Apply、Bind

示例代码

区别

Apply

Call

Bind

Map、Set

foreach

== 和 === 区别

等于操作符

全等操作符

事件循环

同步任务

异步任务

async

await

JavaScript 实现继承

借用构造函数(经典继承)

对象冒充

组合继承

回调函数

回调函数

匿名回调函数

使用注意事项

扩展运算符

对象与数组的解构

# 技术栈知识点巩固——Js相关推荐

最新文章

热门文章