Semua yang ingin Anda ketahui tentang hashtable

Saya ingin mengambil langkah mundur dan berbicara tentang hashtable. Aku menggunakannya sepanjang waktu sekarang. Aku mengajar seseorang tentang mereka setelah pertemuan kelompok pengguna kami tadi malam dan aku menyadari aku memiliki kebingungan yang sama tentang mereka seperti yang dia miliki. Hashtable sangat penting di PowerShell sehingga baik untuk memiliki pemahaman yang kuat tentang mereka.

Catatan

Versi asli artikel ini muncul di blog yang ditulis oleh @KevinMarquette. Tim PowerShell berterima kasih kepada Kevin karena telah membagikan konten ini kepada kami. Silakan lihat blognya di PowerShellExplained.com.

Hashtable sebagai kumpulan hal-hal

Pertama-tama saya ingin Anda melihat Hashtable sebagai koleksi dalam definisi tradisional dari hashtable. Definisi ini memberi Anda pemahaman mendasar tentang cara kerjanya ketika mereka digunakan untuk hal-hal yang lebih canggih nanti. Melewatkan pemahaman ini sering menjadi sumber kebingungan.

Apa itu array?

Sebelum saya melompat ke apa itu Hashtable , saya perlu menyebutkan array terlebih dahulu. Untuk tujuan diskusi ini, array adalah daftar atau kumpulan nilai atau objek.

$array = @(1,2,3,5,7,11)

Setelah Anda memasukkan item ke dalam array, Anda dapat menggunakan foreach untuk melakukan iterasi di atas daftar atau menggunakan indeks untuk mengakses elemen individual dalam array.

foreach($item in $array)
{
    Write-Output $item
}

Write-Output $array[3]

Anda juga dapat memperbarui nilai menggunakan indeks dengan cara yang sama.

$array[2] = 13

Saya hanya menggaruk permukaan pada array tetapi itu harus menempatkan mereka ke dalam konteks yang tepat saat saya pindah ke hashtables.

Apa itu hashtable?

Saya akan mulai dengan deskripsi teknis dasar tentang apa itu hashtable, dalam arti umum, sebelum saya beralih ke cara lain PowerShell menggunakannya.

Hashtable adalah struktur data, seperti array, kecuali Anda menyimpan setiap nilai (objek) menggunakan kunci. Ini adalah penyimpanan kunci/nilai dasar. Pertama, kita membuat hashtable kosong.

$ageList = @{}

Perhatikan bahwa kurung kurawal, alih-alih tanda kurung, digunakan untuk menentukan hashtable. Kemudian kita menambahkan item menggunakan kunci seperti ini:

$key = 'Kevin'
$value = 36
$ageList.add( $key, $value )

$ageList.add( 'Alex', 9 )

Nama orang itu adalah kunci dan usia mereka adalah nilai yang ingin saya simpan.

Menggunakan tanda kurung untuk akses

Setelah menambahkan nilai ke hashtable, Anda dapat menariknya kembali menggunakan kunci yang sama (alih-alih menggunakan indeks numerik seperti yang Anda miliki untuk array).

$ageList['Kevin']
$ageList['Alex']

Ketika aku ingin usia Kevin, aku menggunakan namanya untuk mengaksesnya. Kita dapat menggunakan pendekatan ini untuk menambahkan atau memperbarui nilai ke dalam hashtable juga. Ini sama seperti menggunakan fungsi di add() atas.

$ageList = @{}

$key = 'Kevin'
$value = 36
$ageList[$key] = $value

$ageList['Alex'] = 9

Ada sintaks lain yang dapat Anda gunakan untuk mengakses dan memperbarui nilai yang akan saya bahas di bagian selanjutnya. Jika Anda datang ke PowerShell dari bahasa lain, contoh-contoh ini harus sesuai dengan bagaimana Anda mungkin telah menggunakan hashtable sebelumnya.

Membuat hashtable dengan nilai

Sejauh ini saya telah membuat hashtable kosong untuk contoh-contoh ini. Anda dapat mengisi kunci dan nilai terlebih dahulu saat membuatnya.

$ageList = @{
    Kevin = 36
    Alex  = 9
}

Sebagai tabel pencarian

Nilai nyata dari jenis hashtable ini adalah Anda dapat menggunakannya sebagai tabel pencarian. Berikut contoh sederhana.

$environments = @{
    Prod = 'SrvProd05'
    QA   = 'SrvQA02'
    Dev  = 'SrvDev12'
}

$server = $environments[$env]

Dalam contoh ini, Anda menentukan lingkungan untuk $env variabel dan akan memilih server yang benar. Anda bisa menggunakan switch($env){...} untuk pilihan seperti ini tetapi hashtable adalah pilihan yang bagus.

Ini menjadi lebih baik ketika Anda secara dinamis membangun tabel pencarian untuk menggunakannya nanti. Jadi pikirkan tentang menggunakan pendekatan ini ketika Anda perlu merujuk silang sesuatu. Saya pikir kita akan melihat ini bahkan lebih jika PowerShell tidak begitu baik dalam memfilter pipa dengan Where-Object. Jika Anda pernah berada dalam situasi di mana performa penting, pendekatan ini perlu dipertimbangkan.

Saya tidak akan mengatakan bahwa itu lebih cepat, tetapi memang sesuai dengan aturan Jika performa penting, mengujinya.

Multiseleksi

Umumnya, Anda menganggap hashtable sebagai pasangan kunci/nilai, di mana Anda menyediakan satu kunci dan mendapatkan satu nilai. PowerShell memungkinkan Anda menyediakan array kunci untuk mendapatkan beberapa nilai.

$environments[@('QA','DEV')]
$environments[('QA','DEV')]
$environments['QA','DEV']

Dalam contoh ini, saya menggunakan hashtable pencarian yang sama dari atas dan menyediakan tiga gaya array yang berbeda untuk mendapatkan kecocokan. Ini adalah permata tersembunyi di PowerShell yang tidak diketahui kebanyakan orang.

Iterasi hashtable

Karena hashtable adalah kumpulan pasangan kunci/nilai, Anda melakukan iterasi di atasnya secara berbeda dari yang Anda lakukan untuk array atau daftar item normal.

Hal pertama yang perlu diperhatikan adalah bahwa jika Anda menyalurkan hashtable Anda, pipa memperlakukannya seperti satu objek.

PS> $ageList | Measure-Object
count : 1

Meskipun .count properti memberi tahu Anda berapa banyak nilai yang dikandungnya.

PS> $ageList.count
2

Anda mengatasi masalah ini dengan menggunakan .values properti jika yang Anda butuhkan hanyalah nilai.

PS> $ageList.values | Measure-Object -Average
Count   : 2
Average : 22.5

Seringkali lebih berguna untuk menghitung kunci dan menggunakannya untuk mengakses nilai.

PS> $ageList.keys | ForEach-Object{
    $message = '{0} is {1} years old!' -f $_, $ageList[$_]
    Write-Output $message
}
Kevin is 36 years old
Alex is 9 years old

Berikut adalah contoh yang sama dengan perulangan foreach(){...} .

foreach($key in $ageList.keys)
{
    $message = '{0} is {1} years old' -f $key, $ageList[$key]
    Write-Output $message
}

Kami berjalan setiap kunci dalam hashtable dan kemudian menggunakannya untuk mengakses nilai. Ini adalah pola umum saat bekerja dengan hashtable sebagai koleksi.

GetEnumerator()

Itu membawa kita untuk GetEnumerator() iterasi atas hashtable kita.

$ageList.GetEnumerator() | ForEach-Object{
    $message = '{0} is {1} years old!' -f $_.key, $_.value
    Write-Output $message
}

Enumerator memberi Anda setiap pasangan kunci/nilai satu demi satu. Ini dirancang khusus untuk kasus penggunaan ini. Terima kasih untuk Mark Kraus karena mengingatkanku pada yang satu ini.

BadEnumeration

Salah satu detail penting adalah Anda tidak dapat memodifikasi hashtable saat sedang dijumlahkan. Jika kita mulai dengan contoh dasar $environments kita:

$environments = @{
    Prod = 'SrvProd05'
    QA   = 'SrvQA02'
    Dev  = 'SrvDev12'
}

Dan mencoba mengatur setiap kunci ke nilai server yang sama gagal.

$environments.Keys | ForEach-Object {
    $environments[$_] = 'SrvDev03'
}

An error occurred while enumerating through a collection: Collection was modified; enumeration operation may not execute.
+ CategoryInfo          : InvalidOperation: tableEnumerator:HashtableEnumerator) [], RuntimeException
+ FullyQualifiedErrorId : BadEnumeration

Ini juga akan gagal meskipun terlihat seperti seharusnya juga baik-baik saja:

foreach($key in $environments.keys) {
    $environments[$key] = 'SrvDev03'
}

Collection was modified; enumeration operation may not execute.
    + CategoryInfo          : OperationStopped: (:) [], InvalidOperationException
    + FullyQualifiedErrorId : System.InvalidOperationException

Trik untuk situasi ini adalah mengkloning kunci sebelum melakukan enumerasi.

$environments.Keys.Clone() | ForEach-Object {
    $environments[$_] = 'SrvDev03'
}

Hashtable sebagai kumpulan properti

Sejauh ini jenis objek yang kami tempatkan di hashtable kami semuanya adalah jenis objek yang sama. Saya menggunakan usia dalam semua contoh tersebut dan kuncinya adalah nama orang tersebut. Ini adalah cara yang bagus untuk melihatnya ketika koleksi objek Anda masing-masing memiliki nama. Cara umum lain untuk menggunakan hashtable di PowerShell adalah dengan menyimpan kumpulan properti di mana kuncinya adalah nama properti . Saya akan melangkah ke ide itu dalam contoh berikutnya.

Akses berbasis properti

Penggunaan akses berbasis properti mengubah dinamika hashtable dan bagaimana Anda dapat menggunakannya di PowerShell. Berikut adalah contoh kami yang biasa dari atas memperlakukan kunci sebagai properti.

$ageList = @{}
$ageList.Kevin = 35
$ageList.Alex = 9

Sama seperti contoh di atas, contoh ini menambahkan kunci tersebut jika belum ada di hashtable. Tergantung pada bagaimana Anda mendefinisikan kunci Anda dan apa nilai-nilai Anda, ini agak aneh atau cocok. Contoh daftar usia telah bekerja dengan baik hingga saat ini. Kita perlu contoh baru agar ini terasa benar ke depannya.

$person = @{
    name = 'Kevin'
    age  = 36
}

Dan kita dapat menambahkan dan mengakses atribut pada $person seperti ini.

$person.city = 'Austin'
$person.state = 'TX'

Tiba-tiba hashtable ini mulai terasa dan bertindak seperti objek. Ini masih kumpulan hal-hal, jadi semua contoh di atas masih berlaku. Kami hanya mendekatinya dari sudut pandang yang berbeda.

Memeriksa kunci dan nilai

Dalam kebanyakan kasus, Anda hanya dapat menguji nilai dengan sesuatu seperti ini:

if( $person.age ){...}

Sederhana tetapi telah menjadi sumber banyak bug bagi saya karena saya mengabaikan satu detail penting dalam logika saya. Saya mulai menggunakannya untuk menguji apakah ada kunci. Ketika nilainya $false atau nol, pernyataan tersebut akan kembali $false secara tak terduga.

if( $person.age -ne $null ){...}

Ini bekerja di sekitar masalah itu untuk nilai nol tetapi tidak $null vs kunci yang tidak ada. Sebagian besar waktu Anda tidak perlu membuat perbedaan itu tetapi ada fungsi ketika Anda melakukannya.

if( $person.ContainsKey('age') ){...}

Kami juga memiliki ContainsValue() untuk situasi di mana Anda perlu menguji nilai tanpa mengetahui kunci atau iterasi seluruh koleksi.

Menghapus dan menghapus kunci

Anda dapat menghapus kunci dengan .Remove() fungsi .

$person.remove('age')

Menetapkan nilai kepada mereka $null hanya memberi Anda kunci yang memiliki $null nilai.

Cara umum untuk menghapus hashtable adalah dengan hanya menginisialisasinya ke hashtable kosong.

$person = @{}

Meskipun itu berhasil, cobalah untuk menggunakan fungsi sebagai gantinya clear() .

$person.clear()

Ini adalah salah satu instans di mana menggunakan fungsi membuat kode dokumentasi mandiri dan membuat niat kode sangat bersih.

Semua hal yang menyenangkan

Hashtable yang diurutkan

Secara default, hashtable tidak diurutkan (atau diurutkan). Dalam konteks tradisional, urutan tidak masalah ketika Anda selalu menggunakan kunci untuk mengakses nilai. Anda mungkin menemukan bahwa Anda ingin properti tetap dalam urutan yang Anda tentukan. Untungnya, ada cara untuk melakukannya dengan ordered kata kunci .

$person = [ordered]@{
    name = 'Kevin'
    age  = 36
}

Sekarang ketika Anda menghitung kunci dan nilai, kunci dan nilai tetap dalam urutan tersebut.

Hashtable sebaris

Saat menentukan hashtable pada satu baris, Anda dapat memisahkan pasangan kunci/nilai dengan titik koma.

$person = @{ name = 'kevin'; age = 36; }

Ini akan berguna jika Anda membuatnya di pipa.

Ekspresi kustom dalam perintah alur umum

Ada beberapa cmdlet yang mendukung penggunaan hashtable untuk membuat properti kustom atau terhitung. Anda biasanya melihat ini dengan Select-Object dan Format-Table. Hashtable memiliki sintaks khusus yang terlihat seperti ini ketika sepenuhnya diperluas.

$property = @{
    name = 'totalSpaceGB'
    expression = { ($_.used + $_.free) / 1GB }
}

name adalah apa cmdlet akan melabeli kolom itu. expression adalah blok skrip yang dijalankan di mana $_ adalah nilai objek pada pipa. Berikut adalah skrip yang sedang beraksi:

$drives = Get-PSDrive | Where Used
$drives | Select-Object -Property name, $property

Name     totalSpaceGB
----     ------------
C    238.472652435303

Saya menempatkannya dalam variabel tetapi dapat dengan mudah didefinisikan sebaris dan Anda dapat mempersingkat name ke n dan expression ke e saat Anda berada di dalamnya.

$drives | Select-Object -property name, @{n='totalSpaceGB';e={($_.used + $_.free) / 1GB}}

Saya pribadi tidak suka berapa lama yang membuat perintah dan sering mempromosikan beberapa perilaku buruk yang tidak akan saya masuki. Saya lebih cenderung membuat hashtable baru atau pscustomobject dengan semua bidang dan properti yang saya inginkan alih-alih menggunakan pendekatan ini dalam skrip. Tapi ada banyak kode di luar sana yang melakukan ini jadi aku ingin kau menyadarinya. Saya berbicara tentang membuat pscustomobject nanti.

Ekspresi pengurutan kustom

Sangat mudah untuk mengurutkan koleksi jika objek memiliki data yang ingin Anda urutkan. Anda dapat menambahkan data ke objek sebelum mengurutkannya atau membuat ekspresi kustom untuk Sort-Object.

Get-ADUser | Sort-Object -Parameter @{ e={ Get-TotalSales $_.Name } }

Dalam contoh ini saya mengambil daftar pengguna dan menggunakan beberapa cmdlet kustom untuk mendapatkan informasi tambahan hanya untuk pengurutan.

Mengurutkan daftar Hashtable

Jika Anda memiliki daftar hashtable yang ingin Anda urutkan, Anda akan menemukan bahwa Sort-Object tidak memperlakukan kunci Anda sebagai properti. Kita bisa mendapatkan putaran dengan menggunakan ekspresi pengurutan kustom.

$data = @(
    @{name='a'}
    @{name='c'}
    @{name='e'}
    @{name='f'}
    @{name='d'}
    @{name='b'}
)

$data | Sort-Object -Property @{e={$_.name}}

Percikan hashtable pada cmdlet

Ini adalah salah satu hal favorit saya tentang hashtable yang tidak ditemukan banyak orang sejak dini. Idenya adalah bahwa alih-alih menyediakan semua properti ke cmdlet pada satu baris, Anda dapat mengemasnya ke dalam hashtable terlebih dahulu. Kemudian Anda dapat memberikan hashtable ke fungsi dengan cara khusus. Berikut adalah contoh pembuatan cakupan DHCP dengan cara normal.

Add-DhcpServerv4Scope -Name 'TestNetwork' -StartRange'10.0.0.2' -EndRange '10.0.0.254' -SubnetMask '255.255.255.0' -Description 'Network for testlab A' -LeaseDuration (New-TimeSpan -Days 8) -Type "Both"

Tanpa menggunakan percikan, semua hal tersebut perlu didefinisikan pada satu baris. Ini baik menggulir dari layar atau akan membungkus di mana pun rasanya. Sekarang bandingkan dengan perintah yang menggunakan percikan.

$DHCPScope = @{
    Name        = 'TestNetwork'
    StartRange  = '10.0.0.2'
    EndRange    = '10.0.0.254'
    SubnetMask  = '255.255.255.0'
    Description = 'Network for testlab A'
    LeaseDuration = (New-TimeSpan -Days 8)
    Type = "Both"
}
Add-DhcpServerv4Scope @DHCPScope

Penggunaan @ tanda alih-alih $ adalah apa yang memanggil operasi splat.

Luangkan waktu sejenak untuk menghargai betapa mudahnya contoh itu dibaca. Mereka adalah perintah yang sama persis dengan semua nilai yang sama. Yang kedua lebih mudah dipahami dan dipertahankan ke depan.

Saya menggunakan splatting kapan saja perintah terlalu lama. Saya mendefinisikan terlalu lama karena menyebabkan jendela saya menggulir ke kanan. Jika saya menekan tiga properti untuk fungsi, kemungkinannya adalah saya akan menulis ulang menggunakan hashtable yang tercipta.

Splatting untuk parameter opsional

Salah satu cara paling umum saya menggunakan percikan adalah dengan menangani parameter opsional yang berasal dari beberapa tempat lain dalam skrip saya. Katakanlah saya memiliki fungsi yang membungkus Get-CIMInstance panggilan yang memiliki argumen opsional $Credential .

$CIMParams = @{
    ClassName = 'Win32_Bios'
    ComputerName = $ComputerName
}

if($Credential)
{
    $CIMParams.Credential = $Credential
}

Get-CIMInstance @CIMParams

Saya mulai dengan membuat hashtable saya dengan parameter umum. Kemudian saya menambahkan $Credential jika ada. Karena saya menggunakan splatting di sini, saya hanya perlu memiliki panggilan ke Get-CIMInstance dalam kode saya sekali. Pola desain ini sangat bersih dan dapat menangani banyak parameter opsional dengan mudah.

Agar adil, Anda dapat menulis perintah Anda untuk memungkinkan $null nilai untuk parameter. Anda hanya tidak selalu memiliki kontrol atas perintah lain yang Anda panggil.

Beberapa splat

Anda dapat memercikkan beberapa hashtable ke cmdlet yang sama. Jika kita mengunjungi kembali contoh percikan asli kita:

$Common = @{
    SubnetMask  = '255.255.255.0'
    LeaseDuration = (New-TimeSpan -Days 8)
    Type = "Both"
}

$DHCPScope = @{
    Name        = 'TestNetwork'
    StartRange  = '10.0.0.2'
    EndRange    = '10.0.0.254'
    Description = 'Network for testlab A'
}

Add-DhcpServerv4Scope @DHCPScope @Common

Saya akan menggunakan metode ini ketika saya memiliki sekumpulan parameter umum yang saya berikan ke banyak perintah.

Splatting untuk kode bersih

Tidak ada yang salah dengan memercikkan satu parameter jika membuat Anda membersihkan kode.

$log = @{Path = '.\logfile.log'}
Add-Content "logging this command" @log

Splatting executables

Splatting juga berfungsi pada beberapa executable yang menggunakan /param:value sintaks. Robocopy.exe, misalnya, memiliki beberapa parameter seperti ini.

$robo = @{R=1;W=1;MT=8}
robocopy source destination @robo

Aku tidak tahu bahwa ini semua berguna, tapi aku menemukannya menarik.

Menambahkan hashtable

Hashtable mendukung operator tambahan untuk menggabungkan dua hashtable.

$person += @{Zip = '78701'}

Ini hanya berfungsi jika kedua hashtable tidak berbagi kunci.

Hashtable berlapis

Kita dapat menggunakan hashtable sebagai nilai di dalam hashtable.

$person = @{
    name = 'Kevin'
    age  = 36
}
$person.location = @{}
$person.location.city = 'Austin'
$person.location.state = 'TX'

Saya mulai dengan hashtable dasar yang berisi dua kunci. Saya menambahkan kunci yang disebut location dengan hashtable kosong. Kemudian saya menambahkan dua item terakhir ke hashtable tersebut location . Kita bisa melakukan ini semua sebaris juga.

$person = @{
    name = 'Kevin'
    age  = 36
    location = @{
        city  = 'Austin'
        state = 'TX'
    }
}

Ini menciptakan hashtable yang sama dengan yang kita lihat di atas dan dapat mengakses properti dengan cara yang sama.

$person.location.city
Austin

Ada banyak cara untuk mendekati struktur objek Anda. Berikut adalah cara kedua untuk melihat hashtable berlapis.

$people = @{
    Kevin = @{
        age  = 36
        city = 'Austin'
    }
    Alex = @{
        age  = 9
        city = 'Austin'
    }
}

Ini mencampur konsep penggunaan hashtable sebagai kumpulan objek dan kumpulan properti. Nilainya masih mudah diakses bahkan ketika ditumpuk menggunakan pendekatan apa pun yang Anda sukai.

PS> $people.kevin.age
36
PS> $people.kevin['city']
Austin
PS> $people['Alex'].age
9
PS> $people['Alex']['City']
Austin

Saya cenderung menggunakan properti titik ketika saya memperlakukannya seperti properti . Itu umumnya hal-hal yang telah saya tentukan secara statis dalam kode saya dan saya tahu mereka dari atas kepala saya. Jika saya perlu memanjat daftar atau mengakses kunci secara terprogram, saya menggunakan tanda kurung untuk memberikan nama kunci.

foreach($name in $people.keys)
{
    $person = $people[$name]
    '{0}, age {1}, is in {2}' -f $name, $person.age, $person.city
}

Memiliki kemampuan untuk menyarangkan hashtable memberi Anda banyak fleksibilitas dan opsi.

Melihat hashtable berlapis

Segera setelah Anda mulai menyarangkan hashtable, Anda akan membutuhkan cara mudah untuk melihatnya dari konsol. Jika saya mengambil hashtable terakhir, saya mendapatkan output yang terlihat seperti ini dan hanya masuk begitu dalam:

PS> $people
Name                           Value
----                           -----
Kevin                          {age, city}
Alex                           {age, city}

Saya pergi ke perintah untuk melihat hal-hal ini adalah ConvertTo-JSON karena sangat bersih dan saya sering menggunakan JSON pada hal-hal lain.

PS> $people | ConvertTo-Json
{
    "Kevin":  {
                "age":  36,
                "city":  "Austin"
            },
    "Alex":  {
                "age":  9,
                "city":  "Austin"
            }
}

Bahkan jika Anda tidak tahu JSON, Anda harus dapat melihat apa yang Anda cari. Ada Format-Custom perintah untuk data terstruktur seperti ini tetapi saya masih menyukai tampilan JSON dengan lebih baik.

Membuat objek-objek

Terkadang Anda hanya perlu memiliki objek dan menggunakan hashtable untuk menahan properti hanya tidak menyelesaikan pekerjaan. Paling umum Anda ingin melihat kunci sebagai nama kolom. A pscustomobject membuatnya mudah.

$person = [pscustomobject]@{
    name = 'Kevin'
    age  = 36
}

$person

name  age
----  ---
Kevin  36

Bahkan jika Anda tidak membuatnya sebagai pscustomobject awalnya, Anda selalu dapat melemparkannya nanti saat diperlukan.

$person = @{
    name = 'Kevin'
    age  = 36
}

[pscustomobject]$person

name  age
----  ---
Kevin  36

Saya sudah memiliki penulisan terperinci untuk pscustomobject yang harus Anda baca setelah yang satu ini. Ini dibangun pada banyak hal yang dipelajari di sini.

Membaca dan menulis hashtable ke file

Menyimpan ke CSV

Berjuang dengan mendapatkan hashtable untuk menyimpan ke CSV adalah salah satu kesulitan yang saya lihat di atas. Konversi hashtable Anda menjadi pscustomobject dan akan disimpan dengan benar ke CSV. Ini membantu jika Anda memulai dengan pscustomobject sehingga urutan kolom dipertahankan. Tetapi Anda dapat mentransmisikannya ke sebaris pscustomobject jika diperlukan.

$person | ForEach-Object{ [pscustomobject]$_ } | Export-CSV -Path $path

Sekali lagi, lihat tulisan saya tentang menggunakan pscustomobject.

Menyimpan hashtable berlapis ke file

Jika saya perlu menyimpan hashtable berlapis ke file dan kemudian membacanya kembali, saya menggunakan cmdlet JSON untuk melakukannya.

$people | ConvertTo-JSON | Set-Content -Path $path
$people = Get-Content -Path $path -Raw | ConvertFrom-JSON

Ada dua poin penting tentang metode ini. Pertama adalah bahwa JSON ditulis secara multibaris sehingga saya perlu menggunakan -Raw opsi untuk membacanya kembali menjadi satu string. Yang Kedua adalah bahwa objek yang diimpor bukan lagi .[hashtable] Sekarang menjadi [pscustomobject] dan yang dapat menyebabkan masalah jika Anda tidak mengharapkannya.

Perhatikan hashtable yang sangat berlapis. Ketika Anda mengonversinya ke JSON, Anda mungkin tidak mendapatkan hasil yang Anda harapkan.

@{ a = @{ b = @{ c = @{ d = "e" }}}} | ConvertTo-Json

{
  "a": {
    "b": {
      "c": "System.Collections.Hashtable"
    }
  }
}

Gunakan parameter Kedalaman untuk memastikan bahwa Anda telah memperluas semua hashtable berlapis.

@{ a = @{ b = @{ c = @{ d = "e" }}}} | ConvertTo-Json -Depth 3

{
  "a": {
    "b": {
      "c": {
        "d": "e"
      }
    }
  }
}

Jika Anda membutuhkannya untuk diimpor [hashtable] , maka Anda perlu menggunakan Export-CliXml perintah dan Import-CliXml .

Mengonversi JSON ke Hashtable

Jika Anda perlu mengonversi JSON ke [hashtable], ada satu cara yang saya tahu untuk melakukannya dengan JavaScriptSerializer di .NET.

[Reflection.Assembly]::LoadWithPartialName("System.Web.Script.Serialization")
$JSSerializer = [System.Web.Script.Serialization.JavaScriptSerializer]::new()
$JSSerializer.Deserialize($json,'Hashtable')

Dimulai di PowerShell v6, dukungan JSON menggunakan NewtonSoft JSON.NET dan menambahkan dukungan hashtable.

'{ "a": "b" }' | ConvertFrom-Json -AsHashtable

Name      Value
----      -----
a         b

PowerShell 6.2 menambahkan parameter Kedalaman ke ConvertFrom-Json. Kedalaman default adalah 1024.

Membaca langsung dari file

Jika Anda memiliki file yang berisi hashtable menggunakan sintaks PowerShell, ada cara untuk mengimpornya secara langsung.

$content = Get-Content -Path $Path -Raw -ErrorAction Stop
$scriptBlock = [scriptblock]::Create( $content )
$scriptBlock.CheckRestrictedLanguage( $allowedCommands, $allowedVariables, $true )
$hashtable = ( & $scriptBlock )

Ini mengimpor konten file ke dalam scriptblock, lalu memeriksa untuk memastikannya tidak memiliki perintah PowerShell lainnya di dalamnya sebelum menjalankannya.

Pada catatan itu, tahukah Anda bahwa manifes modul (file psd1) hanya hashtable?

Kunci dapat berupa objek apa pun

Sebagian besar waktu, kuncinya hanyalah string. Jadi kita bisa menaruh tanda kutip di sekitar apa pun dan menjadikannya kunci.

$person = @{
    'full name' = 'Kevin Marquette'
    '#' = 3978
}
$person['full name']

Anda dapat melakukan beberapa hal aneh yang mungkin tidak Anda sadari dapat Anda lakukan.

$person.'full name'

$key = 'full name'
$person.$key

Hanya karena anda dapat melakukan sesuatu, itu tidak berarti bahwa Anda harus. Yang terakhir itu hanya terlihat seperti bug yang menunggu untuk terjadi dan akan dengan mudah disalahpahami oleh siapa pun yang membaca kode Anda.

Secara teknis kunci Anda tidak harus berupa string tetapi lebih mudah dipikirkan jika Anda hanya menggunakan string. Namun, pengindeksan tidak berfungsi dengan baik dengan kunci yang kompleks.

$ht = @{ @(1,2,3) = "a" }
$ht

Name                           Value
----                           -----
{1, 2, 3}                      a

Mengakses nilai dalam hashtable dengan kuncinya tidak selalu berfungsi. Contohnya:

$key = $ht.keys[0]
$ht.$($key)
a
$ht[$key]
a

Ketika kunci adalah array, Anda harus membungkus $key variabel dalam subekspresi sehingga dapat digunakan dengan notasi akses anggota (.). Atau, Anda dapat menggunakan notasi indeks array ([]).

Gunakan dalam variabel otomatis

$PSBoundParameters

$PSBoundParameters adalah variabel otomatis yang hanya ada di dalam konteks fungsi. Ini berisi semua parameter yang dipanggil fungsi. Ini bukan hashtable tetapi cukup dekat sehingga Anda dapat memperlakukannya seperti itu.

Itu termasuk menghapus kunci dan memercikkannya ke fungsi lain. Jika Anda menemukan diri Anda menulis fungsi proksi, lihat lebih dekat yang satu ini.

Lihat about_Automatic_Variables untuk detail selengkapnya.

PSBoundParameters gotcha

Satu hal penting yang perlu diingat adalah bahwa ini hanya mencakup nilai yang diteruskan sebagai parameter. Jika Anda juga memiliki parameter dengan nilai default tetapi tidak diteruskan oleh pemanggil, $PSBoundParameters tidak berisi nilai-nilai tersebut. Ini biasanya diabaikan.

$PSDefaultParameterValues

Variabel otomatis ini memungkinkan Anda menetapkan nilai default ke cmdlet apa pun tanpa mengubah cmdlet. Lihat contoh ini.

$PSDefaultParameterValues["Out-File:Encoding"] = "UTF8"

Ini menambahkan entri ke $PSDefaultParameterValues hashtable yang ditetapkan UTF8 sebagai nilai default untuk Out-File -Encoding parameter . Ini khusus sesi sehingga Anda harus menempatkannya di .$profile

Saya sering menggunakan ini untuk menetapkan nilai sebelumnya yang saya ketik cukup sering.

$PSDefaultParameterValues[ "Connect-VIServer:Server" ] = 'VCENTER01.contoso.local'

Ini juga menerima wildcard sehingga Anda dapat mengatur nilai secara massal. Berikut adalah beberapa cara untuk menggunakannya:

$PSDefaultParameterValues[ "Get-*:Verbose" ] = $true
$PSDefaultParameterValues[ "*:Credential" ] = Get-Credential

Untuk perincian yang lebih mendalam, lihat artikel hebat ini tentang Default Otomatis oleh Michael Sorens.

regex $Matches

Saat Anda menggunakan -match operator, variabel otomatis yang disebut $matches dibuat dengan hasil kecocokan. Jika Anda memiliki sub ekspresi di regex Anda, sub-kecocokan tersebut juga dicantumkan.

$message = 'My SSN is 123-45-6789.'

$message -match 'My SSN is (.+)\.'
$Matches[0]
$Matches[1]

Kecocokan bernama

Ini adalah salah satu fitur favorit saya yang tidak diketahui kebanyakan orang. Jika Anda menggunakan kecocokan regex bernama, maka Anda dapat mengakses yang cocok dengan nama pada kecocokan.

$message = 'My Name is Kevin and my SSN is 123-45-6789.'

if($message -match 'My Name is (?<Name>.+) and my SSN is (?<SSN>.+)\.')
{
    $Matches.Name
    $Matches.SSN
}

Dalam contoh di atas, (?<Name>.*) adalah sub ekspresi bernama. Nilai ini kemudian ditempatkan di $Matches.Name properti .

Group-Object -AsHashtable

Salah satu fitur Group-Object yang sedikit diketahui adalah dapat mengubah beberapa himpunan data menjadi hashtable untuk Anda.

Import-CSV $Path | Group-Object -AsHashtable -Property email

Ini akan menambahkan setiap baris ke dalam hashtable dan menggunakan properti yang ditentukan sebagai kunci untuk mengaksesnya.

Menyalin Hashtable

Satu hal penting yang perlu diketahui adalah bahwa hashtable adalah objek. Dan setiap variabel hanyalah referensi ke objek. Ini berarti bahwa dibutuhkan lebih banyak pekerjaan untuk membuat salinan hashtable yang valid.

Menetapkan jenis referensi

Ketika Anda memiliki satu hashtable dan menetapkannya ke variabel kedua, kedua variabel menunjuk ke hashtable yang sama.

PS> $orig = @{name='orig'}
PS> $copy = $orig
PS> $copy.name = 'copy'
PS> 'Copy: [{0}]' -f $copy.name
PS> 'Orig: [{0}]' -f $orig.name

Copy: [copy]
Orig: [copy]

Ini menyoroti bahwa nilainya sama karena mengubah nilai dalam satu nilai juga akan mengubah nilai di nilai lainnya. Ini juga berlaku saat meneruskan hashtable ke fungsi lain. Jika fungsi tersebut membuat perubahan pada hashtable tersebut, fungsi asli Anda juga diubah.

Salinan dangkal, tingkat tunggal

Jika kita memiliki hashtable sederhana seperti contoh kita di atas, kita dapat menggunakan .Clone() untuk membuat salinan dangkal.

PS> $orig = @{name='orig'}
PS> $copy = $orig.Clone()
PS> $copy.name = 'copy'
PS> 'Copy: [{0}]' -f $copy.name
PS> 'Orig: [{0}]' -f $orig.name

Copy: [copy]
Orig: [orig]

Ini akan memungkinkan kita untuk membuat beberapa perubahan dasar pada perubahan yang tidak berdampak pada yang lain.

Salinan dangkal, bersarang

Alasan mengapa itu disebut salinan dangkal adalah karena hanya menyalin properti tingkat dasar. Jika salah satu properti tersebut adalah jenis referensi (seperti hashtable lain), maka objek berlapis tersebut masih akan menunjuk satu sama lain.

PS> $orig = @{
        person=@{
            name='orig'
        }
    }
PS> $copy = $orig.Clone()
PS> $copy.person.name = 'copy'
PS> 'Copy: [{0}]' -f $copy.person.name
PS> 'Orig: [{0}]' -f $orig.person.name

Copy: [copy]
Orig: [copy]

Jadi Anda dapat melihat bahwa meskipun saya mengkloning hashtable, referensi untuk person tidak dikloning. Kita perlu membuat salinan mendalam untuk benar-benar memiliki hashtable kedua yang tidak terkait dengan yang pertama.

Salinan mendalam

Ada beberapa cara untuk membuat salinan mendalam dari hashtable (dan menyimpannya sebagai hashtable). Berikut adalah fungsi menggunakan PowerShell untuk membuat salinan mendalam secara rekursif:

function Get-DeepClone
{
    [CmdletBinding()]
    param(
        $InputObject
    )
    process
    {
        if($InputObject -is [hashtable]) {
            $clone = @{}
            foreach($key in $InputObject.keys)
            {
                $clone[$key] = Get-DeepClone $InputObject[$key]
            }
            return $clone
        } else {
            return $InputObject
        }
    }
}

Ini tidak menangani jenis referensi atau array lainnya, tetapi ini adalah titik awal yang baik.

Cara lain adalah menggunakan .Net untuk mendeserialisasinya menggunakan CliXml seperti dalam fungsi ini:

function Get-DeepClone
{
    param(
        $InputObject
    )
    $TempCliXmlString = [System.Management.Automation.PSSerializer]::Serialize($obj, [int32]::MaxValue)
    return [System.Management.Automation.PSSerializer]::Deserialize($TempCliXmlString)
}

Untuk hashtable yang sangat besar, fungsi deserialisasi lebih cepat saat diskalakan. Namun, ada beberapa hal yang perlu dipertimbangkan saat menggunakan metode ini. Karena menggunakan CliXml, memorinya intensif dan jika Anda mengkloning hashtable besar, itu mungkin menjadi masalah. Batasan lain dari CliXml adalah ada batasan kedalaman 48. Artinya, jika Anda memiliki hashtable dengan 48 lapisan hashtable berlapis, kloning akan gagal dan tidak ada hashtable yang akan menjadi output sama sekali.

Ada lagi?

Aku menutupi banyak tanah dengan cepat. Harapan saya adalah bahwa Anda berjalan pergi bersandar sesuatu yang baru atau memahaminya lebih baik setiap kali Anda membaca ini. Karena saya membahas spektrum lengkap fitur ini, ada aspek yang mungkin tidak berlaku untuk Anda sekarang. Itu sangat OK dan jenis yang diharapkan tergantung pada berapa banyak Anda bekerja dengan PowerShell.