javascript_继承_JSON_ZHOU125disorder_

继承

 面向对象实现继承的几种方式：
        继承：继承父级样式
        1.原型链继承
        2.构造函数继承
        3.组合继承

原型链继承

// 核心：将父类的实例作为字类的原型
// 缺点：父类新增原型方法/属性，字类都可以访问到，父类一变，其他的都变了

        function Person(name){
            this.name = name;
        }
        Person.prototype.getName = function(){
            return this.name;
        }
        // var person = new Person("卡卡西");
        // console.log(person.getName());  //卡卡西
        // 新的构造函数
        function Parent(age){
            this.age = age;
        }
        Parent.prototype = new Person("鞠婧祎");      //关键  通过构造函数创建一个新的对象，并赋值给新构造函数的原型
        Parent.prototype.getAge = function(){
            return this.age;
        }
        Parent.prototype.getName = function(){
            return "薛之谦";
        }
        var parent = new Parent(18);
        console.log(parent.getAge());   //18
        console.log(parent.getName());  //薛之谦

构造函数继承

        // 构造函数继承(和原型没有关系)
        // 借用构造函数的思想利用call或者apply把父类中通过this指定的属性和方法复制过来
        // 核心：使用父类的构造函数来增强字类实例，等于是复制父类的实例属性给字类
        // 缺点：方法都是在构造函数中定义，只能继承父类的实例属性和方法，不能继承原型属性和方法，无法实现函数复用，影响性能

        function Person(name){
            this.name = name;
            this.word = ["火影","风影"];
            this.getName = function(){
                return this.name;
            }
        }
        function Parent(age){
            Person.call(this,"卡卡西");       //关键          复制Person的属性和方法
            this.age = age;
        }
        var parent = new Parent(30);    
        console.log(parent.age);        //本身的    30
        console.log(parent.name);       //复制Person    卡卡西
        console.log(parent.word);       //0: "火影" 1: "风影"
        console.log(parent.getName());  //卡卡西

组合继承

        // 组合继承
        // 所有实例都能拥有自己的属性，并且可以使用相同的方法，通过上面的两种方式结合体，结合了两者有点，也是最常用的继承方式
        // 核心：通过调用父类的构造，继承父类的属性并保留传参的优点，然后再通过将父类实例作为字类的原型，实现函数复用

        function Person(name){
            this.name = name;
            this.word = ["火影","风影"];
        }
        // 原型方法
        Person.prototype.getName =  function(){
            return this.name;
        }
        function Parent(age){
            Person.call(this,"卡卡西");       //构造函数继承
            this.age = age;
        }
        // 原型链继承
        Parent.prototype = new Person("卡卡西");
        var parent = new Parent(18);
        console.log(parent.name);   //卡卡西
        console.log(parent.word);   //array
        console.log(parent.age);    //18
        console.log(parent.getName());  //卡卡西
        parent.word.push("水影");   
        console.log(parent.word);   //array

JSON

        // JSON是一种轻量级的数据格式
        // 用来存储的表示数据的
        // JSON并不是js当中独有的数据格式
        // JSON的语法可以表示3种类型的值
        // 1.简单值 2.对象 3.数组
        // 包括字符串，数值，布尔值，null不包含特殊值undefined
        // "卡卡西"       最简单的JSON的表示方法

普通形式

        var person = {
            name:"卡卡西",
            age:30
        }

JSON表示方法

 		'{"name":"卡卡西","age":"30"}'
        '["卡卡西",30,true]'
        // 一般情况下，JSON的结构是一种复杂形式，也就是数组结合对象的形式
        var json = '[{"name":"李华","age":"18"},{"name":"韩梅梅","age":"20"},{"name":"李雷","age":"22"}]'

序列化和反序列化

        // 就是指JSON格式的数据和普通数组对象格式的来回转换
        // 序列化：如果是原生的js值，也就是原生的数组对象，可以转换成JSON字符串
        // 反序列化：加载好的JSON文件，转成可以正常解析的原生js值，也就是数组对象

序列化

        var json = [{"name":"李华","age":"18"},{"name":"韩梅梅","age":"20"},{"name":"李雷","age":"22"}]
        JSON.stringify()
        console.log(JSON.stringify(json));
        console.log(typeof JSON.stringify(json));
      	// JSON.stringify()提供了第二个参数，可以是数组，也可以是函数，用于过滤,也提供了第三个参数，过滤排版
		console.log(JSON.stringify(json,["name"]));
        console.log(JSON.stringify(json,function(key,value){
            if(key=="name"){
                return "Mr."+value;
            }else{
                return value;
            }
        }))
        var txt = JSON.stringify(json,["name","age"],~);
        var txt = JSON.stringify(json,["name","age"],"@");
        console.log(txt);

反序列化/解析

JSON.parse

         console.log(JSON.parse(json));
         console.log(typeof JSON.parse(json));