PHP හි, ඔබට කළ හැකිය ...

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

එනම්, ඉහළ සහ පහළ සීමාවන් පසුකරමින් ඔබට සංඛ්‍යා හෝ අක්ෂර පරාසයක් ලබා ගැනීමට ඉඩ සලසන ශ්‍රිතයක් ඇත.

මේ සඳහා ස්වදේශීයව ජාවාස්ක්‍රිප්ට් සඳහා සාදන ලද යමක් තිබේද? එසේ නොවේ නම්, මම එය ක්‍රියාත්මක කරන්නේ කෙසේද?

අංක

[...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<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()ශ්‍රිතය

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

පුස්තකාලයක් නොමැති පැරණි එස් 6 නොවන බ්‍රව්සර්:

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

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

(නිල්ස් පීටර්සෝන් සහ වෙනත් විචාරකයින්ට ES6 ණය)

අංක සඳහා ඔබට ES6 භාවිතා කළ හැකිය Array.from(), එය 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

මගේ නව ප්‍රියතම පෝරමය ( ES2015 )

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

ඔබට stepපරාමිතියක් සහිත ශ්‍රිතයක් අවශ්‍ය නම් :

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

මෙන්න මගේ ශත 2:

function range(start, count) {
  return Array.apply(0, Array(count))
    .map((element, index) => index + start);
}

එය අක්ෂර සහ සංඛ්‍යා සඳහා ක්‍රියා කරයි, විකල්ප පියවරක් සමඟ ඉදිරියට හෝ පසුපසට යයි.

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 .

ස්වදේශීය වර්ග වැඩි කිරීම ඔබේ දෙයක් නම්, එය පවරන්න Array.range.

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

සරල පරාස ශ්‍රිතය:

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

සංස්ථාගත කිරීම සඳහා වූ මෙම BitInt දත්ත ටයිප් සියලු විචල්යයන් එකම බව සහතික, සමහර චෙක්පත් ඇතුළත් කළ හැකිය typeof 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;
}

stopඋදා. range(0,5,2)මගින් අර්ථ දක්වා ඇති අගයන් ඉවත් කිරීමට ඇතුළත් 6විය යුතුය.

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

හරි, ජාවාස්ක්‍රිප්ට් හි අපට PHPrange() වැනි ශ්‍රිතයක් නොමැත , එබැවින් අපට ශ්‍රිතය සෑදිය යුතුය, එය ඉතා පහසු දෙයකි, මම ඔබ වෙනුවෙන් එක්-පේළි ශ්‍රිත කිහිපයක් ලියා ඒවා අංක සහ අක්ෂර සඳහා පහත පරිදි වෙන් කරමි:

අංක සඳහා :

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

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

උපක්‍රමය කිරීමට පහසු කාර්යයක්, පහත කේත ස්නිපටය ධාවනය කරන්න

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

• ඇතුළත් - ඉදිරියට range(5,10) // [5, 6, 7, 8, 9, 10]
• ඇතුළත් - පසුගාමී range(10,5) // [10, 9, 8, 7, 6, 5]
• පියවර - පසුපසට range(10,2,2) // [10, 8, 6, 4, 2]
• සුවිශේෂී - ඉදිරියට range(5,10,0,-1) // [6, 7, 8, 9] not 5,10 themselves
• ඕෆ්සෙට් - පුළුල් කරන්න range(5,10,0,1) // [4, 5, 6, 7, 8, 9, 10, 11]
• ඕෆ්සෙට් - හැකිලීම range(5,10,0,-2) // [7, 8]
• පියවර - පුළුල් කරන්න range(10,0,2,2) // [12, 10, 8, 6, 4, 2, 0, -2]

ඔබට එය ප්‍රයෝජනවත් වේ යැයි සිතමි.

මෙන්න එය ක්‍රියාත්මක වන ආකාරයයි.

මූලික වශයෙන් මම පළමුව ප්‍රති ar ලයක් ලෙස ඇති අරාවෙහි දිග ගණනය කර එම දිගට ශුන්‍ය පිරවූ අරාවක් සාදන්න, ඉන්පසු අවශ්‍ය අගයන්ගෙන් එය පුරවන්න

• (step || 1)=> තවද මේ හා සමාන වෙනත් අය අදහස් කරන්නේ එහි වටිනාකම භාවිතා කරන stepඅතර එය ලබා දී නොමැති නම් ඒ 1වෙනුවට භාවිතා කරන්න
• අපි ආරම්භ කරන්නේ ප්‍රති result ල අරාවෙහි දිග ගණනය කිරීමෙන් (Math.abs(end - start) + ((offset || 0) * 2)) / (step || 1) + 1)එය වඩාත් සරල ලෙස භාවිතා කිරීමෙනි (වෙනස * දිශාව / පියවර යන දෙකෙහිම ඕෆ්සෙට්)
• දිග ලබා ගැනීමෙන් පසුව, අපි මෙහි චෙක් භාවිතා කර ආරම්භක අගයන් සහිත හිස් අරාවක් සාදන්නෙමුnew Array(length).fill(0);
• දැන් අපට [0,0,0,..]අවශ්‍ය දිගට අරාවක් තිබේ. අපි එය සිතියම් ගත කර භාවිතා කිරීමෙන් අපට අවශ්‍ය අගයන් සමඟ නව අරාවක් ලබා දෙන්නෙමුArray.map(function() {})
• var direction = start < end ? 1 : 0;නිසැකවම අපට පසුපසට යා යුතු startප්‍රමාණයට වඩා කුඩා නොවේ නම් end. මම අදහස් කළේ 0 සිට 5 දක්වා හෝ අනෙක් අතට
• සෑම පුනරාවර්තනයකදීම startingPoint+ stepSize* indexඅපට අවශ්‍ය අගය ලබා දෙයි

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

--- යාවත්කාලීන කරන්න (සරල කිරීම සඳහා @lokhmakov ට ස්තූතියි) ---

ES6 උත්පාදක යන්ත්ර භාවිතා කරන තවත් අනුවාදයක් ( ES6 උත්පාදක යන්ත්ර සමඟ විශිෂ්ට පාවුලෝ මොරෙට්ටි පිළිතුර බලන්න ):

const RANGE = (x,y) => Array.from((function*(){
  while (x <= y) yield x++;
})());

console.log(RANGE(3,7));  // [ 3, 4, 5, 6, 7 ]

නැතහොත්, අපට අවශ්‍ය වන්නේ එය නැවත ලබා ගත හැකි නම් පමණි:

const RANGE_ITER = (x,y) => (function*(){
  while (x <= y) yield x++;
})();

for (let n of RANGE_ITER(3,7)){
  console.log(n);
}

// 3
// 4
// 5
// 6
// 7

--- සාමාන්‍ය කේතය වූයේ: ---

const RANGE = (a,b) => Array.from((function*(x,y){
  while (x <= y) yield x++;
})(a,b));

සහ

const RANGE_ITER = (a,b) => (function*(x,y){
  while (x <= y) yield x++;
})(a,b);

Harmony පැතිරුම් ක්‍රියාකරු සහ ඊතල කාර්යයන් භාවිතා කිරීම:

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

උදාහරණයක්:

range(10, 15);
[ 10, 11, 12, 13, 14, 15 ]

විවිධ පරාස කාර්යයන් පිළිබඳව යම් පර්යේෂණ කළාද? මෙම කාර්යයන් සිදු කිරීම සඳහා විවිධ ක්‍රම පිළිබඳ jsperf සංසන්දනය පරීක්ෂා කරන්න. නිසැකවම පරිපූර්ණ හෝ පරිපූර්ණ ලැයිස්තුවක් නොවේ, නමුත් උදව් කළ යුතුය :)

ජයග්රාහකයා වන්නේ...

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

තාක්‍ෂණිකව එය ෆයර්ෆොක්ස් හි වේගවත්ම නොවේ, නමුත් ක්‍රෝම් හි පිස්සු වේග වෙනස (ඉම්හෝ) ඒ සඳහා උපකාරී වේ.

ෆයර්ෆොක්ස් වලට වඩා මෙම අරා ක්‍රියාකාරිත්වයන් සමඟ ක්‍රෝම් කොතරම් වේගවත්ද යන්න සිත්ගන්නා කරුණකි. Chrome අවම වශයෙන් 4 හෝ 5 ගුණයක් වේගවත් වේ.

ඔබට lodash හෝ Undescore.js භාවිතා කළ හැකිය range:

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 ]

ES6 හි උත්පාදක යන්ත්රrange සමඟ ක්රියාත්මක කළ හැකිය :

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

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

ඔබ දෙවරක් පරීක්ෂා කිරීමට කැමති නම්, නියත සම්පත ECMA-262 ප්‍රමිතියයි .

මෙය හොඳම ක්‍රමය නොවිය හැකිය. නමුත් ඔබ එක් කේත පේළියක සංඛ්‍යා පරාසයක් ලබා ගැනීමට බලාපොරොත්තු වන්නේ නම්. උදාහරණයක් ලෙස 10 - 50

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

40 යනු (අවසානය - ආරම්භය) සහ 10 ආරම්භයයි. මෙය නැවත පැමිණිය යුතුය [10, 11, ..., 50]

සිත්ගන්නා සුළු අභියෝගයක් වනුයේ මෙය කිරීමට කෙටිම කාර්යය ලිවීමයි . ගලවා ගැනීමේ පුනරාවර්තනය!

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

විශාල පරාසයන්හි මන්දගාමී වීමට නැඹුරු වන නමුත් වාසනාවකට මෙන් ක්වොන්ටම් පරිගණක කෙළවරේ ය.

අමතර ප්‍රසාද දීමනාවක් නම් එය අපැහැදිලි ය. අපගේ කේතය පිරික්සීමේ ඇස්වලින් සඟවා ගැනීම කොතරම් වැදගත්දැයි අපි කවුරුත් දන්නා බැවිනි.

ශ්‍රිතය සැබවින්ම හා සම්පූර්ණයෙන්ම අපැහැදිලි කිරීමට, මෙය කරන්න:

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

මම මේ වගේ දෙයක් කේත කරනවා:

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]

මෙම සිට කළ නොහැකි වුවත් , PHP , නමුත් අනුකරණය rangeසිට 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] 

Array.from()ස්ථිතික ක්‍රමයට විශේෂ අවධානයක් යොමු කරමින් ES6 දැඩි ලෙස භාවිතා කරන තරමක් අවම ක්‍රියාත්මක කිරීමක් පහත පරිදි නිර්මාණය කළ හැකිය :

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

range(start,end,step): ES6 අනුකාරක සමඟ

ඔබ ඉල්ලන්නේ ඉහළ සහ පහළ සීමාවන් පමණි. මෙන්න අපි පියවරක් සමඟ එකක් නිර්මාණය කරමු.

ඔබට පහසුවෙන් range()උත්පාදක ශ්‍රිතයක් නිර්මාණය කළ හැකි අතර එය අනුකාරකයක් ලෙස ක්‍රියා කළ හැකිය. මෙයින් අදහස් කරන්නේ ඔබ සම්පූර්ණ අරාව පූර්ව උත්පාදනය කළ යුතු නැති බවයි.

function * range ( start, end, step = 1 ) {
  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 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)
}

විශේෂ සටහන්

• ඔබ භාවිතා කරන්නේ නම් Ramda, ඔවුන් තමන්ගේමR.range මෙන් Lodash

දී ඇති පරාසයක් සඳහා සංඛ්‍යාත්මක අරාවක් ජනනය කරන තාක් දුරට, මම මෙය භාවිතා කරමි:

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]

නිසැකවම, එය අකාරාදී අරා සඳහා ක්‍රියා නොකරනු ඇත.

මෙය ප්‍රතිලෝමව ද ක්‍රියා කරයි.

const range = ( a , b ) => Array.from( new Array( b > a ? b - a : a - b ), ( x, i ) => b > a ? i + a : a - i );

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

භාවිතා එකමුතු ජනක යන්ත්ර , IE11 හැර සියලු බ්රව්සර් සහය :

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

උදාහරණ

ගන්න

උදාහරණ 1.

take එය ලබා ගත හැකි තරම් ප්‍රමාණයක් ගනී

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

ප්‍රතිලාභ

[100, 105, 110, 115, 120]

උදාහරණ 2.

to අවශ්‍ය නැහැ

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

ප්‍රතිලාභ

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

සියලු ගැනීමට

උදාහරණ 3.

from අවශ්‍ය නැහැ

takeAll( range( {to: 5} ) )

ප්‍රතිලාභ

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

උදාහරණ 4.

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

ප්‍රතිලාභ

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

උදාහරණ 5.

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

ප්‍රතිලාභ

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

... වැඩි පරාසයක්, උත්පාදක ශ්‍රිතයක් භාවිතා කිරීම.

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.

මෙය ප්‍රයෝජනවත් යැයි සිතමි.

මගේ කෝඩ්ගොල්ෆින් සහායකයා මේ (ES6) සමඟ පැමිණියේ:

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

ඇතුළත් නොවන:

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

දේවල් කෙටි හා සරල ලෙස තබා ගැනීමට ඔබට පහත දැක්වෙන එක්-ලයිනර් භාවිතා කළ හැකිය

var start = 4;
var end = 20;
console.log(Array(end - start + 1).fill(start).map((x, y) => x + y));

ඔබට https://lodash.com/docs#rangelodash ශ්‍රිතය භාවිතා කළ හැකිය_.range(10)

d3 හි පරාසයේ ශ්‍රිතයක් ද ඇත. Https://github.com/mbostock/d3/wiki/Arrays#d3_range බලන්න :

d3.range ([ආරම්භ කරන්න,] නවත්වන්න [, පියවර])

පයිතන් සාදන ලද පරාසයට සමාන අංක ගණිතමය ප්‍රගතියක් සහිත අරාවක් ජනනය කරයි. මෙම ක්‍රමය බොහෝ විට භාවිතා කරනුයේ සංඛ්‍යාත්මක හෝ පූර්ණ සංඛ්‍යා අගයන්, එනම් දර්ශක අරාවකට අනුක්‍රමණය කිරීම සඳහා ය. පයිතන් අනුවාදය මෙන් නොව, තර්ක පූර්ණ සංඛ්‍යා විය යුතු නැත, නමුත් පාවෙන ලක්ෂ්‍ය නිරවද්‍යතාවය නිසා ප්‍රති results ල වඩාත් පුරෝකථනය කළ හැකිය. පියවර මඟ හැරී ඇත්නම්, එය පෙරනිමිය 1 දක්වා වේ.

උදාහරණයක්:

d3.range(10)
// returns [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

පරාසය ([ආරම්භක,] නැවතුම් [, පියවර]) අත්සන භාවිතා කරමින් සම්පූර්ණ ES6 ක්‍රියාත්මක කිරීම:

function range(start, stop, step=1){
  if(!stop){stop=start;start=0;}
  return Array.from(new Array(int((stop-start)/step)), (x,i) => start+ i*step)
}

ඔබට ස්වයංක්‍රීය negative ණ පියවරක් අවශ්‍ය නම් එකතු කරන්න

if(stop<start)step=-Math.abs(step)

හෝ වඩාත් අවම වශයෙන්:

range=(b, e, step=1)=>{
  if(!e){e=b;b=0}
  return Array.from(new Array(int((e-b)/step)), (_,i) => b<e? b+i*step : b-i*step)
}

ඔබට විශාල පරාසයන් තිබේ නම් පාවුලෝ මොරෙට්ටිගේ උත්පාදක ප්‍රවේශය දෙස බලන්න