कई बार एक ही तत्व के साथ एक सरणी बनाएं

Question

पायथन में, जहां [2]एक सूची है, निम्नलिखित कोड यह आउटपुट देता है:

[2] * 5 # Outputs: [2,2,2,2,2]

क्या जावास्क्रिप्ट में एक सरणी के साथ ऐसा करने का एक आसान तरीका मौजूद है?

मैंने इसे करने के लिए निम्नलिखित फ़ंक्शन लिखा था, लेकिन क्या कुछ छोटा या बेहतर है?

var repeatelem = function(elem, n){
    // returns an array with element elem repeated n times.
    var arr = [];

    for (var i = 0; i <= n; i++) {
        arr = arr.concat(elem);
    };

    return arr;
};

Comments

संभावित डुप्लिकेट: stackoverflow.com/questions/1295584/…

— लैरी बैटल

संभव डुप्लिकेट: stackoverflow.com/questions/1877475/repeat-character-n-times

— बेनकिनस

Answer 1

आप इसे इस तरह से कर सकते हैं:

function fillArray(value, len) {
  if (len == 0) return [];
  var a = [value];
  while (a.length * 2 <= len) a = a.concat(a);
  if (a.length < len) a = a.concat(a.slice(0, len - a.length));
  return a;
}

यह प्रत्येक पुनरावृत्ति में सरणी को दोगुना करता है, इसलिए यह कुछ पुनरावृत्तियों के साथ वास्तव में बड़ा सरणी बना सकता है।

---

नोट: आप pushइसके बजाए अपने फ़ंक्शन को बहुत सुधार कर सकते हैं concat, क्योंकि concatप्रत्येक पुनरावृत्ति एक नया सरणी बनाएगा। इस तरह से (उदाहरण के तौर पर दिखाया गया है कि आप एरेज़ के साथ कैसे काम कर सकते हैं):

function fillArray(value, len) {
  var arr = [];
  for (var i = 0; i < len; i++) {
    arr.push(value);
  }
  return arr;
}

Comments

यह बहुत अधिक कुशल है कि सामने की सभी प्रविष्टियों को आवंटित किया जाए arr = new Array(len);, फिर उन्हें लूप में सूचकांक द्वारा असाइन किया जाए, अर्थात arr[i] = value;। इस तरह आप केवल ओ (एन) का भुगतान करते हैं, क्योंकि यह बढ़ने पर सरणी को पुनः व्यवस्थित रखने के बजाय। सामान्य तौर पर, जब संभव हो तो जोड़कर बढ़ते सरणियों से बचना हमेशा बेहतर होता है। यदि आप अंतिम आकार जानते हैं, तो इसका उपयोग करें।

— टॉम करेज्स

Array.from({length:5}).map(x => 2)

— noobninja

@ नोनोनिंजा: महान समाधान; आपको इसे एक उत्तर के रूप में फिर से दर्ज करना चाहिए ताकि इसे अपडाउन किया जा सके।

— jsalvata

Answer 2

ES6 में ऐरे फिल () विधि का उपयोग करते हुए

Array(5).fill(2)
//=> [2, 2, 2, 2, 2]

Comments

इंटरनेट एक्सप्लोरर और ओपेरा अभी तक इसका समर्थन नहीं करते हैं।

— डेनिसकोलॉडिन

Node.js <= 3 इसका समर्थन नहीं करता है।

— Junle Li

@DenisKolodin करेंट ओपेरा करता है। और एज भी।

— कॉम्पिटिट

@ मिचेल आप इसके साथ कर सकते हैं Array(5).fill([1,2,3]).flat()। ध्यान दें कि फ्लैट () अभी भी बहुत प्रयोगात्मक है और ब्राउज़र समर्थन खराब है।

— निको रूतसालीनन

ध्यान दें कि तर्क fillका मूल्यांकन एक बार किया जाता है, इसलिए सरणी में Array(9).fill(someMutable)नौ संदर्भ बनाता है someMutable(एक उत्परिवर्तन 'उन सभी को उत्परिवर्तित करता है')।

— कार्ल स्मिथ

Answer 3

>>> Array.apply(null, Array(10)).map(function(){return 5})
[5, 5, 5, 5, 5, 5, 5, 5, 5, 5]
>>> //Or in ES6
>>> [...Array(10)].map((_, i) => 5)
[5, 5, 5, 5, 5, 5, 5, 5, 5, 5]

Comments

मूर्खतापूर्ण प्रश्न, लेकिन नया ऐरे (10) .मैप काम क्यों नहीं करता है?

— ब्लेज़कोविक ज़ूल

blazkovicz, कारण के लिए इस उत्तर पर ज़र्टोश की टिप्पणी देखें ।

— रॉस रोजर्स

ES6 के साथ, इस के लिए "अपग्रेड" किया जा सकता Array(...Array(10)).map(() => 5)प्रसार ऑपरेटर के साथ या भी करने के लिएArray.from(Array(10)).map(() => 5)

— क्रिस्टोफ़ विडाल

के अनुसार MDN :, आप कर सकते हैं बस की तरह इसArray.from({length: 10}, () => 5);

— Plusb Preco

@blazkovicz Array (10) lenght = 10बिना किसी गुण के गुण की एक सरणी बनाता है । .mapकेवल गणना करने योग्य गुणों पर काम करता है। .applyविधि इस सरणी लेता है, और यह नक्शे एक में arguments array(एक सरणी जैसी वस्तु) को पास करने की Arrayनिर्माता समारोह। तर्क सरणी को विरल नहीं किया जा सकता है ताकि लापता गुण सेट हो जाएं undefinedऔर गणना करने योग्य हो जाएं। अब हम .mapइरादा की तरह उपयोग कर सकते हैं

— CervEd

Answer 4

तुम कोशिश कर सकते हो:

Array(6).join('a').split(''); // returns ['a','a','a','a','a'] (5 times)

अपडेट (01/06/2018) :

अब आपके पास दोहराए जाने वाले पात्रों का एक सेट हो सकता है।

new Array(5).fill('a'); // give the same result as above;
// or
Array.from({ length: 5 }).fill('a')

नोट: संगतता और ब्राउज़र समर्थन के लिए (...) और से (...) के बारे में अधिक जांचें ।

अपडेट (05/11/2019) :

एक और तरीका है, का उपयोग किए बिना fillया from, कि किसी भी लंबाई की स्ट्रिंग के लिए काम करता है:

Array.apply(null, Array(3)).map(_ => 'abc') // ['abc', 'abc', 'abc']

उपरोक्त उत्तर के समान । पूर्णता के लिए जोड़ना।

Comments

अच्छा लगा। सबसे छोटा और सरल।

— जोहान ईचावरिया

साधारण हैंडलिंग के लिए +1। एक शर्म की बात है कि आप उससे खाली तारों का एक सरणी नहीं बना सकते। इसके अलावा बहुत ही स्मार्ट ...

— क्विक

ऐरे (6) .join ('ए')। स्प्लिट ('ए') मुझे खाली स्ट्रिंग की सरणी देता है।

— विवेक

यह केवल 1 चार तार के लिए काम करता है, इसलिए यह पूरी तरह से सवाल का जवाब नहीं देता है।

— az_

@AlfonsoVergara: जावास्क्रिप्ट में, स्ट्रिंग एक आदिम (मूल्य-अर्थ) प्रकार है; एक ही डेटा को संदर्भित करने के लिए दो तार प्राप्त करने का कोई तरीका नहीं है (क्योंकि स्ट्रिंग जावास्क्रिप्ट में संदर्भ नहीं हैं ; वे मान हैं)। आपको वस्तुओं और सूचियों के साथ संदर्भ शब्दार्थ के लिए बाहर देखना होगा, लेकिन तार के साथ नहीं।

— क्क्सप्लसोन

Answer 5

Array.from({length:5}, i => 1) // [1, 1, 1, 1, 1]

या बढ़ते मूल्य के साथ सरणी बनाएँ

Array.from({length:5}, (e, i)=>i) // [0, 1, 2, 3, 4]

Comments

अच्छा, the यह सबसे अच्छा तरीका है अगर आपको डायनामिक तत्व की आवश्यकता है

— IliasT

Array.from({length:5}, i => 1)=> iहै undefined, क्योंकि यह रिक्त मान का प्रतिनिधित्व करता है Array.from({length:5}, (e, i)=>i)=> eहै undefined, क्योंकि यह रिक्त मान का प्रतिनिधित्व करता है। यह होना चाहिए Array.from({length:5}, v => 1)औरArray.from({length:5}, (v, i)=>i)

— रफाल एंडेन

Answer 6

में lodash यह इतना बुरा नहीं है:

_.flatten(_.times(5, function () { return [2]; }));
// [2, 2, 2, 2, 2]

संपादित करें : और भी बेहतर:

_.times(5, _.constant(2));
// [2, 2, 2, 2, 2]

संपादित करें : और भी बेहतर:

_.fill(Array(5), 2);

Comments

_.times (लंबाई, _.constant (मान))

— user1533401

डॉक्स से: _.fill (ऐरे (3), 2); जो ES6 से दूर नहीं है

— kert

Answer 7

[c] * n के रूप में लिखा जा सकता है:

Array(n+1).join(1).split('').map(function(){return c;})

के लिए [2] * 5

Array(6).join(1).split('').map(function(){return 2;})

Comments

वास्तव में, ऐरे (6)। जॉइन (2) .एसपीएलआईटी ('') आसान नहीं होगा? आपको नक्शे की आवश्यकता क्यों होगी?

— एंजेला

वह रिटर्न ["2", "2", "2", "2", "2"] के बजाय [2, 2, 2, 2, 2] है।

— ब्रुक होंग

Answer 8

आप ऐरे की कार्यक्षमता को भी बढ़ा सकते हैं जैसे:

Array.prototype.fill = function(val){
    for (var i = 0; i < this.length; i++){
        this[i] = val;
    }
    return this;
};
// used like:
var arry = new Array(5)​.fill(2);
// or
var arry = new Array(5);
arry.fill(2);


​console.log(arry);​ //[2, 2, 2, 2, 2] 

मुझे ध्यान देना चाहिए कि यदि आप तृतीय-पक्ष पुस्तकालयों के साथ काम कर रहे हैं, तो अंतर्निहित वस्तुओं की कार्यक्षमता का विस्तार करना समस्या पैदा कर सकता है। इसे हमेशा अपने निर्णयों में तौलें।

Comments

ध्यान दें कि यदि आप fillसरणी में प्रत्येक इंडेक्स में एक ऑब्जेक्ट पास करते हैं तो उसी ऑब्जेक्ट को संदर्भित करेगा, इसलिए एक को बदलने से उन सभी को बदल दिया जाएगा। अगर यह एक समस्या बन जाए तो इसे हल करना बहुत मुश्किल नहीं है।

— श्मिट्टी

मुझे नहीं पता है कि कई जावास्क्रिप्ट उपयोगकर्ता आवश्यकता से अनजान हैं कि मूल कार्यों को प्रोटोटाइप के लिए नहीं करना चाहिए।

— ब्रूनाओ

ईएस 6 में एक भरने का तरीका जोड़ा गया है। इसलिए मैं आपके स्वयं के सामान को प्रोटोटाइप में जोड़ने की सलाह नहीं दूंगा, आप तेजी से और अधिक सक्षम संस्करण को अधिलेखित करने वाले हैं।

— Janus Troelsen

@JanusTroelsen जावास्क्रिप्ट या 3-पार्टी पुस्तकालयों को अधिलेखित करने से बचने के लिए यदि आप इसे घोषित करने से पहले मौजूद हैं, तो आप देख सकते हैं। if (!Array.prototype.fill) { }

— ओलिवर

@JanusTroelsen "असली पॉलीफ़िल" से आपका क्या मतलब है ?. मैंने एक पॉलिफ़िल का इस्तेमाल किया। मेरा मतलब है: सुविधा का पता लगाने और कार्यान्वयन के मामले में यह नहीं है के लिए जाँच करें।

— ओलिवर

Answer 9

Node.js REPL में:

> Array.from({length:5}).map(x => 2)
[ 2, 2, 2, 2, 2 ]

Comments

Array.from({length: 5}, x => 2);संदर्भ। https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from#Using_arrow_functions_and_Array.from

— noobninja

Answer 10

मामले में आपको कई बार एक सरणी दोहराने की आवश्यकता होती है :

var arrayA = ['a','b','c'];
var repeats = 3;
var arrayB = Array.apply(null, {length: repeats * arrayA.length})
        .map(function(e,i){return arrayA[i % arrayA.length]});
// result: arrayB = ['a','b','c','a','b','c','a','b','c']

इस उत्तर से प्रेरित है

Comments

es6 में, आप "abc" .repeat (3)

— Janus Troelsen

Answer 11

कोई आसान तरीका नहीं। आपको सरणी में एक लूप और पुश तत्व बनाने की आवश्यकता है।

Comments

धन्यवाद! इससे पहले कि मैं स्वीकार करता हूं, दक्षता के मामले में pushबेहतर या concatबेहतर है?

— जिज्ञासु २

CONCAT को दो सरणियों का निरीक्षण करने की आवश्यकता है, PUSH सिर्फ एक और तत्व जोड़ता है, इसलिए मुझे उम्मीद है कि PUSH सामान्य रूप से अधिक कुशल होगा, लेकिन IDENTICAL DATA के लिए मुझे लगता है कि यह गुफ़ा के उत्तर नाखूनों के लिए है।

— डायोडस - जेम्स मैकफर्लेन

छोरों की कोई जरूरत नहीं है, मेरा जवाब देखिए।

— Janus Troelsen

@JanusTroelsen, जब तक आप इस क्रिया को करने के लिए एक कुशल तरीका नहीं चाहते, लूप की आवश्यकता नहीं है। तुम्हारा एक धीमा अधीरता है जो आप पा सकते हैं। धक्का () से [] सबसे तेज है।

— चारीलीथ

Answer 12

इस फ़ंक्शन का उपयोग करें:

function repeatElement(element, count) {
    return Array(count).fill(element)
}

>>> repeatElement('#', 5).join('')
"#####"

या अधिक कॉम्पैक्ट संस्करण के लिए:

const repeatElement = (element, count) =>
    Array(count).fill(element)

>>> repeatElement('#', 5).join('')
"#####"

या एक करी-सक्षम संस्करण के लिए:

const repeatElement = element => count =>
    Array(count).fill(element)

>>> repeatElement('#')(5).join('')
"#####"

आप इस फ़ंक्शन का उपयोग सूची में कर सकते हैं:

const repeatElement = (element, count) =>
    Array(count).fill(element)

>>> ['a', 'b', ...repeatElement('c', 5)]
['a', 'b', 'c', 'c', 'c', 'c', 'c']

Answer 13

यदि आपको किसी सरणी को दोहराने की आवश्यकता है, तो निम्नलिखित का उपयोग करें।

Array.from({ length: 3 }).fill(['a','b','c']).flat()

वापस होगा

Array(9) [ "a", "b", "c", "a", "b", "c", "a", "b", "c" ]

Comments

एक मौजूदा सरणी का उपयोग करते हुए महान ओनेलर, मुझे क्या चाहिए।

— gneric

Answer 14

एक और एक लाइनर:

Array.prototype.map.call([]+Array(5+1),function(){ return '2'; })

Answer 15

यह फ़ंक्शन (लंबाई) तत्वों की एक सरणी बनाता है जहां प्रत्येक तत्व (मान) तब तक बराबर होता है जब तक (मान) पूर्णांक का एक पूर्णांक या स्ट्रिंग होता है। किसी भी दशमलव संख्या को छोटा कर दिया जाएगा। आप दशमलव संख्या चाहते हैं, तो की जगह "parseInt ( " के साथ " parseFloat ( "

function fillArray(length, intValue) {
     var vals = (new Array(length + 1)).join(intValue + '|').split('|').slice(0,length);
     for(var i = 0; i < length; i += 1) {
         vals[i] = parseInt(vals[i]);
     }
     return vals;
}

उदाहरण:

fillArray(5, 7) // returns [7,7,7,7,7]
fillArray(5, 7.5) // returns [7,7,7,7,7]
fillArray(5, 200) // returns [200,200,200,200,200]

Answer 16

जब मैं एक सरणी का उपयोग करता हूं तो मुझे उल्लिखित विधियों के साथ समस्या थी

var array = ['foo', 'bar', 'foobar'];
var filled = array.fill(7);

//filled should be ['foo', 'bar', 'foobar', 'foo', 'bar', 'foobar', 'foo']

इसे पाने के लिए मैं उपयोग कर रहा हूं:

Array.prototype.fill = function(val){
    var l = this.length;
    if(l < val){
        for(var i = val-1-l; i >= 0; i--){
            this[i+l] = this[i % l];
        }
    }
    return this;
};

Comments

यह अच्छा है, लेकिन शायद नाम होना चाहिए cycle।

— ड्रेनमी

Answer 17

लूप का उपयोग किए बिना 2 डी सरणी बनाने की कोशिश करते हुए मुझे आज यह पता चला। पूर्वव्यापी में, एक नई सरणी में शामिल होना साफ है; मैंने एक नए ऐरे की मैपिंग करने की कोशिश की, जो मैप के खाली स्लॉट्स की तरह काम नहीं करता।

"#".repeat(5).split('').map(x => 0)

"#" चार किसी भी एकल एकल वर्ण हो सकता है। 5 आपके इच्छित तत्वों की संख्या के लिए एक चर होगा। 7 वह मान होगा जिसे आप अपने एरे से भरना चाहते हैं।

नई भरण विधि बेहतर है, और जब मैंने इसे कोडित किया तो मुझे नहीं पता था कि यह अस्तित्व में था, और न ही मुझे पता था कि दोहराना es6 है; मैं ठंडी चीजों को कम करने के साथ मिलकर इस ट्रिक का उपयोग करने के बारे में एक ब्लॉग पोस्ट लिखने जा रहा हूं।

http://jburger.us.to/2016/07/14/functionally-create-a-2d-array/

Answer 18

इसे इस्तेमाल करे:

"avinash ".repeat(5).trim().split(" ");

Answer 19

var finalAry = [..."2".repeat(5).split("")].map(Number);
console.log(finalAry);

Answer 20

अगर आप लॉश / अंडरस्कोर जैसी यूटिलिटी बेल्ट का उपयोग कर रहे हैं तो आप इसे इस तरह से कर सकते हैं :)

let result = _.map(_.times(foo), function() {return bar})

Answer 21

एक-लाइनर के रूप में भी इस्तेमाल किया जा सकता है:

function repeat(arr, len) {
    while (arr.length < len) arr = arr.concat(arr.slice(0, len-arr.length));
    return arr;
}

Answer 22

विवेक के उत्तर में सुधार , यह किसी भी लम्बाई के तारों के लिए काम करता है, लंबाई n की एक सरणी को आबाद करने के लिए:Array(n+1).join('[string to be repeated][separator]').split('[separator]').slice(0, n)

Answer 23

मुझे बार-बार एक सरणी (n आइटम के साथ) को दोहराने / लूप करने का एक तरीका चाहिए था।

उदाहरण के लिए, एक सप्ताह (महीने) में एक सूची (व्यक्तियों का) वितरित करना। मान लीजिए कि मेरे 3 नाम हैं, और मैं उन्हें एक हफ्ते में दोहराना चाहता हूं:

fillArray(["Adam", "Blair", "Curtis"], 7); // returns ["Adam", "Blair", "Curtis", "Adam", "Blair", "Curtis", "Adam"]

function fillArray(pattern, count) {
    let result = [];
    if (["number", "string"].includes(typeof pattern)) {
        result = new Array(5);
        result.fill(pattern);
    }
    else if (pattern instanceof Array) {
        for (let i = 0; i < count; i++) {
            result = result.concat(pattern);
        }
        result = result.slice(0, count);
    }
    return result;
}

fillArray("a", 5);        // ["a", "a", "a", "a", "a"]
fillArray(1, 5);          // [1, 1, 1, 1, 1]
fillArray(["a", "b"], 5); // ["a", "b", "a", "b", "a"]