¿Cómo analizar flotante con dos decimales en javascript?

tengo el siguiente código. Me gustaría tenerlo de modo que si price_result sea igual a un número entero, digamos 10, entonces me gustaría agregar dos lugares decimales. Entonces 10 sería 10.00. O si es igual a 10.6 sería 10.60. No estoy seguro de cómo hacer esto.

price_result = parseFloat(test_var.split('$')[1].slice(0,-1));

Puede usar toFixed () para hacer eso

var twoPlacedFloat = parseFloat(yourString).toFixed(2)

Cuando lo usa toFixed, siempre devuelve el valor como una cadena. Esto a veces complica el código. Para evitar eso, puede hacer un método alternativo para Number.

Number.prototype.round = function(p) {
  p = p || 10;
  return parseFloat( this.toFixed(p) );
};

y use:

var n = 22 / 7; // 3.142857142857143
n.round(3); // 3.143

o simplemente:

(22/7).round(3); // 3.143

Si necesita rendimiento (como en los juegos):

Math.round(number * 100) / 100

Es aproximadamente 100 veces más rápido que parseFloat (number.toFixed (2))

http://jsperf.com/parsefloat-tofixed-vs-math-round

Para devolver un número, agregue otra capa de paréntesis. Lo mantiene limpio

var twoPlacedFloat = parseFloat((10.02745).toFixed(2));

Si su objetivo es analizar, y su entrada puede ser literal, entonces esperaría un floaty toFixedno proporcionará eso, así que aquí hay dos funciones simples para proporcionar esto:

function parseFloat2Decimals(value) {
    return parseFloat(parseFloat(value).toFixed(2));
}

function parseFloat2Decimals(value,decimalPlaces) {
    return parseFloat(parseFloat(value).toFixed(decimalPlaces));
}

techo de lodash es probablemente el mejor

_.ceil("315.9250488",2) 
_.ceil(315.9250488,2) 
_.ceil(undefined,2)
_.ceil(null,2)
_.ceil("",2)

funcionará también con un número y es seguro

@sd Respuesta corta: No hay forma en JS de tener un valor de tipo de datos de Número con ceros finales después de un decimal.

Respuesta larga: es propiedad toFixedo toPrecisionfunción de JavaScript, para devolver la cadena. La razón de esto es que el tipo de datos Number no puede tener un valor como a = 2.00, siempre eliminará los ceros finales después del decimal. Esta es la propiedad incorporada de Number Datatype. Entonces, para lograr lo anterior en JS, tenemos 2 opciones

1. Utilice los datos como una cadena o
2. Acuerde tener un valor truncado con el caso '0' al final ex 2.50 -> 2.5.

Utilice la siguiente función si no desea redondear.

function ConvertToDecimal(num) {
    num = num.toString(); //If it's not already a String
    num = num.slice(0, (num.indexOf(".")) + 3); //With 3 exposing the hundredths place
   alert('M : ' +  Number(num)); //If you need it back as a Number    
}

Por lo que vale: un número decimal, es un número decimal, o lo redondea a otro valor o no. Internamente, se aproximará a una fracción decimal de acuerdo con la regla de la artética y el manejo de coma flotante. Permanece un número decimal (coma flotante, en JS un doble) internamente, sin importar cuántos dígitos desee mostrar.

Para presentarlo para su visualización, puede elegir la precisión de la visualización según lo que desee mediante la conversión de cadenas. La presentación es un problema de visualización, no una cuestión de almacenamiento.

Puede usar .toFixed () para el valor flotante de 2 dígitos

Exampale

let newValue = parseFloat(9.990000).toFixed(2)

//output
9.99

Pruebe esto (vea los comentarios en el código):

function fixInteger(el) {
    // this is element's value selector, you should use your own
    value = $(el).val();
    if (value == '') {
        value = 0;
    }
    newValue = parseInt(value);
    // if new value is Nan (when input is a string with no integers in it)
    if (isNaN(newValue)) {
        value = 0;
        newValue = parseInt(value);
    }
    // apply new value to element
    $(el).val(newValue);
}

function fixPrice(el) {
    // this is element's value selector, you should use your own
    value = $(el).val();
    if (value == '') {
        value = 0;
    }
    newValue = parseFloat(value.replace(',', '.')).toFixed(2);
    // if new value is Nan (when input is a string with no integers in it)
    if (isNaN(newValue)) {
        value = 0;
        newValue = parseFloat(value).toFixed(2);
    }
    // apply new value to element
    $(el).val(newValue);
}

JavaScript simple, cadena para flotar:

var it_price = chief_double($("#ContentPlaceHolder1_txt_it_price").val());

function chief_double(num){
    var n = parseFloat(num);
    if (isNaN(n)) {
        return "0";
    }
    else {
        return parseFloat(num);
    }
}

La solución que funciona para mí es la siguiente

parseFloat(value)

Solution for FormArray controllers 

Inicialice FormArray form Builder

  formInitilize() {
    this.Form = this._formBuilder.group({
      formArray: this._formBuilder.array([this.createForm()])
    });
  }

Crear formulario

  createForm() {
    return (this.Form = this._formBuilder.group({
      convertodecimal: ['']
    }));
  }

Establecer valores de formulario en el controlador de formulario

  setFormvalues() {
    this.Form.setControl('formArray', this._formBuilder.array([]));
    const control = <FormArray>this.resourceBalanceForm.controls['formArray'];
    this.ListArrayValues.forEach((x) => {
      control.push(this.buildForm(x));
    });
  }

  private buildForm(x): FormGroup {
    const bindvalues= this._formBuilder.group({
      convertodecimal: x.ArrayCollection1? parseFloat(x.ArrayCollection1[0].name).toFixed(2) : '' // Option for array collection
// convertodecimal: x.number.toFixed(2)    --- option for two decimal value 
    });

    return bindvalues;
  }

Tengo otra solución.

Puedes usar round()para hacer eso en su lugartoFixed()

var twoPlacedFloat = parseFloat(yourString).round(2)