Couper la chaîne en JavaScript?

la finition de jQuery est commode si vous utilisez déjà ce cadre.

$.trim('  your string   ');

j'ai tendance à utiliser jQuery souvent, donc couper les cordes avec elle est naturel pour moi. Mais il est possible qu'il y ait réaction contre jQuery? :)

bien qu'il y ait un tas de bonnes réponses ci-dessus, il faut noter que l'objet String en JavaScript a une méthode native .trim() à partir de ECMAScript 5 . Ainsi idéalement toute tentative de prototype de la méthode de compensation devrait vraiment vérifier pour voir si elle existe déjà en premier.

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

ajouté nativement dans: JavaScript 1.8.1 / ECMAScript 5

ainsi pris en charge dans:

Firefox: 3.5+

Safari: 5+

Internet Explorer: IE9+ (en mode standard uniquement!) http://blogs.msdn.com/b/ie/archive/2010/06/25/enhanced-scripting-in-ie9-ecmascript-5-support-and-more.aspx

Chrome: 5+

Opéra: 10.5+

ECMAScript 5 Table de soutien: http://kangax.github.com/es5-compat-table /

il y a beaucoup d'implémentations qui peuvent être utilisées. La plus évidente semble être quelque chose comme ceci:

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

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

version Simple ici Qu'est-ce qu'une fonction générale pour JavaScript trim?

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

je sais que cette question a été posée il y a trois ans.Maintenant, String.trim() a été ajouté nativement en JavaScript.Pour une instance, vous pouvez couper directement comme suit,

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

Flagrante Badassery a 11 différentes garnitures des informations de référence:

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

sans surprise regexp-basé sont plus lents que la boucle traditionnelle.

voici ma version personnelle. Ce code est vieux! Je l'ai écrit pour JavaScript1.1 et Netscape 3 et il n'a été que légèrement mis à jour depuis. (L'Original utilisé Chaîne.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);
}

si vous utilisez jQuery, utilisez la fonction jQuery.trim() . Par exemple:

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

utilisez les méthodes JavaScript natives: String.trimLeft() , String.trimRight() , et String.trim() .

String.trim() est pris en charge dans IE9+ et tous les autres navigateurs importants :

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

String.trimLeft() et String.trimRight() ne sont pas standard, mais sont pris en charge dans tous les principaux navigateurs sauf IE

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

Le soutien D'IE est facile avec un polyfill cependant:

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

de nos jours, vous pouvez utiliser la chaîne .trim() qu'est Javascript natif de mise en œuvre

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

voir aussi

• trimLeft ()
• trimRight ()

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

sans Vergogne volé Matt duereg .

code D'assiette de angular js project

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

})();

et l'appeler trim(" hello ")

voici un moyen très simple:

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

utiliser simplement le code

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

prise en charge du Navigateur

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

pour ancien navigateur ajouter prototype

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

vous pouvez simplement déclarer votre variable comme chaîne de caractères et utiliser sa fonction trim:

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

Aujourd'hui, presque tous les navigateurs prennent en charge String.prototype.trim() .

vous l'utilisez comme ceci:

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

au cas où vous auriez encore besoin de prendre en charge un navigateur ancien qui ne supporte pas cette fonctionnalité, il s'agit de a polyfill suggéré par le MDN:

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

j'ai une lib qui utilise trim. donc résolu en utilisant le code suivant.

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

par rapport aux réponses précédentes, il diffère de l'ajout du drapeau m .

Flag m recherche le texte de plusieurs linéaires. Dans ce mode, la marque le début et la fin du motif ( ^ $ ) est insérée avant et après le caractère newline ( \n ).

Je ne sais pas ce que les bogues peuvent cacher ici, mais j'utilise ceci:

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

ou ceci, si le texte contient entre:

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

, essayez un Autre:

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

ici, il est en écriture dactylographiée:

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

il retombera sur le regex si le prototype natif n'est pas disponible.

j'avais écrit cette fonction pour trim, quand le .la fonction trim() n'était pas disponible dans JS way en 2008. Certains anciens navigateurs ne prennent pas en charge les .fonction trim() et j'espère que cette fonction peut aider quelqu'un.

LA FONCTION TRIM

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

explication : la fonction trim () accepte un objet string et supprime les espaces blancs de démarrage et de fuite (espaces, onglets et lignes) et retourner la chaîne tronquée. Vous pouvez utiliser cette fonction pour couper les entrées de formulaire pour assurer la validité des données à envoyer.

la fonction peut être appelée de la manière suivante comme exemple.

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

vous pouvez le faire en utilisant le JavaScript simple:

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

voici quelques-uns des autres exemples de couper une chaîne en utilisant JavaScript .

mine utilise un seul regex pour rechercher les cas où l'élagage est nécessaire, et utilise les résultats de ce regex pour déterminer les limites de substrat désirées:

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
}

la seule décision de conception qui a été prise était l'utilisation d'un substrat pour effectuer la capture finale. s/\?:// (le moyen terme de la capture) et le remplacement du fragment devient:

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

il y a deux paris de performance que j'ai faits dans ces impls:

1. l'implémentation sous-jacente copie-t-elle les données de la chaîne originale? si c'est le cas, dans le premier cas, lorsqu'une chaîne doit être coupée, il y a une double traversée, d'abord dans le regex (qui peut être, espérons-le partiel), et en second lieu dans l'extraction du substrat. avec un peu de chance, une implémentation de substring ne fait référence qu'à la chaîne originale, donc les opérations comme substring peuvent être presque gratuites. croiser les doigts

2. comment bien est-ce que la capture dans le regex impl? le moyen terme, la valeur de sortie, pourrait être très longue. Je n'étais pas prêt à parier que la capture de tous les impls de regex ne serait pas balk à quelques centaines de KB de capture d'entrée, mais je n'ai pas non plus testé (trop d'exécution, désolé!). le second exécute toujours une capture; si votre moteur peut faire cela sans prendre un coup, peut-être en utilisant certaines des techniques de corde-roping ci-dessus, pour sûr L'utiliser!

pour IE9+ et autres navigateurs

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