JavaScript හි නූල් කපන්නද?

ජාවාස්ක්‍රිප්ට් හි නූලක් කපන්නේ කෙසේද?

IE9 + සිට සියලුම බ්‍රව්සර් වල trim()නූල් සඳහා ක්‍රමයක් ඇත.

සහාය නොදක්වන බ්‍රව්සර් සඳහා trim(), ඔබට MDN වෙතින් මෙම පොලිෆිල් භාවිතා කළ හැකිය :

if (!String.prototype.trim) {
    (function() {
        // Make sure we trim BOM and NBSP
        var rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;
        String.prototype.trim = function() {
            return this.replace(rtrim, '');
        };
    })();
}

එයින් කියැවෙන්නේ, භාවිතා කරන්නේ නම් jQuery, $.trim(str)ද ලබා ගත හැකි අතර නිර්වචනය නොකළ / ශුන්‍ය ලෙස හැසිරවිය හැකි ය.

මේක බලන්න:

String.prototype.trim=function(){return this.replace(/^\s+|\s+$/g, '');};

String.prototype.ltrim=function(){return this.replace(/^\s+/,'');};

String.prototype.rtrim=function(){return this.replace(/\s+$/,'');};

String.prototype.fulltrim=function(){return this.replace(/(?:(?:^|\n)\s+|\s+(?:$|\n))/g,'').replace(/\s+/g,' ');};

ඔබ දැනටමත් එම රාමුව භාවිතා කරන්නේ නම් jQuery වෙතින් කැපීම පහසුය.

$.trim('  your string   ');

මම බොහෝ විට jQuery භාවිතා කිරීමට නැඹුරු වෙමි, එබැවින් එය සමඟ නූල් කැපීම මට ස්වාභාවිකය. නමුත් jQuery වලට එරෙහිව පසුබෑමක් ඇතිවිය හැකිද? :)

ඉහත නිවැරදි පිළිතුරු පොකුරක් තිබුණද, Stringජාවාස්ක්‍රිප්ට් හි ඇති වස්තුවට ECMAScript 5 වන විට ස්වදේශීය .trim()ක්‍රමයක් ඇති බව සැලකිල්ලට ගත යුතුය . මේ අනුව, ටිම් ක්‍රමය මූලාකෘතිකරණය කිරීමේ ඕනෑම උත්සාහයක් ඇත්ත වශයෙන්ම එය දැනටමත් තිබේදැයි බැලීමට සැබවින්ම පරීක්ෂා කළ යුතුය.

if(!String.prototype.trim){  
  String.prototype.trim = function(){  
    return this.replace(/^\s+|\s+$/g,'');  
  };  
}

දේශීයව එකතු කරන ලද්දේ: JavaScript 1.8.1 / ECMAScript 5

මේ අනුව සහය දක්වන්නේ:

ෆයර්ෆොක්ස්: 3.5+

සෆාරි: 5+

ඉන්ටර්නෙට් එක්ස්ප්ලෝරර්: IE9 + (ප්‍රමිති ප්‍රකාරයේදී පමණි!) Http://blogs.msdn.com/b/ie/archive/2010/06/25/enhanced-scripting-in-ie9-ecmascript-5-support-and-more .aspx

Chrome: 5+

ඔපෙරා: 10.5+

ECMAScript 5 ආධාරක වගුව: http://kangax.github.com/es5-compat-table/

ඇත ක්රියාවට නැංවීම් ගොඩක් භාවිතා කළ හැකි බව. වඩාත්ම පැහැදිලිව පෙනෙන්නේ මේ වගේ දෙයක්:

String.prototype.trim = function() {
    return this.replace(/^\s+|\s+$/g, "");
};

" foo bar ".trim();  // "foo bar"

සරල අනුවාදය මෙහි ජාවාස්ක්‍රිප්ට් ටිම් සඳහා පොදු කාර්යයක් කුමක්ද?

function trim(str) {
        return str.replace(/^\s+|\s+$/g,"");
}

මෙම ප්‍රශ්නය මීට වසර තුනකට පෙර විමසා ඇති බව මම දනිමි. දැන්, String.trim()එය ජාවාස්ක්‍රිප්ට් හි ස්වදේශීයව එකතු කරන ලදි. උදාහරණයක් ලෙස, ඔබට පහත පරිදි කෙලින්ම කපා ගත හැකිය,

document.getElementById("id").value.trim();

ඔබ jQuery භාවිතා කරන්නේ නම්, jQuery.trim()ශ්‍රිතය භාවිතා කරන්න . උදාහරණයක් වශයෙන්:

if( jQuery.trim(StringVariable) == '')

ෆ්ලැන්ගන්ට් බඩසෙරි හි මිණුම් සලකුණු තොරතුරු සහිත විවිධ ටිම් 11 ක් ඇත:

http://blog.stevenlevithan.com/archives/faster-trim-javascript

සාම්ප්‍රදායික පුඩුවට වඩා මන්දගාමී වේ.

මෙන්න මගේ පෞද්ගලික එකක්. මෙම කේතය පැරණියි! මම එය JavaScript1.1 සහ Netscape 3 සඳහා ලියා ඇති අතර එය යාවත්කාලීන කර ඇත්තේ එතැන් සිට ය. (මුලින් භාවිතා කළ String.charAt)

/**
 *  Trim string. Actually trims all control characters.
 *  Ignores fancy Unicode spaces. Forces to string.
 */
function trim(str) {
    str = str.toString();
    var begin = 0;
    var end = str.length - 1;
    while (begin <= end && str.charCodeAt(begin) < 33) { ++begin; }
    while (end > begin && str.charCodeAt(end) < 33) { --end; }
    return str.substr(begin, end - begin + 1);
}

දේශීය JavaScript ක්රම භාවිතා කරන්න: String.trimLeft(), String.trimRight(), සහ String.trim().

String.trim()IE9 + සහ අනෙකුත් සියලුම ප්‍රධාන බ්‍රව්සර් වල සහය දක්වයි :

'  Hello  '.trim()  //-> 'Hello'

String.trimLeft()හා String.trimRight()සම්මත නොවන, නමුත් තුළ සහය දක්වයි සියලු ප්රධාන බ්රවුසර IE හැර

'  Hello  '.trimLeft()   //-> 'Hello  '
'  Hello  '.trimRight()  //-> '  Hello'

කෙසේ වෙතත් බහු පිරවුමක් සමඟ IE සහාය පහසුය:

if (!''.trimLeft) {
    String.prototype.trimLeft = function() {
        return this.replace(/^\s+/,'');
    };
    String.prototype.trimRight = function() {
        return this.replace(/\s+$/,'');
    };
    if (!''.trim) {
        String.prototype.trim = function() {
            return this.replace(/^\s+|\s+$/g, '');
        };
    }
}

String.prototype.trim = String.prototype.trim || function () {
    return this.replace(/^\s+|\s+$/g, "");
};

String.prototype.trimLeft = String.prototype.trimLeft || function () {
    return this.replace(/^\s+/, "");
};

String.prototype.trimRight = String.prototype.trimRight || function () {
    return this.replace(/\s+$/, "");
};

String.prototype.trimFull = String.prototype.trimFull || function () {
    return this.replace(/(?:(?:^|\n)\s+|\s+(?:$|\n))/g, "").replace(/\s+/g, " ");
};

ලැජ්ජා විරහිතව මැට් ඩියුරෙග් වෙතින් සොරකම් කරන ලදි .

දැන් ඔබට ස්වදේශීය ජාවාස්ක්‍රිප්ට් ක්‍රියාත්මක කිරීම වන string.trim () භාවිතා කළ හැකිය

var orig = "   foo  ";
console.log(orig.trim());//foo

මෙයද බලන්න

• ටිම්ලෙෆ්ට් ()
• triRight ()

කෝණික js ව්‍යාපෘතියෙන් කේතය කපන්න

var trim = (function() {

  // if a reference is a `String`.
  function isString(value){
       return typeof value == 'string';
  } 

  // native trim is way faster: http://jsperf.com/angular-trim-test
  // but IE doesn't have it... :-(
  // TODO: we should move this into IE/ES5 polyfill

  if (!String.prototype.trim) {
    return function(value) {
      return isString(value) ? 
         value.replace(/^\s*/, '').replace(/\s*$/, '') : value;
    };
  }

  return function(value) {
    return isString(value) ? value.trim() : value;
  };

})();

එය එසේ අමතන්න trim(" hello ")

සරල කේත භාවිතා කරන්න

var str = "       Hello World!        ";
alert(str.trim());

බ්‍රව්සර් සහාය

Feature         Chrome  Firefox Internet Explorer   Opera   Safari  Edge
Basic support   (Yes)   3.5     9                   10.5    5       ?

පැරණි බ්‍රව්සරය සඳහා මූලාකෘතියක් එක් කරන්න

if (!String.prototype.trim) {
  String.prototype.trim = function () {
    return this.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
  };
}

මෙන්න ඉතා සරල ක්‍රමයක්:

function removeSpaces(string){
return string.split(' ').join('');
}

භාවිතා trim()මත සංගීත ස්වදේශික වන පහසුම ක්රමය විය හැකි:

const fullName = "       Alireza Dezfoolian     ";
const trimmedFullName = fullName.trim();

console.log(trimmedFullName);

ඔබට ඔබේ විචල්‍යය නූල් ලෙස ප්‍රකාශ කර එහි ටිම් ශ්‍රිතය භාවිතා කළ හැකිය:

var str = new String('my string'); 
str= str.trim();

අද, සෑම බ්‍රව්සරයක්ම සහය දක්වයි String.prototype.trim() .

ඔබ එය මේ ආකාරයට භාවිතා කරයි:

var origStr = '   foo  ';
var newStr = origStr.trim(); // Value of newStr becomes 'foo'

මෙම අංගයට සහය නොදක්වන පැරණි බ්‍රව්සරයකට ඔබට තවමත් සහාය වීමට අවශ්‍ය නම්, මෙය එම්ඩීඑන් විසින් යෝජනා කරන ලද පොලිෆිල් එකකි :

if (!String.prototype.trim) {
    String.prototype.trim = function () {
       return this.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
    };
}

මට ට්‍රිම් භාවිතා කරන ලිබ් එකක් තිබේ. එබැවින් පහත කේතය භාවිතා කිරීමෙන් එය විසඳා ඇත.

String.prototype.trim = String.prototype.trim || function(){ return jQuery.trim(this); };

if(!String.prototype.trim){  
  String.prototype.trim = function(){  
    return this.replace(/^\s+|\s+$/gm,'');  
  };  
}

පෙර පිළිතුරු වලින්, එය ධජය එක් කිරීම වෙනස් වේ m.

ධජය mරේඛීය කිහිපයක පෙළ සොයනු ඇත. මෙම ප්‍රකාරයේදී, රටාවේ ආරම්භය සහ අවසානය සලකුණු කරන්න ( ^ $) නව රේඛා අක්‍ෂරයට පෙර සහ පසුව ඇතුල් කරන්න \n.

සරල ජාවාස්ක්‍රිප්ට් භාවිතයෙන් ඔබට එය කළ හැකිය:

function trimString(str, maxLen) {
if (str.length <= maxLen) {
return str;
}
var trimmed = str.substr(0, maxLen);
return trimmed.substr(0, trimmed.lastIndexOf(' ')) + '…';
}

// Let's test it

sentenceOne = "too short";
sentencetwo = "more than the max length";

console.log(trimString(sentenceOne, 15));
console.log(trimString(sentencetwo, 15));

දැන් javascript වලින් () සාදන්න.

let yourName = ' something   ';
let actualTrimmedName = yourName.trim();

කේතය කොන්සෝලය හෝ මුද්‍රණය කරන්න එවිට ඔබේ නමද කපා දමනු ඇත.

මෙහි සැඟවිය හැකි දෝෂ මොනවාදැයි නොදනී, නමුත් මම මෙය භාවිතා කරමි:

var some_string_with_extra_spaces="   goes here    "
console.log(some_string_with_extra_spaces.match(/\S.*\S|\S/)[0])

හෝ පෙළෙහි ඇතුළත් වන්නේ නම් මෙය ඇතුළත් වේ:

console.log(some_string_with_extra_spaces.match(/\S[\s\S]*\S|\S/)[0])

තවත් උත්සාහයක්:

console.log(some_string_with_extra_spaces.match(/^\s*(.*?)\s*$/)[1])

මෙන්න එය TypeScript හි ඇත:

var trim: (input: string) => string = String.prototype.trim
    ? ((input: string) : string => {
        return (input || "").trim();
    })
    : ((input: string) : string => {
        return (input || "").replace(/^\s+|\s+$/g,"");
    })

ස්වදේශික මූලාකෘතිය නොමැති නම් එය නැවත රීජෙක්ස් වෙතට වැටෙනු ඇත.

2008 දී ජේ .එස්.

TRIM FUNCTION

function trim(str)
{
    var startpatt = /^\s/;
    var endpatt = /\s$/;

    while(str.search(startpatt) == 0)
        str = str.substring(1, str.length);

    while(str.search(endpatt) == str.length-1)
        str = str.substring(0, str.length-1);   

    return str;
}

පැහැදිලි කිරීම : ටිම් () ශ්‍රිතය නූල් වස්තුවක් පිළිගෙන ආරම්භක හා පසුපස ඇති හිස් අවකාශයන් (අවකාශ, ටැබ් සහ නව රේඛා) ඉවත් කර කැපූ නූල ආපසු එවන්න. වලංගු දත්ත යැවීම සහතික කිරීම සඳහා පෝරම යෙදවුම් කැපීමට ඔබට මෙම ශ්‍රිතය භාවිතා කළ හැකිය.

ශ්‍රිතය උදාහරණයක් ලෙස පහත දැක්වෙන ආකාරයෙන් හැඳින්විය හැකිය.

form.elements[i].value = trim(form.elements[i].value);

කැපීම අවශ්‍ය අවස්ථාවන් සෙවීම සඳහා මගේ තනි රීජෙක්ස් භාවිතා කරන අතර අපේක්ෂිත උපස්ථර සීමාවන් තීරණය කිරීම සඳහා එම රීජෙක්ස් ප්‍රති results ල භාවිතා කරයි:

var illmatch= /^(\s*)(?:.*?)(\s*)$/
function strip(me){
    var match= illmatch.exec(me)
    if(match && (match[1].length || match[2].length)){
        me= me.substring(match[1].length, p.length-match[2].length)
    }
    return me
}

මේ සඳහා ගත් එක් සැලසුම් තීරණයක් වූයේ අවසාන ග්‍රහණය සිදු කිරීම සඳහා උපස්ථරයක් භාවිතා කිරීමයි. s / \ ?: // (මැද පදය ග්‍රහණය කර ගන්න) සහ ප්‍රතිස්ථාපන කොටස බවට පත්වන්නේ:

    if(match && (match[1].length || match[3].length)){
        me= match[2]
    }

මෙම ආවේගයන්හි මා විසින් සාදන ලද කාර්ය සාධන ඔට්ටු දෙකක් තිබේ:

1. උපස්ථර ක්‍රියාත්මක කිරීම මුල් නූලෙහි දත්ත පිටපත් කරයිද? එසේ නම්, පළමුවෙන්ම, නූලක් කැපීමට අවශ්‍ය වූ විට ද්විත්ව ගමන් මාර්ගයක් ඇත, පළමුව රීජෙක්ස් හි (එය අර්ධ වශයෙන් විය හැකිය), සහ උපස්ථර නිස්සාරණයෙන් දෙවනුව. උපස්ථරයක් ක්‍රියාත්මක කිරීම මඟින් මුල් නූලට පමණක් යොමු වන බැවින් උපස්ථර වැනි මෙහෙයුම් නිදහස් විය හැකිය. හරස් ඇඟිලි

2. රීජෙක්ස් impl හි අල්ලා ගැනීම කොතරම් හොඳද? මධ්‍ය කාලීන, නිමැවුම් අගය ඉතා දිගු විය හැකිය. සියලුම රීජෙක්ස් ග්‍රහණය කර ගැනීම කේබී සියගණනක් ආදාන ග්‍රහණයට හසු නොවන බව මම බැංකු කිරීමට සූදානම් නැත, නමුත් මම ද පරීක්‍ෂා නොකළෙමි (වැඩිපුර ධාවන වේලාවන්, සමාවෙන්න!). දෙවන සෑම විටම අල්ලා ගැනීමක් ධාවනය කරයි; ඔබේ එන්ජිමට පහරක් නොගෙන මෙය කළ හැකි නම්, සමහර විට ඉහත සඳහන් නූල්-රෝපින්-ශිල්පීය ක්‍රම කිහිපයක් භාවිතා කරමින්, නිසැකවම එය භාවිතා කරන්න!

IE9 + සහ වෙනත් බ්‍රව්සර් සඳහා

function trim(text) {
    return (text == null) ? '' : ''.trim.call(text);
}