Fonctionnement de Powershell Foreach, While et autres boucles

Une première étape cruciale dans l'apprentissage de la programmation consiste à travailler avec des boucles. Heureusement, PowerShell continue de croître avec vos compétences.

Vous pouvez encadrer les commandes existantes que vous utilisez quotidiennement dans des boucles pour gagner du temps et des efforts. Vos scripts font le gros du travail pendant que vous faites le travail important de lire plus d'articles sur MakeUseOf !

Boucles Powershell ForEach :la porte vers la gestion avancée des données

ForEach est l'alias de ForEach-Object. (Un alias est simplement un raccourci pour une commande dans PowerShell.) C'est le bon moment pour parler de la façon dont PowerShell gère les données.

Comme la plupart des langages de programmation modernes, PowerShell est orienté objet. Tout dans PowerShell est un objet, ce qui signifie que même les variables ont des propriétés et des fonctions étendues. Cette propriété est la raison pour laquelle vous pouvez définir vos recherches sur une variable et vous retrouver avec un tableau des résultats.

$votreVar =Get-ChildItem * 
 foreach ($fichier dans $votreVar){ 
 Vos étapes 
 } 
  

Dans certaines langues, le traitement de ce tableau serait un processus en plusieurs étapes. Commencez par obtenir la longueur, puis comptez chaque pas.

Dans PowerShell, vous parcourez le tableau et effectuez l'action sur chacun à l'aide de ForEach. Cela vous permet d'économiser plusieurs lignes de code, ce qui est utile si vous avez un script plus long. Par exemple, voici un petit script qui utiliserait quelques boucles Powershell ForEach. Il crée une archive ZIP de tous vos fichiers que vous n'avez pas ouverts depuis 30 jours.

Création d'un système d'archivage de fichiers à l'aide de boucles ForEach

Décomposons les étapes. Vous utilisez Get-ChildItem pour obtenir tous les fichiers du dossier Documents. La variable d'environnement $env:USERPROFILE exécute le script en utilisant le profil actuel. Cette variable est plus portable qu'un chemin codé en dur. Les résultats de cette recherche sont affectés à la variable $MyDocs . Nous créons ensuite notre boucle ForEach en lui faisant parcourir chaque $Doc dans $MyDocs .

$oldDocs =@() 
 $MyDocs =Get-ChildItem -Path "$($env:USERPROFILE)\Documents" -Recurse 
 foreach ($doc dans $MyDocs){ 
 if($doc.LastAccessTime -lt $(Get-Date).addDays(-30)){ 
 $oldDocs +=$doc 
 } 
 } 
 $ArchiveFolder =New-Item -Path "$($env:USERPROFILE)\Documents\$((Get-Date -Format MMddyy).toString())" -ItemType Directory 
 foreach ($doc dans $oldDocs){ 
 Move-Item -Path $doc.FullName -Destination "$($ArchiveFolder.FullName)\$($doc.Name)" -Confirm $false 
 } 
 $source =$ArchiveFolder.FullName 
 $destination ="$($env:USERPROFILE)\Documents\$($ArchiveFolder.Name).zip" 
 Add-Type -AssemblyName "system.io.compression.filesystem" 
 [io.compression.zipfile] ::CreateFromDirectory($source, $destination) 
 if(test-path $destination){ 
 Remove-Item -Path $ArchiveFolder -Recurse -Confirm $false 
 } 
  

Dans la boucle, nous vérifions si le LastAccessTime de chaque fichier la propriété a plus de 30 jours. Nous obtenons cela avec le Get-Date applet de commande et en utilisant AddDays fonction avec moins trente. Si c'est le cas, nous ajoutons le fichier au $myOldDocs déployer. Une fois le tri du fichier terminé, nous prenons ensuite notre tableau terminé et créons un fichier zip. Ce processus est un peu plus compliqué car il implique d'invoquer un peu de .NET. Ne vous inquiétez pas si vous ne le comprenez pas bien :vous pouvez voler le code de ce document d'aide TechNet.

Pour décomposer ce qui se passe ici :nous déplacerons tous nos anciens fichiers vers un nouveau répertoire nommé d'après la date d'aujourd'hui depuis plus de 30 jours. Une fois ce dossier construit, nous devons créer l'archive ZIP du même nom. Nous allons tester pour nous assurer que l'archive a réussi et que le fichier .ZIP est là, puis supprimer le nouveau dossier. Définissez ceci comme une tâche planifiée à exécuter une fois par mois. Vous économiserez un peu d'espace et garderez votre dossier Documents propre.

While et Do While : boucles sur condition

Si vous souhaitez exécuter une boucle uniquement lorsqu'une condition particulière est remplie, vous utilisez une boucle While. Si vous utilisez une variable pour suivre le décompte, définissez-la d'abord.

i=0 
 tandis que(i<10){ 
 Vos étapes 
 je+=1 
 } 
  

Le problème est que si vous n'utilisez pas de compteur, vous souhaiterez peut-être que votre code s'exécute au moins une fois même si le test est vrai. C'est le cas avec l'exemple de script ci-dessous. Donc, dans ces cas, vous souhaitez utiliser une boucle Do-While. La syntaxe est légèrement différente.

faire{ 
 Vos étapes 
 }while(Instruction conditionnelle) 
  

Leur utilisation n'est pas aussi évidente pour un programmeur novice. En faisant des scripts quotidiens typiques, vous ne les rencontrerez peut-être pas souvent. Là où ils sont particulièrement utiles, c'est pour créer une minuterie de fortune pour tester le succès d'un processus.

Nous allons créer un script rapide pour redémarrer une machine distante et alerter si elle ne revient pas dans les 15 minutes. Ce scénario suppose qu'il s'agit d'un serveur domestique ou d'une autre machine qui ne redémarre pas très souvent. N'hésitez pas à ajuster l'heure si votre ordinateur s'allume généralement plus rapidement.

Redémarrer et vérifier :à l'aide d'une boucle Do-While

Ce script est un peu plus simple. Tout d'abord, vous utilisez le Restart-Computer commande pour redémarrer la machine distante. (Nous avons utilisé ici une adresse IP factice pour les commandes de redémarrage, assurez-vous de l'écraser avec le DNS/IP de votre ordinateur). Créez ensuite la variable de compteur, i et réglez-le sur 0. Ensuite, vous avez votre boucle Do avec Start-Sleep arrêtant le script pendant 300 secondes (cinq minutes). Une deuxième commande ajoute un au compteur.

Restart-Computer -ComputerName 127.0.0.1 
 je=0 
 fais{ 
 Start-Sleep -Secondes 300 
 $i +=1 
 }while((!(Test-Connexion 127.0.0.1 -Quiet)) -or $i -gt 3) 
 si($i -gt 3){ 
 Write-Ouput "La machine distante ne répond pas, veuillez vérifier." 
 } 
 autre{ 
 Sortie d'écriture "Redémarrage réussi" 
 } 
  

Ensuite, nous avons nos critères While. Nous utilisons un test Or pour nous assurer qu'une panne génère une alerte. L'alternative est le script qui boucle sans fin en attendant la machine distante. Pour vérifier la machine, nous utilisons le Test-Connection applet de commande. Pour plus de simplicité, il s'agit de Ping pour PowerShell. Nous ajoutons le paramètre -Quiet ce qui l'oblige à renvoyer True ou False plutôt que les résultats des paquets. La deuxième partie de l'instruction Ou vérifie si le compteur est supérieur à trois.

Une fois la boucle terminée, nous voulons créer la sortie. Cela signifie que nous devons vérifier notre compteur. Il s'agit d'une instruction if/else rapide. S'il est supérieur à trois, le script indique que la machine distante ne répond pas. Si ce n'est pas le cas, il indique que le redémarrage a réussi.

Autres boucles

Il existe deux autres types de boucles disponibles dans PowerShell. Ils sont quelque peu liés aux deux boucles précédentes, ils ne sont tout simplement pas aussi couramment utilisés. Une boucle For fonctionne de la même manière que l'exemple While. Vous définissez tous vos critères dans l'évaluation, puis définissez vos applets de commande.

for($i =0;$i -lt 10;$i++){ 
 Vos étapes 
 } 
  

Les boucles Do Until sont comme les boucles Do While, vous changez simplement l'instruction While en Until. Dans l'exemple de script, ce serait la même chose en ce qui concerne le comportement. C'est un choix de style, mais le Do While est plus polyvalent dans d'autres situations. Donc, si vous ne vous souvenez que d'un seul, Do While est plus utile.

PowerShell a également de l'aide pour chacune de ces boucles. Vous pouvez obtenir de l'aide en ajoutant à propos avant le nom de la boucle dans Get-Help. Vous pouvez ensuite voir des exemples et d'autres conseils pour chaque type. Ceux-ci devraient être utiles si vous êtes bloqué.

Continuer à grandir avec vous

À ce stade, vous avez la plupart des compétences pour commencer à créer des scripts robustes. Qu'il s'agisse d'automatiser votre plate-forme domestique ou de gagner du temps au travail, les boucles aident vos scripts à en faire plus. La combinaison de ces boucles avec la gestion des erreurs déplace votre script au-delà des bases. Cela ouvre la porte à des langages plus avancés.

Quel script PowerShell astucieux avez-vous créé à l'aide de boucles ? Partagez-le avec nous dans les commentaires.