ජාවාස්ක්‍රිප්ට් හි පාවෙන අංකයක් මුළු අංකයකට පරිවර්තනය කරන්නේ කෙසේද?

ජාවාස්ක්‍රිප්ට් හි පාවෙන මුළු අංකයක් බවට පරිවර්තනය කිරීමට මම කැමතියි. ඇත්ත වශයෙන්ම, සම්මත පරිවර්තනයන් දෙකෙන් එකක් කරන්නේ කෙසේදැයි දැන ගැනීමට මා කැමතිය: කප්පාදු කිරීමෙන් සහ වටකුරු කිරීමෙන්. හා කාර්යක්ෂමව, නූල් බවට පරිවර්තනය කිරීම හා විග්‍රහ කිරීම හරහා නොවේ.

var intvalue = Math.floor( floatvalue );
var intvalue = Math.ceil( floatvalue ); 
var intvalue = Math.round( floatvalue );

// `Math.trunc` was added in ECMAScript 6
var intvalue = Math.trunc( floatvalue );

ගණිත වස්තු යොමු කිරීම

උදාහරණ

// value=x        //  x=5          5<x<5.5      5.5<=x<6  

Math.floor(value) //  5            5            5
Math.ceil(value)  //  5            6            6
Math.round(value) //  5            5            6
Math.trunc(value) //  5            5            5
parseInt(value)   //  5            5            5
~~value           //  5            5            5
value | 0         //  5            5            5
value >> 0        //  5            5            5
value >>> 0       //  5            5            5
value - value % 1 //  5            5            5

// value=x        // x=-5         -5>x>=-5.5   -5.5>x>-6

Math.floor(value) // -5           -6           -6
Math.ceil(value)  // -5           -5           -5
Math.round(value) // -5           -5           -6
Math.trunc(value) // -5           -5           -5
parseInt(value)   // -5           -5           -5
value | 0         // -5           -5           -5
~~value           // -5           -5           -5
value >> 0        // -5           -5           -5
value >>> 0       // 4294967291   4294967291   4294967291
value - value % 1 // -5           -5           -5

// x = Number.MAX_SAFE_INTEGER/10 // =900719925474099.1

// value=x            x=900719925474099    x=900719925474099.4  x=900719925474099.5

Math.floor(value) //  900719925474099      900719925474099      900719925474099
Math.ceil(value)  //  900719925474099      900719925474100      900719925474100
Math.round(value) //  900719925474099      900719925474099      900719925474100
Math.trunc(value) //  900719925474099      900719925474099      900719925474099
parseInt(value)   //  900719925474099      900719925474099      900719925474099
value | 0         //  858993459            858993459            858993459
~~value           //  858993459            858993459            858993459
value >> 0        //  858993459            858993459            858993459
value >>> 0       //  858993459            858993459            858993459
value - value % 1 //  900719925474099      900719925474099      900719925474099

// x = Number.MAX_SAFE_INTEGER/10 * -1 // -900719925474099.1

// value = x      // x=-900719925474099   x=-900719925474099.5 x=-900719925474099.6

Math.floor(value) // -900719925474099     -900719925474100     -900719925474100
Math.ceil(value)  // -900719925474099     -900719925474099     -900719925474099
Math.round(value) // -900719925474099     -900719925474099     -900719925474100
Math.trunc(value) // -900719925474099     -900719925474099     -900719925474099
parseInt(value)   // -900719925474099     -900719925474099     -900719925474099
value | 0         // -858993459           -858993459           -858993459
~~value           // -858993459           -858993459           -858993459
value >> 0        // -858993459           -858993459           -858993459
value >>> 0       //  3435973837           3435973837           3435973837
value - value % 1 // -900719925474099     -900719925474099     -900719925474099

බිට්වේස් හෝ ක්‍රියාකරු

පාවෙන ලක්ෂ්‍ය සංඛ්‍යා කප්පාදු කිරීමට බිට්වේස් හෝ ක්‍රියාකරු භාවිතා කළ හැකි අතර එය ධනාත්මක මෙන්ම සෘණ සඳහාද ක්‍රියා කරයි:

function float2int (value) {
    return value | 0;
}

ප්රතිපල

float2int(3.1) == 3
float2int(-3.1) == -3
float2int(3.9) == 3
float2int(-3.9) == -3

කාර්ය සාධනය සංසන්දනය?

මම කාර්ය සාධනය සංසන්දනය කරන JSPerf පරීක්ෂණයක් නිර්මාණය කර ඇත :

• Math.floor(val)
• val | 0 ^{bitwise හෝ}
• ~~val ^{bitwise නැත}
• parseInt(val)

එය ක්‍රියාත්මක වන්නේ ධනාත්මක සංඛ්‍යා සමඟ පමණි. මෙම අවස්ථාවේදී ඔබ බිට්වේස් මෙහෙයුම් භාවිතා කිරීමටද ආරක්ෂිතයිMath.floor ක්‍රියාකාරීත්වය .

නමුත් ඔබේ කේතය ධනාත්මක මෙන්ම නිෂේධනීය දේ සමඟ වැඩ කිරීමට අවශ්‍ය නම්, බිට්වේස් මෙහෙයුම වේගවත්ම වේ (නැතහොත් කැමතිම ක්‍රමය). මෙම අනෙක් JSPerf පරීක්ෂණය අතිරේක සං sign ා පරීක්ෂාව නිසා එය පැහැදිලිව පෙනෙන තැනට සමාන කරයි ගණිතය දැන් මන්දගාමී වේ හතරෙන් වේ.

සටහන

අදහස් දැක්වීමේදී, BITWISE ක්‍රියාකරුවන් අත්සන් කරන ලද 32bit පූර්ණ සංඛ්‍යා මත ක්‍රියාත්මක වේ, එබැවින් විශාල සංඛ්‍යාවක් පරිවර්තනය වේ, උදාහරණයක් ලෙස:

1234567890  | 0 => 1234567890
12345678901 | 0 => -539222987

සටහන: Math.floor()කප්පාදු කිරීම වෙනුවට ඔබට ආදේශකයක් ලෙස භාවිතා කළ Math.floor(-3.1) = -4නොහැක-3 !!

කප්පාදු කිරීම සඳහා නිවැරදි ආදේශකයක් වනුයේ:

function truncate(value)
{
    if (value < 0) {
        return Math.ceil(value);
    }

    return Math.floor(value);
}

පාවෙන කොටස් කපා හැරීම සඳහා ද්විත්ව බිට්වේස් නොවන ක්‍රියාකරු භාවිතා කළ හැකිය. ඔබ සඳහන් කළ අනෙකුත් මෙහෙයුම් හරහා ලබා ගත හැකිය Math.floor,Math.ceil හා Math.round.

> ~~2.5
2
> ~~(-1.4)
-1

වැඩි විස්තර ජේම්ස් පැඩොල්සි අනුග්‍රහයෙනි.

කප්පාදු කිරීම සඳහා:

var intvalue = Math.floor(value);

වටය සඳහා:

var intvalue = Math.round(value);

වටකුරු කිරීම සඳහා ඔබට parseInt ක්‍රමය භාවිතා කළ හැකිය . 0x (hex) සහ 0 (octal) උපසර්ග විකල්ප නිසා පරිශීලක ආදානය සමඟ ප්‍රවේශම් වන්න.

var intValue = parseInt(floatValue, 10);

බිට් මාරුව 0 කින් බෙදීම 1 ට බෙදීමට සමාන වේ

// >> or >>>
2.0 >> 0; // 2
2.0 >>> 0; // 2

ඔබේ නඩුවේදී, ඔබට අවසානයේ නූලක් අවශ්‍ය වූ විට (කොමාව ඇතුල් කිරීම සඳහා), ඔබට Number.toFixed()ශ්‍රිතය භාවිතා කළ හැකිය , කෙසේ වෙතත්, මෙය වටකුරු කිරීමක් සිදු කරයි.

මෙහි බොහෝ යෝජනා තිබේ. බිට්වේස් හෝ දුරින් සරලම බව පෙනේ. Negative ණ සංඛ්‍යා සමඟ මෙන්ම මොඩියුලෝ ක්‍රියාකරු භාවිතා කරන තවත් කෙටි විසඳුමක් මෙන්න. බිට්වේස් වලට වඩා තේරුම් ගැනීම පහසුය හෝ:

intval = floatval - floatval%1;

මෙම ක්‍රමය '| 0' හෝ '~~' හෝ '>> 0' නිවැරදිව ක්‍රියා නොකරන ඉහළ අගය සංඛ්‍යාවක් සමඟ ද ක්‍රියා කරයි:

> n=4294967295;
> n|0
-1
> ~~n
-1
> n>>0
-1
> n-n%1
4294967295

තවත් එක් ක්‍රමයක් - XOR ක්‍රියාකාරිත්වය භාවිතා කරන්න:

console.log(12.3 ^ 0); // 12
console.log("12.3" ^ 0); // 12
console.log(1.2 + 1.3 ^ 0); // 2
console.log(1.2 + 1.3 * 2 ^ 0); // 3
console.log(-1.2 ^ 0); // -1
console.log(-1.2 + 1 ^ 0); // 0
console.log(-1.2 - 1.3 ^ 0); // -2

බිට්වේස් මෙහෙයුම් වල ප්‍රමුඛතාවය ගණිත මෙහෙයුම් වලට වඩා අඩු නම් එය ප්‍රයෝජනවත් වේ. Https://jsfiddle.net/au51uj3r/ මත උත්සාහ කරන්න

කිරීමට ලුප්ත :

// Math.trunc() is part of the ES6 spec
Math.trunc( 1.5 );  // returns 1
Math.trunc( -1.5 ); // returns -1
// Math.floor( -1.5 ) would return -2, which is probably not what you wanted

කිරීමට වටය :

Math.round( 1.5 );  // 2
Math.round( 1.49 ); // 1
Math.round( -1.6 ); // -2
Math.round( -1.3 ); // -1

Mathජාවාස්ක්‍රිප්ට් හි ස්වදේශීය වස්තුව දෙස බැලුවහොත් , සංඛ්‍යා සහ අගයන් යනාදිය මත ක්‍රියා කිරීම සඳහා ඔබට සම්පූර්ණ කාර්යයන් රාශියක් ලැබේ.

මූලික වශයෙන් ඔබට කිරීමට අවශ්‍ය වන්නේ ජාවාස්ක්‍රිප්ට් හි තරමක් සරල හා ස්වදේශීය ය ...

ඔබට පහත අංකය ඇතැයි සිතන්න:

const myValue = 56.4534931;

දැන් ඔබට එය ළඟම ඇති අංකයට රවුම් කිරීමට අවශ්‍ය නම්, සරලවම කරන්න:

const rounded = Math.floor(myValue);

ඔබට ලැබෙන්නේ:

56

ඔබට එය ළඟම ඇති අංකයට රවුම් කිරීමට අවශ්‍ය නම්, කරන්න:

const roundedUp = Math.ceil(myValue);

ඔබට ලැබෙන්නේ:

57

ද Math.roundහුදෙක් වටයේ එය ඉහළ හෝ පහළ අංකය එක් සමීප flot සංඛ්යාව වන මත රඳා පවතී.

ඔබට ~~පාවෙන අංකය පිටුපස භාවිතා කළ හැකිය , එය පාවෙන මුළු අංකයක් බවට පරිවර්තනය කරයි.

ඔබට එය භාවිතා කළ හැකිය ~~myValue...

මට අවශ්‍ය වන්නේ මුදල්මය වශයෙන් ඔබට අවශ්‍ය වන්නේ වටකුරු කිරීමට මිස කප්පාදු කිරීමට නොවේ. 4.999452 * 100 වටකුරු ඔබට 5 ක් ලබා දෙන බැවින්, සතයක්වත් ඉවතට යාම බොහෝ දුරට අඩු ය.

ඊට ඉහළින්, බැංකුකරුගේ වටය ගැන අමතක නොකරන්න , එය සෘජු වටය ලබා දෙන තරමක් ධනාත්මක නැඹුරුවකට එරෙහි වීමේ මාර්ගයකි - ඔබේ මූල්‍ය යෙදුමට එය අවශ්‍ය විය හැකිය.

ජාවාස්ක්‍රිප්ට් හි ගවුසියානු / බැංකුකරුගේ වටය

ඔබ angularjs භාවිතා කරන්නේ නම් පහත දැක්වෙන පරිදි සරල විසඳුමක් HTML අච්චු බන්ධනයේදී

{{val | number:0}}

එය අගය පූර්ණ සංඛ්‍යාවක් බවට පරිවර්තනය කරයි

docs.angularjs.org/api/ng/filter/number මෙම සබැඳිය හරහා යන්න