JavaScript'te bir kayan nokta numarasını tam sayıya nasıl dönüştürebilirim?

JavaScript'te bir şamandırayı tam sayıya dönüştürmek istiyorum. Aslında, standart dönüşümlerin her ikisini de nasıl yapacağımı bilmek istiyorum: keserek ve yuvarlayarak. Ve verimli bir şekilde, bir dizeye dönüştürme ve ayrıştırma yoluyla değil.

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 );

Matematik nesne başvurusu

Örnekler

// 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

Bitsel VEYA operatör

Bir bitsel veya operatör kayan nokta rakamlarını kısaltmak için kullanılabilir ve pozitifler ve negatifler için çalışır:

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

Sonuçlar

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

Performans karşılaştırması?

Arasında performansı karşılaştıran bir JSPerf testi oluşturdum :

• Math.floor(val)
• val | 0 ^{bitsel VEYA}
• ~~val ^{bitsel DEĞİL}
• parseInt(val)

sadece pozitif sayılarla çalışır. Bu durumda, Math.floorfonksiyonun yanı sıra bitsel işlemleri de kullanabilirsiniz .

Ancak , negatiflerin yanı sıra pozitiflerle çalışmak için kodunuza ihtiyacınız varsa , en hızlı şekilde bitsel işlem (VEYA tercih edilen yöntemdir). Bu diğer JSPerf testi , Math'ın ek işaret kontrolü nedeniyle şimdi dördün en yavaş olduğu oldukça açık olanı karşılaştırıyor .

Not

Yorumlarda belirtildiği gibi, BITWISE operatörleri imzalı 32 bit tamsayılarda çalışır, bu nedenle büyük sayılar dönüştürülür, örnek:

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

Not: Math.floor()Kesmek için yedek olarak kullanamazsınız , çünkü Math.floor(-3.1) = -4değil -3!

Kesme için doğru değiştirme:

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

    return Math.floor(value);
}

Şamandıraları kısaltmak için çift bitsel olmayan bir operatör kullanılabilir. Bahsettiğiniz diğer işlemler mevcut aracılığıyla vardır Math.floor, Math.ceilve Math.round.

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

Daha fazla detay James Padolsey'in izniyle.

Kesmek için:

var intvalue = Math.floor(value);

Tur için:

var intvalue = Math.round(value);

Yuvarlama olmadan parseInt yöntemini kullanabilirsiniz . 0x (onaltılık) ve 0 (sekizli) önek seçenekleri nedeniyle kullanıcı girişine dikkat edin.

var intValue = parseInt(floatValue, 10);

1'e bölünmeye eşdeğer olan 0 ile bit kaydırma

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

Sizin durumunuzda, sonunda bir virgül kullanmak istediğinizde (virgül eklemek için), sadece Number.toFixed()işlevi kullanabilirsiniz , ancak bu yuvarlama gerçekleştirecektir.

Burada birçok öneri var. Bitsel VEYA açık ara en basit gibi görünüyor. Modulo operatörünü kullanarak da negatif sayılarla çalışan başka bir kısa çözüm. Anlamak muhtemelen bitsel VEYA'dan daha kolaydır:

intval = floatval - floatval%1;

Bu yöntem aynı zamanda '| 0' veya '~~' veya '>> 0'ın doğru çalışmadığı yüksek değer sayılarıyla da çalışır:

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

To kesmek :

// 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

To turda :

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

Olası bir yol daha - XOR işlemini kullanın:

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

Bitsel işlemlerin önceliği matematik işlemlerinin önceliğinden daha azdır, yararlıdır. Https://jsfiddle.net/au51uj3r/ adresinde deneyin

MathJavaScript'te yerel nesneye bakarsanız , sayılar ve değerler vb. Üzerinde çalışmak için tüm işlevleri alırsınız ...

Temel olarak JavaScript'te yapmak istediğiniz şey oldukça basit ve yerel ...

Aşağıdaki numaraya sahip olduğunuzu düşünün:

const myValue = 56.4534931;

ve şimdi en yakın sayıya yuvarlamak istiyorsanız, yapmanız yeterli:

const rounded = Math.floor(myValue);

ve elde edersiniz:

56

En yakın sayıya yuvarlamak istiyorsanız, yapmanız gerekenler:

const roundedUp = Math.ceil(myValue);

ve elde edersiniz:

57

Ayrıca Math.round, daha yüksek veya daha düşük sayıya yuvarlamak, hangisinin flot numarasına daha yakın olduğuna bağlıdır.

Ayrıca ~~, bir float'ı tam sayıya dönüştürecek olan float numarasının arkasında da kullanabilirsiniz .

Gibi kullanabilirsiniz ~~myValue...

Sadece parasal olarak kırpmak istediğinizi belirtmek istiyorum. 4.999452 * 100 yuvarlatılmış size 5, daha temsili bir cevap vereceğinden, bir kuruş tarafından kapalı olmak daha az olasıdır.

Bunun da ötesinde , bankacının yuvarlamasını unutmayın , bu da düz yuvarlamanın verdiği hafif pozitif önyargılara karşı koymanın bir yoludur - finansal uygulamanız bunu gerektirebilir.

JavaScript'te Gauss / banker yuvarlaması

Angularjs kullanıyorsanız, HTML Şablon Bağlamasında aşağıdaki gibi basit bir çözüm

{{val | number:0}}

val tamsayıya dönüşür

bu bağlantıyı kullanarak docs.angularjs.org/api/ng/filter/number