Ich habe eine Zeichenfolge 12345.00und möchte, dass sie zurückkehrt 12345.0.

Ich habe es angeschaut trim, aber es sieht so aus, als würde es nur Leerzeichen abschneiden und sliceich sehe nicht, wie das funktionieren würde. Irgendwelche Vorschläge?

Sie können die Teilzeichenfolgenfunktion verwenden:

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

Dies ist die akzeptierte Antwort, aber gemäß den folgenden Gesprächen ist die Slice- Syntax viel klarer:

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

Sie können Slice verwenden ! Sie müssen nur sicherstellen, dass Sie wissen, wie man es benutzt. Positive #s sind relativ zum Anfang, negative Zahlen sind relativ zum Ende.

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

Sie können die Teilzeichenfolgenmethode von JavaScript-Zeichenfolgenobjekten verwenden:

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

Es entfernt bedingungslos die letzten vier Zeichen aus der Zeichenfolge s .

Wenn Sie jedoch die letzten vier Zeichen bedingt entfernen möchten , nur wenn sie genau sind _bar :

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

Die einfachste Methode ist die Verwendung der sliceMethode der Zeichenfolge, die negative Positionen zulässt (entsprechend Offsets vom Ende der Zeichenfolge):

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

Wenn Sie etwas Allgemeineres benötigen, um alles nach dem letzten Unterstrich zu entfernen (und einzuschließen), können Sie Folgendes tun (sofern sgarantiert mindestens ein Unterstrich enthalten ist):

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

Für eine Zahl wie Ihr Beispiel würde ich empfehlen, dies noch einmal zu tun substring:

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

Beachten Sie jedoch, dass dies tatsächlich die Zahl rundet, was meiner Meinung nach erwünscht ist, aber vielleicht nicht:

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

Verwenden der Slice-Funktion von JavaScript:

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

Dies kann verwendet werden, um '_bar' am Ende einer Zeichenfolge beliebiger Länge zu entfernen.

Ein regulärer Ausdruck ist das, wonach Sie suchen:

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

Versuche dies:

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

Wie wäre es mit:

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

Verwenden Sie Regex:

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

1. (. *) erfasst jedes Zeichen mehrmals

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

2. ., stimmt in diesem Fall mit dem letzten Zeichen überein

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

3. $, entspricht dem Ende der Zeichenfolge

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

Hier ist eine Alternative, die ich nicht in den anderen Antworten gesehen habe, nur zum Spaß.

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

Nicht so lesbar oder einfach wie Slice oder Teilstring, aber Sie können mit der Saite mit einigen netten Array-Methoden spielen, die es wert sind, kennengelernt zu werden.

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

Der kürzeste Weg:

str.slice(0, -1); 

Wenn Sie generische Floats runden möchten, anstatt nur das letzte Zeichen zu kürzen:

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: Es scheint, dass es dafür eine eingebaute Funktion gibt, wie Paolo betont. Diese Lösung ist offensichtlich viel sauberer als meine. Verwenden Sie parseFloat gefolgt von 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

Verwenden Sie einfach trim, wenn Sie keine Leerzeichen möchten

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

Performance

Heute 2020.05.13 teste ich ausgewählte Lösungen unter Chrome v81.0, Safari v13.1 und Firefox v76.0 unter MacOs High Sierra v10.13.6.

Schlussfolgerungen

• die slice(0,-1)(D) sind schnell oder schnellste Lösung für kurze und lange Ketten , und es wird so schnell Cross-Browser - Lösung empfohlen
• Lösungen basierend auf substring(C) und substr(E) sind schnell
• Lösungen, die auf regulären Ausdrücken (A, B) basieren, sind langsam / mittelschnell
• Die Lösungen B, F und G sind für lange Saiten langsam
• Lösung F ist für kurze Saiten am langsamsten, G für lange Saiten am langsamsten

Einzelheiten

Ich führe zwei Tests für die Lösungen A , B , C , D , E ( ext ), F , G (my) durch.

• für 8-stellige kurze Zeichenfolge (aus der OP-Frage) - Sie können sie HIER ausführen
• für 1M lange Zeichenfolge - Sie können es HIER ausführen

Die Lösungen sind im folgenden Ausschnitt dargestellt

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

Hier sind Beispielergebnisse für Chrome für kurze Zeichenfolgen

Beachten Sie, dass String.prototype.{ split, slice, substr, substring }UTF-16-codierte Zeichenfolgen verwendet werden

Keine der vorherigen Antworten ist Unicode-fähig. Zeichenfolgen werden in den meisten modernen JavaScript-Engines als UTF-16 codiert, höhere Unicode-Codepunkte erfordern jedoch Ersatzpaare. Daher arbeiten ältere, bereits vorhandene Zeichenfolgenmethoden mit UTF-16-Codeeinheiten und nicht mit Unicode-Codepunkten.

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"

Außerdem stimmen die RegExp-Antworten nicht mit den Zeilenumbrüchen am Ende in ihrer aktuellen Form überein:

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

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

Verwenden Sie den String-Iterator, um Zeichen zu iterieren

Unicode-fähiger Code verwendet den Iterator der Zeichenfolge. sehen Array.fromund ...verbreiten . string[Symbol.iterator]kann verwendet werden (zB anstelle vonstring ).

Siehe auch So teilen Sie Unicode-Zeichenfolgen in Zeichen in JavaScript .

Beispiele:

const string = "ẞ🦊";

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

Verwenden Sie die sund u-Flaggen auf aRegExp

Das Flag dotAlloders macht .Zeichen für Zeilenumbrüche, das Flag unicodeoderu aktiviert bestimmte Unicode-bezogene Funktionen.

Beispiele:

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

Es ist zu beachten, dass einige Grapheme aus mehr als einem Codepunkt bestehen, z. B. 🏳️‍🌈der aus der Sequenz 🏳(U + 1F3F3), VS16(U + FE0F) , ZWJ(U + 200D) , 🌈(U + 1F308) besteht. Hier Array.fromwird dies sogar in vier "Zeichen" aufgeteilt. Das Abgleichen dieser ist mit der Unicode-Eigenschaft möglich, die dem Vorschlag für Sequenzeigenschaften entgeht .

In Fällen, in denen Sie etwas entfernen möchten, das sich nahe am Ende einer Zeichenfolge befindet (bei Zeichenfolgen mit variabler Größe), können Sie Slice () und Substr () kombinieren.

Ich hatte eine Zeichenfolge mit dynamisch erstelltem Markup mit einer durch Komma getrennten Liste von Ankertags. Die Saite war so etwas wie:

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

Um das letzte Komma zu entfernen, habe ich Folgendes getan:

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

Versuche dies:

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

Sie können das Live-Arbeitsbeispiel auch unter http://jsfiddle.net/informativejavascript/F7WTn/87/ ausprobieren .

@ Jason S:

Sie können Slice verwenden! Sie müssen nur sicherstellen, dass Sie wissen, wie man es benutzt. Positive #s sind relativ zum Anfang, negative Zahlen sind relativ zum Ende.

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

Entschuldigung für meine Graphomany, aber der Beitrag wurde früher mit 'jquery' markiert. So können Sie nicht verwenden slice () innerhalb jQuery weil slice () jQuery - Methode für den Betrieb mit DOM - Elemente, nicht Substrings ... Mit anderen Worten beantworten @ Jon Erickson vorschlagen wirklich perfekte Lösung.

Ihre Methode funktioniert jedoch mit der jQuery-Funktion in einfachem Javascript. Aufgrund der letzten Diskussion in den Kommentaren muss gesagt werden, dass jQuery sehr viel häufiger eine erneuerbare Erweiterung von JS ist als das bekannteste ECMAScript seines eigenen Elternteils.

Hier existieren auch zwei Methoden:

als unsere:

string.substring(from,to) as plus if 'to' index nulled gibt den Rest der Zeichenfolge zurück. also: string.substring(from) positiv oder negativ ...

und einige andere - substr () -, die einen Bereich von Teilzeichenfolgen und 'Länge' bereitstellen, können nur positiv sein: string.substr(start,length)

Einige Betreuer schlagen außerdem vor, dass die letzte Methode string.substr(start,length)für MSIE nicht funktioniert oder mit Fehlern funktioniert.

Verwenden Sie Teilzeichenfolgen, um alles links von _bar anzuzeigen. Aber zuerst müssen Sie die Instrumente von _bar in der Zeichenfolge erhalten:

str.substring(3, 7);

3 ist der Start und 7 ist die Länge.