标签：引用计数 浅拷贝 参数 合成 null 去掉 mvvm 返回 配置
this表示当前对象，this的指向是根据调用的上下文来决定的，默认指向window对象。
ES5的严格模式是采用具有限制性的Javascript变体的一种方式，从而使代码显式地脱离“马虎模式，懒散模式，稀松模式”，
严格模式对正常的Javascript语义做了一些修改。
调用严格模式：
严格模式可以应用到整个脚本或个别函数中。不能在{}中这样做，在这样的上下文中这么做会无效。
为整个脚本开启严格模式 ，需要在所有语句之前放一个特定语句“use strict”
// 脚本中的严格模式
"use strict";
var a = 'this is a strict mode script';要给某个函数开启严格模式，得把 "use strict"; (或 ‘use strict‘; )声明一字不漏地放在函数体所有语句之前。
// 函数中的严格模式
function strict(){
"use strict";
console.log("this is a strict mode script")
}在JavaScript中，每个函数都有自己的作用域。只有函数内部才能访问函数作用域内部的申明的变量，如果在函数内部使用没有申明的变量会产生隐式全局变量。同一个作用域的变量名必须是唯一的，一个作用域可以嵌套在另一个作用域内，如果当前作用域内没找到变量，则会向外层查找，如果在最外层也没有找到就会隐式创建全局变量。
在javascript中，只有函数内部的子函数才能读取局部变量，所以闭包可以理解成“定义在一个函数内部的函数“。在本质上，闭包是将函数内部和函数外部连接起来的桥梁。
利用事件冒泡机制处理指定一个事件处理程序，来管理某一类型的所有事件。
页面中一个li被点击，相当于其父元素ul，ul的父元素body，body的父元素都被点击。
既然如此，与其给100个li绑定100个事件，还不如给一个ul绑定一个事件，通过event.target来获取具体被点击的元素。
这就是事件委托。
null代表空值，undefined代表尚未初始化。
值类型：
引用类型：
事件冒泡就是嵌套在深层的元素触发一个事件，然后这个事件会顺着嵌套顺序在父元素上跟着触发。防止事件冒泡的方法是：Event.cancel.Bubble 或Event.stopPropagation
window.onload 是等文档和资源都加载完成后调用的事件，js获取元素的时候，已经加载。
作用域链是js中的一种查找机制，从当前作用域查找，当前作用域没有往上一级作用域查找，一直到最外层，如果都找不到则是is not define。
var nums = [223, 432432, 324, 34, 2, 3, 2432, 4, 23424, -3, 43, 3]
for(var i = 0, l = nums.length; i < l; i++){
for(var k = 0, g = nums.length; k < g; k++){
if(nums[k] > nums[k+1]){
var temp = nums[k]
nums[k] = nums[k +1]
nums[k+1] = temp
}
}
}<ol>
<li></li>
<li></li>
<li></li>
<li></li>
<li></li>
</ol>
console.log(document.querySelector('ol').children) <div>
<span></span>
</div>
console.log(document.querySelector('span').parentNode)
document.createElement('div)
document.TextNode('文本内容')var div = document.createElement('div')
box.appendChild(div)div.cloneNode(true)div.remove()
parentNode.removeChild(div)父节点.replaceChild(newChild, refChild)document.querySelector('#root')
document.querySelectorAll('li')window对象是js最大的对象，表示窗口包含document对象。
document是文档对象，，表示html
window.location.search
优点：
缺点：
// 1.创建对象
const ajax = new XMLHttpRequest()
// 2.建立链接
ajax.open('GET', 'http://status.164.red/200', true)
// 3.发送请求
ajax.send()
// ajax.send(json.data) // post请求时
// 4.监听结果
ajax.onreadystatechange = function(){
if(ajax.readyState === 4 || ajax.readyState === 200){
console.log(ajax.response)
}
}console.log(Object.prototype.toString.call(123)); //[object Number]
console.log(Object.prototype.toString.call('123')); //[object String]
console.log(Object.prototype.toString.call(undefined)); //[object Undefined]
console.log(Object.prototype.toString.call(true)); //[object Boolean]
console.log(Object.prototype.toString.call({})); //[object Object]
console.log(Object.prototype.toString.call([])); //[object Array]
console.log(Object.prototype.toString.call(function(){})); //[object Function]
console.log(Object.prototype.toString.call(null)); //[[object Null]]var arr = [1, 3, 5, 7, 10]
console.log( arr instanceof Array)同源策略指的是端口、域名、协议相同，同源策略是一种安全协议。
他们的作用都是用来申明变量的， let和const是ES6的规范。
区别如下：
Set类似于数组，成员是唯一的。是一种叫集合的数据结构。
var a = new Set()
a.add('hello') // Set { 'hello' }
// 去除重复
var arr = [1,1,2,3,4,6,5,2,4,0,4,2]
var arr2 = [... new Set(arr)] // [1, 2, 3, 4,6, 5, 0]// has方法的实现
function Set() {
let items = {};
this.size = 0;
// has(val)方法
this.has = function(val) {
// 对象都有hasOwnProperty方法，判断是否拥有特定属性
return items.hasOwnProperty(val);
};
}
// add方法的实现
this.add = function(val) {
let items = {};
this.size = 0;
if (!this.has(val)) {
items[val] = val;
this.size++; // 累加集合成员数量
return true;
}
return false;
};
// delete(val)方法的实现
this.delete = function(val) {
if (this.has(val)) {
delete items[val]; // 将items对象上的属性删掉
this.size--;
return true;
}
return false;
};
// clear方法的实现
this.clear = function() {
items = {}; // 直接将集合赋一个空对象即可
this.size = 0;
};
// keys()方法的实现
this.keys = function() {
return Object.keys(items); // 返回遍历集合的所有键名的数组
};
// values()方法的实现
this.values = function() {
return Object.values(items); // 返回遍历集合的所有键值的数组
};
// forEach(fn, context)方法
this.forEach = function(fn, context = this) {
for (let i = 0; i < this.size; i++) {
let item = Object.keys(items)[i];
fn.call(context, item, item, items);
}
};Map类似于对象，以键值对的形式存在。是一种叫字典的数据结构(key是有序的）。
Map的属性和方法：
map: 遍历数组，返回回调返回值组成的新数组
forEach: 无法break，可以用try/catch中throw new Error来停止
filter: 过滤
some: 有一项返回true，则整体为true
every: 有一项返回false，则整体为false
join: 通过指定连接符生成字符串
push / pop: 末尾推入和弹出，改变原数组， 返回推入/弹出项
unshift / shift: 头部推入和弹出，改变原数组，返回操作项
sort(fn) / reverse: 排序与反转，改变原数组
concat: 连接数组，不影响原数组， 浅拷贝
slice(start, end): 返回截断后的新数组，不改变原数组
splice(start, number, value...): 返回删除元素组成的数组，value 为插入项，改变原数组
indexOf / lastIndexOf(value, fromIndex): 查找数组项，返回对应的下标
reduce / reduceRight(fn(prev, cur)， defaultPrev): 两两执行，prev 为上次化简函数的return值，cur 为当前值(从第二项开始)Object是JavaScript中所有对象的父对象
数据封装对象：Object、Array、Boolean、Number和String
其他对象：Function、Arguments、Math、Date、RegExp、Error
为什么要组件化？
有时候页面代码量太大，逻辑太多或者同一个功能组件在许多页面均有使用，维护起来相当复杂，这个时候，就需要组件化开发来进行功能拆分、组件封装，已达到组件通用性，增强代码可读性，维护成本也能大大降低。
组件化开发的优点
很大程度上降低系统各个功能的耦合性，并且提高了功能内部的聚合性。这对前端工程化及降低代码的维护来说，是有很大的好处的，耦合性的降低，提高了系统的伸展性，降低了开发的复杂度，提升开发效率，降低开发成本。
组件化开发的原则
模块化的好处
模块化的几种方法
var myModule = {
var1: 1,
var2: 2,
fn1: function(){
},
fn2: function(){
}
}
复制代码
总结：这样避免了变量污染，只要保证模块名唯一即可，同时同一模块内的成员也有了关系
缺陷：外部可以随意修改内部成员，这样就会产生意外的安全问题
复制代码var myModule = (function(){
var var1 = 1;
var var2 = 2;
function fn1(){
}
function fn2(){
}
return {
fn1: fn1,
fn2: fn2
};
})();
复制代码
总结：这样在模块外部无法修改我们没有暴露出来的变量、函数
缺点：功能相对较弱，封装过程增加了工作量，仍会导致命名空间污染可能、闭包是有成本的mouseover：当鼠标移入元素或其子元素都会触发事件，所以有一个重复触发，冒泡的过程。对应的移除事件是mouseout
mouseenter：当鼠标移除元素本身（不包含元素的子元素）会触发事件，也就是不会冒泡，对应的移除事件是mouseleave
标签：引用计数 浅拷贝 参数 合成 null 去掉 mvvm 返回 配置
原文地址：https://www.cnblogs.com/liea/p/12515041.html
