Tengo una cadena, 12345.00y me gustaría que volviera 12345.0.

Lo he mirado trim, pero parece que solo está recortando espacios en blanco y sliceque no veo cómo funcionaría esto. ¿Alguna sugerencia?

Puedes usar la subcadena función de :

let str = "12345.00";
str = str.substring(0, str.length - 1);
console.log(str);

Esta es la respuesta aceptada, pero según las conversaciones a continuación, la sintaxis de corte es mucho más clara:

let str = "12345.00";
str = str.slice(0, -1); 
console.log(str);

¡Puedes usar rebanada ! Solo tiene que asegurarse de saber cómo usarlo. Los números positivos son relativos al principio, los números negativos son relativos al final.

js>"12345.00".slice(0,-1)
12345.0

Puede usar el método de subcadena de los objetos de cadena de JavaScript:

s = s.substring(0, s.length - 4)

Elimina incondicionalmente los últimos cuatro caracteres de la cadena s.

Sin embargo, si desea eliminar condicionalmente los últimos cuatro caracteres, solo si son exactamente _bar :

var re = /_bar$/;
s.replace(re, "");

El método más fácil es usar el slicemétodo de la cadena, que permite posiciones negativas (correspondientes a las compensaciones desde el final de la cadena):

const s = "your string";
const withoutLastFourChars = s.slice(0, -4);

Si necesita algo más general para eliminar todo después (e incluir) el último guión bajo, puede hacer lo siguiente (siempre que sse garantice que contenga al menos un guión bajo):

const s = "your_string";
const withoutLastChunk = s.slice(0, s.lastIndexOf("_"));
console.log(withoutLastChunk);

Para un número como su ejemplo, recomendaría hacer esto de nuevo substring:

console.log(parseFloat('12345.00').toFixed(1));

Sin embargo, tenga en cuenta que esto realmente redondeará el número, lo que me imagino que es deseado, pero tal vez no:

console.log(parseFloat('12345.46').toFixed(1));

Usando la función de división de JavaScript:

let string = 'foo_bar';
string = string.slice(0, -4); // Slice off last four characters here
console.log(string);

Esto podría usarse para eliminar '_bar' al final de una cadena, de cualquier longitud.

Una expresión regular es lo que estás buscando:

let str = "foo_bar";
console.log(str.replace(/_bar$/, ""));

Prueba esto:

const myString = "Hello World!";
console.log(myString.slice(0, -1));

Qué tal si:

let myString = "12345.00";
console.log(myString.substring(0, myString.length - 1));

Utilice expresiones regulares:

let aStr = "12345.00";
aStr = aStr.replace(/.$/, '');
console.log(aStr);

1. (. *), captura cualquier personaje varias veces

console.log("a string".match(/(.*).$/)[1]);

2. ., coincide con el último carácter, en este caso

console.log("a string".match(/(.*).$/));

3. $, coincide con el final de la cadena

console.log("a string".match(/(.*).{2}$/)[1]);

Aquí hay una alternativa que no creo haber visto en las otras respuestas, solo por diversión.

var strArr = "hello i'm a string".split("");
strArr.pop();
document.write(strArr.join(""));

No es tan legible o simple como el corte o la subcadena, pero le permite jugar con la cadena usando algunos buenos métodos de matriz, por lo que vale la pena saberlo.

debris = string.split("_") //explode string into array of strings indexed by "_"

debris.pop(); //pop last element off the array (which you didn't want)

result = debris.join("_"); //fuse the remainng items together like the sun

El camino más corto:

str.slice(0, -1); 

Si desea hacer un redondeo genérico de carrozas, en lugar de simplemente recortar el último carácter:

var float1 = 12345.00,
    float2 = 12345.4567,
    float3 = 12345.982;

var MoreMath = {
    /**
     * Rounds a value to the specified number of decimals
     * @param float value The value to be rounded
     * @param int nrDecimals The number of decimals to round value to
     * @return float value rounded to nrDecimals decimals
     */
    round: function (value, nrDecimals) {
        var x = nrDecimals > 0 ? 10 * parseInt(nrDecimals, 10) : 1;
        return Math.round(value * x) / x;
    }
}

MoreMath.round(float1, 1) => 12345.0
MoreMath.round(float2, 1) => 12345.5
MoreMath.round(float3, 1) => 12346.0

EDITAR: Parece que existe una función integrada para esto, como señala Paolo. Esa solución es obviamente mucho más limpia que la mía. Use parseFloat seguido de toFixed

if(str.substring(str.length - 4) == "_bar")
{
    str = str.substring(0, str.length - 4);
}

https://jsfiddle.net/invos/w3zeqv6v/

/programming/34817546/javascript-how-to-delete-last-two-characters-in-a-string

Solo usa recortar si no quieres espacios

"11.01 °C".slice(0,-2).trim()

Actuación

Hoy 2020.05.13 realizo pruebas de las soluciones elegidas en Chrome v81.0, Safari v13.1 y Firefox v76.0 en MacOs High Sierra v10.13.6.

Conclusiones

• el slice(0,-1)(D) es rápida o solución más rápida para cadenas cortas y largas y se recomienda como solución multi-navegador rápido
• Las soluciones basadas en substring(C) y substr(E) son rápidas
• Las soluciones basadas en expresiones regulares (A, B) son lentas / medio rápidas
• las soluciones B, F y G son lentas para cadenas largas
• la solución F es más lenta para cadenas cortas, G es más lenta para cadenas largas

Detalles

Realizo dos pruebas para las soluciones A , B , C , D , E ( ext ), F , G (my)

• para cadena corta de 8 caracteres (de la pregunta OP): puede ejecutarlo AQUÍ
• para una cadena larga de 1M: puede ejecutarla AQUÍ

Las soluciones se presentan en el siguiente fragmento

function A(str) {
  return str.replace(/.$/, '');
}

function B(str) {
  return str.match(/(.*).$/)[1];
}

function C(str) {
  return str.substring(0, str.length - 1);
}

function D(str) {
  return str.slice(0, -1); 
}

function E(str) {
  return str.substr(0, str.length - 1);
}

function F(str) {
  let s= str.split("");
  s.pop();
  return s.join("");
}

function G(str) {
  let s='';
  for(let i=0; i<str.length-1; i++) s+=str[i];
  return s;
 }



// ---------
// TEST
// ---------

let log = (f)=>console.log(`${f.name}: ${f("12345.00")}`);

[A,B,C,D,E,F,G].map(f=>log(f));

This snippet only presents soutions

Aquí hay resultados de ejemplo para Chrome para cadena corta

Tenga en cuenta que String.prototype.{ split, slice, substr, substring }funciona con cadenas codificadas UTF-16

Ninguna de las respuestas anteriores es compatible con Unicode. Las cadenas están codificadas como UTF-16 en la mayoría de los motores JavaScript modernos, pero los puntos de código Unicode más altos requieren pares sustitutos , por lo que los métodos de cadena más antiguos y existentes operan en unidades de código UTF-16, no en puntos de código Unicode.

const string = "ẞ🦊";

console.log(string.slice(0, -1)); // "ẞ\ud83e"
console.log(string.substr(0, string.length - 1)); // "ẞ\ud83e"
console.log(string.substring(0, string.length - 1)); // "ẞ\ud83e"
console.log(string.replace(/.$/, "")); // "ẞ\ud83e"
console.log(string.match(/(.*).$/)[1]); // "ẞ\ud83e"

const utf16Chars = string.split("");

utf16Chars.pop();
console.log(utf16Chars.join("")); // "ẞ\ud83e"

Además, las respuestas de RegExp no coinciden con los saltos de línea al final en su forma actual:

const string = "Hello, world!\n";

console.log(string.replace(/.$/, "").endsWith("\n")); // true
console.log(string.match(/(.*).$/) === null); // true

Use el iterador de cadena para iterar caracteres

El código compatible con Unicode utiliza el iterador de la cadena; Ver Array.fromy ...difundir . string[Symbol.iterator]se puede usar (por ejemplo, en lugar destring ) también.

Consulte también Cómo dividir cadenas Unicode en caracteres en JavaScript .

Ejemplos:

const string = "ẞ🦊";

console.log(Array.from(string).slice(0, -1).join("")); // "ẞ"
console.log([
  ...string
].slice(0, -1).join("")); // "ẞ"

Use las banderas sy uen unRegExp

El indicador dotAllos hace .coincidir los caracteres de salto de línea, el indicador unicodeou habilita ciertas funciones relacionadas con Unicode.

Ejemplos:

const unicodeString = "ẞ🦊",
  lineBreakString = "Hello, world!\n";

console.log(lineBreakString.replace(/.$/s, "").endsWith("\n")); // false
console.log(lineBreakString.match(/(.*).$/s) === null); // false
console.log(unicodeString.replace(/.$/su, "")); // ẞ
console.log(unicodeString.match(/(.*).$/su)[1]); // ẞ

// Now `split` can be made Unicode-aware:

const unicodeCharacterArray = unicodeString.split(/(?:)/su),
  lineBreakCharacterArray = lineBreakString.split(/(?:)/su);

unicodeCharacterArray.pop();
lineBreakCharacterArray.pop();
console.log(unicodeCharacterArray.join("")); // "ẞ"
console.log(lineBreakCharacterArray.join("").endsWith("\n")); // false

Tenga en cuenta que algunos grafemas consisten en más de un punto de código, por ejemplo, 🏳️‍🌈que consiste en la secuencia 🏳(U + 1F3F3), VS16(U + FE0F) , ZWJ(U + 200D) , 🌈(U + 1F308). Aquí, incluso Array.fromdividirá esto en cuatro "personajes". Es posible que coincidan con la propuesta de propiedades de secuencia de la propiedad Unicode .

En los casos en que desee eliminar algo que esté cerca del final de una cadena (en el caso de cadenas de tamaño variable), puede combinar slice () y substr ().

Tenía una cadena con marcado, construida dinámicamente, con una lista de etiquetas de anclaje separadas por comas. La cadena era algo así como:

var str = "<a>text 1,</a><a>text 2,</a><a>text 2.3,</a><a>text abc,</a>";

Para eliminar la última coma, hice lo siguiente:

str = str.slice(0, -5) + str.substr(-4);

Prueba esto:

<script>
    var x="foo_foo_foo_bar";
    for (var i=0; i<=x.length; i++) {
        if (x[i]=="_" && x[i+1]=="b") {
            break;
        }
        else {
            document.write(x[i]);
        }
    }
</script>

También puede probar el ejemplo de trabajo en vivo en http://jsfiddle.net/informativejavascript/F7WTn/87/ .

@Jason S:

¡Puedes usar rebanada! Solo tiene que asegurarse de saber cómo usarlo. Los números positivos son relativos al principio, los números negativos son relativos al final.

js> "12345.00" .slice (0, -1) 12345.0

Lo siento por mi grafomanía, pero la publicación fue etiquetada 'jquery' anteriormente. Por lo tanto, no puede usar slice () dentro de jQuery porque slice () es un método jQuery para operaciones con elementos DOM, no subcadenas ... En otras palabras, la respuesta @Jon Erickson sugiere una solución realmente perfecta.

Sin embargo, su método funcionará con la función jQuery, dentro de Javascript simple. Es necesario decir, debido a la última discusión en los comentarios, que jQuery es una extensión de JS con mucha más frecuencia renovable que su ECMAScript más conocido.

Aquí también existen dos métodos:

como el nuestro:

string.substring(from,to) como plus si 'to' index nulled devuelve el resto de la cadena. entonces: string.substring(from) positivo o negativo ...

y algunos otros - substr () - que proporcionan un rango de subcadena y 'longitud' solo pueden ser positivos: string.substr(start,length)

También algunos mantenedores sugieren que el último método string.substr(start,length)no funciona o funciona con error para MSIE.

Use la subcadena para obtener todo a la izquierda de _bar. Pero primero tienes que obtener el instr de _bar en la cadena:

str.substring(3, 7);

3 es ese comienzo y 7 es la longitud.