जावास्क्रिप्ट के साथ एक लंबी सरणी को छोटे सरणियों में कैसे विभाजित किया जाए

100

मेरे पास ई-मेल का एक सरणी है (यह सिर्फ 1 ईमेल या 100 ईमेल हो सकता है), और मुझे ऐंजैक्स अनुरोध के साथ सरणी भेजने की आवश्यकता है (जो मुझे पता है कि कैसे करना है), लेकिन मैं केवल एक सरणी भेज सकता हूं जिसमें है इसमें 10 या उससे कम ई-मेल। इसलिए अगर 20 ई-मेल का एक मूल सरणी है, तो मुझे उन्हें 10 प्रत्येक के 2 सरणियों में विभाजित करने की आवश्यकता होगी। या यदि मूल सरणी में 15 ई-मेल हैं, तो 10 का 1 सरणी, और 5 का एक और सरणी। मैं jQuery का उपयोग कर रहा हूं, यह करने का सबसे अच्छा तरीका क्या होगा?

javascript  jquery  arrays  loops 
— बिल
स्रोत

जवाबों:

196

Jquery का उपयोग न करें ... सादे जावास्क्रिप्ट का उपयोग करें

var a = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15];

var b = a.splice(0,10);

//a is now [11,12,13,14,15];
//b is now [1,2,3,4,5,6,7,8,9,10];

आप इसे अपने इच्छित व्यवहार को प्राप्त करने के लिए पा सकते हैं।

var a = YOUR_ARRAY;
while(a.length) {
    console.log(a.splice(0,10));
}

यह आपको एक बार में 10 तत्व देगा ... यदि आप 15 तत्व कहते हैं, तो आपको 1-10, 11-15 मिलेंगे।

— jyore
स्रोत
9
ध्यान दें कि your_ARRAY का उपभोग भी किया जाएगा (सरणी वस्तुएं हैं ...)
— क्लाउडियो
हाँ, मैं सिर्फ इसलिए डाल रहा था कि एक गैर-वर्णनात्मक है, और मैंने पहले ही एक उदाहरण का उपयोग करके लिखा है ... यह कोड की एक पूरी तरह से अनावश्यक रेखा है ... हालांकि, इससे मुझे लगता है ... अगर इस पैटर्न का उपयोग कर रहा है, आप कार्यशील सरणी में एक गहरी प्रतिलिपि बनाना चाह सकते हैं जैसा कि आप को बाधित नहीं करने के लिए मूल
— jyore
@junvar IDK अगर उस 1-लाइनर ने 2018 में काम किया (मुझे गंभीरता से संदेह था), लेकिन यह आज बुरी तरह से विफल है। आपको कभी भी (यानी तत्वों को हटाएं) म्यूट नहीं करना चाहिए, एक सरणी को पुनरावृत्त किया जा रहा है, यह सूचकांक को फेंकता है, अर्थात प्रत्येक हटाने के बाद हटाए गए तत्वों की संख्या द्वारा इसे फिर से समायोजित किया जाना चाहिए, इसलिए यह "आगे निकल जाता है" और उपभोग नहीं करता है पूरी तरह से सरणी। इसे आज़माएं
— ड्रू रीज़
107 
var size = 10; var arrayOfArrays = [];
for (var i=0; i<bigarray.length; i+=size) {
     arrayOfArrays.push(bigarray.slice(i,i+size));
}
console.log(arrayOfArrays);

इसके विपरीत splice(), slice()मूल सरणी के लिए गैर-विनाशकारी है।

— Blazemonger
स्रोत
1
यह समाधान बेहतर है
— Maduekwe Pedro
38

सरणी पर बस लूप करें, इसे तब तक फैलाएं जब तक कि यह सब भस्म न हो जाए।



var a = ['a','b','c','d','e','f','g']
  , chunk

while (a.length > 0) {

  chunk = a.splice(0,3)

  console.log(chunk)

}

उत्पादन


[ 'a', 'b', 'c' ]
[ 'd', 'e', 'f' ]
[ 'g' ]
— क्लाउडियो
स्रोत
13

यह मानते हुए कि आप मूल सरणी को नष्ट नहीं करना चाहते हैं, तो आप लंबे सरणी को छोटे सरणियों में तोड़ने के लिए इस तरह कोड का उपयोग कर सकते हैं, जिस पर आप फिर से पुनरावृति कर सकते हैं:

var longArray = [];   // assume this has 100 or more email addresses in it
var shortArrays = [], i, len;

for (i = 0, len = longArray.length; i < len; i += 10) {
    shortArrays.push(longArray.slice(i, i + 10));
}

// now you can iterate over shortArrays which is an 
// array of arrays where each array has 10 or fewer 
// of the original email addresses in it

for (i = 0, len = shortArrays.length; i < len; i++) {
    // shortArrays[i] is an array of email addresss of 10 or less
}
— jfriend00
स्रोत
6

एक और कार्यान्वयन:

const arr = ["H", "o", "w", " ", "t", "o", " ", "s", "p", "l", "i", "t", " ", "a", " ", "l", "o", "n", "g", " ", "a", "r", "r", "a", "y", " ", "i", "n", "t", "o", " ", "s", "m", "a", "l", "l", "e", "r", " ", "a", "r", "r", "a", "y", "s", ",", " ", "w", "i", "t", "h", " ", "J", "a", "v", "a", "S", "c", "r", "i", "p", "t"];

const size = 3; 
const res = arr.reduce((acc, curr, i) => {
  if ( !(i % size)  ) {    // if index is 0 or can be divided by the `size`...
    acc.push(arr.slice(i, i + size));   // ..push a chunk of the original array to the accumulator
  }
  return acc;
}, []);

// => [["H", "o", "w"], [" ", "t", "o"], [" ", "s", "p"], ["l", "i", "t"], [" ", "a", " "], ["l", "o", "n"], ["g", " ", "a"], ["r", "r", "a"], ["y", " ", "i"], ["n", "t", "o"], [" ", "s", "m"], ["a", "l", "l"], ["e", "r", " "], ["a", "r", "r"], ["a", "y", "s"], [",", " ", "w"], ["i", "t", "h"], [" ", "J", "a"], ["v", "a", "S"], ["c", "r", "i"], ["p", "t"]]

एनबी - यह मूल सरणी को संशोधित नहीं करता है।

या, यदि आप एक कार्यात्मक पसंद करते हैं, तो 100% अपरिवर्तनीय (हालांकि ऊपर किए गए स्थान पर उत्परिवर्तन में वास्तव में कुछ भी बुरा नहीं है) और स्व-निहित विधि:

function splitBy(size, list) {
  return list.reduce((acc, curr, i, self) => {
    if ( !(i % size)  ) {  
      return [
          ...acc,
          self.slice(i, i + size),
        ];
    }
    return acc;
  }, []);
}
— Aurelio
स्रोत
5

@ Jyore के उत्तर के पूरक के रूप में , और यदि आप अभी भी मूल सरणी रखना चाहते हैं: 

var originalArray = [1,2,3,4,5,6,7,8];

var splitArray = function (arr, size) {

  var arr2 = arr.slice(0),
      arrays = [];

  while (arr2.length > 0) {
      arrays.push(arr2.splice(0, size));
  }

  return arrays;
}

splitArray(originalArray, 2);
// originalArray is still = [1,2,3,4,5,6,7,8];
— जस्टिन
स्रोत
5

Array.reduce बड़े सरणियों के लिए अक्षम हो सकता है, खासकर मॉड ऑपरेटर के साथ। मुझे लगता है कि एक क्लीनर (और संभवतः पढ़ने में आसान) कार्यात्मक समाधान यह होगा:

const chunkArray = (arr, size) =>
  arr.length > size
    ? [arr.slice(0, size), ...chunkArray(arr.slice(size), size)]
    : [arr];
— tawnos178
स्रोत
3

एक अन्य विधि:

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

var newArray = new Array(Math.ceil(longArray.length / size)).fill("")
    .map(function() { return this.splice(0, size) }, longArray.slice());

// newArray = [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]];

यह प्रतिलिपि के रूप में मूल सरणी को प्रभावित नहीं करता है, स्लाइस का उपयोग करके बनाया गया है, इसे मानचित्र के 'इस' तर्क में पारित किया गया है।

— AFurlepa
स्रोत
3

मैं अपना समाधान भी साझा करना चाहूंगा। यह थोड़ा अधिक क्रिया है लेकिन साथ ही साथ काम भी करता है।

var data = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15];

var chunksize = 4;


var chunks = [];

data.forEach((item)=>{
  if(!chunks.length || chunks[chunks.length-1].length == chunksize)
  chunks.push([]);

  chunks[chunks.length-1].push(item);
});

console.log(chunks);

आउटपुट (स्वरूपित):

[ [ 1,  2,  3,  4],
  [ 5,  6,  7,  8],
  [ 9, 10, 11, 12],
  [13, 14, 15    ] ]
— निलोपी को छान लें
स्रोत
2

एक और कार्यान्वयन, Array.reduce का उपयोग करते हुए (मुझे लगता है कि यह केवल एक लापता है!)।

const splitArray = (arr, size) =>
{
    if (size === 0) {
        return [];
    }

    return arr.reduce((split, element, index) => {
        index % size === 0 ? split.push([element]) : split[Math.floor(index / size)].push(element);
        return split;
    }, []);
};

ऊपर कई समाधानों के रूप में, यह एक गैर विनाशकारी है। जब आकार 0 होता है तो एक खाली सरणी वापस करना सिर्फ एक सम्मेलन है। यदि ifब्लॉक को छोड़ दिया जाता है, तो आपको एक त्रुटि मिलती है, जो हो सकता है कि आप क्या चाहते हैं।

— Alf
स्रोत
1

आप इस कोड पर एक नज़र डाल सकते हैं। सरल और प्रभावी।

function chunkArrayInGroups(array, unit) {
var results = [],
length = Math.ceil(array.length / unit);

for (var i = 0; i < length; i++) {
    results.push(array.slice(i * unit, (i + 1) * unit));
}
 return results;
}

chunkArrayInGroups(["a", "b", "c", "d"], 2);
— Subhankar
स्रोत
1

यहाँ एक सरल एक लाइनर है

var segment = (arr, n) => arr.reduce((r,e,i) => i%n ? (r[r.length-1].push(e), r)
                                                    : (r.push([e]), r), []),
        arr = Array.from({length: 31}).map((_,i) => i+1);
console.log(segment(arr,7));
स्निपेट का विस्तार करें

— Redu
स्रोत
1

अधिक कॉम्पेक्ट:

const chunk = (xs, size) =>
  xs.map((_, i) =>
    (i % size === 0 ? xs.slice(i, i + size) : null)).filter(Boolean);
    
// Usage:
const sampleArray = new Array(33).fill(undefined).map((_, i) => i);

console.log(chunk(sampleArray, 5));
स्निपेट का विस्तार करें

— dzuc
स्रोत
0

यदि आप ऐसी विधि चाहते हैं जो मौजूदा सरणी को संशोधित न करे, तो यह कोशिश करें:

let oldArray = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15];
let newArray = [];
let size = 3; // Size of chunks you are after
let j = 0; // This helps us keep track of the child arrays

for (var i = 0; i < oldArray.length; i++) {
  if (i % size === 0) {
    j++
  }
  if(!newArray[j]) newArray[j] = [];
  newArray[j].push(oldArray[i])
}
— रयान
स्रोत
0 
function chunkArrayInGroups(arr, size) {
    var newArr=[];

    for (var i=0; arr.length>size; i++){
    newArr.push(arr.splice(0,size));
    }
    newArr.push(arr.slice(0));
    return newArr;

}

chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6], 3);
— zgthompson
स्रोत
बनाने के लिए मत भूलना: newArr = [] एक स्थानीय चर
— zgthompson
कोड-ओनली आंसर फ्लैग हो जाते हैं और फिर लो क्वालिटी होने के लिए डिलीट कर दिए जाते हैं। क्या आप इसके बारे में कुछ टिप्पणी प्रदान कर सकते हैं कि यह मूल समस्या को कैसे हल करता है?
— ग्राहम
यह काम नहीं करता है, यदि चंक आकार इनपुट सरणी आकार से कम है।
— r3wt
0 
function chunkArrayInGroups(arr, size) {
    var newArr=[];

    for (var i=0; i < arr.length; i+= size){
    newArr.push(arr.slice(i,i+size));
    }
    return newArr;

}

chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6], 3);
— रिदवानुल्लाह इब्राहिम
स्रोत
2
Stackoverflow में आपका स्वागत है। कुछ स्पष्टीकरण जोड़कर आपके उत्तर में सुधार किया जाएगा।
— साइमन .A
0

एक समारोह के रूप में

var arrayChunk = function (array, chunkSize) {
            var arrayOfArrays = [];

            if (array.length <= chunkSize) {
                arrayOfArrays.push(array);
            } else {
                for (var i=0; i<array.length; i+=chunkSize) {
                    arrayOfArrays.push(array.slice(i,i+chunkSize));
                }
            }
            return arrayOfArrays;
        }

उपयोग करने के लिए

arrayChunk(originalArray, 10) //10 being the chunk size.
— क्लिंट
स्रोत
0

पुनरावृत्ति का उपयोग करना

let myArr = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16];
let size = 4; //Math.sqrt(myArr.length); --> For a n x n matrix
let tempArr = [];
function createMatrix(arr, i) {
    if (arr.length !== 0) {
      if(i % size == 0) {
        tempArr.push(arr.splice(0,size))
      } 
      createMatrix(arr, i - 1)
    }
}
createMatrix(myArr, myArr.length);
console.log(tempArr);

नोट: मौजूदा सरणी यानी myArr को संशोधित किया जाएगा।

— सिद्धार्थ यादव
स्रोत
0

प्रोटोटाइप का उपयोग करके हम सीधे ऐरे क्लास में सेट कर सकते हैं 

Array.prototype.chunk = function(n) {
  if (!this.length) {
    return [];
  }
  return [this.slice(0, n)].concat(this.slice(n).chunk(n));
};
console.log([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15].chunk(5));
स्निपेट का विस्तार करें

— AmitNayek
स्रोत
0 
const originalArr = [1,2,3,4,5,6,7,8,9,10,11];
const splittedArray = [];
  while (originalArr.length > 0) {
    splittedArray.push(originalArr.splice(0,range));  
  }

रेंज 3 के लिए आउटपुट

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

रेंज 4 के लिए आउटपुट

splittedArray === [[1,2,3,4][5,6,7,8][9,10,11]]
— हॉग्स बोगदान
स्रोत
क्या आप कुछ विवरण जोड़ सकते हैं?
— अहंकार
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.