Есть ли в JavaScript метод типа "range()" для генерации диапазона в заданных границах?

В PHP вы можете делать...

range(1, 3); // Array(1, 2, 3)
range("A", "C"); // Array("A", "B", "C")

То есть, существует функция, которая позволяет получить диапазон чисел или символов, передавая верхнюю и нижнюю границы.

Есть ли что-нибудь встроенное в JavaScript для этого? Если нет, то как мне это реализовать?

Evan Carroll
Редактировал вопрос 10-го марта 2018 в 9:37
Программирование
arrays javascript
9-го октября 2010 в 2:37
23 просмотров
Комментарии к вопросу (9)

Числа 

[...Array(5).keys()];
 => [0, 1, 2, 3, 4]

Итерационный характер

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

Ите

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"

Функции

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

Как типизированные функции

function range(size:number, startAt:number = 0):ReadonlyArray {
    return [...Array(size).keys()].map(i => i + startAt);
}

function characterRange(startChar:string, endChar:string):ReadonlyArray {
    return String.fromCharCode(...range(endChar.charCodeAt(0) -
            startChar.charCodeAt(0), startChar.charCodeAt(0)))
}

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"

Старые номера браузеры на ES6 без библиотеки: 

Array.apply(null, Array(5)).map(function (_, i) {return i;});
 => [0, 1, 2, 3, 4]

в 

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

в

Спасибо.

(Кредит на ES6 Нильса petersohn и в других комментариях)

Ben
Редактировал ответ 12-го апреля 2019 в 5:03
Комментарии (16)

Для чисел можно использовать массив ЕС6.от(), который работает все эти дни, кроме IE:

Сокращенный вариант:

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

Более длинная версия:

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

которая создает массив от 0 до 19 включительно. Это может быть сокращено к одной из этих форм:

Array.from(Array(20).keys())
// or
[...Array(20).keys()]

Нижняя и верхняя границы можно задать, например: 

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

Статья, описывающая это более подробно: http://www.2ality.com/2014/05/es6-array-methods.html

Комментарии (12)

Моя новая любимая форма (ES2015)

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

И если вам нужна функция с шагом парам:

const range = (start, stop, step = 1) =>
  Array(Math.ceil((stop - start) / step)).fill(start).map((x, y) => x + y * step)
Kutyel
Редактировал ответ 6-го января 2019 в 6:06
Комментарии (6)

Здесь's Мои 2 цента:

function range(start, count) {
  return Array.apply(0, Array(count))
    .map((element, index) => index + start);
}
Kutyel
Редактировал ответ 18-го марта 2019 в 7:24
Комментарии (2)
Решение

Он работает для символов и цифр, переходя вперед или назад с дополнительным шагом.


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  0 ? end >= start : end
Комментарии (0)

Простая функция диапазон:

function range(start, stop, step) {
    var a = [start], b = start;
    while (b < stop) {
        a.push(b += step || 1);
    }
    return a;
}

Для включения BitInt тип данных некоторые проверки могут быть включены, гарантируя, что все переменные имеют одинаковые typeof на старт:

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;
}
Peter Krauss
Редактировал ответ 8-го октября 2019 в 7:24
Комментарии (3)
 

Array.range= function(a, b, step){
    var A= [];
    if(typeof a== 'number'){
        A[0]= a;
        step= step || 1;
        while(a+step
Комментарии (1)

ОК, в JavaScript, мы не'т у `диапазон () функция, как РНР, поэтому нам нужно создать функцию, которая является довольно легким делом, я пишу пару однострочных функций для вас и разделить их на числа и алфавиты как ниже:

по числа:

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

и назвали это так:

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

для алфавиты:

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

и назвали это так:

alphabetRange('c', 'h'); //["c", "d", "e", "f", "g"]
Комментарии (1)

Удобный функция, чтобы сделать трюк, выполнить фрагмент кода ниже

в 

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

в

вот как использовать его

диапазон (начало, конец, Шаг=1, смещение=0);

  • включено - спектр "вперед"(5,10) // [5, 6, 7, 8, 9, 10]`
  • включено - спектр отсталых (10,5) // [10, 9, 8, 7, 6, 5] шаг назад спектр(10,2,2) // [10, 8, 6, 4, 2]
  • эксклюзив - вперед `спектр(5,10,0,-1) // [6, 7, 8, 9] не 5,10 себя
  • смещение - расширить диапазон(5,10,0,1) // [4, 5, 6, 7, 8, 9, 10, 11]`
  • смещение - сокращения диапазона(5,10,0,-2) // [7, 8]`
  • шаг - расширить диапазон(10,0,2,2) // [12, 10, 8, 6, 4, 2, 0, -2]`

надеемся, что вы найдете ее полезной.

И вот как это работает.

В основном я'м сначала вычисляется длина результирующего массива и создать нулевой заполненный массив до той длины, затем заполнить его с необходимыми значениями

  • (Шаг || 1) => и других, как это означает использовать значение шаг и если это не было предусмотрено использовать 1 вместо
  • Мы начнем с вычисления длины массива результата, используя (математика.АБС(конец - начало) + ((офсет|| 0) * 2)) / (Шаг || 1) + 1), чтобы положить его проще (разница* смещение в обоих направлениях/шаг)
  • После того, как длина, то мы создаем пустой массив инициализировать значения с помощью новый массив(длина).заполнения(0); посмотреть здесь
  • Теперь у нас есть массив [0,0,0,..] длины мы хотим. Мы карту за это и возвращает новый массив со значениями, нам нужно с помощью массива.карта(функция() {})`
  • ВАР направлении = начало < конец ? 1 : 0; очевидно, что если "старт" не меньше чем "конец", мы должны двигаться назад. Я имею в виду от 0 до 5 или наоборот
  • На каждой итерации, startingPoint + шага * индекс дает нам значение нужно
Комментарии (6)
var range = (l,r) => new Array(r - l).fill().map((_,k) => k + l);
Комментарии (6)

Используя гармонии распространения оператора и стрелочные функции:

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

Пример:

range(10, 15);
[ 10, 11, 12, 13, 14, 15 ]
Комментарии (4)

Стандартный Javascript не имеет встроенной функции для генерации диапазонов. Несколько фреймворков javascript добавляют поддержку таких функций, или, как отметили другие, вы всегда можете создать свою собственную.

Если вы хотите перепроверить, то окончательным ресурсом является ECMA-262 Standard.

Комментарии (4)

Сделал некоторые исследования на различные функции интервала. Проверка на см. Этот тест jsperf сравнения различные способы выполнения этих функций. Конечно, не идеальный или полный перечень, но должно помочь :)

Победитель...

function range(lowEnd,highEnd){
    var arr = [],
    c = highEnd - lowEnd + 1;
    while ( c-- ) {
        arr[c] = highEnd--
    }
    return arr;
}
range(0,31);

Технически не самый быстрый на Firefox, но сумасшедшая разница в скорости (имхо) на Хром составляет для него.

Также Интересное наблюдение: насколько быстрее хрома с этими функциями массива, чем Firefox. Chrome-это, по крайней мере 4 или 5 раз быстрее.

Комментарии (1)

Вы можете использовать лодашь или Undescore.js диапазон:

var range = require('lodash/range')
range(10)
// -> [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]

Кроме того, если вам нужны только ряд последовательных чисел, вы можете сделать что-то вроде:

Array.apply(undefined, { length: 10 }).map(Number.call, Number)
// -> [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]

В ЕС6 спектр может быть реализован с генераторы:

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

Эта реализация позволяет экономить память при переборе больших последовательностей, потому что он не'т иметь, чтобы материализовать все значения в массив:

for (let i of range(1, oneZillion)) {
  console.log(i);
}
Комментарии (3)

Еще один вариант использование генераторов на ES6 ( см. великий Паоло Моретти ответа с генераторами на ES6 ):


const RANGE = (a,b) => Array.from((function*(x,y){
  while (x
Hero Qu
Редактировал ответ 19-го августа 2019 в 1:17
Комментарии (0)

Интересная задача будет состоять в том, чтобы написать короткие функция для этого. Рекурсия к спасению!

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

Имеет тенденцию быть медленным на больших диапазонах, но, к счастью, квантовые компьютеры не за горами.

Дополнительным бонусом является то, что она'ы путанными. Потому что мы все знаем, как важно, чтобы прятать код от посторонних глаз.

Чтобы совершенно скрыть функцию, сделайте следующее:

function r(a,b){return (ab?[]:[a]).sort(function(a,b){return a-b})}
Комментарии (2)

Я бы что-то вроде этого код:

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]

Он ведет себя аналогично серии питон:

>>> range(-4,2)
[-4, -3, -2, -1, 0, 1]
Комментарии (0)

Довольно минималистичный реализации, которые в значительной степени работают на ES6 может быть создан следующим образом, обращая особое внимание на массив .от() статический метод:

const getRange = (start, stop) => Array.from(
  new Array((stop - start) + 1),
  (_, i) => i + start
);
Комментарии (2)

Хотя это не из РНР, но имитация "колеблются" от питон.

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]
Комментарии (1)

диапазон(начало,конец,шаг): с ЕС6 итераторы

Вы только попросите верхней и нижней границ. Здесь мы зделаем тоже шаг.

Вы можете легко создавать диапазона (функция генератор), который может функционировать в качестве итератора. Это означает, что вы Дон'т придется предварительно генерировать весь массив.

function * range ( start, end, step = 1 ) {
  let state = start;
  while ( state < end ) {
    yield state;
    state += step;
  }
  return;
};

Теперь вы можете создать что-то, что предварительно генерирует массив из итератора и возвращает список. Это полезно для функции, которые принимают массив. Для этого можно использовать массив.из()`

const generate_array = (start,end,step) =>
  Array.from( range(start,end,step) );

Теперь вы можете легко создавать статический массив,

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

Но когда что-то желания итератор (или дает возможность использовать итератор) вы можете легко создать.

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

Особые Примечания

Evan Carroll
Редактировал ответ 1-го марта 2019 в 4:28
Комментарии (0)