निकालें x सरणी (टुकड़ा) से आइटम लेकिन अगर अंत तक पहुँच जाता है

Question

चलें कहते हैं कि मैं है शुरू से ही जारी रखने के लिए:

var array = [0,1,2,3,4,5,6,7,8,9] 

मैं परिभाषित:

var itemsToExtract = 5 
var startindex = 7 
var direction = "forward" 

मैं ऐसा करने में सक्षम होना चाहता हूँ:

array.someMethod(startindex, itemsToExtract, direction) 

और मिल

[7,8,9,0,1] 

मैं भी इसे पीछे की ओर काम करना चाहता हूं, अगर मैं "पिछड़ा" (दाएं से बाएं टुकड़े टुकड़े) पर दिशा निर्धारित करता हूं।

मैं बहुत आलसी नहीं था और कुछ पहले से ही करने की कोशिश की, यहाँ देखें: http://jsfiddle.net/MkNrr/

मैं कुछ "tidier" वहाँ है अगर रहा हूँ, यह भी है कि इस विधि के लिए एक नाम है, यह एक ज्ञात समस्या है?

पृष्ठभूमि: मैं एक छवि गैलरी में उपयोग के लिए अनुक्रमिक पूर्व छवि लोडर (दूसरे के बाद एक छवि लोड करें) (स्रोत) लोड करने की कोशिश कर रहा हूं। शायद यहां तक ​​कि ऐसी मुक्ति भी मौजूद है?

Answer 1

इसका बहुत ज्यादा नहीं है, लेकिन लग रहा है ठीक JS Bin:

function overSlice(arr, start, count, dir){ 
    if(dir==='backward'){ 
     arr = arr.reverse(); 
     start = arr.length-start-1; 
    } 
    var lastIndex = start+count; 
    return arr.slice(start, lastIndex>arr.length?arr.length: lastIndex) 
    .concat(arr.slice(0, lastIndex>arr.length?lastIndex-arr.length: 0)); 
} 

var arr = [0,1,2,3,4,5,6,7,8,9]; 
alert(overSlice(arr,7,5,'backward')); 

Answer 2

बस सरणी के प्रति बना सकते हैं और मूल सरणी संलग्न जब तक यह काफी लंबा है:

var arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
var start = 7 
var count = 5 
var tmparr = arr 

while (tmparr.length < start + count) { 
    tmparr = tmparr.concat(arr); 
} 

var result = tmparr.slice(start, start + count); 

alert(result); 

Answer 3

कैसे एक समारोह है कि रिटर्न के बारे में आगे और पीछे सरणी? इस तरह आपको एक स्विच की आवश्यकता नहीं है। कुछ इस तरह:

function overslice(arr, idx, items) { 

    var fwd = arr.filter(function(v,i){ return i >= idx }).slice(0, items), 
     back = arr.filter(function(v,i){ return i <= idx }).slice(-items); 

    while (fwd.length < items) { 
    fwd = fwd.concat(arr).slice(0, items); 
    } 

    while (back.length < items) { 
    back = arr.concat(back).slice(-items); 
    } 

    return { fwd: fwd, back: back }; 
} 

तो फिर तुम यह उपयोग कर सकते हैं:

var array = [0,1,2,3,4,5,6,7,8,9] 
var result = overslice(array, 7, 5); 

console.log(result.fwd, result.back); //=> [7, 8, 9, 0, 1] [3, 4, 5, 6, 7] 

Answer 4

मेरे दृष्टिकोण:

function overslice(array, startindex, count, direction) { 
    var retarray = []; 
    var increment = (direction === 'backward') ? -1 : 1; 

    for(var c=0, i = startindex; c<count; i+=increment, c++){ 
     retarray.push(array[(i + array.length)%array.length]); 
    } 
    return retarray; 
} 

Working fiddle

अद्यतन

count चर का उपयोग कर सकारात्मक/नकारात्मक मूल्यों और का उपयोग कर एक फिक्स के साथ सरणी लंबाई से बड़ा count के उपयोग की अनुमति के लिए दिशा तय करने के लिए एक और संस्करण:

function overslice(array, startindex, count) { 
    var retarray = []; 
    var increment = (count >= 0) ? 1 : -1; 
    count = Math.abs(count); 
    for(var i = startindex, c = 0;c<count;i+=increment, c++){ 
     if(i<0) i= array.length-1; 
     retarray.push(array[i%array.length]); 
    } 
    return retarray; 
} 

Demo fiddle

Answer 5

फ़िल्टर करने के लिए अमान्य स्थिति, मैं कुछ मान्यताओं को जोड़ता हूं, जिसके बिना कोड भी छोटा हो सकता है।

var arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
var countToExtract = 10 
var whereToBegin = -1 
var direction = "backword" 

function overslice(array, startIndex, count, direction) { 
    var retArray = []; 
    var step = direction == "backword" ? -1 : 1; 
    var startPos = (startIndex + array.length) % array.length; 
    var endPos = (startPos + (count % array.length) * step + array.length) % array.length; 

    for (var i = 0; i < count; i++) { 
     var pos = (startPos + (i * step) % array.length + array.length) % array.length; 
     retArray.push(array[pos]); 
    } 
    return retArray; 
} 

var lampa = overslice(arr, whereToBegin, countToExtract, direction) 

alert(lampa) 

ऊपर कोड के साथ

, आप कर सकते हैं:
एक ऋण स्थिति है, जो दूसरे छोर से वापस की गणना होती है से शुरू करते हैं।
गिनती सरणी लंबाई से अधिक हो सकती है, जो आपको बार-बार संख्याएं वापस कर देगी।

Answer 6

हाय इस कोड को आजमाएं।

function myslice(ar , start , count , dir) { 

    dir = dir || 'F'; 

    var out = [] , 
     times = Math.ceil((start + count)/ ar.length ) + 1; 

    while(times--) { 
     [].push.apply(out, ar); 
    } 

    if (dir == 'B') { 
     start = ar.length - start - 1; 
     out = out.reverse() ; 
    } 

    return out.slice(start , start+count); 
} 

myslice ([0,1,2,3,4,5,6,7,8,9] , 7 , 5 , 'B'); 

उसकी jsfiddle `backward` शो में