作业

作业（一）

文章输出来源：拉勾教育打前端训练营

1.谈谈如何理解javascript异步编程的，消息队列，宏任务，微任务都是什么

• javascript异步编程是通过事件循环实现得到的，为了提升单线程的处理效率，事件循环，消息队列 宏任务和微任务都是js异步编程的一种方式
• js代码执行方式，读取代码 存入执行栈，在执行栈处理各个任务，如果是同步任务，处理完排出执行栈，遇到异步任务，执行栈处理完后，会委托宿主环境去执行任务,约定执行后，再将与这个任务的执行结果通过之前约定好的回调函数注册到消息队列，当执行栈的任务执行完成时候，将消息队列里的任务 推到执行栈，然后执行任务
• 宏任务：是消息队列里的任务，常见的接口请求、定时器等异步任务都是宏任务。
• 微任务：是基于当前任务产生而随当前任务结束后立即执行的任务，所以也是异步任务， 但是不需要通过EventLoop监测，通过消息队列取出并压入执行栈中再执行； 像通过Promise、MutationObserver、process.nextTick产生的任务都为微任务。

代码题

一，将下面异步代码使用Promise的方式改进

setTimeout(function(){
    var a="hello"
    setTimeout(function(){
        var b="lagou"
        set Timeout(function(){
            var c="I ♥ U"
            console.log(a+b+c)
        })
    })
})

var promise = new Promise((resolve,reject)=>{
    resolve('hello ')
}).then(res=>{
    return res + 'lagou '
}).then(res=>{
    return res + 'i love u'
}).then(res=>{
    console.log(res);
})

二，基于以下代码完成四个练习

const fp = require('lodash/fp')
const cars = [
    {
        name:'Ferrari FF',
        horsepower:660,
        dollar_value:700000,
        in_stock:true
    },
    {
        name:'Spyker C12 Zagato',
        horsepower:650,
        dollar_value:648000,
        in_stock:false
    },
    {
        name:'Jaguar XKR-S',
        horsepower:550,
        dollar_value:132000,
        in_stock:false
    },
    {
        name:'Audi R8',
        horsepower:525,
        dollar_value:114200,
        in_stock:false
    },
    {
        name:'Aston Martin One-77',
        horsepower:750,
        dollar_value:1850000,
        in_stock:true
    },
    {
        name:'Pagani Huayra',
        horsepower:700,
        dollar_value:1300000,
        in_stock:false
    }
]

使用fp.flowRight()重新实现下面函数

let isLastInStock =function(cars){
	let last_car=fp.last(cars)
	return fp.prop('in_stock',last_car)
}

const fn=fp.flowRight(fp.prop('in_stock'),fp.last)

使用fp.right() fp.prop() fp.first()获取第一个car的name

const fn=fp.flowRight(fp.prop('name'),fp.first())

使用帮助函数_average重构averageDollarValue，使用函数组合的方式实现

let _average=function(xs){
	return fp.reduce(fp.add,0,xs)/xs.length
}
let averageDollarValue=function(cars){
    let dollar_values=fp.map(function(car){
        return car.dollar_value
    },car)
    return _average(dollar_values)
}

const total = cars=>fp.map(cars=>cars.dollar_value,cars)
const fn = fp.flowRight(_average,total);
console.log(fn(cars));

使用flowRight写一个sanitizeNames()函数，返回一个下划线连接的小写字符串，把数组中的name转换为这种形式

let _underscore=fp.replace(/\w+/g,'_'/)
//无须改动，并在sanitizeNames()中方使用她

const sanitizeNames = fp.flowRight(fp.map(_underscore),fp.map(fp.toLower),fp.map(car=>car.name))
console.log(sanitizeNames(cars));

三 基于下面提供的代码，完成后续的四个练习

//support.js
class Container{
	static of(value){
		return new Container(value)
	}
	constructor(value){
		this._value=value
	}
	map(fn){
		return Container.of(fn(this._value))
	}
}
class Maybe{
    static of(x){
        returrn new Maybe(x)
    }
    isNothing(){
        return  this._value===null||this.value===undefined
    }
    constructor(x){
        this.value=x
    }
    map(fn){
        retrun this.isNothing()?this:Maybe.of(fn(this._value))
    }
}
module.exxports={Maybe,COntainer}

• 使用fp.add(x,y) fp.map(f,x)创建一个能让functor里的值增加的函数exl

  let maybe = Maybe.of([5, 6, 1])
  let exl = (x) => {
      return maybe.map(fp.map(a => fp.add(a, x)))
  }
  console.log(exl(2));
  
  

• 实现一个函数ex2 ,能使用fp.first获取列表的第一个元素

  let xs = Container.of(['do','ray','me','fa','so','la','ti','do'])
  let ex2 = ()=>{
      return xs.map(fp.first)
  
  

• 实现一个函数ex3，使用safeProp和fp.first找到user的名字的首字母。

  let safeProp = fp.curry((x,o)=>Maybe.of(o[x]))
  let user = {id:2,name:'Albert'}
  let ex3 = ()=>{
      let safe = safeProp('name',user)
      let names = safe.map(name=>name.split('')).map(fp.first)
      return names
  }
  console.log(ex3());
  
  

• 使用Maybe重写ex4 不要有if语句

  let ex4 = (n)=>{
    return Maybe.of(n).map(parseInt)
  }
  
  

手写Promise

Promise源码地址