var A = {n:4399};
var B = function(){this.n = 9999};
var C = function(){var n = 8888};
B.prototype = A;
C.prototype = A;
var b = new B();
var c = new C();
A.n++;
console.log(b.n);
console.log(c.n); 以上代码，在浏览器中执行的结果是
[单选题]
liyixiaobai
console.log(b.n);
在查找 b.n 是首先查找 b 对象自身有没有 n 属性，如果没有会去原型（prototype）上查找
当执行 var b = new B() 时，函数内部 this.n=9999(此时this指向b)
返回b对象，b对象有自身的n属性，所以返回 9999
console.log(c.n);
同理
当执行 var c = new C() 时，c对象没有自身的n属性，向上查找，找到原型
（prototype）上的 n 属性，因为 A.n++(此时对象A中的n为4400)，
所以返回4400
编辑于 2017-01-09 19:41:20
回复(21)
var A={n:4399};
var B=function(){
this.n=9999
}
var C=function(){
var n=8888
}
B.prototype=A;
C.prototype=A;
var b=new B();
var c=new C();
A.n++;
console.log(b.n);
console.log(c.n);
- 首先改写了B和C的原型，他们的原型对象都指向A，因此，它们的原型都拥有属性n：4399
- 通过new创建了B和C的实例，用这种方式调用构造函数经历四步
- 创建一个新的实例对象；b,c
- 将构造函数的作用域赋值给新对象（this指向新对象b,c）； 此时B中的this指向实例对象b,即b.n=9999；
- 执行构造函数中的代码；给实例添加属性，此时执行b.n=9999,为b添加实例属性；执行var n=8888,对实例c没有影响
- 返回新对象 ；返回实例对象b，拥有实例属性n=9999,通过原型链，具有原型属性n=4399;返回实例对象c，只有原型属性 n=4399
- 然后改写原型的属性A.n，因为原型上的属性是公用的，所以b和c中原型上的n属性都为4400，b还有实例属性n=9999。由于查找属性的时候现在实例上找，再去原型中找，只要找到了就不往后找了。于是b.n=9999（在实例中找到）,c.n=4400（在原型中找到）
编辑于 2018-05-17 14:53:21
回复(8)
var A = {n:4399}; //A是一个对象
var B = function(){this.n = 9999};
//B是一个构造函数，这个函数里有一个属性n，因为用了this.n
var C = function(){var n = 8888};
//C是一个构造函数，这个函数里只是定义了一个局部变量n,
//这个局部变量n并不属于函数自身的属性
B.prototype = A; //prototype是原型，原型的本质也是一个对象。
//现在让B的原型对象指向了A这个对象。此时B的原型对象就是对象A。
C.prototype = A; //prototype是原型，原型的本质也是一个对象。
//现在让C的原型对象指向了A这个对象。此时C的原型对象也是对象A。
var b = new B(); //通过new关键字创建了一个实例化对象b, 注意b的本质是一个对象。
//构造函数的属性都是这个对象的属性。
//因为构造函数B里有一个属性n,故此时 b = {n:9999}
var c = new C(); //通过new关键字创建了一个实例化对象c，注意c的本质是一个对象。
//构造函数的属性都是这个对象的属性。
//因为构造函数C里没有任何属性，古此时 c = {}
A.n++;
console.log(b.n); //b.n 首先会去b对象里找n,b对象里如果有n就直接获取，
//如果没有就去 b对象的构造函数的原型对象 里找
//因为b = {n:9999},所以b对象是有属性n的，故直接获取b.n = 9999
console.log(c.n); //c.n 首先会去c对象里找n,c对象里如果有n就直接获取，
//如果没有就去 c对象的构造函数的原型对象 里找
//因为c = {},所以c对象没有属性n，
//只能去 c对象的构造函数的原型对象（也就是A={n:4399}）里找
//而倒数第三行执行了 A.n++; 故 A.n的值变成了4400， 所以c.n就是4400
编辑于 2022-01-08 19:07:27
回复(0)
this.n 说明这个n是b实例创建的 , 对象b实例和b继承的函数C原型中都有n属性 , 优先查找b实例中的n属性 .
b==B.prototype 但是 b != B
同理
c==C.prototype , c !=C
函数C中var n=8888并不在原型中 , 所以对象c.n无法找var n=8888 , 只在函数C的_proto_原型中找到了n:4400
编辑于 2018-08-15 10:26:47
回复(0)
我也错了, 试了一下, 大概可以解释的通
举个例子
let F = function(){
let num1 = 1;
this.num2 = 2;
}
let f = new F();
console.log(f);
// F {num2: 2}
// 这里控制台的输出找不到num1的半点影子 可以比作c语言中的类, F就是一个类, function(){let num1.........}等是他的构造函数 那么此处的let num1 = 1; 只是在构造函数中声明了一个变量, 构造函数执行完了, num1就被销毁了, 没有任何作用
而构造函数中的this指向了该实例, 这里也就是f, 也就是说f.num2 = 2; 为对象f创建了一个变量num2, 并赋值为2
另外, prototype也就是现在的 [[prototype]] , 应该是只这个对象继承于谁, Object是所有对象的基类, 所以如果不做任何处理, 自己声明的对象其实这个属性应该是指向Object类
这道题改为了指向A,
输出c.n时, C的构造函数和我举的例子一样, 只是声明了一个变量, 没啥用, 也就是说b中没有n, 那么就会沿着原型链网上找, 找到了A, A的上一层是Object, A中有n所以不再往上面的Object找, A中的n被改为了4400, 所以c.n输出的是4400
c{
// 属性
// 没有自己创建的属性
// something else
// 上层原型链(c继承了谁)
[[prototype]]: A{
n: 4400
[[prototype]]: Object{
// something else
}
}
}
输出b.n时, B的构造函数和我举得例子的num2一样, 为对象b创建了一个新的属性n并赋值为9999(this.n = 9999);
所以输出b.n时由于b中有n = 9999, 不再找上一层的A.n
b{
// 属性
n: 9999
// something else
// 上层原型链(b继承了谁)
[[prototype]] : A{
n: 4400
[[prototype]]: Object{
// something else
}
}
}
大概就是这样吧, 我也没系统阅读相关书, 看js高级程序设计把前面跳了, 现在自己试了试之后感觉理解了点
发表于 2022-04-19 22:16:06
回复(0)
不知道，为什么。直接这么看，有的蒙。贴入编辑器以后。反而清楚一点。可能还不熟悉吧
分解看：①简单的看：
var A = {n:4399};
var B = function(){this.n = 9999;}
var C = function(){var n = 88888;}
var b = new B();
var c = new C();
console.log(b.n); //9999
console.log(c.n); //unsigned（在c的对象上没有属性n）
②
var A = {n:4399};
var B = function(){this.n = 9999;}
var C = function(){var n = 88888;}
*2 C.prototype = A;
var b = new B();
var c = new C();
console.log(b.n); //9999
console.log(c.n); //43999（（在c的对象上没有属性n，但是c的原型上有）
③
var A = {n:4399};
var B = function(){this.n = 9999;}
var C = function(){var n = 88888;}
*3 B.prototype = A;
*2 C.prototype = A;
var b = new B();
var c = new C();
console.log(b.n); //9999（b的原型链上A的的对象上有，但是在b的对象上有属性n） console.log(c.n); //43999（在c的对象上没有属性n，但是c的原型链上A的的对象上有）
④
var A = {n:4399};
var B = function(){this.n = 9999;}
var C = function(){var n = 88888;}
*3 B.prototype = A;
*2 C.prototype = A;
var b = new B();
var c = new C();
*4 A.n++;
console.log(b.n); //9999（b的原型链上A的的对象上有，但是在b的对象上有属性n）
console.log(c.n); //43999（在c的对象上没有属性n，但是c的原型链上A的的对象上有，同时a的属性n改变了）
发表于 2017-04-09 21:22:49
回复(0)
new来调用函数属于构造函数调用，会自动执行以下操作：
1.创建/构造一个新对象
2.这个新对象会被执行[[原型]]连接，也就是把这个空对象的__proto__指向构造函数的prototype
3.这个新对象会被绑定到函数调用的this上
4.如果函数没有返回其他对象，那么new表达式中的函数调用会自动返回这个对象
所以在这里，new C()了之后实际执行了
var c=function(){
var o=new Object()
C.apply(o,arguments)
return o;
}
c.n首先会找自身对象上面有没有，没有再找原型
发表于 2023-10-05 22:06:23
回复(0)
问题信息
-
扫描二维码，关注牛客网
- 意见反馈
-
下载牛客APP，随时随地刷题
扫一扫，把题目装进口袋
- 求职之前，先上牛客
-
扫描二维码，进入QQ群
扫描二维码，关注牛客公众号
- 公司地址：北京市朝阳区北苑路北美国际商务中心K2座一层-北京牛客科技有限公司
- 联系方式：010-60728802 投诉举报电话：010-57596212（朝阳人力社保局）
- 牛客科技© All rights reserved admin@nowcoder.com
- 京ICP备14055008号-4 增值电信业务经营许可证 营业执照 人力资源服务许可证
-
京公网安备
11010502036488号
