ക്ലാസുകളുള്ള ഫംഗ്ഷണൽ പവർഷെൽ ഒരു ഓക്സിമോറോൺ അല്ല, ഞാൻ അത് ഉറപ്പുനൽകുന്നു

ഹേ ഹബർ! ലേഖനത്തിന്റെ വിവർത്തനം ഞാൻ നിങ്ങളുടെ ശ്രദ്ധയിൽപ്പെടുത്തുന്നു "ക്ലാസുകളുള്ള ഫംഗ്ഷണൽ പവർഷെൽ.
ഇത് ഒരു ഓക്സിമോറോൺ അല്ലെന്ന് ഞാൻ വാഗ്ദാനം ചെയ്യുന്നു" ക്രിസ്റ്റഫർ കുച്ച് എഴുതിയത്.

ഒബ്ജക്റ്റ് ഓറിയന്റഡ്, ഫങ്ഷണൽ പ്രോഗ്രാമിംഗ് മാതൃകകൾ പരസ്പരം വിയോജിപ്പുള്ളതായി തോന്നിയേക്കാം, എന്നാൽ പവർഷെല്ലിൽ ഇവ രണ്ടും ഒരുപോലെ പിന്തുണയ്ക്കുന്നു. പ്രവർത്തനപരമോ അല്ലാത്തതോ ആയ മിക്കവാറും എല്ലാ പ്രോഗ്രാമിംഗ് ഭാഷകൾക്കും വിപുലീകൃത നെയിം-വാല്യൂ ബൈൻഡിംഗിനുള്ള സൗകര്യങ്ങളുണ്ട്; സ്ട്രക്‌റ്റുകളും റെക്കോർഡുകളും പോലെ ക്ലാസുകൾ ഒരു സമീപനം മാത്രമാണ്. പേരുകളുടെയും മൂല്യങ്ങളുടെയും ബൈൻഡിംഗിലേക്ക് ക്ലാസുകളുടെ ഉപയോഗം പരിമിതപ്പെടുത്തുകയും പാരമ്പര്യം, പോളിമോർഫിസം അല്ലെങ്കിൽ മ്യൂട്ടബിലിറ്റി പോലുള്ള കനത്ത ഒബ്ജക്റ്റ്-ഓറിയന്റഡ് പ്രോഗ്രാമിംഗ് ആശയങ്ങൾ ഒഴിവാക്കുകയും ചെയ്താൽ, ഞങ്ങളുടെ കോഡ് സങ്കീർണ്ണമാക്കാതെ തന്നെ അവയുടെ നേട്ടങ്ങൾ നമുക്ക് പ്രയോജനപ്പെടുത്താം. കൂടാതെ, മാറ്റമില്ലാത്ത തരം പരിവർത്തന രീതികൾ ചേർക്കുന്നതിലൂടെ, ക്ലാസുകൾ ഉപയോഗിച്ച് ഞങ്ങളുടെ ഫങ്ഷണൽ കോഡ് സമ്പുഷ്ടമാക്കാം.

ജാതികളുടെ മായാജാലം

പവർഷെല്ലിലെ ഏറ്റവും ശക്തമായ സവിശേഷതകളിൽ ഒന്നാണ് ജാതികൾ. നിങ്ങൾ ഒരു മൂല്യം കാസ്‌റ്റ് ചെയ്യുമ്പോൾ, നിങ്ങളുടെ അപ്ലിക്കേഷനിലേക്ക് പരിസ്ഥിതി ചേർക്കുന്ന പരോക്ഷമായ സമാരംഭവും മൂല്യനിർണ്ണയ ശേഷിയും നിങ്ങൾ ആശ്രയിക്കുന്നു. ഉദാഹരണത്തിന്, [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'"

കാസ്‌റ്റ് സീരിയസ് ചെയ്‌ത സന്ദർഭങ്ങൾ

Cast സുരക്ഷിതമായ ഡീസിയലൈസേഷൻ അനുവദിക്കുന്നു. ഡാറ്റ ക്ലസ്റ്ററിലെ ഞങ്ങളുടെ സ്പെസിഫിക്കേഷൻ പാലിക്കുന്നില്ലെങ്കിൽ ചുവടെയുള്ള ഉദാഹരണങ്ങൾ പരാജയപ്പെടും

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

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

നിങ്ങളുടെ ഫങ്ഷണൽ കോഡിലെ ജാതികൾ

ഫങ്ഷണൽ പ്രോഗ്രാമുകൾ ആദ്യം ഡാറ്റ ഘടനകളെ നിർവചിക്കുന്നു, തുടർന്ന് മാറ്റമില്ലാത്ത ഡാറ്റാ സ്ട്രക്ചറുകളുടെ പരിവർത്തനങ്ങളുടെ ഒരു ശ്രേണിയായി പ്രോഗ്രാം നടപ്പിലാക്കുന്നു. പരസ്പര വിരുദ്ധമായ മതിപ്പ് ഉണ്ടായിരുന്നിട്ടും, ടൈപ്പ് പരിവർത്തന രീതികൾക്ക് നന്ദി ഫംഗ്ഷണൽ കോഡ് എഴുതാൻ ക്ലാസുകൾ നിങ്ങളെ സഹായിക്കുന്നു.

ഞാൻ എഴുതുന്ന പവർഷെൽ പ്രവർത്തനക്ഷമമാണോ?

C# അല്ലെങ്കിൽ സമാനമായ പശ്ചാത്തലത്തിൽ നിന്ന് വരുന്ന ധാരാളം ആളുകൾ പവർഷെൽ എഴുതുന്നു, ഇത് C# ന് സമാനമാണ്. ഇത് ചെയ്യുന്നതിലൂടെ, നിങ്ങൾ ഫങ്ഷണൽ പ്രോഗ്രാമിംഗ് ആശയങ്ങൾ ഉപയോഗിക്കുന്നതിൽ നിന്ന് മാറുകയാണ്, കൂടാതെ Powershell-ലെ ഒബ്ജക്റ്റ്-ഓറിയന്റഡ് പ്രോഗ്രാമിംഗിലേക്ക് വൻതോതിൽ ഡൈവിംഗ് ചെയ്യുന്നതിനോ അല്ലെങ്കിൽ ഫംഗ്ഷണൽ പ്രോഗ്രാമിംഗിനെക്കുറിച്ച് കൂടുതലറിയുന്നതിനോ പ്രയോജനം ലഭിക്കും.

പൈപ്പ് ലൈനുകൾ (|), എവിടെ-ഒബ്ജക്റ്റ്, ഫോർഎച്ച്-ഒബ്ജക്റ്റ്, സെലക്ട്-ഒബ്ജക്റ്റ്, ഗ്രൂപ്പ്-ഒബ്ജക്റ്റ്, സോർട്ട്-ഒബ്ജക്റ്റ് മുതലായവ ഉപയോഗിച്ച് മാറ്റമില്ലാത്ത ഡാറ്റ രൂപാന്തരപ്പെടുത്തുന്നതിൽ നിങ്ങൾ വളരെയധികം ആശ്രയിക്കുന്നുവെങ്കിൽ - നിങ്ങൾക്ക് കൂടുതൽ പ്രവർത്തനക്ഷമമായ ശൈലിയുണ്ട്, പവർഷെൽ ഉപയോഗിക്കുന്നതിൽ നിന്ന് നിങ്ങൾക്ക് പ്രയോജനം ലഭിക്കും. പ്രവർത്തന ശൈലിയിലുള്ള ക്ലാസുകൾ.

ക്ലാസുകളുടെ പ്രവർത്തനപരമായ ഉപയോഗം

ജാതികൾ, അവർ ഒരു ഇതര വാക്യഘടന ഉപയോഗിക്കുന്നുണ്ടെങ്കിലും, രണ്ട് ഡൊമെയ്‌നുകൾക്കിടയിലുള്ള ഒരു മാപ്പിംഗ് മാത്രമാണ്. പൈപ്പ്ലൈനിൽ, ForEach-Object ഉപയോഗിച്ച് നിങ്ങൾക്ക് മൂല്യങ്ങളുടെ ഒരു നിര മാപ്പ് ചെയ്യാൻ കഴിയും.

ചുവടെയുള്ള ഉദാഹരണത്തിൽ, ഒരു Datum കാസ്‌റ്റ് ചെയ്യുമ്പോൾ ഓരോ തവണയും Node കൺസ്ട്രക്‌റ്റർ എക്‌സിക്യൂട്ട് ചെയ്യപ്പെടുന്നു, ഇത് ന്യായമായ അളവിൽ കോഡ് എഴുതാതിരിക്കാനുള്ള അവസരം നൽകുന്നു. തൽഫലമായി, ഞങ്ങളുടെ പൈപ്പ്‌ലൈൻ ഡിക്ലറേറ്റീവ് ഡാറ്റ ക്വയറിംഗിലും അഗ്രഗേഷനിലും ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നു, അതേസമയം ഞങ്ങളുടെ ക്ലാസുകൾ ഡാറ്റ പാഴ്‌സിംഗും മൂല്യനിർണ്ണയവും ശ്രദ്ധിക്കുന്നു.

# Пример комбинирования классов с конвейерами для 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 എക്സിക്യൂട്ട് ചെയ്യുകയും ഫയലിൽ നിന്ന് എല്ലാ ക്ലാസുകളും നിർവചിക്കുകയും ചെയ്യും.

• നിങ്ങളുടെ എല്ലാ ഇഷ്‌ടാനുസൃത 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-ലെ ഫങ്ഷണൽ പ്രോഗ്രാമിംഗ്

അവലംബം: www.habr.com