javascript - जांचें कि ऑब्जेक्ट एक सरणी है या नहीं?




arrays (25)

मैं एक ऐसा फ़ंक्शन लिखने की कोशिश कर रहा हूं जो या तो तारों की सूची स्वीकार करता है, या एक स्ट्रिंग। यदि यह एक स्ट्रिंग है, तो मैं इसे केवल एक आइटम के साथ सरणी में परिवर्तित करना चाहता हूं। फिर मैं किसी त्रुटि के डर के बिना इसे लूप कर सकता हूं।

तो मैं कैसे जांचूं कि चर एक सरणी है या नहीं?

मैंने नीचे दिए गए विभिन्न समाधानों को गोल किया है और एक जेएसपीआरएफ परीक्षण बनाया है।


Answers

jQuery भी $.isArray() विधि प्रदान करता है:

var a = ["A", "AA", "AAA"];

if($.isArray(a)) {
  alert("a is an array!");
} else {
  alert("a is not an array!");
}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>


यह फ़ंक्शन लगभग किसी भी सरणी में बदल जाएगा:

function arr(x) {
    if(x === null || x === undefined) {
        return [];
    }
    if(Array.isArray(x)) {
        return x;
    }
    if(isString(x) || isNumber(x)) {
        return [x];
    }
    if(x[Symbol.iterator] !== undefined || x.length !== undefined) {
        return Array.from(x);
    }
    return [x];
}

function isString(x) {
    return Object.prototype.toString.call(x) === "[object String]"
}

function isNumber(x) {
    return Object.prototype.toString.call(x) === "[object Number]"
}

यह कुछ नई ब्राउज़र सुविधाओं का उपयोग करता है ताकि आप इसे अधिकतम समर्थन के लिए पॉलीफिल करना चाहें।

उदाहरण:

> arr(null);
[]
> arr(undefined)
[]
> arr(3.14)
[ 3.14 ]
> arr(1/0)
[ Infinity ]
> gen = function*() { yield 1; yield 2; yield 3; }
[Function: gen]
> arr(gen())
[ 1, 2, 3 ]
> arr([4,5,6])
[ 4, 5, 6 ]
> arr("foo")
[ 'foo' ]

एनबी तारों को सरणी की सरणी के बजाय एक तत्व के साथ एक सरणी में परिवर्तित किया जाएगा। isString चेक हटाएं यदि आप इसे दूसरी तरफ पसंद करेंगे।

मैंने Array.isArray का उपयोग यहां किया है क्योंकि यह सबसे मजबूत और सरलतम है।


A = [1,2,3]
console.log(A.map==[].map)

यहां तक ​​कि सबसे कम संस्करण की खोज में मुझे अब तक क्या मिला है।

नोट, कोई सही कार्य नहीं है जो हमेशा सभी संभावित संयोजनों का पता लगाएगा। एक जादू उपकरण की अपेक्षा से अपने उपकरणों की सभी क्षमताओं और सीमाओं को जानना बेहतर है।


यह सभी विधियों में सबसे तेज़ है (सभी ब्राउज़र समर्थित):

function isArray(obj){
    return !!obj && obj.constructor === Array;
}

function isArray(value) {
    if (value) {
        if (typeof value === 'object') {
            return (Object.prototype.toString.call(value) == '[object Array]')
        }
    }
    return false;
}

var ar = ["ff","tt"]
alert(isArray(ar))

आधुनिक ब्राउज़रों में आप कर सकते हैं

Array.isArray(obj)

(क्रोम 5, फ़ायरफ़ॉक्स 4.0, आईई 9, ओपेरा 10.5 और सफारी द्वारा समर्थित 5)

पिछड़े संगतता के लिए आप निम्नलिखित जोड़ सकते हैं

# only implement if no native implementation is available
if (typeof Array.isArray === 'undefined') {
  Array.isArray = function(obj) {
    return Object.prototype.toString.call(obj) === '[object Array]';
  }
};

यदि आप jQuery का उपयोग करते हैं तो आप jQuery.isArray(obj) या $.isArray(obj) उपयोग कर सकते हैं। यदि आप अंडरस्कोर का उपयोग करते हैं तो आप _.isArray(obj) उपयोग कर सकते हैं

यदि आपको अलग-अलग फ्रेम में बनाए गए सरणी का पता लगाने की आवश्यकता नहीं है तो आप केवल instanceof उपयोग कर सकते हैं

obj instanceof Array

एक इनपुट मान एक सरणी है तो परीक्षण के लिए एक सरल कार्य निम्न है:

function isArray(value)
{
  return Object.prototype.toString.call(value) === '[object Array]';
}

यह क्रॉस ब्राउज़र और पुराने ब्राउज़र के साथ काम करता है। इसे टीजे क्रॉडर ब्लॉग पोस्ट से खींचा जाता है


Array.isArray

Array.isArray = Array.isArray || function (vArg) {
    return Object.prototype.toString.call(vArg) === "[object Array]";
};

कल्पना करें कि आपके पास नीचे यह सरणी है:

var arr = [1,2,3,4,5];

जावास्क्रिप्ट (नए और पुराने ब्राउज़र):

function isArray(arr) {
  return arr.constructor.toString().indexOf("Array") > -1;
}

या

function isArray(arr) {
  return arr instanceof Array;
}

या

function isArray(arr) {
  return Object.prototype.toString.call(arr) === '[object Array]';
}

फिर इसे इस तरह कहते हैं:

isArray(arr);

जावास्क्रिप्ट (आईई 9 +, सी 5 +, एफएफ 4 +, सफ 5 +, ओपेरा 10.5 +)

Array.isArray(arr);

jQuery:

$.isArray(arr);

कोणीय:

angular.isArray(arr);

अंडरस्कोर और लोडाश:

_.isArray(arr);

जैसा कि एमडीएन यहां कहते हैं :

सरणी से नियमित वस्तुओं को अलग करने के लिए Array.isArray या Object.prototype.toString.call का उपयोग करें

ऐशे ही:

  • Object.prototype.toString.call(arr) === '[object Array]' , या

  • Array.isArray(arr)


ऑब्जेक्ट एक ऐरे है या नहीं, यह जांचने का सबसे आसान और तेज़ तरीका।

 var arr = [];
  arr.constructor.name ==='Array'  //return true;

या

arr.constructor ===Array //return true;

या आप एक उपयोगिता समारोह कर सकते हैं:

function isArray(obj){ return obj && obj.constructor ===Array}

उपयोग:

isArray(arr); //return true

आप आरे विधि हो सकते हैं लेकिन मैं जांच करना पसंद करूंगा

Object.getPrototypeOf(yourvariable) === Array.prototype


Array.isArray तेजी से काम करता है, लेकिन यह ब्राउज़र के सभी संस्करणों द्वारा समर्थित नहीं है। तो आप दूसरों के लिए अपवाद बना सकते हैं और सार्वभौमिक विधि का उपयोग कर सकते हैं:

    Utils = {};    
    Utils.isArray = ('isArray' in Array) ? 
        Array.isArray : 
        function (value) {
            return Object.prototype.toString.call(value) === '[object Array]';
        }

मैं उस ऑब्जेक्ट के प्रकार का परीक्षण करने के लिए एक फ़ंक्शन करूंगा जिसके साथ आप काम कर रहे हैं ...

function whatAmI(me){ return Object.prototype.toString.call(me).split(/\W/)[2]; }

// tests
console.log(
  whatAmI(["aiming","@"]),
  whatAmI({living:4,breathing:4}),
  whatAmI(function(ing){ return ing+" to the global window" }),
  whatAmI("going to do with you?")
);

// output: Array Object Function String

तो आप कथन अगर एक सरल लिख सकते हैं ...

if(whatAmI(myVar) === "Array"){
    // do array stuff
} else { // could also check `if(whatAmI(myVar) === "String")` here to be sure
    // do string stuff
}

मैं इसे एक बहुत ही सरल तरीके से करता हूं। मेरे लिये कार्य करता है। कोई कमी?

Array.prototype.isArray = true;

a=[]; b={};
a.isArray  // true
b.isArray  // (undefined -> false)

मैंने jsperf fiddle को दो वैकल्पिक तरीकों के साथ-साथ त्रुटि जांच के साथ अद्यतन किया है।

यह पता चला है कि 'ऑब्जेक्ट' और 'ऐरे' प्रोटोटाइप में निरंतर मूल्य को परिभाषित करने वाली विधि किसी भी अन्य तरीकों से तेज है। यह कुछ हद तक आश्चर्यजनक परिणाम है।

/* Initialisation */
Object.prototype.isArray = function() {
  return false;
};
Array.prototype.isArray = function() {
  return true;
};
Object.prototype._isArray = false;
Array.prototype._isArray = true;

var arr = ["1", "2"];
var noarr = "1";

/* Method 1 (function) */
if (arr.isArray()) document.write("arr is an array according to function<br/>");
if (!noarr.isArray()) document.write("noarr is not an array according to function<br/>");
/* Method 2 (value) - **** FASTEST ***** */
if (arr._isArray) document.write("arr is an array according to member value<br/>");
if (!noarr._isArray) document.write("noarr is not an array according to member value<br/>");

वेरिएबल काम नहीं करते हैं, यदि परिवर्तनीय अपरिभाषित मान लेता है, लेकिन यदि आप निश्चित हैं कि उनके पास कोई मान है तो वे काम करते हैं। यदि मान एक सरणी या एकल मान है, तो प्रदर्शन में दिमाग में जांच के संबंध में, दूसरी विधि वैध तेज़ विधि की तरह दिखती है। यह क्रोम पर 'exampleof' से थोड़ा तेज है, इंटरनेट एक्सप्लोरर, ओपेरा और सफारी (मेरी मशीन पर) में दूसरी सबसे अच्छी विधि के रूप में तेज़ी से दोगुना है।


यदि आप जानते हैं कि आपके ऑब्जेक्ट में एक कॉन्सटैट विधि नहीं है तो निम्नलिखित का उपयोग किया जा सकता है।

var arr = [];
if (typeof arr.concat === 'function') {
    console.log("It's an array");
}


इस प्रश्न के लिए सिर्फ एक लाइन समाधान है

x instanceof Array

जहां x वैरिएबल है, यदि यह एक सरणी है और गलत नहीं है तो यह सत्य वापस आ जाएगा।


आप अपने चर के प्रकार की जांच कर सकते हैं चाहे वह एक सरणी है;

var myArray=[];

if(myArray instanceof Array)
{
....
}

Stoyan Stefanov की पुस्तक जावास्क्रिप्ट पैटर्न में एक अच्छा उदाहरण है जो सभी संभावित समस्याओं को संभालने के साथ-साथ ECMAScript 5 विधि Array.isArray () का उपयोग करने का अनुमान लगाता है

तो यहां यह है:

if (typeof Array.isArray === "undefined") {
    Array.isArray = function (arg) {
        return Object.prototype.toString.call(arg) === "[object Array]";
    };
}

वैसे, यदि आप jQuery का उपयोग कर रहे हैं, तो आप इसकी विधि $.isArray() का उपयोग कर सकते हैं


यहां मेरा आलसी दृष्टिकोण है:

if (Array.prototype.array_ === undefined) {
  Array.prototype.array_ = true;
}

// ...

var test = [],
    wat = {};

console.log(test.array_ === true); // true
console.log(wat.array_ === true);  // false

मुझे पता है कि यह प्रोटोटाइप के साथ "गड़बड़" करने के लिए पवित्र है, लेकिन यह अनुशंसित toString विधि से काफी बेहतर प्रदर्शन करता प्रतीत होता है

नोट: इस दृष्टिकोण का एक झटका यह है कि यह iframe सीमाओं पर काम नहीं करेगा , लेकिन मेरे उपयोग के मामले में यह कोई मुद्दा नहीं है।


टिप्पणियों को ध्यान में रखते हुए इस उत्तर पर सुधार करने का मेरा प्रयास है:

var isArray = myArray && myArray.constructor === Array;

यह if / else से छुटकारा पाता है, और सरणी को शून्य या अपरिभाषित होने की संभावना के लिए खाते हैं


मैंने देखा है कि सबसे अच्छा समाधान टाइप के लिए एक क्रॉस ब्राउज़र प्रतिस्थापन है। here एंगस क्रॉल का समाधान देखें।

टीएल; डीआर संस्करण नीचे है, लेकिन लेख इस मुद्दे की एक बड़ी चर्चा है, इसलिए यदि आपके पास समय है तो आपको इसे पढ़ना चाहिए।

Object.toType = function(obj) {
    return ({}).toString.call(obj).match(/\s([a-z|A-Z]+)/)[1].toLowerCase();
}
// ... and usage:
Object.toType([1,2,3]); //"array" (all browsers)

// or to test...
var shouldBeAnArray = [1,2,3];
if(Object.toType(shouldBeAnArray) === 'array'){/* do stuff */};

आप इस दृष्टिकोण को आजमा सकते हैं: http://web.archive.org/web/20100424091244/http://www.ajaxdr.com/code/javascript-version-of-phps-is_array-function/

संपादित करें : अगर आप पहले से ही अपने प्रोजेक्ट में JQuery का उपयोग कर रहे हैं, तो आप इसके फ़ंक्शन $.isArray() उपयोग कर सकते हैं।


ऑपरेटर delete अप्रत्याशित रूप से धीमा है!

benchmark

किसी भी बचे हुए पदार्थों के बिना ऑब्जेक्ट के गुणों को हटाने का एकमात्र सही तरीका है, लेकिन यह "वैकल्पिक" की तुलना में ~ 100 गुना धीमा काम करता है, object[key] = undefined सेटिंग।

यह विकल्प इस सवाल का सही जवाब नहीं है! लेकिन, यदि आप इसे देखभाल के साथ उपयोग करते हैं, तो आप नाटकीय रूप से कुछ एल्गोरिदम को गति दे सकते हैं। यदि आप लूप में delete का उपयोग कर रहे हैं और आपको प्रदर्शन के साथ समस्याएं हैं, तो वर्बोज स्पष्टीकरण पढ़ें।

किसी को कब delete जाना चाहिए और जब मान को undefined ?

एक वस्तु को कुंजी-मूल्य जोड़े के सेट के रूप में देखा जा सकता है। जिसे मैं 'मूल्य' कहता हूं वह एक मूल या अन्य वस्तु का संदर्भ है, जो उस 'कुंजी' से जुड़ा हुआ है।

delete उपयोग करें, जब आप परिणाम ऑब्जेक्ट को उस कोड पर पास कर रहे हैं जिस पर आपके पास नियंत्रण नहीं है (या जब आप अपनी टीम या स्वयं के बारे में निश्चित नहीं हैं)।

यह हैशपैप से कुंजी हटा देता है

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

जब आप प्रदर्शन की परवाह करते हैं , तो सेटिंग को undefined करने के लिए उपयोग करें । यह आपके कोड को गंभीर बढ़ावा दे सकता है।

हैशपैप में इसकी जगह पर कुंजी बनी हुई है , केवल मूल्य को undefined साथ बदल दिया गया है। समझें, कि for..in लूप अभी भी उस कुंजी पर फिर से 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] prop से prop को हटा देता है और इसे स्मृति से मिटा देता है जबकि obj[prop] = undefined बस 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; प्रत्येक एनीमेशन फ्रेम के कारण एक विशाल स्मृति रिसाव का कारण बन जाएगा। प्रत्येक फ्रेम, सभी 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 पूर्ववत नहीं किया जा सकता है। इसलिए, भले ही आप गैर-पॉलीमोर्फिक होने के लिए एक पॉलिमॉर्फिक सरणी को पुनर्स्थापित करते हैं, फिर भी यह ब्राउज़र द्वारा पॉलिमॉर्फिक सरणी के रूप में संग्रहीत किया जाएगा।

एक ड्रग लत के लिए बहुरूपता की तुलना कर सकते हैं। पहली नज़र में, यह बेहद आकर्षक लगता है: अच्छा सुंदर fluffy कोड। फिर, कोडर अपनी सरणी को बहुरूपता की दवा में पेश करता है। तत्काल, polymorphic सरणी कम कुशल हो जाता है, और यह कभी भी कुशल नहीं हो सकता है क्योंकि यह पहले से ही ड्रग किया गया था। इस तरह के परिस्थिति को वास्तविक जीवन में सहसंबंधित करने के लिए, कोकीन पर कोई भी साधारण दरवाजा संभाल करने में सक्षम नहीं हो सकता है, पीआई के अंकों की गणना करने में बहुत कम सक्षम हो सकता है। इसी प्रकार, बहुरूपता की दवा पर एक सरणी कभी भी मोनोमोर्फिक सरणी के रूप में कुशल नहीं हो सकती है।

लेकिन, एक दवा यात्रा समानता कैसे delete ऑपरेशन से संबंधित है? उत्तर उपरोक्त स्निपेट में कोड की अंतिम पंक्ति को घेरता है। इस प्रकार इसे मोड़ के साथ, इस बार पुन: निष्पादित करने दें।

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 समावेशी) और धीमी गति से चलने वाली बिंदु युगल (नाइन और Infinity सहित अन्य कुछ भी)। जब एक पूर्णांक को डबल पर स्थानांतरित किया जाता है, तो उसे पूर्णांक में वापस प्रचारित नहीं किया जा सकता है।
  • स्ट्रिंग आदिम पर टाइप किए गए सरणी / चर का उपयोग करते समय, खाली मान के रूप में प्रयोग करें।
  • एक प्रतीक का उपयोग करते समय, प्रतीक्षा करें, आप एक प्रतीक का उपयोग क्यों कर रहे हैं?!? प्रदर्शन के लिए प्रतीक बुजु जुजू हैं। प्रतीकों का उपयोग करने के लिए प्रोग्राम किए गए सब कुछ को प्रतीकों का उपयोग न करने के लिए पुन: प्रोग्राम किया जा सकता है, जिसके परिणामस्वरूप प्रतीकों के बिना एक तेज कोड होता है। प्रतीक वास्तव में केवल सुपर अक्षम मात्रा मेटा-चीनी हैं।
  • किसी और चीज का उपयोग करते समय, null उपयोग करें।

हालांकि, सावधान रहें! अचानक अपने सभी पूर्ववर्ती कोड के साथ ऐसा करना शुरू न करें क्योंकि यह संभवतः ऐसे पूर्ववर्ती कोड को तोड़ देगा और / या अजीब बग पेश करेगा। इसके बजाय, इस तरह के एक कुशल अभ्यास को शुरुआत से लागू करने की आवश्यकता है, और जब पूर्ववर्ती कोड को परिवर्तित करते हैं, तो यह अनुशंसा की जाती है कि आप इस नए अभ्यास में पुराने कोड को अपग्रेड करने की कोशिश के रूप में उससे संबंधित सभी पंक्तियों को दोहरी, तिगुना, चौगुनी जांचें। जोखिम भरा है क्योंकि यह पुरस्कृत है।





javascript arrays