ใน JavaScript ทำไมisNaN(" ")ประเมินfalseแต่isNaN(" x")ประเมินtrue?

ฉันประสิทธิภาพการดำเนินงานเชิงตัวเลขในช่องป้อนข้อความและผมตรวจสอบหากสนามnull, หรือ"" NaNเมื่อมีคนพิมพ์ช่องว่างจำนวนหนึ่งลงในฟิลด์การตรวจสอบของฉันล้มเหลวทั้งสามครั้งและฉันสับสนว่าทำไมมันถึงผ่านการisNaNตรวจสอบ

JavaScript ตีความสตริงว่างเป็น 0 ซึ่งจะล้มเหลวในการทดสอบ isNAN คุณสามารถใช้ parseInt บนสตริงก่อนซึ่งจะไม่แปลงสตริงว่างเป็น 0 ผลลัพธ์ก็ควรล้มเหลวคือ IS

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

document.write(isNaN("")) // false
document.write(isNaN(" "))  // false
document.write(isNaN(0))  // false
document.write(isNaN(null)) // false
document.write(isNaN(false))  // false
document.write("" == false)  // true
document.write("" == 0)  // true
document.write(" " == 0)  // true
document.write(" " == false)  // true
document.write(0 == false) // true
document.write(" " == "") // false

ดังนั้นนี่หมายความว่า

" " == 0 == false

และ

"" == 0 == false

แต่

"" != " "

มีความสุข :)

เพื่อให้เข้าใจได้ดีขึ้นโปรดเปิดEcma-Script ข้อมูลจำเพาะ pdfในหน้า 43 "ToNumber นำไปใช้กับประเภทสตริง"

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

isNaN('Infinity'); // false

ลองใช้:

alert(isNaN(parseInt("   ")));

หรือ

alert(isNaN(parseFloat("    ")));

จากMDNสาเหตุของปัญหาที่คุณเผชิญ

เมื่ออาร์กิวเมนต์ของฟังก์ชัน isNaN ไม่ใช่ชนิด Number ค่าจะถูกบังคับเป็นค่าแรกให้กับ Number ค่าผลลัพธ์จะถูกทดสอบเพื่อพิจารณาว่าเป็น NaN หรือไม่

คุณอาจต้องการตรวจสอบคำตอบที่ครอบคลุมต่อไปนี้ซึ่งครอบคลุมการเปรียบเทียบ NaN เพื่อความเท่าเทียมเช่นกัน

จะทดสอบได้อย่างไรว่าตัวแปร JavaScript เป็น NaN

ฉันคิดว่าเป็นเพราะการพิมพ์ของ Javascript: ' 'ถูกแปลงเป็นศูนย์ในขณะที่'x'ไม่ใช่:

alert(' ' * 1); // 0
alert('x' * 1); // NaN

หากคุณต้องการที่จะใช้ฟังก์ชั่น isNumber ได้อย่างถูกต้องนี่คือวิธีหนึ่งในการทำจากJavascript: The Good Partsโดย Douglas Crockford [หน้า 105]

var isNumber = function isNumber(value) {
   return typeof value === 'number' && 
   isFinite(value);
}

คำตอบที่ไม่ถูกต้องทั้งหมด

คำตอบที่ได้รับการยอมรับและยอมรับอย่างสูงของ Antonio Haley ที่นี่ทำให้เกิดข้อสันนิษฐานที่ผิด ๆ ว่ากระบวนการนี้ผ่านparseIntฟังก์ชั่นของ JavaScript :

คุณสามารถใช้ parseInt บนสตริง ... ผลลัพธ์ควรล้มเหลวคือ isNAN

เราสามารถพิสูจน์ข้อความนี้ได้อย่างง่ายดายด้วยสตริง"123abc":

parseInt("123abc")    // 123     (a number...
isNaN("123abc")       // true     ...which is not a number)

ด้วยสิ่งนี้เราจะเห็นได้ว่าparseIntฟังก์ชั่นของ JavaScript กลับมา"123abc"เป็นตัวเลข123แต่isNaNฟังก์ชั่นของมันบอกเราว่า"123abc" ไม่ใช่ตัวเลข

คำตอบที่ถูกต้อง

ECMAScript-262 กำหนดวิธีการisNaNตรวจสอบการทำงานในส่วน 18.2.3

18.2.3 isNaN(จำนวน)

isNaNฟังก์ชั่นเป็น%isNaN%วัตถุที่แท้จริง เมื่อisNaNฟังก์ชันถูกเรียกด้วยหมายเลขอาร์กิวเมนต์หนึ่งตัวจะดำเนินการตามขั้นตอนต่อไปนี้:

1. อนุญาตnumไหม ToNumber(number).
2. หากnumมีผลตอบแทนNaNtrue
3. falseมิฉะนั้นกลับ

ToNumberฟังก์ชั่นการอ้างอิงก็ยังถูกกำหนดไว้ในECMAScript-262 ส่วน 7.1.3 ในที่นี้เราได้รับแจ้งว่า JavaScript จัดการกับสตริงที่ส่งผ่านไปยังฟังก์ชันนี้ได้อย่างไร

ตัวอย่างแรกที่ให้ไว้ในคำถามคือสตริงที่ไม่มีอะไรนอกจากตัวอักษรเว้นวรรค ส่วนนี้ระบุว่า:

ที่ว่างเปล่าหรือมีเพียงพื้นที่สีขาวจะถูกแปลงเป็นStringNumericLiteral+0

" "สตริงตัวอย่างจึงถูกแปลง+0ซึ่งเป็นจำนวน

ส่วนเดียวกันยังระบุ:

หากไวยากรณ์ไม่สามารถตีความStringการขยายตัวของStringNumericLiteralแล้วผลมาจากการมีToNumberNaN

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

ฉันไม่แน่ใจว่าทำไมแต่เพื่อแก้ไขปัญหาคุณสามารถตัดช่องว่างก่อนที่จะตรวจสอบ คุณอาจต้องการทำเช่นนั้น

ฟังก์ชั่นisNaN("")การข่มขู่ประเภทสตริงเพื่อหมายเลข

ECMAScript 3-5 กำหนดค่าส่งคืนต่อไปนี้สำหรับตัวดำเนินการ typeof:

• ไม่ได้กำหนด
• วัตถุ (null, วัตถุ, อาร์เรย์)
• บูล
• จำนวน
• เชือก
• ฟังก์ชัน

ดีกว่าที่จะห่อการทดสอบของเราในร่างกายฟังก์ชั่น:

function isNumber (s) {
    return typeof s == 'number'? true
           : typeof s == 'string'? (s.trim() === ''? false : !isNaN(s))
           : (typeof s).match(/object|function/)? false
           : !isNaN(s)
}

ฟังก์ชั่นนี้ไม่ได้ intented ตัวแปรทดสอบประเภทแทนที่จะทดสอบค่าข่มขู่ ตัวอย่างเช่นบูลีนและสตริงมีการรวมกับตัวเลขดังนั้นบางทีคุณอาจต้องการเรียกใช้ฟังก์ชันนี้เป็นisNumberCoerced()

หากไม่จำเป็นต้องทดสอบชนิดอื่น ๆ นอกเหนือจากสตริงและหมายเลขข้อมูลโค้ดต่อไปนี้อาจถูกใช้เป็นส่วนหนึ่งของเงื่อนไขบางประการ:

if (!isNaN(s) && s.toString().trim()!='') // 's' can be boolean, number or string
    alert("s is a number")

ฉันขอแนะนำให้คุณใช้ฟังก์ชั่นต่อไปนี้หากคุณต้องการตรวจสอบอย่างถูกต้องว่าเป็นจำนวนเต็มหรือไม่:

function isInteger(s)
{
   return Math.ceil(s) == Math.floor(s);
}

นั่นisNaN(" ")เป็นเท็จเป็นส่วนหนึ่งของพฤติกรรมที่สับสนของisNaNฟังก์ชั่นทั่วโลกเนื่องจากการบีบบังคับของตัวเลขที่ไม่ใช่ตัวเลขชนิด

จากMDN :

เนื่องจากisNaNข้อกำหนดคุณลักษณะของฟังก์ชันในเวอร์ชันแรกสุดพฤติกรรมของอาร์กิวเมนต์ที่ไม่ใช่ตัวเลขจึงทำให้เกิดความสับสน เมื่ออาร์กิวเมนต์ของisNaNฟังก์ชั่นไม่ใช่ประเภท Number ค่านั้นจะถูกรวมเข้ากับ Number เป็นอันดับแรก ค่าผลลัพธ์จะถูกทดสอบเพื่อพิจารณาว่าเป็นNaNหรือไม่ ดังนั้นสำหรับผู้ที่ไม่ใช่ตัวเลขที่เมื่อถูกบังคับให้พิมพ์ตัวเลขจะส่งผลให้มีค่าตัวเลขที่ไม่ใช่ NaN ที่ถูกต้อง (โดยเฉพาะอย่างยิ่งสตริงว่างและบูลีนแบบดั้งเดิมซึ่งเมื่อถูกบังคับให้ค่าตัวเลขเป็นศูนย์หรืออย่างใดอย่างหนึ่ง) ตัวอย่างเช่นสตริงว่างคือ "ไม่ใช่ตัวเลข" อย่างแน่นอน

โปรดทราบว่าด้วย ECMAScript 6 ขณะนี้ยังมีNumber.isNaNวิธีการซึ่งตาม MDN:

เมื่อเทียบกับisNaN()ฟังก์ชั่นทั่วโลกNumber.isNaN()ไม่ประสบปัญหาในการแปลงพารามิเตอร์เป็นจำนวนมาก วิธีนี้ก็คือตอนนี้ปลอดภัยในการส่งผ่านค่าที่ปกติจะเปลี่ยนไปแต่ไม่จริงค่าเช่นเดียวกับNaN NaNนอกจากนี้ยังหมายความว่าเฉพาะค่าของหมายเลขประเภทที่NaNกลับมาtrueด้วย

น่าเสียดาย :

แม้ ECMAScript 6 Number.isNaNวิธีมีปัญหาของตัวเองตามที่ระบุไว้ในบล็อกโพสต์ - แก้ไขปัญหาที่น่าเกลียด JavaScript และ ES6 น่าน

isNaNฟังก์ชั่นคาดว่าจำนวนเป็นอาร์กิวเมนต์ของมันเพื่อให้การขัดแย้งของประเภทอื่น ๆ (ในกรณีของคุณสตริง) จะถูกแปลงเป็นจำนวนก่อนตรรกะฟังก์ชั่นที่เกิดขึ้นจริงจะดำเนินการ (โปรดทราบว่าNaNยังมีค่าประเภท Number!)

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

การแปลงมาตรฐานสำหรับการStringที่จะสามารถเรียกอย่างชัดเจนด้วยNumber Number()ดังนั้นเราจะเห็นได้ว่า:

• Number(" ") ประเมินให้ 0
• Number(" x") ประเมินให้ NaN

รับนี้ผลของisNaNฟังก์ชั่นมีเหตุผลอย่างสมบูรณ์!

คำถามจริงคือทำไมการแปลงสตริงเป็นตัวเลขมาตรฐานทำงานเหมือนที่มันเป็น การแปลงสตริงเป็นตัวเลขมีจุดประสงค์เพื่อแปลงสตริงตัวเลขเช่น "123" หรือ "17.5e4" เป็นตัวเลขเทียบเท่า การแปลงแรกข้ามช่องว่างเริ่มต้น (ดังนั้น "123" จึงถูกต้อง) จากนั้นพยายามแยกส่วนที่เหลือเป็นตัวเลข หากไม่สามารถแยกวิเคราะห์เป็นตัวเลข ("x" ไม่ได้) ผลลัพธ์จะเป็น NaN แต่มีกฎพิเศษที่ชัดเจนว่าสตริงที่ว่างเปล่าหรือช่องว่างเท่านั้นที่ถูกแปลงเป็น 0 ดังนั้นสิ่งนี้จะอธิบายการแปลง

การอ้างอิง: http://www.ecma-international.org/ecma-262/5.1/#sec-9.3.1

ฉันเขียนฟังก์ชันเล็ก ๆ น้อย ๆ นี้เพื่อช่วยแก้ปัญหานี้

function isNumber(val) {
     return (val != undefined && val != null && val.toString().length > 0 && val.toString().match(/[^0-9\.\-]/g) == null);
};

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

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

if ( isNaN(string) || isNaN(parseInt(string)) ) console.log('Not a number!');

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

NaN ! == "ไม่ใช่ตัวเลข"

NaN เป็นค่าของ Number Type

นี่คือคำจำกัดความของ isNaN () ใน ECMAScript

1. Let num be ToNumber(number).
2. ReturnIfAbrupt(num).
3. If num is NaN, return true.
4. Otherwise, return false.

ลองแปลงค่าเป็น Number

Number(" ") // 0
Number("x") // NaN
Number(null) // 0

ถ้าคุณต้องการตรวจสอบว่าเป็นค่าNaNคุณควรลองแปลงเป็นค่าตัวเลขก่อน

ฟังก์ชั่นนี้ดูเหมือนจะทำงานในการทดสอบของฉัน

function isNumber(s) {
    if (s === "" || s === null) {
        return false;
    } else {
        var number = parseInt(s);
        if (number == 'NaN') {
            return false;
        } else {
            return true;
        }
    }
}

เกี่ยวกับอะไร

function isNumberRegex(value) {        
    var pattern = /^[-+]?\d*\.?\d*$/i;
    var match = value.match(pattern);
    return value.length > 0 && match != null;
}

JavaScriptในตัวisNaNฟังก์ชั่นเป็น - ตามที่ควรจะคาดหวังโดยเริ่มต้น - เป็น "แบบไดนามิกประเภทผู้ประกอบการ" ดังนั้นค่าทั้งหมดที่ (ในระหว่างกระบวนการ DTC) อาจให้ผลลัพธ์จริงอย่างง่าย | false เช่น"", " ", " 000", ไม่สามารถเป็น NaN

หมายความว่าอาร์กิวเมนต์ที่ให้มาจะได้รับการแปลงเป็นครั้งแรกใน:

function isNaNDemo(arg){
   var x = new Number(arg).valueOf();
   return x != x;
}

คำอธิบาย:

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

ในบรรทัดที่สองเรากำลังรับค่าที่ได้จากขั้นตอนก่อนหน้าและข้อดีของความจริงที่ว่าNaNไม่เท่ากับสิ่งใดในเอกภพแม้แต่กับตัวเองเช่นNaN == NaN >> falseในที่สุดเพื่อเปรียบเทียบ (สำหรับความไม่เท่าเทียมกัน) กับตัวเอง .

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

isNaNstatic ()

อย่างไรก็ตามสำหรับผู้ประกอบการประเภทคงที่ - หากจำเป็นและเมื่อจำเป็น - เราสามารถเขียนฟังก์ชั่นที่ง่ายกว่าเช่น:

function isNaNstatic(x){   
   return x != x;
}

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

isNaNStatic(" x"); // will return false เพราะมันยังคงเป็นสตริง

อย่างไรก็ตาม: เป็นความประสงค์เช่นisNaNStatic(1/"x"); // will of course return true.isNaNStatic(NaN); >> true

แต่ไปในทางตรงกันข้ามisNaNที่isNaNStatic("NaN"); >> falseเพราะมัน (อาร์กิวเมนต์) เป็นสตริงธรรมดา

ps: รุ่นคงที่ของ isNaN จะมีประโยชน์มากในสถานการณ์การเข้ารหัสที่ทันสมัย และอาจเป็นหนึ่งในเหตุผลหลักที่ฉันใช้เวลาในการโพสต์ข้อความนี้

ความนับถือ.

isNAN(<argument>)เป็นฟังก์ชั่นที่จะบอกได้ว่าอาร์กิวเมนต์ที่กำหนดนั้นเป็นจำนวนที่ผิดกฎหมายหรือไม่ isNaNพิมพ์อาร์กิวเมนต์ลงในประเภท Number ถ้าคุณต้องการตรวจสอบว่าอาร์กิวเมนต์เป็นตัวเลขหรือไม่? กรุณาใช้$.isNumeric()ฟังก์ชั่นใน jQuery

นั่นคือ isNaN (foo) เทียบเท่ากับ isNaN (Number (foo)) ยอมรับสตริงที่มีตัวเลขทั้งหมดเป็นตัวเลขด้วยเหตุผลที่ชัดเจน สำหรับอดีต

isNaN(123) //false
isNaN(-1.23) //false
isNaN(5-2) //false
isNaN(0) //false
isNaN('123') //false
isNaN('Hello') //true
isNaN('2005/12/12') //true
isNaN('') //false
isNaN(true) //false
isNaN(undefined) //true
isNaN('NaN') //true
isNaN(NaN) //true
isNaN(0 / 0) //true

ฉันใช้สิ่งนี้

    function isNotANumeric(val) {
    	if(val.trim && val.trim() == "") {
         return true;
      } else {
      	 return isNaN(parseFloat(val * 1));
      }
    }
    
    alert(isNotANumeric("100"));  // false
    alert(isNotANumeric("1a"));   // true
    alert(isNotANumeric(""));     // true
    alert(isNotANumeric("   "));  // true

เมื่อตรวจสอบว่าค่าสตริงบางอย่างด้วยช่องว่างหรือ" "ถูกisNaNอาจจะพยายามที่จะดำเนินการตรวจสอบสตริงตัวอย่างเช่น:

// value = "123 " if (value.match(/\s/) || isNaN(value)) { // do something }