javascript - জাভাস্ক্রিপ্ট বই pdf




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

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


ES6 সমাধান:

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

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

এএস 6 ব্যবহার করে এটি করার আরেকটি উপায় এখানে কেউ উল্লেখ করেনি:

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

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

উপরের উদাহরণে, প্রথম প্যারামিটার undefined মানের ভরাট 3 টি প্যারাসিকে বরাদ্দ করে এবং তারপর ল্যাম্বা ফাংশনটি তাদের প্রতিটি মানকে মান 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]

ES6 Array.prototype.fill প্রবর্তন। এটি এভাবে ব্যবহার করা যেতে পারে:

new Array(len).fill(0);

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

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


আপনি যদি ES6 ব্যবহার করেন তবে আপনি Array.from ব্যবহার করতে পারেন:

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

একই ফলাফল আছে

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

কারণ

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

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

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

Zertosh দ্বারা প্রস্তাবিত, কিন্তু একটি নতুন ES6 অ্যারে এক্সটেনশানগুলিতে আপনি fill পদ্ধতি সঙ্গে natively এই কাজ করতে পারবেন। এখন ইন্টারনেট প্রান্ত, ক্রোম এবং এফএফ এটি সমর্থন করে, কিন্তু সামঞ্জস্য টেবিলের চেক

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]


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

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)


আমি সাধারণত এটি করতে (এবং অবিশ্বাস্য দ্রুত) উপায় Uint8Array ব্যবহার করা 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. বিডুয়ান - 2.55
  7. অ্যালেন রাইস - 2.11
  8. কংੈਕਸ - 0.68
  9. TJ। ক্রাউডার - 0.67
  10. zertosh - ত্রুটি

ফায়ারফক্স ২0.0

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

সর্বাধিক গুরুত্বপূর্ণ পরীক্ষা নিখরচায় (অন্তত আমার জন্য): Node.js one। আমি এটা ক্রোম বেঞ্চমার্ক বন্ধ সন্দেহ।


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

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

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


বস্তু নোট ব্যবহার করে

var x = [];

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

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

'অনির্ধারিত' দিয়ে ভরা ...

var x = new Array(7);

zeros সঙ্গে obj নোটেশন

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

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

var x = new Array();

এবং

var y = [];

যারা প্রোটোটাইপ পরিবর্তন হবে

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


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

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

var zero = newFilledArray(maxLength, 0);

এবার এই অ্যারেটি টালি করুন প্রতিবার আপনার দৈর্ঘ্যের দৈর্ঘ্য ভরাট অ্যারে প্রয়োজন । দৈর্ঘ্য < maxLength :

zero.slice(0, requiredLength);

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


lodash বা underscore ব্যবহার করে

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

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

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

new Array(51).join('0').split('') সম্পর্কে কি new Array(51).join('0').split('') ?


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

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

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

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

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

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++;
}

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

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

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

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

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


Phpjs সমাধান সবসময় আছে, যা আপনি এখানে খুঁজে পেতে পারেন:

http://phpjs.org/functions/array_fill/

আমি প্রকল্পের জন্য কথা বলতে পারছি না (পুরো জাভাস্ক্রিপ্ট ফাংশনগুলির একটি লাইব্রেরি তৈরি যা ফোরামের আরও কার্যকারিতা মিরর করে), কিন্তু আমি যেখান থেকে ব্যক্তিগতভাবে টেনেছি তার কয়েকটি ফাংশন একটি চ্যাম্পের মত কাজ করেছে।


উত্তরগুলিতে এই পদ্ধতিটি দেখিনি, তাই এখানে এটি হল:

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

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

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

আমি এই কোডটির কর্মক্ষমতা সম্পর্কে নিশ্চিত নই, তবে এটি অপেক্ষাকৃত ছোট অ্যারেগুলির জন্য ব্যবহার করলে এটি একটি সমস্যা হতে পারে না।


যে দ্রুততম উপায় জন্য প্রতিটি সঙ্গে হয় =)

(আমরা IE এর জন্য পশ্চাদপট সামঞ্জস্য রাখি <9)

var fillArray = Array.prototype.forEach
    ? function(arr, n) {
         arr.forEach(function(_, index) { arr[index] = n; });
         return arr;
      }
    : function(arr, n) {
         var len = arr.length;
         arr.length = 0;
         while(len--) arr.push(n);
         return arr;
      };

// test
fillArray([1,2,3], 'X'); // => ['X', 'X', 'X']

concatক্রোমে আমার পরীক্ষাগুলিতে এই সংস্করণটি আরও দ্রুত (2013-03-21)। প্রায় 100ms 10,000,000 উপাদান বনাম সরাসরি 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('');
}

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

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;
  };
}

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

new Array(7).fill(0) //Array with 7 zeros.






arrays