Hey, Scripting Guy!: Creating A Self-Documenting Script

Article
08/23/2016

Hé, le scripteur ! Création d'un script Self-Documenting

The Microsoft Scripting Guys

Nom de couleur spéciale doit être utilisé pour décrire la profondeur incroyable de bleu brushed générale dans le ciel vers le bas ici en Buenos Aires. Bleu cobalt bleu deep-sea Bleu de minuit, holy-mackerel bleu, aucun de ces même commencer à transmettent la couleur réelle dans le ciel couvrant la ville ancienne. Larges sidewalks alignés par ancien de siècles bâtiments sont en pointillés avec des tables peu. J'AI se trouvent dans une chaise métal vide. Un clin de œil perfumed drifts simplement en exécutant des conseils de cinnamon, cardamom et thyme. Seagulls avec ailes outstretched surfer sur les updrafts avec suffisamment compétence, grâce et poise à engender envy dans le grand Kahuna lui-même. Le leche canular café semble particulièrement apropos et est assez fort pour demander son propre attention par rapport à la concurrence à partir du paysages et les sons de downtown Buenos Aires. Je suis dans ville parler à des clients premier de Microsoft à l'aide de VBScript permettant de gérer leurs réseaux. J'AI extraire une carte pliée mon sac de l'appareil photo et passez à planifier mon itinéraire de Floride Calle pour le Obelisk sur Nueve de Julio avenue.

Je trouve mon emplacement sur la carte. Je suis près de la galerie de shopping Galerias Pacifico. J'active le mappage sur plusieurs fois comme j'essaie d'orienter avec Mon magasin de temps et d'espace. Sur cette fois, un homme hauteur, recherche uniques dans une couleur foncée three-piece s'affiche et est l'acronyme hors de la sunlight. Son ombre danse playfully sur la carte, provoque me Jetez un coup d'oeil haut. JE veille comme il dit, « Buenos dias, se˜nor. »

« Dias Buenos », J'AI inonde répondre.

« Ah, vous êtes un américain peut-être? » il répond avec un accent légèrement livre.

J'ai pris un peu aback et hesitantly répondre dans l'affirmative.

« Est-ce la première fois dans notre ville juste? » qu'il souhaite.

Une fois encore, je suis reticent mais dire « Oui ».

« Puis je peut proposer mon service fonctionnalité pour vous. Ce qui est que vous recherchez? » il politely demande.

Je lui dire, et il passe à me donner des instructions. Après cela nous discuter pendant quelques minutes.

Wow ! Je pense à moi. " Une ville self-documenting ! Inutile de cartes ici. Les personnes ne convivial que vous avez peine de temps pour consulter une carte avant que quelqu'un soit il pour vous aider.

Qui était en fait quelques années. Aujourd'hui, à ma maison de Caroline du Nord, la météo à l'extérieur est lovely me vous rappelle de mon visite Buenos Aires, et comment bien une fonctionnalité self-documenting peut être. Il peut avoir nos scripts exécute un service similaire pour nous, si nous prendre le temps de planifier à l'avance. Dans cet article, nous verront comment développer un script qui va rassembler des commentaires provenant autres scripts qui suivent un certain modèle. Nous pouvez modifier le motif à nos besoins et que vous pouvez développer la technique au-delà de documentation pour les scripts de création.

Voyons un script qui a une documentation soigneusement placée dans il. Dans le script GetSetIEStartPage.ps1 dans la figure 1 (qui a été écrit pour la Hey, Scripting Guy ! article » Comment je modifier ma page d'accueil Internet Explorer ?", commentaires sont placés dans ici-chaînes est ensuite affectées à un commentaire $ nommé variable. Une chaîne ici, est délimité par une balise de début d'un à signe et un guillemet (@ ») et une balise de fermeture d'un guillemet et une arobase (« @). Il sont trois blocs commentaire nous sommes intéressés par les obtenir. La première contient des scripts normal en-tête informations : le titre, l'auteur, date, des mots clés et commentaires sur le script lui-même. Les blocs de deuxième et troisième commentaire sont spécifiquement liées aux deux fonctions principales contenues dans le script.

La figure 1 GetSetIEStartPage.ps1

Param([switch]$get,[switch]$set,$computer="localhost")
$Comment = @"
NAME: GetSetIEStartPage.ps1
AUTHOR: ed wilson, Microsoft
DATE: 1/5/2009

KEYWORDS: stdregprov, ie, [wmiclass] type accelerator,
Hey Scripting Guy
COMMENTS: This script uses the wmiclass type accelerator
and the stdregprov to get the ie start pages and to set the
ie start pages. Using ie 7 or better you can have multiple
start pages

"@ #end comment

Function Get-ieStartPage()
{
$Comment = @"
FUNCTION: Get-ieStartPage 
Is used to retrieve the current settings for Internet Explorer 7 and greater.
The value of $hkcu is set to a constant value from the SDK that points
to the Hkey_Current_User. Two methods are used to read
from the registry because the start page is single valued and
the second start pages key is multi-valued.

"@ #end comment
 $hkcu = 2147483649
 $key = "Software\Microsoft\Internet Explorer\Main"
 $property = "Start Page"
 $property2 = "Secondary Start Pages"
 $wmi = [wmiclass]"\\$computer\root\default:stdRegProv"
 ($wmi.GetStringValue($hkcu,$key,$property)).sValue
 ($wmi.GetMultiStringValue($hkcu,$key, $property2)).sValue
} #end Get-ieStartPage

Function Set-ieStartPage()
{
$Comment = @"
FUNCTION: Set-ieStartPage 
Allows you to configure one or more home pages for IE 7 and greater. 
The $aryValues and the $Value variables hold the various home pages.
Specify the complete URL ex: "http://www.ScriptingGuys.Com" make sure
to include the quotation marks around each URL. 

"@ #end comment
  $hkcu = 2147483649
  $key = "Software\Microsoft\Internet Explorer\Main"
  $property = "Start Page"
  $property2 = "Secondary Start Pages"
  $value = "https://www.microsoft.com/technet/scriptcenter/default.mspx"
  $aryValues = "https://social.technet.microsoft.com/Forums/en/ITCG/threads/",
  "https://www.microsoft.com/technet/scriptcenter/resources/qanda/all.mspx"
  $wmi = [wmiclass]"\\$computer\root\default:stdRegProv"
  $rtn = $wmi.SetStringValue($hkcu,$key,$property,$value)
  $rtn2 = $wmi.SetMultiStringValue($hkcu,$key,$property2,$aryValues)
  "Setting $property returned $($rtn.returnvalue)"
  "Setting $property2 returned $($rtn2.returnvalue)"
} #end Set-ieStartPage

# *** entry point to script 
if($get) {Get-ieStartpage}
if($set){Set-ieStartPage}

Pour écrire les commentaires à partir du fichier source vers un autre document, nous avons besoin pour ouvrir le script d'origine, recherchez les commentaires et puis écrire le texte approprié dans un nouveau fichier. Semble assez simple. Oh, Oui, nous devons également un nom pour notre nouveau script. Appelons GetCommentsFromScript.ps1.

Le script GetCommentsFromScript.ps1, illustré figure 2 , commence par une instruction de paramètre, qui est utilisée pour permettre à nous fournir des informations sur le script au moment de l'exécution. Voici l'instruction de paramètre.

La figure 2 GetCommentsFromScript.ps1

Param($Script= $(throw "The path to a script is required."))
Function Get-FileName($Script)
{
 $OutPutPath = [io.path]::GetTempPath()
 Join-Path -path $OutPutPath -child "$(Split-Path $script-leaf).txt"
} #end Get-FileName

Function Remove-OutPutFile($OutPutFile)
{
  if(Test-Path -path $OutPutFile) { Remove-    Item $OutPutFile | Out-Null }
} #end Remove-OutPutFile

Function Get-Comments($Script,$OutPutFile)
{
 Get-Content -path $Script |
 Foreach-Object `
  { 
    If($_ -match '^\$comment\s?=\s?@"')
     { 
      $beginComment = $True 
     } #end if match @"
   If($_ -match '"@')
     { 
      $beginComment = $False
     } #end if match "@
   If($beginComment -AND $_ -notmatch '@"') 
     {
      $_ | Out-File -FilePath $OutPutFile -append
     } # end if beginComment
  } #end Foreach
} #end Get-Comments

Function Get-OutPutFile($OutPutFile)
{
 Notepad $OutPutFile
} #end Get-OutPutFile

# *** Entry point to script ***
$OutPutFile = Get-FileName($script)
Remove-OutPutFile($OutPutFile)
Get-Comments -script $script -outputfile $OutPutFile
Get-OutPutFile($OutPutFile)vw

Param($Script= $(throw "The path to a script   is required."))

L'avantage d'utiliser un paramètre de ligne de commande est que vous ne devez ouvrir le script et modifiez-le pour fournir le chemin d'accès du script dont nous allons copier les commentaires. Nous faisons ce paramètre obligatoire en affectant une valeur par défaut à la variable de script $. La valeur par défaut utilise la commande de redirection pour générer une erreur, et cela signifie que le script toujours génèrent une erreur quand exécuter, à moins que nous fournir une valeur pour le paramètre –script.

Nous allons digress pendant une minute et observez comment l'instruction throw est utilisée dans le script DemoThrow.ps1 dans la figure 3 . Pour obtenir au-delà de l'erreur est générée par l'instruction throw dans la fonction Set-erreurs, nous devons définir la variable D'errorActionPreference $ sur SilentlyContinue. Cela empêche l'affichage de l'erreur et vous permet le script de continuer. Il est identique à celle On Error Resume Next de VBScript. La si l'instruction est utilisée pour évaluer la variable de valeur $. S'il existe une correspondance, l'instruction throw est détectée et l'exception est levée. Pour évaluer l'erreur, nous utilisons la fonction Get-ErrorDetails. La première chose qu'a lieu est l'affichage du comptage d'erreur, qui est ont été incrémenté de 1 en raison de l'erreur déclenchée par l'instruction throw. Nous avons ensuite prendre la première erreur (l'erreur par la valeur d'index 0 est toujours celui plus récente) et l'envoyer l'objet error à la cmdlet Format-List. Nous choisi toutes les propriétés. Les informations appel, cependant, sont renvoyées sous la forme d'un objet, et nous devons donc d'interroger directement cet objet. Nous pour ce faire, l'accès à l'objet appel via la propriété InvocationInfo de l'objet error. Les informations d'erreur qui en résulte sont illustrées figure 4 .

La figure 3 DemoThrow.ps1

Function Set-Error
{
 $errorActionPreference = "SilentlyContinue"
 "Before the throw statement: $($error.count) errors"
 $value = "bad"
 If ($value -eq "bad") 
   { throw "The value is bad" }
} #end Set-Error

Function Get-ErrorDetails
{
 "After the throw statement: $($error.count) errors"
 "Error details:"
 $error[0] | Format-List -Property * 
 "Invocation information:"
 $error[0].InvocationInfo
} #end Get-ErrorDetails

# *** Entry Point to Script
Set-Error

Get-ErrorDetails

La figure 4 lève l'instruction est utilisée pour générer une erreur

Maintenant nous allons revenir à notre script principal, GetCommentsFromScript.ps1. Nous avons besoin d'une fonction qui crée un nom de fichier pour le nouveau document texte qui contiendra tous les commentaires gleaned à partir du script. Pour ce faire, nous utiliser le mot clé de fonction et procédez comme avec le nom de la fonction. Nous s'appeler notre fonction Get-FileName dans conformes avec la convention de dénomination verbe-substantif Windows PowerShell. Get-FileName prendra un seul paramètre entrée, le chemin d'accès le script pour être analysées qui aura lieu dans la variable script $ dans la fonction. Voici l'entrée à la fonction Get-FileName :

Function Get-FileName($Script)
{

Ensuite nous à obtenir le chemin d'accès le dossier temporaire sur l'ordinateur local. Il existe plusieurs moyens pour ce faire, notamment le lecteur Windows PowerShell environnement. Cependant, nous avons décidé d'utiliser la méthode GetTempPath statique de la classe Io.Path .NET Framework. La méthode GetTempPath renvoie le chemin d'accès dans le dossier temporaire, qui est l'emplacement où nous enregistre le fichier texte nouvellement créé. Nous hold le chemin d'accès au dossier temporaire dans la variable OutPutPath $ comme illustré ici :

$OutPutPath = [io.path]::GetTempPath()

Nous décider de notre nouveau fichier texte un nom après le nom du script. Pour ce faire, nous devez séparer le chemin que le script est stocké dans le nom du script. La cmdlet de double-chemin d'accès nous permet d'effectuer cette surgery. Le paramètre –leaf indique la cmdlet pour renvoyer le nom du script. Si nous aviez voulu le chemin d'accès de répertoire qui contient le script, nous aurait utilisé le paramètre –parent. Nous mettons la commande Fractionner-chemin d'accès à l'intérieur d'une paire de parenthèses car nous souhaitons cette opération à tout d'abord, puis nous placez un signe dollar en face des parenthèses qui s'exécute le code et renvoyer le nom du script pour créer une sous-expression. Nous pouvez use.ps1 comme l'extension pour notre fichier texte, mais qui pourraient être déroutant parce qu'il est l'extension d'un script. Nous avons donc ajoutez simplement une extension .txt au nom de fichier renvoyé et placer la chose entier d'une paire de guillemets. Maintenant, nous utiliser la cmdlet jointure-chemin d'accès pour créer un nouveau chemin d'accès à notre fichier de sortie. Le nouveau chemin d'accès est constitué du dossier temporaire, stockée dans la variable OutPutPath $ et le nom de fichier que nous avons créé à l'aide double-chemin d'accès. Nous pu utiliser la manipulation de chaîne et concaténation pour créer le nouveau chemin d'accès du fichier, mais il est beaucoup plus fiable utiliser jointure-chemin d'accès et double-chemin d'accès pour effectuer ces types d'opérations. Voici à quoi ressemble le code :

Join-Path -path $OutPutPath -child "$(Split-Path $script-leaf).txt"
} #end Get-FileName

Nous devons maintenant décider comment nous allons pour gérer les fichiers dupliqués. Nous peut inviter l'utilisateur en disant qu'un fichier en double existe, à l'aide de code comme suit :

$Response = Read-Host -Prompt "$OutPutFile already exists. Do you wish to delete it <y / n>?"
if($Response -eq "y")
    { Remove-Item $OutPutFile | Out-Null }
ELSE { "Exiting now." ; exit }

Nous peut implémenter un type d'algorithme d'affectation de noms qui effectue une sauvegarde du fichier existant en le renommant avec l'extension .old. Si nous l'avons fait cela, le code serait ressembler à celui-ci :

if(Test-Path -path "$OutPutFile.old") { Remove-Item-Path "$OutPutFile.old" }
Rename-Item -path $OutPutFile -newname "$(Split-Path $OutPutFile -leaf).old"

Ou nous peut simplement supprimer le fichier existant, qui est J'AI choisi. L'action que vous souhaitez effectuer s'effectue dans la fonction Remove-OutPutFile, qui nous créent en à l'aide du mot-clé fonction et en spécifiant le nom de la fonction. Nous utilisons $ OutPutFile pour fournir l'entrée à la fonction, comme illustré ici :

Function Remove-OutPutFile($OutPutFile)
{

Pour déterminer si le fichier existe, nous utilisez la cmdlet Test-chemin d'accès et fournir la chaîne contenue dans la variable OutPutFile $ au paramètre chemin d'accès. La cmdlet Test-chemin d'accès renvoie uniquement une valeur True ou un False, selon si un fichier a été trouvé. Cela signifie nous pouvez utiliser si l'instruction pour évaluer l'existence du fichier. Si le fichier est trouvé, nous effectuer l'action dans le bloc de script. Si le fichier est introuvable, le bloc de script n'est pas exécuté. Vous constatez ici que la première commande ne trouvez pas le fichier et FAUX est renvoyée. Dans la deuxième commande, le bloc de script n'est pas exécuté parce que le fichier ne peut pas être trouvé :

PS C:\> Test-Path c:\missingfile.txt
False
PS C:\> if(Test-Path c:\missingfile.txt){"found file"}
PS C:\>

Dans la fonction Remove-OutPutFile, la Si instruction est utilisée pour déterminer si le fichier référencé par la OutPutFile $ déjà existe. Si c'est le cas, elle est supprimée en utilisant la cmdlet Remove-Item. Les informations qui sont habituellement renvoyées lorsqu'un fichier est supprimé sont pipelined à la Out-Null cmdlet, offrant pour l'opération en mode silencieux. Le code est illustré ici :

if(Test-Path -path $OutPutFile) { Remove-Item $OutPutFile | Out-Null }
} #end Remove-OutPutFile

Une fois que nous avez créé le nom du fichier sortie et supprimé les fichiers sortie précédente qui peuvent être à l'autour, il est temps pour extraire les commentaires du script. Pour ce faire, nous créer la fonction Get-commentaires et transmettez il à la fois la variable de script $ et la variable OutPutFile $, comme illustré ici :

Function Get-Comments($Script,$OutPutFile)
{

Maintenant, nous lire le texte du script en utilisant le cmdlet Get-Content, à laquelle nous transmettre le chemin vers le script. Lorsque nous utilisons Get-Content pour lire un fichier, le fichier est lu une ligne à la fois et chaque ligne est transmise ainsi que le pipeline. Si nous stocker le résultat dans une variable, nous faudrait une matrice. Nous pouvez traiter la variable $ un type de tout autre tableau, y compris les obtenir le nombre d'éléments dans le tableau via la propriété Length et l'indexation directement dans le tableau, comme illustré ici :

PS C:\fso> $a = Get-Content -Path C:\fso\  GetSetieStartPage.ps1
PS C:\fso> $a.Length
62
PS C:\fso> $a[32]
($wmi.GetMultiStringValue($hkcu,$key,   $property2)).sValue

Voici la ligne qui lit le script d'entrée et les envoie ainsi que le pipeline :

Get-Content -path $Script |

Nous devons ensuite rechercher dans chaque ligne pour voir si elle appartient au bloc de commentaire. Pour examiner chaque ligne dans un pipeline, nous utiliser la cmdlet ForEach-Object, qui est similaire à une instruction ForEach…Next qu'il vous permet de nous manipuler un objet individuel à partir de dans une collection, une à la fois. Le caractère de graduation en différé (') est utilisé pour continuer la commande pour la ligne suivante. L'action que nous à effectuer sur chaque objet comme il s'agit dans le pipeline est contenue dans un bloc de script délimité avec un ensemble d'accolades (également appelé accolades). Cette partie de la fonction Get-Content s'affiche ici :

ForEach-Object `
  {

Lorsque nous sont dans le bloc de processus de cmdlet ForEach-Object, nous souhaitons examiner la ligne de texte. Pour ce faire, nous utilisez si l'instruction. La variable $ _ automatique est utilisée pour représenter la ligne actuelle dans le pipeline. L'opérateur –match nous permet d'effectuer une correspondance d'expressions régulières par rapport à la ligne de texte. L'opérateur –match renvoie une valeur de type Boolean True ou False en réponse au modèle que commence le modèle sur le côté droit de l'opérateur –match. Cette section de script est illustrée ci-dessous :

PS C:\fso> '$Comment = @"' -match '^\$comment\s?=\s?@"'
True

Le modèle d'expression régulière que nous utilisons est composé d'un certain nombre de caractères spéciaux :

^ —Match au début

\ —Escape caractères afin du signe $ est traité comme un caractère littéral et pas le caractère spécial utilisé dans des expressions régulières

commentaire $ Caractères —Literal

\s ? —Zero ou plusieurs caractères espace blanc

= Caractère —Literal

\s ? —Zero ou plusieurs caractères espace blanc

@ ", Caractères littéraux

La section de code qui examine la ligne de texte de la canalisation est illustrée ci-dessous :

If($_ -match '^\$comment\s?=\s?@"')

Nous créons un beginComment de variable nommée $ est utilisé pour marquer le début du bloc de commentaire. Si nous il au-delà de l'instruction –match, nous avons découvert le début du bloc de commentaire. Nous avons défini la variable comme étant égale sur $ True comme indiqué ici :

{ 
  $beginComment = $True
} #end if match @"

Ensuite nous vérifie si nous sont à la fin du bloc de commentaire. Pour ce faire, nous utiliser à nouveau l'opérateur de –match. Cette fois nous rechercher le « @ séquence de caractères, qui est utilisée pour fermer un ici-chaîne. Si nous trouver, nous définir la variable beginComment $ sur False :

If($_ -match '"@')
     { 
      $beginComment = $False
     } #end if match "@

Nous avons effectuées il après les deux premiers Si états : le premier élément identifie le début de la chaîne-ici, et le deuxième localise la fin de la chaîne-ici. Nous souhaitons maintenant récupérer le texte à être écrit dans notre fichier de commentaire. Pour ce faire, nous souhaitons la variable beginComment $ à définir sur True. Nous souhaitez également vous assurer que nous ne s'affiche au symbole guillemet (@ ») des caractères de la ligne car elle signifierait la fin de la chaîne-ici. Cette détermination nous permet d'apporter un Si composé instruction :

If($beginComment -AND $_ -notmatch '@"') 
     {

Maintenant, nous écrivez le texte dans le fichier de sortie. Pour ce faire, nous utiliser la variable $ _ automatique, qui représente la ligne de texte ; nous opportunités à la Out-File cmdlet. Le Out-File cmdlet reçoit la variable $ OutPutFile, qui contient le chemin d'accès au fichier commentaire. Nous utilisez le paramètre –append pour spécifier que vous souhaitez rassembler tous les commentaires du script dans le fichier de commentaire. Si nous n'a pas utilisez le paramètre Ajout, le fichier texte contient le dernier commentaire car, par défaut, le Out-File cmdlet serait remplacer son contenu. Nous puis fermez les tous les accolades. Je considère qu'il recommandé d'ajouter un commentaire après chaque fermeture accolade qui indique l'objectif de l'accolade. Cela facilite le script lecture, ainsi que plus facile pour résoudre et tenez à jour :

$_ | Out-File -FilePath $OutPutFile -append
     } # end if beginComment
  } #end ForEach
} #end Get-Comments

Nous maintenant créer une fonction appelée Get-OutPutFile qui ouvrira le fichier de sortie pour nous à lire. Étant donné que le dossier temporaire n'est pas facile à trouver et nous avions le chemin d'accès au fichier dans la variable OutPutFile $, il est judicieux pour utiliser le script pour ouvrir le fichier de sortie. La fonction Get-OutPutFile reçoit une seule entrée variable appelée $ OutPutFile, qui contient le chemin d'accès le fichier commentaire que nous souhaitez ouvrir. Lorsque nous appelez la fonction Get-OutPutFile, nous lui transmettez OutPutFile $. Nous pouvez passer toute valeur que nous souhaitons à la fonction Get-OutPutFile et dans la fonction de que la valeur est être référencée à la variable OutPutFile $. Nous pouvez même transmettre une chaîne directement (sans utiliser les guillemets autour de la chaîne) à la fonction :

Function Get-OutPutFile($OutPutFile)
{
 Notepad $OutPutFile
} #end Get-OutPutFile

Get-OutPutFile -outputfile C:\fso\GetSetieStartPage.ps1

En règle générale, lorsque vous écrivez un script, si vous prévoyez pour rassembler des quelque chose à transmettre à une fonction, il est judicieux d'encase les données dans le même nom de variable Qu'est utilisé à l'intérieur et en dehors de la fonction. Cela suit parmi nos meilleures pratiques pour le développement de script: « ne pas endommager avec la section traitement du script. » Dans cet exemple, lorsque nous appelez la fonction nous » font travail. » Pour modifier ce avenir scripts nécessiterait que nous modifier la valeur de littéral de chaîne. En plaçant la chaîne dans une variable, nous pouvez facilement modifier la valeur de la variable. Nous sont, en fait, vous configurés pour fournir la valeur de la variable via la ligne de commande ou au moyen d'un élément dans une autre fonction. Dans la mesure du possible, évitez de placer des valeurs littérales chaîne directement dans le script. Dans le code qui suit, nous utilisons une variable pour contenir le chemin d'accès au fichier sera passée à la fonction Get-OutPutFile :

Function Get-OutPutFile($OutPutFile)
{
 Notepad $OutPutFile
} #end Get-OutPutFile

$OutPutFile = "C:\fso\GetSetieStartPage.ps1"
Get-OutPutFile -outputfile $OutPutFile

La fonction Get-OutPutFile complète voicie :

Function Get-OutPutFile($OutPutFile)
{
 Notepad $OutPutFile
} #end Get-OutPutFile

Au lieu de taper dans une chaîne littérale pour le chemin d'accès au fichier de sortie, la variable OutPutFile $ reçoit le chemin d'accès est créé par la fonction Get-FileName. La fonction Get-FileName reçoit le chemin d'accès au script contient les commentaires à extraire. Le chemin vers ce script est fourni via le paramètre de ligne de commande. Lorsqu'une fonction est un paramètre d'entrée unique, vous pouvez lui transmettre à la fonction à l'aide d'un jeu de parenthèses. Si, d'autre part, la fonction utilise deux ou plusieurs paramètres d'entrée, vous devez utiliser la syntaxe de nom –parameter :

$OutPutFile = Get-FileName($script)

Ensuite nous appeler la fonction Remove-OutPutFile (décrite plus haut), la passer le chemin d'accès à la OutPutFile contenues dans la variable OutPutFile $ :

Remove-OutPutFile($OutPutFile)

Lorsque nous sont garanties du nom de notre fichier de sortie, nous appeler la fonction Get-commentaires pour extraire des commentaires le script dont le chemin d'accès est indiqué par la variable de script $. Les commentaires sont écrites dans le fichier de sortie référencé par la variable OutPutFile $. Cette ligne de code s'affiche ici :

Get-Comments -script $script -outputfile $OutPutFile

Lorsque les commentaires ont tous été écrite dans le fichier de sortie, nous avons enfin appeler la fonction Get-OutPutFile, la passer le chemin de contenu dans la variable OutPutFile $. Si vous souhaitez le fichier de commentaire pour être ouvert, vous pouvez facilement commentaire la ligne de votre script, ou simplement supprimer elle et la fonction Get-OutPutFile elle-même votre script. Si vous êtes intéressé par l'examen de chaque fichier avant de l'enregistrer, laissez la ligne de code en place :

Get-OutPutFile($OutPutFile)

Lorsque le script GetCommentsFromScript.ps1 s'exécute, aucun message de confirmation s'affiche sur votre écran. La confirmation uniquement qui fonctionnait le script est la présence du fichier texte nouvellement créé affichée dans le bloc-notes, comme indiqué dans la figure 5 .

La figure 5, le nouveau fichier texte affiché dans le bloc-notes

Le script GetCommentsFromScript.ps1 peut être facilement adapté à votre propre manière d'écrire des scripts ou même pour la collecte les autres types de documentation des fichiers journaux basé sur du texte. Tout ce dont vous avez besoin pour faire est de modifier le motif d'expression régulière qui est utilisé pour marquer le début et la fin des parties du texte vous êtes intéressé par collecte. Nous espérons que vous apprécier le script et vous invitons à participer à nous sur le Script Center, où nous publier une nouvelle Hey, Scripting Guy ! article de chaque jour de la semaine.

Édition Wilson , un expert de script bien connu, est l'auteur de huit livres, notamment Guide de script Windows PowerShell (Microsoft Press, 2008) et Microsoft Windows PowerShell Step by Step (Microsoft Press, 2007). Édition contient plus de 20 certifications industrie, y compris Microsoft Certified Systems Engineer (MCSE) et Certified Information Systems Security Professional (CISSP). Ses loisirs, il aime woodworking, underwater photographie et plongée sous-marine. Et thé.

Craig Liebendorfer est wordsmith et longtime éditeur Web de Microsoft. Craig ne peut pas pensez toujours il y a un travail paie lui pour travailler avec des mots chaque jour. Une des ses choses favoris est irreverent d'humour, afin qu'il doit ajuster droite ici. Il considère que ses accomplishment plus élevé dans la vie à sa fille magnificent.

Ressources supplémentaires