මට නූලක් ඇත, 12345.00එය නැවත පැමිණීමට මා කැමතිය 12345.0.

මම බැලුවෙමි trim, නමුත් එය පෙනෙන්නේ එය හිස් අවකාශය කැපීම පමණක් වන අතර මෙය ක්‍රියාත්මක වන්නේ sliceකෙසේදැයි මට නොපෙනේ. යෝජනා තිබේද?

ඔබට උපස්ථර ශ්‍රිතය භාවිතා කළ හැකිය :

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

මෙය පිළිගත් පිළිතුරයි, නමුත් පහත සංවාද වලට අනුව, පෙති සින්ටැක්ස් වඩාත් පැහැදිලි ය:

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

ඔබට පෙත්තක් භාවිතා කළ හැකිය ! ඔබ එය භාවිතා කරන්නේ කෙසේදැයි දැන ගැනීමට වග බලා ගත යුතුය. ධනාත්මක #s ආරම්භයට සාපේක්ෂ වේ, negative ණ සංඛ්‍යා අවසානයට සාපේක්ෂ වේ.

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

ඔබට ජාවාස්ක්‍රිප්ට් නූල් වස්තූන්ගේ උපස්ථර ක්‍රමය භාවිතා කළ හැකිය :

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

එය කොන්දේසි විරහිතව අන්තිම අක්ෂර හතර නූල් වලින් ඉවත් කරයි s.

කෙසේ වෙතත්, ඔබට අවසාන අක්ෂර හතර කොන්දේසි සහිතව ඉවත් කිරීමට අවශ්‍ය නම්, ඒවා හරියටම නම් පමණි _bar:

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

පහසුම ක්‍රමය නම් slice, negative ණාත්මක ස්ථානවලට ඉඩ සලසන නූල් ක්‍රමය භාවිතා කිරීමයි (නූල අවසානයේ සිට ඕෆ්සෙට් වලට අනුරූප වේ):

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

අන්තිම අවධාරනය කිරීමෙන් පසුව (සහ ඇතුළුව) සියල්ල ඉවත් කිරීමට ඔබට තවත් සාමාන්‍ය දෙයක් අවශ්‍ය නම්, ඔබට පහත සඳහන් දෑ කළ හැකිය ( sඅවම වශයෙන් එක් අවධාරණයක්වත් අඩංගු වන බවට සහතික වී ඇති තාක් කල් ):

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

ඔබගේ උදාහරණය වැනි අංකයක් සඳහා, මම මෙය නිර්දේශ කරමි substring:

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

මෙය ඇත්ත වශයෙන්ම සංඛ්‍යාව වටා ඇති බව සලකන්න, කෙසේ වෙතත්, මා සිතන පරිදි එය අපේක්‍ෂා කරන නමුත් සමහර විට එසේ නොවේ:

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

JavaScript හි පෙති ක්‍රියාකාරිත්වය භාවිතා කිරීම:

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

ඕනෑම දිගකින්, නූලක් අවසානයේ '_bar' ඉවත් කිරීමට මෙය භාවිතා කළ හැකිය.

නිත්‍ය ප්‍රකාශනයක් යනු ඔබ සොයන දෙයයි:

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

මේක උත්සාහ කරන්න:

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

කොහොමද:

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

Regex භාවිතා කරන්න:

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

1. (. *), ඕනෑම චරිතයක් කිහිප වතාවක් ග්‍රහණය කරයි

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

2. ., මේ අවස්ථාවේ දී අවසාන අක්ෂරයට ගැලපේ

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

3. $, නූල් අවසානයට ගැලපේ

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

මෙන්න විකල්පයක් මම විනෝදය සඳහා වෙනත් පිළිතුරු වල දැක ඇති බව නොසිතමි.

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

පෙත්තක් හෝ උපස්ථරයක් තරම් පැහැදිලි හෝ සරල නොවන නමුත් හොඳ අරා ක්‍රම කිහිපයක් භාවිතා කරමින් නූල් සමඟ සෙල්ලම් කිරීමට ඔබට ඉඩ සලසයි, එබැවින් දැන ගැනීම වටී.

කෙටිම ක්‍රමය:

str.slice(0, -1); 

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

අන්තිම චරිතය කැපීම වෙනුවට, පාවෙන සාමාන්‍ය වටකුරු කිරීමක් කිරීමට ඔබට අවශ්‍ය නම්:

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

සංස්කරණය කරන්න: පාවුලෝ පෙන්වා දෙන පරිදි මේ සඳහා ගොඩනංවන ලද ශ්‍රිතයක් පවතින බව පෙනේ. එම විසඳුම පැහැදිලිවම මට වඩා පිරිසිදු ය. භාවිතය parseFloat විසින් අනුගමනය toFixed

ඒ ගැන සැලකිලිමත් වන්න String.prototype.{ split, slice, substr, substring }UTF-16 කේතනය කරන ලද නූල් මත ක්‍රියාත්මක වන තබා ගන්න

පෙර පිළිතුරු කිසිවක් යුනිකෝඩ් දැනුවත්ව නැත. බොහෝ නූතන ජාවාස්ක්‍රිප්ට් එන්ජින් වල නූල් යූටීඑෆ් -16 ලෙස සංකේතවත් කර ඇත, නමුත් ඉහළ යුනිකෝඩ් කේත ලක්ෂ්‍යයන්ට ආදේශක යුගල අවශ්‍ය වේ , එබැවින් පැරණි, පෙර පැවති නූල් ක්‍රම ක්‍රියාත්මක වන්නේ යුනිකෝඩ් කේත ලක්ෂ්‍ය නොව යූටීඑෆ් -16 කේත ඒකක මත ය.

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"

ඊට අමතරව, RegExp පිළිතුරු ඒවායේ වර්තමාන ස්වරූපයෙන් අවසානයේ රේඛා බිඳීම් සමඟ නොගැලපේ:

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

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

අක්ෂර පුනරාවර්තනය කිරීම සඳහා string iterator භාවිතා කරන්න

යුනිකෝඩ්-දැනුවත් කේතය නූල් අනුකාරකය භාවිතා කරයි; බලන්න Array.fromසහ ...පැතිරෙන්න . string[Symbol.iterator]භාවිතා කළ හැකිය (උදා. වෙනුවටstring ).

යුනිකෝඩ් නූල ජාවාස්ක්‍රිප්ට් හි අක්ෂර වලට බෙදන්නේ කෙසේද යන්නද බලන්න .

උදාහරණ:

const string = "ẞ🦊";

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

sසහ uධජ භාවිතා කරන්න aRegExp

මෙම dotAllහෝ sධජය කරයි .ද, තරග මාර්ගය කැඩී චරිත unicodeහෝ uධජය යුනිකෝඩ් සම්බන්ධ ඇතැම් ලක්ෂණ හැකියාව ලබා දෙයි.

උදාහරණ:

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

සමහර ග්‍රැෆීම් කේත ලක්ෂ්‍යයකට වඩා වැඩි ගණනකින් සමන්විත වන බව සලකන්න, උදා: 🏳️‍🌈අනුක්‍රමය 🏳(U + 1F3F3), VS16(U + FE0F) , ZWJ(U + 200D) , 🌈(U + 1F308). මෙන්න, මෙය පවා Array.from“අක්ෂර” හතරකට බෙදා ඇත. ඒවා ගැලපීම යුනිකෝඩ් දේපලෙන් අනුක්‍රමික ගුණාංග යෝජනාවෙන් ගැලවිය හැකිය.

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

කාර්ය සාධනය

අද 2020.05.13 මැක් ඕස් සියෙරා v10.13.6 හි ක්‍රෝම් v81.0, සෆාරි v13.1 සහ ෆයර්ෆොක්ස් v76.0 මත තෝරාගත් විසඳුම් පරීක්ෂා කරමි.

නිගමන

• එම slice(0,-1) (D) වේගයෙන් හෝ වේගවත්ම කෙටි හා දිගු නූල් සඳහා විසඳුමක් වන අතර එය වේගයෙන් හරස් වෙබ් බ්රව්සරය විසඳුමක් ලෙස නිර්දේශ කරනු ලැබේ
• substring(C) සහ substr(E) මත පදනම් වූ විසඳුම් වේගවත් ය
• නිත්‍ය ප්‍රකාශන (A, B) මත පදනම් වූ විසඳුම් මන්දගාමී / මධ්‍යම වේගවත් වේ
• B, F සහ G විසඳුම් දිගු නූල් සඳහා මන්දගාමී වේ
• විසඳුම F කෙටි නූල් සඳහා මන්දගාමී වේ, G දිගු නූල් සඳහා මන්දගාමී වේ

විස්තර

A , B , C , D , E ( ext ), F , G (my) විසඳුම් සඳහා මම පරීක්ෂණ දෙකක් සිදු කරමි

• 8-char කෙටි නූල සඳහා (OP ප්‍රශ්නයෙන්) - ඔබට එය ක්‍රියාත්මක කළ හැකිය මෙතැන
• 1M දිගු නූල් සඳහා - ඔබට එය ක්‍රියාත්මක කළ හැකිය මෙතැන

විසඳුම් පහත දැක්වෙන කොටස් වලින් ඉදිරිපත් කෙරේ

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

කෙටි වචන සඳහා Chrome සඳහා උදාහරණ ප්‍රති results ල මෙන්න

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

ඔබට අවකාශය අවශ්‍ය නැතිනම් ටිම් භාවිතා කරන්න

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

ඔබට නූලක අවසානයට ආසන්න යමක් ඉවත් කිරීමට අවශ්‍ය අවස්ථාවන්හිදී (විචල්‍ය ප්‍රමාණයේ නූල් නම්) ඔබට පෙත්ත () සහ උපස්ථරය () ඒකාබද්ධ කළ හැකිය.

මා සතුව සලකුණු සහිත, ගතිකව සාදන ලද, කොමා මඟින් වෙන් කරන ලද නැංගුරම් ටැග් ලැයිස්තුවක් තිබුණි. නූල මෙවැනි දෙයක් විය:

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

අන්තිම කොමාව ඉවත් කිරීම සඳහා මම පහත සඳහන් දේ කළෙමි:

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

මේක උත්සාහ කරන්න:

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

ඔබට සජීවී වැඩ කිරීමේ උදාහරණය http://jsfiddle.net/informativejavascript/F7WTn/87/ වෙතින් උත්සාහ කළ හැකිය .

Ason ජේසන් එස්:

ඔබට පෙත්තක් භාවිතා කළ හැකිය! ඔබ එය භාවිතා කරන්නේ කෙසේදැයි දැන ගැනීමට වග බලා ගත යුතුය. ධනාත්මක #s ආරම්භයට සාපේක්ෂ වේ, negative ණ සංඛ්‍යා අවසානයට සාපේක්ෂ වේ.

js> "12345.00". ස්ලයිස් (0, -1) 12345.0

මගේ ග්‍රැෆෝමනි ගැන කණගාටුයි, නමුත් පෝස්ට් කලින් 'jquery' ලෙස සටහන් කර තිබුණි. එබැවින්, ඔබට jQuery තුළ පෙත්තක් () භාවිතා කළ නොහැක, මන්ද පෙත්ත () යනු DOM මූලද්‍රව්‍ය සමඟ ක්‍රියා කිරීම සඳහා jQuery ක්‍රමය මිස උපස්ථර නොවේ ... වෙනත් වචන වලින් කිවහොත් answer ජෝන් එරික්සන් යෝජනා කරන්නේ පරිපූර්ණ විසඳුමක්.

කෙසේ වෙතත්, ඔබේ ක්‍රමය සරල ජාවාස්ක්‍රිප්ට් තුළ jQuery ක්‍රියාකාරීත්වයෙන් ක්‍රියා කරයි. අදහස් දැක්වීමේ අවසාන සාකච්ඡාව නිසා පැවසිය යුතුය, jQuery බොහෝ විට JS හි පුනර්ජනනීය දිගුව ඔහුගේ මවුපියන්ගේ වඩාත් ප්‍රසිද්ධ ECMAScript වලට වඩා වැඩි ය.

මෙන්න ක්‍රම දෙකක් ද තිබේ:

අපගේ:

string.substring(from,to) 'to' දර්ශකය ශුන්‍ය නම් ප්ලස් ලෙස ඉතිරි නූල් නැවත ලබා දේ. ඉතින්: string.substring(from) ධනාත්මක හෝ negative ණ ...

සහ තවත් සමහරක් - උපස්ථර () - උපස්ථර පරාසය සහ 'දිග' සපයන ධනාත්මක විය හැක්කේ: string.substr(start,length)

සමහර නඩත්තුකරුවන් යෝජනා කරන්නේ අවසාන ක්‍රමය string.substr(start,length)MSIE සඳහා ක්‍රියා නොකරනු ඇති බවයි.

_Bar හි වමට සියල්ල ලබා ගැනීමට උපස්ථරය භාවිතා කරන්න. නමුත් පළමුව ඔබ _bar හි අක්ෂර මාලාව ලබා ගත යුතුය:

str.substring(3, 7);

3 යනු ආරම්භය වන අතර 7 දිග වේ.