首页 > 试题广场 >

请问以下JS代码的输出是什么？ let A = functi

[单选题]

请问以下JS代码的输出是什么？

let A = function() {}
A.prototype.a = 1;
let B = new A();
A.prototype = {
  b: 2,
  c: 3
}
let C = new A();
A.prototype.d = 4;
console.log(B.a);
console.log(B.b);
console.log(C.c);
console.log(C.d);

```
1、2、3、4
```
```
1、undefined、3、4
```
```
1、undefined、undefined、undefined
```
```
undefined、2、3、4
```

查看正确选项

笨笨只会灭火

let A = function() {}
A.prototype.a = 1; 
//此时 A.prototype = { a: 1 }


let B = new A(); //此时 B = {}
//在创建B时，已将B._proto_ = A.prototype = { a: 1 }
//即使后面A.prototype重新赋值，将A.prototype开辟了新的空间指向别的对象
//B._proto_并没有改，还是指向{a:1}这个对象


A.prototype = { //此时 A.prototype = { b: 2, c: 3 }
  b: 2,
  c: 3
}
let C = new A(); //C = {}
A.prototype.d = 4;//此时A.prototype = { b: 2, c: 3, d: 4 }

console.log(B.a); //1
console.log(B.b); //undefined
console.log(C.c); //3
console.log(C.d); //4

//C.d
//着重区分： A.prototype.d = 4 和 A.prototype 重新赋值 不是一个概念 
//A.prototype重新赋值时，A.prototype已经指向另一个对象了   
//A.prototype.d = 4时，访问的还是同一个A.prototype 对象

如果      let B = new A(); 之后

加一个 A.prototype.b = 999;

那么        console.log(B.b); B.b就是999

编辑于 2022-01-26 16:10:53 回复(19)

迷途小学生

在创建B时，已将B._proto_ = A.prototype; 后面A.prototype重新赋值，只是将A.prototype开辟了新的空间，B._proto_并没有改，还是{a:1};

发表于 2021-12-20 10:38:42 回复(3)

冉娃娃2

let A =function() {}

栈指针	堆内存
A.prototype	{ }

A.prototype.a = 1;

栈指针	堆内存
A.prototype	{ a: 1 }

let B =new A();

栈指针	堆内存
A.prototype B.__proto__	{ a: 1 }

A.prototype = { b: 2, c: 3 }

栈指针	堆内存
A.prototype B.__proto__	{ a: 1 } { b: 2, c: 3 }

let C =new A();

栈指针	堆内存
A.prototype B.__proto__ C.__proto__	{ a: 1 } { b: 2, c: 3 }

A.prototype.d = 4;

栈指针	堆内存
A.prototype B.__proto__ C.__proto__	{ constructor: A, a: 1 } { b: 2, c: 3, d: 4 }

编辑于 2022-04-19 17:13:30 回复(1)

gai溜子

1.A是个构造函数,B是构造函数的实力对象 => B.__proto__ === A.prototype, A.prototype.a = 1 => B.a === 1

2.A.prototype = { b : 2 , c : 3 } , A的原型对象重新赋值,但是不会影响之前已经new 出来的B实例, B实例的原型(B.__proto__)跟这个A函数的原型对象没任何关系,但是这个A函数新的原型对象是后续A实例对象的原型(x.__proto__),即后续的实例可以访问该新原型对象中的属性 => B.b === undefined // C.c === 3

发表于 2022-01-11 14:10:15 回复(1)

牛客589683127号

对A原型进行了覆盖，而不是追加

发表于 2022-08-19 15:55:18 回复(0)

Sonny_boy

发表于 2021-12-12 22:32:39 回复(1)

牛客130559470号

这题的意思是实例构造函数其原型地址是静态化。只能直接修改，间接改的不是它。所以在 b= new A()之后，该实例b的构造函数A的原型指向的空间地基打好了，只能往里面添加。想换地基只能b.__proto__= 888 而A.prototype=999 是给A换了地基，不是给b换。

发表于 2022-08-12 12:30:46 回复(1)

hungry_&_foolish

应该是：每个对象创建都会形成自己的原型链，开始A.prototype只有1，然后创建b ：b形成自己的一套原型链；虽然后面{ b: 2,c:3}覆盖了A.prototype，但是b已形成的原型链还只是找得到a，没有b和c

发表于 2022-01-09 15:01:53 回复(0)

迷途未返纠结中

个人感觉，之所以与预料的不一样，原因出在A.prototype={b:2,c:3}这里，相当于把之前的prototype的内容类似废弃了，另辟一个空间存放prototype内容，在这一语句之后的A.prototype.d以及其他都会写入这个内容中

发表于 2021-12-25 15:23:22 回复(2)

dy17

A.prototype指向不同，let B = new A();里面的并没有a, 所以是a是undefined

发表于 2021-12-11 20:46:25 回复(0)

田大包

mark

编辑于 2024-03-06 08:09:08 回复(0)

Aic山鱼

let A = function () {}

A.prototype.a = 1;

// A的prototype里面现在只存有{a:1}

let B = new A();

// B的prototype里面只有当前A里面的所有数据也就是{a:1}

A.prototype = {

b: 2,

c: 3

}

// 给A重新赋值所以就覆盖了之前的A.prototype.a = 1,所以当前的a.A.prototype里面只有{b: 2,c: 3}

let C = new A();

// 当前C里面只有当前A的数据也就是{b: 2,c: 3}

// 我们可以输出一下A.prototype看一看

console.log(A.prototype);

// 由于A内并没有d

// 这个变量所以相当于给A.prototype新添加了一个变量

A.prototype.d = 4;

// 所以当前A.prototype里面有三个值分别是b,c,d

console.log(A.prototype);

console.log(B.a); //1

console.log(B.b); //undefined

console.log(C.c); //3

console.log(C.b); //2

console.log(C.d); //4

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

发表于 2023-04-10 08:39:25 回复(0)

感伤系

在 new 出一个对象之后，它的原型就固定了，不会在后续的 A.prototype 赋值改动

发表于 2023-02-28 11:58:24 回复(0)

牛客595933360号

此题需要明确2点 1.new 构造函数内部发生了什么 new A 首先this= new Object obj.__proto__指向A.prototype 执行函数内部代码绑定this相关属性如果显示return 对象返回对象如果显示return undefine 都默认返回this 2.堆内存地址指向可以看到创建B时上述new后原型指向一个含有a为1的对象而后A.prototype指向另一块地址，也就是b.__proto__指向与A.prototype指向脱钩的ap变化指向只表明ap不指向那个有a=1的内存区域所以b原型上只有a

发表于 2022-04-22 10:55:39 回复(0)