Minden, amit tudni akartál tömbök

• 10/08/2020
• 24 perc olvasni
• • j
  • h
  • s
  • V

Tömbök alapvető nyelvi jellemzője, hogy a legtöbb programozási nyelvek. Ezek olyan tárgyak vagy tárgyak gyűjteménye, amelyeket nehéz elkerülni. Vessünk egy pillantást a tömbökre és mindenre, amit kínálnunk kell.,

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 előtt, 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., Az index segítségével iterálhatja az egyes elemeket, vagy hozzáférhet az egyes elemekhez. A tömb jön létre, mint egy szekvenciális darabmemória, ahol minden értéket közvetlenül a másik mellett tárolja.

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

Basic usage

mivel a tömbök a PowerShell ilyen alapvető jellemzője,van egy egyszerű szintaxis a PowerShellben.,

hozzon létre egy tömb

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

PS> $data = @()PS> $data.count0

tudunk létrehozni egy tömb és mag azt értékeket csak azáltal, hogy azokat a @() zárójelben.

PS> $data = @('Zero','One','Two','Three')PS> $data.count4PS> $dataZeroOneTwoThree

Ez a tömb 4 elemet tartalmaz. Amikor a $data változót hívjuk, látjuk elemeink listáját. Ha ez a húrok rendje, akkor egy sort kapunk karakterlánconként.

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 a tömbjeimet több soron deklarálom. Nem csak könnyebb olvasni, amikortöbb elem van, ez is megkönnyíti a korábbi verziókhoz való összehasonlítást a sourcecontrol használatakor.

Egyéb szintaxis

általánosan ismert, hogy a@() egy tömb létrehozásának szintaxisa, de vesszővel elválasztott listákmunkálja a legtöbb időt.,

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

írási kimenet tömbök létrehozásához

egy hűvös kis trükk, amelyet érdemes megemlíteni, hogy aWrite-Output segítségével gyorsan létrehozhat stringsat a konzolt.

$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 elfogadjastrings. 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> $dataZero

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. Ahhoz, hogy a második tétel, mi lenne szükség, hogy egy eltolás 1 toskip az első tétel.

PS> $dataOne

Ez azt jelentené, hogy az utolsó elem eltolás 3.,

PS> $dataThree

Index

most már láthatja, miért választottam azokat az értékeket, amelyeket erre a példára tettem. Ezt offsetbecause ez az, ami valójában, de ezt az eltolást gyakrabban indexnek nevezik. Anindex, amely a 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., A lista összeállításával több tételt is kiválaszthatunk.

PS> $dataZeroTwoThree

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

PS> $dataThreeZeroThree

megadhatunk egy számsorozatot a beépített .. operátorral.

PS> $dataOneTwoThree

ez fordítva is működik.

PS> $dataThreeTwoOne

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

PS> $dataThree

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. A PowerShell csendben semmit sem ad vissza.

PS> $null -eq $dataTrue

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.RuntimeException kivétel az üzenetCannot index into a null array.,

PS> $empty = $nullSP> $emptyError: 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.count4

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

PS> $date = Get-DatePS> $date.count1

még $null van egy count tulajdonság, kivéve visszatér 0.,

PS> $null.count0

vannak olyan csapdák itt, hogy én újra, amikor fedezi ellenőrzése $null vagy üres tömböklater be ebben a cikkben.

Off-by-one hibák

egy közös programozási hiba jön létre, mert tömbök indul index 0. Az Off-by-one hibák lehetnekkét módon.

az első az, hogy azt gondoljuk, hogy a második elemet akarjuk, és a 2 indexet használjuk, és valóban a harmadik tételt kapjuk. Vagy azt gondolva, hogy négy elemed van, és az utolsó elemet akarod, így a count használatával hozzáférsz az utolsó elemhez.,

$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. Meg kell használni $data.count - 1vagy a -1, hogy megtudtuk a fenti.

PS> $dataThree

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

PS> $dataThree

Lee Dailey arra is rámutatott, hogy a$data.GetUpperBound(0) A max indexszám eléréséhez használhatjuk.,

PS> $data.GetUpperBound(0)3PS> $dataThree

a második leggyakoribb módszer a lista iterálása, nem pedig a megfelelő időben történő megállás. Ezt akkor fogom meglátogatni, 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 nekünkfrissítse az egyes elemeket.

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

ha megpróbálunk frissíteni egy elemet, amely már az utolsó elem, akkor kapunk egyIndex was outside the bounds of the array. hiba.

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 előfordulhat, hogy a teljes listát sétálni vagy iterálni kell, és végre kell hajtania néhány műveletet a tömbben.

csővezeték

tömbök és a PowerShell csővezeték egymásnak szólnak. Ez az egyik legegyszerűbb módfolyamat ezen értékek felett. Ha átad egy tömböt egy csővezetékhez, akkor a tömb minden elemét külön-külön kell feldolgozni.

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 tudd, hogy ez ugyanaz, mint a $_., Használhatja eitherone 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 vagyok elfelejteni ezt, de jól működik az egyszerű műveleteknél. PowerShell lehetővé teszi, hogyhívja a.ForEach() gyűjteményre.

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

a .foreach() olyan paramétert vesz fel, amely egy szkriptblokk., A zárójeleket egyszerűen eldobhatjamegoldja a szkriptblokkot.

$data.foreach{"Item "}

Ez egy kevésbé ismert szintaxis, de ugyanúgy működik. Ezt aforeach módszert adtuk hozzá inPowerShell 4.0.

A hurok

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

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

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

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

kapcsoló hurok

Ez az egyik, hogy könnyű figyelmen kívül hagyni. Ha egy tömböt ad meg egy kapcsolási utasításhoz, akkor ellenőrizze a tömb minden elemét.

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

TickTockTickTock

sok jó dolog van, amit tehetünk a kapcsoló nyilatkozatával. Van még egy cikkem ehhez.,

• mindent, amit valaha is akartam tudni a kapcsoló nyilatkozat

frissítése értékek

Ha a tömb gyűjteménye string vagy egész számok (érték típusok), néha érdemes toupdate az értékeket a tömb, ahogy hurok felettük. A fenti hurkok többsége egy változót használaz érték másolatát tartalmazó hurok. Ha frissíti ezt a változót, akkor a tömb eredeti értékenem frissül.

e kijelentés alóli kivétel afor hurok., Ha egy tömböt szeretne járni és frissíteni az értékeket, akkor a for 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 a hozzárendeléshez.

objektumok tömbjei

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

$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 néhány objektum tömbjére.részletek é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> $dataFirstName LastName----- ----Kevin Marquette

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

PS> $data.FirstNameKevinPS> $data.FirstName = 'Jay'PS> $dataFirstName 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}MarquetteDoe

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

PS> $data | Select-Object -ExpandProperty LastNameMarquetteDoe

de a PowerShell lehetőséget kínál nekünk a LastName közvetlen kérésére. A PowerShell felsorolja nekünk az összes számot, és egy tiszta listát ad vissza.

PS> $data.LastNameMarquetteDoe

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

Where-Object filtering

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

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

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

$data | Where FirstName -eq Kevin

ahol()

tömbök van egy Where() módszer rájuk, amely lehetővé teszi, hogy adja meg a scriptblock 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 az a For loop használata, mert ismernünk kell aindexet 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át járja. Mivel az objektumok referenciatípusok, a$person változó pontosan ugyanazt az objektumot jelöli, amely a tömbben található. Tehát frissíti itsproperties nem frissíti az eredeti.,

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 mutataz eredeti objektumra a tömbben. Ez nem úgy működik, 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 az operátor a legnyilvánvalóbb, ezért nézzük meg először., Szeretem a -joinoperátort, és gyakran használom. Csatlakozik a tömb összes eleméhez a karakterrel vagy a karakterlánccal, amit megadsz.

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

az egyik jellemzője, hogy szeretem a -join operátor, hogy kezeli az egyes elemeket.

PS> 1 -join '-'1

ezt a belső naplózást és verbose üzeneteket használom.

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

-csatlakozzon a $array

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

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

használhatja a -join a tömböt előtag nélküli paraméterként. Vessen egy pillantást erre a példára tosee, hogy beszélek.

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

-replace and-split

a többi operátor, mint a -replaceés -split execute on each elem in the array. 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-01LAX-SQL-02LAX-SQL-03

-tartalmaz

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

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

-in

ha egyetlen értéke van, amelyet ellenőrizni szeretne a több érték egyikével, akkorhasználja a -in operátort. Az érték a bal oldalon, a tömb pedig az operátor jobb oldalán lenne.

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

Ez drága lehet, ha a lista nagy. Gyakran használom a regex mintát, ha többet ellenőrzöknéhány érték.,

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

-eq and-ne

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

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

a -ne operátor használatakor minden olyan értéket kapunk, amely nem egyenlő az értékünkkel.

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

ha ezt egy if() nyilatkozatban használja, a visszaküldött érték egy True érték., Ha nincs érték vissza, akkor ez egy False érték. Mindkét következő kijelentés értéke True.

$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

The -match az operátor 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-01ATX-SQL-01

Ha -match egy értéket használ, egy speciális változó $Matches a matchinfo-val lesz feltöltve., Nem ez a helyzet, ha egy tömböt ilyen módon dolgoznak fel.

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

$servers | Select-String SQL

közelebbről megvizsgálom a Select-String,-match és a $matches változót egy másik bejegyzésben a regex használatának számos módjára hívták.

$null vagy üres

a$null vagy az üres tömbök tesztelése trükkös lehet. 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. Így több olyan elemünk is lehet, amelyek egyetlen $null értékkel rendelkeznek, és $true

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

ezért a legjobb gyakorlat a $null elhelyezése az operátor bal oldalán. Ez a forgatókönyv nem jelent problémát.

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 aa benne lévő objektumok száma., Ha a tömb $null, a szám 0.

if ( $array.count -gt 0 ){ "Array isn't empty"}

van még egy csapda, hogy néz ki itt. Használhatja a countakkor is, ha van egy singleobject, kivéve, ha ez 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 PowerShell 5.1, akkor csomagolja az objektumot egy tömbben ellenőrzése előtt a gróf toget pontos száma.,

if ( @($array).count -gt 0 ){ "Array isn't empty"}

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

if ( $null -ne $array -and @($array).count -gt 0 ){ "Array isn't empty"}

All-eq

nemrég láttam valakit megkérdezni, 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, majdflips az eredmény.

$results = Test-Somethingif ( -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 fel kell nőnie, vagy hozzá kell adnia egy elemet, akkorúj tömböt kell létrehoznia, majd az összes értéket át kell másolnia a régi tömbből. Ez úgy hangzik, mint egy csomó munka, azonban a PowerShell elrejti az új tömb létrehozásának összetettségét. PowerShellimplements a kiegészítés operátor (+) A tömbök.

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 + $secondZeroOneTwoThree

Plus egyenlő +=

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

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

csak ne feledje, hogy minden alkalommal, amikor a += új tömböt hoz létre tömb. 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, ha multipleitemeket tartalmaz.

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

általában, amikor a csővezeték használatára gondolunk, a tipikus PowerShell egybélésekre gondolunk. A csővezetéket foreach() utasításokkal és egyéb hurkokkal tudjuk levezetni. Tehát ahelyett, hogy elemeket adnánk anarray-hez egy hurokban, dobhatunk elemeket a csővezetékre.

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

Tömbtípusok

alapértelmezés szerint a PowerShellben lévő tömb] típus., Ez lehetővé teszi, hogy tartalmazzabármilyen típusú objektum vagy érték. 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ömbbe az egyik legnagyobb korlátja, de van néhány más gyűjteményekhogy fordulhatunk, hogy megoldja ezt a problémát.,

a ArrayList általában az egyik első dolog, amit gondolunk, amikor szükségünk van egy tömb isfaster dolgozni. Úgy viselkedik, mint egy objektum tömb minden helyen, hogy szükségünk van rá, de kezeli addingitems 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áljukhozzon létre. Ezután hívjuk a Add módszert egy elem hozzáadásához.,

az ok, amiért a elején a sor, hogy elnyomja a visszatérési kódot. Some.NET a hívások ezt teszik, és váratlan kimenetet hozhatnak létre.

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

gyakori, hogy az emberek ArrayList tömbökről költöznek. De ez egy olyan időszakból származik, amikor a C# nem rendelkezettáltalános Támogatással., A ArrayList elavult a generikus List

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ó meghatározza a létrehozáskor használt adattípusokat. Tehát, ha számokat vagy karakterláncokat szeretne, akkor meghatározzahogy a int vagy string típusok listáját szeretné.

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

$mylist = ]::new()

vagy a számok listája.,

$mylist = ]::new()

egy létező tömböt leadhatunk egy ilyen listára anélkül, hogy először létrehoznánk az objektumot:

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

lerövidíthetjük a szintaxist a using namespace utasítás PowerShell 5 és újabb. Ausing utasítás a szkript első sorának kell lennie. Egy névtér deklarálásával a PowerShelllets elhagyja az adattípusokat, amikor hivatkozik rájuk.

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

Ez teszi a List 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éka Addmódszer, í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> $myList10

List

bármilyen típusú lista lehet, de ha nem ismeri az objektumok típusát, akkor a] – ot használhatja.,

$list = ]::new()

Eltávolítás()

The ArrayListés az Általános List 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")ZeroOneThree

értéktípusok használatakor eltávolítja az elsőt a listáról. Hívhatja újra és újra, hogy továbbra is eltávolítsa ezt az értéket. Ha referenciatípusai vannak, meg kell adnia az objektumothogy el szeretné távolítani.,

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

$delete = $drives$drives.remove($delete)

az eltávolítási módszer true ha képes volt megtalálni és eltávolítani az elemet a gyűjteményből.

további gyűjtemények

sok más gyűjtemény is használható, de ezek a jó Generikus tömb csere.Ha többet szeretne megtudni ezekről a lehetőségekről, vessen egy pillantást erre a kérdésre.

egyéb árnyalatok

most, hogy lefedtem az összes főbb funkciót, itt van még néhány dolog, amit akartam tomention mielőtt lezárom ezt.,

előre méretezett tömbök

megemlítettem, hogy a létrehozás után nem változtathatja meg a tömb méretét. Létrehozhatunk egy tömbötegy előre meghatározott méret a new($size) konstruktorral.

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

szorzó tömbök

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

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

inicializálás 0

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

PS> ]::new(4)0000

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

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

a szorzás trükkje az, hogy bármilyen értéket használhat. Tehát ha inkábbvan 255 alapértelmezett értékként, ez jó módja annak.

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

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 gridlike mintába illeszkednek.,

itt van két módon tudunk létrehozni egy kétdimenzió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éldát egy normál tömbbeltöbb sor, ahol a vessző opcionális volt. Nem ez a helyzet egy többdimenziós tömb esetében.

az index jelölés használata 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 = 0PS> $inside = 2PS> $data3

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

Write-Output-NoEnumerate

PowerShell szeret kicsomagolni vagy felsorolni tömbök. Ez a PowerShell thepipeline 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-MemberTypeName: System.String...

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

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

van egy második út, ami inkább egy hack (és megpróbálom elkerülni hack, mint ez). Akkor helyezze acomma előtt a tömb, mielőtt cső is.

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

visszaad egy tömböt

Ez a tömbök kicsomagolása akkor is megtörténik, ha egy függvényből értékeket ad ki vagy ad vissza. Akkor is kaphat 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 van egy új tömb., Ha ez valaha is probléma, akkor aWrite-Output -NoEnumerate $array vagyreturn ,$array segítségével dolgozhat körülötte.

bármi más?