PowerShell İşlev Parametreleri: Yeni Başlayanlar İçin Kılavuz

Herhangi bir programlama veya komut dosyası dilinin temel taşı, belirli bir görevi gerçekleştiren yeniden kullanılabilir kod blokları olan işlevler kavramıdır. PowerShell'de bir işlevin etkinliği, parametrelerin kullanımıyla artırılır. İşleve açılan bu küçük ağ geçitleri, işlevin çalışmasını esnek ve dinamik bir şekilde kontrol etmemize olanak tanır. İşlev parametreleri, bir işleve değer aktarmanıza olanak tanıyarak onu daha çok yönlü ve özelleştirilebilir hale getirir. Bu makalede, işlev parametrelerinin temel sözdizimini ele alacağız, PowerShell aracılığıyla kullanılabilen farklı türleri tartışacağız ve bunların ne kadar güçlü olduklarını gösteren gerçek dünyadan örnekleri inceleyeceğiz.

PowerShell İşlev Parametrelerine Genel Bakış

Yüksek düzeyde işlev parametreleri, PowerShell betiğinizin düzgün şekilde yürütülmesi için gereken girişlerdir. Bu girdiler betiğe adlandırılmış argümanlar (örneğin, -Parameter “Value”) biçiminde veya ardışık düzen aracılığıyla aktarılabilir. Bir işleve birincil girdi modu olarak hizmet ederek bilgi aktarmamıza ve işlevin davranışını etkilememize olanak tanırlar. Bir işlevi, bir görevi yerine getiren bir kara kutu olarak hayal edin. Parametreler, bu kutu üzerinde ihtiyaçlarınıza göre ayarlayabileceğiniz kadranlar ve anahtarlar gibidir.

Temel olarak parametreler, işlevlerinizi çok yönlü ve yeniden kullanılabilir hale getirerek daha verimli, bakımı kolay ve ölçeklenebilir komut dosyaları oluşturmanıza olanak tanır. PowerShell işlevlerinde parametrelerin oluşturulmasına ve kullanımına bakalım.

Parametrelerle PowerShell İşlevi Oluşturma

PowerShell'de işlev parametreleri, işlevin kendi içindeki param bloğunda tanımlanır. Bu blok, her biri veri türleri, varsayılan değerler, doğrulama mantığı ve daha fazlası gibi kendi özniteliklerine sahip çeşitli parametreler içerebilir. Her biri bir ad, veri türü, doğrulama mantığı ve isteğe bağlı varsayılan değere sahip bir veya daha fazla parametre tanımlayabilirsiniz. PowerShell işlevinde parametre oluşturmak basittir. Sadece param anahtar kelimesiyle başlar:

Başka bir örneği ele alalım:


#Create a function with parameter
function Greet-User {
    param (
        [string]$Name
    )

    Write-host "Hello, $Name!"
}

#Call the function with parameter
Greet-User "Alice"

Bu fonksiyonda, [string] türünde bir $Name parametresi bildirdik. Bu fonksiyonu çağırırken şu şekilde bir isim verebiliriz: Greet-User -Name "Alice". Fonksiyon Merhaba Alice! çıktısını verecektir. Lütfen parametre değişkenlerinin fonksiyonun kapsamına alındığını unutmayın.

PowerShell'de birden çok parametreli işlevler oluşturma

Bazen birden fazla parametreyi kabul eden işlevler oluşturmanız gerekebilir. PowerShell, birden fazla parametreye sahip işlevleri yalnızca param bloğunda belirterek tanımlamanıza olanak tanır. Bir örneğe bakalım. Burada iki tamsayı parametresi alan ve bunların toplamını döndüren basit bir fonksiyon verilmiştir:


Function Add-Numbers {
Param (
    [int]$num1,
    [int]$num2
)
   $sum = $num1 + $num2
   return $sum
}

Bu örnekte iki parametre tanımladık: $num1 ve $num2. Her iki parametrenin veri türü [int]'tir, yani tamsayı olmaları gerekir. Ek parametreleri virgülle ayırarak aynı şekilde ekleyebilirsiniz.

PowerShell ayrıca bir işleve, komut dosyasına veya komut dosyası bloğuna iletilen parametre değerlerinin bir dizisini içeren $args otomatik değişkenine de sahiptir.

Fonksiyon Parametrelerini Geçirme

PowerShell'de parametreler içeren bir işlevi nasıl çağırırsınız? Parametreli bir işlevi kullanmak için, işlevi çağırırken değerleri ona iletmeniz gerekir. Bunu, parametre adlarını ve değerlerini virgülle ayırarak belirterek yapabilirsiniz. Örneğin yukarıda tanımladığımız Add-Numbers fonksiyonunu kullanmak için onu şu şekilde çağırabilirsiniz:


Add-Numbers -num1 5 -num2 3

Bu, sırasıyla $num1 ve $num2 parametrelerine 5 ve 3 değerlerini aktaracaktır. $num2 için bir değer belirtmezseniz varsayılan değer olan 0'ı kullanır.

Parametrelerle PowerShell İşlev Şablonu

"Parçacıklar"ı kullanarak parametrelerle birlikte bir şablondan hızlı bir şekilde bir PowerShell işlevi oluşturabilirsiniz. PowerShell ISE'de şablondan hızlı bir şekilde fonksiyon oluşturabilirsiniz. PowerShell ISE'yi açın, “Düzenle” menüsünde “Parçacıkları Başlat” menü öğesine tıklayın. Bu, parametre niteliklerine sahip gelişmiş işlevler oluşturmak için hızlı bir başlangıç olabilir.


<#
.Synopsis
   Short description
.DESCRIPTION
   Long description
.EXAMPLE
   Example of how to use this cmdlet
.EXAMPLE
   Another example of how to use this cmdlet
#>
function Verb-Noun
{
    [CmdletBinding()]
    [Alias()]
    [OutputType([int])]
    Param
    (
        # Param1 help description
        [Parameter(Mandatory=$true,
                   ValueFromPipelineByPropertyName=$true,
                   Position=0)]
        $Param1,

        # Param2 help description
        [int]
        $Param2
    )

    Begin
    {
    }
    Process
    {
    }
    End
    {
    }
}

Parametre Tipleri

PowerShell çeşitli parametre türlerini destekler. [string], [int] ve [bool] gibi temel türlerin yanı sıra, [ gibi daha karmaşık türleri de kullanabilirsiniz. array], [hashtable] ve hatta özel nesneleriniz. PowerShell'de kullanabileceğiniz farklı parametre türlerinin bir özetini burada bulabilirsiniz:

[string]: Bu, bir karakter dizisini veya metin dizesini temsil eder.
[int]: Bu, tamsayı sayıları (tam sayılar) ifade eder.
[double]: Bu, ondalık basamağa (kayan noktalı sayı) sahip olabilen bir sayıyı temsil eder.
[bool]: Bu, $true veya $false şeklinde bir Boole değerini temsil eder.
[array]: Bu, herhangi bir türden olabilen bir dizi öğe için kullanılır.
[string[]]: Bu, bir dizi diziyi temsil eder.
[hashtable]: Bu, anahtar/değer çiftlerinin bir koleksiyonu olan karma tablosunu (diğer bazı dillerde sözlük olarak da bilinir) temsil eder.
[pscustomobject]: Bu, özel bir nesne türü için kullanılır.
[DateTime]: Bu, bir tarih ve saat değerini temsil eder.

Ayrıca, PowerShell parametreniz için bir tür belirtmezseniz bu, [object] genel türü olarak kabul edilir ve PowerShell, değeri nasıl uygun bir türe dönüştürmeye çalışır? fonksiyonda kullanılır.

Bir örneğe bakalım:


function MyFunction {
    param(
        [string]$Name,
        [int]$Age,
        [bool]$IsEnabled
    )
    # Function body
}

Bu örnekte, MyFunction işlevi üç parametreyi kabul eder: $Name, $Age ve $IsEnabled. İşlevi çağırırken bu parametrelere değerler iletebilir, böylece davranışının özel gereksinimlerinize göre özelleştirilebilmesini sağlayabilirsiniz.

Fonksiyon parametrelerinde ayarlanan parametre

PowerShell'de parametre kümesi, tek bir senaryo için birlikte çalışan bir parametre grubudur ve bir işlev, farklı senaryoları işlemek için birden fazla parametre kümesine sahip olabilir. ParameterSetName özelliği, belirli bir parametrenin hangi parametre setine ait olduğunu belirtmek için kullanılır. Bu, işlevinizin yalnızca belirli kullanım durumları için kullanılabilen parametrelere sahip olmanızı sağlar.

Bir fonksiyonun birden fazla parametre seti olabilir, ancak fonksiyon her çağrıldığında yalnızca bir tanesi kullanılabilir. Kullanıcı bilgilerini almanın iki farklı yolu olan bir işlevi düşünelim: Kullanıcı adına veya kullanıcı kimliğine göre.

Burada iki parametre setine sahip bir fonksiyon örneği verilmiştir:


function Get-UserInfo {
    [CmdletBinding(DefaultParameterSetName='ByName')]
    param (
        [Parameter(Mandatory=$true, ParameterSetName='ByName')]
        [string]$Name,
        
        [Parameter(Mandatory=$true, ParameterSetName='ByID')]
        [int]$ID
    )

    switch ($PSCmdlet.ParameterSetName) {
        'ByName' { Write-Output "Fetching user information by Name: $Name" }
        'ByID' { Write-Output "Fetching user information by ID: $ID" }
    }
}

Bu işlevin iki parametre seti vardır: 'İsme Göre' ve 'Kimliğe Göre'. -Name parametresi ile çağrıldığında kullanıcı bilgilerini isme göre, -ID ile çağrıldığında ise kullanıcı ID'sine göre kullanıcı bilgilerini getirir. Bu işlevi kullanmak için aşağıdakine benzer bir şey yaparsınız:


Get-UserInfo -Name "Alice"
Get-UserInfo -ID 123

İlk çağrı, Kullanıcı Bilgisi Alınıyor ismine göre çıktı verecek: Alice ve ikinci çağrı, Kullanıcı bilgisi getiriliyor çıktısı ID: 123'e göre verilecek.

PowerShell işlevlerinde anahtar parametrelerinden yararlanma

Anahtar parametreleri, PowerShell'de bir işlevin davranışını boole koşuluna göre denetlemek için kullanılabilen özel bir parametre türüdür. Anahtar parametreleri genellikle ikili opsiyonlar için kullanılır; burada anahtar etkinleştirildiğinde işlevin belirli bir eylemi, devre dışı bırakıldığında ise farklı bir eylemi gerçekleştirir. Anahtar parametrelerinin nasıl kullanılacağını görelim:


function Copy-Files {
    param (
        [Parameter(Mandatory=$true)]
        [string]$SourcePath,

        [Parameter(Mandatory=$true)]
        [string]$DestinationPath,

        [switch]$Overwrite
    )

    if (Test-Path $DestinationPath) {
        if ($Overwrite) {
            Write-Output "Overwriting existing files at $DestinationPath."
            Copy-Item -Path $SourcePath -Destination $DestinationPath -Recurse -Force
        } else {
            Write-Output "Destination path $DestinationPath already exists. Use -Overwrite to force."
        }
    } else {
        Write-Output "Copying files to $DestinationPath."
        Copy-Item -Path $SourcePath -Destination $DestinationPath -Recurse
    }
}

Bu işlevde, $SourcePath ve $DestinationPath, kopyalama işlemi için kaynak ve hedef dizinleri belirten zorunlu dize parametreleridir (Gerekli parametreler). $Overwrite, hedefteki mevcut dosyaların üzerine yazılıp yazılmayacağını belirten bir anahtar parametresidir. Bu işlevi -Overwrite anahtarıyla çağırırsanız, hedefteki mevcut dosyaların üzerine yazar:


Copy-Files -SourcePath "C:\source" -DestinationPath "C:\destination" -Overwrite

PowerShell işlevlerinde adlandırılmış parametreleri kullanma

Bir PowerShell işlevini çağırırken, konum sıralarına güvenmek yerine parametreleri ada göre iletebilirsiniz. Bu, özellikle birden fazla parametreye sahip işlevlerle çalışırken kodunuzu daha okunaklı hale getirebilir ve hataya daha az eğilimli hale getirebilir. Adlandırılmış parametrelerin nasıl kullanılacağını görelim:


Function Get-FullName($FirstName, $MiddleName, $LastName)
{
    $fullName = ''
    if ($firstName) {
        $fullName += $firstName
    }
    if ($middleName) {
        $fullName += " $middleName"
    }
    if ($lastName) {
        $fullName += " $lastName"
    }
    return $fullName.trim()
}

Get-FullName -FirstName "John" -LastName "Doe"
Get-FullName -FirstName "Jane" -MiddleName "Marie" -LastName "Smith"

Bu örnekte, Get-FullName işlevi iki/üç adlandırılmış parametreyle çağrılır: -FirstName, -MiddleName ve - Soyadı. Parametre adlarını açıkça belirterek değerleri herhangi bir sırayla sağlayabilirsiniz, böylece kodunuzu daha esnek ve daha kolay anlaşılır hale getirebilirsiniz.

Zorunlu ve İsteğe Bağlı Parametreler

Varsayılan olarak parametreler isteğe bağlıdır. Ancak PowerShell, [Parameter(Mandatory=$true)] özelliğini kullanarak zorunlu parametreleri belirtmemize olanak tanır ve işlev çağrısı sırasında bunlar sağlanmadıysa işlevin bunları istemesine neden olur. Bir örneğe bakalım:


function Greet-User {
    param (
        [Parameter(Mandatory=$true)]
        [string]$Name
    )

    Write-Output "Hello, $Name!"
}

Greet-User'ın bu sürümünde $Name parametresi zorunludur. Greet-User'ı -Name argümanı olmadan çağırmaya çalışırsak, PowerShell bizden bunu isteyecektir.

Konumsal Parametreler

Varsayılan olarak PowerShell işlev parametreleri adlandırılır, ancak konumsal da olabilirler, yani işlev çağrısındaki konumlarına göre değerler iletilebilir. Bir dikdörtgenin alanını hesaplamak için konum parametrelerini kullanan bir fonksiyon örneği aşağıda verilmiştir:


function CalculateArea {
    param (
        [Parameter(Position=0)]
        [int]$length,

        [Parameter(Position=1)]
        [int]$width
    )
    return $length * $width
}

Bu durumda $length ilk konumsal parametredir ve $width ikincidir. Bu işlevi, parametre adlarını belirtmeden, değerleri doğru sırada ileterek çağırabilirsiniz:


$area = CalculateArea 5 10

Giriş Parametrelerini Doğrulama

Kullanıcı girişinin doğrulanması sağlam, güvenilir ve hatasız PowerShell betikleri oluşturmanın bir diğer önemli yönüdür. Basit veri türü kontrollerinden karmaşık düzenli ifadelere ve doğrulama komut dosyalarına kadar, işlev parametreleriniz için her türlü doğrulama mantığını belirleyebilirsiniz. PowerShell, parametreleri doğrulamak için tür, aralık, desen veya boş veya boş olmama gibi denetimleri zorunlu kılan çeşitli yollar sunar.

ValidateNotNullOrEmpty

Bu, parametre değerinin boş veya boş bir dize olmamasını sağlar.


function Greet-User {
    param (
        [Parameter(Mandatory=$true)]
        [ValidateNotNullOrEmpty()]
        [string]$Name
    )

    Write-Output "Hello, $Name!"
}

Burada $Name parametresine bir ValidateNotNullOrEmpty özelliği ekledik. Şimdi Greet-User -Name "" veya Greet-User -Name $null'u çağırırsak PowerShell bir hata verecektir.

ValidateSet

Bu, parametre değerini belirli bir değer kümesiyle sınırlandırır. PowerShell işlevi parametrelerinin ve doğrulama kümesinin nasıl kullanılacağına ilişkin bir örnek:


Function Get-ProcessInfo {
    Param(
        [ValidateSet("notepad", "explorer")]
        [string]$ProcessName
    )

    Get-Process $ProcessName
}

Bu örnekte Get-ProcessInfo işlevi, [ValidateSet()] özniteliği kullanılarak doğrulanan $ProcessName parametresini alır. Bu, parametreye iletilen değerin “notepad” veya “explorer” olmasını sağlar.

ValidateRange

Bu, parametre değerinin belirli bir sayısal aralıkta kalmasını sağlar.


function Grade-Exam {
    param (
        [Parameter(Mandatory=$true)]
        [ValidateRange(0, 100)]
        [double]$Score
    )

    switch ($Score) {
        { $_ -ge 90 } { return "A" }
        { $_ -ge 80 } { return "B" }
        { $_ -ge 70 } { return "C" }
        { $_ -ge 60 } { return "D" }
        default { return "F" }
    }
}
$grade = Grade-Exam -Score 85
#Will Error
$grade = Grade-Exam -Score 105

Bu işlevi 0-100 aralığının dışında bir puanla çağırmaya çalışırsanız PowerShell bir hata verecektir:

ValidateScript

Bu, doğrulama için özel bir komut dosyası kullanmanıza olanak tanır.


function IsPrime {
    param (
        [Parameter(Mandatory=$true)]
        [ValidateScript({
            $number = $_
            if ($number -eq 1) { return $false }
            2..([Math]::Sqrt($number)) | foreach { if ($number % $_ -eq 0) { return $false } }
            return $true
        })]
        [int]$Number
    )

    return "$Number is a prime number."
}

Deseni Doğrula

Örneğin, $Email parametresinin her zaman geçerli bir e-posta adresi olduğundan emin olmak istiyorsanız doğrulama özelliğini şu şekilde ayarlayabilirsiniz:


function Process-UserInfo {
    param (
        [Parameter(Mandatory=$true)]
        [ValidatePattern("^[\w-]+(\.[\w-]+)*@([\w-]+\.)+[a-zA-Z]{2,7}$")]
        [string]$Email,

        [Parameter(Mandatory=$true)]
        [string]$Name
    )

    Write-Output "Name: $Name"
    Write-Output "Email: $Email"
}

Process-UserInfo -Name "John Doe" -Email "not-an-email" #End up in error
Process-UserInfo -Name "John Doe" -Email "john.doe@example.com"

Bu doğrulama mantığı, giriş dizesinin geçerli bir e-posta biçimiyle eşleşmesini sağlayan normal bir ifade kullanılarak belirtilir. Kullanıcı bu parametre için geçersiz bir değer iletirse, komut dosyası onlardan girişi düzeltmelerini ister.

Tüm bu durumlarda, parametre doğrulaması başarısız olursa PowerShell bir hata atar ve işlev yürütülmez. Bu şekilde sorunları, işlevinizin geri kalanında sorun yaratmadan önce erkenden yakalayabilirsiniz.

Parametreler için Varsayılan Değerlerin Tanımlanması

PowerShell işlevi parametreleriniz için varsayılan değerleri ayarlamak, betiğinizi daha kullanıcı dostu ve verimli hale getirmenin harika bir yoludur. Bir parametreyi varsayılan değerle tanımladığınızda, işlevi çağırırken bu değeri belirtmeniz gerekmez. Herhangi bir değer belirtilmezse PowerShell otomatik olarak varsayılan değeri kullanacaktır. Varsayılan değerleri parametre bildiriminin kendisinde şu şekilde tanımlayabilirsiniz:


Function Get-ProcessInfo {
    Param(
        [string]$ProcessName = "notepad"
    )

    Get-Process $ProcessName
}

Bu örnekte Get-ProcessInfo işlevi, varsayılan değeri "notepad" olan $ProcessName parametresini alır. $ProcessName için bir değer belirtmeden işlevi çağırırsanız, PowerShell varsayılan değeri kullanacak ve Not Defteri işlemiyle ilgili bilgileri döndürecektir.

Fonksiyon parametreleri için varsayılan değerlerin nasıl ayarlanacağına ilişkin başka bir örnek görelim:


function MyFunction {
    param(
        [string]$Name = "John Doe",
        [int]$Age = 30
    )
    # Function body
}

Bu örnekte, MyFunction fonksiyonunun iki parametresi vardır: $Name ve $Age. Arayanın bu parametreler için bir değer sağlamaması durumunda sırasıyla “John Doe” ve 30 varsayılan değerleri kullanılacaktır. Ancak arayan kişi bu parametreler için bir değer sağlarsa, sağlanan değerler varsayılan değerleri geçersiz kılacaktır.

Pipeline Girişini İşlev Parametreleriyle Kullanma

PowerShell ayrıca komut dosyalarınızı daha esnek ve verimli hale getirebilecek işlev parametreleriyle ardışık düzen girişini kullanmanıza da olanak tanır. Bunu yapmak için, fonksiyonun işlem hattından girişi kabul etmesi gerektiğini belirten [ValueFromPipeline] özniteliğine sahip bir parametre tanımlayabilirsiniz. Örneğin, burada bir sayı dizisini alıp toplamlarını döndüren bir fonksiyon var:


Function Add-Numbers {
Param (
   [Parameter(ValueFromPipeline=$true)]
   [int[]]$numbers
)
   $sum = $numbers | Measure-Object -Sum | Select-Object -ExpandProperty Sum
   return $sum
}

Bu örnekte, bir tam sayı dizisini kabul eden, $numbers adında tek bir parametre tanımladık. Bu parametrenin işlem hattından girişi kabul edebileceğini belirtmek için [ValueFromPipeline] özelliğini de ekledik. Bu, ardışık düzen girişini kullanarak bu işleve bir dizi sayıyı şu şekilde aktarabileceğiniz anlamına gelir:


1, 2, 3, 4, 5 | Add-Numbers

Bu, sayı dizisini $numbers parametresine iletecek ve işlev bunların toplamını döndürecektir.


#PowerShell Function with Parameter from Pipeline
Function Test-Pipeline {
  param (
    [Parameter(ValueFromPipeline)]
    $Param
  )
  process { "$($Param.Name) was passed through the pipeline" }
}

#Call the function by passing parameters through Pipeline
Get-Process | Test-Pipeline

Bu, çalışan her işlemi temsil eden bir nesneyi, her biri için bir mesaj verecek olan Test Boru Hattı işlevine iletecektir.

PowerShell'de İşlev Parametresi Olarak Dizi

Dizileri PowerShell işlevlerine parametre olarak kullanmak, bir parametreye birden çok değer aktarmanıza olanak tanır. Bu, birden fazla dosya veya klasörü işlemek gibi aynı görevi birden fazla öğe üzerinde gerçekleştirmeniz gerektiğinde yararlı olabilir.

PowerShell parametre dizisinin nasıl kullanılacağına ilişkin bir örnek:


Function Get-File {
    Param(
        [Parameter(Mandatory=$true)]
        [string[]]$Path
    )

    ForEach ($Item in $Path) {
        Get-Item $Item
    }
}
#Call the function
Get-File -Path "C:\Temp\AppLog.txt", "C:\Temp\FolderList.csv"

Bu örnekte Get-File işlevi, dosya veya klasör yolunu temsil eden bir dizi dizeyi parametre olarak alır. İşlev, dizideki her öğeyi işlemek için bir foreach döngüsü kullanır ve öğeyi Get-Item cmdlet'ini kullanarak döndürür.

Dizi kullanan bir örneğe bakalım:


function Show-Names {
    param (
        [string[]]$Names
    )

    foreach ($Name in $Names) {
        Write-Output "Hello, $Name!"
    }
}

Bu işlevde $Names bir dize dizisidir. Şu şekilde birden fazla ad iletebiliriz: Show-Names -Names "Alice", "Bob", "Charlie".

PowerShell parametrelerini kullanmaya yönelik en iyi uygulamalar

PowerShell işlev parametreleriyle çalışırken komut dosyalarınızın okunmasının, bakımının ve hata ayıklamasının kolay olmasını sağlamak için izlemeniz gereken bazı en iyi uygulamalar vardır. İşte bazı ipuçları:

Parametrenin ne yaptığını açıklayan açıklayıcı parametre adları kullanın.
Parametrenin zorunlu olup olmadığı veya ardışık düzen girişini kabul edip etmediği gibi ek özellikleri belirtmek için [Parameter()] niteliğini kullanın.
İsteğe bağlı parametreler için varsayılan değerleri kullanın.
Özellikle çok sayıda parametre söz konusu olduğunda, konumsal parametreler yerine adlandırılmış parametreleri kullanın.
Parametrelere iletilen değerlerin doğru türde olduğundan emin olmak için doğrulamayı kullanın.
Kabul ettikleri parametreler ve beklenen davranışları hakkında bilgiler de dahil olmak üzere, işlevleriniz için net belgeler sağlayın.

Bu en iyi uygulamaları takip ederek kullanımı ve bakımı kolay parametrelerle PowerShell işlevleri oluşturabilirsiniz.

Kapanıyor

İşlev parametrelerinde uzmanlaşmak PowerShell yolculuğunuzda çok önemli bir adımdır. Sağlam, çok yönlü ve çeşitli senaryolara uyarlanabilen işlevler yazmanıza olanak tanır. Bu kapsamlı kılavuzda PowerShell'deki işlev parametreleri dünyasını keşfettik. Fonksiyon parametrelerinin temellerini, mevcut farklı parametre türlerini ve parametreler için varsayılan değerlerin nasıl ayarlanacağını öğrendik. Ayrıca parametrelerin nasıl zorunlu hale getirileceğini, adlandırılmış parametrelerin nasıl kullanılacağını, giriş değerlerinin nasıl doğrulanacağını, ardışık düzendeki parametrelerle nasıl çalışılacağını ve anahtar parametrelerinden nasıl yararlanılacağını da gördük. Ayrıca PowerShell'deki işlev parametresi örneklerine baktık ve bunları etkili bir şekilde kullanmaya yönelik en iyi uygulamaları tartıştık.

İşlevlerinizdeki parametreleri anlayıp etkili bir şekilde kullanarak daha esnek, yeniden kullanılabilir ve verimli komut dosyaları yazabilecek ve böylece PowerShell yeteneğinizi artırabileceksiniz. Mutlu senaryolar!