ในบทความนี้ เราจะดูรายละเอียดเกี่ยวกับตัวเลข ตัวดำเนินการทางคณิตศาสตร์ วิธีแปลงตัวเลขให้เป็นสตริง และในทางกลับกัน รวมถึงประเด็นสำคัญอื่นๆ อีกมากมาย

ฟังก์ชัน isFinite

ฟังก์ชัน isFinite ช่วยให้คุณตรวจสอบว่าอาร์กิวเมนต์เป็นจำนวนจำกัดหรือไม่

เพื่อเป็นการตอบสนอง ฟังก์ชันนี้จะคืนค่าเท็จหากอาร์กิวเมนต์เป็น Infinity, -Infinity, NaN หรือจะถูกแปลงเป็นค่าตัวเลขพิเศษค่าใดค่าหนึ่งเหล่านี้ มิฉะนั้นฟังก์ชันนี้จะคืนค่าเป็นจริง

มีจำนวนจำกัด(73); // จริง isFinite(-1/0); // false isFinite(อนันต์); // false isFinite(น่าน); // false isFinite("ข้อความ"); // เท็จ

นอกเหนือจากฟังก์ชัน isFinite ส่วนกลางแล้ว JavaScript ยังมีเมธอด Number.isFinite อีกด้วย ต่างจาก isFinite ตรงที่ไม่ได้บังคับให้แปลงอาร์กิวเมนต์เป็นตัวเลข

IsFinite("73"); // true Number.isFinite("73"); // เท็จ

ฟังก์ชัน isNaN

ฟังก์ชัน isNaN ได้รับการออกแบบมาเพื่อกำหนดว่าอาร์กิวเมนต์เป็นตัวเลขหรือสามารถแปลงเป็นตัวเลขได้ หากเป็นเช่นนั้น ฟังก์ชัน isNaN จะส่งคืนค่าเท็จ มิฉะนั้นจะคืนค่าเป็นจริง

คือน่าน(น่าน); //จริงคือNaN("25px"); //จริงเพราะว่า. 20px ไม่ใช่ตัวเลขคือNaN(25.5) //false isNaN("25.5"); //เท็จคือNaN(" "); //ผิดเพราะว่า. ช่องว่างหรือหลายช่องว่างถูกแปลงเป็น 0 isNaN(null); //ผิดเพราะว่า. null ถูกแปลงเป็น 0 isNaN(true); //ผิดเพราะว่า. true ถูกแปลงเป็น 1 isNaN(false); //ผิดเพราะว่า. เท็จจะถูกแปลงเป็น 0

หากจำเป็นต้องดำเนินการนี้โดยไม่มีการพิมพ์ ให้ใช้เมธอด Number.isNaN วิธีการนี้ถูกนำมาใช้ในภาษาที่เริ่มต้นด้วย ECMAScript 6

จะแปลงสตริงเป็นตัวเลขอย่างชัดเจนได้อย่างไร?

คุณสามารถแปลงสตริงเป็นตัวเลขได้อย่างชัดเจนโดยใช้วิธีการต่อไปนี้:

1. การใช้งาน ตัวดำเนินการเอกภาค +ซึ่งจะต้องวางไว้หน้าค่า

+"7.35"; // 7.35 +"ข้อความ"; // แนน

เมธอดนี้จะละเว้นช่องว่างที่จุดเริ่มต้นและจุดสิ้นสุดของบรรทัด รวมถึง \n (การป้อนบรรทัด)

+" 7.35 "; //7.35 +"7.35 \n "; //7.35

เมื่อใช้วิธีการนี้ คุณต้องใส่ใจกับความจริงที่ว่าสตริงว่างหรือสตริงที่ประกอบด้วยช่องว่างและ \n จะถูกแปลงเป็นตัวเลข 0 นอกจากนี้ยังแปลงชนิดข้อมูล null และค่าบูลีนเป็นตัวเลขด้วย .

โมฆะ; //0 +จริง; //1 +เท็จ; //0 +" "; //0

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

ParseInt("18px"); //18 parseInt("33.3%"); //33

ฟังก์ชันนี้สามารถทำงานกับระบบตัวเลขต่างๆ ได้ (ไบนารี ฐานแปด ทศนิยม ฐานสิบหก) ฐานของระบบตัวเลขระบุโดยใช้ 2 อาร์กิวเมนต์

ParseInt("18px", 10); //18 parseInt("33.3%", 10); //33 parseInt("101",2); //5 parseInt("B5",16); //181

นอกจากฟังก์ชัน parseInt แล้ว JavaScript ยังมีเมธอด Number.parseInt อีกด้วย วิธีนี้ไม่แตกต่างจากฟังก์ชัน parseInt และถูกนำมาใช้ใน JavaScript ด้วยข้อกำหนด ECMASCRIPT 2015 (6)

3. ฟังก์ชั่นแยกวิเคราะห์โฟลต ฟังก์ชัน parseFloat คล้ายกับ parseInt ยกเว้นว่าช่วยให้คุณสามารถแปลงอาร์กิวเมนต์เป็นจำนวนเศษส่วนได้

ParseFloat("33.3%"); //33.3

นอกจากนี้ ฟังก์ชัน parseFloat ต่างจาก parseInt ตรงที่ไม่มี 2 อาร์กิวเมนต์ ดังนั้นจึงพยายามถือว่าสตริงเป็นตัวเลขในระบบสัญลักษณ์ทศนิยมเสมอ

ParseFloat("3.14"); parseFloat("314e-2"); parseFloat("0.0314E+2");

นอกเหนือจากฟังก์ชัน parseFloat แล้ว JavaScript ยังมีเมธอด Number.parseFloat อีกด้วย วิธีนี้ไม่แตกต่างจากฟังก์ชัน parseFloat และถูกนำมาใช้ใน JavaScript ด้วยข้อกำหนด ECMASCRIPT 2015 (6)

การแปลงตัวเลขเป็นสตริง

คุณสามารถเปลี่ยนตัวเลขให้เป็นสตริงได้โดยใช้เมธอด toString

(12.8).toString(); //"12.8"

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

(255).toString(16); //"เอฟ"

วิธีตรวจสอบว่าตัวแปรเป็นตัวเลขหรือไม่

คุณสามารถกำหนดได้ว่าค่าของตัวแปรเป็นตัวเลขหรือไม่โดยใช้วิธีใดวิธีหนึ่งต่อไปนี้:

1. การใช้ฟังก์ชัน isNaN และ isFinite:

// myVar เป็นตัวแปร if (!isNaN(parseFloat(myVar)) && isFinite(parseFloat(myVar))) ( //myVar เป็นตัวเลขหรือสามารถร่ายลงไปได้);

เป็นฟังก์ชัน:

// ฟังก์ชั่น ฟังก์ชั่น isNumeric(value) ( ​​​​return !isNaN(parseFloat(value)) && isFinite(parseFloat(value)); ) // use var myVar = "12px"; console.log(isNumeric(myVar)); //จริง

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

2. การใช้ตัวดำเนินการ typeof และ isFinite ฟังก์ชัน isNaN:

// ฟังก์ชั่นตรวจสอบว่าค่าเป็นฟังก์ชันตัวเลขหรือไม่ isNumber(value) ( ​​​​return typeof value === "number" && isFinite(value) && !isNaN(value); }; // использование функции isNumber isNumber(18); //true // использование функций для проверки текстовых значений isNumber(parseFloat("")); //false isNumber(parseFloat("Infinity")); //false isNumber(parseFloat("12px")); //true !}

ฟังก์ชันนี้จะกำหนดว่าค่าที่ระบุเป็นประเภท Number หรือไม่และเป็นค่าพิเศษค่า Infinity, -Infinity และ NaN หรือไม่ หากเป็นเช่นนั้น ฟังก์ชันนี้จะคืนค่าเป็นจริง

3. การใช้เมธอด ECMAScript 6 Number.isInteger(value) วิธีการนี้ช่วยให้คุณกำหนดได้ว่าค่าที่ระบุเป็นจำนวนเต็มหรือไม่

Number.isInteger("20"); //ผิดเพราะว่า. เมธอดนี้ไม่ได้แปลงสตริงเป็นตัวเลข Number.isInteger(20) //จริงเพราะว่า. ค่านี้เป็นตัวเลข

เลขคู่และเลขคี่

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

// ฟังก์ชันสำหรับตรวจสอบตัวเลขสำหรับฟังก์ชันความเท่าเทียมกันของเลขคู่ isEven(n) ( return n % 2 == 0; ) // ฟังก์ชันสำหรับตรวจสอบตัวเลขของฟังก์ชันความเท่าเทียมกันของเลขคี่ isOdd(n) ( return Math.abs(n % 2) == 1; )

แต่ก่อนที่จะดำเนินการตรวจสอบดังกล่าวขอแนะนำให้ตรวจสอบให้แน่ใจว่าค่าที่ระบุเป็นตัวเลข:

ค่า = 20; if (Number.isInteger(ค่า)) ( if (isEven(value)) ( console.log("Number " + value.toString() + " -even"); ) )

จำนวนเฉพาะใน Javascript

ลองดูตัวอย่างที่เราจะแสดงจำนวนเฉพาะตั้งแต่ 2 ถึง 100 โดยใช้ Javascript

// ฟังก์ชันที่ตรวจสอบว่าตัวเลขเป็นฟังก์ชันไพรม์หรือไม่ isPrime(value) ( ​​​​if (isNaN(value) || !isFinite(value) || value%1 || value< 2) return false; var max=Math.floor(Math.sqrt(value)); for (var i = 2; i< = max; i++) { if (value%i==0) { return false; } } return true; } // создать массив, который будет содержать простые числа от 2 до 100 var primaryNumber = ; for (var i = 2; i <= 100; i++) { if(isPrime(i)) primaryNumber.push(i); } // вывести в консоль простые числа от 2 до 100 console.log(primaryNumber);

การปัดเศษตัวเลขใน Javascript

มีหลายวิธีในการปัดเศษเศษส่วนให้เป็นจำนวนเต็มใน JavaScript

1. ใช้วิธี Math.floor, Math.ceil และ Math.round ที่ออกแบบมาเพื่อสิ่งนี้โดยเฉพาะ เมธอด Math.floor ปัดเศษเศษส่วนลงให้เป็นจำนวนเต็มที่ใกล้ที่สุด เช่น เพียงแค่ละทิ้งส่วนที่เป็นเศษส่วน Math.ceil ปัดเศษเศษส่วนขึ้นเป็นจำนวนเต็มที่ใกล้ที่สุด Math.round ปัดเศษตัวเลขขึ้นหรือลงขึ้นอยู่กับค่าของเศษส่วน หากส่วนที่เป็นเศษส่วนมากกว่าหรือเท่ากับ 0.5 ให้ขึ้น มิฉะนั้นการบิดจะลง

Console.log (Math.floor (7.9)); //7 console.log(Math.ceil(7.2)); //8 console.log(Math.round(7.5)); //8

2. ใช้วิธี toFixed (แม่นยำ) วิธีนี้จะปัดเศษเศษส่วนของตัวเลขตามความแม่นยำที่ระบุ ผลลัพธ์การปัดเศษจะถูกส่งกลับเป็นสตริง

Console.log(7.987.toFixed(2)); //"7.99"

หากมีตำแหน่งทศนิยมไม่เพียงพอที่จะกำหนดความแม่นยำของตัวเลขที่กำหนด ระบบจะเติมด้วยศูนย์

Console.log (7.987.toFixed (5)); //"7.98700"

3. การใช้วิธี toPrecision (ความแม่นยำ) วิธีนี้แทนตัวเลขที่มีความแม่นยำตามที่กำหนด ในเวลาเดียวกันเขาสามารถปัดเศษได้ไม่เพียง แต่เศษส่วนเท่านั้น แต่ยังสามารถปัดเศษทั้งหมดของตัวเลขได้อีกด้วย วิธีนี้สามารถแสดงตัวเลขผลลัพธ์ที่มีจุดคงที่หรืออยู่ในรูปแบบเลขชี้กำลัง ทั้งนี้ขึ้นอยู่กับผลลัพธ์

Console.log((1001).toPrecision(2)); //"1.0e+3" console.log((1001).toPrecision(5)); //"1001.0" console.log((12.4).toPrecision(1)); //"1e+1" console.log((12.4).toPrecision(2)); //"12" console.log((12.4).toPrecision(3)); //"12.4" console.log((12.4).toPrecision(5)); //"12.400"

4. การใช้ตัวดำเนินการเชิงตรรกะ NOT หรือ OR

// ผ่านการปฏิเสธแบบลอจิคัลคู่ console.log (~~ 7.9); //7 // โดยใช้ตรรกะหรือกับศูนย์: console.log(7.9^0); //7

ส่วนจำนวนเต็มและเศษส่วนของตัวเลข

คุณสามารถรับส่วนจำนวนเต็มของตัวเลขได้โดยใช้เมธอด Math.floor() และ parseInt():

Console.log (Math.floor (7.21)); // 7 console.log(parseInt(7.21)); // 7

คุณสามารถรับเศษส่วนของตัวเลขได้โดยใช้ตัวดำเนินการเปอร์เซ็นต์ (%) ตัวดำเนินการนี้จะส่งคืนส่วนที่เหลือที่จะได้รับจากการหารตัวเลขแรกด้วยวินาที ในกรณีนี้ คุณต้องใช้ 1 เป็นตัวเลขที่ 2

คอนโซล.ล็อก(7.21%1); // 0.20999999999999996 // แม่นยำถึงทศนิยม 2 ตำแหน่ง console.log((7.21%1).toFixed(2)); // "0.21"

นอกจากนี้ยังสามารถรับส่วนที่เป็นเศษส่วนได้โดยใช้การคำนวณ:

หมายเลขวาร์ = 7.21; varเศษส่วนNumber = จำนวน - Math.floor(Math.abs(number)); console.log(เศษส่วนจำนวน); // 0.20999999999999996

ตัวเลขหารด้วยจำนวนเต็มได้หรือไม่?

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

หมายเลขวาร์ = 9; // ถ้าเศษที่เหลือหารด้วย 3 คือ 0 แสดงว่าใช่ มิฉะนั้นจะไม่ใช่ถ้า (number%3==0) ( console.log ("ตัวเลข " + ​​number + " หารด้วย 3"); ) else ( console.log("ตัวเลข " + ​​หมายเลข + " หารด้วย 3 ไม่ลงตัว");

การจัดรูปแบบตัวเลข

ใน JavaScript เมธอด toLocaleString() อนุญาตให้คุณจัดรูปแบบเอาต์พุตของตัวเลขตามมาตรฐานภูมิภาค (การตั้งค่าภาษาของระบบปฏิบัติการ)

ตัวอย่างเช่น ลองจัดรูปแบบตัวเลขตามมาตรฐานภูมิภาคที่ติดตั้งในระบบตามค่าเริ่มต้น:

หมายเลขวาร์ = 345.46; console.log(number.toLocaleString()); //"345.46"

ตัวอย่างเช่น จัดรูปแบบตัวเลขตามมาตรฐานภูมิภาคของรัสเซีย (ru):

Console.log((108.1).toLocaleString("ru-RU")); //"108.1"

วิธีนี้ยังสามารถใช้เพื่อจัดรูปแบบตัวเลขเป็นสกุลเงินได้:

Console.log((2540.125).toLocaleString("ru-RU",(style:"currency", สกุลเงิน:"RUB"))); //"2,540.13 ₽" console.log((89.3).toLocaleString("ru-RU",(style:"currency", สกุลเงิน:"USD"))); //"89.30 $" console.log((2301.99).toLocaleString("ru-RU",(style:"currency", สกุลเงิน:"EUR"))); //"€2,301.99"

แทนตัวเลขเป็นเปอร์เซ็นต์:

Console.log((0.45).toLocaleString("ru-RU",(สไตล์:"เปอร์เซ็นต์"))); //"45%"

แบ่งตัวเลขออกเป็นตัวเลข (useGrouping คุณสมบัติ):

Console.log((125452.32).toLocaleString("ru-RU",(useGrouping:true))); //"125,452.32"

พิมพ์ตัวเลขด้วยจำนวนหลัก (2) หลังจุดทศนิยม:

Console.log((1240.4564).toLocaleString("ru-RU",(minimumFractionDigits:2, maximumFractionDigits:2))); //"1,240.46"

การเปรียบเทียบตัวเลข

ตัวดำเนินการต่อไปนี้ใช้ในการเปรียบเทียบตัวเลขใน JavaScript: == (เท่ากับ), != (ไม่เท่ากัน), > (มากกว่า),< (меньше), >= (มากกว่าหรือเท่ากับ)<= (меньше или равно).

ตัวอย่างเช่น ลองเปรียบเทียบตัวเลขสองตัว:

คอนโซล.log(2>3); //false console.log(5>=3); //จริง

เมื่อเปรียบเทียบตัวเลขกับเศษส่วนจำเป็นต้องคำนึงถึงข้อผิดพลาดที่อาจเกิดขึ้นระหว่างการคำนวณเหล่านี้

ตัวอย่างเช่น ใน JavaScript ผลรวมของตัวเลข (0.2 + 0.4) ไม่เท่ากับ 0.6:

Console.log((0.2+0.4)==0.6); //เท็จ

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

ตัวอย่างเช่น จำนวน 0.25 10 จะถูกแปลงเป็นไบนารี่ทุกประการ

0.125 × 2 = 0.25 | 0 0.25 × 2 = 0.5 | 0 0.5 × 2 = 1 | 1 0.125 10 = 0.001 2

ตัวอย่างเช่นตัวเลข 0.2 10 สามารถแปลงเป็นระบบ 2 ได้โดยมีความแม่นยำบางประการเท่านั้น:

0.2 × 2 = 0.4 | 0 0.4 × 2 = 0.8 | 0 0.8 × 2 = 1.6 | 1 0.6 × 2 = 1.2 | 1 0.2 × 2 = 0.4 | 0 0.4 × 2 = 0.8 | 0 0.8 × 2 = 1.6 | 1 0.6 × 2 = 1.2 | 1 0.2 × 2 = 0.4 | 0 0.4 × 2 = 0.8 | 0 0.8 × 2 = 1.6 | 1 0.6 × 2 = 1.2 | 1 ... 0.2 10 = 0.001100110011... 2

เป็นผลให้ข้อผิดพลาดเหล่านี้จะส่งผลต่อการคำนวณผลรวมของตัวเลขสองตัวและผลการเปรียบเทียบ เหล่านั้น. ปรากฎว่า JavaScript จะเห็นรายการนี้จริง ๆ ดังนี้:

0.6000000000000001==0.6

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

ตัวอย่างเช่น เปรียบเทียบตัวเลขที่มีทศนิยมสูงสุด 2 ตำแหน่งโดยใช้เมธอด toFixed() และ toPrecision()

//วิธีการ toFixed() console.log((0.2+0.4).toFixed(2)==(0.6).toFixed(2)); //true //วิธีการ toPrecision() console.log((0.2+0.4).toPrecision(2)==(0.6).toPrecision(2)); //จริง

การดำเนินการทางคณิตศาสตร์ขั้นพื้นฐาน

ตัวดำเนินการทางคณิตศาสตร์ต่อไปนี้มีอยู่ใน JavaScript: + (การบวก), - (การลบ), * (การคูณ), / (การหาร), % (โมดูโล), ++ (เพิ่มค่า 1), -- (ลดค่าโดย 1)

6+3 //9 6-3 //3 6*3 //18 6/3 //2 6%3 //0 เช่น 6:3=2 => 6-3*2 => ส่วนที่เหลือ (0) 5%2 //1 เช่น 5:2=2(.5) => 5-2*2 => ส่วนที่เหลือ(1) 7.3%2 //1.3 เช่น 7.3:2=3(.65) => 7.3-2*3 => rest(1.3) //เครื่องหมายของผลลัพธ์ของการดำเนินการ % เท่ากับเครื่องหมายของค่าแรก -9%2.5 //-1.5 , เช่น. 9:2.5=3(.6) => 9-2.5*3 => ส่วนที่เหลือ(1.5) -9%-2.5 //-1.5 เช่น 9:2.5=3(.6) => 9-2.5*3 => ส่วนที่เหลือ(1.5) -2%5 //-2 เช่น 2:5=0(.4) => 2-5*0 => พัก(2) x = 3; console.log(x++); //เอาท์พุท 3 จากนั้นตั้งค่า 4 console.log(x); //4 x = 3; console.log(++x); //ตั้งค่า 4 และเอาต์พุต x = 5; console.log(x--); //เอาท์พุท 5 จากนั้นตั้งค่า 4 console.log(x); //4 x = 5; console.log(--x); //ชุดที่ 4 และเอาต์พุต นอกจากนี้ JavaScript ยังมีตัวดำเนินการรวมกัน: x+=y (x=x+y), x-=y (x=x-y), x*=y (x=x*y), x/= y (x=x/y), x%=y (x=x%y)