Ho una stringa 12345.00e vorrei che tornasse 12345.0.

Ho visto trim, ma sembra che stia solo tagliando gli spazi bianchi e sliceche non vedo come funzionerebbe. Eventuali suggerimenti?

È possibile utilizzare la funzione di sottostringa :

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

Questa è la risposta accettata, ma secondo le conversazioni di seguito, la sintassi della sezione è molto più chiara:

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

Puoi usare slice ! Devi solo assicurarti di sapere come usarlo. I numeri positivi sono relativi all'inizio, i numeri negativi sono relativi alla fine.

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

È possibile utilizzare il metodo di sottostringa degli oggetti stringa JavaScript:

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

Rimuove incondizionatamente gli ultimi quattro caratteri dalla stringa s.

Tuttavia, se si desidera rimuovere in modo condizionale gli ultimi quattro caratteri, solo se sono esattamente _bar :

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

Il metodo più semplice è utilizzare il slicemetodo della stringa, che consente posizioni negative (corrispondenti agli offset dalla fine della stringa):

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

Se hai bisogno di qualcosa di più generale per rimuovere tutto dopo (e incluso) l'ultimo carattere di sottolineatura, puoi fare quanto segue (purché ssia garantito che contenga almeno un carattere di sottolineatura):

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

Per un numero come il tuo esempio, consiglierei di fare questo sopra substring:

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

Si noti che questo in realtà arrotonderà il numero, tuttavia, che immagino sia desiderato ma forse no:

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

Utilizzando la funzione slice di JavaScript:

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

Questo potrebbe essere usato per rimuovere '_bar' alla fine di una stringa, di qualsiasi lunghezza.

Un'espressione regolare è ciò che stai cercando:

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

Prova questo:

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

Che ne dite di:

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

Usa regex:

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

1. (. *), cattura ogni personaggio più volte

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

2. ., corrisponde all'ultimo carattere, in questo caso

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

3. $, corrisponde alla fine della stringa

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

Ecco un'alternativa che non credo di aver visto nelle altre risposte, solo per divertimento.

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

Non leggibile o semplice come lo slice o la sottostringa ma ti permette di giocare con la stringa usando alcuni metodi array utili, quindi vale la pena saperlo.

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

Il modo più breve:

str.slice(0, -1); 

Se vuoi fare un arrotondamento generico di float, invece di tagliare solo l'ultimo carattere:

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

EDIT: Sembra che esista una funzione integrata per questo, come sottolinea Paolo. Questa soluzione è ovviamente molto più pulita della mia. Usa parseFloat seguito da 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

Usa solo trim se non vuoi spazi

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

Prestazione

Oggi 2020.05.13 eseguo test delle soluzioni scelte su Chrome v81.0, Safari v13.1 e Firefox v76.0 su MacOs High Sierra v10.13.6.

conclusioni

• la slice(0,-1)(D) è la soluzione più veloce o più veloce per stringhe corte e lunghe ed è consigliata come soluzione cross-browser veloce
• le soluzioni basate su substring(C) ed substr(E) sono veloci
• le soluzioni basate su espressioni regolari (A, B) sono lente / medio veloci
• le soluzioni B, F e G sono lente per le corde lunghe
• la soluzione F è la più lenta per le stringhe corte, la G è la più lenta per le stringhe lunghe

Dettagli

Eseguo due test per le soluzioni A , B , C , D , E ( ext ), F , G (my)

• per una stringa breve da 8 caratteri (dalla domanda OP) - puoi eseguirla QUI
• per 1 m di stringa lunga: puoi eseguirlo QUI

Le soluzioni sono presentate nello snippet seguente

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

Ecco alcuni risultati di esempio per Chrome per stringa corta

Tenere presente che String.prototype.{ split, slice, substr, substring }operano su stringhe codificate UTF-16

Nessuna delle risposte precedenti è compatibile con Unicode. Le stringhe sono codificate come UTF-16 nella maggior parte dei moderni motori JavaScript, ma i punti di codice Unicode più elevati richiedono coppie surrogate , quindi i metodi di stringa preesistenti più vecchi operano su unità di codice UTF-16, non su punti di codice 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"

Inoltre, le risposte RegExp non corrispondono alle interruzioni di riga alla fine nella loro forma corrente:

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

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

Utilizzare l'iteratore di stringhe per iterare i caratteri

Il codice compatibile con Unicode utilizza l'iteratore della stringa; vedere Array.frome ...diffondere . string[Symbol.iterator]può essere utilizzato (ad es. anzichéstring ).

Vedi anche Come dividere la stringa Unicode in caratteri in JavaScript .

Esempi:

const string = "ẞ🦊";

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

Utilizzare i flag se usu aRegExp

Il flag dotAllos crea .caratteri di interruzione di riga di corrispondenza, il flag unicodeou abilita alcune funzionalità relative a Unicode.

Esempi:

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

Si noti che alcuni grafemi sono costituiti da più di un punto di codice, ad es. 🏳️‍🌈Che consiste nella sequenza 🏳(U + 1F3F3), VS16(U + FE0F) , ZWJ(U + 200D) , 🌈(U + 1F308). Qui, anche Array.fromdividerà questo in quattro "personaggi". La corrispondenza di questi è possibile con la proprietà Unicode sfugge alla proposta delle proprietà della sequenza .

Nei casi in cui si desidera rimuovere qualcosa che si trova vicino alla fine di una stringa (nel caso di stringhe di dimensioni variabili) è possibile combinare slice () e substr ().

Avevo una stringa con markup, costruita dinamicamente, con un elenco di tag di ancoraggio separati da virgola. La stringa era qualcosa del tipo:

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

Per rimuovere l'ultima virgola ho fatto quanto segue:

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

Prova questo:

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

Puoi anche provare l'esempio di lavoro dal vivo su http://jsfiddle.net/informativejavascript/F7WTn/87/ .

@Jason S:

Puoi usare slice! Devi solo assicurarti di sapere come usarlo. I numeri positivi sono relativi all'inizio, i numeri negativi sono relativi alla fine.

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

Ci scusiamo per la mia grafica ma il post è stato taggato "jquery" in precedenza. Quindi, non puoi usare slice () all'interno di jQuery perché slice () è il metodo jQuery per operazioni con elementi DOM, non sottostringhe ... In altre parole, la risposta di @Jon Erickson suggerisce una soluzione davvero perfetta.

Tuttavia, il tuo metodo funzionerà con la funzione jQuery, all'interno di Javascript semplice. Devo dire a causa dell'ultima discussione nei commenti, che jQuery è molto più spesso un'estensione rinnovabile di JS rispetto al suo genitore ECMAScript più noto.

Qui esistono anche due metodi:

come il nostro:

string.substring(from,to) come plus se l'indice 'to' annullato restituisce il resto della stringa. quindi: string.substring(from) positivo o negativo ...

e alcuni altri - substr () - che forniscono un intervallo di sottostringa e 'lunghezza' possono essere solo positivi: string.substr(start,length)

Inoltre alcuni manutentori suggeriscono che l'ultimo metodo string.substr(start,length)non funziona o funziona con errori per MSIE.

Usa la sottostringa per ottenere tutto alla sinistra di _bar. Ma prima devi ottenere l'istruzione di _bar nella stringa:

str.substring(3, 7);

3 è quell'inizio e 7 è la lunghezza.