练习（niukewang）

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

A: confirm()

B:alert()

C:prompt()

d:open()

解析：

        confirm()是弹出判断对话框；

        alert()是弹窗；

        prompt()显示对话框；

        open()是打开新的页面；

2.执行以下程序，下列说法中，正确的是（A）

var arr = new Array(3); ...①

arr[0] = 1;

= 0;

console.log(); ...②

(value=>{

(value); ...③

})

for(var i in arr){

(arr[i]); ...④

}

A:①式创建一个长度为3的数组

B:②式输出结果为4

C:③式输出结果为1 0

D:④式输出结果为1

解析：

        var arr = new Array(3); ...①    //结果是【empty ，empty ，empty  】

        arr[0] = 1;                                //结果是【1，empty ，empty 】

          = 0;                                //结果是【1，empty ，empty ，b:0】 

                                                //通过点操作符（.）添加的属性和length属性处于同一层级，不会影响length的值。

        (); ...②    //结果是3

        (value=>{

                (value); ...③   //结果是1 ，因为此时遍历的是【1，empty ，empty】

        })                                              //通过点操作符（.）添加的属性可以用for...in...循环遍历，但不能用foreach循环遍历。

         for(var i in arr){

              (arr[i]); ...④    //结果是0 ，因为此时遍历的是【b:0】

        }                                             //通过点操作符（.）添加的属性可以用for...in...循环遍历，但不能用foreach循环遍历。

注意：

        通过点操作符（.）添加的可以用 forin 循环遍历，但不能用 foreach 循环遍历。而且添加的属性和length属性处于同一层级，不会影响length的值。

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

function a(){

  (this);

} 

(null);

A:document

B:null

C:window

D:a

E:undefined

解析：

         call继承，对象冒充，因为传入是null或者undefind和没传一样，所以还是全局的window

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

let num = (function(x){delete x;return x;})(1);

(num);

A:抛出异常

B:null

C:undefined

D:1

解析：

        delete只能删除对象的属性。 如果是 ,就可以使用delete删除。

        不能删除变量和原型链中的变量。

5.在下列Promise所提供的方法中，用来向成功或者失败的回调函数队列中添加回调函数的是（ D）

A:done

B:fail

C:always

D:then

解析：

        then 接收两个回调函数并返回一个新的 promise 对象，这两个回调函数分别对应成功回调 onFullfilled 和失败回调 onRejected，这两个回调函数接收 promise 的返回值；
        always (finally) 接收一个回调函数并返回一个新的 promise 对象，回调函数在上一个 promise 解析完成之后调用，也就是不管前面是 then 还是 catch 被调用了，它都会被调用，该回调函数不会接收参数。

6.下列逻辑表达式的结果为false的是（A） 

A:NaN == NaN

B:null == undefined

C:'' == 0

D:true == 1

解析：

        NaN == NaN  // false

        (NaN，NaN)  // true

        同一个NaN是相等的,判断两个NaN相等要用() 之前不相等是因为JS的设计有误，现在已经有方法可以判断了

扩展：

        ==   会进行类型转换，值相同即为true

        ===    不会进行类型转换，类型和值都相同的情况即为true

        ()

     === 和()的区别在于对NaN和带符号的0的处理：

                  NaN === NaN // false

                  +0 === -0 // true

                  -0 === +0 // true

                  (NaN, NaN) // true

                  (+0, -0) // false

                  (-0, +0) // false

         ('foo', 'foo');     // true

   (window, window);   // true

   ('foo', 'bar');     // false

   ([], []);           // false

   var foo = { a: 1 };

   var bar = { a: 1 };

   (foo, foo);         // true

   (foo, bar);         // false

   (null, null);       // true

   // 特例

   (0, -0);            // false

   (0, +0);            // true

   (-0, -0);           // true

   (NaN, 0/0);         // true

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

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

A:return false;

B:return ;

C:return test;

D:什么都不做

解析：

        在构造函数里面，如果不写return的话默认就是返回创建的实例对象，但是如果加入了return的话，如果return的是一个基本数据类型的话比如，boolean,number,undefined等那么仍然返回实例对象，如果返回的是一个对象的话，则返回该对象，原本的指向实际对象的this会被无效化。

        选项A：

                const test = {
                          rules: false
                };
                function Build() {
                     = true;
                    return false;    // 这里返回基本类型时：实例build是实例对象 { rules: true}

                    return test ;    // 这里返回一个对象时：实例build是该对象 { rules: false}
                }
                const build = new Build();
                ();

8.请问以下JS代码的执行结果是什么？（B）

function control(x) {
  if (x == 3) throw new Error("break");
}
function foo(x = 6) {
  return {
    next: () => {
      control(x);
      return {done: !x, value: x && x--};
    }
  }
}
let x = new Object;
x[] = foo;
for (let i of x) (i);

A:6、5、4、3、2、1

B:6、5、4、报错

C:1、2、3、4、5、6

D:1、2、报错

解析：

        1. ES6 规定，默认的 Iterator 接口部署在数据结构的属性，或者说，一个数据结构只要具有属性，就可以认为是“可遍历的”（iterable）。属性本身是一个函数，就是当前数据结构默认的遍历器生成函数。执行这个函数，就会返回一个遍历器。至于属性名，它是一个表达式，返回Symbol对象的iterator属性，这是一个预定义好的、类型为 Symbol 的特殊值，所以要放在方括号内

        2. throw 异常信息;中止程序抛出异常，可用于中止程序

        3. foo 是遍历器生成函数，遍历的时候遇到 throw 就中止遍历和抛出错误

        4. 还是推荐 阮一峰老师 /#docs/iterator

a = parseInt([0,0,1,0,0].join('')+1) a的值为 （C）

A:2        

B:101

C:1001

D:NaN

解析：

 var a = parseInt([0,0,1,0,0].join('')+1);
                1)首先，  [0,0,1,0,0].join()        结果是    '00100'
                2)  然后，   '00100'+1                 结果是    '001001'
                3)  最后，   parseInt('001001')    结果是    1001

考点一：数组join()的用法
                1)    join() 方法不传参数的时候，将数组作为字符串返回(把数组的中括号变成'')。
                       例如：[1,2,3,4,5,6].join()    结果是    '1,2,3,4,5,6'
                2)    join() 方法传参数的时候，参数作为数组里每一项的连接符。
                       例一：[1,2,3,4,5,6].join('')   结果是   '123456'          //连接符为空
                       例二：[1,2,3,4,5,6].join(' ')  结果是   '1 2 3 4 5 6'     //连接符是空格
                       例三：[1,2,3,4,5,6].join('-')  结果是   '1-2-3-4-5-6'    //连接符是-
                       例四：[1,2,3,4,5,6].join(',')  结果是   '1,2,3,4,5,6'    //连接符是逗号，(注意：此时和join()结果一样)

考点二：算术运算符+ - * % / 
               加法运算：如果有一边为字符串，那么+表示字符串连接
                                 如果两边都没有字符串，那么就是普通的加法运算，不是Number类型的会先隐式转换成数字计算。
               减，乘，除，取余：Number类型的会先隐式转换成数字计算。
               1)   String + Number                   例如：'a'+3 得 'a3'
               2） Boolean + Number               例如：false+3 得 3
               3)    Null + Number                     例如：null+3 得 3  （因为Number(null)为0）
               4)    undefined + Number           例如：undefined +3 得 NaN  （因为Number(undefined)为NaN）
               5)    Boolean + Null                    例如：true+ null 得 1
               6)    Boolean + undefined           例如：true + undefinde 得 NaN
               等等....

考点三：parseInt(String,radix)的用法
              parseInt()会先把传到括号里的参数隐式转换成String,然后再转成整数

()用于判断数据类型，数据类型有:

        ①基本数据类型:string number null undefined boolean         ②复杂数据类型:object 

11. 请问以下JS代码的输出结果会是什么 （D）

var a = 'w' 
let obj = {
  a: 'o',
  print: function() {
    ();
  },
  print2: () => { 
    ();
  }
}
let p = ;
let p2 = obj.print2;
();
obj.print2();
p();
p2();

A:o、 undefined、 undefined、undefined

B:o、 w、 undefined、 undefined

C:o、 w、 w、 undefined

D:o、 w、 w、 w

解析：

        一般函数的this指向调用者，箭头函数的this与最外层的this保持一致。

        调用 obj.print2() 时，如果是普通函数，该方法内部的 this 指向 obj ；如果写成上面那样的箭头函数，使得 this 指向全局对象，因此不会得到预期结果。这是因为对象不构成单独的作用域，导致 print2 箭头函数定义时的作用域就是全局作用域。

阮一峰老师有说到  ES6 入门教程

12.请问以下JS代码最后输出的len值是多少？（A）

var len = 117;
let func = {
  len: 935,
  showLen: function() {
    ();
  },
  show: function() {
    (function(cb) {
      cb();
    })()
  }
}
();

A:117

B:935

C:undefined

D:null

解析：

        立即执行的函数表达式中this指向全局也就是window;

        var len=117;我们可以发现这个是用var声明的，属于全局变量，所以打印的结果为117； 若将var改为let，则打印的结果为undefined

13. setInterval(“alert(welcome)”,1000);  （D）

A:等待1000秒后，再弹出一个对话框

B:等待1秒钟后弹出一个对话框

C:每隔一秒钟弹出一个对话框

D:语句报错，语法有问题

解析：
        语法错误：

                setInterval第一个参数是函数，不是字符串；

                并且welcome需要用引号包裹，是字符串。

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

A:

uname = 'window';

setTimeout(function(){

()

},1000);

B:

var uname = 'window';

(function(){()}());

C:

function fn(a,a){

(a+a);

}

fn(1,1);

D:

var uname = 'window'

function Person(){();}

var p = new Person();

解析：

选项A：
        1)uname = 'window' 抛出错误：在严格模式下，给未声明的变量赋值，会导致抛出ReferenceError，报错。 简而言之，严格模式下变量必须用关键字声明后才能使用 。
        2)严格模式下，普通函数的this指向undefined
        3)严格模式下，立即执行函数的this指向undefined
        4)严格模式下，setTimeout中函数的this指向的window（与普通函数不同）

选项B：

        严格模式下，立即执行函数的this指向的是undefinded，所以当然会报错

选项C：
严格模式下，函数的参数不能同名，否则报错
非严格模式下，函数的参数如果同名，会取第二个实参的值。

选项D：
        严格模式下：构造函数的this指向undefined，但是构造函数实例化对象的this指向的是实例化对象本身
        构造函数实例化对象的this指向的是实例化对象本身，而实例化对象下没有uname这个属性，所以得到undefined，没有报错

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

A:17

B:NaN

C:15

D:Error

解析：

        +运算符作为二元运算符时，有两个功能 数字相加连接字符串 数字相加没啥好说的，连接字符串时，会先把两个参数都转换成字符串再进行连接。 +作为一元运算符时，会将参数转换为数字返回 结果 所以(+new Array(017));输出的是NaN 其他 类似的还有-运算符，输出一个转换后的负数 附上一些其他的输出 
        (+new Array()); //0 
        (+new Array(0)); //0 
        (+new Array(1)); //0 
        (+new Array(2)); //2以上都是NaN //NaN 
        (+[]); //0 
        (+[1]); //1 
        (+[1, 2]); //NaN 
        (+[undefined]); //0 
        (+[undefined, undefined]); //NaN

16.现有函数test返回一个数组num，如果遍历执行该数组的每一个元素，结果是什么？（D） 

function test (){
  var num = []
  var i
  for (i = 0; i < 3; i++) {
      num[i] = function () {
          (i)
      }
  }
  return num
}
test()

A:[0,1,2]

B:[3,3,3]

C:[undefined、undefined、undefined]

D:[ƒ(), ƒ(), ƒ()]

解析：

      数组为  [ƒ(), ƒ(), ƒ()]

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

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

 A:flag1

B:flag2

C:flag1、flag2

D:什么都不会输出

解析：

       对于 || 来说，如果条件判断结果为 true 就返回第一个操作数的值，如果为 false 就返回第二个操作数的值。

        && 则相反，如果条件判断结果为 true 就返回第二个操作数的值，如果为 false 就返回第一个操作数的值。

        || 和 && 返回它们其中一个操作数的值，而非条件判断的结果。

        所以flag1是undefined，flag2是null。

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

var obj = {brand:'华为',price:1999};
(obj,'id',{value:1})
(obj,'price',{configurable:false})
((obj).length); ...①
for (var k in obj){
    (obj[k]); ...②
}
= 999;
delete obj['price']
(obj); ...③

A:①式输出结果为3

B:②式输出结果为华为 1999 1

C:③式输出结果为{brand: '华为', price: 999, id: 1}

D:③式输出结果为{brand: '华为', id: 1}

解析：

        为啥添加的属性既不能被()遍历，也不能被for...in...遍历？？？
        因为：defineProperty为对象设置属性后，该属性的描述符writable、configurable以及enumberable默认为false。
enumberable为false代表该属性不可遍历

var obj = {brand:'华为',price:1999};
(obj,'id',{value:1})
//给obj添加一个id属性，此时obj = { brand:'华为',price:1999，id:1 }；
//此时id的其他属性都是false，不可被遍历，不可写，不可配置
  
(obj,'price',{configurable:false})
//configurable:false表示price不可配置，也代表不可被delete删除
  
((obj).length); 
//因为id不可被遍历，故值为['brand','price']
  
for (var k in obj){
     (obj[k]);//因为id不可被遍历，故值为 华为 1999
}
  
= 999;
delete obj['price'] //失效，因为price设置了configurable:false
(obj);//obj = { brand:'华为',price:1999，id:1 }；

知识点扩展：
        for ...in ...可以把原型对象身上的属性遍历出来
        （）不能把原型对象身上的属性遍历出来

1）属性描述对象：
JavaScript 提供了一个内部数据结构，用来描述对象的属性，控制它的行为，比如该属性是否可写、可遍历等等。
这个内部数据结构称为“属性描述对象”（attributes object）

2）属性描述对象的6个元属性：
        value：设置该属性的属性值，默认值为undefined
        writable：表示能否修改属性的值，也就是说该属性是可写的还是只读的，默认为true（可写）
        enumerable：表示改属性是否可遍历，默认为true（可遍历）
        configurable：表示能否通过 delete 删除属性、能否修改属性的特性，或者将属性修改为访问器属性，默认为true（可配置）
        get：get是一个函数，表示该属性的取值函数（getter），默认为undefined
        set：get是一个函数，表示该属性的存值函数（setter），默认为undefined
configurable  如果设为false，将阻止某些操作改写该属性，比如无法删除该属性，也不得改变该属性的属性描述对象（value属性除外）

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

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

A:1、class a {}

B:报错、class a {}

C:报错、报错

D:1、报错

解析：

        es6中的class和let const一样都不存在变量提升，但是都有暂时性死区。（实际存在提升，只是因为TDZ的作用，并不会像var那样得到undefined,而是直接抛出错误）

        暂时性死区：
                ES6 明确规定，如果区块中存在let和const命令（本题的class也和let const 一样），
                这个区块对这些命令声明的变量，从一开始就形成了封闭作用域。
                凡是在声明之前就使用这些变量，就会报错。

                暂时性死区可访问：/#docs/let

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

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

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

A:999

B:undefined

C:抛出异常

D:888

解析：

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

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

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

21. 请问以下JS代码会输出什么（D）

var a = 10; 
(function a() {
    a = 20;
    (a); 
})()

A:10

B:20

C:undefined

D:输出函数a的内容

解析：

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

        普通函数可以修改变量名，立即执行函数不能修改变量名。

22.请问以下JS代码输出的结果是什么？（C） 

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

A:undefined、200、undefined

B:100、200、undefined

C:100、200、100

D:undefined、200、100

解析：

        相当于创建全局变量a再传入函数调用

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

function fn(value){
    (arguments instanceof Array); ...①
    ();...②
    (value);...③
    var arr = [...arguments];...④
}

fn(1,2,3);

A:①式的输出结果为false

B:②式输出结果为2

C:③式的输出结果为1

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

解析：

arguments：

• 内置对象
• 有length，可以被遍历
• 无pop() push()等数组方法 ，arguments是伪数组，不是数组
• 可以结合...arr扩展字符串生成数组

        var arr3 = [1, 2, 3]; let arr4 = [...arr3]; (arr4); // 123
     

 function fn(value) {
            (arguments instanceof Array); // false
            (); // 3
            (value); // 1 如果实参大于形参，按照形参的个数匹配；如果实参小于形参的个数，多余的形参会是undefined，那么打印出来就是NaN
            var arr = [...arguments];
            (arr); // [1,2,3]
 }
 fn(1, 2, 3);             

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

<button>点击</button>
<script>
    var btn = ('button');
</script>

A:

= function(){
    var that = this;
    setTimeout(function(){ = true;},1000)
}

B:

= function(){
    setTimeout(function(){ = true;},1000)
}

C:

= function(){
    setTimeout(()=>{
         = true;
    },1000)
}

D:

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

解析：

        this的指向问题。 A：用that来保存当前按钮的this B：回调函数执行时this指向了window C：箭头函数的this为外层的this，也就是按钮 D：用bind来绑定当前this

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

 A:
var res = ((val1,val2)=>{
    return val1 > 10;
})
(res);    

B:
var res = ((val1,val2)=>{
    return val1 > 10;
})
(res);

C:
var res = ((val1,val2)=>{
    return val1 > 10;
})
(res);

D:
var res = ((val1,val2)=>{
    return val1 > 10;
})
(res);

解析：

A:[20, 12]

B:true

C:false

D:[false, true, false, true, false]

1.数组方法forEach遍历数组

     (function(value, index, array) {
               //参数一是:数组元素
               //参数二是:数组元素的索引
               //参数三是:当前的数组
     })
      //相当于数组遍历的 for循环 没有返回值
2.数组方法filter过滤数组
    var arr = [12, 66, 4, 88, 3, 7];

    var newArr = (function(value, index,array) {
        //参数一是:数组元素
        //参数二是:数组元素的索引
        //参数三是:当前的数组
        return value >= 20;
    });
  
    (newArr);//[66,88] //返回值是一个新数组
3.数组方法some
    //some 查找数组中是否有满足条件的元素 
    var arr = [10, 30, 4];

    var flag = (function(value,index,array) {
        //参数一是:数组元素
        //参数二是:数组元素的索引
        //参数三是:当前的数组
        return value < 3;
    });
    (flag); //false返回值是布尔值,只要查找到满足条件的一个元素就立马终止循环
some和forEach区别:

•  如果查询数组中唯一的元素, 用some方法更合适,在some 里面 遇到 return true 就是终止遍历 迭代效率更高
•  在forEach 里面 return 不会终止迭代

4.数组方法map
    //返回一个数组，数组中元素为原始数组的平方根

    var numbers = [4, 9, 16, 25];
    function myFunction() {
        x = ("demo")
         = ();
    }
    //map() 方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。
    //map() 方法按照原始数组元素顺序依次处理元素。
    //注意： map() 不会对空数组进行检测。// 注意： map() 不会改变原始数组。

26.执行以下程序，会抛出语法错误的式子是（B）

var s = Symbol('key'); ...①
(s + '123'); ...②
var obj = {
    [s]:function(){(1);} ...③
}
var b = (obj); ...④

A:①

B:②

C:③

D:④

解析：

        Symbol 本质上是一种唯一标识符，可用作对象的唯一属性名，这样其他人就不会改写或覆盖你设置的属性值。
        注意事项
                值不能与其他类型的值进行运算
                 值不可以和其他类型值进行混合运算,否则会报错
                 值如果想要作为属性名，那就不能再用点运算符，因为点运算符后面跟的总是字符串
                4.在对象内部使用Symbol 值作为属性名的时候，必须要将值放在方括号中

Symbol 值不能与其他类型的值进行运算，会报错。
        新的API：() 方法可以返回所有类型的键名，包括常规键名和 Symbol 键名。

ES6 入门教程