2 (ES6)

যে কেউ এটা প্রয়োজন ...

এই থ্রেডে @ উত্তর উত্তরটি সম্পূর্ণ করতে, যদি আপনি স্প্রেড সিনট্যাক্স ব্যবহার করে একটি গতিশীল পরিবর্তনশীল অপসারণ করতে চান তবে আপনি এটি এমনভাবে করতে পারেন:

const key = 'a';

const { [key]: foo, ...rest } = { a: 1, b: 2, c: 3 };

console.log(rest); // { b: 2, c: 3 }

* fooএর মান সহ একটি নতুন পরিবর্তনশীল হবে a(যা 1)।

আপডেট :
একটি বস্তুর থেকে একটি সম্পত্তি অপসারণ করার কয়েকটি সাধারণ উপায় আছে।
প্রতিটি এক এটি নিজস্ব পেশাদার এবং বিপরীত আছে ( এই কর্মক্ষমতা তুলনা চেক করুন ):

developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
পাঠযোগ্য এবং সংক্ষিপ্তdeveloper.mozilla.org/en-US/docs/Web/JavaScript/Reference/… , তবে এটির সর্বোত্তম পছন্দ নাও হতে পারে তবে এটির কার্যকারিতাটি অপ্টিমাইজ করা না থাকলেও এটি বেশ ভাল পছন্দ হতে পারে না।

delete obj[key];

Reassignment
চেয়ে 2x দ্রুততরdelete, তবে সম্পত্তিমুছে ফেলাহয়নাএবং পুনরাবৃত্তি করা যেতে পারে।

obj[key] = null;
obj[key] = false;
obj[key] = undefined;

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

{ [key]: val, ...rest } = obj;

খুব সহজ:

var myObject = {
    "ircEvent": "PRIVMSG",
    "method": "newURI",
    "regex": "^http://.*"
};

delete myObject.regex;

ড্যানের দাবি যে 'মুছে ফেলুন' খুব ধীর এবং তিনি পোস্ট করা বেঞ্চমার্ক সন্দেহ ছিল। তাই আমি নিজেই ক্রোম 59-এ পরীক্ষা চালাই। মনে হচ্ছে যে মুছে ফেলা প্রায় 30 বার ধীরে ধীরে হয়।

var iterationsTotal = 10000000;  // 10 million
var o;
var t1 = Date.now(),t2;
for (let i=0; i<iterationsTotal; i++) {
   o = {a:1,b:2,c:3,d:4,e:5};
   delete o.a; delete o.b; delete o.c; delete o.d; delete o.e;
}
console.log ((t2=Date.now())-t1);  // 6135
for (let i=0; i<iterationsTotal; i++) {
   o = {a:1,b:2,c:3,d:4,e:5};
   o.a = o.b = o.c = o.d = o.e = undefined;
}
console.log (Date.now()-t2);  // 205

মনে রাখবেন যে আমি অন্য অপারেশনগুলির দ্বারা সৃষ্ট প্রভাবটিকে কমিয়ে আনতে এক লুপ চক্রের মধ্যে একাধিক 'মুছে ফেলার' ক্রিয়াকলাপ পরিচালনা করেছি।

আপনি আপনার প্রশ্ন শিরোনাম ব্যবহার শব্দটি Remove a property from a JavaScript object , কিছু ভিন্ন উপায়ে ব্যাখ্যা করা যেতে পারে। এটি সম্পূর্ণ মেমরির জন্য এবং বস্তুর কীগুলির তালিকার জন্য বা অন্যটি কেবল আপনার বস্তুর থেকে অপসারণ করতে হয়। এটি অন্য কিছু উত্তর উল্লেখ করা হয়েছে, delete মূল শব্দটি মূল অংশ। আসুন আপনার মত আপনার বস্তু আছে বলুন:

myJSONObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};

যদি তুমি করো:

console.log(Object.keys(myJSONObject));

ফলাফল হবে:

["ircEvent", "method", "regex"]

আপনি আপনার অবজেক্ট কীগুলি থেকে নির্দিষ্ট কীটি মুছতে পারেন, যেমন:

delete myJSONObject["regex"];

তারপর আপনার অবজেক্ট কী Object.keys(myJSONObject) ব্যবহার করে হবে:

["ircEvent", "method"]

কিন্তু পয়েন্টটি যদি আপনার মেমরির যত্ন নেয় এবং আপনি পুরো বস্তুটিকে মেমরি থেকে সরিয়ে ফেলতে চান তবে এটি কী মুছে ফেলার আগে এটি নিলতে সেট করার প্রস্তাব দেওয়া হয়:

myJSONObject["regex"] = null;
delete myJSONObject["regex"];

এখানে অন্য গুরুত্বপূর্ণ পয়েন্ট একই বস্তুর আপনার অন্যান্য রেফারেন্স সম্পর্কে সতর্ক হতে হবে। উদাহরণস্বরূপ, যদি আপনি একটি পরিবর্তনশীল তৈরি করেন:

var regex = myJSONObject["regex"];

অথবা এটি অন্য বস্তুর নতুন পয়েন্টার হিসাবে যুক্ত করুন:

var myOtherObject = {};
myOtherObject["regex"] = myJSONObject["regex"];

এমনকি যদি আপনি এটি আপনার বস্তু থেকে মুছে ফেলেন তবে আমার নির্দিষ্ট myJSONObject মেমরি থেকে মুছে ফেলা হবে না, কারণ regex পরিবর্তনশীল এবং myOtherObject["regex"] এখনও তাদের মান আছে। তাহলে কিভাবে আমরা নিশ্চিত করতে মেমরি থেকে বস্তু অপসারণ করতে পারে?

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

এই ক্ষেত্রে আপনি যে বস্তুটি সরাতে পারবেন না কারণ আপনি একটি var বিবৃতির মাধ্যমে regex পরিবর্তনশীল তৈরি করেছেন এবং যদি আপনি করেন:

delete regex; //False

ফলাফল false , যার অর্থ আপনার মুছে ফেলা বিবৃতিটি প্রত্যাশিত হিসাবে কার্যকর করা হয়নি। কিন্তু যদি আপনি আগে এই পরিবর্তনশীলটি তৈরি করেন নি, এবং আপনার শেষ বিদ্যমান রেফারেন্স হিসাবে আপনি শুধুমাত্র আমার myOtherObject["regex"] , তবে আপনি এটি মুছে ফেলার মাধ্যমে এটি ঠিক করতে পারেন:

myOtherObject["regex"] = null;
delete myOtherObject["regex"];

অন্য কথায়, আপনার কোডটিতে কোনও রেফারেন্স অবশিষ্ট নেই এমন কোনও জাভাস্ক্রিপ্ট অবজেক্ট মারা যায় না।

আপডেট: ধন্যবাদ @ এজেন্টME:

এটি মুছে ফেলার আগে কোনও সম্পত্তিকে নিলতে সেট করা কোনও কাজ সম্পাদন করে না (যতক্ষণ না বস্তুটি Object.seal দ্বারা সিল হয়ে যায় এবং মুছে ফেলার ব্যর্থ হয়। এটি বিশেষভাবে কেস না হওয়া পর্যন্ত আপনি তা বিশেষভাবে চেষ্টা করেন না)।

আরও তথ্য পেতে Object.seal: Object.seal()

নিম্নলিখিত পদ্ধতি চেষ্টা করুন। Objectসম্পত্তি মান নির্ধারণ করুন undefined। তারপর stringifyবস্তু এবং parse।

 var myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};

myObject.regex = undefined;
myObject = JSON.parse(JSON.stringify(myObject));

console.log(myObject);

ধরুন আপনার কাছে এমন একটি বস্তু রয়েছে যা এই রকম দেখাচ্ছে:

var Hogwarts = {
    staff : [
        'Argus Filch',
        'Filius Flitwick',
        'Gilderoy Lockhart',
        'Minerva McGonagall',
        'Poppy Pomfrey',
        ...
    ],
    students : [
        'Hannah Abbott',
        'Katie Bell',
        'Susan Bones',
        'Terry Boot',
        'Lavender Brown',
        ...
    ]
};

একটি বস্তুর সম্পত্তি মুছে ফেলা হচ্ছে

আপনি যদি পুরো staffঅ্যারেটি ব্যবহার করতে চান তবে এটি করার সঠিক উপায়টি আপনাকে করতে হবে:

delete Hogwarts.staff;

অন্যথায়, আপনি এটিও করতে পারেন:

delete Hogwarts['staff'];

একইভাবে, সম্পূর্ণ ছাত্র অ্যারে মুছে ফেলার মাধ্যমে কল delete Hogwarts.students;বা করা হবেdelete Hogwarts['students']; ।

একটি অ্যারে সূচক মুছে ফেলা হচ্ছে

এখন, যদি আপনি একটি স্টাফ সদস্য বা ছাত্রকে সরাতে চান তবে পদ্ধতিটি একটু আলাদা, কারণ উভয় বৈশিষ্ট্যগুলি অ্যারে নিজেদের।

আপনি যদি আপনার স্টাফ সদস্যের সূচকটি জানেন তবে আপনি কেবল এটি করতে পারেন:

Hogwarts.staff.splice(3, 1);

যদি আপনি সূচীটি জানেন না, তবে আপনাকে একটি সূচী অনুসন্ধান করতে হবে:

Hogwarts.staff.splice(Hogwarts.staff.indexOf('Minerva McGonnagall') - 1, 1);

বিঃদ্রঃ

আপনি টেকনিক্যালি deleteএকটি অ্যারের জন্য ব্যবহার করতে পারেন , যখন এটি ব্যবহার করে Hogwarts.staff.lengthপরে উদাহরণ কল যখন ভুল ফলাফল পেতে হবে। অন্য কথায়, deleteউপাদান মুছে ফেলা হবে, কিন্তু এটি lengthসম্পত্তি মান আপডেট হবে না । ব্যবহার deleteকরে আপনার সূচী আপ জগাখিচুড়ি হবে।

সুতরাং, যখন কোনও বস্তুর মানগুলি মুছে ফেলার সময় সর্বদা প্রথমে বিবেচনা করুন যে আপনি বস্তুর বৈশিষ্ট্যগুলির সাথে ডিল করছেন কিনা বা আপনি অ্যারের মানগুলির সাথে ডিল করছেন কিনা এবং তার উপর ভিত্তি করে উপযুক্ত কৌশল নির্বাচন করুন।

আপনি যদি এটার সাথে পরীক্ষা করতে চান, তবে আপনি এই ফিডেলটি একটি প্রারম্ভিক বিন্দু হিসাবে ব্যবহার করতে পারেন ।

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

এই নতুন unsetফাংশনটি লেখার কারণটি হল হ্যাশ_ম্যাপের অন্যান্য সমস্ত ভেরিয়েবলের সূচী রাখা। নিম্নলিখিত উদাহরণটি দেখুন এবং দেখুন "test2" সূচী কীভাবে হ্যাশ_ম্যাপ থেকে একটি মান সরানোর পরে পরিবর্তন হয়নি।

function unset(unsetKey, unsetArr, resort){
  var tempArr = unsetArr;
  var unsetArr = {};
  delete tempArr[unsetKey];
  if(resort){
    j = -1;
  }
  for(i in tempArr){
    if(typeof(tempArr[i]) !== 'undefined'){
      if(resort){
        j++;
      }else{
        j = i;
      }
      unsetArr[j] = tempArr[i];
    }
  }
  return unsetArr;
}

var unsetArr = ['test','deletedString','test2'];

console.log(unset('1',unsetArr,true)); // output Object {0: "test", 1: "test2"}
console.log(unset('1',unsetArr,false)); // output Object {0: "test", 2: "test2"}

ES6 ব্যবহার করে:

(ধ্বংসাত্মক + স্প্রেড অপারেটর)

    const myObject = {
      regex: "^http://.*",
      b: 2,
      c: 3
    };
    const { regex, ...noRegex } = myObject;
    console.log(noRegex); // => { b: 2, c: 3 }

আপনি কেবল deleteশব্দ ব্যবহার করে একটি বস্তুর কোনো সম্পত্তি মুছে ফেলতে পারেন ।

উদাহরণ স্বরূপ:

var obj = {key1:"val1",key2:"val2",key3:"val3"}

কোনও সম্পত্তি সরাতে key1, deleteএভাবে কীওয়ার্ড ব্যবহার করুন :

delete obj.key1

অথবা আপনি অ্যারে-মত নোটেশন ব্যবহার করতে পারেন:

delete obj[key1]

রেফারেন্সঃ developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… ।

হ্যালো আপনি এই সহজ একটি সাজানোর চেষ্টা করতে পারেন

var obj = [];

obj.key1 = {name: "John", room: 1234};
obj.key2 = {name: "Jim", room: 1234};

delete(obj.key1);

অপারেটর delete অপ্রত্যাশিতভাবে ধীর!

benchmark তাকান।

মুছে ফেলুন কোনও অবশিষ্টাংশ ছাড়াই বস্তুর বৈশিষ্ট্যগুলি মুছে ফেলার একমাত্র সত্য উপায়, তবে এটি "বিকল্প", সেটিং object[key] = undefined তুলনায় ~ 100 গুণ object[key] = undefined ।

এই বিকল্পটি সঠিক প্রশ্নের উত্তর নয়! কিন্তু, যদি আপনি এটি যত্ন সহ ব্যবহার করেন তবে আপনি কিছু অ্যালগরিদমগুলি নাটকীয়ভাবে গতিতে করতে পারেন। আপনি loops delete ব্যবহার করছেন এবং আপনি কর্মক্ষমতা সঙ্গে সমস্যা আছে, verbose ব্যাখ্যা পড়ুন।

যখন একটি delete ব্যবহার করা উচিত এবং যখন undefined মান সেট করা?

একটি বস্তু কী-মান জোড়াগুলির একটি সেট হিসাবে দেখা যেতে পারে। আমি যেটিকে 'মান' বলি তা একটি আদিম বা অন্যান্য বস্তুর একটি রেফারেন্স, যা 'কী' সংযুক্ত।

delete , আপনি যখন কোনও নিয়ন্ত্রণের কোড না পেয়ে ফলাফল ফলাফলটি পাস করছেন (অথবা আপনি আপনার টিম বা নিজের সম্পর্কে নিশ্চিত না হন)।

এটি হাশম্যাপ থেকে কী মুছে ফেলে ।

 var obj = {
     field: 1     
 };
 delete obj.field;

আপনি কর্মক্ষমতা যত্ন যখন , undefined সেটিং ব্যবহার করুন । এটি আপনার কোড একটি গুরুতর অনুমোদন দিতে পারেন।

হাশম্যাপে তার অবস্থানটিতে কীটি অবশিষ্ট থাকে , শুধুমাত্র মানটি undefined প্রতিস্থাপিত হয়। বোঝার জন্য যে for..in লুপটি এখনও সেই কীটির উপর পুনরাবৃত্তি করবে।

 var obj = {
     field: 1     
 };
 obj.field = undefined;

এই পদ্ধতি ব্যবহার করে, সম্পত্তি অস্তিত্ব নির্ধারণ করার সমস্ত উপায় প্রত্যাশিত হিসাবে কাজ করবে না।

যাইহোক, এই কোড:

object.field === undefined

উভয় পদ্ধতির জন্য সমানভাবে আচরণ করবে।

টেস্ট

সংক্ষেপে, পার্থক্য সম্পত্তির অস্তিত্ব নির্ধারণের উপায় এবং for..in লুপ সম্পর্কে উপায়গুলি।

 console.log('* -> "Takes prototype inheritance into consideration, that means it lookups all over prototype chain too."');

 console.log(obj.field === undefined, 'obj.field === undefined', 'You get "undefined" value when querying for "field" in object-hashmap. *');

 console.log(obj["field"] === undefined, 'obj["field"] === undefined', 'Just another way to query (equivalent). *');

 console.log(typeof obj.field === "undefined", 'typeof obj.field === "undefined"', 'Get the value attached to "field" key, and check it\'s type is "undefined". *');

 console.log("field" in obj, '"field" in obj', 'This statement returns true if "field" key exists in the hashmap. False otherwise. *');

 console.log(obj.hasOwnProperty("field"), 'obj.hasOwnProperty("field")', 'This statement returns true if \'field\' key exists in the hashmap. The ONLY way NOT to lookup for property in the prototype chain!');
 //Object.keys().indexOf() is an overkill that runs much slower :)

 var counter = 0,
     key;
 for (key in obj) {
     counter++;
 }
 console.assert(counter === 0, 'counter === 0', '"field" is not iterated using "for .. in" loop. *');

মেমরি লিক সাবধান!

obj[prop] = undefined ব্যবহার করে obj[prop] = undefined delete obj[prop] চেয়ে দ্রুততর, অন্য গুরুত্বপূর্ণ বিবেচ্য বিষয় হল যে obj[prop] = undefined সবসময় উপযুক্ত নাও হতে পারে। delete obj[prop] মুছে delete obj[prop] থেকে prop এবং এটি মেমরি থেকে মুছে ফেলা হয় যখন obj[prop] = undefined সহজভাবে obj[prop] = undefined মান সেট করে যা মেমরিতে এখনও prop ছেড়ে দেয়। অতএব, যেখানে অনেকগুলি কী তৈরি এবং মুছে ফেলা হচ্ছে, obj[prop] = undefined ব্যবহার করে ব্যয়বহুল মেমরি পুনর্মিলন (পৃষ্ঠাটিকে স্থগিত করা) এবং সম্ভাব্য আউট-মেমরি ত্রুটিটি জোরদার করতে পারে। নিম্নলিখিত কোড পরীক্ষা করে দেখুন।

"use strict";
var theNodeList=[], i, current, numberOfNodes=65536, body=document.body, nodeRecords=[];
for (i = 0; i !== numberOfNodes; i++) {
    nodeRecords[i] = [];
    current = theNodeList[i] = document.createElement("div");
    current.textContent = i;
    document.body.appendChild( current );
}
var lastTime = -1;
requestAnimationFrame(function recordUpdates(){
    var currentTime = Math.round( performance.now()*1000 )
    for (i = 0; i !== numberOfNodes; i++) {
        if (lastTime !== -1) {
            // the previously collected data is no longer in use
            /*************************************************/
            /****/ nodeRecords[i][lastTime] = undefined; /****/
            /*************************************************/
        }
        nodeRecords[i][currentTime] = theNodeList[i].outerHTML;
    }
    lastTime = currentTime;
    requestAnimationFrame( recordUpdates );
});

উপরে কোডে, কেবল nodeRecords[i][lastTime] = undefined; করছেন nodeRecords[i][lastTime] = undefined; প্রতিটি অ্যানিমেশন ফ্রেম একটি বিশাল মেমরি লিক কারণ হবে। প্রতিটি ফ্রেম, 65536 ডিওএম উপাদানগুলি 65536 টি পৃথক স্লট নিয়ে যাবে, তবে পূর্ববর্তী 65536 স্লটগুলি কেবলমাত্র অনির্দিষ্টভাবে সেট করা হবে যা তাদের স্মৃতিতে ঝুলন্ত ছেড়ে দেয়। এগিয়ে যান, কনসোলের উপরে কোডটি চালানোর চেষ্টা করুন এবং নিজের জন্য দেখুন। আউট-অফ-মেমরি ত্রুটি জোরদার করার পরে, কোডটির নিম্নোক্ত সংস্করণের ব্যতীত এটি পুনরায় চালানোর চেষ্টা করুন যা পরিবর্তে delete অপারেটর ব্যবহার করে।

"use strict";
var theNodeList=[], i, current, numberOfNodes=65536, body=document.body, nodeRecords=[];
for (i = 0; i !== numberOfNodes; i++) {
    nodeRecords[i] = [];
    current = theNodeList[i] = document.createElement("div");
    current.textContent = i;
    document.body.appendChild( current );
}
var lastTime = -1;
requestAnimationFrame(function recordUpdates(){
    var currentTime = Math.round( performance.now()*1000 )
    for (i = 0; i !== numberOfNodes; i++) {
        if (lastTime !== -1) {
            // the previously collected data is no longer in use
            /********************************************/
            /****/ delete nodeRecords[i][lastTime]; /****/
            /********************************************/
        }
        nodeRecords[i][currentTime] = theNodeList[i].outerHTML;
    }
    lastTime = currentTime;
    requestAnimationFrame( recordUpdates );
});

উপরে কোড স্নিপেট হিসাবে দেখা যায়, delete অপারেটর জন্য কিছু বিরল উপযুক্ত ব্যবহার ক্ষেত্রে আছে। তবে, এই সমস্যা সম্পর্কে খুব বেশি চিন্তা করবেন না। এটি শুধুমাত্র দীর্ঘ-জীবনকালের বস্তুর সাথে একটি সমস্যা হয়ে উঠবে যা নতুন কীগুলিকে ক্রমাগত যুক্ত করে। অন্য কোন ক্ষেত্রে (যা রিয়েল-ওয়ার্ল্ড প্রোগ্রামিং এর প্রায় প্রতিটি ক্ষেত্রে), এটি obj[prop] = undefined ব্যবহার করার পক্ষে সবচেয়ে উপযুক্ত। এই বিভাগের মূল উদ্দেশ্যটি কেবল আপনার মনোযোগে আনতে হবে যাতে আপনার কোডে এটি একটি সমস্যা হয়ে দাঁড়ায়, তারপরে আপনি সমস্যাটিকে আরও সহজেই বুঝতে পারেন এবং এইভাবে আপনার কোডটি সনাক্ত করার জন্য ঘন্টাটি বিচ্ছিন্ন করতে হবে না এবং এই সমস্যা বুঝতে।

সর্বদা undefined সেট করবেন না

জাভাস্ক্রিপ্টের একটি দিক যা বিবেচনা করা গুরুত্বপূর্ণ তা হল পলিমারফিজম। পলিমারফিজম যখন একই পরিবর্তনশীল / স্লট-ইন-অ-অবজেক্টটি বিভিন্ন ধরণের নিচের হিসাবে দেখানো হয়।

var foo = "str";
foo = 100;          // variable foo is now labeled polymorphic by the browser
var bar = ["Some", "example"];
bar[2] = "text";    // bar is a monomorphic array here because all its entries have the
                    // same type: string primitive
bar[1] = undefined; // bar is now a polymorphic array

তবে, পলিমারফিক অ্যারেগুলির সাথে দুটি বড় অফলাইন সমস্যা রয়েছে:

1. তারা ধীর এবং মেমরি অকার্যকর। একটি নির্দিষ্ট সূচী অ্যাক্সেস করার সময়, কেবল অ্যারের জন্য বিশ্বব্যাপী টাইপ পাওয়ার পরিবর্তে, ব্রাউজারটিকে প্রতি-সূচক ভিত্তিতে টাইপ পেতে হবে যার ফলে প্রতিটি সূচক তার টাইপের অতিরিক্ত মেটাডেটা সঞ্চয় করে।
2. একবার polymorphic, সবসময় polymorphic। যখন একটি অ্যারে polymorphic করা হয়, ওয়েবকিট ব্রাউজারে polymorphism পূর্বাবস্থায় ফেরানো যাবে না। সুতরাং, যদি আপনি একটি পলিমারফিক অ্যারে অ-পলিমোফিক হিসাবে পুনরুদ্ধার করেন তবে এটি এখনও পলিমারফিক অ্যারের হিসাবে ব্রাউজার দ্বারা সংরক্ষণ করা হবে।

এক পলিমারফিজম একটি ড্রাগ আসক্তি থেকে তুলনা করতে পারে। প্রথম নজরে, এটি awesomely লাভজনক বলে মনে হচ্ছে: চমৎকার সুন্দর fluffy কোড। তারপর, কোডার polymorphism ড্রাগ তাদের অ্যারে প্রবর্তন। তাত্ক্ষণিকভাবে, পলিমোফিক অ্যারে কম দক্ষ হয়ে ওঠে, এবং এটি ড্রাগযুক্ত হওয়ার আগে এটি আগের মতো দক্ষ হয়ে উঠতে পারে না। আসল জীবনে এ ধরনের পরিস্থিতির সাথে সম্পর্কযুক্ত করার জন্য, কোকেনের কেউ হয়তো সহজ দরজা হ্যান্ডেল পরিচালনা করতে সক্ষম নাও হতে পারে, পিআই এর সংখ্যা গণনা করতে সক্ষম হবেন না। অনুরূপভাবে, পলিমোফিজিজমের মাদকের একটি অ্যারে কখনও একটি মোনোমর্ফিক অ্যারে হিসাবে কার্যকর হতে পারে না।

কিন্তু কিভাবে একটি ড্রাগ ট্রিপ উপমা delete অপারেশন সম্পর্কিত? উত্তর উপরের স্নিপেটে কোডের শেষ লাইনকে অস্বীকার করে। সুতরাং এটি একটি মোড়ক সঙ্গে এই সময়, reexamined করা যাক।

var bar = ["Some", "example"];
bar[2] = "text";    // bar is not a polymorphic array here because all its entries have the
                    // same type: string primitive
bar[1] = "";        // bar is still a monomorphic array
bar[1] = undefined; // bar is now a polymorphic array

কর। bar[1] = "" পলিমারফিজমকে বজায় রাখে না যখন bar[1] = undefined করে। অতএব, সর্বদা যখনই সম্ভব তাদের বস্তুর জন্য সংশ্লিষ্ট ধরনের ব্যবহার করা উচিত যাতে দুর্ঘটনাক্রমে পলিমারফিজম না হয়। এমন একজন ব্যক্তি নিম্নোক্ত তালিকাটি তাদের যাওয়ার জন্য সাধারণ রেফারেন্স হিসাবে ব্যবহার করতে পারেন। তবে, নীচের ধারনা স্পষ্টভাবে ব্যবহার করবেন না দয়া করে। পরিবর্তে, আপনার কোড জন্য ভাল কাজ যাই হোক না কেন ব্যবহার করুন।

• বুলিয়ান আদিমতে টাইপ করা একটি অ্যারে / পরিবর্তনশীল ব্যবহার করার সময়, খালি মান হিসাবে false বা undefined ব্যবহার করুন। অপ্রয়োজনীয় পলিমারফিজম এড়ানো ভাল, আপনার সব কোড পুনর্বিবেচনা করা স্পষ্টভাবে নিষিদ্ধ করার জন্য এটি আসলে কার্যক্ষমতা হ্রাস হতে পারে সম্ভবত। সাধারণ রায় ব্যবহার করুন!
• একটি অ্যারে / পরিবর্তনশীল ব্যবহার করে সংখ্যা আদিম টাইপ করা হলে, খালি মান হিসাবে 0 ব্যবহার করুন। মনে রাখবেন অভ্যন্তরীণভাবে দুটি ধরণের সংখ্যা রয়েছে: দ্রুত পূর্ণসংখ্যা (2147483647 থেকে -2147483648 অন্তর্ভুক্ত) এবং ধীর ভাসমান বিন্দু ডাবলস ( NaN এবং Infinity সহ অন্যান্য কিছু)। যখন একটি পূর্ণসংখ্যা দ্বিগুণ হয়, এটি একটি পূর্ণসংখ্যা ফিরে উন্নীত করা যাবে না।
• স্ট্রিং আদিম টাইপ করা একটি অ্যারে / পরিবর্তনশীল ব্যবহার করার সময়, খালি মান হিসাবে "" ব্যবহার করুন।
• একটি চিহ্ন ব্যবহার করার সময়, অপেক্ষা করুন, আপনি একটি প্রতীক ব্যবহার করছেন কেন?!?! পারফরম্যান্সের জন্য প্রতীক খারাপ juju হয়। প্রতীক ব্যবহার করার জন্য সব কিছু প্রতীক চিহ্ন ব্যবহার না করার জন্য পুনরায় প্রোগ্রাম করা যেতে পারে, যার ফলে প্রতীক ছাড়া দ্রুত কোড তৈরি হয়। প্রতীক সত্যিই মাত্র অক্ষম মেটা চিনি হয়।
• অন্য কিছু ব্যবহার করার সময়, null ব্যবহার করুন।

তবে, সতর্ক থাকুন! হঠাৎ করে আপনার সমস্ত পূর্ববর্তী কোডের সাথে এটি করা শুরু করবেন না কারণ এটি সম্ভবত পূর্বরূপ কোডটি ভাঙবে এবং / অথবা অদ্ভুত বাগগুলি পরিচয় দেবে। পরিবর্তে, এই কার্যকর অনুশীলনকে শুরু থেকে বাস্তবায়ন করতে হবে এবং পূর্বনির্ধারিত কোড রূপান্তর করার সময়, এটি প্রস্তাব করা হয় যে আপনি পুরোনো কোডটিকে এই নতুন অনুশীলনে আপগ্রেড করার চেষ্টা করার সাথে সাথে সম্পর্কিত সমস্ত লাইন, দ্বিগুণ, ত্রিভুজ, চতুর্ভুজ পরীক্ষা করতে পারেন এটা ঝুঁকিপূর্ণ হিসাবে ঝুঁকিপূর্ণ।

জাভাস্ক্রিপ্ট সম্পত্তি সম্পত্তি অপসারণ

এই পৃষ্ঠায় উপস্থাপিত অনেকগুলি বিকল্প রয়েছে, কারণ বেশিরভাগ বিকল্পগুলি ভুল নয়-নাকি উত্তরগুলির সদৃশ হয়-কিন্তু যথাযথ কৌশলটি আপনার অবস্থার উপর নির্ভর করে এবং আপনি এবং / অথবা আপনার কাজগুলির লক্ষ্যগুলির উপর নির্ভর করে দল পরিপূর্ণ করার চেষ্টা করছেন। আপনি স্পষ্টভাবে প্রশ্ন উত্তর দিতে, এক জানা প্রয়োজন:

1. আপনি লক্ষ্য করছেন ECMAScript সংস্করণ
2. অবজেক্ট প্রকারের পরিসর যা আপনি সম্পত্তিগুলি সরাতে চান এবং আপনি যে ধরনের সম্পত্তি নামগুলি বাদ দিতে চান তা বাদ দিতে চান (শুধুমাত্র স্ট্রিংগুলি? প্রতীক? দুর্বল রেফারেন্সগুলি ইচ্ছাকৃত বস্তু থেকে ম্যাপ করা হয়েছে? এগুলি এখন জাভাস্ক্রিপ্টগুলিতে বহু বছর ধরে সম্পত্তি পয়েন্টারগুলির মতো )
3. আপনি এবং আপনার দলের ব্যবহার প্রোগ্রামিং প্রোগ্রামিং / নিদর্শন। আপনি কি কার্যকরী পন্থাগুলি এবং মিউটেশনটি আপনার টিমের ক্রিয়াপদ সমর্থন করেন বা আপনি বন্য পশ্চিমা পরিবর্তনশীল অবজেক্ট-ভিত্তিক কৌশলগুলি কাজে লাগান?
4. আপনি কি এটি বিশুদ্ধ জাভাস্ক্রিপ্টে অর্জন করতে চান নাকি আপনি তৃতীয় পক্ষের লাইব্রেরি ব্যবহার করতে ইচ্ছুক?

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

পরিবর্তনশীল বস্তু সম্পত্তি মুছে ফেলার, অনিরাপদ

যখন আপনি মূল রেফারেন্সটি ধরে রাখতে চান / অবিরত রাখতে চান এবং আপনার কোডটিতে স্থিতিহীন কার্যকরী নীতিগুলি ব্যবহার করেন না তখন এই বিভাগটি বস্তুর আক্ষরিক বা বস্তুর দৃষ্টিকোণগুলিতে অপারেটিংয়ের জন্য। এই বিভাগে সিনট্যাক্সের একটি উদাহরণ টুকরা:

'use strict'
const iLikeMutatingStuffDontI = { myNameIs: 'KIDDDDD!', [Symbol.for('amICool')]: true }
delete iLikeMutatingStuffDontI[Symbol.for('amICool')] // true
Object.defineProperty({ myNameIs: 'KIDDDDD!', 'amICool', { value: true, configurable: false })
delete iLikeMutatingStuffDontI['amICool'] // throws

এই বিভাগটি প্রাচীনতম, সবচেয়ে সহজবোধ্য এবং সম্পত্তি অপসারণের সর্বাধিক ব্যাপকভাবে সমর্থিত বিভাগ। এটি Symbolস্ট্রিং ছাড়াও এবং অ্যারে সূচীগুলিকে সমর্থন করে এবং প্রথম সংস্করণ ব্যতীত জাভাস্ক্রিপ্টের প্রতিটি সংস্করণে কাজ করে। যাইহোক, এটি পরিবর্তনমূলক কিছু প্রোগ্রামিং নীতি লঙ্ঘন করে এবং কর্মক্ষমতা প্রভাব আছে। developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… ব্যবহৃত হলে এটি অসংগত ব্যতিক্রমগুলিতেও developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… ।

বিশ্রাম ভিত্তিক স্ট্রিং সম্পত্তি ভঙ্গি

এই বিভাগটি একটি নন-মিউটেশিয়াল পদ্ধতির পছন্দসই হওয়ার সময় নতুন ECMAScript স্বাদে প্লেইন অবজেক্ট বা অ্যারে ইনস্ট্যান্সের জন্য অপারেটিংয়ের জন্য এবং আপনাকে প্রতীক কীগুলির জন্য অ্যাকাউন্টের দরকার নেই:

const foo = { name: 'KIDDDDD!', [Symbol.for('isCool')]: true }
const { name, ...coolio } = foo // coolio doesn't have "name"
const { isCool, ...coolio2 } = foo // coolio2 has everything from `foo` because `isCool` doesn't account for Symbols :(

পরিবর্তনশীল বস্তু সম্পত্তি মুছে ফেলার, নিরাপদ

অনির্বাচিত বৈশিষ্ট্যগুলিতে ব্যতিক্রমগুলি ছাড়াই সুরক্ষা দেওয়ার সময় আপনি যখন মূল রেফারেন্স ব্যবহার করতে চান / ধরে রাখতে চান তখন অবজেক্ট লিটারাল বা বস্তুর দৃষ্টান্তগুলিতে অপারেটিংয়ের জন্য এই বিভাগটি:

'use strict'
const iLikeMutatingStuffDontI = { myNameIs: 'KIDDDDD!', [Symbol.for('amICool')]: true }
Reflect.deleteProperty(iLikeMutatingStuffDontI, Symbol.for('amICool')) // true
Object.defineProperty({ myNameIs: 'KIDDDDD!', 'amICool', { value: true, configurable: false })
Reflect.deleteProperty(iLikeMutatingStuffDontI, 'amICool') // false

উপরন্তু, স্থান পরিবর্তন করার সময় বস্তুগুলি বিন্যস্ত নয়, আপনি Reflect.deletePropertyআংশিক অ্যাপ্লিকেশন এবং deleteবিবৃতিগুলির সাথে সম্ভব নয় এমন অন্যান্য কার্যকরী কৌশলগুলি করতে কার্যকরী প্রকৃতি ব্যবহার করতে পারেন ।

সিনট্যাক্স-ভিত্তিক স্ট্রিং সম্পত্তি বর্ধিতকরণ

এই বিভাগটি একটি নন-মিউটেশিয়াল পদ্ধতির পছন্দসই হওয়ার সময় নতুন ECMAScript স্বাদে প্লেইন অবজেক্ট বা অ্যারে ইনস্ট্যান্সের জন্য অপারেটিংয়ের জন্য এবং আপনাকে প্রতীক কীগুলির জন্য অ্যাকাউন্টের দরকার নেই:

const foo = { name: 'KIDDDDD!', [Symbol.for('isCool')]: true }
const { name, ...coolio } = foo // coolio doesn't have "name"
const { isCool, ...coolio2 } = foo // coolio2 has everything from `foo` because `isCool` doesn't account for Symbols :(

লাইব্রেরী ভিত্তিক সম্পত্তি বিলোপ

এই বিভাগটি সাধারণত আরও কার্যকরী নমনীয়তার জন্য, প্রতীকগুলির জন্য অ্যাকাউন্টিং সহ এবং এক বিবৃতিতে একাধিক সম্পত্তি বাদ দেওয়ার অনুমতি দেয়:

const o = require("lodash.omit")
const foo = { [Symbol.for('a')]: 'abc', b: 'b', c: 'c' }
const bar = o(foo, 'a') // "'a' undefined"
const baz = o(foo, [ Symbol.for('a'), 'b' ]) // Symbol supported, more than one prop at a time, "Symbol.for('a') undefined"

ramda#dissoc ব্যবহার করে আপনি বৈশিষ্ট্য ছাড়া একটি নতুন বস্তু পাবেন regex:

const newObject = R.dissoc('regex', myObject);
// newObject !== myObject

আপনি একই প্রভাব অর্জন করতে অন্যান্য ফাংশন ব্যবহার করতে পারেন - বাদ, পিক, ...

ডিলিট পদ্ধতি ব্যবহার করে এটি করার সবচেয়ে ভাল উপায়, MDN বিবরণ অনুসারে, মুছে ফেলার অপারেটর একটি বস্তুর থেকে একটি সম্পত্তি মুছে ফেলে। সুতরাং আপনি সহজভাবে লিখতে পারেন:

delete myObject.regex;
// OR
delete myObject['regex'];

মুছে ফেলার অপারেটর একটি বস্তুর থেকে একটি প্রদত্ত সম্পত্তি মুছে ফেলে। সফল মুছে ফেলা হলে, এটি সত্য ফিরে আসবে, অন্যথায় মিথ্যা ফেরত পাঠানো হবে। তবে, নিম্নলিখিত পরিস্থিতিতে বিবেচনা করা গুরুত্বপূর্ণ:

• যদি আপনি যে সম্পত্তিটি মুছে ফেলার চেষ্টা করছেন তা বিদ্যমান নেই, মুছে ফেলার কোনো প্রভাব নেই এবং সত্য ফিরে আসবে

• যদি একই নামের একটি সম্পত্তি বস্তুর প্রোটোটাইপ শৃঙ্খলে বিদ্যমান থাকে, তবে, মুছে ফেলার পরে, বস্তুটি প্রোটোটাইপ শৃঙ্খলে সম্পত্তিটি ব্যবহার করবে (অন্য কথায়, মুছে ফেলা শুধুমাত্র নিজের বৈশিষ্ট্যগুলির উপর প্রভাব ফেলবে)।

• Var সহ ঘোষণা করা কোনও সম্পত্তি গ্লোবাল সুযোগ থেকে বা ফাংশন এর সুযোগ থেকে মুছে ফেলা যাবে না।

• যেমন, মুছে ফেলুন গ্লোবাল স্কোপে কোনও ফাংশন মুছে ফেলতে পারে না (এটি একটি ফাংশন সংজ্ঞা বা একটি ফাংশন (এক্সপ্রেশন) থেকে অংশযুক্ত কিনা।

• কার্যাবলী যা একটি বস্তুর অংশ (
  বৈশ্বিক সুযোগ ব্যতীত) মুছে ফেলার মাধ্যমে মুছে ফেলা যেতে পারে।

• লেট বা কনস্টেবল দিয়ে ঘোষণা করা কোনও সম্পত্তিকে তারা যে সংজ্ঞায়িত করা হয়েছিল তার থেকে মুছে ফেলা যাবে না। অ-কনফিগারযোগ্য বৈশিষ্ট্য মুছে ফেলা যাবে না। এতে অন্তর্নির্মিত অবজেক্টের বৈশিষ্ট্য অন্তর্ভুক্ত রয়েছে যেমন ম্যাথ, অ্যারে, অবজেক্ট এবং বৈশিষ্ট্যাবলী যা Object.defineProperty () হিসাবে পদ্ধতিগুলির সাথে অ-কনফিগারযোগ্য হিসাবে তৈরি করা হয়।

নিম্নলিখিত স্নিপেট আরেকটি সহজ উদাহরণ দেয়:

var Employee = {
      age: 28,
      name: 'abc',
      designation: 'developer'
    }
    
    console.log(delete Employee.name);   // returns true
    console.log(delete Employee.age);    // returns true
    
    // When trying to delete a property that does 
    // not exist, true is returned 
    console.log(delete Employee.salary); // returns true

আরো তথ্যের জন্য এবং আরো উদাহরণ দেখার জন্য, নীচের লিঙ্কে যান:

developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…

Object.assign () এবং Object.keys () এবং Array.map ()

const obj = {
    "Filters":[
        {
            "FilterType":"between",
            "Field":"BasicInformationRow.A0",
            "MaxValue":"2017-10-01",
            "MinValue":"2017-09-01",
            "Value":"Filters value"
        }
    ]
};

let new_obj1 = Object.assign({}, obj.Filters[0]);
let new_obj2 = Object.assign({}, obj.Filters[0]);

/*

// old version

let shaped_obj1 = Object.keys(new_obj1).map(
    (key, index) => {
        switch (key) {
            case "MaxValue":
                delete new_obj1["MaxValue"];
                break;
            case "MinValue":
                delete new_obj1["MinValue"];
                break;
        }
        return new_obj1;
    }
)[0];


let shaped_obj2 = Object.keys(new_obj2).map(
    (key, index) => {
        if(key === "Value"){
            delete new_obj2["Value"];
        }
        return new_obj2;
    }
)[0];


*/


// new version!

let shaped_obj1 = Object.keys(new_obj1).forEach(
    (key, index) => {
        switch (key) {
            case "MaxValue":
                delete new_obj1["MaxValue"];
                break;
            case "MinValue":
                delete new_obj1["MinValue"];
                break;
            default:
                break;
        }
    }
);

let shaped_obj2 = Object.keys(new_obj2).forEach(
    (key, index) => {
        if(key === "Value"){
            delete new_obj2["Value"];
        }
    }
);

পুরাতন প্রশ্ন, আধুনিক উত্তর। বস্তু ধ্বংসকারী ব্যবহার করে, একটি ECMAScript 6 বৈশিষ্ট্য, এটি ECMAScript 6 সহজ:

const { a, ...rest } = { a: 1, b: 2, c: 3 };

অথবা প্রশ্ন নমুনা সঙ্গে:

const myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
const { regex, ...newObject } = myObject;
console.log(newObject);

আপনি Babel চেষ্টা-আউট সম্পাদক এ এটি অ্যাকশন দেখতে পারেন।

সম্পাদনা:

একই পরিবর্তনশীল পুনরায় Assign, একটি let ব্যবহার করুন:

let myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
({ regex, ...myObject } = myObject);
console.log(myObject);

2018-07-21 আপডেট করুন: দীর্ঘকাল ধরে, আমি এই উত্তর সম্পর্কে বিব্রত বোধ করেছি, তাই আমার মনে হয় সময়টা একটু স্পর্শ করে। এই উত্তরের অপ্রত্যাশিত দীর্ঘ এবং দৃঢ় অংশ পড়ার দ্রুত গতিতে সাহায্য করার জন্য সামান্য ভাষ্য, ব্যাখ্যা, এবং বিন্যাস।

সংক্ষিপ্ত সংস্করণ

প্রশ্নের প্রকৃত উত্তর

অন্যদের বলেছেন, আপনি delete ব্যবহার করতে পারেন।

obj // {"foo": "bar"}
delete obj["foo"]
obj // {}
obj["foo"] // undefined

সমান সমান

একটি অ্যারে থেকে delete না। পরিবর্তে Array.prototype.splice ব্যবহার করুন।

arr // [1,2,3,4,5]
arr.splice(3,1); // 4
arr // [1,2,3,5]

দীর্ঘ সংস্করণ

জাভাস্ক্রিপ্ট একটি OOP ভাষা, তাই সবকিছু অ্যারে সহ একটি বস্তু ,. সুতরাং, আমি একটি বিশেষ সতর্কতা নির্দেশ করা প্রয়োজন বোধ করি।

অ্যারেতে, প্লেইন পুরোনো বস্তুর বিপরীতে, null আকারে আবর্জনাগুলি পেছনে delete , অ্যারের একটি "গর্ত" তৈরি করুন।

var array = [1, 2, 3, 4];
delete array[2];
/* Expected result --> [1, 2, 4]
 * Actual result   --> [1, 2, null, 4]
 */

আপনি দেখতে পারেন হিসাবে, delete সবসময় এক হিসাবে আশা করতে পারে না কাজ করে। মান overwritten, কিন্তু মেমরি পুনরায় বরাদ্দ করা হয় না। বলতে হয়, array[4] array[3] স্থানান্তর করা হয় না array[3] । যা Array.prototype.unshift এর বিপরীতে Array.prototype.unshift , যা অ্যারের প্রারম্ভে একটি উপাদান সন্নিবেশ করে এবং সবকিছুকে উপরে সরিয়ে দেয় ( array[0] array[1] হয়ে যায় array[1] , ইত্যাদি)

নিঃসন্দেহে, undefined পরিবর্তে নিল থেকে সরানো থেকে বিরত থাকা - যা বৈধভাবে অদ্ভুত - এই আচরণটি বিস্ময়কর হওয়া উচিত নয় , যেহেতু delete একটি অবিচ্ছিন্ন অপারেটর, typeof মতো, এটি ভাষাতে typeof উষ্ণ এবং যত্নশীল নয় বস্তুর ধরন সম্পর্কে এটি ব্যবহার করা হচ্ছে, যেখানে Array Object একটি উপশ্রেণী যা বিশেষভাবে অ্যারের সাথে কাজ করার জন্য ডিজাইন করা হয়েছে । তাই অ্যারে পুনরায় বদলানোর জন্য একটি বিশেষ কেস রান্না করার জন্য delete কোনও ভাল কারণ নেই, কারণ এটি কেবল অপ্রয়োজনীয় কাজের সাথে কিছুটা ধীর করে তুলবে। বিপরীত দিকে, আমার প্রত্যাশা অবাস্তব ছিল।

অবশ্যই, এটা আমাকে অবাক করেছে। কারণ আমি "খালি আবর্জনা" বিরুদ্ধে আমার ক্রুসেডকে ন্যায্যতা দেওয়ার জন্য এটি লিখেছি:

বিপদ এবং সমস্যাগুলি নিঃশব্দে অন্তর্নিহিত সমস্যাগুলিকে অগ্রাহ্য করে, এবং স্থানটি নষ্ট হয়ে যায়, অ্যারের সুনির্দিষ্ট হওয়ার প্রয়োজন হলে এটি সমস্যাযুক্ত হতে পারে।

কোনটি নিল s থেকে পরিত্রাণ পেতে একটি ভয়ানক যুক্তিযুক্ত - null শুধুমাত্র বিপজ্জনকভাবে ব্যবহৃত হলে বিপজ্জনক, এবং এটি "নির্ভুলতা" এর সাথে কিছু করার নেই। অ্যারে থেকে আপনি delete না এমন আসল কারণটি হ'ল চারপাশে আবর্জনা-ভরা এবং নোংরা ডেটা কাঠামোগুলি হ্রাস করা মাতাল এবং বাগ-প্রবণ।

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

... এটা বোকা, আমি জানি।

কনড্রিভড এবং লম্বা বাতাসের পিডিপি -11 দৃশ্য

উদাহরণস্বরূপ, আপনি একটি ওয়েবপৃষ্ঠা তৈরি করছেন যা একটি স্ট্রিংয়ে 'ট্যাব' এর জন্য ব্যবহৃত অ্যারে সংরক্ষণ করতে JSON-serialization ব্যবহার করে। (এই ক্ষেত্রে, localStorage )। আসুন এটিও বলি যে কোডটি অ্যারের সদস্যদের সংখ্যাসূচক সূচকগুলিকে স্ক্রিনে অঙ্কন করার সময় "শিরোনাম" এ ব্যবহার করে। কেন আপনি শুধু "শিরোনাম" সংরক্ষণের চেয়ে বরং এই করছেন? কারণ ... কারণ ।

ঠিক আছে, চলুন শুধু বলুন যে আপনি এই ব্যবহারকারীর অনুরোধে মেমরি সংরক্ষণ করার চেষ্টা করছেন যিনি 1 9 60 এর চলমান ইউনিক্স থেকে একটি পিডিপি -11 মিনিকম্পিউটার চালান এবং নিজের এলিংক-ভিত্তিক, জাভাস্ক্রিপ্ট-সঙ্গতিপূর্ণ, লাইন-প্রিন্টার-বান্ধব লিখেছেন। ব্রাউজারটি কারণ X11 প্রশ্নটির বাইরে ।

ক্রমবর্ধমান মূঢ় প্রান্ত-কেস দৃশ্যকল্প সরাইয়া, বলা অ্যারে delete ব্যবহার করে অ্যারে দূষিত দূষণ করা হবে, এবং সম্ভবত পরে অ্যাপ্লিকেশনের বাগগুলি ঘটবে। এবং যদি আপনি null চেক করেন তবে এটি সংখ্যাগুলিকে সরাসরি ছাড়বে যা ট্যাবগুলিকে র্যান্ডম করা হয়েছে [1] [2] [4] [5] ...

if (array[index] == null)
    continue;
else
    title = (index + 1).toString();
/* 0 -> "1"
 * 1 -> "2"
 * 2 -> (nothing)
 * 3 -> "4"
 */

হ্যাঁ, এটা অবশ্যই আপনি যা চেয়েছিলেন তা নয়।

এখন, আপনি j মতো দ্বিতীয় ইটারারেটর রাখতে পারেন যখন কেবলমাত্র অ্যারে থেকে বৈধ মানগুলি পড়তে হয়। কিন্তু যে null ইস্যু সমাধান করবে না, এবং আপনি এখনও যে troll পিডিপি -11 ব্যবহারকারী দয়া করে করতে হবে। আচ্ছা, তার কম্পিউটারে শেষ পূর্ণসংখ্যা রাখার জন্য পর্যাপ্ত মেমরি নেই _{(তিনি কোন পরিবর্তনশীল-প্রস্থের অ্যারে পরিচালনা করতে কীভাবে জিজ্ঞাসা করবেন না ...)} ।

সুতরাং, তিনি আপনাকে ক্রোধে একটি ইমেল পাঠান:

Hey, your webapp broke my browser! I checked my localStorage database after your stupid code made my browser segfault, and this is what I found:

>"tabs:['Hello World', 'foo bar baz', null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, ... ]"

After clearing my precious data, it segfaulted again, and I did a backtrace, and what do I find? WHAT DO I FIND!? YOU USE TOO MANY VARIABLES!

>var i = index;
>var j = 1;

Grr, I am angry now.
-Troll Davidson

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

সমাধান: Array.prototype.splice

সৌভাগ্যবশত, অ্যারে Array.prototype.splice() মুছে ফেলার এবং মেমরি Array.prototype.splice() করার জন্য একটি বিশেষ পদ্ধতি আছে: Array.prototype.splice() । আপনি এই মত কিছু লিখতে পারে:

Array.prototype.remove = function(index){
  this.splice(index,1);
}
...
array = [1, 2, 3, 4];
array.remove(2);
// Result -> [1, 2, 4]

এবং ঠিক মত, আপনি মিঃ পিডিপি -11 খুশি। হুররে! _{(আমি এখনও তাকে বলতে চাই, যদিও ...)}

Array.prototype.splice বনাম Array.prototype.slice বনাম

আমি উভয় একই নামযুক্ত ফাংশন মধ্যে পার্থক্য নির্দেশ করা গুরুত্বপূর্ণ, তারা উভয় খুব দরকারী হিসাবে।

Array.prototype.splice (শুরু, এন)

.splice() অ্যারে পরিবর্তন করে এবং সরানো সূচকগুলি ফেরত দেয়। অ্যারের সূচী থেকে শুরু কাটা হয়, start , এবং n উপাদান কাটা হয়। যদি n অনির্দিষ্ট হয়, start হওয়ার পরে সমগ্র অ্যারে বাদ দেওয়া হয় ( n = array.length - start )।

let a = [5,4,3,2,1];
let chunk = a.splice(2,2);

// a     [5,4,3,2,1]
// start  0 1 2 - -
// n      - - 1 2 -

chunk; // [3,2]
a;     // [5,4,1]

Array.prototype.slice (শুরু, শেষ)

.slice() কোনও বিধ্বংসী নয় এবং start থেকে end পর্যন্ত নির্দেশিত সূচকগুলি সহ একটি নতুন অ্যারে প্রদান করে। যদি .splice() নির্দিষ্ট না করা থাকে তবে আচরণটি .splice() ( end = array.length ) হিসাবে একই। আচরণটি কিছুটা জটিল, যেহেতু কিছু কারণে, end সূচীগুলি 0 এর পরিবর্তে 1 থেকে 0. আমি জানি না এটি কেন এটি করে, কিন্তু এটি এমনভাবে হয়। এছাড়াও, যদি end <= start , ফলাফল একটি খালি অ্যারে হয়।

let a = [5,4,3,2,1];
let chunks = [
    a.slice(2,0),
    a.slice(2,2),
    a.slice(2,3),
    a.slice(2,5) ];

// a             [5,4,3,2,1]
// start          0 1 2 - -
// end, for...    - - - - -
//   chunks[0]  0 - - - - -   
//   chunks[1]    1 2 - - -
//   chunks[2]    1 2 3 - -
//   chunks[3]    1 2 3 4 5

chunks; // [ [], [], [3], [3,2,1] ]
a;      // [5,4,3,2,1]

আসলে কি হচ্ছে তা নয়, কিন্তু এভাবে চিন্তা করা সহজ। এমডিনের মতে, এখানে আসলে কি হচ্ছে:

// a             [5,4,3,2,1]
// start          0 1 2 - - -
// end, for...    - - - - - -
//   chunks[0]    0 - - - - -
//   chunks[1]    0 1 2 - - -
//   chunks[2]    0 1(2)3 - -
//   chunks[3]    0 1(2 3 4)5

end দ্বারা নির্দিষ্ট সূচক স্লাইস থেকে কেবল বাদ দেওয়া হয়। বন্ধনী সংকেত কি sliced ​​পায় নির্দেশ। যেকোনো উপায়ে, আচরণটি স্বজ্ঞাত নয় এবং এটি বন্ধ-ত্রুটি-ত্রুটির .splice() ভাগ করে নেওয়ার জন্য আবদ্ধ, তাই আপনি হয়তো এটির সহায়ক হতে পারে wrapper ফাংশনটি .splice() এর আচরণকে আরও নিখুঁতভাবে .splice() :

function ez_slice(array, start = 0, n = null){
    if(!Array.isArray(array) || !is_number(start))
        return null;

    if(is_number(n))
        return array.slice(start, start + n);

    if(n === null)
        return array.slice(start);

    return null;
}

ez_slice([5,4,3,2,1], 2, 1) // [3]
ez_slice([5,4,3,2,1], 2)    // [3,2,1]

/* Fun fact: isNaN is unreliable.
 * [NaN, [], {}, 0, 1, Infinity, undefined, null, "Hi"].filter(isNaN)
 * [NaN, {}, undefined, "Hi"]
 *
 * What we want is...
 *
 * [NaN, [], {}, 0, 1, Infinity, undefined, null, "Hi"].filter(is_nan)
 * [NaN]
 */
function is_nan(num){
    return typeof num === "number"
        && num !== num;
}

function is_number(num){
    return !is_nan(num)
        && typeof num === "number"
        && isFinite(num);
}

উল্লেখ্য যে মোড়ক ফাংশনটি বিভিন্ন ধরণের সম্পর্কে কঠোর হতে ডিজাইন করা হয়েছে এবং যদি কিছু বন্ধ থাকে তবে এটি null ফিরে আসবে। যে "3" মত একটি স্ট্রিং নির্বাণ অন্তর্ভুক্ত। এটি তার ধরনের সম্পর্কে অধ্যবসায়ী হতে প্রোগ্রামার পর্যন্ত বাকি আছে। এই ভাল প্রোগ্রামিং অনুশীলন উত্সাহিত করা হয়।

is_array() সংক্রান্ত আপডেট is_array()

এটি এই (এখন সরানো) স্নিপেট সম্পর্কিত:

function is_array(array){
    return array !== null
        && typeof array === "object"
        && typeof array.length !== "undefined"
        && array.__proto__ === Array.prototype;
}

সুতরাং এটি সক্রিয় হয়ে গেলে, প্রকৃতপক্ষে একটি অ্যারে প্রকৃতপক্ষে একটি অ্যারে আছে কিনা তা জানাতে একটি অন্তর্নির্মিত উপায়, এবং এটি Array.isArray() 5 (ডিসেম্বর ২009) এ উপস্থাপিত Array.isArray() )। বস্তু থেকে অ্যারে বলার বিষয়ে জিজ্ঞাসা করার প্রশ্ন থাকলে দেখি, আমার চেয়েও ভাল সমাধান আছে কিনা, অথবা কেউ ছিল না যদি খনি যোগ করার জন্য প্রশ্ন করা হয় তবে আমি এটি খুঁজে পেয়েছি। সুতরাং, আপনি যদি জাভাস্ক্রিপ্টের সংস্করণটি ব্যবহার করছেন যা ইসিএমএ 5 এর চেয়ে আগের, আপনার পলিফিল আছে। যাইহোক, আমি আমার is_array() ফাংশনটি ব্যবহার করার বিরুদ্ধে দৃঢ়ভাবে সুপারিশ করছি, জাভাস্ক্রিপ্টের পুরানো সংস্করণগুলিকে সমর্থন করা চালিয়ে যাওয়ার মানে হল যে পুরানো ব্রাউজারগুলিকে তাদের বাস্তবায়ন সমর্থন করা চালিয়ে যাওয়া, যার অর্থ হচ্ছে অনিরাপদ সফ্টওয়্যার ব্যবহারকে উত্সাহ দেওয়া এবং ব্যবহারকারীদের ম্যালওয়ারের ঝুঁকি রাখা। সুতরাং, Array.isArray() ব্যবহার করুন। ব্যবহার করুন এবং গঠন। ভাষা যোগ করা যে নতুন বৈশিষ্ট্য ব্যবহার করুন। বিক্রেতা উপসর্গ ব্যবহার করবেন না । আপনার ওয়েবসাইট থেকে IE পলিফিল বিষ্ঠা মুছুন । XHTML <!CDATA[[... মুছুন <!CDATA[[... খুব, আমরাও ২014 সালে HTML5 এ চলেছি। যত তাড়াতাড়ি সবাই সেই পুরোনো / গোপনীয় ব্রাউজারগুলির জন্য সমর্থন প্রত্যাহার করবে, যত তাড়াতাড়ি ব্রাউজার বিক্রেতারা ওয়েব মান অনুসরণ করবে এবং আলিঙ্গন করবে নতুন প্রযুক্তি, এবং যত তাড়াতাড়ি আমরা আরো নিরাপদ ওয়েবে যেতে পারেন।

var myObject = {"ircEvent": "PRIVMSG", "method": "newURI", "regex": "^http://.*"};
    
delete myObject.regex;

console.log ( myObject.regex); // logs: undefined

এটি ফায়ারফক্স এবং ইন্টারনেট এক্সপ্লোরারে কাজ করে এবং আমি মনে করি এটি অন্য সকলের মধ্যে কাজ করে।

"regex"সম্পত্তি ছাড়াই একটি নতুন বস্তু তৈরি করার কথা বিবেচনা করুন কারণ মূল অবজেক্টটি আপনার প্রোগ্রামের অন্যান্য অংশগুলির দ্বারা সর্বদা উল্লেখ করা যেতে পারে। সুতরাং আপনি এটি manipulating এড়াতে হবে।

const myObject = {
    "ircEvent": "PRIVMSG",
    "method": "newURI",
    "regex": "^http://.*"
};

const { regex, ...newMyObject } = myObject;

console.log(newMyObject);

আরেকটি সমাধান, ব্যবহার করে Array#reduce।

var myObject = {
  "ircEvent": "PRIVMSG",
  "method": "newURI",
  "regex": "^http://.*"
};

myObject = Object.keys(myObject).reduce(function(obj, key) {
  if (key != "regex") {           //key you want to remove
    obj[key] = myObject[key];
  }
  return obj;
}, {});

console.log(myObject);

যাইহোক, এটি মূল বস্তু mutate হবে । আপনি নির্দিষ্ট কী ছাড়া একটি নতুন বস্তু তৈরি করতে চান , শুধুমাত্র একটি নতুন পরিবর্তনশীল ফাংশন হ্রাস, যেমন:

(ES6)

const myObject = {
  ircEvent: 'PRIVMSG',
  method: 'newURI',
  regex: '^http://.*',
};

const myNewObject = Object.keys(myObject).reduce((obj, key) => {
  key !== 'regex' ? obj[key] = myObject[key] : null;
  return obj;
}, {});

console.log(myNewObject);

লোডশ ব্যবহার করে

import omit from 'lodash/omit';

const prevObject = {test: false, test2: true};
// Removes test2 key from previous object
const nextObject = omit(prevObject, 'test2');

রমডা ব্যবহার করে

R.omit(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, c: 3}

ECMAScript 2015 (বা ES6) বিল্ট-ইন Reflect বস্তুর সাথে এসেছিল । প্যারামিটার হিসাবে লক্ষ্য বস্তু এবং সম্পত্তি কী সহ Reflect.deleteProperty() ফাংশন কল করে বস্তুর সম্পত্তি মুছতে পারে :

Reflect.deleteProperty(myJSONObject, 'regex');

যা সমতুল্য:

delete myJSONObject['regex'];

কিন্তু যদি বস্তুর সম্পত্তি কনফিগারযোগ্য না হয় তবে এটি মুছে ফেলা যাবে না deleteProperty ফাংশন বা অপারেটরটি মুছে ফেলবে না:

let obj = Object.freeze({ prop: "value" });
let success = Reflect.deleteProperty(obj, "prop");
console.log(success); // false
console.log(obj.prop); // value

Object.freeze() বস্তুর সমস্ত বৈশিষ্ট্য কনফিগারযোগ্য নয় (অন্যান্য জিনিস ছাড়া Object.freeze() তোলে। deletePropertyফাংশন (সেইসাথে developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… ) তার falseকোনও বৈশিষ্ট্য মুছে ফেলার চেষ্টা করলে ফেরত দেয় । যদি সম্পত্তি কনফিগারযোগ্য হয় তবে এটি ফেরত দেয় true, এমনকি যদি সম্পত্তি বিদ্যমান না থাকে।

কঠোর মোড ব্যবহার করার সময় deleteএবং মধ্যে পার্থক্য deleteProperty:

"use strict";

let obj = Object.freeze({ prop: "value" });
Reflect.deleteProperty(obj, "prop"); // false
delete obj["prop"];
// TypeError: property "prop" is non-configurable and can't be deleted