Recortar cadena en JavaScript?

¿Cómo recorto una cadena en JavaScript?

Todos los navegadores desde IE9 + tienen un trim()método para cadenas.

Para aquellos navegadores que no son compatibles trim(), puede usar este polyfill de 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, '');
        };
    })();
}

Dicho esto, si se usa jQuery, $.trim(str)también está disponible y maneja indefinido / nulo.

Mira esto:

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

El recorte de jQuery es conveniente si ya está utilizando ese marco.

$.trim('  your string   ');

Tiendo a usar jQuery a menudo, por lo que recortar cadenas con él es natural para mí. ¿Pero es posible que haya una reacción violenta contra jQuery? :)

Aunque hay un montón de respuestas correctas arriba, debe tenerse en cuenta que el Stringobjeto en JavaScript tiene un .trim()método nativo a partir de ECMAScript 5 . Por lo tanto, idealmente, cualquier intento de crear un prototipo del método de recorte realmente debería comprobar si ya existe primero.

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

Agregado de forma nativa en: JavaScript 1.8.1 / ECMAScript 5

Así apoyado en:

Firefox: 3.5+

Safari: 5+

Internet Explorer: IE9 + (¡solo en modo estándar!) 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+

Tabla de soporte de ECMAScript 5: http://kangax.github.com/es5-compat-table/

Hay muchas implementaciones que se pueden usar. Lo más obvio parece ser algo como esto:

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

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

Versión simple aquí ¿Cuál es una función general para el recorte de JavaScript?

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

Sé que esta pregunta se hizo hace tres años. Ahora, String.trim()se agregó de forma nativa en JavaScript. Por ejemplo, puede recortar directamente de la siguiente manera,

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

Si está utilizando jQuery, use la jQuery.trim()función Por ejemplo:

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

Flagrant Badassery tiene 11 versiones diferentes con información de referencia:

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

No sorprendentemente, las expresiones basadas en expresiones regulares son más lentas que el bucle tradicional.

Aquí está mi personal. Este código es viejo! Lo escribí para JavaScript1.1 y Netscape 3 y desde entonces solo se ha actualizado ligeramente. (Original usado 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);
}

Utilizar los métodos nativos de JavaScript: String.trimLeft(), String.trimRight(), y String.trim().

String.trim()es compatible con IE9 + y todos los demás navegadores principales :

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

String.trimLeft()y String.trimRight()no son estándar, pero son compatibles con todos los principales navegadores, excepto IE

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

Sin embargo, el soporte de IE es fácil con un polyfill:

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

Desvergonzadamente robado de Matt Duereg .

Hoy en día puedes usar string.trim () que es una implementación nativa de Javascript

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

Ver también

• trimLeft ()
• trimRight ()

Recortar código del proyecto angular 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;
  };

})();

y llámalo como trim(" hello ")

usa simplemente código

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

Soporte del navegador

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

Para el navegador antiguo, agregue el prototipo

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

Aquí hay una manera muy simple:

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

Usar trim()en String, que es nativo, podría ser la forma más fácil:

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

console.log(trimmedFullName);

Puede declarar su variable como cadena y usar su función de recorte:

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

Hoy, casi todos los navegadores son compatibles String.prototype.trim().

Lo usas así:

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

En caso de que aún necesite admitir un navegador antiguo que no admite esta función, este es un polyfill sugerido por el MDN:

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

Tengo una lib que usa trim. así que lo resolvió usando el siguiente código.

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

De las respuestas anteriores, difiere agregar bandera m.

Flag mbuscará el texto de varios lineales. En este modo, la marca al comienzo y al final del patrón ( ^ $) se inserta antes y después del carácter de nueva línea ( \n).

Puedes hacerlo usando el 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));

Ahora recorte () construir en javascript.

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

solo consola o imprima el código, su nombre también se recortará.

No sé qué errores pueden esconderse aquí, pero uso esto:

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

O esto, si el texto contiene ingresa:

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

Otro intento:

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

Aquí está en TypeScript:

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

Volverá a la expresión regular si el prototipo nativo no está disponible.

Había escrito esta función para trim, cuando la función .trim () no estaba disponible en JS en 2008. Algunos de los navegadores más antiguos todavía no admiten la función .trim () y espero que esta función pueda ayudar a alguien.

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

Explicación : La función trim () acepta un objeto de cadena y elimina los espacios en blanco iniciales y finales (espacios, tabulaciones y líneas nuevas) y devuelve la cadena recortada. Puede usar esta función para recortar entradas de formulario para garantizar que se envíen datos válidos.

La función se puede llamar de la siguiente manera como ejemplo.

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

el mío usa una expresión regular única para buscar casos en los que es necesario recortar, y usa los resultados de la expresión regular para determinar los límites de subcadena deseados:

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 única decisión de diseño que se tomó fue utilizar una subcadena para realizar la captura final. s / \?: // (hacer la captura del término medio) yy el fragmento de reemplazo se convierte en:

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

Hay dos apuestas de rendimiento que hice en estas implicaciones:

1. ¿La implementación de la subcadena copia los datos de la cadena original? si es así, en el primero, cuando se necesita recortar una cadena, hay un doble recorrido, primero en la expresión regular (que, con suerte, puede ser parcial), y segundo en la extracción de la subcadena. es de esperar que una implementación de subcadena solo haga referencia a la cadena original, por lo que operaciones como la subcadena pueden ser casi gratuitas. cruza los dedos

2. ¿Qué tan buena es la captura en el regex impl? El término medio, el valor de salida, podría ser potencialmente muy largo. no estaba listo para admitir que todas las capturas de expresiones regulares de expresión no se resistirían a una captura de entrada de un par de cientos de KB, pero tampoco probé (¡demasiados tiempos de ejecución, lo siento!). el segundo SIEMPRE ejecuta una captura; si su motor puede hacer esto sin recibir un golpe, tal vez usando algunas de las técnicas de cuerda de cuerda anteriores, ¡seguro que LO USE!

Para IE9 + y otros navegadores

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