关于前端:2020回顾个人web分享JavaScript面试题附加回答

把你的前端拿捏得死死的，每天学习得爽爽的，达达前端程序员
感激不负每一份酷爱前端的程序员，不管前端技能有多奇葩，欢送关注

心愿能够通过这篇文章，可能给你失去帮忙。

对于在 JavaScript 中的字符串，对象，数组是没有固定大小的，只有当对他们进行动态分配存储时，解释器就会分配内存来存储这些数据，当 JavaScript 的解释器耗费完零碎中所有可用的内存时，就会造成零碎解体。

内存透露，在某些状况下，不再应用到的变量所占用内存没有及时开释，导致程序运行中，内存越占越大，极其状况下能够导致系统解体，服务器宕机。

so，JavaScript 有本人的一套垃圾回收机制，JavaScript 的解释器能够检测到什么时候程序不再应用这个对象了（数据），就会把它所占用的内存开释掉。

针对 JavaScript 的来及回收机制有以下两种办法（罕用）：标记革除 ， 援用计数。

当变量进入到执行环境时，垃圾回收器就会将其标记为“进入环境”，当变量来到环境时，就会将其标记为“来到环境”。

垃圾回收器在运行时会给存储在内存中的所有变量都加上标记，接着去掉环境环境中的变量，和被环境中的变量所援用的变量的标记，在此之后再被加上标记的变量将被视为筹备删除的变量，就是要删除的变量，垃圾收集器实现内存革除工作，销毁这些带有的标记的值，回收它们所占用的内存空间。

说到援用计数，局部人是不晓得是啥的，援用计数作为垃圾回收策略的一种，含意是跟踪记录每个值被援用的次数。

当申明了一个变量并将一个援用类型赋值给该变量时，则这个值的援用次数就是为 1。

相同的，如果该变量的值变成了另外一个，则这个值的援用次数减一。（当这个值的援用次数变为 0 的时候，阐明没有变量在应用，则这个值没法被拜访。）— 因此就能够将它占用的空间回收起来，这样垃圾回收器就会在运行的时候清理援用次数为 0 的值占用的空间。

然而援用计数存在如果互相援用大量的存在会导致大量的内存透露；同时如果呈现循环援用问题也会导致内存透露的问题。

所以，要缩小 JavaScript 中的垃圾回收，在初始化的时候新建对象，而后在后续过程中尽量多的重用这些创立好的对象。咱们能够：1. 数组 array 优化；2. 对象尽量优化；3. 循环优化。

如下内存调配形式：

{} 创立一个新对象
[] 创立一个新数组
funtion(){...} 创立一个新的办法
new Foo() new 关键字，一次内存的调配

反复利用：对对象 object 的优化，遍历此对象的所有属性，一一删除属性，最终将对象清空为一个空对象。

嗯，好的，DOM 节点类型有：Document 节点，整个文档是一个文档节点；Element 节点，每个 HTML 标签是一个元素节点；Attribute 节点，每一个 HTML 属性是一个属性节点；Text 节点，蕴含在 HTML 元素中的文本是文本节点。

个别状况下，脚本的下载和执行将会依照文档的先后顺序同步执行，当脚本下载和执行的时候，文档解析会被阻塞，在脚本下载和执行实现之后文档才会往下持续进行解析。

如果 script 标签中没有 defer 或 async 属性，浏览器在渲染过程中遇到 script 标签时，会进行渲染来下载执行 js 代码，期待 js 执行结束后，浏览器再从中断的中央复原渲染。

你会晓得这样浏览器会造成阻塞，如果你想要你的我的项目首屏渲染很快的话，就尽量不要在首屏加载 js 文件，所以学习的时候会倡议将 script 标签放在 body 标签底部。

说到 defer（提早执行）和 async（异步加载）属性的区别，上面展现应用 script 标签有以下三种状况：

<script src="dadaqianduan.js"></script> // 浏览器会立刻加载并执行相应的脚本

<script async src="dadaqianduan.js"></script> // 后续文档的加载和渲染与 js 脚本的加载和执行是并行进行的

<script defer src="dadaqianduan.js"></script> // 加载后续文档的过程和 js 脚本的加载是并行进行的，js 脚本的执行须要等到文档所有元素解析实现之后，DOMContentLoaded 事件触发执行之前

当加载的 js 脚本有多个的时候，async 是无程序的加载，而 defer 是有程序的加载，defer 属性示意提早执行引入的 JavaScript，这段 JavaScript 加载时 HTML 并未进行解析，so，defer 是不会阻塞 html 解析的，它是等 Dom 加载完后再去执行 JavaScript 代码的。（当 html 解析过程中，遇到 defer 属性，就会异步加载该 js 文件，不会中断 HTML 文档的解析，当整个 HTML 解析实现后，回头再来解析该 js 文件）

当有 defer 属性时，脚本的加载过程和文档加载是 异步产生 的，等到 文档解析 完脚本才开始执行。
当有 async 属性时，脚本的加载过程和文档加载也是 异步产生 的，这里留神的是 脚本下载实现 后，会 进行 HTML 解析 ， 先执行脚本 ， 脚本解析完 后 持续 HTML 解析。
同时有 async 和 defer 属性时，执行成果与 async 统一。

defer 属性 - 是否提早执行脚本，直到页面加载为止；async 属性 - 脚本一旦可用，就异步执行。defer 属性并行加载 JavaScript 文件，会依照页面上的 script 标签程序执行，而 async 并行加载，下载实现就立刻执行，不会依照页面上的程序执行。

面试前端，当面试官问你，谈谈你对闭包的了解的时候，该怎么答复呢？

简略说就是定义在一个函数外部的函数，外部函数持有内部函数内的变量或参数的援用。外部函数依赖内部函数，内部函数参数和变量不会被垃圾回收机制回收，这些变量会始终存在于内存中。

益处能够读取函数外部的变量，能够防止全局变量的净化，害处会减少内存的使用量，容易导致内存透露，解决办法就是退出函数前，将不实用的局部变量全副删除。在 JavaScript 中，函数即是闭包，只有函数才会产生作用域。

闭包个性，函数嵌套函数，在函数外部能够援用内部的参数和变量，参数和变量不会被垃圾回收机制回收。

因为在 js 中，变量的作用域属于函数作用域，在函数执行后，作用域就会被清理，内存也会被回收，然而因为闭包是建设在一个函数外部的子函数，因为子函数能够拜访下级作用域的起因，即便下级函数执行完，作用域也不会随之销毁。

在实质上，闭包就是将函数外部和函数内部连接起来的一座桥梁。

代码闭包表现形式：

// 作为函数参数传递
var a = 1;
function foo() {
 var a = 2;
 function dada() {console.log(a);
 }
 da(dada);
}

function da(fn) {
 // 闭包
 fn();}

foo(); // 输入 2

unshift()办法能够想数组结尾增加一个或多个元素，并返回新的长度。

arrayObject.unshift(newelement1,newelement2,....,newelementX)
newelement1    必须。向数组增加的第一个元素。newelement2    可选。向数组增加的第二个元素。newelementX    可选。可增加若干个元素。

返回值 - arrayObject 的新长度。

unshift() 办法将把它的参数插入 arrayObject 的头部，并将曾经存在的元素依次地移到较高的下标处，以便留出空间。该办法的第一个参数将成为数组的新元素 0，如果还有第二个参数，它将成为新的元素 1，以此类推。

请留神，unshift() 办法不创立新的创立，而是间接批改原有的数组。该办法会扭转数组的长度。

1.encodeURl()用于将 URL 转换为十六进制编码。
2.decodeURI()用于将编码的 URL 转换回失常 URL。

innerHTML内容每次刷新，因而很慢。在 innerHTML 中没有验证的余地，因而，更容易在文档中插入错误代码，从而使网页不稳固。

DOM 节点操作方法：

拜访、获取节点

document.getElementById(id);
// 返回对领有指定 id 的第一个对象进行拜访

document.getElementsByName(name);
// 返回带有指定名称的节点汇合

document.getElementsByTagName(tagName);
// 返回带有指定标签名的对象汇合

document.getElementsByClassName(className);
// 返回带有指定 class 名称的对象汇合

创立节点 / 属性

createDocumentFragment() // 创立一个 DOM 片段

document.createElement(eName); // 创立一个节点
document.createAttribute(attrName); // 对某个节点创立属性
document.createTextNode(text); // 创立文本节点

增加节点

document.insertBefore(newNode, referenceNode); // 在某个节点前插入节点
parentNode.appendChild(newNode); // 给某个节点增加子节点

复制节点

cloneNode(true | false); // 复制某个节点

删除节点

parentNode.removeChild(node); // 删除某个节点的子节点 node 是要删除的节点

属性操作

getAttribute(name) // 通过属性名称获取某个节点属性的值
setAttribute(name,value); // 通过某个节点属性的值
removeAttribute(name); // 删除某个属性

获取相邻的节点

curtNode.previousSibling; // 获取已知节点的相邻的上一个节点
curtNode.nextSibling; // 获取已知节点的下一个节点

应用localStorage, 应用localStorage.setItem(key,value); 增加内容

应用 storage 事件监听增加、批改、删除的动作

window.addEventListener("storage",function(event){$("#name").val(event.key+"="+event.newValue);
});

$(function(){$("#btn").click(function(){var name = $("#name").val();
       localStorage.setItem("name", name);
   });
});

console.log(null==undefined)//true

console.log(null===undefined)//false

null：Null 类型，代表“空值”，代表一个空对象指针

undefined：Undefined 类型，当一个申明了一个变量未初始化时，失去的是 undefined

undefined 示意“短少值”，此处应该有一个值，然而还没有定义。

null 示意“没有对象”，该处不应该有值。

new 操作符首先，创立了一个空对象：

var obj = new Object();

设置原型链：

obj._proto_ = Object.prototype

示例代码理解 new 的作用：

function da(name) {this.name = name;}
da.prototype.sayName = function() {console.log(this.name);
}
const jeskson = new da('dada');
console.log(jeskson.name); // dada
jeskson.sayName(); // dada

由例子得出：

new 通过构造函数 da 创立进去的实例能够拜访到构造函数中的属性

new 通过构造函数 da 创立进去的实例能够拜访到构造函数原型链中的属性，（通过 new 操作符，实例与构造函数通过原型链连贯了起来）

如果给构造函数一个 return 返回值，（没有显式的 return 任何值，默认返回 undefined)

function da(name) {
 this.name = name;
 return 1;
}
const jeskson = new da('dada');
console.log(jeskson.name); // dada

这个返回值没有任何的用途，构造函数如果返回原始值，这个返回值没有意义。

function da(name) {
 this.name = name;
 console.log(this); // da {name: 'dada'}
 return {age:1}
}
const jeskson = new da('dada');
console.log(jeskson); // {age:1}
console.log(jeskson.name); // undefined

构造函数如果返回值为对象，那么这个返回值就会被失常应用。

new 操作符会返回一个对象
这个对象，也就是构造函数中的 this，能够拜访到挂载在 this 上的任意属性
这个对象能够拜访到构造函数原型上的属性
返回原始值会疏忽，返回对象会失常解决

js 的提早加载有助于进步页面的加载速度

提早有：defer 属性，async 属性，动态创建 DOM 形式，应用 JQuery 的 getScript 办法，应用 setTimeout 提早办法，让 JS 最初加载。

应用 setTimeout 提早办法

<script type="text/javascript" >
  function A(){$.post("/lord/login",{name:username,pwd:password},function(){alert("Hello");
    });
  }
  $(function (){setTimeout('A()', 1000); // 提早 1 秒
  })
</script>

call(), applay() 都属于 Function.prototype 的一个办法，它是 JavaScript 引擎内实现的，属于 Function.prototype，所以每个 Function 对象实例，每个办法都有 call，apply 属性。

call()和 apply()，它们的作用都是雷同的，不同的在于，它们的参数不同。

call(this, arg1, arg2, arg3);
apply(this, arguments);

function add(a,b){console.log(a+b);
}
function sub(a,b){console.log(a-b);
}
add.call(sub, 2, 1);
add.apply(sub, [2,1]);

对于 A.applay(B)或 A.call(B)，简略地说，B 先执行，执行后依据后果去执行 A，用 A 去执行 B 的内容代码，再执行本人的代码。

var f1 = function(a,b) {console.log(a+b);
}
var f2 = function(a,b,c) {console.log(a,b,c);
}
f2.apply(f1,[1,2]) // 1 2 undefined

解析一下就是，先执行 f1,f1 执行后，这里留神 f1 是 f1，不是 f1()执行办法，所以外面的 console.log 等内容代码并没有执行，相等于，初始化了代码 f1，因为没有返回值，后果是 undefined，f2 执行的时候 this 指向 window。参数中为[1,2]，解析后参数为 1,2,undefined；执行 f2 办法后，打印出后果值为：1 2 undefined

A.call(B, 1,2,3) 前面的参数都是独立的参数对象，会被主动解析为 A 的参数：

var f1 = function(a,b) {console.log(a+b);
}
var f2 = function(a,b,c) {console.log(a,b,c);
}
f2.call(f1,[1,2]); // [1,2] undefined undefined
f2.call(f1, 1, 2); // 1 2 undefined

解析一下就是，参数中的[1,2]，因为传入了一个数组，相当于只传入了第一个参数，b 和 c 参数没有传。

应用 apply()和 call()：

 //apply 用法
 var arr = new Array(1,2,3)
 var arr1 = new Array(11,21,31)
 Array.prototype.push.apply(arr,arr1)
 console.log(arr)//[1, 2, 3, 11, 21, 31]
 
 //call 用法
 var arr = new Array(1,2,3)
 var arr1 = new Array(11,21,31)
 Array.prototype.push.call(arr,arr1[0],arr1[1],arr1[2])
 console.log(arr)//[1, 2, 3, 11, 21, 31]

数组利用 Math 求最大和最小值

 //apply 的用法
 var _maxNum = Math.max.apply(null,[1,3,2,4,5])
 console.log(_maxNum)//5
 var _minNum = Math.min.apply(null,[1,3,2,4,5])
 console.log(_minNum)//1
 
 //call 的用法
 var _maxNum = Math.max.call(null,1,3,2,4,5)
 console.log(_maxNum)//5
 var _minNum = Math.min.call(null,1,3,2,4,5)
 console.log(_minNum)//1

one 总结：Function.prototype.apply 和 Function.prototype.call 的作用是一样的，区别在于传入参数的不同；第一个参数都是指定函数体内 this 的指向；第二个参数就不同了，apply 是传入带下标的汇合，数组或者类数组，apply 把它传给函数作为参数，call 从第二个开始传入的参数是不固定的，都会传给函数作为参数。call 比 applay 的性能要好，平时多用 call。

two 总结：尤其是 es6 引入了 Spread operator 延展操作符后，即便参数是数组，能够应用 call 了。

let params = [1,2,3,4,5];
dada.call(obj, ... params);

传入的第一个参数为 null, 函数体内的 this 会指向默认的宿主对象, 在浏览器中则是 window

var func = function(a, b, c){console.log(this === window); // 输入:true
};
func.apply(null, [ 1, 2, 3] );

// 在严格模式下, 函数体内的 this 还是为 null

var func = function(a, b, c){ 
    "use strict";
    console.log(this === null); // 输入:true
};
func.apply(null, [ 1, 2, 3] );

扭转 this 指向

var obj1={name: 'dada'};
var obj2={name: 'da'};
window.name = 'window';
var getName = function(){console.log ( this.name);
};
getName(); // 输入: window
getName.call(obj1);// 输入: dada
getName.call(obj2); // 输入: da

document.getElementById('div1').onclick = function(){console.log( this.id);// 输入: div1
    var func = function(){console.log ( this.id);// 输入: undefined
    } 
    func();}; 
// 修改后
document.getElementById('div1').onclick = function(){var func = function(){console.log ( this.id);// 输入: div1
    } 
    func.call(this);
};

工厂模式, 创立形式

function createPerson(name,age,job){var o = new Object();
    o.name=name;
    o.age=age;
    o.job=job;
    o.sayName = function(){alert(this.name);
    }
}
var person1 = createPerson("da",1,"it");
var person2 = createPerson("dada",2,"it");

构造函数模式

function Person(name,age,ob){
    this.name=name;
    this.age=age;
    this.job=job;
    this.sayName = function(){alert(this.name);
    }
var person1 = new Person("dada",1,"web");
var person2 = new Person("dada",2,"web");
}

应用原型模式：

function Person(){}
Person.prototype.name = "da";
Person.prototype.age = 1;
Person.prototype.job = "web";
Person.prototype.sayName = function(){alert(this.name);
}
 
var person1 = new Person();
person1.sayName();    //"dada"
 
var person2 = new Person();
person2.sayName();    //"dada"
 
alert(person1.sayName == person2.sayName);   //true

组合应用构造函数模式和原型模式

function Person(name,age){
    this.name = name;
    this.age = age;
    this.friends = ["da","dada"];
}
Person.prototype = {
    constructor:Person,
    sayName:function(){alert(this.name);
    }
}
var person1 = new Person("da1",1);
var person2 = new Person("da2",2);
person1.friends.push("dadada");
console.log(person1.friends);    //["da","dada","dadada"]
console.log(person2.friends);    //["da","dada"]
console.log(person1.friends === person2.friends);    //false
console.log(person1.sayName === person2.sayName);   //true

动静原型模式

function Person(name,age,job){
    this.name=name;
    this.age=age;
    this.job=job;

    if(typeof this.sayName!="function"){Person.prototype.sayName=function(){alert(this.name);
        };
    }
}

JavaScript 对象的创立形式，1，Object 构造函数式，2，对象字面量式,3，工厂模式,4，平安工厂模式，5，构造函数模式，6，原型模式，7，混合构造函数和原型模式，8，动静原型模式，9，寄生构造函数模式，10，稳当构造函数模式。

学习应用异步很重要，在浏览器端，耗时很长的操作都应该异步执行，防止浏览器失去响应，最好的例子是 ajax 操作。

简略的 promise 对象的构造函数的构造：var Promise = function() {this.callbacks = []; // 用于治理回调函数
}
Promise.prototype = {
 construct: Promise,
 resolve: function(result) {// 申请胜利时执行的办法},
 reject: function(result) {// 申请失败时执行的办法},
 complete: function(type, result) {// 执行回调},
 then: function(successHandler, failedHandler) {// 绑定回调函数}
}

对于回调函数，益处是简略，容易了解，然而毛病在于代码的浏览和保护，各个局部之间高度耦合，流程也会很乱，每个工作只能指定一个回调函数，称之为：回调天堂。

// 同步操作变成异步操作
f1();
f2();

function f1(callback) {setTimeout(function() {callback();
 },1000);
}
f1(f2);

事件监听 (采纳事件驱动模式，工作的执行不取决于代码的程序，而取决于某个事件是否产生) 示例如下：

$('#clickBtn').on('click',function(e){console.log('xxx');}

f1.on('dada', f2);

function f1() {setTimeout(function() {f1.trigger('dada');
 },1000);
}

// f1.trigger('dada')示意执行实现后，立刻触发 dada 事件，而后开始执行 f2

对于事件监听，可绑定多个事件，而且每个事件能够指定多个回调函数，能够“去耦合”，有利于实现模块化，毛病就是整个程序都要编程事件驱动型，运行流程会变得很不清晰。

对于采纳公布，订阅形式，和“事件监听”相似。(公布 / 订阅)

对于应用 Promise 对象实现，每一个异步工作返回一个 Promise 对象，该对象有一个 then 办法，容许指定回调函数。

同源策略的目标是为了避免某个文档或脚本从多个不同源装载，同源策略是指，协定，域名，端口雷同。同源策略是一种平安协定，指一段脚本只能读取来自同一起源的窗口和文档的属性。

有同源限度能够搁置黑客盗取信息。

函数是第一类对象：

这些函数能够作为参数传递给其余函数，作为其余函数的值返回，调配给变量，也能够存储在数据结构中。

如果公民分等级，一等公民什么都能够做，次等公民这不能做那不能做。JavaScript 的函数也是对象，能够有属性，能够赋值给一个变量，能够放在数组里作为元素，能够作为其余对象的属性，什么都能够做，别的对象能做的它能做，别的对象不能做的它也能做。这不就是一等公民的位置嘛。

函数申明：

foo(); // 在函数申明之后调用 foo，能够失常调用。因为 foo 被提前到最后面定义了。function foo() {return true;}

调用：

函数名(参数)

函数名.call(函数名, 参数)

函数名.apply(函数名,[参数])

new 函数名(参数)

定时器

把函数申明变成函数表达式再调用

ES6 里的模版字符串

函数表达式：

foo(); // 在函数表达式之前调用函数，报错。因为这时候还没有 foo 这个变量。var foo = function() {return foo;};

调用

函数名(参数)

函数名.call(函数名, 参数)

函数名.apply(函数名,[参数])

new 函数名(参数)

间接在前面加上一对小括号

定时器

ES6 里的模版字符串

以被赋值的模式呈现（依据具体模式调用）

在向执行环境中加载数据时，解析器对函数申明和函数表达式不一样的，解析器首先读取读取函数申明，并使它在执行任何代码之前可用，对于函数表达式，就须要等到解析器执行到它所在的代码行。

JavaScript 解释器中存在一种变量申明被晋升的机制，也就是说函数申明会被晋升到作用域的最后面，即便写代码的时候是写在最初面，也还是会被晋升至最后面。

var getName // 变量被晋升，此时为 undefined

getName() // dada 函数被晋升

var getName = function() {console.log('da')
}
// 函数表达式此时才开始笼罩函数申明的定义

getName() // da

function getName() {console.log('dada')
}

getName() // da

在 JavaScript 中定义一个函数有四种形式

1. 函数申明
2. 函数表达式
3. ES6 里箭头函数
4. new Function()

ES5 规定，函数只能在顶级作用域和函数作用域中申明，否则是不非法的。
ES6 引入了块级作用域的概念，这种定义方法就被容许了。

代码如下：

document.cookie = 'user=jeskson;expires='+new Date(0);

一个英文字符占用一个字节，一个中文字符占用两个字节

function byte(str) {
 var bytes = str.length;
 for(var i=0; i<bytes; i++) {if(str.charCodeAt(i)>255) {bytes++;}
 }
 return bytes
}
console.log(byte('dada'));

attribute 是 dom 元素在文档中作为 HTML 标签领有的属性，property 就是 dom 元素在 JavaScript 中作为对象领有的属性。

attribute 个性，property 属性。

默认状况下，在页面加载期间，HTML 代码的解析将暂停，晓得脚本进行执行。如果服务器速度较慢或者脚本特地惨重，会导致网页提早，在应用 Deferred 时，脚本会提早执行直到 HTML 解析器运行。这缩小了网页加载工夫，并且它们的显示速度更快。

function outer() {
 var a = '变量 1'
 var inner = function() {console.info(a);
}
return inner; // inner 就是一个闭包函数，因为它能拜访到 outer 函数的作用域
}

在 JavaScript 中的一大特点就是闭包，很多高级利用都要依附闭包来实现。因为闭包会使得函数中的变量都被保留在内存中，内存耗费很大的，所以不要乱滥用闭包，否则会导致页面的性能问题，在 IE 中可能会导致内存透露，所以能够在退回函数前，将不应用的局部变量全副删除。

instanceof 关键字，判断一个对象是否是类的实例化对象
constructor 属性，判断一个对象是否是类的构造函数

hasOwnProperty

document.write 会重绘整个页面
innerHTML 能够重绘页面的一部分

成果动态图：

<button onclick="fun()" > 按鈕 </button>
<script>
    function fun() {document.write("write 内容");
    }
</script>

<button onclick="fun()"> 按钮 </button>
<script>
    function fun() {document.getElementById("p").innerHTML="新减少的 innerHTML 内容";
    }
</script>

读取服务器中的文件内容

function readAjaxFile(url) {
 // 创立 xhr
 var xhr = new XMLHttpRequest();
 // 监听状态
 xhr.onreadystatechange = function() {
  // 监听状态值
  if(xhr.readyState === 1 && xhr.status === 200) {console.log(xhr.responseTest)
  }
 }
 // 关上申请
 xhr.open('GET', url, true)
 // 发送数据
 xhr.send(null)
}

读取本地计算机中的内容

function readInputFile(id) {var file = document.getElementById(id).files[0];
 // 实例化
 var reader = new FileReader();
 // 读取文件
 reader.readAsText(file)
 // 监听返回
 reader.onload = function(data) {console.log(data, this.result);
 }
}

document.form.action = 'submit';

不要在同一行申明多个变量
应用对象字面量代替 new Array 这种模式
不要应用全局函数
switch 语句必须带有 default 分支
函数不应该有时有返回值，有时没有返回值
for 循环必须应用大括号括起来
if 语句必须应用大括号括起来
写正文
命名规定，结构器函数首字母大写

eval 的性能是把对应的字符串解析成 JavaScript 代码并运行。然而应该防止应用 eval，应用它可能会造成程序不平安，影响性能因要一次解析成 JavaScript 语句，一次执行。

["1","2","3"].map(parseInt)

[1,NaN,NaN]因 parseInt 须要两个参数 val,radix，其中 radix 示意解析时用的基数，map 传递了 3 个参数 item, index, array，对应的 radix 不非法导致解析失败。

this 指的是调用函数的那个对象，个别状况下，this 是全局对象 Global，能够作为办法调用。this 随着函数的应用场合的不同，this 的值会发生变化。

this 是谁调用就指向谁，在全局环境里，指向的是 window 对象。

var name = 'jeskson';
function person() {return this.name;}

console.log(this.name); // jeskson
console.log(window.name); // jeskson
console.log(person()); // jeskson

部分环境：

var name = "jeskson";

function person() {console.log(this.name);
}

person(); // jeskson

var obj = {
 name: "dada",
 person: function() {console.log(this.name);
 }
}

obj.person(); // dada

构造函数内应用 this

function Person(name) {
 this.name = name;
 return name;
}
console.log(new Person('jeskson').name); // jeskson

应用 apply 和 call 函数扭转 this 的指向

function person() {return this.name;}

var obj = {name: 'jeskson'}

console.log(person.call(obj)); // jeskson
console.log(person.apply(obj)); // jeskson

对象函数调用，哪个对象调用就指向哪个对象

<input type="button" id="btnDa" value="dada">

<script>
var btnDa = document.getElementById("btnDa");
btnDa.onClick=function() {console.log(this); // this 指向的是 btnDa 对象
}
</script>

应用 new 实例化对象，在构造函数中的 this 指向实例化对象

var show = function() {this.myName="jeskson"; /// this 指向的是 obj 对象}
var obj = new show();

典型的类（伪）数组是函数的 argument 参数，在调用 getElementsByTagName 和document.childNodes办法时，它们返回的 NodeList 对象都属于伪数组。
能够应用 Array.prototype.slice.call(fakeArray) 将数组转化为真正的 Array 对象。

什么是伪数组，是能通过 Array.prototype.slice 转换为真正的数组的带有 length 属性的对象。

// 规范的有伪数组对象
var da = {0: 'a', 1: 'b', length: 2};
var dada = Array.prototype.slice.call(da);
console.log(da[0]); // a
var dadada = [].slice.call(dada);
console.log(da[0]); // a

伪数组：就是无奈应用数组的办法和 api, 但任然能够应用便当数组的形式遍历他们。

一个伪数组 Array.prototype.slice.call() 进行转换为一个真正的数组

caller 返回一个对于函数的援用，该函数调用了以后函数
callee 返回正在执行的函数，也就是指定的 function 对象的注释

caller 是 JavaScript 函数类型的一个属性，它援用调用以后函数的函数; callee 则不是函数对象的属性，它是函数上下文中 arguments 对象的属性。

aaaabbbccccddhgddada

function dealStr(str) {var obj = {};
 for(var i = 0; i<str.length; i++){var v = str.charAt(i);
  if(obj[v] && obj[v].value === v) {++obj[v].count
  }else{obj[v] = {
    count: 1,
    value: v
   }
  }
 }
 return obj;
}

var obj = dealStr(str);
for(key in obj) {console.log(obj[key].value+'='+obj[key].count);
}

function trim(str) {if (str && typeof str === "string") {return str.replace(/(^\s*)|(\s*)$/g,""); // 去除前后空白符
    }
}

for 循环数组

var arr3 = [];

// 遍历 arr1
for (var i = 0; i < arr1.length; i++) {arr3.push(arr1[i]);
}

// 遍历 arr2
for (var j = 0; j < arr2.length; j++) {arr3.push(arr2[j]);
}

console.log(arr3); // [1,2,3,4,5,6]

concat()办法:concat()办法，作用是连贯两个或更多的数组，并返回一个新的数组。

var arr3 = arr1.concat(arr2);

console.log(arr3); // [1,2,3,4,5,6]

apply()办法

arr1.push.apply(arr1, arr2);

&&运算符
||运算符
!运算符

事件代理，又称为事件委托，就是把本来须要绑定的事件委托给父元素，让父元素负责事件监听，事件代理的原理是 DOM 元素的事件冒泡，应用事件代理的益处是进步性能。

未声明的变量呈现中不存在且未声明的变量。如果程序尝试读取未声明变量的值，则会遇到运行时谬误。

xxx is not defined

未定义的变量是在程序中申明但尚未给出任何值的变量。如果程序尝试读取未定义变量的值，则返回未定义的值。

曾经通过 var 指令申明，然而没有赋值，没有定义类型，所以会打印 undefined 未定义

全家变量是整个代码中都可用的变量，这些变量没有任何作用域。var 关键字用于申明局部变量或对象，如果省略 var 关键字，则声明一个全局变量。

应用全局变量所面临的问题是局部变量和全局变量名称的抵触，很难调试和测试依赖于全局变量的代码。

setTimeout(function,delay)函数用于启动在所属提早之后调用特定性能的定时器。
setInterval(function,delay)函数用于在提到的提早中反复执行给定的性能，只有在勾销时才进行。
clearInterval(id)函数批示定时器进行。

ViewState 用于会话中的页面
SessionState 用于 Web 应用程序中的所有页面上拜访的用户特定数据

46. 什么是 `===` 运算符

===为严格等式运算符，只有当两个操作数具备雷同的值和类型时，，才会返回true

for, while, do...while, for_in, for of (es6 新增)

while(条件表达式语句)
{执行语句块;}

do
{执行语句块；}
while(条件表达式语句);

for(初始化表达式; 循环条件表达式; 循环后的操作表达式)
{执行语句块;}

null 用于示意无值或无对象，示意没有对象或空字符串，没有无效的布尔值，没有数值和数组对象。

delete 操作符用于删除对象中的某个属性，然而不能删除变量，函数等。

    var obj = {name: 'jeskson'}
    console.log(obj.name);//'jeskson'
    delete obj.name;
    console.log(obj.name);//undefined

alert, confirm, prompt

其作用是用于避免页面刷新，并在调用时传递参数“0”；用于调用另一种办法而不刷新页面

cookie 是一些数据，存储你电脑上的文本文件中，当 web 服务器向浏览器发送 web 页面时，在连贯敞开后，服务端不会记录用户的信息。

Cookie 的模式，Cookie 是由 name=value 模式成对存在的，Cookie 字符串必须以分号作为结束符，Cookie 除了 name 属性之外还存在其余 4 个相干属性。

设置 Cookie 的语法如下：set-Cookie:name=value;[expires=date];[path=dir];[domain=domainn];[secure]

pop()办法将最初一个元素从给定的数组中取出并返回

var da = [1, 2, 3];
da.pop();

// da: [1,2]

datatypes的两个根本组是原始类型和援用类型。

typeof 是一个运算符，用于返回变量类型的字符串形容。

push 办法是将一个或多个元素增加或附加到数组的开端。

unshift 办法是将一个或多个元素增加到数组的结尾。

为对象增加属性的办法，罕用两种：

中括号语法
点语法

在将页面加载到浏览器中时，这两个性能都能够用来执行工作，然而它们在执行形式和执行工夫方面存在轻微的差别。

当浏览器加载 DOM 树和所有其余资源（例如图像，对象等）时，“window.onload”将执行代码。

onDocumentReady在构建 DOM 树时执行，而无需期待其余资源加载。这样能够应用 onDocumentReady 更快地针对 DOM 执行代码。

另一个区别是 window.onload 与跨浏览器不兼容，而应用相似 jQuery 的 document.ready() 则能够在所有浏览器上很好地工作。

用于循环对象的属性：

for (var item in object

被申明为没有任何命名标识符的函数，一般来说，匿名函数在申明后无法访问。

var da = function() {console.log('dadaqianduan.cn')
}
da();

单击子级的处理程序，父级的处理程序也将执行同样的工作。

对事件冒泡机制的了解？

事件流的执行程序，捕捉阶段 -》指标阶段 -》冒泡阶段。冒泡从里到外的执行。<div><span> 点我 </span></div>,在 div 上定义的事件，点击 span 的时候会触发 span 下面绑定的事件，之后也会触发里面 div 下面的事件，这就是冒泡。

冒泡阶段是从指标到 window 对象的过程。事件默认是冒泡的，当父元素增加监听事件，点击子元素后，父元素上的事件会被触发，这就是典型的冒泡。

它只是一个类数组对象，并没有数组的办法。

构造函数是用来创建对象时初始化对象，与 new 一起试用，创建对象的语句中构造函数的名称必须与类名完全相同。

构造函数只能由 new 关键字调用
构造函数能够创立实例化对象
构造函数是类的标记

split()办法是用来切割成数组的模式
join()办法是将数组转换成字符串

"abcdef".split("")   //  ["a","b","c","d","e","f"]"abcdef".split()    // ["abcdef"]"2:3:4:5".split(":",3)  //  ["2","3","4"]

[1,2,3,4,5].join()   // "1,2,3,4,5"
[1,2,3,4,5].join(':')  // "1:2:3:4:5"

JavaScript 的每个对象都继承另一个父级对象，父级对象称为原型 (prototype) 对象。

原型链简直是前端面试的必问题目

每一个实例对象都有一个公有属性 __proto__ 指向其构造函数的原型对象prototype，该原型对象也会作为实例对象有一个公有属性__proto__，层层向上直到一个对象的原型对象值为null。

当拜访一个对象的属性或办法时，js引擎会先查找该对象自身是否蕴含，如果没有，会去该对象的 __proto__ 属性所指向的原型对象上找，如果没有，会持续向上一层找，直到某个对象的 __proto__ 值为null, 这就是原型链。

在 js 中，每个构造函数都有一个 prototype 属性，指向另外一个对象，阐明整个对象所有的属性和办法都会被构造函数所领有。

function Person (name, age) {
  this.name = name
  this.age = age
}
 
console.log(Person.prototype)
 
Person.prototype.type = 'it'
 
Person.prototype.sayName = function () {console.log(this.name)
}
 
var p1 = new Person('jeskson', 18);
var p2 = new Person('dada', 18);
 
console.log(p1.sayName === p2.sayName) // => true

构造函数 Person：

function Person() {}

--> 原型属性（prototype) 神秘的对象 Person.prototype

--> 由构造函数创立 Person 实例 --> __proto__ 原型对象 --> 神秘对象

任何一个构造函数都有一个 prototype 属性，该属性是一个objec t 对象。

构造函数的 prototype 对象都有一个默认的 constructor 属性，指向 prototype 对象所在函数。

通过构造函数失去的实例对象外部会蕴含一个指向构造函数的 prototype 对象的指针 __proto__

console.log(obj.__proto__);

console.log(obj.prototype);

console.log(obj.__proto__ === Object.prototype);

构造函数（prototype）指向原型
构造函数，New 实例化（实例对象），实例对象中 (.constructor) 指向构造函数
实例对象 （.__proto__） 指向原型

1. 实例对象.__proto__=== 原型

2. 原型.constructor=== 构造函数

3. 构造函数.prototype=== 原型

typeof 是一个一元运算，它返回值是一个字符串，该字符串阐明运算数的类型。

instanceof，判断该对象是谁的实例

instanceof 运算符用来测试一个对象在其原型链中是否存在一个构造函数的 prototype 属性,instanceof 只能用来判断对象和函数, 不能用来判断字符串和数字

function getDataType(obj) {if (obj === null) {return“null”;} else if (typeof obj ===“object”) {if (obj instanceof Array) {return“array”;} else {return“object”;}
} else {return typeof obj;}
}

事件流是指从页面中接管事件的程序。

指不太具体的元素更早地接管到事件，而最具体的节点最初接管到事件。

它就是一个通过函数指针调用的函数。

自执行函数是指申明的一个匿名函数，能够立刻调用整个匿名函数，个别用于框架，插件等场景，益处在于防止各种 JavaScript 库的抵触，隔离作用域，防止净化。

事件委托是利用冒泡的原理，把事件加到父级上，触发执行成果。益处在于，缩小事件数量，进步性能，防止内存外泄。

在 JavaScript 中，数据类型的转换有：隐式类型转换和强制类型转换（也叫显式类型转换）两种形式。

隐式类型转换：

==  只做值的判断，理论隐式转换了类型，而后才进行的比拟

强制类型转换：

parseInt()     将字符串强类型制转换为数字整数类型

parseFloat()  将字符串类型转换为浮点类型

Number()      只能将纯数字的字符转换为数字

NaN示意“不是数字”，然而它的类型是Number，NaN 和任何内容比拟，甚至是本人，后果都是 false.

狭义跨域就是指跨域拜访，简略来说就是 A 网站的 javascript 代码试图拜访 B 网站，包含提交容和获取内容容。因为平安起因，跨域拜访是被各大浏览器所默认禁止的。

跨域是指不同域名之间的互相拜访。

var d = new Date();
var year = d.getFullYear();
var month = d.getMonth() + 1;
month = month < 10 ? "0" + month : month;
var day = d.getDate();
daty = day<10? "0"+day : day;
console.log(year+'-'+month+'-'+day);

var isArray = [];
function getRandom(start, end) {return Math.floor(Math.random() * (end-start+1) + start)
}
for(var i = 0; i<10; i++){isArray.push(getRandom(10,100))
}
isArray.sort()
console.log(isArray)

function clone(obj) {
 var buf;
 if(obj instanceof Array) {
  var i = obj.lenght;
  buf = [];
  while(i--) {buf[i] = clone(obj[i])
  }
  return buf;
 }else if(obj instanceof Object) {buf = {};
  for(var i in obj) {buf[i] = clone(obj[i])
  }
  return buf;
 }else{return buf = obj;}
}

function noRepeat(arr) {
 var i = 0,
 len = arr.length,
 obj = {},
 result = [];
 while(++i < len) {obj[arr[i]] || result.push(arr[i])
 obj[arr[i]] = true;
}
return result;
}

getElementById()依据元素 id 查找
getElementsByTagName(tag)依据标签名称查找
getElementsByName(name)依据元素名称进行查找

function Person(name, job, site) {
 this.name = name;
 this.job = job;
 this.site = site;
}
Person.prototype = {getName: function() {console.log('my name'+this.name);
 }
 getJob: function() {console.log('my job'+ this.job);
 }
 getWork: function() {console.log('my work' + this.site);
 }
}

var da = new Person('dada', 'it', 'shenzheng');
da.getName();
da.getJob();
da.getWork();

变量作用域，变量的可用性范畴。通常来说，一段程序代码中所用到的名字并不总是无效可用的，而限定这个名字的可用性的代码范畴就是这个名字的作用域。作用域的应用，可进步程序逻辑的局部性，加强程序的可靠性，缩小名字抵触。从作用域角度辨别，变量可分为全局变量和局部变量。

在子构造函数中，将父类的构造函数在子类的作用域中执行
在子类的原型中，复制父类构造函数原型上的属性办法

JavaScript 是如何实现继承的(六种形式)

1. 原型链：利用原型让一个援用类型继承另外一个援用类型的属性和办法。

原型链实现继承例子：

function SuperType() {this.property = true;}
SuperType.prototype.getSuperValue = function() {return this.property;}
function SubType() {this.property = false;}
// 继承了 SuperType
SubType.prototype = new SuperType();
SubType.prototype.getSubValue = function (){return this.property;}
var instance = new SubType();
console.log(instance.getSuperValue());//true

2. 借用构造函数：在子类型构造函数的外部调用超类构造函数，通过应用 call()和 apply()办法能够在新创建的对象上执行构造函数。

function SuperType() {this.colors = ["red","blue","green"];
}

function SubType() {SuperType.call(this);// 继承了 SuperType
}

var instance1 = new SubType();

instance1.colors.push("black");

console.log(instance1.colors);//"red","blue","green","black"

var instance2 = new SubType();

console.log(instance2.colors);//"red","blue","green"

3. 组合继承：将原型链和借用构造函数的技术组合在一块，从而施展两者之长的一种继承模式。

function SuperType(name) {
this.name = name;
this.colors = ["red","blue","green"];
}

SuperType.prototype.sayName = function() {console.log(this.name);
}

function SubType(name, age) {SuperType.call(this,name);// 继承属性
this.age = age;
}

// 继承办法
SubType.prototype = new SuperType();
Subtype.prototype.constructor = Subtype;
Subtype.prototype.sayAge = function() {console.log(this.age);
}

var instance1 = new SubType("da",18);

instance1.colors.push("black");

consol.log(instance1.colors);//"red","blue","green","black"

instance1.sayName();//"EvanChen"

instance1.sayAge();//18

var instance2 = new SubType("dada",20);

console.log(instance2.colors);//"red","blue","green"

instance2.sayName();//"dada"

instance2.sayAge();//20

4. 原型式继承：借助原型能够基于已有的对象创立新对象，同时还不必须因而创立自定义的类型。

5. 寄生式继承：创立一个仅用于封装继承过程的函数，该函数在外部以某种形式来加强对象，最初再像真正是它做了所有工作一样返回对象。

6. 寄生组合式继承：通过借用函数来继承属性，通过原型链的混成模式来继承办法

作用域链与函数执行栈绝对应。js 运行环境分为全局、函数以及 eval 三类，每当代码执行进入了一个新的运行环境就会将环境的执行上下文入栈，退出环境时将其出栈，从栈顶到栈底造成从内层到外层的嵌套关系。

由执行上下文创立的词法环境持有外层执行上下文的词法环境援用，当 JS 引擎在以后词法环境中找不到相应的变量时，会逐层向外查找，如此造成的链表即为作用域链。

作用域链指的是代码执行时, 查找变量的规定, 先在以后本身的作用域查找, 找不到在往下级作用域查找, 查不到的话直至全局环境, 当然全局环境不能拜访部分作用域的变量

JavaScript 中的每个对象都有一个 prototype 属性，称为原型，而原型的值也是一个对象，因而它也有本人的原型，这样就造成了一条原型链，原型链的链头是 object，它的 prototype 比拟非凡，值为 null。

__proto__是在查找链中用于解析办法的理论对象等，prototype应用以下命令 __proto__ 创建对象时用于构建的对象new：

(new Foo).__proto__ === Foo.prototype;
(new Foo).prototype === undefined;

prototype是 Function 对象的属性，它是由该性能结构的对象的原型。

__proto__是对象的外部属性，指向其原型。以后提供了 Object.getPrototypeOf(o) 办法，只管事实上的规范 __proto__ 更快。

能够应用 instanceof 通过将函数 prototype 与对象的 __proto__ 链进行比拟来找到关系，也能够通过更改来突破这些关系。

function Point(x, y) {
    this.x = x;
    this.y = y;
}

var myPoint = new Point();

// the following are all true
myPoint.__proto__ == Point.prototype
myPoint.__proto__.__proto__ == Object.prototype
myPoint instanceof Point;
myPoint instanceof Object;

有参函数
无参函数
空函数

1、函数式申明
2、函数表达式（函数字面量）
3、函数结构法，参数必须加引号
4、对象间接量
5、原型继承
6、工厂模式

// 通过函数字面量
function da() {}

// 函数表达式
var da = function() {}

// 通过构造函数
var da = new Function();

全局属性和函数可用于所有内建的 JavaScript 对象。默认的 this 指向 window, 默认全局对象的属性和办法不必在后面加 window，能够间接调用。

顶层函数（全局函数）:

decodeURI()    解码某个编码的 URI。decodeURIComponent()    解码一个编码的 URI 组件。encodeURI()    把字符串编码为 URI。encodeURIComponent()    把字符串编码为 URI 组件。escape()    对字符串进行编码。eval()    计算 JavaScript 字符串，并把它作为脚本代码来执行。getClass()    返回一个 JavaObject 的 JavaClass。isFinite()    查看某个值是否为有穷大的数。isNaN()    查看某个值是否是数字。Number()    把对象的值转换为数字。parseFloat()    解析一个字符串并返回一个浮点数。parseInt()    解析一个字符串并返回一个整数。String()    把对象的值转换为字符串。unescape()    对由 escape() 编码的字符串进行解码。

顶层属性（全局属性）

Infinity    代表正的无穷大的数值。java    代表 java.* 包层级的一个 JavaPackage。NaN    批示某个值是不是数字值。Packages    根 JavaPackage 对象。undefined    批示未定义的值。

罕用的是 Array 对象、Date 对象、正则表达式对象、string 对象、Global 对象

Concat（）：示意把几个数组合并成一个数组。Join（）：返回字符串值，其中蕴含了连贯到一起的数组的所有元素，元素由指定的分隔符分隔开来。Pop（）：移除数组最初一个元素。Shift（）：移除数组中第一个元素。Slice（start，end）：返回数组中的一段。Push（）：往数组中新增加一个元素，返回最新长度。Sort（）：对数组进行排序。Reverse（）：反转数组的排序。toLocaleString(); 返回以后零碎工夫。ceil()：向上取整。floor(): 向下取整。round(): 四舍五入。random(): 取随机数。get/setDate()：返回或设置日期。get/setFullYear(): 返回或设置年份，用四位数示意。get/setYear(): 返回或设置年份。get/setMonth(): 返回或设置月份。0 为一月
get/setHours(): 返回或设置小时，24 小时制
get/setMinutes(): 返回或设置分钟数。get/setSeconds(): 返回或设置秒钟数。get/setTime(): 返回或设置工夫（毫秒为单位）。

DOM，文档对象模型（Document Object Model）。DOM 是 W3C（万维网联盟）的规范，DOM 定义了拜访 HTML 和 XML 文档的规范。在 W3C 的规范中，DOM 是独于平台和语言的接口，它容许程序和脚本动静地拜访和更新文档的内容、构造和款式。

分三种：

外围 DOM，针对任何结构化文档的规范模型
xml Dom，针对 xml 文档的规范模型
html Dom，针对 HTML 文档的规范模型

队列是先进先出的，栈是先进后出的
栈和队列都是线性表，都是限度了插入删除点的线性表，都是只能在线性表的端点插入和删除

cookie 数据寄存在客户的浏览器上，session 数据寄存在服务器上
cookie 不是很平安
session 会在肯定工夫内放弃在服务器上，当拜访多时，会影响服务器的性能。
用户验证这种场合个别会用 session
session 能够放在文件、数据库、或内存中都能够
Cookie 和 Session 都是会话技术
Cookie 有大小限度以及浏览器在存 cookie 的个数也有限度，Session 是没有大小限度和服务器的内存大小无关

我是 Jeskson(达达前端)，感激各位人才的：点赞、珍藏和评论，咱们下期见！

SegmentFault 思否征文「2020 总结」

前言

1. JavaScript 垃圾回收机制的理解

标记革除

援用计数

2. 说说有几种类型的 DOM 节点

3. 在 script 标签中 defer 和 async 属性的区别

4. 说说你对闭包的理解

5. 解释一下 unshift()的办法

6. 说说 encodeURI()和 decodeURI()的作用是什么

7. 为什么不倡议在 JavaScript 中应用 innerHTML

8. 在 DOM 操作中怎么创立，增加，移除，替换，插入，查找节点

9. 如何实现浏览器内多个标签页之间的通信

10. null 和 undefined 的区别是什么

11. new 操作符的作用是什么

12. JavaScript 提早加载的形式有哪些

13. call()和 apply()的区别和作用是什么

14. 哪些操作会造成内存透露

15. 说说 JavaScript 对象的几种创立形式

16. 如何实现异步编程

17. 说说 JavaScript 的同源策略

18. 说一下为啥要有同源限度

19. 在 JavaScript 中，为啥说函数是第一类对象

20. 函数申明与函数表达式的区别

21. 如何删除一个 cookie

22. 写一下一个办法，求字符串的长度

23. attribute 和 property 的区别是什么

24. 提早脚本在 JavaScript 中有什么作用

25. 说说什么是闭包，闭包的优缺点是什么

26. 判断一个对象是否属于某个类

27. 你晓得有个函数，执行间接对象查找时，它始终不会查找原型，这是什么函数

28. document.write 和 innerHTML 的区别

29. 在 JavaScript 中读取文件的办法是什么

30. 如何调配对象属性

31. 罕用的 JavaScript 语句根本标准

32. eval 的性能是什么

33. 如下执行后果：

34. 说说 this 对象的了解

35. 在 JavaScript 中什么是类（伪）数组，如何将类（伪）数组转换为规范数组

36. JavaScript 中的 callee 和 caller 的作用是什么

37. 统计字符串中字母的个数或统计最多的字母：

38. 写一个函数，革除字符串前后的空格

39. 写一个函数实现一个数组合并的办法

40. 工作中，罕用的逻辑运算符有哪些

41. 什么是事件代理（事件委托）

42. 什么是未声明和未定义的变量

43. 什么是全局变量，这些变量如何申明，应用全局变量有哪些问题

44. 罕用的定时器工作阐明，应用定时器的毛病

45. 说说 ViewState 和 SessionState 有什么区别

46. 什么是 === 运算符

47. JavaScript 中的循环构造有哪些

48. 在 JavaScript 中的 null 示意什么

49. delete 操作符的性能有什么

50. 在 JavaScript 中有哪些类型的弹出框

51. 常见的 void(0)的作用是什么

52. 什么是 JavaScript cookie

53. 解释 JavaScript 中的 pop()办法

54. 在 JavaScript 中，datatypes 的两个根本组是什么

55. typeof 是用来做什么的

56. 在 JavaScript 中，push 办法的作用是什么

57. 在 JavaScript 中，unshift 办法的作用是什么

58. 如何为对象增加属性

59. 说说 window.onload 和 onDocumentReady

60. 说说 for-in 循环

61. 说说 JavaScript 中的匿名函数

62. 说说一下事件冒泡

63. JavaScript 里函数参数 arguments 是数组吗

64. 什么是构造函数，它与一般函数有什么区别

65. 说说 split()与 join()函数的区别

66. 说说你对原型链, prototype 的了解

67. typeof 与 instanceof 的区别是什么

68. 说说事件流吧

69. 说说事件捕捉

70. 说说什么是回调函数

71. 什么是自执行函数，它有哪些利用场景，有什么益处

72. 什么是事件委托，有什么益处

73. 什么是强制类型转换，什么是隐式类型转换

74. NaN 是什么，它的类型是什么，如何牢靠地判断一个值是否等于 NaN

75. 什么是跨域

76. 以 YYYY-MM-DD 的形式，输入当天的日期，比方当天是 2020 年 1 月 1 日，则输入 2020-01-01

77. 用 JavaScript 随机选取 10 到 100 之间的 10 个数字，把它们存入一个数组中并排序

46. 什么是 `===` 运算符