JavaScript
यूनरी ऑपरेटर्स

वाक्य - विन्यास

• शून्य अभिव्यक्ति; // अभिव्यक्ति का मूल्यांकन करता है और रिटर्न वैल्यू वापस करता है
• + अभिव्यक्ति; // अभिव्यक्ति को संख्या में बदलने का प्रयास
• ऑब्जेक्ट हटाएं; // ऑब्जेक्ट की संपत्ति हटाएं
• ऑब्जेक्ट हटाएं ["संपत्ति"]; // ऑब्जेक्ट की संपत्ति हटाएं
• टाइपोफ़ ऑपरेंड; // ऑपरेंड का प्रकार लौटाता है
• ~ अभिव्यक्ति; // प्रत्येक बिट अभिव्यक्ति पर ऑपरेशन नहीं करें
• ! अभिव्यक्ति; // अभिव्यक्ति पर तार्किक उपेक्षा करें
• -expression; // संख्या में रूपांतरण का प्रयास करने के बाद नेगेट अभिव्यक्ति

यूनीरी प्लस ऑपरेटर (+)

यूनीरी प्लस ( + ) इसके ऑपरेंड से पहले और इसके ऑपरेंड का मूल्यांकन करता है। यदि यह पहले से ही नहीं है, तो यह ऑपरेंड को एक संख्या में बदलने का प्रयास करता है।

वाक्य - विन्यास:

+expression

यह दिखाता है:

• एक Number ।

विवरण

यूनरी प्लस ( + ) ऑपरेटर किसी संख्या में किसी चीज़ को परिवर्तित करने का सबसे तेज़ (और पसंदीदा) तरीका है।

यह परिवर्तित कर सकते हैं:

• पूर्णांक (दशमलव या हेक्साडेसिमल) और फ्लोट्स के स्ट्रिंग निरूपण।
• बूलियन: true , false ।
• null

वे मान जिन्हें परिवर्तित नहीं किया जा सकता वे NaN मूल्यांकन करेंगे।

उदाहरण:

+42           // 42
+"42"         // 42
+true         // 1
+false        // 0
+null         // 0
+undefined    // NaN
+NaN          // NaN
+"foo"        // NaN
+{}           // NaN
+function(){} // NaN

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

[].toString() === '';
[1].toString() === '1';
[1, 2].toString() === '1,2';

ऑपरेटर फिर उन तारों को संख्याओं में बदलने का प्रयास करता है:

+[]           // 0   ( === +'' )
+[1]          // 1   ( === +'1' )
+[1, 2]       // NaN ( === +'1,2' )

हटाने वाला

delete ऑपरेटर एक ऑब्जेक्ट से एक संपत्ति को हटा देता है।

वाक्य - विन्यास:

delete object.property

delete object['property']

यह दिखाता है:

यदि विलोपन सफल है, या संपत्ति मौजूद नहीं थी:

• true

यदि हटाई जाने वाली संपत्ति स्वयं की गैर-विन्यास योग्य संपत्ति है (नष्ट नहीं की जा सकती):

• गैर-सख्त मोड में false ।
• सख्त मोड में त्रुटि फेंकता है

विवरण

delete ऑपरेटर सीधे मेमोरी को फ्री नहीं करता है। यह अप्रत्यक्ष रूप से मुफ्त मेमोरी हो सकता है यदि ऑपरेशन का मतलब संपत्ति के सभी संदर्भ चले गए हैं।

ऑब्जेक्ट के गुणों पर कार्य delete । यदि समान नाम वाली कोई संपत्ति ऑब्जेक्ट की प्रोटोटाइप श्रृंखला पर मौजूद है, तो संपत्ति को प्रोटोटाइप से विरासत में मिली होगी।
delete चर या फ़ंक्शन नामों पर काम नहीं करता है।

उदाहरण:

// Deleting a property
foo = 1;              // a global variable is a property of `window`: `window.foo`
delete foo;           // true
console.log(foo);     // Uncaught ReferenceError: foo is not defined

// Deleting a variable
var foo = 1;
delete foo;           // false
console.log(foo);     // 1 (Not deleted)

// Deleting a function
function foo(){ };
delete foo;           // false
console.log(foo);     // function foo(){ } (Not deleted)

// Deleting a property
var foo = { bar: "42" };
delete foo.bar;       // true
console.log(foo);     // Object { } (Deleted bar)

// Deleting a property that does not exist
var foo = { };
delete foo.bar;       // true
console.log(foo);     // Object { } (No errors, nothing deleted)

// Deleting a non-configurable property of a predefined object
delete Math.PI;       // false  ()
console.log(Math.PI); // 3.141592653589793 (Not deleted)

टाइपो ऑपरेटर

typeof ऑपरेटर स्ट्रिंग के रूप में अनवैल्यूएटेड ऑपरेंड के डेटा प्रकार को लौटाता है।

वाक्य - विन्यास:

typeof operand

यह दिखाता है:

ये typeof से संभावित वापसी मान हैं:

typeof ऑपरेटर के साथ document.all का असामान्य व्यवहार विरासत ब्राउज़रों का पता लगाने के लिए अपने पूर्व उपयोग से है। अधिक जानकारी के लिए, यह देखें कि डॉक्यूमेंट क्यों लिखा गया है लेकिन टाइपऑफ डॉक्यूमेंट.ऑल रिटर्न "अपरिभाषित" है?

उदाहरण:

// returns 'number'
typeof 3.14;
typeof Infinity;
typeof NaN;               // "Not-a-Number" is a "number"

// returns 'string'
typeof "";
typeof "bla";
typeof (typeof 1);        // typeof always returns a string

// returns 'boolean'
typeof true;
typeof false;

// returns 'undefined'
typeof undefined;
typeof declaredButUndefinedVariable;
typeof undeclaredVariable;
typeof void 0;
typeof document.all       // see above

// returns 'function'
typeof function(){};
typeof class C {};
typeof Math.sin;

// returns 'object'
typeof { /*<...>*/ };
typeof null;
typeof /regex/;           // This is also considered an object
typeof [1, 2, 4];         // use Array.isArray or Object.prototype.toString.call.
typeof new Date();
typeof new RegExp();
typeof new Boolean(true); // Don't use!
typeof new Number(1);     // Don't use!
typeof new String("abc"); // Don't use!

// returns 'symbol'
typeof Symbol();
typeof Symbol.iterator;

शून्य संचालक

void ऑपरेटर दी गई अभिव्यक्ति का मूल्यांकन करता है और फिर undefined लौटता है।

वाक्य - विन्यास:

void expression

यह दिखाता है:

• undefined

विवरण

void ऑपरेटर को अक्सर void 0 या void(0) लिखने के माध्यम से undefined आदिम मूल्य प्राप्त करने के लिए उपयोग किया जाता है। ध्यान दें कि void एक ऑपरेटर है, फ़ंक्शन नहीं है, इसलिए () की आवश्यकता नहीं है।

आमतौर पर एक void अभिव्यक्ति और undefined के परिणाम का उपयोग परस्पर विनिमय किया जा सकता है।
हालाँकि, ECMAScript के पुराने संस्करणों में, window.undefined को किसी भी मान को असाइन किया जा सकता है, और फ़ंक्शन के अंदर फ़ंक्शन पैरामीटर चर के लिए नाम के रूप में undefined का उपयोग करना अभी भी संभव है, इस प्रकार अन्य कोड को बाधित करता है जो undefined के मूल्य पर निर्भर करता है।
void हमेशा सही undefined मान निकलेगा।

void 0 का उपयोग आमतौर पर कोड मिनिफिकेशन में भी किया जाता है, जो undefined लिखने का एक छोटा तरीका है। इसके अलावा, यह शायद अधिक सुरक्षित है क्योंकि कुछ अन्य कोड window.undefined साथ छेड़छाड़ कर window.undefined ।

उदाहरण:

undefined लौटना:

function foo(){
    return void 0;
}
console.log(foo()); // undefined

एक निश्चित दायरे के अंदर undefined के मूल्य को बदलना:

(function(undefined){
    var str = 'foo';
    console.log(str === undefined); // true
})('foo');

एकतरफा नकार ऑपरेटर (-)

यूरी नेगेशन ( - ) इसके ऑपरेंड से पहले होता है और इसे नंबर में बदलने की कोशिश के बाद इसे नकार दिया जाता है।

वाक्य - विन्यास:

-expression

यह दिखाता है:

• एक Number ।

विवरण

एकात्मक नकार ( - ) समान प्रकार / मानों को रूपांतरित कर सकता है जैसा कि यूनियरी प्लस ( + ) ऑपरेटर कर सकता है।

-NaN मूल्यों को परिवर्तित नहीं किया जा सकता है, वे NaN मूल्यांकन करेंगे (कोई -NaN नहीं है)।

उदाहरण:

-42           // -42
-"42"         // -42
-true         // -1
-false        // -0
-null         // -0
-undefined    // NaN
-NaN          // NaN
-"foo"        // NaN
-{}           // NaN
-function(){} // NaN

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

[].toString() === '';
[1].toString() === '1';
[1, 2].toString() === '1,2';

ऑपरेटर फिर उन तारों को संख्याओं में बदलने का प्रयास करता है:

-[]           // -0  ( === -'' )
-[1]          // -1  ( === -'1' )
-[1, 2]       // NaN ( === -'1,2' )

बिटवाइज़ ऑपरेटर नहीं (~)

बिटवाइज़ NOT ( ~ ) प्रत्येक बिट पर एक मान में एक ऑपरेशन नहीं करता है।

वाक्य - विन्यास:

~expression

यह दिखाता है:

• एक Number ।

विवरण

NOT ऑपरेशन की सत्य तालिका है:

1337  (base 10) = 0000010100111001 (base 2)
~1337 (base 10) = 1111101011000110 (base 2) = -1338 (base 10)

एक बिटवाइज़ एक नंबर रिजल्ट में नहीं: -(x + 1) ।

उदाहरण:

तार्किक नहीं ऑपरेटर ()

लॉजिकल नॉट ( ! ) ऑपरेटर एक एक्सप्रेशन पर तार्किक निषेध करता है।

वाक्य - विन्यास:

!expression

यह दिखाता है:

• एक Boolean ।

विवरण

लॉजिकल नॉट ( ! ) ऑपरेटर एक एक्सप्रेशन पर तार्किक निषेध करता है।

बूलियन मूल्य बस उल्टा हो जाता है: !true === false और !false === true ।
गैर-बूलियन मूल्य पहले बूलियन मूल्यों में परिवर्तित हो जाते हैं, फिर नकारात्मक होते हैं।

इसका मतलब यह है कि एक बूलियन के लिए किसी भी मूल्य को डालने के लिए एक डबल लॉजिकल नॉट ( !! ) का उपयोग किया जा सकता है:

!!"FooBar" === true
!!1 === true
!!0 === false

ये सभी !true बराबर हैं:

!'true' === !new Boolean('true');
!'false' === !new Boolean('false');
!'FooBar' === !new Boolean('FooBar');
![] === !new Boolean([]);
!{} === !new Boolean({});

ये सब !false बराबर हैं:

!0 === !new Boolean(0);
!'' === !new Boolean('');
!NaN === !new Boolean(NaN);
!null === !new Boolean(null);
!undefined === !new Boolean(undefined);

उदाहरण:

!true         // false
!-1           // false
!"-1"         // false
!42           // false
!"42"         // false
!"foo"        // false
!"true"       // false
!"false"      // false
!{}           // false
![]           // false
!function(){} // false

!false        // true
!null         // true
!undefined    // true
!NaN          // true
!0            // true
!""           // true

अवलोकन

यूनिरी संचालक केवल एक ऑपरेंड वाले ऑपरेटर हैं। मानक जावास्क्रिप्ट फ़ंक्शन कॉल की तुलना में यूनिरी ऑपरेटर्स अधिक कुशल हैं। इसके अतिरिक्त, यूनीरी ऑपरेटरों को ओवरराइड नहीं किया जा सकता है और इसलिए उनकी कार्यक्षमता की गारंटी है।

निम्नलिखित यूनिरी ऑपरेटर उपलब्ध हैं: