ultimo - substr javascript

Recortar cadena en JavaScript?

Question

¿Cómo puedo recortar una cadena en JavaScript?

Answer 1

Ahora, los días se puede usar MDN que es la implementación nativa de Javascript.

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

Ver también

• trimLeft()
• trimRight()

Answer 2

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.

Answer 3

Aquí hay una manera muy simple:

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

Answer 4

Aunque hay un montón de respuestas correctas arriba, se debe tener en cuenta que el objeto String en JavaScript tiene un .trim() nativo .trim() partir de ECMAScript 5 . Por lo tanto, lo ideal sería que cualquier intento de prototipo del método de recorte realmente verifique si ya existe primero.

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

Añadido 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/

Answer 5

Código de recorte 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 llamarlo como trim(" hello ")

Answer 6

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

$.trim(''  your string   '');

Tiendo a usar jQuery a menudo, así que recortar cuerdas es algo natural para mí. ¿Pero es posible que haya una reacción violenta contra jQuery por ahí? :)

Answer 7

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

FUNCION DE 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 cualquier espacio en blanco inicial y final (espacios, tabulaciones y nuevas líneas) y devuelve la cadena recortada. Puede utilizar 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);

Answer 8

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

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

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

Answer 9

Hoy en día, casi todos los navegadores admiten String.prototype.trim() .

Lo usas así:

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

En caso de que aún debas tener que admitir un navegador antiguo que no sea compatible con 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, '''');
    };
}

Answer 10

No sé qué errores pueden ocultar 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 entra:

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

Answer 11

Para IE9 + y otros navegadores.

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

Answer 12

Puedes hacerlo usando el JavaScript plano:

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

Estos son algunos de los ejemplos más para recortar una cadena con JavaScript .

Answer 13

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

Answer 14

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

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

Answer 15

Solo puede declarar su variable como cadena y usar su función de ajuste:

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

Answer 16

Tengo una lib que utiliza recortar. Así lo resolvió utilizando el siguiente código.

String.prototype.trim = String.prototype.trim || function(){ return jQuery.trim(this); };

Answer 17

Todos los navegadores desde IE9 + tienen trim() .

Para aquellos navegadores que no son compatibles con 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, '''');
        };
    })();
}

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

Answer 18

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

String.trim() es compatible con http://kangax.github.com/es5-compat-table/ :

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

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

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

El soporte de IE es fácil con un polyfill sin embargo:

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

Answer 19

Versión simple aquí ¿Qué es una función general para el recorte de JavaScript?

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

Answer 20

el mío usa una expresión regular única para buscar casos donde es necesario recortar, y utiliza los resultados de esa 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 usar una subcadena para realizar la captura final. s / /?: // (haga la captura del término medio) y 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 instrucciones:

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

2. ¿Qué tan buena es la captura en la expresión regular? El término medio, el valor de salida, podría ser potencialmente muy largo. No estaba preparado para acumular que la captura de todos los implícitos de expresiones regulares no obstaculizaría una captura de entrada de unos doscientos 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 utilice algunas de las técnicas de cuerda de cuerda anteriores, ¡seguro que lo UTILICE!

Answer 21

usar simplemente el 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 agregar prototipo

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

Answer 22

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

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

No es sorprendente que las basadas en expresiones regulares sean más lentas que los bucles tradicionales.

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

Answer 23

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

Robado descaradamente de Matt Duereg .

Answer 24

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

De las respuestas anteriores, difiere añadiendo flag m .

La bandera m buscará el texto de varios lineales. En este modo, la marca, el principio y el final del patrón ( ^ $ ) se inserta antes y después del carácter de nueva línea ( /n ).