7. ifadeler

Söz dizimi:

expression:
    logical-expression

Açıklama:

İfade bir yöntem, bir işlev, yazılabilir bir konum veya bir değer belirten işleçler ve işlenenler dizisidir; bir değerin hesaplamasını belirtir; bir veya daha fazla yan efekt üretir; veya bazı birleşimleri gerçekleştirir. Örneğin,

• 123 sabit 123 değeri, int değerini atayan bir ifadedir.
• İfade 1,2,3,4 , gösterilen değerlere sahip 4 öğeli dizi nesnesini belirler.
• İfade 10.4 * $a bir hesaplama belirtiyor.
• İfade $a++ bir yan etkisi üretir.
• İfade $a[$i--] = $b[++$j] , bu nesnelerin bir bileşimini gerçekleştirir.

Bazı işleçler için belirtilmedikçe, bir ifadede koşulların değerlendirilme sırası ve yan etkilerin gerçekleştiği sırada ikisi de belirtilmemiş olur. Belirtilmeyen davranışa örnek olarak şunlar verilebilir: $i++ + $i , $i + --$i , ve $w[$j++] = $v[$j] .

PowerShell 'in uygulanması, Kullanıcı tanımlı türler için destek sağlayabilir ve bu türlerin kendileri üzerinde tanımlı işlemleri olabilir. Bu tür türlerin ve işlemlerin tüm ayrıntıları uygulama tanımlı ' dır.

Üst düzey ifade , bazı daha büyük bir ifadenin parçası olmayan bir ifadedir. Üst düzey bir ifade bir yan efekt operatörü içeriyorsa, bu ifadenin değeri işlem hattına yazılmaz; Aksi takdirde,. Ayrıntılı bir tartışma için bkz. § 7.1.1 .

Normalde, bir koleksiyon (§ 4) oluşturan bir ifade, bu ifadenin değeri kullanıldığında onun bileşen öğelerine numaralandırılır. Ancak, ifade bir cmdlet çağrısı olduğunda bu durum böyle değildir. Örneğin,

$x = 10,20,30
$a = $($x; 99)                     # $a.Length is 4

$x = New-Object 'int[]' 3
$a = $($x; 99)                     # equivalent, $a.Length is 4

$a = $(New-Object 'int[]' 3; 99)   # $a.Length is 2

İşlecin ilk iki kullanımında $(...) , koleksiyonu belirleyen ifade, üç int değer ve 99 ile int ortaya çıkacak olan değişkenidir $x . Ancak, üçüncü durumda ifade bir cmdlet 'e doğrudan çağrıdır, bu nedenle sonuç numaralandırılamaz ve $a iki öğe int[3] dizisi ve int olur.

Bir işlem PowerShell tarafından tanımlanmamışsa, sol işlenen tarafından belirtilen değerin türü ilgili op_<operation> bir yönteme sahip olup olmadığını görmek için denetlenir.

7,1 birincil ifadesi

Söz dizimi:

primary-expression:
    value
    member-access
    element-access
    invocation-expression
    post-increment-expression
    post-decrement-expression

value:
    parenthesized-expression
    sub-expression
    array-expression
    script-block-expression
    hash-literal-expression
    literal
    type-literal
    variable

7.1.1 gruplama ayraçları

Söz dizimi:

İpucu

~opt~Söz dizimi tanımlarındaki Gösterim, sözcük temelli varlığın sözdiziminde isteğe bağlı olduğunu gösterir.

parenthesized-expression:
    ( new-lines~opt~ pipeline new-lines~opt~ )

Açıklama:

Parantez içine alınmış bir ifade, türü ve değeri parantezsiz deyimle aynı olan bir birincil ifadedir . İfade bir değişken alıyorsa, parantez içine alınmış ifade aynı değişkeni belirler. Örneğin, $x.m ve ($x).m eşdeğerdir.

Gruplandırma ayraçları, bu ifade içindeki varsayılan önceliği ve ilişkilendirilebilirliği belgelemek için bir ifadede kullanılabilir. Bu varsayılan önceliği ve ilişkilendirilebilirliği geçersiz kılmak için de kullanılabilir. Örneğin,

4 + 6 * 2    # 16
4 + (6 * 2)  # 16 document default precedence
(4 + 6) * 2  # 20 override default precedence

Normalde, en üst düzeyde gruplama parantezleri gereksizdir. Ancak, bu her zaman durum değildir. Aşağıdaki örneği inceleyin:

2,4,6       # Length 3; values 2,4,6
(2,4),6     # Length 2; values [object[]],int

İkinci durumda, parantez, iki öğe bir dizi 2 ve skaler tamsayı 6 olan bir dizi olan bir dizi ile sonuçlanır ve semantiğini değiştirir.

Başka bir özel durum aşağıda verilmiştir:

23.5/2.4          # pipeline gets 9.79166666666667
$a = 1234 * 3.5   # value not written to pipeline
$a                # pipeline gets 4319

Birinci ve üçüncü durumlarda, sonucun değeri işlem hattına yazılır. Ancak, ikinci durumda ifade değerlendirilse de, en üst düzeyde yan etkinin olması nedeniyle sonuç işlem hattına yazılmaz. (Bölümün kaldırılması $a = , * bir yan efekt operatörü olmadığından değerin yazılmasına izin verir.)

Üst düzey yan etkileri olmayan herhangi bir ifadenin bir değerini, işlem hattına yazılmasının dışında bırakmak için, aşağıdaki gibi açık bir şekilde atın:

# None of these value are written to pipeline
[void](23.5/2.4)
[void]$a
$null = $a
$a > $null

Ardışık düzene yazmak için üst düzey yan etkileri içeren herhangi bir ifadenin değerini aşağıdaki şekilde parantez içine alın:

($a = 1234 * 3.5) # pipeline gets 4319

Bu nedenle, bu durumda gruplandırma ayraçları gereksiz değildir.

Aşağıdaki örnekte, bir dize sabit değerinde yer alan değişken değiştirme (§ 2.3.5.2) sunuyoruz:

">$($a = -23)<"    # value not written to pipeline, get
><
">$(($a = -23))<"  # pipeline gets >-23<

İlk durumda, parantezler bir alt ifadenin sınırlayıcılarını gruplandırma parantezleri olarak temsil eder ve en üst düzey ifade bir yan efekt operatörü içeriyorsa, ifadenin değeri ardışık düzene yazılmaz. Kuşkusuz, > ve < karakterleri hala yazılmıştır.) Gruplandırma ayracı eklenirse (ikinci durumda gösterildiği gibi) yazma etkindir.

Aşağıdaki örneklerde her biri en üst düzey yan etki işleçleri içerir:

$a = $b = 0      # value not written to pipeline
$a = ($b = 0)    # value not written to pipeline
($a = ($b = 0))  # pipeline gets 0

++$a             # value not written to pipeline
(++$b)           # pipeline gets 1

$a--             # value not written to pipeline
($b--)           # pipeline gets 1

Üst düzey yan etkileri olmayan bir ifade etrafında gruplandırma parantezleri kullanımı, bu ayraçları gereksiz hale getirir. Örneğin;

$a      # pipeline gets 0
($a)    # no side effect, so () redundant

İki yan etkisi olan aşağıdaki örneği göz önünde bulundurun, ikisi de en üst düzeyindedir:

12.6 + ($a = 10 - ++$b) # pipeline gets 21.6.

Sonuç, en üst düzey ifadenin yan etkileri olmadığından, işlem hattına yazılır.

7.1.2 üye erişimi

Söz dizimi:

member-access: Note no whitespace is allowed after primary-expression. 
    primary-expression . member-name
    primary-expression :: member-name

Açıklama:

İşleci . , bir nesneden bir örnek üye veya bir Hashtable öğesinden bir anahtar seçmek için kullanılır. Sol işlenen bir nesne belirlemelidir ve sağ işlenen erişilebilir bir örnek üyesi belirtmelidir.

Sağ işlenen, sol işlenen tarafından belirlenen nesnenin türü içinde erişilebilir bir örnek üye belirler veya sol işlenen bir diziyi alıyorsa, sağ işlenen dizinin her bir öğesi içinde erişilebilir örnek üyelerini belirler.

İşleçten önce . boşluk kullanılmasına izin verilmez.

Bu operatör sola ilişkilendirilebilir.

İşleci :: , belirli bir türden statik üye seçmek için kullanılır. Sol işlenen bir tür belirlemelidir ve sağ işlenen bu tür içinde erişilebilir bir statik üye belirlemelidir.

İşleçten önce :: boşluk kullanılmasına izin verilmez.

Bu operatör sola ilişkilendirilebilir.

Sağ işlenen, sol işlenen tarafından belirlenen nesnenin türü içinde yazılabilir bir konum alıyorsa, tüm ifade yazılabilir bir konum atar.

Örnekler:

$a = 10, 20, 30
$a.Length                    # get instance property

(10, 20, 30).Length

$property = "Length"
$a.$property                 # property name is a variable

$h1 = @{ FirstName = "James"; LastName = "Anderson"; IDNum = 123
}
$h1.FirstName                # designates the key FirstName
$h1.Keys                     # gets the collection of keys

[int]::MinValue              # get static property
[double]::PositiveInfinity   # get static property
$property = "MinValue"
[long]::$property            # property name is a variable

foreach ($t in [byte], [int], [long]) {
    $t::MaxValue             # get static property
}

$a = @{ID = 1 }, @{ID = 2 }, @{ID = 3 }
$a.ID                        # get ID from each element in the array

7.1.3 çağırma ifadeleri

Söz dizimi:

invocation-expression: Note no whitespace is allowed after primary-expression. 
    primary-expression . member-name argument-list
    primary-expression :: member-name argument-list

argument-list:
    ( argument-expression-list~opt~ new-lines~opt~ )

Açıklama:

Bir çağırma ifadesi , birincil ifade tarafından belirlenen yöntemi çağırır. üye-adı veya birincil-ifade::üye adı. Bağımsız değişkendeki parantez, değerleri yöntemine geçirilecek bağımsız değişkenleri belirleyen, muhtemelen boş, virgülle ayrılmış bir ifade listesi içerir. Yöntemi çağrılmadan önce, bağımsız değişkenler değerlendirilir ve § 6 kurallarına göre, yöntemi tarafından beklenen türlerle eşleşecek şekilde dönüştürülür. Birincil ifadenin değerlendirmesi sırası. üye-adı, birincil-ifade::üye-adı ve bağımsız değişkenler belirtilmemiş.

Bu operatör sola ilişkilendirilebilir.

Bir çağırma ifadesinin sonucunun türü bir Yöntem göstergesinin (§ 4.5.24).

Örnekler:

[math]::Sqrt(2.0)            # call method with argument 2.0
[char]::IsUpper("a")         # call method
$b = "abc#$%XYZabc"
$b.ToUpper()                 # call instance method

[math]::Sqrt(2)              # convert 2 to 2.0 and call method
[math]::Sqrt(2D)             # convert 2D to 2.0 and call method
[math]::Sqrt($true)          # convert $true to 1.0 and call method
[math]::Sqrt("20")           # convert "20" to 20 and call method

$a = [math]::Sqrt            # get method descriptor for Sqrt
$a.Invoke(2.0)               # call Sqrt via the descriptor
$a = [math]::("Sq"+"rt")     # get method descriptor for Sqrt
$a.Invoke(2.0)               # call Sqrt via the descriptor
$a = [char]::ToLower         # get method descriptor for ToLower
$a.Invoke("X")               # call ToLower via the descriptor

7.1.4 öğe erişimi

Söz dizimi:

element-access: Note no whitespace is allowed between primary-expression and [.
    primary-expression [ new-lines~opt~ expression new-lines~opt~ ]

Açıklama:

Birincil ifade ve sol köşeli ayraç ( [ ) arasında boşluk olmamalıdır.

dizi 7.1.4.1 alt simge oluşturma

Açıklama:

Diziler, § 9 ' da ayrıntılı olarak ele alınmıştır. İfade 1 boyutlu bir diziyse, bkz. § 7.1.4.5.

Birincil Ifade a 1 boyutlu bir dizi belirlediğinde, işleci [] ifadesi değerine dönüştürüldükten int sonra konumunda A[0 + expression] bulunan öğesini döndürür. Sonuç, alt simge eklenen dizinin öğe türüne sahiptir. İfade negatifse, A[expression] öğesinde bulunan A[A.Length + expression] öğesini belirler.

Birincil ifade 2 boyutlu bir dizi B belirlediğinde, işleci [] , ifadenin (virgülle ayrılmış bir liste olarak belirtilir) int satır ve sütun bileşenleri değerinden sonra konumunda B[0 + row,0 + column] bulunan öğesini döndürür. Sonuç, alt simge eklenen dizinin öğe türüne sahiptir. 1 boyutlu bir dizinin aksine, negatif konumların özel bir anlamı yoktur.

Birincil ifade üç veya daha fazla boyutun dizisini oluştururken, 2 boyutlu diziler için kurallar geçerlidir ve boyut konumları, virgülle ayrılmış bir değerler listesi olarak belirtilir.

Mevcut olmayan bir öğe üzerinde okuma erişimi denendiğinde sonuç olur $null . Mevcut olmayan bir öğeye yazmak bir hatadır.

Çok boyutlu dizi alt simge ifadesinde boyut konumu ifadelerinin değerlendirmesi sırası belirtilmemiş olur. Örneğin, 3 boyutlu bir dizi $a verildiğinde, davranışı $a[$i++,$i,++$i] belirtilmemiş olur.

İfade bir diziyse, bkz. § 7.1.4.5.

Bu işleç, ilgili olarak bıraktır.

Örnekler:

$a = [int[]](10,20,30) # [int[]], Length 3
$a[1] # returns int 20
$a[20] # no such position, returns $null
$a[-1] # returns int 30, i.e., $a[$a.Length-1]
$a[2] = 5 # changes int 30 to int 5
$a[20] = 5 # implementation-defined behavior

$a = New-Object 'double[,]' 3,2
$a[0,0] = 10.5 # changes 0.0 to 10.5
$a[0,0]++ # changes 10.5 to 10.6

$list = ("red",$true,10),20,(1.2, "yes")
$list[2][1] # returns string "yes"

$a = @{ A = 10 },@{ B = $true },@{ C = 123.45 }
$a[1]["B"] # $a[1] is a Hashtable, where B is a key

$a = "red","green"
$a[1][4] # returns string "n" from string in $a[1]

Mevcut olmayan bir öğeye yazma erişimi denenirse IndexOutOfRange özel durumu ortaya çıkar.

7.1.4.2 Dizeye alt simge oluşturma

Açıklama:

Birincil ifade S dizesini belirterek[] karakter olarak ifadeyle belirtilen sıfır tabanlı konumda bulunan karakteri döndürür. İfade , bu dizenin uzunluğuna eşit veya daha büyükse sonuç olur $null. İfade negatifse , S[expression] öğesinde bulunan öğesini olarak ifade eder S[S.Length + expression].

Örnekler:

$s = "Hello"   # string, Length 5, positions 0-4
$c = $s[1]     # returns "e" as a string
$c = $s[20]    # no such position, returns $null
$c = $s[-1]    # returns "o", i.e., $s[$s.Length-1]

7.1.4.3 Karma Tablosu Alt Simge oluşturma

Açıklama:

Birincil-ifade bir Hashtable'ın belirlenerek işleç, [] ifade tarafından belirlenen anahtarlarla ilişkili değerleri döndürür. İfade türü kısıtlanmaz.

İfade tek bir anahtar adı olduğunda sonuç ilişkili değerdir ve böyle bir anahtar olmadığı sürece bu türe sahip olur. Bu durumda sonuç olur $null. anahtar $null olarak kullanılırsa, davranış uygulama tanımlıdır. İfade bir anahtar adları dizisi ise bkz. .7.1.4.5.

İfade bir dizi ise bkz. .7.1.4.5.

Örnekler:

$h1 = @{ FirstName = "James"; LastName = "Anderson"; IDNum = 123 }
$h1['FirstName']     # the value associated with key FirstName
$h1['BirthDate']     # no such key, returns $null

$h1 = @{ 10 = "James"; 20.5 = "Anderson"; $true = 123 }
$h1[10]              # returns value "James" using key 10
$h1[20.5]            # returns value "Anderson" using key 20.5
$h1[$true]           # returns value 123 using key $true

İfade tek bir anahtar adı olduğunda, $null Hashtable'ın alt simgelerini tek değer olarak kullanılırsa, NullArrayIndex özel durumu ortaya çıkar.

7.1.4.4 XML belgesinin alt simgelerini oluşturma

Açıklama:

Birincil-ifade xml türünde bir nesne belirtse , gerekirse ifade dizeye dönüştürülür ve işleç, [] ifade tarafından belirtilen adı içeren ilk alt öğeyi döndürür. İfade türü dize olmalıdır. Sonucun türü uygulama tanımlıdır. Sonuç, ilk alt öğesini geri dönmek için alt simgeli olabilir. İfade tarafından belirtilen adla bir alt öğe yoksa sonuç olur $null. Sonuç yazılabilir bir konum atamaz.

Örnekler:

$x = [xml]@"
<Name>
<FirstName>Mary</FirstName>
<LastName>King</LastName>
</Name>
"@

$x['Name']                # refers to the element Name
$x['Name']['FirstName']   # refers to the element FirstName within Name
$x['FirstName']           # No such child element at the top level, result is `$null`

Sonucun türü veya ' System.Xml.XmlElement dır System.String.

7.1.4.5 Dizi dilimleri oluşturma

Birincil-ifade numaralandırılabilir bir türde bir nesne (geçerli olabilir (geçerli)veya Hashtable olduğunda ve ifade 1 boyutlu bir dizi olduğunda sonuç, ifade öğeleri tarafından belirlenen birincil-ifade öğelerini içeren bir dizi dilimidir (yaklaşık 9,9).

Bir Hashtable söz konusu olduğu durumlarda, dizi dilimi sağlanan anahtarlarla ilişkili değerleri içerir, böyle bir anahtar yoksa (bu durumda, karşılık gelen öğesi olur).$null Herhangi $null bir anahtar adı olarak kullanılırsa, davranış uygulama tanımlıdır.

Örnekler:

$a = [int[]](30,40,50,60,70,80,90)
$a[1,3,5]                 # slice has Length 3, value 40,60,80
++$a[1,3,5][1]            # preincrement 60 in array 40,60,80
$a[,5]                    # slice with Length 1
$a[@()]                   # slice with Length 0
$a[-1..-3]                # slice with Length 0, value 90,80,70
$a = New-Object 'int[,]' 3,2
$a[0,0] = 10; $a[0,1] = 20; $a[1,0] = 30
$a[1,1] = 40; $a[2,0] = 50; $a[2,1] = 60
$a[(0,1),(1,0)]           # slice with Length 2, value 20,30, parens needed
$h1 = @{ FirstName = "James"; LastName = "Anderson"; IDNum = 123 }
$h1['FirstName']          # the value associated with key FirstName
$h1['BirthDate']          # no such key, returns $null
$h1['FirstName','IDNum']  # returns [object[]], Length 2 (James/123)
$h1['FirstName','xxx']    # returns [object[]], Length 2 (James/$null)
$h1[$null,'IDNum']        # returns [object[]], Length 1 (123)

Windows PowerShell : İfade iki veya daha fazla anahtar adı koleksiyonu olduğunda, $null anahtar yoksayılan ve sonuçta elde edilen dizide karşılık gelen bir öğeye sahip olmayan herhangi bir anahtar adı olarak kullanılırsa.

7.1.5 Sonek artırma ve azaltma işleçleri

Söz dizimi:

post-increment-expression:
    primary-expression ++

post-decrement-expression:
    primary-expression dashdash

dashdash:
    --

Açıklama:

Birincil ifade, sayısal türde (°4) veya değerine sahip yazılabilir bir konum atamalı $null. İşleç tarafından belirlenen değer ise $null, işleç değerlendirilmeden önce bu değer int türüne ve sıfır değerine dönüştürülür. Birincil ifade tarafından belirlenen değerin türü , sonuç depolandığı zaman değişebilir. Atama yoluyla tür değişikliği hakkında bir tartışma için bkz. .7.11 .

Sonek işleci tarafından üretilen sonuç ++ , işlenen tarafından belirlenen değerdir. Bu sonuç elde edildikten sonra, işlenen tarafından belirlenen değer uygun türde 1 artırılır. İfadenin sonucu türü, E++ ifadenin sonucuyla E + 1 aynıdır (yaklaşık olarak 7.7).

Sonek işleci tarafından üretilen sonuç -- , işlenen tarafından belirlenen değerdir. Bu sonuç elde edildikten sonra, işlenen tarafından belirlenen değer uygun türün 1'i tarafından geri kazanılır. İfadenin sonucu türü, E-- ifadenin sonucuyla E - 1 aynıdır (yaklaşık olarak 7.7).

Bu işleçler, ilgili olarak bıraktır.

Örnekler:

$i = 0                # $i = 0
$i++                  # $i is incremented by 1
$j = $i--             # $j takes on the value of $i before the decrement

$a = 1,2,3
$b = 9,8,7
$i = 0
$j = 1
$b[$j--] = $a[$i++]   # $b[1] takes on the value of $a[0], then $j is
                      # decremented, $i incremented

$i = 2147483647       # $i holds a value of type int
$i++                  # $i now holds a value of type double because
                      # 2147483648 is too big to fit in type int

[int]$k = 0           # $k is constrained to int
$k = [int]::MaxValue  # $k is set to 2147483647
$k++                  # 2147483648 is too big to fit, imp-def bahavior

$x = $null            # target is unconstrained, $null goes to [int]0
$x++                  # value treated as int, 0->1

7.1.6 $(...) işleci

Söz dizimi:

sub-expression:
    $( new-lines~opt~ statement-list~opt~ new-lines~opt~ )

Açıklama:

deyim-listesi atlanırsa sonuç şu şekildedir$null: . Aksi takdirde deyim-listesi değerlendirilir. Değerlendirmenin bir parçası olarak işlem hattına yazılan tüm nesneler sırasıyla sınırlandırilmemiş 1 boyutlu bir dizide toplanır. Toplanan nesnelerin dizisi boşsa sonuç olur $null. Toplanan nesneler dizisi tek bir öğe içeriyorsa, sonuç o öğedir; Aksi takdirde sonuç, toplanan sonuçların sınırlandırilmemiş 1 boyutlu dizisidir.

Örnekler:

$j = 20
$($i = 10) # pipeline gets nothing
$(($i = 10)) # pipeline gets int 10
$($i = 10; $j) # pipeline gets int 20
$(($i = 10); $j) # pipeline gets [object[]](10,20)
$(($i = 10); ++$j) # pipeline gets int 10
$(($i = 10); (++$j)) # pipeline gets [object[]](10,22)
$($i = 10; ++$j) # pipeline gets nothing
$(2,4,6) # pipeline gets [object[]](2,4,6)

7.1.7 @(...) işleci

Söz dizimi:

array-expression:
    @( new-lines~opt~ statement-list~opt~ new-lines~opt~ )

Açıklama:

deyim-listesi atlanırsa, sonuç sıfır uzunluğunda sınırlandırilmemiş 1 boyutlu bir dizidir. Aksi takdirde deyim-listesi değerlendirilir ve değerlendirmenin bir parçası olarak işlem hattına yazılan tüm nesneler sırasıyla sınırlandırilmemiş 1 boyutlu bir dizide toplanır. Sonuç, sınırlandırilmemiş (muhtemelen boş) 1 boyutlu dizidir.

Örnekler:

$j = 20
@($i = 10)             # 10 not written to pipeline, result is array of 0
@(($i = 10))           # pipeline gets 10, result is array of 1
@($i = 10; $j)         # 10 not written to pipeline, result is array of 1
@(($i = 10); $j)       # pipeline gets 10, result is array of 2
@(($i = 10); ++$j)     # pipeline gets 10, result is array of 1
@(($i = 10); (++$j))   # pipeline gets both values, result is array of 2
@($i = 10; ++$j)       # pipeline gets nothing, result is array of 0

$a = @(2,4,6)          # result is array of 3
@($a)                  # result is the same array of 3
@(@($a))               # result is the same array of 3

7.1.8 Betik bloğu ifadesi

Söz dizimi:

script-block-expression:
    { new-lines~opt~ script-block new-lines~opt~ }

script-block:
    param-block~opt~ statement-terminators~opt~ script-block-body~opt~

script-block-body:
    named-block-list
    statement-list

Açıklama:

param-block , 8.10.9 içinde açıklanmıştır. named-block-list , 8.10.7 içinde açıklanmıştır.

Betik bloğu, tek bir birim olarak kullanılan adlandırlanmamış bir deyim bloğu olur. Betik blokları, tek bir komut gibi bir kod bloğu çağırmak için kullanılabilir veya yürütülen değişkenlere atanabilir.

named-block-list veya statement-list yürütülür ve sonucun türü ve değerleri, bu deyim kümelerinin sonuçlarının türü ve değerleridir.

Bir script-block-ifadesi, type scriptblock 'a (yaklaşık 4.3.7) sahip.

param-block atlanırsa, betik bloğuna geçirilen $args tüm bağımsız değişkenler aracılığıyla kullanılabilir (+8.10.1).

Parametre bağlama sırasında, betik bloğu bir betik bloğu nesnesi olarak veya betik bloğu değerlendirildikten sonra sonuç olarak geçirebilirsiniz. Daha fazla bilgi için bkz. .6.17 .

7.1.9 Karma değişmez değer ifadesi

Söz dizimi:

hash-literal-expression:
    @{ new-lines~opt~ hash-literal-body~opt~ new-lines~opt~ }

hash-literal-body:
    hash-entry
    hash-literal-body statement-terminators hash-entry

hash-entry:
    key-expression = new-lines~opt~ statement

key-expression:
    simple-name
    unary-expression

statement-terminators:
    statement-terminator
    statement-terminators statement-terminator

statement-terminator:
    ;
    new-line-character

Açıklama:

Karma-değişmez-değer-ifadesi, her biri bir anahtar/değer çifti olan sıfır veya daha fazla öğeden bir Hashtable (Yaklaşık 10) oluşturmak için kullanılır.

Anahtarın null türü dışında herhangi bir türü olabilir. İlişkili değerlerin null türü de dahil olmak üzere herhangi bir türü olabilir ve bu değerlerin her biri de dahil olmak üzere istenen değerin adı olan herhangi bir ifade olabilir $null.

Anahtar/değer çiftlerinin sıraları önemli değildir.

Örnekler:

$h1 = @{ FirstName = "James"; LastName = "Anderson"; IDNum = 123 }
$last = "Anderson"; $IDNum = 120
$h2 = @{ FirstName = "James"; LastName = $last; IDNum = $IDNum + 3 }
$h3 = @{ }
$h4 = @{ 10 = "James"; 20.5 = "Anderson"; $true = 123 }

her biri üç anahtar/değer çifti $h1 $h2içeren iki Hashtable ve boş olan üçüncü $h3bir Hashtable oluşturur. Hashtable $h4 ' da çeşitli türlerde anahtarlar vardır.

7.1.10 Tür değişmez ifade

Söz dizimi:

type-literal:
    [ type-spec ]

type-spec:
    array-type-name new-lines~opt~ dimension~opt~ ]
    generic-type-name new-lines~opt~ generic-type-arguments ]
    type-name

dimension:
    ,
    dimension ,

generic-type-arguments:
    type-spec new-lines~opt~
    generic-type-arguments , new-lines~opt~ type-spec

array-type-name:
    type-name [

generic-type-name:
    type-name [

Açıklama:

Tür sabiti, bir uygulamada belirtilmeyen bazı temel türler tarafından temsil eder. Sonuç olarak, tür adı temel türü için bir eş anlamlıdır.

Tür değişmezleri bir dizi bağlamda kullanılır:

• Açık dönüştürme belirtme (İsk 6, Varsayılan 7.2.9)
• Türü kısıtlanmış dizi oluşturma (yaklaşık 9.4)
• Bir nesnenin statik üyelerine erişme (yaklaşık 7.1.2)
• Değişkende (yaklaşık 5.3) veya işlev parametresinde tür kısıtlaması belirtme (yaklaşık 8.10.2)

Örnekler:

Tür değişmez değişmezlerinin örnekleri , [int]ve [object[]'tir [int[,,]]. Dizeleri tutmak için özelleştirilmiş genel bir yığın türü (yaklaşık 4,4) [Stack[string]]``int olarak yazılmış ve ilişkili dize değerlerine sahip anahtarları tutmak için özelleştirilmiş genel bir sözlük türü olarak yazılmış olabilir[Dictionary[int,string]].

Bir tür-değişmez-değişmez-türü : System.Type. Yukarıda önerilen tür için tam Stack[string] ad şu şekildedir System.Collections.Generic.Stack[int]: . Yukarıda önerilen tür için tam Dictionary[int,string] ad şu şekildedir System.Collections.Generic.Dictionary[int,string]: .

7.2 Birli işleçler

Söz dizimi:

unary-expression:
    primary-expression
    expression-with-unary-operator

expression-with-unary-operator:
    , new-lines~opt~ unary-expression
    -not new-lines~opt~ unary-expression
    ! new-lines~opt~ unary-expression
    -bnot new-lines~opt~ unary-expression
    + new-lines~opt~ unary-expression
    dash new-lines~opt~ unary-expression
    pre-increment-expression
    pre-decrement-expression
    cast-expression
    -split new-lines~opt~ unary-expression
    -join new-lines~opt~ unary-expression

dash:*
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

pre-increment-expression:
    ++ new-lines~opt~ unary-expression

pre-decrement-expression:
    dashdash new-lines~opt~ unary-expression

cast-expression:
    type-literal unary-expression

dashdash:
    dash dash

7.2.1 Birli virgül işleci

Açıklama:

Bu işleç, türü ve değeri birli ifadeye ait olan bir öğeye sahip, sınırlandırlanmamış bir 1 boyutlu dizi oluşturur.

Bu işleç doğru şekilde bir iosaslıdır.

Örnekler:

$a = ,10         # create an unconstrained array of 1 element, $a[0],
                 # which has type int

$a = ,(10,"red") # create an unconstrained array of 1 element,
$a[0],
                 # which is an unconstrained array of 2 elements,
                 # $a[0][0] an int, and $a[0][1] a string

$a = ,,10        # create an unconstrained array of 1 element, which is
                 # an unconstrained array of 1 element, which is an int
                 # $a[0][0] is the int. Contrast this with @(@(10))

7.2.2 Mantıksal NOT

Açıklama:

-not işleci, birli-ifade tarafından belirlenen değeri gerekirse bool (gie 6.2) türüne dönüştürür ve bu türün bir sonucu üretir. Birli ifadenin değeri True ise sonuç False olur ve bunun tersi de geçerlidir. işleci ! , -not için alternatif bir yazımdır.

Bu işleç doğru şekilde bir iosaslıdır.

Örnekler:

-not $true         # False
-not -not $false   # False
-not 0             # True
-not 1.23          # False
!"xyz"             # False

7.2.3 Bitwise NOT

Açıklama:

-bnot işleci, birli ifade tarafından belirlenen değeri gerekirse tamsayı türüne (yaklaşık 6,4) dönüştürür. Dönüştürülen değer int türünde temsil edildiyse sonuç türü bu olur. Yoksa, dönüştürülen değer uzun bir türle temsil edildiyse sonuç türü bu olur. Aksi takdirde ifade kötü düsk olur. Sonuçta elde edilen değer, dönüştürülen değerin bire tamamlayıcısı olur.

Bu işleç doğru şekilde bir iosaslıdır.

Örnekler:

-bnot $true         # int with value 0xFFFFFFFE
-bnot 10            # int with value 0xFFFFFFF5
-bnot 2147483648.1  # long with value 0xFFFFFFFF7FFFFFFF
-bnot $null         # int with value 0xFFFFFFFF
-bnot "0xabc"       # int with value 0xFFFFF543

7.2.4 Birli artı

Açıklama:

+birli-ifade formunun ifadesi , 0 + unary-expression olarak yazılmış gibi kabul edilir (+7.7). Tamsayı değişmez değeri 0 türündedir int.

Bu işleç doğru şekilde bir iosaslıdır.

Örnekler:

+123L         # type long, value 123
+0.12340D     # type decimal, value 0.12340
+"0xabc"      # type int, value 2748

7.2.5 Birli eksi

Açıklama:

-birli-ifadesi formunun ifadesi olarak yazılmış 0 - unary-expression gibi kabul edilir (yaklaşık 7.7). Tamsayı değişmez değeri 0 türündedir int.

Bu işleç doğru şekilde bir iosaslıdır.

Örnekler:

-$true # type int, value -1 -123L # type long, value -123 -0,12340D # type decimal, value -0,12340

7.2.6 Ön ek artırma ve azaltma işleçleri

Açıklama:

Birli ifade, sayısal türde (°4) veya değerine sahip yazılabilir bir konum atamalı$null. Birli-ifadesi tarafından belirlenen değer $nullise, birli-ifadenin değeri, işleç değerlendirilmeden önce int türüne ve sıfır değerine dönüştürülür.

Not

Birli ifade tarafından belirlenen değerin türü , sonuç depolandığı zaman değişebilir. Atama yoluyla tür değişikliği hakkında bir tartışma için bkz. .7.11 .

Ön ek ++ işleci için, birli ifadenin değeri uygun türde 1 artırılır. Sonuç, artırma gerçekleştikten sonra yeni değerdir. İfade ile ++E eşdeğerdir E += 1 (yaklaşık olarak 7.11.2).

Ön ek -- işleci için, birli ifadenin değeri uygun türden 1'i tarafından geri aşar. Sonuç, geri ödeme gerçekleştikten sonra yeni değerdir. İfade ile --E eşdeğerdir E -= 1 (yaklaşık olarak 7.11.2).

Bu işleçler doğru şekilde bir şekilde irdeler.

Örnekler:

$i = 0                # $i = 0
$++i                  # $i is incremented by 1
$j = --$i             # $i is decremented then $j takes on the value of $i

$a = 1,2,3
$b = 9,8,7
$i = 0;
$j = 1
$b[--$j] = $a[++$i]   # $j is # decremented, $i incremented, then $b[0]
                      # takes on the value of $a[1]

$i = 2147483647       # $i holds a value of type int
++$i                  # $i now holds a value of type double because
                      # 2147483648 is too big to fit in type int

[int]$k = 0           # $k is constrained to int
$k = [int]::MinValue  # $k is set to -2147483648
$--k                  # -2147483649 is too small to fit, imp-def behavior

$x = $null            # target is unconstrained, $null goes to [int]0
$--x                  # value treated as int, 0->-1

7.2.7 Birli -join işleci

Açıklama:

Birli işleç -join , birli ifade tarafından belirlenen bir veya daha fazla nesne değerinin bir sonucu olan bir dize oluşturur. (Ayırıcı, bu işlecin ikili sürümü kullanılarak eklenebilir (yaklaşık olarak 7.8.4.4).)

birli-ifade skaler değer veya koleksiyon olabilir.

Örnekler:

-join (10, 20, 30)             # result is "102030"
-join (123, $false, 19.34e17)  # result is "123False1.934E+18"
-join 12345                    # result is "12345"
-join $null                    # result is ""

7.2.8 Birli bölme işleci

Açıklama:

Birli işleç-split, birli ifade tarafından belirlenen bir veya daha fazla dizeyi bölerek alt parçalarını kısıtlanmış 1 boyutlu bir dize dizisine döndürür. Bitişik boşluk karakterleri grubunu ardışık altpart'lar arasındaki sınırlayıcı olarak ele almaktadır. (Açık bir sınırlayıcı dizesi, bu işlecin ikili sürümü kullanılarak belirtilebilir (yaklaşık olarak 7.8.4.5).) Bu işleçte iki çeşitleme (yaklaşık 7,8) vardır.

Sınırlayıcı metni, elde edilen dizelere dahil değildir. Giriş dizesinde baştaki ve sonda boşluk yok sayılır. Boş veya boşluk içeren bir giriş dizesi yalnızca boş olan 1 dize dizisiyle sonuç verir.

birli-ifade bir skaler değer veya dize dizisi olarak belirlene bir değere sahip olabilir.

Örnekler:

-split " red\`tblue\`ngreen " # 3 strings: "red", "blue", "green"
-split ("yes no", "up down") # 4 strings: "yes", "no", "up", "down"
-split " " # 1 (empty) string

7.2.9 Cast işleci

Açıklama:

Bu işleç, birli ifade tarafından belirlenen değeri açıkça tür-değişmez değeri tarafından belirlenen türe dönüştürür .().Bu işleç, birli-ifade tarafından belirlenen değeri açıkça tür-değişmez-değer tarafından belirlenen türe dönüştürür. tür-değişmez değeri void dışında ise, sonucun türü adlandırılmış türdür ve değer dönüştürmeden sonra gelen değerdir. Tür-değişmez-değişmez-sayı geçersizse, işlem hattına hiçbir nesne yazılır ve sonuç yoktur.

Herhangi bir türde bir ifade aynı türe tür ve değer, birli ifadenin türü ve değeridir.

Bu işleç doğru şekilde bir iosaslıdır.

Örnekler:

[bool]-10        # a bool with value True
[int]-10.70D     # a decimal with value -10
[int]10.7        # an int with value 11
[long]"+2.3e+3"  # a long with value 2300
[char[]]"Hello"  # an array of 5 char with values H, e, l, l, and o.

7.3 İkili virgül işleci

Söz dizimi:

array-literal-expression:
    unary-expression
    unary-expression , new-lines~opt~ array-literal-expression

Açıklama:

İkili virgül işleci, öğeleri işlenenleri tarafından belirlenen değerler olan 1 boyutlu bir dizi oluşturur. Dizi sınırlandırlanmamış türe sahip.

Örnekler:

2,4,6                    # Length 3; values 2,4,6
(2,4),6                  # Length 2; values [object[]],int
(2,4,6),12,(2..4)        # Length 3; [object[]],int,[object[]]
2,4,6,"red",$null,$true  # Length 6

Parantezleri belirli ikili virgül ifadelerine gruplamanın ek olması, varsayılan önceliği belgelemektedir; bunun yerine sonucu değiştirir.

7.4 Aralık işleci

Söz dizimi:

range-expression:
array-literal-expression
range-expression *..* new-lines~opt~
array-literal-expression

Açıklama:

Aralık-ifadesi, öğeleri aralık sınırları tarafından belirtilen int dizisinin değerleri olan sınırlandırlanmamış 1 boyutlu bir dizi oluşturur. Gerekirse işlenenler tarafından belirlenen değerler int'e dönüştürülür (yaklaşık 6.4). Dönüştürmeden sonra düşük değeri belirten işlenen alt sınır, işlenen ise dönüştürmeden sonra daha yüksek değeri belirten işlenen üst sınırdır. Her iki sınır da aynı olabilir, bu durumda sonuçta elde edilen dizi 1 uzunluğuna sahip olur. Sol işlenen alt sınırın tasarımını yapıyorsa, sıra artan düzendedir. Sol işlenen üst sınırın tasarımını yapıyorsa, sıra azalan sıradadır.

Kavramsal olarak, bu işleç karşılık gelen ikili virgül işleç dizisi için bir kısayolu. Örneğin, aralığı 5..8 kullanılarak da üret olabilir 5,6,7,8. Ancak, bir dizi olmadan artan veya azalan bir dizi gerekli olursa, uygulama gerçek bir dizi oluşturmaktan kaçın olabilir. Örneğin, içinde foreach ($i in 1..5) { ... }hiçbir dizi oluşturulmaz.

Bir dizi dilimi belirtmek için bir aralık-ifadesi kullanılabilir (yaklaşık 9,9).

Örnekler:

1..10        # ascending range 1..10
-500..-495   # descending range -500..-495
16..16       # sequence of 1

$x = 1.5
$x..5.40D    # ascending range 2..5

$true..3     # ascending range 1..3
-2..$null    # ascending range -2..0
"0xf".."0xa" # descending range 15..10

7.5 Biçim işleci

Söz dizimi:

format-expression:
    range-expression
    format-expression format-operator new-lines~opt~ range-expression

format-operator:
    dash f

dash:
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

Açıklama:

Biçim-ifadesi, range-expression tarafından belirlenen bir veya daha fazla değeri biçim-ifadesi tarafından belirlenen bir biçim belirtimi dizesine göre biçimlendirer. Range-expression tarafından belirlenen değerlerin konumu sıfırdan başlayarak ve sözcük sırasıyla artırarak numaralanır. Sonuç türüne sahip string.

Biçim belirtimi dizesi, her biri aşağıdaki biçime sahip sıfır veya daha fazla biçim belirtimi içerebilir:

{N [ ,M ][ : FormatString ]}

N bir (gerekli) aralık-ifadesi değer konumunu temsil eder, M (isteğe bağlı) en düşük görüntüleme genişliğini temsil eder ve FormatString (isteğe bağlı) biçimi gösterir. Biçimlendirilmiş bir değerin genişliği belirtilen genişliği aşarsa genişlik uygun şekilde artırılır. FormatString'de konumlara başvurul olmayan değerler, herhangi bir yan etki için değerlendirildikten sonra yoksayılır. N mevcut olmayan bir konuma başvurursa, davranış uygulama tanımlıdır. türü ve void $null değeri boş dizeler olarak biçimlendirildi. Diziler, alt ifade için olarak biçimlendirildi (yaklaşık olarak 7.1.6). Biçim sınırlayıcı olarak yorumlanmadan "{" ve "}" karakterlerini biçim belirtimlerine dahil etmek için bunları sırasıyla "{{" ve "}}" olarak yazın.

Biçim belirtimlerinin tam tanımı için Ecma Teknik Raporu System.IFormattable TR/84'te türe bakın.

Örnekler:

`$i` = 10; $j = 12
"{2} <= {0} + {1}\`n" -f $i,$j,($i+$j)  # 22 <= 10 + 12
">{0,3}<" -f 5                          # > 5<
">{0,-3}<" -f 5                         # >5 <
">{0,3:000}<" -f 5                      # >005<
">{0,5:0.00}<" -f 5.0                   # > 5.00<
">{0:C}<" -f 1234567.888                # >$1,234,567.89<
">{0:C}<" -f -1234.56                   # >($1,234.56)<
">{0,12:e2}<" -f 123.456e2              # > 1.23e+004<
">{0,-12:p}<" -f -0.252                 # >-25.20 % <
$format = ">{0:x8}<"
$format -f 123455                       # >0001e23f<

Bir biçim belirtimsinde , N mevcut olmayan bir konuma başvuruyorsa bir FormatError yükseltildi.

7.6 Çarpma işleçleri

Söz dizimi:

multiplicative-expression:
    format-expression
    multiplicative-expression * new-lines~opt~ format-expression
    multiplicative-expression / new-lines~opt~ format-expression
    multiplicative-expression % new-lines~opt~ format-expression

7.6.1 Çarpma

Açıklama:

Çarpma işlecinin * sonucu, normal aritmetik dönüştürmeler (satır 6.15) uygulandıktan sonra iki işlenen tarafından belirlenen değerlerin çarpımıdır.

Bu işleç, ilgili olarak bıraktır.

Örnekler:

12 * -10L      # long result -120
-10.300D * 12  # decimal result -123.600
10.6 * 12      # double result 127.2
12 * "0xabc"   # int result 32976

7.6.2 Dize çoğaltma

Açıklama:

Sol işlenen bir * dizeyi oluşturduğunda ikili işleç, sol işlenen tarafından belirlenen dizeyi içeren yeni bir dize oluşturur ve sağ işlenenin değeri tarafından belirlenen sayı tamsayı türüne dönüştürülecek şekilde çoğaltılır (yaklaşık 6,4).

Bu işleç, ilgili olarak bıraktır.

Örnekler:

"red" * "3"       # string replicated 3 times
"red" * 4         # string replicated 4 times
"red" * 0         # results in an empty string
"red" * 2.3450D   # string replicated twice
"red" * 2.7       # string replicated 3 times

7.6.3 Dizi çoğaltması

Açıklama:

Sol işlenen bir * diziyi oluşturduğunda ikili işleç, sol işlenen tarafından belirlenen değeri içeren yeni bir sınırlandırılmış 1 boyutlu dizi oluşturur ve sağ işlenenin değeri tarafından belirlenen sayı tamsayı türüne dönüştürülecek şekilde çoğaltılır (yaklaşık 6,4). Sıfır çoğaltma sayısı, uzunluğu 1 olan bir diziyle sonuçlanır. Sol işlenen çok boyutlu bir diziyi tasarlarsa kullanılmadan önce düz (yaklaşık 9,12) olur.

Bu işleç, ilgili olarak bıraktır.

Örnekler:

$a = [int[]](10,20)              # [int[]], Length 2*1
$a * "3"                         # [object[]], Length 2*3
$a * 4                           # [object[]], Length 2*4
$a * 0                           # [object[]], Length 2*0
$a * 2.3450D                     # [object[]], Length 2*2
$a * 2.7                         # [object[]], Length 2*3
(New-Object 'float[,]' 2,3) * 2  # [object[]], Length 2*2

7.6.4 Bölüm

Açıklama:

Bölme işlecinin / sonucu, normal aritmetik dönüştürmeler (yaklaşık 6,15) uygulandıktan sonra sol işlenen tarafından belirlenen değere bölündükçe bölüm işlecinin sonucu olur.

Tamsayı veya ondalık bölmeyi sıfıra bölme girişimi yapılırsa, uygulama tanımlı sonlandırma hatası ortaya çıkar.

Bu işleç, ilgili olarak bıraktır.

Örnekler:

10/-10      # int result -1
12/-10      # double result -1.2
12/-10D     # decimal result 1.2
12/10.6     # double result 1.13207547169811
12/"0xabc"  # double result 0.00436681222707424

Tamsayı veya ondalık bölmeyi sıfıra bölme girişimi yapılırsa RuntimeException özel durumu ortaya çıkar.

7.6.5 Kalan

Açıklama:

Normal aritmetik % dönüştürmeler (yaklaşık 6,15) uygulandıktan sonra sol işlenen tarafından belirlenen değer, sağ işlenen tarafından belirlenen değere bölündükçe, kalan işlecin sonucu kalan işlecinin sonucu olur.

Tamsayı veya ondalık bölmeyi sıfıra bölme girişimi yapılırsa, uygulama tanımlı sonlandırma hatası ortaya çıkar.

Örnekler:

10 % 3          # int result 1
10.0 % 0.3      # double result 0.1
10.00D % "0x4"  # decimal result 2.00

Tamsayı veya ondalık bölmeyi sıfıra bölme girişimi yapılırsa RuntimeException özel durumu ortaya çıkar.

7.7 Eklenebilir işleçler

Söz dizimi:

additive-expression:
    multiplicative-expression
    additive-expression + new-lines~opt~ multiplicative-expression
    additive-expression dash new-lines~opt~ multiplicative-expression

7.7.1 Ekleme

Açıklama:

Toplama işlecinin + sonucu, normal aritmetik dönüştürmeler (yaklaşık 6,15) uygulandıktan sonra iki işlenen tarafından belirlenen değerlerin toplamıdır.

Bu işleç, ilgili olarak bıraktır.

Örnekler:

12 + -10L       # long result 2
-10.300D + 12   # decimal result 1.700
10.6 + 12       # double result 22.6
12 + "0xabc"    # int result 2760

7.7.2 Dize concatentaion

Açıklama:

Sol işlenen bir + dizeyi belirledikçe ikili işleç, sol işlenen tarafından belirlenen değeri içeren yeni bir dize oluşturur ve ardından hemen ardından sağ işlenen tarafından belirtilen değerlerin tür dizesine dönüştürülmesiyle (İçe 6.8).

Bu işleç, ilgili olarak bıraktır.

Örnekler:

"red" + "blue"      # "redblue"
"red" + "123"       # "red123"
"red" + 123         # "red123"
"red" + 123.456e+5  # "red12345600"
"red" + (20,30,40)  # "red20 30 40"

7.7.3 Dizi birle

Açıklama:

Sol işlenen bir + diziyi oluşturduğunda ikili işleç, sol işlenen tarafından belirlenen öğeleri ve ardından sağ işlenen tarafından belirlenen değerlerin hemen ardından gelen öğeleri içeren yeni ve sınırlandırilmemiş 1 boyutlu bir dizi oluşturur. her iki işlenende de çok boyutlu diziler kullanılmadan önce düz (yaklaşık 9,12) olur.

Bu işleç, ilgili olarak bıraktır.

Örnekler:

$a = [int[]](10,20)               # [int[]], Length 2
$a + "red"                        # [object[]], Length 3
$a + 12.5,$true                   # [object[]], Length 4
$a + (New-Object 'float[,]' 2,3)  # [object[]], Length 8
(New-Object 'float[,]' 2,3) + $a  # [object[]], Length 8

7.7.4 Karma tablosu birleştirmek

Açıklama:

Her iki işlenen de Hashtable'ları belirledikçe ikili + işleç, sol işlenen tarafından belirlenen öğeleri içeren yeni bir Hashtable oluşturur ve hemen ardından sağ işlenen tarafından belirlenen öğelere sahiptir.

Hashtable'lar aynı anahtarı içeriyorsa, uygulama tanımlı sonlandırma hatası ortaya çıkar.

Bu işleç, ilgili olarak bıraktır.

Örnekler:

$h1 = @{ FirstName = "James"; LastName = "Anderson" }
$h2 = @{ Dept = "Personnel" }
$h3 = $h1 + $h2      # new Hashtable, Count = 3

Hashtable'lar aynı anahtarı içeriyorsa BadOperatorArgument türünde bir özel durum ortaya çıkar.

7.7.5 Çıkarma

Açıklama:

Çıkarma işlecinin - sonucu, normal aritmetik dönüştürmeler (yaklaşık 6,15) uygulandıktan sonra sağ işlenen tarafından belirlenen değerden çıkarılmış olan değer arasındaki farktır.

Bu işleç, ilgili olarak bıraktır.

Örnekler:

12 - -10L      # long result 2c
-10.300D - 12  # decimal result -22.300
10.6 - 12      # double result -1.4
12 - "0xabc"   # int result -2736

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

Söz dizimi:

comparison-operator: one of
    dash as           dash ccontains     dash ceq
    dash cge          dash cgt           dash cle
    dash clike        dash clt           dash cmatch
    dash cne          dash cnotcontains  dash cnotlike
    dash cnotmatch    dash contains      dash creplace
    dash csplit       dash eq            dash ge
    dash gt           dash icontains     dash ieq
    dash ige          dash igt           dash ile
    dash ilike        dash ilt           dash imatch
    dash in           dash ine           dash inotcontains
    dash inotlike     dash inotmatch     dash ireplace
    dash is           dash isnot         dash isplit
    dash join         dash le            dash like
    dash lt           dash match         dash ne
    dash notcontains  dash notin         dash notlike
    dash notmatch     dash replace       dash shl
    dash shr          dash split

dash:
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

Açıklama:

Karşılaştırma yapılmadan önce, sol işlenen tarafından belirlenen değerin türü, gerekirse sağ işlenen tarafından belirlenen değerin nasıl dönüştürüleceklerini belirler (yaklaşık 6).

Bazı karşılaştırma işleçleri (burada -op olarak yazılır) biri büyük/harfe duyarlı (-cop) ve biri de (-iop) olmayan iki varyanta sahip olur. -op sürümü -iop ile eşdeğerdir. Büyük/küçük harf duyarlılığı yalnızca dize türü değerlerinin karşılaştırmaları ile anlamlıdır. Dize olmayan karşılaştırma bağlamlarında iki değişken aynı şekilde davranır.

Bu işleçler, ilgili olarak bıraktır.

7.8.1 Eşitlik ve ilişkisel işleçler

Açıklama:

İki eşitlik işleci vardır: eşitlik (-eq) ve eşitsizlik (-ne); ve dört ilişkisel işleç : küçük (), küçük veya eşittir (-lt``-le), büyüktür (-gt) ve büyüktür-büyüktür veya eşittir ().-ge Bunların her biri iki varyanta (yaklaşık 7,8) sahip.

İki dizenin eşit karşılaştırması için aynı uzunlukta ve içerikte ve uygunsa büyük/büyük harfe sahip olması gerekir.

Sol işlenen tarafından belirlenen değer bir koleksiyon yoksa, sonuç türüne sahiptir bool. Aksi takdirde sonuç, doğru işlenen tarafından belirlenen değerle karşılaştırıldığında True testini içeren koleksiyonun öğelerini içeren boş ve sınırlandırilmemiş 1 boyutlu bir dizi olur.

Örnekler:

10 -eq "010"           # True, int comparison
"010" -eq 10           # False, string comparison
"RED" -eq "Red"        # True, case-insensitive comparison
"RED" -ceq "Red"       # False, case-sensitive comparison
"ab" -lt "abc"         # True

10,20,30,20,10 -ne 20  # 10,30,10, Length 3
10,20,30,20,10 -eq 40  # Length 0
10,20,30,20,10 -ne 40  # 10,20,30,20,10, Length 5
10,20,30,20,10 -gt 25  # 30, Length 1
0,1,30 -ne $true       # 0,30, Length 2
0,"00" -eq "0"         # 0 (int), Length 1

7.8.2 Containment işleçleri

Açıklama:

Dört içerme işleci vardır: contains (-contains), does-not-contain (‑notcontains), in (-in) ve not-in (-notin). Bunların her biri iki varyanta (yaklaşık 7,8) sahip.

Containment işleçleri, bir değerin dizi öğelerinde en az bir kez olup olmadığını belirten bool türünde bir sonuç döndürür. ‑notcontainsve -contains ile, değer sağ işlenen tarafından, dizi ise sol işlenen tarafından belirlenmiştir. -in ve -notinile işlenenler tersine çevrilir. Değer, sol işlenen tarafından, dizi ise sağ işlenen tarafından belirlenmiştir.

Bu işleçlerin amaçları doğrultusunda, dizi işleneni bir skaler değere sahipse, skaler değer bir öğe dizisi olarak kabul edilir.

Örnekler:

10,20,30,20,10 -contains 20     # True
10,20,30,20,10 -contains 42.9   # False
10,20,30 -contains "10"         # True
"010",20,30 -contains 10        # False
10,20,30,20,10 -notcontains 15  # True
"Red",20,30 -ccontains "RED"    # False

7.8.3 Tür testi ve dönüştürme işleçleri

Açıklama:

Tür işleci -is , sol işlenen tarafından belirlenen değerin türe sahip olup olmadığını veya sağ işlenen tarafından belirlenen türe sahip bir türden türetilen olup olmadığını sınır. Sağ işlenen bir tür veya türe dönüştürülecek bir değer (bir türü adlandıran dize gibi) ataması gerekir. Sonucun türü şu şekildedir bool: . tür işleci -isnot , karşılık gelen formun mantıksal olumsuzlama döndürür -is .

Tür işleci -as , sol işlenen tarafından belirlenen değeri sağ işlenen tarafından belirlenen türe dönüştürmeye çalışır. Sağ işlenen bir tür veya türe dönüştürülecek bir değer (bir türü adlandıran dize gibi) ataması gerekir. Dönüştürme başarısız olursa döndürülür $null ; aksi takdirde, dönüştürülen değer döndürülür ve bu sonucun dönüş türü, dönüştürülen değerin çalışma zamanı t değeridir.

Örnekler:

$a = 10            # value 10 has type int
$a -is [int]       # True

$t = [int]
$a -isnot $t       # False
$a -is "int"       # True
$a -isnot [double] # True

$x = [int[]](10,20)
$x -is [int[]]     # True

$a = "abcd"        # string is derived from object
$a -is [object]    # True

$x = [double]
foreach ($t in [int],$x,[decimal],"string") {
    $b = (10.60D -as $t) * 2  # results in int 22, double 21.2
}                             # decimal 21.20, and string "10.6010.60"

7.8.4 Desen eşleştirme ve metin işleme işleçleri

7.8.4.1 -like ve -notlike işleçleri

Açıklama:

Sol işlenen bir koleksiyon tasarlamazsa, sonuç türüne sahiptir bool. Aksi takdirde sonuç, doğru işlenen tarafından belirlenen değerle karşılaştırıldığında True testini içeren koleksiyonun öğelerini içeren boş ve sınırlandırilmemiş 1 boyutlu bir dizi olur. Sağ işlenen, joker karakter ifadeleri içeren bir dize (°3.15) atlar. Bu işleçler iki varyanta (yaklaşık 7,8) sahip olur.

Örnekler:

"Hello" -like "h*"                   # True, starts with h
"Hello" -clike "h*"                  # False, does not start with lowercase h
"Hello" -like "*l*"                  # True, has an l in it somewhere
"Hello" -like "??l"                  # False, no length match

"-abc" -like "[-xz]*"                # True, - is not a range separator
"#$%\^&" -notlike "*[A-Za-z]"        # True, does not end with alphabetic character
"He" -like "h[aeiou]?*"              # False, need at least 3 characters
"When" -like "*[?]"                  # False, ? is not a wildcard character
"When?" -like "*[?]"                 # True, ? is not a wildcard character

"abc","abbcde","abcgh" -like "abc*"  # object[2], values
"abc" and "abcgh"

7.8.4.2 -match ve -notmatch işleçleri

Açıklama:

Sol işlenen bir koleksiyon tasarlamazsa, bool $truesonuç türüne sahiptir ve bu sonuç ise Hashtable'ın $matches öğeleri, sağ işlenen tarafından belirlenen değerle eşan (veya eşleşmez) dizelere ayarlanır. Aksi takdirde sonuç, doğru işlenen tarafından belirlenen değerle karşılaştırıldığında True $matches testini içeren koleksiyonun öğelerini içeren, sınırlandırilmemiş 1 boyutlu bir dizi olabilir ve ayarlanmamıştır. Sağ işlenen, normal ifadeler (°3.16) içeren bir dizeyi, bu durumda desen olarak adlandırılır. Bu işleçler iki varyanta (yaklaşık 7,8) sahip olur.

Bu işleçler alt tikleri (yaklaşık 7.8.4.6) destekler.

Örnekler:

"Hello" -match ".l"                    # True, $matches key/value is 0/"el"
"Hello" -match '\^h.*o$'               # True, $matches key/value is
0/"Hello"
"Hello" -cmatch '\^h.*o$'              # False, $matches not set
"abc\^ef" -match ".\\\^e"              # True, $matches key/value is 0/"c\^e"

"abc" -notmatch "[A-Za-z]"             # False
"abc" -match "[\^A-Za-z]"              # False
"He" -match "h[aeiou]."                # False, need at least 3 characters
"abc","abbcde","abcgh" -match "abc.*"  # Length is 2, values "abc", "abcgh"

7.8.4.3 -replace işleci

Açıklama:

işleci -replace , sağ işlenen tarafından belirlenen değerleri kullanarak sol işlenen tarafından belirlenen bir veya daha fazla dizede metin değişimine izin verir. Bu işleçte iki çeşitleme (yaklaşık 7,8) vardır. Sağ işlenen aşağıdaki biçimlerden birini içerir:

• Yer alan ve normal ifadeler (yaklaşık 3.16) içeren dize. Bu durumda, değiştirme dizesi örtülü olarak "" olur.
• Yer alan dizeyi içeren 2 nesneden bir dizi, ardından değiştirme dizesi.

Sol işlenen bir dizeyi tasarlarsa sonuç tür dizesine sahiptir. Sol işlenen, 1 boyutlu bir dize dizisi tasarlarsa sonuç, uzunluğu sol işlenenin dizisiyle aynı olan ve değiştirme tamamlandıktan sonra giriş dizelerini içeren sınırlandırlanmamış 1 boyutlu bir dizidir.

Bu işleç alt tikleri (yaklaşık 7.8.4.6) destekler.

Örnekler:

"Analogous","an apple" -replace "a","*"      # "*n*logous","*n *pple"
"Analogous" -creplace "[aeiou]","?"          # "An?l?g??s"
"Analogous","an apple" -replace '\^a',"%%A"  # "%%Analogous","%%An apple"
"Analogous" -replace "[aeiou]",'$&$&'        # "AAnaaloogoouus"

7.8.4.4 İkili -join işleci

Açıklama:

İkili işleç -join , gerekirse, dizeye dönüştürüldikten sonra sol işlenen tarafından belirlenen bir veya daha fazla nesne değerinin bir sonucu olan bir dize oluşturur .6.7. Sağ işlenen tarafından belirlenen dize, sonuçta elde edilen dizede (muhtemelen boş) değerleri ayırmak için kullanılır.

Sol işlenen bir skaler değer veya koleksiyon olabilir.

Örnekler:

(10, 20, 30) -join "\|"    # result is "10\|20\|30"
12345 -join ","            # result is "12345", no separator needed
($null,$null) -join "<->"  # result is "<->", two zero-length values

7.8.4.5 İkili bölme işleci

Açıklama:

İkili işleç -split , sol işlenen tarafından belirlenen bir veya daha fazla dizeyi bölerek alt parçalarını kısıtlanmış 1 boyutlu bir dize dizisinde döndürür. Bu işleçte iki çeşitleme (yaklaşık 7,8) vardır. Sol işlenen bir skaler değer veya dize dizisi tasarlar. Sağ işlenen aşağıdaki biçimlerden birini içerir:

• Sınırlayıcı dize
• Sınırlayıcı dize içeren ve ardından sayısal bölme sayısı gelen 2 nesne dizisi
• Sınırlayıcı dizesi, sayısal bölme sayısı ve seçenekler dizesi içeren 3 nesne dizisi
• Betik bloğu
• Betik bloğu ve ardından sayısal bölme sayısı içeren 2 nesne dizisi

Sınırlayıcı dizesi normal ifadeler (yaklaşık 3.16) içerebilir. Giriş dizeleriyle alt parça bulmak için kullanılır. Sınırlayıcı, elde edilen dizelere dahil değildir. Sol işlenen boş bir dize tasarlarsa, bu boş bir dize öğesiyle sonuç verir. Sınırlayıcı dizesi boş bir dize ise, giriş dizelerinin her karakter konumunda bulunur.

Varsayılan olarak, giriş dizelerinin tüm alt parçaları, sonucun içine ayrı öğeler olarak yerleştirilir; ancak, bölme sayısı bu davranışı değiştirmek için kullanılabilir. Bu sayı negatif, sıfır veya bir giriş dizesinde alt parça sayısına eşit veya daha büyükse, her alt parça ayrı bir öğeye gider. Bu sayı, giriş dizesinde alt parça sayısından küçükse, sonuçta ilk sayma - 1 alt parçanın ötesindeki tüm alt parçaları içeren son öğe ile birlikte sayı öğeleri vardır.

Seçenekler dizesi, her bitişik çifti virgülle ayırarak sıfır veya daha fazla seçenek adı içerir. Baştaki, sonda ve eklenmiş boşluk yoksayılır. Seçenek adları herhangi bir sırada olabilir ve büyük/büyük/büyük harfe duyarlıdır.

Bir seçenek dizesi SimpleMatch seçenek adını içeriyorsa, ignoreCase seçenek adını da içerebilir. Bir seçenek dizesi RegexMatch seçenek adını içeriyorsa veya RegexMatch veya SimpleMatch içeriyorsa, SimpleMatch dışında herhangi bir seçenek adı içerebilir. Ancak, hem Çok Satırlı hem de Tek Satırlı içermesi gerekir.

Seçenek adları kümesi şu şekildedir:

Seçenek	Açıklama
CultureInvariant	Sınırlayıcıyı değerlendirirken dil arasındaki kültürel farkları yok sayar.
ExplicitCapture	Sonuç listesinde yalnızca açık yakalama gruplarının döndürülecek şekilde adlandırılmış olmayan eşleşme gruplarını yoksayar.
IgnoreCase	Kullanılıyor olsa bile büyük/küçük harfe duyarsız eşleştirmeyi -csplit zorlar.
IgnorePatternWhitespace	Kaçışsız boşluğu ve sayı işareti (#) ile işaretlenmiş açıklamalarını yoksayar.
Multiline	Bu mod, satır ve dizelerin başlangıcını ve sonunu tanır. Varsayılan mod Tek satırlı'dır.
RegexMatch	Sınırlayıcıyı değerlendirmek için normal ifade eşleştirmesi kullanın. Bu varsayılan seçenektir.
SimpleMatch	Sınırlayıcıyı değerlendirirken basit dize karşılaştırması kullanın.
Tek satırlı	Bu mod, dizelerin yalnızca başlangıcını ve sonunu tanır. Varsayılan moddur.

Betik bloğu (gie 7.1.8), sınırlayıcıyı belirlemeye ilişkin kuralları belirtir ve bool türüne göre değerlendirin.

Örnekler:

"one,forty two,," -split ","              # 5 strings: "one" "forty two" "" ""

"abc","de" -split ""                      # 9 strings: "" "a" "b" "c" "" "" "d" "e" ""

"ab,cd","1,5,7,8" -split ",", 2           # 4 strings: "ab" "cd" "1" "5,7,8"

"10X20x30" -csplit "X", 0, "SimpleMatch"  # 2 strings: "10" "20x30"

"analogous" -split "[AEIOU]", 0, "RegexMatch, IgnoreCase"
                                          # 6 strings: "" "n" "l" "g" "" "s"

"analogous" -split { $_ -eq "a" -or $_ -eq "o" }, 4
                                          # 4 strings: "" "n" "l" "gous"

7.8.4.6 AltLıklar

, ve ile eşlene -match``-notmatch``-replace desen, parantezle ayrılmış alt parça (alt eşleşmeler olarak adlandırılan) içerebilir. Aşağıdaki örneği inceleyin:

"red" -match "red"

Sonuç olur ve $true 0 $matches anahtarı, sol işlenen tarafından belirlenen dizenin sağ işlenen tarafından belirlenen desenle tam olarak eşan "kırmızı" bölümünü içerir.

Aşağıdaki örnekte, desenin tamamı bir alt eşleşmedir:

"red" -match "(red)"

Daha önce olduğu gibi, 0 anahtarı "kırmızı" içerir; ancak, 1. anahtar aynı zamanda sol işlenen tarafından belirlenen ve alt eşleşmeyle tam olarak eşan dizenin bu bölümü olan "red" içerir.

Aşağıdaki, daha karmaşık deseni göz önünde bulundurarak:

"red" -match "((r)e)(d)"

Bu düzen "r", "re", "d" veya "red" alt desenlerini sağlar.

0 anahtarında da "red" vardır. Anahtar 1 "re" içerir, anahtar 2 "r" ve anahtar 3 "d" içerir. Anahtar/değer çiftleri, desende soldan sağa eşleştirme sırasına sahip olur ve daha kısa dizelerden önce daha uzun dize eşleşmeleri olur.

durumunda, değiştirme -replace``$nmetni formun adları aracılığıyla alt eşleşmelere erişebilirsiniz; $1burada ilk eşleşme , $3ikinci ise , ve bu şekilde devam ediyor. Örneğin,

"Monday morning" -replace '(Monday|Tuesday) (morning|afternoon|evening)','the $2 of $1'

Sonuçta elde edilen dize "Pazartesinin sabahı"dır.

Anahtarların sıfır tabanlı dizinler $matches olması yerine, alt aksamalar formu kullanılarak adlandırılmış olabilir ?<*name*>. Örneğin, "((r)e)(d)" m1, m2 ve m3 adlı üç alt tik ile şu şekilde yazabilirsiniz: "(?<m1>(?<m2>r)e)(?<m3>d)".

7.8.5 Kaydırma işleçleri

Açıklama:

Shift left (-shl) işleci ve shift right (-shr) işleci, normal aritmetik dönüştürmeleri kullanarak, sol işlenen tarafından tasarlanan değeri bir tamsayı türüne ve sağ işlenen tarafından belirlenen değeri int'e dönüştürür ().6.15).

Sola kaydırma işleci, aşağıda açıklandığı gibi hesaplanan bir dizi bitin sol işlenenini sola kaydırıyor. Düşük sıra boş bit konumları sıfır olarak ayarlanır.

Sağ kaydırma işleci, aşağıda açıklandığı gibi hesaplanan bir dizi bitle sol işleneni sağa kaydırıyor. Sol işlenenin düşük sıralı bitleri atılır, kalan bitler sağa kaydırılır. Sol işlenen imzalı bir değer olduğunda, sol işlenen negatif değilse yüksek sıra boş bit konumlarını sıfır olarak, sol işlenen negatif ise bir olarak ayarlanır. Sol işlenen imzasız bir değer olduğunda, yüksek sıra boş bit konumları sıfır olarak ayarlanır.

Sol işlenende int türü olduğunda, kaydırma sayısı sağ işlenenin düşük sıra beş biti tarafından verilir. Sağ işlenenin türü uzun olduğunda, kaydırma sayısı sağ işlenenin düşük sıra altı biti tarafından verilir.

Örnekler:

0x0408 -shl 1             # int with value 0x0810
0x0408 -shr 3             # int with value 0x0081
0x100000000 -shr 0xfff81  # long with value 0x80000000

7.9 Bitwise işleçleri

Söz dizimi:

bitwise-expression:
    comparison-expression
    bitwise-expression -band new-lines~opt~ comparison-expression
    bitwise-expression -bor new-lines~opt~ comparison-expression
    bitwise-expression -bxor new-lines~opt~ comparison-expression

Açıklama:

Bitwise AND -bandişleci , bitwise OR -borişleci ve bitwise XOR işleci -bxor, normal aritmetik dönüştürmeleri (×6.15) kullanarak gerekirse işlenenleri tarafından belirlenen değerleri tamsayı türlerine dönüştürür. Dönüştürmeden sonra, her iki değer de sonucun türü olan int türüne sahipse. Aksi takdirde, her iki değer de uzun türüne sahipse, sonucun türü bu olur. Bir değer int türüne ve diğeri uzun türüne sahipse, sonucun türü uzun olur. Aksi takdirde ifade kötü düsk olur. Sonuç, dönüştürülmesi olası işlenen değerlerinin bitwise AND, bitwise OR veya bitwise XOR değeridir.

Bu işleçler, ilgili olarak bıraktır. İşleçlerin hiçbiri yan etki içeriyorsa bunlar değişmez.

Örnekler:

0x0F0F -band 0xFE    # int with value 0xE
0x0F0F -band 0xFEL   # long with value 0xE
0x0F0F -band 14.6    # long with value 0xF

0x0F0F -bor 0xFE     # int with value 0xFFF
0x0F0F -bor 0xFEL    # long with value 0xFFF
0x0F0F -bor 14.40D   # long with value 0xF0F

0x0F0F -bxor 0xFE    # int with value 0xFF1
0x0F0F -bxor 0xFEL   # long with value 0xFF1
0x0F0F -bxor 14.40D  # long with value 0xF01
0x0F0F -bxor 14.6    # long with value 0xF00

7.10 Mantıksal işleçler

Söz dizimi:

logical-expression:
    bitwise-expression
    logical-expression -and new-lines~opt~ bitwise-expression
    logical-expression -or new-lines~opt~ bitwise-expression
    logical-expression -xor new-lines~opt~ bitwise-expression

Açıklama:

Mantıksal AND işleci -and , işlenenleri tarafından belirlenen değerleri boolgerekirse değerine dönüştürür (yaklaşık 6.2). Sonuç, dönüştürülecek olası işlenen değerlerinin mantıksal AND değeridir ve türündedir bool. Sol işlenen False olarak değerlendirilirse sağ işlenen değerlendirilmez.

Mantıksal OR işleci -or , işlenenleri tarafından belirlenen değerleri boolgerekirse değerine dönüştürür (yaklaşık 6.2). Sonuç, dönüştürülecek olası işlenen değerlerinin mantıksal VEYA değeridir ve türüne sahiptir bool. Sol işlenen True olarak değerlendirilirse sağ işlenen değerlendirilmez.

Mantıksal XOR işleci -xor , işlenenleri tarafından belirlenen değerleri bool (×6.2) olarak dönüştürür. Sonuç, dönüştürülen işlenen değerlerinin mantıksal XOR değeridir ve türüne sahiptir bool.

Bu işleçler, ilgili olarak bıraktır.

Örnekler:

$j = 10
$k = 20
($j -gt 5) -and (++$k -lt 15)   # True -and False -> False
($j -gt 5) -and ($k -le 21)     # True -and True -> True
($j++ -gt 5) -and ($j -le 10)   # True -and False -> False
($j -eq 5) -and (++$k -gt 15)   # False -and True -> False

$j = 10
$k = 20
($j++ -gt 5) -or (++$k -lt 15)  # True -or False -> True
($j -eq 10) -or ($k -gt 15)     # False -or True -> True
($j -eq 10) -or (++$k -le 20)   # False -or False -> False

$j = 10
$k = 20
($j++ -gt 5) -xor (++$k -lt 15) # True -xor False -> True
($j -eq 10) -xor ($k -gt 15)    # False -xor True -> True
($j -gt 10) -xor (++$k -le 25)  # True -xor True -> False

7.11 Atama işleçleri

Söz dizimi:

assignment-expression:
    expression assignment-operator statement

assignment-operator: *one of
    =   dash =   +=   *=   /=   %=

Açıklama:

Atama işleci, bir değeri ifade tarafından belirlenen yazılabilir konumda depolar. Atama işleciyle ilgili bir tartışma için = bkz . .7.11.1. Diğer tüm atama işleçleri hakkında bir tartışma için bkz . .7.11.2.

Atama ifadesi, atama gerçekleştikten sonra ifade tarafından belirlenen değere sahip olur; ancak, bu atama ifadesi yazılabilir bir konum atamaz. İfade türü kısıtlanmışsa (yaklaşık 5,3), bu kısıtlamada kullanılan tür sonucun t t türlerindedir; Aksi takdirde, sonucun türü normal aritmetik dönüştürmeler (yaklaşık 6,15) uygulandıktan sonra tür olur.

Bu işleç doğru şekilde bir iosaslıdır.

7.11.1 Basit atama

Açıklama:

Basit atamada ()= deyimiyle belirlenen değer , ifade tarafından belirlenen yazılabilir konumda depolanan değerin yerini almaktadır. Ancak, ifade bir Hashtable'da mevcut olmayan bir anahtar belirlirse, bu anahtar Deyimi tarafından belirlenen değerin ilişkili bir değeriyle Hashtable'a eklenir.

Dil bilgisi tarafından gösterildiği gibi , ifade yazılabilir konumların virgülle ayrılmış bir listesini ortaya atabilir. Bu, birden çok atama olarak bilinir. deyimi , bir veya daha fazla virgülle ayrılmış değerin listesini gösterir. her iki işlenen listesinde de virgüller, çoklu atama söz dizimlerinin bir parçasıdır ve ikili virgül işleci temsil etmez. Değerler deyim tarafından belirlenen listeden sözcük sırasıyla alınır ve ifade tarafından belirlenen ilgili yazılabilir konumda depolanır. deyimi tarafından belirlenen liste , yazılabilir ifade konumlardan daha az değere sahipse fazlalık konumları değerini alır$null. deyimi tarafından belirlenen liste, ifade yazılabilir konumlarından daha fazla değere sahipse, en doğru ifade konumu dışında hepsi karşılık gelen deyim değerini alır ve en doğru ifade konumu, kalan tüm deyim değerlerini öğe olarak içeren sınırlandırilmemiş bir 1 boyutlu dizi haline gelir.

Değerleri olan deyimler için (yaklaşık 8.1.2), deyimi bir deyim olabilir.

Örnekler:

$a = 20; $b = $a + 12L             # $b has type long, value 22
$hypot = [Math]::Sqrt(3*3 + 4*4)   # type double, value 5
$a = $b = $c = 10.20D              # all have type decimal, value 10.20
$a = (10,20,30),(1,2)              # type [object[]], Length 2
[int]$x = 10.6                     # type int, value 11
[long]$x = "0xabc"                 # type long, value 0xabc
$a = [float]                       # value type literal [float]
$i,$j,$k = 10,"red",$true          # $i is 10, $j is "red", $k is True
$i,$j = 10,"red",$true             # $i is 10, $j is [object[]], Length 2
$i,$j = (10,"red"),$true           # $i is [object[]], Length 2, $j is True
$i,$j,$k = 10                      # $i is 10, $j is $null, $k is $null

$h = @{}
[int] $h.Lower, [int] $h.Upper = -split "10 100"

$h1 = @{ FirstName = "James"; LastName = "Anderson"; IDNum = 123 }
$h1.Dept = "Finance"               # adds element Finance
$h1["City"] = "New York"           # adds element City

[int]$Variable:v = 123.456         # v takes on the value 123
${E:output.txt} = "a"              # write text to the given file
$Env:MyPath = "x:\data\file.txt"   # define the environment variable
$Function:F = { param ($a, $b) "Hello there, $a, $b" }
F 10 "red"                         # define and invoke a function
function Demo { "Hi there from inside Demo" }
$Alias:A = "Demo"                  # create alias for function Demo
A                                  # invoke function Demo via the alias

7.11.2 Bileşik atama

Açıklama:

Bileşik atama, şeklindedir E1 op= E2``E1 = E1 op (E2) ve bileşik atama durumunda E1 ifadesinin yalnızca bir kez değerlendirilmesi dışında basit atama ifadesine eşdeğerdir. İfade türü kısıtlanmışsa (yaklaşık 5,3), bu kısıtlamada kullanılan tür sonucun t t türlerindedir; aksi takdirde, sonucun türü op tarafından belirlenir. için *=bkz. ;7.6.1, %7.6.2, .7.6.3; /=için bkz. .7.6.4; %=için bkz. .7.6.5; için +=bkz. .7.7.1, %7.7.2, .7.7.3; -=için bkz. .. 7.7.5.

Not

Sayısal türün kısıtlanmamış bir değerini belirten işlenenin türü, sonuç depolandığı zaman bir atama işleci tarafından değiştirilebilir.

Örnekler:

$a = 1234; $a *= (3 + 2)  # type is int, value is 1234 * (3 + 2)
$b = 10,20,30             # $b[1] has type int, value 20
$b[1] /= 6                # $b[1] has type double, value 3.33...

$i = 0
$b = 10,20,30
$b[++$i] += 2             # side effect evaluated only once

[int]$Variable:v = 10     # v takes on the value 10
$Variable:v -= 3          # 3 is subtracted from v

${E:output.txt} = "a"     # write text to the given file
${E:output.txt} += "b"    # append text to the file giving ab
${E:output.txt} *= 4      # replicate ab 4 times giving abababab

7.12 Yeniden yönlendirme işleçleri

Söz dizimi:

pipeline:
    assignment-expression
    expression redirections~opt~ pipeline-tail~opt~
    command verbatim-command-argument~opt~ pipeline-tail~opt~

redirections:
    redirection
    redirections redirection

redirection:
    merging-redirection-operator
    file-redirection-operator redirected-file-name

redirected-file-name:
    command-argument
    primary-expression

file-redirection-operator: one of
    >   >>   2>   2>>   3>   3>>   4>   4>>
    5>  5>>  6>   6>>   >    >>    <

merging-redirection-operator: one of
    >&1   2>&1   3>&1   4>&1   5>&1   6>&1
    >&2   1>&2   3>&2   4>&2   5>&2   6>&2

Açıklama:

Yeniden yönlendirme işleci > , işlem hattından standart çıktıyı alır ve yeniden yönlendirilen dosya-adı tarafından belirlenen konuma yeniden yönlendirerek bu konumun geçerli içeriğinin üzerine gelir.

Yeniden yönlendirme işleci >> , işlem hattından standart çıktıyı alır ve yeniden yönlendirilen dosya-adı tarafından belirlenen konuma yeniden yönlendirerek varsa bu konumun geçerli içeriklerini ekler. Bu konum yoksa oluşturulur.

form ile yeniden yönlendirme n> işleci işlem hattından n akışının çıktısını alır ve yeniden yönlendirilen-dosya-adı tarafından belirlenen konuma yeniden yönlendirerek konumun geçerli içeriğinin üzerine gelir.

form ile yeniden yönlendirme n>> işleci, işlem hattından n akışının çıkışını alır ve varsa, bu konumun geçerli içeriklerini ek olarak yeniden yönlendirilen-dosya-adı tarafından belirlenen konuma yeniden yönlendirer. Bu konum yoksa oluşturulur.

form ile yeniden yönlendirme işleci, m>&n m akışından çıktıyı n akışıyla aynı konuma yazar.

Geçerli akışlar aşağıdakilerdir:

Akış	Açıklama
1	Standart çıkış akışı
2	Hata çıkış akışı
3	Uyarı çıkış akışı
4	Ayrıntılı çıkış akışı
5	Çıkış akışında hata ayıklama
*	Standart çıkış, hata çıkışı, uyarı çıkışı, ayrıntılı çıkış ve çıkış akışlarında hata ayıklama

, ve yeniden yönlendirme işleçleri 1>&2``6>``6>> < gelecekte kullanılmak üzere ayrılmıştır.

Çıktıda redirected-file-name değeri ise $nullçıkış atılır.

Normalde, üst düzey yan etki içeren bir ifadenin değeri, bir çift parantez içine alınmışsa işlem hattına yazlanmaz. Ancak, böyle bir ifade standart çıkışı yeniden yönlendiren bir işlecin sol işleneni ise değer yazılır.

Örnekler:

$i = 200                       # pipeline gets nothing
$i                             # pipeline gets result
$i > output1.txt               # result redirected to named file
++$i >> output1.txt            # result appended to named file
type file1.txt 2> error1.txt   # error output redirected to named file
type file2.txt 2>> error1.txt  # error output appended to named file
dir -Verbose 4> verbose1.txt   # verbose output redirected to named file

# Send all output to output2.txt
dir -Verbose -Debug -WarningAction Continue *> output2.txt

# error output redirected to named file, verbose output redirected
# to the same location as error output
dir -Verbose 4>&2 2> error2.txt