Ответ 1

Вы можете сделать свою собственную повторно используемую функцию, я полагаю, для вашего примера:

function makeArray(count, content) {
   var result = [];
   if(typeof content == "function") {
      for(var i = 0; i < count; i++) {
         result.push(content(i));
      }
   } else {
      for(var i = 0; i < count; i++) {
         result.push(content);
      }
   }
   return result;
}

Тогда вы можете сделать одно из следующих:

var myArray = makeArray(8, 1);
//or something more complex, for example:
var myArray = makeArray(8, function(i) { return i * 3; });

Вы можете попробовать здесь, обратите внимание, что приведенный выше пример не полагается на jQuery вообще, чтобы вы могли его использовать без него. Вы просто ничего не получаете от библиотеки для чего-то вроде этого:)

Ответ 2

Без цикла for это решение:

Array.apply(0, Array(8)).map(function() { return 1; })

Объяснение следует.

Array(8) создает разреженный массив с 8 элементами, все undefined. Тройка apply превратит его в плотный массив. Наконец, при map мы заменим undefined (то же) значение 1.

Ответ 3

for (var i=8, a=[]; i--;) a.push(1);

Ответ 4

Использование JQuery:

$.map($(Array(8)),function(val, i) { return i; })

Это возвращает:

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

$.map($(Array(8)),function() { return 1; })

Это возвращает:

[1, 1, 1, 1, 1, 1, 1, 1]

Ответ 5

Если вы используете более новый синтаксис Javascript, то же самое может быть достигнуто с помощью:

Array(8).fill(1)

Следующее тоже хорошо работает, но, как заметил Мэтт, ключевое слово "new" является избыточным.

new Array(8).fill(1)

Ответ 6

2016 - Пришла функциональность современного браузера. Нет необходимости в jquery все время.

Array.from({length: 8}, (el, index) => 1);

Вы можете заменить функцию стрелки на простую функцию обратного вызова, чтобы охватить чуть более широкий диапазон поддерживаемых браузеров. По крайней мере, для меня это самый простой способ перебора инициализированного массива за один шаг.

Примечание: IE не поддерживается в этом решении, но для этого есть polyfill на developer.mozilla.org/...

Ответ 7

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

Массив - это список предварительно вычисленных значений. Это займет некоторое время, прежде чем можно будет использовать первое значение. И это требует большой памяти, потому что все возможные значения последовательности должны храниться в памяти. И вы должны определить верхний предел.

Это означает, что в большинстве случаев не рекомендуется создавать массив с значениями последовательностей. Вместо этого лучше реализовать последовательность как реальную последовательность, которая ограничена только длиной слова процессора.

function make_sequence (value, increment)
{
  if (!value) value = 0;
  if (!increment) increment = function (value) { return value + 1; };

  return function () {
    let current = value;
    value = increment (value);
    return current;
  };
}

i = make_sequence()
i() => 0
i() => 1
i() => 2

j = make_sequence(1, function(x) { return x * 2; })
j() => 1
j() => 2
j() => 4
j() => 8

Ответ 8

The fastest way to define an array of 8 1s is to define it-
var A= [1, 1, 1, 1, 1, 1, 1, 1];

// You'd have to need a lot of 1s to make a dedicated function worthwhile.

// Maybe in the Matrix, when you want a lot of Smiths:

Array.repeat= function(val, len){
    for(var i= len, a= []; i--; ) a[i]= val;
    return a;
}
var A= Array.repeat('Smith',100)

/*  returned value: (String)
Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith, Smith
*/

Ответ 9

Метод машинописи на основе кода Ария Хидаят:

/**
 * Generates sequence of numbers from zero.
 * @ param {number} count Count of numbers in result array.
 * @ return {Array<number>} Sequence of numbers from zero to (count - 1).
 */
public static sequence(count: number): Array<number>
{
    return Array.apply(0, Array(count)).map((x, i) =>
    {
        return i;
    });
}

Ответ 10

range(start,end,step): с помощью итераторов ES6

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

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

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

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

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

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

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

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

Ответ 11

Если, как и я, вы часто используете linspace, вы можете легко изменить свою версию linspace следующим образом:

function linSeq(x0, xN) {
    return linspace(x0, xN, Math.abs(xN-x0)+1);
}

function linspace(x0, xN, n){

    dx = (xN - x0)/(n-1);
    var x = [];
    for(var i =0; i < n; ++i){
        x.push(x0 + i*dx);
    }

    return x;
}

Затем вы можете использовать linSeq в любом направлении, например, linSeq (2,4) генерирует 2,3,4, а linSeq (4,2) генерирует 4,3,2.

Ответ 12

Генерация целочисленной последовательности - это то, что определенно должно быть более удобным в JavaScript. Вот рекурсивная функция возвращает целочисленный массив.

function intSequence(start, end, n = start, arr = []) {
  return n === end ? arr.concat(n)
    : intSequence(start, end, start < end ? n + 1 : n - 1, arr.concat(n));
}

$> intSequence(1, 1)
<- Array [ 1 ]

$> intSequence(1, 3)
<- Array(3) [ 1, 2, 3 ]

$> intSequence(3, -3)
<- Array(7) [ 3, 2, 1, 0, -1, -2, -3 ]

Ответ 13

Один лайнер:

new Array(10).fill(1).map( (_, i) => i+1 )

Урожайность:

[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]

Ответ 14

Почему бы просто просто не объединиться и не расколоться?

function seq(len, value)
{
    // create an array
    // join it using the value we want
    // split it
    return (new Array(len + 1)).join(value).split("");
}

seq(10, "a");
["a", "a", "a", "a", "a", "a", "a", "a", "a", "a"]

seq(5, 1);
["1", "1", "1", "1", "1"]