[关闭]
@JunQiu 2018-09-18T13:18:45.000000Z 字数 2697 阅读 491

Js_常见err情况、管道技术、柯里化

summary_2018/08 language_js

1、日常

1.1、js:关于err的冒泡和一些实际情况的处理

1.2、管道技术及柯里化技术

2、技术

2.1、js:关于err的冒泡和一些实际情况的处理

2.1.1、Promise.all
  1. const res=Promise.all([Promise.resolve(11),Promise.reject(22)])
  2. // 不对错误进行处理,返回第一个reject
  3. res.then(
  4. res => console.log(res)
  5. ).catch(error => console.log(error)) // 22
  6. const res1=Promise.all([Promise.resolve(11),Promise.reject(22).catch(err=>err)])
  7. // 对错误进行处理,不会上抛到Promise.all层,并可以修改其返回值
  8. res1.then(
  9. res => console.log(res)
  10. ).catch(error => console.log(error)) // [ 11, 22 ]
2.1.2、arrary.map
  1. const arr = [1, 2, 3]
  2. // 没有异常抛出的情况就不用说了,当有某个值执行时有err抛出
  3. function test (x) {
  4. if (x === 1)
  5. throw new Error('error')
  6. return x * x
  7. }
  8. // console.log(arr.map(test)) // 报错(这是当然的,err没有进行处理)
  9. // 如果我们在异常外面包裹一层处理会怎么样???
  10. // const res = Promise.all(arr.map(test))
  11. // res.then(res => console.log(res)).catch(error => console.log(error)) // 报错,并不能处理 ,显然这也是不能处理的,并没有想象中冒泡到Promise.all层,因为这里其实并不能算是map外面的的上层,只是对map结果的处理
  12. /**真正的,或者下面那样**/
  13. try {
  14. arr.map(test) // 这才是对map的包裹
  15. }catch (e) {
  16. console.log(e.toString())
  17. }
  18. // err正常的上冒直接由上层处理
  19. function test1 () {
  20. // test(1)
  21. arr.map(test)
  22. }
  23. try {
  24. test1()
  25. } catch (e) {
  26. console.log(e.toString())
  27. }
  28. // 正确的处理对map传入的函数进行处理
  29. /*function test (x) {
  30. if (x === 1) {
  31. try {
  32. throw new Error('error')
  33. } catch (e) {
  34. return 'xx'
  35. }
  36. }
  37. return x * x
  38. }*/
  39. // 一些新同学对异步回调的错误处理
  40. /*
  41. const fs = require('fs')
  42. try {
  43. fs.readFile('/some/file/that/does-not-exist', (err, data) => {
  44. if (err) {
  45. throw err // 错误实际在这里处理,已经被返回
  46. }
  47. })
  48. } catch (err) {
  49. // This will not catch the throw!
  50. console.log(err)
  51. }
  52. */

2.1.3 p-pipe对异常的处理极不友善,需要在管道内部及时处理:见下文


2.2、管道技术及柯里化技术

2.2.1 管道技术
  1. // Tips:对 err的处理极不友善,需要在管道内部及时处理
  2. const pPipe = require('p-pipe')
  3. const a = (x) => {
  4. console.log('a:' + x)
  5. return x
  6. }
  7. const d = (x) => {
  8. throw new Error('test')
  9. console.log('d:' + x)
  10. return x
  11. }
  12. const b = (x) => {
  13. console.log('b:' + x)
  14. return x + 1
  15. }
  16. // 封装为一个管道
  17. const p = pPipe(a, b)
  18. const c = all => Promise.all(all.map(p))
  19. // 可以刚才的管道基础上来生成管道
  20. const p1 = pPipe(d, c)
  21. const arr = [1, 2]
  22. async function f () {
  23. const res = await p1(arr).catch().catch(err => console.log(err.toString())) // 捕获不到d中的err但是可以用try-catch
  24. }
  25. f()
  26. // 自己实现只有等周末了,事情有点多。。。。扎心
  27. // 好像时间挤挤还是有的,哈哈
  28. function pipe (...next) {
  29. return async function (para) {
  30. let curPara = para
  31. for (let i = 0; i < next.length; i++) {
  32. curPara = await next[i](curPara)
  33. }
  34. return curPara
  35. }
  36. }
  37. // 或者 同步func
  38. async function a (x) {
  39. console.log(x)
  40. return x + 1
  41. }
  42. async function f () {
  43. console.log(await pipe(a, a, a)(1)) // 1 2 3 4
  44. }
  45. f()
2.2.2 柯里化技术
  1. ## Example
  2. g(a,b,c)
  3. 你可以:
  4. g(a)(b)(c)
  5. g(a,b)(c)
  6. g(a,b,c)
  7. 然后返回结果,这对上面的管道技术是不是很有用啊,因为上的面的p-pipe仅支持上一个函数的结果作下一个函数的参数,虽然可以在上一个结果中包含(但很丑)。
  8. 其实柯里化并没有想象中那么复杂,比如我们自己来实现一个:
  9. function test (a, b) {
  10. return function (b) {
  11. return b
  12. }
  13. }
  14. // 使用,只是一个简单的例子,复杂的实现还是比较难
  15. test(a)(b)
添加新批注
在作者公开此批注前,只有你和作者可见。
回复批注