函数——面向对象（oop&&构造函数&原型链）

    <script>
        var person = {
            name: ‘davina‘,
            age: 20,
            play: function () {
                console.log(‘write code‘);
            }
        }
        console.log(person); //{name: "davina", age: 20, play: ƒ}

        person.heigth = ‘170CM‘;
        console.log(person);  //{name: "davina", age: 20, heigth: "170CM", play: ƒ}
    </script>

function Fn(){
    //......
}
let f = new Fn();//Fn是类，f是类的一个实例
console.log(f);
let f2 = new Fn();//f2也是Fn的一个实例，f2和f是独立分开的

function Func() { }
let f = Func();
console.log(f);//undefined

/* 
 *把它当做是普通函数执行(形成私有上下文，初始化作用域链，初始化this，初始化arguments,形参赋值，变量提升，代码执行......)
  *f获取的是函数的返回结果（函数中没有return,所以f为undefined）
 *
 */
function Func() { }
let f = new Func();
console.log(f);//Func{}
/* 
 * 这是构造函数执行，当做类来执行，此时Func被称为是‘类‘，返回的结果（f）被称为当前‘类’的一个‘实例’，它是一个实例对象
 */

function Func(x, y) {
    // num只是当做普通函数执行的时候，给私有上下文中设置的私有变量，和实例对象没有关系，只有this是实例对象，所以this.XXX=XXX才和实例有关系
    let num = x + y;
    this.x = x;
    this.y = y;

    // return {
    //     name: ‘xxx‘
    // }; //=>返回基本类型值,f2依然是创建的实例对象；如果自己返回的就是一个引用值，一切以自己返回的为主，此时的f2={name:‘xxx‘}而不再是当前类的实例了
}
let f2 = new Func(10, 20);
console.log(f2);

//语法：实例 instanceof 类 返回boolean类型
f2 instanceof (Func);

/* 
 * 函数数据类型：普通函数、类（内置类/自定义类）、箭头函数  => 都是Function的实例
 * 对象数据类型：普通对象、数组对象、正则对象、日期对象、实例对象、函数对象（函数也是一个对象，也像普通对象一样，有自己的键值对）、类的prototype也是对象  => 都是Object的实例
 */
function Fn() {
    this.x = 100;
    this.y = 200;
    this.getX = function () {
        console.log(this.x);
    }
}
Fn.prototype.getX = function () {
    console.log(this.x);
}
let f1 = new Fn();
console.log(f1.getX === Fn.prototype.getX);
console.log(f1.getX());
console.log(f1.__proto__.getX());

function fun(){
    this.a=0;
    this.b=function(){
        alert(this.a);
    }
}
fun.prototype={
    b:function(){
        this.a=20;
        alert(this.a);
    },
    c:function(){
        this.a=30;
        alert(this.a)
    }
    fun.prototype.constructor = fun;
}
var my_fun=new fun();
my_fun.b();
my_fun.c();

String.prototype.queryURLParams = function queryURLParams(key) {
    // this -> 当前要处理解析的URL
    let obj = {};
    this.replace(/([^?&=#]+)=([^?&=#]+)/g, (_, $1, $2) => obj[$1] = $2);
    this.replace(/#([^?&=#]+)/g, (_, $1) => obj[‘_HASH‘] = $1);
    return typeof key === "undefined" ? obj : obj[key];
};
let url = "https://support.google.com/chrome/?p=help&ctx=keyboard";
let result = url.queryURLParams();
console.log(result);

String.prototype.indexOf = function indexOf() {
    return ‘OK‘;
};
console.log(url.indexOf(‘?‘));

(function () {
    function handleNum(num) {
        num = Number(num);
        return isNaN(num) ? 0 : num;
    }
    Number.prototype.plus = function plus(num) {
        num = handleNum(num);
        return this + num;
    };
    Number.prototype.minus = function minus(num) {
        num = handleNum(num);
        return this - num;
    };
})();

let n = 10;
let m = n.plus(10).minus(5);
console.log(m); //=>15

// obj.__proto__=Object.prototype;
// func是可枚举的属性了
Object.prototype.func = function func() {};
let obj = {
    name: ‘davina‘,
    age: 18
};
for (let key in obj) {
    // 在遍历的时候，对于原型上扩展的公共属性方法，我们过滤掉，只遍历对象中私有的属性方法（必须是可枚举的）
    if (!obj.hasOwnProperty(key)) break;
    console.log(key);
} 

    <!-- <script>
       class name[extends]{
           //calss body
       }
       extends为继承，是个可选的参数
    </script> -->

    <script>
        //es6的写法  创建一个Person类
        class Person {
            //类的共有属性放到constructor中
            constructor(name, age) {
                this.name = name;
                this.age = age;  //共享属性
            }
            say() {          //共享方法  自动放在prototype
                console.log(‘人可生如蚁而美如神!‘)
            }
        }

        //利用类创建对象
        const [person1, person2] = [new Person(‘davina‘, 20), new Person(‘lisa‘, 21)];  //这是两个实例
        person1.sex = ‘male‘;

        console.log(
            typeof Person,  //function 构造函数，虽说是类，但本质上还是构造函数
            Person.prototype.constructor === Person,  // true  
            person1.__proto__ === Person.prototype, // true
            person1 instanceof Person,  //true
            person2.constructor == Person,  ///true
            Object.getOwnPropertyNames(person1),//  ["name", "age", "sex"]  找实例身上自己的属性   
            person1.hasOwnProperty(‘say‘), //false  say是放在prototype里，继承而来，并不是实例身上自有的
            Object.keys(Person.prototype),  //  [] 内置身上的方法一般是不可以被枚举
        )

        // class Person{}    //SyntaxError: Identifier ‘Person‘ has already been declared   不能重复的声明

        //构造函数和实例放在一起
        const MyPerson = new class {
            move() {
                console.log(12);
            }
        }
        MyPerson.move(); //12
    </script>