Création d’une classe en PowerShell

Qu’est-ce qu’une classe ?

Si tu te retrouves sur cette page, c’est que, je suppose, tu viens d’effectuer une recherche Google avec les mots-clés « classe » et « PowerShell » et que par conséquent tu comprends assez bien la notion de classe.

Sinon, pour faire simple, une classe est une collection d’objets. D’ailleurs, en développement on parle de langage orienté objet pour désigner n’importe quel langage qui intègre la notion de classe dont je vais t’expliquer tout de suite. Un peu de patience.

Prenons un objet de la vie de tout les jousr, n’importe lequel. Allez un « vélo » ! Un vélo est un objet constitué d’un « cadre », deux « roues », une « chaine », un « pédale » et un « guidon » et beaucoup d’autres petites pièces sans importance. Je rigole ?

Une « classe » en développement, est la modélisation théorique de ton vélo. En gros c’est la reprise de la phrase ci-dessus en langage de développement. Ça ressemble à ça en powerShell.

class Velo
{
    $cadre
    $roues
    $chaine
    $pedale 
    $guidon
}

Oui ! c’est ça, rien de sorcier. Tu mets le mot-clé « class » puis le nom de ta classe ici « Velo » et tu déclares autant de variables que tu veux entre crochets. J’entends la voix au fond de toi répéter : mais à quoi ça sert ?

Imaginez que vous vous voulez créer 2 vélos dans votre code. Ils n’iront pas loin j’avoue mais l’idée est là. ?

Pour créer 2 vélos il faudra répéter chaque variable deux fois « $cadre1, $cadre2, $roues1, $roues2… » Imagines toi créer 10 vélos, quoi . Tu veux créer 50 vélos . Ce serait possible mais je te rassure que le scriptage ne servirait presque à rien. Si je dois passer trois heures à écrire un script pour économiser deux heures de travail. Autant se mettre sur le travail lui-même.

Avec la classe créé ci-dessus. Il suffirait d’écrire le code suivant pour générer 1000 vélos à vendre à 1€ la pièce sur le boncoin. ?

class Velo
{
    $cadre
    $roues
    $chaine
    $pedale 
    $guidon
}

$mesMilleVelos = @{} 

for ($i = 0; $i -lt 1000; $i++)
{
    $veloTemp = [Velo]::New()
    $mesMilleVelos[$i] = $veloTemp
}  

Tu as reconnu reconnu la classe. La ligne suivante sert à #Initier une hashtable vide dans laquelle nous allons stocker les vélos dans une relation clé/valeur. (Si tu ne sais pas t’en servir je t’invite à consulter la doc Microsoft ici)

Ensuite on fait tourner une boucle mille fois. Je suppose que tu n’as pas besoin d’explication sur les boucles PowerShell. Sinon il faudrait peut-être commencer par apprendre les bases.
En fin les deux lignes qui nous intéressent vraiment :

$veloTemp = [Velo]::New()  #on initialise un vélo vide  
$mesMilleVelos[$i] = $veloTemp #ici on ajoute le vélo créer dans notre hashtable* 

*Le premier vélo aura comme clé 0, le deuxième 1 ainsi de suite jusqu’au 1000eme vélo qui aura la clé 999.
Par la suite, pour récupérer un vélo dans le hashtable, il suffit de faire $mesMilleVelos[20] (ici on récupère le 19eme vélo)

Et pour modifier le « cadre » on fera :

$mesMilleVelos[20].cadre = « cadre en bois »

C’est exactement comme si on avait créé un vélo isolé sans l’ajouter dans une collection (hashtable)

$velo1 = [Velo]::New()  #création d’un vélo 
#Pour modifier le cadre je fais 
$vélo1.cadre = "cadre en titane"

Pour les autres variables il suffit de faire pareil. $vélo1.roues, $vélo1.chaines….
Il est possible de faire en sorte qu’on puisse renseigner les informations du vélo dès sa création.

Pour ça on crée ce qu’on appelle « constructeur ». Comme son nom l’indique c’est la fonction qui sert à créer l’objet. En effet, pour chaque classe, il y en a un par défaut qui crée des objets vides. On peut créer le nôtre afin de maitriser son comportement. Voilà la même classe avec un constructeur.

class Velo
{
    $cadre
    $roues
    $chaine
    $pedale 
    $guidon	
	
    Velo($ca, $ro, $ch, $pe, $gu)
    {
       		$this.cadre = $ca
		$this.roues = $ro
		$this.chaine = $ch
		$this.pedale = $pe
		$this.guidon = $gu
    } 
}

On constate que le constructeur porte le même nom que la classe et il attend autant de variable que les variables de la classe. On aurait pu se limiter à ce qu’on veut pour n’avoir que ces variables qui auront des données à la création d’un objet.

Les noms des variables du constructeur ($ca, $ro, $ch, $pe, $gu) peuvent être nommés n’importe comment tant qu’il respecte les règles de nommages des variables.
Le mot-clé « $this » sert à dire dans cette classe, récupère moi le variable « cadre »

Maintenant pour créer un vélo avec des données on peut faire.

$velo1 = [Velo]::New(« bois », »bambou », »Acier », »bambou », »bois »)

Voilà un vélo qui vaut une fortune. Notre classe est fonctionnelle. On peut lui ajouter d’autre fonction pour donner à notre vélo des actions à faire comme pédaler, tourner le guidon etc. À vous d’imaginer le code à écrire à l’intérieur.

Attention : en créant un constructeur avec des arguments nous ne pouvons plus créer des objets sans leur passer d’argument. Pour rendre cela possible il suffit de déclarer notre constructeur vide après ou avant le constructeur avec argument.

Velo() {}

En faisant cela on peut de nouveau créer des objets vides comme des objets avec arguments :

$objetvide = [Velo]::New()
$objetavecargument = [Velo]::New($ca, $ro, $ch, $pe, $gu)

La classe que nous avons ici peut nous être très utile dans certains cas. Imagines-toi travailler chez un fabricant de vélos et que tu as un dossier dans lequel se trouvent une cinquantaine de fichier Excel décrivant les modèles de vélos à créer et à l’intérieur de chaque fichier les données qui serviront à créer tes vélos sont localisés à des cellules précises : « cadre », deux « roues », une « chaine », un « pédale » et un « guidon ». Tu dois extraire ces données et les regrouper dans un seul fichier.

Attention l’idée que les données à récupérer soient localisés à des cellules précises comme dans l’image ci-dessous est très importante car si les données étaient organisées en forme de colonne filtrable facilement on aurait recours à une autre méthode.

Comme on peut constater dans l’image ci-dessus les donnés à récupérer sont localisés comme suit :

$cadre = B11
$roues = B22
$chaine = E30
$pedale = H29
$guidon = J14

L’exercice est de récupérer ces données dans les 50 fichiers Excel à traiter et en faire un seul fichier une entête comme suit :

nous n’allons pas nous prêter à l’exercice sinon l’article serait long. L’idée et la suivante :

1. Tu crées une collection astable $mesmillevelos =@{;
2. Tu enregistres dans une variable le répertoire du dossier dans lequel se trouvent les fichiers Excel
3. Tu crées une boucle qui va ouvrir un fichier Excel à la fois et à l’intérieur :
   • Tu crées des variables temporaires qui contiennent chacune une donnée des cellules recherchées sur Excel. supposons : $ca, $ro, $ch, $pe, $du
   • Tu crées ensuite un vélo avec les données précédents $velotemp = [Velo]: : New($ca, $ro, $ch, $pe, $du)
   • Tu ajoutes le vélo dans la collection $mesmillevelos[$i] = $velotemp

La boucle tourne jusqu’à ce qu’il ait plus de fichier.
Enfin cette ligne de code enregistrera ta collection de vélo dans un fichier Excel au format CSV:

$ mesMilleVelos.GetEnumerator() | ForEach-Object { $_.Value } | Export-Csv -Path "path" -Delimiter ";"

Remplacer « path » par le répertoire où enregistrer le fichier par exemple : « C://dosier/mesvelos.csv »