Aracılığıyla paylaş

İfade hakkında if bilmek istediğiniz her şey

  • Makale

Diğer birçok dilde olduğu gibi PowerShell'de de betiklerinizde koşullu kod yürütmeye yönelik deyimler bulunur. Bu ifadelerden biri If deyimidir. Bugün PowerShell'deki en temel komutlardan birine ayrıntılı bir şekilde göz atacağız.

Not

Bu makalenin özgün sürümü, @KevinMarquette tarafından yazılan blogda yer almıştır. PowerShell ekibi, bu içeriği bizimle paylaştığı için Kevin'e teşekkür ederiz. Lütfen PowerShellExplained.com'daki blogunu inceleyin.

Koşullu yürütme

Betiklerinizin genellikle karar vermeleri ve bu kararlara göre farklı mantıklar gerçekleştirmeleri gerekir. Koşullu yürütmeyi kastetdiğim budur. Değerlendirilecek bir deyiminiz veya değeriniz var, ardından bu değerlendirmeye göre kodun farklı bir bölümünü yürütebilirsiniz. Deyimi tam olarak bunu if yapar.

Deyimi if

Aşağıda deyiminin temel bir örneği verilmiştir if :

$condition = $true
if ( $condition )
{
    Write-Output "The condition was true"
}

deyiminin if yaptığı ilk şey ifadeyi parantez içinde değerlendirmektir. olarak değerlendirilirse $true, küme ayraçlarında öğesini scriptblock yürütür. Değer ise $false, bu betik bloğunun üzerinden atlar.

Önceki örnekte if deyimi yalnızca değişkenini $condition değerlendiriyormuş. Betik bloğunun Write-Output içinde komutunu yürütürdü ve yürütürdü$true.

Bazı dillerde, deyiminden sonra if tek bir kod satırı yerleştirebilirsiniz ve kod yürütülür. PowerShell'de böyle bir durum söz konusu değildir. Düzgün çalışması için küme ayraçlarıyla dolu scriptblock bir sağlamanız gerekir.

Karşılaştırma işleçleri

deyiminin if en yaygın kullanımı, iki öğeyi birbiriyle karşılaştırmaktır. PowerShell'in farklı karşılaştırma senaryoları için özel işleçleri vardır. Karşılaştırma işleci kullandığınızda, sol taraftaki değer sağ taraftaki değerle karşılaştırılır.

Eşitlik için -eq

, -eq birbirine eşit olduklarından emin olmak için iki değer arasında eşitlik denetimi yapar.

$value = Get-MysteryValue
if ( 5 -eq $value )
{
    # do something
}

Bu örnekte, değerinin bilinen bir değerini 5 alıyorum ve eşleşip eşleşmediğini görmek için değeri ile karşılaştırıyorum $value .

Olası kullanım örneklerinden biri, bir eylem gerçekleştirmeden önce değerin durumunu denetlemektir. Bir hizmet alabilir ve hizmeti çağırmadan Restart-Service önce durumun çalışıp çalışmadığını kontrol edebilirsiniz.

C# gibi diğer dillerde eşitlik (örn. 5 == $value) için kullanılır==, ancak Bu PowerShell ile çalışmaz. İnsanların yaptığı bir diğer yaygın hata, değişkenlere değer atamak için ayrılmış eşittir işaretini (örn: 5 = $value) kullanmaktır. Bilinen değerinizi sola yerleştirerek, bu hatayı yapmak daha garip hale getirir.

Bu işlecin (ve diğerlerinin) birkaç varyasyonu vardır.

  • -eq büyük/küçük harfe duyarsız eşitlik
  • -ieq büyük/küçük harfe duyarsız eşitlik
  • -ceq büyük/küçük harfe duyarlı eşitlik

-ne eşit değil

Birçok işleç, karşıt sonucu denetleen ilgili bir işlecine sahiptir. -ne değerlerin birbirine eşit olmadığını doğrular.

if ( 5 -ne $value )
{
    # do something
}

Eylemin yalnızca değer değilse 5yürütüldiğinden emin olmak için bunu kullanın. Bir hizmeti başlatmaya çalışmadan önce çalışır durumda olup olmadığını denetlemek için iyi bir kullanım örnekleri.

Varyasyon -ları:

  • -ne büyük/küçük harfe duyarsız eşit değil
  • -ine büyük/küçük harfe duyarsız eşit değil
  • -cne büyük/küçük harfe duyarlı eşit değil

Bunlar ters varyasyonlarıdır -eq. Diğer işleçler için varyasyonları listelediğimde bu türleri birlikte gruplandıracağım.

Büyük veya küçüktür için -gt -ge -lt -le

Bu işleçler, bir değerin başka bir değerden daha büyük veya daha küçük olup olmadığını denetlerken kullanılır. -gt -ge -lt -le GreaterThan, GreaterThanOrEqual, LessThan ve LessThanOrEqual ifadesinin standı.

if ( $value -gt 5 )
{
    # do something
}

Varyasyon -ları:

  • -gt büyüktür
  • -igt büyüktür, büyük/küçük harfe duyarsız
  • -cgt büyüktür, büyük/küçük harfe duyarlı
  • -ge büyüktür veya eşittir
  • -ige büyüktür veya eşittir, büyük/küçük harfe duyarsız
  • -cge büyüktür veya eşittir, büyük/küçük harfe duyarlı
  • -lt küçüktür
  • -ilt küçüktür, büyük/küçük harfe duyarlı değil
  • -clt küçüktür, büyük/küçük harfe duyarlı
  • -le küçüktür veya eşittir
  • -ile küçüktür veya eşittir, büyük/küçük harfe duyarsız
  • -cle küçüktür veya eşittir, büyük/küçük harfe duyarlı

Bu işleçler için büyük/küçük harfe duyarlı ve duyarsız seçenekleri neden kullandığınızı bilmiyorum.

-like joker karakter eşleşmeleri

PowerShell'in kendi joker karakter tabanlı desen eşleştirme söz dizimi vardır ve bunu işleçle -like birlikte kullanabilirsiniz. Bu joker karakter desenleri oldukça temeldir.

  • ? herhangi bir tek karakterle eşleşir
  • * herhangi bir sayıda karakterle eşleşir
$value = 'S-ATX-SQL01'
if ( $value -like 'S-*-SQL??')
{
    # do something
}

Desenin dizenin tamamıyla eşleşdiğini belirtmek önemlidir. Dizenin ortasındaki bir şeyi eşleştirmeniz gerekiyorsa, dizenin * her iki ucuna da yerleştirmeniz gerekir.

$value = 'S-ATX-SQL02'
if ( $value -like '*SQL*')
{
    # do something
}

Varyasyon -ları:

  • -like büyük/küçük harfe duyarlı olmayan joker karakter
  • -ilike büyük/küçük harfe duyarlı olmayan joker karakter
  • -clike büyük/küçük harfe duyarlı joker karakter
  • -notlike büyük/küçük harfe duyarlı olmayan joker karakter eşleşmedi
  • -inotlike büyük/küçük harfe duyarlı olmayan joker karakter eşleşmedi
  • -cnotlike büyük/küçük harfe duyarlı joker karakter eşleşmiyor

-match normal ifade

işleci, -match normal ifade tabanlı eşleşme için bir dizeyi denetlemenize olanak tanır. Joker karakter desenleri sizin için yeterince esnek olmadığında bunu kullanın.

$value = 'S-ATX-SQL01'
if ( $value -match 'S-\w\w\w-SQL\d\d')
{
    # do something
}

Bir regex deseni varsayılan olarak dizenin herhangi bir yerinde eşleşir. Bu nedenle, aşağıdaki gibi eşleşmesini istediğiniz bir alt dize belirtebilirsiniz:

$value = 'S-ATX-SQL01'
if ( $value -match 'SQL')
{
    # do something
}

Regex kendi karmaşık bir dilidir ve araştırılmaya değer. Başka bir makalede regex kullanmanın birçok yolu ve hakkında -match daha fazla konuşuyorum.

Varyasyon -ları:

  • -match büyük/küçük harfe duyarlı olmayan regex
  • -imatch büyük/küçük harfe duyarlı olmayan regex
  • -cmatch büyük/küçük harfe duyarlı regex
  • -notmatch büyük/küçük harfe duyarlı olmayan regex eşleşmedi
  • -inotmatch büyük/küçük harfe duyarlı olmayan regex eşleşmedi
  • -cnotmatch büyük/küçük harfe duyarlı regex eşleşmedi

-türü

Bir değerin türünü işleciyle -is de kontrol edebilirsiniz.

if ( $value -is [string] )
{
    # do something
}

Sınıflarla çalışıyorsanız veya işlem hattı üzerinden çeşitli nesneleri kabul ediyorsanız bunu kullanabilirsiniz. Giriş olarak bir hizmet veya hizmet adı olabilir. Ardından bir hizmetiniz olup olmadığını denetleyin ve yalnızca ada sahipseniz hizmeti getirin.

if ( $Service -isnot [System.ServiceProcess.ServiceController] )
{
    $Service = Get-Service -Name $Service
}

Varyasyon -ları:

  • -is türü
  • -isnot türünde değil

Koleksiyon işleçleri

Önceki işleçleri tek bir değerle kullandığınızda, sonuç veya $falseşeklindedir$true. Bu, bir koleksiyonla çalışırken biraz farklı işlenir. Koleksiyondaki her öğe değerlendirilir ve işleç olarak değerlendirilen $trueher değeri döndürür.

PS> 1,2,3,4 -eq 3
3

Bu, bir if deyimde düzgün çalışmaya devam ediyor. Bu nedenle, işleciniz tarafından bir değer döndürülür ve deyiminin tamamı olur $true.

$array = 1..6
if ( $array -gt 3 )
{
    # do something
}

Burada ayrıntıların içinde gizlenen küçük bir tuzak var. işlecini bu şekilde kullanırken -ne , mantığa yanlışlıkla geriye doğru bakmak kolaydır. -ne Koleksiyon ile kullanmak, koleksiyondaki herhangi bir öğe değerinizle eşleşmiyorsa döndürür$true.

PS> 1,2,3 -ne 4
1
2
3

Bu akıllıca bir numara gibi görünebilir, ancak işleçlerimiz -contains var ve -in bu işi daha verimli bir şekilde hallediyoruz. Ve -notcontains beklediğiniz şeyi yapar.

-Içerir

işleci -contains , koleksiyonda değerinizi denetler. Eşleşme bulur bulmaz döndürür $true.

$array = 1..6
if ( $array -contains 3 )
{
    # do something
}

Bu, bir koleksiyonun değerinizi içerip içermediğini görmek için tercih edilen yöntemdir. (veya-eq) kullanmak Where-Object , her seferinde listenin tamamında izlenir ve çok daha yavaştır.

Varyasyon -ları:

  • -contains büyük/küçük harfe duyarlı olmayan eşleşme
  • -icontains büyük/küçük harfe duyarlı olmayan eşleşme
  • -ccontains büyük/küçük harfe duyarlı eşleşme
  • -notcontains büyük/küçük harfe duyarsız eşleşmedi
  • -inotcontains büyük/küçük harfe duyarsız eşleşmedi
  • -cnotcontains büyük/küçük harfe duyarlı eşleşmedi

-Inç

İşleç -in aynı işleç gibidir -contains ancak koleksiyon sağ taraftadır.

$array = 1..6
if ( 3 -in $array )
{
    # do something
}

Varyasyon -ları:

  • -in büyük/küçük harfe duyarlı olmayan eşleşme
  • -iin büyük/küçük harfe duyarlı olmayan eşleşme
  • -cin büyük/küçük harfe duyarlı eşleşme
  • -notin büyük/küçük harfe duyarsız eşleşmedi
  • -inotin büyük/küçük harfe duyarsız eşleşmedi
  • -cnotin büyük/küçük harfe duyarlı eşleşmedi

Mantıksal işleçler

Mantıksal işleçler, diğer ifadeleri ters çevirmek veya birleştirmek için kullanılır.

-Değil

işleci -not bir ifadeyi ile $false$true arasında çevirir $true$false. Burada, olduğunda Test-Path bir eylem gerçekleştirmek istediğimiz bir örnek verilmiştir $false.

if ( -not ( Test-Path -Path $path ) )

Bahsettiğimiz işleçlerin çoğunun işlecini kullanmanız gerekmeyen bir varyasyonu -not vardır. Ancak hala yararlı olduğu zamanlar vardır.

! işleç

için -notdiğer ad olarak kullanabilirsiniz!.

if ( -not $value ){}
if ( !$value ){}

C# gibi başka dillerden gelen kişilerin daha fazla kullandığını görebilirsiniz ! . Yazmak istiyorum çünkü senaryolarıma hızlı bir şekilde bakarken görmenin zor olduğunu görüyorum.

-Ve

İfadeleri işleciyle -and birleştirebilirsiniz. Bunu yaptığınızda, ifadenin tamamının olması $true için her iki tarafın da olması $truegerekir.

if ( ($age -gt 13) -and ($age -lt 55) )

Bu örnekte, $age sol taraf için 13 veya daha eski, sağ taraf için 55'ten küçük olmalıdır. Bu örnekte daha net hale getirmek için fazladan ayraç ekledim ama ifade basit olduğu sürece isteğe bağlı. Bunlar olmadan da aynı örnek aşağıda verilmiştir.

if ( $age -gt 13 -and $age -lt 55 )

Değerlendirme soldan sağa gerçekleşir. İlk öğe olarak değerlendirilirse $false, erken çıkar ve doğru karşılaştırmayı yapmaz. Bu, kullanmadan önce bir değerin var olduğundan emin olmanız gerektiğinde kullanışlıdır. Örneğin, Test-Path bir yol verirseniz $null bir hata oluşturur.

if ( $null -ne $path -and (Test-Path -Path $path) )

-Veya

iki -or ifade belirtmenize olanak tanır ve bunlardan biri ise $truedöndürür$true.

if ( $age -le 13 -or $age -ge 55 )

Aynı işleçte -and olduğu gibi değerlendirme de soldan sağa gerçekleşir. İlk bölüm $trueise, deyimin tamamı olur $true ve ifadenin geri kalanını işlemez.

Söz diziminin bu işleçler için nasıl çalıştığını da not edin. İki ayrı ifadeye ihtiyacınız vardır. Kullanıcıların hatalarını fark etmeden böyle $value -eq 5 -or 6 bir şey yapmaya çalıştıklarını gördüm.

-xor özel veya

Bu biraz sıra dışı. -xor yalnızca bir ifadenin değerlendirmesine $trueizin verir. Bu nedenle, her iki öğe $false de veya her ikisi de ise $true, ifadenin tamamı olur $false. Buna bakmanın başka bir yolu da ifadenin yalnızca $true sonuçları farklı olduğunda ifadedir.

Herkesin bu mantıksal işleci kullanması çok nadirdir ve bunu neden kullanacağıma dair iyi bir örnek bulamıyorum.

Bit düzeyinde işleçler

Bit düzeyinde işleçler, değerlerin içindeki bitler üzerinde hesaplamalar yapar ve sonuç olarak yeni bir değer üretir. Bit düzeyinde işleçleri öğretmek bu makalenin kapsamının dışındadır, ancak bunların listesi aşağıda verilmiştir.

  • -band ikili AND
  • -bor ikili OR
  • -bxor ikili özel OR
  • -bnot ikili DEĞİl
  • -shl sola kaydırma
  • -shr sağa kaydırma

PowerShell ifadeleri

Koşul deyiminin içinde normal PowerShell kullanabiliriz.

if ( Test-Path -Path $Path )

Test-Pathveya $false yürütüldüğünde döndürür$true. Bu, diğer değerleri döndüren komutlar için de geçerlidir.

if ( Get-Process Notepad* )

Döndürülen bir işlem olup olmadığını ve $false yoksa olduğunu değerlendirir$true. İşlem hattı ifadelerini veya aşağıdaki gibi diğer PowerShell deyimlerini kullanmak son derece geçerlidir:

if ( Get-Process | Where Name -eq Notepad )

Bu ifadeler ve -or işleçleriyle -and birleştirilebilir, ancak bunları alt ifadelere ayırmak için parantez kullanmanız gerekebilir.

if ( (Get-Process) -and (Get-Service) )

$null denetleniyor

Sonuç veya $null değer olmaması deyiminde if değerlendirilir$false. özellikle için $nulldenetlerken, sol tarafa yerleştirmek $null en iyi yöntemdir.

if ( $null -eq $value )

PowerShell'de değerlerle $null ilgilenirken birkaç nüans vardır. Daha derine inmek istiyorsanız, $null hakkında bilmek istediğiniz her şey hakkında bir makalem var.

Koşul içindeki değişken ataması

Prasoon Karunan V bana hatırlatana kadar bunu eklemeyi neredeyse unutuyordum.

if ($process=Get-Process notepad -ErrorAction ignore) {$process} else {$false}

Normalde bir değişkene değer atadığınızda, değer işlem hattına veya konsola geçirilir. Bir alt ifadede değişken ataması yaptığınızda işlem hattına geçirilir.

PS> $first = 1
PS> ($second = 2)
2

Atamanın $first çıkışı olmadığını ve atamanın $second nasıl yaptığını görün. Bir atama bir if deyimde yapıldığında, yukarıdaki atama gibi $second yürütülür. Bunu nasıl kullanabileceğinize ilişkin temiz bir örnek aşağıda verilmiştir:

if ( $process = Get-Process Notepad* )
{
    $process | Stop-Process
}

Bir değer atanırsa $process , deyimi olur $true ve $process durdurulur.

Bu bir eşitlik denetimi olmadığından bunu -eq karıştırmadığınızdan emin olun. Bu, çoğu kişinin bu şekilde çalıştığını fark etmediğinden daha belirsiz bir özelliktir.

Betik bloğundan değişken atama

Bir değişkene if değer atamak için deyimi betik bloğu da kullanabilirsiniz.

$discount = if ( $age -ge 55 )
{
    Get-SeniorDiscount
}
elseif ( $age -le 13 )
{
    Get-ChildDiscount
}
else
{
    0.00
}

Her betik bloğu, komutların veya değerin sonuçlarını çıkış olarak yazıyor. deyiminin if sonucunu değişkenine $discount atayabiliriz. Bu örnek, bu değerleri doğrudan her betik bloğunda değişkene $discount kolayca atamış olabilir. Bunu deyimiyle if sık kullandığımı söyleyemem, ancak bunu son zamanlarda kullandığım bir örneğim var.

Alternatif yürütme yolu

deyimi if , yalnızca deyimi $trueolduğunda değil aynı zamanda olduğunda için de bir eylem belirtmenize $falseolanak tanır. bu ifadenin else devreye girdiği yerdir.

else

deyimi else her zaman kullanıldığında deyiminin if son bölümüdür.

if ( Test-Path -Path $Path -PathType Leaf )
{
    Move-Item -Path $Path -Destination $archivePath
}
else
{
    Write-Warning "$path doesn't exist or isn't a file."
}

Bu örnekte, bir dosya olduğundan emin olmak için öğesini denetleyeceğiz $path . Dosyayı bulursak, taşıyacağız. Aksi takdirde bir uyarı yazarız. Bu tür dallanma mantığı çok yaygındır.

İç içe eğer

if ve else deyimleri bir betik bloğu alır, böylece başka if bir deyim de dahil olmak üzere tüm PowerShell komutlarını içlerine yerleştirebiliriz. Bu, çok daha karmaşık mantık kullanmanıza olanak tanır.

if ( Test-Path -Path $Path -PathType Leaf )
{
    Move-Item -Path $Path -Destination $archivePath
}
else
{
    if ( Test-Path -Path $Path )
    {
        Write-Warning "A file was required but a directory was found instead."
    }
    else
    {
        Write-Warning "$path could not be found."
    }
}

Bu örnekte, önce mutlu yolu test edeceğiz ve ardından üzerinde işlem yapacağız. Bu başarısız olursa, kullanıcıya daha ayrıntılı bilgi sağlamak için başka bir denetim yaparız.

Elseıf

Yalnızca tek bir koşullu denetimle sınırlı değildir. deyimini kullanarak elseif iç içe yerleştirme yerine ve else deyimlerini birbirine zincirleyebilirizif.

if ( Test-Path -Path $Path -PathType Leaf )
{
    Move-Item -Path $Path -Destination $archivePath
}
elseif ( Test-Path -Path $Path )
{
    Write-Warning "A file was required but a directory was found instead."
}
else
{
    Write-Warning "$path could not be found."
}

Yürütme yukarıdan aşağıya doğru gerçekleşir. İlk olarak top if deyimi değerlendirilir. Bu ise $false, bir sonrakine elseif veya else listede aşağı doğru hareket eder. Bu son else , diğerlerinin hiçbiri döndürmezse $truegerçekleştirecek varsayılan eylemdir.

switch

Bu noktada ifadeden switch bahsetmem gerekiyor. Bir değerle birden çok karşılaştırma yapmak için alternatif bir söz dizimi sağlar. switchile bir ifade belirtirsiniz ve bu sonuç birkaç farklı değerle karşılaştırılır. Bu değerlerden biri eşleşirse, eşleşen kod bloğu yürütülür. Şu örneğe göz atın:

$itemType = 'Role'
switch ( $itemType )
{
    'Component'
    {
        'is a component'
    }
    'Role'
    {
        'is a role'
    }
    'Location'
    {
        'is a location'
    }
}

ile eşleşebilecek $itemTypeüç olası değer vardır. Bu durumda ile Roleeşleşir. Operatöre biraz maruz kalmanı sağlamak için switch basit bir örnek kullandım. Başka bir makalede switch deyimi hakkında bilmek istediğiniz her şeyden daha fazla bahsediyorum.

Satır içi dizi

Invoke-SnowSql adlı ve birkaç komut satırı bağımsız değişkeniyle yürütülebilir dosya başlatan bir işlevim var. Bağımsız değişken dizisini derlediğim işlevden bir klip aşağıdadır.

$snowSqlParam = @(
    '--accountname', $Endpoint
    '--username', $Credential.UserName
    '--option', 'exit_on_error=true'
    '--option', 'output_format=csv'
    '--option', 'friendly=false'
    '--option', 'timing=false'
    if ($Debug)
    {
        '--option', 'log_level=DEBUG'
    }
    if ($Path)
    {
        '--filename', $Path
    }
    else
    {
        '--query', $singleLineQuery
    }
)

$Debug ve $Path değişkenleri, son kullanıcı tarafından sağlanan işlevdeki parametrelerdir. Bunları dizimin başlatılmasının içinde satır içinde değerlendiriyorum. Doğruysa $Debug , bu değerler doğru yere düşer $snowSqlParam . Aynı, değişken için $Path de geçerlidir.

Karmaşık işlemleri basitleştirme

Kontrol etmek için çok fazla karşılaştırması olan bir durumla karşılaşırsınız ve deyiminiz If ekranın sağ tarafında kaydırılır.

$user = Get-ADUser -Identity $UserName
if ( $null -ne $user -and $user.Department -eq 'Finance' -and $user.Title -match 'Senior' -and $user.HomeDrive -notlike '\\server\*' )
{
    # Do Something
}

Okuması zor olabilir ve bu da sizi hata yapmaya daha meyilli hale getirir. Bu konuda yapabileceğimiz birkaç şey var.

Satır devamlılığı

PowerShell'de komutu bir sonraki satıra sarmalamanıza olanak sağlayan bazı işleçler vardır. mantıksal işleçler -and ve -or ifadenizi birden çok satıra bölmek istiyorsanız iyi işleçlerdir.

if ($null -ne $user -and
    $user.Department -eq 'Finance' -and
    $user.Title -match 'Senior' -and
    $user.HomeDrive -notlike '\\server\*'
)
{
    # Do Something
}

Orada hala çok şey oluyor, ama her parçayı kendi hattına yerleştirmek büyük bir fark yaratır. Genellikle ikiden fazla karşılaştırma yaptığımda veya mantığın herhangi birini okumak için sağa kaydırmam gerektiğinde bunu kullanırım.

Sonuçları önceden hesaplama

Bu deyimi deyiminden if alabilir ve yalnızca sonucu denetleyebiliriz.

$needsSecureHomeDrive = $null -ne $user -and
    $user.Department -eq 'Finance' -and
    $user.Title -match 'Senior' -and
    $user.HomeDrive -notlike '\\server\*'

if ( $needsSecureHomeDrive )
{
    # Do Something
}

Bu, önceki örnekten çok daha temiz bir histir. Ayrıca, gerçekten neleri denetlediğini açıklayan bir değişken adı kullanma fırsatı da verilir. Bu ayrıca ve gereksiz açıklamaları kaydeden kendi kendini belgeleyen kod örneğidir.

Birden çok if deyimi

Bunu birden çok deyime ayırabilir ve tek tek kontrol edebiliriz. Bu durumda, sonuçları birleştirmek için bir bayrak veya izleme değişkeni kullanırız.


$skipUser = $false

if( $null -eq $user )
{
    $skipUser = $true
}

if( $user.Department -ne 'Finance' )
{
    Write-Verbose "isn't in Finance department"
    $skipUser = $true
}

if( $user.Title -match 'Senior' )
{
    Write-Verbose "Doesn't have Senior title"
    $skipUser = $true
}

if( $user.HomeDrive -like '\\server\*' )
{
    Write-Verbose "Home drive already configured"
    $skipUser = $true
}

if ( -not $skipUser )
{
    # do something
}

Bayrak mantığının düzgün çalışması için mantığı ters çevirmem gerekirdi. Her değerlendirme ayrı if bir deyimdir. Bunun avantajı, hata ayıklarken mantığın tam olarak ne yaptığını anlayabilebilmenizdir. Aynı anda çok daha iyi ayrıntı ekleyebildim.

Bunun en belirgin dezavantajı, yazacak çok daha fazla kod olmasıdır. Tek bir mantık satırı alıp 25 veya daha fazla satıra bölerken koda bakmak daha karmaşıktır.

İşlevleri kullanma

Ayrıca tüm bu doğrulama mantığını bir işleve taşıyabiliriz. Bunun bir bakışta ne kadar temiz göründüğüne bakın.

if ( Test-SecureDriveConfiguration -ADUser $user )
{
    # do something
}

Doğrulamayı yapmak için işlevi yine de oluşturmanız gerekir, ancak bu kodla çalışmayı çok daha kolay hale getirir. Bu kodu test etmek daha kolay hale getirir. Testlerinizde çağrısıyla Test-ADDriveConfiguration dalga geçebilirsiniz ve bu işlev için yalnızca iki teste ihtiyacınız vardır. Biri döndürdüğü $true , diğeri ise döndürdüğü $falseyer. Diğer işlevin test edilmesi çok küçük olduğundan daha basittir.

Bu işlevin gövdesi yine de başladığımız tek satırlı veya son bölümde kullandığımız patlayan mantık olabilir. Bu, her iki senaryo için de iyi çalışır ve bu uygulamayı daha sonra kolayca değiştirmenize olanak tanır.

Hata işleme

deyiminin if önemli bir kullanımı, hatayla karşılaşabilmeniz için önce hata koşullarını denetlemektir. Bir klasörü oluşturmaya çalışmadan önce zaten var olup olmadığını denetlemek iyi bir örnektir.

if ( -not (Test-Path -Path $folder) )
{
    New-Item -Type Directory -Path $folder
}

Eğer bir istisna olmasını bekliyorsanız, bunun bir istisna olmadığını söylemek isterim. Bu nedenle, değerlerinizi denetleyin ve koşullarınızı nerede yapabileceğinizi doğrulayın.

Gerçek özel durum işlemeye biraz daha fazla girmek istiyorsanız, özel durumlar hakkında bilmek istediğiniz her şey hakkında bir makalem var.

Son sözcükler

deyimi if çok basit bir deyimdir ancak PowerShell'in temel bir parçasıdır. Yazdığınız hemen her betikte bunu birden çok kez kullanırken bulacaksınız. Umarım öncekinden daha iyi bir anlayışa sahipsindir.