Nu JavaScript au o metodă cum ar fi "gama()" pentru a genera o gama cadrul furnizate limitele?
În PHP, poti face...
range(1, 3); // Array(1, 2, 3)
range("A", "C"); // Array("A", "B", "C")Că este, există o funcție care vă permite să obțineți o serie de numere sau caractere prin care trece limitele superioare și inferioare.
Este ceva built-in pentru JavaScript nativ pentru asta? Dacă nu, cum aș putea să-l pună în aplicare?
Numere
[...Array(5).keys()];
=> [0, 1, 2, 3, 4]Caracter de repetare
String.fromCharCode(...[...Array('D'.charCodeAt(0) - 'A'.charCodeAt(0) + 1).keys()].map(i => i + 'A'.charCodeAt(0)));
=> "ABCD"Repetare
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"Ca funcții
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)))
}Ca tastat funcții
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)))
}lodash.js _.intervalul() funcția
_.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"Vechi non es6 browsere fără o bibliotecă:
Array.apply(null, Array(5)).map(function (_, i) {return i;});
=> [0, 1, 2, 3, 4]console.log([...Array(5).keys()]);Multumesc.
(ES6 credit pentru nils petersohn și alți comentatori)
Pentru numerele pe care le puteți folosi ES6 Matrice.de la(), care funcționează în toate aceste zile IE cu excepția:
Versiunea scurta:
Array.from({length: 20}, (x,i) => i);Versiune mai lungă:
Array.from(new Array(20), (x,i) => i)care creează o gamă de la 0 la 19 inclusiv. Acest lucru poate fi în continuare redus la unul dintre aceste forme:
Array.from(Array(20).keys())
// or
[...Array(20).keys()]Inferioară și superioară limitele pot fi specificate, de exemplu:
Array.from(new Array(20), (x,i) => i + *lowerBound*)Un articol care descrie acest lucru în detaliu: http://www.2ality.com/2014/05/es6-array-methods.html
Noul meu favorit forma (ES2015)
Array(10).fill(1).map((x, y) => x + y)Și dacă ai nevoie de o funcție cu un " pas " param:
const range = (start, stop, step = 1) =>
Array(Math.ceil((stop - start) / step)).fill(start).map((x, y) => x + y * step)
Aici's my 2 cents:
function range(start, count) {
return Array.apply(0, Array(count))
.map((element, index) => index + start);
}Acesta funcționează pentru caractere și numere, de a merge înainte sau înapoi cu un pas opțional.
var range = function(start, end, step) {
var range = [];
var typeofStart = typeof start;
var typeofEnd = typeof end;
if (step === 0) {
throw TypeError("Step cannot be zero.");
}
if (typeofStart == "undefined" || typeofEnd == "undefined") {
throw TypeError("Must pass start and end arguments.");
} else if (typeofStart != typeofEnd) {
throw TypeError("Start and end arguments must be of same type.");
}
typeof step == "undefined" && (step = 1);
if (end < start) {
step = -step;
}
if (typeofStart == "number") {
while (step > 0 ? end >= start : end <= start) {
range.push(start);
start += step;
}
} else if (typeofStart == "string") {
if (start.length != 1 || end.length != 1) {
throw TypeError("Only strings with one character are supported.");
}
start = start.charCodeAt(0);
end = end.charCodeAt(0);
while (step > 0 ? end >= start : end <= start) {
range.push(String.fromCharCode(start));
start += step;
}
} else {
throw TypeError("Only string and number types are supported");
}
return range;
}[jsFiddle][1].
Dacă augmentarea nativ tipuri este dvs. de lucru, apoi atribuiți-l la Matrice.gama.
var range = function(start, end, step) {
var range = [];
var typeofStart = typeof start;
var typeofEnd = typeof end;
if (step === 0) {
throw TypeError("Step cannot be zero.");
}
if (typeofStart == "undefined" || typeofEnd == "undefined") {
throw TypeError("Must pass start and end arguments.");
} else if (typeofStart != typeofEnd) {
throw TypeError("Start and end arguments must be of same type.");
}
typeof step == "undefined" && (step = 1);
if (end < start) {
step = -step;
}
if (typeofStart == "number") {
while (step > 0 ? end >= start : end <= start) {
range.push(start);
start += step;
}
} else if (typeofStart == "string") {
if (start.length != 1 || end.length != 1) {
throw TypeError("Only strings with one character are supported.");
}
start = start.charCodeAt(0);
end = end.charCodeAt(0);
while (step > 0 ? end >= start : end <= start) {
range.push(String.fromCharCode(start));
start += step;
}
} else {
throw TypeError("Only string and number types are supported");
}
return range;
}
console.log(range("A", "Z", 1));
console.log(range("Z", "A", 1));
console.log(range("A", "Z", 3));
console.log(range(0, 25, 1));
console.log(range(0, 25, 5));
console.log(range(20, 5, 5));
Simplu funcția gama:
function range(start, stop, step) {
var a = [start], b = start;
while (b < stop) {
a.push(b += step || 1);
}
return a;
}Să includă BitInt tip de date unele verificați pot fi incluse, asigurându-se că toate variabilele sunt de același tip start`:
function range(start, stop, step) {
var a = [start], b = start;
if (typeof start == 'bigint') {
stop = BigInt(stop)
step = step? BigInt(step): 1n;
} else
step = step || 1;
while (b < stop) {
a.push(b += step);
}
return a;
}
Array.range= function(a, b, step){
var A= [];
if(typeof a== 'number'){
A[0]= a;
step= step || 1;
while(a+step<= b){
A[A.length]= a+= step;
}
}
else{
var s= 'abcdefghijklmnopqrstuvwxyz';
if(a=== a.toUpperCase()){
b=b.toUpperCase();
s= s.toUpperCase();
}
s= s.substring(s.indexOf(a), s.indexOf(b)+ 1);
A= s.split('');
}
return A;
}
Array.range(0,10);
// [0,1,2,3,4,5,6,7,8,9,10]
Array.range(-100,100,20);
// [-100,-80,-60,-40,-20,0,20,40,60,80,100]
Array.range('A','F');
// ['A','B','C','D','E','F')
Array.range('m','r');
// ['m','n','o','p','q','r']
OK în JavaScript nu ne't au o raza()` funcția de ca PHP, deci avem nevoie de a crea funcția care este destul de ușor, am scris două de o linie de funcții pentru tine și separați-le de Numere și Alfabete ca mai jos:
pentru Numere:
function numberRange (start, end) {
return new Array(end - start).fill().map((d, i) => i + start);
}și-l numesc, cum ar fi:
numberRange(5, 10); //[5, 6, 7, 8, 9]pentru Alfabete:
function alphabetRange (start, end) {
return new Array(end.charCodeAt(0) - start.charCodeAt(0)).fill().map((d, i) => String.fromCharCode(i + start.charCodeAt(0)));
}și-l numesc, cum ar fi:
alphabetRange('c', 'h'); //["c", "d", "e", "f", "g"]
La îndemână funcție pentru a face truc, rula fragmentul de cod de mai jos
function range(start, end, step, offset) {
var len = (Math.abs(end - start) + ((offset || 0) * 2)) / (step || 1) + 1;
var direction = start < end ? 1 : -1;
var startingPoint = start - (direction * (offset || 0));
var stepSize = direction * (step || 1);
return Array(len).fill(0).map(function(_, index) {
return startingPoint + (stepSize * index);
});
}
console.log('range(1, 5)=> ' + range(1, 5));
console.log('range(5, 1)=> ' + range(5, 1));
console.log('range(5, 5)=> ' + range(5, 5));
console.log('range(-5, 5)=> ' + range(-5, 5));
console.log('range(-10, 5, 5)=> ' + range(-10, 5, 5));
console.log('range(1, 5, 1, 2)=> ' + range(1, 5, 1, 2));aici este cum să-l folosească
range (Start, End, Pas=1, Offset=0);
- inclusive - forward
gama(5,10) // [5, 6, 7, 8, 9, 10] - inclusive - înapoi raza(10,5) // [10, 9, 8, 7, 6, 5]`
- pas - înapoi raza(10,2,2) // [10, 8, 6, 4, 2]`
- exclusiv - forward
gama(5,10,0,-1) // [6, 7, 8, 9] nu 5,10 se - offset - și extindă raza de acțiune(5,10,0,1) // [4, 5, 6, 7, 8, 9, 10, 11]`
- offset - micsora raza(5,10,0,-2) // [7, 8]`
- pas - și extindă raza de acțiune(10,0,2,2) // [12, 10, 8, 6, 4, 2, 0, -2]`
sper că veți găsi util.
Și aici este modul în care funcționează.
Practic am'm calculeze lungimea array și de a crea un zero tablou plin la aceasta lungime, apoi umple-l cu cele necesare valori
(pas || 1)=> Și alții ca acest lucru înseamnă utiliza valoarea de " pas " și dacă nu a fost prevăzută utilizarea1în loc- Vom începe prin a calcula lungimea tabloului rezultat folosind
(Math.abs(end - start) + ((offset|| 0) * 2)) / (pas || 1) + 1)să-l pună mai simplu (diferența* offset în ambele direcții/pas) - Dupa ce lungime, apoi vom crea un array gol inițializat cu valori folosind
new Array(lungime).umple(0);numai aici - Acum avem o serie
[0,0,0,..]la lungimea vrem. Am harta peste ea și să se întoarcă o nouă matrice cu valorile avem nevoie de ajutorulMatrice.harta(function() {}) var direcție = start < end ? 1 : 0;, Evident, dacă "start" nu este mai mică decât "sfârșitul" avem nevoie pentru a muta înapoi. Adică merge de la 0 la 5 sau vice-versa- Pe fiecare iterație,
startingPoint+stepSize* "index" va ne dă valoarea trebuie
var range = (l,r) => new Array(r - l).fill().map((_,k) => k + l);
Cu ajutorul Armoniei răspândirea operator și săgeată funcții:
var range = (start, end) => [...Array(end - start + 1)].map((_, i) => start + i);Exemplu:
range(10, 15);
[ 10, 11, 12, 13, 14, 15 ]
Standard Javascript nu't au o funcție de built-in pentru a genera intervale. Mai multe cadre javascript adauga suport pentru astfel de caracteristici, sau ca altii au subliniat, puteți rula întotdeauna a ta.
Daca'd place să verificați, resursa definitiv este ECMA-262 Standard.
A făcut unele cercetări în diverse Gamă de Funcții. Checkout jsperf comparație diferite moduri de a face aceste funcții. Cu siguranță nu o perfectă sau listă exhaustivă, dar ar trebui să ajute :)
Câștigătorul este...
function range(lowEnd,highEnd){
var arr = [],
c = highEnd - lowEnd + 1;
while ( c-- ) {
arr[c] = highEnd--
}
return arr;
}
range(0,31);Din punct de vedere tehnic nu cel mai rapid de pe firefox, dar diferenta de viteza (imho) pe chrome face pentru el.
De asemenea observație interesantă este cum mult mai rapid chrome este cu aceste matrice funcții decât firefox. Chrome este de cel puțin 4 sau 5 ori mai rapid.
Puteți utiliza lodash sau Undescore.js "gama":
var range = require('lodash/range')
range(10)
// -> [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]Alternativ, dacă aveți nevoie doar de un interval continuu de numere întregi puteți face ceva de genul:
Array.apply(undefined, { length: 10 }).map(Number.call, Number)
// -> [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]În ES6 "gama" pot fi puse în aplicare cu generatoarele:
function* range(start=0, end=null, step=1) {
if (end == null) {
end = start;
start = 0;
}
for (let i=start; i < end; i+=step) {
yield i;
}
}Această punere în aplicare economisește memorie atunci când iterarea mare de secvențe, pentru că nu't trebuie să se materializeze toate valorile într-o matrice:
for (let i of range(1, oneZillion)) {
console.log(i);
}
O altă versiune folosind ES6 generatoare ( a se vedea mare Paolo Moretti răspuns cu ES6 generatoare ):
const RANGE = (a,b) => Array.from((function*(x,y){
while (x <= y) yield x++;
})(a,b));
console.log(RANGE(3,7)); // [ 3, 4, 5, 6, 7 ]Sau, dacă avem nevoie doar de iterable, atunci:
const RANGE_ITER = (a,b) => (function*(x,y){
while (x <= y) yield x++;
})(a,b);
for (let n of RANGE_ITER(3,7)){
console.log(n);
}
// 3
// 4
// 5
// 6
// 7
O provocare interesantă ar fi să scrie scurt funcția pentru a face acest lucru. Recursivitate la salvare!
function r(a,b){return a>b?[]:[a].concat(r(++a,b))}Tinde a fi lent la intervale mari, dar, din fericire, calculatoarele cuantice sunt doar în jurul valorii de colț.
Un bonus este ca's obfuscatory. Pentru că știm cu toții cât de important este de a ascunde codul nostru de ochii indiscreti.
Cu adevărat și cu totul obfuscate funcția, face acest lucru:
function r(a,b){return (a<b?[a,b].concat(r(++a,--b)):a>b?[]:[a]).sort(function(a,b){return a-b})}
Aș cod ceva de genul asta:
function range(start, end) {
return Array(end-start).join(0).split(0).map(function(val, id) {return id+start});
}
range(-4,2);
// [-4,-3,-2,-1,0,1]
range(3,9);
// [3,4,5,6,7,8]Se comportă în mod similar cu Python gama:
>>> range(-4,2)
[-4, -3, -2, -1, 0, 1]
O mai degrabă minimalist implementarea puternic care are ES6 poate fi creat, după cum urmează, atrăgând în mod special atenția asupra Matrice.de la() metoda statica:
const getRange = (start, stop) => Array.from(
new Array((stop - start) + 1),
(_, i) => i + start
);Deși acest lucru nu este de la PHP, dar o imitație de "range" de la Python.
function range(start, end) {
var total = [];
if (!end) {
end = start;
start = 0;
}
for (var i = start; i < end; i += 1) {
total.push(i);
}
return total;
}
console.log(range(10)); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
console.log(range(0, 10)); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
console.log(range(5, 10)); // [5, 6, 7, 8, 9] range(start,end,pas): Cu ES6 Iteratori
Tu doar cere-o de limite superioare și inferioare. Aici vom crea unul cu un pas prea.
Puteți crea cu ușurință raza()` generator de funcție care poate funcționa ca un iterator. Acest lucru înseamnă că don't trebuie să pre-genera întreaga matrice.
function * range ( start, end, step = 1 ) {
let state = start;
while ( state < end ) {
yield state;
state += step;
}
return;
};Acum este posibil să doriți să creați ceva care pre-generează o matrice de iterator și returnează o listă. Acest lucru este util pentru funcții care acceptă o matrice. Pentru aceasta putem folosi Matrice.din()
const generate_array = (start,end,step) =>
Array.from( range(start,end,step) );Acum puteți genera o matrice statice cu ușurință,
const array1 = generate_array(1,10,2);
const array1 = generate_array(1,7);Dar atunci când ceva nu dorește un iterator (sau vă oferă opțiunea de a utiliza un iterator), puteți crea cu ușurință o prea.
for ( const i of range(1, Number.MAX_SAFE_INTEGER, 7) ) {
console.log(i)
}Note Speciale
- Dacă utilizați Ramda, ei au propriile lor
R. gamala fel ca Lodash
