Dans ce tutoriel Sketchup, nous traitons Ruby pour Sketchup. Après avoir vu les nombres et les chaînes, nous parlons de variables, de constantes et de tableaux. Ce sont des concepts et des définitions de base dans l’étude des langages de programmation. Également important pour apprendre les bases de la création de scripts dans Sketchup.

Ruby pour Sketchup : Table des matières

• Variables et constantes
• Variables
• Constantes
• Les tableaux
• Accès aux éléments du tableau
• Opérations de base sur les tableaux
• Méthodes de tableau

Puisque nous en sommes au troisième article consacré au guide Ruby pour Sketchup, en plus de l’introduction, nous dirons qu’il convient d’apporter le lien vers les articles déjà vus. De cette façon, si vous tombez sur ici à partir de la recherche sur le Web, vous pourrez trouver les messages passés.

• Introduction à Ruby pour Sketchup
• Ruby pour Sketchup : nombres et opérateurs numériques
• Scripts Sketchup : chaînes

Par ailleurs, pour en savoir plus, il est utile de se souvenir du guide Ruby sur le site html.it

Variables et constantes
Dans le Ruby Guide for Sketchup, nous avons traité des nombres et des chaînes bruts jusqu’à présent, mais nous nommons généralement les données et opérons sur les noms plutôt que sur les données brutes. Dans Ruby, les données nommées se répartissent en deux catégories : les variables et les constantes. Cette leçon explique comment ils sont utilisés et les différences entre eux.

Variables
Dans les scripts SketchUp, il est plus pratique de travailler avec des noms plutôt que des nombres. Par exemple, si vous voulez changer la hauteur d’une porte de 210 à 220 cm, vous ne voudrez certainement pas changer chaque occurrence.

Il est plus facile d’utiliser un nom de souris door_height. Ainsi, vous pouvez facilement modifier toutes les valeurs de hauteur : définissez simplement door_height sur 220 sur une ligne et cette valeur sera valide pour toutes les occurrences utilisées.

Dans la console, affectez 2 à la variable x avec la commande simple suivante :

x = 2

SketchUp réserve de la mémoire pour la variable x ; dans la mémoire allouée, il y met 2. Vous pouvez maintenant opérer sur cette variable comme s’il s’agissait d’un nombre normal. Par exemple

x + 5 donne 7
x * 2 renvoie 4
x ** 3 donne 8
Dans ces opérations, x conserve sa valeur après chaque commande. Pour modifier la valeur d’une variable, vous devez procéder comme suit :

x = x + 1
x = x – 3
x = x * 7
x = x / 9
Vous pouvez obtenir les mêmes résultats avec les abréviations Ruby :

x + = 1
x – = 3
x * = 7
x / = 9
Les opérations vues sont basées sur des nombres entiers, mais si vous le souhaitez, vous pouvez définir x pour qu’il soit égal à une valeur à virgule flottante ou à une chaîne. Par exemple, les commandes suivantes créent une variable contenant « Hello » et utilisent l’opérateur d’ajout de chaîne, +, pour ajouter une autre chaîne :

str = "Salut"

Bonjour; salut

str + = ", monde!"

Bonjour le monde!

Les noms de variables x et door_height partagent une caractéristique importante : ils commencent tous les deux par une lettre minuscule.

En Ruby, une variable peut commencer par le trait de soulignement ou n’importe quelle lettre minuscule, mais pas par une lettre majuscule. Si les données reçoivent un nom avec une majuscule, Ruby l’interprète comme une constante, ce qui sera expliqué plus tard.

Constantes
Il existe des cas où les valeurs ne doivent pas être modifiées. Par exemple, p (pi-grec) sera toujours égal à environ 3,14159 et il y aura toujours 2,54 centimètres dans un pouce. Dans ces cas, l’utilisation d’une variable n’est pas une bonne idée car sa valeur pourrait être modifiée lors de l’exécution d’un script.

Pour cette raison, Ruby fournit des constantes qui fonctionnent comme des variables et peuvent être affectées aux mêmes types de valeurs. Mais si la valeur d’une constante est réaffectée, Ruby vous avertit que la valeur a été modifiée.

Pour vérifier son fonctionnement, essayez d’entrer les deux commandes dans la fenêtre de la console :

X = 8

X + = 2

Après avoir exécuté ces deux lignes, Sketchup affiche le message résultant dans la console Ruby : “X déjà initialisé”.

Malgré l’avertissement, la deuxième commande modifie la valeur de X de 8 à 10.

Si vous répétez ces commandes avec x (minuscule) au lieu de X, aucun avertissement ne s’affichera. En effet, Ruby utilise la première lettre de la structure de données pour distinguer les constantes des variables. Si la première lettre est en majuscule, Ruby la traite comme une constante. S’il est en minuscule, Ruby le traite comme une variable.

Les tableaux
Chaque point, ligne et forme d’un dessin SketchUp est basé sur trois valeurs pour les coordonnées x, y et z. Plutôt que de traiter les coordonnées comme des nombres uniques, il est plus facile de les mettre dans des collections appelées tableaux.

Un tableau est une structure de données qui contient une séquence ordonnée de valeurs appelées éléments. Les tableaux sont similaires aux chaînes que nous avons vues précédemment, mais bien qu’une chaîne soit composée de caractères, un tableau peut contenir n’importe quoi, y compris des nombres, des chaînes, des variables, des constantes et même d’autres tableaux.

Tout comme les chaînes sont entourées de guillemets simples ou doubles, les tableaux sont placés entre crochets. Par exemple, la commande suivante crée un tableau de sept éléments :

arr = [1, 2, "ab", 4.0, 'Hello', 6.0, [1, 2, 3]]

Un tableau appelé arr est créé dont les éléments sont 1, 2, “ab”, 4.0, ‘Hello’ et [1, 2, 3].

Ruby pour sketchup / Accès aux éléments du tableau

Chaque élément du tableau est accessible en fonction de sa position : il part de la position 0. La position d’un élément est appelée l’index. La commande suivante accède à l’élément arr dont l’indice est égal à 2 :

x = arr [2]

La commande suivante à la place, définit la valeur du quatrième élément, dont l’indice est égal à 3 :

arr [3] = 12

Les indices des éléments du tableau suivent les mêmes règles que celles observées pour les chaînes. L’index 0 représente le premier élément, l’index 1 représente le deuxième élément et l’index 2 représente le troisième élément.

Les indices négatifs accèdent aux éléments à partir de la fin du tableau. C’est-à-dire qu’un indice de -1 renvoie le dernier élément du tableau, -2 renvoie l’avant-dernier élément du tableau et ainsi de suite.

Comme pour les chaînes, il est possible d’accéder à plusieurs éléments du tableau en définissant une plage d’indices. Cela peut être fait en plaçant deux ou trois points entre les valeurs de début et de fin.

Les exemples montrent l’accès aux éléments du tableau arr défini précédemment :

arr [2..5]

renvoie “ab”, 4.0, “Bonjour”, 6.0]

arr [0 … 3]

renvoie [1, 2, “ab”]

arr [-6 ..- 4]

renvoie [2, “ab”, 4.0]

Vous pouvez également définir un index principal et identifier le nombre d’éléments supplémentaires devant être présents dans le sous-tableau. La commande suivante forme un sous-tableau avec quatre éléments commençant par l’élément dans l’index 2 :

x = arr [2, 4]

renvoie [“ab”, 4.0, “Bonjour”, 6.0]

Cette commande définit x égal à un tableau contenant les éléments “ab”, 4.0, “Hello” et 6.0. Notez la différence entre l’écriture [2..4] et [2, 4]. Gardez cela à l’esprit si vous rencontrez des erreurs relatives à l’intervalle.

Ruby pour sketchup : opérations de base sur les tableaux

Ruby propose plusieurs manières de manipuler les tableaux, et nombre d’entre elles sont exactement similaires aux opérations sur les chaînes décrites ci-dessus. Le tableau 1 répertorie six opérateurs avec des descriptions et des exemples de leur utilisation.

Opérateur	Description	Exemple
+	Compone i due array in uno più grande	[6, 7] + [“aa”, “bb”, “cc”] -> [6, 7, “aa”, “bb”, “cc”]
–	Supprimer les éléments du deuxième tableau du premier	[1, 2, 3, 4] – [1, 2] -> [3, 4]
*	Éléments en double d’un tableau	[a, b] * 3 -> [a, b, a, b, a, b]
<<	Suspend” un élément à la fin du tableau	[x, y, 12] << 13 -> [x, y, 12, 13]
|	Fusionner deux tableaux sans dupliquer	[1, 2, 3] | [2, 3, 4] -> [1, 2, 3, 4]
&	Tableaux “Intersect” : ne laisser que les éléments en double	[1, 2, 3] & [2, 3, 4] -> [2, 3]

Dans la troisième colonne, les éléments du tableau comprennent des noms textuels contenus entre guillemets (“aa” et “bb”) et des lettres contenues sans guillemets (x et y). Comme indiqué ci-dessus, les noms sans guillemets sont utilisés pour identifier les variables et les constantes et doivent être initialisés avant d’être insérés dans un tableau.

Le troisième opérateur, *, est particulièrement utile lorsque vous souhaitez initialiser chaque élément d’un tableau avec la même valeur. Par exemple, la commande suivante remplit zero_array avec douze zéros :

zero_array = [0] * 12

L’opérateur << ajoute un élément à la fin d’un tableau. Si le deuxième argument est un autre tableau, ce tableau deviendra un élément unique du premier tableau. Par exemple, la commande

[1, 2, 3] << [4, 5, 6]

renvoie [1, 2, 3, [4, 5, 6]], pas [1, 2, 3, 4, 5, 6]. Le deuxième tableau est « imbriqué » à la quatrième place du premier tableau.

Si vous souhaitez ajouter les éléments du deuxième tableau, vous devez utiliser la méthode concat décrite ci-dessous.

Les deux derniers opérateurs peuvent prêter à confusion, alors méfiez-vous.

L’opérateur | concatène les tableaux d’entrée et supprime les doublons de la concaténation. Autrement dit, si les deux tableaux d’entrée contiennent x et y, le résultat ne contiendra qu’une instance de x et y.

L’opérateur &, d’autre part, crée un tableau composé uniquement d’éléments en double. Si x et y sont les seuls doublons dans les tableaux d’entrée, le résultat de l’opérateur & ne contiendra que x et y.

Ruby pour sketchup : Méthodes de tableau

Les tableaux Ruby ont des méthodes qui peuvent être appelées comme les méthodes String décrites précédemment. Le tableau 2 répertorie douze méthodes importantes et d’autres méthodes seront introduites si nécessaire.

Opérateur	Description	Exemple
new	Créer un nouveau tableau	num_list = Array.new(30)
length	Renvoie le nombre d’éléments du tableau	[1, 2, 3, 4].length -> 4
index	Renvoie l’index de la valeur de l’élément donné	[1, 2, 3].index(1) -> 0
concat	Concaténer deux tableaux	[1, 2, 3].concat([4, 5]) -> [1, 2, 3, 4, 5]
delete_at	Supprimer un élément du tableau par index	a = [1, 2, 3] a.delete_at(1) a -> [1, 3]
delete	Supprimer un élément du tableau par valeur d’élément	a = [1, 2, 3] a.delete(1) a -> [2, 3]
clear	Supprimer tous les éléments du tableau	[“a”, “b”, “c”].clear -> []
uniq	Supprimer les éléments en double du tableau	[1, 1, 2, 2, 3].uniq -> [1, 2, 3]
fill	Remplacer les éléments du tableau par une valeur	[1, 2, 3].fill(7) -> (7, 7, 7)
sort	Trier les éléments du tableau	[“ab”, “yz”, “wx”, “ac”].sort -> [“ab”, “ac”, “wx”, “yz”]
first	Renvoie le premier élément du tableau	[1, 2, 3].first -> 1
last	Renvoie le dernier élément du tableau	[1, 2, 3].last -> 3

La nouvelle méthode crée de nouveaux tableaux. Il peut être utilisé de trois manières différentes, comme le montrent les exemples suivants :

num_list = Array.new 20 – crée un tableau avec une certaine taille sans initialiser ses éléments ;
num_list = Array.new 4, “xyz” – crée un nouveau tableau avec quatre éléments, chacun étant défini sur “xyz” ;
num_list = Array.new old_list – crée un nouveau tableau avec les mêmes éléments que ceux du tableau old_list ;
La méthode de longueur identifie le nombre d’éléments présents dans le tableau. L’index renvoie la position associée à une valeur d’élément donnée. C’est l’inverse de l’utilisation normale du tableau, qui renvoie la valeur de l’élément associé à un indice.

La méthode concat est similaire à l’opérateur + du tableau 1 et ajoute des éléments d’un tableau à la fin du deuxième tableau. La différence est que + crée un troisième tableau pour stocker le résultat concaténé et concat modifie le deuxième tableau.

Les commandes suivantes montrent comment il est utilisé :

first_array = [5, 4, 3, 2, 1]
second_array = [8, 7, 6].concat (first_array)

la deuxième ligne de code ajoute les éléments de first_array à la fin de second_array, qui est maintenant égal à [8, 7, 6, 5, 4, 3, 2, 1].

Les méthodes delete_at et delete suppriment toutes deux des éléments du tableau, mais elles fonctionnent de différentes manières. La méthode delete_at supprime un élément du tableau à un index spécifique, tandis que la méthode delete supprime tous les éléments avec une valeur spécifique.

Les exemples montrent comment ces deux méthodes sont utilisées :

test = [10, “x”, 9, “x”, 8, “y”, “x”]

test.delete_at 4

vous obtenez test = [10, “x”, 9, “x”, “y”, “x”]

test.supprimer “x”

on obtient test = [10, 9, “y”]

La méthode delete_at supprime le cinquième élément du tableau, dont la valeur est 8. La méthode delete supprime les éléments dont la valeur est égale à “x”.

La méthode uniq supprime les éléments en double d’un tableau et la méthode clear supprime tous les éléments d’un tableau, renvoyant un tableau vide. La méthode fill définit les éléments d’un tableau égaux à une valeur donnée.

Cette méthode peut être utilisée de quatre manières principales, comme le montrent les commandes suivantes :

fill_test = [1, 2, 3, 4, 5, 6]

fill_test.fill 9 définit tous les éléments égaux à 9

fill_test.fill 10, 0..2 définit le premier au troisième élément égal à 10

fill_test.fill 21, 4, 2 définit deux éléments égaux à 21, en commençant par l’élément 4

La méthode de tri place les éléments du tableau dans l’ordre numérique ou alphabétique, mais uniquement si tous les éléments sont numériques ou tous alphabétiques.

La première méthode renvoie le premier élément du tableau tandis que la dernière renvoie le dernier. Ces méthodes peuvent être répliquées en accédant aux index de tableau 0 et -1, respectivement.
En savoir plus sur ce texte source