Property (programming) explained

A property, in some object-oriented programming languages, is a special sort of class member, intermediate in functionality between a field (or data member) and a method. 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, yet the interposition of method calls "under the hood" allows for data validation, active updating (e.g., of GUI elements), or implementation of what may be called "read-only fields".

Support in languages

Programming languages that support properties include ActionScript 3, C#, D, Delphi/Free Pascal, eC, F#, Kotlin, JavaScript, Objective-C 2.0, Python, Scala, Swift, Lua, and Visual Basic.

Some object-oriented languages, such as Java and C++, do not support properties, requiring the programmer to define a pair of accessor and mutator methods instead.^[1]

Oberon-2 provides an alternative mechanism using object variable visibility flags.

Other languages designed for the Java Virtual Machine, such as Groovy, natively support properties.

While C++ does not have first class properties, they can be emulated with operator overloading.^[2]

Also note that some C++ compilers support first class properties as language extensions.

• In Microsoft Visual Studio,^[3] GCC, and llvm/clang,^[4] the __declspec(property) creates properties similar to C#.
• Borland C++ and Borland/CodeGear/Embarcadero C++Builder use the __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 a read-only or an uncommon write-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. in Perl.

Some languages (Ruby, Smalltalk) achieve property-like syntax using normal methods, sometimes with a limited amount of syntactic sugar.

Syntax variants

Some languages follow well-established syntax conventions for formally specifying and utilizing properties and methods.

Among these conventions:

• Dot notation
• Bracket notation

Dot notation

The following example demonstrates dot notation in JavaScript.

document.createElement('pre');

Bracket notation

The following example demonstrates bracket notation in JavaScript.

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

Example syntax

C#

class Pen

// accessing:Pen pen = new Pen;int color_tmp = 0;// ...pen.Color = 17;color_tmp = 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.

class Shape

C++

C++ does not have first class properties, but there exist several ways to emulate properties to a limited degree. Two of which follow:

Using Standard C++

1. include

template class property ;

struct Foo ;

struct Bar ;

int main Also see Stack Overflow for a more detailed example.

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

An example taken from the MSDN documentation page.

// declspec_property.cppstruct S

int main

D

class Pen

auto pen = new Pen;pen.color = ~pen.color; // bitwise complement

// the set property can also be used in expressions, just like regular assignmentint theColor = (pen.color = 0xFF0000);

In D version 2, each property accessor or mutator must be marked with @property:

class Pen

Delphi/Free Pascal

type TPen = class private FColor: TColor; function GetColor: TColor; procedure SetColor(const AValue: TColor); public property Color: Integer read GetColor write SetColor;end;

function TPen.GetColor: TColor;begin Result := FColor;end;

procedure TPen.SetColor(const AValue: TColor);begin if FColor <> AValue then FColor := AValue;end;

// accessing:var Pen: TPen;// ...Pen.Color := not Pen.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 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.)

• )

eC

class Pen Pen blackPen ;Pen whitePen ;Pen pen3 ;Pen pen4 ;

F#

type Pen = class let mutable _color = 0

member this.Color with get = _color and set value = _color <- valueendlet pen = new Penpen.Color <- ~~~pen.Color

JavaScript

function Pen // Add the property to the Pen type itself, can also// be set on the instance individuallyObject.defineProperties(Pen.prototype,);var pen = new Pen;pen.color = ~pen.color; // bitwise complementpen.color += 1; // Add one

ActionScript 3.0

package var pen:Pen = new Pen;pen.color = ~pen.color; // bitwise complementpen.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@synthesize colour; // 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 = Pen alloc init];pen.colour = [NSColor blackColor];float red = pen.colour.redComponent;[pen.colour drawSwatchInRect: NSMakeRect(0, 0, 100, 100)]

PHP

class Pen $p = new Pen;$p->color = ~$p->color; // Bitwise complementecho $p->color;

Python

Properties only work correctly for new-style classes (classes that have object as a superclass), and are only available in Python 2.2 and newer (see the relevant section of the tutorial Unifying types and classes in Python 2.2). Python 2.6 added a new syntax involving decorators for defining properties.

class Pen: def __init__(self) -> None: self._color = 0 # "private" variable

@property def color(self): return self._color

@color.setter def color(self, color): self._color = color

pen = Pen

1. Accessing:

pen.color = ~pen.color # Bitwise complement ...

Ruby

class Pen def initialize @color = 0 end # Defines a getter for the @color field def color @color end

# Defines a setter for the @color field def color=(value) @color = value endend

pen = Pen.newpen.color = ~pen.color # Bitwise complement

Ruby also provides automatic getter/setter synthesizers defined as instance methods of Class.

class Pen 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)

def initialize @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 endend

pen = Pen.newputs pen.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

Visual Basic

Visual Basic (.NET 2003–2010)

Public Class Pen Private _color As Integer ' Private field

Public Property Color As Integer ' Public property Get Return _color End Get Set(ByVal value As Integer) _color = value End Set End Property

End Class

' Create Pen class instanceDim pen As New Pen

' Set valuepen.Color = 1

' Get valueDim color As Int32 = pen.Color

Visual Basic (only .NET 2010)

Public Class Pen

Public Property Color As Integer ' Public property

End Class ' Create Pen class instanceDim pen As New Pen

' Set valuepen.Color = 1

' Get valueDim color As Int32 = pen.Color

Visual Basic 6

' in a class named clsPenPrivate m_Color As Long

Public Property Get Color As Long Color = m_ColorEnd Property

Public Property Let Color(ByVal RHS As Long) m_Color = RHSEnd Property

' accessing:Dim pen As New clsPen' ...pen.Color = Not pen.Color

See also

• Attribute (computing)
• Bound property
• Field (computer science)
• Indexer (programming)
• Method (computer programming)
• Mutator method
• Uniform access principle

Notes and References

1. Web site: Accessors And Mutators In Java . C# Corner - Community of Software and Data Developers . 5 January 2022.
2. Web site: Portability of Native C++ properties . Stack Overflow . Stack Overflow . 5 January 2022.
3. Web site: property (C++) . Microsoft technical documentation . Microsoft . 5 January 2022 . 21 November 2021.
4. Web site: clang::MSPropertyDecl Class Reference . Clang: a C language family frontend for LLVM . 5 January 2022.
5. Web site: __property Keyword Extension . Embarcadero/IDERA Documentation Wiki . 5 January 2022.