Propriété (informatique)

En programmation orientée objet ou en Resource Description Framework, une propriété est un élément de description d'un objet. Un type de classe regroupe, entre autres, l'ensemble des propriétés communes à un type d'objet.

Une propriété, dans certains langages de programmation orientés objet, est une sorte de membre de classe. Il se traduit par un champ du point de vue de l'interface d'une classe, mais auquel sont adjoints une ou plusieurs méthodes, dites accesseurs et mutateurs, vouées à lire (get / accesseur) et modifier (set / mutateur) la valeur du champ de l'instance.

Le champ de la propriété peut selon le langage se traduire par un attribut, éventuellement homonyme des accesseurs (getter ou setter).

Utilisation des propriétés

L'usage courant des propriétés est de pouvoir rajouter des instructions appliquées systématiquement au moment de la modification ou de la lecture de toute instance d'une classe sans pour autant modifier l'interface de cette classe.

Les propriétés sont également utilisées pour contrôler l’accès au champ, en rendant celui-ci private pour forcer l'usage aux accesseurs, dans lesquels des contrôles de cohérence peuvent être insérés.

Cette faculté permissive est cependant source de risques, notamment du fait qu'elle permet de modifier les valeurs d'attribut(s) lors d'opération vouée normalement à leur lecture.

Exemples de syntaxe

Propriétés en C#

class Pen {
    private int m_Color; // private field
    
    public int Color {  // public property
        get
        {
            return m_Color;
        }
        set 
        {
            m_Color = value;
        }
    }
}

// accessing:
Pen pen = new Pen();
// ...
pen.Color = ~pen.Color; // bitwise complement ...
// another silly example:
pen.Color += 1; // a lot clearer than "pen.set_Color(pen.get_Color() + 1)"!

Les dernières versions de C# autorisent de plus les "auto-implemented properties", pour lesquelles le champ sous-jacent à la propriété est généré par le compilateur à la compilation. Ceci implique que la propriété ait un 'setter', éventuellement privé.

class Shape {
    
    public Int32 Height { get; set; }
    public Int32 Width  { get; private set; }
    
}

Propriétés en C++

C++ n'a pas de propriétés de classe, mais il existe plusieurs manières d'imiter les propriétés dans une certaine limite. Voici deux exemples :

#include <iostream>
template <typename T> class property {
        T value;
    public:
        T & operator = (const T &i) {
            ::std::cout << i << ::std::endl;
            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.
        template <typename T2> T2 & operator = (const T2 &i) {
            ::std::cout << "T2: " << i << ::std::endl;
            T2 &guard = value;
            throw guard; // Never reached.
        }
        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;
}

Propriétés en C++, Microsoft & C++Builder-specific

Un exemple tiré de la MSDN documentation page:

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

Propriétés en Objective-C 2.0

 
@interface Pen : NSObject {
   NSColor *color;
}
@property(copy) NSColor *color;        // color values always copied.
@end
@implementation Pen
@synthesize color;                     // synthesize accessor methods.
@end
// Example Usage
Pen *pen = [[Pen alloc] init];
pen.color = [NSColor blackColor];
float red = pen.color.redComponent;
[pen.color drawSwatchInRect:NSMakeRect(0, 0, 100, 100)];

Notez que le moderne Objective-C runtime peut convertir les variables d'instance en propriétés, d'où la déclaration explicite des variables d'instance qui n'est pas nécessaire, mais toujours possible.

Propriétés en langage D

class Pen
{
    private int m_color; // private field
    
    // public get property
    public int color () {
        return m_color;
    }
    
    // public set property
    public int color (int value) {
        return 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é 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 int color (int value) {
        return m_color = value;
    }
}

Propriétés en Delphi/Free Pascal

type TPen = class
  private
    m_Color: Integer;
    function Get_Color: Integer;
    procedure Set_Color(RHS: Integer);
  public
    property Color: Integer read Get_Color write Set_Color;
end;
function TPen.Get_Color: Integer;
begin
  Result := m_Color
end;
procedure TPen.Set_Color(RHS: Integer);
begin
  m_Color := RHS
end;

// accessing:
var pen: TPen;
// ...
pen.Color := not pen.Color;
(*
Delphi also supports a 'direct field' syntax -
property Color: Integer read m_Color write Set_Color;
or
property Color: Integer read Get_Color write m_Color;
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.)
*)

Propriétés en 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

Propriétés en JavaScript ES2015[1]

class Pen() {
    constructor() {
        this._color = 0;
    }
    get color() {
        return this._color;
    }
    set color(value) {
        this._color = value;
    }
}

Propriétés en JavaScript ES5

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

Propriétés en PHP

class Pen {
    private $_color;
    function __set($property, $value) {
        if ($property == 'Color') { 
            return $this->_color = $value;
        }
    }
    function __get($property) {
        if ($property == 'Color') {
            return $this->_color;
        }
    }
}

$p = new Pen();
$p->Color = ~$p->Color; // bitwise complement
echo $p->Color;

Propriétés en Python

Les propriétés ne fonctionnent correctement que pour les nouveaux types de classe qui sont uniquement disponibles en Python 2.2 ou plus récents. Python 2.6 ajoute une nouvelle syntaxe pour définir les propriétés.

class Pen(object):
    def __init__(self):
        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 ...

Propriétés en Ruby

class Pen
    def initialize
        @color = 0
    end
    # there is actually a shortcut for these: attr_accessor :color will
    # synthetise both methods automatically, it was expanded for
    # compatibility with properties actually worth writing out
    def color
        @color
    end
    def color = value
        @color = value
    end
end
pen = Pen.new
pen.color = ~pen.color

Propriétés en Visual Basic (.NET to 2010)

Public Class Pen
 
    Private m_Color As Integer ' Private field
    Public Property Color As Integer ' Public property
        Get
            Return m_Color
        End Get
        Set(ByVal Value As Integer)
            m_Color = Value
        End Set
    End Property
End Class

' accessing:
Dim pen As New Pen()
' ...
pen.Color = Not pen.Color

Propriétés en 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

Voir aussi

Interface (informatique)

Notes et références

(en) « ECMAScript 2015 Language Specification », sur ecma-international.org (consulté le 10 avril 2023).

Cet article est issu de wikipedia. Text licence: CC BY-SA 4.0, Des conditions supplémentaires peuvent s’appliquer aux fichiers multimédias.