Property (programming)

Support in languages

Syntax variants

Dot notation

document.createElement("pre");

Bracket notation

document["createElement"]("pre");

Example syntax

C#

classPen
{
privateintcolor;// private field

// public property
publicintColor
{
get
{
returnthis.color;
}
set
{
if(value>0)
{
this.color=value;
}
}
}
}

// accessing:
Penpen=newPen();
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)"!

classShape
{
publicintHeight{get;set;}
publicintWidth{get;privateset;}
}

C++

Using Standard C++

importstd;
usingstd::same_as;
template<typenameT>
classProperty{
Tvalue;
public:
// Ensure T and T2 are the same type
template<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;
}

C++, Microsoft, GCC, LLVM/clang and C++Builder-specific

// declspec_property.cpp
structInteger{
intvalue;
voidsetValue(intj){
value=j;
}
intgetValue(){
returni;
}
__declspec(property(get=getValue,put=setValue))
intprop;
};
intmain(){
Integers;
s.prop=5;
return0;
}

D

classPen{
privateintmyColor;// private field

// public get property
publicintcolor(){
returnmyColor;
}

// public set property
publicvoidcolor(intvalue){
myColor=value;
}
}

Penpen=newPen;
pen.color=~pen.color;// bitwise complement
// the set property can also be used in expressions, just like regular assignment
inttheColor=(pen.color=0xFF0000);

classPen{
privateintmyColor;// private field

// public get property
@property
publicintcolor(){
returnmyColor;
}

// public set property
@property
publicvoidcolor(intvalue){
myColor=value;
}
}

Delphi/Free Pascal

typeTPen=class
private
FColor:TColor;
functionGetColor:TColor;
procedureSetColor(constAValue:TColor);
public
propertyColor:IntegerreadGetColorwriteSetColor;
end;
functionTPen.GetColor:TColor;
begin
Result:=FColor;
end;
procedureTPen.SetColor(constAValue:TColor);
begin
ifFColor<>AValue
thenFColor:=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;
or
property Color: TColor read GetColor write FColor;
where the compiler generates the exact same code as for reading and writing
a 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 member
access with a method call.)
*)

eC

classPen
{
// private data member
Colorcolor;
public:
// public property
propertyColorcolor
{
get{returncolor;}
set{color=value;}
}
}
PenblackPen{color=black};
PenwhitePen{color=white};
Penpen3{color={30,80,120}};
Penpen4{color=ColorHSV{90,20,40}};

F#

typePen()=class
letmutable_color=0
memberthis.Color
withget()=_color
andsetvalue=_color<-value
end

letpen=newPen()
pen.Color<-~~~pen.Color

JavaScript

functionPen(){
this._color=0;
}
// Add the property to the Pen type itself, can also
// be set on the instance individually
Object.defineProperties(Pen.prototype,{
color:{
get:function(){
returnthis._color;
},
set:function(value){
this._color=value;
}
}
});

varpen=newPen();
pen.color=~pen.color;// bitwise complement
pen.color+=1;// Add one

ActionScript 3.0

package{
publicclassPen{
privatevar_color:uint=0;

publicfunctiongetcolor():uint{
return_color;
}

publicfunctionsetcolor(value:uint):void{
_color=value;
}
}
}

varpen:Pen=newPen();
pen.color=~pen.color;// bitwise complement
pen.color+=1;// add one

Objective-C 2.0

@interface Pen : NSObject
@property(copy)NSColor*colour;// The "copy" attribute causes the object's copy to be
// retained, instead of the original.
@end
@implementation Pen
@synthesizecolour;// Compiler directive to synthesise accessor methods.
// It can be left behind in Xcode 4.5 and later.
@end

Pen*pen=[[Penalloc]init];
pen.colour=[NSColorblackColor];
floatred=pen.colour.redComponent;
[pen.colourdrawSwatchInRect:NSMakeRect(0,0,100,100)];

PHP

class Pen
{
 private int $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;
 }
 return null;
 }
}

$p = new Pen();
$p->color = ~$p->color; // Bitwise complement
echo $p->color;

Python

classPen:
 def__init__(self):
 self._color = 0 # "private" variable
 @property
 defcolor(self):
 return self._color
 @color.setter
 defcolor(self, color):
 self._color = color

pen = Pen()
# Accessing:
pen.color = ~pen.color # Bitwise complement ...

Ruby

classPen
definitialize
@color=0
end

# Defines a getter for the @color field
defcolor
@color
end
# Defines a setter for the @color field
defcolor=(value)
@color=value
end
end
pen=Pen.new
pen.color=~pen.color# Bitwise complement

classPen
attr_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 method
end
end
pen=Pen.new
putspen.brand# Accesses the pen brand through the generated getter
pen.size=0.5# Updates the size field of the pen through the generated setter
pen.color=~pen.color

Visual Basic

Visual Basic (.NET 2003–2010)

PublicClassPen

Private_colorAsInteger' Private field
PublicPropertyColor()AsInteger' Public property
Get
Return_color
EndGet
Set(ByValvalueAsInteger)
_color=value
EndSet
EndProperty
EndClass

' Create Pen class instance
DimpenAsNewPen()
' Set value
pen.Color=1
' Get value
DimcolorAsInt32=pen.Color

Visual Basic (only .NET 2010)

PublicClassPen
PublicPropertyColor()AsInteger' Public property
EndClass

' Create Pen class instance
DimpenAsNewPen()
' Set value
pen.Color=1
' Get value
DimcolorAsInt32=pen.Color

Visual Basic 6

' in a class named clsPen
Privatem_ColorAsLong
PublicPropertyGetColor()AsLong
Color=m_Color
EndProperty
PublicPropertyLetColor(ByValRHSAsLong)
m_Color=RHS
EndProperty

' accessing:
DimpenAsNewclsPen
' ...
pen.Color=Notpen.Color

See also

References