web-dev-qa-db-fra.com

Quel est le meilleur moyen de trim () en javascript

La question dit tout; JS ne semble pas avoir de méthode native trim (). 

javascriptjquerystring
39
MDCore

Je sais que cette question est ancienne, mais maintenant, Javascript a un .trim () natif

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/Trim

16
K. R.

La forme la plus courte pour jQuery:

string = $.trim(string);

Lien

41
Darryl Hein

selon cette page la meilleure approche globale est

return str.replace(/^\s\s*/, '').replace(/\s\s*$/, '');

Bien sûr, si vous utilisez jQuery, il vous fournira une méthode de découpe optimisée.

31
Pat

Eh bien, comme beaucoup de gens le disent toujours, la fonction de rognage fonctionne plutôt bien, mais si vous ne voulez pas utiliser tout un cadre pour effectuer un rognage, il peut être utile de jeter un coup d'œil à sa mise en œuvre. Alors la voici:

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

Les principaux avantages que je vois dans cette mise en œuvre, par rapport à une autre solution déjà proposée ici, sont les suivants:

  • L'indicateur 'g' qui vous permet d'effectuer une coupe sur une chaîne multiligne
  • La syntaxe (text || "") qui garantit que la fonction fonctionnera toujours, même si l'argument transmis est null ou non défini.
18
gizmo

Comme quelques-uns l'ont déjà noté, il est généralement préférable de faire ce genre de chose en utilisant une bibliothèque JS tierce. Bien que trim () ne soit pas une fonction compliquée à créer par vous-même, il y a tellement de fonctions qui ne sont pas natives en JavaScript dont vous pourriez avoir besoin et qui finissent par écrire vous-même, il devient rapidement plus rentable d'utiliser une bibliothèque.

Bien entendu, un autre avantage de l'utilisation d'une bibliothèque JS est que les auteurs s'assurent que les fonctions fonctionnent sur tous les principaux navigateurs, de sorte que vous puissiez coder vers une interface standard et oublier les différences irritantes entre Internet Explorer et tous les autres. les autres navigateurs.

8
Richard Turner

Une version légèrement plus fine de @ Pat's.

return str.replace( /^\s+|\s+$/g, '' );
7
harpo

Pour ltrim, remplacez les espaces ancrés au début de la chaîne par rien:

str2 = str.replace(/^\s+/,'');

Pour rtrim, remplacez les espaces ancrés à la fin de la chaîne par rien:

str2 = str.replace(/\s+$/,'');

Pour la garniture:

str2 = str.replace(/^\s+|\s+$/g,'');

Ceux-ci utilisent tous des regex'es pour faire le travail réel.

6
paxdiablo

Utilisez la fonction de rognage rapide d’Ariel Flesler :

// Licensed under BSD
function myBestTrim( str ){
 var start = -1,
  end = str.length;
 while( str.charCodeAt(--end) < 33 );
 while( str.charCodeAt(++start) < 33 );
 return str.slice( start, end + 1 );
};

Ma solution, cependant, serait la suivante (car l’objet String dans Firefox 3.5 et versions ultérieures possède déjà une méthode trim ):

String.prototype.trim = String.prototype.trim || function () {
    var start = -1,
        end   = this.length;

    while( this.charCodeAt(--end) < 33 );
    while( this.charCodeAt(++start) < 33 );

    return this.slice( start, end + 1 );
};
5
Ionuț G. Stan

Pourquoi ne pas simplement modifier le prototype String? Pourquoi ne pas voler la fonction de découpage dans une bibliothèque open source, comme je l’ai fait ici avec YUI? (Avez-vous vraiment besoin de charger un framework complet pour cette tâche simple?) Assemblez-les et vous obtenez ceci: 

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

var s = " hello ";
alert(s.trim() == "hello"); // displays true
5
Benry

J'ai pensé à la vitesse de la fonction de trim. Cette fonction bat dans une différence évidente sur les 24 concurrents (dont beaucoup utilisent des expressions régulières) ainsi que dans la version native string.trim () de Chrome et Chromium (!) Et est aussi rapide que le trim () de Safari. Les résultats des tests sont ici: http://jsperf.com/mega-trim-test/7

function trim27(str) {
  var c;
  for (var i = 0; i < str.length; i++) {
    c = str.charCodeAt(i);
    if (c == 32 || c == 10 || c == 13 || c == 9 || c == 12)
    continue; else break;
  }
  for (var j = str.length - 1; j >= i; j--) {
    c = str.charCodeAt(j);
    if (c == 32 || c == 10 || c == 13 || c == 9 || c == 12)
    continue; else break;
  }
  return str.substring(i, j + 1);
}

La fonction supprime les caractères "\ n\r\t\f", mais il est facile d'ajouter plus de caractères d'espacement, par exemple. ceux que regexp utilise comme espaces (\ s) avec seulement une perte de performance mineure (veuillez consulter http://jsperf.com/mega-trim-test/8 ).

Edit: la version précédente trim27 () coupe uniquement les caractères les plus courants ("\ n\r\t\f"), mais pour supprimer tous les espaces blancs possibles, j’ai inclus ci-dessous une nouvelle fonction mytrim (): 

if (!String.prototype.trim || "\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF".trim() || navigator.userAgent.toString().toLowerCase().indexOf("chrome") != -1)
    var mytrim = function(str) {
        var c;
        for (var i = 0; i < str.length; i++) {
            c = str.charCodeAt(i);
            if (c == 32 || c == 10 || c == 13 || c == 9 || c == 12 || c == 11 || c == 160 || c == 5760 || c == 6158 || c == 8192 || c == 8193 || c == 8194 || c == 8195 || c == 8196 || c == 8197 || c == 8198 || c == 8199 || c == 8200 || c == 8201 || c == 8202 || c == 8232 || c == 8233 || c == 8239 || c == 8287 || c == 12288 || c == 65279)
            continue; else break;
        }
        for (var j = str.length - 1; j >= i; j--) {
            c = str.charCodeAt(j);
            if (c == 32 || c == 10 || c == 13 || c == 9 || c == 12 || c == 11 || c == 160 || c == 5760 || c == 6158 || c == 8192 || c == 8193 || c == 8194 || c == 8195 || c == 8196 || c == 8197 || c == 8198 || c == 8199 || c == 8200 || c == 8201 || c == 8202 || c == 8232 || c == 8233 || c == 8239 || c == 8287 || c == 12288 || c == 65279)
            continue; else break;
        }
        return str.substring(i, j + 1);
    };
    else var mytrim = function(str) {
        return str.trim();
    }

Utilisez-le de cette façon:

var foo = mytrim(" \n \t Trimmed \f \n "); // foo is now "Trimmed"

Le mytrim () ci-dessus fait ce qui suit: 

  • Taille 26 espaces blancs différents (les 25 espaces mentionnés dans http://perfectionkills.com/whitespace-deviations/ ainsi que uFEFF, qui correspond à ZERO WIDTH NO-BREAK SPACE.
  • Rend les résultats de coupe cohérents sur tous les navigateurs. 
  • Utilise trim () native () si disponible ET a la capacité de supprimer tous les 27 espaces blancs. L'exception est Chrome et Chromium, qui ont tous les deux un trim () natif si lent qu'au lieu de natif, nous utilisons notre trim personnalisé. 
  • ET LE PLUS IMPORTANT: N’est pas beau et n’est pas court, mais IS est manifestement plus rapide que l’une des 24 alternatives proposées par la concurrence dans http://jsperf.com/mega-trim-test/12 (exception : assez ancien Firefox 3.6.25 dans Windows 7 exécute mytrim () plutôt lentement pour une raison inconnue).
4
Timo Kähkönen

Je l'utilise avec du JavaScript natif

// Adding trim function to String object if its not there
if(typeof String.prototype.trim !== 'function') {
  String.prototype.trim = function() {
    return this.replace(/^\s+|\s+$/g, '');
  }
}

Utiliser comme ça

var myString = "                  some text                  ";

alert(myString.trim());

Exemple 

// Adding trim function to String object if its not there
if(typeof String.prototype.trim !== 'function') {
  String.prototype.trim = function() {
    return this.replace(/^\s+|\s+$/g, '');
  }
}

var str = "      some text              ";
console.log(str.trim());

3
kiranvj

La réponse à tant de questions JavaScript: jQuery

$j.trim(string)



Remarque: Ce qui précède suppose que votre jQuery a été configuré avec:

<script type="text/javascript">$j = jQuery.noConflict();</script>

Ce qui est bien plus judicieux que "$" et beaucoup moins verbeux que de taper "jQuery" à chaque fois.

1
Peter Boughton

Microsoft .NET a également String.trim function dans le cadre des extensions de base JavaScript. Il pourrait être utilisé si vous codez une application ASP.NET.

1
Alexander Prokofyev

Je l'utilise.

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

C'est une vieille question, mais aucune d'entre elles n'a fonctionné pour moi. J'avais juste besoin de couper les espaces blancs de début et de fin et c'est ce que j'ai fait. Ma balise div avait un id = date de début.

$("#start-date").text().trim()
0
CodeChops

En fait, avec jQuery, cela semble être le moyen:

jQuery.trim(string)

(Référence)

0
Evan

J'utilise ceci:

Travailler avec des fonctions.

 function trim($) { 
                return (typeof $ == "function" ? $() : $).replace(/[\s]*/g,"")
        }

        code example: 

        trim((function(){ return "a  b"})) // ab

        trim(" a  b") //ab
0
Jet

Vous pouvez utiliser ce qui suit ...

function trim(str) {
    try {
        if (str && typeof(str) == 'string') {
            return str.replace(/^\s*|\s*$/g, "");
        } else {
            return '';
        }
    } catch (e) {
        return str;
    }
}
0
RaviRaj

Ce n'est probablement pas le plus rapide, et pourrait violer ce que ".trim ()" devrait être, mais je n'aime pas les RegEx (principalement parce qu'il faut beaucoup de temps pour comprendre ce qu'ils signifient/font) et j'aime bien avoir quelque chose que je sais fonctionnera que je possède ou non jQuery (sans parler de la bonne version, car j'ai essayé $ .trim (myVar) avec jQuery 1.4.2 et cela ne fonctionne pas) et va se débarrasser de TOUT des espaces supplémentaires, pas seulement à la fin, en le reconstruisant comme il se doit:

function Trim(obj) {
    var coll = "";
    var arrObj = obj.split(' ');

    for (var i=0;i<arrObj.length;i++) {
        if (arrObj[i] == "") {
            arrObj.splice(i,1);  // removes array indices containing spaces
        }
    }
    //alert(arrObj.length);  // should be equal to the number of words
    // Rebuilds with spaces in-between words, but without spaces at the end
    for (var i=0;i<arrObj.length;i++) {
        if (arrObj[i] != "" && i != arrObj.length-1)
            coll += arrObj[i] + " ";
        if (arrObj[i] != "" && i == arrObj.length-1)
            coll += arrObj[i];
    }

    return coll;
}
0
vapcguy