การคืนค่าʻundefined` หรือ `null` จากฟังก์ชัน javascript จะดีกว่าไหม

ฉันมีฟังก์ชั่นที่ฉันเขียนซึ่งโดยทั่วไปมีลักษณะดังนี้:

function getNextCard(searchTerms) {
  // Setup Some Variables

  // Do a bunch of logic to pick the next card based on termed passed through what I'll call here as 'searchTerms' all of this logic is omitted because it's not important for my question.
  // ...

  // If we find a next card to give, than give it
  if (nextCardFound)
    return nextCardFound;

  // Otherwise - I'm returning undefined
  return undefined;
}

คำถาม: กลับ "null" ที่นี่จะดีกว่าไหม

ฉันสามารถผ่านอะไรก็ได้ที่ต้องการกลับมา - เห็นได้ชัดว่า ... ฉันไม่แน่ใจว่าอะไรคือสิ่งที่ดีที่สุดที่จะใช้

รหัสที่เรียกใช้ฟังก์ชันนี้รู้วิธีจัดการกับ undefined (จริงๆแล้วจะไม่เกิดขึ้นจริง ๆ เว้นแต่จะมีบางอย่างผิดพลาดอย่างน่ากลัว)

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

เอกสารประกอบ:

Mozilla Docsไม่ได้ตอบคำถามของฉัน ... google ไม่ได้: \

คำถาม SO นี้ - กว้างเกินไปสำหรับสิ่งที่ฉันพยายามหาที่นี่

ฉันจะเถียงว่าไม่มีวิธีที่ดีที่สุดและแม้แต่ฟังก์ชันมาตรฐานบางครั้งก็เลือกอย่างใดอย่างหนึ่ง

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

• [[ต้นแบบ]]

  วัตถุธรรมดามีสล็อตภายใน [[Prototype]] ซึ่งกำหนดว่าวัตถุอื่น ๆ จะสืบทอดมาจากวัตถุใด แน่นอนว่าต้องมีวิธีที่จะบอกว่าวัตถุนั้นไม่ได้รับมรดกจากสิ่งอื่นใด ในกรณีนี้ "ไม่มีวัตถุดังกล่าว" nullเป็นตัวแทนโดยใช้

• Object.getOwnPropertyDescriptor

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

• document.getElementById

  คาดว่าจะส่งคืนองค์ประกอบที่มีรหัสที่กำหนด อย่างไรก็ตามอาจไม่มีองค์ประกอบที่มีรหัสดังกล่าว ในกรณีนี้ "ไม่มีองค์ประกอบดังกล่าว" nullเป็นตัวแทนโดยใช้

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

โดยทั่วไปไม่ได้กำหนดหมายถึงสิ่งที่ยังไม่ได้กำหนดค่า (ยัง) Null หมายถึงสิ่งที่ไม่มีค่าแน่นอน ในกรณีนี้ฉันขอแนะนำให้คืนค่าว่าง โปรดทราบว่าฟังก์ชันที่ไม่มีค่าส่งคืนที่ระบุโดยปริยายจะส่งคืนไม่ได้กำหนด

จากข้อมูลจำเพาะ ECMAScript2015

4.3.10 ค่าที่ไม่ได้กำหนด

ค่าดั้งเดิมใช้เมื่อไม่ได้กำหนดค่าตัวแปร

4.3.12 ค่า null

ค่าดั้งเดิมที่แสดงถึงการไม่มีค่าวัตถุใด ๆ โดยเจตนา

http://www.ecma-international.org/ecma-262/6.0/#sec-terms-and-definitions-undefined-type

อ่านเพิ่มเติม:

เมื่อใดที่เป็นโมฆะหรือไม่ได้กำหนดถูกใช้ใน JavaScript

ฉันจะให้ความเห็นส่วนตัวของฉันในการเลือกระหว่างทั้งสอง

คำถามง่ายๆของฉันคือ: ค่าสามารถกำหนดอินพุต / สถานะ / บริบทให้กับบางสิ่งได้หรือไม่?

ถ้าคำตอบคือใช่แล้วใช้การใช้งานอื่นnull ๆ undefinedโดยทั่วไปแล้วฟังก์ชันใด ๆ ที่ส่งคืนวัตถุควรส่งคืนnullเมื่อไม่มีอ็อบเจ็กต์ที่ต้องการ เนื่องจากอาจมีอยู่เนื่องจากอินพุต / สถานะ / บริบทอื่น

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

undefinedโดยปริยายหมายถึงการไม่มีความหมายของค่านั้นในบริบทของแอปพลิเคชันของคุณ ตัวอย่างเช่นถ้าผมจัดการกับวัตถุที่มีให้ชุดของคุณสมบัติและฉันพยายามที่จะเข้าถึงสถานที่ให้บริการuser pikatchuควรตั้งค่าของคุณสมบัตินี้เป็นundefinedเพราะในบริบทของฉันมันไม่สมเหตุสมผลที่จะมีคุณสมบัติดังกล่าว

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

ลองพิจารณาตัวอย่างนี้

function getSomething() {
     // .. do something
     return undefined;
}

function doSomething() {
     // .. I'm not gonna return anything.
}

var a = getSomething();
var b = doSomething();

ผลตัวอย่างข้างต้นซึ่งเป็นa === b undefinedความแตกต่างคือคุณบันทึก 1 การดำเนินการคำสั่ง

ขึ้นอยู่กับว่าคุณต้องทำอะไรกับค่าที่ส่งคืน

typeof null ส่งคืนวัตถุ วัตถุนั้นมีค่าไม่ได้กำหนด

typeof undefined ส่งกลับไม่ได้กำหนด

นี่คือตัวอย่างที่undefinedสมเหตุสมผลมากกว่าnull:

ฉันใช้ฟังก์ชัน wrapper เพื่อJSON.parseแปลงข้อยกเว้นเป็นundefined:

// parses s as JSON if possible and returns undefined otherwise
// return undefined iff s is not a string or not parseable as JSON; undefined is not a valid JSON value https://stackoverflow.com/a/14946821/524504
function JSON_parse_or_undefined(s) {
    if ("string" !== typeof s) return undefined

    try {
        const p = JSON.parse(s)
        return p
    } catch (x){}

    return undefined
}

โปรดทราบว่าnullใช้ได้ใน JSON ในขณะที่undefinedไม่ใช่

คำตอบแรกถูกต้อง พวกเขามีความหมายที่แตกต่างกันในทางทฤษฎี อย่างไรก็ตามมันไม่ชัดเจนเสมอไปว่าจะเลือกอะไรดี

ฉันมักจะใช้ค่าว่างในการพัฒนาแม้ว่าฉันจะคิดว่าเป็นเรื่องที่เป็นส่วนตัว

ฉันใช้ส่วนใหญ่เพราะ:

1. ตัวแปรที่ไม่ได้กำหนดอาจถูกเขียนทับในเบราว์เซอร์เก่าดังนั้นการส่งคืนมันจึงซับซ้อนกว่าเล็กน้อย ปัญหาเดียวกันนี้บังคับให้คุณใช้typeof var === 'undefined'เมื่อได้รับผลลัพธ์ของฟังก์ชันลิงค์

2. ภาษาอื่น ๆ มักจะใช้ null กันอย่างแพร่หลายส่วนมากไม่มีการกำหนด (เช่น php) นั่นทำให้ฉันมีความสอดคล้องกันเมื่อสลับระหว่างภาษาอย่างรวดเร็ว

ฉันคิดว่ามันเป็นที่ถกเถียงกันมากว่าจะใช้อะไร ฉันชอบรหัสที่มีความหมายตามความหมายมากที่สุดดังนั้นฉันคิดว่าundefinedเหมาะสมในกรณีนี้

ฉันคิดว่าการnullมอบหมายงานมีความหมายว่า ซึ่งตรงข้ามกับundefinedความหมาย "สิ่งนี้ไม่มีเลย"

ตามที่คำตอบก่อนหน้านี้ชี้ให้เห็นว่าการส่งคืนundefinedมีปัญหาและขึ้นอยู่กับคุณว่าจะรบกวนคุณ มันจะไม่รบกวนฉัน

ฉันขอแย้งว่าในกรณีนี้nullควรส่งคืน

หากคุณพิจารณาคำถามจากมุมมองทางวิทยาศาสตร์คอมพิวเตอร์เชิงทฤษฎีจะใช้undefinedเพื่อระบุการไม่ยุติ / ไม่สามารถคำนวณได้ (เช่นตัวยึดตำแหน่งสำหรับจุดที่ไม่ได้กำหนดxของฟังก์ชันบางส่วน fซึ่งมักเขียนf(x) = ⊥ )

getNextCardอย่างไรก็ตามดูเหมือนว่าจะสามารถคำนวณการ์ดถัดไปได้ (ถ้ามี) และยังสามารถคำนวณได้หากไม่มีการ์ดถัดไป กล่าวอีกนัยหนึ่งฟังก์ชั่นจะรวมเนื่องจากจะสิ้นสุดสำหรับทุกอินพุต

ที่ถูกกล่าวว่าเป็นค่าพิเศษการส่งสัญญาณการเลิกจ้างโดยไม่ต้องผลที่มีความหมาย (คือ "มีบัตรไม่มีฉันสามารถกลับสำหรับการป้อนข้อมูลนี้") เป็นสิ่งจำเป็นและสำหรับฉันก็คือไม่ได้nullundefined

หมายเหตุ:

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

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

ในท้ายที่สุดความชอบส่วนตัวของฉันจะไม่กลับมาในundefinedที่ที่ฉันสามารถกลับมาได้nullและฉันก็ขอเถียงว่านี่เป็นรูปแบบการเข้ารหัสที่ดีกว่า (เพราะสิ่งอื่น ๆx !== nullนั้นสั้นกว่าtypeof x !== 'undefined')

ความคิดเห็นส่วนตัวของฉันตามประสบการณ์ของฉันคืออย่าใช้ undefined และเป็นโมฆะหากคุณไม่ต้องการที่จะทำให้รหัสของคุณผิดพลาด อย่างน้อยก็เลี่ยงเป็นการส่วนตัว มีฟังก์ชั่นมากมายใน Javascript ที่คืนค่าไม่ได้กำหนดและเราต้องใช้มัน แต่เมื่อคุณออกแบบโค้ดของคุณอย่าใช้มัน สิ่งสำคัญคือต้องคืนบางสิ่ง"false"อย่างน้อยที่สุดเสมอ หากคุณมีอาร์เรย์เช่นและคุณจับคู่มัน มันไม่ได้เป็นสิ่งที่ดีที่จะกลับหรือเพียงแค่[undefined, undefined.....] undefinedจะดีกว่าถ้าคุณเก็บประเภทของอาร์เรย์เดิมไว้ ตัวอย่าง:

 const mapper:Map <string[],boolean[]>  
['i', 'dont', 'use', 'null or undefined'] -> [false, true, false, true, false]
or ['', dont, '', '', use] 
or al the stuff above and then filter(v => v)
that will keep all undefined and null out

นั่นคือความคิด ฉันพยายามตลอดเวลาเพื่อหลีกเลี่ยงมัน เนื่องจากnullหรือundefinedสามารถทำให้รหัสของคุณผิดพลาดได้อย่างง่ายดาย