जवाबों:
कंप्यूटिंग में, एक आदर्श ऑपरेशन वह है जिसका कोई अतिरिक्त प्रभाव नहीं पड़ता है यदि इसे एक ही इनपुट मापदंडों के साथ एक से अधिक बार कहा जाता है। उदाहरण के लिए, सेट से किसी आइटम को हटाने पर सेट पर एक सुखद संचालन माना जा सकता है।
गणित में, एक निष्क्रिय ऑपरेशन वह होता है जहाँ f (f (x)) = f (x) होता है । उदाहरण के लिए, abs()
फ़ंक्शन सर्वव्यापी है क्योंकि abs(abs(x)) = abs(x)
सभी के लिए x
।
गणितीय परिभाषा में उस x को किसी वस्तु की स्थिति का प्रतिनिधित्व करने पर विचार करके इन थोड़ी भिन्न परिभाषाओं को समेटा जा सकता है , और f एक ऑपरेशन है जो उस वस्तु को उत्परिवर्तित कर सकता है। उदाहरण के लिए, पायथनset
और इसकी discard
विधि पर विचार करें । discard
विधि एक सेट से एक तत्व निकाल देता है, और अगर तत्व मौजूद नहीं है कुछ नहीं करता है। इसलिए:
my_set.discard(x)
दो बार एक ही ऑपरेशन करने के समान प्रभाव है:
my_set.discard(x)
my_set.discard(x)
बेरोजगार संचालन अक्सर नेटवर्क प्रोटोकॉल के डिजाइन में उपयोग किया जाता है, जहां ऑपरेशन करने का अनुरोध कम से कम एक बार होने की गारंटी है, लेकिन एक से अधिक बार भी हो सकता है। यदि ऑपरेशन बेकार है, तो ऑपरेशन को दो या अधिक बार करने में कोई बुराई नहीं है।
पर विकिपीडिया लेख देखें idempotence अधिक जानकारी के लिए।
उपरोक्त उत्तर में पहले कुछ गलत और भ्रामक उदाहरण थे। अप्रैल 2014 से पहले लिखी गई टिप्पणियाँ एक पुराने संशोधन का उल्लेख करती हैं।
set
जवाब में पायथन उदाहरण में, सेट ऑब्जेक्ट में स्पष्ट रूप से राज्य है और कुछ सुखद संचालन जैसे कि प्रदान करता है discard
।
discard
रिटर्न वैल्यू में राज्य को शामिल करके एक स्टेटलेस तरीके से लागू किया जा सकता है discard([my_set, x]) = [my_new_set, x]
:। तो आप कर सकते हैं discard(discard([my_set, x]))
। ध्यान दें कि [my_new_set, x]
है सिर्फ एक तर्क और उसके प्रकार 2-टपल है।
discard(x)
सेट नहीं रह में शामिल होंगे: दूसरी बार यह बुला पहली बार के रूप में ही प्रभाव पड़ेगा x
। कम्प्यूटिंग इम्पोटेंस एक सिस्टम की मजबूती के बारे में है। चूंकि चीजें विफल हो सकती हैं (उदाहरण के लिए नेटवर्क आउटेज), जब विफलता का पता चलता है, तो आप कैसे ठीक होते हैं? सबसे आसान रिकवरी सिर्फ इसे फिर से करना है, लेकिन यह केवल तभी काम करता है जब इसे फिर से किया जाए। उदाहरण के discard(x)
लिए उदासीन है, लेकिन pop()
नहीं है। यह त्रुटि पुनर्प्राप्ति के बारे में है।
एक मनमाने ढंग से किए जाने वाले ऑपरेशन को कई बार दोहराया जा सकता है और इसका परिणाम वही होगा जैसा कि एक बार किया गया था। अंकगणित में, शून्य को एक संख्या में जोड़ना बेमानी है।
"रेस्टफुल" वेब सेवाओं के संदर्भ में इम्पोटोटेंस की बहुत चर्चा की जाती है। REST कार्यक्रमों को वेब सामग्री तक पहुँच देने के लिए HTTP का अधिकतम लाभ उठाने का प्रयास करता है, और आमतौर पर SOAP- आधारित वेब सेवाओं के विपरीत सेट किया जाता है, जो HTTP अनुरोधों और प्रतिक्रियाओं के अंदर टनल रिमोट प्रक्रिया कॉल शैली सेवाओं को कहते हैं।
REST एक वेब एप्लिकेशन को "संसाधनों" (जैसे ट्विटर उपयोगकर्ता, या फ़्लिकर छवि) में व्यवस्थित करता है और फिर उन संसाधनों को बनाने, अपडेट करने, पढ़ने और हटाने के लिए POST, PUT, GET और DELETE की HTTP क्रियाओं का उपयोग करता है।
REST में Idempotence एक महत्वपूर्ण भूमिका निभाता है। यदि आप REST संसाधन का प्रतिनिधित्व करते हैं (जैसे, फ़्लिकर से एक JPEG छवि), और ऑपरेशन विफल रहता है, तो आप बस GET को फिर से और फिर से दोहरा सकते हैं जब तक कि ऑपरेशन सफल नहीं हो जाता। वेब सेवा के लिए, इससे कोई फर्क नहीं पड़ता कि छवि कितनी बार प्राप्त हुई है। इसी तरह, यदि आप अपने ट्विटर खाते की जानकारी को अपडेट करने के लिए एक RESTful वेब सेवा का उपयोग करते हैं, तो आप वेब सेवा से पुष्टिकरण प्राप्त करने के लिए नई जानकारी को जितनी बार चाहें ले सकते हैं। PUT-ing इसे एक हजार बार PUT-ing के रूप में एक ही बार है। इसी तरह एक हजार बार DELETE-ing एक बार इसे हटाने के समान है। इस प्रकार, बेरोजगारी एक वेब सेवा का निर्माण करना आसान बनाती है जो संचार त्रुटियों के लिए लचीला है।
आगे पढ़े: रिचर्डसन और रूबी द्वारा रिस्टफुल वेब सर्विसेज (पेज 103-104 पर चर्चा की गई है), और रेस्ट पर रॉय फील्डिंग की पीएचडी शोध प्रबंध । फ़ील्डिंग HTTP 1.1, RFC-2616 के लेखकों में से एक था, जो कि 9.1.2 सेक्शन में आलस्य के बारे में बात करता है ।
आप चाहे जितनी बार भी ऑपरेशन कहें, परिणाम वही होगा।
truncate
और delete
।
Idempotence का मतलब है कि एक ऑपरेशन को एक बार लागू करना या इसे कई बार लागू करना एक ही प्रभाव है।
उदाहरण:
के लिए शुद्ध कार्यों (कोई साइड इफेक्ट के साथ काम करता है) तो idempotency कि f (x) = f (f (x)) = च (च (f (x))) = च (च (च (f (x))) का अर्थ है ) = ...... x के सभी मूल्यों के लिए
साइड इफेक्ट्स वाले कार्यों के लिए , बेरोजगारी का अर्थ है कि पहले आवेदन के बाद कोई अतिरिक्त दुष्प्रभाव नहीं होगा। यदि आप चाहें, तो आप फ़ंक्शन के लिए अतिरिक्त "छिपी" पैरामीटर के लिए दुनिया की स्थिति पर विचार कर सकते हैं।
ध्यान दें कि जिस दुनिया में आपके पास समवर्ती क्रियाएं चल रही हैं, आप पा सकते हैं कि जिन ऑपरेशनों के बारे में आपने सोचा था, वे ऐसा करने के लिए बेकार थे, उदाहरण के लिए, एक और धागा ऊपर के उदाहरण में बूलियन ध्वज के मूल्य को परेशान कर सकता है)। मूल रूप से जब भी आपके पास समवर्ती और परिवर्तनशील स्थिति होती है, तो आपको बहुत अधिक सावधानी से सोचने की आवश्यकता होती है।
मजबूत व्यवस्थाओं के निर्माण में प्रायः बेरोजगारी एक उपयोगी संपत्ति है। उदाहरण के लिए, यदि कोई जोखिम है कि आप किसी तीसरे पक्ष से एक डुप्लिकेट संदेश प्राप्त कर सकते हैं, तो संदेश हैंडलर को एक निष्क्रिय ऑपरेशन के रूप में कार्य करने में मदद मिलती है ताकि संदेश प्रभाव केवल एक बार ही हो।
f(x) = f(f(x))
, तो क्या आपका मतलब f(x){return x+1;}
शुद्ध कार्य नहीं है? क्योंकि f(x) != f(f(x))
: f(1)
2 देता है जबकि f(2)
3 देता है
f(x) = f(f(x))
। लेकिन जैसा कि @GregHewgill ने उल्लेख किया है, इस परिभाषा के अर्थ में, आपको x
एक वस्तु के f
रूप में और एक ऑपरेशन के रूप में विचार करना होगा जो वस्तु की स्थिति को उत्परिवर्तित करता है (यानी: आउटपुट f
एक उत्परिवर्तित होता है x
)।
एक निष्क्रिय ऑपरेशन उसी राज्य में परिणाम उत्पन्न करता है, भले ही आप इसे एक से अधिक बार कॉल करें, बशर्ते आप एक ही पैरामीटर में पास हों।
बस एक वास्तविक उपयोग के मामले को बाहर फेंकना चाहता था जो कि बेरोजगारी को प्रदर्शित करता है। जावास्क्रिप्ट में, आप मॉडल कक्षाओं के एक समूह (एमवीसी मॉडल के रूप में) को परिभाषित कर रहे हैं। जिस तरह से इसे अक्सर लागू किया जाता है वह कार्यात्मक रूप से कुछ इस तरह से (मूल उदाहरण) के बराबर है:
function model(name) {
function Model() {
this.name = name;
}
return Model;
}
फिर आप इस तरह नई कक्षाओं को परिभाषित कर सकते हैं:
var User = model('user');
var Article = model('article');
लेकिन यदि आप कोड में कहीं और से User
कक्षा को प्राप्त करने का प्रयास करते हैं model('user')
, तो यह विफल हो जाएगा:
var User = model('user');
// ... then somewhere else in the code (in a different scope)
var User = model('user');
वे दो User
कंस्ट्रक्टर अलग होंगे। अर्थात्,
model('user') !== model('user');
इसे निष्प्रभावी बनाने के लिए , आप बस किसी प्रकार का कैशिंग तंत्र जोड़ेंगे, जैसे:
var collection = {};
function model(name) {
if (collection[name])
return collection[name];
function Model() {
this.name = name;
}
collection[name] = Model;
return Model;
}
कैशिंग को जोड़कर, हर बार जब आप model('user')
करते हैं, तो यह एक ही वस्तु होगी, और इसलिए यह बेकार है। इसलिए:
model('user') === model('user');
एक इम्पोटेंट ऑपरेशन एक ऑपरेशन, एक्शन, या रिक्वेस्ट है, जिसे रिजल्ट में बदलाव किए बिना कई बार लागू किया जा सकता है, यानी सिस्टम की स्थिति, प्रारंभिक एप्लिकेशन से परे।
परीक्षा (वेब एप्लिकेशन संपर्क):
IDEMPOTENT: कई समान अनुरोध करना एकल अनुरोध करने के समान प्रभाव डालता है। एक ईमेल संदेश प्रणाली में एक संदेश खोला और डेटाबेस में "खोला" के रूप में चिह्नित किया गया है। संदेश को कई बार खोल सकते हैं लेकिन यह दोहराया कार्रवाई केवल उस संदेश को "खोले" स्थिति में होगी। यह एक इम्पोटेंट ऑपरेशन है। पहली बार एक संसाधन का अद्यतन करने के लिए एक संसाधन का अद्यतन करता है जो संसाधन (सिस्टम की स्थिति) से मेल नहीं खाता है, सिस्टम के अपडेट होने पर सिस्टम की स्थिति बदल जाएगी। यदि कोई बार-बार किसी संसाधन के लिए एक ही अपडेट करता है, तो अपडेट में जानकारी हर PUT पर सिस्टम में पहले से मौजूद जानकारी से मेल खाएगी, और सिस्टम की स्थिति में कोई परिवर्तन नहीं होगा। एक ही जानकारी के साथ बार-बार PUTs का होना लाजिमी है:
NON-IDEMPOTENT: यदि कोई ऑपरेशन हमेशा स्थिति में बदलाव का कारण बनता है, जैसे एक उपयोगकर्ता को एक ही संदेश को बार-बार पोस्ट करना, जिसके परिणामस्वरूप डेटाबेस में हर बार एक नया संदेश भेजा और संग्रहीत किया जाता है, तो हम कहते हैं कि ऑपरेशन NON-IDEMPOTENT है।
NULLIPOTENT: यदि किसी ऑपरेशन का कोई साइड इफेक्ट नहीं है, जैसे किसी डेटाबेस में किसी भी बदलाव के बिना वेब पेज पर पूरी तरह से जानकारी प्रदर्शित करना (दूसरे शब्दों में आप केवल डेटाबेस पढ़ रहे हैं), तो हम कहते हैं कि ऑपरेशन NULLIPOTENT है। सभी GETs अशक्त होना चाहिए।
जब सिस्टम की स्थिति के बारे में बात कर रहे हैं, तो हम स्पष्ट रूप से लॉगिंग और डायग्नोस्टिक्स जैसे उम्मीद से हानिरहित और अपरिहार्य प्रभावों की अनदेखी कर रहे हैं।
निष्पादक संचालन: कई बार निष्पादित किए जाने वाले कार्यों का कोई दुष्प्रभाव नहीं होता है।
उदाहरण : एक ऑपरेशन जो डेटा संसाधन से मान प्राप्त करता है और कहता है, यह
गैर-निष्पादक संचालन को प्रिंट करता है
: संचालन जो कई बार निष्पादित होने पर कुछ नुकसान पहुंचाएगा। (जैसा कि वे कुछ मूल्यों या राज्यों को बदलते हैं)
उदाहरण: एक ऑपरेशन जो बैंक खाते से वापस लेता है
एक विस्तृत और तकनीकी जवाब। बस एक साधारण परिभाषा जोड़ रहा हूँ।
उदासीन = पुनः चलने योग्य
उदाहरण के लिए, Create
यदि एक से अधिक बार क्रियान्वित किया जाता है , तो
ऑपरेशन को बिना त्रुटि के चलाने की गारंटी नहीं है। लेकिन अगर कोई ऑपरेशन होता है, CreateOrUpdate
तो यह फिर से चलाने की क्षमता (Idempotency) बताता है।
एक सेट पर एक बेमिसाल ऑपरेशन एक या अधिक बार लागू होने पर अपने सदस्यों को अपरिवर्तित छोड़ देता है।
यह निरपेक्ष (एक्स) की तरह एक अपरिपक्व ऑपरेशन हो सकता है जहां x सकारात्मक पूर्णांकों के समूह से संबंधित है। यहाँ निरपेक्ष (निरपेक्ष (x)) = x
यह एक बाइनरी ऑपरेशन हो सकता है जैसे किसी सेट का यूनियन खुद के साथ हमेशा एक ही सेट लौटाएगा।
चियर्स
यह कोई भी ऑपरेशन है जो प्रत्येक एनटीटी परिणाम के परिणामस्वरूप 1 परिणाम के मूल्य से मेल खाता है। उदाहरण के लिए -1 का निरपेक्ष मान है। -1 के निरपेक्ष मान का निरपेक्ष मान है। 1. -1 के निरपेक्ष मान का निरपेक्ष मान 1. है। और इसी तरह।
यह भी देखें: पुनरावृत्ति का उपयोग करने के लिए वास्तव में मूर्खतापूर्ण समय कब होगा?
एक सुस्पष्ट संचालन को समझने का एक अच्छा उदाहरण रिमोट कुंजी के साथ एक कार को लॉक करना हो सकता है।
log(Car.state) // unlocked
Remote.lock();
log(Car.state) // locked
Remote.lock();
Remote.lock();
Remote.lock();
log(Car.state) // locked
lock
एक आदर्श ऑपरेशन है। यहां तक कि अगर आपके चलने पर हर बार कुछ साइड इफेक्ट होते हैं lock
, जैसे कि पलक झपकते ही, कार अभी भी उसी लॉक अवस्था में है, चाहे आप कितनी भी बार लॉक ऑपरेशन चला लें।
मेरा 5 सी: एकीकरण और नेटवर्किंग में बेरोजगारी बहुत महत्वपूर्ण है। वास्तविक जीवन से कई उदाहरण: कल्पना कीजिए, हम लक्ष्य प्रणाली के लिए डेटा वितरित करते हैं। संदेशों के अनुक्रम द्वारा दिया गया डेटा। 1. यदि चैनल में अनुक्रम मिलाया जाता है तो क्या होगा? (जैसा कि नेटवर्क पैकेज हमेशा करते हैं :))। यदि लक्ष्य प्रणाली बेकार है, तो परिणाम अलग नहीं होगा। यदि लक्ष्य प्रणाली अनुक्रम में सही क्रम पर निर्भर करती है, तो हमें लक्ष्य साइट पर रेज़पेंसेर को लागू करना होगा, जो सही क्रम को बहाल करेगा। 2. यदि संदेश डुप्लिकेट हैं तो क्या होगा? यदि लक्ष्य प्रणाली का चैनल समय पर स्वीकार नहीं करता है, तो स्रोत प्रणाली (या चैनल खुद) आमतौर पर संदेश की एक और प्रतिलिपि भेजता है। परिणामस्वरूप हम लक्ष्य प्रणाली की ओर डुप्लिकेट संदेश दे सकते हैं। यदि लक्ष्य प्रणाली उदासीन है, यह ध्यान रखता है और परिणाम अलग नहीं होगा। यदि टारगेट सिस्टम बेकार नहीं है, तो हमें चैनल के टारगेट सिस्टम साइड पर डुप्लीकेटर लागू करना होगा।
संक्षेप में , Idempotent ऑपरेशंस का अर्थ है कि ऑपरेशन अलग-अलग परिणामों में परिणाम नहीं देगा चाहे आप कितनी बार idempotent संचालन करें।
उदाहरण के लिए, HTTP की कल्पना की परिभाषा के अनुसार, GET, HEAD, PUT, and DELETE
बेरोजगार संचालन हैं; हालाँकि POST and PATCH
नहीं हैं। इसलिए कभी-कभी POST
इसकी जगह ले ली जाती है PUT
।
पुन: प्रयास करें-सुरक्षित।
आमतौर पर कंप्यूटर विज्ञान में इसके अर्थ को समझने का सबसे आसान तरीका है।
Idempotent operations are often used in the design of network protocols
यहां संबंधित उदाहरण ** GET को सर्वर पर कुछ भी बदलने के लिए नहीं माना गया है, इसलिए GET, बेकार है। HTTP / सर्वलेट के संदर्भ में, इसका मतलब है कि एक ही अनुरोध दो बार बिना किसी नकारात्मक परिणाम के किया जा सकता है। ** POST बेकार नहीं है।