JS 面试题库

4个月前 ⋅ 0

1.['1','2','3'].map(parseInt)   =》   [1, NaN, NaN]

map函数的第一个参数callback，这个callback一共可以接收三个参数，其中第一个参数代表当前被处理的元素，而第二个参数代表该元素的索引。
parseInt则是用来解析字符串的，使字符串成为指定基数的整数。接收两个参数，第一个表示被处理的值（字符串），第二个表示为解析时的基数。
parseInt(string, radix)

  • parseInt('1', 0) //radix为0时，且string参数不以“0x”和“0”开头时，按照10为基数处理。这个时候返回1；
  • parseInt('2', 1) //基数为1（1进制）表示的数中，最大值小于2，所以无法解析，返回NaN；
  • parseInt('3', 2) //基数为2（2进制）表示的数中，最大值小于3，所以无法解析，返回NaN；

    2.Promise 构造函数是同步执行还是异步执行，then 呢？

    
const promise = new Promise((resolve, reject) => {
console.log(1)
resolve()
console.log(2)
})

promise.then(() => { console.log(3) })

console.log(4) //输入结果 1 2 4 3

promise构造函数是同步执行的，then方法是异步执行的；<br />Promise new的时候会立即执行里面的代码，then是微任务, 会在本次任务执行完的时候执行 ，setTimeout是宏任务， 会在下次任务执行的时候执行；

<a name="7wHMT"></a>
## 3.考察promise,async ,await
<a name="a2fBS"></a>
###### 示例1:
```javascript
async function async1() {
    console.log("async1 start");
    await async2();
    console.log("async1 end");
}

async function async2() {
    console.log("async2");
}

console.log("script start");

setTimeout(function() {
    console.log("setTimeout");
}, 0);

async1();

new Promise(function(resolve) {
    console.log("promise1");
    resolve();
}).then(function() {
    console.log("promise2");
});

console.log("script end");

输出结果：

script start
async1 start
async2
promise1
script end
async1 end
promise2
setTimeout

示例二：

async function testFun(){
    console.log("function start");

    await Promise.resolve(()=>{
        console.log("promise1");
    })

    console.log("function test");

    return "function end"
}

console.log("test start");

testFun().then(res=>console.log(res));

console.log("test end");

输出结果：

//test start
//function start
//test end
//function test
//function end

4.执行顺序

  const fn = () => new Promise((resolve, reject) => {
      console.log(1)
      const p = new Promise((resolve, reject) => {
        console.log(2)
        setTimeout(() => {
          console.log(3)
          resolve(4)
        }, 0)
        resolve(5)
      })
      p.then(m => console.log(m))
      resolve(6)
  })

  fn().then(n => console.log(n))
  console.log(7)

//打印顺序
1
2
7
5
6
3

5.JS赋值

var foo = { n: 1 };
var bar = foo;
foo.x = foo = { n: 2 };
console.log(foo.x); // undefined

关键点在于它的返回值，简单解释就是说：如果有表达式foo.x，则它的返回值是一个指向foo对象x属性的引用。根据这一点，开始分析：
首先是两个变量的声明和初始化，var foo = { n: 1 }; var bar = foo; ，这个很好理解，就是foo和bar同时指向了一个相同的对象 { n: 1 }。
接下来，对于表达式 foo.x = foo = { n: 2 }; ，实际上等于是 foo.x = (foo = { n: 2 }) 。虽然赋值运算符具有右结合性，然而它首先做的是得到表达式foo.x的值，它返回一个指向对象{ n: 1}的x成员的引用，需要注意的是，这个时候foo并没有改变引用的指向。
继续，开始计算右边的结果，就是让foo指向另外的一个对象{n: 2}，返回值就是其右边运算式的结果，即对象{n: 2}。
那么现在应该清楚了，赋值语句中foo.x的结果是指向对象一成员x的引用，而下面的console.log(foo.x)中的foo指向的是对象二，所以这里foo.x返回undefined就理所当然了。
所以试着输出对象一，即bar（因为它从始至终指向的是对象一）：{ n: 1, x: { n: 2 } }

6.实现一个函数的链式调用


//LazyPig("Peggy")输出:   Hello，I’m Peggy！

//LazyPig("Peggy").sleep(10).eat("dinner")输出: Hello，I'm Peggy！
//等待10秒..
//Wake up after 10
//Eat dinner

//LazyPig("Peggy").eat("dinner").eat("supper")输出:
//Hello，I'm Peggy！
//Eat dinner
//Eat supper

function LazyPig(name){
    return new Lazy(name)
}

function Lazy(name){
    this.name = name;
    this.task = [];
    console.log('Hi, 我是' + name)
    let _this = this;
    let fn = (function(){
        return function(){
            _this.next()
        }
    })()
    this.task.push(fn)
    setTimeout(()=>{
        _this.next()
    },0)
}

Lazy.prototype = {
    next: function(){
        var fn = this.task.shift()
        fn && fn()
    },
    sleep: function(time){
        let _this = this;
        let fn = (function(time){
            return function(){
                setTimeout(()=>{
                    console.log(_this.name + ' Wake up !')
                    _this.next()
                }, time * 1000)
            }
        })(time)
        this.task.push(fn)
        return this;
    },
    eat: function(smt){
        let _this = this;
        let fn = (function(smt){
            return function(){
                console.log(_this.name + ' is eating ' + smt);
                _this.next()
            }
        })(smt)
        this.task.push(fn)
        return this;
    }
}
LazyPig('哼哼').sleep(5).eat('早饭')