Отримайте десяткову частину числа за допомогою JavaScript


248

У мене є плаваючі числа, як 3.2і 1.6.

Мені потрібно відокремити число на цілу і десяткову частину. Наприклад, значення 3.2поділиться на два числа, тобто 3і0.2

Отримати частину цілого числа просто:

n = Math.floor(n);

Але у мене виникають проблеми з отриманням десяткової частини. Я спробував це:

remainer = n % 2; //obtem a parte decimal do rating

Але це не завжди працює правильно.

Попередній код має такий вихід:

n = 3.1 => remainer = 1.1

Чого я тут пропускаю?


1
Зауважте, що n = Math.floor(n);лише повертаєте бажаний результат (ціла частина) для негативних чисел
цемер

Simplfy use % 1not% 2
masterxilo

Відповіді:


366

Використовуйте 1, не 2.

js> 2.3 % 1
0.2999999999999998

60
У світі, де 0,2999999999999998 дорівнює 0,3, це може бути прийнятним. Для мене це не ... Отже, для вирішення цього завдання я б утримався від використання Math.*чи %операцій.
Marcel Stör

62
Щоб уникнути зазначених проблем із округленням плаваючої точки, використання toFixedможе допомогти в деяких ситуаціях, наприклад, (2.3 % 1).toFixed(4)== "0.3000".
Брайан М. Хант

12
(2.3 % 1).toFixed(4).substring(2)= "3000"якщо вам це потрібно без0.
Simon_Weaver

14
У світі, де число 2.3виникло, а немає 2чи 3, це число 0.2999999999999998цілком прийнятно, незважаючи на те, як це образливо виглядає людським очам.
Гершом

1
@GershomMaes Існують різні обставини, коли це число неприйнятне.
Адам

92
var decimal = n - Math.floor(n)

Хоча це не працює для мінусових чисел, тому нам, можливо, доведеться це робити

n = Math.abs(n); // Change to positive
var decimal = n - Math.floor(n)

Якщо у вас вже є ціла частина, не потрібно дзвонити Math.floor()знову - просто використовуйте цілу частину, яку ви обчислили.
tvanfosson

4
var n = 3.2, integr = Math.floor(n), decimal = n - integr;використовуйте Math.floor () лише один раз. integr = 3; decimal = 0.20000000000000018;
Нурлан

2
Для того , щоб працювати з негативним числом, просто поміняти місцями Math.floorз Math.trunc.
Ігор Сільва

це було повернення неточного числа, як я очікував, що отримаю 0,80 від 100,80, а не 0,79999 ... Я вирішив це, додавши decimal.toFixed (2)
Луїс Фебро

77

Ви можете перетворити на рядок, правда?

n = (n + "").split(".");

17
Це добре працює скрізь, окрім континентальної Європи, де десяткові знаки є комою. Якщо ви плануєте використовувати це, не забудьте врахувати це, якщо ви є багатонаціональною та цільовою Європою, оскільки це рішення не зробить для них великої роботи.
cdmdotnet

8
Я з континентальної Європи з французьким Firefox, і це працює. Зазвичай ми використовуємо косу як десятковий роздільник у Франції. Причина в тому, що в JavaScript немає культури, яка бере участь у перетворенні числа в рядок, хоча я б вважав за краще використовувати n.toString()замість того, n + ""що він є більш читабельним.
Габріель Hautclocq

2
Якщо швидкість критична, то n + ""справді краще (див. Jsperf.com/number-vs-number-tostring-vs-string-number )
Габріель Hautclocq

@cdmdotnet JS використовує .як десятковий роздільник, тож вам добре скрізь, якщо тип вхідної змінної є плаваючим. Ви повинні вирішити це питання лише в тому випадку, якщо ваше введення є рядковим. Маю також зазначити, що ця відповідь повертає рядок у масив. Більш повне рішенняparseFloat('0.' + (n + '').split('.')[1])
totymedli

@cdmdotnet місце незалежне рішення тут: stackoverflow.com/a/59469716/1742529
user1742529

32

Як 0,2999999999999998 є прийнятною відповіддю? Якби я був запитувачем, я хотів би відповісти .3. Ми маємо помилкову точність, і мої експерименти з підлогою,% та ін вказують на те, що Javascript любить помилкову точність цих операцій. Тому я думаю, що відповіді, які використовують перетворення в рядок, знаходяться на правильному шляху.

Я б це зробив:

var decPart = (n+"").split(".")[1];

Зокрема, я використовував 100233.1 і хотів відповіді ".1".


6
Я, як правило, згоден, але ви не можете розраховувати на "." регулярний вираз як десятковий роздільник є символом i18n .
Marcel Stör

1
@jomofrodo Насправді, деякі можуть захотіти значення без округлення. Я не пригадую, щоб ОП просили округлити значення, просто розділили значення.
VVV

1
@VVV так, деякі можуть захотіти значення не округлого. Але те, що ви можете захотіти точності до 9 знаків після коми, не означає, що ваші вхідні дані насправді це підтримують. Саме тому його називають "хибною точністю". Якщо ваш внесок становить 3,1, найбільш точна у вашій відповіді може бути десята частина, тобто .1. Якщо ви відповідаєте .09, це означає, що ви насправді обчислили / виміряли до 100-точної точності, коли насправді оригінальний вхід був точним лише до 10-ї точності.
jomofrodo

1
@ MarcelStör, з яким можна легко обробити: var decPart = (n.toLocaleString ("en")). Split (".") [1];
Джем

1
.toString()не вважає i18n. Десятковий роздільник завжди буде . відповідно до MDN та специфікації ECMA
Andrewmat

18

Ось як я це роблю, і, на мою думку, це найпростіший спосіб зробити це:

var x = 3.2;
int_part = Math.trunc(x); // returns 3
float_part = Number((x-int_part).toFixed(2)); // return 0.2

15

Простий спосіб зробити це:

var x = 3.2;
var decimals = x - Math.floor(x);
console.log(decimals); //Returns 0.20000000000000018

На жаль, це не повертає точне значення. Однак це легко виправити:

var x = 3.2;
var decimals = x - Math.floor(x);
console.log(decimals.toFixed(1)); //Returns 0.2

Ви можете використовувати це, якщо ви не знаєте кількості знаків після коми:

var x = 3.2;
var decimals = x - Math.floor(x);

var decimalPlaces = x.toString().split('.')[1].length;
decimals = decimals.toFixed(decimalPlaces);

console.log(decimals); //Returns 0.2


9

Мовний незалежний шлях:

var a = 3.2;
var fract = a * 10 % 10 /10; //0.2
var integr = a - fract; //3

зауважте, що воно виправляється лише для чисел з однією фрактиональною довжиною)


3
Чи можете ви пояснити, чому ви вважаєте, що це мова незалежна? Це JavaScript.
hotzst

4
@hotzst, немає функції, визначеної для мови
Нурлан

1
Мова незалежна, тому що це просто чиста математика. Практичне рішення. З бажаною довжиною фракції:var factor = Math.pow(10, desiredFractionLength); var fract = a * factor % factor / factor;
муратгозель

6

Ви можете використовувати parseInt()функцію, щоб отримати цілу частину, ніж використовувати її для вилучення десяткової частини

var myNumber = 3.2;
var integerPart = parseInt(myNumber);
var decimalPart = myNumber - integerPart;

Або ви можете використовувати регулярний вираз, наприклад:

splitFloat = function(n){
   const regex = /(\d*)[.,]{1}(\d*)/;
   var m;

   if ((m = regex.exec(n.toString())) !== null) {
       return {
          integer:parseInt(m[1]),
          decimal:parseFloat(`0.${m[2]}`)
       }
   }
}

decimalPart наближається 0.20000000000000018... це справді стає важко, тому що 0.2 < 0.20000000000000018повертає справжнє .. 3.2 повинно повернути 0,2: P, зробивши так багато нерівностей та використовуючи .toFixed(2)рядок повернення: P
Himanshu Bansal

@HimanshuBansal - це проблема JavaScript (до цього питання . Ви можете використовувати другий метад, що я запропонував.
Шекі

Ну у мене є Ліл »біт інше постановка задачі ... Цікаве використовував обидва способів ур: P , щоб вирішити .. ^^
Himanshu Bansal

@HimanshuBansal рада, що мій пост допоміг вирішити вашу проблему!
Шекі

5

Наведені нижче дії незалежно від регіональних параметрів десяткового роздільника ... за умови, що для роздільника використовується лише один символ.

var n = 2015.15;
var integer = Math.floor(n).toString();
var strungNumber = n.toString();
if (integer.length === strungNumber.length)
  return "0";
return strungNumber.substring(integer.length + 1);

Це не дуже, але точно.


Це, звичайно, рядок, тож ви можете спочатку проаналізувати parseInt (), якщо хочете його як число. Вам не потрібно розбирати Floloat () ... якщо тільки чогось тут мені не вистачає з базою 8, а не з базовими 10 номерами ... щось, що я смутно пам'ятаю з років тому
cdmdotnet

5

Якщо точність має значення і вам потрібні послідовні результати, ось декілька пропозицій, які повернуть десяткову частину будь-якого числа у вигляді рядка, включаючи провідне "0.". Якщо вам це потрібно як поплавок, просто додайте var f = parseFloat( result )в кінці.

Якщо десяткова частина дорівнює нулю, "0,0" повернеться. Нульові, NaN та невизначені числа не перевіряються.

1. String.split

var nstring = (n + ""),
    narray  = nstring.split("."),
    result  = "0." + ( narray.length > 1 ? narray[1] : "0" );

2. String.substring, String.indexOf

var nstring = (n + ""),
    nindex  = nstring.indexOf("."),
    result  = "0." + (nindex > -1 ? nstring.substring(nindex + 1) : "0");

3. Math.floor, Number.toFixed, String.indexOf

var nstring = (n + ""),
    nindex  = nstring.indexOf("."),
    result  = ( nindex > -1 ? (n - Math.floor(n)).toFixed(nstring.length - nindex - 1) : "0.0");

4. Math.floor, Number.toFixed, String.split

var nstring = (n + ""),
    narray  = nstring.split("."),
    result  = (narray.length > 1 ? (n - Math.floor(n)).toFixed(narray[1].length) : "0.0");

Ось посилання jsPerf: https://jsperf.com/decpart-of-number/

Ми можемо бачити, що пропозиція №2 є найшвидшою.


не використовуйте жодне з них. вони порушаться, як тільки переведення числа перейде на інженерний. вони також не чутливі до локальної точки зору.
Спонгмен

Чи можете ви пояснити "перемикачі чисельної передачі номерів на техніку"? Крім того, локалізація не є актуальною, оскільки ми просто хочемо десяткову частину числа, а не локалізований рядок, що представляє число.
Габріель Хацлокк

4

Ви можете перетворити його в рядок і використати replaceметод для заміни цілої частини на нуль, а потім перетворити результат назад у число:

var number = 123.123812,
    decimals = +number.toString().replace(/^[^\.]+/,'0');

Хіба це рішення не працює в континентальній Європі, де комою є десятковий роздільник ??
Престон

@preston Ви можете замінити крапку в регулярному виразі будь-яким іншим символом роздільника, який вам подобається (наприклад /^[^,]/), але потім слід залишити результат у вигляді рядка (видалити +оператор), щоб уникнути NaNрезультатів.
gion_13

4

Залежно від використання ви надасте згодом, але це просте рішення також може вам допомогти.

Я не кажу, що це добре рішення, але для деяких конкретних випадків це працює

var a = 10.2
var c = a.toString().split(".")
console.log(c[1] == 2) //True
console.log(c[1] === 2)  //False

Але це займе більше часу, ніж запропоновано рішення @Brian M. Hunt

(2.3 % 1).toFixed(4)

1
Це добре працює скрізь, окрім континентальної Європи, де кома є десятковим роздільником. Якщо ви плануєте використовувати це, не забудьте врахувати це, якщо ви є багатонаціональною та цільовою Європою, оскільки це рішення не зробить для них великої роботи.
cdmdotnet

1

У мене був випадок, коли я знав, що всі числа, про які йдеться, матимуть лише одне десяткове число, і хотів отримати десяткову частину як ціле число, тому я в кінцевому підсумку використовував такий підхід:

var number = 3.1,
    decimalAsInt = Math.round((number - parseInt(number)) * 10); // returns 1

Це добре працює також з цілими числами, повертаючи 0 у цих випадках.


1

Я використовую:

var n = -556.123444444;
var str = n.toString();
var decimalOnly = 0;

if( str.indexOf('.') != -1 ){ //check if has decimal
    var decimalOnly = parseFloat(Math.abs(n).toString().split('.')[1]);
}

Вхід: -556.123444444

Результат: 123444444


1

Математичні функції швидші, але завжди повертають не первісні очікувані значення. Найпростіший спосіб, який я знайшов

(3.2+'').replace(/^[-\d]+\./, '')

1

Хороший варіант - перетворити число в рядок, а потім розділити його.

// Decimal number
let number = 3.2;

// Convert it into a string
let string = number.toString();

// Split the dot
let array = string.split('.');

// Get both numbers
// The '+' sign transforms the string into a number again
let firstNumber  = +array[0]; // 3
let secondNumber = +array[1]; // 2

В одному рядку коду

let [firstNumber, secondNumber] = [+number.toString().split('.')[0], +number.toString().split('.')[1]];

0

Переглянувши декілька з них, я зараз використовую ...

var rtnValue = Number(7.23);
var tempDec = ((rtnValue / 1) - Math.floor(rtnValue)).toFixed(2);


0

Хоча я дуже пізно відповів на це, будь ласка, подивіться на код.

let floatValue = 3.267848;
let decimalDigits = floatValue.toString().split('.')[1];
let decimalPlaces = decimalDigits.length;
let decimalDivider = Math.pow(10, decimalPlaces);
let fractionValue = decimalDigits/decimalDivider;
let integerValue = floatValue - fractionValue;

console.log("Float value: "+floatValue);
console.log("Integer value: "+integerValue);
console.log("Fraction value: "+fractionValue)

0

Формат десяткових знаків і цифр з плаваючою комою може залежати від країни ( .,), тому самостійним рішенням, яке зберегло частину з плаваючою комою, є:

getFloatDecimalPortion = function(x) {
    x = Math.abs(parseFloat(x));
    let n = parseInt(x);
    return Number((x - n).toFixed(Math.abs((""+x).length - (""+n).length - 1)));
}

- це інтернаціоналізоване рішення, а не залежне від місця розташування:

getFloatDecimalPortion = x => parseFloat("0." + ((x + "").split(".")[1]));

Опис розчину крок за кроком:

  1. parseFloat() для гарантування введення корекції
  2. Math.abs() для уникнення проблем із від’ємними числами
  3. n = parseInt(x) для отримання десяткової частини
  4. x - n для підрахунку десяткової частини
  5. Зараз у нас число з нульовою десятковою частиною, але JavaScript може дати нам додаткові цифри з плаваючою частиною, які ми не хочемо
  6. Отже, обмежте додаткові цифри, зателефонувавши toFixed()з підрахунком цифр у плаваючу частину вихідного числа з поплавком x. Кількість обчислюється як різниця між довжиною вихідного числа xта кількістю nв їх рядковому поданні.

-1

Скористайтеся цим:

function isNatural(n) {
    n = +n
    if (isNaN(n)) return 'NaN';
    return (n >= 0.0) && (Math.floor(n) === n) && n !== Infinity;
  }

Math.frac = function frac(x, m) {
    x = +x
    if (isNaN(x)) return NaN;
    if (isNatural(x) === true) return 0;
    m = +m || 1

      if (isNatural(x) === false && m === 1){
        var a = x.toString()
        var b = a.split('.')[1]
        var c = '0.' + b
        var d = +c
        return d;
      }

      if (isNatural(x) === false && m === 2){
        var a = x.toString()
        var b = a.split('.')[1]
        var c = +b
        return c;
      }

      if (isNatural(x) === false && m === 3){
        var a = x.toString()
        var b = a.split('.')[1]
        var c = '0.' + b
        var d = +c * 100
        return d;
      }    
  }

Тут Math.fracфункція має 3 режими:

Math.frac(11.635) //0.635
Math.frac(11.635, 1) //0.635 - default mode is 1
Math.frac(11.635, 2) //635
Math.frac(11.635, 3) //63,5 (%)

Це просто :)


-9
float a=3.2;
int b=(int)a; // you'll get output b=3 here;
int c=(int)a-b; // you'll get c=.2 value here

4
це не схоже на JavaScript для мене!
Ch'marr

1
Це не сценарій Java
Amrut

У JS воно має бути таким: var a = 3,2; var b = parseInt (a, 10); var c = a - b;
Ju-v
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.