Ei, Scripting Guy! Criar um script Self-Documenting
The Microsoft Scripting Guys
Para descrever a profundidade incrível de azul brushed amplamente entre o céu pressionada aqui em Buenos Aires, nomes de cores especiais devem ser usados. Azul cobalt azul deep-sea azul de meia-noite, holy-mackerel azul, nenhum desses mesmo começar a portray a cor real Vista na abóbada cobrindo a cidade antiga. Grande calçadas lado por edifícios séculos-antigo são pontilhadas com pouco tabelas. Estão em uma cadeira de metal vazia. Moleza perfumed drifts ociosamente executando as dicas de cinnamon, cardamom e thyme. Seagulls com asas outstretched navegar os updrafts com suficiente habilidades, cortesia e poise engender envy in the Kahuna grande se. O café con leche parece especialmente apropos e é segura o suficiente para solicitar seu próprio atenção em relação a concorrência dos sights e sons de luzes da cidade Buenos Aires. Estou na cidade para conversar com clientes Microsoft Premier sobre o uso do VBScript para ajudar a gerenciar suas redes. Eu extrair um mapa dobrado bolsa minha câmera e prossiga para planejar meu rota da Flórida Calle para o Obelisk Nueve de Julio Avenue.
Acho que minha localização no mapa. Estou próximo a Galeria de compra Galerias Pacifico. Eu vire o mapa de várias vezes como eu tentar orientar com o local em tempo e espaço. Sobre esse tempo, um homem alto, procurando distinto de um naipe escuro three-piece aparece e significa apenas do sunlight. A sombra, dançar playfully no mapa, faz com que me Observe backup. Espera que ele diz, "Buenos dias, se˜nor."
"Buenos dias", obedientemente respostas.
"AH, é um americano talvez?" ele responde com um acento ligeiramente britânico.
EU sou um pouco informada aback e hesitantly responder in the affirmative.
"É essa a primeira vez em nossa cidade razoável?", ele inquires.
Novamente, eu estou reticent mas dizer "Sim".
", Em seguida, pode oferecer meu serviço humble para você. O que é que você busca?" ele educadamente pergunta.
Dizer que ele, e ele continua me dar instruções. Depois disso, bate-papo por alguns minutos.
Uau! Eu acho que para mim. " Uma cidade self-documenting! Não há necessidade de mapas aqui. As pessoas estão tão amigáveis que você quase não terá tempo para ver um mapa antes que alguém está lá para ajudá-lo."
Isso foi, na verdade, há alguns anos atrás. Hoje em dia, na minha casa na Carolina do Norte, o tempo fora é tão atraente-lembra-me de meu visita ao Buenos Aires — e de boa como um recurso self-documenting pode ser. Nós podem ter nossos scripts executar um serviço semelhante para nós, se é levar o tempo para planejar antecipadamente. Neste artigo, nós aprenderá a desenvolver um script que irá coletar comentários de outros scripts que seguem um determinado padrão. É possível modificar o padrão para atender às necessidades de nossas próprios e pode expandir a técnica além da criação de documentação para scripts.
Vamos examinar um script que tem algumas documentação cuidadosamente colocada em-lo. No script GetSetIEStartPage.ps1 na Figura 1 (que foi escrito para Ei, Equipe de Scripts! artigo " Como alterar minha home page do Internet Explorer?", comentários são colocados em aqui-seqüências de caracteres, em seguida, é atribuídos a um comentário de $ nomeado variável. Um aqui-cadeia de caracteres é delineado por uma marca de início de um símbolo arroba e uma aspa (@ ") e uma marca de fechamento de aspas e um sinal de arroba ("@). Há três blocos de comentário estamos interessados na obtenção. O primeiro contém informações de cabeçalho de script normal: o título, autor, data, palavras-chave e comentários sobre o script propriamente dito. Os blocos de comentário do segundo e terceiro especificamente estão relacionados às duas funções principais contidas no script.
A 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 gravar os comentários do arquivo de origem em outro documento, nós precisa para abrir o script original, procurar os comentários e, em seguida, escreva o texto apropriado para um novo arquivo. Parece bastante simples. Ah, sim, também precisamos um nome para o nosso novo script. Vamos chamá-lo GetCommentsFromScript.ps1.
O script GetCommentsFromScript.ps1, mostrado na Figura 2 , começa com uma instrução de parâmetros, que é usada para permitir a fornecer informações para o script em tempo de execução. Eis a instrução de parâmetros.
A 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."))
A vantagem de usar um parâmetro de linha de comando é que nós não precisa abrir o script e editá-lo a fornecer o caminho para o script cujos comentários, vamos copiar. Estamos fazendo este parâmetro obrigatório, atribuindo um valor padrão a variável $ script. O valor padrão usa o comando Enviar para gerar um erro e isso significa que o script irá sempre gerar um erro quando executado, a menos que é fornecer um valor para o parâmetro –script.
Vamos digress por um minuto e dê uma olhada como a declaração throw é usada no script DemoThrow.ps1 na Figura 3 . Para obter após o erro que é gerado pela instrução throw na função Set-erro, primeiro precisamos definir a variável de errorActionPreference $ como SilentlyContinue. Isso impede que o erro seja exibida e permite que o script continuar. É o mesmo que a configuração On Error Resume Next do VBScript. O se a declaração é usada para avaliar a variável de valor $. Se houver uma correspondência, a declaração throw for encontrada e a exceção é lançada. Para avaliar o erro, usamos a função de Get-ErrorDetails. A primeira coisa que ocorre é a exibição da contagem de erro, que será ter sido incrementada em 1 por causa do erro gerado pela declaração throw. Nós, em seguida, se o primeiro erro (o erro com o valor de índice de 0 é sempre que mais recente) e envie o objeto de erro para o cmdlet Format-List. Escolhemos todas as propriedades. No entanto, as informações de invocação, são retornadas como um objeto, e, portanto, precisamos consultar esse objeto diretamente. Fazemos isso, acessando o objeto de chamada por meio da propriedade InvocationInfo do objeto erro. As informações de erro resultante são mostradas na Figura 4 .
A 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
A Figura 4 Lançar A declaração é usada para gerar um erro
Agora vamos retornar ao nosso script principal, GetCommentsFromScript.ps1. É necessário uma função que irá criar um nome de arquivo para o novo documento de texto que irá conter todos os comentários retirados do script. Para fazer isso, é usar a palavra-chave de função e siga-lo com o nome para a função. Será chamamos nossa função Get-FileName em acordo com a convenção de nomenclatura de verbo-substantivo Windows PowerShell. Get-FileName terão um único parâmetro de entrada, o caminho do script a ser analisado, que será retido na variável de script $ dentro a função. Eis a entrada para a função de Get-FileName:
Function Get-FileName($Script)
{
Em seguida, obter o caminho para a pasta temporária no computador local. Há várias maneiras para fazer isso, inclusive usando a unidade do Windows PowerShell ambiental. No entanto, decidimos usar o método GetTempPath estático da classe Io.Path .NET Framework. O método GetTempPath retorna o caminho para a pasta temporária, que é onde armazenaremos o arquivo de texto recém-criado. Mantenha o caminho da pasta temporária na variável $ OutPutPath conforme mostrado aqui:
$OutPutPath = [io.path]::GetTempPath()
Decidimos nomear o nosso novo arquivo de texto após o nome do script. Para fazer isso, precisamos separar o nome de script do caminho que o script é armazenado em. Usamos o cmdlet de caminho de divisão para executar este surgery. O parâmetro –leaf informa o cmdlet para retornar o nome do script. Se nós quisesse o caminho do diretório que contém o script, seria usamos o parâmetro –parent. Colocamos o comando Dividir-caminho dentro de um par de parênteses porque queremos essa operação para ocorrer em primeiro lugar, e nós coloque um sinal de dólar na frente dos parênteses para criar um sub-expression que irá executar o código e retornar o nome do script. Nós poderia use.ps1 como a extensão para nosso arquivo de texto, mas que pode ser confuso porque é a extensão de um script. Nós, portanto, simplesmente adicione uma extensão .txt com o nome de arquivo retornado e coloque tudo em um par de aspas. Agora, usamos o cmdlet de caminho de associação para criar um novo caminho em nosso arquivo de saída. O novo caminho é composto da pasta temporária, armazenada na variável $ OutPutPath e o nome do arquivo que criamos usando o caminho de divisão. Poderíamos ter usado manipulação de seqüência de caracteres e concatenação para criar o novo caminho de arquivo, mas é mais confiável para usar associação-caminho e o caminho dividido para executar esses tipos de operações. Eis o código é semelhante:
Join-Path -path $OutPutPath -child "$(Split-Path $script-leaf).txt"
} #end Get-FileName
Agora precisamos decidir como vamos para manipular arquivos duplicados. Nós pode solicitar ao usuário dizendo que um arquivo duplicado existe, usando código como este:
$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 }
Pode implementar algum tipo de algoritmo de nomeação que faz um backup do arquivo existente, renomeando-lo com uma extensão. old. Se nós fizemos isso, o código poderia ser algo semelhante ao seguinte:
if(Test-Path -path "$OutPutFile.old") { Remove-Item-Path "$OutPutFile.old" }
Rename-Item -path $OutPutFile -newname "$(Split-Path $OutPutFile -leaf).old"
Ou, pode simplesmente excluir o arquivo existente, que é a que escolhi. A ação que deseja executar ocorre na função remove-OutPutFile, que nós cria usando a palavra-chave Function e especificando o nome da função. Usamos $ OutPutFile para fornecer a entrada para a função, como mostrado aqui:
Function Remove-OutPutFile($OutPutFile)
{
Para determinar se o arquivo existir, é usar o cmdlet Test-caminho e fornecer a cadeia de caracteres contida na variável $ OutPutFile para o parâmetro de caminho. O cmdlet Test-Path retorna somente um True ou um false, dependendo se um arquivo for encontrado. Isso significa que pode usar se instrução para avaliar a existência do arquivo. Se o arquivo for encontrado, é executar a ação no bloco de script. Se o arquivo não for encontrado, o bloco de script não é executado. Você pode ver aqui que o primeiro comando não localizar o arquivo, e False será retornado. No segundo comando, o bloco de script não é executado porque o arquivo não pode ser localizado:
PS C:\> Test-Path c:\missingfile.txt
False
PS C:\> if(Test-Path c:\missingfile.txt){"found file"}
PS C:\>
Dentro da função de remove-OutPutFile, o se instrução é usada para determinar se o arquivo referenciado pelo OutPutFile $ já existe. Se tiver, ele será excluído usando o cmdlet remove-item. As informações que normalmente são retornadas quando um arquivo é excluído é pipelined para o Out-Null cmdlet, propiciando a operação silenciosa. O código é mostrado aqui:
if(Test-Path -path $OutPutFile) { Remove-Item $OutPutFile | Out-Null }
} #end Remove-OutPutFile
Depois que tiver criou o nome para o arquivo de saída e excluiu qualquer arquivos de saída anterior que podem ser residente em torno, é tempo para recuperar os comentários de script. Para fazer isso, nós criamos a função de Get-comentários e passe-a variável de script $ e a variável $ OutPutFile, conforme mostrado aqui:
Function Get-Comments($Script,$OutPutFile)
{
Agora, leia o texto do script usando o cmdlet de Get-Content, para o qual, passamos o caminho para o script. Quando usamos Get-Content para ler um arquivo, o arquivo é lido uma linha por vez e cada linha é passada junto o pipeline. Se precisássemos armazenar o resultado em uma variável, teria uma matriz. Nós pode tratar a variável $ um tipo que qualquer outra matriz, incluindo como obter o número de elementos na matriz por meio da propriedade comprimento e indexar diretamente para a matriz como mostrado aqui:
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
Eis a linha que lê o script de entrada e o envia junto o pipeline:
Get-Content -path $Script |
Em seguida, precisamos examinar cada linha para ver se ele pertence o bloco de comentários. Para examinar cada linha dentro de um pipeline, usamos o cmdlet ForEach-Object, que é semelhante a uma instrução ForEach…Next em que ele permite trabalhar com um objeto individual de dentro de uma coleção, uma por vez. O caractere de escala Voltar (') é usado para continuar o comando para a próxima linha. A ação que deseja executar em cada objeto conforme ele encontra o pipeline está contida dentro de um bloco de script, que é delineado com um conjunto de chaves (também chamado de chaves). Nesta parte da função Get-Content é Vista aqui:
ForEach-Object `
{
Quando estamos dentro do bloco de processo de cmdlet ForEach-Object, queremos examinar a linha do texto. Para fazer isso, nós use se instrução. A variável $ _ automático é usada para representar a linha atual que está no pipeline. Nós usamos o operador –match para realizar uma correspondência de padrão expressão regular com a linha do texto. O operador –match retorna um Boolean True ou False em resposta ao padrão que começa O padrão no lado direito do operador –match. Esta seção do script é mostrada aqui:
PS C:\fso> '$Comment = @"' -match '^\$comment\s?=\s?@"'
True
O padrão de expressão regular que estamos usando é composto de um número de caracteres especiais:
^ —Match no início
\ —Escape caracteres para o sinal de $ é tratado como um caractere literal e não o caractere especial usado em expressões regulares
comentário de $ Caracteres —Literal
\s? —Zero ou mais caracteres de espaço em branco
= Caractere —Literal
\s? —Zero ou mais caracteres de espaço em branco
@ " — Caracteres literais
A seção do código que examina a linha de texto no pipeline atual é mostrada aqui:
If($_ -match '^\$comment\s?=\s?@"')
Criamos um beginComment variável $ nomeado que é usado para marca o início do bloco de comentário. Se nós fizer a instrução –match, descobrimos início do bloco de comentários. Definimos a variável igual como $ true conforme ilustrado aqui:
{
$beginComment = $True
} #end if match @"
Em seguida, verifique se estamos no final do bloco de comentário. Para fazer isso, novamente, use o operador de –match. Desta vez, procure o "@ seqüência de caracteres, que é usado para fechar um aqui-cadeia de caracteres. Se nós achar, definimos a variável de beginComment $ como False:
If($_ -match '"@')
{
$beginComment = $False
} #end if match "@
Fizemos-lo após os dois primeiros se instruções: primeiro identifica o início das aqui-cadeia de caracteres, e a segunda localiza final as aqui-cadeia de caracteres. Agora deseja capturar o texto a ser escrito em nosso arquivo de comentário. Para fazer isso, queremos que a variável $ beginComment ser definido como True. Nós também deseja se certificar que nós não vir no sinal de aspas (@ ") caracteres na linha porque ela significaria final as aqui-cadeia de caracteres. Para fazer essa determinação, use um se compostos instrução:
If($beginComment -AND $_ -notmatch '@"')
{
Agora, escreva o texto no arquivo de saída. Para fazer isso, é usar a variável $ _ automática, que representa a linha atual de texto; nós pipeline que o Out-File cmdlet. O Out-File cmdlet recebe a variável $ OutPutFile, que contém o caminho para o arquivo de comentário. Usamos o parâmetro –append para especificar que desejamos que coletar todos os comentários do script no arquivo comentário. Se nós não usou o parâmetro append, o arquivo de texto conteria apenas o último comentário porque, por padrão, o Out-File cmdlet substituiria seu conteúdo. Nós, em seguida, feche-out de todas as chaves. EU considero a ele uma prática recomendada é adicionar um comentário após cada chave fechamento que indica a finalidade da chave. Isso faz o script muito mais fácil leitura, bem como mais fácil solucionar problemas e a manter:
$_ | Out-File -FilePath $OutPutFile -append
} # end if beginComment
} #end ForEach
} #end Get-Comments
Agora, criamos uma função chamada Get-OutPutFile que abrirá o arquivo de saída para nós ler. Como a pasta temporária não é fácil localizar e tivemos o caminho para o arquivo na variável $ OutPutFile, faz sentido usar o script para abrir o arquivo de saída. A função de Get-OutPutFile recebe uma única entrada variável chamada $ OutPutFile, que contém o caminho para o arquivo de comentário que deseja abrir. Quando chamamos a função de Get-OutPutFile, nós passará $ OutPutFile a ele. Foi passamos qualquer valor que deseja para a função de Get-OutPutFile e dentro a função que o valor deve ser referenciado pela variável $ OutPutFile. Podemos até passar uma seqüência de caracteres diretamente (sem usar aspas a seqüência de caracteres) para a função:
Function Get-OutPutFile($OutPutFile)
{
Notepad $OutPutFile
} #end Get-OutPutFile
Get-OutPutFile -outputfile C:\fso\GetSetieStartPage.ps1
Em geral, ao escrever um script, se você for para reunir up algo para passar para uma função, ela é uma boa idéia a encase os dados no mesmo nome de variável que será usado tanto dentro quanto fora a função. Isso segue uma das nossas recomendações para o desenvolvimento do script: "não estragar com a seção de trabalho do script." Neste exemplo, quando chamamos a função estamos "fazendo trabalho." Para alterar isso no futuro scripts exigiria que nós editar o valor literal de seqüência de caracteres. Colocando a seqüência de caracteres em uma variável, pode editar facilmente o valor da variável. Nós, na verdade, configurados para fornecer o valor da variável através da linha de comando ou por meio de algo feito em outra função. Sempre que possível, evite colocar valores literais de seqüência de caracteres diretamente no script. O código que segue, usamos uma variável para conter o caminho para o arquivo que será passado para a função de Get-OutPutFile:
Function Get-OutPutFile($OutPutFile)
{
Notepad $OutPutFile
} #end Get-OutPutFile
$OutPutFile = "C:\fso\GetSetieStartPage.ps1"
Get-OutPutFile -outputfile $OutPutFile
A função de Get-OutPutFile completa é mostrada aqui:
Function Get-OutPutFile($OutPutFile)
{
Notepad $OutPutFile
} #end Get-OutPutFile
Em vez de digitar em uma seqüência literal para o caminho para o arquivo de saída, a variável de OutPutFile $ recebe o caminho que é criado pela função de Get-FileName. A função de Get-FileName recebe o caminho para o script que contém os comentários a serem extraídos. O caminho para esse script é via o parâmetro de linha de comando. Quando uma função tem um único parâmetro de entrada, você pode passá-lo para a função usando um conjunto de parênteses. Se, por outro lado, a função usa dois ou mais parâmetros de entrada, você deve usar a sintaxe de nome –parameter:
$OutPutFile = Get-FileName($script)
Em seguida, chamamos a função de remove-OutPutFile (discutida anteriormente) e passar o caminho para o OutPutFile contidos na variável $ OutPutFile:
Remove-OutPutFile($OutPutFile)
Quando nós são certeza do nome do nosso arquivo de saída, chamamos a função de Get-comentários para recuperar comentários do script cujo caminho é indicado pela variável de script de $. Os comentários serão gravados no arquivo de saída referido pela variável $ OutPutFile. Esta linha de código é Vista aqui:
Get-Comments -script $script -outputfile $OutPutFile
Quando os comentários têm todos os foram gravados no arquivo de saída, nós finalmente chamar a função de Get-OutPutFile e passá-lo o caminho contido na variável $ OutPutFile. Se você quiser o arquivo de comentário a ser aberto, você pode facilmente comente a linha fora do seu script, ou simplesmente excluir- e a função de Get-OutPutFile propriamente dito do seu script. Se você não tiver interessado revisar cada arquivo antes de salvá-lo, deixe a linha de código no local:
Get-OutPutFile($OutPutFile)
Quando o script GetCommentsFromScript.ps1 é executado, nenhuma mensagem de confirmação é mostrada na tela. A confirmação apenas que o script funcionou é a presença do arquivo texto recém-criado exibido no Bloco de notas, como mostrado na Figura 5 .
A Figura 5 O novo arquivo de texto exibido no Bloco de notas
O script GetCommentsFromScript.ps1 pode ser facilmente adaptado a sua própria maneira de escrever scripts ou até mesmo para reunir outros tipos de documentação de arquivos de log baseado em texto. Tudo o que você precisa fazer é modificar o padrão de expressão regular que é usado para marcar o início e o fim das partes do texto que você está interessado em coletar. Esperamos que você aproveite o script e você está convidado a Junte-se no Script Center, onde é publicar uma nova Ei, Equipe de Scripts! artigo todos os dias da semana.
Ed Wilson , uma especialista em scripts conhecida, é autor de oito livros, incluindo o Windows PowerShell Scripting Guide (Microsoft Press, 2008) e Microsoft Windows PowerShell Step by Step (Microsoft Press, 2007). Ed contém mais de 20 certificações do setor, incluindo Microsoft Certified Systems Engineer (MCSE) e o Professional de Security Systems (CISSP) de informações do certificado. Em seu tempo livre, ele goza woodworking, fotografia submarinas e scuba diving. E Chá.
Craig Liebendorfer é um wordsmith e longtime editor da Microsoft. Craig ainda não acredito há um trabalho que paga-lo para trabalhar com palavras todos os dias. Uma das suas coisas favoritas é irreverent humor, para que ele deve ajustar direita em aqui. Ele considera seu accomplishment maior na vida seja sua filha magnificent.