[duyi]171130 继承、枚举、克隆

最新推荐文章于 2024-05-29 22:28:54 发布
最新推荐文章于 2024-05-29 22:28:54 发布
阅读量248 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/simpleone_/article/details/78675884
版权

tips1.继承方式

  1. 1原始继承方式
Event.prototype.say = function() {
    console.log('say');
}

function Event() {
    var a = 10;
    this.type = 'function';
}

Http.prototype = new Event();

function Http() {

}
var oHttp = new Http();
console.log(oHttp.type);


 - 过多的继承无用的属性
  1. 2.借用构造函数
function Person(name, age, sex) {
   this.name = name;
   this.age = age;
   this.sex = sex;
}
var oPerson = new Person();
function Student(name, age, sex, grade, clas) {
   // creative this {} 

   // this.name = name;
   // this.age = age;
   // this.sex = sex;
   Person.call(this, name, age, sex); 
   this.grade = grade;
   this.clas = clas;
   //return this;
}
var oStudent = new Student('yp', 18, 'man', 3, 3);

 - 不能继承借用构造函数的原型
 - 每次构造函数都要多走一个函数
  1. 3共享原型
Event.prototype.say = function() {
    console.log('say');
}
Event.prototype.show = function(){
}
function Event() {
    var a = 10;
    this.type = 'function';
    this.show();
}

Http.prototype = Event.prototype;
Http.prototype.show = function(){
}
function Http() {

}
var oHttp = new Http();
console.log(oHttp.type);

 - 虽然不会继承多余属性
 - 但是由于对象是引用值，因此下游改变会影响上游
  1. 4圣杯模式
Father.prototype.lastName = 'Deng';

function Father() {

}

function Son() {
   this.girlFriend = 'ab';

}
Event.prototype.say = function() {}

function Event() {

}

function Http() {
   this.status = 200;
}
var inherit = (function() {
   var Cache = function() {
       //生成闭包
   };
   return function(Target, Origin) {
       Cache.prototype = Origin.prototype;
       Target.prototype = new Cache();
       Target.prototype.constructor = Target;
       Target.prototype.uber = Origin;
   }
})();
inherit(Son, Father);
inherit(Http, Event);

这里写图片描述

tips2.命名空间

  • 管理变量， 防止污染全局， 适用于模块化开发
  • 命名空间已经不使用
  • 防止代码污染 有效方式： 立即执行函数， 封闭作用域
(function() {
     var message = 'red div';
     topDiv.onclick = function() {
         alert(message);
     }
})();

这里写图片描述

tips3.链式调用

var mrDeng = {
    health: 100,
    smoke: function() {
        this.health -= 5;
        return this;
    }, 
    drink: function() {
        this.health -= 4;
        return this;
    },
    perm: function() {
        this.health += 2;
        return this;
    }
}
mrDeng.smoke().drink().perm(); //链式调用
// 返回值.drink().perm();
// 我们返回一个对象，刷新后的mrDeng继续调用后面的方法 return (新的)this--(mrDeng)
  • mrDeng是一个对象，然后链式的执行方法，其中的原理很简单，就是执行完一个方法之后就返回对象本身
 var prop = 'wife1';
 var mrDeng = {
     wife1: 'xiao 1',
     wife2: 'xiao 2',
     wife3: 'xiao 3',
     wife4: 'xiao 4',
     sayWife: function() {
         document.write('my wife' + this.prop);
     }
 };
 mrDeng.sayWife();
  • 输出结果是【my wifeundefined】
  • this.prop 相当于 this[‘prop’]
  • 对象内没有这个属性字符串
  • this[prop]
var prop = 'wife1';
var mrDeng = {
    wife1: 'xiao liu',
    wife2: 'xiao wang',
    wife3: 'xiao lang',
    wife4: 'xiao gei',
    saywife: function(num) {
        // document.write('我的老婆是' + this['wife' + num]);
        //mrDeng.wife2 -> mrDeng['wife2']   this.wife2 -> this['wife2']
        document.write('我的老婆是' + this.prop);
        document.write('我的老婆是' + this['prop']);
        //this.prop -> this['prop'] 字符串prop和变量prop
        document.write('我的老婆是' + this[prop]); 
    }
}
mrDeng.saywife(3);

tips4.对象枚举

  • for _ in _ （枚举遍历所有属性）
var mrDeng = {
        son: 'mini Deng',
        wife: 'miss liu',
        age: 40,
        sex: 'male',
        __proto__: {
            company: 'DUYI',
            car: 'oooo'
        }
    }
for (var prop in mrDeng) {
    console.log(prop);
    console.log(prop, mrDeng[prop]);
}

这里写图片描述

  • hasOwnProperty (判断是否是自己的属性)
var mrDeng = {
    son: 'mini Deng',
    wife: 'miss liu',
    age: 40,
    sex: 'male',
    __proto__: {
        company: 'DUYI',
        car: 'oooo'
    }
}
for (var prop in mrDeng) {
console.log(prop, mrDeng[prop], mrDeng.hasOwnProperty(prop));

这里写图片描述

  • in（判断是否是自己以及原型链中的属性）
var mrDeng = {
    son: 'mini Deng',
    wife: 'miss liu',
    age: 40,
    sex: 'male',
    __proto__: {
        company: 'DUYI',
        car: 'oooo'
    }
}
for (var prop in mrDeng) {
    console.log(prop in mrDeng);
}

这里写图片描述

  • instanceof（看一下A的原型链上有没有B的原型）
function A() {

}
var oA = new A();
console.log(oA instanceof A);

var b = [];

console.log(b.constructor);
console.log(b instanceof Array);
console.log(b instanceof Object);
// A(对象的原型链上) instanceof(有没有)  B(构造函数的原型)  
// 看一下A的原型链上有没有B的原型
// 跨域不适用

这里写图片描述

  • caller & callee
  • caller(调用者)返回一个函数的引用，这个函数调用了当前的函数;
  • callee放回正在执行的函数本身的引用，它是arguments的一个属性
var num = (function(n) {
    if (n == 1 || n == 2) {
        return 1;
    }
    return arguments.callee(n - 1) + arguments.callee(n - 2);
})(7);
  • 递归

这里写图片描述

tips5.克隆

  • 浅层克隆
var mrChen = {
    name: 'cst',
    age: 18,
    sex: 'man',
    girlFriend: {
        name: 'zly',
        age: 28
    },
    height: 183
}
var obj = {};

function clone(target, origin) {
    for (var prop in origin) {
        target[prop] = origin[prop];
    }
}
clone(obj, mrChen);
obj.girlFriend.name = 'zzt';

//这种克隆存在弊端。原始对象的引用值地址给了克隆体，克隆体改变值会影响原始值

  • 深层克隆

    1.判断是不是原始值，如果是引用值，地址给了你，大家都可以改变 
    2.判断是数组还是对象 
    3.如果是建立在相应的数组或对象 反之直接copy 
    4.如果上述建立了数组或对象，对此我们再次深度拷贝

var mrChen = {
    name: 'cst',
    age: 18,
    sex: 'man',
    girlFriend: {
        name: 'zly',
        age: 28
    },
    height: 183
}
var obj = {};

function clone(target, origin) {
    var str = '[object Array]';  //判断是不是数组的关键字
    var toString = Object.prototype.toString; //如果经常使用某一个方法可以使用简单的变量名去储存
    for (var prop in origin) {
        if (origin.hasOwnProperty(prop)) {
        //是不是自己的属性，不想要原型链上的属性
            if (typeof origin[prop] == 'object') {
            //判断这个值是不是对象或数组
                if (toString.call(origin[prop]) === str) {
                //判断是不是数组
                    target[prop] = [];
                    //你是数组，先给你一个数组的外壳，你是引用值不能把地址直接给你，
                    //我用递归把你属性中属性值是数组、对象的属性再次循环判断
                    //将其中的值赋给克隆体，给外壳加料
                } else {
                    target[prop] = {};//后面把值给他
                }
                clone(target[prop], origin[prop]);
                //递归，将属性中对象的值赋给它
            } else {
                target[prop] = origin[prop]//原始值直接赋值
            }

        }
    }
}
clone(obj, mrChen);
obj.girlFriend.name = 'zzh';
  • 纯函数(pure function)：纯函数是指不依赖于且不改变它作用域之外的变量状态的函数。
         也就是说，纯函数的返回值只由它调用时的参数决定，  它的执行不依赖于系统的状态（比如：何时、何处调用它——译者注）。


----------------------------------------------------------------------------------------------------------------------------------------



----------------------------------------------------------------------------------------------------------------------------------------


  • 判断一个对象是不是数组的方法
var a = [];
1. Object.prototype.toString.call(a);
2. a instanceof Array;
3. a.consturctor

这里写图片描述

tips6.this

  • 普通函数
function test(a) {
    //AO {a:44, b:undefined, c:function(){}, this:window}
    console.log(this);
    //没有任何显示调用，那么this就是window，可以输出
    var b = 10;

    function c() {

    }
    var c = 20;
}
test(44); //window

这里写图片描述

  • 一个对象的属性
 var obj = {
     show: function test(a) {
         //AO {a:44, b:undefined, c:function(){}, this:obj}
         console.log(this);
         var b = 10;

         function c() {

         }
         var c = 20;
     },
     name: 'yp'
 }

 obj.show(44); //obj

这里写图片描述

  • 构造函数
function test(a) {
    //AO {a:44, b:undefined, c:function(){}, this:Object.create(test.prototype)}
    //var this = Object.create(test.prototype);
    console.log(this);
    var b = 10;

    function c() {

    }
    var c = 20;
}
var b = new test(); //Object.create(test.prototype)
//this 是个 对象  原型是test.prototype

这里写图片描述


simpleone_
关注
JavaScript继承模式+对象枚举+习题（六）
Miracle1203的博客
04-29 2446
解决： 在node1和master节点分别输入 # start-dfs.sh 解决
深度克隆（deepclone）
cmchenmei的博客
04-11 1114
var obj1 = { name:'duyi', people:{ cs:'cc', }, student:['jack'], } var obj2 = { name:"tengxu", people:{ teacher1:'jc', teacher2:'wb', teacher3:'dg', ...
java核心语法：接口、继承、克隆
我爱吃兔兔的博客
08-02 165
1、数组:声明数组时不能指定长度，堆内存。 2、接口有利于代码的拓展（加新功能），继承有利于代码功能的修改。 继承Eg：一代类test1，方法test（），二代子类test2，重写test（）方法 public class test2 extends test1 { public void test(){ System.out.println("xxxxxxxxx"); ...
Javascript 继承和克隆
weixin_30871905的博客
01-07 77
个人总结： call 继承的是父类私有 prototype 继承的父类公有 create 可以将公有或私有继承到子类上去(克隆) for in 克隆 不管公有还是私有的都克隆成私有的 1.原型继承：将父类的私有和公有都继承子类的原型上。子类的原型等于父类的实例。（私有...
JS对象克隆及JS继承
ltyisangel的专栏
09-02 844
var deepClone = function(source,target){ source = source || {} ; target = target || {}; var toStr = Object.prototype.toString , arrStr = '[object array]' ; for(var i in source)
克隆对象、对象继承
panxiang162497的博客
01-06 231
1.克隆对象 这种写法不是对象克隆，就是把obj的内存地址赋给了obj2（这是错误的写法） （1）通过for in克隆，不管是私有的还是公有的全部克隆成私有的 （2）js提供了一个一个克隆的方法 Object.create() var obj2=Object.create() 将obj的所有的属性克隆到obj2的原型上 2.对象的继承 （1）原型继承：就是将父类的实例赋值给子类的原型 ...
java —— 克隆对象、枚举
最新发布
firstgrass的博客
05-29 920
在本案例中，由于 Student 类不是基本类型，当把 st1 赋给 st2 的时候，st1 和 st2 实际指向同一个对象 Tom，此时不论更改 st1 还是 st2 中的任何一个，另一个都会随之更改。方法：① 该对象的类要实现 cloneable 接口；② 在该对象的类中对父类 Object 的 clone() 方法进行重写。在本案例中，使用 st2=st1.clone()，实质上等于 st1 和 st2 指向两个 Tom，此时不论更改其中任何一个，都不会影响另一个的值。
duyi20230317_jar的生成与引入，服务器多线程准备，浏览器url处理(dmc).zip
03-20
本项目涉及的主题是“duyi20230317_jar的生成与引入”，这部分将深入讲解如何创建和使用jar文件。首先，我们需要理解Java Archive (JAR) 文件的作用，它允许我们将多个类文件打包成一个可执行文件，便于分发和执行。...
UnhandledPromiseRejectionWarning: D:\duyi\vue3\vue3-app-vite\node_modules\@vue\compiler-sfc\dist\compiler-sfc.cjs.js:16397 #fillNegs() {
06-03
这个错误通常是由于未处理的 Promise rejection 引起的，可能是因为某个异步操作抛出了一个异常或者被拒绝了，但是没有被捕获和处理。在这个错误信息中，似乎是在使用 Vue 3 中的 compiler-sfc 模块时出现了问题，...
用vite搭建vue3的项目报UnhandledPromiseRejectionWarning: D:\duyi\vue3\vue3-app-vite\node_modules\@vue\compiler-sfc\dist\compiler-sfc.cjs.js:16397 #fillNegs() { ^
06-03
这个错误通常是由于未处理的 Promise rejection 引起的，可能是因为某个异步操作抛出了一个异常或者被拒绝了，但是没有被捕获和处理。在你使用 Vite 搭建 Vue 3 项目时，出现了这个错误，可能是因为你的代码中使用了...
java为什么不用枚举,为什么Java枚举不可克隆？
weixin_36003504的博客
03-21 344
改变这个问题为时已晚，但是更精确的是问"为什么clone()不允许单例？"。 copy()方法会更方便。有什么原因无法克隆Java中的枚举？该手册指出This guarantees that enums are never cloned, which is necessary to preserve their"singleton" status.但是返回实例本身也将保留其状态，并且我将能够以与其...
关于对象的创建，克隆，和继承面试题
weixin_45846980的博客
09-06 136
 关于对象一直都是面试中经常出现的常客，既然是经常出现的，我们就要把这个点拿下。以下有三道面试题 面试题：JavaScript创建对象有几种方式 //1.（字面量创建） var obj = {}; obj.name = '张三'; obj.action = function () { alert('吃饭'); }; //2.（使用Object创建对象） var obj = new Object(); obj.name = '张三'; obj.action = function () { alert('吃
java enum方法_Java Enum clone（）方法与示例
cumtv80668的专栏
07-24 861
java enum方法 枚举类clone()方法 (Enum Class clone() method) clone() method is available in java.lang package. clone()方法在java.lang包中可用。 clone() method is used to give assurance that enum cannot be cloned () (...
java clone()方法_Java Enum clone()方法与示例
weixin_39710660的博客
03-06 317
枚举类clone()方法clone()方法在java.lang包中可用。clone()方法用于确保不能克隆枚举(即无法复制枚举对象)，这是保持属性的“单例”行为所必需的。clone()方法是一种非静态方法，只能使用类对象访问，如果尝试使用类名称访问该方法，则会收到错误消息。clone()方法是最终方法，因此在子类中不可重写。clone()方法可能会在不克隆枚举时抛出异常CloneNotSuppor...
[duyi]171221 try...catch | ES5严格模式
simpleone_的博客
12-21 166
js
js设计模式 + 克隆 + 继承 + ES6高级
阿宝的博客
03-25 107
垃圾回收机制是由系统控制的，程序是无法精准控制垃圾回收机制的时机的，程序只能知道对象什么时候不再被引用，当一个对象永久性地失去引用后，会由可达状态变为可恢复状态，程序会通知系统进行垃圾回收，但只是通知，最终是否回收是不确定的；当一个对象失去了所有的引用之后，它就进入了可恢复状态，这个状态下，系统的垃圾回收机制会随时调用finalize()方法对它占有的资源进行回收，此时只要有引用变量引用对该对象，这个对象又会变为可达状态，否则进入不可达状态；处于不可达状态的对象，就会等待系统随时对它所占的资源进行回收。
Object中克隆方法实现
小白有个大牛梦
12-22 238
引用类型克隆对象
复制和克隆
JAVA程序猿
07-16 1150
复制：将某个对象的引用复制给另一个对象，两个对象还是指向同一个应用。 克隆：分为浅复制、深复制。 浅复制：将对象的数据进行复制，但是对象中包含的对象，仍旧只是复制对象的引用。 深复制：不仅复制对象的基本类型属性，对于对象中包含的对象的数据也进行复制。 要实现克隆，需要重写Object的访问权限protected的clone方法。 既然Object是所有类的超类，为什么不能直接调用clone方法？ 这
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值