Encapsulant les données pour une bonne conception et la maintenabilité à Swift

Considérons le concept de encapsulation, un concept important de la programmation objet # 8208 orientée. L'idée derrière l'encapsulation est que les objets devraient être opaques: Vous ne devriez pas être en mesure de dire ce qui est à l'intérieur des données d'une app, quelles fonctionnalités qu'il contient, ou ce que les opérations qu'elle effectue. Faire ce qui rend vos objets flexibles et réutilisables.

Ce concept a fait ses preuves au fil des ans. L'original # 173-architecture Objectif # 8208-C est composée de cadres d'objets (bien que le mot “ cadre n ° 148; n'a pas été utilisé au début). Les objets étaient opaques afin que les ingénieurs en logiciels ne pouvaient pas regarder à l'intérieur eux (ou, au moins, ils ne devaient pas). Un objet nommé (par exemple) monObjet, a été supposé avoir certaines données - peut-être appelé données - et ces données lui-même était off # 8208-limites pour les développeurs.

Au lieu d'accéder directement aux données, les développeurs ont appris à envoyer un message à monObjet pour obtenir ses données. Par convention, le message serait nommé objectData et provoquerait monObjet pour renvoyer les données de monObjet.

Si vous regardez de plus près à cette conception, monObjet de classe est le objectData est le nom de la fonction ou méthode qui sert de getter. Une autre méthode appelée (par défaut) setObjectData est le setter. Le compositeur prend un seul paramètre (généralement appelé (newObjectData).

Vous ne ferait que l'accès objectData en utilisant soit objectData pour l'obtenir ou setObjectData pour définir ou mettre à jour. L'une des conséquences intéressantes et utiles de cette conception est que objectData (les données stockées par monObjet) Ne doit pas nécessairement exister du tout.

Les accesseurs (objectData et setObjectData) Peuvent travailler avec des données dynamique qui ne peut jamais être réellement stockée. Avec l'encapsulation comme ça, vous ne seriez jamais besoin de savoir si oui ou non les données sont stockées ou calculées à la volée. Tout ce que vous devez savoir est que monObjet obtient des données pour vous avec objectData et prend les données de vous avec setObjectData.

Tant que les deux accesseurs travaillent, que ce soit calculée à la volée, stockées dans une base, ou même stocké sur la lune n'a pas d'importance: monObjet encapsulats ses données.

Autres langues seraient de vous permettre d'accéder aux données directement en utilisant une syntaxe comme myObject.objectData, mais parce que la référence actuelle aux données dans ce cas serait myObject.objectData () - une méthode ou un appel de fonction (notez les parenthèses à la fin) - encapsulation est terminée.

La syntaxe hypothétique indiqué dans les paragraphes précédents est une version générique de la syntaxe moderne ou “ dot syntaxe ” utilisé en Objective-C # 8208 depuis les fin des années 1990 en avant. Utilisation du style original de l'objectif # 8208-C (parfois appelé le format de message) La façon d'envoyer le objectData message monObjet serait avec le code suivant: [monObjet objectData].

Création et préservation de l'encapsulation est devenu une partie importante de développement Objectif # 8208-C. Il est vrai que l'encapsulation conserve bon nombre des fonctionnalités puissantes de l'Objectif # 8208-C et permet la réutilisation de code beaucoup plus facile, mais dans certains cas, l'encapsulation peut être un peu plus compliqué à écrire et prend parfois plus de ressources à exécuter.

Ainsi, bien que la structure ne soit pas particulièrement compliqué, le stockage, la récupération et la mise en valeur d'une variable nécessite trois éléments.

Les éléments de cette structure sont les suivants:

• 
  
  
  
  

  une variable ou un code réelle de le calculer (tout cela est invisible pour vous)

• une méthode de lecture pour obtenir la valeur de la variable (ce qui est visible pour vous)

• une méthode setter pour définir la valeur de la variable (ce qui est visible pour vous)

En Objective-C 8208 # 2 (sorti en 2007), propriétés nommées ont été introduits. Ils constituent un moyen de simplifier cette structure, mais ils sont tout à fait compatible avec elle. Une propriété nommée a un tel format:

property (, nonatomic forte) id detailItem- @ propriété (faible, nonatomic) IBOutletUILabel * detailDescriptionLabel-

La propriété commence avec la directive de compilation property suivie de mémoire et l'utilisation des attributs entre parenthèses, comme fort, faible, lecture seulement, et nonatomic - les significations spécifiques ne comptent pas à ce point.

Voici les attributs entre parenthèses sont le type de la propriété, puis son nom. Pour les types d'objets, un pointeur est utilisé. Le type de classe id est pas un pointeur. Encore une fois, les détails ne sont pas importants à ce stade.

Ce qui importe est que, avec une déclaration de propriété, le compilateur est capable de déclarer automatiquement et créer un variable de support, qui est la variable elle-même où les données sont stockées. Il est également capable de créer un getter et un setter en utilisant les conventions décrites précédemment (le getter est le nom de la variable et le setter est setMyVariable).

Plusieurs conventions entrent en jeu ici. Les noms de variables commencent par une lettre minuscule. Si le nom de la variable se compose de plusieurs mots, mots après le premier commencent avec des majuscules (ce qu'on appelle camelCase). Méthodes et fonctions commencent avec des classes de lettres-minuscules commencent par les lettres majuscules. Les conventions se retrouvent dans le nom d'un compositeur.

Considérons une variable appelée myVariable dont le compositeur est appelé setMyVariable. Cela est conforme à la convention que les méthodes commencent avec des lettres minuscules, et il est également conforme à la convention de camelCase. Cependant, parce que la réunion de ces deux conventions pourrait suggérer le nom setmyVariable, camelCase remplace d'autres conventions.

Ainsi, les propriétés nommées réduire la quantité de frappe nécessaire pour utiliser les propriétés en ayant le compilateur ne le travail de création des getter et setter accesseurs et de créer la variable de support.

Dans certains cas, les développeurs ont besoin de plus de contrôle sur les questions. Les deux cas les plus courants de ce étaient les suivants:

• Quand un développeur a besoin d'une variable de soutien d'avoir un certain nom et doit être en mesure d'y accéder directement.

• Lorsque le compositeur ou le getter doit faire plus que simplement définir ou obtenir la valeur d'une variable.

Voici où la complexité commence à venir.

Le synthétiseur de la propriété automatisé synthétise une variable de support avec le nom de la propriété précédée par un tiret. Ainsi, la valeur par défaut sauvegarde variable pour ma propriété est _ma propriété. (Vous pouvez définir cela comme une option dans la déclaration de propriété.)

Vous pouvez aussi écrire vos propres accesseurs. Il est courant d'avoir eux effectuent des tâches supplémentaires au-delà de leur rôle de simples accesseurs. Un des plus commune de ces tâches est d'établir une connexion de base de données de telle sorte que un getter peut obtenir une valeur précédemment stockée pour sa propriété.

Il ya beaucoup d'autres variations sur cette structure (y compris les propriétés qui ne disposent pas des variables d'accompagnement, mais reposent simplement sur un getter pour calculer ou de récupérer une valeur sur la base que # 8208 nécessaire). Et, pour terminer cette partie de l'image, vous pouvez mélanger et assortir propriétés avec des variables traditionnelles (les variables nus ne font pas partie d'une propriété déclarée).

Un grand nombre des arguments contre l'utilisation de propriétés nommées (et ils ont été amère) centre autour du fait que l'accès à une valeur des propriétés nommées dans la variable de support nécessite plus de ressources de la machine que de simplement accéder à un emplacement de mémoire. Avec les ordinateurs d'aujourd'hui - même dans les appareils mobiles - Cela peut sembler une réaction extrême, mais il est courant dans certains milieux.

Ce, alors, est le monde des propriétés et des variables que les adresses Swift. Que toutes ses complexités et les combinaisons sont nécessaires est la peine de discuter: Tous ont trouvé des utilisations dans les applications et même dans les cadres d'Apple qui composent Cocoa et Cocoa Touch.

Il ya une autre couche de complexité à l'égard des déclarations de # 173-propriétés et les variables. La plupart des déclarations dans les classes de l'Objectif # Code 8208-C sont placées dans un fichier d'en-tête dans le interface section. (Par convention, ce fichier est nommé avec un .h après le nom de la classe.)

Assez récemment (dans les fin des années 2000), il est devenu monnaie courante pour ajouter un deuxième interface section dans le format d'une extension de classe dans le corps principal du fichier de classe (le fichier avec le .m extension). Déclarations dans le fichier d'en-tête peuvent être regroupés en sections avec divers accès - public, privé, et protégé. public et privé interfaces ne sont que cela. protégé éléments de l'interface sont visibles à la classe elle-même et à un de ses sous-classes.

Enfin, à l'intérieur du fichier principal (le .m extension de fichier), vous pouvez accéder à la variable la sauvegarde en utilisant son nom, comme dans _myBackingVariable. Cela évite l'utilisation du getter et enregistre quelques cycles de la machine. Il peut également l'autre # 8208 étape tout # 173-traitement supplémentaire que le getter does- cette convention peut être très utile.

Tel est le contexte des propriétés et des variables en Objective-C # 8208 et maintenant à Swift.