ფუნქციური Powershell კლასებით არ არის ოქსიმორონი, ამის გარანტიას ვაძლევ

ჰეი ჰაბრ! თქვენს ყურადღებას წარმოგიდგენთ სტატიის თარგმანს "ფუნქციური PowerShell კლასებით.
გპირდები, რომ ეს არ არის ოქსიმორონი" კრისტოფერ კუეხის მიერ.

ობიექტზე ორიენტირებული და ფუნქციონალური პროგრამირების პარადიგმები შეიძლება ეწინააღმდეგებოდეს ერთმანეთს, მაგრამ ორივე თანაბრად არის მხარდაჭერილი Powershell-ში. თითქმის ყველა პროგრამირების ენას, ფუნქციონალურ თუ არა, აქვს გაფართოებული სახელი-მნიშვნელობის დაკავშირების საშუალებები; კლასები, ისევე როგორც სტრუქტურები და ჩანაწერები, მხოლოდ ერთი მიდგომაა. თუ ჩვენ შევზღუდავთ კლასების გამოყენებას სახელებისა და მნიშვნელობების შეერთებით და თავიდან ავიცილებთ მძიმე ობიექტზე ორიენტირებული პროგრამირების ცნებებს, როგორიცაა მემკვიდრეობა, პოლიმორფიზმი ან ცვალებადობა, ჩვენ შეგვიძლია ვისარგებლოთ მათგან ჩვენი კოდის გართულების გარეშე. გარდა ამისა, უცვლელი ტიპის კონვერტაციის მეთოდების დამატებით, ჩვენ შეგვიძლია გავამდიდროთ ჩვენი ფუნქციური კოდი კლასებით.

კასტების მაგია

კასტები 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
}

გარდა ამისა, ჩამოსხმა ხელს უწყობს სუფთა გამოსავლის მიღებას. შეადარეთ Format-Table-ზე გადაცემული კლასტერული ჰეშტბელური მასივის გამომავალი, რასაც მიიღებთ, თუ პირველად გადაიტანეთ ეს ჰეშტბლები კლასში. კლასის თვისებები ყოველთვის ჩამოთვლილია იმ თანმიმდევრობით, რომლითაც ისინი იქ არის განსაზღვრული. არ დაგავიწყდეთ დამალული საკვანძო სიტყვის დამატება ყველა იმ თვისებამდე, რომელიც არ გსურთ რომ იყოს ხილული შედეგებში.

მნიშვნელობების როლი

თუ თქვენ გაქვთ კონსტრუქტორი ერთი არგუმენტით, თქვენი კლასის ტიპზე მნიშვნელობის მიცემა გადასცემს მნიშვნელობას თქვენს კონსტრუქტორს, სადაც შეგიძლიათ თქვენი კლასის ეგზემპლარის ინიციალიზაცია.

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"

კასტები თქვენს ფუნქციურ კოდში

ფუნქციური პროგრამები ჯერ განსაზღვრავს მონაცემთა სტრუქტურებს, შემდეგ ახორციელებს პროგრამას, როგორც ტრანსფორმაციების თანმიმდევრობას მონაცემთა უცვლელ სტრუქტურებზე. წინააღმდეგობრივი შთაბეჭდილების მიუხედავად, კლასები ნამდვილად გეხმარებათ დაწეროთ ფუნქციური კოდი, ტიპების კონვერტაციის მეთოდების წყალობით.

Powershell, რომელსაც ვწერ, ფუნქციონალურია?

ბევრი ადამიანი, რომელიც მოდის C#-დან ან მსგავსი ფონიდან, წერს Powershell-ს, რომელიც C#-ის მსგავსია. ამით თქვენ შორდებით ფუნქციონალური პროგრამირების კონცეფციების გამოყენებას და სავარაუდოდ ისარგებლებთ ობიექტზე ორიენტირებულ პროგრამირებაში Powershell-ში ჩასვლით ან მეტის შესწავლით ფუნქციური პროგრამირების შესახებ.

თუ დიდად ეყრდნობით უცვლელი მონაცემების ტრანსფორმაციას მილსადენების (|), Where-Object, ForEach-Object, Select-Object, Group-Object, Sort-Object და ა.შ. - თქვენ გაქვთ უფრო ფუნქციონალური სტილი და ისარგებლებთ Powershell-ის გამოყენებით. კლასები ფუნქციურ სტილში.

კლასების ფუნქციური გამოყენება

კასტები, მიუხედავად იმისა, რომ ისინი იყენებენ ალტერნატიულ სინტაქსს, არის მხოლოდ რუქა ორ დომენს შორის. მილსადენში შეგიძლიათ შეადგინოთ მნიშვნელობების მასივი ForEach-Object-ის გამოყენებით.

ქვემოთ მოყვანილ მაგალითში Node კონსტრუქტორი სრულდება ყოველ ჯერზე, როდესაც Datum არის ჩამოთვლილი, და ეს გვაძლევს შესაძლებლობას, თავი ავარიდოთ კოდის სამართლიანი რაოდენობის დაწერას. შედეგად, ჩვენი მილსადენი ფოკუსირებულია მონაცემების დეკლარაციულ მოთხოვნაზე და აგრეგაციაზე, ხოლო ჩვენი კლასები ზრუნავენ მონაცემთა გაანალიზებაზე და ვალიდაციაზე.

# Пример комбинирования классов с конвейерами для 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 შესრულდება თქვენი გარემო.

რომელი ვარიანტიც არ უნდა აირჩიოთ, გაითვალისწინეთ, რომ Powershell-ის ტიპის სისტემას არ შეუძლია სხვადასხვა ადგილიდან ჩატვირთული ერთიდაიმავე სახელის ტიპების ამოხსნა.
მაშინაც კი, თუ თქვენ ჩატვირთეთ ორი იდენტური კლასი ერთი და იგივე თვისებებით სხვადასხვა ადგილიდან, თქვენ რისკავთ პრობლემების წინაშე.

წინსვლის გზა

ტიპის რეზოლუციის პრობლემების თავიდან აცილების საუკეთესო გზაა თქვენი კლასების არასოდეს გამოაშკარავოთ მომხმარებლებისთვის. იმის ნაცვლად, რომ მოელოდეთ მომხმარებლის მიერ კლასით განსაზღვრული ტიპის იმპორტს, თქვენი მოდულიდან ფუნქციის ექსპორტი, რომელიც გამორიცხავს კლასში უშუალოდ წვდომის აუცილებლობას. კლასტერისთვის შეგვიძლია ახალი კლასტერის ფუნქციის ექსპორტი, რომელიც ხელს შეუწყობს მომხმარებლისთვის მოსახერხებელი პარამეტრების კომპლექტს და დააბრუნებს კლასტერს.

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