ධාවන වේලාවේදී N පමණක් දන්නා තැනක සිට 1 සිට N දක්වා ජාවාස්ක්‍රිප්ට් අරා නිර්මාණය කිරීම සඳහා මම පහත විකල්පයන් සොයමි.

var foo = [];

for (var i = 1; i <= N; i++) {
   foo.push(i);
}

මට එය දැනෙන්නේ ලූපයක් නොමැතිව මෙය කිරීමට ක්‍රමයක් තිබිය යුතු බවයි.

ඔබ පසුව ඇති දේ මට ලැබුනේ නම්, ඔබට පසුව සංඛ්‍යා 1..nලකුණක් අවශ්‍ය වේ.

ඔබට අවශ්‍ය වන්නේ මෙය නම්, ඒ වෙනුවට ඔබට මෙය කළ හැකිද?

var foo = new Array(45); // create an empty array with length 45

ඔබට එය භාවිතා කිරීමට අවශ්‍ය වූ විට ... (ප්‍රශස්තිකරණය නොකළ, උදාහරණයක් ලෙස)

for(var i = 0; i < foo.length; i++){
  document.write('Item: ' + (i + 1) + ' of ' + foo.length + '<br/>'); 
}

උදා: ඔබට ගබඩා කිරීමට අවශ්‍ය නැතිනම් අරාවෙහි කිසිවක් , ඔබට අවශ්‍ය වන්නේ නිවැරදි දිගකින් යුත් කන්ටේනරයක් ඔබට නැවත නැවත කළ හැකි ... මෙය පහසු විය හැකිය.

එය ක්‍රියාවෙන් බලන්න: http://jsfiddle.net/3kcvm/

ES6 හි () සහ යතුරු () ක්‍රම වලින් අරාව භාවිතා කිරීම.

Array.from(Array(10).keys())
//=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

පැතිරුම් ක්‍රියාකරු භාවිතා කරමින් කෙටි අනුවාදය .

[...Array(10).keys()]
//=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

() සිට සිතියම් ශ්‍රිතය අරාව වෙත යොමු කිරීමෙන් 1 සිට ආරම්භ කරන්න

Array.from(Array(10), (_, i) => i + 1)
//=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

ඔබට එසේ කළ හැකිය:

var N = 10; 
Array.apply(null, {length: N}).map(Number.call, Number)

ප්‍රති result ලය: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

හෝ අහඹු අගයන් සමඟ:

Array.apply(null, {length: N}).map(Function.call, Math.random)

ප්‍රති result ලය: [0.7082694901619107, 0.9572225909214467, 0.8586748542729765, 0.8653848143294454, 0.008339877473190427, 0.9911756622605026, 0.8133423360995948, 0.83775885535785535785580585535785535785535785535

පැහැදිලි කිරීම

පළමුව, මේ ලිපිය Number.call(undefined, N)හා සමාන වේ Number(N)කරන පමණක් ප්රතිලාභ, N. අපි පසුව එම කරුණ භාවිතා කරමු.

Array.apply(null, [undefined, undefined, undefined])ට සමාන Array(undefined, undefined, undefined)වන අතර එය මූලද්‍රව්‍ය තුනක අරාවක් නිපදවන අතර undefinedඑක් එක් මූලද්‍රව්‍යයට පවරයි .

N මූලද්‍රව්‍යයන්ට එය සාමාන්‍යකරණය කරන්නේ කෙසේද? Array()ක්‍රියා කරන ආකාරය සලකා බලන්න , එය මේ වගේ දෙයක් වේ:

function Array() {
    if ( arguments.length == 1 &&
         'number' === typeof arguments[0] &&
         arguments[0] >= 0 && arguments &&
         arguments[0] < 1 << 32 ) {
        return [ … ];  // array of length arguments[0], generated by native code
    }
    var a = [];
    for (var i = 0; i < arguments.length; i++) {
        a.push(arguments[i]);
    }
    return a;
}

ECMAScript 5 සිට , Function.prototype.apply(thisArg, argsArray)තාරා-ටයිප් කළ අරාව වැනි වස්තුවක් එහි දෙවන පරාමිතිය ලෙස පිළිගනී. අපි ආයාචනා කළහොත් Array.apply(null, { length: N })එය ක්‍රියාත්මක වේ

function Array() {
    var a = [];
    for (var i = 0; i < /* arguments.length = */ N; i++) {
        a.push(/* arguments[i] = */ undefined);
    }
    return a;
}

දැන් අපට N -element array එකක් ඇත, සෑම මූලද්‍රව්‍යයක්ම සකසා ඇත undefined. අපි .map(callback, thisArg)එය ඉල්ලා සිටින විට, එක් එක් මූලද්රව්යයේ ප්රති .ලයට සැකසෙනු ඇත callback.call(thisArg, element, index, array). එමනිසා, [undefined, undefined, …, undefined].map(Number.call, Number)එක් එක් මූලද්‍රව්‍යය සිතියම් ගත (Number.call).call(Number, undefined, index, array)කරනු ඇත Number.call(undefined, index, array), එය අප කලින් නිරීක්ෂණය කළ පරිදි ඇගයීමට සමාන වේindex . එමඟින් මූලද්‍රව්‍ය ඒවායේ දර්ශකයට සමාන වන අරාව සම්පූර්ණ කරයි.

Array.apply(null, {length: N})සාධාරණ වෙනුවට කරදරයෙන් මිදෙන්නේ ඇයි Array(N)? සියල්ලට පසු, ප්‍රකාශන දෙකෙහිම ප්‍රති -ලය වනුයේ නිර්වචනය නොකළ මූලද්‍රව්‍යයන්ගේ N- මූලද්‍රව්‍ය සමූහයකි. මෙහි ඇති වෙනස වන්නේ හිටපු ප්රකාශනය තුළ, එක් එක් මූලද්රව්යය සුවිශේෂව බව ය සකස් නිර්වචනය නොකළ කිරීමට, අග දී, එක් එක් මූලද්රව්යය කවදාවත් නියම කර තිබූ අතර. ප්‍රලේඛනයට අනුව .map():

callbackනියම කර ඇත්තේ අගයන් පවරා ඇති අරාවේ දර්ශක සඳහා පමණි; මකාදැමූ හෝ කිසි විටෙකත් අගයන් පවරා නොමැති දර්ශක සඳහා එය ආයාචනා නොකෙරේ.

එබැවින් Array(N)ප්රමාණවත් නොවේ; Array(N).map(Number.call, Number)එහි ප්‍රති result ලය වනුයේ N හි ආරම්භක නොවන අරාවකි .

අනුකූලතාව

මෙම තාක්ෂණය Function.prototype.apply()ECMAScript 5 හි නිශ්චිතව දක්වා ඇති හැසිරීම මත රඳා පවතින බැවින් , එය ක්‍රෝම් 14 සහ ඉන්ටර්නෙට් එක්ස්ප්ලෝරර් 9 වැනි පූර්ව ECMAScript බ්‍රව්සර් 5 හි ක්‍රියා නොකරනු ඇත .

ES6 භාවිතා කරන විවිධ ක්‍රම

පැතිරුම් ක්‍රියාකරු ( ...) සහ යතුරු ක්‍රමය භාවිතා කිරීම

[ ...Array(N).keys() ].map( i => i+1);

පුරවන්න / සිතියම

Array(N).fill().map((_, i) => i+1);

අරාව

Array.from(Array(N), (_, i) => i+1)

Array.from සහ { length: N }හැක්

Array.from({ length: N }, (_, i) => i+1)

සාමාන්‍යකරණය කළ පෝරමය පිළිබඳ සටහන

හැකි නිෂ්පාදන පෙලගැස්මක් ඉහත සියලු ආකාර එච්චරමයි ඕනෑම වෙනස් කිරීම මගින් අගයන් අවශ්ය කිරීමට initialised i+1අවශ්ය ප්රකාශනය කිරීමට (උදා: i*2, -i, 1+i*2, i%2හා ආදිය). කිසියම් ශ්‍රිතයකින් ප්‍රකාශනය ප්‍රකාශ කළ හැකි fනම් පළමු ස්වරූපය සරලව පෙනේ

[ ...Array(N).keys() ].map(f)

උදාහරණ:

Array.from({length: 5}, (v, k) => k+1); 
// [1,2,3,4,5]

අරාව undefinedඑක් එක් ස්ථානය සමඟ ආරම්භ කර ඇති බැවින් , එහි අගයv වනු ඇතundefined

සියලු ආකාර පෙන්වන උදාහරණය

let demo= (N) => {
  console.log(
    [ ...Array(N).keys() ].map(( i) => i+1),
    Array(N).fill().map((_, i) => i+1) ,
    Array.from(Array(N), (_, i) => i+1),
    Array.from({ length: N }, (_, i) => i+1)
  )
}

demo(5)

අභිරුචි ආරම්භක ශ්‍රිතය සමඟ වඩාත් සාමාන්‍ය උදාහරණය fඑනම්

[ ...Array(N).keys() ].map((i) => f(i))

හෝ ඊටත් වඩා සරලයි

[ ...Array(N).keys() ].map(f)

let demo= (N,f) => {
  console.log(
    [ ...Array(N).keys() ].map(f),
    Array(N).fill().map((_, i) => f(i)) ,
    Array.from(Array(N), (_, i) => f(i)),
    Array.from({ length: N }, (_, i) => f(i))
  )
}

demo(5, i=>2*i+1)

අරා සහජයෙන්ම ඒවායේ දිග කළමනාකරණය කරයි. ඒවා ගමන් කරන විට, ඒවායේ දර්ශක මතකයේ තබාගෙන එම අවස්ථාවේදී යොමු කළ හැකිය. අහඹු දර්ශකයක් දැන ගැනීමට අවශ්‍ය නම්, indexOfක්‍රමය භාවිතා කළ හැකිය.

මෙය ඔබගේ අවශ්‍යතා සඳහා යම් ප්‍රමාණයක පෙළක් ප්‍රකාශ කිරීමට අවශ්‍ය විය හැකිය:

var foo = new Array(N);   // where N is a positive integer

/* this will create an array of size, N, primarily for memory allocation, 
   but does not create any defined values

   foo.length                                // size of Array
   foo[ Math.floor(foo.length/2) ] = 'value' // places value in the middle of the array
*/

ES6

බෝ වීම

පැතිරීමේ ක්‍රියාකරු ( ...) සහ keysක්‍රමය භාවිතා කිරීමෙන්, දර්ශක නිපදවීම සඳහා තාවකාලික N ප්‍රමාණයේ ශ්‍රේණියක් නිර්මාණය කිරීමට ඔබට හැකි වන අතර, පසුව ඔබේ විචල්‍යයට පැවරිය හැකි නව අරාවක්:

var foo = [ ...Array(N).keys() ];

පුරවන්න / සිතියම

ඔබට මුලින්ම ඔබට අවශ්‍ය අරාවෙහි ප්‍රමාණය සෑදිය හැකිය, එය නිර්වචනය නොකළ ඒවා පුරවා නව අරාවක් භාවිතා mapකර එක් එක් මූලද්‍රව්‍ය දර්ශකයට සකසයි.

var foo = Array(N).fill().map((v,i)=>i);

අරාව

මෙය N ප්‍රමාණයේ දිගට ආරම්භ කිරීම සහ අරාව එක් වර්‍ගයක ජනගහනය කිරීම විය යුතුය.

Array.from({ length: N }, (v, i) => i)

අදහස් හා ව්‍යාකූලත්වය වෙනුවට, ඉහත උදාහරණ වල 1..N වෙතින් අගයන් ග්‍රහණය කර ගැනීමට ඔබට සැබවින්ම අවශ්‍ය නම්, විකල්ප කිහිපයක් තිබේ:

1. දර්ශකය තිබේ නම්, ඔබට එය එකකින් වැඩි කළ හැකිය (උදා:) ++i.

2. දර්ශකය භාවිතා නොකරන අවස්ථාවන්හිදී - සහ වඩාත් කාර්යක්ෂම ක්‍රමයක් - ඔබේ අරාව නිර්මාණය කිරීම, නමුත් N N + 1 නිරූපණය කිරීම, ඉන්පසු ඉදිරිපසින් මාරුවීම.

   එබැවින් ඔබ අංක 100 ක් කැමති නම්:

   let arr; (arr=[ ...Array(101).keys() ]).shift()

ES6 හි ඔබට කළ හැක්කේ:

Array(N).fill().map((e,i)=>i+1);

http://jsbin.com/molabiluwa/edit?js,console

සංස්කරණය කරන්න: ඔබ ප්‍රශ්නය යාවත්කාලීන කළ දින සිට වෙනස් Array(45)කරන Array(N)ලදි.

console.log(
  Array(45).fill(0).map((e,i)=>i+1)
);

ඉතා ජනප්‍රිය Underscore _.range ක්‍රමය භාවිතා කරන්න

// _.range([start], stop, [step])

_.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]
_.range(0); // => []

function range(start, end) {
    var foo = [];
    for (var i = start; i <= end; i++) {
        foo.push(i);
    }
    return foo;
}

පසුව කැඳවනු ලැබේ

var foo = range(1, 5);

ජාවාස්ක්‍රිප්ට් හි මෙය සිදු කිරීම සඳහා කිසිදු ක්‍රමයක් නොමැත, නමුත් ඔබට එය එක් වරකට වඩා කිරීමට අවශ්‍ය නම් එය නිර්මාණය කිරීම සඳහා පරිපූර්ණ වලංගු උපයෝගීතා කාර්යයකි.

සංස්කරණය කරන්න: මගේ මතය අනුව, පහත දැක්වෙන්නේ වඩා හොඳ පරාසයක ශ්‍රිතයකි. සමහර විට මම ලින්ක් පක්ෂග්‍රාහීව සිටින නිසා විය හැකිය, නමුත් එය තවත් අවස්ථා වලදී වඩාත් ප්‍රයෝජනවත් යැයි මම සිතමි. ඔබගේ සැතපුම් ගණන වෙනස් විය හැකිය.

function range(start, count) {
    if(arguments.length == 1) {
        count = start;
        start = 0;
    }

    var foo = [];
    for (var i = 0; i < count; i++) {
        foo.push(start + i);
    }
    return foo;
}

Arrayv8 පිරවීම සඳහා වේගවත්ම ක්‍රමය නම්:

[...Array(5)].map((_,i) => i);

ප්‍රති result ලය වනු ඇත්තේ: [0, 1, 2, 3, 4]

මෙම ප්‍රශ්නයට සංකීර්ණ පිළිතුරු රාශියක් ඇත, නමුත් සරල එක් ලයිනර්:

[...Array(255).keys()].map(x => x + 1)

එසේම, ඉහත ලිවීමට කෙටි (හා පිළිවෙලට) තිබුණද, පහත දැක්වෙන දේ ටිකක් වේගවත් යැයි මම සිතමි (උපරිම දිග සඳහා:

127, Int8,

255, Uint8,

32,767, Int16,

65,535, Uint16,

2,147,483,647, Int32,

4,294,967,295, යූන්ට් 32.

( උපරිම නිඛිල අගයන් මත පදනම්ව ), ටයිප් කළ අරා පිළිබඳ වැඩි විස්තර මෙහි ඇත ):

(new Uint8Array(255)).map(($,i) => i + 1);

මෙම විසඳුම ද එතරම් පරමාදර්ශී නොවුනත්, එය අරා දෙකක් නිර්මාණය කරන අතර අතිරේක විචල්‍ය ප්‍රකාශය "$" භාවිතා කරයි (මෙම ක්‍රමය භාවිතා කර එය වටා යාමට කිසිදු ක්‍රමයක් විශ්වාස නැත). මෙය කළ හැකි නිරපේක්ෂ වේගවත්ම ක්‍රමය පහත දැක්වෙන විසඳුම යැයි මම සිතමි.

for(var i = 0, arr = new Uint8Array(255); i < arr.length; i++) arr[i] = i + 1;

මෙම ප්‍රකාශය කළ පසු ඕනෑම වේලාවක, ඔබට වර්තමාන විෂය පථය තුළ "අර" විචල්‍යය භාවිතා කළ හැකිය;

ඔබට එයින් සරල කාර්යයක් කිරීමට අවශ්‍ය නම් (මූලික සත්‍යාපනය සමඟ):

function range(min, max) {
    min = min && min.constructor == Number ? min : 0;
    !(max && max.constructor == Number && max > min) && // boolean statements can also be used with void return types, like a one-line if statement.
        ((max = min) & (min = 0));  //if there is a "max" argument specified, then first check if its a number and if its graeter than min: if so, stay the same; if not, then consider it as if there is no "max" in the first place, and "max" becomes "min" (and min becomes 0 by default)

    for(var i = 0, arr = new (
        max < 128 ? Int8Array : 
        max < 256 ? Uint8Array :
        max < 32768 ? Int16Array : 
        max < 65536 ? Uint16Array :
        max < 2147483648 ? Int32Array :
        max < 4294967296 ? Uint32Array : 
        Array
    )(max - min); i < arr.length; i++) arr[i] = i + min;
    return arr;
}



//and you can loop through it easily using array methods if you want
range(1,11).forEach(x => console.log(x));

//or if you're used to pythons `for...in` you can do a similar thing with `for...of` if you want the individual values:
for(i of range(2020,2025)) console.log(i);

//or if you really want to use `for..in`, you can, but then you will only be accessing the keys:

for(k in range(25,30)) console.log(k);

console.log(
    range(1,128).constructor.name,
    range(200).constructor.name,
    range(400,900).constructor.name,
    range(33333).constructor.name,
    range(823, 100000).constructor.name,
    range(10,4) // when the "min" argument is greater than the "max", then it just considers it as if there is no "max", and the new max becomes "min", and "min" becomes 0, as if "max" was never even written
);

එබැවින්, ඉහත ශ්‍රිතය සමඟ, ඉහත සුපිරි මන්දගාමී “සරල එක්-ලයිනර්” සුපිරි වේගවත්, ඊටත් වඩා කෙටි වේ:

range(1,14000);

ඔබට මෙය භාවිතා කළ හැකිය:

new Array(/*any number which you want*/)
    .join().split(',')
    .map(function(item, index){ return ++index;})

උදාහරණයක් වශයෙන්

new Array(10)
    .join().split(',')
    .map(function(item, index){ return ++index;})

පහත දැක්වෙන අරාව නිර්මාණය කරයි:

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

ES6 මෙය උපක්‍රමය කරයි:

[...Array(12).keys()]

ප්‍රති result ලය බලන්න:

[...Array(12).keys()].map(number => console.log(number))

මම මෙන් ඔබේ යෙදුමේ ඔබ d3.js භාවිතා කරන්නේ නම් , D3 ඔබට උපකාරක කාර්යයක් සපයයි.

එබැවින් 0 සිට 4 දක්වා අරාවක් ලබා ගැනීම සඳහා එය පහසු ය:

d3.range(5)
[0, 1, 2, 3, 4]

ඔබ ඉල්ලූ පරිදි 1 සිට 5 දක්වා අරාවක් ලබා ගැනීමට:

d3.range(1, 5+1)
[1, 2, 3, 4, 5]

වැඩි විස්තර සඳහා මෙම නිබන්ධනය බලන්න .

ES2015 / ES6 පැතිරුම් ක්‍රියාකරු භාවිතා කිරීම

[...Array(10)].map((_, i) => i + 1)

console.log([...Array(10)].map((_, i) => i + 1))

සංඛ්‍යා සමූහයක් ජනනය කිරීමේ වේගවත්ම ක්‍රමය මෙය විය හැකිය

කෙටිම

var a=[],b=N;while(b--)a[b]=b+1;

පෙළට

var arr=(function(a,b){while(a--)b[a]=a;return b})(10,[]);
//arr=[0,1,2,3,4,5,6,7,8,9]

ඔබට 1 සිට ආරම්භ කිරීමට අවශ්‍ය නම්

var arr=(function(a,b){while(a--)b[a]=a+1;return b})(10,[]);
//arr=[1,2,3,4,5,6,7,8,9,10]

ශ්‍රිතයක් අවශ්‍යද?

function range(a,b,c){c=[];while(a--)c[a]=a+b;return c}; //length,start,placeholder
var arr=range(10,5);
//arr=[5,6,7,8,9,10,11,12,13,14]

ඇයි?

1. while වේගවත්ම ලූපයයි

2. සෘජු සැකසුම වඩා වේගවත් ය push

3. [] වඩා වේගවත් new Array(10)

4. එය කෙටි ... පළමු කේතය බලන්න. ඉන්පසු මෙහි ඇති අනෙකුත් සියලුම කාර්යයන් දෙස බලන්න.

ඔයා නැතුව ජීවත් වෙන්න බෑ වගේ නම් සඳහා

for(var a=[],b=7;b>0;a[--b]=b+1); //a=[1,2,3,4,5,6,7]

හෝ

for(var a=[],b=7;b--;a[b]=b+1); //a=[1,2,3,4,5,6,7]

ඔබ lodash භාවිතා කරන්නේ නම්, ඔබ භාවිතා කළ හැකිය _.range :

_.range([start=0], end, [step=1])

ආරම්භයේ සිට අවසානය දක්වා ඉදිරියට යන නමුත් සංඛ්‍යා ඇතුළත් (ධනාත්මක සහ / හෝ negative ණ) සංඛ්‍යා සමූහයක් නිර්මාණය කරයි. අවසානයක් හෝ පියවරක් නොමැතිව සෘණ ආරම්භයක් නියම කර ඇත්නම් -1 පියවරක් භාවිතා වේ. අවසානය නිශ්චිතව දක්වා නොමැති නම්, එය ආරම්භයෙන් ආරම්භ කර 0 ලෙස සකසා ඇත.

උදාහරණ:

_.range(4);
// ➜ [0, 1, 2, 3]

_.range(-4);
// ➜ [0, -1, -2, -3]

_.range(1, 5);
// ➜ [1, 2, 3, 4]

_.range(0, 20, 5);
// ➜ [0, 5, 10, 15]

_.range(0, -4, -1);
// ➜ [0, -1, -2, -3]

_.range(1, 4, 0);
// ➜ [1, 1, 1]

_.range(0);
// ➜ []

පිරවීම සඳහා නව ක්‍රමය Array:

const array = [...Array(5).keys()]
console.log(array)

ප්‍රති result ලය වනු ඇත්තේ: [0, 1, 2, 3, 4]

ES6 සමඟ ඔබට කළ හැක්කේ:

// `n` is the size you want to initialize your array
// `null` is what the array will be filled with (can be any other value)
Array(n).fill(null)

අවසාන සාරාංශ වාර්තාව .. Drrruummm Rolll -

මේ වන කෙටිම කේතය ප්රමාණය එන් (මෙහි 10) ක Array උත්පාදනය කිරීමට ES6 භාවිතා නොකර . ඉහත කොකෝගේ අනුවාදය සමීප නමුත් කෙටිම නොවේ.

(function(n){for(a=[];n--;a[n]=n+1);return a})(10)

නමුත් මෙම කේත ගොල්ෆ් ක්‍රීඩාවේ අවිවාදිත ජයග්‍රාහකයා (ප්‍රභව කේතයේ අවම බයිට් කිහිපයකින් විශේෂිත ගැටළුවක් විසඳීමේ තරගය) නිකෝ රූට්සාලයිනන් ය . Array Constructor සහ ES6 පැතිරුම් ක්‍රියාකරු භාවිතා කිරීම . (බොහෝ ES6 සින්ටැක්ස් වලංගු ටයිප් ස්ක්‍රිප්ට් වේ, නමුත් පහත දැක්වෙන්නේ නැත. එබැවින් එය භාවිතා කරන විට විනිශ්චය කරන්න)

[...Array(10).keys()]

එහි භාවිතා ES6 තවත් ක්රමයකි Array.from 2 තර්ක කාලයක් ගතවේ, පළමු වන arrayLike (මෙම නඩුවේ වස්තුවක් lengthදේපල), දෙවැන්නා සිතියම් ශ්රිතයක් වේ (මෙම අවස්ථාවේදී අපි එහි දර්ශකය අයිතමය සිතියම්ගත)

Array.from({length:10}, (v,i) => i)

මෙය කෙටි වන අතර ඉරට්ටේ සංඛ්‍යා උත්පාදනය වැනි වෙනත් අනුක්‍රම සඳහා භාවිතා කළ හැකිය

Array.from({length:10}, (v,i) => i*2)

මෙය වෙනත් බොහෝ ක්‍රමවලට වඩා හොඳ කාර්ය සාධනයක් ඇති බැවින් එය අරාව හරහා එක් වරක් පමණක් ලූප වේ. සමහර සැසඳීම් සඳහා ස්නිපිට් පරීක්ෂා කරන්න

// open the dev console to see results

count = 100000

console.time("from object")
for (let i = 0; i<count; i++) {
  range = Array.from({length:10}, (v,i) => i )
}
console.timeEnd("from object")

console.time("from keys")
for (let i =0; i<count; i++) {
  range = Array.from(Array(10).keys())
}
console.timeEnd("from keys")

console.time("apply")
for (let i = 0; i<count; i++) {
  range = Array.apply(null, { length: 10 }).map(function(element, index) { return index; })
}
console.timeEnd("apply")

ES6 හි:

Array.from({length: 1000}, (_, i) => i).slice(1);

හෝ වඩා හොඳ තවමත් (අතිරේක විචල්‍යය නොමැතිව _ සහ අතිරේක sliceඇමතුමකින් තොරව ):

Array.from({length:1000}, Number.call, i => i + 1)

හෝ තරමක් වේගවත් ප්‍රති results ල සඳහා, ඔබේ ලැයිස්තුව ප්‍රති results ල 256 ට වඩා කෙටි නම් ඔබට Uint8Array භාවිතා කළ හැකිය (නැතහොත් ලැයිස්තුව කෙතරම් කෙටිද යන්න මත පදනම්ව ඔබට වෙනත් Uint ලැයිස්තු භාවිතා කළ හැකිය, උපරිම අංක 65535 සඳහා Uint16 හෝ උපරිම සඳහා Uint32 වැනි 4294967295 යනාදිය. නිල වශයෙන්, මෙම ටයිප් කළ අරා එකතු කරන ලද්දේ ඊඑස් 6 හි පමණි ). උදාහරණයක් වශයෙන්:

Uint8Array.from({length:10}, Number.call, i => i + 1)

ES5:

Array.apply(0, {length: 1000}).map(function(){return arguments[1]+1});

විකල්පයක් ලෙස, ES5 හි, සිතියම් ක්‍රියාකාරිත්වය සඳහා ( Array.fromඉහත ES6 හි ශ්‍රිතයේ දෙවන පරාමිතිය වැනි ), ඔබට Number.call භාවිතා කළ හැකිය

Array.apply(0,{length:1000}).map(Number.call,Number).slice(1)

නැත්නම්, ඔබ විරුද්ධ නම් .slice මෙහි ද , ඔබට ඉහත සඳහන් කළ ES5 ට සමාන (ES6 වෙතින්) කළ හැකිය:

Array.apply(0,{length:1000}).map(Number.call, Function("i","return i+1"))

නව අරා ක්‍රම භාවිතා කිරීම සහ =>ES6 ප්‍රමිතියෙන් ක්‍රියාකාරී සින්ටැක්ස් භාවිතා කිරීම (ලියන අවස්ථාවේ ෆයර්ෆොක්ස් පමණි).

සිදුරු පිරවීමෙන් undefined:

Array(N).fill().map((_, i) => i + 1);

Array.from"සිදුරු" බවට පත් undefinedකිරීම Array.mapඅපේක්ෂිත පරිදි ක්‍රියා කරයි:

Array.from(Array(5)).map((_, i) => i + 1)

for(var i,a=[i=0];i<10;a[i++]=i);

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

මෙම සම්පූර්ණ පිළිතුරු ලැයිස්තුවේ දැනට නොමැති එකම රසය ජනක යන්ත්‍රයක් බව පෙනේ; එබැවින් එයට පිළියමක් ලෙස:

const gen = N => [...(function*(){let i=0;while(i<N)yield i++})()]

මෙසේ භාවිතා කළ හැකිය:

gen(4) // [0,1,2,3]

මෙහි ඇති හොඳ දෙය නම් ඔබ වැඩි කළ යුතු නොවේ ... igor-shubin දුන් පිළිතුරෙන් ආශ්වාදයක් ලබා ගැනීම සඳහා, ඔබට ඉතා පහසුවෙන් අහඹු ලෙස නිර්මාණය කළ හැකිය:

const gen = N => [...(function*(){let i=0;
  while(i++<N) yield Math.random()
})()]

දිගුකාලීන මෙහෙයුම් මිල අධික දෙයක් වෙනුවට :

const slow = N => new Array(N).join().split(',').map((e,i)=>i*5)
// [0,5,10,15,...]

ඔබට ඒ වෙනුවට කළ හැකිය:

const fast = N => [...(function*(){let i=0;while(i++<N)yield i*5})()]

තවත් ES6 අනුවාදයක් පමණි.

Array.fromදෙවන විකල්ප තර්කය භාවිතා කිරීමෙන් :

Array.from (arrayLike [, mapFn [, thisArg]])

හිස් Array(10)ස්ථාන වලින් අපට අංකිත අරාව සෑදිය හැකිය :

Array.from(Array(10), (_, i) => i)

var arr = Array.from(Array(10), (_, i) => i);
document.write(arr);

Iterable භාවිතා අනුවාදය ජනකය වෙනස් නොවන බව උත්සවය Number.prototype.

function sequence(max, step = 1) {
  return {
    [Symbol.iterator]: function* () {
      for (let i = 1; i <= max; i += step) yield i
    }
  }
}

console.log([...sequence(10)])

Array.from({ length: (stop - start) / step + 1}, (_, i) => start + (i * step));

මුලාශ්‍රය: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from

Object.keys(Array.apply(0, Array(3))).map(Number)

ප්‍රතිලාභ [0, 1, 2]. ඊගෝර් ෂුබින්ගේ විශිෂ්ට පිළිතුරට බොහෝ සමාන ය , නමුත් තරමක් අඩු උපක්‍රම සහිතව (සහ එක් චරිතයක් දිගු).

පැහැදිලි කිරීම:

• Array(3) // [undefined × 3]දිග n = 3 අරාවක් ජනනය කරන්න. අවාසනාවට මෙම අරාව අපට බොහෝ දුරට නිෂ් less ල ය, එබැවින් අපට…
• Array.apply(0,Array(3)) // [undefined, undefined, undefined]අරාව නැවත කළ හැකි කරන්න. සටහන: අයදුම් කිරීමේ පළමු ආරුක්කුව මෙන් ශුන්‍යය වඩාත් සුලභ නමුත් 0 කෙටි වේ.
• Object.keys(Array.apply(0,Array(3))) // ['0', '1', '2'] ඉන්පසු අරාවේ යතුරු ලබා ගන්න (ක්‍රියා කරන්නේ අරා යනු යතුරු සඳහා වන දර්ශක සහිත වස්තුවකි.
• Object.keys(Array.apply(0,Array(3))).map(Number) // [0, 1, 2] යතුරු හරහා සිතියම් ගත කරන්න, නූල් සංඛ්‍යා බවට පරිවර්තනය කරයි.

Array(8).fill(0).map(Number.call, Number)

Igors Number.callඋපක්‍රම සොරකම් කිරීම නමුත් fill()තරමක් කෙටි කිරීමට භාවිතා කිරීම. ES6 සහ ඊට ඉහළින් පමණක් ක්‍රියා කරයි.