Madame Lelica

tömbökről, a legtöbb programozási nyelv alapvető nyelvi jellemzője. Ezek értékek vagy tárgyak gyűjteménye, ezért nehéz elkerülni. Vessünk egy pillantást a tömbökre és mindenre, amit kínálhatnak.

• Oldalindex
• mi az a tömb?,mérkőzés

mi az a tömb?

egy alapvető műszaki leírással fogom kezdeni, hogy milyen tömbök vannak, és hogyan használják őket a legtöbb programozási nyelv, mielőtt a PowerShell más módon használja őket.

egy tömb olyan adatstruktúra, amely több elem gyűjteményeként szolgál. A tömb felett iterálhat, vagy index segítségével elérheti az egyes elemeket. A tömb jön létre, mint egy szekvenciális darab memória, ahol minden értéket tárolja közvetlenül a másik mellett.

mindegyik részletet megérintem, ahogy megyünk.,

alapvető használat

mivel a tömbök a PowerShell ilyen alapvető jellemzője, van egy egyszerű szintaxis a PowerShellben való munkavégzéshez.

hozzon létre egy tömb @()

egy üres tömb lehet létrehozni segítségével @()

 PS> $data = @() PS> $data.count 0

 PS> $data = @('Zero','One','Two','Three') PS> $data.count 4 PS> $data Zero One Two Three

Ez a tömb 4 tételből áll. Amikor a $data változót hívjuk, látjuk elemeink listáját., Ha ez egy sor húrok, akkor lesz egy sor egy string.

egy tömböt több sorban is deklarálhatunk. Ebben az esetben a vessző opcionális, általában kihagyva.

 $data = @( 'Zero' 'One' 'Two' 'Three' )

inkább több vonalon deklarálom a tömbjeimet. Nem csak könnyebb olvasni, ha több elem van, hanem megkönnyíti a korábbi verziókhoz való összehasonlítást a forrásvezérlés használatakor.,

Egyéb szintaxis

általánosan ismert, hogy a@() egy tömb létrehozásának szintaxisa, de a vesszővel elválasztott listák az idő nagy részében működnek.

 $data = 'Zero','One','Two','Three'

Write-Output tömbök létrehozásához

egy jó kis trükk, amit érdemes megemlíteni, hogy a karakterláncok gyors létrehozásához a konzolon.

 $data = Write-Output Zero One Two Three

Ez azért hasznos, mert nem kell idézőjeleket tenni a karakterláncok körül, amikor a paraméter elfogadja a karakterláncokat., Soha nem tennék ezt egy szkriptben, de ez tisztességes játék a konzolon.

elemek elérése

most, hogy van egy tömb elemeivel, érdemes lehet hozzáférni és frissíteni ezeket az elemeket.

eltolás

az egyes elemek eléréséhez a zárójeleket használjuk 0-tól kezdődő eltolási értékkel. Így kapjuk meg a tömb első elemét:

 PS> $data = 'Zero','One','Two','Three' PS> $data Zero

az oka annak, hogy itt nullát használunk, mert az első elem a lista elején van, így 0 elem eltolását használjuk ahhoz, hogy elérjük., A második elem eléréséhez az 1 eltolását kell használnunk az első elem kihagyásához.

 PS> $data One

Ez azt jelentené, hogy az utolsó elem az offset 3.

 PS> $data Three

Index

most láthatja, miért választottam azokat az értékeket, amelyeket erre a példára tettem. Ezt eltolásként vezettem be, mert ez az, ami valójában, de ezt az eltolást gyakrabban indexnek nevezik. Index, amely 0címen kezdődik. A cikk többi részében az eltolást Indexnek hívom.,

speciális indextrükkök

a legtöbb nyelvben csak egyetlen számot adhatunk meg indexként, és egyetlen elemet kapunk vissza. A PowerShell sokkal rugalmasabb. Egyszerre több indexet is használhat. Az indexek listájának megadásával több elemet is kiválaszthatunk.

 PS> $data Zero Two Three

az elemek a megadott indexek sorrendje alapján kerülnek visszaadásra. Ha egy indexet duplikál, akkor ezt az elemet mindkét alkalommal megkapja.,

 PS> $data Three Zero Three

meghatározhatunk egy sor számot a beépített.. operátorral.

 PS> $data One Two Three

ez fordítva is működik.

 PS> $data Three Two One

negatív indexértékeket használhat a végétől való eltoláshoz. Tehát, ha szüksége van a lista utolsó elemére, használhatja a -1.,

 PS> $data Three

határain kívül

a legtöbb nyelven, ha megpróbál hozzáférni egy olyan elem indexéhez, amely a tömb végén túl van, akkor valamilyen típusú hibát vagy kivételt kap. PowerShell csendben kapsz semmit.

 PS> $null -eq $data True

nem lehet indexelni egy null tömbbe

Ha a változó$nullés megpróbálja indexelni, mint egy tömb, akkor kap egySystem.Management.Automation.RuntimeExceptionkivételt a az üzenetCannot index into a null array.,

 PS> $empty = $null SP> $empty Error: Cannot index into a null array.

tehát győződjön meg róla, hogy a tömbök nem$null mielőtt megpróbálna hozzáférni a bennük lévő elemekhez.

Count

tömbök és más gyűjtemények egy gróf tulajdonsággal rendelkeznek, amely megmondja, hogy hány elem van a tömbben.

 PS> $data.count 4

PowerShell 3.0 hozzáadott egy gróf tulajdonságot a legtöbb objektumhoz. lehet, hogy egy objektum, és meg kell adni egy gróf 1.,

 PS> $date = Get-Date PS> $date.count 1

még$nullvan egy count tulajdonság, kivéve, hogy visszatér0.

 PS> $null.count 0

vannak csapdák, hogy nem fog újra, amikor fedezze ellenőrzése $null vagy üres tömbök később ezt a cikket.

ki egy hiba

egy közös programozási hiba jön létre, mert tömbök indul index 0. Egy ki egy hiba lehet bevezetni két nagyon gyakori módon.,

az első az, hogy azt gondoljuk, hogy a 2. elemet akarjuk, és a 2 indexet használjuk, és valóban megkapjuk a harmadik elemet. Vagy azt gondolva, hogy van 4 elem, és azt szeretné, hogy az utolsó elem, így csak használja a méret eléréséhez az utolsó elem.

 $data

a PowerShell tökéletesen örül annak, hogy ezt megteheti, és pontosan megadja, hogy milyen elem létezik a 4.Indexnél,$null. A $data.count - 1 vagy a -1 – t kell használnia, amelyről fent tanultunk.,

 PS> $data Three

itt használhatja a-1 indexet az utolsó elem eléréséhez.

 PS> $data Three

Lee Dailey is rámutatott, hogy tudjuk használni a $data.GetUpperBound(0) a max index száma.

 PS> $data.GetUpperBound(0) Three

a második leggyakoribb módszer a lista iterálása, és csak nem a megfelelő időben áll meg. Ezt újra megvizsgálom, amikor a for hurok használatáról beszélünk.,

elemek frissítése

ugyanazt az indexet használhatjuk a tömb meglévő elemeinek frissítéséhez. Ez közvetlen hozzáférést biztosít az egyes elemek frissítéséhez.

 $data = 'dos' $data = 'tres'

ha megpróbálunk frissíteni egy elemet, amely elmúlt az utolsó elemen, akkor kapunk egyIndex was outside the bounds of the array. hibát.

ezt később újra megvizsgálom, amikor arról beszélek, hogyan lehet egy tömböt nagyobbá tenni.

iteráció

egy bizonyos ponton meg kell járnia vagy meg kell ismételnie a teljes listát, és végre kell hajtania néhány műveletet a tömb minden elemére.,

csővezeték

tömbök és a PowerShell csővezeték egymásnak szólnak. Ez az egyik legegyszerűbb módja annak, hogy ezeket az értékeket feldolgozzuk. Amikor egy tömböt átad egy csővezetéknek, a tömb minden egyes elemét egyedileg dolgozzák fel.

 PS> $data = 'Zero','One','Two','Three' PS> $data | ForEach-Object {"Item: "} Item: Item: Item: Item: 

Ha még nem látta $PSItem korábban, csak tudja, hogy ugyanaz, mint a . Használhatja akár egy, mert mindkettő képviseli az aktuális objektum a csővezeték.,

ForEach loop

aForEach loop jól működik a gyűjteményekkel. A szintaxis használata: foreach ( <variable> in <collection> )

 foreach ( $node in $data ) { "Item: " }

ForEach módszer

hajlamosak elfelejteni ezt, de jól működik az egyszerű műveleteknél. PowerShell lehetővé teszi, hogy hívja .ForEach() egy gyűjtemények.

 PS> $data.foreach({"Item "}) Item Item Item Item 

a.foreach() olyan paramétert vesz fel, amely egy szkriptblokk. Ejtheted a zárójeleket, és megadhatod a szkriptblokkot.,

 $data.foreach{"Item "}

Ez egy kevésbé ismert szintaxis, de ugyanúgy működik. Ezt aforeach módszert a PowerShell 4.0-ban adták hozzá.

a hurok

a for hurok erősen használják a legtöbb más nyelven, de nem látja sokat PowerShell. Amikor látja, gyakran egy tömb sétálásával összefüggésben van.

 for ( $index = 0; $index -lt $data.count; $index++) { "Item: " -f $data }

az első dolog, amit csinálunk, az egy $index 0., Ezután hozzáadjuk azt a feltételt, hogy a $index kevesebbnek kell lennie, mint a $data.count. Végül meghatározzuk, hogy minden alkalommal, amikor hurok, hogy nekem kell növelni az index 1. Ebben az esetben a $index++rövidítése $index = $index + 1.

Hafor hurkot használ, fordítson különös figyelmet az állapotra. Régebben $index -lt $data.count itt. Nagyon könnyű, hogy a feltétel kissé rossz, hogy kap egy off egy hiba a logika., A $index -le $data.count vagy $index -lt ($data.count - 1) használata mindig kissé rossz. Ez azt eredményezné, hogy az eredmény túl sok vagy túl kevés elemet dolgoz fel. Ez a klasszikus ki egy hiba.

kapcsoló hurok

Ez az egyik, hogy nagyon könnyű figyelmen kívül hagyni. Ha egy tömb egy kapcsoló nyilatkozatot, akkor egyezik az egyes elemeket a tömbben.

 $data = 'Zero','One','Two','Three' switch( $data ) { 'One' { 'Tock' } 'Three' { 'Tock' } Default { 'Tick' } }

Ez hozza létre ezt a kimenetet:

 Tick Tock Tick Tock

van egy csomó jó dolog, mint ez, amit tehetünk a kapcsoló nyilatkozat., Van egy másik cikkem erre.

• minden, amit valaha is tudni akart a switch utasításról

frissítési értékek

amikor a tömb karakterláncok vagy egész számok gyűjteménye (értéktípusok), néha frissíteni szeretné a tömb értékeit, amikor körbejárja őket. A fenti hurkok többsége olyan változót használ a hurokban, amely az érték másolatát tartalmazza. Ha frissíti a változót,a tömb eredeti értéke nem frissül.

e kijelentés alóli kivétel afor hurok., Ha egy tömböt szeretne járni, és értékeket szeretne frissíteni benne, akkor afor hurok az, amit keres.

 for ( $index = 0; $index -lt $data.count; $index++ ) { $data = "Item: " -f $data }

Ez a példa érték index szerint, néhány változtatást hajt végre, majd ugyanazt az indexet használja vissza.

objektumok tömbjei

eddig az egyetlen dolog, amit egy tömbbe helyeztünk, egy értéktípus, de a tömbök objektumokat is tartalmazhatnak.

 $data = @( @{FirstName='Kevin';LastName='Marquette'} @{FirstName='John'; LastName='Doe'} )

sok parancsmag visszaadja az objektumok gyűjteményeit tömbként, amikor egy változóhoz rendeli őket.,

 $processList = Get-Process

az összes alapvető funkció, amelyről már beszéltünk, továbbra is vonatkozik az objektumok tömbjeire, néhány részletre érdemes rámutatni.

Accessing properties

egy indexet használhatunk egy gyűjtemény egyes elemeinek eléréséhez, akárcsak az értéktípusok esetében.

 PS> $data FirstName LastName ----- ---- Kevin Marquette

közvetlenül elérhetjük és frissíthetjük a tulajdonságokat.,

 PS> $data.FirstName Kevin PS> $data.FirstName = 'Jay' PS> $data FirstName LastName ----- ---- Jay Marquette

Array properties

általában a teljes listát így kell felsorolni az összes tulajdonság eléréséhez:

 PS> $data | ForEach-Object {$_.LastName} Marquette Doe

vagy a Select-Object -ExpandProperty cmdlet használatával.

 PS> $data | Select-Object -ExpandProperty LastName Marquette Doe

de a PowerShell lehetőséget kínál nekünk aLastName közvetlen igénylésére. A PowerShell felsorolja mindannyiunkat, és tiszta listát ad nekünk.,

 PS> $data.LastName Marquette Doe

a felsorolás még mindig megtörténik, de nem látjuk a bonyolultságot.

Where-Object filtering

Ez az, aholWhere-Object jön, így tudjuk szűrni, és válassza ki, mit akarunk ki a tömb tulajdonságai alapján az objektum.

 PS> $data | Where-Object {$_.FirstName -eq 'Kevin'} FirstName LastName ----- ---- Kevin Marquette

ugyanazt a lekérdezést írhatjuk, hogy megkapjuk aFirstName keresünk.,

 $data | Where FirstName -eq Kevin

ahol ()

tömbök van egyWhere()módszer rájuk, amely lehetővé teszi, hogy adja meg ascriptblock a szűrő.

 $data.Where({$_.FirstName -eq 'Kevin'})

ezt a funkciót a PowerShell 4.0-ban adták hozzá.

objektumok frissítése hurkokban

értéktípusokkal, a tömb frissítésének egyetlen módja a for loop használata, mert ismernünk kell az indexet az érték cseréjéhez. Több lehetőségünk van az objektumokkal, mert referenciatípusok., Itt egy gyors példa:

 foreach($person in $data) { $person.FirstName = 'Kevin' }

Ez a hurok a$data tömb minden objektumán jár. Mivel az objektumok referenciatípusok, a$person változó pontosan ugyanazt az objektumot jelöli, amely a tömbben található. Tehát a tulajdonságok frissítései frissítik az eredetit.

az egész objektumot így még mindig nem tudja kicserélni. Ha új objektumot próbál hozzárendelni a $person változóhoz, frissíti a változó hivatkozását valami másra, amely már nem mutat a tömb eredeti objektumára., Ez nem fog úgy működni, mint amire számítana:

 foreach($person in $data) { $person = @{ FirstName='Kevin' LastName='Marquette' } }

operátorok

a PowerShell operátorai tömbökön is működnek. Néhányan kissé másképp működnek.

– join

a -join operátor a legnyilvánvalóbb, így először megnézzük. Szeretem a -join operátort, és gyakran használom. A tömb minden eleméhez csatlakozik egy megadott karakterrel vagy karakterlánccal.,

 PS> $data = @(1,2,3,4) PS> $data -join '-' 1-2-3-4 PS> $data -join ',' 1,2,3,4

egyik jellemzője, hogy szeretem a-join üzemeltető, hogy kezeli az egyes elemeket.

 PS> 1 -join '-' 1

ezt a naplózási és verbózási üzeneteket használom.

 PS> $data = @(1,2,3,4) PS> "Data is $($data -join ',')." Data is 1,2,3,4.

-csatlakozzon a $array

– hez egy okos trükk, amelyet Lee Dailey mutatott nekem., Ha valaha is szeretne csatlakozni mindent nélkül határoló, ahelyett, hogy ezt:

 PS> $data = @(1,2,3,4) PS> $data -join $null 1234

használhatja-join a tömb, mint a paraméter nem előtag. Vessen egy pillantást erre a példára, hogy lássam, hogy beszélek.

 PS> $data = @(1,2,3,4) PS> -join $data 1234

-replace and-split

a többi operátor, mint a -replace és -split a tömb minden elemén végrehajtásra kerül. Nem mondhatom, hogy valaha is használtam őket ilyen módon, de itt van egy példa.,

 PS> $data = @('ATX-SQL-01','ATX-SQL-02','ATX-SQL-03') PS> $data -replace 'ATX','LAX' LAX-SQL-01 LAX-SQL-02 LAX-SQL-03

-tartalmaz

a-contains operátor lehetővé teszi, hogy ellenőrizze egy sor értéket, hogy ha tartalmaz egy meghatározott értéket.

 PS> $data = @('red','green','blue') PS> $data -contains 'green' True

-in

ha egyetlen értéke van, amelyet ellenőrizni szeretne, akkor a-in operátort használhatja. Az érték a művelet bal oldalán, a tömb pedig a jobb oldalon lenne.,

 PS> $data = @('red','green','blue') PS> 'green' -in $data True

Ez drága lehet, ha a lista nagy. Gyakran használok regex mintát, ha több mint 4-5 értéket ellenőrizek.

 PS> $data = @('red','green','blue') PS> $pattern = "^({0})$" -f ($data -join '|') PS> $pattern ^(red|green|blue)$ PS> 'green' -match $pattern True

-eq és-ne

az egyenlőség és a tömbök bonyolultabbá válhatnak. Ha a tömb a bal oldalon van, minden elem összehasonlításra kerül. A True visszaadása helyett a megfelelő objektumot adja vissza.,

 PS> $data = @('red','green','blue') PS> $data -eq 'green' green

amikor a-ne operátort használjuk, minden olyan értéket megkapunk, amely nem egyenlő az értékünkkel.

 PS> $data = @('red','green','blue') PS> $data -ne 'green' red blue

Ha ezt egyif()nyilatkozatban használja, a visszaküldött érték egyTrue érték. Ha nincs érték vissza, akkor ez egy False érték. Mindkét következő kijelentés Trueértékre lesz kiértékelve.,

 $data = @('red','green','blue') if ( $data -eq 'green' ) { 'Green was found' } if ( $data -ne 'green' ) { 'And green was not found' }

ezt egy pillanat alatt újra megvizsgálom, amikor a$null teszteléséről beszélünk.

– match

a-match az üzemeltető megpróbálja egyeztetni a gyűjtemény minden elemét.

 PS> $servers = @( 'LAX-SQL-01' 'LAX-API-01' 'ATX-SQL-01' 'ATX-API-01' ) PS> $servers -match 'SQL' LAX-SQL-01 ATX-SQL-01

Ha-matchegy értékkel egy speciális$Matches egyezési információval lesz feltöltve. Nem ez a helyzet, ha egy tömb ilyen módon kerül feldolgozásra.

ugyanezt a megközelítést alkalmazhatjuk a Select-String.,

 $servers | Select-String SQL

I take a closer look atSelect-String,és a$matches változó egy másik bejegyzésben a Regex használatának számos módja.

$ null vagy üres

$null vagy üres tömbök trükkösek lehetnek. Itt vannak a közös csapdák tömbökkel.

egy pillanat alatt ez a kijelentés úgy néz ki, mintha működnie kellene.

 if ( $array -eq $null) { 'Array is $null' }

de csak átnéztem, hogy a-eq hogyan ellenőrzi a tömb minden elemét., Tehát több elemből álló tömb lehet, egyetlen $ null értékkel, és a $true

 $array = @('one',$null,'three') if ( $array -eq $null) { 'I think Array is $null, but I would be wrong' }

Ez az oka annak, hogy a legjobb gyakorlat a bal oldalán az operátor. Ez teszi ezt a forgatókönyvet nem kérdés.

 if ( $null -eq $array ) { 'Array actually is $null' }

a$null array nem ugyanaz, mint egy üres tömb. Ha tudja, hogy van egy tömb, ellenőrizze az objektumok számát., Ha a tömb $null, akkor a szám 0lesz.

 if ( $array.count -gt 0 ) { 'Array is not empty' }

van még egy csapda, amelyre figyelni kell. Használhatja a count akkor is, ha van egy objektum, kivéve, ha az objektum egy PSCustomObject. Ez egy hiba, amelyet a PowerShell 6.1 rögzít. Ez jó hír, de sokan még mindig az 5.1-en vannak, és vigyázniuk kell rá.

 PS> $object = @{Name='TestObject'} PS> $object.count $null

Ha még mindig a PowerShell 5.,1, akkor csomagolja az objektumot egy tömbben, mielőtt ellenőrzi a gróf, hogy pontos számot.

 if ( @($array).count -gt 0 ) { 'Array is not empty' }

a biztonságos lejátszáshoz ellenőrizze a$null számot, majd ellenőrizze a számot.

 if ( $null -ne $array -and @($array).count -gt 0 ) { 'Array is not empty' }

All-eq

nemrég láttam, hogy valaki megkérdezi, hogyan lehet ellenőrizni, hogy egy tömb minden értéke megfelel-e egy adott értéknek. Reddit felhasználó / u / bis volt ez okos megoldás, amely ellenőrzi a helytelen értékeket, majd fejtetőre az eredmény.,

 $results = Test-Something if ( -not ( $results -ne 'Passed') ) { 'All results a Passed' }

hozzáadása tömbök

Ezen a ponton, akkor kezd csoda, hogyan kell hozzáadni elemeket egy tömb. A gyors válasz az, hogy nem lehet. egy tömb rögzített méretű a memóriában. Ha meg kell nőnie, vagy hozzá kell adnia egy elemet, akkor létre kell hoznia egy új tömböt, majd át kell másolnia az összes értéket a régi tömbből. Ez drágának tűnik, mint sok munka, azonban a PowerShell elrejti az új tömb létrehozásának összetettségét.

Array addition

az addition operátort tömbökkel használhatjuk új tömb létrehozásához., Tehát figyelembe véve ezt a két tömböt:

 $first = @( 'Zero' 'One' ) $second = @( 'Two' 'Three' )

összeadhatjuk őket, hogy új tömböt kapjunk.

 PS> $first + $second Zero One Two Three

Plus egyenlő +=

létrehozhatunk egy új tömböt a helyén, és hozzáadhatunk hozzá egy elemet:

 $data = @( 'Zero' 'One' 'Two' 'Three' ) $data += 'four'

ne feledje, hogy minden alkalommal, amikor a += – t használja, Új tömböt hoz létre. Ez nem jelent problémát a kis adatkészletek számára, de rendkívül rosszul mérlegel.,

csővezeték hozzárendelés

bármely csővezeték eredményét hozzárendelheti egy változóhoz. Ez egy tömb lesz, ha több elemet tartalmaz.

 $array = 1..5 | ForEach-Object { "ATX-SQL-$PSItem" }

általában, amikor a csővezeték használatára gondolunk, a tipikus PowerShell egysorosokra gondolunk. A csővezetéket foreach() utasításokkal és egyéb hurkokkal tudjuk kihasználni. Tehát ahelyett, hogy elemeket adnánk egy tömbbe egy hurokban, dobhatunk elemeket a csővezetékre.,

 $array = foreach ( $node in (1..5)) { "ATX-SQL-$node" }

aforeach eredményeinek hozzárendelésével egy változóhoz rögzítjük az összes objektumot, és létrehozunk egy tömböt.

Tömbtípusok

alapértelmezés szerint a PowerShellben lévő tömb ] típusként jön létre. Ez lehetővé teszi, hogy bármilyen típusú objektumot vagy értéket tartalmazzon. Ez azért működik, mert minden a PSObject típustól örökölt.

erősen gépelt tömbök

bármilyen típusú tömböt létrehozhat hasonló szintaxis használatával., Erősen gépelt tömb létrehozásakor csak a megadott típusú értékeket vagy objektumokat tartalmazhat.

ArrayList

elemek hozzáadása egy tömbhöz az egyik legnagyobb korlátja, de van néhány más gyűjtemény, amelyhez fordulhatunk, hogy megoldjuk ezt a problémát.

a ArrayList általában az egyik első dolog, amit gondolunk, amikor szükségünk van egy tömb, amely gyorsabb dolgozni. Úgy viselkedik, mint egy objektum tömb minden helyen, hogy szükségünk van rá, de kezeli hozzá elemeket gyorsan.

így hozunk létre egy ArrayList és adunk hozzá elemeket.,

 $myarray = ::new() $myArray.Add('Value')

felhívjuk a.Net-t, hogy megkapja ezt a típust. Ebben az esetben az alapértelmezett konstruktort használjuk annak létrehozásához. Ezután hívjuk a Add módszert egy elem hozzáadásához.

az ok, amiért a a sor elején használom, a visszatérési kód elnyomása. Néhány. Net-hívás ezt teszi, és váratlan kimenetet hozhat létre.

Ha az egyetlen adat, hogy van a tömb húrok, akkor is vessen egy pillantást a StringBuilder., Ez szinte ugyanaz a dolog, de van néhány módszer, amely csak a húrok kezelésére szolgál. AStringBuilder kifejezetten a teljesítményre lett tervezve.

• Concatenate húrok segítségével StringBuilder

Ez tényleg gyakori, hogy az emberek mozognak ArrayList A tömbök. De olyan időből származik, amikor a C# nem volt általános támogatás., AArrayList a generikusList

Generikus lista

a generikus típus egy speciális Típus A C# – ban, amely egy általánosított osztályt határoz meg, és a felhasználó megadja a létrehozáskor használt adattípusokat. Tehát, ha számokat vagy karakterláncokat szeretne, akkor meghatározhatja, hogy a int vagy string típusok.

itt van, hogyan hozhat létre egy listát a karakterláncok.

 $mylist = ]::new()

vagy a számok listája.,

 $mylist = ]::new()

a szereposztás meglévő tömb, lista nélkül létrehozása az objektum első:

 $mylist = ]@(1,2,3)

Tudjuk rövidíteni a szintaxis egy kicsit a using namespace nyilatkozat a PowerShell 5 vagy újabb. Ausing utasítás a szkript első sorának kell lennie. A névtér deklarálásával a PowerShell lehetővé teszi, hogy elhagyja azt az adattípusoktól, amikor hivatkozik rájuk.,

 using namespace System.Collections.Generic $myList = ]@(1,2,3)

Ez teszi aList sokkal használhatóbbá.

van egy hasonló Add módszer áll az Ön rendelkezésére. Az ArrayList-től eltérően nincs visszatérési érték a Add metóduson, így nem kell void it.

 $myList.Add(10)

és továbbra is hozzáférhetünk az elemekhez, mint más tömbök.,

 PS> $myList 10

List

lehet egy listát bármilyen típusú, de ha nem tudja, hogy milyen típusú tárgyak, akkor a] tartalmazza azokat.

 $list = ]::new()

Eltávolítás ()

TheArrayListés a generikus mindkét támogatás elemek eltávolítása a gyűjteményből.

 using namespace System.Collections.Generic $myList = ]@('Zero','One','Two','Three') $myList.Remove("Two") Zero One Three

értéktípusok használatakor eltávolítja az elsőt a listáról., Újra és újra felhívhatja, hogy eltávolítsa ezt az értéket. Ha rendelkezik referenciatípusokkal, meg kell adnia az eltávolítani kívánt objektumot.

 ]$drives = Get-PSDrive $drives.remove($drives)

 $data = ]::new(4) $data.count 4

szorzó tömbök

érdekes kis trükk az, hogy egy tömböt egész számokkal meg lehet szorozni.

 PS> $data = @('red','green','blue') PS> $data * 3 red green blue red green blue red green blue

inicializálja a 0

egy közös forgatókönyv az, hogy minden nullával tömböt szeretne létrehozni. Ha csak egész számok lesznek, akkor az egész számok erősen gépelt tömbje alapértelmezés szerint minden nullára vonatkozik.

 PS> ]::new(4) 0 0 0 0

erre is használhatjuk a szorzó trükköt.,

 PS> $data = @(0) * 4 PS> $data 0 0 0 0

a szorzás trükkje az, hogy bármilyen értéket használhat. Tehát, ha inkább255 lenne az alapértelmezett értéke, ez jó módszer erre.

 PS> $data = @(255) * 4 PS> $data 255 255 255 255

beágyazott tömbök

egy tömb belsejében egy tömb neve beágyazott tömb. Nem használom ezeket sokat PowerShellben, de más nyelveken is használtam őket. Fontolja meg a tömbök tömb használatát, amikor az adatok egy rácshoz hasonló mintához illeszkednek.

itt van két módon tudunk létrehozni egy 2 dimenziós tömb.,

 $data = @(@(1,2,3),@(4,5,6),@(7,8,9)) $data2 = @( @(1,2,3), @(4,5,6), @(7,8,9) )

a vessző nagyon fontos ezekben a példákban. Adtam egy korábbi példa a normál tömb több sorban, ahol a vessző opcionális volt. Nem ez a helyzet egy többdimenziós tömb esetében.

az indexjelzés használatának módja kissé megváltozik, most, hogy beágyazott tömbünk van. A fenti $data használatával így érhetjük el a 3 értéket.

 PS> $outside = 0 PS> $inside = 2 PS> $data 3

adjon hozzá egy konzolkészletet a tömb fészkelésének minden szintjéhez., Az első sor zárójelben van a külső legtöbb tömb, majd a munka az utat onnan.

Write-Output-NoEnumerate

PowerShell szeret kicsomagolni vagy felsorolni tömbök. Ez a PowerShell csővezeték használatának alapvető szempontja, de vannak olyan idők, amikor nem akarja, hogy ez megtörténjen.

i általában cső tárgyak Get-Member többet róluk. Amikor egy tömböt csatlakoztatok hozzá, az kicsomagolódik, és a Get-Member látja a tömb tagjait, nem pedig a tényleges tömböt.,

 PS> $data = @('red','green','blue') PS> $data | Get-Member TypeName: System.String ...

a tömb kicsomagolásának megakadályozása érdekében aWrite-Object -NoEnumerate – t használhatja.

 PS> Write-Output -NoEnumerate $data | Get-Member TypeName: System.Object ...

van egy második módja ennek, hogy ez inkább egy hack (és megpróbálom elkerülni hack, mint ez). A tömb előtt egy vesszőt helyezhet el, mielőtt megcsípné.

 PS> ,$data | Get-Member TypeName: System.Object ...

visszaad egy tömböt

Ez a tömbök csomagolása akkor is megtörténik, ha egy függvényből értékeket ad ki vagy ad vissza., Még mindig kaphat egy tömböt, ha a kimenetet egy változóhoz rendeli, így ez általában nem jelent problémát.

a fogás az, hogy új tömb lesz. Ha ez valaha is probléma, használhatja aWrite-Output -NoEnumerate $array vagyreturn ,$array dolgozni körülötte.

bármi más?

tudom, hogy ez mind sok, amit be kell venni. Remélem, hogy minden alkalommal, amikor elolvassa, megtanul valamit ebből a cikkből, és hogy hosszú ideig jó referencia lesz az Ön számára., Ha úgy találta, hogy ez hasznos, kérjük, ossza meg másokkal, hogy úgy gondolja, kap értéket belőle.

innen azt javaslom, hogy nézzen meg egy hasonló bejegyzést, amelyet a hashtables-ről írtam.