首页 > 试题广场 >

关于这段代码的描述,正确的是：

[单选题]

var F=function(){};
Object.prototype.a=function(){};
Function.prototype .b=function(){};
var f=new F();

关于这段代码的描述,正确的是：

```
f能取到a，但取不到b
```
```
f能取到a,b
```
```
F能取到b，不能取到a
```
```
F能取到a，不能取到b
```

查看正确选项

夏🌸樱

（注：从网上找到了一个很详细的答案）

网上有一道美团外卖的面试题是这样的：  Function.prototype.a = 'a';
Object.prototype.b = 'b';
function Person(){};
var p = new Person();
console.log('p.a: '+ p.a); // p.a: undefined
console.log('p.b: '+ p.b); // p.b: b  问为什么？

有不少同学第一眼看上去就觉得很疑惑，p不是应该继承了Function原型里面的属性吗，为什么p.a返回值是undefined呢？
其实，只要仔细想一想就很容易明白了，Person函数才是Function对象的一个实例，所以通过Person.a可以访问到Function
原型里面的属性，但是new Person()返回来的是一个对象，它是Object的一个实例,是没有继承Function的，所以无法访问
Function原型里面的属性。但是,由于在js里面所有对象都是Object的实例，所以，Person函数可以访问到Object原型里面的
属性，Person.b => 'b'

发表于 2018-07-19 20:05:48 回复(16)

牛客526366号

这个问题涉及到js的原型继承

1. f.__proto__ === f[的构造函数].prototype === F.prototype

2. F.prototype.__proto__ === (F.prototype)[的构造函数].prototype === Object.prototype (所以a能够通过f.a访问)

3. f.constructor === F

4. F.__proto__ === F[的构造函数].prototype === Function.prototype (所以b可以通过, f.constructor.b访问到)

注意:

(F.prototype)[的构造函数] === Object

F[的构造函数] === Function

多啰嗦一句( js 的继承靠的是__proto__ ,并不是prototype)

发表于 2017-01-21 18:28:39 回复(22)

todaylg

所有普通对象都源于这个Object.prototype对象，只要是对象，都能访问到a ，而f通过new 关键词进行函数调用，之后无论如何都会返回一个与F关联的普通对象（因为不是通过函数构造创建的对象，所以不是函数对象，也就取不到b了）

发表于 2017-03-29 10:59:23 回复(9)

亭亭如盖矣

浅显一点的方法(非考点): 用instanceof判别，

f instanceof Object // true ;

f instanceof Function //false ;

由此可见用new操作符创建的f只是对象,所以只能继承于Object.prototype.

但是F是多继承，可以通过F.a , F.b拿到a,b的值, 具体原因得用原型链解释

发表于 2017-08-12 17:27:29 回复(4)

Simple53

var F=function(){};
var f=new F();
F.__proto__ ==== Function.prototype;//true
f.__proto__ ==== F.prototype;//true
F.prototype.__proto__ === Object.prototype;//true

f继承的是F的prototype，所以说通过Function.prototype定义的属性相当于定义在F.proto上，可F.proto 与 F.prototype其实没什么关系。所以说f访问不到b,

发表于 2017-08-10 21:10:10 回复(3)

无奈

这张图就可以解释清楚了

发表于 2017-08-11 10:46:18 回复(2)

kayor

function Person(){}
var friend = new Person();

Person.prototype = {
    constructor : Person,
    name : "kayorl",
    sayName : function () {console.log(this.name);}
}

friend.sayName(); //ERROR

根据小红书 P156页,可知原型修改后, 切断了原来原形与更改后原形的关系.

一开始我以为是这样的

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

后来测试了一下,

即,小 f 是个对象, 不是 Function 的实例了

发表于 2017-04-01 20:47:45 回复(3)

imwtr

只要能理解new 构造函数究竟做了什么就行了

1. 创建一个空对象

2. 将空对象的原型设置为构造函数的原型

3. 改变空对象的this指向为构造函数，并执行构造函数，将其中的成员变量更新到空对象中

4. 返回这个空对象

对应的代码类似这样


	var obj  = {};



	obj.__proto__ = F.prototype;



	F.call(obj);



	return obj

所以最后返回的obj只跟Object有关系

1. 本身obj为对象，在成员中找不到a属性，就沿着原型链查找F.prototype，这里也没有，继续沿着链找Object.prototype

2. 所以跟Function链没啥关系

发表于 2018-08-26 00:27:34 回复(1)

codeplay

http://blog.csdn.net/u010582082/article/details/71105140 看这篇博客，能彻底明白这些问题不用谢我

发表于 2017-05-03 10:32:54 回复(0)

张不瓜

new F() 返回的是一个Object，所以f instanceof Function 是false，答案没问题

发表于 2017-03-28 09:58:20 回复(0)

Bytedancer2021

这个问题涉及到js的原型继承

1. f.__proto__ === f[的构造函数].prototype === F.prototype

2. F.prototype.__proto__ === (F.prototype)[的构造函数].prototype === Object.prototype (所以a能够通过f.a访问)

3. f.constructor === F

4. F.__proto__ === F[的构造函数].prototype === Function.prototype (所以b可以通过, f.constructor.b访问到)

-->

f 能取到a，但取不到b

F 能取到a,b

发表于 2019-08-30 23:06:04 回复(0)

摇到外婆桥

f 与其原型

1.1 __proto__是浏览器实现的实例对象访问原型的方式；propertype是构造函数自身的原型属性，也就是构造函数访问原型的方式，所以有

f.__proto__ === F.prototype

1.2 基本上所有的对象最终都是继承于Object（null和undefined没有原型对象），

检查一下f的类型：

f instanceof Object // true ;

f instanceof Function //false ;

由此可见用new操作符创建的f只是对象,所以只能继承于Object.prototype.故而

F.prototype.__proto__==Object.prototype

所以有关于f 的原型链上并没有Function什么事情，所以就不能访问到b

1.3 关于constructor的问题，constructor 属性返回对创建此原型对象的构造函数的引用。

f.__proto__.constructor===F.prototype.constructor //都是function类型的匿名函数 (){}

F.prototype.constructor === F; //在prototype中的constructor的定义

f.constructor === F //这里的f.constructor应该是原型中的

2.F与其原型

2.1 F不是由构造函数创建的，F是一个函数Function类型的数据，所以F是从Function对象继承而来的

F.__proto__ === Function.prototype

2.2同时一切引用类型都是对象，对象是若干属性的集合,

这里可以使用isPrototypeOf方法检验一下,表明Object和Function都是F的原型

Function.prototype.isPrototypeOf(F) //true

Object.prototype.isPrototypeOf(F) //true

所以F最终也是继承于Object

F.__proto__===Object.prototype //false

F.__proto__ === Function.prototype //true

F.__proto__.__proto__===Object.prototype //true

编辑于 2019-01-03 10:59:07 回复(0)

萌儿Qi

因为f并不是Function的“实例”，f instanceof Function返回的是false。

发表于 2017-03-25 11:50:10 回复(0)

🌀落在起风的地方🌀

这题肯定是选A。答案不对。具体解释可参考我写的这个笔记。

https://github.com/Hydraz320/FE.note/blob/master/JS/%E7%BB%A7%E6%89%BF/%E6%9D%A5%E4%B8%AA%E5%85%B7%E4%BD%93%E4%BE%8B%E5%AD%90%E6%84%9F%E5%8F%97%E4%B8%8B.md

发表于 2017-02-23 13:44:55 回复(5)

宋佑廉

所有普通对象都源于这个Object.prototype对象，只要是对象，都能访问到a ，而f通过new 关键词进行函数调用，之后无论如何都会返回一个与F关联的普通对象（因为不是通过函数构造创建的对象，所以不是函数对象，也就 取不到b了 ）

发表于 2018-10-27 14:49:06 回复(0)

nguu

对于F = function(){}：

F.__proto__ = Function.prototype

Function.prototype.__proto__ = Object.prototype

对于f = new F()：

f.__proto__ = F.prototype

F.prototype.__proto__ = Object.prototype

编辑于 2018-05-21 12:33:32 回复(0)

蒲公英想养花

f是F的实例，F才是Function的实例，所以F可以访问a,b，但是f只能访问到a，两者可以访问a是因为引用数据类型本质上都是object类型

发表于 2023-03-29 10:22:43 回复(0)

德志

看图，看图，大神的解释，我的图。

（注：从网上找到了一个很详细的答案）

网上有一道美团外卖的面试题是这样的：  Function.prototype.a = 'a';
Object.prototype.b = 'b';
function Person(){};
var p = new Person();
console.log('p.a: '+ p.a); // p.a: undefined
console.log('p.b: '+ p.b); // p.b: b  问为什么？

有不少同学第一眼看上去就觉得很疑惑，p不是应该继承了Function原型里面的属性吗，为什么p.a返回值是undefined呢？
其实，只要仔细想一想就很容易明白了，Person函数才是Function对象的一个实例，所以通过Person.a可以访问到Function
原型里面的属性，但是new Person()返回来的是一个对象，它是Object的一个实例,是没有继承Function的，所以无法访问
Function原型里面的属性。但是,由于在js里面所有对象都是Object的实例，所以，Person函数可以访问到Object原型里面的
属性，Person.b => 'b'

发表于 2022-03-05 15:28:55 回复(0)

Rober点点

由于 js 里面所有的对象都是 Object 的实例，所以，F 函数可以访问到 Object 原型里面的属性，所以 f 能取到 a
但 new F() 返回来的是一个对象，它是 Object 的一个实例，是没有继承 Function 的，所以无法访问 Function 原型里面的属性，即取不到 b。

发表于 2021-08-18 23:10:59 回复(0)

kinjaze123

Object.prototype.a='a'

Function.prototype.b='b'

var f=new F();

function F(){};

其中，f 是一个对象所以只能访问到对象类型的prototype 所以可以得到 a 但是无法得到 b

F，是一个函数所以可以访问函数类型的prototype，又因为f 是F的一个实例即 F可以通过 __prototo__ 访问到 f 所以F也可访问到对象类型的prototype 所以F可以访问到 a 和 b

发表于 2020-07-31 12:29:57 回复(0)

提交观点

问题信息

来自：盛趣游戏2017校招前...

上传者：牛100

难度：

87条回答 6332收藏 10037浏览

关于这段代码的描述,正确的是：

问题信息

热门推荐

相关试题