tomoya06
commented
4 years ago 面向对象
概述
面向对象程序设计（英语：Object-oriented programming，缩写：OOP）是一种具有对象概念的程序编程典范，同时也是一种程序开发的抽象方针。
面向对象的三大特性
- 封装：把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。
- 继承：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。通过继承创建的新类称为“子类”或“派生类”，被继承的类称为“基类”、“父类”或“超类”。
- 多态：允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。实现多态的方法有重写(Overriding)和重载(Overloading)。
重写 vs 重载
Java代码示例参考菜鸟教程
- 重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写。
- 重载是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。
原型
- 每个函数都有
prototype属性，该属性指向原型。特例Function.prototype.bind()也是函数，但没有prototype属性。 - 每个对象都有
__proto__属性，指向了创建该对象的构造函数的原型。其实这个属性指向了[[prototype]]，但是[[prototype]]是内部属性，我们并不能访问到，所以使用__proto__来访问。
下面总结来自这里
Object是所有对象的爸爸，所有对象都可以通过__proto__找到它Function是所有函数的爸爸，所有函数都可以通过__proto__找到它Function.prototype和Object.prototype是两个特殊的对象，他们由引擎来创建- 除了以上两个特殊对象，其他对象都是通过构造器 new 出来的
- 函数的
prototype是一个对象，也就是原型 - 对象的
__proto__指向原型，__proto__将对象和原型连接起来组成了原型链
function Foo() {}
foo = new Foo()
foo.__proto__ === Foo.prototype // => truenew
过程
- 新生成一个空对象
- 链接到原型：把新对象的
__proto__链接到构造函数的prototype - 绑定
this到这个空对象并执行构造函数 - 返回新对象
模拟实现：
function create() {
// 创建一个空的对象
let obj = new Object()
// 获得构造函数。别忘了arguments是类数组
let Con = [].shift.call(arguments)
// 链接到原型
obj.__proto__ = Con.prototype
// 绑定 this，执行构造函数
let result = Con.apply(obj, arguments)
// 确保 new 出来的是个对象
return typeof result === 'object' ? result : obj
}由此可见，如果在new函数中加了return：如果return值类型，那么对构造函数没有影响，实例化对象返回空对象；如果return引用类型（数组，函数，对象），那么实例化对象就会返回该引用类型；
instanceof
instanceof 可以正确的判断对象的类型，因为内部机制是通过判断对象的原型链中是不是能找到类型的 prototype
模拟实现：
function instanceof(left, right) {
// 获得类型的原型
let prototype = right.prototype
// 获得对象的原型
left = left.__proto__
// 判断对象的类型是否等于类型的原型
while (true) {
if (left === null)
return false
if (prototype === left)
return true
left = left.__proto__
}
}this
- JS中的this代表的是当前行为执行的主体
- this实际上是在函数被调用时发生的绑定，它指向什么完全取决于函数在哪里被调用。
- 箭头函数的this看外层的是否有函数，如果有，外层函数的this就是内部箭头函数的this，如果没有，则this是window
判断方法
- 当函数被当做构造函数使用，又new引导调用时，this只想new创建出来的对象。（new绑定）；
- 函数通过apply,call,bind绑定时，this指向绑定的对象。（显式绑定）
- 当函数由一个对象引导调用时，this指向该对象。（隐式绑定）
- 当函数在没有任何修饰的情况下调用，非严格模式下，this指向window，严格模式下this指向undefined。（默认绑定）
优先级为：new绑定 > 显示绑定 > 隐式绑定 > 默认绑定；
call、apply和bind
都是可以用来改变方法执行时this的指向。call和apply立即执行，但取参数的方法不同；bind只是改变指向并返回新的方法。
//在非严格模式下
var obj={ name: "new name" };
function fn(num1, num2){
console.log(num1+num2);
console.log(this);
}
fn.call(100,200); //this->100 num1=200 num2=undefined
fn.call(obj,100,200); //this->obj num1=100 num2=200
fn.call(); //this->window
fn.call(null); //this->window
fn.call(undefined); //this->window
//严格模式下
fn.call(); //在严格模式下this->undefined
fn.call(null); // 在严格模式 下this->null
fn.call(undefined); //在严格模式下this->undefined
// call() vs apply() 传参方式不同
fn.call(obj, 1, 2);
fn.apply(obj, [1, 2]);
fn.call(obj,1,2); //->改变this和执行fn函数是一起都完成了
fn.bind(obj,1,2);
var tempFn = fn.bind(obj,1,2); //->只是改变了fn中的this为obj并传递参数，但是此时并没有把fn这个函数执行
tempFn(); //这样才把fn这个函数执行模拟实现：有点底层了，这里先忽略。参考这里
继承
听说有六种继承方式。优缺点参考这里
初始化：
//父类型
function Person(name, age) {
this.name = name,
this.age = age,
this.play = [1, 2, 3]
this.setName = function () {}
}
Person.prototype.setAge = function () {}
//子类型
function Student(price) {
this.price = price
this.setScore = function () {}
}原型链继承
Student.prototype = new Person() // 子类型的原型为父类型的一个实例对象
Student.prototype.sayHello = function () { }借助构造函数
Person.prototype.setAge = function () {}
function Student(name, age, price) {
Person.call(this, name, age) // 相当于: this.Person(name, age)
// 其他初始化...
}
Student.prototype.sayHello = function () { }原型链+构造函数
下面几种关键差异在于如何延长原型链：
// begin
// 方法1：
Student.prototype = new Person()
Student.prototype.constructor = Student //组合继承也是需要修复构造函数指向的
// 方法2：
Student.prototype = Person.prototype
// 方法3：
Student.prototype = Object.create(Person.prototype)
Student.prototype.constructor = Student
// end
Student.prototype.sayHello = function () { } ES6语法
class Person {
//调用类的构造方法
constructor(name, age) {
this.name = name
this.age = age
}
//定义一般的方法
showName () {
console.log("调用父类的方法")
console.log(this.name, this.age);
}
}
let p1 = new Person('kobe', 39)
console.log(p1)
//定义一个子类
class Student extends Person {
constructor(name, age, salary) {
super(name, age)//通过super调用父类的构造方法
this.salary = salary
}
showName () {//在子类自身定义方法
console.log("调用子类的方法")
console.log(this.name, this.age, this.salary);
}
}
语法基础
数据类型
参考MDN文档
typeof
类型转换
转Boolean
转自MDN：对Symbol.toPrimitive的更多用法
四则运算
one more thing...
双等号比较
分析：
[] == ![] // => true