વર્ગો સાથે કાર્યાત્મક પાવરશેલ ઓક્સિમોરોન નથી, હું તેની ખાતરી આપું છું

હે હબર! હું તમારા ધ્યાન પર લેખનો અનુવાદ રજૂ કરું છું "વર્ગો સાથે કાર્યાત્મક પાવરશેલ.
હું વચન આપું છું કે તે ઓક્સિમોરોન નથી" ક્રિસ્ટોફર કુચ દ્વારા.

ઑબ્જેક્ટ-ઓરિએન્ટેડ અને ફંક્શનલ પ્રોગ્રામિંગ પેરાડિમ્સ એકબીજા સાથે વિરોધાભાસી લાગે છે, પરંતુ પાવરશેલમાં બંને સમાન રીતે સપોર્ટેડ છે. લગભગ તમામ પ્રોગ્રામિંગ ભાષાઓ, કાર્યાત્મક હોય કે ન હોય, વિસ્તૃત નામ-મૂલ્ય બંધન માટે સુવિધાઓ ધરાવે છે; વર્ગો, જેમ કે સ્ટ્રક્ચર્સ અને રેકોર્ડ્સ, માત્ર એક અભિગમ છે. જો આપણે વર્ગોના અમારા ઉપયોગને નામો અને મૂલ્યોના બંધન સુધી મર્યાદિત રાખીએ, અને હેવી ઑબ્જેક્ટ-ઓરિએન્ટેડ પ્રોગ્રામિંગ ખ્યાલો જેમ કે વારસા, પોલીમોર્ફિઝમ અથવા પરિવર્તનશીલતા ટાળીએ, તો અમે અમારા કોડને જટિલ બનાવ્યા વિના તેમના લાભોનો લાભ લઈ શકીએ છીએ. આગળ, અપરિવર્તનશીલ પ્રકારની રૂપાંતરણ પદ્ધતિઓ ઉમેરીને, અમે વર્ગો સાથે અમારા કાર્યાત્મક કોડને સમૃદ્ધ બનાવી શકીએ છીએ.

જાતિઓનો જાદુ

જાતિ એ પાવરશેલની સૌથી શક્તિશાળી વિશેષતાઓમાંની એક છે. જ્યારે તમે મૂલ્ય કાસ્ટ કરો છો, ત્યારે તમે ગર્ભિત આરંભ અને માન્યતા ક્ષમતાઓ પર આધાર રાખો છો જે પર્યાવરણ તમારી એપ્લિકેશનમાં ઉમેરે છે. ઉદાહરણ તરીકે, ફક્ત [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"

તમારા કાર્યાત્મક કોડમાં જાતિઓ

ફંક્શનલ પ્રોગ્રામ્સ પહેલા ડેટા સ્ટ્રક્ચર્સને વ્યાખ્યાયિત કરે છે, પછી અપરિવર્તનશીલ ડેટા સ્ટ્રક્ચર્સ પર પરિવર્તનના ક્રમ તરીકે પ્રોગ્રામનો અમલ કરે છે. વિરોધાભાસી છાપ હોવા છતાં, વર્ગો ખરેખર તમને કાર્યાત્મક કોડ લખવામાં મદદ કરે છે કારણ કે રૂપાંતરણ પદ્ધતિઓ ટાઇપ કરે છે.

શું હું લખી રહ્યો છું તે પાવરશેલ કાર્યરત છે?

C# અથવા સમાન પૃષ્ઠભૂમિમાંથી આવતા ઘણા લોકો પાવરશેલ લખી રહ્યા છે, જે C# જેવું જ છે. આમ કરવાથી, તમે ફંક્શનલ પ્રોગ્રામિંગ કોન્સેપ્ટનો ઉપયોગ કરવાથી દૂર જઈ રહ્યા છો અને પાવરશેલમાં ઑબ્જેક્ટ-ઓરિએન્ટેડ પ્રોગ્રામિંગમાં ભારે ડાઇવિંગ કરવાથી અથવા ફંક્શનલ પ્રોગ્રામિંગ વિશે વધુ શીખવાથી તમને ફાયદો થશે.

જો તમે પાઇપલાઇન્સ (|), ક્યાં-ઑબ્જેક્ટ, ફોરએચ-ઑબ્જેક્ટ, સિલેક્ટ-ઑબ્જેક્ટ, ગ્રુપ-ઑબ્જેક્ટ, સૉર્ટ-ઑબ્જેક્ટ વગેરેનો ઉપયોગ કરીને અપરિવર્તનશીલ ડેટાને રૂપાંતરિત કરવા પર ખૂબ આધાર રાખતા હોવ તો - તમારી પાસે વધુ કાર્યાત્મક શૈલી છે અને તમને પાવરશેલનો ઉપયોગ કરવાથી ફાયદો થશે. કાર્યાત્મક શૈલીમાં વર્ગો.

વર્ગોનો કાર્યાત્મક ઉપયોગ

જાતિઓ, જો કે તેઓ વૈકલ્પિક વાક્યરચનાનો ઉપયોગ કરે છે, તે માત્ર બે ડોમેન્સ વચ્ચેનું મેપિંગ છે. પાઇપલાઇનમાં, તમે ફોરએચ-ઑબ્જેક્ટનો ઉપયોગ કરીને મૂલ્યોની શ્રેણીને મેપ કરી શકો છો.

નીચેના ઉદાહરણમાં, જ્યારે પણ ડેટમ કાસ્ટ કરવામાં આવે છે ત્યારે નોડ કન્સ્ટ્રક્ટરને એક્ઝિક્યુટ કરવામાં આવે છે, અને આ અમને કોડની વાજબી રકમ ન લખવાની તક આપે છે. પરિણામે, અમારી પાઇપલાઇન ઘોષણાત્મક ડેટા ક્વેરી અને એકત્રીકરણ પર ધ્યાન કેન્દ્રિત કરે છે, જ્યારે અમારા વર્ગો ડેટા પાર્સિંગ અને માન્યતાની કાળજી લે છે.

# Пример комбинирования классов с конвейерами для 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