Mam ciąg 12345.00i chciałbym, aby powrócił 12345.0.

Patrzyłem trim, ale wygląda na to, że to tylko przycinanie białych znaków, a slicenie wiem, jak to by działało. Jakieś sugestie?

Możesz użyć funkcji podciągu :

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

To jest akceptowana odpowiedź, ale zgodnie z poniższymi rozmowami składnia plastra jest znacznie bardziej przejrzysta:

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

Możesz użyć plasterka ! Musisz tylko upewnić się, że wiesz, jak go używać. Dodatnie liczby # odnoszą się do początku, liczby ujemne odnoszą się do końca.

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

Możesz użyć metody podciągów obiektów łańcuchowych JavaScript:

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

Bezwarunkowo usuwa ostatnie cztery znaki z łańcucha s.

Jeśli jednak chcesz warunkowo usunąć ostatnie cztery znaki, tylko jeśli są one dokładnie _bar :

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

Najłatwiejszą metodą jest użycie slicemetody ciągu, która pozwala na pozycje ujemne (odpowiadające przesunięciom z końca łańcucha):

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

Jeśli potrzebujesz czegoś bardziej ogólnego, aby usunąć wszystko po ostatnim podkreśleniu (włącznie z nim), możesz wykonać następujące czynności (pod warunkiem, sże zawiera on co najmniej jeden znak podkreślenia):

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

W przypadku liczby takiej jak twój przykład zaleciłbym zrobienie tego ponad substring:

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

Zauważ, że to faktycznie zaokrągli liczbę, co, jak sądzę, jest pożądane, ale może nie:

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

Korzystanie z funkcji wycinka JavaScript:

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

Można tego użyć do usunięcia „_bar” na końcu łańcucha dowolnej długości.

Wyrażenie regularne jest tym, czego szukasz:

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

Spróbuj tego:

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

Co powiesz na:

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

Użyj wyrażenia regularnego:

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

1. (. *), przechwytuje dowolną postać wiele razy

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

2. ., w tym przypadku dopasowuje ostatni znak

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

3. $, dopasowuje koniec łańcucha

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

Oto alternatywa, której nie widziałem w innych odpowiedziach, dla zabawy.

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

Nie jest tak czytelny ani prosty jak plasterek lub podciąg, ale pozwala grać z ciągiem przy użyciu kilku fajnych metod tablicowych, więc warto wiedzieć.

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

Najkrótsza droga:

str.slice(0, -1); 

Jeśli chcesz zrobić ogólne zaokrąglanie liczb zmiennoprzecinkowych, zamiast przycinać ostatni znak:

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

EDYCJA: Wydaje się, że istnieje wbudowana funkcja do tego, jak zauważa Paolo. To rozwiązanie jest oczywiście znacznie czystsze niż moje. Użyj parseFloat, a następnie 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

Po prostu użyj wykończenia, jeśli nie chcesz spacji

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

Wydajność

Dzisiaj 2020.05.13 przeprowadzam testy wybranych rozwiązań na Chrome v81.0, Safari v13.1 i Firefox v76.0 na MacOs High Sierra 10.13.6.

Wnioski

• slice(0,-1)(D) jest szybki i najszybszym rozwiązaniem dla krótkich i długich ciągów i zaleca się jako szybkie rozwiązanie cross-browser
• rozwiązania oparte na substring(C) i substr(E) są szybkie
• rozwiązania oparte na wyrażeniach regularnych (A, B) są wolne / średnio szybkie
• rozwiązania B, F i G są wolne dla długich łańcuchów
• rozwiązanie F jest najwolniejsze dla krótkich łańcuchów, G jest najwolniejsze dla długich łańcuchów

Detale

Przeprowadzam dwa testy dla rozwiązań A , B , C , D , E ( ext ), F , G (mój)

• dla 8-znakowego krótkiego ciągu (od pytania OP) - możesz go uruchomić TUTAJ
• na łańcuch 1M - możesz go uruchomić TUTAJ

Rozwiązania są przedstawione poniżej

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

Oto przykładowe wyniki dla Chrome dla krótkiego ciągu

Pamiętaj, że String.prototype.{ split, slice, substr, substring }działają na ciągach kodowanych w UTF-16

Żadna z poprzednich odpowiedzi nie obsługuje Unicode. Łańcuchy są kodowane jako UTF-16 w większości nowoczesnych silników JavaScript, ale wyższe punkty kodu Unicode wymagają par zastępczych , więc starsze, wcześniej istniejące metody łańcuchów działają na jednostkach kodu UTF-16, a nie punktach kodu 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"

Ponadto odpowiedzi RegExp nie pasują do podziałów linii na końcu w ich obecnej formie:

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

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

Użyj iteratora ciągów do iteracji znaków

Kod obsługujący Unicode wykorzystuje iterator łańcucha; widzieć Array.fromi ...rozprzestrzeniać się . string[Symbol.iterator]można użyć (np. zamiaststring ).

Zobacz także Jak podzielić ciąg znaków Unicode na znaki w JavaScript .

Przykłady:

const string = "ẞ🦊";

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

Użyj flag si unaRegExp

Te dotAlllub sflag marki .dopasować znaki przerwy linii, unicodeczy uflaga umożliwia pewne funkcje związane z Unicode.

Przykłady:

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

Zauważ, że niektóre grafemy składają się z więcej niż jednego punktu kodowego, np. 🏳️‍🌈Który składa się z sekwencji 🏳(U + 1F3F3), VS16(U + FE0F) , ZWJ(U + 200D) , 🌈(U + 1F308). Tutaj nawet Array.frompodzieli to na cztery „postacie”. Dopasowanie ich jest możliwe dzięki właściwości Unicode, która ucieka od propozycji właściwości sekwencji .

W przypadkach, gdy chcesz usunąć coś, co znajduje się blisko końca łańcucha (w przypadku łańcuchów o zmiennej wielkości), możesz połączyć slice () i substr ().

Miałem ciąg znaków ze znacznikami, zbudowany dynamicznie, z listą tagów kotwicy oddzielonych przecinkiem. Ciąg był podobny do:

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

Aby usunąć ostatni przecinek, wykonałem następujące czynności:

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

Spróbuj tego:

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

Możesz także wypróbować działający przykład na żywo pod adresem http://jsfiddle.net/informativejavascript/F7WTn/87/ .

@Jason S:

Możesz użyć plasterka! Musisz tylko upewnić się, że wiesz, jak go używać. Dodatnie liczby # odnoszą się do początku, liczby ujemne odnoszą się do końca.

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

Przepraszam za moje grafiki, ale post został wcześniej oznaczony jako „jquery”. Tak więc nie możesz używać slice () wewnątrz jQuery, ponieważ slice () jest metodą jQuery do operacji z elementami DOM, a nie podciągami ... Innymi słowy odpowiedź @Jon Erickson sugeruje naprawdę idealne rozwiązanie.

Jednak twoja metoda będzie działała poza funkcją jQuery, w prostym JavaScript. Muszę powiedzieć ze względu na ostatnią dyskusję w komentarzach, że jQuery jest znacznie częściej odnawialnym rozszerzeniem JS niż jego najbardziej znany ECMAScript.

Istnieją również dwie metody:

jak nasz:

string.substring(from,to) plus plus, jeśli indeks „do” nulled zwraca resztę ciągu. więc: string.substring(from) pozytywne lub negatywne ...

i niektóre inne - substr () - które zapewniają zakres podciągów i „długość” mogą być dodatnie: string.substr(start,length)

Również niektórzy opiekunowie sugerują, że ostatnia metoda string.substr(start,length)nie działa lub działa z błędem dla MSIE.

Użyj podciągów, aby uzyskać wszystko po lewej stronie _bar. Ale najpierw musisz pobrać instrukcję _bar w ciągu:

str.substring(3, 7);

3 to ten początek, a 7 to długość.