আমি কীভাবে চেক করব যে কোনও নম্বরটি ভাসমান বা পূর্ণসংখ্যা?


716

একটি নম্বর floatবা এটি কীভাবে খুঁজে পাবেন integer?

1.25 --> float  
1 --> integer  
0 --> integer  
0.25 --> float

47
আপনি এখানে কী জিজ্ঞাসা করছেন তা আমি বুঝতে পেরেছি, তবে কেবল স্পষ্ট করে বলার জন্য: <nit-pick>জাভাস্ক্রিপ্টের পৃথক পূর্ণসংখ্যার এবং ভাসমান সংখ্যাসূচক ধরণের নেই। জাভাস্ক্রিপ্টের প্রতিটি সংখ্যা মাত্র একটি Number</nit-pick>
ম্যাট বল 21

4
আপনি Infinityযতটা উদ্বিগ্ন কোনও পূর্ণসংখ্যা বা অ-পূর্ণসংখ্যার মান? এখানে উত্তরগুলি এই স্কোরটিতে সমানভাবে বিতরণ করা হয়েছে।
মাইক স্যামুয়েল

11
@ মাইকসামুয়েল গাণিতিকভাবে নির্ভুল হতে: যেহেতু অনন্তটি কোনও আসল সংখ্যা নয় এবং সমস্ত পূর্ণসংখ্যার আসল সংখ্যা, সুতরাং Infinityএটি পূর্ণসংখ্যা হিসাবে বিবেচনা করা যায় না।
rvighne

@ আরভিঘনে, প্রশ্নটি "রিয়েল" নয়, "ভাসমান" সম্পর্কে জিজ্ঞাসা করে। যেভাবেই হোক না কেন, বাস্তবগুলি অপ্রাসঙ্গিক কারণ কম্পিউটারগুলি কেবল গণনাযোগ্য সংখ্যা উপস্থাপন করতে পারে ।
মাইক স্যামুয়েল

2
@ আরভিঘেন, আমি মনে করি আমরা একমত যে এই অসম্পূর্ণতা এবং এনএনএন আসল সংখ্যা নয় এর অর্থ এই যে আইইইই -4৫৪ ফ্লোটগুলি আসল সংখ্যার উপসেট নয়। আইইইই -754 ভিত্তিক সমস্ত সংখ্যা বিশ্লেষণকে এই সত্যটি মোকাবেলা করতে হবে। আমি যা বুঝতে পারি না তা হ'ল আপনি কীভাবে এই সত্যটি নির্ধারণ করেন যে কীভাবে_আইনটিগ্রালকে ব্র্ট কার্ডিনালিটিগুলি আচরণ করা উচিত। ব্যক্তিগতভাবে, আমি মনে করি ((x% 1) == 0) একটি ভাল প্রক্সি এবং আইইইই -754 দ্বারা সম্পূর্ণরূপে নির্দিষ্ট করা হয়েছে, তাই বিভিন্ন নম্বর লাইনের মধ্যে চিঠিপত্র সম্পর্কে তর্ক করার দরকার নেই।
মাইক স্যামুয়েল

উত্তর:


1252

1 দ্বারা বিভাজক করার সময় বাকী অংশটি পরীক্ষা করুন:

function isInt(n) {
   return n % 1 === 0;
}

আপনি যদি জানেন না যে যুক্তিটি একটি সংখ্যা, আপনার দুটি পরীক্ষা দরকার:

function isInt(n){
    return Number(n) === n && n % 1 === 0;
}

function isFloat(n){
    return Number(n) === n && n % 1 !== 0;
}

এই উত্তরটি লেখার 5 বছর পরে 2019 আপডেট করুন , একটি সমাধান ইসিএমএ স্ক্রিপ্ট 2015 তে মানিক করা হয়েছিল That সমাধানটি এই উত্তরে coveredাকা হয়েছে ।


138
সাবধান, এই সত্য একটি খালি স্ট্রিং জন্য, ফিরে আসবে একটি স্ট্রিং অবিচ্ছেদ্য সংখ্যা প্রতিনিধিত্বমূলক, true, false, null, একটি খালি অ্যারে, একটি বিন্যাস একটি একক অবিচ্ছেদ্য নম্বর, একটি অ্যারের একটি স্ট্রিং অবিচ্ছেদ্য সংখ্যা প্রতিনিধিত্বমূলক ধারণকারী, এবং হয়তো আরো রয়েছে।
ডাগ ন্যাবিট

17
দুর্দান্ত কৌশল কিন্তু সঠিক উত্তর নয় কারণ এটি খালি স্ট্রিং চেক করতে ব্যর্থ হয়েছে ""এবং 1.0 isInt("");&& isInt(1.0);উভয়ই trueএই ডেমোটি দেখুন jsbin.com/elohuq/1/edit
চ্যাম্প

9
তবে, === এর ব্যবহারকে সাধারণভাবে == এর চেয়ে বেশি উত্সাহ দেওয়া হয়, কারণ এটি আরও ধরণের সুরক্ষা এবং আরও অনুমানযোগ্য, অভিন্ন আচরণের দিকে পরিচালিত করে। পূর্ববর্তী উত্তরদাতারা যেমন বলেছেন, এই উত্তরটি একেবারে 100% ভুল। মানগুলি নাল, খালি স্ট্রিং, 1.0 এবং আরও অনেকগুলি ভুল হিসাবে নিখুঁত হিসাবে পূর্ণসংখ্যা হিসাবে নিবন্ধিত হবে (এমনকি === চেক সহ)।
হোব্লিটজ

54
প্রশ্নটি ছিল যে কোনও সংখ্যাটি পূর্ণসংখ্যা কিনা তা কীভাবে চেক করা যায়, কোনও মান কীভাবে চেক করা যায় তা নয়।
কেনেবেেক

24
এটি স্ট্রিংকে কীভাবে বৈধতা দেয় না সে সম্পর্কে প্রচুর প্রতিকূল মন্তব্য। এটি ওপি-র প্রশ্নের অংশ নয়। আমি যদি অ্যারের শেষ উপাদানটি পুনরুদ্ধার সম্পর্কে কোনও প্রশ্ন জিজ্ঞাসা করতে এবং যদি কেউ উত্তর দিয়ে থাকে function last (array) { return array[array.length - 1]; }তবে এটি "ঠিক ভুল" বা "এসও-তে সবচেয়ে খারাপ উত্তর" কারণ এটি পরীক্ষা করে না যে আর্গুমেন্টটি প্রথমে অ্যারে কিনা? হ্যাঁ, যুক্তি যাচাই করতে ভাল অনুশীলন, তবে এটি বিকাশকারীদের দায়িত্ব। এসও উত্তরগুলি সংক্ষিপ্ত হওয়া উচিত এবং যথাসম্ভব পরিষ্কারভাবে প্রশ্নের উত্তর দেওয়া উচিত।
এম মিলার

150

মানটি কোনও সংখ্যক আদিম মান যা এর কোন ভগ্নাংশের অংশ নেই এবং যা সঠিক সংখ্যার হিসাবে উপস্থাপিত হতে পারে তার আকারের সীমাতে রয়েছে কিনা তা পরীক্ষা করে দেখার জন্য এই ফাংশনগুলি ব্যবহার করে দেখুন।

function isFloat(n) {
    return n === +n && n !== (n|0);
}

function isInteger(n) {
    return n === +n && n === (n|0);
}

5
হেই অবসোম শোষণ, এটি বেশ অনেকটা আমার (সংখ্যাটি n===+nপরীক্ষা করার জন্য , গোলাকারে n|0), তবে বিল্ট-ইন অপারেটরগুলির সাথে। ফানকি
ক্লোদিয়

7
@ জন হার্টসক একটি স্ট্রিং কখনও সংখ্যার মান হতে চলেছে না। এটি একটি স্ট্রিং। এই ফাংশনটির মূলটি হল কোনও মানটি জাভাস্ক্রিপ্টের সংখ্যাসূচক মান কিনা যার কোন ভগ্নাংশের অংশ নেই এবং যা সঠিক সংখ্যার হিসাবে উপস্থাপিত হতে পারে তার আকারের সীমাতে রয়েছে কিনা তা পরীক্ষা করা। যদি কোনও স্ট্রিংটিতে কোনও সংখ্যার প্রতিনিধিত্বকারী অক্ষরের ক্রম থাকে কিনা তা পরীক্ষা করতে চান তবে আপনাকে parseFloat()প্রথমে কল করতে হবে ।
পয়েন্টটি

4
@ জন হার্টসক: সংখ্যাটি আদিম পাস না হলে এটি সত্য হবে না। আমি মনে করি যে ফাংশনগুলির নাম প্রদান করে তা বোধগম্য হয়। অন্য যে কোনও কিছুর জন্য স্ট্রিং, ইসবুলিয়ান ইত্যাদির প্রার্থী হওয়া উচিত যদি এই ধরনের ফাংশনগুলি লেখা থাকে।
Dagg Nabbit

4
@ পয়েন্ট: ডাবল স্পষ্টতা ভাসমানগুলি ঠিক 2 ^ 53 অবধি পূর্ণসংখ্যার মানগুলি উপস্থাপন করতে পারে। সুতরাং এটি নির্ভর করে যদি ওপি গণিতের অর্থে (পুরো সংখ্যা) বা 32-বিট ডেটা অর্থে পূর্ণসংখ্যা সম্পর্কে জিজ্ঞাসা করে। যদি এটি পরে থাকে তবে আপনার সমাধানটি নিখুঁত।
ডিজেডি

8
জাভাস্ক্রিপ্টে, বিটওয়াইস অপারেটরগুলি |(ওআর) কেবলমাত্র স্বাক্ষরিত 32-বিট পূর্ণসংখ্যায় কাজ করে। স্বাক্ষরযুক্ত অন্তর্গত 32 মানগুলি পরীক্ষা করার লক্ষ্য যদি ওপিকে বলা হয় না। সুতরাং এটি পরিসীমা সংখ্যার বাইরে কাজ করবে না। যা ভুল তা isInteger(5000000000)ফিরিয়ে দেবে false!
ওনুর ইল্ডারিয়াম

93

কেন এই জাতীয় কিছু না:

var isInt = function(n) { return parseInt(n) === n };

এটি আসলে আমার জন্য ভাল সমাধানের মূল বিষয়। আমার ইতিবাচক পূর্ণসংখ্যার অনুমতি দেওয়া এবং ফ্লোট, স্ট্রিং এবং নেতিবাচক পূর্ণসংখ্যার অনুমতি দেওয়া দরকার।
ইমরান-ইউকে

4
এটি এই থ্রেডের অন্যদের তুলনায় এক বৃহত্তর সমাধানের মতো বলে মনে হচ্ছে। সম্প্রদায় সম্ভবত কিছু সমালোচনা দিতে পারে?
এসবিচেনকো

5
var y = 1.00; y === parseInt (y, 10); // এটি আমার কাছে সত্য প্রত্যাবর্তন, যা আমরা যা চাই তা সত্য নয়।
হুফটন

কেবলমাত্র "খারাপ" আমি দেখতে পাচ্ছি যে প্রদত্ত নম্বরটি nএকটি স্ট্রিংয়ে রূপান্তরিত হয়েছে parseIntএমডিএন দেখুন । তবে আমি এই সমাধানটি ব্যবহার করব। :)
রাইনো ডেভেল

2
@ কেকসবার্গ: কেন এই প্রত্যাবর্তনটি মিথ্যা হবে? 1 একটি int হয়। এবং 02, দ্বিতীয় যুক্তি উপেক্ষা করা হয়।
ঝাঁকুনি

88

একটি পদ্ধতি বলা হয় Number.isInteger()যা বর্তমানে আইই ব্যতীত সমস্ত ক্ষেত্রে প্রয়োগ করা হয়। MDN অন্যান্য ব্রাউজারগুলির জন্য একটি পলিফিলও সরবরাহ করে:

Number.isInteger = Number.isInteger || function(value) {
  return typeof value === 'number' && 
    isFinite(value) && 
    Math.floor(value) === value;
};

যাইহোক, বেশিরভাগ ব্যবহারের ক্ষেত্রে, আপনি ব্যবহার করা ভাল Number.isSafeInteger যা মানটি এত বেশি / নিম্নমানের যে কোনও দশমিক স্থান যে কোনওভাবেই হারাতে পারত কিনা তা পরীক্ষা করে দেখুন। এমডিএন এর জন্য একটি পলিফিলও রয়েছে। (আপনার isIntegerউপরের পলিফিলও প্রয়োজন ))

if (!Number.MAX_SAFE_INTEGER) {
    Number.MAX_SAFE_INTEGER = 9007199254740991; // Math.pow(2, 53) - 1;
}
Number.isSafeInteger = Number.isSafeInteger || function (value) {
   return Number.isInteger(value) && Math.abs(value) <= Number.MAX_SAFE_INTEGER;
};


1
আমার মতে সেরা সমাধান।
অটোমেটিকো

1
পলিফিল সহ এটি সর্বাধিক নির্ভরযোগ্য এবং সহজ সমাধান।
ফ্রান্সেস্কো পাসা

2
@SergeyPanfilov 12.0 ∈ ℤ
Константин Ван

1
এই উত্তরটি সরবরাহ করার পর থেকে অনুমানটি পরিবর্তিত হয়েছে কিনা তা আমি অসচেতন, তবে মনে রাখবেন যে উপরের ফাংশনটি সঠিক পলিফিল নয় Number.isInteger। এটি অবশ্য সঠিক পলিফিল Number.isSafeIntegerNumber.isIntegerনম্বরটি "নিরাপদ পূর্ণসংখ্যা" কিনা তা পরীক্ষা করা উচিত নয়। MDN দেখুন: isInteger এবং isafeInteger
নুনোস্ট্রোমার্টিন্স

33

আপনি একটি সাধারণ নিয়মিত এক্সপ্রেশন ব্যবহার করতে পারেন:

function isInt(value) {

    var er = /^-?[0-9]+$/;

    return er.test(value);
}

অথবা আপনি আপনার প্রয়োজন অনুসারে নীচের ফাংশনগুলিও ব্যবহার করতে পারেন। এগুলি পিএইচপিজেএস প্রকল্প দ্বারা বিকাশিত

is_int() => ভেরিয়েবল টাইপটি পূর্ণসংখ্য কিনা এবং এর সামগ্রীটি পূর্ণসংখ্য কিনা তা পরীক্ষা করুন

is_float() => ভেরিয়েবল টাইপ ভাসমান কিনা এবং এর সামগ্রী ভাসমান কিনা তা পরীক্ষা করে দেখুন

ctype_digit() => ভেরিয়েবল টাইপ স্ট্রিং কিনা এবং এর সামগ্রীতে কেবল দশমিক সংখ্যা রয়েছে কিনা তা পরীক্ষা করুন

আপডেট 1

এখন এটি নেতিবাচক সংখ্যাগুলিও পরীক্ষা করে, @ ক্রিসবার্টলে মন্তব্যের জন্য ধন্যবাদ !


1
সাধারণ স্বাক্ষরযুক্ত পূর্ণসংখ্যার পরীক্ষার জন্য উপযুক্ত।
টোথামারিও

7
একটি লাইনার:/^[0-9]+$/.test(String(value))
টোথামারিও

সংক্ষিপ্ত এবং কিছুটা কম পঠনযোগ্য ওয়ান-লাইনার:/^[0-9]+$/.test(''+value)
স্কাগগেস

3
Negativeণাত্মক পূর্ণসংখ্যাগুলি পরিচালনা করে না। পরীক্ষার () কোনও বুলিয়ান রিটার্ন করার পরে আপনার আর টেরিনারি অপারেটরের দরকার নেই। এটি করা উচিত:return /^-?\d+$/.test(String(value));
ক্রিস বার্টলে

@ ক্রিসবার্টলে, ধন্যবাদ! আমি আপনার ক্রেডিট সহ একটি আপডেট করেছি। এখন সবকিছু ঠিক আছে কিনা তা দয়া করে পরীক্ষা করে দেখুন।
মারসিও মাজ্জাচাতো

19

এখানে কার্যকর ফাংশন রয়েছে যা মানটি একটি সংখ্যা কিনা বা নিরাপদে কোনও সংখ্যায় রূপান্তর করতে পারে তা পরীক্ষা করে :

function isNumber(value) {
    if ((undefined === value) || (null === value)) {
        return false;
    }
    if (typeof value == 'number') {
        return true;
    }
    return !isNaN(value - 0);
}

এবং পূর্ণসংখ্যার জন্য (মানটি যদি ভাসমান হয় তবে মিথ্যা ফিরে আসবে):

function isInteger(value) {
    if ((undefined === value) || (null === value)) {
        return false;
    }
    return value % 1 == 0;
}

এখানে দক্ষতা হ'ল পার্সিয়ান্ট (বা পার্সনম্বার) এড়ানো যায় যখন মানটি ইতিমধ্যে একটি সংখ্যা হয়। উভয় পার্সিং ফাংশন সর্বদা প্রথমে স্ট্রিংয়ে রূপান্তর করে এবং তারপরে সেই স্ট্রিংটিকে বিশ্লেষণ করার চেষ্টা করে, যা ইতিমধ্যে মানটি যদি একটি সংখ্যা হয় তবে এটি নষ্ট হবে।

অপ্টিমাইজেশনের জন্য আরও ধারণা দেওয়ার জন্য এখানে অন্যান্য পোস্টগুলিতে আপনাকে ধন্যবাদ!


3
এই ফাংশনটি খালি স্ট্রিংয়ে ব্যর্থ হয়: isNumber ('') সত্য।
জেসন গ্রাউট

14
function isInteger(x) { return typeof x === "number" && isFinite(x) && Math.floor(x) === x; }
function isFloat(x) { return !!(x % 1); }

// give it a spin

isInteger(1.0);        // true
isFloat(1.0);          // false
isFloat(1.2);          // true
isInteger(1.2);        // false
isFloat(1);            // false
isInteger(1);          // true    
isFloat(2e+2);         // false
isInteger(2e+2);       // true
isFloat('1');          // false
isInteger('1');        // false
isFloat(NaN);          // false
isInteger(NaN);        // false
isFloat(null);         // false
isInteger(null);       // false
isFloat(undefined);    // false
isInteger(undefined);  // false

4
স্পষ্টতই, .0 দিয়ে শেষ হওয়া ভাসমানগুলি স্বয়ংক্রিয়ভাবে জাভাস্ক্রিপ্টে INT এ কাস্ট করা হয়।

সঙ্গে ব্যর্থ 1.2। সর্বদা 0.1 0.2 0.3 দিয়ে সংখ্যাসূচক ফাংশনগুলি পরীক্ষা করুন
লুকাশ লিসিস

@ LuasLies আমার জন্য নয়
ডাবলআর্ট

কঠোর সাম্য অপারেটরগুলির কোনওটির প্রয়োজন নেই এখানে।
ডাবলআর্ট

isFloat (1563457121531) মিথ্যা ফিরিয়ে দেয়
আলেেক্স গবি

9
function isInt(n) 
{
    return n != "" && !isNaN(n) && Math.round(n) == n;
}
function isFloat(n){
    return n != "" && !isNaN(n) && Math.round(n) != n;
}

সব ক্ষেত্রে কাজ করে।


2
+1 এটি ভাল। প্রত্যাশিত হিসাবে isInt('1')প্রত্যাবর্তন true(কমপক্ষে আমার জন্য)। অদ্ভুত যথেষ্ট, যদিও, এই আয় trueথেকে isInt([5])পাশাপাশি। আমার পক্ষে কিছু যায় আসে না, তবে আপনার জন্যও তাই হতে পারে, যত্ন নিন।
acdcjunior

2
isFloat (12.0) মিথ্যা
জ্যাঙ্গো

6

অন্যরা যেমন উল্লেখ করেছে, আপনার জেএসে কেবল দ্বিগুণ রয়েছে। সুতরাং আপনি সংখ্যার সংখ্যাকে সংখ্যার সংজ্ঞা দেওয়া কীভাবে করবেন? বৃত্তাকার সংখ্যাটি নিজের সমান কিনা তা কেবল পরীক্ষা করুন:

function isInteger(f) {
    return typeof(f)==="number" && Math.round(f) == f;
}
function isFloat(f) { return typeof(f)==="number" && !isInteger(f); }

3
মানটি সংখ্যাসূচক কিনা তা পরীক্ষা করতে পারে ... isFloat('abc')ফেরত দেয়true
ডাগ ন্যাবিট

isFloat(NaN) // true
শীম

@ শিম: ভাল ক্যাচ এনএএন প্রযুক্তিগতভাবে একটি ভাসমান পয়েন্ট সংখ্যা যদিও ... আমি মনে করি ব্যবহারের কেসটি নির্ভর করে।
ক্লাদিউ


5

আমি পূর্ণসংখ্যার জন্য যা ব্যবহার করি তা এখানে:

Math.ceil(parseFloat(val)) === val

সংক্ষিপ্ত, দুর্দান্ত :) সব সময় কাজ করে। আমি ভুল না হলে ডেভিড ফ্লানাগন এটাই পরামর্শ দেয়।


আমি এটি পছন্দ করি কারণ এটি একটি সংক্ষিপ্ত, সহজ উত্তর যা ক্রিপ্টিক বিটওয়াইজ অপারেশনের উপর নির্ভর করে না।
জিম

কেন parseFloat?
ডাবলআর্ট

4

এটি আপনি কী অর্জন করতে চান তার উপর নির্ভর করে। আপনি যদি শক্তভাবে টাইপ করা ভাষাগুলি "অনুকরণ" করতে চান তবে আমি আপনাকে চেষ্টা না করার পরামর্শ দিচ্ছি। অন্যরা উল্লিখিত হিসাবে সমস্ত সংখ্যার একই উপস্থাপনা (একই ধরণের) থাকে।

ক্লাউডিয়ু সরবরাহের মতো কিছু ব্যবহার করে :

isInteger( 1.0 ) -> সত্য

যা সাধারণ জ্ঞানের জন্য দুর্দান্ত দেখায়, তবে সি এর মতো কিছুতে আপনি পাবেন false


4

শূন্য দশমিক অংশের সাথে যে কোনও ফ্লোট নম্বর (উদাহরণস্বরূপ, 1.0, 12.00, 0.0) পুরোপুরিভাবে পূর্ণসংখ্যায় কাস্ট করা হয়, সুতরাং সেগুলি ফ্লোট কিনা তা চেক করা সম্ভব নয়।



3

এটা আসলে এত জটিল হতে হবে না। একটি পূর্ণসংখ্যার পার্সফ্লোট () এবং পার্সিয়ান্ট () সমতুল্যগুলির সংখ্যার মানটি একই হবে। সুতরাং আপনি এটি করতে পারেন:

function isInt(value){ 
    return (parseFloat(value) == parseInt(value)) && !isNaN(value);
}

তারপর

if (isInt(x)) // do work

এটি স্ট্রিং চেকগুলির জন্যও অনুমতি দেয় এবং এইভাবে কঠোর নয়। যদি একটি শক্তিশালী ধরণের সমাধান চান (ওরফে, স্ট্রিংগুলির সাথে কাজ করবে না):

function is_int(value){ return !isNaN(parseInt(value * 1) }

isInteger (12.0) সত্য
জ্যাঙ্গো

3
var isInt = function (n) { return n === (n | 0); };

এটি কাজ না করে এমন কোনও মামলা হয়নি।


আরে দুঃখিত কেন এই মিথ্যা ফিরে? console.log (isInt (7932938942839482938));
itme

4
কারণ এটি ম্যাক্সেন্ট ছাড়িয়ে গেছে।
অ্যাঙ্কর

তবে আপনি কোন সর্বোচ্চ দৈর্ঘ্যের নোপ সেট করতে পারেন? আমি যদি দুনো ইন্টের দৈর্ঘ্য ফেরত পাই?
এটিমে

1
@ কেকসবার্গ হ্যাঁ কারণ 2একটি পূর্ণসংখ্যা এবং 23এটি ফাংশনের দ্বিতীয় যুক্তি হিসাবে বিবেচিত হয়। জাভাস্ক্রিপ্টে দশমিকগুলি বিভাজক হিসাবে ডট ব্যবহার করে লেখা হয় - সুতরাং এটি হওয়া উচিত 2.23
অ্যাঙ্কর

1
অথবা বিটওয়াইজ অপারেশন সম্পর্কে শেখার একটি দুর্দান্ত সুযোগ। আপনি যে এগিয়ে যাওয়া থেকে অনেক উপকার পাবেন।
অঙ্কুর

2

এটি অন্তর্ভুক্ত এবং ফ্লাট পরীক্ষা করার জন্য শেষ কোড

function isInt(n) { 
   if(typeof n == 'number' && Math.Round(n) % 1 == 0) {
       return true;
   } else {
       return false;
   }
} 

অথবা

function isInt(n) {   
   return typeof n == 'number' && Math.Round(n) % 1 == 0;   
}   

এটি কেবলমাত্র
ভাসমানের

2
function isInteger(n) {
   return ((typeof n==='number')&&(n%1===0));
}

function isFloat(n) {
   return ((typeof n==='number')&&(n%1!==0));
}

function isNumber(n) {
   return (typeof n==='number');
}

একটি পূর্ণসংখ্যা একটি ভাসা না? আমার কাছে খবর।
মার্টেন বোদেউয়েস

2

এটি এত সহজ:

if( n === parseInt(n) ) ...

কনসোল এ চেষ্টা করুন:

x=1;
x===parseInt(x); // true
x="1";
x===parseInt(x); // false
x=1.1;
x===parseInt(x); // false, obviously

// BUT!

x=1.0;
x===parseInt(x); // true, because 1.0 is NOT a float!

এটি প্রচুর মানুষকে বিভ্রান্ত করে। যখনই কিছু .0 হয়, এটি আর ভাসা নয়। এটি একটি পূর্ণসংখ্যা অথবা আপনি এটিকে কেবল "একটি সংখ্যাসূচক জিনিস" বলতে পারেন কারণ সি এর মতো আর কোনও কঠোর পার্থক্য নেই Good

সুতরাং মূলত, আপনি যা করতে পারেন তা হ'ল 1.000 একটি পূর্ণসংখ্যা এই সত্যটি গ্রহণ করে inte

আকর্ষণীয় দিক নোট

বিশাল সংখ্যা সম্পর্কে একটি মন্তব্য ছিল। বিশাল সংখ্যার অর্থ এই পদ্ধতির কোনও সমস্যা নেই; যখনই পার্সিয়ান্ট সংখ্যাটি পরিচালনা করতে অক্ষম (কারণ এটি খুব বড়) এটি আসল মান ব্যতীত অন্য কিছু ফিরিয়ে আনবে যাতে পরীক্ষাটি মিথ্যা ফিরিয়ে দেয়। এটি একটি ভাল জিনিস কারণ আপনি যদি কোনও "সংখ্যার" কিছু বিবেচনা করেন তবে আপনি সাধারণত জেএস এর সাথে গণনা করতে সক্ষম হবেন বলে আশা করেন - সুতরাং হ্যাঁ, সংখ্যাগুলি সীমাবদ্ধ এবং পার্সেন্ট এটি এটিকে এইভাবে রাখার জন্য এটি বিবেচনায় নেবে

এটা চেষ্টা কর:

<script>

var a = 99999999999999999999;
var b = 999999999999999999999; // just one more 9 will kill the show!
var aIsInteger = (a===parseInt(a))?"a is ok":"a fails";
var bIsInteger = (b===parseInt(b))?"b is ok":"b fails";
alert(aIsInteger+"; "+bIsInteger);

</script>

আমার ব্রাউজারে (আইই 8) এটি "a ঠিক আছে; বি ব্যর্থ" ফিরে আসে যা হ'ল বি এর বিশাল সংখ্যার কারণে। সীমাটি পৃথক হতে পারে তবে আমার ধারণা 20 টি সংখ্যার "কারও পক্ষে যথেষ্ট হওয়া উচিত", একটি শাস্ত্রীয় উদ্ধৃত করার জন্য :)


এটি ঠিক আছে যদি আপনার কেবলমাত্র অবিচ্ছেদ্য সংখ্যাগুলি (গণিতের পিওভি থেকে) পরীক্ষা করা প্রয়োজন তবে আপনি যদি নিশ্চিত করতে চান যে তারা আসলে সংখ্যার মতো কাজ করে (একটি কম্পিউটিং পিওভি থেকে) এটি বিশাল সংখ্যার জন্য ভুল হতে চলেছে। এই মন্তব্য দেখুন ।
Dagg Nabbit

মমমমমমম ... তুমি কেন এমন ভাবছো? আমি বলতে চাইছি, যদি পার্সিয়ান্ট কিছু ফিরিয়ে দেয় এবং এটি ভেরিয়েবলের সাথে সমান মনে হয়, আপনি নিশ্চিত হতে পারেন যে আপনার এন সত্যই একটি পূর্ণসংখ্যা হিসাবে কাজ করে। আমি দেখতে পেলাম যে 9999999999999999999999 (অর্থাত 20 গুণ "9") একটি সংখ্যার সময় আরও একটি "9" যুক্ত করলে পার্সেন্ট ব্যর্থ হয়ে যায় (ফিরে আসা 1)। এটি ব্রাউজার-নির্ভর হতে পারে; তবে, হ্যাঁ, একটি সীমা রয়েছে এবং কোনও কিছুই নেই, যে সীমাটি বাইরে রয়েছে তা উপরের চেকটির জন্য সত্য হবে না।
dkellner

আমার অর্থ হ'ল বিটওয়াইজ অপারেটরগুলি (যা সংখ্যাকে 32 বিট ইন্ট হিসাবে বিবেচনা করে) 32 বিট ইন্ট হিসাবে প্রতিনিধিত্ব করা যায় না এমন সংখ্যায় প্রত্যাশিত ফলাফল দেয় না, সুতরাং সেই সংখ্যাগুলি ইনট হিসাবে চিহ্নিত করা উচিত নয়। এটি প্রস্তাবিত কীভাবে Number.isIntegerকাজ করে তার সাথে সামঞ্জস্যপূর্ণ ।
ড্যাগ নাবিত

একটি নির্দিষ্ট উপায়ে সংরক্ষণ না করে কিছু সত্যিকারের পূর্ণসংখ্যা হতে পারে। আমি আপনার পয়েন্টটি দেখতে পাচ্ছি কিন্তু পূর্ণসংখ্যাগুলি পূর্ণসংখ্যা হয় কারণ তাদের কোনও ভগ্নাংশের অংশ নেই এবং ভাসমানের মতো ফলাফল না পেয়ে নির্বিচারে যোগ / বিয়োগ করা যেতে পারে। যদি আপনি বিটফিল্ড হিসাবে সংখ্যার সাথে আচরণ করেন তবে আপনি কীভাবে তা সংরক্ষণ করছেন তা সম্পর্কে কিছু ধারণা করছেন - আমার মতে - কার্যত কার্যকর কিন্তু 100% নির্ভরযোগ্য উপায় নয়। যদি আপনি "একটি নির্দিষ্ট উপায়ে একটি পূর্ণসংখ্যার সঞ্চিত" খুঁজছেন, ভাল, আমি নিশ্চিত নই যে এখানে একটি একক-লাইন পরীক্ষা আছে যা আপনি নিরাপদে সমস্ত প্ল্যাটফর্মে ব্যবহার করতে পারবেন।
ডিজেলনার

32-বিট ইনট হিসাবে প্রকাশ করা যায় এমন নম্বরগুলি বিটওয়াইজ অপারেটরগুলির সাথে 100% নির্ভরযোগ্যভাবে কাজ করে। আপনি "সেগুলি কীভাবে সংরক্ষণ করা হয় সে সম্পর্কে কিছু মনে করছেন না"; সংখ্যাগুলি নির্দিষ্টকরণ অনুসারে 32-বিট বিগ-এন্ডিয়ান টু এর পরিপূরক পূর্ণসংখ্যায় রূপান্তরিত হয়। এই বিন্যাসে প্রতিনিধিত্ব করা যায় না এমন সংখ্যাগুলি পূর্ণসংখ্যার হিসাবে বিবেচনা করা উচিত নয়। আবার, এটি কীভাবে Number.isIntegerকাজ করে তার সাথে সামঞ্জস্য। একটি একক লাইন পরীক্ষা n === (n | 0)অন্য উত্তরে দেখানো হয়েছে।
Dagg Nabbit

2

এই সমাধানটি আমার পক্ষে কাজ করেছিল।

<html>
<body>
  <form method="post" action="#">
    <input type="text" id="number_id"/>
    <input type="submit" value="send"/>
  </form>
  <p id="message"></p>
  <script>
    var flt=document.getElementById("number_id").value;
    if(isNaN(flt)==false && Number.isInteger(flt)==false)
    {
     document.getElementById("message").innerHTML="the number_id is a float ";
    }
   else 
   {
     document.getElementById("message").innerHTML="the number_id is a Integer";
   }
  </script>
</body>
</html>

1

পূর্ণসংখ্যার জন্য আমি এটি ব্যবহার করি

function integer_or_null(value) {
    if ((undefined === value) || (null === value)) {
        return null;
    }
    if(value % 1 != 0) {
        return null;
    }
    return value;
}

1

জাভা স্ক্রিপ্টে সমস্ত সংখ্যা internally 64 bit floating pointজাভাতে দ্বিগুণ। জাভাস্ক্রিপ্টে কোনও আলাদা ধরনের নেই, সমস্তই টাইপ দ্বারা প্রতিনিধিত্ব করা হয় number। অতএব আপনি instanceofচেক করতে সক্ষম হবেন না । তবে আপনি প্রদত্ত উপরের সমাধানগুলি এটি কোনও ভগ্নাংশের সংখ্যা কিনা তা অনুসন্ধান করতে ব্যবহার করতে পারেন। জাভা স্ক্রিপ্টের ডিজাইনাররা একক প্রকারের সাথে অনুভব করেছেন যে তারা অসংখ্য ধরণের কাস্ট ত্রুটি এড়াতে পারবেন।


1

কিছু সময় সংখ্যার অবজেক্ট আপনাকে সরাসরি মোড অপারেটর (%) ব্যবহার করার অনুমতি দেয় না, যদি আপনি সেই ক্ষেত্রে সম্মুখীন হন তবে আপনি এই সমাধানটি ব্যবহার করতে পারেন।

if(object instanceof Number ){
   if( ((Number) object).doubleValue() % 1 == 0 ){
      //your object is an integer
   }
   else{
      //your object is a double
   }
}

1

এখানে কয়েকটি উত্তর চেষ্টা করে আমি এই সমাধানটি লিখে শেষ করেছি। এটি স্ট্রিংয়ের ভিতরে সংখ্যাগুলির সাথেও কাজ করে।

function isInt(number) {
    if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
    return !(number - parseInt(number));
}

function isFloat(number) {
    if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
    return number - parseInt(number) ? true : false;
}

    var tests = {
        'integer' : 1,
        'float' : 1.1,
        'integerInString' : '5',
        'floatInString' : '5.5',
        'negativeInt' : -345,
        'negativeFloat' : -34.98,
        'negativeIntString' : '-45',
        'negativeFloatString' : '-23.09',
        'notValidFalse' : false,
        'notValidTrue' : true,
        'notValidString' : '45lorem',
        'notValidStringFloat' : '4.5lorem',
        'notValidNan' : NaN,
        'notValidObj' : {},
        'notValidArr' : [1,2],
    };

    function isInt(number) {
        if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
        return !(number - parseInt(number));
    }
    
    function isFloat(number) {
        if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
        return number - parseInt(number) ? true : false;
    }

    function testFunctions(obj) {
        var keys = Object.keys(obj);
        var values = Object.values(obj);

        values.forEach(function(element, index){
            console.log(`Is ${keys[index]} (${element}) var an integer? ${isInt(element)}`);
            console.log(`Is ${keys[index]} (${element}) var a float? ${isFloat(element)}`);
        });
    }

    testFunctions(tests);


0

এটি সম্ভবত% উত্তরের মতো পারফরম্যান্ট নয়, যা আপনাকে প্রথমে স্ট্রিংয়ে রূপান্তর করতে বাধা দেয় তবে আমি এখনও কাউকে এটি পোস্ট করতে দেখিনি, সুতরাং এখানে আরও একটি বিকল্প রয়েছে যা ভাল কাজ করা উচিত:

function isInteger(num) {
    return num.toString().indexOf('.') === -1;
}

ভাল পদ্ধতির আইএমএইচও
সের্গেই পানফিলভ

আমি যুক্ত করব যে ES6 পদ্ধতিতে অন্তর্ভুক্ত রয়েছে () এই উত্তরটিকে আরও সহজ করে তোলে
এক্সেল

0

এই কৌতূহলীদের জন্য, বেঞ্চমার্ক.জেএস ব্যবহার করে আমি এই পোস্টে সর্বাধিক ভোট প্রাপ্ত উত্তরগুলি (এবং আজ পোস্ট করা একটি) পরীক্ষা করেছি, এখানে আমার ফলাফল রয়েছে:

var n = -10.4375892034758293405790;
var suite = new Benchmark.Suite;
suite
    // kennebec
    .add('0', function() {
        return n % 1 == 0;
    })
    // kennebec
    .add('1', function() {
        return typeof n === 'number' && n % 1 == 0;
    })
    // kennebec
    .add('2', function() {
        return typeof n === 'number' && parseFloat(n) == parseInt(n, 10) && !isNaN(n);
    })

    // Axle
    .add('3', function() {
        return n.toString().indexOf('.') === -1;
    })

    // Dagg Nabbit
    .add('4', function() {
        return n === +n && n === (n|0);
    })

    // warfares
    .add('5', function() {
        return parseInt(n) === n;
    })

    // Marcio Simao
    .add('6', function() {
        return /^-?[0-9]+$/.test(n.toString());
    })

    // Tal Liron
    .add('7', function() {
        if ((undefined === n) || (null === n)) {
            return false;
        }
        if (typeof n == 'number') {
            return true;
        }
        return !isNaN(n - 0);
    });

// Define logs and Run
suite.on('cycle', function(event) {
    console.log(String(event.target));
}).on('complete', function() {
    console.log('Fastest is ' + this.filter('fastest').pluck('name'));
}).run({ 'async': true });

0 x 12,832,357 ops/sec ±0.65% (90 runs sampled)
1 x 12,916,439 ops/sec ±0.62% (95 runs sampled)
2 x 2,776,583 ops/sec ±0.93% (92 runs sampled)
3 x 10,345,379 ops/sec ±0.49% (97 runs sampled)
4 x 53,766,106 ops/sec ±0.66% (93 runs sampled)
5 x 26,514,109 ops/sec ±2.72% (93 runs sampled)
6 x 10,146,270 ops/sec ±2.54% (90 runs sampled)
7 x 60,353,419 ops/sec ±0.35% (97 runs sampled)

Fastest is 7 Tal Liron

0

আমার কোড এখানে। এটি খালি স্ট্রিং নয় (তা অন্যথায় কেটে যাবে) তা নিশ্চিত করার জন্য এটি পরীক্ষা করে এবং তারপরে এটি সংখ্যার বিন্যাসে রূপান্তর করে। এখন, আপনি '1.1' কে 1.1 এর সমান হতে চান তার উপর নির্ভর করে, আপনি যা খুঁজছেন তা এটি হতে পারে বা নাও পারে।

var isFloat = function(n) {
    n = n.length > 0 ? Number(n) : false;
    return (n === parseFloat(n));
};
var isInteger = function(n) {
    n = n.length > 0 ? Number(n) : false;
    return (n === parseInt(n));
};

var isNumeric = function(n){

   if(isInteger(n) || isFloat(n)){
        return true;
   }
   return false;

};

0

আমি এই ছোট্ট ফাংশনটি পছন্দ করি, যা ইতিবাচক এবং নেতিবাচক উভয় পূর্ণসংখ্যার জন্যই সত্য ফিরে আসবে:

function isInt(val) {
    return ["string","number"].indexOf(typeof(val)) > -1 && val !== '' && !isNaN(val+".0");
}

এটি কাজ করে কারণ 1 বা "1" "1.0" হয়ে যায়, যা isNaN () মিথ্যা ফিরিয়ে দেয় (যার পরে আমরা প্রত্যাখ্যান করি এবং ফিরে আসি), তবে 1.0 বা "1.0" "1.0.0" হয়ে যায়, "স্ট্রিং" "স্ট্রিং" হয়ে যায়। 0 ", যার মধ্যে কোনওটিই সংখ্যা নয়, সুতরাং isNaN () মিথ্যা ফেরত দেয় (এবং, আবার উপেক্ষিত হয়)।

আপনি যদি কেবল ইতিবাচক পূর্ণসংখ্যার চান তবে এই বৈকল্পিকটি রয়েছে:

function isPositiveInt(val) {
    return ["string","number"].indexOf(typeof(val)) > -1 && val !== '' && !isNaN("0"+val);
}

বা, নেতিবাচক পূর্ণসংখ্যার জন্য:

function isNegativeInt(val) {
    return `["string","number"].indexOf(typeof(val)) > -1` && val !== '' && isNaN("0"+val);
}

isPositiveInt () পরীক্ষিত হওয়ার মানটির আগে সংক্ষিপ্ত সংখ্যাযুক্ত স্ট্রিংটি সরিয়ে নিয়ে কাজ করে। উদাহরণস্বরূপ, isPositiveInt (1) এর ফলাফল "01" এর মূল্যায়ন isNaN (), যা মিথ্যা মূল্যায়ন করে। এদিকে, isososantInt (-1) এর ফলাফল "0-1" মূল্যায়ন করে isNaN (), যা সত্যের মূল্যায়ন করে। আমরা রিটার্ন মানকে অবহেলা করি এবং এটি আমাদের যা চায় তা দেয় gives isNegativeInt () একইভাবে কাজ করে, তবে isNaN () এর রিটার্ন মান অবহেলা না করে।

সম্পাদনা:

আমার আসল বাস্তবায়ন অ্যারে এবং খালি স্ট্রিংয়ের ক্ষেত্রেও সত্য ফিরে আসবে। এই প্রয়োগের যে ত্রুটি নেই। যদি ভাল স্ট্রিং বা সংখ্যা না হয় বা এটি যদি খালি স্ট্রিং হয়, তবে তা দ্রুত ফিরিয়ে নেওয়ার সুবিধাও রয়েছে। প্রথম দুটি ধারাটি প্রতিস্থাপন করে আপনি এটিকে আরও সংশোধন করতে পারেন

typeof(val) != "number"

আপনি যদি কেবল আক্ষরিক সংখ্যার সাথে মিল রাখতে চান (এবং স্ট্রিং নয়)

সম্পাদনা:

আমি এখনও মন্তব্য পোস্ট করতে পারি না, তাই আমি আমার উত্তরে এটি যুক্ত করছি। @ আসোক পোস্ট করা বেঞ্চমার্কটি খুব তথ্যপূর্ণ; তবে দ্রুততম ফাংশন প্রয়োজনীয়তার সাথে খাপ খায় না, কারণ এটি ভাসমান, অ্যারে, বুলিয়ান এবং খালি স্ট্রিংয়ের জন্যও সত্য দেয়।

আমি তালিকায় আমার উত্তর যুক্ত করে প্রতিটি ফাংশনটি পরীক্ষা করার জন্য নিম্নলিখিত টেস্ট স্যুটটি তৈরি করেছি (ফাংশন 8, যা স্ট্রিংগুলিকে পার্স করে এবং 9 নং ফাংশন দেয় না):

funcs = [
    function(n) {
        return n % 1 == 0;
    },
    function(n) {
        return typeof n === 'number' && n % 1 == 0;
    },
    function(n) {
        return typeof n === 'number' && parseFloat(n) == parseInt(n, 10) && !isNaN(n);
    },
    function(n) {
        return n.toString().indexOf('.') === -1;
    },
    function(n) {
        return n === +n && n === (n|0);
    },
    function(n) {
        return parseInt(n) === n;
    },
    function(n) {
        return /^-?[0-9]+$/.test(n.toString());
    },
    function(n) {
        if ((undefined === n) || (null === n)) {
            return false;
        }
        if (typeof n == 'number') {
            return true;
        }
        return !isNaN(n - 0);
    },
    function(n) {
        return ["string","number"].indexOf(typeof(n)) > -1 && n !== '' && !isNaN(n+".0");
    }
];
vals = [
    [1,true],
    [-1,true],
    [1.1,false],
    [-1.1,false],
    [[],false],
    [{},false],
    [true,false],
    [false,false],
    [null,false],
    ["",false],
    ["a",false],
    ["1",null],
    ["-1",null],
    ["1.1",null],
    ["-1.1",null]
];

for (var i in funcs) {
    var pass = true;
    console.log("Testing function "+i);
    for (var ii in vals) {
        var n = vals[ii][0];
        var ns;
        if (n === null) {
            ns = n+"";
        } else {
            switch (typeof(n)) {
                case "string":
                    ns = "'" + n + "'";
                    break;
                case "object":
                    ns = Object.prototype.toString.call(n);
                    break;
                default:
                    ns = n;
            }
            ns = "("+typeof(n)+") "+ns;
        }

        var x = vals[ii][1];
        var xs;
        if (x === null) {
            xs = "(ANY)";
        } else {
            switch (typeof(x)) {
                case "string":
                    xs = "'" + n + "'";
                    break;
                case "object":
                    xs = Object.prototype.toString.call(x);
                    break;
                default:
                    xs = x;
            }
            xs = "("+typeof(x)+") "+xs;
        }

        var rms;
        try {
            var r = funcs[i](n);
            var rs;
            if (r === null) {
                rs = r+"";
            } else {
                switch (typeof(r)) {
                    case "string":
                        rs = "'" + r + "'";
                        break;
                    case "object":
                        rs = Object.prototype.toString.call(r);
                        break;
                    default:
                        rs = r;
                }
                rs = "("+typeof(r)+") "+rs;
            }

            var m;
            var ms;
            if (x === null) {
                m = true;
                ms = "N/A";
            } else if (typeof(x) == 'object') {
                m = (xs === rs);
                ms = m;
            } else {
                m = (x === r);
                ms = m;
            }
            if (!m) {
                pass = false;
            }
            rms = "Result: "+rs+", Match: "+ms;
        } catch (e) {
            rms = "Test skipped; function threw exception!"
        }

        console.log("    Value: "+ns+", Expect: "+xs+", "+rms);
    }
    console.log(pass ? "PASS!" : "FAIL!");
}

আমি তালিকায় যোগ করা # 8 ফাংশন সহ বেঞ্চমার্কটিও পুনরায় পুনরায় পেশ করি। আমি ফলাফলটি পোস্ট করব না, কারণ তারা কিছুটা বিব্রতকর (যেমন ফাংশনটি দ্রুত নয়) ...

(সংক্ষিপ্ত - আমি সফল পরীক্ষাগুলি সরিয়েছি, যেহেতু আউটপুটটি বেশ দীর্ঘ) ফলাফলগুলি নিম্নরূপ:

Testing function 0
Value: (object) [object Array], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) true, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) false, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: null, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
FAIL!

Testing function 1
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 2
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 3
Value: (object) true, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (object) false, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Array], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Object], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: null, Expect: (boolean) false, Test skipped; function threw exception!
Value: (string) '', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) 'a', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
FAIL!

Testing function 4
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 5
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 6
Value: null, Expect: (boolean) false, Test skipped; function threw exception!
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 7
Value: (number) 1.1, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (number) -1.1, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (object) true, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Array], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Object], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) true, Match: N/A
FAIL!

Testing function 8
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 9
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

আমি ব্যর্থতা ফেলে রেখেছি যাতে আপনি প্রতিটি ফাংশনটি কোথায় ব্যর্থ হচ্ছে তা দেখতে পাবেন এবং (স্ট্রিং) '#' পরীক্ষাগুলি যাতে আপনি দেখতে পারেন যে প্রতিটি ফাংশন স্ট্রিংগুলিতে কীভাবে পূর্ণসংখ্যা এবং ভাসমান মানকে পরিচালনা করে, যেমন কেউ এগুলি সংখ্যার হিসাবে পার্স করতে চান এবং কিছু নাও হতে পারে.

পরীক্ষিত 10 টি ফাংশনগুলির মধ্যে, আসলে ওপি'র প্রয়োজনীয়তাগুলি মাপসই [1,3,5,6,8,9]


0

ভাসমান বৈধতার শর্ত:

if (lnk.value == +lnk.value && lnk.value != (lnk.value | 0)) 

পূর্ণসংখ্যার বৈধতার শর্ত:

if (lnk.value == +lnk.value && lnk.value == (lnk.value | 0)) 

আশা করি এটি সহায়ক হতে পারে।


0
function int(a) {
  return a - a === 0 && a.toString(32).indexOf('.') === -1
}

function float(a) {
  return a - a === 0 && a.toString(32).indexOf('.') !== -1
}

আপনি typeof a === 'number'যদি স্ট্রিংগুলি বাদ দিতে চান তবে আপনি যোগ করতে পারেন।

আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.