Tagliare la stringa in JavaScript?

Come taglio una stringa in JavaScript?

Tutti i browser da IE9 + hanno un trim()metodo per le stringhe.

Per quei browser che non supportano trim(), è possibile utilizzare questo polyfill da 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, '');
        };
    })();
}

Detto questo, se si utilizza jQuery, $.trim(str)è anche disponibile e gestisce undefined / null.

Guarda questo:

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

Il rivestimento di jQuery è utile se si sta già utilizzando quel framework.

$.trim('  your string   ');

Tendo a usare spesso jQuery, quindi tagliare le corde con esso è naturale per me. Ma è possibile che ci sia un contraccolpo contro jQuery là fuori? :)

Sebbene sopra ci siano un sacco di risposte corrette, va notato che l' Stringoggetto in JavaScript ha un .trim()metodo nativo a partire da ECMAScript 5 . Quindi idealmente qualsiasi tentativo di prototipare il metodo di trim dovrebbe davvero verificare se esiste già prima.

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

Aggiunto nativamente in: JavaScript 1.8.1 / ECMAScript 5

Così supportato in:

Firefox: 3.5+

Safari: 5+

Internet Explorer: IE9 + (solo in modalità Standard!) 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+

Tabella di supporto ECMAScript 5: http://kangax.github.com/es5-compat-table/

Ci sono molte implementazioni che possono essere utilizzate. Il più ovvio sembra essere qualcosa del genere:

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

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

Versione semplice qui Che cos'è una funzione generale per il trim JavaScript?

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

So che questa domanda è stata posta tre anni fa. Ora, è String.trim()stata aggiunta nativamente in JavaScript. Per un'istanza, puoi tagliare direttamente come segue,

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

Se si utilizza jQuery, utilizzare la jQuery.trim()funzione. Per esempio:

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

Flagrant Badassery ha 11 diverse finiture con informazioni di riferimento:

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

Non sorprendentemente basati su regexp sono più lenti del loop tradizionale.

Ecco il mio personale. Questo codice è vecchio! L'ho scritto per JavaScript1.1 e Netscape 3 e da allora è stato solo leggermente aggiornato. (Original usato 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);
}

Utilizzare i metodi nativi JavaScript: String.trimLeft(), String.trimRight(), e String.trim().

String.trim()è supportato in IE9 + e in tutti gli altri principali browser :

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

String.trimLeft()e String.trimRight()non sono standard, ma sono supportati in tutti i principali browser tranne IE

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

Il supporto di IE è facile con un polyfill tuttavia:

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

Spudoratamente rubato a Matt duereg .

Oggi puoi usare string.trim () che è l'implementazione nativa di Javascript

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

Guarda anche

• TrimLeft ()
• TrimRight ()

Taglia il codice dal progetto js angolare

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

})();

e chiamalo come trim(" hello ")

usa semplicemente il codice

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

Supporto per il browser

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

Per il vecchio browser aggiungere il prototipo

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

Ecco un modo molto semplice:

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

L'utilizzo trim()su String nativo potrebbe essere il modo più semplice:

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

console.log(trimmedFullName);

Puoi semplicemente dichiarare la tua variabile come stringa e usare la sua funzione trim:

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

Oggi praticamente supporta ogni browser String.prototype.trim().

Lo usi in questo modo:

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

Nel caso in cui sia ancora necessario supportare un browser antico che non supporta questa funzionalità, si tratta di un polyfill suggerito da MDN:

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

Ho una lib che usa trim. così risolto utilizzando il seguente codice.

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

Dalle risposte precedenti, differisce dall'aggiunta di flag m.

Flag mcercherà il testo di più lineari. In questa modalità, il segno di inizio e fine del modello ( ^ $) viene inserito prima e dopo il carattere di nuova riga ( \n).

Puoi farlo usando il semplice 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));

Ora trim () build in javascript.

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

solo console o codice di stampa, anche il tuo nome verrà tagliato.

Non so quali bug possono nascondere qui, ma io uso questo:

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

O questo, se il testo contiene:

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

Un altro tentativo:

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

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

Tornerà alla regex se il prototipo nativo non è disponibile.

Avevo scritto questa funzione per trim, quando la funzione .trim () non era disponibile in JS nel 2008. Alcuni dei browser più vecchi non supportano ancora la funzione .trim () e spero che questa funzione possa aiutare qualcuno.

FUNZIONE DI FINITURA

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

Spiegazione : La funzione trim () accetta un oggetto stringa e rimuove qualsiasi spazio bianco iniziale e finale (spazi, tabulazioni e nuove righe) e restituisce la stringa tagliata. È possibile utilizzare questa funzione per tagliare gli input del modulo per garantire l'invio di dati validi.

La funzione può essere chiamata come esempio come segue.

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

il mio usa un unico regex per cercare casi in cui è necessario il taglio e usa i risultati di quel regex per determinare i limiti di sottostringa desiderati:

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
}

l'unica decisione progettuale che è stata presa in questo è stata l'utilizzo di una sottostringa per eseguire l'acquisizione finale. s / \?: // (effettua l'acquisizione a medio termine) e il frammento di sostituzione diventa:

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

ci sono due scommesse sulle prestazioni che ho fatto in questi impls:

1. l'implementazione della sottostringa copia i dati della stringa originale? in tal caso, nel primo, quando una stringa deve essere tagliata, esiste una doppia traversata, prima nella regex (che può essere, si spera, parziale) e seconda nell'estrazione della sottostringa. si spera che un'implementazione della sottostringa faccia riferimento solo alla stringa originale, quindi operazioni come la sottostringa possono essere quasi gratuite. incrocia le dita

2. quanto è buona la cattura nell'impianto regex? il medio termine, il valore di output, potrebbe essere potenzialmente molto lungo. non ero pronto a ritenere che la cattura di tutti i regex impls non avrebbe torto a una cattura di input di duecento KB, ma non ho provato (troppi runtime, scusate!). il secondo esegue SEMPRE una cattura; se il tuo motore è in grado di farlo senza subire un colpo, magari usando alcune delle tecniche di corde di cui sopra, sicuramente UTILIZZARLO!

Per IE9 + e altri browser

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