 | This articleneeds additional citations forverification. Please helpimprove this article byadding citations to reliable sources. Unsourced material may be challenged and removed. Find sources: "Property" programming – news ·newspapers ·books ·scholar ·JSTOR(January 2022) (Learn how and when to remove this message) |
Aproperty, in someobject-orientedprogramming languages, is a special sort ofclass member, intermediate in functionality between afield (or data member) and amethod. The syntax for reading and writing of properties is like for fields, but property reads and writes are (usually) translated to 'getter' and 'setter' method calls. The field-like syntax is easier to read and write than many method calls,[citation needed] yet the interposition of method calls "under the hood" allows fordata validation,active updating (e.g., ofGUI elements), or implementation of what may be called "read-only fields".
Programming languages that support properties includeActionScript 3,C#,D,Delphi/Free Pascal, eC,F#,Kotlin,JavaScript,Objective-C 2.0,Python,Scala,Swift,Lua, andVisual Basic.
Some object-oriented languages, such asJava andC++, do not support properties, requiring the programmer to define a pair ofaccessor andmutator methods instead.[1][citation needed]
Oberon-2 provides an alternative mechanism using object variable visibility flags.[citation needed]
Other languages designed for theJava Virtual Machine, such asGroovy, natively support properties.
WhileC++ does not have first class properties, they can be emulated withoperator overloading.[2]
Also note that some C++ compilers support first class properties as language extensions.[citation needed]
__declspec(property) creates properties similar toC#.__property keyword.[5]In many object oriented languages properties are implemented as a pair of accessor/mutator methods, but accessed using the same syntax as for public fields. Omitting a method from the pair yields aread-only or an uncommonwrite-only property.
In some languages with no built-in support for properties, a similar construct can be implemented as a single method that either returns or changes the underlying data, depending on the context of its invocation. Such techniques are used e.g. inPerl.[citation needed]
Some languages (Ruby,Smalltalk) achieve property-like syntax using normal methods, sometimes with a limited amount ofsyntactic sugar.
Some languages follow well-established syntax conventions for formally specifying and utilizing properties and methods.
Among these conventions:
The following example demonstrates dot notation in JavaScript.
document.createElement("pre");
The following example demonstrates bracket notation in JavaScript.
document["createElement"]("pre");
classPen{privateintcolor;// private field// public propertypublicintColor{get{returnthis.color;}set{if(value>0){this.color=value;}}}}
// accessing:Penpen=new();intcolorTmp=0;// ...pen.Color=17;colorTmp=pen.Color;// ...pen.Color=~pen.Color;// bitwise complement ...// another silly example:pen.Color+=1;// a lot clearer than "pen.set_Color(pen.get_Color() + 1)"!
Recent C# versions also allow "auto-implemented properties" where the backing field for the property is generated by the compiler during compilation. This means that the property must have a setter. However, it can be private.
classShape{publicintHeight{get;set;}publicintWidth{get;privateset;}}
| This sectiondoes notcite anysources. Please helpimprove this section byadding citations to reliable sources. Unsourced material may be challenged andremoved.(October 2016) (Learn how and when to remove this message) |
 | This articlemay beconfusing or unclear to readers. Please helpclarify the article. There might be a discussion about this onthe talk page.(October 2016) (Learn how and when to remove this message) |
C++ does not have first class properties, but there exist several ways to emulate properties to a limited degree. Two of which follow:
importstd;usingstd::same_as;template<typenameT>classProperty{Tvalue;public:// Ensure T and T2 are the same typetemplate<typenameU>requiressame_as<T,U>T&operator=(constU&i){value=i;return*this;}// Implicit conversion back to T.operatorTconst&()const{returnvalue;}};structFoo{// Properties using unnamed classes.class{private:intvalue;public:int&operator=(constint&i){returnvalue=i;}intoperatorint()const{returnvalue;}}alpha;class{private:floatvalue;public:float&operator=(constfloat&f){returnvalue=f;}floatoperatorfloat()const{returnvalue;}}bravo;};structBar{// Using the Property<>-template.Property<bool>alpha;Property<unsignedint>bravo;};intmain(intargc,char*argv[]){Foofoo;foo.alpha=5;foo.bravo=5.132f;Barbar;bar.alpha=true;bar.bravo=true;// This line will yield a compile time error due to the guard template member function.std::println("{}, {}, {}, {}",foo.alpha,foo.bravo,bar.alpha,bar.bravo);return0;}
An example adapted from the MSDNdocumentation page.
// declspec_property.cppstructInteger{intvalue;voidsetValue(intj)noexcept{value=j;}[[nodiscard]]intgetValue()constnoexcept{returni;}__declspec(property(get=getValue,put=setValue))intprop;};intmain(){Integers;s.prop=5;return0;}
classPen{privateintmyColor;// private field// public get propertypublicintcolor(){returnmyColor;}// public set propertypublicvoidcolor(intvalue){myColor=value;}}
Penpen=newPen;pen.color=~pen.color;// bitwise complement// the set property can also be used in expressions, just like regular assignmentinttheColor=(pen.color=0xFF0000);
In D version 2, each property accessor or mutator must be marked with @property:
classPen{privateintmyColor;// private field// public get property@propertypublicintcolor(){returnmyColor;}// public set property@propertypublicvoidcolor(intvalue){myColor=value;}}
typeTPen=classprivateFColor:TColor;functionGetColor:TColor;procedureSetColor(constAValue:TColor);publicpropertyColor:IntegerreadGetColorwriteSetColor;end;functionTPen.GetColor:TColor;beginResult:=FColor;end;procedureTPen.SetColor(constAValue:TColor);beginifFColor<>AValuethenFColor:=AValue;end;
// accessing:varPen:TPen;// ...Pen.Color:=notPen.Color;(*Delphi and Free Pascal also support a 'direct field' syntax -property Color: TColor read FColor write SetColor;orproperty Color: TColor read GetColor write FColor;where the compiler generates the exact same code as for reading and writinga field. This offers the efficiency of a field, with the safety of a property.(You can't get a pointer to the property, and you can always replace the memberaccess with a method call.)*)
classPen{// private data memberColorcolor;public:// public propertypropertyColorcolor{get{returncolor;}set{color=value;}}}PenblackPen{color=black};PenwhitePen{color=white};Penpen3{color={30,80,120}};Penpen4{color=ColorHSV{90,20,40}};
typePen()=classletmutable_color=0memberthis.Colorwithget()=_colorandsetvalue=_color<-valueend
letpen=newPen()pen.Color<-~~~pen.Color
functionPen(){this._color=0;}// Add the property to the Pen type itself, can also// be set on the instance individuallyObject.defineProperties(Pen.prototype,{color:{get:function(){returnthis._color;},set:function(value){this._color=value;}}});
varpen=newPen();pen.color=~pen.color;// bitwise complementpen.color+=1;// Add one
package{publicclassPen{privatevar_color:uint=0;publicfunctiongetcolor():uint{return_color;}publicfunctionsetcolor(value:uint):void{_color=value;}}}
varpen:Pen=newPen();pen.color=~pen.color;// bitwise complementpen.color+=1;// add one
@interfacePen :NSObject@property(copy)NSColor*colour;// The "copy" attribute causes the object's copy to be// retained, instead of the original.@end@implementationPen@synthesizecolour;// Compiler directive to synthesise accessor methods.// It can be left behind in Xcode 4.5 and later.@end
The above example could be used in an arbitrary method like this:
Pen*pen=[[Penalloc]init];pen.colour=[NSColorblackColor];floatred=pen.colour.redComponent;[pen.colourdrawSwatchInRect:NSMakeRect(0,0,100,100)];
classPen{privateint$color=1;function__set($property,$value){if(property_exists($this,$property)){$this->$property=$value;}}function__get($property){if(property_exists($this,$property)){return$this->$property;}returnnull;}}
$p=newPen();$p->color=~$p->color;// Bitwise complementecho$p->color;
Properties only work correctly for new-style classes (classes that haveobject as asuperclass), and are only available in Python 2.2 and newer (seethe relevant section of the tutorialUnifying types and classes in Python 2.2). Python 2.6 added a new syntax involving decorators for defining properties.
classPen:_color:int# "private" variabledef__init__(self)->None:self._color=0@propertydefcolor(self)->int:returnself._color@color.setterdefcolor(self,color:int)->None:self._color=color
pen:Pen=Pen()# Accessing:pen.color=~pen.color# Bitwise complement ...
classPendefinitialize@color=0end# Defines a getter for the @color fielddefcolor@colorend# Defines a setter for the @color fielddefcolor=(value)@color=valueendendpen=Pen.newpen.color=~pen.color# Bitwise complement
Ruby also provides automatic getter/setter synthesizers defined as instance methods of Class.
classPenattr_reader:brand# Generates a getter for @brand (Read-Only)attr_writer:size# Generates a setter for @size (Write-Only)attr_accessor:color# Generates both a getter and setter for @color (Read/Write)definitialize@color=0# Within the object, we can access the instance variable directly@brand="Penbrand"@size=0.7# But we could also use the setter method defined by the attr_accessor Class instance methodendendpen=Pen.newputspen.brand# Accesses the pen brand through the generated getterpen.size=0.5# Updates the size field of the pen through the generated setterpen.color=~pen.color
PublicClassPenPrivate_colorAsInteger' Private fieldPublicPropertyColor()AsInteger' Public propertyGetReturn_colorEndGetSet(ByValvalueAsInteger)_color=valueEndSetEndPropertyEndClass
' Create Pen class instanceDimpenAsNewPen()' Set valuepen.Color=1' Get valueDimcolorAsInt32=pen.Color
PublicClassPenPublicPropertyColor()AsInteger' Public propertyEndClass
' Create Pen class instanceDimpenAsNewPen()' Set valuepen.Color=1' Get valueDimcolorAsInt32=pen.Color
' in a class named clsPenPrivatem_ColorAsLongPublicPropertyGetColor()AsLongColor=m_ColorEndPropertyPublicPropertyLetColor(ByValRHSAsLong)m_Color=RHSEndProperty
' accessing:DimpenAsNewclsPen' ...pen.Color=Notpen.Color
