JavaScript专项训练 错题集

1、执行以下代码，输出结果为（）

1 2 3 4 5 6 7 8

console.log(1); let a = setTimeout(() => {console.log(2)}, 0); console.log(3); Promise.resolve(4).then(b => {     console.log(b);     clearTimeout(a); }); console.log(5);

A、  1
        2
        3
        4
        5

B、  1
        3
        4
        5

C、  1
        3
        5
        4

D、  1
        3
        5
        4
        2

promise对象的then()方法属于微任务，而setTimeout()定时器函数为宏任务。在执行顺序处理上，js会先执行所有同步代码，然后执行微任务队列中的所有微任务，最后再继续执行宏任务。在本题中，先执行同步代码并输出1 3 5，接着执行Promise.resolve().then()方法，输出4，由于在then()方法内删除了定时器函数，所以不会再输出2，最终输出结果为1 3 5 4，C选项正确。

2、下列window方法中，可以显示对话框的一项是（）

A、confirm()

B、alert()

C、prompt()

D、open()

confirm()显示的是确认框，alert()显示的是警示框，prompt()显示的是对话框，open()用于打开新的窗口或者寻找已命名的窗口

3、以下输出结果为object的是( )

A、typeof null

B、typeof undefined

C、typeof []

D、typeof 5

4、执行下列程序，输出结果为（）

1 2 3 4 5 6 7 8 9

var a = 1; function fn(){     var a = 2;     function a(){console.log(3);}     return a;     function a(){console.log(4);} } var b = fn(); console.log(b);

A、1

B、2

C、f a(){console.log(3);}

D、f a(){console.log(4);}

输出的b值为函数fn内的变量a，在函数fn内部，由于存在变量提升和函数提升，且函数提升会在变量提升之前，因此变量a会先被赋值为函数f a(){console.log(3);}，之后被重新赋值为函数f a(){console.log(4);}，最后被赋值为2，所以b值为2

5、Math.round(-2019.5)的结果是

A、2019

B、-2019

C、2020

D、-2020

Math.round(）函数返回一个数字四舍五入后最接近的整数

如果参数的小数部分大于0.5，四舍五入到相邻的绝对值更大的整数

如果参数的小数部分小于0.5，四舍五入到相邻的绝对值更小的整数

如果参数的小数部分等于0.5，四舍五入到相邻的在正无穷（+∞）方向上的整数。

例：

x=Math.round(2019.49) ;      //2019

x=Math.round(2019.5);         //2020

x=Math.round(-2019.5);        //-2019

x=Math.round(-2019.51);      //-2020

6、请问以下JS代码的输出结果是什么？

1 2 3 4 5 6 7 8 9 10

let a = 1; let obj = {   x: 1 } delete a; delete obj.x; delete 2; console.log(a); console.log(obj.x); console.log(2);

A、1、1、2

B、1、undefined、2

C、1、undefined、undefined

D、undefined、undefined、undefined

delete方法只有在删除对象成员这种引用才有意义，或者说只能删除一种引用即对象成员，其余情况并没有太大的意义，基本都是返回一个布尔值true表示没有错误。

7、下面匹配整数的正则表达式中，正确的是( )

A、(-?[1-9]\d*)|0

B、[1-9]\d*

C、-[1-9]\d*

D、[1-9]\d*|0

（）| 0  括号里面的，或者0
-? 负号不出现或者出现一次
[1-9] 数字1-9
\d 数字0-9，等同于[0-9]
* 前面的不出现或者出现不限次
全部加起来就是：（有负号或者没有负号 数字1-9之间任意一个至少出现一次 数字0-9之间任意一个不出现或者出现任意次数）或者 0
翻译成人话：正负整数或0
已知：整数是正整数、负整数、0的集合

8、运行以下程序

1 2 3 4 5 6 7 8 9 10 11

<script>      var m= 1, j = k = 0;      function add(n) {          return n = n+1;  　 }      y = add(m);      function add(n) {          return n = n + 3;      }  z = add(m);  </script>

y和z的最终结果为:

A、2,4

B、4,4

C、2,2

D、报异常

js里面没有函数重载的概念，在其他语言中（如java）java中，可以存在同名函数， 只要传入的参数数量或者类型不同即可。在js中，定义了两个同名函数后， 后面的函数会覆盖前面定义的函数。结合这道题来说，由于函数声明提升， 所以函数声明会提前，由于存在同名函数，后面的add函数将覆盖第一个add函数， 所以两次调用add()返回的值是相同的。也就是y,z都为4.

9、假设有如下代码，那么a(10)的返回结果是？

1 2 3 4

function a(a){     a^=(1<<4)-1;     return a; }

A、5

B、10

C、15

D、16

1<<4   左移相当于1*2^4=16

a^=16-1=15

a=a^15=10^15

^ 异或运算：

10的二进制00001010

15的二进制00001111

========>00000101  转成十进制：5

（按位异或运算，同为1或同为0取0，不同取1）

10、以上代码输出结果为（      ）

1 2	var str1=new RegExp("e"); document.write(str1.exec("hello"));

A、e

B、null

C、1

D、其他几项都不对

exec() 方法是一个正则表达式方法。

exec() 方法用于检索字符串中的正则表达式的匹配。

该函数返回一个数组，其中存放匹配的结果。如果未找到匹配，则返回值为 null。

本题的exec执行结果是一个数组，但是使用了document.write，所以显示在html中的内容是数组中的元素，即e

11、以下哪些代码执行后i的值为10：

A、let i =1 + {
  valueOf() { return 9; }
};

B、let i = 0;
new Array(10).forEach(() => {
  i++;
});

C、let i = parseInt('0xA');

D、let i = 5;
function a(i) {
  i *= 2;
}
a(i);

B:

forEach方法按升序为数组中含有效值的每一项执行一次 callback函数，那些未初始化的项将被跳过。

new Array(10)创建的数组默认值都是empty，所以回调函数都会被跳过。

D: 

i是形参，，属于局部变量，不影响全局变量i的值

12、以下哪一项正则能正确的匹配网址: http://www.bilibili.com/video/av21061574 （）

A、/^(https?:\/\/)?([a-zA-Z\d]+).bilibili.com\/?video\/av(\D{1,8})\/?$/

B、/^(http:\/\/)?(\w+)\.bilibili\.com\/?video\/av(\d{1,8})\/?$/

C、/^(https?:\/\/)?(\w+)\.bilibili\.com\/?\w*$/

D、/^(http:\/\/)?([a-zA-Z\d]+).bilibili.com\/?video\/av\w*\/+$/

首先，^表示匹配输入的开始，$表示匹配输入的结束

每个选项从前向后看，http都能够严格匹配

?表示匹配某元素0次或1次，这里四个选项都没有问题，能够匹配0次或1次字符s

接下来:严格匹配，\/\/严格匹配两个//

接着往下看，[]表示字符集合，它用在正则表达式中表示匹配集合中的任一字符

A D 选项中的 [a-zA-Z\d] 表示匹配一个小写字母 或者 大写字母 或者 数字

B C 选项中的 \w 表示匹配字母数字或下划线（注意这里比A D中能多匹配下划线类型）

+表示匹配某元素1次或多次，到这里四个选项都能够完美匹配字符www

.可以匹配除了换行符\n \r外的任何字符

接下来我们看选项A，bilibili com video av都严格匹配，而 \D 表示匹配一个非数字字符而非数字字符，av后的数字是无法匹配成功的，A错误

B选项，\d匹配数字，{m,n}表示最少匹配m次，最多匹配n次，\/?能匹配末尾的0个或1个/字符，B正确

C选项，*表示匹配某元素0次或多次，但 \w 并不能匹配字符 /，C错误

D选项，前面都对，错在最后的\/+至少要匹配一个/，而原字符串最后并没有/

13.AngularJS中的服务实质上是

A、网络服务

B、单例对象

C、接口对象

D、函数调用

14、({} + 'b' > {} + 'a')返回值是（）

A、a

B、b

C、ba

D、true

E、false

F、执行报错

在{}+‘b’>{}+'a'中

{}处在语句的起始位置，不会被解析成{}空对象，会被解析为一个表达式，类似于这样

{

}

+‘b’

此时的+‘b’是一个表达式值为NaN

第二个{}并没有处在语句的起始位置，所以会被解析成为空对象

此时的{}+'a' 结果为【object object】a

所以{}+'b'>{}+'a'结果为false

而（{}+'b'>{}+'a'）结果为true

因为上面的表达式解析后的结果是【object object】b >【object object】a 

此时会按照ASCII码进行比较

15.下列语句运行后哪些打印的结果是false（）

A、alert（2<1<3）

B、alert（3 == “3”）

C、alert（null == undefined）

D、alert（null == 0）

一、A选项：

2<1显示false, false在比较运算符中，先被转换为数字0再进行比较，也就是比较0<3，显示true

二、CD选项：

1. 相等性检查==和普通比较符> < >= <=的代码逻辑是相互独立的。

(1) 在进行值的比较值，null会被转化为数字再进行比较

(2) 在相等性检查==中，不能将null和undefined转换为其他任何值，除了它们之间互等外，不会等于任何其他的值。

16、下列不属于JavaScript内置对象的是

A、Math

B、Date

C、RegExp

D、Window

E、Error

JS中，可以将对象分为“内部对象”、“宿主对象”和“自定义对象”三种。

1，内部对象

js中的内部对象包括Array、Boolean、Date、Function、Global、Math、Number、Object、RegExp、String以及各种错误类对象，包括Error、EvalError、RangeError、ReferenceError、SyntaxError和TypeError。

其中Global和Math这两个对象又被称为“内置对象”，这两个对象在脚本程序初始化时被创建，不必实例化这两个对象。

2.宿主对象

宿主对象就是执行JS脚本的环境提供的对象。对于嵌入到网页中的JS来说，其宿主对象就是浏览器提供的对象，所以又称为浏览器对象，如IE、Firefox等浏览器提供的对象。不同的浏览器提供的宿主对象可能不同，即使提供的对象相同，其实现方式也大相径庭！这会带来浏览器兼容问题，增加开发难度。

浏览器对象有很多，如Window和Documen，Element，form，image，等等。

3.自定义对象

顾名思义，就是开发人员自己定义的对象。JS允许使用自定义对象，使JS应用及功能得到扩充

17、下面哪些语句执行结果为true

A、'foo' == new function(){ return String('foo'); };

B、'foo' == new function(){ return new String('foo'); };

C、[] == 0

D、![]

E、!0

构造函数始终会返回一个对象：
 情况1：你写了return {a:xxx} 他就会返回你定义的这个对象
情况2：你没写return 或者你return a 一个基本类型 这两种情况（没写或者return基本类型）它都会默认返回一个对象
a选项返回了一个String 所以构造函数会默认返回一个空对象
b选项返回一个String对象（因为有new 所以是字符串对象）所以构造函数就返回了这个String对象

 

==

情况：对象、字符串、数值、布尔、null、undefined、NaN

1. 如果有一个是对象，另一个不是，则调用valueOf()方法取得其原始值，如果没有则调用toString()方法

2. 如果有一个是字符串，另一个是数值，则转换为数值

3. 有一个是布尔值，则转换为数字

4. null == undefined // true

5. 有一个是NaN就是false

6. 两个对象之间一般不相等，除非是重新赋值

18、关于JavaScript里的xml处理，以下说法正确的是 ()

A、Xml是种可扩展标记语言，格式更规范，是作为未来html的替代

B、Xml一般用于传输和存储数据，是对html的补充，两者的目的不同

C、在JavaScript里解析和处理xml数据时，因为浏览器的不同，其做法也不同

D、在IE浏览器里处理xml，首先需要创建ActiveXObject对象

19、下面这段JavaScript代码的的输出是什么？

1 2 3 4 5 6 7 8 9 10 11 12 13

var myObject = {     foo: "bar",     func: function() {         var self = this;         console.log(this.foo);            console.log(self.foo);            (function() {             console.log(this.foo);                console.log(self.foo);            }());     } }; myObject.func();

A、bar bar bar bar

B、bar bar bar undefined

C、bar bar undefined bar

D、undefined bar undefined bar

1.第一个this.foo输出bar，因为当前this指向对象myObject。 2.第二个self.foo输出bar，因为self是this的副本，同指向myObject对象。 3.第三个this.foo输出undefined，因为这个IIFE(立即执行函数表达式)中的this指向window。 4.第四个self.foo输出bar，因为这个匿名函数所处的上下文中没有self，所以通过作用域链向上查找，从包含它的父函数中找到了指向myObject对象的self。

20、下列关于 JavaScript 模块化的描述，错误的是（）

A、AMD推崇依赖前置，CMD推崇依赖就近

B、Sea.js遵循AMD规范，RequireJS遵循CMD规范

C、主流的模块化包括CommonJS,AMD,CMD等

D、模块化有利于管理模块间的依赖，更依赖模块的维护

AMD 是 RequireJS 在推广过程中对模块定义的规范化产出，而CMD 是 SeaJS 在推广过程中对模块定义的规范化产出，也就是，RequireJS遵循AMD规范，而Sea.js遵循CMD规范，故B选项说法错误，其他选项的说法均正确。

21、下列不属于document对象方法的是？

A、onload

B、querySelectorAll

C、children

D、ajax

A.onload 为 document 对象的属性，而不是方法：onload是属于window的事件

C. ParentNode.children 是一个只读属性，返回一个节点的子元素，是一个动态更新的 HTMLCollection 类型。不是 document 对象的方法。

D. AJAX不是JavaScript的规范，它只是一个缩写：Asynchronous JavaScript and XML，意思就是用JavaScript执行异步网络请求。在现代浏览器中主要依靠 XmlHttpRequest 对象

22、在标准的 JavaScript 中， Ajax 异步执行调用基于下面哪一个机制才能实现？

A、Event和callback

B、多线程操作

C、多CPU核

D、Deferral和promise

JavaScript是单线程的，浏览器实现了异步的操作，整个js程序是事件驱动的，每个事件都会绑定相应的回调函数

23.执行以下程序，输出结果为（）

function fn(o,val){

           o.b = 1;

           val = 1;

}

var obj = {b:0};

var num = 0;

fn(obj,num);

console.log(obj,num);

A、{b:0} 0

B、{b:1} 0

C、{b:0} 1

D、{b:1} 1

js传参包括基本数据类型传参和复杂数据类型传参，基本数据类型传参实际上是复制值传递，函数对形参的处理不会影响到外面的实参，而复杂数据类型传参是引用传递，即把数据的地址复制一份后传递到函数中，此时形参和实参指向同一地址的对象，对于形参的修改会影响到实参。在本题中，obj是使用引用传递，num是使用值传递，因此最终结果为B选项。

24.在严格模式下执行以下选项的程序，不会抛出异常的是（）

A、uname = 'window';

setTimeout(function(){

console.log(this.uname)

},1000);

B、var uname = 'window';

(function(){console.log(this.uname)}());

C、function fn(a,a){

console.log(a+a);

}

fn(1,1);

D、var uname = 'window'

function Person(){console.log(this.uname);}

var p = new Person();

25.以下哪些对象是Javascript内置的可迭代对象？

A、Array

B、Map

C、String

D、Object

JavaScript的可迭代对象

1）数组Arrays

console.log([][Symbol.iterator])   for(let x of ['a','b'])    

 console.log(x)

2）字符串Strings

console.log(""[Symbol.iterator]) for(let x of "abc")    

 console.log(x)

3）Map let map = new Map().set('a', 1).set('b', 2);

console.log(map[Symbol.iterator]);

for (let pair of map) 

{     console.log(pair); }

4）Set let set = new Set().add('a').add('b');

for (let x of set) {     console.log(x); }

5）arguments

function printArgs() {     for (let x of arguments) {         console.log(x);     } }

printArgs('a', 'b');

6）Typed Arrays

7）Generators，ES6新增加

26、如下代码输出的结果是什么：

1 2 3 4

console.log(1+ "2"+"2"); console.log(1+ +"2"+"2"); console.log("A"- "B"+"2"); console.log("A"- "B"+2);

A、122 122 NaN NaN

B、122 32 NaN NaN2

C、122 32 NaN2 NaN

D、122 32 NaN2 NaN2

1.

console.log(1+ "2"+"2");

做加法时要注意双引号，当使用双引号时，JavaScript认为是字符串，字符串相加等于字符串合并。
因此，这里相当于字符串的合并，即为122.

2.

console.log(1+ +"2"+"2");

第一个+"2"中的加号是一元加操作符，+"2"会变成数值2，因此1+ +"2"相当于1+2=3.
然后和后面的字符串“2”相合并，变成了字符串"32".

3.

console.log("A"- "B"+"2");

"A"-"B"的运算中，需要先把"A"和"B"用Number函数转换为数值，其结果为NaN，在剪发操作中，如果有一个是NaN，则结果是NaN，因此"A"-"B"结果为NaN。
然后和"2"进行字符串合并，变成了NaN2.

4.

console.log("A"- "B"+2);

根据上题所述，"A"-"B"结果为NaN，然后和数值2进行加法操作，在加法操作中，如果有一个操作数是NaN，则结果为NaN。

27.执行以下程序，输出结果为（）

1 2 3

var one; var two = null; console.log(one == two,one === two);

A、true false

B、true true

C、false false

D、false true

E、抛出异常

变量one只声明未赋值，所以其值为undefined，在使用“==”对undefined和null进行比较时，不能将null和undefined转换成其他任何值，并且规定undefined == null返回结果为true，而使用“===”进行比较时，由于“===”需要严格区分数据类型，故undefined === null返回结果为False，A选项正确。

28.以下哪个选项的描述是错误的

A、iframe是用来在网页中插入第三方页面，早期的页面使用iframe主要是用于导航栏这种很多页面都相同的部分，这样在切换页面的时候避免重复下载

B、iframe的创建比一般的DOM元素慢了1-2个数量级

C、iframe标签会阻塞页面的的加载

D、iframe本质是动态语言的Incude机制和利用ajax动态填充内容

ifreme本身不是动态语言，样式和js需要额外导入。其加载完成之后才会加载windis的onload事件

29.当在手机中需要保存移动手机号码时，怎样才能知道输入的手机号就是11位的移动手机号（      ）

A、var filt=/^1[0-9]{10}$/;
if(!filt.test(str))
{
  alert("手机号输入错误");
}

B、var filt=^1[0-9]{10};
if(!filt.test(str))
{
  alert("手机号输入错误");
}

C、var filt=/^[0-9]{10}/;
if(!filt.test(str))
{
  alert("手机号输入错误");
}

D、var filt=/^1[0-9]/;
if(!filt.test(str))
{
alert("手机号输入错误");
}

^1表示1开头，[0-9]{10}表示0-9的数字出现十次，$为结束标记

30.以下哪些操作会触发Reflow：

1	var obj = document.getElementById(“test”);

A、alert(obj.className)

B、alert(obj.offsetHeight)

C、obj.style.height = “100px”

D、obj.style.color = “red”

正确答案： BC。

B计算了offsetHeight，C重新设置了高度。

A打印出类名，无影响。

D重新设置背景，引起重绘。

reflow(回流)和repaint(重绘)

简要：整个在浏览器的渲染过程中（页面初始化，用户行为改变界面样式，动画改变界面样式等）reflow(回流)和repaint(重绘) 会大大影响web性能，尤其是手机页面。因此我们在页面设计的时候要尽量减少reflow和repaint。

reflow：例如某个子元素样式发生改变，直接影响到了其父元素以及往上追溯很多祖先元素（包括兄弟元素），这个时候浏览器要重新去渲染这个子元素相关联的所有元素的过程称为回流。

reflow：几乎是无法避免的。现在界面上流行的一些效果，比如树状目录的折叠、展开（实质上是元素的显 示与隐藏）等，都将引起浏览器的 reflow。鼠标滑过、点击……只要这些行为引起了页面上某些元素的占位面积、定位方式、边距等属性的变化，都会引起它内部、周围甚至整个页面的重新渲 染。通常我们都无法预估浏览器到底会 reflow 哪一部分的代码，它们都彼此相互影响着。

repaint：如果只是改变某个元素的背景色、文 字颜色、边框颜色等等不影响它周围或内部布局的属性，将只会引起浏览器 repaint（重绘）。repaint 的速度明显快于 reflow

下面情况会导致reflow发生

1：改变窗口大小

2：改变文字大小

3：内容的改变，如用户在输入框中敲字

4：激活伪类，如:hover

5：操作class属性

6：脚本操作DOM

7：计算offsetWidth和offsetHeight

8：设置style属性

31.以下代码执行后，array的结果是？

1 2	var array=[-1,1,3,4,6,10]; array.sort((a,b)=>Math.abs(a-3)-Math.abs(b-3));

A、[10,-1,6,1,4,3]

B、[10,6,4,3,1,-1]

C、[3,4,1,6,-1,10]

D、[-1,1,3,4,6,10]

sort() 方法用于对数组的元素进行排序，参数决定排序的顺序。

• 原数组var array=[-1,1,3,4,6,10];
• 参数(a,b)=>Math.abs(a-3)-Math.abs(b-3)：即数值减3的绝对值[4，2，0，1，3，7]作为参数决定排序。
• 根据绝对值减3大小排列[0，1，2，3，4，7]，对应的原数组排序后为[3，4，1，6，-1，10]

32.在JavaScript中，文本域不支持的事件包括（）

A、onlostFocused

B、onfocus

C、onchange

D、onblur

js并没有onlostFocused事件，文本域自然也没有onlostFocused事件，当文本域失去焦点时触发的事件称为onblur事件，故A选项符合题意，D选项不符合题意；当文本域聚焦时触发的事件为onfocus事件，B选项不符合题意；当文本域失去焦点时，如果此时文本域的文本内容与聚焦时的文本内容不一样，就会触发onchange事件，C选项不符合题意。

33.执行以下程序，输出结果为（）

1 2 3 4 5 6

var datas=[10,20,30]; datas.unshift(40,50);  datas.pop(); datas.push(60,70);  datas.shift(); console.log(datas.toString());

A、50,10,20,60,70

B、40,10,20,60,70

C、10,20,30

D、50,10,20,60

array.unshift()用于将新元素添加到数组的开头，如果参数有多个，它们作为整体一块插入，所以执行datas.unshift(40,50)后，数组datas为[40,50,10,20,30]，而不是[50,40,10,20,30]；array.pop()表示移除数组的最后一个元素，并将该元素返回，执行该方法后datas数组为[40,50,10,20]；array.push()表示在数组末尾追加元素，同理，如果参数有多个，会作为整体一块在末尾追加，执行该方法后数组datas为[40,50,10,20,60,70]；array.shift()表示删除数组的第一个元素，并将该元素返回e，执行该方法后，数组datas为[50,10,20,60,70]，故正确答案为A选项。

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

1 2 3 4 5 6 7 8 9 10 11 12 13

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);

A、1、2、3、4

B、1、undefined、3、4

C、1、undefined、undefined、undefined

D、undefined、2、3、4

首先需要明确new方法返回的是构造函数的prototype也就是一个对象，其中直接给对象上不存在的a变量赋值相当于往这个对象添加了一个a变量，因此B可以访问到变量a，但是后续是直接赋值了一个对象，那么原对象就无法感知到了，所以B访问不到新对象的变量b，也因此产生了新旧两个prototype的引用。C的话拿到的是新对象以及往新对象里面新增的d变量。

35.

1 2 3 4

var arr=[{a:1},{}]; arr.forEach(function(item,idx){     item.b=idx; });

上面代码执行后， arr 的值是：（）

A、[{a:1},{}]

B、[{a:1,b:0},{b:1}]

C、[{a:1,b:1},{b:1}]

D、[{a:!,b:0},{b:0}]

arr.forEach（a,b,c）

这个函数用于数组的遍历，其中三个参数abc意义如下

a代表arr[0]---arr[arr.length-1]

b代表0---arr.length-1

c代表arr

//参数c被省略了

所以第一次循环 a={a:1} , b=0;

执行a.b = 0 后，以为a是一个对象，即给对象啊添加一个b属性，值为0 得到[{a:1,b:0},{}]

第二次循环也是这个意思

36.

var a =[1,4,5,2,9];
下面求a中最大值的代码正确的是

A、Math.max(a)

B、Array.max(a)

C、Math.max.call(null,a)

D、Math.max.apply(null,a)

E、以上均不是

Max是Math对象的方法，由于a是一个数组对象，而Max又是一个Math对象，所以在返回最大值的同时需要指名返回的值属于哪种对象，只要指定了一个真实存在的对象，就会返回最大值。call和apply的第一个参数都是this指向，而call从第二个参数开始，代表了第一个要计算的实参，以此类推，第三个参数就是第二个实参。。。第n个代表n-1个实参。和apply的区别仅在于，apply把除了第一个参数之后的所有参数，都纳入一个数组里。

37.Alert(1&&2)的值是？

A、1

B、2

C、FALSE

D、TRUE

&& 运算，如果前面值为true,则结果为后面的值。如果前面值为false,则值为前值.

|| 运算，如果前面值为true,则结果为前面的值,如果前面的值为false,则结果为后面的值。

38.下列哪些事件不支持冒泡?（）

A、resize

B、click

C、blur

D、mouseleave

“俺（unload）”“妈（mouseenter） 妈（mouseleave） 不（blur） 让（resize） 浪（load） 费（focus）”

39.

1 2 3 4 5 6 7 8 9 10

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);

以上代码，在浏览器中执行的结果是

A、9999 8889

B、10000 8888

C、4400 8889

D、9999 4400

E、4400 4400

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

40.以下代码执行后的输出是？

1 2 3 4 5

var arr = []; arr[0] = 0; arr[1] = 1; arr.foo = 'c'; console.log(arr.length);

A、报错

B、3

C、2

D、undefined

.foo 跟.length地位是并列的：就是arr的一个属性，同时arr的数组方法跟这些属性是毫不相关

41.下列哪些会返回false？

A、null

B、undefined

C、0

D、'0'

关于js的类型转换（强制类型和隐式类型）

转 boolean 规则：

null, undefined, "", 0, -0, NaN 转换成布尔值是false， 剩下的全转化 true;

转 number 规则：

string  '2.3.1' => NaN;

null, '', false, [] ==>> 0;

undefined => NaN;

object => x    Number(object.toString())

隐式类型转换 ==

1、有布尔值则转换为数值

2、字符串数值，则字符串转换为数值

3、只有一个是对象，则toString() valueOf()

4、null == undefined

5、NaN != NaN

6、对象==，比较内存地址

42.以下表达式不会出现错误的有（）

A、2.toString()

B、2..toString()

C、2 .toString()

D、(2).toString()

数字后面.会被解析为小数点，而B、C、D则规避了这种情况。

43.XMLHttpRequest对象在调用send()前需要调用哪个方法？

A、prepare ()

B、open ()

C、init ()

D、build ()

Ajax技术核心就是XMLHttpRequest对象。

Ajax技术的工作原理：可以分成3步

1.创建Ajax对象：var xhr = new XMLHttpRequest();

2.xhr 发送请求：xhr.open('get','test.html','true');

                          xhr.send();

3.xhr获取响应：

                          xhr.onreadystatechange = function(){

                                   if(xhr.readystate == 4){//请求的状态码

                                                       /*

                                                        0:请求还没有建立（open执行前）

                                                        1：请求建立了还没发送（执行了open）

                                                        2：请求正式发送（执行了send）

                                                        3：请求已受理，有部分数据可以用，但还没有处理完成

                                                        4：请求完全处理完成

                                                           */

                                         alert(xhr.responseText);//返回的数据

                                     }

                             }

可以看到，send()前是open()

44.请问以下JS代码会做什么样的输出

1 2 3 4 5 6 7 8 9 10

let a = 'w' let obj = {   a: 'o',   print: function() {     console.log(this.a);   }, } let p = obj.print; obj.print(); p();

A、o、o

B、w、w

C、o、w

D、o、undefined

首先明确this指向无法传递，所以函数p的this是指向window，同时因为let声明的变量不会挂载到window上所以是window下的a变量只能是undefined。至于obj.print方法this指向的是obj所以输出的是obj里面的变量a的值即o。

45.下面有关JavaScript中call和apply方法的描述，错误的是？

A、call与apply都属于Function.prototype的一个方法，所以每个function实例都有call、apply属性

B、两者传递的参数不同，call函数第一个参数都是要传入给当前对象的对象，apply不是

C、apply传入的是一个参数数组，也就是将多个参数组合成为一个数组传入

D、call传入的则是直接的参数列表。call 方法可将一个函数的对象上下文从初始的上下文改变为由 thisObj 指定的新对象。

1、每个函数都包含两个非继承而来的方法：apply()和call()。 

2、他们的用途相同，都是在特定的作用域中调用函数。 

3、接收参数方面不同，apply()接收两个参数，一个是函数运行的作用域(this)，另一个是参数数组。

                     call()方法第一个参数与apply()方法相同，但传递给函数的参数必须列举出来。 

46.请给出下面这段代码的运行结果（ ）

1 2 3 4 5 6 7 8 9

<SCRIPT LANGUAGE="JavaScript"> var bb = 1; function aa(bb) {     bb = 2;     alert(bb); }; aa(bb); alert(bb); </SCRIPT>

A、1 1

B、1 2

C、2 1

D、2 2

function aa(bb) {     bb = 2;     alert(bb); }; 在aa函数中，bb是以传值的方式传入的，在函数中，会重新定义一个bb变量，并将其值覆为2，并不影响函数体外的bb变量，所以其值仍然为1.

47.执行以下程序，当用户在prompt输入框中输入0时，输出结果为（）

1 2 3 4 5 6 7 8 9 10 11 12

var num = prompt('请输入分母:') try{   console.log('a');   value = 0 / num;   console.log('b'); } catch(e){   console.log('c'); } finally{   console.log('d'); }

A、a c d

B、a b d

C、a b c d

D、a b c

当用户输入0时，会导致分母为0。虽然在绝大多数编程语言中，0是不能作为分母，但在js中，0是可以作分母的，0/0的结果为NaN，并不会抛出异常，因此会执行try块中所有代码，输出a b，并且由于没有异常的发生不会执行catch块，不管有没有异常，finally块都会执行的，因此最终输出结果为a b d，B选项正确。

48.JS中存在块语句，那么请问以下块语句的集合最终输出的值是多少？

1 2 3 4 5 6 7 8

eval(`{       1 + 3;       a = 2;       x:break x;        3;       4 + 6;       ;    }`)

A、4

B、undefined

C、10

D、3

在块中多个语句执行时，一般后者会覆盖前者，但是；和break的返回值都是empty，无法覆盖任何值。而3覆盖了4，10最终又覆盖了3，因此最终的结果是10。

49.执行以下程序，下列选项中，说法错误的是（）

function fn(value){

console.log(arguments instanceof Array); ...①

console.log(arguments.length);...②

console.log(value);...③

var arr = [...arguments];...④

}

fn(1,2,3);

A、①式的输出结果为false

B、②式输出结果为2

C、③式的输出结果为1

D、④式可以利用arguments对象新生成一个数组

arguments是函数（除了箭头函数外）的内置对象，它是一个伪数组，因此①式结果为false；arguments对象用来获得函数的全部实参，因此②式输出结果为3而非2；value是函数的形参，匹配第一个实参，因此③式输出结果为1；④式是参数解构，可以新生成一个真正意义上的数组。

50.假设DOM结构为：
<div id="a"><div id="b"></div></div>
JS代码为：

1 2	document.getElementById('a').addEventListener('click', e => {console.log(1)}); document.getElementById('b').addEventListener('click', e => {e.preventDefault();console.log(2)});

当点击id为b的div时，控制台输出的内容是：

A、1
      2

B、2
      1

C、1

D、2

知识点有四个

1.事件冒泡。

2.addEventListener是有第三个可选参数的，默认为false，意思是不在捕获阶段提前触发。

3.preventDefault()是阻止事件的默认操作，比如点submit之后会提交表单。类似的属性是returnValue=false

4.阻止冒泡的方法是，e.stopPropagation()或者e.cancelBubbe

按照W3C的标准，是先捕获，再冒泡。但是 addEventListener 的第三个参数是用来设置回调函数是在捕获时触发，还是在冒泡时触发，默认为false，即冒泡时触发，也就是说上面两个回调函数先执行第二个，再执行第一个。

但是有一点需要注意：虽然W3C标准是先执行捕获，再执行冒泡，但这是对多个元素而言的。如果对一个元素的某个事件同时设置了捕获和冒泡，那么具体的执行顺序和事件的注册顺序是一样的，谁先注册，谁先执行，我想是和事件循环有关。

51.请问以下JS代码输出结果是什么？

1 2 3

console.log(typeof ''.prototype); console.log(typeof ''.__proto__);  console.log(typeof ''.__proto__ === typeof ''.prototype);

A、object、object、true

B、undefined、undefined、true

C、undefined、object、false

D、object、undefined、false

针对本题，咱们先理解 prototype和__proto__ 的关系。

主要有以下三点：

1）函数（或构造函数）身上才有 prototype （prototype名字叫原型，原型是一个对象）；

2）而其他任何通过构造函数实例化出来的对象(不包括null、undefined）身上都有 __proto__（__proto__是隐式原型，隐式原型也一个对象）

3）实例化对象的__proto__ 就是 构造函数的 prototype   （===关系）

附：undefind 和 null 既没有prototype也没有 __proto__  ，因为它俩不是函数，也不是函数实例化出来的对象

具体说明如下：

1）函数（或构造函数）身上才有 prototype （prototype名字叫原型，原型是一个对象）；

例如：String、Number、Boolean、Array、Object

2）而其他任何通过构造函数实例化出来的对象(不包括null、undefined）身上都有 __proto__（__proto__是隐式原型，隐式原型也一个对象）

例如： 'a' 是通过String函数实例化出来的对象（这里包括以下说的对象不是Objcet数据类型）

            4 是通过Number函数实例化出来的对象

            true是通过Boolean函数实例化出来的对象

            [1,2,3]是通过Array函数实例化出来的对象

            {}是通过Objec函数实例化出来的对象

3）实例化对象的__proto__ 就是 构造函数的 prototype

例如：'a'.__proto__ === String.protptype            //true

           true.__proto__  ===  Boolean.prototype   //true 

52.void();

上面表达式的结果是：

A、undefined

B、TypeError

C、null

D、SyntaxError

typeof  1; //'number'
typeof (1);//'number'
typeof (); //SyntaxError 语法错误

void  0; //undefined
void (0);//undefined
void (); //SyntaxError 语法错误

53.下面哪个不是RegExp对象的方法？（）

A、test

B、match

C、exec

D、compile

JavaScript RegExp 对象有 3 个方法：test()、exec() 和 compile()。
(1) test() 方法用来检测一个字符串是否匹配某个正则表达式，如果匹配成功，返回 true ，否则返回 false；
(2) exec() 方法用来检索字符串中与正则表达式匹配的值。exec() 方法返回一个数组，其中存放匹配的结果。如果未找到匹配的值，则返回 null；
（3）compile() 方法可以在脚本执行过程中编译正则表达式，也可以改变已有表达式。

54.关于W3C制定的 JavaScript 标准事件模型，以下正确的顺序以及描述是

A、事件捕获>事件冒泡

B、事件捕获->事件处理->事件冒泡

C、事件冒泡->事件处理

D、事件冒泡->事件处理->事件捕获

E、事件处理->事件捕获->事件冒泡

"DOM2级事件"规定事件流的三个阶段：事件捕获阶段、处于目标阶段和事件冒泡阶段。首先发生的是事件捕获，为截获事件提供了机会；然后是实际的目标接收到事件；最后一个阶段是冒泡阶段，可以在这个阶段对事件作出响应。

55.如果以下程序的输出结果是false，则①式可以替换为（）

1 2 3 4 5 6 7 8 9

const test = {   rules: false }; function Build() {     this.rules = true;         ① } const build = new Build(); console.log(build.rules);

A、return false;

B、return this.rules;

C、return test;

D、什么都不做

1、在构造函数里面，如果不写return的话默认就是返回创建的实例对象。

2、在构造函数里面，如果写了return的话，

        1）如果return的是一个基本数据类型的话比如，boolean,number,undefined等那么仍然返回实例对象；

        2）如果return的是一个对象的话，则返回该对象。原本的指向实例对象的this会被无效化。

情况一：return false  （return基本数据类型，仍然返回实例化对象）

情况二：return this.rules   （return基本数据类型，仍然返回实例化对象）

情况三：return test    （return对象test，返回对象test）

情况四：什么都不做 （不写return，默认返回创建的实例对象。）

56.下列代码中，页面打开后能够弹出1的是？

A、<iframe src=”javascript: alert(1)”></iframe>

B、<img src=”” οnerrοr=”alert(1)”/>

C、IE下<s style=”top:expression(alert(1))”></s>

D、<div οnclick=”alert(1)”></div>

A 加载页面的时候触发； B onerror   事件 当图片不存在时,将触发； C 在ie 7下会连续弹出， IE5及其以后版本支持在CSS中使用expression，用来把CSS属性和Javascript表达式关联起来，这里的CSS属性可以是元素固有的属性，也可以是自定义属性。就是说CSS属性后面可以是一段Javascript表达式，CSS属性的值等于Javascript表达式计算的结果。 在表达式中可以直接引用元素自身的属性和方法，也可以使用其他浏览器对象。这个表达式就好像是在这个元素的一个成员函数中一样。参考资料 http://www.blueidea.com/tech/site/2006/3705.asp D 不可以,因为div里没有内容，盒子的宽度为0所以点击不了的；

57.以下哪些表达式的值为0？

A、(()=>{}).length

B、1 & 2

C、+[]

D、[1,2,-3].reduce((a, b) => a - b, 0)

• (()=>{}).length; 获取方法形参个数，形参为0
• 1=0001 2=0010  按位与运算，同为1才为1，否则返回0
• +[] 隐式类型转换，因为[]是对象，所以toPrimitive->valueOf->toString为''，结果就是+''===0
• reduce对数组中的每个元素执行一个reducer函数(升序执行)，将其结果汇总为单个返回值。a为累计器累计回调的返回值，b为数组的每一项元素，传入初始值0->0-(1)->(-1)-2->(-3)-(-3)->0

58.正则表达式语法中 \d 匹配的是？（）

A、数字

B、非数字

C、字母

D、空白字符

\d      匹配一个数字字符。等价于 [0-9]。
\D     匹配一个非数字字符。等价于 [^0-9]。
\f       匹配一个换页符。等价于 \x0c 和 \cL。
\n      匹配一个换行符。等价于 \x0a 和 \cJ。
\r       匹配一个回车符。等价于 \x0d 和 \cM。
\s      匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
\S      匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\t       匹配一个制表符。等价于 \x09 和 \cI。
\v      匹配一个垂直制表符。等价于 \x0b 和 \cK。
\w     匹配字母、数字、下划线。等价于'[A-Za-z0-9_]'。
\W    匹配非字母、数字、下划线。等价于 '[^A-Za-z0-9_]'。

59.下面哪一个不是 JavaScript 的保留字？

A、goto

B、abstract

C、implements

D、super

E、array

保留字

（字母排序）

abstract

boolean break byte

case catch char class const continue

debugger default delete do double

else enum export extends

false final finally float for function

goto

if implements import in instanceof int interface

long

native new null

package private protected public

return

short static super switch synchronized

this throw throws transient true try typeof

var void volatile

while with

60.执行以下程序，下列选项中，说法正确的是（）

1 2 3 4 5 6 7 8 9

class Dog{   static dog(){     console.log(this); ...①     }   bark(){     console.log('狗会叫');     } } var dog = new Dog();

A、①式的this指代类的实例对象

B、调用dog方法，既可以使用Dog.dog()，也可以使用dog.dog()

C、调用bark方法，只能使用dog.bark()，不能使用Dog.bark()

D、在类中，不允许静态方法和非静态方法重名

dog方法为静态方法，bark方法为实例方法，静态方法本身不能使用实例对象来调用，所以this不会指向实例对象，A选项错误；静态方法只能由类进行调用，实例方法只能由实例对象进行调用，B选项错误，C选项正确；D选项，由于类内部的静态方法的调用者只能为类，实例方法的调用者只能为实例对象，不会在调用时造成歧义，因此允许重名。

61.下列说法正确的是()

A、每个JS对象一定对应一个原型对象，并从原型对象继承属性和方法

B、对象的__proto__指向自己构造函数的prototype

C、Object.prototype. __proto__=== null，说明原型链到Object.prototype终止

D、表达式 Function.prototype.__proto__.__proto__ === null 的运行结果为true

Function.prototype.__proto__ === Object.prototype // true

Object.prototype.__proto__ === null // true

所以 Function.prototype.__proto__.__proto__ === null // true

62.语句var arr=[a,b,c,d];执行后，数组arr中每项都是一个整数，下面得到其中最大整数语句正确的是哪几项？

A、Math.max(arr)

B、Math.max(arr[0], arr[1], arr[2], arr[3])

C、Math.max.call(Math, arr[0], arr[1], arr[2], arr[3])

D、Math.max.apply(Math,arr)

Math.max(args...)传入参数是任意数量的值

A  传入数组,所以错误

B  可以

C  Function.call()可以传入任意多个参数,C正确

D  Function.apply()第二个参数以数组形式传递,D正确

63.下面的语言中哪些语言是动态语言(       )

A、C

B、JavaScript

C、C++

D、CSS

E、Java

F、Objective-C

64.下面哪些属于JavaScript的typeof运算符的可能结果：（）

A、symbol

B、int

C、boolean

D、null

E、array

F、undefined

G、string

65.以下 JavaScript 代码，在浏览器中运行的结果是

1 2 3 4 5 6 7 8 9

function foo(){     console.log('first');     setTimeout(function (){         console.log('second');     },5); } for(var i=0;i< 4399999999;i++) {     foo(); }

A、first,second,first,second..依次顺序输出

B、首先全部输出first，然后全部输出second

C、first，second无顺序输出

D、首先输出first，超出5ms输出所有second，最后输出余下的first

JS单线程,而 setTimeout 是异步执行, 解释器会先执行后面的代码,然后再去执行定时器那块代码

66.下面有关JavaScript内部对象的描述，正确的有？

A、History 对象包含用户（在浏览器窗口中）访问过的 URL

B、Location 对象包含有关当前 URL 的信息

C、Window 对象表示浏览器中打开的窗口

D、Navigator 对象包含有关浏览器的信息

Navagator：提供有关浏览器的信息

Window：Window对象处于对象层次的最顶层，它提供了处理Navagator窗口的方法和属性 Location：提供了与当前打开的URL一起工作的方法和属性，是一个静态的对象

History：提供了与历史清单有关的信息

Document：包含与文档元素一起工作的对象，它将这些元素封装起来供编程人员使用

67.触摸事件包括以下哪几种？（）

A、touchStart

B、touchMove

C、touchCancel

D、touchEnd

以下是四种touch事件

touchstart:     //手指放到屏幕上时触发

touchmove:      //手指在屏幕上滑动式触发

touchend:    //手指离开屏幕时触发

touchcancel:     //系统取消touch事件的时候触发，这个好像比较少用

68.下面哪一个语句可以实现在jQuery中找到所有元素的同辈元素？

A、eq(index)

B、find(expr)

C、siblings([expr])

D、next()

jQuery siblings() 方法

siblings() 方法返回被选元素的所有同胞元素。

下面的例子返回 <h2> 的所有同胞元素：

实例

$(document).ready(function(){
  $("h2").siblings();
});

下面的例子返回属于 <h2> 的同胞元素的所有 <p> 元素：

实例

$(document).ready(function(){
  $("h2").siblings("p");
});

jQuery next() 方法

next() 方法返回被选元素的下一个同胞元素。

该方法只返回一个元素。

下面的例子返回 <h2> 的下一个同胞元素：

实例

$(document).ready(function(){
  $("h2").next();
});

jQuery find() 方法

find() 方法返回被选元素的后代元素，一路向下直到最后一个后代。

下面的例子返回属于 <div> 后代的所有 <span> 元素：

实例

$(document).ready(function(){
  $("div").find("span");
});

69.执行以下程序，输出结果为（）

1 2 3 4

function a(){   console.log(this); }  a.call(null);

A、document

B、null

C、window

D、a

E、undefined

call/apply用来改变函数的执行上下文（this），它们的第一个参数thisArg是个对象，即作为函数内的this。有两种情况需要注意，传null或undefined时，将是JS执行环境的全局变量。浏览器中是window，其它环境（如node）则是global。

70.下列哪些函数是JavaScript的全局函数？

A、encodeURI

B、parseFloat

C、setTimeout

D、eval

6（编码相关）+ 2（数据处理）+ 4（数字相关）+ 1（特殊）

编码相关：

    escape()、unescape()、encodeURI()、decodeURI()、

    encodeURIComponent()、decodeURIComponent()

数据处理：

    Number()、String()

数字相关：

    isFinite()、isNaN()、parseFloat()、parseInt()

特殊：

    eval()

71.执行以下程序后，x的值为（）

1 2 3 4 5 6

var x=0;   switch(++x) {       case 0: ++x;       case 1: ++x;       case 2: ++x;   }

A、1

B、2

C、3

D、4

++x是前置自增，也就是先自增加1，再将x返回，所以switch表达式的值为1，匹配第二个case语句，同样对x进行前置自增，x的值变为2，由于没有使用break语句，在成功匹配后，会继续往下执行后面的case语句，也就是继续执行第三个case语句，最终x值为3，C选项正确。

72.以下哪些语句触发了隐式的类型转换？

A、parseInt(12.34, 10)

B、0 ? 1 : 2

C、2e1 * 0xaa

D、1 + '1'

1. parseInt() 函数可解析一个字符串，并返回一个整数。 所以说，number类型的12.34发生隐式转换为string。
2. 三元运算符，会判断?前的表达式为true或者false。所以number类型的0发生了隐式转换为boolean。
3. +运算发生了字符串的隐式转化。原本number类型的1，和string类型的'1'进行了+运算，连接了字符串。返回'11'。

• C选项： e是js里面指数的一种表示形式。也就是10的多少次方。 2e1 等价于 2 *（10^1） = 20 2e2 等价于 2 *（10^2）= 200 0xaa是16进制的表示方法。相当于十进制的170。 这里都是number类型，发生了数字的乘法运算：20*170，没有发生类型转换。

73.以下哪些事件会在页面加载完成（onload）之前触发？

A、readystatechange

B、pageshow

C、beforeunload

D、DOMContentLoaded

1. A. readystatechange document有readyState属性来描述document的loading状态，readyState的改变会触发readystatechange事件.
   • loading 文档仍然在加载
   • interactive 文档结束加载并且被解析，但是像图片，样式，frame之类的子资源仍在加载
   • complete 文档和子资源已经结束加载，该状态表明将要触发load事件。

因此readystatechange在onload之前触发。

        B.onpageshow onpageshow 事件在用户浏览网页时触发。 onpageshow 事件类似于 onload 事件，onload 事件在页面第一次加载时触发， onpageshow 事件在每次加载页面时触发，即 onload 事件在页面从浏览器缓存中读取时不触发。

        C. beforeunload 当浏览器窗口，文档或其资源将要卸载时，会触发beforeunload事件。这个文档是依然可见的，并且这个事件在这一刻是可以取消的. 如果处理函数为Event对象的returnValue属性赋值非空字符串，浏览器会弹出一个对话框，来询问用户是否确定要离开当前页面（如下示例）。有些浏览器会将返回的字符串展示在弹框里，但有些其他浏览器只展示它们自定义的信息。没有赋值时，该事件不做任何响应。

        D.DOMContentLoaded 当初始的 HTML 文档被完全加载和解析完成之后，DOMContentLoaded 事件被触发，而无需等待样式表、图像和子框架的完成加载。 另一个不同的事件 load 应该仅用于检测一个完全加载的页面。因此DOMContentLoaded是HTML完全加载和解析完成之后发生的，发生时间点要早于load，选D。 在使用 DOMContentLoaded 更加合适的情况下使用 load 是一个令人难以置信的流行的错误，所以要谨慎。 注意：DOMContentLoaded 事件必须等待其所属script之前的样式表加载解析完成才会触发。

74.在开发中，往往需要从后台调用一些数据在前端显示，如何在前端显示一组无序的数据（      ）

①

1 2 3 4

$(document).ready(function(e) {     var $li = $("<li>张三</li>");     $("ul").append($li); });

②

1 2 3 4

$(document).ready(function(e) {     var $li = $("<li>张三</li>");     $($li).appendTo("ul"); });

③

1 2 3 4

$(document).ready(function() {     var $li = $("<li>张三</li>");     $($li).append("ul"); });

④

1 2 3 4

$(document).ready(function(e) {     var $li = $("<li>张三</li>");     $("ul").appendTo($li); });

A、①

B、②

C、③

D、④

• $(父元素).append(子元素)
• $(子元素).appendTo(父元素)

75.以下对call() 和 apply() 说法哪些是正确的  ()

A、apply()函数有两个参数：第一个参数是上下文，第二个参数是参数组成的数组;

B、非严格模式，如果第一个参数是null，则使用全局对象代替；

C、call和apply的意思一样,只不过是参数列表不一样.

D、通过apply可以将数组装换为参数列表的集合

76.请问以下JS代码在Node环境下的输出顺序是？

1 2 3 4 5 6 7 8 9 10 11 12 13

Promise.resolve() .then(() => {   console.log('p1'); }) .then(() => {   console.log('p2'); }) process.nextTick(() => {   console.log('n1');   process.nextTick(() => {     console.log('n2');   }) })

A、p1、p2、n1、n2

B、n1、n2、p1、p2

C、p1、n1、p2、n2

D、n1、p1、n2、p2

Node 中的“微任务(microtasks)其实是一个统称，包含了两部分：

• process.nextTick() 注册的回调 （nextTick task queue）
• promise.then() 注册的回调 （promise task queue）

Node 在执行微任务时， 会优先执行 nextTick task queue 中的任务，执行完之后会接着执行 promise task queue 中的任务。所以如果 process.nextTick 的回调与 promise.then 的回调都处于主线程或事件循环中的同一阶段， process.nextTick 的回调要优先于 promise.then 的回调执行。

77.对于代码 var a = 10.42; 取出 a 的整数部分，以下代码哪些是正确的？

A、parseInt(a);

B、Math.floor(a);

C、Math.ceil(a);

D、a.split('.')[0];

A. parseInt转换为整数，默认为10进制，结果为10

B. floor向下取整，结果为10 

C. ceil向上取整，结果为11

D. Number中无split方法。（Uncaught TypeError: a.split is not a function）

78.依据以下JS代码，在位置A打印变量a与在位置B打印变量a各会有怎样的输出？

1 2 3 4 5 6 7

var a = 1; function test(){     // 位置A class a {}    // 位置B } test();

A、1、class a {}

B、报错、class a {}

C、报错、报错

D、1、报错

class和let一样都有暂时性死区，在被声明前无法访问

也就是在当前作用域能找到，但是要在声明后才能访问
es6中的class和let const一样都不存在提升
（实际存在提升，只是因为TDZ的作用，并不会像var那样得到undefined,而是直接抛出错误）

原来的代码
var a = 1;
function test(){
    //console.log(a) 位置A
class a {}
   // console.log(a) 位置B
}
test();

实际上提升后的
var a = 1;
function test(){
    console.log(a) 位置A //在test()作用域内找得到a
//是一个class但是存在TDZ暂时性死区，访问报错
    class a {}
    console.log(a) 位置B //a已经声明创建出来了
}
test()

79.不能从字符串 const str = 'qwbewrbbeqqbbbweebbbbqee';中能得到结果 ["b", "bb", "bbb", "bbbb"]的语句是？

A、str.match(/b+/g)

B、str.match(/b*/g)

C、str.match(/b{1,4}/g)

D、str.match(/b{1,5}/g)

/b+/g //匹配前面的子表达式一次或多次，有一个或多个b

/b*/g //匹配前面的子表达式零次或多次,结果不止数组中那么多

/b{1,4}/g //匹配1-4个b

/b{1,5}/g //匹配1-5个b

80.如果想要获取整个网页文档中h1标签的个数，可以通过（）

A、var hele=document.getElementByTagName('h1');
alert(hele.length);

B、var hele=document.getElementsByTagName('h1');
alert(hele.length);

C、var hele=getElementsByTagName('h1');
alert(hele.length);

D、var hele=getElementByTagName('h1');
alert(hele.length);

document.getElementById();

document.getElementsByTagName();

document.getElementsByName();

document.getElementsByClassName();

除了ById是Element，其余都是Elements

81.下列选项中，不属于JavaScript继承的方式的一项是（）

A、原型链继承

B、构造函数继承

C、组合继承

D、关联继承

js常见的继承方式包括原型链继承、借用构造函数继承、组合继承、原型式继承、寄生式继承、寄生组合式继承，以及ES6新增的class继承，但不包括关联继承，

82.在一个表单中，如果想要给输入框添加一个输入验证，可以用下面的哪个事件实现？

A、hover(over ,out)

B、keypress（fn）

C、change()

D、change(fn)

• hover移入移出，输入验证一般不会使用hover
• keypress也不会用作输入验证，
• change可以用作输入验证的事件，change(fn)只是一种实现方式，还有其他实现方式：
  • 原生js的onchange属性，
  • html属性onchange，
  • addEventListener(onchange,fn)都是实现方式，
  • jquery中除了$(selector).change(fn)外还有bind(change,fn)

83.请问以下JS代码输出的结果是什么？

1 2 3 4 5 6 7

function f(x) {   console.log(x);   var x = 200;   console.log(x);   } f(a = 100); console.log(a);

A、undefined、200、undefined

B、100、200、undefined

C、100、200、100

D、undefined、200、100

JS中的函数是非惰性求值，也就是说f（a=100）是将a=100完成计算赋值后的结果即100传入到了f函数中，传入的是值而不是逻辑，相当于f（100），同时变量a也处于函数外也即全局环境了，因此f函数里面的x一开始是传进来的100，后续被重新赋值为200.

84.以下哪些正则表达式满足regexp.test('abc') === true？

A、/^abc$/

B、/...(?=.)/

C、/[ab]{2}[^defgh]/

D、/[defgh]*/

A.这算是完全匹配了，^a表示以a开头，c$表示以c结尾，中间再夹个b

B."."表示匹配除换行符的任意字符，"x(?=y)"匹配'x'仅仅当'x'后面跟着'y'.这种叫做先行断言。所以这里可以理解为：

1.当没有换行符时，只要字符前面是三的倍数/.../，并且后面跟有字符/(?=.)/，就可匹配，如1234，abcdefg,234wewrwwr（下划线处为匹配项）

2.有换行符时，每一行要重新匹配，即字符长度独立，从0开始（下划线处为匹配项）

121sfs12

12sd

323fd

C.[ab]表示a或b {2}表示长度为2  [^defgh]表示非defgh的字符，所以可匹配的有,aac,bbc,abc,abcd等，注意这里匹配长度为3

D."*"表示0或者多个字符，这里可匹配空，或者括号内任意字符

85.以下哪个表达式的值为true？

A、'1' === 1

B、isNaN(1/0)

C、1 in [1]

D、1 && 2 > 1

1. A选项，'1'是字符串string，1是数字number。类型不一样，===下比较返回false。
2. B选项。

• 任何数值除以0都会导致错误而终止程序执行。但是在 JavaScript 中，会返回出特殊的值，因此不会影响程序的执行。
• 比0大的数除以0，则会得到无穷大，所以 js 用 Infinity 来显示出来。
• 也就是1/0得到的是Infinity。isNaN(1/0)返回的是false。但是isNaN(0/0)返回的就是true

3. C选项。

• in操作符，对于数组属性需要指定数字形式的索引值来表示数组的属性名称（固有属性除外，如length）。
• 所以说在这里，1 in [1]并不是表示数字1在不在数组里。而是表示数组中含不含有1这个索引index值。 数组长度为1，所以只含有的index值为0，这个表达式返回fasle。

4. D选项。

• 1 && 2 > 1，先判断右边的表达式，2>1返回true。1 && true返回的结果也是true。

1&&true 结果为true,原因如下；

对于“&&”和‘||’的规律：

1、只要“||”前面为false，无论“||”后面是true还是false，结果都返回“||”后面的值。

2、只要“||”前面为true，无论“||”后面是true还是false，结果都返回“||”前面的值。

3、只要“&&”前面是false，无论“&&”后面是true还是false，结果都将返“&&”前面的值;

4、只要“&&”前面是true，无论“&&”后面是true还是false，结果都将返“&&”后面的值;

86.下面哪些关于块内声明函数的用法是正确的？

A、if (x) { function foo() {}}

B、if (x) { var foo = function() {}}

C、if (x) { foo = function() {}}

D、ECMAScript明确的规范了块内函数，javascript实现了这个规范

块内声明的变量只要没加var 都算作全局变量。

js看起来像支持块级作用域，实际上只有函数作用域和全局作用域。

JavaScript语言精粹内对全局变量有明确的批判

A，声明一个全局匿名函数

C，声明一个全局函数foo

D，ES6才规定块级作用域。

87.执行以下程序，要求当用户点击按钮1秒后禁用按钮，以下选项的做法，不符合要求的是（）

<button>点击</button>

<script>

    var btn = document.querySelector('button');

</script>

A、btn.onclick = function(){

var that = this;

setTimeout(function(){that.disabled = true;},1000)

}

B、btn.onclick = function(){

setTimeout(function(){this.disabled = true;},1000)

}

C、btn.onclick = function(){

setTimeout(()=>{

this.disabled = true;

},1000)

}

D、btn.onclick = function(){

setTimeout(function(){this.disabled = true;}.bind(this),1000)

}

this的指向问题。

A：用that来保存当前按钮的this

B：回调函数执行时this指向了window

C：箭头函数的this为外层的this，也就是按钮

D：用bind来绑定当前this

88.下列符合ES6规范的语法有

A、let x=10

B、const pi=3.1415926

C、let s=Symbol()

D、Object.assign(target,source1,source2)

E、function *helloWorld(){yield ‘hello’; yield  ’world’;return ‘ending’}

AB比较简单，变量的赋值，正确
C：Symbol的用法
Symbol 值通过Symbol函数生成。这就是说，对象的属性名现在可以有两种类型，一种是原来就有的字符串，另一种就是新增的 Symbol 类型。凡是属性名属于 Symbol 类型，就都是独一无二的，可以保证不会与其他属性名产生冲突。

let s = Symbol();

D. Object.assign()方法：
Object.assign方法用于对象的合并，将源对象（source）的所有可枚举属性，复制到目标对象（target）。

const target = { a: 1 };

const source1 = { b: 2 };
const source2 = { c: 3 };

Object.assign(target, source1, source2);
target // {a:1, b:2, c:3}

Object.assign方法的第一个参数是目标对象，后面的参数都是源对象。

E. Generator函数
形式上，Generator 函数是一个普通函数，但是有两个特征。一是，function关键字与函数名之间有一个星号；二是，函数体内部使用yield表达式，定义不同的内部状态（yield在英语里的意思就是“产出”）。

function* helloWorldGenerator() {
  yield 'hello';
  yield 'world';
  return 'ending';
}

var hw = helloWorldGenerator();

89.执行以下程序，输出结果为（）

1 2 3 4

let flag1 = null || undefined; let flag2 = null && undefined; if (flag1 === true) console.log('flag1'); if (flag2 === false) console.log('flag2');

A、flag1

B、flag2

C、flag1、flag2

D、什么都不会输出

||返回第一个为true的值，找不到就反回最后一个假值false，&&返回第一个为false的，找不到就返回最后一个真值true

在本题中，flag1和flag2的值只可能是undefined和null中的一个。当使用“===”进行比较时，需要严格区分数据类型，所以flag1 === true的返回结果一定是false，flag2 === false的返回结果也一定是false，故不会有任何输出，D选项正确。

90.如何阻止IE和各大浏览器默认行为（      ）

A、window.event.cancelBubble = true;

B、window.event.returnValue = false;

C、event.stopPropagation();

D、event.preventDefault();

阻止默认事件：

e.preventDefault()

e.returnValue = false  (IE)

阻止冒泡：

e.stopPropagation()

e.cancelBubble = true (IE)

91."+new Array(017)" 这段代码输出为？（）

A、17

B、NaN

C、15

D、Error

首先，前面+是一元运算符，相当于我们说的正负，无运算效果，但是可以将字符串等转为number类型。  

 此题中017其实是八进制，故而是是Array(15)。  

这里相当于对于一个未赋值但是长度为15的数组进行number类型转化，其结果为NaN

92.下面说法错误的是（ ）

A、每个对象都具有一个名为__proto__的属性

B、每个对象都具有一个名为prototype的方法

C、每个对象的__proto__属性指向自身构造函数的prototype

D、对象不具有prototype属性，只有函数才有prototype属性

对象分为函数对象和普通对象，只有函数对象是有prototype的，object.__proto__也有prototype，但它指向null

93.执行以下程序，输出结果为（）

var arr = [2,1,3,5,9];

var count = 0;

arr.forEach((val1,val2)=>{

        count++;

        if(count % 3 == 0){

            return;

        }

        console.log(val1);

})

A、2 1

B、0 1

C、0 1 3 4

D、2 1 5 9

arr.forEach()是循环遍历数组，它的参数是一个函数，每迭代一次数组，就执行函数一次，也就是，虽然在函数内部存在return语句，但是当执行return时相当于退出一次迭代，当前数组会继续下一次迭代，函数有两个参数，参数val1为数组的元素值，参数val2为数组元素对应的索引，因此正确答案为D选项。

94.下列表达式中，返回值为true的是（）

①Object.is(NaN,NaN)

②Object.is(+0,-0)

③NaN === NaN

④+0 === -0

A、①④

B、①③

C、②③

D、②④

Object.is()，其行为与===基本一致，不过有两处不同： +0不等于-0。 NaN等于自身。

95.在文件/home/somebody/workspace/somemodule.js中第一行引用了一个模块：require(‘othermodule‘)，请问require查找模块的顺序是：

A. /home/somebody/workspace/node_modules/othermodule/index.js
B. /home/somebody/workspace/node_modules/othermodule. Js
C.CORE MODULES named othermodule
D./home/somebody/node_modules/othermodule/index.js

A、C D A B

B、C B D A

C、C B A D

D、C D B A

96.已知数组arr = [2,20,3,12,9]，现在要对数组进行遍历，只要数组存在大于10的元素，则输出true，否则输出false，则下列选项中，符合要求的是（）

A、var res = arr.filter((val1,val2)=>{

return val1 > 10;

})

console.log(res);

B、var res = arr.some((val1,val2)=>{

return val1 > 10;

})

console.log(res);

C、var res = arr.every((val1,val2)=>{

return val1 > 10;

})

console.log(res);

D、var res = arr.map((val1,val2)=>{

return val1 > 10;

})

console.log(res);

arr.filter()用于筛选出满足要求的数组元素，并返回新的数组，因此输出结果为[20,12]，A选项错误；arr.some()用于检测数组是否有满足条件的元素，只要存在元素满足要求，则返回true，否则返回false，B选项正确；arr.every()用于检测数组的所有元素是否都满足条件，都满足条件时返回true，否则返回false，C选项错误；arr.map()会对数组中每个元素进行单独判断，返回true或者false，作为新数组的元素，因此输出结果为[false, true, false, true, false]，D选项错误。

97.以下哪个语句打印出来的结果是false？

A、alert(3==true)

B、alert(2=="2")

C、alert(null == undefined)

D、alert(isNaN("true"))

A、

1 == true   // 布尔值会转成number true即为1 所以结果是true

2 == true   // 布尔值会转成number true即为1 所以结果是false
3 == true   // 布尔值会转成number true即为1 所以结果是false
1 == false  // 布尔值会转成number false即为0 所以结果是false

0 == false  // 布尔值会转成number false即为0 所以结果是true

B、数字字符串2会转换成数字2在和数字2进行比较 。
== js会优先选择将字符串转成数字==

C、Javascript规范中提到， 要比较相等性之前，不能将null和undefined转换成其他任何值，并且规定null和undefined是相等的。

null和undefined都代表着无效的值。

D、

isNaN() 函数用于检查其参数是否是非数字值。

如果参数值为 NaN 或字符串、对象、undefined等非数字值则返回 true, 否则返回 false。

98.以下哪一项不属于浏览器Response Headers字段：

A、Referer

B、Connection

C、Content-Type

D、Server

Referer是request Header里的内容，不是response header里的内容。

99.按照CommonJS规范，在任何模块代码的作用域下内置了以下哪些变量？

A、module

B、context

C、require

D、exports

commonJS四个重要环境变量：require、exports、module、global

100.请阅读以下代码

1 2 3

var obj = {}; obj.log = console.log; obj.log.call(console,this);

该代码在浏览器中执行，输出的日志结果是什么？

A、undefined

B、window

C、console

D、obj

这道题看似在考this的绑定问题，实际上是通过this绑定为幌子，考察非严格模式下JavaScript语句中“this”默认指向全局对象（window）。

题目的关键点在第3行，我们知道，this绑定的优先级是new>bind>call(apply)>obj.func()>默认绑定。也就是说obj.log.call(console, this)语句中，实际上log函数内的this实际上指代的是console（这也是本题最大的陷阱！）。然而实际上这一语句中obj.log.call(console, this)这一语句中打印的this是在外部传进去的，和函数内的this对象根本没有关系！也就是说此时log函数内的this指代console，但是打印的是从外面传进去的this对象，也就是window！

为了证明这一点，读者朋友们可以把obj.log.call(console, this)中的console改成任意一个对象，然后在非严格模式下执行，会发现结果都是window。

101.以下代码执行后， num 的值是？

1 2 3 4 5 6 7

var foo=function(x,y){     return x-y; } function foo(x,y){     return x+y; } var num=foo(1,2);

A、-1

B、3

C、1

D、2

考察 js 解析顺序

// 变量提升
var foo; 
var name;
// 函数声明提升
function foo(){
    return x+y;
}
 
foo = function(x,y) {
    return x-y;
}
name = foo(1,2);

102.下面这段程序的显示结果是？

1 2 3 4 5 6 7 8

var x = new Boolean(false); if (x) {   alert('hi');  } var y = Boolean(0); if (y) {   alert('hello');   }

A、hi

B、hi hello

C、hello

D、不显示

• if(x) 这里期望 x 是一个布尔类型的原始值，而 x 是一个对象，任何对象转为布尔值，都为得到 true（切记！在 JS 中，只有 0，-0，NaN，""，null，undefined 这六个值转布尔值时，结果为 false）。
• 题目的第二部分，一定要注意 y = Boolean(0)，而不是 y = new Boolean(0)。这两个有很大区别，用 new 调用构造函数会新建一个布尔对象，此处没有加 new，进行的是显示类型转换，正如上述第一条所说，0 转换布尔，结果为 false，所以此时 y 的值就是 false。如果加了 new，那么 y 就是一个 Boolean 类型的对象，执行 if(y) 时，对象转布尔，始终是 true，所以结果会与不加 new 的时候相反。

103.请问在非严格模式下以下JS代码最终的输出是什么？

1 2 3 4 5 6 7 8 9 10

function change(obj) {   with(obj) {     color = 'red'   } } var box = {   size: '15*15' } change(box); console.log(color);

A、undefined

B、null

C、red

D、报错

 with 代码块内部，每个变量首先会指向 obj 对象属性，所以color = 'red' 可以等效于obj.color = red

但是obj身上并没有color这个属性，于是去change函数的作用域寻找color但也没有找到，

最后在全局作用域没有color的情况下，于是直接设置 全局.color = 'red'

这就是数据泄漏的过程，经过一通操作，color泄露到全局

104.下列表达式中，结果为NaN的是（）

A、123 + null

B、123 / 0

C、123 + '1';

D、123 + undefined;

对于“+”运算，如果一端为字符串，则另一端会被转为字符串进行字符串之间的连接，因此C选项结果为1231，如果一端为Number类型，另一端为原始数据类型，则另一端会被转为Number类型，再相加，null会被转为0，A选项结果为123，undefined会被转为NaN，结果也为NaN，因此D选项正确；B选项，123/0结果为Infinity。

105.执行下列选项的程序，输出结果不是Window对象的是（）

A、setTimeout(function(){

console.log(this);

},1000);

B、function Star(){

console.log(this);

}

new Star();

C、var o = {

sayHi:()=>{

console.log(this);

}

}

o.sayHi();

D、(function(){

console.log(this);

}());

在setTimeout()定时器中，this指向Window对象，A选项不符合题意；通过new Star()来调用Star函数，由于使用new绑定，Star函数内部的this指向new创建的实例，而非Window对象，B选项符合题意；箭头函数不会与this进行绑定，其this指向取决于该箭头函数同级作用域的this指向，又由于对象不能形成自己的作用域，因此其作用域为全局作用域，this指向Window对象，C选项不符合题意；D选项，立即执行函数的this指向Window对象，D选项不符合题意。

106.执行以下程序，下列选项中，说法正确的是（）

1 2 3 4 5 6 7 8 9 10 11 12

<button>点击</button> <script> function a(){     console.log(1);     return function b(){         console.log(2); } } var btn = document.querySelector('button'); btn.onclick = a(); ...① btn.onclick = a; ...② </script>

A、若注释①，则执行结束后会输出1，当用户点击button按钮时，输出2

B、若注释①，则执行结束后不会有输出，当用户点击button按钮时，输出1

C、若注释②，则执行结束后不会有输出，当用户点击button按钮时，输出1

D、若注释②，则执行结束后输出1，当用户点击button按钮时，不会有任何输出

注释①式，执行②式，执行效果表现为在用户触发点击事件时执行事件处理函数a，输出1，并不会执行return后的语句，B选项正确，A选项错误；注释②式，执行①式，执行效果表现为不管用户有没有触发事件，都会先执行事件处理函数a，输出1，然后将a的返回值作为用户触发事件的处理函数，相当于btn.onclick = b，当用户触发点击事件时，执行函数b，输出2，CD选项均错误。

107.以下关于JavaScript的描述中错误的是

A、在原型上扩展的可枚举方法，会被for in循环出来

B、使用object.defineProperty可向对象添加或者修改属性

C、每个对象都有prototype属性，返回对象类型原型的引用

D、通过hasOwnProperty可判断一个对象以及其原型链上是否具有指定名称的属性

E、原型链是JS实现继承的一种模型

F、For循环是按顺序的，for in 循环是不一定按顺序的

C、函数对象才有prototype属性

D、不能判断原型链

F、for in 遍历对象，无序遍历，而且会遍历原型，如果不想看到不要的属性，一定要if判断

108.以下哪些事件支持冒泡？

A、mouseenter

B、scroll

C、focus

D、keypress

不能被冒泡的9个事件：① load和unload ② mouseenter和mouseleave ③ blur和focus ④ error ⑤ resize和abort从3个角度说可分为ui事件、鼠标移入移出事件、聚焦和失焦件，

109.现有如下html结构

1 2 3 4 5 6

<ul>  <li>click me</li>  <li>click me</li>  <li>click me</li>  <li>click me</li> </ul>

运行如下代码：

1 2 3 4 5 6 7

var elements=document.getElementsByTagName('li'); var length=elements.length; for(var i=0;i<length;i++){     elements[i].onclick=function() {         alert(i);     } }

依次点击4个li标签，哪一个选项是正确的运行结果?

A、依次弹出1，2，3，4

B、依次弹出0，1，2，3

C、依次弹出3，3，3，3

D、依次弹出4，4，4，4

事件(click,focus等等)，定时器(setTimeout和setInterval)，ajax,都是会触发异步，属于异步任务；js是单线程的，一个时间点只能做一件事，优先处理同步任务； 按照代码从上往下执行，遇到异步，就挂起，放到异步任务里，继续执行同步任务，只有同步任务执行完了，才去看看有没有异步任务，然后再按照顺序执行！ 这里for循环是同步任务，onclick是异步任务，所以等for循环执行完了，i变成4了，注意：这里因为i是全局变量，最后一个i++，使得i为4(后面的onclick函数，最后在循环外面执行，不受i<length限制)； 所以for循环每执行一次，onclick事件函数都会被挂起一次，共4次； for循环结束后，点击事件 触发了4个onclick函数，接着输出4个4！

110.执行以下程序，下列选项中，说法错误的是（）

1 2 3 4 5 6 7 8 9 10 11

class Phone{   constructor(brand){     this.brand = brand; }   call(){}...① } function playGame(){console.log("我可以打游戏")}; function photo(){console.log("我可以拍照")}; console.log(typeof Phone);...② var p = new Phone('华为'); console.log(p.brand);...③

A、①式的call方法是定义在类Phone的prototype对象上

B、②式输出结果为Object

C、③式输出结果为华为

D、若想一次性给类添加playGame和photo两个实例方法，可以使用Object.assign(Phone.prototype,{playGame,photo})

类的所有实例方法均定义在类的原型对象上，因此，在类内定义的实例方法和在类的原型对象上定义方法是等价的，call()是实例方法，故A选项说法正确，不符合题意；类的本质是函数，实际上，ES6中的类可以视为ES5中构造函数的另一种写法，所以②式的输出结果为function而不是Object，B选项说法错误，符合题意；p为类的实例对象，该对象有一个属性brand，属性值为华为，C选项说法正确，不符合题意；Object.assign(target, source)可将source源对象所有可枚举的属性（或方法）分配给target对象，所以可以使用Object.assign(Phone.prototype,{playGame,photo})为类一次性添加playGame和photo两个实例方法，D选项说法正确，不符合题意。

111.以下代码的执行后，str 的值是：

1 2	var str = "Hellllo world"; str = str.replace(/(l)\1/g, '$1');

A、Helo world

B、Hello world

C、Helllo world

D、Hellllo world

对于正则表达式 /(l)\1/g，其中(l)是第一个分组，\1指向第一个分组，即\1重复了第一个分组的内容，所以该正则表达式可以表示成/(ll)/g

而对于第二个参数$1，表示用第一个分组的内容 l 对匹配到的部分进行替换(即 ll 替换成 l )，同时正则表达式有g表示全局匹配，所以4个ll被替换成2个ll。

112.下面这段代码运行后的输出是

1 2 3 4 5 6 7

(function() {     var x=foo();     var foo=function foo() {         return "foobar"     };     return x; })();

A、foo()

B、类型错误

C、undefined

D、foobar

var x = foo();
var foo=function foo() {...}

语句中变量的声明会提升，但是定义不会提升。以上代码等同于：

var foo;
var x = foo();
foo = function foo() {...}

当执行到 x = foo() 时，由于foo未被定义为函数，所以会返回

TypeError: foo is not a function

113.下列代码

1 2 3

var obj={} …….. obj.hasOwnProperty("val")

中hasOwnProperty的作用是？

A、判断obj对象是否具有val属性

B、判断obj对象是否具有val的值

C、判断obj的原型对象是否具有val的属性

D、判断obj的原型对象是否具有val的值

hasOwnProperty： 是用来判断一个对象是否有你给出名称的属性或对象。不过需要注意的是，此方法无法检查该对象的原型链中是否具有该属性，该属性必须是对象本身的一个成员。

isPrototypeOf : 是用来判断要检查其原型链的对象是否存在于指定对象实例中，是则返回true，否则返回false。

114.针对以下f函数分别执行f（2）和f（）会有怎样的结果？

1	f = (x = x) => x;

A、2、undefined

B、报错、报错

C、2、报错

D、undefined、undefined

函数的参数后面用等号（=），可以为参数赋一个默认值

执行f(2)，2作为函数的参数，忽略参数的默认值（即使括号中的 x = x 有错误），输出2

执行f()，因为函数的参数变量是默认声明的，括号中的 x = x 相当于 let x = x，导致错误：Cannot access 'x' before initialization，初始化之前无法访问'x'（注意，错误信息不是 x is not defined）

115.JavaScript 中的数字在计算机内存中占多少个Byte？

A、2 Byte

B、4Byte

C、8Byte

D、16Byte

关于Javascript中数字的部分知识总结：

1.Javascript中，由于其变量内容不同，变量被分为基本数据类型变量和引用数据类型变量。基本类型变量用八字节内存，存储基本数据类型(数值、布尔值、null和未定义)的值，引用类型变量则只保存对对象、数组和函数等引用类型的值的引用(即内存地址)。

2. JS中的数字是不分类型的，也就是没有byte/int/float/double等的差异。

116.假设val已经声明,可定义为任何值。则下面js代码有可能输出的结果为:

console.log('Value is ' + (val != '0') ? 'define' : 'undefine');

A、Value is define

B、Value is undefine

C、define

D、undefine

E、Value is define 或者 Value is undefine

F、define 或者 undefine

G、其它选项都有可能

答案C 加号优先级高于 三目运算。低于括号。 所以括号中无论真假 加上前边的字符串都为 TRUE 三目运算为TRUE是 输出 define

117.执行以下程序，输出结果为（）

1 2 3 4 5 6 7 8 9 10

class Phone{   constructor(price){     this.price = price;   }   get price(){     return 999;   } } var p = new Phone(888); console.log(p.price);

A、999

B、undefined

C、抛出异常

D、888

这个应该是class底层用到了Objetct.defineProperty() :  对访问器属性price只是设置了get，set默认没有，所以price属性视为读属性

   然后在第三行  this.price = price又用了设置price(set)，所以会报错： price是只读的

  解决： get price() {}后面加上： set price(value) {}          ===>   set需要参数！！！        就返回999了

118.以下符合 ES6 写法的有：（）

A、class Foo { constructor() {return Object.create(null);} } Foo()

B、var m=1; export m;

C、export var firstName=’Michael’;

D、在A模块中export{readFile}后，在B模块中import readFile from ‘A’可以获取到readFile

• A:类必须使用new调用，否则会报错。这是它跟普通构造函数的一个主要区别，后者不用new也可以执行。
• B:export命令规定的是对外的接口，必须与模块内部的变量建立一一对应关系。

  // 报错
  export 1;
  // 报错
  var m = 1;
  export m;

  上面两种写法都会报错，因为没有提供对外的接口。第一种写法直接输出 1，第二种写法通过变量m，还是直接输出 1。1只是一个值，不是接口。正确的写法是下面这样。

  // 写法一
  export var m = 1;
  // 写法二
  var m = 1;
  export {m};
  // 写法三
  var n = 1;
  export {n as m};

• D:A模块对外暴露了一个对象，引入的时候需要使用解构赋值

import {readFile} from ‘A'

119.以下哪些函数是JavaScript的全局函数：

A、escape

B、parseFloat

C、eval

D、setTimeout

js的全局属性：Infinity、NAN、undefined

js的全局函数：decodeURI()、decodeURIcomponent()、

                        encodeURI、encodeURIcomponent()、

                          escape()、eval()、isFinite()、isNAN()、

                        Number()、parseFloat()、parseInt()、String()、unescape()。

120.请问以下JS代码会输出什么

1 2 3 4 5

var a = 10;  (function a() {     a = 20;     console.log(a);  })()

A、10

B、20

C、undefined

D、输出函数a的内容

函数可以在函数体中访问自己的标识符(函数名)

• 这里面的 a = 20，a 实质上是函数名，log打印的是函数名为a的整个函数体
• a=20是修改函数为20，不会在function里面产生额外的变量,但是不能修改，所以此这条语句是无效的，别***扰了，忽略掉即可，或者你换成b=20就好理解了，这样就会产生全局变量b了。

  var a = 10;  //函数已经在体内找到名为a的了
  //因此不会到全局作用域去找全局变量a（var a = 10）
  (function a() {
    a = 20; //这里的a是函数名，相当于修改函数a=20,无效
    console.log(a); //a是函数名，打印整个a函数体
  })()

121.以下代码的输出结果是

1 2 3 4

var f = function g() {     return 23;  }; typeof g();

A、"number"

B、"undefined"

C、"function"

D、Error

var f = function g() {
    return 23;
};
typeof g();
A. "number"
B. "undefined"
C. "function"
D. Eorror
1）函数定义有两种方式，一种是普通函数直接声明function a () {return b;};（这种在解析时会被优先处理）

2）另外一种就是匿名函数 var a = function () {returnb;};，这种也被称为表达式类型，因为右边部分已经成为一个表达式的一部分，无法再被正常访问

3）题目中的情况按照第二种方法理解，作为表达式的g函数已经无法被访问

4）注意，题目是typeof g()，不是typeof g；这两者的区别在于函数调用"()"的运算优先级高于typeof，所以先解析g()的情况下，js直接报错，而不是给出"undefiend"；因此答案是D

//调试比对结果
//typeof a是function这个没有问题
//typeof fn1是得到undefined
//typeof fn1()是错误报警形式出现
var a = function fn1 (){}
typeof a  //"function"
typeof fn1()  //Uncaught ReferenceError: fn1 is not defined(…)
typeof fn1  //"undefined"

进度（377/377  错题：121）完结