म्यूटेटर विधि: Difference between revisions

From Vigyanwiki
No edit summary
No edit summary
Line 1: Line 1:
[[कंप्यूटर विज्ञान]] में, एक म्यूटेटर विधि एक चर में परिवर्तन को नियंत्रित करने के लिए उपयोग की जाने वाली [[विधि (कंप्यूटर विज्ञान)|विधि]] है। उन्हें व्यापक रूप से सेटर विधियों के रूप में भी जाना जाता है। अक्सर एक सेटर के साथ एक गेट्टर (एक साथ एक्सेसर्स के रूप में भी जाना जाता है) होता है, जो निजी [[सदस्य चर]] का मान लौटाता है।
[[कंप्यूटर विज्ञान]] में, एक '''म्यूटेटर विधि''' एक चर में परिवर्तन को नियंत्रित करने के लिए उपयोग की जाने वाली [[विधि (कंप्यूटर विज्ञान)|विधि]] है। उन्हें व्यापक रूप से सेटर विधियों के रूप में भी जाना जाता है। अक्सर एक सेटर के साथ एक गेट्टर (एक साथ एक्सेसर्स के रूप में भी जाना जाता है) होता है, जो निजी [[सदस्य चर]] का मान लौटाता है।


एनकैप्सुलेशन के सिद्धांत को ध्यान में रखते हुए, म्यूटेटर विधि का उपयोग अक्सर [[ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग]] में किया जाता है। इस सिद्धांत के अनुसार, एक वर्ग के सदस्य [[चर (प्रोग्रामिंग)]] को छिपाने और उन्हें अन्य कोड से बचाने के लिए निजी बनाया जाता है, और इसे केवल एक सार्वजनिक सदस्य फ़ंक्शन (म्यूटेटर विधि) द्वारा संशोधित किया जा सकता है, जो पैरामीटर के रूप में वांछित नया मान लेता है, वैकल्पिक रूप से मान्य करता है यह, और निजी सदस्य चर को संशोधित करता है। म्यूटेटर विधियों की तुलना असाइनमेंट [[ऑपरेटर ओवरलोडिंग]] से की जा सकती है लेकिन वे आम तौर पर ऑब्जेक्ट पदानुक्रम के विभिन्न स्तरों पर दिखाई देते हैं।
एनकैप्सुलेशन के सिद्धांत को ध्यान में रखते हुए, म्यूटेटर विधि का उपयोग अक्सर [[ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग]] में किया जाता है। इस सिद्धांत के अनुसार, एक वर्ग के सदस्य [[चर (प्रोग्रामिंग)]] को छिपाने और उन्हें अन्य कोड से बचाने के लिए निजी बनाया जाता है, और इसे केवल एक सार्वजनिक सदस्य फ़ंक्शन (म्यूटेटर विधि) द्वारा संशोधित किया जा सकता है, जो पैरामीटर के रूप में वांछित नया मान लेता है, वैकल्पिक रूप से मान्य करता है यह, और निजी सदस्य चर को संशोधित करता है। म्यूटेटर विधियों की तुलना असाइनमेंट [[ऑपरेटर ओवरलोडिंग]] से की जा सकती है लेकिन वे आम तौर पर ऑब्जेक्ट पदानुक्रम के विभिन्न स्तरों पर दिखाई देते हैं।
Line 25: Line 25:
}}</ref>
}}</ref>


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


इसमें शामिल अतिरिक्त चरणों के कारण डेटा फ़ील्ड को सीधे लाने या संग्रहीत करने की तुलना में एक्सेसर फ़ंक्शन कम कुशल हो सकते हैं,<ref>{{cite web
इसमें शामिल अतिरिक्त चरणों के कारण डेटा फ़ील्ड को सीधे लाने या संग्रहीत करने की तुलना में एक्सेसर फ़ंक्शन कम कुशल हो सकते हैं,<ref>{{cite web
Line 37: Line 37:


=== सभा ===
=== सभा ===
<वाक्यविन्यास प्रकाश लैंग = nasm>
student                  struct
छात्र संरचना
    age        dd        ?
    उम्र डीडी?
student                  end  .code
छात्र समाप्त
student_get_age      proc      object:DWORD
</वाक्यविन्यास हाइलाइट>
                      mov      ebx, object
<वाक्यविन्यास प्रकाश लैंग = nasm>
                      mov      eax, student.age[ebx]
                    कोड
                      ret
स्टूडेंट_गेट_एज प्रो ऑब्जेक्ट:DWORD
student_get_age      endp
                      मूव ईबीएक्स, ऑब्जेक्ट
                      मूव ईएक्स, स्टूडेंट.एज[ईबीएक्स]
student_set_age      proc      object:DWORD, age:DWORD
                      गीला करना
                      mov      ebx, object
स्टूडेंट_गेट_एज एंडप
                      mov      eax, age
 
                      mov      student.age[ebx], eax
स्टूडेंट_सेट_एज प्रो ऑब्जेक्ट: DWORD, आयु: DWORD
                      ret
                      मूव ईबीएक्स, ऑब्जेक्ट
student_set_age      endp
                      मूव ईएक्स, उम्र
                      मूव स्टूडेंट.एज [ईबीएक्स], ईएक्स
                      गीला करना
छात्र_सेट_आयु अंत
</वाक्यविन्यास हाइलाइट>


=== सी ===
=== सी ===
#ifndef _STUDENT_H
#define _STUDENT_H
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);
#endif


फ़ाइल छात्र में। एच:
#include <stdlib.h>
<वाक्यविन्यास लैंग = सी>
#include <string.h>
#ifndef _STUDENT_H
#include "student.h"
#STUDENT_H को परिभाषित करें
 
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);
<वाक्यविन्यास लैंग = सी>
}
#शामिल <stdlib.h>
#शामिल <string.h>
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;
  एस-> नाम = strdup (नाम);
}
  s->उम्र = आयु;
  #include <stdio.h>
  वापसी एस;
#include "student.h"
}
 
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);
शून्य छात्र_सेट_उम्र (छात्र *s, अंतर उम्र) {
  int new_age = student_get_age(s);
  s->उम्र = आयु;
  printf("%s's new age = %i\n", name, new_age);
}
  student_delete(s);
 
  return 0;
इंट स्टूडेंट_गेट_एज (स्टूडेंट * एस) {
}
  वापसी एस-> उम्र;
}
 
चार * छात्र_गेट_नाम (छात्र * एस) {
  वापसी एस-> नाम;
}
</वाक्यविन्यास हाइलाइट>
 
फ़ाइल main.c में:
<वाक्यविन्यास लैंग = सी>
#शामिल <stdio.h>
#छात्र शामिल करें


पूर्णांक मुख्य (शून्य) {
all: out.txt; cat $<
  छात्र *s = छात्र_नया (19, मौरिस);
out.txt: main; ./$< > $@
  चार * नाम = छात्र_नाम_नाम;
main: main.o student.o
  int old_age = छात्र_get_age(s);
main.o student.o: student.h
  प्रिंटफ (% s की वृद्धावस्था =% i \ n, नाम, Old_age);
clean: ;$(RM) *.o out.txt main
  छात्र_सेट_उम्र (एस, 21);
  int new_age = छात्र_प्राप्त_उम्र;
  प्रिंटफ (% s की नई आयु =% i \ n, नाम, new_age);
  छात्र_हटाएं;
  वापसी 0;
}
</वाक्यविन्यास हाइलाइट>
 
फ़ाइल मेकफ़ाइल में:
<वाक्यविन्यास लैंग = मेकफाइल>
सब: out.txt; बिल्ली $<
out.txt: मुख्य; ./$< > $@
मुख्य: main.o छात्र.o
main.o छात्र.o: छात्र.एच
साफ: ;$(RM) *.o out.txt main
</वाक्यविन्यास हाइलाइट>


=== सी ++ ===
=== सी ++ ===
फ़ाइल छात्र में। एच:
#ifndef STUDENT_H
<वाक्यविन्यास लैंग = सीपीपी>
#define STUDENT_H
#ifndef STUDENT_H
#छात्र_एच को परिभाषित करें
#include <string>
 
#शामिल <स्ट्रिंग>
class Student {
 
public:
कक्षा छात्र {
    Student(const std::string& name);
जनता:
    छात्र (स्थिरांक एसटीडी :: स्ट्रिंग और नाम);
    const std::string& name() const;
 
    void name(const std::string& name);
    स्थिरांक एसटीडी :: स्ट्रिंग और नाम () स्थिरांक;
    शून्य नाम (स्थिरांक एसटीडी :: स्ट्रिंग और नाम);
private:
 
    std::string name_;
निजी:
};
    एसटीडी :: स्ट्रिंग नाम_;
};
#endif
 
In file Student.cpp:
#अगर अंत
#include "Student.h"
</वाक्यविन्यास हाइलाइट>
फ़ाइल में छात्र.सीपीपी:
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;
}
}
 
शून्य छात्र :: नाम (स्थिरांक एसटीडी :: स्ट्रिंग और नाम) {
    नाम_ = नाम;
}
</वाक्यविन्यास हाइलाइट>


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


<वाक्यविन्यास प्रकाश लैंग = csharp>
बाद के C# संस्करणों (.NET फ्रेमवर्क 3.5 और ऊपर) में, निजी चर <code>name</code> घोषित किए बिना, इस उदाहरण को निम्नानुसार संक्षिप्त किया जा सकता है।
सार्वजनिक वर्ग छात्र
{
    निजी स्ट्रिंग नाम;


    /// <सारांश>
public class Student
    /// छात्र का नाम प्राप्त या सेट करता है
{
    /// </ सारांश>
    public string Name { get; set; }
    सार्वजनिक स्ट्रिंग नाम
}
    {
संक्षिप्त सिंटैक्स का उपयोग करने का अर्थ है कि अंतर्निहित चर अब कक्षा के अंदर से उपलब्ध नहीं है। नतीजतन, संपत्ति का <code>set</code> हिस्सा असाइनमेंट के लिए मौजूद होना चाहिए। एक्सेस को <code>set</code>-विशिष्ट एक्सेस संशोधक के साथ प्रतिबंधित किया जा सकता है।
        प्राप्त करें {वापसी का नाम; }
        सेट {नाम = मान; }
    }
}
</वाक्यविन्यास हाइलाइट>


बाद के C# संस्करणों (.NET फ्रेमवर्क 3.5 और ऊपर) में, निजी चर घोषित किए बिना, इस उदाहरण को संक्षिप्त रूप में निम्नानुसार किया जा सकता है <code>name</code>.
public class Student
 
{
<वाक्यविन्यास प्रकाश लैंग = csharp>
    public string Name { get; private set; }
सार्वजनिक वर्ग छात्र
}
{
    सार्वजनिक स्ट्रिंग नाम {प्राप्त करें; तय करना; }
}
</वाक्यविन्यास हाइलाइट>
 
संक्षिप्त सिंटैक्स का उपयोग करने का अर्थ है कि अंतर्निहित चर अब कक्षा के अंदर से उपलब्ध नहीं है। परिणामस्वरूप, द <code>set</code> संपत्ति का हिस्सा असाइनमेंट के लिए मौजूद होना चाहिए। एक्सेस को a से प्रतिबंधित किया जा सकता है <code>set</code>विशिष्ट पहुँच संशोधक।
<वाक्यविन्यास प्रकाश लैंग = csharp>
सार्वजनिक वर्ग छात्र
{
    सार्वजनिक स्ट्रिंग नाम {प्राप्त करें; निजी सेट; }
}
</वाक्यविन्यास हाइलाइट>


=== सामान्य लिस्प ===
=== सामान्य लिस्प ===
Line 218: Line 188:
सीएलओएस के पास गुणों की कोई धारणा नहीं है, हालांकि कॉमन लिस्प ऑब्जेक्ट सिस्टम#मेटाओब्जेक्ट प्रोटोकॉल एक्सटेंशन निर्दिष्ट करता है कि स्लॉट के रीडर और लेखक फ़ंक्शन नामों तक पहुंचने के लिए, जिसमें से उत्पन्न होते हैं <code>:accessor</code> विकल्प।<ref name="mop-slot-definitions">{{cite web |url=http://www.lisp.org/mop/concepts.html#slot-definitions |title=MOP: Slot Definitions |accessdate=2011-03-29}}</ref>
सीएलओएस के पास गुणों की कोई धारणा नहीं है, हालांकि कॉमन लिस्प ऑब्जेक्ट सिस्टम#मेटाओब्जेक्ट प्रोटोकॉल एक्सटेंशन निर्दिष्ट करता है कि स्लॉट के रीडर और लेखक फ़ंक्शन नामों तक पहुंचने के लिए, जिसमें से उत्पन्न होते हैं <code>:accessor</code> विकल्प।<ref name="mop-slot-definitions">{{cite web |url=http://www.lisp.org/mop/concepts.html#slot-definitions |title=MOP: Slot Definitions |accessdate=2011-03-29}}</ref>
निम्न उदाहरण इन स्लॉट विकल्पों और डायरेक्ट स्लॉट एक्सेस का उपयोग करके छात्र वर्ग की परिभाषा दिखाता है:
निम्न उदाहरण इन स्लॉट विकल्पों और डायरेक्ट स्लॉट एक्सेस का उपयोग करके छात्र वर्ग की परिभाषा दिखाता है:
<वाक्यविन्यास प्रकाश लैंग = लिस्प>
(defclass student ()
(डिफक्लास छात्र ()
  ((name      :initarg :name      :initform "" :accessor student-name) ; student-name is setf'able
  ((नाम: initarg: नाम: initform: एक्सेसर छात्र-नाम); छात्र-नाम सेट करने योग्य है
    (birthdate :initarg :birthdate :initform 0 :reader student-birthdate)
  (जन्मतिथि :initarg :जन्मतिथि :initform 0 :पाठक छात्र-जन्मतिथि)
    (number   :initarg :number    :initform 0 :reader student-number :writer set-student-number)))
   (संख्या:initarg:संख्या:initform 0:पाठक छात्र-संख्या:लेखक सेट-छात्र-संख्या))
 
;; Example of a calculated property getter (this is simply a method)
;; एक परिकलित संपत्ति प्राप्तकर्ता का उदाहरण (यह केवल एक विधि है)
(defmethod student-age ((self student))
(defmethod छात्र-आयु ((स्वयं छात्र))
  (- (get-universal-time) (student-birthdate self)))
  (- (प्राप्त-सार्वभौमिक-समय) (विद्यार्थी-जन्मतिथि स्वयं)))
 
;; Example of direct slot access within a calculated property setter
;; परिकलित प्रॉपर्टी सेटर के भीतर डायरेक्ट स्लॉट एक्सेस का उदाहरण
(defmethod (setf student-age) (new-age (self student))
(defmethod (सेटफ स्टूडेंट-एज) (न्यू-एज (सेल्फ स्टूडेंट))
  (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))
(defmethod सेट-छात्र-संख्या: पहले (नया-नंबर (स्वयं छात्र))
  ;; You could also check if a student with the new-number already exists.
  ;; आप यह भी जांच सकते हैं कि नए नंबर वाला छात्र पहले से मौजूद है या नहीं।
  (check-type new-number (integer 1 *)))
  (चेक-टाइप न्यू-नंबर (पूर्णांक 1 *)))
</वाक्यविन्यास हाइलाइट>


=== डी ===
=== डी ===
[[डी (प्रोग्रामिंग भाषा)]] एक गेट्टर और सेटर फंक्शन सिंटैक्स का समर्थन करता है। भाषा गेट्टर और सेटर वर्ग/संरचना विधियों के संस्करण 2 में होना चाहिए <code>@property</code> गुण।<ref>{{cite web |url=http://dlang.org/function.html |title=Functions - D Programming Language |url-status=live |accessdate=2013-01-13}}</ref><ref>{{cite web|url=http://dlang.org/dstyle.html |title=The D Style |accessdate=2013-02-01}}</ref>
[[डी (प्रोग्रामिंग भाषा)]] और सेटर फ़ंक्शन सिंटैक्स का समर्थन करता है। भाषा गेट्टर और सेटर वर्ग/संरचना विधियों के संस्करण 2 में <code>@property</code> विशेषता होनी चाहिए।<ref>{{cite web |url=http://dlang.org/function.html |title=Functions - D Programming Language |url-status=live |accessdate=2013-01-13}}</ref><ref>{{cite web|url=http://dlang.org/dstyle.html |title=The D Style |accessdate=2013-02-01}}</ref>
<वाक्यविन्यास प्रकाश लैंग = डी>
    class Student {
कक्षा छात्र {
    private char[] name_;
    निजी चार [] नाम_;
    // Getter
    // गेट्टर
    @property char[] name() {
    @ संपत्ति चार [] नाम () {
        return this.name_;
        इसे वापस करें। नाम_;
    }
    }
    // Setter
    // सेटर
    @property char[] name(char[] name_in) {
    @ संपत्ति चार [] नाम (चार [] नाम_इन) {
        return this.name_ = name_in;
        इसे वापस करें। नाम_ = नाम_इन;
    }
    }
}
}
एक <code>Student</code> उदाहरण इस तरह इस्तेमाल किया जा सकता है:
</वाक्यविन्यास हाइलाइट>
auto student = new Student;
<code>Student</code> उदाहरण इस तरह इस्तेमाल किया जा सकता है:
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
    FName: स्ट्रिंग;
    /// <summary>
    प्रक्रिया सेटनाम (स्थिरांक मान: स्ट्रिंग);
    /// Get or set the name of the student.
  जनता
    /// </summary>
    /// <सारांश>
    property Name: string read FName write SetName;
    /// छात्र का नाम प्राप्त करें या सेट करें।
  end;
    /// </ सारांश>
    संपत्ति का नाम: स्ट्रिंग पढ़ें FName लिखें SetName;
// ...
  अंत;
 
implementation
// ...
 
procedure TStudent.SetName(const Value: string);
कार्यान्वयन
begin
 
  FName := Value;
प्रक्रिया TStudent.SetName (स्थिरांक मान: स्ट्रिंग);
end;
शुरू
  एफनाम := मान;
end.
अंत;
 
अंत।
</वाक्यविन्यास हाइलाइट>


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


    सार्वजनिक स्ट्रिंग getName () {
=== जावास्क्रिप्ट ===
        वापसी का नाम;
इस उदाहरण में कंस्ट्रक्टर-फंक्शन स्टूडेंट का उपयोग केवल संग्रहीत नाम वाले छात्र का प्रतिनिधित्व करने वाली वस्तुओं को बनाने के लिए किया जाता है।
    }
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;
    }
    });
}</syntaxhighlight>
   
 
    this.__defineSetter__('name', function(value) {
=== जावास्क्रिप्ट ===
        _name = value;
इस उदाहरण में कंस्ट्रक्टर-फ़ंक्शन <code>Student</code> केवल संग्रहीत नाम वाले छात्र का प्रतिनिधित्व करने वाली वस्तुओं को बनाने के लिए उपयोग किया जाता है।
    });
<वाक्यविन्यास लैंग = जावास्क्रिप्ट>
}
समारोह छात्र (नाम) {
या (वंशानुक्रम और <code>[[ES6]]</code> एक्सेसर सिंटैक्स के लिए प्रोटोटाइप का उपयोग करके  
  वर _नाम = नाम;
function Student(name){
 
    this._name = name;
  यह getName = फ़ंक्शन () {
}
    वापसी नाम;
  };
Student.prototype = {
 
    get name() {
  यह सेटनाम = फ़ंक्शन (मान) {
        return this._name;
    _नाम = मूल्य;
    },
  };
    set name(value) {
}
        this._name = value;
</वाक्यविन्यास हाइलाइट>
    } 
या (वेब ​​ब्राउज़र में एक्सेसर्स को परिभाषित करने के लिए बहिष्कृत तरीके का उपयोग करके):<ref>{{Cite web|title=Object.prototype.__defineGetter__() - JavaScript {{!}} MDN|url=https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/__defineGetter__|access-date=2021-07-06|website=developer.mozilla.org|language=en-US}}</ref>
<वाक्यविन्यास लैंग = जावास्क्रिप्ट>
कार्य छात्र (नाम) {
    वर _नाम = नाम;
 
    this.__defineGetter__('name', function() {
        वापसी नाम;
    });
 
    this.__defineSetter__('name', function(value) {
        _नाम = मूल्य;
    });
}
</वाक्यविन्यास हाइलाइट>
या (वंशानुक्रम और [[ES6]] एक्सेसर सिंटैक्स के लिए प्रोटोटाइप का उपयोग करके):
<वाक्यविन्यास लैंग = जावास्क्रिप्ट>
कार्य छात्र (नाम) {
    यह._नाम = नाम;
}
 
छात्र.प्रोटोटाइप = {
    नाम प्राप्त करें () {
        इसे वापस करो._नाम;
    },
    सेट नाम (मान) {
        यह._नाम = मूल्य;
    }
};
</वाक्यविन्यास हाइलाइट>
या (प्रोटोटाइप का उपयोग किए बिना):
या (प्रोटोटाइप का उपयोग किए बिना):
<वाक्यविन्यास लैंग = जावास्क्रिप्ट>
  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;
Object.defineProperty(Student.prototype, 'name', {
    },
    प्राप्त करें: फ़ंक्शन () {
    set: function(value) {
        इसे वापस करो._नाम;
        this._name = value;
    },
    }
    सेट करें: फ़ंक्शन (मान) {
});
        यह._नाम = मूल्य;
    }
});
</वाक्यविन्यास हाइलाइट>


===एक्शनस्क्रिप्ट 3.0===
===एक्शनस्क्रिप्ट 3.0===
<वाक्यविन्यास लैंग = क्रियालेख>
package
पैकेट
{
{
    public class Student
    सार्वजनिक वर्ग छात्र
    {
    {
        private var _name : String;
        निजी संस्करण _नाम: स्ट्रिंग;
 
        public function get name() : String
        सार्वजनिक कार्य नाम प्राप्त करें (): String
        {  
        {
            return _name;
            वापसी नाम;
        }
        }
 
        public function set name(value : String) : void
        सार्वजनिक फ़ंक्शन सेट नाम (मान: स्ट्रिंग): शून्य
        {
        {
            _name = value;
            _नाम = मूल्य;
        }
        }
    }
    }
}
}
</वाक्यविन्यास हाइलाइट>


=== उद्देश्य-सी ===
=== उद्देश्य-सी ===
उबंटू संस्करण इतिहास # 1204 | उबंटू 12.04 पर [[जीएनयूस्टेप]] पर काम करने वाले मैनुअल संदर्भ गिनती के साथ पारंपरिक ऑब्जेक्टिव-सी 1.0 सिंटैक्स का उपयोग करना:
<code>Ubuntu 12.04</code> पर <code>GNUstep</code> पर काम करने वाले के रूप में मैनुअल रेफरेंस काउंटिंग के साथ पारंपरिक ऑब्जेक्टिव-सी 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
@अंत
Mac OS X 10.6, iOS 4 और Xcode 3.2 में उपयोग किए गए नए Objective-C 2.0 सिंटैक्स का उपयोग करते हुए, ऊपर बताए अनुसार समान कोड जनरेट करना:
</वाक्यविन्यास हाइलाइट>
@interface Student : NSObject
Mac OS X 10.6, [[iOS 4]] और [[Xcode]] 3.2 में उपयोग किए गए नए Objective-C 2.0 सिंटैक्स का उपयोग करते हुए, ऊपर बताए अनुसार समान कोड जनरेट करना:
<वाक्यविन्यास हाइलाइट लैंग = ओबीजेसी>
@property (nonatomic, retain) NSString *name;
@इंटरफेस छात्र: एनएसओब्जेक्ट
 
@end
@ संपत्ति (गैर-परमाणु, बनाए रखें) एनएसएसटींग * नाम;
 
@implementation Student
@अंत
 
@synthesize name = _name;
@ कार्यान्वयन छात्र
 
@end
@synthesize नाम = _name;
और OS X 10.8 और iOS 6 से शुरू करते हुए, <code>Xcode 4.4</code> और ऊपर का उपयोग करते हुए, सिंटैक्स को और भी सरल बनाया जा सकता है:
 
@interface Student : NSObject
@अंत
</वाक्यविन्यास हाइलाइट>
@property (nonatomic, strong) NSString *name;
और OS X 10.8 और [[iOS 6]] से शुरू करते हुए, Xcode 4.4 और ऊपर का उपयोग करते हुए, सिंटैक्स को और भी सरल बनाया जा सकता है:
<वाक्यविन्यास हाइलाइट लैंग = ओबीजेसी>
@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];
    $self->{name} = $_[0];
}
}
 
sub get_name {
उप get_name {
    my $self = shift;
    मेरा $ स्व = शिफ्ट;
    return $self->{name};
    वापसी $ स्वयं-> {नाम};
}
}
 
1;
1;
</वाक्यविन्यास हाइलाइट>
 
या, कक्षा :: एक्सेसर का उपयोग करना
या, कक्षा :: एक्सेसर का उपयोग करना
<वाक्यविन्यास प्रकाश लैंग = पर्ल>
package Student;
पैकेज छात्र;
use base qw(Class::Accessor);
आधार क्यूडब्ल्यू (कक्षा :: एक्सेसर) का उपयोग करें;
__PACKAGE__->follow_best_practice;
__पैकेज__->का पालन_सर्वश्रेष्ठ_अभ्यास;
 
Student->mk_accessors(qw(name));
छात्र-> mk_accessors (qw (नाम));
 
1;
1;
या, [[मूस (पर्ल)]] ऑब्जेक्ट सिस्टम का उपयोग करना:
</वाक्यविन्यास हाइलाइट>
package Student;
 
use Moose;
या, [[मूस (पर्ल)]] का उपयोग करना:
<वाक्यविन्यास प्रकाश लैंग = पर्ल>
# Moose uses the attribute name as the setter and getter, the reader and writer properties
पैकेज छात्र;
# allow us to override that and provide our own names, in this case get_name and set_name
मूस का प्रयोग करें;
has 'name' => (is => 'rw', isa => 'Str', reader => 'get_name', writer => 'set_name');
 
# मूस विशेषता नाम का उपयोग सेटर और गेट्टर, पाठक और लेखक गुणों के रूप में करता है
1;
# हमें इसे ओवरराइड करने की अनुमति दें और हमारे अपने नाम प्रदान करें, इस मामले में get_name और set_name
है 'नाम' => (is => 'rw', isa => 'Str', रीडर => 'get_name', लेखक => 'set_name');
 
1;
</वाक्यविन्यास हाइलाइट>


=== पीएचपी ===
=== पीएचपी ===
PHP जादू के तरीकों को परिभाषित करती है <code>__get</code>और<code>__set</code> वस्तुओं के गुणों के लिए।<ref>{{Cite web|title=PHP: Overloading - Manual|url=https://www.php.net/manual/en/language.oop5.overloading.php|access-date=2021-07-06|website=www.php.net}}</ref>
PHP जादू के तरीकों को परिभाषित करती है <code>__get</code>और<code>__set</code> वस्तुओं के गुणों के लिए।<ref>{{Cite web|title=PHP: Overloading - Manual|url=https://www.php.net/manual/en/language.oop5.overloading.php|access-date=2021-07-06|website=www.php.net}}</ref>
एक सरल वर्ग (कंप्यूटर विज्ञान) के इस उदाहरण में एक छात्र का प्रतिनिधित्व करने वाला केवल नाम संग्रहीत है, कोई देख सकता है कि चर (प्रोग्रामिंग) नाम निजी है, अर्थात केवल छात्र वर्ग से दिखाई देता है, और सेटर और गेट्टर सार्वजनिक है, अर्थात् <code>getName()</code> और <code>setName('name')</code> तरीके।
एक सरल वर्ग (कंप्यूटर विज्ञान) के इस उदाहरण में एक छात्र का प्रतिनिधित्व करने वाला केवल नाम संग्रहीत है, कोई देख सकता है कि चर (प्रोग्रामिंग) नाम निजी है, अर्थात केवल छात्र वर्ग से दिखाई देता है, और सेटर और गेट्टर सार्वजनिक है, अर्थात् <code>getName()</code> और <code>setName('name')</code> तरीके।
<वाक्यविन्यास लैंग = php>
वर्ग छात्र
{
    निजी स्ट्रिंग $ नाम;
    /**
    * @return स्ट्रिंग नाम।
    */
    सार्वजनिक समारोह getName (): स्ट्रिंग
    {
        वापसी $ यह-> नाम;
    }


    /**
class Student
     * @ अपरम स्ट्रिंग $ नया नाम सेट करने के लिए नाम।
{
    */
    private string $name;
    सार्वजनिक फ़ंक्शन सेटनाम (स्ट्रिंग $ नया नाम): शून्य
    {
    /**
        $ यह-> नाम = $ नया नाम;
      * @return string The name.
    }
      */
}</syntaxhighlight>
    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
    def __init__(स्वयं, नाम: str) -> कोई नहीं:
>>> bob.name = "Alice"
        # छात्र का नाम धारण करने के लिए एक उदाहरण चर
>>> bob.name
        स्व._नाम = नाम
Alice
 
>>> bob._name = "Charlie" # bypass the setter
    # गेट्टर विधि
>>> bob._name # bypass the getter
    @संपत्ति
Charlie
    डीईएफ़ नाम (स्वयं):
        स्व._नाम वापस करें
 
    # सेटर विधि
    @ नाम.सेटर
    डीईएफ़ नाम (स्वयं, new_name):
        स्व._नाम = नया_नाम
</वाक्यविन्यास हाइलाइट>
<वाक्यविन्यास लैंग = पिकॉन>
>>> बॉब = छात्र (बॉब)
>>> बॉब.नाम
बीओबी
>>> बॉब.नाम = ऐलिस
>>> बॉब.नाम
ऐलिस
>>> बॉब._नाम = चार्ली # सेटर को बायपास करें
>>> बॉब._नाम # गेट्टर को बायपास करें
चार्ली
</वाक्यविन्यास हाइलाइट>


=== रैकेट ===
=== रैकेट ===
[[रैकेट (प्रोग्रामिंग भाषा)]] में, ऑब्जेक्ट सिस्टम कोड को व्यवस्थित करने का एक तरीका है जो मॉड्यूल और यूनिट के अतिरिक्त आता है। बाकी भाषा की तरह, ऑब्जेक्ट सिस्टम में प्रथम श्रेणी के मान हैं और वस्तुओं और विधियों तक पहुंच को नियंत्रित करने के लिए लेक्सिकल स्कोप का उपयोग किया जाता है।
[[रैकेट (प्रोग्रामिंग भाषा)]] में, ऑब्जेक्ट सिस्टम कोड को व्यवस्थित करने का एक तरीका है जो मॉड्यूल और यूनिट के अतिरिक्त आता है। बाकी भाषा की तरह, ऑब्जेक्ट सिस्टम में प्रथम श्रेणी के मान हैं और वस्तुओं और विधियों तक पहुंच को नियंत्रित करने के लिए लेक्सिकल स्कोप का उपयोग किया जाता है।
 
#lang racket
<वाक्यविन्यास प्रकाश लैंग = रैकेट>
(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"
(एस सेट-नाम भेजें! बॉब)
(एस गेट-नाम भेजें); => बॉब
</वाक्यविन्यास हाइलाइट>
 
संरचनात्मक परिभाषाएँ नए प्रकार के मूल्यों को परिभाषित करने का एक वैकल्पिक तरीका है, जब स्पष्ट रूप से आवश्यक होने पर म्यूटेटर मौजूद होते हैं:
संरचनात्मक परिभाषाएँ नए प्रकार के मूल्यों को परिभाषित करने का एक वैकल्पिक तरीका है, जब स्पष्ट रूप से आवश्यक होने पर म्यूटेटर मौजूद होते हैं:
<वाक्यविन्यास प्रकाश लैंग = रैकेट>
#lang racket
#लैंग रैकेट
(struct student (name) #:mutable)
(संरचना छात्र (नाम) #: परिवर्तनशील)
(define s (student "Alice"))
(एस परिभाषित करें (छात्र ऐलिस))
(set-student-name! s "Bob")
(सेट-छात्र-नाम! एस बॉब)
(student-name s)                       ; => "Bob"
(छात्र-नाम एस); => बॉब
</वाक्यविन्यास हाइलाइट>
 
=== रूबी ===
[[रूबी (प्रोग्रामिंग भाषा)]] में, अलग-अलग एक्सेसर और म्यूटेटर विधियों को परिभाषित किया जा सकता है, या मेटाप्रोग्रामिंग निर्माण <code>attr_reader</code> या <code>attr_accessor</code> कक्षा में एक निजी चर घोषित करने के लिए और क्रमशः पढ़ने-योग्य या पढ़ने-लिखने के लिए सार्वजनिक पहुंच प्रदान करने के लिए दोनों का उपयोग किया जा सकता है।
 
अलग-अलग एक्सेसर और म्यूटेटर विधियों को परिभाषित करने से डेटा के पूर्व-प्रसंस्करण या सत्यापन के लिए जगह बनती है
<वाक्यविन्यास लैंग = रूबी>
वर्ग छात्र
  डीईएफ़ नाम
    @नाम
  अंत
 
  डीईएफ़ नाम = (मान)
    @ नाम = मूल्य
  अंत
अंत
</वाक्यविन्यास हाइलाइट>
 
निहित करने के लिए केवल-पढ़ने के लिए सरल सार्वजनिक पहुँच <code>@name</code> चर
<वाक्यविन्यास लैंग = रूबी>
वर्ग छात्र
  attr_reader : नाम
अंत
</वाक्यविन्यास हाइलाइट>


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


=== जंग ===
=== रस्ट ===
<वाक्यविन्यास प्रकाश लैंग = जंग>
struct Student {
संरचना छात्र {
    name: String,
    नाम: स्ट्रिंग,
}
}
 
impl Student {
इम्प्ल छात्र {
    fn name(&self) -> &String {
    एफएन नाम (और स्वयं) -> और स्ट्रिंग {
        &self.name
        &self.name
    }
    }
 
    fn set_name(&mut self, name: String) {
    fn set_name(&म्यूट स्व, नाम: स्ट्रिंग) {
        self.name = name
        स्व.नाम = नाम
    }
    }
}
}
</वाक्यविन्यास हाइलाइट>


=== स्मालटॉक ===
=== स्मालटॉक ===
<वाक्यविन्यास लैंग = स्मॉलटॉक>
   age: aNumber
   आयु: एक संख्या
      " Set the receiver age to be aNumber if is greater than 0 and less than 150 "
      यदि 0 से अधिक और 150 से कम है तो रिसीवर की आयु एक संख्या के रूप में सेट करें
    (aNumber between: 0 and: 150)
    (बीच की संख्या: 0 और: 150)
        ifTrue: [ age := aNumber ]
      ifTrue: [आयु := एक संख्या]
</वाक्यविन्यास हाइलाइट>


=== तेज ===
=== तेज ===
<वाक्यविन्यास प्रकाश लैंग = तेज>
class Student {
कक्षा छात्र {
    private var _name: String = ""
    निजी संस्करण _नाम: स्ट्रिंग =
 
    var name: String {
    वर नाम: स्ट्रिंग {
        get {
        पाना {
            return self._name
            स्व._नाम वापस करें
        }
        }
        set {
        तय करना {
            self._name = newValue
            स्व._नाम = नया मूल्य
        }
        }
    }
    }
}
}
</वाक्यविन्यास हाइलाइट>


=== विजुअल बेसिक .NET ===
=== विजुअल बेसिक .NET ===
यह उदाहरण कक्षाओं में उपयोग किए जाने वाले गुणों के VB.NET विचार को दिखाता है। C# के समान, इसका एक स्पष्ट उपयोग है <code>Get</code> और <code>Set</code> तरीके।
यह उदाहरण कक्षाओं में उपयोग किए जाने वाले गुणों के VB.NET विचार को दिखाता है। सी # के समान, <code>Get</code> और <code>Set</code> विधियों का स्पष्ट उपयोग होता है।
 
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
    संपत्ति समाप्त करें
 
अंत वर्ग
 
</वाक्यविन्यास हाइलाइट>
 
VB.NET 2010 में, Get और Set सिंटैक्स का उपयोग किए बिना एक संपत्ति बनाने के लिए ऑटो इम्प्लीमेंटेड गुणों का उपयोग किया जा सकता है। ध्यान दें कि एक छुपा चर संकलक द्वारा बनाया गया है, जिसे कहा जाता है <code>_name</code>, संपत्ति के साथ मेल खाने के लिए <code>name</code>. नामित वर्ग के भीतर एक अन्य चर का उपयोग करना <code>_name</code> एक त्रुटि में परिणाम होगा। अंतर्निहित चर के लिए विशेषाधिकार प्राप्त पहुँच कक्षा के भीतर से उपलब्ध है।
VB.NET 2010 में, Get और Set सिंटैक्स का उपयोग किए बिना एक संपत्ति बनाने के लिए ऑटो इम्प्लीमेंटेड गुणों का उपयोग किया जा सकता है। ध्यान दें कि एक छुपा चर संकलक द्वारा बनाया गया है, जिसे कहा जाता है <code>_name</code>, संपत्ति के साथ मेल खाने के लिए <code>name</code>. नामित वर्ग के भीतर एक अन्य चर का उपयोग करना <code>_name</code> एक त्रुटि में परिणाम होगा। अंतर्निहित चर के लिए विशेषाधिकार प्राप्त पहुँच कक्षा के भीतर से उपलब्ध है।
 
Public Class Student
<वाक्यविन्यास लैंग = वीबी>
    Public Property name As String
 
End Class
पब्लिक क्लास स्टूडेंट
    सार्वजनिक संपत्ति का नाम स्ट्रिंग के रूप में
अंत वर्ग
 
</वाक्यविन्यास हाइलाइट>


== यह भी देखें ==
== यह भी देखें ==
* संपत्ति (प्रोग्रामिंग)
* प्रोपर्टी (प्रोग्रामिंग भाषा)
*[[अनुक्रमणिका (प्रोग्रामिंग)]]
*[[अनुक्रमणिका (प्रोग्रामिंग)|इंडेक्सर (प्रोग्रामिंग भाषा)]]
* [[अपरिवर्तनीय वस्तु]]
* [[अपरिवर्तनीय वस्तु]]



Revision as of 17:35, 18 February 2023

कंप्यूटर विज्ञान में, एक म्यूटेटर विधि एक चर में परिवर्तन को नियंत्रित करने के लिए उपयोग की जाने वाली विधि है। उन्हें व्यापक रूप से सेटर विधियों के रूप में भी जाना जाता है। अक्सर एक सेटर के साथ एक गेट्टर (एक साथ एक्सेसर्स के रूप में भी जाना जाता है) होता है, जो निजी सदस्य चर का मान लौटाता है।

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

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

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

निहितार्थ

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

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

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

आधुनिक प्रोग्रामिंग भाषाएं अक्सर एक ही पंक्ति में म्यूटेटर और एक्सेसर्स के लिए बॉयलरप्लेट कोड उत्पन्न करने की क्षमता प्रदान करती हैं - उदाहरण के लिए C#'spublic string Name { get; set; } और रूबी का attr_accessor :name इन मामलों में, सत्यापन, प्रीप्रोसेसिंग या संश्लेषण के लिए कोई कोड ब्लॉक नहीं बनाया जाता है। ये सरलीकृत एक्सेसर्स अभी भी सरल सार्वजनिक उदाहरण चर पर एनकैप्सुलेशन के लाभ को बरकरार रखते हैं, लेकिन यह सामान्य है कि जैसे-जैसे सिस्टम डिजाइन प्रगति करता है, सॉफ्टवेयर बनाए रखा जाता है और आवश्यकताएं बदलती हैं, डेटा की मांग अधिक परिष्कृत हो जाती है। कई स्वचालित म्यूटेटर और एक्सेसर्स अंततः कोड के अलग-अलग ब्लॉकों द्वारा प्रतिस्थापित किए जाते हैं। कार्यान्वयन के शुरुआती दिनों में उन्हें स्वचालित रूप से बनाने का लाभ यह है कि वर्ग का सार्वजनिक इंटरफ़ेस समान रहता है चाहे अधिक परिष्कार जोड़ा जाए या नहीं, यदि कोई व्यापक रिफैक्टरिंग की आवश्यकता नहीं है।[1]

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

इसमें शामिल अतिरिक्त चरणों के कारण डेटा फ़ील्ड को सीधे लाने या संग्रहीत करने की तुलना में एक्सेसर फ़ंक्शन कम कुशल हो सकते हैं,[2] हालाँकि ऐसे कार्य अक्सर इनलाइन फ़ंक्शन होते हैं जो फ़ंक्शन कॉल के ओवरहेड को समाप्त कर देते हैं।

उदाहरण

सभा

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

सी

#ifndef _STUDENT_H
#define _STUDENT_H

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);

#endif
#include <stdlib.h>
#include <string.h>
#include "student.h"

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 <stdio.h>
#include "student.h"

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

सी ++

#ifndef STUDENT_H
#define STUDENT_H

#include <string>

class Student {
public:
    Student(const std::string& name);

    const std::string& name() const;
    void name(const std::string& name);

private:
    std::string name_;
};

#endif

In file Student.cpp:

#include "Student.h"

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;
}

सी#

यह उदाहरण गुणों के सी # विचार को दिखाता है, जो एक विशेष प्रकार के वर्ग सदस्य हैं। जावा के विपरीत, कोई स्पष्ट तरीके परिभाषित नहीं हैं; एक सार्वजनिक 'संपत्ति' में क्रियाओं को संभालने के लिए तर्क होता है। बिल्ट-इन (अघोषित) वेरिएबल value के उपयोग पर ध्यान दें।

public class Student
{
    private string name;

    /// <summary>
    /// Gets or sets student's name
    /// </summary>
    public string Name
    {
        get { return name; }
        set { name = value; }
    }
}

बाद के C# संस्करणों (.NET फ्रेमवर्क 3.5 और ऊपर) में, निजी चर घोषित किए बिना, इस उदाहरण को संक्षिप्त रूप में निम्नानुसार किया जा सकता है name.

बाद के C# संस्करणों (.NET फ्रेमवर्क 3.5 और ऊपर) में, निजी चर name घोषित किए बिना, इस उदाहरण को निम्नानुसार संक्षिप्त किया जा सकता है।

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

संक्षिप्त सिंटैक्स का उपयोग करने का अर्थ है कि अंतर्निहित चर अब कक्षा के अंदर से उपलब्ध नहीं है। नतीजतन, संपत्ति का set हिस्सा असाइनमेंट के लिए मौजूद होना चाहिए। एक्सेस को set-विशिष्ट एक्सेस संशोधक के साथ प्रतिबंधित किया जा सकता है।

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

सामान्य लिस्प

कॉमन लिस्प ऑब्जेक्ट सिस्टम में, क्लास परिभाषाओं के भीतर स्लॉट स्पेसिफिकेशंस इनमें से किसी को भी निर्दिष्ट कर सकते हैं :reader, :writer और :accessor पाठक विधियों, सेटर विधियों और एक्सेसर विधियों (एक पाठक विधि और संबंधित setf तरीका)।[3] के उपयोग के साथ स्लॉट हमेशा उनके नाम के माध्यम से सीधे पहुंच योग्य होते हैं with-slots और slot-value, और स्लॉट एक्सेसर विकल्प उपयोग करने वाली विशेष विधियों को परिभाषित करते हैं slot-value.[4] सीएलओएस के पास गुणों की कोई धारणा नहीं है, हालांकि कॉमन लिस्प ऑब्जेक्ट सिस्टम#मेटाओब्जेक्ट प्रोटोकॉल एक्सटेंशन निर्दिष्ट करता है कि स्लॉट के रीडर और लेखक फ़ंक्शन नामों तक पहुंचने के लिए, जिसमें से उत्पन्न होते हैं :accessor विकल्प।[5] निम्न उदाहरण इन स्लॉट विकल्पों और डायरेक्ट स्लॉट एक्सेस का उपयोग करके छात्र वर्ग की परिभाषा दिखाता है:

(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 में @property विशेषता होनी चाहिए।[6][7]

   class Student {
    private char[] name_;
    // Getter
    @property char[] name() {
        return this.name_;
    }
    // Setter
    @property char[] name(char[] name_in) {
        return this.name_ = name_in;
    }
}

एक Student उदाहरण इस तरह इस्तेमाल किया जा सकता है:

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
    /// <summary>
    /// Get or set the name of the student.
    /// </summary>
    property Name: string read FName write SetName;
  end;

// ...

implementation

procedure TStudent.SetName(const Value: string);
begin
  FName := Value;
end;

end.

जावा

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

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

या (वंशानुक्रम और ES6 एक्सेसर सिंटैक्स के लिए प्रोटोटाइप का उपयोग करके

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;
        }
    }
}

उद्देश्य-सी

Ubuntu 12.04 पर GNUstep पर काम करने वाले के रूप में मैनुअल रेफरेंस काउंटिंग के साथ पारंपरिक ऑब्जेक्टिव-सी 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

Mac OS X 10.6, iOS 4 और Xcode 3.2 में उपयोग किए गए नए Objective-C 2.0 सिंटैक्स का उपयोग करते हुए, ऊपर बताए अनुसार समान कोड जनरेट करना:

@interface Student : NSObject

@property (nonatomic, retain) NSString *name;

@end

@implementation Student

@synthesize name = _name;

@end

और OS X 10.8 और iOS 6 से शुरू करते हुए, Xcode 4.4 और ऊपर का उपयोग करते हुए, सिंटैक्स को और भी सरल बनाया जा सकता है:

@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;

# Moose uses the attribute name as the setter and getter, the reader and writer properties
# allow us to override that and provide our own names, in this case get_name and set_name
has 'name' => (is => 'rw', isa => 'Str', reader => 'get_name', writer => 'set_name');

1;

पीएचपी

PHP जादू के तरीकों को परिभाषित करती है __getऔर__set वस्तुओं के गुणों के लिए।[8] एक सरल वर्ग (कंप्यूटर विज्ञान) के इस उदाहरण में एक छात्र का प्रतिनिधित्व करने वाला केवल नाम संग्रहीत है, कोई देख सकता है कि चर (प्रोग्रामिंग) नाम निजी है, अर्थात केवल छात्र वर्ग से दिखाई देता है, और सेटर और गेट्टर सार्वजनिक है, अर्थात् getName() और setName('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

रैकेट

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

#lang racket
(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"

संरचनात्मक परिभाषाएँ नए प्रकार के मूल्यों को परिभाषित करने का एक वैकल्पिक तरीका है, जब स्पष्ट रूप से आवश्यक होने पर म्यूटेटर मौजूद होते हैं:

#lang racket
(struct student (name) #:mutable)
(define s (student "Alice"))
(set-student-name! s "Bob")
(student-name s)                        ; => "Bob"

रुबी

रुबी में, अलग-अलग एक्सेसर और म्यूटेटर विधियों को परिभाषित किया जा सकता है, या मेटाप्रोग्रामिंग attr_reader या attr_accessorदोनों का उपयोग कक्षा में एक निजी चर घोषित करने के लिए किया जा सकता है और क्रमशः पढ़ने-योग्य या पढ़ने-लिखने के लिए सार्वजनिक पहुंच प्रदान करने के लिए किया जा सकता है।

class Student
  def name
    @name
  end

  def name=(value)
    @name=value
  end
end

निहित @name चर के लिए केवल-पढ़ने के लिए सरल सार्वजनिक पहुंच

class Student
  attr_reader :name
end

निहित @nameचर के लिए सरल सार्वजनिक पहुंच पढ़ें-लिखें

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
        }
    }
}

विजुअल बेसिक .NET

यह उदाहरण कक्षाओं में उपयोग किए जाने वाले गुणों के VB.NET विचार को दिखाता है। सी # के समान, Get और Set विधियों का स्पष्ट उपयोग होता है।

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

VB.NET 2010 में, Get और Set सिंटैक्स का उपयोग किए बिना एक संपत्ति बनाने के लिए ऑटो इम्प्लीमेंटेड गुणों का उपयोग किया जा सकता है। ध्यान दें कि एक छुपा चर संकलक द्वारा बनाया गया है, जिसे कहा जाता है _name, संपत्ति के साथ मेल खाने के लिए name. नामित वर्ग के भीतर एक अन्य चर का उपयोग करना _name एक त्रुटि में परिणाम होगा। अंतर्निहित चर के लिए विशेषाधिकार प्राप्त पहुँच कक्षा के भीतर से उपलब्ध है।

Public Class Student
    Public Property name As String
End Class

यह भी देखें

संदर्भ

  1. Stephen Fuqua (2009). "Automatic Properties in C# 3.0". Archived from the original on 2011-05-13. Retrieved 2009-10-19.
  2. Tim Lee (1998-07-13). "Run Time Efficiency of Accessor Functions".
  3. "CLHS: Macro DEFCLASS". Retrieved 2011-03-29.
  4. "CLHS: 7.5.2 Accessing Slots". Retrieved 2011-03-29.
  5. "MOP: Slot Definitions". Retrieved 2011-03-29.
  6. "Functions - D Programming Language". Retrieved 2013-01-13.{{cite web}}: CS1 maint: url-status (link)
  7. "The D Style". Retrieved 2013-02-01.
  8. "PHP: Overloading - Manual". www.php.net. Retrieved 2021-07-06.