Czy przyciąć ciąg w JavaScript?

Jak przyciąć ciąg w JavaScript?

Wszystkie przeglądarki od IE9 + mają trim()metodę ciągów.

W przypadku przeglądarek, które nie obsługują trim(), możesz użyć tego wypełnienia z 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, '');
        };
    })();
}

To powiedziawszy, jeśli używasz jQuery, $.trim(str)jest również dostępne i obsługuje niezdefiniowane / null.

Zobacz:

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,' ');};

Przycinanie z jQuery jest wygodne, jeśli już używasz tego frameworka.

$.trim('  your string   ');

Często używam jQuery, więc przycinanie za pomocą niego znaków jest dla mnie naturalne. Ale możliwe, że istnieje reakcja na jQuery? :)

Chociaż powyżej znajduje się kilka poprawnych odpowiedzi, należy zauważyć, że Stringobiekt w JavaScript ma natywną .trim()metodę od ECMAScript 5 . Dlatego idealnie byłoby, gdyby każda próba prototypowania metody przycinania naprawdę sprawdziła, czy już istnieje.

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

Dodano natywnie w: JavaScript 1.8.1 / ECMAScript 5

Tak obsługiwane w:

Firefox: 3.5+

Safari: 5+

Internet Explorer: IE9 + (tylko w trybie Standardowym!) Http://blogs.msdn.com/b/ie/archive/2010/06/25/enhanced-scripting-in-ie9-ecmascript-5-support-and-more .aspx

Chrome: 5+

Opera: 10.5+

Tabela obsługi ECMAScript 5: http://kangax.github.com/es5-compat-table/

Istnieje wiele implementacji , których można użyć. Najbardziej oczywistym wydaje się być coś takiego:

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

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

Prosta wersja tutaj Jaka jest ogólna funkcja przycinania JavaScript?

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

Wiem, że to pytanie zostało zadane trzy lata temu. Teraz String.trim()zostało natywnie dodane w JavaScript. Na przykład można przyciąć bezpośrednio w następujący sposób,

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

Jeśli używasz jQuery, użyj jQuery.trim()funkcji. Na przykład:

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

Rażące Badassery ma 11 różnych wykończeń z informacjami porównawczymi:

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

Nic dziwnego, że oparte na wyrażeniach regularnych są wolniejsze niż tradycyjna pętla.

Oto mój osobisty. Ten kod jest stary! Napisałem go dla JavaScript 1.1 i Netscape 3 i od tego czasu jest tylko nieznacznie aktualizowany. (Oryginał użył 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);
}

Użyj metod Język JavaScript: String.trimLeft(), String.trimRight(), i String.trim().

String.trim()jest obsługiwany w IE9 + i wszystkich innych głównych przeglądarkach :

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

String.trimLeft()i String.trimRight()są niestandardowe, ale są obsługiwane we wszystkich głównych przeglądarkach oprócz IE

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

Obsługa IE jest łatwa dzięki wielopełniaczowi:

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, " ");
};

Bezwstydnie skradziony Mattowi Dueregowi .

Teraz możesz używać string.trim (), który jest natywną implementacją Javascript

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

Zobacz też

• trimLeft ()
• trimRight ()

Przytnij kod z projektu kątowego 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;
  };

})();

i nazwać to jak trim(" hello ")

użyj po prostu kodu

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

Obsługa przeglądarki

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

Do starej przeglądarki dodaj prototyp

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

Oto bardzo prosty sposób:

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

Używanie trim()na String, który jest rodzimy, może być najłatwiejszym sposobem:

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

console.log(trimmedFullName);

Możesz po prostu zadeklarować zmienną jako ciąg i użyć jej funkcji przycinania:

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

Obecnie prawie każda przeglądarka obsługuje String.prototype.trim().

Używasz go w ten sposób:

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

W przypadku, gdy nadal będziesz musiał obsługiwać starą przeglądarkę, która nie obsługuje tej funkcji, jest to polifill sugerowany przez MDN:

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

Mam bibliotekę, która korzysta z przycinania. rozwiązał to za pomocą następującego kodu.

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,'');  
  };  
}

Od poprzednich odpowiedzi różni się dodawanie flagi m.

Flaga m przeszuka tekst kilku liniowych. W tym trybie znacznik początku i końca wzoru ( ^ $) jest wstawiany przed i po znaku nowej linii ( \n).

Możesz to zrobić za pomocą zwykłego JavaScript:

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

Teraz trim () build w javascript.

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

po prostu kod konsoli lub wydrukuj, a następnie Twoje imię również zostanie przycięte.

Nie wiem, jakie błędy mogą tutaj ukryć, ale używam tego:

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

Lub jeśli wpis zawiera tekst:

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

Kolejna próba:

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

Oto w TypeScript:

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

Wróci do wyrażenia regularnego, jeśli natywny prototyp nie jest dostępny.

Napisałem tę funkcję dla trim, gdy funkcja .trim () nie była dostępna w JS w 2008 roku. Niektóre starsze przeglądarki nadal nie obsługują funkcji .trim () i mam nadzieję, że ta funkcja może komuś pomóc.

FUNKCJA PRZYCINANIA

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

Objaśnienie : Funkcja trim () akceptuje obiekt ciągu i usuwa wszelkie początkowe i końcowe białe spacje (spacje, tabulatory i znaki nowej linii) i zwraca przycięty ciąg. Za pomocą tej funkcji można przyciąć dane wejściowe formularza, aby zapewnić przesyłanie prawidłowych danych.

Przykładowo funkcję można wywołać w następujący sposób.

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

mine używa pojedynczego wyrażenia regularnego do wyszukiwania przypadków, w których konieczne jest przycinanie, i używa wyników wyrażenia regularnego do określenia pożądanych granic podciągów:

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
}

jedyną decyzją projektową, która weszła w to, było użycie podłańcucha do wykonania ostatecznego przechwytywania. s / \?: // (przechwytywanie terminu średni), a fragment zastępujący staje się:

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

w tych implikacjach postawiłem dwa zakłady na wyniki:

1. czy implementacja podłańcucha kopiuje dane oryginalnego ciągu? jeśli tak, to w pierwszym, gdy trzeba przyciąć łańcuch, następuje podwójne przejście, najpierw w wyrażeniu regularnym (które, miejmy nadzieję, może być częściowe), a drugie w ekstrakcji podłańcucha. mam nadzieję, że implementacja podłańcuchu odwołuje się tylko do oryginalnego ciągu, więc operacje takie jak podłańcuch mogą być prawie darmowe. krzyżować palce

2. jak dobre jest przechwytywanie w wyrażeniu regularnym? średni okres, wartość wyjściowa, może potencjalnie być bardzo długi. nie byłem gotowy stwierdzić, że przechwytywanie wszystkich wyrażeń regularnych nie przeszkadza w przechwytywaniu danych wejściowych o kilkaset KB, ale też nie testowałem (zbyt wiele środowisk uruchomieniowych, przepraszam!). drugi ZAWSZE uruchamia przechwytywanie; jeśli twój silnik może to zrobić bez uderzenia, być może wykorzystując niektóre z powyższych technik sznurkowych, na pewno UŻYJ GO!

Dla IE9 + i innych przeglądarek

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