मेरे पास जावास्क्रिप्ट में एक सरणी है जिसने इन मानों को परिभाषित किया है:

var myStringArray = ["1","2","3","4","5","6","7","8","9","10"];

और जब मैं पहली बार किसी फ़ंक्शन को कॉल करता हूं, तो मुझे इसे प्राप्त करने की आवश्यकता होती है:

1
2
3

इसे फिर से कॉल करना मुझे प्राप्त करने की आवश्यकता है:

4
5
6

इसे फिर से कॉल करना:

7
8
9

इसे फिर से कॉल करना:

10
1
2

फिर से कॉल करना:

3
4
5

और इसी तरह। आपको बिंदु मिल गया है, सरणी से 3 मान दिखा रहा है और यदि हम सरणी के अंत में हैं, तो शुरुआत से पढ़ें ... मेरे पास एक ऐप है जिसमें रिमोट कंट्रोल है और इसमें डाउन और अप कीज़ हैं। जब उपयोगकर्ता उपरोक्त उदाहरण में वर्णित सरणी से इन मानों को प्राप्त करने के लिए डाउन बटन दबाता है, यदि उपयोगकर्ता ऊपर बटन दबाता है तो उसे एक उदाहरण से वापस जाने की आवश्यकता होती है ... इसलिए सरणी को लूप में पढ़ना (अंत में, सरणी शुरुआत से पढ़ी जाती है, लेकिन हमेशा तीन मान दिखाती है)।

मैं इसका उपयोग करने का प्रयास करता हूं:

var myStringArray = ["1","2","3","4","5","6","7","8","9","10"];
var arrayLength = myStringArray.length;
for (var i = 0; i < arrayLength; i++) {
    if (i<(6)) {
       console.log(myStringArray[i]);
    }
}

लेकिन अगली बार जब मैं इस कोड को कॉल करता हूं, तो यह सरणी के शुरुआती मूल्यों से दिखाता है, दूसरों के मूल्य को पढ़ना जारी नहीं रखता ... क्या मुझे दूसरे काउंटर की आवश्यकता है?

11
Igor Petev 22 मई 2018, 16:37

8 जवाब

सबसे बढ़िया उत्तर

यदि आप अपने मूल सरणी में हेरफेर करने के साथ ठीक हैं, तो आप इसके माध्यम से लूप कर सकते हैं splice और concat नीचे के समान (या यदि आप मूल सरणी को जारी रखने की आवश्यकता है तो आप सरणी के क्लोन का उपयोग कर सकते हैं):

var myStringArray = ["1","2","3","4","5","6","7","8","9","10"];

var loopByX = function(x){
  var y = myStringArray.splice(0,x);
  myStringArray = myStringArray.concat(y);
  
  return y;
}

console.log(loopByX(3));
console.log(loopByX(3));
console.log(loopByX(3));
console.log(loopByX(3));
console.log(loopByX(3));

यदि आप द्वि-दिशात्मक जाना चाहते हैं (क्या आप इसे कहते हैं?), जैसा कि टिप्पणियों में बताया गया है, तो आप इसे नीचे के रूप में कर सकते हैं जो आपको पीछे या आगे जाने की क्षमता देता है और ऐसा करने के लिए लचीलापन देता है। संख्या:

var myStringArray = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"];

var loopByX = function(x) {
  var len = myStringArray.length;

  // Ensure x is always valid but you can add any behaviour here in that case yourself. As an example I return an empty array.
  if (Math.abs(x) > len) {
    return [];
  }

  var y = x > 0 ? myStringArray.splice(0, x) : myStringArray.splice(len + x, len);

  myStringArray = x > 0 ? myStringArray.concat(y) : y.concat(myStringArray);

  return y;
}

console.log(loopByX(20)); // invalid number
console.log(loopByX(-20)); // invalid number
console.log(loopByX(-3));
console.log(loopByX(-6));
console.log(loopByX(3));
console.log(loopByX(4));
9
Nope 22 मई 2018, 17:02

@Igor Petev, JavaScript का बंद होना एक अच्छी अवधारणा है जिसका उपयोग आप अपनी समस्या को हल करने के लिए कर सकते हैं।

कृपया JavaScript's Closers - w3schools लेख पढ़ें। यह वास्तव में अच्छा और उत्कृष्ट है।

मैंने इस समस्या को हल करने के लिए बंद करने की अवधारणा का उपयोग किया है। यदि आपको मेरा कोड या इस समस्या से संबंधित कोई अन्य बात समझ में नहीं आती है तो कृपया एक टिप्पणी छोड़ दें।

कृपया नीचे दिए गए कोड पर एक नज़र डालें।

var get3items = (function () {

    var index = 0;
    var myStringArray = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"];
    var len = myStringArray.length

    return function () {
       for(var count = 0; count < 3; count += 1)
       {
           console.log(myStringArray[index]);

           if(index == (len - 1))
           {
               index = 0;
           }
           else {
               index += 1;
           }
       }
    }
})();

get3items (); // First call

console.log()
get3items (); // Second call

console.log()
get3items (); // Third call

console.log()
get3items (); // Fourth call

console.log()
get3items (); // Fifth call

/*
 1
 2
 3

 4
 5
 6

 7
 8
 9

 10
 1
 2

 3
 4
 5
*/
1
Peter Mortensen 23 मई 2018, 02:25

जनरेटर का उपयोग करने के बारे में:

function* get3() {
  var myStringArray = ["1","2","3","4","5","6","7","8","9","10"];
  var index = 0;
  while (true) {
    yield [0, 1, 2].map(i => myStringArray[(index + i) % myStringArray.length])
    index = (index + 3) % myStringArray.length;
  }
}

इस फ़ंक्शन को कॉल करना एक ऑब्जेक्ट देता है जिसे आप .next() पर कॉल कर सकते हैं, अगले 3 का सेट प्राप्त करने के लिए:

var getter = get3();
console.log(getter.next().value); // ["1","2","3"]
console.log(getter.next().value); // ["4","5","6"]
console.log(getter.next().value); // ["7","8","9"]
// etc.
0
Tom Fenech 22 मई 2018, 20:08
function* employeeNames(){
    var empList =  ["1","2","3","4","5","6","7","8","9","10"];

    for(var i =0; i<=empList.length; i++){
        yield empList[i];
    }
}

var emp;
emp = employeeNames();

यह एक जनरेटर फ़ंक्शन का उपयोग करता है ...

-2
Peter Mortensen 23 मई 2018, 02:20

आप एक फ़ंक्शन ले सकते हैं जो तीन तत्वों को काटता है और यदि संभव नहीं है, तो यह सरणी के आवश्यक पहले मान भी लेता है।

function take3() {
    var temp = array.slice(index, index += 3)
    index %= array.length;
    console.log(temp.concat(temp.length < 3 ? array.slice(0, index) : []).join(' '));
}

var array = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"],
    index = 0;
<button onclick="take3()">take 3</button>

एक गतिशील गिनती के मानचित्रण के साथ।

function take(length) {
    console.log(Array.from({ length }, _ => array[++index, index %= array.length]));
}

var array = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"],
    index = -1;
<button onclick="take(3)">take 3</button>
4
Peter Mortensen 23 मई 2018, 02:22

यदि आप अपने सर्कुलर लूपिंग को प्राप्त करने का अपरिवर्तनीय तरीका चाहते हैं

function loopArray(arr, step=3) {
    let i = 0;
    return function inner() {
        for (let j = 0; j < step; j++) {
            console.log(arr[i]);
            i = (i + 1) % arr.length;
        }
    };
 }

const func = loopArray(["1","2","3","4","5","6","7","8","9","10"], 3);
func();
func();
func();
func();
func();
1
soueuls 22 मई 2018, 17:04

आपका चर i for लूप के लिए स्थानीय है, जिसका अर्थ है कि यह मूल रूप से हर बार लूप शुरू होने पर रीसेट हो जाता है। तो सबसे पहले अपने वेरिएबल i को ग्लोबल बनाएं।

var i=0;
function employeeNames(){
    var empList =  ["1","2","3","4","5","6","7","8","9","10"];
    var output = [];
    var j=0;
    while(j<3)
    {
        output.push(empList[i])
        i=(i+1)%empList.length;
        j++;
    }
    return output;
}

console.log(employeeNames());
console.log(employeeNames());
console.log(employeeNames());
console.log(employeeNames());
console.log(employeeNames());
2
Peter Mortensen 23 मई 2018, 02:23

जनरेटर कार्यों के साथ फैंसी समाधान:

function* cycle(arr) {
    let i=0;
    while (true) {
        yield arr[i++];
        i %= arr.length;
    }
}
function* chunksOf(n, iterable) {
    let chunk = [];
    for (const x of iterable) {
        chunk.push(x)
        if (chunk.length >= n) {
            yield chunk;
            chunk = [];
        }
    }
    if (chunk.length > 0)
        yield chunk;
}
function toFunction(iterator) {
    return () => iterator.next().value;
}
var myStringArray = ["1","2","3","4","5","6","7","8","9","10"];

const f = toFunction(chunksOf(3, cycle(myStringArray)));
console.log(f());
console.log(f());
console.log(f());
// …
1
Bergi 22 मई 2018, 20:16