JavaScript理论篇1之基础理论

1、JS面向对象的理解
1）一切皆对象，类是对象的一个抽象集合，对象是类的实例化
2）面向对象三大特征：封装，继承，多态
1】封装
关于属性和方法，封装在函数里面，外部不可见，感知不到
2】继承
es6之前没有类的概念，是通过原型链来实现继承，es6通过class实现继承
3】多态（覆盖、重载）
定义：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果
a、覆盖（子类重写父类方法）
原型链上面的同名函数（方法），子类会覆父类的
b、重载
同一函数，参数不同（个数和类型），执行结果不同
JS没有严格意义上的重载，需要通过其他手段去实现，比如通过arguments对象去判断

*注：函数重载（多态的一种体现）
函数名相同，函数的参数不同(包括参数个数和参数类型)，根据参数的不同去执行不同的操作
注意：JavaScript 中没有真正意义上的函数重载
1）通过 arguments 对象来实现
arguments 对象，是函数内部的一个类数组对象，它里面保存着调用函数时，传递给函数的所有参数。
function overload () {
if (arguments.length === 1) {
console.log(‘一个参数’)
}
if (arguments.length === 2) {
console.log(‘两个参数’)
}
}
overload(1); //一个参数
overload(1, 2); //两个参数

2）jQuery 中的 css( ) 方法
jQuery 的 css( ) 方法就是通过判断参数的类型，来确定执行什么操作

3）总结
虽然 JavaScript 并没有真正意义上的重载，但是重载的效果在JavaScript中却非常常见，比如 数组的 splice( )方法，一个参数可以删除，两个参数可以删除一部分，三个参数可以删除完了，再添加新元素。 再比如 parseInt( )方法 ，传入一个参数，就判断是用十六进制解析，还是用十进制解析，如果传入两个参数，就用第二个参数作为数字的基数，来进行解析

2、JS变量提升
1】定义
JS引擎在读取JS代码时，会先通篇扫描所有的代码，然后把所有声明变量声明提升到当前执行环境的最顶端。全局变量提升至该组件的最顶部，函数变量提升至函数的最顶部。
2】例子
var test = “outside”;
function f1() {
console.log(test); //undefined
if (false) {
var test = “inside”;
}
console.log(test); //undefined
}
function f2() {
console.log(test); //undefined
var test = “inside”;
console.log(test); //inside
}

3、JS函数提升
类似变量，函数声明也会被提升至代码顶部。
1）JS中，函数是第一公民。函数提升优先级比变量提升还高。
2）函数声明才会提升，函数表达式则不会。
3）如果是两个函数声明，出现在后面的函数声明可以覆盖前面的。
function t1(age) {
console.log(age);
var age = 27;
console.log(age);
function age() {}
console.log(age);
}
t1(3);
等价于：
function t1(age) {
var age = function () {}
console.log(age);
var age = 27;
console.log(age);
console.log(age);
}

4、JS类型的隐式转换和显式转换
1】隐式转换（弱类型的标志之一）
不同数据类型的数据运算时，会进行一个隐式的转换
1）字符串和数字
“+” 操作符，如果有一个为字符串，那么都转化到字符串然后执行字符串拼接
“-” 操作符，转换为数字，相减 (-a, a * 1 a/1) 都能进行隐式强制类型转换
[] + {} 和 {} + []
2）布尔值到数字
1 + true = 2
1 + false = 1
!! 运算符可以将右侧的值强制转换为布尔值，这也是将值转换为布尔值的一种简单方法

2】显式转换
显示转换一般指使用Number、String和Boolean三个构造函数，手动将各种类型的值，转换成数字、字符串或者布尔值。
Number(‘’) // 0
Number(true) // 1
Number(null) // 0
Number(undefined) // NaN
3】等于 和 严格等于
== 在表达式两边的数据类型不一致时,会隐式转换为相同数据类型,然后对值进行比较。
=== 不会进行类型转换,在比较时除了对值进行比较以外,还比较两边的数据类型。
===的缺陷：===的NaN不等于自身，以及+0等于-0（用es6的Object.is()解决）
4】小例子
a、如何让 (a == 1 && a == 2 && a == 3) 的值为true？
let a = [1,2,3]
a.join = a.shift
b、把字符串型的数字转化为真正的数字

• parseInt：
  parseInt() 函数可解析一个字符串，并返回一个整数
  parseInt(“10”); //返回 10
  parseInt(“19”,10); //返回 19 (10+9)
• Number
• 通过运算来转换：
  js的弱类型的特点，只进行了算术运算，实现了字符串到数字的类型转换

5、null、NaN和undefined的区别
未定义的值和定义未赋值的为undefined
null表面上代表空对象，null是一种特殊的object
NaN是一种特殊的number
undefined与null是相等（严格=的时候不相等）；NaN与任何值都不相等，与自己也不相等
**undefined 与 undeclared 的区别？
已在作用域中声明但还没有赋值的变量，是undefined。相反，还没有在作用域中声明过的变量，是 undeclared 的。

6、js判断数据类型
1】typeof

能判断：number、boolean、symbol、string、object、undefined、function
缺陷：判断引用类型，除了function返回function类型外，其他均返回object
判断Array和null都返回object
2】toString（较为完美的判断方法）
toString() 是 Object 的原型方法，调用该方法，默认返回当前对象的 [[Class]] 。这是一个内部属性，其格式为 [object Xxx] ，其中 Xxx 就是对象的类型
Object.prototype.toString.call(‘’) ; // [object String]
Object.prototype.toString.call(1) ; // [object Number]
Object.prototype.toString.call(true) ; // [object Boolean]
Object.prototype.toString.call(Symbol()); //[object Symbol]
Object.prototype.toString.call(undefined) ; // [object Undefined]
Object.prototype.toString.call(null) ; // [object Null]
Object.prototype.toString.call(new Function()) ; // [object Function]
Object.prototype.toString.call(new Date()) ; // [object Date]
Object.prototype.toString.call([]) ; // [object Array]
Object.prototype.toString.call(new RegExp()) ; // [object RegExp]
Object.prototype.toString.call(new Error()) ; // [object Error]
Object.prototype.toString.call(document) ; // [object HTMLDocument]
Object.prototype.toString.call(window) ; //[object global] window 是全局对象 global 的引用
3】instanceof
原理：instanceof 可以判断一个引用是否属于某构造函数；另外，还可以在继承关系中用来判断一个实例是否属于它的父类型。
instanceof的判断逻辑是： 从当前引用的proto一层一层顺着原型链往上找，能否找到对应的prototype。找到了就返回true。
instanceof 是用来判断 A 是否为 B 的实例，表达式为：A instanceof B，如果 A 是 B 的实例，则返回 true,否则返回 false，例如：
1 instanceof Number
true instanceof Boolean
运行机制：
假设现在有 x instanceof y 一条语句，则其内部实际做了如下判断：
while(x.proto!==null) {
if(x.proto===y.prototype) {
return true;
}
x.proto = x.proto.proto__;
}
if(x.proto==null) {return false;}
复制代码
x会一直沿着隐式原型链__proto__向上查找直到x.proto.proto…===y.prototype为止，如果找到则返回true，也就是x为y的一个实例。否则返回false，x不是y的实例。
4】constructor属性
查看对象对应的构造函数
object的