Propriété (programmation) - Property (programming)
Une propriété , dans certains langages de programmation orientés objet , est un type spécial de membre de classe , intermédiaire en fonctionnalité entre un champ (ou un membre de données) et une méthode . La syntaxe pour la lecture et l'écriture des propriétés est la même que pour les champs, mais les lectures et écritures de propriétés sont (généralement) traduites en appels de méthode ' getter ' et ' setter '. La syntaxe de type champ est plus facile à lire et à écrire que de nombreux appels de méthode, mais l'interposition d'appels de méthode "sous le capot" permet la validation des données , la mise à jour active (par exemple, des éléments de l' interface graphique ) ou la mise en œuvre de ce que l'on peut appeler " champs en lecture seule ".
Voir un exemple instructif pour le langage C# ci-dessous.
Accompagnement en langues
Les langages de programmation qui prennent en charge les propriétés incluent ActionScript 3 , C# , D , Delphi / Free Pascal , eC , F# , Kotlin , JavaScript , Objective-C 2.0 , Python , Scala , Swift , Lua et Visual Basic .
Certains langages orientés objet, tels que Java et C++ , ne prennent pas en charge les propriétés et nécessitent plutôt que le programmeur définisse une paire de méthodes d' accesseur et de mutateur .
Oberon-2 fournit un mécanisme alternatif utilisant des indicateurs de visibilité des variables d'objet.
D'autres langages conçus pour la machine virtuelle Java , tels que Groovy , prennent en charge nativement les propriétés.
Bien que C++ n'ait pas de propriétés de première classe, elles peuvent être émulées en raison de la surcharge des opérateurs .
Notez également que certains compilateurs C++ prennent en charge les propriétés de première classe (le compilateur Microsoft C++ par exemple).
Dans la plupart des langages, les propriétés sont implémentées sous la forme d'une paire de méthodes d'accesseur/mutateur, mais accessibles en utilisant la même syntaxe que pour les champs publics. L'omission d'une méthode de la paire génère une propriété en lecture seule ou en écriture seule peu commune .
Dans certains langages sans prise en charge intégrée des propriétés, une construction similaire peut être implémentée en tant que méthode unique qui renvoie ou modifie les données sous-jacentes, selon le contexte de son invocation. De telles techniques sont utilisées par exemple en Perl .
Certains langages (Ruby, Smalltalk) réalisent une syntaxe de type propriété en utilisant des méthodes normales, parfois avec une quantité limitée de sucre syntaxique .
Variantes de syntaxe
Certains langages suivent des conventions de syntaxe bien établies pour spécifier et utiliser formellement les propriétés et les méthodes.
Parmi ces conventions :
- Notation par points
- Notation entre parenthèses
Notation par points
L'exemple suivant illustre la notation par points en JavaScript.
document.createElement('pre');
Notation entre parenthèses
L'exemple suivant illustre la notation entre crochets en JavaScript.
document['createElement']('pre');
Exemple de syntaxe
C#
class Pen
{
private int color; // private field
// public property
public int Color
{
get
{
return this.color;
}
set
{
if (value > 0) {
this.color = value;
}
}
}
}
// 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)"!
Les versions récentes de C# autorisent également les "propriétés implémentées automatiquement" où le champ de sauvegarde de la propriété est généré par le compilateur lors de la compilation. Cela signifie que la propriété doit avoir un setter. Cependant, il peut être privé.
class Shape
{
public Int32 Height { get; set; }
public Int32 Width { get; private set; }
}
C++
C++ n'a pas de propriétés de première classe, mais il existe plusieurs façons d'émuler des propriétés à un degré limité. Dont deux suivent :
#include <iostream>
template <typename T> class property {
T value;
public:
T & operator = (const T &i) {
return value = i;
}
// This template class member function template serves the purpose to make
// typing more strict. Assignment to this is only possible with exact identical types.
// The reason why it will cause an error is temporary variable created while implicit type conversion in reference initialization.
template <typename T2> T2 & operator = (const T2 &i) {
T2 &guard = value;
throw guard; // Never reached.
}
// Implicit conversion back to T.
operator T const & () const {
return value;
}
};
struct Foo {
// Properties using unnamed classes.
class {
int value;
public:
int & operator = (const int &i) { return value = i; }
operator int () const { return value; }
} alpha;
class {
float value;
public:
float & operator = (const float &f) { return value = f; }
operator float () const { return value; }
} bravo;
};
struct Bar {
// Using the property<>-template.
property <bool> alpha;
property <unsigned int> bravo;
};
int main () {
Foo foo;
foo.alpha = 5;
foo.bravo = 5.132f;
Bar bar;
bar.alpha = true;
bar.bravo = true; // This line will yield a compile time error
// due to the guard template member function.
::std::cout << foo.alpha << ", "
<< foo.bravo << ", "
<< bar.alpha << ", "
<< bar.bravo
<< ::std::endl;
return 0;
}
Spécifique à C++, Microsoft et C++Builder
Un exemple tiré de la page de documentation MSDN .
// declspec_property.cpp
struct S
{
int i;
void putprop(int j)
{
i = j;
}
int getprop()
{
return i;
}
__declspec(property(get = getprop, put = putprop)) int the_prop;
};
int main()
{
S s;
s.the_prop = 5;
return s.the_prop;
}
ré
class Pen
{
private int m_color; // private field
// public get property
public int color () {
return m_color;
}
// public set property
public void color (int value) {
m_color = value;
}
}
auto pen = new Pen;
pen.color = ~pen.color; // bitwise complement
// the set property can also be used in expressions, just like regular assignment
int theColor = (pen.color = 0xFF0000);
Dans D version 2, chaque accesseur de propriété ou mutateur doit être marqué avec @property :
class Pen
{
private int m_color; // private field
// public get property
@property public int color () {
return m_color;
}
// public set property
@property public void color (int value) {
m_color = value;
}
}
Delphi/Pascal libre
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 also supports 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.)
*)
CE
class Pen
{
// private data member
Color color;
public:
// public property
property Color color
{
get { return color; }
set { color = value; }
}
}
Pen blackPen { color = black };
Pen whitePen { color = white };
Pen pen3 { color = { 30, 80, 120 } };
Pen pen4 { color = ColorHSV { 90, 20, 40 } };
F#
type Pen() = class
let mutable _color = 0
member this.Color
with get() = _color
and set value = _color <- value
end
let pen = new Pen()
pen.Color <- ~~~pen.Color
JavaScript
function Pen() {
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 () {
return this._color;
},
set: function (value) {
this._color = value;
}
}
});
var pen = new Pen();
pen.color = ~pen.color; // bitwise complement
pen.color += 1; // Add one
ActionScript 3.0
package {
public class Pen {
private var _color:uint = 0;
public function get color():uint {
return _color;
}
public function set color(value:uint):void {
_color = value;
}
}
}
var pen:Pen = new Pen();
pen.color = ~pen.color; // bitwise complement
pen.color += 1; // add one
Objectif-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
L'exemple ci-dessus pourrait être utilisé dans une méthode arbitraire comme celle-ci :
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
{
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
Les propriétés ne fonctionnent correctement que pour les classes de nouveau style (classes qui ont objectcomme superclasse ), et ne sont disponibles qu'en Python 2.2 et plus récent (voir la section correspondante du tutoriel Unifier les types et les classes en Python 2.2 ). Python 2.6 a ajouté une nouvelle syntaxe impliquant des décorateurs pour définir les propriétés.
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()
# Accessing:
pen.color = ~pen.color # Bitwise complement ...
Rubis
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
end
end
pen = Pen.new
pen.color = ~pen.color # Bitwise complement
Ruby fournit également des synthétiseurs getter/setter automatiques définis comme méthodes d'instance de 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
end
end
pen = Pen.new
puts pen.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)
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 instance
Dim pen As New Pen()
' Set value
pen.Color = 1
' Get value
Dim color As Int32 = pen.Color
Visual Basic (uniquement .NET 2010)
Public Class Pen
Public Property Color() As Integer ' Public property
End Class
' Create Pen class instance
Dim pen As New Pen()
' Set value
pen.Color = 1
' Get value
Dim color As Int32 = pen.Color
Visual Basic 6
' in a class named clsPen
Private m_Color As Long
Public Property Get Color() As Long
Color = m_Color
End Property
Public Property Let Color(ByVal RHS As Long)
m_Color = RHS
End Property
' accessing:
Dim pen As New clsPen
' ...
pen.Color = Not pen.Color