วิธีเขียนนิพจน์ ternary operator (aka if) โดยไม่ต้องทำซ้ำ

ตัวอย่างเช่นสิ่งนี้:

var value = someArray.indexOf(3) !== -1 ? someArray.indexOf(3) : 0

มีวิธีเขียนที่ดีกว่านี้ไหม อีกครั้งฉันไม่ได้ต้องการคำตอบสำหรับคำถามที่แน่นอนข้างต้นเป็นเพียงตัวอย่างของเวลาที่คุณอาจมีตัวถูกดำเนินการซ้ำ ๆ ในนิพจน์ตัวดำเนินการที่เกี่ยวข้อง ...

โดยส่วนตัวแล้วฉันพบว่าวิธีที่ดีที่สุดในการทำสิ่งนี้ยังคงเป็นifคำพูดเก่าที่ดี:

var value = someArray.indexOf(3);
if (value === -1) {
  value = 0;
}

รหัสควรอ่านได้ดังนั้นการกระชับไม่ควรหมายถึงการลดต้นทุนไม่ว่าจะด้วยต้นทุนใดก็ตามเพราะคุณควรโพสต์ใหม่ไปที่https://codegolf.stackexchange.com/ดังนั้นฉันขอแนะนำให้ใช้ตัวแปรท้องถิ่นตัวที่สองที่ตั้งชื่อindexเพื่อเพิ่มความเข้าใจในการอ่านให้มากที่สุด ( ด้วยต้นทุนรันไทม์ที่น้อยที่สุดฉันทราบ):

var index = someArray.indexOf( 3 );
var value = index == -1 ? 0 : index;

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

1: ตัวแปรชั่วคราวในไฟล์ varคำสั่ง

คุณสามารถใช้varความสามารถของคำสั่งเพื่อกำหนด (และกำหนด) ตัวแปรชั่วคราวตัวที่สองindexเมื่อคั่นด้วยลูกน้ำ:

var index = someArray.indexOf(3), value = index !== -1 ? index: 0;

2: ฟังก์ชันที่ไม่ระบุตัวตนที่ดำเนินการเอง

อีกทางเลือกหนึ่งคือฟังก์ชันที่ไม่ระบุตัวตนที่ดำเนินการเอง:

// Traditional syntax:
var value = function( x ) { return x !== -1 ? x : 0 }( someArray.indexOf(3) );

// ES6 syntax:
var value = ( x => x !== -1 ? x : 0 )( someArray.indexOf(3) );

3: ตัวดำเนินการจุลภาค

นอกจากนี้ยังมี "ตัวดำเนินการลูกน้ำ" ที่น่าอับอายซึ่ง JavaScript รองรับซึ่งมีอยู่ใน C และ C ++ ด้วย

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comma_Operator

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

คุณสามารถใช้เพื่อแนะนำผลข้างเคียงในกรณีนี้โดยกำหนดใหม่เป็นvalue:

var value = ( value = someArray.indexOf(3), value !== -1 ? value : 0 );

สิ่งนี้ใช้งานได้เนื่องจากvar valueถูกตีความก่อน (เนื่องจากเป็นคำสั่ง) จากนั้นจึงเป็นการกำหนดทางซ้ายสุดด้านในสุดvalueและทางขวามือของตัวดำเนินการลูกน้ำจากนั้นตัวดำเนินการตามกฎหมายทั้งหมด - JavaScript ที่ถูกกฎหมาย

4: กำหนดใหม่ในนิพจน์ย่อย

ผู้แสดงความคิดเห็น @IllusiveBrian ชี้ให้เห็นว่าการใช้ตัวดำเนินการลูกน้ำ (ในตัวอย่างก่อนหน้านี้) ไม่จำเป็นหากใช้การกำหนดให้valueเป็นนิพจน์ย่อยในวงเล็บ:

var value = ( ( value = someArray.indexOf(3) ) !== -1 ? value : 0 );

โปรดทราบว่าการใช้เชิงลบในนิพจน์เชิงตรรกะอาจทำให้มนุษย์ปฏิบัติตามได้ยากขึ้นดังนั้นตัวอย่างทั้งหมดข้างต้นสามารถทำให้อ่านง่ายขึ้นโดยเปลี่ยนidx !== -1 ? x : yเป็นidx == -1 ? y : x:

var value = ( ( value = someArray.indexOf(3) ) == -1 ? 0 : value );

สำหรับตัวเลข

คุณสามารถใช้Math.max()ฟังก์ชัน

var value = Math.max( someArray.indexOf('y'), 0 );

มันจะรักษาขอบเขตของผลลัพธ์ตั้งแต่0จนถึงผลลัพธ์แรกมากกว่า0ถ้าเป็นเช่นนั้น และถ้าผลลัพธ์จากindexOfคือ-1มันจะส่งกลับ 0 เมื่อมากกว่า-1เป็นมากกว่า

สำหรับบูลีนและค่าบูลีน - y

สำหรับ JS ไม่มีกฎทั่วไปของ AFAIK เป็นพิเศษเพราะมันเป็นเท็จแค่ไหนค่าได้รับการประเมิน

แต่ถ้าสิ่งที่สามารถช่วยคุณได้เกือบตลอดเวลาคือหรือตัวดำเนินการ ( ||):

// Instead of
var variable = this_one === true ? this_one : or_this_one;
// you can use
var variable = this_one || or_this_one;

คุณจะต้องระมัดระวังเป็นอย่างมากกับเรื่องนี้เพราะในตัวอย่างแรกของคุณindexOfสามารถกลับมา0และถ้าคุณประเมิน0 || -1ว่ามันจะกลับมา-1เพราะ0เป็นfalsyค่า

ไม่จริงแค่ใช้ตัวแปรอื่น

ตัวอย่างของคุณแสดงถึงสิ่งต่างๆเช่นนี้

var x = predicate(f()) ? f() : default;

คุณกำลังทดสอบค่าที่คำนวณแล้วกำหนดค่านั้นให้กับตัวแปรหากผ่านเพรดิเคตบางส่วน วิธีหลีกเลี่ยงการคำนวณค่าที่คำนวณซ้ำนั้นชัดเจน: ใช้ตัวแปรเพื่อเก็บผลลัพธ์

var computed = f();
var x = predicate(computed) ? computed : default;

ฉันเข้าใจในสิ่งที่คุณหมายถึงดูเหมือนว่ามันน่าจะมีวิธีทำที่ดูสะอาดกว่านี้หน่อย แต่ฉันคิดว่านั่นเป็นวิธีที่ดีที่สุดในการทำสิ่งนี้ หากคุณทำรูปแบบนี้ซ้ำมากในโค้ดของคุณด้วยเหตุผลบางประการคุณอาจเขียนฟังก์ชันตัวช่วยเล็กน้อย:

var setif = (value, predicate, default) => predicate(value) ? value : default;
var x = setif(someArray.indexOf(3), x => x !== -1, 0)

แก้ไข: นี่คือข้อเสนอสำหรับNullary-coalescingใน JavaScript!

ใช้ ||

const result = a ? a : 'fallback value';

เทียบเท่ากับ

const result = a || 'fallback value';

ถ้าหล่อaเพื่อBooleanผลตอบแทนfalse, resultจะได้รับมอบหมายมิฉะนั้นค่าของ'fallback value'a

จะตระหนักถึงกรณีขอบa === 0ซึ่งจะปลดเปลื้องfalseและresultจะ (ถูก) 'fallback value'ใช้เวลา ใช้กลอุบายเช่นนี้โดยยอมรับความเสี่ยงของคุณเอง

ปล. ภาษาเช่น Swift มีตัวดำเนินการรวมศูนย์ ( ??) ซึ่งทำหน้าที่คล้ายกัน ตัวอย่างเช่นใน Swift คุณจะเขียนresult = a ?? "fallback value"ซึ่งค่อนข้างใกล้เคียงกับ JavaScriptconst result = a || 'fallback value';

ใช้การปรับโครงสร้างตัวแปรแยก :

var index = someArray.indexOf(3);
var value = index !== -1 ? index : 0

มันจะดียิ่งขึ้นกับแทนconst varคุณสามารถทำการสกัดเพิ่มเติมได้:

const index = someArray.indexOf(3);
const condition = index !== -1;
const value = condition ? index : 0;

ในทางปฏิบัติใช้ชื่อที่มีความหมายมากกว่าindex, และconditionvalue

const threesIndex = someArray.indexOf(3);
const threeFound = threesIndex !== -1;
const threesIndexOrZero = threeFound ? threesIndex : 0;

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

Array.prototype.coalesce = function() {
    for (var i = 0; i < this.length; i++) {
        if (this[i] != false && this[i] != null) return this[i];
    }
}

[null, false, 0, 5, 'test'].coalesce(); // returns 5

สิ่งนี้สามารถสรุปได้มากขึ้นในกรณีของคุณโดยการเพิ่มพารามิเตอร์ให้กับฟังก์ชัน:

Array.prototype.coalesce = function(valid) {
    if (typeof valid !== 'function') {
        valid = function(a) {
            return a != false && a != null;
        }
    }

    for (var i = 0; i < this.length; i++) {
        if (valid(this[i])) return this[i];
    }
}

[null, false, 0, 5, 'test'].coalesce(); // still returns 5
[null, false, 0, 5, 'test'].coalesce(function(a){return a !== -1}); // returns null
[null, false, 0, 5, 'test'].coalesce(function(a){return a != null}); //returns false

โดยส่วนตัวแล้วฉันชอบสองสายพันธุ์:

1. บริสุทธิ์ถ้าเช่นที่ @slebetman แนะนำ

2. ฟังก์ชันแยกซึ่งแทนที่ค่าที่ไม่ถูกต้องด้วยค่าเริ่มต้นเช่นในตัวอย่างนี้:

function maskNegative(v, def) {
  return v >= 0 ? v : def;
}

Array.prototype.indexOfOrDefault = function(v, def) {
  return maskNegative(this.indexOf(v), def);
}

var someArray = [1, 2];
console.log(someArray.indexOfOrDefault(2, 0)); // index is 1
console.log(someArray.indexOfOrDefault(3, 0)); // default 0 returned
console.log(someArray.indexOfOrDefault(3, 123)); // default 123 returned

ฉันชอบคำตอบของ @ slebetman ความคิดเห็นที่อยู่ข้างใต้แสดงความกังวลเกี่ยวกับตัวแปรที่อยู่ใน "สถานะกลาง" หากนี่เป็นปัญหาใหญ่สำหรับคุณฉันขอแนะนำให้ห่อหุ้มไว้ในฟังก์ชัน:

function get_value(arr) {
   var value = arr.indexOf(3);
   if (value === -1) {
     value = 0;
   }
   return value;
}

จากนั้นโทร

var value = get_value( someArray );

คุณสามารถทำฟังก์ชันทั่วไปได้มากขึ้นหากคุณใช้งานในที่อื่น ๆ แต่อย่าใช้วิศวกรมากเกินไปหากเป็นกรณีที่เฉพาะเจาะจงมาก

แต่พูดตามตรงฉันจะทำในฐานะ @slebetman เว้นแต่ฉันจะต้องใช้ซ้ำจากหลาย ๆ ที่

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

var value = someArray.indexOf(3) !== -1 ? someArray.indexOf(3) : 0;

สามารถ (และควรได้รับการเรียกใช้ฟังก์ชัน) ให้สั้นลงดังนี้:

var value = someArray.indexOf(3);
value = value !== -1 ? value : 0;

หากคุณกำลังมองหาวิธีแก้ปัญหาทั่วไปที่ป้องกันการทำซ้ำของตัวแปรใน ternary เช่น:

var value = conditionalTest(foo) ? foo : bar;

ที่fooปรากฏเพียงครั้งเดียว การทิ้งโซลูชันของแบบฟอร์ม:

var cad = foo;
var value = conditionalTest(foo) ? cad : bar;

ตามเทคนิคที่ถูกต้อง แต่พลาดจุดนั้นคุณก็โชคไม่ดี มีตัวดำเนินการฟังก์ชันและวิธีการที่มีไวยากรณ์สั้น ๆ ที่คุณต้องการ แต่โครงสร้างดังกล่าวตามความหมายไม่ใช่ตัวดำเนินการที่เกี่ยวข้อง

ตัวอย่าง:

javascript ใช้||เพื่อส่งคืน RHS เมื่อ LHS คือfalsey:

var value = foo || bar; // equivalent to !foo ? bar : foo

ใช้ฟังก์ชันตัวช่วย:

function translateValue(value, match, translated) {
   return value === match ? translated : value;
}

ตอนนี้โค้ดของคุณสามารถอ่านได้มากและไม่มีการทำซ้ำ

var value = translateValue(someArray.indexOf(3), -1, 0);

ลำดับชั้นของความกังวลในการเข้ารหัสคือ:

1. ถูกต้อง (รวมถึงข้อกังวลด้านประสิทธิภาพที่แท้จริงหรือ SLA)
2. ชัดเจน
3. กระชับ
4. เร็ว

คำตอบทั้งหมดในหน้านี้ดูเหมือนจะถูกต้อง แต่ฉันคิดว่าเวอร์ชันของฉันมีความชัดเจนสูงสุดซึ่งสำคัญกว่าความกระชับ หากคุณไม่นับฟังก์ชันตัวช่วยซึ่งสามารถนำกลับมาใช้ใหม่ได้ - ฟังก์ชันนี้จะรัดกุมที่สุดเช่นกัน คำแนะนำที่ค่อนข้างคล้ายกันในการใช้ฟังก์ชันตัวช่วยน่าเสียดายที่ใช้แลมบ์ดาซึ่งสำหรับฉันเพียงแค่ปิดบังสิ่งที่มันทำ ฟังก์ชั่นที่ง่ายกว่าโดยมีจุดประสงค์เดียวที่ไม่ใช้แลมด้าเพียงแค่ค่านิยมสำหรับฉันดีกว่ามาก

ปล. ถ้าคุณชอบไวยากรณ์ ES6:

const translateValue = (value, match, translated) => value === match ? translated : value;
let value = translateValue(someArray.indexOf(3), -1, 0); // or const

ฉันคิดว่าตัว||ดำเนินการสามารถปรับให้เหมาะกับindexOf:

var value = ((someArray.indexOf(3) + 1) || 1) - 1;

ค่าที่ส่งคืนจะถูกเลื่อนขึ้นโดย 1 ทำให้ 0 จาก -1 ซึ่งเป็นเท็จดังนั้นจึงถูกแทนที่ด้วย 1 ที่สองจากนั้นจึงเลื่อนกลับ

อย่างไรก็ตามโปรดทราบว่าความสามารถในการอ่านดีกว่าการหลีกเลี่ยงการทำซ้ำ

นี่เป็นวิธีแก้ปัญหาง่ายๆโดยใช้bitwise NOTและค่าเริ่มต้น-1ซึ่งส่งผลให้เป็นศูนย์ในภายหลัง

index = ~(~array.indexOf(3) || -1);

มันทำงานโดยทั่วไปโดยใช้บิตสองเท่า NOT ซึ่งจะส่งคืนค่าเดิมหรือค่าเริ่มต้นซึ่งหลังจากใช้ bitwise แล้วจะไม่ส่งกลับศูนย์

มาดูตารางความจริงกัน:

 indexOf    ~indexOf   boolean    default     value      result         comment
---------  ---------  ---------  ---------  ---------  ---------  ------------------
      -1          0     falsy          -1         -1          0   take default value
       0         -1    truthy                     -1          0
       1         -2    truthy                     -2          1
       2         -3    truthy                     -3          2

คุณสามารถใช้การมอบหมายซ้ำ:

• เริ่มต้นตัวแปรเป็นค่าเดียว
• ใช้การทำให้เป็นอนุกรมของตัว&&ดำเนินการสำหรับการกำหนดใหม่เนื่องจากถ้าเงื่อนไขแรกเป็นเท็จนิพจน์ที่สองจะไม่ได้รับการประเมิน

เช่น

var value = someArray.indexOf(3);
value == -1 && (value=0);

var someArray = [4,3,2,1];

var value = someArray.indexOf(1);
value == -1 && (value=0);
console.log('Found:',value);

var value = someArray.indexOf(5);
value == -1 && (value=0);
console.log('Not Found:',value);

ได้รับโค้ดตัวอย่างที่คำถามที่มันไม่ชัดเจนว่ามันจะได้รับการพิจารณาว่า3เป็นหรือไม่ได้ตั้งค่าที่ดัชนีของ0 การส่งคืนจากจะมีค่าในกรณีนี้เพื่อจุดประสงค์ในการยกเว้นการจับคู่ที่สันนิษฐานไว้ซึ่งอาจเป็นการจับคู่someArray-1.indexOf()

หาก3ไม่รวมอยู่ในอาร์เรย์-1จะถูกส่งกลับ เราสามารถเพิ่ม1ถึงผลของการ.indexOf()ที่จะประเมินผลเป็นfalseผลเป็น-1ที่ตามมาด้วยผู้ประกอบการและ|| OR 0เมื่อvalueมีการอ้างอิงลบที่จะได้รับดัชนีขององค์ประกอบของอาร์เรย์หรือ1-1

ซึ่งนำกลับไปเพียงแค่ใช้.indexOf()และตรวจสอบ-1ในifสภาพ หรือกำหนดvalueเป็นundefinedหลีกเลี่ยงความสับสนที่เป็นไปได้ผลจริงของสภาพการประเมินที่เกี่ยวข้องกับการอ้างอิงเดิม

var someArray = [1,2,3];
var value = someArray.indexOf(3) + 1 || 1;
console.log(value -= 1);

var someArray = [1,2,3];
var value = someArray.indexOf(4) + 1 || 1;
// how do we know that `4` is not at index `0`?
console.log(value -= 1);

var someArray = [1,2,3];
var value = someArray.indexOf(4) + 1 || void 0;
// we know for certain that `4` is not found in `someArray`
console.log(value, value = value || 0);

ternary ก็เหมือนกับ if-else ถ้าคุณไม่ต้องการส่วนอื่นทำไมไม่ใช้ if แทน ..

if ((value = someArray.indexOf(3)) < 0) value = 0;

สำหรับกรณีนี้คุณสามารถใช้การลัดวงจรกับตัว||ดำเนินการทางตรรกะ ในฐานะที่0เป็นที่ยอมรับว่า falsy คุณสามารถเพิ่ม1การจัดทำดัชนีของคุณจึงถ้าindex+1เป็นแล้วคุณจะได้รับทางด้านขวามือของตรรกะหรือเป็นผลของคุณมิฉะนั้นคุณจะได้รับของคุณ0 index+1เนื่องจากผลลัพธ์ที่คุณต้องการถูกหักล้างด้วย1คุณจึงสามารถลบออก1เพื่อให้ได้ดัชนีของคุณ:

const someArray = [1, 2, 3, 4];
const v = ((someArray.indexOf(3)+1) || 1)-1;
console.log(v);