¿Tiene JavaScript un método como "rango()" para generar un rango dentro de los límites proporcionados?
En PHP, puedes hacer...
range(1, 3); // Array(1, 2, 3)
range("A", "C"); // Array("A", "B", "C")
Es decir, existe una función que te permite obtener un rango de números o caracteres pasando los límites superior e inferior.
¿Hay algo integrado en JavaScript de forma nativa para esto? Si no, ¿cómo lo implementaría?
Números
[...Array(5).keys()];
=> [0, 1, 2, 3, 4]
Iteración de personajes
String.fromCharCode(...[...Array('D'.charCodeAt(0) - 'A'.charCodeAt(0) + 1).keys()].map(i => i + 'A'.charCodeAt(0)));
=> "ABCD"
Iteración
for (const x of Array(5).keys()) {
console.log(x, String.fromCharCode('A'.charCodeAt(0) + x));
}
=> 0,"A" 1,"B" 2,"C" 3,"D" 4,"E"
Como funciones
function range(size, startAt = 0) {
return [...Array(size).keys()].map(i => i + startAt);
}
function characterRange(startChar, endChar) {
return String.fromCharCode(...range(endChar.charCodeAt(0) -
startChar.charCodeAt(0), startChar.charCodeAt(0)))
}
Como funciones escritas
function range(size:number, startAt:number = 0):ReadonlyArray<number> {
return [...Array(size).keys()].map(i => i + startAt);
}
function characterRange(startChar:string, endChar:string):ReadonlyArray<string> {
return String.fromCharCode(...range(endChar.charCodeAt(0) -
startChar.charCodeAt(0), startChar.charCodeAt(0)))
}
_.range()función lodash.js
_.range(10);
=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
_.range(1, 11);
=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
_.range(0, 30, 5);
=> [0, 5, 10, 15, 20, 25]
_.range(0, -10, -1);
=> [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
String.fromCharCode(..._.range('A'.charCodeAt(0), 'D'.charCodeAt(0) + 1));
=> "ABCD"
Navegadores antiguos que no son es6 y sin biblioteca:
Array.apply(null, Array(5)).map(function (_, i) {return i;});
=> [0, 1, 2, 3, 4]
console.log([...Array(5).keys()]);(Crédito de ES6 para nils petersohn y otros comentaristas)
Para números puedes usar ES6 Array.from(), que funciona en todo hoy en día excepto en IE:
Versión más corta:
Array.from({length: 20}, (x, i) => i);
Versión más larga:
Array.from(new Array(20), (x, i) => i);
que crea una matriz del 0 al 19 inclusive. Esto se puede reducir aún más a una de estas formas:
Array.from(Array(20).keys());
// or
[...Array(20).keys()];
También se pueden especificar límites inferiores y superiores, por ejemplo:
Array.from(new Array(20), (x, i) => i + *lowerBound*);
Un artículo que describe esto con más detalle: http://www.2ality.com/2014/05/es6-array-methods.html
Mi nueva forma favorita ( ES2015 )
Array(10).fill(1).map((x, y) => x + y)
Y si necesitas una función con un stepparámetro:
const range = (start, stop, step = 1) =>
Array(Math.ceil((stop - start) / step)).fill(start).map((x, y) => x + y * step)
Otra posible implementación sugerida por los documentos de MDN :
// Sequence generator function
// (commonly referred to as "range", e.g. Clojure, PHP etc)
const range = (start, stop, step) =>
Array.from({ length: (stop - start) / step + 1}, (_, i) => start + (i * step))
Aquí están mis 2 centavos:
function range(start, end) {
return Array.apply(0, Array(end - 1))
.map((element, index) => index + start);
}
