PowerShell'de İşlevler Nasıl Oluşturulur ve Kullanılır

Fonksiyonlar herhangi bir programlama dilinde çok önemlidir; aynısı PowerShell için de geçerlidir. PowerShell komut dosyaları yazmak istiyorsanız PowerShell'de işlevlerin nasıl oluşturulacağını ve kullanılacağını bilmelisiniz. PowerShell'e yeni başlayanların da anlayabilmesi için detayları burada göstereceğim.

PowerShell'deki İşlev Nedir?

PowerShell'deki bir işlev, belirli bir görevi gerçekleştiren adlandırılmış bir kod bloğudur. İşlevler, yeniden kullanım ve daha iyi organizasyon için kodu kapsüllemek amacıyla kullanılır. Giriş parametrelerini alabilir, verileri işleyebilir ve sonuçları döndürebilirler. İşlevleri kullanarak kod tekrarını önleyebilir ve komut dosyalarınızı daha modüler ve bakımı kolay hale getirebilirsiniz.

Neden PowerShell'deki İşlevleri Kullanmalı?

PowerShell'de işlevleri kullanmanın birkaç avantajını burada bulabilirsiniz.

1. Kodun Yeniden Kullanılabilirliği: İşlevler, bir kod parçasını bir kez yazmanıza ve onu komut dosyanız boyunca birden çok kez yeniden kullanmanıza olanak tanır.
2. Modülerlik: Karmaşık komut dosyalarını daha küçük, yönetilebilir işlevlere bölmek, kodunuzu daha düzenli ve okunması kolay hale getirir.
3. Bakım kolaylığı: İşlevler, komut dosyalarınızın güncellenmesini ve bakımını kolaylaştırır. Belirli bir işlevi değiştirmeniz gerekiyorsa, komut dosyasının tamamını aramak yerine yalnızca işlevi güncellemeniz gerekir.
4. Test Etme: İşlevler bağımsız olarak test edilebilir; bu, hataların belirlenmesine ve komut dosyanızın her bir bölümünün doğru şekilde çalıştığından emin olmanıza yardımcı olur.

PowerShell İşlevinin Söz Dizimi

PowerShell'de işlevler, Function anahtar sözcüğü ve ardından bir ad ve bir çift küme parantezi { kullanılarak tanımlanır. Parantezlerin içine çalıştırılacak kodu yerleştirirsiniz.

PowerShell'de bir işlevi tanımlamaya yönelik temel sözdizimi aşağıdaki gibidir:

Function FunctionName {
    # Your code here
}

• Fonksiyon: Bir fonksiyonu bildirmek için kullanılan anahtar kelime.
• FunctionName: İşlevinize vereceğiniz ad. Fiil-isim adlandırma kuralının kullanılması iyi bir uygulamadır (ör. Get-UserInfo).
• {}: Kıvrımlı parantez, işlevi oluşturan kod bloğunu içine alır.

İşte basit bir örnek.

Function Say-Hello {
    Write-Output "Hello, World!"
}

İşlev adında Get, Set veya New gibi onaylanmış fiiller ve ardından bir isim kullanılmalıdır. Bu, standart adlandırma kurallarının korunmasına yardımcı olur ve kodun okunabilirliğini artırır.

İşlevleri tanımlarken adın, işlevin ne yaptığını açıkça belirttiğinden emin olun. Bu, diğer kullanıcıların (veya daha sonra kendinizin) kodu incelemeden işlevin amacını anlamasına yardımcı olur.

PowerShell Veri Türlerini Okuyun

PowerShell'de işlevler oluşturma ve kullanma

Şimdi PowerShell’de fonksiyonların nasıl oluşturulup kullanılacağını örneklerle inceleyelim.

Temel PowerShell İşlevi

Basit bir örnekle başlayalım. Bir kullanıcıyı karşılayan bir fonksiyon oluşturmak istediğimizi varsayalım. İşte PowerShell betik kodunun tamamı:

Function Greet-User {
    Write-Output "Hello, welcome to PowerShell scripting!"
}

# Calling the function
Greet-User

Bu örnekte, karşılama mesajı veren bir Kullanıcıyı Selamlama işlevi tanımladık. Daha sonra sadece adını yazarak fonksiyonu çağırıyoruz.

PowerShell betiğini çalıştırdıktan sonra aşağıdaki ekran görüntüsünde çıktıyı görebilirsiniz.

Parametrelerle PowerShell İşlevleri

Fonksiyonlar parametreleri kabul ettiklerinde daha da güçlü hale gelirler. Parametreler, işlevinize veri aktarmanıza olanak tanıyarak onu daha esnek hale getirir.

Burada PowerShell fonksiyonunun parametrelerle sözdizimi verilmiştir.

Function FunctionName {
    param (
        [Parameter1Type]$Parameter1,
        [Parameter2Type]$Parameter2
    )
    # Your code here
}

Burada Parametreleri olan bir PowerShell fonksiyonunun örneği verilmiştir.

Kullanıcıyı adıyla karşılayan bir fonksiyon oluşturalım.

Function Greet-User {
    param (
        [string]$FirstName,
        [string]$LastName
    )
    Write-Output "Hello, $FirstName $LastName! Welcome to PowerShell scripting!"
}

# Calling the function with parameters
Greet-User -FirstName "John" -LastName "Doe"

Bu örnekte, Greet-User işlevi iki parametre alır: FirstName ve LastName. Fonksiyonu çağırırken bu parametreler için değerler sağlıyoruz.

PowerShell betiğini VS kodunu kullanarak çalıştırdıktan sonra aşağıdaki ekran görüntüsüne bakın.

Parametrelerle PowerShell İşlev Örneklerini Okuyun

PowerShell İşlevi Varsayılan Parametre Değerleri

PowerShell işlevlerinde parametreler için varsayılan değerleri de ayarlayabilirsiniz. Arayanın bir değer sağlamaması durumunda varsayılan değer kullanılacaktır.

İşte bir sözdizimi:

Function Greet-User {
    param (
        [string]$FirstName = "John",
        [string]$LastName = "Doe"
    )
    Write-Output "Hello, $FirstName $LastName! Welcome to PowerShell scripting!"
}

# Calling the function without parameters
Greet-User

Bu durumda, hiçbir parametre sağlanmazsa işlev varsayılan değerler olarak "John" ve "Doe"yu kullanır.

PowerShell İşlevlerinden Dönen Değerler

PowerShell İşlevleri ayrıca değer döndürebilir. Bir değer döndürmek için PowerShell işlevinde return anahtar sözcüğünü kullanabilirsiniz.

İşte bir örnek:

Function Add-Numbers {
    param (
        [int]$Number1,
        [int]$Number2
    )
    return $Number1 + $Number2
}

# Calling the function and storing the result
$result = Add-Numbers -Number1 5 -Number2 10
Write-Output "The sum is: $result"

Burada, Numara Ekleme işlevi iki tam sayıyı parametre olarak alır, bunları toplar ve sonucu döndürür.

Bir Fonksiyondaki Zorunlu ve İsteğe Bağlı Parametreler

PowerShell işlevlerindeki parametreler zorunlu veya isteğe bağlı olabilir. İşlev çağrıldığında zorunlu bir parametre sağlanmalıdır; aksi takdirde PowerShell kullanıcıdan bir değer girmesini ister. Zorunlu bir parametre tanımlamak için Zorunlu özelliğini kullanın:

İşte sözdizimi:

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

Ancak İsteğe bağlı parametreler, herhangi bir değer belirtilmemişse kullanıcı girişi gerektirmez. Bunlara varsayılan bir değer atanabilir:

param (
    [Parameter(Mandatory=$false)]
    [string]$City = "Unknown"
)

Bu kurulum, işlevin minimum kullanıcı girişi ile çalışabilmesini sağlar ancak yine de gerektiğinde önemli girişleri zorlar.

PowerShell İşlevinde Birden Çok Parametre Kullanma

Ayrıca birden fazla parametreyi işleyen ve daha karmaşık mantık içeren işlevler de oluşturabilirsiniz. PowerShell'de alışveriş sepetindeki ürünlerin vergi dahil toplam fiyatını hesaplayan bir fonksiyon oluşturalım.

Function Calculate-TotalPrice {
    param (
        [hashtable]$Cart,
        [decimal]$TaxRate = 0.07
    )
    $total = 0
    foreach ($item in $Cart.Keys) {
        $total += $Cart[$item]
    }
    $totalWithTax = $total * (1 + $TaxRate)
    return [math]::Round($totalWithTax, 2)
}

# Simulated shopping cart
$cart = @{
    "Laptop" = 999.99
    "Mouse"  = 25.50
    "Keyboard" = 45.75
}

# Calling the function
$totalPrice = Calculate-TotalPrice -Cart $cart
Write-Output "The total price including tax is: $totalPrice"

Bu örnekte, ToplamFiyat Hesapla işlevi, bir alışveriş sepetini ve vergi oranını temsil eden bir karma tablosunu parametre olarak alır.

Konumsal ve Adlandırılmış Parametreler

PowerShell'de işlev parametreleri konumsal veya adlandırılmış olabilir. Konumsal parametreler, bağımsız değişkenlerin sağlanma sırasına bağlıdır:

function Test-Params {
    param ([string]$First, [string]$Second)
    Write-Output "$First $Second"
}

Test-Params "Hello" "World"

Adlandırılmış parametreler için parametre adları, girişlerle eşleşmek üzere kullanılır:

function Test-Params {
    param ([string]$First, [string]$Second)
    Write-Output "$First $Second"
}

Test-Params -First "Hello" -Second "World"

PowerShell İşlev Parametre Setleri

Parametre setleri, bir fonksiyon için farklı parametre setleri tanımlamanıza olanak tanır. İşte bir örnek.

Function Get-Info {
    param (
        [Parameter(Mandatory = $true, ParameterSetName = "ByName")]
        [string]$Name,

        [Parameter(Mandatory = $true, ParameterSetName = "ByID")]
        [int]$ID
    )
    switch ($PSCmdlet.ParameterSetName) {
        "ByName" { Write-Output "Getting info by Name: $Name" }
        "ByID" { Write-Output "Getting info by ID: $ID" }
    }
}

# Calling the function with different parameter sets
Get-Info -Name "John Doe"
Get-Info -ID 12345

İşlev Parametresi Olarak Boru Hattı Girişi

PowerShell işlevleri ayrıca işlem hattından gelen girişi de kabul edebilir. İşte bir örnek.

Function ConvertTo-UpperCase {
    param (
        [Parameter(ValueFromPipeline = $true)]
        [string]$InputString
    )
    process {
        Write-Output $InputString.ToUpper()
    }
}

# Using the function with pipeline input
"john doe", "jane smith" | ConvertTo-UpperCase

Bu örnekte, ConvertTo-UpperCase işlevi ardışık düzenden girişi kabul eder ve her giriş dizesini büyük harfe dönüştürür.

Bir Fonksiyondaki Başlangıç, İşleme ve Bitiş Blokları

PowerShell işlevleri, farklı yürütme aşamalarını yönetmek için Begin, Process ve End bloklarını içerebilir.

• Bloğu başlat: Başlangıçta bir kez çalıştırılır ve genellikle değişkenleri başlatmak için kullanılır.
• İşlem bloğu: İşlem hattından alınan her öğeyi, her nesne için yürüterek işler.
• Bloğu sonlandır: Tüm ardışık düzen girişi işlendikten sonra çalıştırılır; temizleme görevleri için kullanışlıdır.

Örnek :

function Get-Sample {
    [CmdletBinding()]
    param (
        [string]$Name,
        [int]$Age
    )
    begin {
        # Code to initialize
    }
    process {
        # Code to process each item
    }
    end {
        # Code to clean up
    }
}

PowerShell işlevlerinde blokların nasıl kullanılacağı budur.

Parametrelerle Komut Satırından PowerShell Komut Dosyasını Çalıştırmayı Okuyun

PowerShell'deki İşlevlerde Hata İşleme

PowerShell işlevlerindeki hataları işlemek her zaman iyidir. PowerShell, hata işleme için try-catch blokları ve hata değişkenleri gibi farklı yöntemler sağlar. Hata işlemenin işlevlere nasıl dahil edileceğini görelim.

Try-Catch'i kullanın

PowerShell işlevlerinde try-catch'in nasıl kullanılacağı aşağıda açıklanmıştır.

Function Divide-Numbers {
    param (
        [int]$Dividend,
        [int]$Divisor
    )
    try {
        if ($Divisor -eq 0) {
            throw "Division by zero is not allowed."
        }
        $result = $Dividend / $Divisor
        return $result
    } catch {
        Write-Output "Error: $_"
    }
}

# Calling the function with error handling
$result = Divide-Numbers -Dividend 10 -Divisor 0
Write-Output "Result: $result"

Bu örnekte, Sayıları Böl işlevi bölenin sıfır olup olmadığını kontrol eder ve sıfırsa bir hata atar. Try-catch bloğu hatayı yakalar ve uygun bir mesaj verir.

-ErrorAction ve $Error'ı kullanın

PowerShell ayrıca -ErrorAction ve $Error otomatik değişkenini kullanarak hata davranışını kontrol etmenize de olanak tanır.

PowerShell'deki bir işlevde hata işleme için bu değişkenlerin nasıl kullanılacağı aşağıda açıklanmıştır.

Function Get-FileContent {
    param (
        [string]$FilePath
    )
    Get-Content -Path $FilePath -ErrorAction Stop
}

# Calling the function with error handling
try {
    $content = Get-FileContent -FilePath "nonexistentfile.txt"
    Write-Output $content
} catch {
    Write-Output "Error: $_"
}

Burada Get-FileContent işlevi, Get-Content tarafından karşılaşılan hataların sonlandırma hataları olarak değerlendirilmesini sağlamak için -ErrorAction Stop'u kullanır. Try-catch bloğu daha sonra bu hataları işler.

PowerShell İşlevlerini Okuyun: Dönüş Değerleri ve Çoklu Değerler

PowerShell'de İşlevler Nasıl Çağrılır?

PowerShell'de bir işlevi çağırmak için kullanıcıların sözdizimini ve parametrelerin etkili bir şekilde nasıl iletileceğini anlaması gerekir. Şimdi size, işlevleri çağırmanın temel yollarını ve PowerShell'deki çağrı işlevlerine argümanların nasıl iletileceğini göstereyim.

Basit PowerShell İşlev Çağrısı

PowerShell'de bir işlevi çağırmak için işlevin adını ve ardından parantezleri yazmanız yeterlidir. Örneğin, Greet-User adlı bir işlev verildiğinde, onu şunu yazarak çağırabilirsiniz:

Greet-User

Bu, Greet-User işlevi içindeki kodu çalıştıracaktır.

Parametreleri İşlevlere Aktarma

PowerShell işlevleri genellikle onları daha esnek hale getirmek için parametreler alır. Parametreleri iletmek için bunları işlev adından sonra parantez içine ekleyin. Örneğin, Greet-User bir kullanıcı adı için bir parametreyi kabul ederse:

function Greet-User {
    param ($Name)
    Write-Output "Hello, $Name!"
}

Bu işlevi çağırabilir ve aşağıdaki gibi bir ad iletebilirsiniz:

Greet-User -Name "Alice"

Bu şu çıktıya yol açar: Merhaba Alice!. Parametreler zorunlu veya isteğe bağlı olabilir. Bunları tanımlamak için param bloğunu kullanın; gerekli olup olmadıklarını veya varsayılan değerlere sahip olup olmadıklarını belirttiğinizden emin olun.

Birden fazla parametre için her birini aşağıdaki gibi bir boşlukla ayırın:

Greet-User "Alice" 25

PowerShell İşlevleri için En İyi Uygulamalar

PowerShell'de işlevler oluştururken ve kullanırken birkaç en iyi uygulamayı izlemelisiniz.

Adlandırma Kuralları ve Onaylanmış Fiiller

İşlevler fiil-isim biçimini izlemelidir. Örneğin, işlemleri getiren bir işleve Get-Process adı verilebilir.

PowerShell'de tutarlılığı sağlamak için kullanılması gereken onaylanmış fiillerin bir listesi vardır. Yaygın olarak kullanılan fiillerden bazıları arasında Al, Ayarla, Kaldır ve Başlat yer alır. Bu fiilleri kullanmak, başkalarının işlevin amacını hızlı bir şekilde anlamasına yardımcı olur.

Ayrıca işlev adlarının PascalCase'de olması gerekir. Okunabilirliği artırmak için her kelimenin ilk harfini Hizmeti Başlat veya İşlemi Durdur gibi büyük yapın.

Yoruma Dayalı Yardım ve Dokümantasyon

Yoruma dayalı yardımla işlevlerin belgelenmesi, kullanılabilirliğini artırır. İşlevin amacını, parametrelerini ve çıktılarını açıklayan açıklamalar ekleyin.

Kısa bir açıklama vermek için belgelere .SYNOPSIS ile başlayın. Daha fazla ayrıntı için .DESCRIPTION kullanın. Parametrelerin .PARAMETER ile belgelenmesi gerekli girişlerin netleştirilmesine yardımcı olur. Örneğin:

<#
.SYNOPSIS
   Retrieves the list of running processes.
.DESCRIPTION
   Retrieves and displays the list of all running processes on the system.
.PARAMETER Name
   The name of the process to retrieve.
.EXAMPLE
   Get-Process -Name "notepad"
#>

Bu yorumların eklenmesi, başkalarının işlevleri anlamasını ve kullanmasını kolaylaştırır. Ayrıca kod bakımına ve gelecekteki güncellemelere de yardımcı olur.

PowerShell İşlev Örnekleri

İşte birkaç PowerShell işlevi örneği.

Örnek 1: Kullanıcı Bilgilerini Alma

Aşağıdaki PowerShell işlevi, karma tablosu kullanarak simüle edilmiş bir veritabanından kullanıcı bilgilerini alır.

# Simulated database of users
$users = @{
    "john.doe" = @{
        FirstName = "John"
        LastName  = "Doe"
        Email     = "john.doe@example.com"
    }
    "jane.smith" = @{
        FirstName = "Jane"
        LastName  = "Smith"
        Email     = "jane.smith@example.com"
    }
}

Function Get-UserInfo {
    param (
        [string]$Username
    )
    if ($users.ContainsKey($Username)) {
        return $users[$Username]
    } else {
        Write-Output "User not found."
    }
}

# Calling the function
$userInfo = Get-UserInfo -Username "john.doe"
if ($userInfo) {
    Write-Output "First Name: $($userInfo.FirstName)"
    Write-Output "Last Name: $($userInfo.LastName)"
    Write-Output "Email: $($userInfo.Email)"
}

Örnek 2: Vergi Dahil Toplam Fiyatın Hesaplanması

Bu PowerShell işlevi, alışveriş sepetindeki öğelerin vergi dahil toplam fiyatını hesaplar.

Function Calculate-TotalPrice {
    param (
        [hashtable]$Cart,
        [decimal]$TaxRate = 0.07
    )
    $total = 0
    foreach ($item in $Cart.Keys) {
        $total += $Cart[$item]
    }
    $totalWithTax = $total * (1 + $TaxRate)
    return [math]::Round($totalWithTax, 2)
}

# Simulated shopping cart
$cart = @{
    "Laptop" = 999.99
    "Mouse"  = 25.50
    "Keyboard" = 45.75
}

# Calling the function
$totalPrice = Calculate-TotalPrice -Cart $cart
Write-Output "The total price including tax is: $totalPrice"

Örnek 3: Metni Büyük Harfe Dönüştürme

PowerShell'deki aşağıdaki işlev, giriş metnini büyük harfe dönüştürür ve ardışık düzen girişini destekler.

Function ConvertTo-UpperCase {
    param (
        [Parameter(ValueFromPipeline = $true)]
        [string]$InputString
    )
    process {
        Write-Output $InputString.ToUpper()
    }
}

# Using the function with pipeline input
"john doe", "jane smith" | ConvertTo-UpperCase

İşte aşağıdaki ekran görüntüsündeki çıktı:

Örnek 4: Disk Alanını Kontrol Edin

Bu PowerShell işlevi, belirtilen sürücüdeki kullanılabilir disk alanını kontrol eder ve alan belirli bir eşiğin altındaysa bir uyarı verir.

Function Check-DiskSpace {
    param (
        [string]$DriveLetter = "C",
        [int]$ThresholdGB = 10
    )
    $drive = Get-PSDrive -Name $DriveLetter
    $freeSpaceGB = [math]::Round($drive.Free / 1GB, 2)
    if ($freeSpaceGB -lt $ThresholdGB) {
        Write-Output "Warning: Free space on drive $DriveLetter is below $ThresholdGB GB. Current free space: $freeSpaceGB GB."
    } else {
        Write-Output "Drive $DriveLetter has sufficient free space: $freeSpaceGB GB."
    }
}

# Calling the function
Check-DiskSpace -DriveLetter "C" -ThresholdGB 15

Örnek 5: Yedekleme Dosyaları

Aşağıdaki PowerShell işlevi, dosyaları bir kaynak dizinden hedef dizine yedekler.

Function Backup-Files {
    param (
        [string]$SourceDirectory,
        [string]$DestinationDirectory
    )
    if (-Not (Test-Path $SourceDirectory)) {
        Write-Output "Source directory does not exist."
        return
    }
    if (-Not (Test-Path $DestinationDirectory)) {
        New-Item -ItemType Directory -Path $DestinationDirectory
    }
    Copy-Item -Path "$SourceDirectory\*" -Destination $DestinationDirectory -Recurse -Force
    Write-Output "Backup completed from $SourceDirectory to $DestinationDirectory."
}

# Calling the function
Backup-Files -SourceDirectory "C:\Users\JohnDoe\Documents" -DestinationDirectory "D:\Backup\Documents"

Çözüm

Umarım bu eğitim size PowerShell işlevlerinin nasıl oluşturulacağı ve kullanılacağı konusunda eksiksiz bir fikir vermiştir. PowerShell'deki işlevlerin söz dizimini ve birkaç örneğini açıkladım.