javascript - রহম - জাভাস্ক্রিপ্ট বাংলা বই




আমি কিভাবে একটি জাভাস্ক্রিপ্ট বস্তুর থেকে একটি সম্পত্তি অপসারণ করবেন? (20)

নিম্নরূপ একটি বস্তু তৈরি করুন বলুন: 

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

নিম্নরূপ নতুন myObject সঙ্গে শেষ পর্যন্ত সম্পত্তি regex অপসারণ করার সেরা উপায় কি? 

var myObject = {
    "ircEvent": "PRIVMSG",
    "method": "newURI"
};

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;

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"];
        }
    }
);

অপারেটর 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 ব্যবহার করুন।

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

আপনি আপনার প্রশ্ন শিরোনাম ব্যবহার শব্দটি 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()

এটার মত: 

delete myObject.regex;
// or,
delete myObject['regex'];
// or,
var prop = "regex";
delete myObject[prop];

ডেমো 

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

console.log(myObject);

যে কেউ এটি সম্পর্কে আরও পড়তে আগ্রহী, স্ট্যাক ওভারফ্লো ব্যবহারকারী kangax তাদের ব্লগে delete বিবৃতি সম্পর্কে delete বিবৃতি সম্পর্কে অবিশ্বাস্যভাবে গভীরভাবে ব্লগ পোস্ট লিখেছে। এটা অত্যন্ত সুপারিশ করা হয়।

পুরাতন প্রশ্ন, আধুনিক উত্তর। বস্তু ধ্বংসকারী ব্যবহার করে, একটি 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);

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

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

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

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

এই নতুন 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"}

এটা চেষ্টা কর 

delete myObject['key'];

খুব সহজ: 

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

delete myObject.regex;

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

var deepObjectRemove = function(obj, path_to_key){
    if(path_to_key.length === 1){
        delete obj[path_to_key[0]];
        return true;
    }else{
        if(obj[path_to_key[0]])
            return deepObjectRemove(obj[path_to_key[0]], path_to_key.slice(1));
        else
            return false;
    }
};

উদাহরণ: 

var a = {
    level1:{
        level2:{
            level3: {
                level4: "yolo"
            }
        }
    }
};

deepObjectRemove(a, ["level1", "level2", "level3"]);
console.log(a);

//Prints {level1: {level2: {}}}

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

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}


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

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

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

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

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

console.log(myObject)
console.log(regex)
console.log(other)

developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… তা করার সবচেয়ে ভাল উপায়।

দেখানোর জন্য একটি লাইভ উদাহরণ: 

var foo = {bar: 'bar'};
delete foo.bar;
console.log('bar' in foo); // Logs false, because bar was deleted from foo.

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

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

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

console.log(newMyObject);

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

আপনি কেবল 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/… ।

আরেকটি সমাধান, ব্যবহার করে 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);

ড্যানের দাবি যে 'মুছে ফেলুন' খুব ধীর এবং তিনি পোস্ট করা বেঞ্চমার্ক সন্দেহ ছিল। তাই আমি নিজেই ক্রোম 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

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




রহম   অবজ   javascript   javascript-objects   object-properties  


object-properties