ਕਲਾਸਾਂ ਵਾਲਾ ਫੰਕਸ਼ਨਲ ਪਾਵਰਸ਼ੈਲ ਇੱਕ ਆਕਸੀਮੋਰੋਨ ਨਹੀਂ ਹੈ, ਮੈਂ ਇਸਦੀ ਗਰੰਟੀ ਦਿੰਦਾ ਹਾਂ

ਹੇ ਹਬਰ! ਮੈਂ ਲੇਖ ਦਾ ਅਨੁਵਾਦ ਤੁਹਾਡੇ ਧਿਆਨ ਵਿੱਚ ਪੇਸ਼ ਕਰਦਾ ਹਾਂ "ਕਲਾਸਾਂ ਦੇ ਨਾਲ ਕਾਰਜਸ਼ੀਲ PowerShell।
ਮੈਂ ਵਾਅਦਾ ਕਰਦਾ ਹਾਂ ਕਿ ਇਹ ਆਕਸੀਮੋਰੋਨ ਨਹੀਂ ਹੈ" ਕ੍ਰਿਸਟੋਫਰ ਕੁਚ ਦੁਆਰਾ.

ਆਬਜੈਕਟ-ਓਰੀਐਂਟਿਡ ਅਤੇ ਫੰਕਸ਼ਨਲ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਪੈਰਾਡਾਈਮਜ਼ ਇੱਕ ਦੂਜੇ ਨਾਲ ਮਤਭੇਦ ਜਾਪਦੇ ਹਨ, ਪਰ ਪਾਵਰਸ਼ੇਲ ਵਿੱਚ ਦੋਵੇਂ ਬਰਾਬਰ ਸਮਰਥਿਤ ਹਨ। ਲਗਭਗ ਸਾਰੀਆਂ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ, ਕਾਰਜਸ਼ੀਲ ਜਾਂ ਨਹੀਂ, ਵਿਸਤ੍ਰਿਤ ਨਾਮ-ਮੁੱਲ ਬਾਈਡਿੰਗ ਲਈ ਸੁਵਿਧਾਵਾਂ ਹਨ; ਕਲਾਸਾਂ, ਜਿਵੇਂ ਕਿ ਢਾਂਚੇ ਅਤੇ ਰਿਕਾਰਡ, ਸਿਰਫ਼ ਇੱਕ ਪਹੁੰਚ ਹਨ। ਜੇਕਰ ਅਸੀਂ ਕਲਾਸਾਂ ਦੀ ਸਾਡੀ ਵਰਤੋਂ ਨੂੰ ਨਾਮਾਂ ਅਤੇ ਮੁੱਲਾਂ ਦੇ ਬੰਧਨ ਤੱਕ ਸੀਮਿਤ ਕਰਦੇ ਹਾਂ, ਅਤੇ ਭਾਰੀ ਵਸਤੂ-ਅਧਾਰਿਤ ਪ੍ਰੋਗਰਾਮਿੰਗ ਧਾਰਨਾਵਾਂ ਜਿਵੇਂ ਕਿ ਵਿਰਾਸਤ, ਬਹੁਰੂਪਤਾ, ਜਾਂ ਪਰਿਵਰਤਨਸ਼ੀਲਤਾ ਤੋਂ ਬਚਦੇ ਹਾਂ, ਤਾਂ ਅਸੀਂ ਆਪਣੇ ਕੋਡ ਨੂੰ ਗੁੰਝਲਦਾਰ ਬਣਾਏ ਬਿਨਾਂ ਉਹਨਾਂ ਦੇ ਲਾਭਾਂ ਦਾ ਲਾਭ ਲੈ ਸਕਦੇ ਹਾਂ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਅਟੱਲ ਕਿਸਮ ਦੇ ਪਰਿਵਰਤਨ ਵਿਧੀਆਂ ਨੂੰ ਜੋੜ ਕੇ, ਅਸੀਂ ਕਲਾਸਾਂ ਦੇ ਨਾਲ ਸਾਡੇ ਕਾਰਜਸ਼ੀਲ ਕੋਡ ਨੂੰ ਅਮੀਰ ਬਣਾ ਸਕਦੇ ਹਾਂ।

ਜਾਤਾਂ ਦਾ ਜਾਦੂ

ਪਾਵਰਸ਼ੇਲ ਵਿੱਚ ਜਾਤਾਂ ਸਭ ਤੋਂ ਸ਼ਕਤੀਸ਼ਾਲੀ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹਨ। ਜਦੋਂ ਤੁਸੀਂ ਕੋਈ ਮੁੱਲ ਪਾਉਂਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਪਰਿਭਾਸ਼ਿਤ ਸ਼ੁਰੂਆਤੀ ਅਤੇ ਪ੍ਰਮਾਣਿਕਤਾ ਸਮਰੱਥਾਵਾਂ 'ਤੇ ਭਰੋਸਾ ਕਰਦੇ ਹੋ ਜੋ ਵਾਤਾਵਰਣ ਤੁਹਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਜੋੜਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਸਿਰਫ਼ [xml] ਵਿੱਚ ਇੱਕ ਸਤਰ ਕਾਸਟ ਕਰਨ ਨਾਲ ਇਹ ਪਾਰਸਰ ਕੋਡ ਰਾਹੀਂ ਚੱਲੇਗਾ ਅਤੇ ਇੱਕ ਪੂਰਾ xml ਟ੍ਰੀ ਤਿਆਰ ਕਰੇਗਾ। ਅਸੀਂ ਉਸੇ ਉਦੇਸ਼ ਲਈ ਆਪਣੇ ਕੋਡ ਵਿੱਚ ਕਲਾਸਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਾਂ।

ਹੈਸ਼ਟੇਬਲ ਕਾਸਟ ਕਰੋ

ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ ਕੰਸਟਰਕਟਰ ਨਹੀਂ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਆਪਣੀ ਕਲਾਸ ਦੀ ਕਿਸਮ 'ਤੇ ਹੈਸ਼ਟੇਬਲ ਕਾਸਟ ਕਰਕੇ ਇੱਕ ਤੋਂ ਬਿਨਾਂ ਜਾਰੀ ਰੱਖ ਸਕਦੇ ਹੋ। ਇਸ ਪੈਟਰਨ ਦਾ ਪੂਰਾ ਫਾਇਦਾ ਲੈਣ ਲਈ ਪ੍ਰਮਾਣਿਕਤਾ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਨਾ ਭੁੱਲੋ। ਇਸ ਦੇ ਨਾਲ ਹੀ, ਅਸੀਂ ਕਲਾਸ ਦੀਆਂ ਟਾਈਪ ਕੀਤੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੀ ਵਰਤੋਂ ਡੂੰਘੇ ਸ਼ੁਰੂਆਤੀ ਅਤੇ ਪ੍ਰਮਾਣਿਕਤਾ ਤਰਕ ਨੂੰ ਚਲਾਉਣ ਲਈ ਕਰ ਸਕਦੇ ਹਾਂ।

class Cluster {
    [ValidatePattern("^[A-z]+$")]
    [string] $Service
    [ValidateSet("TEST", "STAGE", "CANARY", "PROD")]
    [string] $FlightingRing
    [ValidateSet("EastUS", "WestUS", "NorthEurope")]
    [string] $Region
    [ValidateRange(0, 255)]
    [int] $Index
}

[Cluster]@{
    Service       = "MyService"
    FlightingRing = "PROD"
    Region        = "EastUS"
    Index         = 2
}

ਇਸ ਤੋਂ ਇਲਾਵਾ, ਕਾਸਟਿੰਗ ਇੱਕ ਸਾਫ਼ ਆਉਟਪੁੱਟ ਪ੍ਰਾਪਤ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦੀ ਹੈ। ਫਾਰਮੈਟ-ਟੇਬਲ ਨੂੰ ਪਾਸ ਕੀਤੇ ਗਏ ਕਲੱਸਟਰ ਹੈਸ਼ਟੇਬਲ ਐਰੇ ਦੇ ਆਉਟਪੁੱਟ ਦੀ ਤੁਲਨਾ ਕਰੋ ਕਿ ਤੁਹਾਨੂੰ ਕੀ ਮਿਲਦਾ ਹੈ ਜੇਕਰ ਤੁਸੀਂ ਇਹਨਾਂ ਹੈਸ਼ਟੇਬਲਾਂ ਨੂੰ ਪਹਿਲੀ ਕਲਾਸ ਵਿੱਚ ਕਾਸਟ ਕਰਦੇ ਹੋ। ਇੱਕ ਕਲਾਸ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਹਮੇਸ਼ਾਂ ਉਸੇ ਕ੍ਰਮ ਵਿੱਚ ਸੂਚੀਬੱਧ ਹੁੰਦੀਆਂ ਹਨ ਜਿਸ ਵਿੱਚ ਉਹਨਾਂ ਨੂੰ ਉੱਥੇ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ। ਉਹਨਾਂ ਸਾਰੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਤੋਂ ਪਹਿਲਾਂ ਲੁਕੇ ਹੋਏ ਕੀਵਰਡ ਨੂੰ ਜੋੜਨਾ ਨਾ ਭੁੱਲੋ ਜੋ ਤੁਸੀਂ ਨਤੀਜਿਆਂ ਵਿੱਚ ਦਿਖਾਈ ਨਹੀਂ ਦੇਣਾ ਚਾਹੁੰਦੇ।

ਅਰਥਾਂ ਦੀ ਕਾਸਟ

ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ ਇੱਕ ਆਰਗੂਮੈਂਟ ਵਾਲਾ ਇੱਕ ਕੰਸਟਰਕਟਰ ਹੈ, ਤਾਂ ਤੁਹਾਡੀ ਕਲਾਸ ਦੀ ਕਿਸਮ ਵਿੱਚ ਇੱਕ ਮੁੱਲ ਪਾਉਣਾ ਤੁਹਾਡੇ ਕੰਸਟਰਕਟਰ ਨੂੰ ਮੁੱਲ ਪਾਸ ਕਰੇਗਾ, ਜਿੱਥੇ ਤੁਸੀਂ ਆਪਣੀ ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਸ਼ੁਰੂ ਕਰ ਸਕਦੇ ਹੋ।

class Cluster {
    [ValidatePattern("^[A-z]+$")]
    [string] $Service
    [ValidateSet("TEST", "STAGE", "CANARY", "PROD")]
    [string] $FlightingRing
    [ValidateSet("EastUS", "WestUS", "NorthEurope")]
    [string] $Region
    [ValidateRange(0, 255)]
    [int] $Index

    Cluster([string] $id) {
        $this.Service, $this.FlightingRing, $this.Region, $this.Index = $id -split "-"
    }
}

[Cluster]"MyService-PROD-EastUS-2"

ਲਾਈਨ ਵਿੱਚ ਕਾਸਟ ਕਰੋ

ਤੁਸੀਂ ਆਬਜੈਕਟ ਦੀ ਸਟ੍ਰਿੰਗ ਪ੍ਰਤੀਨਿਧਤਾ ਦੇ ਪਿੱਛੇ ਤਰਕ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਲਈ [string] ToString() ਕਲਾਸ ਵਿਧੀ ਨੂੰ ਵੀ ਓਵਰਰਾਈਡ ਕਰ ਸਕਦੇ ਹੋ, ਜਿਵੇਂ ਕਿ ਸਟ੍ਰਿੰਗ ਇੰਟਰਪੋਲੇਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਨਾ।

class Cluster {
    [ValidatePattern("^[A-z]+$")]
    [string] $Service
    [ValidateSet("TEST", "STAGE", "CANARY", "PROD")]
    [string] $FlightingRing
    [ValidateSet("EastUS", "WestUS", "NorthEurope")]
    [string] $Region
    [ValidateRange(0, 255)]
    [int] $Index

    [string] ToString() {
        return $this.Service, $this.FlightingRing, $this.Region, $this.Index -join "-"
    }
}

$cluster = [Cluster]@{
    Service       = "MyService"
    FlightingRing = "PROD"
    Region        = "EastUS"
    Index         = 2
}

Write-Host "We just created a model for '$cluster'"

ਲੜੀਬੱਧ ਉਦਾਹਰਨਾਂ ਨੂੰ ਕਾਸਟ ਕਰੋ

ਕਾਸਟ ਸੁਰੱਖਿਅਤ ਡੀਸੀਰੀਅਲਾਈਜ਼ੇਸ਼ਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਹੇਠਾਂ ਦਿੱਤੀਆਂ ਉਦਾਹਰਣਾਂ ਅਸਫਲ ਹੋ ਜਾਣਗੀਆਂ ਜੇਕਰ ਡੇਟਾ ਕਲੱਸਟਰ ਵਿੱਚ ਸਾਡੇ ਨਿਰਧਾਰਨ ਨੂੰ ਪੂਰਾ ਨਹੀਂ ਕਰਦਾ ਹੈ

# Валидация сериализованных данных

[Cluster]$cluster = Get-Content "./my-cluster.json" | ConvertFrom-Json
[Cluster[]]$clusters = Import-Csv "./my-clusters.csv"

ਤੁਹਾਡੇ ਕਾਰਜਾਤਮਕ ਕੋਡ ਵਿੱਚ ਜਾਤਾਂ

ਫੰਕਸ਼ਨਲ ਪ੍ਰੋਗਰਾਮ ਪਹਿਲਾਂ ਡੇਟਾ ਸਟਰਕਚਰ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹਨ, ਫਿਰ ਪਰਿਵਰਤਨਸ਼ੀਲ ਡੇਟਾ ਸਟ੍ਰਕਚਰ ਉੱਤੇ ਪਰਿਵਰਤਨ ਦੇ ਕ੍ਰਮ ਵਜੋਂ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਲਾਗੂ ਕਰਦੇ ਹਨ। ਵਿਰੋਧਾਭਾਸੀ ਪ੍ਰਭਾਵ ਦੇ ਬਾਵਜੂਦ, ਕਲਾਸਾਂ ਅਸਲ ਵਿੱਚ ਤੁਹਾਨੂੰ ਫੰਕਸ਼ਨਲ ਕੋਡ ਲਿਖਣ ਵਿੱਚ ਮਦਦ ਕਰਦੀਆਂ ਹਨ, ਟਾਈਪ ਪਰਿਵਰਤਨ ਵਿਧੀਆਂ ਦਾ ਧੰਨਵਾਦ।

ਕੀ Powershell ਜੋ ਮੈਂ ਲਿਖ ਰਿਹਾ ਹਾਂ ਕਾਰਜਸ਼ੀਲ ਹੈ?

C# ਜਾਂ ਸਮਾਨ ਪਿਛੋਕੜ ਵਾਲੇ ਬਹੁਤ ਸਾਰੇ ਲੋਕ Powershell ਲਿਖ ਰਹੇ ਹਨ, ਜੋ ਕਿ C# ਦੇ ਸਮਾਨ ਹੈ। ਅਜਿਹਾ ਕਰਨ ਨਾਲ, ਤੁਸੀਂ ਫੰਕਸ਼ਨਲ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਸੰਕਲਪਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਤੋਂ ਦੂਰ ਜਾ ਰਹੇ ਹੋ ਅਤੇ ਪਾਵਰਸ਼ੇਲ ਵਿੱਚ ਆਬਜੈਕਟ-ਓਰੀਐਂਟਡ ਪ੍ਰੋਗਰਾਮਿੰਗ ਵਿੱਚ ਬਹੁਤ ਜ਼ਿਆਦਾ ਗੋਤਾਖੋਰੀ ਕਰਨ ਜਾਂ ਫੰਕਸ਼ਨਲ ਪ੍ਰੋਗਰਾਮਿੰਗ ਬਾਰੇ ਹੋਰ ਸਿੱਖਣ ਤੋਂ ਸੰਭਾਵਤ ਤੌਰ 'ਤੇ ਲਾਭ ਪ੍ਰਾਪਤ ਕਰੋਗੇ।

ਜੇਕਰ ਤੁਸੀਂ ਪਾਈਪਲਾਈਨਾਂ (|), Where-Object, ForEach-Object, Select-Object, Group-Object, Sort-Object, ਆਦਿ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਟੱਲ ਡਾਟਾ ਬਦਲਣ 'ਤੇ ਬਹੁਤ ਜ਼ਿਆਦਾ ਭਰੋਸਾ ਕਰਦੇ ਹੋ - ਤਾਂ ਤੁਹਾਡੇ ਕੋਲ ਵਧੇਰੇ ਕਾਰਜਸ਼ੀਲ ਸ਼ੈਲੀ ਹੈ ਅਤੇ ਤੁਹਾਨੂੰ Powershell ਦੀ ਵਰਤੋਂ ਕਰਨ ਦਾ ਫਾਇਦਾ ਹੋਵੇਗਾ। ਇੱਕ ਕਾਰਜਾਤਮਕ ਸ਼ੈਲੀ ਵਿੱਚ ਕਲਾਸਾਂ.

ਕਲਾਸਾਂ ਦੀ ਕਾਰਜਸ਼ੀਲ ਵਰਤੋਂ

ਜਾਤੀਆਂ, ਹਾਲਾਂਕਿ ਉਹ ਇੱਕ ਵਿਕਲਪਿਕ ਸੰਟੈਕਸ ਦੀ ਵਰਤੋਂ ਕਰਦੀਆਂ ਹਨ, ਦੋ ਡੋਮੇਨਾਂ ਵਿਚਕਾਰ ਸਿਰਫ਼ ਇੱਕ ਮੈਪਿੰਗ ਹਨ। ਪਾਈਪਲਾਈਨ ਵਿੱਚ, ਤੁਸੀਂ ForEach-Object ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮੁੱਲਾਂ ਦੀ ਇੱਕ ਐਰੇ ਨੂੰ ਮੈਪ ਕਰ ਸਕਦੇ ਹੋ।

ਹੇਠਾਂ ਦਿੱਤੀ ਉਦਾਹਰਨ ਵਿੱਚ, ਨੋਡ ਕੰਸਟਰਕਟਰ ਨੂੰ ਹਰ ਵਾਰ ਇੱਕ ਡੈਟਮ ਕਾਸਟ ਕਰਨ 'ਤੇ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਇਹ ਸਾਨੂੰ ਇੱਕ ਉਚਿਤ ਮਾਤਰਾ ਵਿੱਚ ਕੋਡ ਨਾ ਲਿਖਣ ਦਾ ਮੌਕਾ ਦਿੰਦਾ ਹੈ। ਨਤੀਜੇ ਵਜੋਂ, ਸਾਡੀ ਪਾਈਪਲਾਈਨ ਘੋਸ਼ਣਾਤਮਕ ਡੇਟਾ ਪੁੱਛਗਿੱਛ ਅਤੇ ਏਕੀਕਰਣ 'ਤੇ ਕੇਂਦ੍ਰਤ ਕਰਦੀ ਹੈ, ਜਦੋਂ ਕਿ ਸਾਡੀਆਂ ਕਲਾਸਾਂ ਡੇਟਾ ਪਾਰਸਿੰਗ ਅਤੇ ਪ੍ਰਮਾਣਿਕਤਾ ਦਾ ਧਿਆਨ ਰੱਖਦੀਆਂ ਹਨ।

# Пример комбинирования классов с конвейерами для separation of concerns в конвейерах

class Node {
    [ValidateLength(3, 7)]
    [string] $Name
    [ValidateSet("INT", "PPE", "PROD")]
    [string] $FlightingRing
    [ValidateSet("EastUS", "WestUS", "NorthEurope", "WestEurope")]
    [string] $Region
    Node([string] $Name) {
        $Name -match "([a-z]+)(INT|PPE|PROD)([a-z]+)"
        $_, $this.Service, $this.FlightingRing, $this.Region = $Matches
        $this.Name = $Name
    }
}

class Datum {
    [string] $Name
    [int] $Value
    [Node] $Computer
    [int] Severity() {
        $this.Name -match "[0-9]+$"
        return $Matches[0]
    }
}

Write-Host "Urgent Security Audit Issues:"
Import-Csv "./audit-results.csv" `
    | ForEach-Object {[Datum]$_} `
    | Where-Object Value -gt 0 `
    | Group-Object {$_.Severity()} `
    | Where-Object Name -lt 2 `
    | ForEach-Object Group `
    | ForEach-Object Computer `
    | Where-Object FlightingRing -eq "PROD" `
    | Sort-Object Name, Region -Unique

ਮੁੜ ਵਰਤੋਂ ਲਈ ਪੈਕੇਜਿੰਗ ਕਲਾਸ

ਕੁਝ ਵੀ ਓਨਾ ਚੰਗਾ ਨਹੀਂ ਹੈ ਜਿੰਨਾ ਇਹ ਲੱਗਦਾ ਹੈ

ਬਦਕਿਸਮਤੀ ਨਾਲ, ਕਲਾਸਾਂ ਨੂੰ ਫੰਕਸ਼ਨਾਂ ਜਾਂ ਵੇਰੀਏਬਲਾਂ ਦੇ ਰੂਪ ਵਿੱਚ ਮੋਡੀਊਲ ਦੁਆਰਾ ਨਿਰਯਾਤ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ; ਪਰ ਕੁਝ ਗੁਰੁਰ ਹਨ। ਮੰਨ ਲਓ ਕਿ ਤੁਹਾਡੀਆਂ ਕਲਾਸਾਂ ਫਾਈਲ ./my-classes.ps1 ਵਿੱਚ ਪਰਿਭਾਸ਼ਿਤ ਹਨ

• ਤੁਸੀਂ ਕਲਾਸਾਂ ਦੇ ਨਾਲ ਇੱਕ ਫਾਈਲ ਨੂੰ ਡਾਟਸੋਰਸ ਕਰ ਸਕਦੇ ਹੋ:. ./my-classes.ps1. ਇਹ ਤੁਹਾਡੇ ਮੌਜੂਦਾ ਦਾਇਰੇ ਵਿੱਚ my-classes.ps1 ਨੂੰ ਚਲਾਏਗਾ ਅਤੇ ਉੱਥੇ ਫਾਈਲ ਤੋਂ ਸਾਰੀਆਂ ਕਲਾਸਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੇਗਾ।

• ਤੁਸੀਂ ਇੱਕ Powershell ਮੋਡੀਊਲ ਬਣਾ ਸਕਦੇ ਹੋ ਜੋ ਤੁਹਾਡੇ ਸਾਰੇ ਕਸਟਮ API (cmdlets) ਨੂੰ ਨਿਰਯਾਤ ਕਰਦਾ ਹੈ ਅਤੇ ਤੁਹਾਡੇ ਮੋਡੀਊਲ ਮੈਨੀਫੈਸਟ ਵਿੱਚ ScriptsToProcess = "./my-classes.ps1" ਵੇਰੀਏਬਲ ਨੂੰ ਸੈੱਟ ਕਰ ਸਕਦਾ ਹੈ, ਉਸੇ ਨਤੀਜੇ ਦੇ ਨਾਲ: ./my-classes.ps1 ਵਿੱਚ ਚਲਾਇਆ ਜਾਵੇਗਾ। ਤੁਹਾਡਾ ਵਾਤਾਵਰਣ

ਤੁਸੀਂ ਜੋ ਵੀ ਵਿਕਲਪ ਚੁਣਦੇ ਹੋ, ਯਾਦ ਰੱਖੋ ਕਿ ਪਾਵਰਸ਼ੇਲ ਦਾ ਟਾਈਪ ਸਿਸਟਮ ਵੱਖ-ਵੱਖ ਥਾਵਾਂ ਤੋਂ ਲੋਡ ਕੀਤੇ ਇੱਕੋ ਨਾਮ ਦੀਆਂ ਕਿਸਮਾਂ ਨੂੰ ਹੱਲ ਨਹੀਂ ਕਰ ਸਕਦਾ।
ਭਾਵੇਂ ਤੁਸੀਂ ਵੱਖੋ-ਵੱਖ ਥਾਵਾਂ ਤੋਂ ਇੱਕੋ ਜਿਹੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਾਲੇ ਦੋ ਸਮਾਨ ਕਲਾਸਾਂ ਨੂੰ ਲੋਡ ਕਰਦੇ ਹੋ, ਤੁਹਾਨੂੰ ਸਮੱਸਿਆਵਾਂ ਵਿੱਚ ਆਉਣ ਦਾ ਖ਼ਤਰਾ ਹੈ।

ਅੱਗੇ ਦਾ ਰਸਤਾ

ਟਾਈਪ ਰੈਜ਼ੋਲੂਸ਼ਨ ਸਮੱਸਿਆਵਾਂ ਤੋਂ ਬਚਣ ਦਾ ਸਭ ਤੋਂ ਵਧੀਆ ਤਰੀਕਾ ਇਹ ਹੈ ਕਿ ਕਦੇ ਵੀ ਆਪਣੀਆਂ ਕਲਾਸਾਂ ਨੂੰ ਉਪਭੋਗਤਾਵਾਂ ਦੇ ਸਾਹਮਣੇ ਨਾ ਪੇਸ਼ ਕਰੋ। ਉਪਭੋਗਤਾ ਤੋਂ ਕਲਾਸ-ਪਰਿਭਾਸ਼ਿਤ ਕਿਸਮ ਨੂੰ ਆਯਾਤ ਕਰਨ ਦੀ ਉਮੀਦ ਕਰਨ ਦੀ ਬਜਾਏ, ਆਪਣੇ ਮੋਡੀਊਲ ਤੋਂ ਇੱਕ ਫੰਕਸ਼ਨ ਨਿਰਯਾਤ ਕਰੋ ਜੋ ਸਿੱਧੇ ਕਲਾਸ ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਨੂੰ ਖਤਮ ਕਰਦਾ ਹੈ। ਕਲੱਸਟਰ ਲਈ, ਅਸੀਂ ਇੱਕ ਨਵਾਂ-ਕਲੱਸਟਰ ਫੰਕਸ਼ਨ ਨਿਰਯਾਤ ਕਰ ਸਕਦੇ ਹਾਂ ਜੋ ਉਪਭੋਗਤਾ-ਅਨੁਕੂਲ ਪੈਰਾਮੀਟਰ ਸੈੱਟਾਂ ਦਾ ਸਮਰਥਨ ਕਰੇਗਾ ਅਤੇ ਇੱਕ ਕਲੱਸਟਰ ਵਾਪਸ ਕਰੇਗਾ।

class Cluster {
    [ValidatePattern("^[A-z]+$")]
    [string] $Service
    [ValidateSet("TEST", "STAGE", "CANARY", "PROD")]
    [string] $FlightingRing
    [ValidateSet("EastUS", "WestUS", "NorthEurope")]
    [string] $Region
    [ValidateRange(0, 255)]
    [int] $Index
}

function New-Cluster {
    [OutputType([Cluster])]
    Param(
        [Parameter(Mandatory, ParameterSetName = "Id", Position = 0)]
        [ValidateNotNullOrEmpty()]
        [string] $Id,
        [Parameter(Mandatory, ParameterSetName = "Components")]
        [string] $Service,
        [Parameter(Mandatory, ParameterSetName = "Components")]
        [string] $FlightingRing,
        [Parameter(Mandatory, ParameterSetName = "Components")]
        [string] $Region,
        [Parameter(Mandatory, ParameterSetName = "Components")]
        [int] $Index
    )

    if ($Id) {
        $Service, $FlightingRing, $Region, $Index = $Id -split "-"
    }

    [Cluster]@{
        Service       = $Service
        FlightingRing = $FlightingRing
        Region        = $Region
        Index         = $Index
    }
}

Export-ModuleMember New-Cluster

ਹੋਰ ਕੀ ਪੜ੍ਹਨਾ ਹੈ

ਕਲਾਸਾਂ ਬਾਰੇ
ਰੱਖਿਆਤਮਕ PowerShell
PowerShell ਵਿੱਚ ਕਾਰਜਸ਼ੀਲ ਪ੍ਰੋਗਰਾਮਿੰਗ

ਸਰੋਤ: www.habr.com