trim en javascript

Despues de leer algunos documentos como este Faster JavaScript Trim me di a la tarea de generar una implementacion de esta funcion, la cual fuera lo mar eficiente y eficaz posible en la medida de mis posibilidades, evitando la dependencia de un navegador web en particular.

funcion trim en javascript

01: // spaces list
02: var wl = [ ' ', '\n', '\r', '\t', '\f', '\u000B', '\u0085', '\u00A0', '\u1680',
03:                 '\u180E', '\u2000', '\u2001', '\u2002', '\u2003', '\u2004', '\u2005',
04:                 '\u2006', '\u2007', '\u2008', '\u2009', '\u200A', '\u200B', '\u2028',
05:                 '\u2029', '\u202F', '\u205F', '\u3000', '\uFEFF' ];
06: 
07: function iltrim(sValue, l, wll) {
08:         var i;
09:         for (i = 0; i < l; i++) {
10:                 var c = sValue[i];// cache
11:                 var j;
12:                 for (j = 0; j < wll; j++) { // search in spaces list
13:                         if (c == wl[j]) {
14:                                 break;
15:                         }
16:                 }
17:                 if (j == wll) { // not a space?
18:                         break;// not a space!
19:                 }
20:                 // found a space, continue with next
21:         }
22:         return i;
23: }
24: 
25: function ltrim(sValue) {
26:         var i = iltrim(sValue, sValue.length, wl.length);// index
27:         return i > 0 ? sValue.substr(i) : sValue;// i need substr?
28: }
29: 
30: function irtrim(sValue, l, wll) {
31:         var i;
32:         for (i = l - 1; i >= 0; i--) {
33:                 var c = sValue[i];// cache
34:                 var j;
35:                 for (j = 0; j < wll; j++) { // search in spaces list
36:                         if (c == wl[j]) {
37:                                 break;
38:                         }
39:                 }
40:                 if (j == wll) { // not a space?
41:                         i += 1;// not a space!, need this char
42:                         break;
43:                 }
44:                 // found a white; continue with prev
45:         }
46:         return i;
47: }
48: 
49: function rtrim(sValue) {
50:         var l = sValue.length;// cache
51:         var r = irtrim(sValue, l, wl.length);// index
52:         return r != l ? sValue.substr(0, r) : sValue;// i need substr?
53: }
54: 
55: function trim(sValue) {
56:         var l = sValue.length;// string length
57:         var wll = wl.length;// cache
58:         var r = irtrim(sValue, l, wll);// r index
59:         // optimization (start in r not in 0) -- why? --
60:         var i = iltrim(sValue, r, wll);// l index
61:         return i > 0 || r != l ? sValue.substr(i, r - i) : sValue; // substr?
62: }

Explicacion:

• 02-05: Se definen un arreglo que contiene todos los caracteres "blancos" que pude encontrar, definidos en unicode.
  
• 07-23: funcion iltrim esta funcion obtiene el indice del primer caracter no blanco dentro de la cadena (de izquierda a derecha)
• 25-28: funcion ltrim esta funcion realiza un trim por la izquierda.
• 30-47: funcion irtrim esta funcion obtiene el indice del ultimo caracter no blanco dentro de la cadena (de izquierda a derecha)
• 49-53: funcion rtrim esta funcion realiza un trim por la derecha.
• 55-62: funcion trim esta funcion realiza un trim por la izquierda y por la derecha.

Optimizacion:

1. Se evita el uso de funciones, como indexOf (Esta funcion busca cadenas en una cadena. Pero estamos buscando caracteres en una cadena).
2. Se evita el uso de banderas.
3. Se evita crear objetos intermedios, creando funciones que buscan indices y posteriormente se decide si se genera una nueva cadena o no, utilizando substr. 
4. Se crea "cache" de algunos valores, por ejemplo del caracter a comparar, o de las longitudes.
5. Se evita el uso  de cadenas, cuando es posible utilizar un arreglo (dada la rapidez al acceder a un elemento, sin necesidad de invocar una funcion.