大发快乐8APP下载_大发快乐8APP官方 - 大发快乐8APP下载,大发快乐8APP官方是新浪网最重要的频道之一,24小时滚动报道国内、国际及社会新闻。每日编发新闻数以万计。

JavaScript 复杂判断的更优雅写法

  • 时间:
  • 浏览:0

  switch (status) {

  ['guest_5', () => { /*do sth*/ }],

}

  const functionC = () => { /*send log*/ }

 */

  [3, ['fail', 'FailPage']],

    identity: 'guest',

])

  return new Map([

    status: 1

      sendLog('processing')

    } else {

  jumpTo(pageName)

  let action = [...actions()].filter(([key, value]) => (key.identity == identity && key.status == status))

一元判断时:存到Object里

    }, functionA],

  'guest_1': () => { /*do sth*/ },

  [5, ['cancel', 'CancelPage']],

  let action = actions[`${identity}_${status}`] || actions['default']

    status: 2

  ['master_3', () => { /*do sth*/ }],

  }, () => { /* functionA */ }],

 * @param {number} status 活动情况报告:1开团进行中 2开团失败 3 商品售罄 4 开团成功 5 系统退还

/**

  [{

 */

const onButtonClick = (identity, status) => {

  '1': ['processing', 'IndexPage'],

const onButtonClick = (status) => {

}

const actions = new Map([

  [{

}

  const functionA = () => { /*do sth*/ }

}

  ['master_4', () => { /*do sth*/ }],

}

  //...

      sendLog('fail')

这类人现在再将难度升级这类点,假如有一天guest情况报告下,status1-4的解决逻辑都一样咋办 办,最差的情况报告是原本:

const actions = () => {

      jumpTo('CancelPage')

  } else if (status == 3) {

    status: 1

  }

 * 按钮点击事件

 * 按钮点击事件

  '2': ['fail', 'FailPage'],

原本写咋样会让能满足日常需求了,但认真这类讲,中间重写了4次functionA还是有点痛 不爽,假如有一天判断条件变得有点痛 简化,比如identity有3种情况报告,status有10种情况报告,那你前要定义1000条解决逻辑,而往往你这类逻辑中间好多好多 全部都是相同的,这似乎也是笔者不不接受的,那还还后能 原本实现:

  } else if (status == 2) {

}

}

      sendLog('success')

 * 按钮点击事件

通过代码还还后能 看完你这类按钮的点击逻辑:根据不同活动情况报告做两件事情,发送日志分派和跳转到对应页面,这类人还还后能 很轻易的提出这段代码的改写方案,switch出场:

    //...

    } else if (status == 2) {

是全部都是又高级了这类点?

这里也看出来Map与Object的区别,Map还还后能 用任何类型的数据作为key。

  ['guest_4', () => { /*do sth*/ }],

}

    sendLog('fail') jumpTo('FailPage')

    if (status == 1) {

 * @param {number} status 活动情况报告:1 开团进行中 2 开团失败 3 商品售罄 4 开团成功 5 系统退还

  let action = actions[status] || actions['default'],

    [{

}

  ['master_5', () => { /*do sth*/ }],

  'guest_2': () => { /*do sth*/ },

  }, () => { /*do sth*/ }],

  let action = [...actions].filter(([key, value]) => (key.identity == identity && key.status == status))

多元判断时:将condition拼接成字符串存到Object里

从中间的例子这类人还还后能 看完,当你的逻辑升级为二元判断时,你的判断量会加倍,你的代码量也会加倍,这时咋办 写更清爽呢?

 * @param {number} status 活动情况报告:1开团进行中 2开团失败 3 开团成功 4 商品售罄 5 有库存未开团

  sendLog(logName)

    sendLog('cancel') jumpTo('CancelPage')

    [/^guest_[1-4]$/, functionA],

 */

/**

}

好这类的写法是将解决逻辑函数进行缓存:

}

  ])

  }, () => { /* functionA */ }],

  action.call(this)

const actions = new Map([

    identity: 'guest',

const onButtonClick = (identity, status) => {

const actions = () => {

      //do sth

  const functionA = () => { /*do sth*/ }

  } else if (status == 4) {

  ['master_2', () => { /*do sth*/ }],

  [1, ['processing', 'IndexPage']],

本文咋样会让教你了8种逻辑判断写法,包括:

      identity: 'guest',

    [{

  action.forEach(([key, value]) => value.call(this))

    }

    //...

  [4, ['success', 'SuccessPage']],

  }, () => { /* functionB */ }],

const onButtonClick = (identity, status) => {

    } else if (status == 5) {

}

  [{

  let action = [...actions()].filter(([key, value]) => (key.test(`${identity}_${status}`)))

是全部都是还有这类写法呢?有的:

}

  } else {

原本写用到了es6里的Map对象,是全部都是更爽了?Map对象和Object对象有你这类区别呢?

const onButtonClick = (status) => {

  'default': ['other', 'Index'],

}

  [{

    sendLog('other') jumpTo('Index')

    }, functionA],

    default:

      identity: 'guest',

一元判断时:存到Map里

原本对象通常全部都是当事人的原型,好多好多 原本对象总有原本"prototype"键。

    } else if (status == 3) {

 */

  action.forEach(([key, value]) => value.call(this))

  ['default', () => { /*do sth*/ }],

  [2, ['fail', 'FailPage']],

      //do sth

上述代码核心逻辑是:把原本条件拼接成字符串,并通过以条件拼接字符串作为键,以解决函数作为值的Map对象进行查找并执行,你这类写法在多元条件判断以前尤其好用。

      status: 2

当然上述代码咋样会让用Object对象来实现也是这类的:

 * @param {string} identity 身份标识:guest客态 master主态

const onButtonClick = (status) => {

const onButtonClick = (identity, status) => {

const onButtonClick = (status, identity) => {

const actions = new Map([

switch

      jumpTo('Index')

 * @param {number} status 活动情况报告:1 开团进行中 2 开团失败 3 商品售罄 4 开团成功 5 系统退还

也好多好多 说利用数组循环的形态学 ,符合正则条件的逻辑全部都是被执行,那就还还后能 一并执行公共逻辑和单独逻辑,咋样会让正则的存在,我能 打开想象力解锁更多的玩法,本文就不赘述了。

      status: 3

  jumpTo(action[1])

    } else if (status == 4) {

      jumpTo('FailPage')

这时有同學會说,还有更简单的写法:

    [/^guest_5$/, functionB],

  const functionB = () => { /*do sth*/ }

    [{

    [{

  let action = [...actions()].filter(([key, value]) => (key.test(`${identity}_${status}`)))

  }, () => { /*do sth*/ }],

  return new Map([

  let action = actions.get(`${identity}_${status}`) || actions.get('default')

  return new Map([

  ['master_1', () => { /*do sth*/ }],

咋样会让这类并学人太好把查询条件拼成字符串有点痛 别扭,那还有并全部都是方案,好多好多 用Map对象,以Object对象作为key:

}

    status: 5

  action.call(this)

  } else if (identity == 'master') {

      jumpTo('IndexPage')

])

这类人编写js代码时一直遇到简化逻辑判断的情况报告,通常这类人还还后能 用if/else咋样会让switch来实现多个条件判断,但从全部都是有个问提,随着逻辑简化度的增加,代码中的if/else/switch会变得这样臃肿,这样看不懂,这样咋样更优雅的写判断逻辑,本文带你试一下。

  ['default', ['other', 'Index']]

  '5': ['cancel', 'CancelPage'],

    pageName = action[1]

const onButtonClick = (status) => {

const actions = () => {

 * 按钮点击事件

    logName = action[0],

if/else

    } else if (status == 4) {

    [/^guest_.*$/, functionC],

  [{

const onButtonClick = (identity, status) => {

    identity: 'guest',

      identity: 'guest',

  '4': ['success', 'SuccessPage'],

/**

原谅我又用了if/else,咋样会让我看完好多好多 人依然在用if/else写你这类大段的逻辑判断。

    case 3:

  '3': ['fail', 'FailPage'],

    [/^guest_5$/, functionB],

    }, functionA],

    status: 3

  if (identity == 'guest') {

 * 按钮点击事件

  action.forEach(([key, value]) => value.call(this))

    case 2:

    sendLog('fail') jumpTo('FailPage')

  const functionA = () => { /*do sth*/ }

  ])

    } else if (status == 3) {

    } else {

    //...

      //do sth

  //...

 * 按钮点击事件

  ['guest_1', () => { /*do sth*/ }],

    }

  const functionB = () => { /*do sth*/ }

这类人前要把问提升级一下,以前按钮点击以前只前要判断status,现在还前要判断用户的身份:

 */

const actions = new Map([

先看一段代码

  }, () => { /* functionA */ }],

  ])

这里Map的优势更加凸显,还还后能 用正则类型作为key了,原本全部都是了无限咋样会让,假如有一天需求变成,凡是guest情况报告全部都是发送原本日志分派,不同status情况报告也前要单独的逻辑解决,原本们还还后能 原本写:

    case 1:

  if (status == 1) {

])

    case 4:

      //do sth

中间代码人太好看起来更清爽了,你这类办法 的聪明之存在于:将判断条件作为对象的属性名,将解决逻辑作为对象的属性值,在按钮点击的以前,通过对象属性查找的办法 来进行逻辑判断,你这类写法有点痛 适合一元条件判断的情况报告。

      //do sth

    sendLog('processing') jumpTo('IndexPage')

      identity: 'guest',

/**

  }, () => { /* functionA */ }],

      //do sth

    } else if (status == 5) {

      break

const actions = {

    [/^guest_[1-4]$/, functionA],

      //do sth

  [{

    status: 4

  sendLog(action[0])

    }, functionA],

      break

嗯,原本看起来比if/else清晰多了,细心的同学也发现了小技巧,case 2和case 3逻辑一样的以前,还还后能 省去执行语录和break,则case 2的情况报告自动执行case 3的逻辑。

      //do sth

      //do sth

    } else if (status == 2) {

我能 通过size属性很容易地得到原本Map的键值对个数,而对象的键值对个数能够手动确认。

      break

    identity: 'guest',

多元判断时:将condition拼接成字符串存到Map里

}

      status: 4

    if (status == 1) {

至此,本文也将告一段落,愿你未来的人生里,不好多好多 有if/else/switch。

/**

  ['guest_2', () => { /*do sth*/ }],

      status: 5

      break

 */

    [{

多元判断时:将condition存为Object存到Map里

  [{

    identity: 'guest',

原谅我不写每个判断里的具体逻辑了,咋样会让代码太冗长了。

 * @param {string} identity 身份标识:guest客态 master主态

      status: 1

  }

      jumpTo('SuccessPage')

      identity: 'guest',

    status: 2

      sendLog('cancel')

  ['guest_3', () => { /*do sth*/ }],

    identity: 'guest',

    identity: 'guest',

  } else if (status == 5) {

])

  //....

      sendLog('other')

    case 5:

  action.forEach(([key, value]) => value.call(this))

  const functionB = () => { /*do sth*/ }

  }

原本对象的键能够是字符串咋样会让Symbols,但原本Map的键还还后能 是任意值。

    }, functionB],

 * @param {number} status 活动情况报告:1 开团进行中 2 开团失败 3 开团成功 4 商品售罄 5 有库存未开团

      //do sth

多元判断时:将condition写作正则存到Map里

    sendLog('success') jumpTo('SuccessPage')

 * @param {number} status 活动情况报告:1 开团进行中 2 开团失败 3 商品售罄 4 开团成功 5 系统退还

  let action = actions.get(status) || actions.get('default')

      break

/**

const actions = {

const onButtonClick = (identity, status) => {

      //do sth

      //do sth