একটি শূন্য ভরা জাভাস্ক্রিপ্ট অ্যারে তৈরি করার সবচেয়ে কার্যকর উপায়?

Question

জাভাস্ক্রিপ্টে একটি স্বেচ্ছাসেবী দৈর্ঘ্যের শূন্য ভরা অ্যারে তৈরির সবচেয়ে কার্যকর উপায় কী?

Comments

এ সম্পর্কে কিছু আসল তথ্য: jsperf.com/zeroarrayjs

— ওয়েব_ডিজাইনার

ES6 পূরণটি স্থানীয়ভাবে এটি করতে দেয়।

— সালভাদোর ডালি

আরআর = নতুন অ্যারে (দৈর্ঘ্য + 1) .জয়েন্ট (চরিত্র) .স্প্লিট ('');

— জর্ডান স্টেফেনেলি

আপডেট ২০১

— কার্ল মরিসন

let i = 0; Array.from(Array(10), ()=>i++);

— বার্ট হোইকস্ট্রা

Answer 1

ES6 পরিচয় করিয়ে দেয় Array.prototype.fill। এটি এর মতো ব্যবহার করা যেতে পারে:

new Array(len).fill(0);

এটি দ্রুত কিনা তা নিশ্চিত নয় তবে আমি এটি পছন্দ করি কারণ এটি সংক্ষিপ্ত এবং স্ব-বর্ণনামূলক।

এটি এখনও আই-তে নেই ( সামঞ্জস্যতা পরীক্ষা করুন ), তবে একটি পলিফিল উপলব্ধ ।

Comments

পূরণ দ্রুত হয়। new Array(len)বেদনাদায়ক ধীর। (arr = []).length = len; arr.fill(0);সবচেয়ে দ্রুত সমাধান

— আইভির

@ পিম্পট্রিজেকিট arr = Array(n)এবং অনুমান (arr = []).length = nঅনুসারে অভিন্ন আচরণ করুন। কিছু বাস্তবায়নে একটি দ্রুততর হতে পারে, তবে আমি মনে করি না এর মধ্যে আরও বড় পার্থক্য রয়েছে।

— ওরিওল

ঠিক আছে, আমি এটি বহু মাত্রিক অ্যারে দিয়ে পরীক্ষা করতে শুরু করেছি এবং এটি আমার পরীক্ষার কেসগুলিকে ব্যাপকতর গতিবেগ বলে মনে হয়েছে। এখনই এফএফ 41 এবং Chrome45.0.2454.99 মি তে আরও কিছু পরীক্ষা চালিয়েছে। হ্যাঁ, আমি অনুমান করি নিজেকে ব্যাখ্যা করার জন্য আমার আরও সত্যিকারের আরও জায়গা প্রয়োজন। আমার বেশিরভাগ পরীক্ষার পক্ষপাতিত্ব ছিল আমি স্বীকার করব। তবে, এটি পরীক্ষা করে দেখুন। একটি বর্ণের পূর্বনির্ধারিত করা এবং ক্রোম এবং এফএফ উভয় ক্ষেত্রেই গতি পরীক্ষার (arr = []).length = 1000; বিরুদ্ধে এই লাইনটি ব্যবহার করা arr = new Array(1000);... এটি newঅত্যন্ত ধীর slow এখন, অ্যারের দৈর্ঘ্যের জন্য ছোট .. বলুন <50 বা সেখানে অস্তিত্ব আছে ... তবে new Array()আরও ভাল পারফর্ম করা হবে বলে মনে হচ্ছে না। তবে ..

— পিম্প ট্রিজকিট

... আমি স্বীকার করব আমি এই অংশটি মিস করেছি ... যখন আমি পরীক্ষায় দ্বিতীয় লাইন যুক্ত করি ... arr.fill(0) ... সমস্ত কিছু পরিবর্তিত হয়। এখন, new Array()ব্যবহারগুলি বেশিরভাগ ক্ষেত্রেই দ্রুততর হয় কেবলমাত্র আপনি 100000 এর অ্যারে পেতে না পারলে ... তারপরে আপনি আবার গতি বৃদ্ধি আরও দেখতে শুরু করতে পারেন। তবে যদি আপনাকে আসলে এটি জিরো দিয়ে প্রিফিল করতে না হয় এবং খালি অ্যারেগুলির স্ট্যান্ডার্ড ফ্যালসি ব্যবহার করতে পারেন। তারপরে (arr = []).length = xবেশিরভাগ সময় আমার পরীক্ষার ক্ষেত্রে দ্রুত পাগল হয়।

— পিম্প ট্রাইজকিট

দ্রষ্টব্য যে অ্যারের উপর পুনরাবৃত্তি করতে (যেমন মানচিত্র বা প্রতিটি জন্য) মানগুলি সেট করা উচিত , অন্যথায় এটি সেই সূচিগুলি এড়িয়ে যাবে। আপনার নির্ধারিত মানগুলি আপনি যা চান তা হতে পারে - এমনকি অপরিজ্ঞাত। উদাহরণ: new Array(5).forEach(val => console.log('hi'));বনাম চেষ্টা করুন new Array(5).fill(undefined).forEach(val => console.log('hi'));।

— আরনেহুগো

Answer 2

যদিও এটি একটি পুরানো থ্রেড, আমি এটিতে আমার 2 সেন্ট যোগ করতে চেয়েছিলাম। এটি কতটা ধীর / গতিবেগ তা নিশ্চিত নয়, তবে এটি দ্রুত একটি লাইনার। আমি যা করি তা এখানে:

আমি যদি কোনও সংখ্যার সাথে প্রাক-পূরণ করতে চাই:

Array.apply(null, Array(5)).map(Number.prototype.valueOf,0);
// [0, 0, 0, 0, 0]

আমি যদি একটি স্ট্রিং দিয়ে প্রাক-পূরণ করতে চাই:

Array.apply(null, Array(3)).map(String.prototype.valueOf,"hi")
// ["hi", "hi", "hi"]

---

অন্যান্য উত্তরের পরামর্শ দেওয়া হয়েছে:

new Array(5+1).join('0').split('')
// ["0", "0", "0", "0", "0"]

তবে আপনি যদি 0 (সংখ্যা) চান এবং "0" (একটি স্ট্রিংয়ের ভিতরে শূন্য) চান না, আপনি এটি করতে পারেন:

new Array(5+1).join('0').split('').map(parseFloat)
// [0, 0, 0, 0, 0]

Comments

দুর্দান্ত উত্তর! আপনি দয়া করে কৌশলটি ব্যাখ্যা করতে পারেন Array.apply(null, new Array(5)).map(...)? খালি কাজ করার কারণ (নতুন অ্যারে (5)) মানচিত্র (...)

— অনুমান

(বিটিডব্লিউ, আমাদের আসলে দরকার নেই new) আপনি যখন Array(5)এমন কোনও বস্তু তৈরি করছেন যা টাইপাকে এমন দেখাচ্ছে: { length: 5, __proto__: Array.prototype }- চেষ্টা করুন console.dir( Array(5) )। লক্ষ করুন যে কোনো বৈশিষ্ট্য নেই 0, 1, 2, ইত্যাদি কিন্তু আপনি যখন applyযে কাছে Arrayকন্সট্রাকটর, এটা বলার অপেক্ষা রাখে না মত Array(undefined, undefined, undefined, undefined, undefined)। এবং আপনি এমন একটি বস্তু পেয়েছেন যা কিন্ডার মতো দেখাচ্ছে { length: 5, 0: undefined, 1: undefined...}। mapবৈশিষ্ট্য 0, 1ইত্যাদির উপর কাজ করে which এজন্য আপনার উদাহরণটি কাজ করে না, তবে আপনি যখন applyএটি ব্যবহার করেন তখন।

— zertosh

এর জন্য প্রথম প্যারামিটারটি .applyহ'ল আপনি যা চান তা হ'ল this। এই উদ্দেশ্যগুলির জন্য thisকিছু যায় আসে না - আমরা কেবলমাত্র "বৈশিষ্ট্য" এর পরামিতি ছড়িয়ে দেওয়ার বিষয়ে যত্নশীল। .applyযাতে এটি কোনও মূল্য হতে পারে। আমি পছন্দ করি nullকারণ এটি সস্তা, আপনি সম্ভবত ব্যবহার করতে চান না {}বা []যেহেতু আপনি কোনও কারণ ছাড়াই কোনও বস্তুকে তাত্ক্ষণিকভাবে চালাবেন।

— zertosh

আকার + এসাইনমেন্টের সাথে আরম্ভ করুন ধাক্কা তুলনায় অনেক দ্রুত। পরীক্ষার কেসটি

— কলিন

অ্যারে.অ্যাপ্লি (নাল, অ্যারে (5)) কী? মানচিত্র (x => 0)? এটা একটু খাটো!

— আর্চ লিনাক্স টাকস

Answer 3

প্রাক্পম্পিউটেড মান সহ একটি অ্যারে পূরণ করার মার্জিত উপায়

ES6 ব্যবহার করে এটি করার আরও একটি উপায় এখানে এখনও পর্যন্ত কেউ উল্লেখ করেনি:

> Array.from(Array(3), () => 0)
< [0, 0, 0]

এটি দ্বিতীয় প্যারামিটার হিসাবে একটি মানচিত্র ফাংশন পাস করে কাজ করে Array.from।

উপরের উদাহরণে, প্রথম প্যারামিটারটি ভ্যালুতে পূর্ণ 3 পজিশনের একটি অ্যারে বরাদ্দ করে undefinedএবং তারপরে ল্যাম্বদা ফাংশন তাদের প্রত্যেককে মানকে মানচিত্র করে 0।

যদিও Array(len).fill(0)সংক্ষিপ্ত, আপনাকে প্রথমে কিছু গণনা করে অ্যারে পূরণ করার প্রয়োজন হলে এটি কাজ করে না (আমি জানি প্রশ্নটি এটি জিজ্ঞাসা করে নি, তবে অনেক লোক এখানে এটি সন্ধান করছে) ।

উদাহরণস্বরূপ, আপনার যদি 10 টি এলোমেলো সংখ্যার সাথে অ্যারের প্রয়োজন হয়:

> Array.from(Array(10), () => Math.floor(10 * Math.random()))
< [3, 6, 8, 1, 9, 3, 0, 6, 7, 1]

এটি সমমানের চেয়ে আরও সংক্ষিপ্ত (এবং মার্জিত):

const numbers = Array(10);
for (let i = 0; i < numbers.length; i++) {
    numbers[i] = Math.round(10 * Math.random());
}

এই পদ্ধতিটি কলব্যাকে প্রদত্ত সূচক প্যারামিটারের সুযোগ নিয়ে সংখ্যার ক্রম উত্পন্ন করতে ব্যবহার করা যেতে পারে:

> Array.from(Array(10), (d, i) => i)
< [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

---

বোনাস উত্তর: স্ট্রিং ব্যবহার করে একটি অ্যারে পূরণ করুন repeat()

যেহেতু এই উত্তরটি ভালভাবে মনোযোগ পাচ্ছে, তাই আমি এই দুর্দান্ত কৌশলটিও দেখাতে চেয়েছিলাম। যদিও আমার মূল উত্তরের মতো কার্যকর না হলেও এটি এখনও খুব পরিচিত না, তবে স্ট্রিং repeat()পদ্ধতিটি কার্যকরভাবে পরিচয় করিয়ে দেবে । কৌশলটি এখানে:

> "?".repeat(10).split("").map(() => Math.floor(10 * Math.random()))
< [5, 6, 3, 5, 0, 8, 2, 7, 4, 1]

শীতল হাহ? repeat()একটি স্ট্রিং তৈরির জন্য খুব দরকারী পদ্ধতি যা নির্দিষ্ট স্ট্রিংয়ের নির্দিষ্ট সংখ্যার পুনরাবৃত্তি। এর পরে, split()আমাদের জন্য একটি অ্যারে তৈরি করে, যা তারপরে map()আমরা যে মানগুলি চাই তা অনুসরণ করে। পদক্ষেপে এটি ভঙ্গ:

> "?".repeat(10)
< "??????????"

> "?".repeat(10).split("")
< ["?", "?", "?", "?", "?", "?", "?", "?", "?", "?"]

> "?".repeat(10).split("").map(() => Math.floor(10 * Math.random()))
< [5, 6, 3, 5, 0, 8, 2, 7, 4, 1]

Comments

সেই পোস্টে প্রচুর পার্লার ট্রিকস, তবে আশা করা যায় যে প্রডাকশন কোডে পৌঁছাবে না এমন কোনটি :)

— এরিক গ্রেঞ্জ

যদিও repeatকৌশলটি অবশ্যই প্রযোজনায় চায়নি, Array.from()পুরোপুরি ঠিক আছে :-)

— লুসিও পাইভা

আসলেই নয়, অ্যারে.ফ্রোম () এখানে মূলত একটি অ্যারে তৈরি করছে, এটির মাধ্যমে মানচিত্র () দিয়ে পুনরাবৃত্তি করছে, প্রতিটি আইটেমকে একটি নতুন অ্যারে তৈরি করার জন্য একটি ফাংশন কল করছে, তারপরে প্রথম অ্যারে ছাড়ছে ... ছোট অ্যারেগুলির জন্য এটি হতে পারে নির্দোষ, বৃহত্তর অ্যারেগুলির জন্য, এটি এমন ধরণের প্যাটার্ন যার ফলস্বরূপ লোকেরা ব্রাউজারগুলিকে "মেমরি হোগ" বলে ডাকে :)

— এরিক গ্রেঞ্জ

বড় অ্যারেগুলির সাথে লেনদেন করা লোকদের অবশ্যই এটির চেয়ে ভাল জানা উচিত। সাধারণ অ্যাপ্লিকেশনগুলির জন্য, তবে, তাত্ক্ষণিকভাবে নিষ্পত্তি করা হবে এমন একটি নিয়মিত আকারের অক্স অ্যারে (10 কে উপাদান পর্যন্ত) তৈরি করা পুরোপুরি ঠিক আছে (সামান্য পরিমাণে সময় লাগে যদি আপনি অতিরিক্ত অ্যারে তৈরিটি এড়িয়ে যান - সর্বশেষ Chrome এর সাথে পরীক্ষিত)। এই জাতীয় ক্ষেত্রে, পাঠ্যতা ছোট কর্মক্ষমতা অপ্টিমাইজেশানের চেয়ে গুরুত্বপূর্ণ হয়ে ওঠে। ও (এন) সময় সম্পর্কে, প্রতিটি উপাদানের (আমার উত্তরের মূল বিষয়) জন্য যদি আপনার আলাদা কিছু গণনা করা প্রয়োজন তবে এটি প্রয়োজনীয়। এই আলোচনাটি খুব আকর্ষণীয়, আপনি এটি উত্থাপন করে যে আনন্দিত!

— লুসিও পাইভা

Answer 4

সবচেয়ে কম

Array(n).fill(0)

(১ char চর), যেখানে nঅ্যারের আকার

---

2018.10.28 আমি অন্যান্য উত্তর থেকে 15 টি প্রস্তাবের পারফরম্যান্স তুলনা করেছি। ম্যাক ওএস এক্স 10.13.6 উচ্চ সিয়েরাতে তিনটি ব্রাউজারে পরীক্ষা করা হয়েছিল: ক্রোম 69.0.3497, সাফারি 12.0 (13606.2.11) এবং ফায়ারফক্স 63৩.০ (bit৪ বিট)।

এন = 100000 এর ফলাফল

আমি নীচে দ্রুত ব্রাউজার (সাফারি) এর ফলাফল দেখাব:

সমস্ত ব্রাউজারের জন্য দ্রুততম সমাধান এম ছিল - তবে এটি "সাধারণ অ্যারে" নয় (তবে খুব দ্রুত) - সাফারি 33.8k অপারেশন / সেকেন্ড, ক্রোম 5.2 কে, এফএফ 3.5 কে,

সাধারণ অ্যারেগুলির দ্রুততম সমাধান:

• একজন এবং বি (অনুরূপ ছিল না) সাফারি 5.5k এবং Chrome 1.1k জন্য (FIREFOX উপর এ 0.1k, বি 0.06 কে )
• এফ ফায়ারফক্স 0.6k জন্য (সাফারি 3.1k উপর, ক্রোম 1.1k)
• ক্রোম এবং সাফারির জন্য এ, বি, এফ-এর ফলাফল নিকটে ছিল

সবচেয়ে ধীর সমাধান:

• জি সাফারি 0.02 কে এবং ফায়ারফক্স 0.04 কে (ক্রোম 0.1k এ)
• ডি ক্রোম 0.04 কে (সাফারি 0.33 কে, ফায়ারফক্স 0.15 কে তে)

সমাধান এন কেবল ফায়ারফক্স এবং ক্রোমে কাজ করে।

এন = 10 এর ফলাফল

দ্রুততম:

• এম ক্রোম 17.3 এবং সাফারি 13.3 এম (ফায়ারফক্স 4.7 ) এ দ্রুততম ছিল
• এ, বি ফায়ারফক্স ১.9.৯ এম (ক্রোম 15.6 এম, সাফারি 3.5 এম) তে একই এবং দ্রুত ছিল

ধীরতম:

• হে সাফারি 0.35 এম এর জন্য
• কেক্রোম 0.35 এম এর জন্য
• এনফায়ারফক্স 0.31 এম এর জন্য

উপসংহার

• সমস্ত ব্রাউজারের দ্রুততম সমাধানটি ছিল ( nফায়ারফক্সে ছোট বাদে ) এম let a = new Float32Array(n) ( (তবে সাধারণ অ্যারে নয়) - এর জন্য দ্রুততম ব্রাউজারটি ছিল সাফারি ( nক্রোমের চেয়ে বড় > 6x দ্রুত,> ফায়ারফক্সের চেয়ে 9x দ্রুত)
• সাধারণ অ্যারেগুলির জন্য পছন্দসই দ্রবণটি হ'ল এ let a = Array(n).fill(0) (দ্রুত এবং সংক্ষিপ্ত কোড)

আপনি এখানে আপনার মেশিনে পরীক্ষা করতে পারেন ।

Comments

Chrome on 77 এ সবেমাত্র কিছু পরীক্ষা চালিয়েছে এবং পুশ () সহ একটি সাধারণ লুপ ফিল () এর চেয়ে দ্বিগুণ দ্রুত ... আমি অবাক হই যে ফিল () এর সূক্ষ্ম পার্শ্ব-প্রতিক্রিয়া কী আরও কার্যকর বাস্তবায়নকে আটকাবে?

— এরিক গ্রেঞ্জ

@ এরিকগ্রঞ্জ আমি উত্তরটি আপডেট করছি - নীচে আমি আপনার প্রস্তাবের সাথে বেঞ্চহ্যাম্কের লিঙ্কটি আপডেট করছি: কেস পি let a=[]; for(i=n;i--;) a.push(0);- তবে এটি 4x এর চেয়ে ধীর fill(0)- তাই আমি এমনকি সেই ক্ষেত্রে ছবির ডাইনিকে আপডেট করব না।

— কামিল কিয়েসজেউস্কি

সুন্দর পরিমাপ। বিশ্লেষণ: প্রতিটি পুনরাবৃত্তিতে অ্যারে পুনরায় আকার দেওয়ার কারণে জি ধীর গতির এবং পুনরায় আকার দেওয়ার অর্থ একটি নতুন মেমরি বরাদ্দ করা। এ, বি, এম দ্রুত কারণ আকার পরিবর্তন কেবল একবার করা হয়। +1

— রোল্যান্ড

Answer 5

ইতিমধ্যে উল্লিখিত ES 6 পূরণের পদ্ধতিটি সুন্দরভাবে এটি যত্ন করে। বেশিরভাগ আধুনিক ডেস্কটপ ব্রাউজারগুলি ইতিমধ্যে আজকের হিসাবে প্রয়োজনীয় অ্যারে প্রোটোটাইপ পদ্ধতিগুলিকে সমর্থন করে (ক্রোমিয়াম, এফএফ, এজ এবং সাফারি) [ 1 ]। আপনি MDN- এ বিশদটি সন্ধান করতে পারেন । একটি সাধারণ ব্যবহার উদাহরণ

a = new Array(10).fill(0);

বর্তমান ব্রাউজার সমর্থন প্রদত্ত আপনি আপনার শ্রোতা আধুনিক ডেস্কটপ ব্রাউজারগুলি ব্যবহার করেন না তা নিশ্চিত হওয়া পর্যন্ত আপনি এটি ব্যবহার করতে সতর্ক হওয়া উচিত।

Comments

আপনি যদি কোনও রেফারেন্স টাইপ পূরণ করেন তবে এটি সমস্ত ক্ষেত্রে একই রেফারেন্স হবে। নতুন অ্যারে (10) .ফিল (নাল)। ম্যাপ (() => []) এটি কাছাকাছি যাওয়ার জন্য একটি সংক্ষিপ্ত পথ হবে (আমাকে প্রাথমিকভাবে জ্বালিয়ে দিলেন)

— জন কালভিনার

আপডেট ২০১

— কার্ল মরিসন

এটি অ্যারেগুলির জন্য কাজ করবে। a = Array(10).fill(null).map(() => { return []; });

— অ্যান্ডি

@ অ্যান্ড্রুঅ্যান্টনি জার্স্ট টার্সার:a = Array(10).fill(0).map( _ => [] );

— ফোগজ

Answer 6

নোট যোগ করা অগস্ট 2013, ফেব্রুয়ারী 2015 আপডেট হয়েছে: 2009 থেকে নীচের উত্তর জাভাস্ক্রিপ্টের জেনেরিকের সাথে সম্পর্কিত Array ধরণের । এটা তোলে নতুন কহা না টাইপ [MANY ব্রাউজারে এখন এবং উপলব্ধ] ES2015 সংজ্ঞায়িত অ্যারে, মত Int32Arrayএবং এই ধরনের। এছাড়াও খেয়াল করুন যে ES2015 fillউভয় অ্যারে এবং টাইপ করা অ্যারেগুলিতে একটি পদ্ধতি যুক্ত করেছে , এটি সম্ভবত পূরণের সবচেয়ে কার্যকর উপায় হতে পারে ...

এছাড়াও, আপনি কীভাবে অ্যারে তৈরি করেন তা কিছু বাস্তবায়নে এটি একটি বড় পার্থক্য করতে পারে। ক্রোমের ভি 8 ইঞ্জিন, বিশেষত, কেবলমাত্র যখন প্রয়োজন তখন অবজেক্ট-ভিত্তিক অ্যারেটিতে স্থানান্তরিত করতে পারে এমনটি যদি মনে করে তবে এটি একটি অত্যন্ত দক্ষ, সংক্ষিপ্ত-মেমরি অ্যারে ব্যবহার করার চেষ্টা করে।

---

বেশিরভাগ ভাষার সাথে এটি প্রাক-বরাদ্দ হবে, তারপরে শূন্য-পূরণ হবে:

function newFilledArray(len, val) {
    var rv = new Array(len);
    while (--len >= 0) {
        rv[len] = val;
    }
    return rv;
}

তবে , জাভাস্ক্রিপ্ট অ্যারেগুলি সত্যই অ্যারে নয় , তারা অন্য সকল জাভাস্ক্রিপ্ট অবজেক্টের মতো কী / মানচিত্রের মানচিত্র, তাই করার জন্য কোনও "প্রাক-বরাদ্দ" নেই (দৈর্ঘ্য নির্ধারণ করে যে অনেকগুলি স্লট পূরণ করতে বরাদ্দ দেয় না), বা না বিশ্বাস করার কোনও কারণ আছে যে শূন্যে গণনা করার সুবিধা (যা কেবল লুপের তুলনায় দ্রুত তৈরি করা যায়) বিপরীত ক্রমে কীগুলি যুক্ত করে কার্যকর করা সম্ভব নয় যখন বাস্তবায়নটি কীগুলি পরিচালনা করার ক্ষেত্রে অনুকূলতা অর্জন করতে পারে তত্ত্বের অ্যারে সম্পর্কিত যা আপনি সাধারণত তাদের ক্রম হিসাবে করেন।

প্রকৃতপক্ষে, ম্যাথু ক্রামলে উল্লেখ করেছেন যে ফায়ারফক্সে গণনা গণনা করা তুলনায় উল্লেখযোগ্যভাবে ধীরে ধীরে, যার ফলস্বরূপ আমি নিশ্চিত করতে পারি - এটির অ্যারে অংশ (শূন্যের নিচে লুপিং একটি ভারে সীমাবদ্ধতা অবধি লুপিংয়ের চেয়ে আরও দ্রুত)। স্পষ্টতই বিপরীতে ক্রমে উপাদানগুলিকে অ্যারেতে যুক্ত করা ফায়ারফক্সের একটি ধীর গতি। প্রকৃতপক্ষে, জাভাস্ক্রিপ্ট প্রয়োগের ফলে ফলাফলগুলি কিছুটা পৃথক হয় (যা এতটা অবাক করে না)। ব্রাউজার বাস্তবায়নের জন্য এখানে নীচে একটি দ্রুত এবং নোংরা পরীক্ষার পৃষ্ঠা রয়েছে (খুব নোংরা, পরীক্ষার সময় ফল দেয় না, তাই ন্যূনতম প্রতিক্রিয়া সরবরাহ করে এবং স্ক্রিপ্ট সময়সীমা থেকে অনেক বেশি চলবে)। আমি পরীক্ষার মধ্যে রিফ্রেশ সুপারিশ; আপনি যদি না করেন তবে এফএফ (কমপক্ষে) পুনরাবৃত্তি পরীক্ষাগুলি ধীর করে দেয়।

অ্যারে # কনক্যাট ব্যবহার করা মোটামুটি জটিল সংস্করণটি এফএফ-তে সরাসরি 1000 থেকে 2,000 অ্যালিমেন্ট অ্যারেগুলির তুলনায় দ্রুততর হয়। ক্রোমের ভি 8 ইঞ্জিনে, যদিও স্ট্রেট ডিএন প্রতিবারই জয়ী হয় ...

পরীক্ষার পৃষ্ঠাটি এখানে ( সরাসরি কপি ):

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Zero Init Test Page</title>
<style type='text/css'>
body {
    font-family:    sans-serif;
}
#log p {
    margin:     0;
    padding:    0;
}
.error {
    color:      red;
}
.winner {
    color:      green;
    font-weight:    bold;
}
</style>
<script type='text/javascript' src='prototype-1.6.0.3.js'></script>
<script type='text/javascript'>
var testdefs = {
    'downpre':  {
        total:  0,
        desc:   "Count down, pre-decrement",
        func:   makeWithCountDownPre
    },
    'downpost': {
        total:  0,
        desc:   "Count down, post-decrement",
        func:   makeWithCountDownPost
    },
    'up':       {
        total:  0,
        desc:   "Count up (normal)",
        func:   makeWithCountUp
    },
    'downandup':  {
        total:  0,
        desc:   "Count down (for loop) and up (for filling)",
        func:   makeWithCountDownArrayUp
    },
    'concat':   {
        total:  0,
        desc:   "Concat",
        func:   makeWithConcat
    }
};

document.observe('dom:loaded', function() {
    var markup, defname;

    markup = "";
    for (defname in testdefs) {
        markup +=
            "<div><input type='checkbox' id='chk_" + defname + "' checked>" +
            "<label for='chk_" + defname + "'>" + testdefs[defname].desc + "</label></div>";
    }
    $('checkboxes').update(markup);
    $('btnTest').observe('click', btnTestClick);
});

function epoch() {
    return (new Date()).getTime();
}

function btnTestClick() {

    // Clear log
    $('log').update('Testing...');

    // Show running
    $('btnTest').disabled = true;

    // Run after a pause while the browser updates display
    btnTestClickPart2.defer();
}
function btnTestClickPart2() {

    try {
        runTests();
    }
    catch (e) {
        log("Exception: " + e);
    }

    // Re-enable the button; we don't yheidl
    $('btnTest').disabled = false;
}

function runTests() {
    var start, time, counter, length, defname, def, results, a, invalid, lowest, s;

    // Get loops and length
    s = $F('txtLoops');
    runcount = parseInt(s);
    if (isNaN(runcount) || runcount <= 0) {
        log("Invalid loops value '" + s + "'");
        return;
    }
    s = $F('txtLength');
    length = parseInt(s);
    if (isNaN(length) || length <= 0) {
        log("Invalid length value '" + s + "'");
        return;
    }

    // Clear log
    $('log').update('');

    // Do it
    for (counter = 0; counter <= runcount; ++counter) {

        for (defname in testdefs) {
            def = testdefs[defname];
            if ($('chk_' + defname).checked) {
                start = epoch();
                a = def.func(length);
                time = epoch() - start;
                if (counter == 0) {
                    // Don't count (warm up), but do check the algorithm works
                    invalid = validateResult(a, length);
                    if (invalid) {
                        log("<span class='error'>FAILURE</span> with def " + defname + ": " + invalid);
                        return;
                    }
                }
                else {
                    // Count this one
                    log("#" + counter + ": " + def.desc + ": " + time + "ms");
                    def.total += time;
                }
            }
        }
    }

    for (defname in testdefs) {
        def = testdefs[defname];
        if ($('chk_' + defname).checked) {
            def.avg = def.total / runcount;
            if (typeof lowest != 'number' || lowest > def.avg) {
                lowest = def.avg;
            }
        }
    }

    results =
        "<p>Results:" +
        "<br>Length: " + length +
        "<br>Loops: " + runcount +
        "</p>";
    for (defname in testdefs) {
        def = testdefs[defname];
        if ($('chk_' + defname).checked) {
            results += "<p" + (lowest == def.avg ? " class='winner'" : "") + ">" + def.desc + ", average time: " + def.avg + "ms</p>";
        }
    }
    results += "<hr>";
    $('log').insert({top: results});
}

function validateResult(a, length) {
    var n;

    if (a.length != length) {
        return "Length is wrong";
    }
    for (n = length - 1; n >= 0; --n) {
        if (a[n] != 0) {
            return "Index " + n + " is not zero";
        }
    }
    return undefined;
}

function makeWithCountDownPre(len) {
    var a;

    a = new Array(len);
    while (--len >= 0) {
        a[len] = 0;
    }
    return a;
}

function makeWithCountDownPost(len) {
    var a;

    a = new Array(len);
    while (len-- > 0) {
        a[len] = 0;
    }
    return a;
}

function makeWithCountUp(len) {
    var a, i;

    a = new Array(len);
    for (i = 0; i < len; ++i) {
        a[i] = 0;
    }
    return a;
}

function makeWithCountDownArrayUp(len) {
    var a, i;

    a = new Array(len);
    i = 0;
    while (--len >= 0) {
        a[i++] = 0;
    }
    return a;
}

function makeWithConcat(len) {
    var a, rem, currlen;

    if (len == 0) {
        return [];
    }
    a = [0];
    currlen = 1;
    while (currlen < len) {
        rem = len - currlen;
        if (rem < currlen) {
            a = a.concat(a.slice(0, rem));
        }
        else {
            a = a.concat(a);
        }
        currlen = a.length;
    }
    return a;
}

function log(msg) {
    $('log').appendChild(new Element('p').update(msg));
}
</script>
</head>
<body><div>
<label for='txtLength'>Length:</label><input type='text' id='txtLength' value='10000'>
<br><label for='txtLoops'>Loops:</label><input type='text' id='txtLoops' value='10'>
<div id='checkboxes'></div>
<br><input type='button' id='btnTest' value='Test'>
<hr>
<div id='log'></div>
</div></body>
</html>

Comments

আপনি কেবলমাত্র উপাদানগুলিতে অ্যাক্সেস করছেন (সেগুলি মুছে ফেলা হচ্ছে না) এবং আপনি ইতিমধ্যে প্রাক-বরাদ্দ হয়ে গেছেন তা নিশ্চিত না যে পিছনের দিকগুলি পূরণ করা এখানে গুরুত্বপূর্ণ। আমি কি ভূল?

— ট্রিপটিচ

পিছনের দিকের ফিলের বিন্দুটি অ্যারের সাথে বিশেষভাবে করা নয়, কিছুক্ষণের জন্য পালানোর শর্তটি করা উচিত - ভুয়া 0 খুব দক্ষতার সাথে লুপটি সমাপ্ত করে

— অন্নাকাট

(যদিও আমি সবেমাত্র লক্ষ্য করেছি যে এই কোডটি আসলে এটি ব্যবহার করে না)

— অন্নাকাট

@ ননাকাটা, আপনি এখানে এটি ব্যবহার করতে পারবেন না, কারণ 0 একটি বৈধ সূচক।

— ট্রিপটিচ

@ ট্রাইপটিচ: সত্য নয়, এটি সমস্তটাই সঠিক অর্ডার - আমার পোস্টটি দেখুন

— অনাকাটা

Answer 7

ডিফল্টরূপে Uint8Array, Uint16Arrayএবং Uint32Arrayক্লাস, তার মান হিসাবে শূন্য রাখা যাতে করে আপনাকে কোনো জটিল ভর্তি কৌশল প্রয়োজন হবে না, শুধু একটি করুন:

var ary = new Uint8Array(10);

অ্যারের সমস্ত উপাদান aryডিফল্টভাবে শূন্য হবে।

Comments

এই চমৎকার কিন্তু মন নোট এই একটি স্বাভাবিক অ্যারে হিসাবে একই চিকিত্সা করা যাবে না, যেমন Array.isArray(ary)হয় false। দৈর্ঘ্যটি কেবল পঠনযোগ্য তাই আপনি নতুন আইটেমগুলিকে এর মতো ary.push

— চাপতে

সমস্ত টাইপ করা অ্যারেগুলি 0তাদের ডিফল্ট মান হিসাবে রাখে wi

— jfunk

@ মুসিকআনিমাল, Array.from(new Uint8Array(10))একটি সাধারণ অ্যারে সরবরাহ করবে।

— টমাস ল্যাংকাআস

@ টমাসল্যাংকাআস: হ্যাঁ, তবে অন্য একটি জবাব দেখায় যে Array(n).fill(0)আপনার যদি জেএস অ্যারে আসলেই প্রয়োজন হয় তবে এটি ক্রোমের চেয়ে প্রায় 5x কম er আপনি যদি কোনও টাইপড্রাই ব্যবহার করতে পারেন তবে এটির তুলনায় এটি আরও দ্রুততর .fill(0), বিশেষত যদি আপনি এর ডিফল্ট আরম্ভকারী মানটি ব্যবহার করতে পারেন 0। এমন কোনও নির্মাণকারীর মতো মনে হচ্ছে না যা পূরণের মান এবং দৈর্ঘ্য নেয়, সি ++ std::vectorএর মতো উপায় । এটি শূন্য নয় এমন কোনও মানের জন্য মনে হচ্ছে আপনাকে একটি শূন্যযুক্ত টাইপড্ররে তৈরি করতে হবে এবং তারপরে এটি পূরণ করতে হবে। : /

— পিটার

Answer 8

আপনি যদি ES6 ব্যবহার করেন তবে আপনি অ্যারে.ফর্ম () এর মতো ব্যবহার করতে পারেন :

Array.from({ length: 3 }, () => 0);
//[0, 0, 0]

একই ফলাফল আছে

Array.from({ length: 3 }).map(() => 0)
//[0, 0, 0]

কারণ

Array.from({ length: 3 })
//[undefined, undefined, undefined]

Answer 9

function makeArrayOf(value, length) {
  var arr = [], i = length;
  while (i--) {
    arr[i] = value;
  }
  return arr;
}

makeArrayOf(0, 5); // [0, 0, 0, 0, 0]

makeArrayOf('x', 3); // ['x', 'x', 'x']

লক্ষ্য করুন whileসাধারণত অধিক কার্যকরী হয় for-in, forEachইত্যাদি

Comments

নয় iস্থানীয় পরিবর্তনশীল বিদেশী? lengthমান দ্বারা পাস করা হয় যাতে আপনার এটি সরাসরি হ্রাস করতে সক্ষম হওয়া উচিত।

— শান উজ্জ্বল

যদিও এটি প্রথমে দুর্দান্ত দেখায়, দুর্ভাগ্যক্রমে এটির (যেমন arr[i] = value) একটি স্বেচ্ছাসেবী বিন্দুতে মান নির্ধারণ করা খুব ধীর । এটি শুরু থেকে শেষ এবং ব্যবহার পর্যন্ত লুপ করা খুব দ্রুত arr.push(value)। এটি বিরক্তিকর, কারণ আমি আপনার পদ্ধতিটি পছন্দ করি।

— নিক ব্রান্ট

Answer 10

অবজেক্ট স্বরলিপি ব্যবহার করে

var x = [];

শূন্য ভরা? মত ...

var x = [0,0,0,0,0,0];

'অপরিবর্তিত' দিয়ে ভরা ...

var x = new Array(7);

শূন্য সঙ্গে আপত্তি স্বরলিপি

var x = [];
for (var i = 0; i < 10; i++) x[i] = 0;

পার্শ্ব নোট হিসাবে, আপনি যদি অ্যারের প্রোটোটাইপটি উভয়টি সংশোধন করেন

var x = new Array();

এবং

var y = [];

এই প্রোটোটাইপ পরিবর্তন আছে

যাইহোক, আমি এই অপারেশনের দক্ষতা বা গতির সাথে অত্যধিকভাবে উদ্বিগ্ন হব না, এমন আরও অনেকগুলি কাজ রয়েছে যা আপনি সম্ভবত করছেন যেগুলি শূন্যগুলি সহ নির্ধারিত দৈর্ঘ্যের অ্যারে ইনস্ট্যান্সিয়েট করার চেয়ে অনেক বেশি অপচয় এবং ব্যয়বহুল।

Comments

এর ... nullএই অ্যারেটিতে কোনও এস নেই -var x = new Array(7);

— কঙ্গাক্স

প্রকৃতপক্ষে, অ্যারে কোনও নতুন অ্যারে (এন) দিয়ে পূর্ণ হয় না, এমনকি 'অপরিবর্তিত' নয়, এটি কেবল অ্যারের দৈর্ঘ্যের মানকে এন তে সেট করে। আপনি এটিকে (নতুন অ্যারে (1)) কল করে চেক করতে পারেন for ফর (প্রতিটি) ... () জন্য। forEach কখনই কার্যকর করে না, যদি আপনি এটিকে [অপরিজ্ঞাত] বলে থাকেন তবে তার বিপরীতে।

— JussiR

new Array(7)"অপরিবর্তিত" দিয়ে কোনও অ্যারে তৈরি করে না । এটি দৈর্ঘ্যের 7 সহ একটি খালি অ্যারে তৈরি করে

— রবজি

আপনি নিজের উত্তরের কিছু অংশ পুনর্বিবেচনা করতে চান যেহেতু @ রবজি যা বলছে তা সমালোচনাযোগ্য (যদি আপনি যা বলছিলেন সত্যই, ম্যাপিংটি আরও সহজ হত)

— আবদো

এই দিন আপনি করতে পারে (new Array(10)).fill(0) ।

— জাভিয়ের ডি লা রোজা

Answer 11

আমি প্রাক বরাদ্দকৃত / প্রাক-বরাদ্দ নয়, গণনা / নিচে গণনা এবং আই 6/7/8, ফায়ারফক্স 3.5, ক্রোম এবং অপেরাতে লুপগুলি / এর জন্য সমস্ত সংমিশ্রণ পরীক্ষা করেছি।

নীচের ফাংশনগুলি ফায়ারফক্স, ক্রোম এবং আই 8 এ ধারাবাহিকভাবে দ্রুত বা অত্যন্ত নিকটে ছিল এবং অপেরা এবং আইই 6 এর দ্রুততম তুলনায় খুব ধীর ছিল না এটি আমার মতে সহজতম এবং স্পষ্টও। আমি বেশ কয়েকটি ব্রাউজার পেয়েছি যেখানে লুপ সংস্করণটি সামান্য দ্রুত, তাই আমি এটিও রেফারেন্সের জন্য অন্তর্ভুক্ত করছি।

function newFilledArray(length, val) {
    var array = [];
    for (var i = 0; i < length; i++) {
        array[i] = val;
    }
    return array;
}

অথবা

function newFilledArray(length, val) {
    var array = [];
    var i = 0;
    while (i < length) {
        array[i++] = val;
    }
    return array;
}

Comments

আপনি var array = []ঘোষণাকে লুপের প্রথম অংশে ফেলে দিতে পারেন , কেবলমাত্র কমা দ্বারা পৃথক।

— দামিয়ানব

আমি দামিয়ানব এর পরামর্শটি পছন্দ করি তবে বর্ধিতকরণের আগে অ্যাসাইনমেন্ট এবং কমা রাখার কথা মনে রাখি! `এর জন্য (var i = 0; i <দৈর্ঘ্য; অ্যারে [i] = ভাল, i ++);

— পেনট্রেস

অন্য প্রত্যেকে আপনার দ্বিতীয়টির জন্য যা হারিয়েছে তা করুন এবং অ্যারের দৈর্ঘ্য lengthইতিমধ্যে প্রদত্ত মানটিতে সেট করুন যাতে এটি নিয়মিত পরিবর্তন হয় না। আমার মেশিনে 1 মিলিয়ন দৈর্ঘ্যের অ্যারে শূন্যের 40 মিমি থেকে 8 টি পর্যন্ত এনেছে।

— জোনাথন গ্রে

আমি যখন এই দ্রবণটিকে এক লাইনে পরিণত করি তখন আমি 10-15% গতি বৃদ্ধি পাব বলে মনে হয়। for (i = 0, array = []; i < length; ++i) array[i] = val;.. কিছুটা ব্লক? ... যাইহোক, এছাড়াও ... আমি যদি array.lengthনতুন অ্যারের দৈর্ঘ্যটি সেট করে রাখি .. তবে আমি এফএফ-তে আরও 10% -15% গতি বৃদ্ধি পাব বলে মনে হচ্ছে ... ক্রোমে, এটি গতি দ্বিগুণ বলে মনে হচ্ছে -> var i, array = []; array.length = length; while(i < length) array[i++] = val;(আমি যদি এটি forলুপ হিসাবে রেখে দিয়েছিলাম তবে আরও দ্রুত ছিল ... তবে আর while

— ডিআইআইটির

আমি আমার পরীক্ষায় এটিও নোট করব। আমার পরীক্ষার মামলার একটি শালীন সংখ্যায়, উপরের চূড়ান্ত সংস্করণটি 10x এর চেয়ে দ্রুত গতিতে দ্রুত 3x সম্পাদন করছে বলে মনে হচ্ছে ... কেন আমি নিশ্চিত নই ... (ক্রোম এবং এফএফ-এর মধ্যে বিভিন্ন অ্যারের আকারের পরীক্ষা করা হয়েছে)

— পিম্প ট্রাইজকিট

Answer 12

function zeroFilledArray(size) {
    return new Array(size + 1).join('0').split('');
}

Comments

আপনি new Array(size+1).join("x").split("x").map(function() { return 0; })প্রকৃত সংখ্যাগুলি

— পেতেও

@ ইউভাল বা ঠিকnew Array(size+1).join('0').split('').map(Number)

— পল

Answer 13

আপনার কোডটি কার্যকর করার সময় যদি আপনাকে বিভিন্ন দৈর্ঘ্যের অনেকগুলি শূন্য ভরাট অ্যারে তৈরি করতে হয় তবে আমি এটির দ্রুততম উপায়টি খুঁজে পেয়েছি একবার শূন্য অ্যারে তৈরি করা is এই শর্তে উল্লিখিত পদ্ধতিগুলির একটি ব্যবহার করে আপনি জানেন যা কখনও ছাড়িয়ে যাবে না এবং তারপরে প্রয়োজনীয় অ্যারেটি কেটে নিন।

উদাহরণস্বরূপ (অ্যারে শুরু করার জন্য উপরের উত্তর থেকে ফাংশনটি ব্যবহার করে), দৈর্ঘ্য সর্বাধিক দৈর্ঘ্যের একটি শূন্য ভরাট অ্যারে তৈরি করুন , কোডটির জন্য শূন্য অ্যারেগুলির দরকার একটি ভেরিয়েবল হিসাবে:

var zero = newFilledArray(maxLength, 0);

এখন এই অ্যারের সব যেভাবেই আপনি দৈর্ঘ্যের একটি শূন্য ভরা অ্যারের প্রয়োজন requiredLength < MAXLENGTH :

zero.slice(0, requiredLength);

আমি আমার কোডটি কার্যকর করার সময় কয়েক হাজার বার শূন্য ভরাট অ্যারে তৈরি করছিলাম, এটি প্রক্রিয়াটিকে দুর্দান্তভাবে গতিবেগ করেছে।

Answer 14

এর বিরুদ্ধে আমার কিছুই নেই:

Array.apply(null, Array(5)).map(Number.prototype.valueOf,0);
new Array(5+1).join('0').split('').map(parseFloat);

জের্তোষ দ্বারা প্রস্তাবিত, তবে একটি নতুন ES6 অ্যারে এক্সটেনশনে আপনাকে fillপদ্ধতিতে স্থানীয়ভাবে এটি করার অনুমতি দেয় । এখন আইই প্রান্ত, ক্রোম এবং এফএফ এটি সমর্থন করে তবে উপযুক্ততা সারণীটি পরীক্ষা করুন check

new Array(3).fill(0)দিতে হবে [0, 0, 0]। আপনি অ্যারে যেমন কোনও মান new Array(5).fill('abc')(এমনকি বস্তু এবং অন্যান্য অ্যারে) দিয়ে পূরণ করতে পারেন ।

তার উপরে আপনি পূর্বের অ্যারেগুলি পূরণ করে সংশোধন করতে পারেন:

arr = [1, 2, 3, 4, 5, 6]
arr.fill(9, 3, 5)  # what to fill, start, end

যা আপনাকে দেয়: [1, 2, 3, 9, 9, 6]

Answer 15

আমি সাধারণত যেভাবে এটি করি (এবং আশ্চর্যজনক দ্রুত) তা ব্যবহার করছে Uint8Array। উদাহরণস্বরূপ, 1 এম উপাদানগুলির একটি শূন্য ভেক্টর তৈরি করা:

  var zeroFilled = [].slice.apply(new Uint8Array(1000000))

আমি লিনাক্স ব্যবহারকারী এবং সর্বদা আমার জন্য কাজ করেছি, তবে একবার ম্যাক ব্যবহার করা বন্ধুর কিছু শূন্য উপাদান ছিল না। আমি ভেবেছিলাম তার মেশিনটি ত্রুটিযুক্ত ছিল, তবে এখনও এটি ঠিক করার জন্য আমরা এখানে সবচেয়ে নিরাপদ উপায় পেয়েছি:

  var zeroFilled = [].slice.apply(new Uint8Array(new Array(1000000)) 

সম্পাদিত

ক্রোম 25.0.1364.160

1. ফ্রেডেরিক গটলিয়েব - 6.43
2. স্যাম বার্নুম - 4.83
3. এলি - 3.68
4. জোশুয়া 2.91
5. ম্যাথিউ ক্রামলে - 2.67
6. bduran - 2.55
7. অ্যালেন রাইস - 2.11
8. কঙ্গাক্স - 0.68
9. TJ। জনতা - 0.67
10. জেরটোশ - ত্রুটি

ফায়ারফক্স 20.0

1. অ্যালেন রাইস - 1.85
2. জোশুয়া - 1.82
3. ম্যাথিউ ক্রামলে - 1.79
4. bduran - 1.37
5. ফ্রেডেরিক গটলিয়েব - 0.67
6. স্যাম বার্নুম - 0.63
7. এলি - 0.59
8. কাগজ - 0.13
9. TJ। ক্রাউডার - 0.13
10. জেরটোশ - ত্রুটি

সবচেয়ে গুরুত্বপূর্ণ পরীক্ষাটি নিখোঁজ হয়েছে (কমপক্ষে আমার জন্য): নোড.জেএস একটি। আমি সন্দেহ করি এটি ক্রোম বেনমার্কের খুব কাছে।

Comments

এটি আমার আঙ্গুলগুলির জন্য এবং আমার চোখের জন্য সবচেয়ে কার্যকর উপায়। তবে এটি ক্রোমের পক্ষে খুব ধীর গতির (সেই জেএসপিফের সাথে সম্মত .৯% ধীর)।

— অরওলোফিল

আমি ভাবছি যদি আপনার বন্ধুর Mac এ সমস্যা সম্পর্কিত ছিল: stackoverflow.com/questions/39129200/... হয়তো বা Array.slice UInt8Array হ্যান্ডলিং এবং uninitialised মেমরি লিক করা হয়নি? (একটি সুরক্ষা সমস্যা!)।

— রোবোকট

@robocat ভাল ধরা! যদি আমি এটি ভালভাবে মনে করি তবে আমরা নোড.জেএস 0 0 বা 0.8 ব্যবহার করছিলাম। আমরা একধরণের ফাঁস হওয়ার কথা ভেবেছিলাম কিন্তু আমরা এটি উত্পাদন স্ট্যাকের সাথে পুনরুত্পাদন করতে পারিনি তাই আমরা কেবল এটিকে এড়িয়ে যাওয়ার সিদ্ধান্ত নিয়েছি।

— durum

Answer 16

লড্যাশ বা আন্ডারস্কোর ব্যবহার করা

_.range(0, length - 1, 0);

অথবা যদি আপনার কাছে অ্যারে বিদ্যমান থাকে এবং আপনি একই দৈর্ঘ্যের একটি অ্যারে চান

array.map(_.constant(0));

Comments

আমি আন্ডারস্কোর ব্যবহার করার সাথে সাথে আপনি এই উত্তরটি যুক্ত করেছেন বলে খুব খুশী হয়েছিলেন এবং আমি জানতাম যে এর জন্য কিছু ছিল ... তবে এখনও এটি সন্ধান করতে পারিনি। আমি কেবল ইচ্ছুক যে আমি এটি ব্যবহার করে অবজেক্টগুলির অ্যারে তৈরি করতে পারতাম

— পান্ডাওয়ুড

@ পান্ডাওড _আরঞ্জ (0, দৈর্ঘ্য -1, 0)। ম্যাপ (অবজেক্ট.নু), আমি মনে করি।

— djechlin

হওয়া উচিত _.range(0, length, 0), আমি বিশ্বাস করি। লোডাশ শেষ মানটির সাথে একচেটিয়া

— ব্যবহারকারী 481515162342

Answer 17

ES6 সমাধান:

[...new Array(5)].map(x => 0); // [0, 0, 0, 0, 0]

Answer 18

ECMAScript2016 হিসাবে, বড় অ্যারেগুলির জন্য একটি পরিষ্কার পছন্দ রয়েছে।

যেহেতু এই উত্তরটি এখনও গুগল অনুসন্ধানে শীর্ষের কাছাকাছি দেখা যাচ্ছে, তাই 2017 এর উত্তর এখানে।

কয়েক ডজন জনপ্রিয় পদ্ধতি সহ একটি বর্তমান জেএসবেঞ্চ এখানে রয়েছে, এই প্রশ্নটিতে এখন পর্যন্ত অনেকগুলি প্রস্তাবিত রয়েছে। আপনি যদি আরও ভাল পদ্ধতি খুঁজে পান তবে দয়া করে যুক্ত করুন, কাঁটাচামচ করুন এবং ভাগ করুন।

আমি লক্ষ করতে চাই যে একটি নির্বিচার দৈর্ঘ্য শূন্য ভরাট অ্যারে তৈরি করার জন্য সত্যিকারের সবচেয়ে কার্যকর উপায় নেই। আপনি গতির জন্য, বা স্বচ্ছতা এবং রক্ষণাবেক্ষণের জন্য অনুকূল করতে পারেন - হয় প্রকল্পের প্রয়োজনের উপর নির্ভর করে আরও দক্ষ পছন্দ হিসাবে বিবেচনা করা যেতে পারে।

গতির জন্য অনুকূলকরণ করার সময়, আপনি চান: আক্ষরিক বাক্য গঠন ব্যবহার করে অ্যারে তৈরি করুন; দৈর্ঘ্য সেট করুন, পুনরুক্তি পরিবর্তনশীল আরম্ভ করুন এবং কিছুক্ষণ লুপ ব্যবহার করে অ্যারের মাধ্যমে পুনরাবৃত্তি করুন। এখানে একটি উদাহরণ।

const arr = [];
arr.length = 120000;
let i = 0;
while (i < 120000) {
  arr[i] = 0;
  i++;
}

আর একটি সম্ভাব্য বাস্তবায়ন হ'ল:

(arr = []).length = n;
let i = 0;
while (i < n) {
    arr[i] = 0;
    i++;
}

তবে আমি এই দ্বিতীয় প্রতিস্থাপনটি ব্যবহারে দৃ strongly়ভাবে নিরুৎসাহিত করব কারণ এটি কম পরিষ্কার এবং আপনাকে আপনার অ্যারে ভেরিয়েবলের উপর ব্লক স্কোপিং বজায় রাখতে দেয় না।

এগুলি লুপের জন্য পূরণের চেয়ে উল্লেখযোগ্যভাবে দ্রুত এবং মানক পদ্ধতির চেয়ে প্রায় 90% দ্রুত faster

const arr = Array(n).fill(0);

তবে স্বচ্ছতা, সংক্ষিপ্ততা এবং রক্ষণাবেক্ষণের কারণে এই পূরণ পদ্ধতিটি এখনও ছোট অ্যারেগুলির পক্ষে সবচেয়ে কার্যকর পছন্দ। পারফরম্যান্স পার্থক্য সম্ভবত আপনাকে মেরে ফেলবে না আপনি যদি না কয়েক হাজার বা আরও বেশি ক্রমের উপর দিয়ে দৈর্ঘ্যের সাথে প্রচুর অ্যারে তৈরি করেন making

আরও কয়েকটি গুরুত্বপূর্ণ নোট বেশিরভাগ স্টাইল গাইড আপনাকে varES6 বা তার পরে ব্যবহার করার সময় খুব বিশেষ কারণ ছাড়াই আপনাকে আর ব্যবহার না করার পরামর্শ দেয় । constপরিবর্তনশীলগুলির জন্য ব্যবহার করুন যা পুনরায় সংজ্ঞায়িত হবে না এবং letভেরিয়েবলগুলির জন্য যা হবে will MDN এবং Airbnb এর শৈলী গাইড মহান সর্বোত্তম কার্যাভ্যাস সম্পর্কে আরও তথ্যের জন্য যেতে স্থান। প্রশ্নগুলি সিনট্যাক্স সম্পর্কে ছিল না, তবে জেএসে নতুন লোকেরা পুরানো এবং নতুন উত্তরগুলির এই রিমগুলি অনুসন্ধান করার সময় এই নতুন মান সম্পর্কে জেনে রাখা গুরুত্বপূর্ণ।

Answer 19

একটি নতুন নতুন অ্যারে তৈরি করতে

new Array(arrayLength).fill(0);

বিদ্যমান অ্যারের শেষে কিছু মান যুক্ত করতে

[...existingArray, ...new Array(numberOfElementsToAdd).fill(0)]

উদাহরণ

//**To create an all new Array**

console.log(new Array(5).fill(0));

//**To add some values at the end of an existing Array**

let existingArray = [1,2,3]

console.log([...existingArray, ...new Array(5).fill(0)]);

Answer 20

উত্তরে এই পদ্ধতিটি দেখেনি, সুতরাং এটি এখানে:

"0".repeat( 200 ).split("").map( parseFloat )

ফলস্বরূপ আপনি দৈর্ঘ্যের 200 শূন্য-মূল্যবান অ্যারে পাবেন:

[ 0, 0, 0, 0, ... 0 ]

আমি এই কোডটির কার্যকারিতা সম্পর্কে নিশ্চিত নই তবে আপনি যদি এটি অপেক্ষাকৃত ছোট অ্যারে ব্যবহার করেন তবে এটি কোনও সমস্যা হওয়া উচিত নয়।

Comments

দ্রুততম বা সংক্ষিপ্ততম কোনওটিই নয় তবে সমাধানের বৈচিত্র্যে দুর্দান্ত অবদান।

— 7vujy0f0hy

Answer 21

const arr = Array.from({ length: 10 }).fill(0)

Comments

এটি শূন্যের সাথে অ্যারে পূরণ করে না। এটি এটি অপরিশোধিত দিয়ে পূর্ণ করে।

— jlh

@ জেএলএইচ ধন্যবাদ স্থির

— d্লেক্স ডায়কিі

Answer 22

কি হবে new Array(51).join('0').split('')?

Comments

তাহলে .map(function(a){return +a})?

— lonewarrior556

Answer 23

লুপ কোডের জন্য সবচেয়ে ছোট

a=i=[];for(;i<100;)a[i++]=0;

edit:
for(a=i=[];i<100;)a[i++]=0;
or
for(a=[],i=100;i--;)a[i]=0;

নিরাপদ ভার্সন সংস্করণ

var a=[],i=0;for(;i<100;)a[i++]=0;

edit:
for(var i=100,a=[];i--;)a[i]=0;

Comments

দৈর্ঘ্যটি একটি সংজ্ঞায়িত পরিবর্তনশীল হিসাবে প্রদত্ত, এটি আরও nখাটো হবে:for(var a=[];n--;a[n]=0);

— টমাস ল্যাংকায়াস

Answer 24

আমার দ্রুততম কাজটি হবে:

function newFilledArray(len, val) {
    var a = [];
    while(len--){
        a.push(val);
    }
    return a;
}

var st = (new Date()).getTime();
newFilledArray(1000000, 0)
console.log((new Date()).getTime() - st); // returned 63, 65, 62 milliseconds

অ্যারেতে আইটেম যুক্ত করতে নেটিভ পুশ এবং শিফ্ট ব্যবহার করা অ্যারের স্কোপটি ঘোষণা করার এবং প্রতিটি আইটেমটির মান নির্ধারণের চেয়ে উল্লেখ করার চেয়ে অনেক দ্রুত (প্রায় 10 বার)।

ফাইআই: ফায়ারব্যাগে (ফায়ারফক্স এক্সটেনশন) চালানোর সময় আমি প্রথম লুপটির সাথে ধারাবাহিকভাবে দ্রুতগতি লাভ করি।

var a = [];
var len = 1000000;
var st = (new Date()).getTime();
while(len){
    a.push(0);
    len -= 1;
}
console.log((new Date()).getTime() - st); // returned 863, 894, 875 milliseconds
st = (new Date()).getTime();
len = 1000000;
a = [];
for(var i = 0; i < len; i++){
    a.push(0);
}
console.log((new Date()).getTime() - st); // returned 1155, 1179, 1163 milliseconds

আমি জানতে আগ্রহী যে টিজে ক্রোডার এটি কী করে? :-)

Comments

আপনি এটি এটিকে পরিবর্তন করে দ্রুততর করে তুলতে পারেন while (len--).. আমার প্রসেসিংয়ের সময়টি প্রায় 60 মিমি থেকে প্রায় 54 মিমি নিয়ে গেছে

— নিকফ

ম্যাথু ক্রম্বলির উত্তর এখনও এটি (30 মিমি) মারছে!

— নিকফ

Answer 25

এই concatসংস্করণটি Chrome এ আমার পরীক্ষাগুলিতে আরও দ্রুত (2013-03-21)। 10,000,000 উপাদানের জন্য প্রায় 200ms সোজা আরম্ভের জন্য 675 বনাম।

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

বোনাস: আপনি যদি স্ট্রিং দিয়ে আপনার অ্যারে পূরণ করতে চান তবে এটি করার একটি সংক্ষিপ্ত উপায় এটি (যতটা দ্রুত তত দ্রুত নয় concat):

function filledArrayString(len, value) {
    return new Array(len+1).join(value).split('');
}

Comments

ঠিক আছে, বন্য। এটি নতুন অ্যারে (লেন) ব্যবহারের চেয়ে দ্রুত। কিন্ত! আমি ক্রোমে দেখছি যে পরবর্তীকালে সেই ডেটা পড়তে যথেষ্ট সময় লাগে। আমার অর্থ কী তা বোঝানোর জন্য এখানে কয়েকটি টাইমস্ট্যাম্প রয়েছে: (নতুন অ্যারে (লেন) ব্যবহার করে) 0.365: অ্যারে তৈরি করা 4.526: কনভোলিউশন কার্যকর করা হচ্ছে 10.75: কনভোলিউশন সম্পূর্ণ (কনটাক্ট ব্যবহার করা) 0.339: অ্যারে তৈরি করা 0.591: কনভোলিউশন নির্বাহ // ওএমজি, দ্রুত 18.056: কনভোলিউশন সম্পূর্ণ

— ব্রুকস

Answer 26

আমি টিজে ক্রোডার দ্বারা দুর্দান্ত উত্তরটি পরীক্ষা করছিলাম, এবং ক্রোমে তার পরীক্ষাগুলিতে যে কোনওটি ছাড়িয়ে যায় এমন কনট্যাট সমাধানের ভিত্তিতে একটি পুনরাবৃত্ত মার্জ নিয়ে এসেছি (আমি অন্যান্য ব্রাউজারগুলিকে পরীক্ষা করি নি)।

function makeRec(len, acc) {
    if (acc == null) acc = [];
    if (len <= 1) return acc;
    var b = makeRec(len >> 1, [0]);
    b = b.concat(b);
    if (len & 1) b = b.concat([0]);
    return b;
},

পদ্ধতিটি কল করুন makeRec(29)।

Answer 27

এটি উল্লেখ করার মতো হতে পারে Array.prototype.fill, এটি ইসমাস্ক্রিপ্ট ((হারমোনি) প্রস্তাবনার অংশ হিসাবে যুক্ত করা হয়েছিল । থ্রেডে উল্লিখিত অন্যান্য বিকল্পগুলি বিবেচনা করার আগে আমি নীচে লিখিত পলিফিলটি দিয়ে যেতে চাই।

if (!Array.prototype.fill) {
  Array.prototype.fill = function(value) {

    // Steps 1-2.
    if (this == null) {
      throw new TypeError('this is null or not defined');
    }

    var O = Object(this);

    // Steps 3-5.
    var len = O.length >>> 0;

    // Steps 6-7.
    var start = arguments[1];
    var relativeStart = start >> 0;

    // Step 8.
    var k = relativeStart < 0 ?
      Math.max(len + relativeStart, 0) :
      Math.min(relativeStart, len);

    // Steps 9-10.
    var end = arguments[2];
    var relativeEnd = end === undefined ?
      len : end >> 0;

    // Step 11.
    var final = relativeEnd < 0 ?
      Math.max(len + relativeEnd, 0) :
      Math.min(relativeEnd, len);

    // Step 12.
    while (k < final) {
      O[k] = value;
      k++;
    }

    // Step 13.
    return O;
  };
}

Answer 28

let filled = [];
filled.length = 10;
filled.fill(0);

console.log(filled);

Answer 29

আমি জানতাম আমার কোথাও এই প্রোটো আছে :)

Array.prototype.init = function(x,n)
{
    if(typeof(n)=='undefined') { n = this.length; }
    while (n--) { this[n] = x; }
    return this;
}

var a = (new Array(5)).init(0);

var b = [].init(0,4);

সম্পাদনা: পরীক্ষা

জোশুয়া এবং অন্যান্য পদ্ধতির প্রতিক্রিয়া হিসাবে আমি আমার নিজস্ব বেঞ্চমার্কিং চালিয়েছি, এবং আমি তাদের প্রতিদ্বন্দ্বীদের সম্পূর্ণ ভিন্ন ফলাফল দেখছি।

আমি যা পরীক্ষা করেছি তা এখানে:

//my original method
Array.prototype.init = function(x,n)
{
    if(typeof(n)=='undefined') { n = this.length; }
    while (n--) { this[n] = x; }
    return this;
}

//now using push which I had previously thought to be slower than direct assignment
Array.prototype.init2 = function(x,n)
{
    if(typeof(n)=='undefined') { n = this.length; }
    while (n--) { this.push(x); }
    return this;
}

//joshua's method
function newFilledArray(len, val) {
    var a = [];
    while(len--){
        a.push(val);
    }
    return a;
}

//test m1 and m2 with short arrays many times 10K * 10

var a = new Date();
for(var i=0; i<10000; i++)
{
    var t1 = [].init(0,10);
}
var A = new Date();

var b = new Date();
for(var i=0; i<10000; i++)
{
    var t2 = [].init2(0,10);
}
var B = new Date();

//test m1 and m2 with long array created once 100K

var c = new Date();
var t3 = [].init(0,100000);
var C = new Date();

var d = new Date();
var t4 = [].init2(0,100000);
var D = new Date();

//test m3 with short array many times 10K * 10

var e = new Date();
for(var i=0; i<10000; i++)
{
    var t5 = newFilledArray(10,0);
}
var E = new Date();

//test m3 with long array created once 100K

var f = new Date();
var t6 = newFilledArray(100000, 0)
var F = new Date();

ফলাফল:

IE7 deltas:
dA=156
dB=359
dC=125
dD=375
dE=468
dF=412

FF3.5 deltas:
dA=6
dB=13
dC=63
dD=8
dE=12
dF=8

সুতরাং আমার গণনা ধাক্কা দিয়ে আসলেই সাধারণত ধীর হয় তবে এফএফ-তে দীর্ঘতর অ্যারেগুলির সাথে আরও ভাল সঞ্চালিত হয় তবে আইইয়ের চেয়েও খারাপ যা কেবল সাধারণভাবে (কোয়েল সারপ্রাইজ) ডাকে।

Comments

আমি এটি পরীক্ষা করে দেখেছি: দ্বিতীয় পদ্ধতিটি ( b = []...) প্রথমটির চেয়ে 10-15% দ্রুত, তবে এটি জোশুয়ার উত্তরের চেয়ে 10 গুণ বেশি ধীর।

— নিকফ

আমি জানি এটি একটি প্রাচীন পোস্ট । তবে এটি এখনও অন্যের (আমার মত) আগ্রহের বিষয়। অতএব আমি প্রোটোটাইপ ফাংশনটিতে একটি বিজ্ঞাপনের পরামর্শ দিতে চাই: চেকের else {this.length=n;}পরে একটি অন্তর্ভুক্ত করুন this.length। এটি initআলাদা দৈর্ঘ্যে পুনর্বিবেচনা করার সময় প্রয়োজনে এটি ইতিমধ্যে বিদ্যমান অ্যারে সংক্ষিপ্ত করবে n।

— কার

Answer 30

নামবিহীন ফাংশন:

(function(n) { while(n-- && this.push(0)); return this; }).call([], 5);
// => [0, 0, 0, 0, 0]

লুপের সাথে কিছুটা খাটো:

(function(n) { for(;n--;this.push(0)); return this; }).call([], 5);
// => [0, 0, 0, 0, 0]

যে কোনও সাথেই কাজ করে Object, কেবল যা ভিতরে রয়েছে তা পরিবর্তন করুন this.push()।

আপনি এমনকি ফাংশনটি সংরক্ষণ করতে পারেন:

function fill(size, content) {
  for(;size--;this.push(content));
  return this;
}

এটি ব্যবহার করে কল করুন:

var helloArray = fill.call([], 5, 'hello');
// => ['hello', 'hello', 'hello', 'hello', 'hello']

ইতিমধ্যে বিদ্যমান অ্যারেতে উপাদান যুক্ত করা:

var helloWorldArray = fill.call(helloArray, 5, 'world');
// => ['hello', 'hello', 'hello', 'hello', 'hello', 'world', 'world', 'world', 'world', 'world']

পারফরম্যান্স: http://jsperf.com/zero-filled-array-creation/25