วิธีการย่อข้อความตามเงื่อนไขของฉันให้สั้นลง

ฉันมีคำสั่งที่มีเงื่อนไขยาวมากดังต่อไปนี้:

if(test.type == 'itema' || test.type == 'itemb' || test.type == 'itemc' || test.type == 'itemd'){
    // do something.
}

ฉันสงสัยว่าถ้าฉันสามารถ refactor การแสดงออก / คำสั่งนี้ในรูปแบบที่กระชับมากขึ้น

ความคิดเกี่ยวกับวิธีการบรรลุสิ่งนี้?

ใส่ค่าของคุณลงในอาร์เรย์และตรวจสอบว่ารายการของคุณอยู่ในอาร์เรย์:

if ([1, 2, 3, 4].includes(test.type)) {
    // Do something
}

หากเบราว์เซอร์ที่คุณสนับสนุนไม่มีArray#includesวิธีคุณสามารถใช้polyfill นี้ได้

คำอธิบายสั้น ๆ ของ~ทางลัดตัวหนอน:

อัปเดต:เนื่องจากตอนนี้เรามีincludesวิธีการแล้วจึงไม่มีประโยชน์ในการใช้~แฮ็คอีกต่อไป เพียงแค่เก็บไว้ที่นี่สำหรับผู้ที่สนใจที่จะรู้ว่ามันทำงานอย่างไรและ / หรือได้พบมันในรหัสของผู้อื่น

แทนที่จะตรวจสอบว่าผลลัพธ์indexOfเป็น>= 0หรือไม่มีทางลัดที่ดีเล็กน้อย:

if ( ~[1, 2, 3, 4].indexOf(test.type) ) {
    // Do something
}

นี่คือซอ: http://jsfiddle.net/HYJvK/

มันทำงานอย่างไร หากพบรายการในอาร์เรย์ให้indexOfส่งคืนดัชนี -1หากรายการไม่พบก็จะกลับมา โดยไม่ลงรายละเอียดมากเกินไป~เป็นค่าที่เหมาะสมไม่ได้ผู้ประกอบการที่จะกลับมาเฉพาะสำหรับ0-1

ฉันชอบใช้~ทางลัดเนื่องจากมันสั้นกว่าการเปรียบเทียบค่าส่งคืน ฉันหวังว่าจาวาสคริปต์จะมีin_arrayฟังก์ชั่นที่ส่งกลับบูลีนโดยตรง (คล้ายกับ PHP) แต่นั่นเป็นเพียงแค่ความคิดที่ปรารถนา ( อัปเดต:ตอนนี้มันทำแล้วเรียกว่าincludesดูด้านบน) โปรดทราบว่า jQuery inArrayในขณะที่แชร์ลายเซ็นของวิธีการของ PHP จะเลียนแบบภาษาของจริงindexOfฟังก์ชัน (ซึ่งมีประโยชน์ในหลายกรณีหากดัชนีคือสิ่งที่คุณต้องการอย่างแท้จริง)

หมายเหตุสำคัญ:การใช้ช็อตคัตตัวหนอนดูเหมือนว่าจะมีการถกเถียงกันอย่างรุนแรงเนื่องจากบางคนเชื่อว่ารหัสไม่ชัดเจนเพียงพอและควรหลีกเลี่ยงค่าใช้จ่ายทั้งหมด (ดูความคิดเห็นในคำตอบนี้) หากคุณแบ่งปันความเชื่อมั่นคุณควรยึด.indexOf(...) >= 0แนวทางแก้ไข

คำอธิบายอีกต่อไปเล็กน้อย:

จำนวนเต็มใน JavaScript มีการลงชื่อซึ่งหมายความว่าบิตซ้ายสุดถูกสงวนไว้เป็นบิตลงชื่อ ธงเพื่อระบุว่าจำนวนเป็นค่าบวกหรือลบโดยมี1ค่าลบ

นี่คือตัวอย่างตัวเลขในรูปแบบไบนารี 32 บิต:

1 :    00000000000000000000000000000001
2 :    00000000000000000000000000000010
3 :    00000000000000000000000000000011
15:    00000000000000000000000000001111

ตอนนี้ที่นี่มีตัวเลขเดียวกัน แต่เป็นลบ:

-1 :   11111111111111111111111111111111
-2 :   11111111111111111111111111111110
-3 :   11111111111111111111111111111101
-15:   11111111111111111111111111110001

ทำไมชุดค่าผสมดังกล่าวแปลกสำหรับจำนวนลบ? ง่าย จำนวนลบเป็นเพียงค่าผกผันของจำนวนบวก + 1 0การเพิ่มจำนวนลบไปยังหมายเลขที่ดีควรผลผลิตเสมอ

เพื่อให้เข้าใจสิ่งนี้ลองทำเลขคณิตไบนารีง่ายๆ

นี่คือวิธีการที่เราจะเพิ่ม-1ไป+1:

   00000000000000000000000000000001      +1
+  11111111111111111111111111111111      -1
-------------------------------------------
=  00000000000000000000000000000000       0

และนี่คือวิธีการที่เราจะเพิ่ม-15ไป+15:

   00000000000000000000000000001111      +15
+  11111111111111111111111111110001      -15
--------------------------------------------
=  00000000000000000000000000000000        0

เราจะได้รับผลลัพธ์เหล่านั้นได้อย่างไร ด้วยการเพิ่มปกติวิธีที่เราสอนในโรงเรียน: คุณเริ่มต้นที่คอลัมน์ขวาสุดและคุณรวมแถวทั้งหมด หากผลรวมมากกว่าตัวเลขหลักเดียวที่ยิ่งใหญ่ที่สุด (ซึ่งเป็นทศนิยม9แต่ในรูปแบบเลขฐานสอง1) เราจะนำส่วนที่เหลือไปยังคอลัมน์ถัดไป

ตอนนี้เป็นคุณจะแจ้งให้ทราบเมื่อมีการเพิ่มจำนวนลบไปยังหมายเลขบวกที่คอลัมน์ขวามากที่สุดที่ไม่ได้ทั้งหมด0เสมอจะมีสอง1s 2ซึ่งเมื่อรวมเข้าด้วยกันจะส่งผลให้ การแทนเลขฐานสองของสิ่งมีชีวิตทั้งสอง10เราจะนำ1ไปยังคอลัมน์ถัดไปและวาง0ผลลัพธ์ในคอลัมน์แรก คอลัมน์อื่น ๆ ทางด้านซ้ายมีเพียงหนึ่งแถว1เท่านั้นดังนั้นการ1ดำเนินการจากคอลัมน์ก่อนหน้าจะรวมกันอีกครั้ง2ซึ่งจะดำเนินการต่อไป ... กระบวนการนี้จะทำซ้ำตัวเองจนกว่าเราจะไปที่คอลัมน์ซ้ายสุด ที่1จะต้องดำเนินการต่อไปไม่มีที่ไหนเลยดังนั้นมันจึงล้นและหายไปและเราก็เหลือไว้ด้วย0กัน

ระบบนี้เรียกว่าการเติมเต็ม 2 คุณสามารถอ่านเพิ่มเติมเกี่ยวกับเรื่องนี้ได้ที่นี่:

การเป็นตัวแทนที่สมบูรณ์ของ 2 สำหรับจำนวนเต็มที่ลงนามแล้ว

ตอนนี้หลักสูตรความผิดพลาดในส่วนประกอบ 2 จบลงแล้วคุณจะสังเกตเห็นว่า-1เป็นหมายเลขเดียวที่มีการแทนค่าฐานสอง1ทั้งหมด

การใช้ตัวดำเนินการ~bitwise NOT บิตทั้งหมดในจำนวนที่กำหนดจะกลับด้าน วิธีเดียวที่จะ0กลับมาจากการแปลงกลับบิตทั้งหมดคือถ้าเราเริ่มต้นด้วย1ทุกอย่าง

ดังนั้นทั้งหมดนี้เป็นวิธีที่ยืดยาวในการบอกว่า~nจะกลับมา0ถ้าnเป็น-1เท่านั้น

คุณสามารถใช้คำสั่ง switch ด้วย fall thru:

switch (test.type) {

  case "itema":
  case "itemb":
  case "itemc":
  case "itemd":
    // do something
}

การใช้วิทยาศาสตร์: คุณควรทำสิ่งที่ idfah พูดและสิ่งนี้เพื่อความเร็วที่เร็วที่สุดในขณะที่ให้รหัสสั้น:

นี่เร็วกว่า~วิธี

var x = test.type;
if (x == 'itema' ||
    x == 'itemb' ||
    x == 'itemc' ||
    x == 'itemd') {
    //do something
}

http://jsperf.com/if-statements-test-techsin (ชุดด้านบน: Chrome, ชุดด้านล่าง: Firefox)

สรุป:

ถ้าเป็นไปได้ไม่กี่และคุณรู้ว่าบางคนมีแนวโน้มที่จะเกิดขึ้นกว่าที่คุณได้รับประสิทธิภาพสูงสุดจากif ||, และswitch fall throughif(obj[keyval])

หากความเป็นไปได้มีมากมายและทุกคนในนั้นอาจเป็นสิ่งที่เกิดขึ้นมากที่สุดในอีกนัยหนึ่งคุณไม่สามารถรู้ได้ว่าสิ่งใดที่น่าจะเกิดขึ้นมากกว่าที่คุณจะได้รับประสิทธิภาพสูงสุดจากการค้นหาวัตถุif(obj[keyval])และregexถ้ามันเหมาะสม

http://jsperf.com/if-statements-test-techsin/12

ฉันจะอัปเดตหากมีอะไรใหม่เกิดขึ้น

หากคุณกำลังเปรียบเทียบกับสตริงและมีรูปแบบให้พิจารณาใช้นิพจน์ทั่วไป

มิฉะนั้นฉันสงสัยว่าพยายามย่อให้สั้นลงจะทำให้รหัสของคุณงงงวย พิจารณาการพันลายเส้นเพื่อทำให้สวย

if (test.type == 'itema' ||
    test.type == 'itemb' ||
    test.type == 'itemc' ||
    test.type == 'itemd') {
    do something.
}

var possibilities = {
  "itema": 1,
  "itemb": 1,
  "itemc": 1,
…};
if (test.type in possibilities) { … }

การใช้ออบเจ็กต์เป็นอาเรย์แบบเชื่อมโยงเป็นสิ่งที่พบเห็นได้ทั่วไป แต่เนื่องจากจาวาสคริปต์ไม่มีชุดภาษาดั้งเดิมคุณจึงสามารถใช้ออบเจ็กต์เป็นชุดราคาถูกได้เช่นกัน

if( /^item[a-d]$/.test(test.type) ) { /* do something */ }

หรือหากรายการไม่เหมือนกันให้ทำดังนี้

if( /^(itema|itemb|itemc|itemd)$/.test(test.type) ) { /* do something */ }

คำตอบที่ยอดเยี่ยม แต่คุณสามารถทำให้โค้ดอ่านง่ายขึ้นโดยการห่อหนึ่งในฟังก์ชัน

สิ่งนี้ซับซ้อนหากคำสั่งเมื่อคุณ (หรือคนอื่น) อ่านโค้ดในเวลาหนึ่งปีคุณจะสแกนเพื่อค้นหาส่วนเพื่อทำความเข้าใจกับสิ่งที่เกิดขึ้น คำสั่งที่มีตรรกะทางธุรกิจระดับนี้จะทำให้คุณสะดุดในสองสามวินาทีในขณะที่คุณทำงานสิ่งที่คุณกำลังทดสอบ ในกรณีที่รหัสเช่นนี้จะช่วยให้คุณสแกนต่อไป

if(CheckIfBusinessRuleIsTrue())
{
    //Do Something
}

function CheckIfBusinessRuleIsTrue() 
{
    return (the best solution from previous posts here);
}

ตั้งชื่อฟังก์ชั่นของคุณอย่างชัดเจนเพื่อให้ชัดเจนในสิ่งที่คุณกำลังทดสอบและรหัสของคุณจะง่ายต่อการสแกนและทำความเข้าใจ

คุณสามารถใส่คำตอบทั้งหมดลงในชุด Javascriptจากนั้นเพียงโทรหา.contains()ชุด

คุณยังต้องประกาศเนื้อหาทั้งหมด แต่การโทรแบบอินไลน์จะสั้นลง

สิ่งที่ต้องการ:

var itemSet = new Set(["itema","itemb","itemc","itemd"]);
if( itemSet.contains( test.type ){}

หนึ่งในวิธีที่ฉันโปรดปรานในการทำสิ่งนี้ให้สำเร็จคือใช้ห้องสมุดเช่น underscore.js ...

var isItem = _.some(['itema','itemb','itemc','itemd'], function(item) {
    return test.type === item;
});

if(isItem) {
    // One of them was true
}

http://underscorejs.org/#some

อีกวิธีหนึ่งหรืออีกวิธีที่ยอดเยี่ยมที่ฉันพบคือ ...

if ('a' in oc(['a','b','c'])) { //dosomething }

function oc(a)
{
  var o = {};
  for(var i=0;i<a.length;i++)  o[a[i]]='';
  return o;
}

แน่นอนว่าคุณสามารถเห็นสิ่งนี้ดำเนินการในขั้นตอนเดียวและทำให้พวกเขาปฏิบัติตามตรรกะได้ง่าย

http://snook.ca/archives/javascript/testing_for_a_v

ใช้ตัวดำเนินการเช่น ~ && || ((), ()) ~~ ใช้ได้ก็ต่อเมื่อรหัสของคุณแตกหักในภายหลัง คุณจะไม่รู้ว่าจะเริ่มจากตรงไหน ดังนั้นการอ่านมีค่ามาก

ถ้าคุณต้องทำให้มันสั้นลง

('a' in oc(['a','b','c'])) && statement;
('a' in oc(['a','b','c'])) && (statements,statements);
('a' in oc(['a','b','c']))?statement:elseStatement;
('a' in oc(['a','b','c']))?(statements,statements):(elseStatements,elseStatements);

และถ้าคุณต้องการที่จะทำผกผัน

('a' in oc(['a','b','c'])) || statement;

เพียงแค่ใช้switchคำสั่งแทนifคำสั่ง:

switch (test.type) {

  case "itema":case "itemb":case "itemc":case "itemd":
    // do your process
  case "other cases":...:
    // do other processes
  default:
    // do processes when test.type does not meet your predictions.
}

Switch ยังทำงานได้เร็วกว่าการเปรียบเทียบเงื่อนไขจำนวนมากภายใน if

สำหรับรายการสตริงที่ยาวมาก ๆ ความคิดนี้จะช่วยตัวละครสองสามตัว (ไม่ได้บอกว่าฉันแนะนำในชีวิตจริง แต่ควรใช้งานได้)

เลือกตัวละครที่คุณรู้ว่าจะไม่เกิดขึ้นใน test.type ของคุณใช้มันเป็นตัวคั่นติดมันทั้งหมดลงในสายยาวหนึ่งอันแล้วค้นหาว่า:

if ("/itema/itemb/itemc/itemd/".indexOf("/"+test.type+"/")>=0) {
  // doSomething
}

หากสายอักขระของคุณมีข้อ จำกัด เพิ่มเติมคุณสามารถละเว้นตัวคั่นได้ ...

if ("itemaitembitemcitemd".indexOf(test.type)>=0) {
  // doSomething
}

... แต่คุณต้องระวังข้อผิดพลาดที่เป็นบวกในกรณีนั้น (เช่น "embite" จะจับคู่ในเวอร์ชันนั้น)

เพื่อความสามารถในการอ่านสร้างฟังก์ชั่นสำหรับการทดสอบ (ใช่ฟังก์ชั่นหนึ่งบรรทัด):

function isTypeDefined(test) {
    return test.type == 'itema' ||
           test.type == 'itemb' ||
           test.type == 'itemc' ||
           test.type == 'itemd';
}

จากนั้นเรียกมันว่า:

…
    if (isTypeDefined(test)) {
…
}
...

ฉันคิดว่ามี 2 วัตถุประสงค์เมื่อเขียนเงื่อนไขแบบนี้

1. ความกะทัดรัด
2. การอ่าน

เช่น # 1 บางครั้งอาจเร็วที่สุด แต่ฉันจะใช้ # 2 เพื่อการบำรุงรักษาง่ายในภายหลัง ขึ้นอยู่กับสถานการณ์ฉันมักจะเลือกคำตอบของวอลเตอร์

เพื่อเริ่มต้นฉันมีฟังก์ชั่นที่ใช้งานได้ทั่วโลกซึ่งเป็นส่วนหนึ่งของห้องสมุดที่มีอยู่ของฉัน

function isDefined(obj){
  return (typeof(obj) != 'undefined');
}

และเมื่อฉันต้องการรันเงื่อนไข if คล้ายกับของคุณฉันจะสร้างวัตถุที่มีรายการค่าที่ถูกต้อง:

var validOptions = {
  "itema":1,
  "itemb":1,
  "itemc":1,
  "itemd":1
};
if(isDefined(validOptions[test.type])){
  //do something...
}

มันไม่เร็วเท่ากับคำสั่ง switch / case และ verbose มากกว่าตัวอย่างอื่น ๆ เล็กน้อย แต่ฉันมักจะนำวัตถุกลับมาใช้ที่อื่นในรหัสซึ่งค่อนข้างมีประโยชน์

Piggybacking กับหนึ่งในตัวอย่าง jsperf ที่สร้างขึ้นด้านบนฉันเพิ่มการทดสอบนี้และการเปลี่ยนแปลงเพื่อเปรียบเทียบความเร็ว http://jsperf.com/if-statements-test-techsin/6สิ่งที่น่าสนใจที่สุดที่ฉันสังเกตคือชุดทดสอบใน Firefox นั้นเร็วกว่า Chrome มาก

สิ่งนี้สามารถแก้ไขได้ด้วยการวนรอบอย่างง่าย:

test = {};
test.type = 'itema';

for(var i=['itema','itemb','itemc']; i[0]==test.type && [
    (function() {
        // do something
        console.log('matched!');
    })()
]; i.shift());

เราใช้ส่วนแรกของ for for เพื่อเริ่มต้นอาร์กิวเมนต์ที่คุณต้องการจับคู่ส่วนที่สองเพื่อหยุดการวนรอบ for จากการทำงานและส่วนที่สามเพื่อทำให้การวนซ้ำสิ้นสุดลงในที่สุด