tablas - Cuál es la mejor manera de recortar() en javascript

obtener datos de una tabla html javascript

Question

La pregunta lo dice todo; JS no parece tener un método nativo trim ().

Answer 1

¿Por qué no modificas el prototipo de cadena? ¿Por qué no robar la función de recorte de una biblioteca de código abierto, como hice aquí con YUI? (¿Realmente necesitas cargar y todo el framework para estas tareas simples?) Ponlas juntas y obtendrás esto:

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

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

Answer 2

Yo uso esto con JavaScript nativo

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

Use así

var myString = "                  some text                  ";

alert(myString.trim());

Answer 3

Como ya han señalado algunos otros, generalmente es mejor hacer este tipo de cosas utilizando una biblioteca JS de terceros. No es que trim () sea una función complicada para crear usted mismo, pero hay tantas funciones que no son nativas de JavaScript que pueda necesitar y se escriba usted mismo al final, pronto se vuelve más rentable utilizar una biblioteca.

Por supuesto, otra ventaja del uso de una biblioteca JS es que los autores hacen el trabajo duro de garantizar que las funciones funcionen en todos los navegadores principales, para que pueda codificar a una interfaz estándar y olvidarse de las irritantes diferencias entre Internet Explorer y todos los otros navegadores

Answer 4

Una versión un poco más pequeña de @ Pat''s.

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

Answer 5

de acuerdo con esta página, el mejor enfoque general es

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

Por supuesto, si está utilizando jQuery, le proporcionará un método de recorte optimizado.

Answer 6

En realidad, con jQuery este parece ser el camino:

jQuery.trim(string)

(Referencia)

Answer 7

La forma más corta para jQuery:

string = $.trim(string);

Enlazar

Answer 8

La respuesta a tantas preguntas de JavaScript: jQuery

$j.trim(string)

Nota: lo anterior supone que su jQuery se ha configurado con:

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

Que es mucho más sensato que "$", y mucho menos detallado que escribir "jQuery" cada vez.

Answer 9

Para ltrim, reemplace los espacios anclados al comienzo de la cadena sin nada:

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

Para rtrim, reemplace los espacios anclados al final de la cadena sin nada:

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

Para el ajuste:

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

Todos usan expresiones regulares para hacer el trabajo real.

Answer 10

Microsoft .NET también tiene la función String.trim como parte de JavaScript Base Type Extensions. Se podría usar si está codificando la aplicación ASP.NET.

Answer 11

Utilice la función de ajuste rápido de 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 );
};

Mi solución, sin embargo, sería esta (porque el objeto String en Firefox 3.5 y superior ya tiene un método de 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 );
};

Answer 12

Yo uso esto.

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

Answer 13

Yo uso esto:

Trabajar con funciones

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

        code example: 

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

        trim(" a  b") //ab

Answer 14

Bueno, como mucha gente siempre dice, la función de ajuste funciona bastante bien, pero si no quieres utilizar un marco completo solo para realizar un ajuste, puede ser útil echarle un vistazo a su implementación. Asi que aqui esta:

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

Las principales ventajas que veo en esta implementación, en comparación con otra solución ya propuesta aquí son:

• La bandera ''g'' que le permite realizar un corte en una cuerda de varias líneas
• La sintaxis (texto || "") que asegura que la función siempre funcionará, incluso si el argumento pasado es nulo o indefinido.

Answer 15

Hice una velocidad de función de ajuste en mente. Esta función supera claramente a los 24 competidores (de los cuales muchos usan expresiones regulares) y también a native string.trim () de Chrome y Chromium (!) Y realiza tan rápido como el ajuste de Safari (). Los resultados de la prueba están aquí: 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 función recorta los caracteres "/ n / r / t / f", pero es fácil agregar más espacios en blanco, por ejemplo. aquellos que regexp usan como espacios en blanco (s) con solo un rendimiento menor perdido (consulte http://jsperf.com/mega-trim-test/8 ).

Editar: El trim27 () anterior recorta solo los caracteres más comunes ("/ n / r / t / f"), pero para recortar todos los espacios en blanco posibles, incluí a continuación una nueva función 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();
    }

Úselo de esta manera:

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

El mytrim () anterior hace lo siguiente:

• Recorta 26 espacios en blanco diferentes (los 25 espacios en blanco mencionados en http://perfectionkills.com/whitespace-deviations/ y adicionalmente uFEFF, que es ZERO WIDTH NO-BREAK SPACE.
• Hace que los resultados de recorte sean consistentes en todos los navegadores.
• Utiliza ajuste nativo () si está disponible Y tiene la capacidad de recortar los 27 espacios en blanco diferentes. La excepción es Chrome y Chromium, que tienen un ajuste nativo tan lento () que, en lugar de nativos, usamos nuestro ajuste personalizado.
• Y LO MÁS IMPORTANTE: no es hermoso y no es corto, pero ES CLARAMENTE MÁS RÁPIDO que cualquiera de las 24 alternativas competitivas en http://jsperf.com/mega-trim-test/12 (excepción: bastante viejo Firefox 3.6.25 en Windows 7 ejecuta mytrim () bastante lentamente por un motivo desconocido).

Answer 16

Probablemente este no sea el más rápido, y podría violar lo que probablemente sea ".trim ()", pero no me gustan los RegEx (principalmente porque toma mucho tiempo averiguar qué significan / hacen realmente) y me gusta tener algo que sé que funcionará independientemente de si tengo jQuery o no (sin mencionar la versión correcta, ya que probé $ .trim (myVar) con jQuery 1.4.2 y no funciona), y me desharé de ALL espacios adicionales, no solo al final, reconstruyéndolo como debería ser:

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

Answer 17

Sé que esta pregunta es antigua, pero ahora, Javascript realmente tiene un .trim nativo ()

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

Answer 18

Esta es una vieja pregunta, pero ninguna de estas me funcionó. Solo necesitaba recortar el espacio en blanco inicial y final y esto es lo que hice. Mi etiqueta div tenía una id = fecha de inicio.

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

Answer 19

Puede usar siguiente ...

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