java 深拷贝vo,JS知识—面试准备（一）

最新推荐文章于 2023-05-16 10:55:53 发布
最新推荐文章于 2023-05-16 10:55:53 发布
阅读量150 收藏
点赞数
文章标签： java 深拷贝vo

1.JS内置类型

分为基本数据类型和Object.

基本数据类型有：null,undefined,string,boolean,number,symbol.

console.log(typeof null);//object

console.log(typeof []);//object

console.log(typeof {});//object

如果想要区分null，数组，对象，应该怎么办？

console.log(Object.prototype.toString.call(null));//[object Null]

console.log(Object.prototype.toString.call([]));//[object Array]

console.log(Object.prototype.toString.call({}));//[object Object]

我的简单理解：toString(数据)；作用：将数据转化为字符串。

2.类型转化

类型转化：分为显示类型转化，和隐式类型转化。

1.Number(数据)

如果数据内容式纯粹的数字，才可以转化为数字，否则式NaN。

var str2="12px";//NaN

var str2="1.2";//1.2

var str2="1.2.3";//NaN

var str2=null;//0

console.log(Number(str2));

2.NaN

NaN的数据类型书Number。注意：NaN和任何东西都不相等，包括自己。

3.isNaN(数据)

会先把数据用Number转化，转化完了之后在判断是不是NaN，如果是NaN则返回为true。否则返回为fasle。

console.log(isNaN(1));//false

console.log(isNaN("123"));//false

console.log(isNaN("abc"));//true

4.parseInt(数据)和parseFloat(数据)

parseInt(数据)：把数据变成整数，舍去小数点，取整数。

parseFloat(数据)：把数据转化为数字，可以是小数。

注意:这两个方法会从左往右开始，除去空格，找到第一位非0数字，开始进行转换，直到转换到不是数字的那位为止，或者，转换出合适的值为止。

console.log( parseInt( "1" ) );//1

console.log( parseInt( "1.9" ) );//1

console.log( parseInt( "20px" ) );//20

console.log( parseInt( " 25px" ) );//25

console.log( parseInt( " 0.0026px" ) );//0

console.log( parseFloat( " 0.0026px" ) );//0.0026

5.Stirng( )和Boolean()也可以进行显示类型转化，这里不缀述

条件判断中，除了null,undefined,'',NaN,false,0都转化为false，其余都转化为true。

6.隐式类型转化

只有当加法运算时，其中一方是字符串类型，就会把另一个也转为字符串类型。其他运算只要其中一方是数字，那么另一方就转为数字。并且加法运算会触发三种类型转换：将值转换为原始值，转换为数字，转换为字符串。

console.log( "abc"-1 );//NaN

console.log( NaN-1 );//NaN

console.log( NaN+1 );//NaN

console.log( NaN+"1" );//NaN1

//------------------------------------------

console.log( "3"-1 );//转成数字2

console.log( "345" - 0 );//转成数字345

console.log( "345" * 1 );//转成数字345

console.log( "345" / 1 );//转成数字345

console.log( "345px" - 0 );//NaN

//------------------------------------------

console.log( 123 + "" );//转成字符串 "123"

//------------------------------------------

console.log( !!234 );//转成boolean类型 true

console.log( !!0 );//转成boolean类型 false

console.log( !!{} );//转成boolean类型 true

console.log( !!null );//转成boolean类型 false

3.运算符

==和===

==：

1.如果类型相同的话，比较内容

类型不相同，类型转化在比较

1)一个是undefined,一个是null，则相等。

2)数字和字符串的的话，将字符串转化为数字再进行比较。

===：

1.类型相同比教内容，类型不同则返回fasle。

4.原型，原型链，new

1.new

1.新生成了一个对象

2.链接到原型

3.绑定this

4.返回新对象

2.prototype 原型

prototype 原型

当一个函数被申明的时候，该函数下默认有一个属性：prototype，该属性的值是一个对象

当我们去调用一个对象的属性或者方法的时候，如果该对象自身没有该属性或方法，

则会调用到该对象 的 构造函数的prototype的属性或方法

把通过构造函数构造出来的对象，共有的方法或者属性，放在prototype身上

__proto__

当一个对象被创建的时候，

该对象会自动被添加上一个属性：__proto__，

他的值也是一个对象，并且该属性 就是 当前这个对象的构造函数的prototype

对象.__proto__ === 构造函数.prototype

3.原型链

Function.prototype.a = "a";

Object.prototype.b = "b";

function Person(){}

console.log(Person); //function Person()

let p = new Person();

console.log(p); //Person {} 对象

console.log(p.a); //undefined

console.log(p.b); //b

解析：

会一直通过__proto__向上查找，最后当查找到Object.prototype时找到，最后打印出b，向上查找过程中，得到的是Object.prototype，而不是Function.prototype，找不到a属性，所以结果为undefined，这就是原型链，通过__proto__向上进行查找，最终到null结束

//Function

function Function(){}

console.log(Function); //Function()

console.log(Function.prototype.constructor); //Function()

console.log(Function.prototype.__proto__); //Object.prototype

console.log(Function.prototype.__proto__.__proto__); //NULL

console.log(Function.prototype.__proto__.constructor); //Object()

console.log(Function.prototype.__proto__ === Object.prototype); //true

总结：

1.查找属性，如果本身没有，则会去__proto__中查找，也就是构造函数的显式原型中查找，如果构造函数中也没有该属性，因为构造函数也是对象，也有__proto__，那么会去它的显式原型中查找，一直到null，如果没有则返回undefined

2.p.__proto__.constructor == function Person(){}

3.p.___proto__.__proto__== Object.prototype

4.p.___proto__.__proto__.__proto__== Object.prototype.__proto__ == null

5.通过__proto__形成原型链而非protrotype

5.instanceof

检测对象原型是否在要检测对象的原型链上，返回值为true或者false

使用：object instanceof constructor

function Fn () {}

var f = new Fn();

console.log( f instanceof Fn );//true

console.log( f instanceof Object );//true

// //str是字面量生成的，是由JS内部的String构造函数new出来的。

// //但是str会立刻"压扁"自己，让自己不是对象。

// //所以str都不是对象了，自然instanceof String 的得到的值为fasle

// //但str.indexOf(),str还是可以调用indexOf()方法的原因是，当它调用方法的时候，会重新将自己包装成对象。

// //使用结束后会重新"压扁"自己，让自己不是对象。

var str = "123";

console.log( str instanceof Array );//false

console.log( str instanceof String);//false

console.log( str instanceof Object);//false

//

var obj = {};

console.log( obj instanceof Array );//false

console.log( obj instanceof Object);//true

6.hasOwnProperty

作用

用来判断某个对象是否含有 指定的 自身属性

语法

boolean object.hasOwnProperty(prop)

参数

object

要检测的对象

prop

要检测的属性名称。

注意：不会沿着原型链查找属性，只查找自身属性

function Fn(name,gender){

this.name = name;

this.gender = gender;

}

Fn.prototype.kind = "human";

Fn.prototype.say = function(){

console.log(1);

};

var f = new Fn("kimoo","男");

console.log( f.hasOwnProperty("name") ); //true

console.log( f.hasOwnProperty("kind") ); //false

console.log( f.hasOwnProperty("say") ); //false

8.call,bind,apply

call,bind,apply的作用都是修改this指向。

区别:

1.call:函数会立即执行,括号中的内容 第一个参数 就是 函数执行时候 ,内部的this指向。后面的参数就是函数内部的实参。

function foo (a,b) {

console.log( this );

console.log( a,b );

}

foo.call( document,2,3 );//运行结果：#document 2，3

2.apply:函数会立即执行,括号中的内容 第一个参数 就是 函数执行时候 ,内部的this指向。不过第二个参数接受数组。

function foo (a,b) {

console.log( this );

console.log( a,b );

}

foo.apply( document,[2,3] ); // 和call 相似 直接调用 , 不过第二个参数接受数组。运行结果：#document 2，3

3.bind:函数 不会 立刻执行,返回的是 修改了 this指向的新函数.第二个参数是参数列表。

function foo (a,b) {

console.log( this );

console.log( a,b );

}

var fn = foo.bind( document,2,3);// 函数 不会 立刻执行,返回的是 修改了 this指向的新函数

fn();

//运行结果:

//#document

//2 3

9.组合式继承

function Person(){

this.arr = [1,2,3];

this.age = 10;

}

Person.prototype.say = function(){

console.log( "我会说话" );

};

// 父类构造函数中的方法,使用借用构造函数的方式继承

function Coder(name,money) {

Person.call(this);

this.name = name;

this.money = money;

}

// 父类构造函数原型上的方法,使用原型链继承

Coder.prototype = new Person();

Coder.prototype.constructor = Coder; // 重新修改 constructor

Coder.prototype.say = function(){

console.log( "我是程序员,我叫" + this.name +",我一个月:"+ this.money );

}

var p = new Person();

console.log( p.age );

console.log( p.arr );

console.log( p.kind );

p.say();

var c1 = new Coder("a",10000);

console.log( c1.age );

c1.say();

c1.arr.push(4);

console.log( c1.arr );

console.log( c1.name );

console.log( c1.money );

var c2 = new Coder("b",30000);

c2.say();

console.log( c2.age );

console.log( c2.arr );

console.log( c2.name );

console.log( c2.money );

console.log(Coder.prototype.constructor);

10.拷贝式继承

function Person(){

this.arr = [1,2,3];

this.age = 10;

}

Person.prototype.say = function(){

console.log( "我会说话" );

}

function Coder(){

Person.call(this);

}

Coder.prototype = cloneFn( Person.prototype );

Coder.prototype.constructor = Coder;

Coder.prototype.say = function(){

console.log( "我是程序员" );

}

var p = new Person();

console.log( p.age );

console.log( p.arr );

p.say();

console.log( "----------------" );

var c1 = new Coder();

console.log( c1.age );

c1.say();

c1.arr.push(4);

console.log( c1.arr );

console.log( "----------------" );

var c2 = new Coder();

console.log( c2.age );

console.log( c2.arr );

c2.say();

//------------------------------------------

function cloneFn( sourse ){

var o = Object.prototype.toString.call(sourse).toLowerCase().indexOf("array")!==-1 ? [] : {};

for( var attr in sourse ){

if( (typeof sourse[attr] === "object") && sourse[attr] !== null ){

o[attr] = cloneFn( sourse[attr] ) ;

}else{

o[attr] = sourse[attr];

}

}

return o;

}

11.class继承

class Person {

constructor(name){

this.name = name;

}

say(){

console.log( '我的名字叫 ${this.name}');

}

}

class Coder extends Person{

// constructor( name,money ){

// super(name); // 相当于 调用 父类的 构造函数,修改内部的this,

一定要先调用 super 再使用 this

// this.money = money;

// }

say(){

console.log( `我的名字叫 ${this.name}` );

}

eat(){

console.log( "我会吃" );

}

}

var p = new Person("kimoo");

// console.log( p );

// p.say();

// p.eat(); // 报错: p.eat is not a function

var c = new Coder("zm");

console.log( c );

c.say();

c.eat();

12.函数作用域，执行上下文，变量提升，闭包

1.作用域

JS作用域分为全局作用域和函数作用域，函数作用域可以访问全局作用域中的变量，对象，函数等。但是函数作用域外部访问不到函数内部的变量，对象，函数。

但在ES6中新增了块级作用域。let，const在块中声明的变量，函数等，外部都访问不到。

{

var a=1;

let b=2;

console.log(b);//2

{

console.log(b);//2

}

}

console.log(a);//1

console.log(b);//报错，b is not defined

总结：

1. 调用函数是会为其创建执行上下文，并压入执行环境栈的栈顶，执行完毕弹出，执行上下文被销毁，随之VO也被销毁

2. EC创建阶段分创建阶段和代码执行阶段

3. 创建阶段初始变量值为undefined，执行阶段才为变量赋值

4. 函数申明先于变量申明

3.变量提升(域解析)

关键：变量提升过程中函数优先级高于变量优先级

function foo() {

console.log(f1); //f1() {}

console.log(f2); //undefined

var f1 = 'hosting';

var f2 = function() {}

function f1() {}

}

foo();

4.闭包

闭包：函数 A 返回了一个函数 B，并且函数 B 中使用了函数 A 的变量，函数 B 就被称为闭包。

for ( var i=1; i<=5; i++) {

setTimeout( function timer() {

console.log( i );

}, i*1000 );

}

首先因为 setTimeout 是个异步函数，所有会先把循环全部执行完毕，这时候 i 就是 6 了，所以会输出一堆 6。

解决方法一：

for (var i = 1; i <= 5; i++) {

(function(j) {

setTimeout(function timer() {

console.log(j);

}, j * 1000);

})(i);

}

解决方法二：

for ( var i=1; i<=5; i++) {

setTimeout( function timer(j) {

console.log( j );

}, i*1000, i);

}

解决方法三：

for ( let i=1; i<=5; i++) {

setTimeout( function timer() {

console.log( i );

}, i*1000 );

}

13.深浅拷贝

1.浅拷贝

首先可以通过 Object.assign 来解决这个问题。

let a = {

age: 1

}

let b = Object.assign({}, a)

a.age = 2

console.log(b.age) // 1

当然我们也可以通过展开运算符(…)来解决

let a = {

age: 1

}

let b = {...a}

a.age = 2

console.log(b.age) // 1

2.深拷贝

function cloneFn( sourse ){

var o = Object.prototype.toString.call(sourse).toLowerCase().indexOf("array")!==-1 ? [] : {};

for( var attr in sourse ){

if( (typeof sourse[attr] === "object") && sourse[attr] !== null ){

o[attr] = cloneFn( sourse[attr] ) ;

}else{

o[attr] = sourse[attr];

}

}

return o;

}

weixin_39550940
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
AS3深拷贝数据对象(2)深拷贝VO对象
weixin_33847182的博客
08-11 138
Topic：对于用户自定义的VO对象进行深拷贝，一种VO对象的某属性可能是另一种VO对象的实例。 方法1：通过传说中的“AS3隐藏特性——ByteArray.writeObject和readObject”进行操作，代码如下： registerClassAlias("test.vo.ResVO", ResVO); registerClassAlias("test.vo.TestVO", T...
js中VO解析
anmeiba2865的博客
04-22 530
执行环境(环境) 执行环境的用处 执行环境定义了变量或函数有权访问的其他数据，每一个执行环境都存在一个关联的变量对象(VO),代码无法访问，内部解析器会使用它，如果环境为函数，则将函数的AO作为VO,函数执行时，会创建一个以当前函数VO为前端的作用域链，以保证执行环境有权访问的所有变量和函数的有序访问。 顶级AO对象 全局 全局对象(Global object) 是在进入任何执行上下文之...
js--变量对象VO，活动对象AO
王欢的博客
10-23 9379
变量对象VO变量对象VO是与执行上下文相关的特殊对象,用来存储上下文的函数声明，函数形参和变量。在global全局上下文中，变量对象也是全局对象自身，在函数上下文中，变量对象被表示为活动对象AO。变量对象VO存储上下文中声明的以下内容 { 函数声明FD(如果在函数上下文中),—-不包含函数表达式 函数形参function arguments, 变量声明–注意b=10不
js中VO和VE 【2021.12.5】
masierty的博客
12-06 1145
VO是早期ECMA规范中的变量对象（variable object）的缩写； 早期ECMA规范这么写到：每一个执行上下文会被关联到一个变量对象（variable object）。在源代码中的变量和函数声明会被作为属性添加到VO中。对于函数来说，参数也会被添加到VO中。 在最新的ECMA规范中，对这个定义做出了一些修改，更加的严谨，而变量对象也就是VO修改成了变量环境（variable Environment）也就是VE。 来看看最新ECMA规范里面是怎么描述的吧：每一个执行上下文会关联到一个变量环境（
【JavaScript高级】02-深入JS执行原理：AO、VO及作用域链
SevgiliD的博客
11-14 1103
JavaScript的代码执行过程：执行上下文，GO,AO,VO，变量查找的作用域链顺序
Java中 PO VO BO DTO DAO 和 POJO 关系图
03-13
Java中 PO VO BO DTO DAO 和 POJO 关系图
java实现相同属性名称及相似类型的pojo、dto、vo等互转操作
08-24
主要介绍了java实现相同属性名称及相似类型的pojo、dto、vo等互转操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
POBOVODTOPOJODAO.zip_dto_java dto dao_java vo_qovod
09-20
PO可以严格对应数据库表，一张表对映一个PO。 BO则是业务逻辑处理对象，我的理解是它装满了业务逻辑的处理，在业务逻辑复杂的应用中有用。 VO：value object值对象、view object视图对象 PO：持久对象 QO：查询对象 ...
基于java中的PO VO DAO BO POJO(详解)
08-30
下面小编就为大家带来一篇基于java中的PO VO DAO BO POJO(详解)。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Java反射通过Getter方法获取对象VO的属性值过程解析
08-25
主要介绍了Java反射通过Getter方法获取对象VO的属性值过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
python-JSOV:基于JSOV（Javascript对象可视化）模板的可视输出生成器
05-10
python-JSOV 基于JSOV（JavaScript对象可视化）模板的可视输出生成器。 JSOV是用于可视化JSON对象的模板系统。 python-JSOV是Python3中基于JSOV的可视生成器的实现。 该生成器从JSON文件中获取对象，并基于JSOV模板生成对象的可视表示（例如，输出为HTML / CSS）。 JSOV模板负责如何以图形方式表示对象及其不同的子代和参数。 有两种方法可以使用python-JSOV生成JSON对象的可视输出： 使用内置，灵活且易于使用的JSOV模板； 使用用户定制的模板，以防JSOV模板的灵活性不够。 要求 可以通过运行pip3 install -r requirements.txt来安装项目pip3 install -r requirements.txt 使用范例 JSOV模板 语法： ./main.py -t template.j
Java对象深拷贝的几种方式
最新发布
penn
05-16 8378
java对象拷贝的几种方式
OV系列CMOS图像传感芯片的接口时序的FPGA实现
Paul的专栏
01-05 2800
图像传感器使用的是美商半导体公司（omnivision）的CAMERACHIP图像传感器OV7670。该传感器的感光阵列式640×480，核电压为1.8VDV±10%，模拟电压为2.45VDV到3.0V，IO口电压为1.7V到3.0V。数据输出格式（8位）有四种，分别是YUV/YCbCr4：2：2、RGB565/555/444、GRB4：2：2和Raw RGB Data。最大帧率为30fpsV
浅谈js执行的AO/VO
Ancecis的博客
02-18 5487
浅谈AO/VO详解 首先说明一下AO和VO的含义 AO：Activive Object，即函数的活动对象。 VO：Variable Object，即变量对象。 它们的作用是帮助js引擎在引用变量的时候能够去顺利找到变量。并且它们之间的联系可以实现作用域链。 VO 在执行函数的时候，会经历执行上下文的创建和代码的执行。如下图。 我们会先进行上下文的创建，创建VO、通过[Scope]属性指向外层...
Java深拷贝的实现
hudeyong926的专栏
03-11 7581
如果一个类中有指针对象，那么在拷贝这个类的对象的时候，默认的拷贝方式是只拷贝指针本身，而不重新构建并拷贝指针所指内容。这就叫做浅拷贝Shallow Copy。 如果拷贝的方式是不仅仅拷贝指针，而且把指针所指的内容也新建一份，那就叫深拷贝Deep Copy。 在有些业务场景下，我们需要两个完全相同却彼此无关的java对象。比如使用原型模式、多线程编程等。对此，java提供了深拷贝的概念。通过深度拷贝可以从源对象完美复制出一个相同却与源对象彼此独立的目标对象。这里的相同是指两个对象的状态和动作相同，彼此独立
java不同对象的集合拷贝_优雅的拷贝不同层的对象(VO,DO等)
weixin_32187075的博客
02-26 1230
编写代码时，因为分层，所以经常需要VO,DO甚至DTO等层对象进行拷贝，DO是数据库对象，VO是要展示到前端的对象，其实Spring提供的BeanUtils拷贝一般对象够了，但是对于List支持还没有，所以自己稍微对于BeanUtils扩展一下，并且对于拷贝对象添加回调方法，便于不同层转换时及时修改一些有差异的字段。使用方法public class TestCopyProperty {public...
java 实体拷贝Vo Dto entity转换
weixin_44851436的博客
08-31 3321
2.java 实体拷贝Vo Dto entity转换 代码如下（示例）： import cn.hutool.core.bean.BeanUtil; import lombok.SneakyThrows; import lombok.extern.slf4j.Slf4j; import java.text.SimpleDateFormat; import java.util.*; import java.util.function.Function; import java.util.stream.Coll
BO 与 VO 的属性拷贝 copyProperties(bo,vo)
weixin_30423977的博客
04-04 673
NewClass extends OldClass : newClass继承自oldClass,属性大多数相同,但是也有新的扩展.beanUtils.copyProperties(oldClass, newClass); //两者都一样的属性,其值可以拷贝.Spring中也提供了BeanUtils.copyProperties(sourceObj, targetOb...
java深拷贝二叉树_端午安康--DTO,VO,POJO深拷贝工具
weixin_39824834的博客
02-26 185
端午安康--DTO,VO,POJO深拷贝工具不管是经典的MVC框架还算是现在火热的DDD领域驱动设计，为了业务之间的结构分离，都生成了各种对象，比如VO,DTO,POJO等十分常见，还有Domain，Value，Entity等领域对象也是频繁出现，随之而来的也是各个对象之间的转换，于是，各家拷贝工具也是百家齐放，争奇斗艳，我试着写了一个，斗胆发出来献献丑功能同属性直接复制属性特异化赋值同名但是类型...
java DTO VO
05-12
DTO（Data Transfer Object）和VO（Value Object）都是Java中常用的数据传输对象，它们的主要作用是在不同层之间传输数据，并且在传输过程中可以进行数据的转换和封装。 DTO通常用于服务端与客户端之间的数据传输，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值