คำอธิบายการกำหนดตัวแปร JavaScript หรือ (||)

รับตัวอย่าง JavaScript นี้ ...

var a;
var b = null;
var c = undefined;
var d = 4;
var e = 'five';

var f = a || b || c || d || e;

alert(f); // 4

ใครช่วยอธิบายหน่อยได้ไหมว่าเทคนิคนี้เรียกว่าอะไร (เดาที่ดีที่สุดของฉันอยู่ในชื่อของคำถามนี้!) แล้วมันทำงานยังไงกันแน่?

ความเข้าใจของฉันคือตัวแปรfจะถูกกำหนดค่าที่ใกล้ที่สุด (จากซ้ายไปขวา) ของตัวแปรแรกที่มีค่าที่ไม่เป็นโมฆะหรือไม่ได้กำหนด แต่ฉันไม่สามารถหาวัสดุอ้างอิงเกี่ยวกับเทคนิคนี้ได้มากและมี เห็นมันใช้มาก

นอกจากนี้เทคนิคนี้ใช้เฉพาะกับ JavaScript หรือไม่ ฉันรู้ว่าการทำสิ่งที่คล้ายกันใน PHP จะส่งผลให้fมีค่าบูลีนที่แท้จริงมากกว่าค่าของdตัวเอง

ดูการประเมินการลัดวงจรสำหรับคำอธิบาย มันเป็นวิธีการทั่วไปในการใช้ตัวดำเนินการเหล่านี้ มันไม่ซ้ำกับ JavaScript

นี้ทำเพื่อกำหนดค่าเริ่มต้นในกรณีนี้ค่าของyถ้าxตัวแปรfalsy

ตัวดำเนินการบูลีนใน JavaScript สามารถส่งคืนตัวถูกดำเนินการและไม่ได้ผลบูลีนเช่นเดียวกับในภาษาอื่น ๆ

ตัวดำเนินการ Logical OR ( ||) ส่งคืนค่าของตัวถูกดำเนินการตัวที่สองถ้าตัวแรกเป็นค่าเท็จมิฉะนั้นค่าของตัวถูกดำเนินการแรกจะถูกส่งกลับ

ตัวอย่างเช่น:

"foo" || "bar"; // returns "foo"
false || "bar"; // returns "bar"

Falsyค่าเป็นผู้ที่บีบบังคับไปfalseเมื่อนำมาใช้ในบริบทแบบบูลและพวกเขาจะ0, null, undefined, สตริงว่างและแน่นอนNaNfalse

Javacript ใช้การประเมินผลการลัดวงจรสำหรับผู้ประกอบการเชิงตรรกะและ|| อย่างไรก็ตามมันแตกต่างจากภาษาอื่น ๆ โดยที่มันจะส่งคืนผลลัพธ์ของค่าสุดท้ายที่หยุดการดำเนินการแทนค่าหรือค่า&&truefalse

ค่าต่อไปนี้ถือว่าเป็นเท็จใน JavaScript

• เท็จ
• โมฆะ
• "" (สตริงว่าง)
• 0
• น่าน
• ไม่ได้กำหนด

การเพิกเฉยต่อกฎสำคัญของโอเปอเรเตอร์และทำให้สิ่งต่าง ๆ เรียบง่ายตัวอย่างต่อไปนี้แสดงค่าที่หยุดการประเมินและได้รับผลลัพธ์

false || null || "" || 0 || NaN || "Hello" || undefined // "Hello"

ค่า 5 อันดับแรกเกินNaNจริงดังนั้นค่าทั้งหมดจะถูกประเมินจากซ้ายไปขวาจนกระทั่งตรงตามค่าจริงแรก"Hello"ซึ่งทำให้การแสดงออกทั้งหมดเป็นจริงดังนั้นสิ่งใดที่เกินจะไม่ถูกประเมินและ"Hello"ได้รับผลตอบแทนจากการแสดงออก . ในทำนองเดียวกันในกรณีนี้:

1 && [] && {} && true && "World" && null && 2010 // null

5 ค่าแรกนั้นเป็นความจริงทั้งหมดและได้รับการประเมินจนกว่าจะตรงตามค่า falsy แรก ( null) ซึ่งทำให้นิพจน์เป็นเท็จดังนั้น2010จะไม่ถูกประเมินอีกต่อไปและnullได้รับผลตอบแทนจากการแสดงออก

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

var a = false;
var b = a || "Hello";

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

var messages = 0;
var newMessagesText = "You have " + messages + " messages.";
var noNewMessagesText = "Sorry, you have no new messages.";
alert((messages && newMessagesText) || noNewMessagesText);

ภายในการแจ้งเตือนเราตรวจสอบว่าmessagesเป็น falsy และถ้าใช่แล้วประเมินและผลตอบแทนอย่างอื่นในการประเมินและผลตอบแทนnoNewMessagesText newMessagesTextเนื่องจากเป็น falsy ในตัวอย่างนี้เราหยุดที่ noNewMessagesText "Sorry, you have no new messages."และการแจ้งเตือน

ไม่ได้พิมพ์ตัวแปร Javascript ดังนั้น f สามารถกำหนดค่าจำนวนเต็มแม้ว่าจะถูกกำหนดผ่านตัวดำเนินการบูลีน

ฉถูกกำหนดค่าที่ใกล้ที่สุดที่เป็นไม่ได้เทียบเท่ากับการเท็จ ดังนั้น 0, false, null, undefined, ถูกส่งผ่านทั้งหมด:

alert(null || undefined || false || '' || 0 || 4 || 'bar'); // alerts '4'

ไม่มีเวทย์มนตร์ใด ๆ นิพจน์บูลีนที่ชอบa || b || c || dประเมินอย่างเกียจคร้าน Interpeter ค้นหาค่าของaมันไม่ได้กำหนดดังนั้นจึงเป็นเท็จดังนั้นจึงดำเนินการต่อจากนั้นจะเห็นว่าbเป็นโมฆะซึ่งยังคงให้ผลลัพธ์ที่เป็นเท็จดังนั้นจึงย้ายไปแล้วก็เห็นc- เรื่องเดียวกัน ในที่สุดมันก็เห็นdและพูดว่า 'ฮะมันไม่ใช่โมฆะดังนั้นฉันจึงได้ผลลัพธ์' และมันกำหนดให้ตัวแปรสุดท้าย

เคล็ดลับนี้จะทำงานในภาษาแบบไดนามิกทั้งหมดที่ทำการประเมินผลแบบลัดวงจรของนิพจน์บูลีนที่ขี้เกียจ ในภาษาแบบคงที่มันจะไม่รวบรวม (ข้อผิดพลาดประเภท) ในภาษาที่มีความกระตือรือร้นในการประเมินนิพจน์บูลีนมันจะคืนค่าตรรกะ (เช่นจริงในกรณีนี้)

คำถามนี้ได้รับคำตอบที่ดีหลายประการแล้ว

โดยสรุปเทคนิคนี้ใช้ประโยชน์จากคุณสมบัติของวิธีการรวบรวมภาษา นั่นคือจาวาสคริปต์ "การลัดวงจร" การประเมินผลตัวดำเนินการบูลีนและจะส่งคืนค่าที่เกี่ยวข้องกับค่าตัวแปรที่ไม่ใช่เท็จตัวแรกหรือตัวแปรสุดท้ายที่มี ดูคำอธิบายของ Anurag เกี่ยวกับค่าเหล่านั้นที่จะประเมินเป็นเท็จ

การใช้เทคนิคนี้ไม่ใช่วิธีปฏิบัติที่ดีด้วยเหตุผลหลายประการ อย่างไรก็ตาม

1. ความสามารถในการอ่านรหัส: นี่คือการใช้ตัวดำเนินการบูลีนและหากพฤติกรรมของวิธีการคอมไพล์นี้ไม่เป็นที่เข้าใจแล้วผลที่คาดหวังจะเป็นค่าบูลีน
2. ความเสถียร: นี่คือการใช้คุณสมบัติของวิธีการรวบรวมภาษาที่ไม่สอดคล้องกันในหลายภาษาและเนื่องจากสิ่งนี้เป็นสิ่งที่อาจเป็นเป้าหมายสำหรับการเปลี่ยนแปลงในอนาคต

3. คุณสมบัติที่เป็นเอกสาร: มีทางเลือกที่มีอยู่ที่ตรงกับความต้องการนี้และสอดคล้องกันในหลายภาษา นี่จะเป็นผู้ประกอบการที่สาม:

   () ค่า 1: ค่า 2

การใช้ตัวดำเนินการที่ประกอบไปด้วยต้องการพิมพ์อีกเล็กน้อย แต่ก็แยกความแตกต่างระหว่างนิพจน์บูลีนที่ถูกประเมินและค่าที่ได้รับมอบหมาย นอกจากนี้มันสามารถถูกผูกมัดดังนั้นประเภทของการมอบหมายเริ่มต้นที่ดำเนินการด้านบนอาจถูกสร้างขึ้นใหม่

var a;
var b = null;
var c = undefined;
var d = 4;
var e = 'five';

var f =  ( a ) ? a : 
                ( b ) ? b :
                       ( c ) ? c :
                              ( d ) ? d :
                                      e;

alert(f); // 4

ส่งคืนค่าที่แท้จริงก่อน

หากทั้งหมดเป็นเท็จคืนค่าเท็จล่าสุด

ตัวอย่าง:-

  null || undefined || false || 0 || 'apple'  // Return apple

มันตั้งค่าตัวแปรใหม่ ( z) ให้เป็นค่าxถ้าเป็น "ความจริง" (ไม่ใช่ศูนย์วัตถุที่ถูกต้อง / อาร์เรย์ / ฟังก์ชั่น / สิ่งที่มันเป็น) หรือyอย่างอื่น เป็นวิธีที่ใช้กันโดยทั่วไปในการให้ค่าเริ่มต้นในกรณีที่xไม่มี

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

function doSomething(data, callback) {
    callback = callback || function() {};
    // do stuff with data
    callback(); // callback will always exist
}

หมายความว่าหากxตั้งค่าไว้ค่าzจะเป็นxอย่างอื่นหากyตั้งไว้ค่าจะถูกตั้งเป็นzค่าของ

มันเหมือนกับ

if(x)
  z = x;
else
  z = y;

เป็นไปได้เนื่องจากตัวดำเนินการเชิงตรรกะใน JavaScript ไม่ส่งคืนค่าบูลีน แต่ค่าขององค์ประกอบสุดท้ายที่จำเป็นในการดำเนินการให้เสร็จสมบูรณ์ (ในประโยค OR จะเป็นค่าที่ไม่ใช่ค่าแรกในประโยค AND และจะเป็นค่าสุดท้าย ) หากการดำเนินการล้มเหลวfalseจะถูกส่งคืน

มันเรียกว่าผู้ประกอบการลัดวงจร

การประเมินการลัดวงจรกล่าวว่าอาร์กิวเมนต์ที่สองจะถูกดำเนินการหรือประเมินผลก็ต่อเมื่ออาร์กิวเมนต์แรกไม่พอเพียงเพื่อกำหนดค่าของนิพจน์ เมื่ออาร์กิวเมนต์แรกของฟังก์ชัน OR (||) ประเมินค่าเป็นจริงค่าโดยรวมต้องเป็นจริง

นอกจากนี้ยังสามารถใช้เพื่อตั้งค่าเริ่มต้นสำหรับอาร์กิวเมนต์ของฟังก์ชันได้

function theSameOldFoo(name){ 
  name = name || 'Bar' ;
  console.log("My best friend's name is " + name);
}
theSameOldFoo();  // My best friend's name is Bar
theSameOldFoo('Bhaskar');  // My best friend's name is Bhaskar`

มันจะประเมินค่า X และถ้า X ไม่เป็นโมฆะสตริงว่างหรือ 0 (ตรรกะเท็จ) จากนั้นมันจะกำหนดให้กับ z ถ้า X เป็นโมฆะสตริงว่างหรือ 0 (ตรรกะเท็จ) จากนั้นมันจะกำหนด y เป็น z

var x = '';
var y = 'bob';
var z = x || y;
alert(z);

จะส่งออก 'บ๊อบ';

ตามโพสต์บล็อกของ Bill Higgins ' ; จาวาสคริปต์ตรรกะหรือการกำหนดสำนวน (ก.พ. 2550) พฤติกรรมนี้เป็นจริงเมื่อวันที่ v1.2 (อย่างน้อย)

นอกจากนี้เขายังแนะนำการใช้งานอื่นให้กับมัน (ที่ยกมา): "การทำให้ความแตกต่างของเบราว์เซอร์เป็นมาตรฐานมีน้ำหนักเบา "

// determine upon which element a Javascript event (e) occurred
var target = /*w3c*/ e.target || /*IE*/ e.srcElement;