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

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

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

ജാതി മാന്ത്രികത

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

നിങ്ങളുടെ ഫങ്ഷണൽ കോഡിൽ കാസ്റ്റുകൾ

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

ഞാൻ ഫങ്ഷണൽ പവർഷെൽ ആണോ എഴുതുന്നത്?

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

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

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

കാസ്റ്റുകൾ, ഒരു ബദൽ വാക്യഘടന ഉപയോഗിക്കുന്നുണ്ടെങ്കിലും, രണ്ട് ഡൊമെയ്‌നുകൾക്കിടയിലുള്ള ഒരു മാപ്പിംഗ് മാത്രമാണ്. ഒരു പൈപ്പ്‌ലൈനിൽ, 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 എക്സിക്യൂട്ട് ചെയ്യുകയും അവിടെയുള്ള ഫയലിൽ നിന്നുള്ള എല്ലാ ക്ലാസുകളും നിർവചിക്കുകയും ചെയ്യും.

• നിങ്ങളുടെ എല്ലാ ഇഷ്‌ടാനുസൃത 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

വേറെ എന്ത് വായിക്കാൻ

ക്ലാസുകളെക്കുറിച്ച്
പ്രതിരോധ പവർഷെൽ
പവർഷെല്ലിലെ ഫങ്ഷണൽ പ്രോഗ്രാമിംഗ്

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