Autor : Li Juncai (jcLee95) : https://blog.csdn.net/qq_28550263
E-mail: [email protected]
Endereço do artigo : https://blog.csdn.net/qq_28550263/article/details/132872318
Índice
1. Visão Geral
Uma das filosofias de design do PowerShell é que tudo é um objeto. Mesmo os tipos de dados básicos possuem representações de objetos correspondentes. No PowerShell, os objetos são um conceito central; eles são usados para representar e manipular dados. PowerShell é uma linguagem de script e ambiente shell que permite trabalhar com vários objetos, incluindo objetos no .NET Framework, objetos personalizados e objetos integrados. Abaixo discutiremos objetos no PowerShell e coisas relacionadas à programação orientada a objetos.
2. Objetos no PowerShell
Objetos no PowerShell são objetos .NET no .NET Framework e incluem vários tipos, como strings, inteiros, matrizes, tabelas hash, objetos personalizados, etc.
-
Tipos de dados básicos: No PowerShell, você pode lidar com tipos de dados básicos, como números inteiros, strings, números de ponto flutuante, etc. No PowerShell, tipos de dados básicos (como números inteiros, strings, números de ponto flutuante, etc.) podem ser tratados como objetos. Por exemplo, você pode adicionar dois números inteiros e armazenar o resultado em uma variável.
$a = 5 $b = 10 $sum = $a + $b -
Array: Um array é uma coleção ordenada de elementos que você pode acessar usando um índice.
$fruits = @("Apple", "Banana", "Cherry") $fruits[1] # 输出 "Banana" -
Tabela hash: Uma tabela hash é uma coleção de pares chave-valor que permite associar valores a chaves exclusivas. No PowerShell, você pode usar tabelas hash para armazenar e recuperar dados.
$person = @{ "Name" = "John" "Age" = 30 "City" = "New York" } $person["Name"] # 输出 "John" -
Objetos personalizados: você pode criar seus próprios objetos personalizados, que podem conter propriedades e métodos personalizados. Objetos personalizados fazem parte da programação orientada a objetos no PowerShell.
$person = New-Object PSObject -Property @{ "Name" = "Alice" "Age" = 25 } $person | Add-Member -MemberType NoteProperty -Name "City" -Value "Los Angeles" $person.Name # 输出 "Alice"
3. Programação orientada a objetos
Embora o PowerShell seja principalmente uma linguagem de script, ele também oferece suporte a conceitos de programação orientada a objetos (OOP). No PowerShell, você pode criar e manipular objetos personalizados, vincular métodos a objetos e usar conceitos OOP, como herança e encapsulamento.
A seguir estão os conceitos do PowerShell relacionados à programação orientada a objetos:
classes e objetos
Você usa uma classe para definir um modelo para um objeto e, em seguida, usa essa classe para criar instâncias de objeto. Isso permite vincular propriedades e métodos a objetos. Por exemplo:
class Employer {
[string]$Name
[int]$Age
Employer([string]$name, [int]$age) {
$this.Name = $name
$this.Age = $age
}
[void] SayHello() {
Write-Host "Hello, my name is $($this.Name) and I am $($this.Age) years old."
}
}
$employer = [Employer]::new("Jack", 28)
$employer.SayHello() # 输出 "Hello, my name is Jack and I am 28 years old."
A saída é:
Hello, my name is Jack and I am 28 years old.
enumerar
Enumeração (Enum) é um tipo de dados especial usado para definir um conjunto de valores constantes nomeados. As enumerações também podem ser consideradas, até certo ponto, como uma classe especial, embora sua sintaxe e propósito sejam um pouco diferentes das classes regulares. O PowerShell também oferece suporte a tipos de enumeração. As enumerações são semelhantes às classes, que contêm membros. Esses membros são tratados como campos constantes na enumeração. Você pode atribuir valores específicos aos membros da enumeração, assim como pode atribuir valores aos campos de uma classe. Esses valores são imutáveis e não podem ser modificados. No PowerShell, você pode criar e usar enumerações para melhorar a legibilidade e a manutenção do seu código.
1. Defina enumerações
No PowerShell, você pode usar enumpalavras-chave para definir enumerações. Aqui está um exemplo:
enum DaysOfWeek {
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
Sunday
}
Aqui definimos um DaysOfWeekenum nomeado que contém cada dia da semana.
2. Use enumerações
Depois de definir uma enumeração, você poderá usá-la em seu código. Os membros da enumeração podem ser acessados por meio da notação de ponto. Por exemplo:
$today = [DaysOfWeek]::Monday
Write-Host $today
O código acima definirá $todayum DaysOfWeekmembro da enumeração, nomeadamente "Segunda-feira". A saída é:
Monday
3. Valores enumerados
Por padrão, os valores dos membros da enumeração são inteiros começando em 0. Você também pode especificar explicitamente valores para membros de enumeração, como segue:
enum DaysOfWeek {
Monday = 1
Tuesday = 2
Wednesday = 3
Thursday = 4
Friday = 5
Saturday = 6
Sunday = 7
}
No exemplo acima, atribuímos um valor inteiro a cada membro da enumeração, o que torna os valores da enumeração mais significativos.
4. Use enumerações para melhorar a legibilidade do código
As enumerações fornecem melhor legibilidade no código, especialmente quando você precisa representar um conjunto de valores constantes relacionados. Eles podem ser usados para melhorar a capacidade de manutenção do seu código porque permitem que você use nomes significativos em vez de valores codificados.
Por exemplo, digamos que você tenha uma função que executa ações diferentes com base no dia da semana:
# 定义一个枚举类型 DaysOfWeek，表示一周中的每一天
enum DaysOfWeek {
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
Sunday
}
# 定义一个函数 DoWork，接受一个 DaysOfWeek 类型的参数 $day
function DoWork([DaysOfWeek]$day) {
# 使用 switch 语句根据不同的 $day 值执行不同的操作
switch ($day) {
Monday {
Write-Host "今天是星期一，是一周的开始。"
}
Friday {
Write-Host "今天是星期五，是时候庆祝了！"
}
default {
Write-Host "今天是一周中的其他一天。"
}
}
}
# 调用 DoWork 函数并传递一个 DaysOfWeek 值作为参数
DoWork Monday
DoWork Friday
DoWork Wednesday
Neste exemplo, usamos enumerações DaysOfWeekcomo parâmetros de função para melhorar a legibilidade e clareza do código. O resultado da execução deste código é:
今天是星期一，是一周的开始。
今天是星期五，是时候庆祝了！
今天是一周中的其他一天。
herdar
Você pode criar um relacionamento de herança de classe, onde uma classe pode herdar as propriedades e métodos de outra classe.
class Employee {
[string]$Name
[int]$Age
Employee([string]$name, [int]$age) {
$this.Name = $name
$this.Age = $age
}
[string] SayHello() {
return "Hello, my name is $($this.Name) and I am $($this.Age) years old."
}
}
class Employer: Employee {
[string]$EmployeeID
Employer([string]$name, [int]$age, [string]$employeeID) : base($name, $age) {
$this.EmployeeID = $employeeID
}
[string] SayHello() {
return "Hello, my name is $($this.Name) and I am $($this.Age) years old and I'm glad to be your boss."
}
}
# 创建 Employee 对象
$employee = [Employer]::new("Jack", 28, "ID00001")
# 调用 SayHello 方法
$greeting = $employee.SayHello()
Write-Host $greeting
Neste exemplo, o chefe herda do funcionário e substitui o método SayHello da classe funcionário como funcionário especial. A saída após a execução é:
Hello, my name is Jack and I am 28 years old and I'm glad to be your boss.
encapsulamento
Você pode usar modificadores de acesso para controlar o nível de acesso de propriedades e métodos para obter o encapsulamento. Por exemplo:
class BankAccount {
[string]$AccountNumber
[decimal]$Balance
<#
构造函数：BankAccount
初始化银行账户对象。
参数：
$accountNumber (string) - 账户号码
$balance (decimal) - 初始余额
返回值：
无
#>
BankAccount([string]$accountNumber, [decimal]$balance) {
$this.AccountNumber = $accountNumber
$this.Balance = $balance
Write-Host "账户创建成功，账号：$($this.AccountNumber)，余额：$($this.Balance)。"
}
<#
存款方法：Deposit
存入指定金额到银行账户。
参数：
$amount (decimal) - 存款金额
返回值：
无
#>
[void] Deposit([decimal]$amount) {
$this.Balance += $amount
Write-Host "存款成功，存入金额：$($amount)，账号：$($this.AccountNumber)。新余额：$($this.Balance)。"
}
<#
取款方法：Withdraw
从银行账户中取出指定金额。
参数：
$amount (decimal) - 取款金额
返回值：
无
#>
[void] Withdraw([decimal]$amount) {
if ($this.Balance -ge $amount) {
$this.Balance -= $amount
Write-Host "取款成功，取出金额：$($amount)，账号：$($this.AccountNumber)。新余额：$($this.Balance)。"
} else {
Write-Host "余额不足。"
}
}
}
$account = [BankAccount]::new("A12345", 1000)
$account.Deposit(500)
$account.Withdraw(200)
Este código é um exemplo de classe do PowerShell BankAccountque representa uma conta bancária simples e encapsula o status e as operações da conta por meio de encapsulamento em programação orientada a objetos.
- Encapsulamento de atributos: Na definição da classe, existem dois atributos
AccountNumbereBalance, que são declarados como tipos[string]e[decimal], usados para armazenar números de contas e informações de saldo, respectivamente. Essas propriedades são encapsuladas dentro da classe e seus valores não podem ser acessados ou modificados diretamente pelo mundo externo. Esse encapsulamento garante a segurança e integridade dos dados da conta. - Encapsulamento do construtor: O construtor
BankAccounté usado para inicializar o objeto conta e aceita dois parâmetrosaccountNumberebalance, que são usados para definir o número da conta e o saldo inicial, respectivamente. Esses parâmetros são atribuídos às propriedades da classeAccountNumbere às propriedades dentro do construtorBalance, e o código externo não pode acessá-los ou alterá-los diretamente. - Encapsulamento de métodos:
DepositDois métodos são definidos na classeWithdraw, que são usados para realizar operações de depósito e retirada. Esses métodos também encapsulam o comportamento da conta. O código externo só pode interagir com o objeto da conta por meio de chamadas de método e não pode operar diretamente os atributos da conta. - Ocultação de dados: dentro dos métodos, você pode ver que suas operações nas propriedades são
$thisacessadas por meio de palavras-chave, como$this.AccountNumbere$this.Balance. Este método esconde os detalhes específicos de implementação das propriedades.O código externo só precisa saber como operar através dos métodos e não precisa se preocupar com a estrutura das propriedades internas.
Além disso, a saída deste código é:
账户创建成功，账号：A12345，余额：1000。
存款成功，存入金额：500，账号：A12345。新余额：1500。
取款成功，取出金额：200，账号：A12345。新余额：1300。
Através dos exemplos acima, podemos ver que embora o PowerShell seja uma linguagem de script, ele fornece muitos recursos de programação orientada a objetos, incluindo criação e operação de objetos personalizados, herança, encapsulamento e polimorfismo. Isso torna o PowerShell adequado não apenas para tarefas de automação, mas também para tarefas complexas de desenvolvimento e gerenciamento de aplicativos.