เหตุใดจึงมีค่า "null" ใน JavaScript

ใน JavaScript มีสองค่าซึ่งโดยทั่วไปจะบอกว่า 'ฉันไม่อยู่ - และundefinednull

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

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

ทั้งคู่ยังประเมินfalseในบริบทบูลีน ข้อแตกต่างที่แท้จริงที่ฉันสามารถคิดเป็นที่หนึ่งประเมินเพื่อNaNการอื่น ๆ เพื่อ0ในบริบทที่เป็นตัวเลข

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

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

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

ฉันสามารถใช้ชีวิตแบบนั้นได้หากการใช้งาน JavaScript บังคับใช้พฤติกรรมนี้จริง - แต่undefinedเป็นค่าดั้งเดิมที่ถูกต้องอย่างสมบูรณ์ดังนั้นจึงสามารถกำหนดให้กับคุณสมบัติที่มีอยู่เพื่อทำลายสัญญานี้ได้อย่างง่ายดาย ดังนั้นหากคุณต้องการตรวจสอบว่ามีคุณสมบัติอยู่หรือไม่คุณต้องใช้ตัวinดำเนินการหรือhasOwnProperty()อย่างไรก็ตาม อีกครั้ง: การใช้ประโยชน์สำหรับค่าที่แยกต่างหากสำหรับundefinedและnullคืออะไร

ฉันใช้จริงundefinedเมื่อต้องการยกเลิกการตั้งค่าคุณสมบัติที่ไม่ได้ใช้งานอีกต่อไป แต่ไม่ต้องการdeleteใช้ ฉันควรใช้nullแทนหรือไม่?

คำถามไม่ได้เป็น "เหตุใดจึงมีค่า null ใน JS" - มีค่า null ของการจัดเรียงบางอย่างในภาษาส่วนใหญ่และโดยทั่วไปถือว่ามีประโยชน์มาก

คำถามคือ "เหตุใดจึงมีค่าที่ไม่ได้กำหนดใน JS" สถานที่สำคัญที่ใช้:

1. เมื่อคุณประกาศvar x;แต่ไม่มอบหมายให้xถือไม่ได้กำหนดไว้
2. เมื่อฟังก์ชันของคุณได้รับอาร์กิวเมนต์น้อยกว่าที่ประกาศ
3. เมื่อคุณเข้าถึงคุณสมบัติอ็อบเจ็กต์ที่ไม่มีอยู่จริง

nullแน่นอนจะใช้งานได้ดีสำหรับ (1) และ (2) * (3) ควรโยนข้อยกเว้นออกไปทันทีและความจริงที่ว่ามันไม่ได้แทนที่จะส่งคืนสิ่งแปลก ๆundefinedที่จะล้มเหลวในภายหลังกลับเป็นปัญหาใหญ่ในการแก้ไขจุดบกพร่อง

*: คุณสามารถโต้แย้งได้ว่า (2) ควรมีข้อยกเว้น แต่คุณจะต้องระบุกลไกที่ดีกว่าและชัดเจนกว่าสำหรับอาร์กิวเมนต์เริ่มต้น / ตัวแปร

อย่างไรก็ตาม JavaScript ไม่มีข้อยกเว้นในตอนแรกหรือวิธีใด ๆ ในการถามออบเจ็กต์ว่ามีสมาชิกภายใต้ชื่อที่กำหนดหรือไม่วิธีเดียวคือ (และบางครั้งก็ยังคงเป็น) ในการเข้าถึงสมาชิกและดูว่าคุณได้อะไร เนื่องจากnullมีจุดประสงค์อยู่แล้วและคุณอาจต้องการตั้งค่าสมาชิกเป็นค่านี้จำเป็นต้องมีค่านอกวงที่แตกต่างกัน ดังนั้นเราจึงมีundefinedปัญหาในขณะที่คุณชี้ให้เห็นและเป็น 'คุณลักษณะ' ของ JavaScript ที่ยอดเยี่ยมอีกอย่างหนึ่งที่เราจะไม่สามารถกำจัดได้

ฉันใช้ undefined เมื่อฉันต้องการยกเลิกการตั้งค่าของคุณสมบัติที่ไม่ได้ใช้งานอีกต่อไป แต่ฉันไม่ต้องการลบ ฉันควรใช้ null แทนหรือไม่?

ใช่. เก็บundefinedเป็นค่าพิเศษสำหรับการส่งสัญญาณเมื่อภาษาอื่นอาจทำให้เกิดข้อยกเว้นแทน

nullโดยทั่วไปจะดีกว่ายกเว้นในอินเทอร์เฟซ IE DOM บางตัวที่การตั้งค่าบางอย่างnullอาจทำให้คุณเกิดข้อผิดพลาดได้ บ่อยครั้งในกรณีนี้การตั้งค่าเป็นสตริงว่างมีแนวโน้มที่จะทำงาน

อธิบายได้ดีที่สุดที่นี่แต่โดยสรุป:

ไม่ได้กำหนดคือการขาดประเภทและค่าและค่าว่างคือการขาดค่า

นอกจากนี้หากคุณทำการเปรียบเทียบแบบธรรมดา '==' คุณพูดถูกมันก็ออกมาเหมือนกัน แต่ลอง === ซึ่งเปรียบเทียบทั้งประเภทและค่าแล้วคุณจะสังเกตเห็นความแตกต่าง

ฉันไม่คิดว่าไม่มีเหตุผลใด ๆ ที่จะมีทั้งสองอย่างnullและundefinedเพราะเหตุผลเดียวที่หลายคนแนะนำ (" undefinedหมายความว่าไม่มีตัวแปร / คุณสมบัติดังกล่าว") ไม่ถูกต้องอย่างน้อยก็ใน JavaScript undefinedไม่สามารถบอกคุณได้ว่ามีตัวแปร / คุณสมบัติอยู่หรือไม่

console.log(foo);               // "ReferenceError: foo is not defined"
                                // foo does not exist
var foo;
console.log(foo);               // "undefined", a different response
console.log(foo === undefined); // "true", but it does exist

var obj = {};
console.log(obj.hasOwnProperty("foo")); // "false", no such property
obj.foo = undefined;
console.log(obj.hasOwnProperty("foo")); // "true", it exists and has the value "undefined"
console.log(obj.foo === undefined);     // "true", but it does exist

obj.bar = "delete me";
obj.bar = undefined;
console.log(obj.hasOwnProperty("bar")); // "true", not actually deleted
delete obj.bar;
console.log(obj.hasOwnProperty("bar")); // "false", deleted

ที่คุณสามารถดูการตรวจสอบfoo === undefinedไม่ได้บอกคุณได้ว่าfooมีอยู่และการตั้งค่าไม่จริงลบobj.bar = undefinedbar

อาจเป็นความตั้งใจดั้งเดิมของผู้เขียน JavaScript ที่undefinedควรแสดงถึง "ไม่มีอยู่จริง" อย่างไรก็ตามการนำไปใช้งานไม่ได้เป็นอย่างนั้น

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

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

ฉันจะต้องยอมรับว่าการใช้งานนั้นแปลกเพราะหลายครั้งความแตกต่างจะเบลอ อย่างไรก็ตามฉันคิดว่าใน JavaScript ความแตกต่างเป็นสิ่งสำคัญ และความสามารถในการมอบหมายundefinedเป็นสิ่งสำคัญ

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

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

ในฐานะโปรแกรมเมอร์ Java ฉันเห็นความแตกต่างอย่างมากระหว่าง undefined และ null การเข้ารหัส JavaScript ไม่มากนักเนื่องจาก JavaScript ไม่ได้ถูกพิมพ์อย่างรุนแรงและความแตกต่างระหว่างไม่ได้กำหนดและ null จะเบลอโดยการแปลงอัตโนมัติที่มักเกิดขึ้นตามเวลาทำงาน BTW ฉันใช้ประโยชน์จากการแปลงเหล่านั้นบ่อยๆ ทำให้โค้ด JS ของฉันกะทัดรัดและอ่านง่ายขึ้น

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

null หมายความว่า "ไม่มีค่า" ถูกตั้งค่าไว้อย่างชัดเจน ในทางปฏิบัติคุณกำลังบอกฉันบางอย่างเกี่ยวกับคุณสมบัติบางทีอาจจะไม่ได้ใช้ในบริบทนี้หรือยังไม่ได้กำหนดมูลค่า

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

ลองดูตัวอย่างนี้:

<html>
<head>
    <script type="text/javascript">
        function ShowObjProperties(obj) {
            var property, propCollection = "";

            for(property in obj) {
                propCollection += (property + ": " + obj[property] + "\n");
            }

            alert(propCollection);
        }

        var obj = {
            userid: 3,
            name: 'me!',
            speak: function() { alert('Hi! My name is ' + this.name + ' and my ID is ' + this.userid + '.'); }
        }

        //Shows all properties
        ShowObjProperties(obj);

        //The Speak function is no longer in the list!
        delete obj.speak;
        alert(typeof obj.speak);
        ShowObjProperties(obj);

        //The UserID is still listed, it just has no value!
        obj.userid = null;
        ShowObjProperties(obj);
    </script>
</head>
<body>

</body>
</html>

ฉันคิดว่ามีการใช้งานจริงมากสำหรับ 2 ประเภทที่แตกต่างกันที่นี่

สิ่งที่ลงมาคือลักษณะไดนามิกของจาวาสคริปต์

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

เป็นคุณลักษณะทางภาษาที่สำคัญหากคุณรวมโปรแกรมของคุณไว้ในกระบวนทัศน์ของจาวาสคริปต์

// a key exists as a placeholder for something
if(obj[name] === null) 
// no key exists int eh hashtable that is in this object
if(obj[name] === undefined)

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

filter_func_pt = {
  date:function(d){ return Math.round(d.getTime()/1000);},
  user: null,
}

function transform(obj){
    var ret = {};
    for( var prop in obj){
       var f = filter_func_pt[prop];
       if(f)
          ret[prop] = f(obj);
       else if(filter_func_pt[prop] === null)
         continue;
       else
         ret[prop] == obj;
    }
  return ret;
}

var a = {
   date: new Date(),
   user: 'sam'
   votes: [23, 41, 55] 
};

var b = transform(a);

/* b = {
 *    date: 1298582417
 *    votes: [23, 41, 55]
 * }
 */

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

เป็นโมฆะที่สวยงาม

เช่นเดียวกับ Live Script ประเภทอื่น ๆ ทั้งหมด

อ้างอิง: ใน JavaScript มีค่าสองค่าซึ่งโดยพื้นฐานแล้วบอกว่า 'ฉันไม่มีอยู่จริง' - ไม่ได้กำหนดและเป็นโมฆะ

ทำไมถึงอยากพูดผิด ๆ ถูก ๆ !

"null"เป็น"วัตถุว่างเปล่า"เช่นเดียวกับ "0" เป็น"เลขที่ว่างเปล่า" 0 ไม่มีอะไรเลย - มีอยู่เป็น Type of a Number nullเป็นหลักสูตรที่ยังว่างเปล่า แต่ "มันคือ" และมันเป็นสิ่งที่กำหนดไว้อย่างดีของชนิดของวัตถุ

เป็นเรื่องปกติที่จะพูดถึงสิ่งเหล่านี้ในฐานะ "ประเภท" เมื่อมันไม่ใช่ จริงๆแล้วมันคือ "หมวดหมู่" แต่ตอนนี้จบแล้ว

ดังนั้นจะติดว่า "null" เป็น Type of Object ที่ไม่มี Kind และ "null" บอกว่า "ฉันมีอยู่มาก [!] แต่ฉันไม่มีเนื้อหาในแบบของฉัน"

ในขณะที่undefinedขาดทั้ง Type และ Kind โดยที่undefinedเป็นนิยาม Type ด้วย ประเภทที่ไม่ได้กำหนดจะกลายเป็นประเภทที่โดดเด่น ประเภทของคำถาม [ไม่ "ไม่มีอะไร" และคุณกำหนดคำถาม "ไม่มีอะไร" ได้อย่างไร?

อ้าง: ไม่ได้กำหนดหรือ null สามารถส่งคืนจากฟังก์ชันตัวสร้างเนื่องจากทั้งสองจะถูกแปลงเป็นวัตถุว่างเปล่า

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

อ้างถึง: ความแตกต่างที่แท้จริงเพียงอย่างเดียวที่ฉันคิดได้คือสิ่งหนึ่งประเมินเป็น NaN ส่วนอีกค่าเป็น 0 ในบริบทตัวเลข

นั่นทำให้จุดรวมของความแตกต่างหลักดังที่กล่าวไว้: undefinedเป็นโทเค็นธรรมดาและเนื่องจากมันถูกสร้างขึ้นจากวัสดุ 'พันธุกรรม' เดียวกันกับญาติห่าง ๆ : สตริงการดำเนินการ [+ ไม่ได้กำหนด] จะเปลี่ยนเป็น NaN แน่นอนว่าจะเป็นโมฆะในทำนองเดียวกันจะแปรเปลี่ยนเป็นชนิด 0 \ Number ที่ถูกต้องแทนและตรงข้ามกับไม่ได้กำหนดซึ่งจะแปรเปลี่ยนเป็นสตริง (! ซึ่งไม่ว่างเปล่า!) และนั่นคือสาเหตุที่ทำให้เกิดNaNแทน ที่ไหน: + undefined >> + "undefined" >> NaN. เนื่องจากบริบทตัวเลขคาดว่าจะมีค่าที่ชัดเจน

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

มาตัดต่อ ...

อ้างอิง: อีกครั้ง: การใช้งานจริงสำหรับค่าที่แยกจากกันสำหรับค่าที่ไม่ได้กำหนดและค่าว่างคืออะไร?

ฉันจะพยายามให้คุณเพียงสองตัวอย่างเชิงประจักษ์และหวังว่าจะพอเพียง

oElement.onclick >> null

// หมายถึง - คุณสมบัติมีอยู่; ค่าที่คาดไว้คือ Type: Objectและ oElement นั้นรองรับเหตุการณ์ "onclick"!

oElement.innerText >> ""

// หมายถึง - ทรัพย์สินมีอยู่; ค่าที่คาดไว้คือ Type: Stringซึ่งหมายความว่า oElement สนับสนุนคุณสมบัติ "innerText"

ในทั้งสองกรณี - หากคุณได้รับ "ไม่ได้กำหนด" หมายความว่าไม่มีคุณสมบัตินั้น ไม่ได้รับการสนับสนุนหรือมีการใช้งาน (ua vendor) ที่ไม่ถูกต้อง

อยู่กับความเย็นและมีความสุข

หลังจากอ่านการสนทนาที่น่าทึ่งเกี่ยวกับ undefined vs null การค้นหาเล็กน้อยใน Google ก็พาฉันไปที่ Mozilla Documentations https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/null มีการกล่าวถึง - null มักจะ ดึงข้อมูลในสถานที่ที่สามารถคาดหวังวัตถุได้ แต่ไม่มีวัตถุใดที่เกี่ยวข้อง

ไม่คล้ายกับ Null object pattern https://en.wikipedia.org/wiki/Null_object_pattern

ฉันเดาว่ามันสมเหตุสมผลแล้วที่จะมีประเภทข้อมูล Null

เอกสารยังกล่าวถึงเป็น typeof null // "object" (ไม่ใช่ "null" เนื่องจากเหตุผลเดิม)

ไม่แน่ใจว่าเหตุผลเดิมคืออะไร