[APORTE] Función range() equivalente a su similar de PHP

[Alexis88]

Hola amigos del foro, en esta ocasión, quiero compartir con ustedes esta pequeña y mejorable función (porque creo que puede ser más eficiente) para generar un array mediante un rango indicado, ya sea este de números o letras.

Código Javascript:

var range = function(array, start, end, step){
        array.push(start);
        start = typeof start === "string" ? 
                String.fromCharCode(start.charCodeAt(0) + (step || 1)) : 
                start += step || 1;
        return start <= end ? range(array, start, end, step) : array;
    };
 
console.log(range([], 1, 10));
console.log(range([], "a", "z"));
console.log(range([], "A", "Z"));
console.log(range([], 1, 10, 2));
 

Los resultados para lo anterior son los siguientes:

Código HTML:

1,2,3,4,5,6,7,8,9,10
a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z
A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z
1,3,5,7,9
 

Cualquier duda, sugerencia o crítica constructiva, será bienvenida.

Saludos

[quimfv]

Muy bien!! Gracias

Deberias asegurarte que si start o end son string solo sean de un caracter.

O modificar la función para que sea capaz de solucionar esto

console.log(range([], "ab", "yz"));

ab,ac,ad,....,ya,.....,yy,yz

tambien deberías asegurarte que start < end o que en ese caso los steps sean negativos.

Que start, end sean del mismo tipo.

Uff queria ser constructivo y me estan saliendo demasiadas cosas.

[Italico76]

Buena idea...... y como mencionas a PHP me hace acordar a mi implementacion de Range como clase para PHP pues tambien es iterable como tu version en JS:

Código Javascript:

range([], 1, 10)[5]
 

[Alexis88]

Gracias quimfv por las observaciones, de hecho esta función es mejorable. Ayer, luego de publicarla, me puse a pensar en las mejoras que se le pueden hacer, pero como estoy avanzando con un proyecto para un cliente, no las pude implementar y de hecho que estaba el tema de que start sea menor que end. ¿De verdad crees que no estás siendo constructivo? Pues opino todo lo contrario.

Hey, Italico76, no había visto tu clase en PHP, está excelente.

Bueno, sin más rodeos, aquí está la versión 2.0 de la función range():

Código Javascript:

var range = function(array, start, end, step){
        if (typeof start === typeof end){
            array.push(typeof start === "string" ? start[0] : start);
            step = start > end ? 
                   !isNaN(step) && isFinite(step) && step < 0 ? step : -step || -1 : 
                   !isNaN(step) && isFinite(step) ? step : 1;
            start = typeof start === "string" ? 
                    String.fromCharCode(start.charCodeAt(0) + step) : 
                    start += step;
            return (step > 0 && start <= end) || (step < 0 && start >= end) ? 
                    range(array, start, end, step) : array;
        }
        return false;
    };
 
console.log(range([], "a", "z"));
console.log(range([], "ab", "yz"));
console.log(range([], 1, 10));
console.log(range([], 10, 1));
console.log(range([], 10, 1, 1.5)); //Toma la parte entera
console.log(range([], 10, 1, "4")); //Toma el 4 como valor numérico, ignorando su tipo
console.log(range([], 10, 1, "a")); //Toma el 1 como valor por defecto, ignorando la "a"
console.log(range([], 10, 1, -2));
console.log(range([], 10, "1"));
 

Esto imprime lo siguiente:

Código HTML:

a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z
a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y
1,2,3,4,5,6,7,8,9,10
10,9,8,7,6,5,4,3,2,1
10,9,8,7,6,5,4,3,2,1
10,6,2
10,9,8,7,6,5,4,3,2,1
10,8,6,4,2
false
 

Mejoras implementadas:

• Opera solo con límites del mismo tipo.
• En caso de ser letras, solo toma a la primera.
• Si start es mayor que end, los pasos se dan hacia atrás, creándose una lista en orden descendente.
• El valor de step tiene que ser numérico (no precisamente el tipo), de lo contrario, se incrementa/decrementa el valor de los pasos de 1 en 1.

Al igual que con la función range() de PHP, si los límites fueran ab hasta yz, solo se toma el primer caracter, tal y como lo pueden comprobar en este ejemplo. Como ahora la función permite la creación de una lista de valores en orden descendente, da igual si step es positivo o negativo.

Cuando termine con mis labores, veré qué más mejoras se pueden hacer, pero si tienen otras, solo díganmelas y las implemento.

Saludos

[jp91]

No entiendo para que pasar el array como parametro.pero bueno.

Código Javascript:

function range(comienzo,fin, paso) {
  //  discusion : http://phpjs.org/functions/range/
  // originalmente hecho por : Waldo Malqui Silva
 
 
  var resultado = [];
  var valorIni, valorFinal, suma;
  var aux = paso || 1;
  var letras = false;
 
  if (!isNaN(comienzo) && !isNaN(fin)) {
    valorIni = comienzo;
    valorFinal = fin;
  } else if (isNaN(comienzo) && isNaN(fin)) {
    letras = true;
    valorIni = comienzo.charCodeAt(0);
    valorFinal = fin.charCodeAt(0);
  } else {
    valorIni = (isNaN(comienzo) ? 0 : comienzo);
    valorFinal = (isNaN(fin) ? 0 : fin);
  }
 
  suma = ((valorIni > valorFinal) ? false : true);
  if (suma) {
    while (valorIni <= valorFinal) {
      resultado.push(((letras) ? String.fromCharCode(valorIni) : valorIni));
      valorIni += aux;
    }
  } else {
    while (valorIni >= valorFinal) {
      resultado.push(((letras) ? String.fromCharCode(valorIni) : valorIni));
      valorIni -= aux;
    }
  }
 
  return resultado;
};
 

[Alexis88]

Paso un array porque la función es recursiva, no hago uso de bucles como en tu ejemplo. Si creara un array en la función, siempre se reemplazaría por otro, a menos que pueda declarárselo de tipo static como en PHP, aunque no estoy seguro de que eso se pueda. Por cierto, es más eficiente hacer esto:

Código Javascript:

var a, b, c;
 

Que esto:

Código Javascript:

var a;
var b;
var c;
 

Y ten en cuenta que con !isNaN(comienzo) no basta para comprobar que se trata de un valor numérico, pues si haces !isNaN(""), también obtendrás true por respuesta.

Saludos

Edito: Tengo algunas observaciones sobre tu función. Si paso es una cadena, siempre inserta el primer valor de la secuencia al array, pero ahí se detiene, incluso si la cadena es un número como "4". Por otro lado, si paso es negativo, no se respetan los límites, probé con un rango de 10 a 1 con paso -2 y el último número de la lista fue el 114467.

Bueno, al menos estamos aprendiendo todos aquí.

[jp91]

pasar el array no se me siento raro pero entre gustos, jejejej no esa funcion no la hice yo como puedes ver hay esta quien la hizo y la discusion con sus diferentes adaptaciones.

claro si nos dedicamos a mejorarla psssss..., y tanto como static hay es la famosas variables estaticas en el prototype de la clase.

[Alexis88]

Para crear métodos estáticos, no es necesario el uso de prototype, basta con hacer uso de la Dot Notation o la Bracket Notation para crear métodos estáticos en la función, pues al fin y al cabo, en JS todos son objetos.

Lo malo está en que al ser estático, al llamar a la función para generar otro array, se añade al que previamente se creó. Veré si puedo adaptar esto.

Edito: Sí se pudo.

Código Javascript:

var range = function(start, end, step){
        range.array = range.array || [];
        if (typeof start === typeof end){
            range.array.push(typeof start === "string" ? start[0] : start);
            step = start > end ? 
                   !isNaN(step) && isFinite(step) && step < 0 ? step : -step || -1 : 
                   !isNaN(step) && isFinite(step) ? step : 1;
            start = typeof start === "string" ? 
                    String.fromCharCode(start.charCodeAt(0) + step) : 
                    start += step;
            return (step > 0 && start <= end) || (step < 0 && start >= end) ? 
                    range(start, end, step) : (function(){
                        var aux = range.array;
                        range.array = [];
                        return aux;
                    })();
        }
        return false;
    };
 
console.log(range(1, 10)); //1,2,3,4,5,6,7,8,9,10
console.log(range("a", "z")); //a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z
 

[jp91]

jejejej si claro que todo es objeto bueno "casi" solo te decia un ejemplo general, ya se me hacia raro eso de <al llamar a la función para generar otro array, se añade al que previamente se creó> pero ya veo compruebas el array.

Si esa es la idea compartir y aprender un poco mas.:)

[Alexis88]

Claro, con esto de que son llamadas recursivas, al primer llamado no existirá y es ahí en donde se crea para que no sea el usuario el que lo cree, ya luego de ser creado, simplemente se le añaden los valores y antes de entregarse el resultado, hago una copia del array la cual será enviada y al original lo dejo vacío para poder utilizarlo en el futuro y crear listas con otros elementos. Y sí, en JS casi todo son objetos, me olvidé del casi que casi siempre pongo.

Gracias por tu participación, jp91, así es como debemos de trabajar en la comunidad.

[jp91]

jjeje Es interesante ver lo que pasaria aqui haciendo un calculo mental si colocamos como inicio "a" en minusculas y "Z" en mayusculas me imagino que se volvera loco.

[Alexis88]

Sucede lo mismo que en PHP.

Justo estoy trabajando en algunas mejoras, también tomaré eso en cuenta.

[Alexis88]

Bueno, luego de haber pensado y probado algunas mejoras, aquí está la versión 3.0 de la función range():

Código Javascript:

var range = function(start, end, step){
        range.array = range.array || [];
        
        if (typeof start !== typeof end){
            start = !isNaN(Number(start)) && isFinite(Number(start)) ? Number(start) : 0;
            end = !isNaN(Number(end)) && isFinite(Number(end)) ? Number(end) : 0;
        }
 
        if (typeof start === "string") 
            start = !isNaN(Number(start)) && isFinite(Number(start)) ? Number(start) : start[0].toLowerCase();
        if (typeof end === "string")
            end = !isNaN(Number(end)) && isFinite(Number(end)) ? Number(end) : end[0].toLowerCase();
 
        range.array.push(start);
 
        if (!isNaN(step) && isFinite(step))
            step = start > end ? 
                   Number(step > 0 ? -step || -1 : step || -1) : 
                   Number(step < 0 ? -step || 1 : step || 1);
        else
            step = start > end ? -1 : 1;
 
        start = typeof start === "string" ? 
                String.fromCharCode(start.charCodeAt(0) + step) : 
                start += step;
 
        return (step > 0 && start <= end) || (step < 0 && start >= end) ? 
                range(start, end, step) : (function(){
                    var aux = range.array;
                    range.array = [];
                    return aux;
                })();
    };
 
console.log(range("z", "A"));
console.log(range("Z", "a"));
console.log(range("z", "a"));
console.log(range("a", "Z"));
console.log(range("A", "z"));
console.log(range("a", "z"));
console.log(range("ab", "yz"));
console.log(range(1, 10));
console.log(range(10, 1));
console.log(range(10, 1, 1.5));
console.log(range(1, 10, "-4"));
console.log(range(10, 1, "-4"));
console.log(range(1, 10, "4"));
console.log(range(10, 1, "4"));
console.log(range(10, 1, "a"));
console.log(range(10, 1, -2));
console.log(range(1, 10, 2));
console.log(range("1", 10));
console.log(range(10, "1"));
console.log(range(10, "a"));
console.log(range(1, 10, -2));
console.log(range("a", 10));
console.log(range("1", "10"));
console.log(range("10", "1"));
 

Los resultados son los siguientes:

Código HTML:

z,y,x,w,v,u,t,s,r,q,p,o,n,m,l,k,j,i,h,g,f,e,d,c,b,a
z,y,x,w,v,u,t,s,r,q,p,o,n,m,l,k,j,i,h,g,f,e,d,c,b,a
z,y,x,w,v,u,t,s,r,q,p,o,n,m,l,k,j,i,h,g,f,e,d,c,b,a
a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z
a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z
a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z
a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y
1,2,3,4,5,6,7,8,9,10
10,9,8,7,6,5,4,3,2,1
10,8.5,7,5.5,4,2.5,1
1,5,9 
10,6,2 
10,9,8,7,6,5,4,3,2,1
10,8,6,4,2
1,3,5,7,9
1,2,3,4,5,6,7,8,9,10
10,9,8,7,6,5,4,3,2,1
10,9,8,7,6,5,4,3,2,1,0
1,3,5,7,9
0,1,2,3,4,5,6,7,8,9,10
1,2,3,4,5,6,7,8,9,10
10,9,8,7,6,5,4,3,2,1
 

Mejoras implementadas:

• Si los tipos de dato de los límites son diferentes, la función toma sus valores numéricos en caso de tenerlos, dígase "4", "100", mas no "a" o "b", caso contrario, se asigna 0 ya sea a start y/o a end.
• En caso de tener letras como límites y de estar uno de ellos en mayúscula y el otro en minúscula, siempre serán convertidos a minúsculas y se operarán como tales, obteniendo así el valor Unicode correspondiente a la letra en cuestión en minúscula.
• Siempre toma el valor numérico de step, para así poder dar pasos de, por ejemplo, "-4" o "4", los cuales serán tomados como -4 y 4, respectivamente.
• Si los límites son cadenas pero con valor numérico, dígase "1" y "10", se toma el valor numérico de ambos.

Cualquier otro aporte o sugerencia, será bienvenido.

Saludos