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

Artículo
08/23/2016

¡ Hola, chicos del scripting! Crear una secuencia de comandos Self-Documenting

The Microsoft Scripting Guys

Para describir la profundidad increíble de azul roza ampliamente entre el cielo hacia abajo de aquí en Buenos Aires, se deben utilizar los nombres de color especiales. Azul cobalt deep-sea azul azul medianoche, mackerel de piedra azul, ninguno de estos incluso empezar a portray el color real visto en la canopy cubre la ciudad antigua. Amplia aceras alineado junto por siglos de antiguo edificios son puntos con tablas poco. Están en una silla de metal vacía. Esta técnica de implementación resulte muy sencilla de otros proveedores perfumed podido lazily drifts al ejecutar las sugerencias de cinnamon cardamom y thyme. Seagulls con alas outstretched explorar los updrafts con suficientes habilidades, gracia y poise para generar envy en la gran Kahuna a sí mismo. La leche de café con parece especialmente apropos y es eficaz para exigir su atención frente a la competencia de los sights y sonidos de downtown Buenos Aires. Estoy en ciudad para comunicarse con clientes de Microsoft Premier sobre cómo utilizar VBScript para ayudar a administrar sus redes. Extraer un mapa de plegado de la bolsa de cámara y vaya al planear la ruta desde Calle Florida a la Obelisk en Nueve de Julio Lagos.

Encuentro mi ubicación en el mapa. Estoy cerca de la galería de la compra Galerias Pacifico. Activar la asignación a través de varias veces cuando intento orientar con mi ubicación en el tiempo y espacio. Sobre este tiempo, un hombre alto, buscando completo de un palo oscuro three-piece aparece y significa sólo fuera de la sunlight. La sombra, dancing playfully en el mapa, hace que me glance hacia arriba. Sustituir como, dice, "Buenos dias, se˜nor."

"DIAS Buenos," ininterrumpida responder.

"AH, es un estadounidense, quizás,?" responde con un acento ligeramente libra.

Algo me tomado aback y hesitantly responder en la affirmative.

"Es esto la primera vez que en nuestro ciudad justo?" inquires.

Una vez nuevo, me reticent pero decir "Sí".

", A continuación, es posible que ofrecen mi humilde servicio para usted. ¿Qué es que busca?" politely pregunta.

Ordenarle, y continúa con me proporcionan las instrucciones. Después de eso, charla durante unos minutos.

Vaya! Creo que yo mismo. " Una ciudad self-documenting! No es necesario para asignaciones aquí. Las personas son por lo que descriptivo que apenas tenga tiempo para ver un mapa antes de que alguien se existe para ayudarle a".

Que era hace realmente unos años. Hoy en día, en mi casa de carolina del Norte, el tiempo fuera es tan estupendo me avisa de la visita a Buenos Aires, y de cómo interesante puede ser una utilidad self-documenting. Puede tenemos nuestros scripts realizar un servicio similar para nosotros, si se toma el tiempo de planear por adelantado. En este artículo, veremos cómo desarrollar una secuencia de comandos que se recopila los comentarios de otras secuencias de comandos que siguen un patrón de determinados. Se puede modificar el modelo de nuestras propias necesidades y puede expandir la técnica más allá de documentación de las secuencias de comandos.

Echemos un vistazo a una secuencia de comandos que tiene algunos documentación cuidadosamente se coloca en él. En el script GetSetIEStartPage.ps1 en la figura 1 (que se ha escrito para el ¡ Hola, chicos del scripting! artículo " ¿Cómo se puede cambiar la página principal de Internet Explorer?", los comentarios se colocan en las cadenas aquí que, a continuación, se asigna a un comentario de $ variable con nombre. Una cadena, aquí se descritos por una etiqueta de inicio de al inicio de sesión y un carácter de comillas (@ ") y una etiqueta de cierre de una marca de presupuesto y una arroba ("@). Hay tres bloques de comentarios, estamos interesados en obtener. La primera contiene información de encabezado de secuencia de comandos normal: el título, autor, fecha, palabras clave y comentarios en la secuencia de comandos. Los bloques de comentario de la segunda y tercera están específicamente relacionados con las dos funciones principales contenidas en la secuencia de comandos.

La figura 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}

Para escribir los comentarios del archivo de origen en otro documento, se necesita para abrir la secuencia de comandos original, busque los comentarios y, a continuación, escribir el texto apropiado en un archivo nuevo. Parece bastante sencillo. AH, sí, también necesitamos un nombre para la nueva secuencia de comandos. Vamos a llamar GetCommentsFromScript.ps1.

La secuencia de comandos GetCommentsFromScript.ps1, mostrada en la figura 2 , comienza con una instrucción de parámetro, que se utiliza para permitir que nos proporcione información a la secuencia de comandos en tiempo de ejecución. Aquí es la instrucción de parámetro.

La Figura 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."))

La ventaja de utilizar un parámetro de la línea de comandos es que no debemos abrir la secuencia de comandos y modificarlo para proporcionar la ruta de acceso a la secuencia de comandos cuyos comentarios se va a copiar. Se está realizando este parámetro obligatorio asignando un valor predeterminado a la variable de secuencias de comandos de $. El valor predeterminado utiliza el comando throw para elevar un error y, esto significa que la secuencia de comandos provocarán siempre un error cuando se ejecuta, a menos que se proporciona un valor para el parámetro –script.

Vamos a digress durante un minuto y echemos un vistazo a cómo la instrucción de throw se utiliza en la secuencia de comandos DemoThrow.ps1 en la figura 3 . Para obtener pasar del error provocado por la instrucción throw en la función de conjunto de error, se primero necesita establecer la variable de errorActionPreference $ a SilentlyContinue. Esto impide que el error que se muestra y permite continuar con la secuencia de comandos. Es igual a la configuración On Error Resume Next de VBScript. El si la instrucción se utiliza para evaluar la variable del valor de $. Si hay una coincidencia, se encuentra la instrucción throw y se produce la excepción. Para evaluar el error, utilizamos la función de Get-ErrorDetails. Lo primero que tiene lugar es la pantalla del recuento de errores, que se han se incrementa en 1 causa del error provocado por la instrucción throw. A continuación, se toma el primer error (el error con el valor de índice de 0 es siempre el más reciente) y enviar el objeto de error al cmdlet Format-List. Elija todas las propiedades. La información de invocación, sin embargo, se devuelve como un objeto, y, por tanto, debemos consultar ese objeto directamente. Hacemos esto mediante el acceso al objeto de invocación a través de la propiedad InvocationInfo del objeto error. La información de error resultante se muestra en la figura 4 .

La figura 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 figura 4 producir la instrucción se utiliza para elevar un error

Ahora vamos a volver a nuestra secuencia de comandos principal, GetCommentsFromScript.ps1. Tenemos una función que va a crear un nombre de archivo para el nuevo documento de texto que va a contener todos los comentarios gleaned de la secuencia de comandos. Para ello, se utiliza la palabra clave de función y siguen con el nombre de la función. Nos se llamar a nuestra función Get-FileName de acuerdo con la convención de nomenclatura verbo-objeto de Windows PowerShell. Get-FileName toman un único parámetro de entrada, la ruta a la secuencia de comandos analizarse, que se retiene en la variable de secuencias de comandos $ dentro de la función. Ésta es la entrada para la función de Get-FileName:

Function Get-FileName($Script)
{

A continuación se obtener la ruta de acceso a la carpeta temporal en el equipo local. Hay muchas formas para ello, incluidos con la unidad de Windows PowerShell del entorno. Sin embargo, hemos decidido utilizar el método GetTempPath estático de la clase Io.Path .NET Framework. El método GetTempPath devuelve la ruta de acceso a la carpeta temporal, que es donde almacenaremos el archivo de texto recién creado. Nos conservar la ruta de acceso a la carpeta temporal en la variable de OutPutPath $ tal como se muestra aquí:

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

Se decide nombre nuestro nuevo archivo de texto después del nombre de la secuencia de comandos. Para ello, necesitamos separar el nombre de secuencia de comandos de la secuencia de comandos se almacena en la ruta de acceso. Usar el cmdlet división de ruta de acceso para realizar esta operación. El parámetro –leaf indica el cmdlet para devolver el nombre de secuencia de comandos. Si había quisiéramos la ruta de acceso de directorio que contiene la secuencia de comandos, hemos podría utilizado el parámetro –parent. Incluimos el comando de división de ruta de acceso dentro de un par de paréntesis porque queremos esa operación que se produzca en primer lugar, a continuación, se coloque un signo de dólar delante de los paréntesis para crear un sub-expression que se ejecuta el código y devolver el nombre de la secuencia de comandos. Podríamos use.ps1 como la extensión para nuestro archivo de texto, pero que puede ser confuso porque es la extensión de una secuencia de comandos. Por tanto, sólo debemos agregue una extensión .txt al nombre de archivo devuelto y colocar lo todo de un par de comillas. Ahora se usa el cmdlet combinación de ruta de acceso para crear una nueva ruta de acceso a nuestro archivo de salida. La nueva ruta de acceso se compone de la carpeta temporal, almacenadas en la variable de OutPutPath $ y el nombre de archivo que hemos creado mediante la división de ruta de acceso. Podríamos haber usado manipular las cadenas y concatenación para crear la nueva ruta de archivo, pero es mucho más confiable utilizar combinación de ruta de acceso y la división de ruta de acceso para realizar estos tipos de operaciones. Este es el código que es similar al siguiente:

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

Ahora tenemos que decidir cómo se va a controlar los archivos duplicados. Se podría preguntar al usuario diciendo que existe un archivo de duplicados, mediante código como éste:

$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 }

Se podría implementar algún tipo de algoritmo de asignación de nombres que hace una copia de seguridad del archivo existente para cambiar el nombre con una extensión old. Si se hizo esto, el código tendría aspecto siguiente:

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

O simplemente se puede eliminar el archivo existente, que es lo elija. La acción que desea realizar tiene lugar en la función Remove-OutPutFile, que se crean utilizando la palabra clave (función) y especificando el nombre de la función. Utilizamos OutPutFile $ para proporcionar la entrada a la función, tal como se muestra aquí:

Function Remove-OutPutFile($OutPutFile)
{

Para determinar si el archivo existe, se utilice el cmdlet Test-ruta de acceso y suministrar la cadena contenida en la variable OutPutFile $ en el parámetro de ruta de acceso. El cmdlet Test-ruta de acceso devuelve sólo un True o un falso, dependiendo de si se encuentra un archivo. Esto significa que puede utilizar el si instrucción para evaluar la existencia del archivo. Si se encuentra el archivo, la acción realizar en el bloque de secuencias de comandos. Si no se encuentra el archivo, no se ejecuta el bloque de secuencias de comandos. Puede ver aquí que el primer comando no encuentra el archivo y se devuelve False. En el segundo comando, el bloque de secuencias de comandos no se ejecuta porque no puede ser encuentra el archivo:

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

Dentro de la función Remove-OutPutFile, la si la instrucción se utiliza para determinar si el archivo al que hace referencia el OutPutFile $ ya existe. En caso afirmativo, se elimina mediante el cmdlet Remove-elemento. La información que normalmente se devuelve cuando se elimina un archivo es canalizada en la Out-Null cmdlet, proporcionando para operación silenciosa. El código se muestra aquí:

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

Una vez se haya creado el nombre del archivo de salida y eliminado los archivos salida anterior que es posible que se muestra alrededor, es el momento para recuperar los comentarios de la secuencia de comandos. Para ello, creamos la función de Get-comentarios y pasar, tanto la variable de secuencias de comandos $ y la variable $ OutPutFile, tal como se muestra aquí:

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

Ahora se lea el texto de la secuencia de comandos mediante el cmdlet Get-Content, para que pasamos la ruta de acceso a la secuencia de comandos. Cuando usamos Get-Content para leer un archivo, el archivo se lee una línea a la vez y cada línea se pasa a lo largo de la canalización. Si tuviéramos que almacenar el resultado en una variable, será necesario una matriz. Se puede tratar la variable $ un como cualquier otro matriz, incluidos obtener el número de elementos de la matriz a través de la propiedad Length y índice directamente en la matriz tal como se muestra aquí:

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

Ésta es la línea que lee la secuencia de entrada y se envía a lo largo de la canalización:

Get-Content -path $Script |

A continuación necesitamos buscar dentro de cada línea para ver si pertenece al bloque de comentario. Para examinar cada línea dentro de una canalización, se utilice el cmdlet ForEach-Object, que es similar a una instrucción ForEach…Next en que permite nos trabajar con un objeto individual de dentro de una colección, una cada vez. El carácter de marcas de graduación espera (') se utiliza para continuar con el comando para la línea siguiente. La acción que desea realizar en cada objeto tal como lo que respecta a través de la canalización está contenida dentro de un bloque de secuencias de comandos, que se define con un conjunto de entre llaves (también denominado llaves). Esta parte de la función de Get-Content se considera aquí:

ForEach-Object `
  {

Cuando estemos dentro del bloque de proceso cmdlet ForEach-Object, queremos examine la línea de texto. Para ello, se utilice si la instrucción. La variable $ _ automático se utiliza para representar la línea actual que se encuentra en la canalización. Se utilice el operador de –match para realizar una coincidencia de modelo de expresión regular en la línea de texto. El operador –match devuelve un valor de tipo Boolean True o False en respuesta a la trama que comienza la trama a la derecha del operador de –match. Esta sección de la secuencia de comandos se muestra aquí:

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

El modelo de expresión regular que estamos utilizando se compone de un número de caracteres especiales:

^ —Match al principio

\ —Escape caracteres por lo que el signo $ se trata como un carácter literal y no el carácter especial utilizado en expresiones regulares

comentario de $ Caracteres —Literal

¿\s? —Zero o más caracteres de espacio en blanco

= Carácter —Literal

¿\s? —Zero o más caracteres de espacio en blanco

@ ", Caracteres literales

La sección de código que examina la línea actual de texto en la canalización se muestra aquí:

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

Creamos un beginComment variable denominada $ que se utiliza para marca el inicio del bloque de comentario. Si se realizan más allá de la instrucción –match, se ha encontrado el principio del bloque de comentario. Hemos establecido la variable igual al $ True tal como muestra aquí:

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

A continuación, compruebe si se encuentran al final del bloque de comentario. Para ello, nos nuevo utilice el operador –match. Esta vez, busque el "@ secuencia de caracteres, que se utiliza para cerrar una cadena de aquí. Si se encuentra, se establece la variable de beginComment $ en Falso:

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

Se ha realizado, más allá de los dos primeros si las instrucciones: la primera uno identifica el principio de la cadena de aquí, y la segunda busca el final de la cadena de aquí. Ahora que deseamos tomar el texto que se escriban en nuestro archivo de comentario. Para ello, deseamos que la variable de beginComment $ se establezca en True. Nos también desean asegurarse de que se no ve el en marca de presupuesto de inicio de sesión (@ ") de caracteres de la línea porque significaría el final de la cadena de aquí. Para realizar esta determinación, se utilice un si compuesta instrucción:

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

Ahora, escriba el texto en el archivo de resultados. Para ello, utilizamos la variable $ _ automático, que representa la línea actual de texto; se canalización que la Out-File cmdlet. El Out-File cmdlet recibe la variable de OutPutFile $, que contiene la ruta de acceso al archivo comentario. Se utilice el parámetro –append para especificar que desea recopilar todos los comentarios de la secuencia de comandos en el archivo de comentario. Si se ha no usamos el parámetro de datos anexados, el archivo de texto contendría sólo el último comentario porque, de forma predeterminada, el Out-File cmdlet podría sobrescribir su contenido. A continuación, cerramos fuera todas las llaves. Considera que una práctica recomendada de agregar un comentario después de cada cierre llave que indica el propósito de la llave. Esto facilita la secuencia de comandos mucho para lectura, así como facilita la solución de problemas y mantener:

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

Ahora, crear una función denominada Get-OutPutFile que se abrirá el archivo de salida para nosotros para leer. Porque la carpeta temporal no es fácil encontrar y tenemos la ruta de acceso al archivo en la variable de OutPutFile $, sentido utilizar la secuencia de comandos para abrir el archivo de salida. La función de Get-OutPutFile recibe una única entrada variable denominada $ OutPutFile, que contiene la ruta de acceso del archivo de comentario que desea abrir. Cuando se llama a la función de Get-OutPutFile, se pasará $ OutPutFile a ella. Se podría pasar cualquier valor que desea en la función de Get-OutPutFile y dentro de la función que hace el valor podría ser referencia la $ OutPutFile variable. Incluso se puede pasar una cadena directamente (sin utilizar comillas alrededor de la cadena) a la función:

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

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

En general, al escribir una secuencia de comandos, si se va a recopilar copia algo para pasar a una función, es una buena idea encase los datos en el mismo nombre de variable que se utilizará tanto dentro como fuera de la función. Esto sigue uno de nuestras prácticas recomendadas para el desarrollo de secuencias de comandos: "No estropear con la sección de trabajo de la secuencia de comandos". En este ejemplo, cuando se llama a la función son "hacemos trabajo." Para cambiar este en futuras secuencias de comandos sería necesario que nos modificar el valor literal de cadena. Al colocar la cadena en una variable, se puede modificar fácilmente el valor de la variable. Son, de hecho, configuramos proporcionar el valor de la variable a través de la línea de comandos o por medio de algo en otra función. Siempre que sea posible, debe evitar colocar los valores literales de cadena directamente en la secuencia de comandos. En el código que aparece a continuación, utilizamos una variable para contener la ruta de acceso al archivo que se pasará a la función de Get-OutPutFile:

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

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

La función de Get-OutPutFile completa se muestra aquí:

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

En lugar de escribir en una cadena literal la ruta de acceso del archivo de salida, la variable de OutPutFile $ recibe la ruta que se crea mediante la función de Get-FileName. La función de Get-FileName recibe la secuencia de comandos que contiene los comentarios que se extraen la ruta de acceso. La ruta de acceso esta secuencia de comandos se incluye en mediante el parámetro de la línea de comandos. Cuando una función tiene un solo parámetro de entrada, puede pasar a la función utilizando un conjunto de paréntesis. Si, por otro lado, la función utiliza dos o más parámetros de entrada, debe utilizar la sintaxis de nombre –parameter:

$OutPutFile = Get-FileName($script)

A continuación se llame a la función Remove-OutPutFile (descrita anteriormente) y pasarle la ruta de acceso a la OutPutFile que está en la variable de OutPutFile $:

Remove-OutPutFile($OutPutFile)

Cuando nos se asegura de nombre de nuestro archivo de salida, nos llamar a la función de Get-comentarios para recuperar los comentarios de la secuencia de comandos cuya ruta de acceso se indica mediante la variable de secuencia de comandos $. Los comentarios se escribirán en el archivo de salida al que hace referencia la variable de OutPutFile $. Esta línea de código se considera aquí:

Get-Comments -script $script -outputfile $OutPutFile

Cuando los comentarios han todos se escriben en el archivo de salida,, por último, llamar a la función Get-OutPutFile y pasarla la ruta contenida en la variable de OutPutFile $. Si no desea que se abrirá el archivo de comentario, puede fácilmente comentario la línea de la secuencia de comandos o simplemente eliminar y la propia función Get-OutPutFile desde la secuencia de comandos. Si está interesado en revisar cada uno de los archivos antes de guardarlo, dejar la línea de código en su lugar:

Get-OutPutFile($OutPutFile)

Cuando se ejecuta la secuencia de comandos GetCommentsFromScript.ps1, no se muestra ningún mensaje de confirmación en la pantalla. La confirmación sólo que funcionaban de la secuencia de comandos es la presencia del nuevo archivo de texto mostrará en el bloc de notas, tal como se muestra en la figura 5 .

La figura 5 el nuevo archivo de texto mostrado en el bloc de notas

La secuencia de comandos GetCommentsFromScript.ps1 se puede adaptar fácilmente a su propia forma de escribir secuencias de comandos o incluso para recopilar otros tipos de documentación de los archivos de registro basado en texto. Todo lo que necesita hacer es modificar el modelo de expresión regular se utiliza para marcar el principio y final de las partes de texto está interesado en recopilar. Esperamos que disfrute de la secuencia de comandos y invitamos a que se Únase a nosotros en el Centro de secuencias de comandos, donde se publique un nuevo ¡ Hola, chicos del scripting! artículo todos los días de la semana.

Ed Wilson , un experto de secuencias de comandos conocido, es el autor de ocho libros, como guía de secuencias de comandos de Windows PowerShell (Microsoft Press, 2008) y Microsoft Windows PowerShell paso por paso (Microsoft Press, 2007). Ed contiene más de 20 certificaciones del sector, incluidos Microsoft Certified Systems Engineer (MCSE) y Certified Information Systems Security Professional (CISSP). En su tiempo libre, disfruta woodworking, fotografía underwater y scuba diving. Y té.

Craig Liebendorfer es wordsmith y longtime editor Web de Microsoft. Craig aún no se puede creer hay un trabajo que se paga a trabajar con las palabras cada día. Uno de sus cosas favoritas es irreverent humor, para que debe ajustarse derecha en aquí. Considera que su accomplishment mayor en la vida que su hija magnificent.

Compartir a través de

Recursos adicionales