Czy JavaScript ma metodę, taką jak „range ()”, do generowania zakresu w podanych granicach?

Potwierdzenie od:

Liczby

[...Array(5).keys()];

 => [0, 1, 2, 3, 4]

Natura iteracyjna

String.fromCharCode(...[...Array('D'.charCodeAt(0) - 'A'.charCodeAt(0) + 1).keys()].map(i => i + 'A'.charCodeAt(0)));

 => "ABCD"

Iteracja

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"

Jak działa

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)))

}

Funkcje typu As

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

_.range()

https://lodash.com/docs/4.16.4#range
funkcjonować

_.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"

Starsze przeglądarki inne niż ES6 bez biblioteki:

Array.apply(null, Array(5)).map(function (_, i) {return i;});

 => [0, 1, 2, 3, 4]

console.log([...Array(5).keys()]);

Dzięki.

(Podziękowania ES6 dla Nielsa Petersona i innych komentatorów

)

Anonimowy użytkownik

Potwierdzenie od:

W przypadku liczb możesz użyć ES6

Array.from ()

,

który działa w dzisiejszych czasach we wszystkim
https://developer.mozilla.org/ ... ility
z wyjątkiem IE:
Skrócona wersja:

Array.from({length: 20}, (x,i) => i);

Długa wersja:

Array.from(new Array(20), (x,i) => i)

co tworzy tablicę od 0 do 19 włącznie. Można go dalej zredukować do jednej z następujących form:

Array.from(Array(20).keys())

// or

[...Array(20).keys()]

Możesz również określić dolną i górną granicę, na przykład:

Array.from(new Array(20), (x,i) => i + *lowerBound*)

Artykuł opisujący to bardziej szczegółowo:

http://www.2ality.com/2014/05/ ... .html
http://www.2ality.com/2014/05/ ... .html

Anonimowy użytkownik

Potwierdzenie od:

Moja nowa ulubiona forma (

ES2015

)

Array(10).fill(1).map((x, y) => x + y)

A jeśli potrzebujesz funkcji z parametrem

step

:

const range = (start, stop, step = 1) =>

 Array(Math.ceil((stop - start)/step)).fill(start).map((x, y) => x + y * step)

Anonimowy użytkownik

Potwierdzenie od:

Oto moje 2 centy:

function range(start, count) {

 return Array.apply(0, Array(count))

 .map((element, index) => index + start);

}

Anonimowy użytkownik

Potwierdzenie od:

Działa w przypadku symboli i liczb, przechodząc do przodu lub do tyłu z dodatkowym krokiem.

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
http://jsfiddle.net/ZaZAZ/
.
Jeśli chcesz rozszerzyć własne typy, przypisz je do

Array.range

.
<div class="snippet-code snippet-currently-hidden">
<div class="snippet" data-babel="false" data-console="true" data-hide="true" data-lang="js">
<pre class="snippet-code-js lang-js prettyprint-override">

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

Anonimowy użytkownik

Potwierdzenie od:

Prosta funkcja zakresu:

function range(start, stop, step) {

 var a = [start], b = start;

 while (b < stop) {

 a.push(b += step || 1);

 }

 return a;

}

Anonimowy użytkownik

Potwierdzenie od:

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']

Anonimowy użytkownik

Potwierdzenie od:

OK,

w JavaScript nie mamy funkcji

range ()

, takiej jak

PHP

więc musimy stworzyć funkcję, która jest całkiem prostą rzeczą, piszę dla ciebie kilka funkcji jednowierszowych i oddzielam je dla

liczby

i

alfabety

jak pokazano niżej:
dla numerów:

function numberRange (start, end) {

 return new Array(end - start).fill().map((d, i) => i + start);

}

i nazwijmy to tak:

numberRange(5, 10);//[5, 6, 7, 8, 9]

dla

alfabety

:

function alphabetRange (start, end) {

 return new Array(end.charCodeAt(0) - start.charCodeAt(0)).fill().map((d, i) => String.fromCharCode(i + start.charCodeAt(0)));

}

i nazwijmy to tak:

alphabetRange('c', 'h');//["c", "d", "e", "f", "g"]

Anonimowy użytkownik

Potwierdzenie od:

Wygodna

Aby załatwić sprawę, uruchom poniższy fragment kodu
<div class="snippet-code">
<div class="snippet" data-babel="false" data-console="true" data-hide="false" data-lang="js">
<pre class="snippet-code-js lang-js prettyprint-override">

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

oto jak go używać

zakres (początek, koniec, krok = 1, przesunięcie = 0

);

inclusive-forward
```
range (5,10)// [5, 6, 7, 8, 9, 10]
```
inclusive-backward
```
range (10,5)// [10, 9, 8, 7, 6, 5]
```
cofnij się
```
range (10,2,2)// [10, 8, 6, 4, 2]
```

zakres

forward-exclusive (5,10,0, -1)// [6, 7, 8, 9] a nie 5,10 siebie

offset-expand

range (5,10,0,1)// [4, 5, 6, 7, 8, 9, 10, 11]

offset - shrink
```
range (5,10,0, -2)// [7, 8]
```

step-expand

range (10,0,2,2)// [12, 10, 8, 6, 4, 2, 0, -2]

mam nadzieję, że uznasz to za przydatne.
Oto jak to działa.
Zasadniczo najpierw obliczam długość wynikowej tablicy i tworzę tablicę wypełnioną zerami do tej długości, a następnie wypełniam ją wymaganymi wartościami

```
(krok || 1)
```
= & > i inne podobne narzędzia używają wartości
```
step
```
, a jeśli nie została podana, użyj zamiast niej
```
1
```
Zaczynamy od obliczenia długości wynikowej tablicy za pomocą
```
(Math.abs (end - start) + ((offset || 0) * 2))/(step || 1) + 1)
```
do uprościć jego (różnica * przesunięcie w obu kierunkach/kroku)
Po uzyskaniu długości tworzymy pustą tablicę z zainicjowanymi wartościami za pomocą
```
new Array (length) .fill (0);
```
check here https://stackoverflow.com/a/ 23326623/3160597
Mamy teraz tablicę
```
[0,0,0, ..]
```
odpowiadającą potrzebnej długości. Mapujemy to i zwracamy nową tablicę z wartościami, które chcemy, używając
```
Array.map (function () {})
```
```
var direction = start & < koniec 1: 0;
```
oczywiście, jeśli
```
start
```
jest nie mniejszy niż
```
end
```
, musimy cofnąć się. Mam na myśli przejście od 0 do 5 lub odwrotnie
Przy każdej iteracji
```
startPoint
```
+
```
stepSize
```
*
```
index
```
poda nam potrzebną wartość

Anonimowy użytkownik

Potwierdzenie od:

var range = (l,r) => new Array(r - l).fill().map((_,k) => k + l);

Anonimowy użytkownik

Potwierdzenie od:

Inna wersja wykorzystująca generatory ES6 (patrz.

odpowiedź wielkiego Paolo Morettiego z generatorami ES6
https://stackoverflow.com/a/31357608/5437379
):

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 ]

Lub, jeśli chcemy tylko iterowalne, to:

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

}

Anonimowy użytkownik

Potwierdzenie od:

Za pomocą

operator propagacji harmonicznej
https://developer.mozilla.org/ ... rator
i funkcje strzałkowe:

var range = (start, end) => [...Array(end - start + 1)].map((_, i) => start + i);

Przykład:

range(10, 15);

[ 10, 11, 12, 13, 14, 15 ]

Anonimowy użytkownik

Potwierdzenie od:

Zrobiłem jakieś badania na temat różnych funkcji zakresu.

Sprawdź porównanie Zobacz ten test jsperf

http://jsperf.com/javascript-range-tests
różne sposoby wykonywania tych funkcji. Oczywiście nie jest to lista idealna ani wyczerpująca, ale powinna pomóc :)

Jest zwycięzca.

..

function range(lowEnd,highEnd){

 var arr = [],

 c = highEnd - lowEnd + 1;

 while ( c-- ) {

 arr[c] = highEnd--

 }

 return arr;

}

range(0,31);

Technicznie nie jest najszybszy w Firefoksie, ale szalona różnica prędkości (imho) w Chrome to rekompensuje.
Interesujące jest również zobaczenie, o ile szybszy jest Chrome z tymi funkcjami tablicowymi niż Firefox.

Chrome jest co najmniej 4 lub 5 razy szybszy

.

Anonimowy użytkownik

Potwierdzenie od:

możesz użyć

lodash
https://lodash.com/docs#range
lub

Undescore.js
http://underscorejs.org/#range

range

:

var range = require('lodash/range')

range(10)

// -> [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]

Ponadto, jeśli chcesz tylko sekwencyjny zakres liczb całkowitych, możesz zrobić coś takiego:

Array.apply(undefined, { length: 10 }).map(Number.call, Number)

// -> [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]

W ES6

zakres

można zaimplementować z

generatory
https://developer.mozilla.org/ ... yield
:

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;

 }

}

Ta implementacja oszczędza pamięć podczas iteracji po dużych sekwencjach, ponieważ nie musi materializować wszystkich wartości w tablicy:

for (let i of range(1, oneZillion)) {

 console.log(i);

}

Anonimowy użytkownik

Potwierdzenie od:

Standardowy JavaScript nie ma wbudowanej funkcji do generowania zakresów. Kilka frameworków javascript dodaje obsługę takich funkcji, lub jak zauważyli inni, zawsze możesz uruchomić własny.
Jeśli chcesz dwukrotnie sprawdzić, ostatecznym zasobem jest

to jest standard
http://www.ecma-international. ... 2.htm
ECMA-262 .

Anonimowy użytkownik

Potwierdzenie od:

To może nie być najlepszy sposób. Ale jeśli chcesz uzyskać zakres liczb w jednym wierszu kodu. Na przykład 10-50

Array(40).fill(undefined).map((n, i) => i + 10)

Gdzie 40 to (koniec to początek), a 10 to początek. Powinien wrócić

[10, 11, ..., 50

]

Anonimowy użytkownik

Potwierdzenie od:

Ciekawym zadaniem byłoby napisanie jak najwięcej

krótki

funkcja do tego. Rekursja przyszła na ratunek!

function r(a,b){return a>b?[]:[a].concat(r(++a,b))}

Generalnie działa wolno na dużych odległościach, ale na szczęście komputery kwantowe są tuż za rogiem.
Dodatkową zaletą jest to, że jest to mylące. Ponieważ wszyscy wiemy, jak ważne jest, aby ukryć nasz kod przed wzrokiem ciekawskich.
Aby naprawdę i całkowicie zmylić funkcję, wykonaj następujące czynności:

function r(a,b){return (a<b?[a,b].concat(r(++a,--b)):a>b?[]:[a]).sort(function(a,b){return a-b})}

Anonimowy użytkownik

Potwierdzenie od:

Zakodowałbym coś takiego:

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]

Zachowuje się podobnie do zakresu Pythona:

>>> range(-4,2)

[-4, -3, -2, -1, 0, 1]

Anonimowy użytkownik

Potwierdzenie od:

Dość minimalistyczną implementację, która intensywnie wykorzystuje ES6, można stworzyć w następujący sposób, ze szczególnym uwzględnieniem metody statycznej

Array.from()

https://developer.mozilla.org/ ... /from
:

const getRange = (start, stop) => Array.from( new Array((stop - start) + 1),

 (_, i) => i + start);

Anonimowy użytkownik

Potwierdzenie od:

range (start, end, step)
: z iteratorami ES6
>
Pytasz tylko o górne i dolne granice.

Tutaj również tworzymy jeden z krokiem.

Możesz łatwo utworzyć funkcję generatora

range ()

, która może działać jako iterator. Oznacza to, że nie musisz wstępnie generować całej tablicy.

function * range ( start, end, step = 1 ) {

 let state = start;

 while ( state < end ) {

 yield state;

 state += step;

 }

 return;

};

Teraz możesz utworzyć coś, co wstępnie generuje tablicę z iteratora i zwraca listę. Jest to przydatne w przypadku funkcji, które akceptują tablice. W tym celu możemy użyć

Array.from ()

const generate_array = (start,end,step) =>

 Array.from( range(start,end,step) );

Teraz możesz łatwo wygenerować tablicę statyczną,

const array1 = generate_array(1,10,2);

const array1 = generate_array(1,7);

Ale gdy coś potrzebuje iteratora (lub daje ci możliwość użycia iteratora), możesz łatwo go również utworzyć.

for ( const i of range(1, Number.MAX_SAFE_INTEGER, 7) ) {

 console.log(i)

}

specjalna notatka
>

Jeśli używasz Ramdu, mają swój własny
```
R.range
```
, https://ramdajs.com/docs/#rangetakże Lodash https://lodash.com/docs/4.17.11#range

Anonimowy użytkownik

Potwierdzenie od:

Chociaż nie jest z

PHP

i symulowanie

range

from

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]

Anonimowy użytkownik

Potwierdzenie od:

Jeśli chodzi o tworzenie tablicy numerycznej dla danego zakresu, używam tego:

function range(start, stop)

{

 var array = []; var length = stop - start;  for (var i = 0; i <= length; i++) { 

 array[i] = start;

 start++;

 } return array;

}console.log(range(1, 7));// [1,2,3,4,5,6,7]

console.log(range(5, 10));// [5,6,7,8,9,10]

console.log(range(-2, 3));// [-2,-1,0,1,2,3]

Oczywiście to nie zadziała dla tablic alfabetycznych.

Anonimowy użytkownik

Potwierdzenie od:

Za pomocą

generatory harmonii
http://wiki.ecmascript.org/dok ... ators
,

obsługiwane przez wszystkie przeglądarki oprócz IE11
http://kangax.github.io/es5-compat-table/es6/
:

var take = function (amount, generator) {

 var a = []; try {

 while (amount) {

 a.push(generator.next());

 amount -= 1;

 }

 } catch (e) {} return a;

};var takeAll = function (gen) {

 var a = [],

 x; try {

 do {

 x = a.push(gen.next());

 } while (x);

 } catch (e) {} return a;

};var range = (function (d) {

 var unlimited = (typeof d.to === "undefined"); if (typeof d.from === "undefined") {

 d.from = 0;

 } if (typeof d.step === "undefined") {

 if (unlimited) {

 d.step = 1;

 }

 } else {

 if (typeof d.from !== "string") {

 if (d.from < d.to) {

 d.step = 1;

 } else {

 d.step = -1;

 }

 } else {

 if (d.from.charCodeAt(0) < d.to.charCodeAt(0)) {

 d.step = 1;

 } else {

 d.step = -1;

 }

 }

 } if (typeof d.from === "string") {

 for (let i = d.from.charCodeAt(0); (d.step > 0) ? (unlimited ? true : i <= d.to.charCodeAt(0)) : (i >= d.to.charCodeAt(0)); i += d.step) {

 yield String.fromCharCode(i);

 }

 } else {

 for (let i = d.from; (d.step > 0) ? (unlimited ? true : i <= d.to) : (i >= d.to); i += d.step) {

 yield i;

 }

 }

});

Próbki
>

brać
Przykład 1.

take

zajmuje tylko tyle, ile może

take(10, range( {from: 100, step: 5, to: 120} ) )

zwroty

[100, 105, 110, 115, 120]

Przykład 2.

do

jest opcjonalny

take(10, range( {from: 100, step: 5} ) )

zwroty

[100, 105, 110, 115, 120, 125, 130, 135, 140, 145]

takeAll
Przykład 3.

from

opcjonalnie

takeAll( range( {to: 5} ) )

zwroty

[0, 1, 2, 3, 4, 5]

Przykład 4.

takeAll( range( {to: 500, step: 100} ) )

zwroty

[0, 100, 200, 300, 400, 500]

Przykład 5.

takeAll( range( {from: 'z', to: 'a'} ) )

zwroty

["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"]

Anonimowy użytkownik

Potwierdzenie od:

...
większy zasięg dzięki funkcji generatora.

function range(s, e, str){

// create generator that handles numbers & strings.

 function *gen(s, e, str){

 while(s <= e){

 yield (!str) ? s : str[s]

 s++

 }

 }

 if (typeof s === 'string' && !str)

 str = 'abcdefghijklmnopqrstuvwxyz'

 const from = (!str) ? s : str.indexOf(s)

 const to = (!str) ? e : str.indexOf(e)

// use the generator and return.

 return [...gen(from, to, str)]

}// usage ...

console.log(range('l', 'w'))

//=> [ 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w' ]console.log(range(7, 12))

//=> [ 7, 8, 9, 10, 11, 12 ]// first 'o' to first 't' of passed in string.

console.log(range('o', 't', "ssshhhooooouuut!!!!"))

// => [ 'o', 'o', 'o', 'o', 'o', 'u', 'u', 'u', 't' ]// only lowercase args allowed here, but ...

console.log(range('m', 'v').map(v=>v.toUpperCase()))

//=> [ 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V' ]// => and decreasing range ...

console.log(range('m', 'v').map(v=>v.toUpperCase()).reverse())// => ... and with a step

console.log(range('m', 'v')

 .map(v=>v.toUpperCase())

 .reverse()

 .reduce((acc, c, i) => (i % 2) ? acc.concat(c) : acc, []))// ... etc, etc.

Mam nadzieję, że to będzie pomocne.

Anonimowy użytkownik

Potwierdzenie od:

Mój kolega z codegolfingu wymyślił to (ES6),
włącznie:

(s,f)=>[...Array(f-s+1)].map((e,i)=>i+s)

numery włącznie:

(s,f)=>[...Array(f-s)].map((e,i)=>i+s)

Czy JavaScript ma metodę, taką jak „range ()”, do generowania zakresu w podanych granicach?

25 odpowiedzi

Powiązane pytanie

Stan problemu

Czy JavaScript ma metodę, taką jak „range ()”, do generowania zakresu w podanych granicach?

Linki dotyczące treści

25 odpowiedzi

Powiązane pytanie

Stan problemu