Làm thế nào để rút ngắn các tuyên bố điều kiện của tôi

Tôi có một tuyên bố điều kiện rất dài như sau:

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

Tôi đã tự hỏi nếu tôi có thể cấu trúc lại biểu thức / tuyên bố này thành một hình thức ngắn gọn hơn.

Bất kỳ ý tưởng về làm thế nào để đạt được điều này?

Đặt các giá trị của bạn vào một mảng và kiểm tra xem mục của bạn có nằm trong mảng không:

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

Nếu một trình duyệt bạn hỗ trợ không có Array#includesphương pháp, bạn có thể sử dụng polyfill này .

Giải thích ngắn về ~phím tắt dấu ngã:

Cập nhật: Vì chúng tôi hiện có includesphương pháp, không còn sử dụng ~hack nữa. Chỉ cần giữ điều này ở đây cho những người quan tâm đến việc biết nó hoạt động như thế nào và / hoặc đã gặp nó trong mã của người khác.

Thay vì kiểm tra nếu kết quả indexOflà >= 0, có một phím tắt nhỏ đẹp:

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

Đây là câu đố: http://jsfiddle.net/HYJvK/

Cái này hoạt động ra sao? Nếu một mục được tìm thấy trong mảng, indexOftrả về chỉ mục của nó. Nếu vật phẩm không được tìm thấy, nó sẽ trở lại -1. Mà không đi vào chi tiết quá nhiều, ~là một Bitwise NOT điều hành , mà sẽ trở lại 0chỉ cho -1.

Tôi thích sử dụng ~phím tắt, vì nó ngắn gọn hơn so với thực hiện so sánh về giá trị trả về. Tôi ước JavaScript có một in_arrayhàm trả về Boolean trực tiếp (tương tự PHP), nhưng đó chỉ là suy nghĩ mong muốn ( Cập nhật: hiện tại nó đã được gọi includes. Xem ở trên). Lưu ý rằng jQuery inArray, trong khi chia sẻ chữ ký phương thức của PHP, thực sự bắt chước indexOfchức năng gốc (rất hữu ích trong các trường hợp khác nhau, nếu chỉ mục là thứ bạn thực sự theo đuổi).

Lưu ý quan trọng: Sử dụng phím tắt dấu ngã dường như bị tranh cãi, vì một số người kịch liệt tin rằng mã không đủ rõ ràng và nên tránh bằng mọi giá (xem các bình luận về câu trả lời này). Nếu bạn chia sẻ tình cảm của họ, bạn nên bám sát vào .indexOf(...) >= 0giải pháp.

Một lời giải thích dài hơn:

Các số nguyên trong JavaScript được ký, có nghĩa là bit ngoài cùng bên trái được dành riêng làm bit dấu; một cờ để cho biết số đó là dương hay âm, với một số 1âm.

Dưới đây là một số số dương mẫu ở định dạng nhị phân 32 bit:

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

Bây giờ đây là những con số tương tự, nhưng tiêu cực:

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

Tại sao kết hợp kỳ lạ như vậy cho các số âm? Đơn giản. Số âm đơn giản là nghịch đảo của số dương + 1; thêm số âm vào số dương sẽ luôn luôn mang lại 0.

Để hiểu điều này, chúng ta hãy làm một số số học nhị phân đơn giản.

Đây là cách chúng tôi sẽ thêm -1vào +1:

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

Và đây là cách chúng tôi sẽ thêm -15vào +15:

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

Làm thế nào để chúng ta có được những kết quả đó? Bằng cách bổ sung thường xuyên, cách chúng tôi được dạy ở trường: bạn bắt đầu ở cột ngoài cùng bên phải và bạn cộng tất cả các hàng. Nếu tổng lớn hơn số có một chữ số lớn nhất (số thập phân là 9, nhưng ở dạng nhị phân 1), chúng tôi sẽ chuyển phần còn lại sang cột tiếp theo.

Bây giờ, như bạn sẽ nhận thấy, khi thêm một số âm vào số dương của nó, cột ngoài cùng bên phải không phải là tất cả 0sẽ luôn có hai 1s, khi được thêm vào với nhau sẽ dẫn đến 2. Biểu diễn nhị phân của hai bản thể 10, chúng tôi mang 1đến cột tiếp theo và đặt 0kết quả cho cột đầu tiên. Tất cả các cột khác ở bên trái chỉ có một hàng với a 1, do đó, cột 1được chuyển từ cột trước sẽ lại thêm vào 2, sau đó sẽ tiếp tục ... Quá trình này lặp lại cho đến khi chúng ta đến cột ngoài cùng bên trái, trong đó việc 1phải mang đi không có nơi nào để đi, vì vậy nó tràn ra và bị mất, và chúng ta còn lại với 0tất cả.

Hệ thống này được gọi là Bổ sung 2 . Bạn có thể đọc thêm về điều này ở đây:

Đại diện bổ sung cho 2 số nguyên đã ký .

Bây giờ khóa học sự cố trong phần bù của 2 đã kết thúc, bạn sẽ nhận thấy đó -1là số duy nhất có đại diện nhị phân là 1tất cả.

Sử dụng ~toán tử bitwise NOT, tất cả các bit trong một số đã cho được đảo ngược. Cách duy nhất để 0quay trở lại từ việc đảo ngược tất cả các bit là nếu chúng ta bắt đầu với 1tất cả.

Vì vậy, tất cả điều này là một cách nói dài dòng ~nsẽ chỉ trở lại 0nếu ncó -1.

Bạn có thể sử dụng câu lệnh switch với fall thru:

switch (test.type) {

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

Sử dụng Khoa học: bạn nên làm những gì idfah đã nói và điều này để có tốc độ nhanh nhất trong khi giữ mã ngắn:

~Phương pháp này nhanh hơn

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

http://jsperf.com/if-statements-test-techsin (Bộ trên cùng: Chrome, bộ dưới cùng: Firefox)

Phần kết luận :

Nếu khả năng là vài và bạn biết rằng những người nhất định có nhiều khả năng xảy ra hơn bạn nhận được hiệu suất tối đa if ||, switch fall throughvà if(obj[keyval]).

Nếu khả năng là rất nhiều , và bất kỳ ai trong số họ có thể là người xảy ra nhiều nhất, nói cách khác, bạn không thể biết rằng cái nào có khả năng xảy ra nhiều nhất là bạn có được hiệu suất cao nhất khi tra cứu đối tượng if(obj[keyval])và regexnếu điều đó phù hợp.

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

Tôi sẽ cập nhật nếu có cái gì đó mới.

Nếu bạn đang so sánh với các chuỗi và có một mẫu, hãy xem xét sử dụng các biểu thức thông thường.

Nếu không, tôi nghi ngờ việc cố gắng rút ngắn nó sẽ chỉ làm xáo trộn mã của bạn. Hãy xem xét chỉ đơn giản là gói các đường để làm cho nó đẹp.

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) { … }

Sử dụng một đối tượng làm mảng kết hợp là một điều khá phổ biến, nhưng vì JavaScript không có tập gốc, bạn cũng có thể sử dụng các đối tượng làm tập giá rẻ.

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

hoặc nếu các mặt hàng không đồng nhất, thì:

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

Câu trả lời tuyệt vời, nhưng bạn có thể làm cho mã dễ đọc hơn bằng cách gói một trong số chúng vào một hàm.

Điều này rất phức tạp nếu câu lệnh, khi bạn (hoặc ai đó) đọc mã trong một năm, bạn sẽ quét qua để tìm phần để hiểu điều gì đang xảy ra. Một tuyên bố với mức logic kinh doanh này sẽ khiến bạn vấp ngã trong vài giây trong khi bạn tìm ra những gì bạn đang thử nghiệm. Trường hợp mã như thế này, sẽ cho phép bạn tiếp tục quét.

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

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

Đặt tên cho chức năng của bạn một cách rõ ràng để ngay lập tức rõ ràng những gì bạn đang kiểm tra và mã của bạn sẽ dễ dàng hơn để quét và hiểu.

Bạn có thể đặt tất cả các câu trả lời vào Bộ Javascript và sau đó chỉ cần gọi.contains() trên bộ.

Bạn vẫn phải khai báo tất cả các nội dung, nhưng cuộc gọi nội tuyến sẽ ngắn hơn.

Cái gì đó như:

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

Một trong những cách yêu thích của tôi để thực hiện điều này là với một thư viện như 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

một cách khác hoặc một cách tuyệt vời khác mà tôi tìm thấy là ...

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;
}

tất nhiên như bạn có thể thấy điều này sẽ đưa mọi thứ đi một bước xa hơn và làm cho chúng dễ dàng theo logic.

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

sử dụng các toán tử như ~ && || ((), ()) ~ ~ chỉ ổn nếu mã của bạn bị hỏng sau này. Bạn sẽ không biết bắt đầu từ đâu. Vì vậy, khả năng đọc là LỚN.

nếu bạn phải bạn có thể làm cho nó ngắn hơn.

('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);

và nếu bạn muốn làm ngược lại

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

Chỉ cần sử dụng một switchtuyên bố thay vì iftuyên bố:

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 cũng hoạt động nhanh hơn so với việc so sánh nhiều điều kiện trong một if

Đối với các danh sách chuỗi dài, ý tưởng này sẽ lưu một vài ký tự (không nói rằng tôi muốn giới thiệu nó trong cuộc sống thực, nhưng nó sẽ hoạt động).

Chọn một ký tự mà bạn biết sẽ không xảy ra trong test.type của bạn, sử dụng nó làm dấu phân cách, gắn tất cả chúng vào một chuỗi dài và tìm kiếm:

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

Nếu chuỗi của bạn bị hạn chế hơn nữa, bạn thậm chí có thể bỏ qua các dấu phân cách ...

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

... nhưng bạn phải cẩn thận với những thông tin sai trong trường hợp đó (ví dụ: "embite" sẽ khớp với phiên bản đó)

Để dễ đọc, hãy tạo một hàm cho bài kiểm tra (có, một hàm một dòng):

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

sau đó gọi nó:

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

Tôi nghĩ có 2 mục tiêu khi viết loại này nếu có điều kiện.

1. ngắn gọn
2. khả năng đọc

Vì đôi khi số 1 có thể là nhanh nhất, nhưng tôi sẽ lấy số 2 để bảo trì dễ dàng sau này. Tùy thuộc vào kịch bản, tôi sẽ thường chọn cách thay đổi câu trả lời của Walter.

Để bắt đầu, tôi có một chức năng có sẵn trên toàn cầu như là một phần của thư viện hiện tại của tôi.

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

và sau đó khi tôi thực sự muốn chạy một điều kiện if tương tự như điều kiện của bạn, tôi sẽ tạo một đối tượng với một danh sách các giá trị hợp lệ:

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

Nó không nhanh như một câu lệnh switch / case và dài dòng hơn một số ví dụ khác nhưng tôi thường sử dụng lại đối tượng ở nơi khác trong mã có thể khá tiện dụng.

Cõng trên một trong các mẫu jsperf được thực hiện ở trên tôi đã thêm thử nghiệm này và một biến thể để so sánh tốc độ. http://jsperf.com/if-statements-test-techsin/6 Điều thú vị nhất tôi lưu ý là các combo thử nghiệm nhất định trong Firefox nhanh hơn nhiều so với Chrome.

Điều này có thể được giải quyết với một vòng lặp đơn giản:

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

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

Chúng tôi sử dụng phần đầu tiên của vòng lặp for để khởi tạo các đối số bạn muốn khớp, phần thứ hai để ngăn vòng lặp for chạy và phần thứ ba để khiến vòng lặp cuối cùng thoát ra.