म्यूटेटर विधि

कंप्यूटर विज्ञान में, म्यूटेटर विधि एक वेरिएबल (चर) में परिवर्तन को नियंत्रित करने के लिए उपयोग की जाने वाली विधि है। जिसे व्यापक रूप से सेटर विधि के रूप में भी जाना जाता है। प्रायः एक सेटर फ़ाइल के साथ एक गेटर फ़ाइल होती है जिसको एक साथ 'एक्सेसर फ़ाइल' के रूप में भी जाना जाता है जो निजी वेरिएबल के मान को वापस करती है।

केप्सूलीकरण के सिद्धांत को ध्यान में रखते हुए, म्यूटेटर विधि का उपयोग प्रायः वस्तु-उन्मुख प्रोग्रामिंग (ओओपीएस) में किया जाता है। इस सिद्धांत के अनुसार, एक वर्ग के वेरिएबल (प्रोग्रामिंग) को गुप्त कोड और उन्हें अन्य कोड से सुरक्षित करने के लिए निजी बनाया जाता है और इसे केवल एक सार्वजनिक म्यूटेटर विधि द्वारा संशोधित किया जा सकता है जो पैरामीटर के रूप में वांछित नए मान को वैकल्पिक रूप से स्वीकृत करता है और निजी वेरिएबल को संशोधित करता है। म्यूटेटर विधियों की तुलना असाइनमेंट ऑपरेटर ओवरलोडिंग से की जा सकती है लेकिन वे सामान्यतः वस्तु पदानुक्रम के विभिन्न स्तरों पर प्रदर्शित होते हैं।

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

प्रोग्रामिंग भाषाओं में जो उनका समर्थन करते हैं और उपयुक्त केप्सूलीकरण प्रोग्रामिंग की उपयोगिता के अतिरिक्त एक सुविधाजनक विकल्प प्रदान करते हैं। नीचे दिए गए उदाहरणों में, किसी घटना को स्थगित करने के लिए पूर्ण रूप से कार्यान्वित म्यूटेटर विधि भी इनपुट डेटा को स्वीकृत कर सकती है।

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

वह ब्लॉक (प्रोग्रामिंग) जहां म्यूटेटर को परिभाषित किया गया है वह आने वाले सभी डेटा के सत्यापन या प्रीप्रोसेसिंग का अवसर प्रदान करता है। यदि सभी एक्सेस को म्यूटेटर के माध्यम से आने के लिए प्रीप्रोसेसिंग की जाती है तो इन वेरिएबलों को अस्वीकृत नहीं किया जा सकता है। उदाहरण के लिए, यदि किसी दिनांक को अलग-अलग निजी,   और   के वेरिएबल द्वारा दर्शाया जाता है, तो आने वाली तिथियों को   म्यूटेटर द्वारा विभाजित किया जा सकता है, जबकि निरंतरता के लिए समान निजी उदाहरण वेरिएबल को   और   द्वारा एक्सेस किया जाता है। सभी स्थितियों में 1 - 12 के बाहर के महीने के मानों को उसी कोड द्वारा अस्वीकृत किया जा सकता है। एक्सेसर इसके विपरीत आंतरिक वेरिएबल से उपयोगी डेटा के माध्यम से मान्यीकरण की स्वीकृति देते हैं जबकि उनकी संरचना को बाहरी मॉड्यूल से अलग और गुप्त रखते हैं। एक आर्थिक   एक्सेसर एक निश्चित   पैरामीटर द्वारा परिभाषित दशमलव स्थानों की संख्या के साथ एक संख्यात्मक वेरिएबल से एक स्ट्रिंग बना सकता है।

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

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

इसमें सम्मिलित अतिरिक्त वेरिएबल के कारण डेटा को प्रत्यक्ष रूप से लाने या संग्रहीत करने की तुलना में एक्सेसर कारक कम सक्षम हो सकते हैं हालाँकि ऐसे कार्य प्रायः समरेखीय होते हैं जो के ओवरहेड को समाप्त कर देते हैं।

असेंबली (प्रोग्रामिंग भाषा)
student                  struct age        dd        ? student                  end   .code student_get_age      proc      object:DWORD mov      ebx, object mov      eax, student.age[ebx] ret student_get_age      endp student_set_age      proc      object:DWORD, age:DWORD mov      ebx, object mov      eax, age mov      student.age[ebx], eax ret student_set_age      endp

सी (प्रोग्रामिंग भाषा)
फ़ाइल struct student; /* opaque structure */ typedef struct student student; student *student_new(int age, char *name); void student_delete(student *s); void student_set_age(student *s, int age); int student_get_age(student *s); char *student_get_name(student *s); फ़ाइल struct student { int age; char *name; }; student *student_new(int age, char *name) { student *s = malloc(sizeof(student)); s->name = strdup(name); s->age = age; return s; } void student_delete(student *s) { free(s->name); free(s); } void student_set_age(student *s, int age) { s->age = age; } int student_get_age(student *s) { return s->age; } char *student_get_name(student *s) { return s->name; } #include  int main(void) { student *s = student_new(19, "Maurice"); char *name = student_get_name(s); int old_age = student_get_age(s); printf("%s's old age = %i\n", name, old_age); student_set_age(s, 21); int new_age = student_get_age(s); printf("%s's new age = %i\n", name, new_age); student_delete(s); return 0; } फ़ाइल all: out.txt; cat $< out.txt: main; ./$< > $@ main: main.o student.o main.o student.o: student.h clean: ;$(RM) *.o out.txt main
 * 1) ifndef _STUDENT_H
 * 2) define _STUDENT_H
 * 1) endif
 * 1) include 
 * 2) include 
 * 3) include "student.h"
 * 1) include "student.h"

सी ++ (प्रोग्रामिंग भाषा)
फ़ाइल class Student { public: Student(const std::string& name); const std::string& name const; void name(const std::string& name); private: std::string name_; }; फ़ाइल Student::Student(const std::string& name) : name_(name) { } const std::string& Student::name const { return name_; } void Student::name(const std::string& name) { name_ = name; }
 * 1) ifndef STUDENT_H
 * 2) define STUDENT_H
 * 1) include
 * 1) endif
 * 1) include "Student.h"

सी# (प्रोग्रामिंग भाषा)
यह उदाहरण प्रोग्रामिंग भाषा सी # के विचार को प्रदर्शित करता है, जो एक विशेष प्रकार के वर्ग सदस्य हैं। जावा के विपरीत कोई स्पष्ट तरीके इसमे परिभाषित नहीं हैं एक सार्वजनिक 'एल्गोरिथम' में क्रियाओं को हल के लिए तर्क होता है। निम्न निर्धारित वेरिएबल  के उपयोग पर ध्यान दें। public class Student {    private string name; ///     /// Gets or sets student's name ///     public string Name {        get { return name; } set { name = value; } } } बाद के C# संस्करणों (.NET फ्रेमवर्क 3.5 और ऊपर) में, निजी वेरिएबल को निर्धारित किए बिना, इस उदाहरण को संक्षिप्त रूप में निम्नानुसार किया जा सकता है।

public class Student {    public string Name { get; set; } } संक्षिप्त 'एल्गोरिथम' का उपयोग करने का अर्थ यह है कि अंतर्निहित वेरिएबल अब कक्ष के अंदर से उपलब्ध नहीं है। जिसके परिणाम स्वरूप, एल्गोरिथम का  भाग असाइनमेंट के लिए सम्मिलित होता है। एक्सेस को  विशिष्ट एक्सेस संशोधक के साथ निर्धारित किया जा सकता है।

public class Student {    public string Name { get; private set; } }

सामान्य लिस्प
सामान्य लिस्प ऑब्जेक्ट सिस्टम में, कक्ष परिभाषाओं के भीतर निर्धारित विनिर्देशन इनमें से किसी को भी निर्दिष्ट कर सकते हैं,   और   टेक्स्ट विधियों, सेटर विधियों और एक्सेसर विधियों (एक   विधि और संबंधित   प्रकार) के उपयोग के साथ   उनके नाम के माध्यम से प्रत्यक्ष रूप से योग्य होते हैं   और   और स्लॉट एक्सेसर विकल्प उपयोग करने वाली विशेष  विधियों को परिभाषित करते हैं.

सीएलओएस के पास गुणों की कोई धारणा नहीं होती है, हालांकि मेटाऑब्जेक्ट प्रोटोकॉल एक्सटेंशन निर्दिष्ट करता है कि स्लॉट के और   फ़ंक्शन नामों तक अभिगमन का अर्थ   विकल्प से उत्पन्न होता है। निम्न उदाहरण इन   विकल्पों और   एक्सेस का उपयोग करके छात्र वर्ग की परिभाषा को प्रदर्शित करते है: (defclass student   ((name      :initarg :name      :initform "" :accessor student-name) ; student-name is setf'able (birthdate :initarg :birthdate :initform 0 :reader student-birthdate) (number   :initarg :number    :initform 0  :reader student-number :writer set-student-number))) ;; Example of a calculated property getter (this is simply a method) (defmethod student-age ((self student))  (- (get-universal-time) (student-birthdate self))) ;; Example of direct slot access within a calculated property setter (defmethod (setf student-age) (new-age (self student))  (with-slots (birthdate) self (setf birthdate (- (get-universal-time) new-age)) new-age)) ;; The slot accessing options generate methods, thus allowing further method definitions (defmethod set-student-number :before (new-number (self student))  ;; You could also check if a student with the new-number already exists.   (check-type new-number (integer 1 *)))

डी (प्रोग्रामिंग भाषा)
डी (प्रोग्रामिंग भाषा)  और   फ़ंक्शन सिंटैक्स का समर्थन करती है। भाषा गेटर और सेटर वर्ग/संरचना विधियों के संस्करण 2 में   विशेषता होनी चाहिए। class Student { private char[] name_; // Getter @property char[] name { return this.name_; }    // Setter @property char[] name(char[] name_in) { return this.name_ = name_in; } } उदाहरण: एक  का इस तरह उपयोग किया जा सकता है: auto student = new Student; student.name = "David";          // same effect as student.name("David") auto student_name = student.name; // same effect as student.name

डेल्फी (प्रोग्रामिंग भाषा)
यह डेल्फी भाषा में एक साधारण वर्ग है जो एक निजी क्षेत्र तक अभिगमन के लिए सार्वजनिक  की अवधारणा को प्रदर्शित करता है। interface type TStudent = class strict private FName: string; procedure SetName(const Value: string); public ///     /// Get or set the name of the student. ///     property Name: string read FName write SetName; end; // ... implementation procedure TStudent.SetName(const Value: string); begin FName := Value; end; end.

जावा
एक छात्र का प्रतिनिधित्व करने वाले एक साधारण वर्ग के इस उदाहरण में केवल संग्रहीत नाम के साथ कोई भी देख सकता है कि वेरिएबल नाम निजी है, अर्थात केवल छात्र वर्ग से दिखाई देता है जिसमे "सेटर" और "गेटर" अर्थात् " और " " विधियां सार्वजनिक हैं।  public class Student {     private String name;     public String getName {         return name;     }     public void setName(String newName) {         name = newName;     } }

जावास्क्रिप्ट
इस उदाहरण में  का उपयोग केवल संग्रहीत नाम वाले छात्र का प्रतिनिधित्व करने वाली वस्तुओं को बनाने के लिए किया जाता है। function Student(name) { var _name = name; this.getName = function { return _name; };  this.setName = function(value) { _name = value; }; } वेब ब्राउज़र में एक्सेसर्स को परिभाषित करने के लिए बहिष्कृत तरीके का उपयोग करना: function Student(name) {   var _name = name; this.__defineGetter__('name', function {        return _name;     }); this.__defineSetter__('name', function(value) {        _name = value;     }); } और इन्हेरिटन्स-एक्सेसर विधि के लिए प्रोटोटाइप का उपयोग: function Student(name){ this._name = name; } Student.prototype = { get name { return this._name; },    set name(value) { this._name = value; } या (प्रोटोटाइप के उपयोग के अतिरिक्त) var Student = { get name { return this._name; },    set name(value) { this._name = value; } }; या  का उपयोग करके: function Student(name){ this._name = name; } Object.defineProperty(Student.prototype, 'name', {    get: function {         return this._name;     },     set: function(value) {         this._name = value;     } });

एक्शनस्क्रिप्ट 3.0
package {    public class Student {        private var _name : String; public function get name : String {             return _name; }        public function set name(value : String) : void {            _name = value; }    } }

ऑब्जेक्ट-सी प्रोग्रामिंग
पर   कार्य करने वाले के रूप में मैनुअल   गणना के साथ पारंपरिक ऑब्जेक्टिव-सी प्रोग्रामिंग 1.0 सिंटैक्स का उपयोग करना: @interface Student : NSObject {    NSString *_name; } - (NSString *)name; - (void)setName:(NSString *)name; @end @implementation Student - (NSString *)name {    return _name; } - (void)setName:(NSString *)name {    [_name release]; _name = [name retain]; } @end मैक ओएस एक्स 10.6, आईओएस 4 और एक्सकोड 3.2 में उपयोग किए गए नए ऑब्जेक्टिव-सी 2.0 सिंटैक्स का उपयोग करते हुए, ऊपर बताए गए कोड के अनुसार समान कोड निर्मित करना: @interface Student : NSObject @property (nonatomic, retain) NSString *name; @end @implementation Student @synthesize name = _name; @end और ओएस एक्स 10.8 और आईओएस 6 से प्रारम्भ करते हुए,  और इससे ऊपर के कोड का उपयोग करते हुए, सिंटैक्स को और भी सरल बनाया जा सकता है: @interface Student : NSObject @property (nonatomic, strong) NSString *name; @end @implementation Student //Nothing goes here and it's OK. @end

पर्ल
package Student; sub new { bless {}, shift; } sub set_name { my $self = shift; $self->{name} = $_[0]; } sub get_name { my $self = shift; return $self->{name}; } 1; या   का उपयोग करना: package Student; use base qw(Class::Accessor); __PACKAGE__->follow_best_practice; Student->mk_accessors(qw(name)); 1; या पर्ल ऑब्जेक्ट सिस्टम का उपयोग करना: package Student; use Moose; has 'name' => (is => 'rw', isa => 'Str', reader => 'get_name', writer => 'set_name'); 1;
 * 1) Moose uses the attribute name as the setter and getter, the reader and writer properties
 * 2) allow us to override that and provide our own names, in this case get_name and set_name

पीएचपी
पीएचपी वस्तुओं के गुणों के लिए "मैजिक विधि" और  को परिभाषित करती है।

एक छात्र का प्रतिनिधित्व करने वाले एक साधारण वर्ग के इस उदाहरण में केवल संग्रहीत नाम के साथ यह कोई देख सकता है कि वेरिएबल नाम निजी है, अर्थात केवल यह छात्र वर्ग से दिखाई देता है "सेटर" और "गेटर" अर्थात्  और   विधियां सार्वजनिक है।

class Student {    private string $name; /**     * @return string The name. */    public function getName: string {        return $this->name; }    /**      * @param string $newName The name to set. */    public function setName(string $newName): void {        $this->name = $newName; } }

पायथन
यह उदाहरण एक वेरिएबल, एक गेटर और एक सेटर के साथ एक पायथन वर्ग का उपयोग करता है। class Student: # Initializer def __init__(self, name: str) -> None: # An instance variable to hold the student's name self._name = name # Getter method @property def name(self): return self._name # Setter method @name.setter def name(self, new_name): self._name = new_name

>>> bob = Student("Bob") >>> bob.name Bob >>> bob.name = "Alice" >>> bob.name Alice >>> bob._name = "Charlie" # bypass the setter >>> bob._name # bypass the getter Charlie

रैकेट (प्रोग्रामिंग भाषा)
रैकेट (प्रोग्रामिंग भाषा) में, ऑब्जेक्ट सिस्टम कोड को व्यवस्थित करने का एक तरीका है जो मॉड्यूल और यूनिट के अतिरिक्त होता है। अन्य भाषाओ की तरह, ऑब्जेक्ट सिस्टम में प्रथम श्रेणी के मान हैं वस्तुओं और विधियों तक एक्सेस को नियंत्रित करने के लिए लेक्सिकल-स्कोप का उपयोग किया जाता है। (define student%  (class object% (init-field name) (define/public (get-name) name) (define/public (set-name! new-name) (set! name new-name)) (super-new))) (define s (new student% [name "Alice"])) (send s get-name)                      ; => "Alice" (send s set-name! "Bob") (send s get-name)                      ; => "Bob" स्पष्ट रूप से आवश्यक होने पर म्यूटेटर के साथ नए प्रकार के मानों को परिभाषित करने के लिए संरचनात्मक परिभाषाओ का यह एक वैकल्पिक तरीका है: (struct student (name) #:mutable) (define s (student "Alice")) (set-student-name! s "Bob") (student-name s)                       ; => "Bob"
 * 1) lang racket
 * 1) lang racket

रुबी (प्रोग्रामिंग भाषा)
रुबी में, अलग-अलग एक्सेसर और म्यूटेटर विधियों को परिभाषित किया जा सकता है या मेटाप्रोग्रामिंग  या  दोनों का उपयोग कक्ष में एक निजी वेरिएबल घोषित करने के लिए किया जा सकता है और क्रमशः पढ़ने-योग्य या पढ़ने-लिखने के लिए सार्वजनिक सुविधा प्रदान करने के लिए किया जा सकता है। class Student def name @name end def name=(value) @name=value end end निहित  वेरिएबल   के लिए सरल सार्वजनिक एक्सेसर विधि: class Student attr_reader :name end निहित  वेरिएबल   के लिए सरल सार्वजनिक एक्सेसर विधि: class Student attr_accessor :name end

रस्ट प्रोग्रामिंग
struct Student { name: String, } impl Student { fn name(&self) -> &String { &self.name }    fn set_name(&mut self, name: String) { self.name = name } }

स्मालटॉक प्रोग्रामिंग
age: aNumber " Set the receiver age to be aNumber if is greater than 0 and less than 150 " (aNumber between: 0 and: 150) ifTrue: [ age := aNumber ]

स्विफ्ट प्रोग्रामिंग
class Student { private var _name: String = "" var name: String { get { return self._name }        set { self._name = newValue }    } }

विजुअल बेसिक डाटनेट
यह उदाहरण कक्षाओं में उपयोग किए जाने वाले गुणों के वीबी डाटनेट विचार को प्रदर्शित करता है। जहां सी # के समान  और   विधियों का स्पष्ट उपयोग होता है। Public Class Student Private _name As String Public Property Name Get Return _name End Get Set(ByVal value) _name = value End Set End Property End Class वीबी डाटनेट 2010 कार्यान्वित एल्गोरिथम का उपयोग  और   सिंटैक्स का उपयोग किए बिना एक एल्गोरिथम बनाने के लिए किया जा सकता है। ध्यान दें कि यह एल्गोरिथम के नाम के अनुरूप होने के लिए कंपाइलर द्वारा एक गुप्त वेरिएबल बनाया जाता है जिसे   कहा जाता है।   वेरिएबल की कक्षा के भीतर एक अन्य वेरिएबल का उपयोग करने से त्रुटि होती है। अंतर्निहित वेरिएबल के लिए विशेषाधिकार प्राप्त एक्सेसर  के भीतर से उपलब्ध होते है। Public Class Student Public Property name As String End Class

यह भी देखें

 * प्रोपर्टी प्रोग्रामिंग
 * इंडेक्सर प्रोग्रामिंग
 * अपरिवर्तनीय वस्तु-उन्मुख कोड