人，工人
//类的定义
function Person(name,age){ //构造函数
//工厂模式
//1.原料
//var obj = new Object();
//2.加工
this.name = name;
this.age = age;
//3.出厂
//return obj;
}
//方法
Person.prototype.showName = function(){
return this.name;
};
//实例化
var p1 = new Person('zhangsan',28);
new:
1. 创建一个新的空白对象
2. 把这个对象赋值给 this
3. 自动返回this
//继承 工人 -> 人
1)继承属性
function Worker(name,age,job){
//继承父类属性
Person.apply(this,arguments);
//增加自己的属性
this.job = job;
}
2)继承方法
Worker.prototype = new Person();
Worker.prototype.constructor = Worker;
* 万物皆对象
* 能new的东西都是函数
* 构造函数约定首字母大写
* 实例化一个类的时候（new Person()），构造函数自动执行
* 类的原型 prototype 可以用来扩展系统方法
* 解决this:
1) 在this正确的地方，存一下
2) fn.call(this的指向，参数1...);
3) fn.apply(this的指向，[参数1....]);
4) bind
var a = fn.bind(this的指向，参数1);
a(参数2);
//this 正确
oBtn.onclick = function(){
//this 指向按钮，希望指向外面
}.bind(this);
* 类型检测
1） typeof ： 基本类型
数字，字符串，布尔，undefined
2）instanceof : 用于检测 当前对象是不是某个类的实例， 包含父级以及一直向上
alert(p1 instanceof Person); √
alert(p1 instanceof Object); √
3）constructor：用户判断当前对象的是不是由某个类构造出来的
p1.constructor == Person
==========================
一、ES6前面向对象周边的知识
1、给一个类的原型上加方法时，要一个一个加，不能用一个JSON整体覆盖，否则，会把原来已经有的东西覆盖掉（prototype.constructor 被覆盖）
2、原型链
使用某个方法或属性时，先看自己有没有，如果自己有就用自己的，否则找父级...一直找到为止 —— Object
* 如果一个对象属于子类，那么这个对象必然属于这个子类的父类。
* 作用链：
var c = 100;
function aaa(){
var c = 5;
function bbb(){
//var c = 12;
alert(c);
}
bbb();
}
aaa();
show(1)(2)(3); —— 6 //返回函数
aa(1).bb(2).cc(3); —— 6 //返回JSON
3、所有东西都是对象？
基本类型不是对象。
除了基本类型外，其它的东西都是对象。
包装类型：
数字 Number
字符串 String
布尔 Boolean
undefined Undefined ×
* 包装类型，在JS中，没用。
4、单体模式/单例模式 设计模式
以前： 工厂模式
* 只有一个实例，不能扩展 —— 利用 JSON
let Person = {
name:'张三',
age:18,
showName(){
return this.name + '^_^';
}
};
5、命名空间
利用JSON,把一些独立的模块、频道、子系统 ，中使用的变量的包起来。
达到： 避免变量名冲突
例：
let top = {
a:12
}
let body = {
a:5
}
let footer = {
a:20
}
top.a
body.a
footer.a
变量冲突的解决：
1、封闭空间
2、面向对象 ： 把相同的变量放到不同的对象里
3、命名空间（名称空间）
4、模块化
6、this 的问题
this: 发生事件的对象（元素），当前方法属于谁，this就是谁
对this优先级进行排序：只供参考
1） new > 定时器
2） 定时器 > 事件
3） 事件 > 方法
4） 其它 （window）
优先级： new > 定时器 > 事件 > 方法
7、js 中的 BUG （自相矛盾的地方）
1、Object 和 Function 互为爹，自称爹
* 一切都是对象
* 能new 都是函数
2、只认爹，不认爷
3、花祖宗的钱，不认祖宗
==========================
二、ES6面向对象
类、构造函数 —— 面向对象(java)
类：
定义——
//类
class Person{
//构造函数
constructor(name,age){
this.name = name;
this.age = age;
}
//方法
showName(){
return this.name;
}
showAge(){
return this.age;
}
}
使用——
let p1=new Person('zhang3',28);
继承：
class Worker extends Person{
constructor(name,age,job){
super(name,age); //相当于调用 父级 的构造函数
this.job = job;
}
showJob(){
return this.job;
}
}
*super —— 超类
==========================
用面向对象的方式写程序 ， 没有统一的写法。
例1：点div变红
例2：选项卡
==========================
模块化：
一、什么，为什么
模块化：把一个大的系统，一个较复杂的功能，切分为若干个小部分。
有利于 系统的扩展、人员之间分工合作、可以提高效率...
二、JS中模块化：
09年，美国，一哥们，写了一个程序 —— NodeJS
标志着JS中模块化开发的开始。
三、JS中模块化遵循的标准：
CommonJs： NodeJS —— 同步
const express = require('express');
let server = express();
AMD: —— 异步
Asynchronous Module Definition 异步模块定义
库：requirejs
CMD：
库：seajs
官网： seajs.org
四、requirejs
安装：
1) 官网下载
http://requirejs.org/
2) npm i requirejs