Algorithm:

No.7 整数翻转

  1. /** 
  2.  * Given   num = 123, -123, 120
  3.  * return        321, -321, 21
  4.  * @author kanelogger
  5.  * @result runtime 84 ms ; memory 36.2 MB
  6. */
  7. var reverse = function(num=0) {
  8.   let a = Math.pow(2,31);
  9.     let b = num.toString().replace( /\d+/g , e => +(e.split('').reverse().join('')));
  10.   if(+b>=a-1 || +b<=-a)return 0
  11.     return +b
  12. };
  1. // 64 ms 36 MB,
  2. var reverse = function(x) {
  3.     const reversed =  parseInt(Math.abs(x).toString().split('').reverse().join('')) * Math.sign(x);
  4.     return (reversed <= 0x7fffffff && reversed >= -0x80000000) ? reversed : 0;
  5. }

这一道题很简单，但是在处理负数的问题上，没有用到 Math.sign() ，造成了方法比较复杂。

No.10 回文数

  1. /**
  2.  * @param {number} x 
  3.  * Input: 121      -121     10
  4.  * Output: true    false    false
  5.  * @return {boolean}
  6.  * 212 ms    45.8 MB 
  7.  */
  8. var isPalindrome = function(x) {
  9.     let a = x.toString(),b = a.length-1;
  10.     if(x<0)return false
  11.     let c = b/2;
  12.     for(let i=0;i<c;i++){
  13.         if(a[i]!=a[b-i])return false
  14.     }
  15.     return true
  16. };
  18. //  最佳实践
  19. //     212 ms    44.8 MB
  20. var isPalindrome = function(x) {
  21.     let w = x,
  22.         y = 0;
  24.     while(w > 0) {
  25.         let z = w % 10;
  27.         y *= 10;
  28.         y += z;
  30.         w -= z;
  31.         w /= 10;
  32.     }
  34.     return x === y;
  35. };

No.13 罗马数转整数

  1. // 136 ms    40.1 MB
  2. var romanToInt = function(s) {
  3.     const m = {
  4.         I:1,V:5,X:10,L:50,C:100,D:500,M:1000
  5.     }
  6.     let ans = 0
  7.     for(let i=0,l=s.length;i<l;i++){
  8.         if( i<l-1 && m[s[i]]<m[s[i+1]] ){
  9.            ans-=m[s[i]]
  10.         }
  11.         else{
  12.             ans+=m[s[i]]
  13.         }
  14.     }
  15.     return ans
  16. };
  18. // 最佳实践: 132ms/40MB
  19. let map = {
  20.   'M' : 1000,
  21.   'D' : 500,
  22.   'C' : 100,
  23.   'L' : 50,
  24.   'X' : 10,
  25.   'V' : 5,
  26.   'I' : 1,
  27. }
  29. var romanToInt = function(s) {
  30.   let result = 0
  32.   for (i=0;i<s.length-1;i++){
  33.     if(map[s[i]] < map[s[i+1]]){
  34.       result -= map[s[i]]
  35.     } else{
  36.       result += map[s[i]]
  37.     }
  38.   }
  39.   result += map[s[s.length-1]]
  41.   return result
  42. };

Review: 阅读并点评一篇英文技术文章

JavaScript的核心是一种同步的、阻塞的单线程语言。为什么我们需要异步呢？
week02 - 图1

有了异步，就可以对可能发生在后台的事情使用异步方法。
异步的演变：回调, promises, async/await
回调函数

  1. a( resultA=>{
  2.   b( resultA,resultB => {
  3.     c( resultB,resultC => {
  4.       console.log(resultC)
  5.     } ) )
  6.   } )
  7. } )

promise

  1. const doSteps = new Promise((res,rej)=>{
  2.   // pending
  3.   if(){
  4.     res()
  5.   }else{
  6.     rej()
  7.   }
  8. })
  9. doSteps()
  10. .then( res => console.log(res))
  11. .catch( err => console.log(err))

async/await 封装在 promise 顶部的语法糖

对比promise和async/await

  1. function getJSON(ms){
  2.   const a = true;// control
  3.   return new Promise((res,rej)=>{
  4.     console.log("pending")
  5.     if(a){
  6.       return setTimeout(res, ms, 'resolve');
  7.     }else{
  8.       return setTimeout(rej, ms, 'reject');
  9.     }
  10.   })
  11. }
  13. // promise
  14. getJSON(100)
  15. .then(res=>console.log(res)); 
  16. // pending
  17. // Promise {<pending>}
  18. // resolve
  20. // async/await
  21. const res = await getJSON(100);
  22. console.log(res)
  23. // pending
  24. // resolve

一个then，一个await,区别显而易见。

注意: await 只能在异步函数内部调用。

  1. Promise.resolve("hi");//Promise {<resolved>: "hi"}
  3. (async ()=> 'hi')() //Promise {<resolved>: "hi"}

使用async，即使您没有明确返回promise，它也将确保您的代码通过promise传递。

错误处理

  1. const A = () => {
  2.   B()
  3.   .then(res=>C(res))
  4.   .catch(err=>console.log(err))
  5. }
  7. const A = async ()=> {
  8.   try {
  9.     const res = await B()
  10.     C(result)
  11.   }catch(err)
  12.   console.log(err)
  13. }

Tips: 学习一个技术技巧

  • [].flat(depth) 数组扁平化
  1. let arr = [1,2,3,4,5,[6,7]]
  3. arr.flat(1) || arr.flat() // [1,2,3,4,5,6,7]
  5. let arr1= [1,2,3,[4,[5,6]]]
  7. arr1.flat()//[1,2,3,4,[5,6]]
  9. arr1.flat(Infinity) //[1,2,3,4,5,6] 传入 Infinity无论多深都可以展开
  11. let arr2 = [1, 2, , 4, 5];
  13. arr2.flat();// [1,2,4,5] 移除数组中的空项:
  • [].flatMap() 串联两个函数map().flat(1)
  1. const arr = [1, 2, 3, 4];
  2. console.log(arr.flatMap(x => [x, x + 10]))    // [1,11,2,12,3,13,4,14]
  3. console.log(arr.map(x => [x, x + 10]).flat()) // [1,11,2,12,3,13,4,14]

Share: 分享一篇有观点和思考的技术文章

  1. 12张图带你理解异步JS
  2. 拆解 JavaScript 中的异步模式