JS笔试题（二）

最新推荐文章于 2021-03-18 16:06:24 发布

重阳微噪

最新推荐文章于 2021-03-18 16:06:24 发布

阅读量564

点赞数

分类专栏： js

本文链接：https://blog.csdn.net/weixin_44160385/article/details/107504171

版权

本文主要解析JavaScript笔试题目，涉及原型链、构造函数、变量提升、类方法扩展、深克隆等核心概念。通过实例分析，帮助理解JavaScript中的原型链工作机制、函数调用方式以及对象和数组的操作技巧。

摘要由CSDN通过智能技术生成

JS笔试题（二）

一、原型原型链

(1) 每个函数|构造函数都有一个原型prototype，用来存储公有的属性和方法

(2) 每个原型对象都有一个constructor属性，指向函数本身

(3) 每个实例都有__ proto __ 隐式指向所在类的原型

原型链的机制是：当成员访问的时候，首先查找自身的私有属性，如果没有会隐式查找所在模块原型上的属性和方法，再查不到会一直通过__ proto __ 向上查找，一直找到Object.prototype 为止。最终原型链指向null结束，这种机制称为原型链机制

1、下面代码运行的结果

function fun(){
   
    this.a=0;
    this.b=function(){
   
        alert(this.a);
    }
}
fun.prototype={
   
    b:function(){
   
        this.a=20;
        alert(this.a);
    },
    c:function(){
   
        this.a=30;
        alert(this.a)
    }
}
var my_fun=new fun();  
my_fun.b();
my_fun.c();

结果：

“0” “30”

分析:

类原型的重定向：会失去constructor，原始的原型对象上的属性方法会被新的原型对象覆盖，内置类原型无法重定向

var my_fun=new fun(); => { a:0 , b: function(){ alert(this.a)}}

my_fun.b(); => 此时 this=> my_fun ，所以结果为"0"

my_fun.c(); => 此时my_fun中没有c这个属性，去原型中查找，打印结果为“30”

2、写出下面代码执行输出的结果

function C1(name) {
   
    if (name) {
   
        this.name = name;
    }
}
function C2(name) {
   
    this.name = name;
}
function C3(name) {
   
    this.name = name || 'join';
}
C1.prototype.name = 'Tom';
C2.prototype.name = 'Tom';
C3.prototype.name = 'Tom';
alert((new C1().name) + (new C2().name) + (new C3().name));

结果：

“Tomundefinedjoin”

分析：

考察原型原型链构造函数，函数实例化，参数不传为undefined

new C1().name => 因为name为undefined，所以当前函数内没有name属性，只能去原型对象去找所以结果为"Tom"

new C2().name => 因为name为undefined，所以当前函数内拥有私有属性name为 undefined，结果为undefined

new C3().name => 因为name为undefined，所以当前函数内拥有私有属性name为 “join”，结果为’join’

综上，结果为 alert(“Tom” + undefined + ‘join’) => “Tomundefinedjoin”

3、下面代码运行的结果？

function Fn() {
   
    let a = 1;
    this.a = a;
}
Fn.prototype.say = function () {
   
    this.a = 2;
}
Fn.prototype = new Fn;

let f1 = new Fn;
Fn.prototype.b = function () {
   
    this.a = 3;
};

console.log(f1.a);
console.log(f1.prototype);  // undefined
console.log(f1.b);
console.log(f1.hasOwnProperty('b'));
console.log('b' in f1);
console.log(f1.constructor == Fn);

结果：

分析:

f1 => {

a: 1 ,

__ proto __ : {
 a =1,

 b:function(){  this.a = 3;},

  __ proto __ :   {

          say: func(){this.a = 2;}

          }

    } 
}

console.log(f1.a); => 1

console.log(f1.prototype); => 对象是没有prototype属性的，只有函数才有，结果为undefined

console.log(f1.b); => function(){ this.a =3 }

console.log(f1.hasOwnProperty(‘b’)); => false

console.log(‘b’ in f1); => true

console.log(f1.constructor == Fn); => true

4、写出下面代码执行输出的结果

function Foo() {
   
    getName = function () {
   
        console.log(1);
    };
    return this;
}
Foo.getName = function () {
   
    console.log(2);
};
Foo.prototype.getName = function () {
   
    console.log(3);
};
var getName = function () {
   
    console.log(4);
};
function getName() {
   
    console.log(5);
}
Foo.getName();
getName();
Foo().getName();
getName();
new Foo.getName();
new