Zeichenfolge in JavaScript schneiden?

Wie schneide ich eine Zeichenfolge in JavaScript?

Alle Browser seit IE9 + haben eine trim()Methode für Zeichenfolgen.

Für diejenigen Browser, die dies nicht unterstützen trim(), können Sie diese Polyfüllung von MDN verwenden :

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

Das heißt, wenn verwendet jQuery, $.trim(str)ist auch verfügbar und behandelt undefiniert / null.

Sieh dir das an:

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

Das Trimmen von jQuery ist praktisch, wenn Sie dieses Framework bereits verwenden.

$.trim('  your string   ');

Ich benutze jQuery oft, daher ist es für mich selbstverständlich, Strings damit zu beschneiden. Aber ist es möglich, dass es da draußen eine Gegenreaktion gegen jQuery gibt? :) :)

Obwohl es oben eine Reihe korrekter Antworten gibt, sollte beachtet werden, dass das StringObjekt in JavaScript ab ECMAScript 5 über eine native .trim()Methode verfügt . Daher sollte im Idealfall jeder Versuch, die Trimmmethode zu prototypisieren, wirklich prüfen, ob sie bereits vorhanden ist.

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

Nativ hinzugefügt in: JavaScript 1.8.1 / ECMAScript 5

So unterstützt in:

Firefox: 3.5+

Safari: 5+

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

Chrome: 5+

Oper: 10,5+

ECMAScript 5-Supporttabelle: http://kangax.github.com/es5-compat-table/

Es gibt viele Implementierungen , die verwendet werden können. Das offensichtlichste scheint so etwas zu sein:

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

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

Einfache Version hier Was ist eine allgemeine Funktion für das Trimmen von JavaScript?

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

Ich weiß, dass diese Frage vor drei Jahren gestellt wurde. Jetzt String.trim()wurde sie nativ in JavaScript hinzugefügt. Für eine Instanz können Sie direkt wie folgt zuschneiden :

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

Wenn Sie jQuery verwenden, verwenden Sie die jQuery.trim()Funktion. Zum Beispiel:

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

Flagrant Badassery hat 11 verschiedene Verzierungen mit Benchmark-Informationen:

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

Es ist nicht überraschend, dass Regexp-basierte Schleifen langsamer sind als herkömmliche Schleifen.

Hier ist meine persönliche. Dieser Code ist alt! Ich habe es für JavaScript1.1 und Netscape 3 geschrieben und es wurde seitdem nur geringfügig aktualisiert. (Original verwendet 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);
}

Verwenden Sie die nativen JavaScript - Methoden: String.trimLeft(), String.trimRight(), und String.trim().

String.trim()wird in IE9 + und allen anderen gängigen Browsern unterstützt :

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

String.trimLeft()und String.trimRight()sind nicht Standard, werden jedoch in allen gängigen Browsern außer IE unterstützt

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

Die IE-Unterstützung ist mit einer Polyfüllung jedoch einfach:

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

Schamlos von Matt Duereg gestohlen .

Heute können Sie string.trim () verwenden , eine native Javascript-Implementierung

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

Siehe auch

• trimLeft ()
• trimRight ()

Trimmcode aus dem eckigen js- Projekt

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

})();

und nenne es als trim(" hello ")

benutze einfach Code

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

Browser-Unterstützung

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

Für alten Browser Prototyp hinzufügen

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

Hier ist ein sehr einfacher Weg:

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

Mit trim()auf String , der eine native könnte der einfachste Weg sein:

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

console.log(trimmedFullName);

Sie können Ihre Variable einfach als Zeichenfolge deklarieren und ihre Trimmfunktion verwenden:

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

Heute unterstützt so ziemlich jeder Browser String.prototype.trim().

Sie verwenden es so:

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

Falls Sie möglicherweise noch einen alten Browser unterstützen müssen, der diese Funktion nicht unterstützt, ist dies eine vom MDN vorgeschlagene Polyfüllung:

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

Ich habe eine Bibliothek, die Trim verwendet. so löste es mit dem folgenden Code.

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

Von den vorherigen Antworten unterscheidet es sich beim Hinzufügen eines Flags m .

Flag mdurchsucht den Text mehrerer linearer. In diesem Modus wird die Markierung für Anfang und Ende des Musters ( ^ $) vor und nach dem Zeilenumbruchzeichen ( \n) eingefügt .

Sie können dies mit dem einfachen JavaScript tun:

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

Jetzt trim () in Javascript bauen.

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

Nur Konsolen- oder Druckcode, dann wird auch Ihr Name gekürzt.

Ich weiß nicht, welche Fehler sich hier verstecken können, aber ich benutze dies:

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

Oder dies, wenn Text enthält:

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

Noch ein Versuch:

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

Hier ist es in TypeScript:

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

Es wird auf den regulären Ausdruck zurückgegriffen, wenn der native Prototyp nicht verfügbar ist.

Ich hatte diese Funktion für das Trimmen geschrieben, als die .trim () -Funktion 2008 in JS nicht verfügbar war. Einige der älteren Browser unterstützen die .trim () -Funktion immer noch nicht und ich hoffe, dass diese Funktion jemandem helfen kann.

TRIM-FUNKTION

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

Erläuterung : Die Funktion trim () akzeptiert ein Zeichenfolgenobjekt und entfernt alle beginnenden und nachfolgenden Leerzeichen (Leerzeichen, Tabulatoren und Zeilenumbrüche) und gibt die zugeschnittene Zeichenfolge zurück. Mit dieser Funktion können Sie Formulareingaben kürzen, um sicherzustellen, dass gültige Daten gesendet werden.

Die Funktion kann als Beispiel folgendermaßen aufgerufen werden.

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

Mine verwendet einen einzelnen regulären Ausdruck, um nach Fällen zu suchen, in denen ein Trimmen erforderlich ist, und verwendet die Ergebnisse dieses regulären Ausdrucks, um die gewünschten Teilstring-Grenzen zu bestimmen:

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
}

Die einzige Entwurfsentscheidung, die dazu führte, war die Verwendung eines Teilstrings, um die endgültige Erfassung durchzuführen. s / \ ?: // (machen Sie die mittelfristige Erfassung) und und das Ersatzfragment wird:

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

Es gibt zwei Leistungswetten, die ich in diesen Impls gemacht habe:

1. Kopiert die Teilstring-Implementierung die Daten der ursprünglichen Zeichenfolge? Wenn dies der Fall ist, gibt es im ersten Fall, wenn ein String gekürzt werden muss, eine doppelte Durchquerung, zuerst im regulären Ausdruck (der hoffentlich teilweise sein kann) und zweitens in der Teilstring-Extraktion. Hoffentlich verweist eine Teilzeichenfolgenimplementierung nur auf die ursprüngliche Zeichenfolge, sodass Operationen wie Teilzeichenfolgen nahezu kostenlos sein können. Finger kreuzen

2. Wie gut ist die Erfassung im Regex-Gerät? Der mittlere Wert, der Ausgabewert, könnte möglicherweise sehr lang sein. Ich war nicht bereit zu glauben, dass die Erfassung aller Regex-Impls nicht mit ein paar hundert KB Input-Capture einhergehen würde, aber ich habe auch nicht getestet (zu viele Laufzeiten, sorry!). der zweite führt IMMER eine Erfassung durch; Wenn Ihr Motor dies ohne einen Treffer kann, vielleicht mit einigen der oben genannten String-Roping-Techniken, verwenden Sie es auf jeden Fall!

Für IE9 + und andere Browser

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