PowerShell รับค่าคุณสมบัติของวัตถุตามชื่อ [9 วิธี]

รับค่าทรัพย์สินระดับแรกของวัตถุตามชื่อ

ใน PowerShell เรามีหลายวิธีในการรับค่าคุณสมบัติระดับแรกของวัตถุโดยใช้ชื่อของมัน ก่อนที่จะเจาะลึกโซลูชัน จำเป็นต้องทำความเข้าใจวิธีการสร้างออบเจ็กต์ใน PowerShell (หากคุณรู้อยู่แล้ว คุณสามารถข้ามไปยังโซลูชันได้) เราจะใช้วัตถุต่อไปนี้สำหรับโซลูชันทั้งหมดที่ได้รับคุณสมบัติระดับแรกของวัตถุตามชื่อของมัน

สร้างวัตถุใน PowerShell:

$props = $([ordered]@{
    firstName="John"
    lastName="Williamson"
    age=30
})
$object = New-Object PSObject -Property $props
$object

เอาท์พุท :

firstName lastName age
--------- -------- ---
John   Williamson     30

ขั้นแรก เราใช้ตารางแฮชเพื่อสร้างคู่ key=value ที่อยู่ภายใน @{} ตัวเลือก [ordered] ถูกใช้เพื่อให้มีคุณสมบัติในลำดับเดียวกันกับที่สร้างขึ้น มิฉะนั้น คุณสมบัติจะเรียงลำดับแบบสุ่มทุกครั้งที่คุณแสดงคุณสมบัติเหล่านั้น จากนั้น เราใส่ตารางแฮชที่สั่งไว้ภายในวงเล็บ (()) และนำหน้าด้วย $ เพื่อบอกให้ PowerShell ประเมินนิพจน์ทั้งหมดภายใน () โดยรวม จากนั้นกำหนดค่าที่ส่งคืนให้กับตัวแปร $props

หลังจากสร้างคุณสมบัติที่ต้องการสำเร็จแล้ว เราใช้ New-Object cmdlet เพื่อสร้างวัตถุและเก็บไว้ในตัวแปร $object $object นี้มีคุณสมบัติทั้งหมดที่เก็บไว้ใน $props; เราระบุไว้โดยใช้พารามิเตอร์ -Property ต่อไป เราใช้ New-Object cmdlet กับคลาส PSObject เพื่อเพิ่มคุณสมบัติที่กำหนดให้กับวัตถุเป็น NoteProperty NoteProperty ถูกสร้างขึ้นเมื่อเราระบุคุณสมบัติเฉพาะที่ไม่มีอยู่บนวัตถุนั้น โปรดจำไว้ว่า หากคุณไม่ได้ใช้คลาส PSObject สำหรับกรณีการใช้งานเฉพาะนี้ คุณจะได้รับข้อผิดพลาดที่ไม่ยุติซึ่งสร้างโดย New-Object cmdlet

ใช้เครื่องหมายจุด

ใช้เครื่องหมายจุด (.) เพื่อรับค่าคุณสมบัติของวัตถุตามชื่อใน PowerShell

ใช้เครื่องหมายจุด:

$object.firstName
$object.lastName
$object.age

เอาท์พุท :

John
Williamson
30

ใช้ Select-Object Cmdlet

ใช้ Select-Object cmdlet เพื่อรับค่าคุณสมบัติของวัตถุตามชื่อใน PowerShell

ใช้ Select-Object Cmdlet:

$object | Select-Object firstName

เอาท์พุท :

firstName
---------
John

ใช้ Select-Object cmdlet เพื่อรับค่าคุณสมบัติหลายค่าของวัตถุตามชื่อใน PowerShell

ใช้ Select-Object Cmdlet:

$object | Select-Object firstName, lastName, age

เอาท์พุท :

firstName lastName age
--------- -------- ---
John   Williamson     30

ใช้ Select-Object cmdlet พร้อมด้วยพารามิเตอร์ -ExpandProperty เพื่อรับค่าคุณสมบัติของวัตถุตามชื่อใน PowerShell เท่านั้น

ใช้ Select-Object กับ -ExpandProperty:

$object | Select-Object -ExpandProperty firstName

เอาท์พุท :

John

ในตัวอย่างข้างต้น $object คืออ็อบเจ็กต์ที่เราใช้เข้าถึงคุณสมบัติของมัน เราส่ง $object ไปที่ Select-Object cmdlet เพื่อรับค่าคุณสมบัติโดยใช้ชื่อคุณสมบัติ โปรดทราบว่า Select-Objectcmdlet ใช้เพื่อเลือกคุณสมบัติที่ระบุของวัตถุหรือชุดของวัตถุ และแสดงวัตถุที่มีชื่อคุณสมบัติและค่าของมัน หากคุณต้องการรับค่าคุณสมบัติเท่านั้น ให้ใช้พารามิเตอร์ -ExpandProperty พร้อมด้วย Select-Object cmdlet (เราใช้มันในข้อมูลโค้ดที่สาม)

พารามิเตอร์ -ExpandProperty ของ cmdlet Select-Object ใช้เพื่อดึงค่าของคุณสมบัติเดียวที่ระบุของวัตถุ และขยายลงในกระแสข้อมูลขาออกเป็นวัตถุใหม่ โปรดจำไว้ว่า คุณจะได้รับข้อผิดพลาดที่ระบุว่าไม่สามารถแปลง System.Object[] เป็นประเภท System.String ที่ต้องการโดยพารามิเตอร์ ExpandProperty หากคุณจะพยายามใช้ -ExpandProperty เพื่อขยายคุณสมบัติของ $object หลายรายการเนื่องจากใช้งานได้กับคุณสมบัติเดียวเท่านั้น

นอกจากนี้เรายังสามารถใช้นามแฝง Select เพื่อรับค่าคุณสมบัติของวัตถุตามชื่อใน PowerShell Select เป็นนามแฝงของ Select-Object cmdlet ดังนั้น การแทนที่ Select-Object ด้วย Select ในตัวอย่างข้างต้นก็จะใช้งานได้เช่นกัน

ใช้ รับสมาชิก Cmdlet

ใช้ Get-Member cmdlet เพื่อรับค่าคุณสมบัติเดียวของวัตถุตามชื่อใน PowerShell

ใช้ Get-Member Cmdlet:

$object | Get-Member -MemberType NoteProperty firstName

เอาท์พุท :

TypeName: System.Management.Automation.PSCustomObject
Name      MemberType   Definition
----      ----------   ----------
firstName NoteProperty string firstName=John

ใช้ Get-Member cmdlet เพื่อรับค่าคุณสมบัติหลายค่าของวัตถุตามชื่อใน PowerShell

ใช้ Get-Member Cmdlet:

$object | Get-Member -MemberType NoteProperty firstName, lastName

เอาท์พุท :

TypeName: System.Management.Automation.PSCustomObject
Name      MemberType   Definition
----      ----------   ----------
firstName NoteProperty string firstName=John
lastName  NoteProperty string lastName=Williamson

ใช้ cmdlet Get-Member พร้อมด้วยพารามิเตอร์ -ExpandProperty เพื่อรับค่าคุณสมบัติของวัตถุตามชื่อใน PowerShell เท่านั้น

ใช้ Get-Member Cmdlet:

$strObj = $object |
       Get-Member -MemberType NoteProperty firstName |
       Select-Object -ExpandProperty Definition
$strObj.Split('=')[1]

เอาท์พุท :

John

ในตัวอย่างข้างต้น เราได้ไพพ์ $object ไปที่ Get-Member cmdlet เพื่อดึงข้อมูลคุณสมบัติเฉพาะหรือคุณสมบัติ (คั่นด้วยเครื่องหมายจุลภาค) ดูตัวอย่างโค้ดตัวแรกและตัวที่สอง เราใช้พารามิเตอร์ -MemberType เพื่อบอก Get-Member cmdlet ว่าจะดึงข้อมูลอะไร ไม่ว่าจะเป็น Method, Property รหัส> หรือ <รหัส>คุณสมบัติหมายเหตุ; เราพูดถึง NoteProperty เพราะเราต้องการเข้าถึงคุณสมบัติที่เราสร้างขึ้น

ข้อมูลโค้ดที่สามจะคล้ายกับตัวอย่างแรกและตัวอย่างที่สอง โดยมีสิ่งเพิ่มเติมบางประการ นอกจากนี้ยังไพพ์ $object ไปยัง Get-Member cmdlet และตั้งค่าพารามิเตอร์ -MemberType เป็น NoteProperty สำหรับการดึงข้อมูล คุณสมบัติ firstName ที่นี่ Get-Member สร้าง PSCustomObject ที่มี Name, MemberType และ Definition คุณสมบัติ คุณใช้ $object | รับ Member -MemberType NoteProperty firstName เพื่อดู

เราส่ง PSCustomObject นี้ไปยัง Select-Object cmdlet ซึ่งเลือกคุณสมบัติ Definition และขยายโดยใช้ -ExpandProperty พารามิเตอร์ ตอนนี้ เราจะมีวัตถุประเภทสตริงเป็น string firstName=John; คุณสามารถดูได้โดยใช้ $object | รับสมาชิก - MemberType NoteProperty firstName | คำสั่ง Select-Object -ExpandProperty Definition

เราเก็บออบเจ็กต์สตริงนี้ไว้ในตัวแปร $strObj และเชื่อมโยงเมธอด Split() เพื่อแยก $strObj โดยใช้ = เป็นตัวคั่น เมธอด Split() ส่งคืนอาร์เรย์ของสตริงย่อยที่มีสองค่า: string firstName และ John เราใช้ตัวดำเนินการดัชนี ([1]) เพื่อดึงข้อมูลองค์ประกอบที่ดัชนี 1 ซึ่งก็คือ John

นอกจากนี้เรายังสามารถใช้นามแฝง gm เพื่อรับสมาชิกที่ระบุใน PowerShell gm เป็นนามแฝงของ Get-Member cmdlet ดังนั้น การแทนที่ Get-Member ด้วย gm ในตัวอย่างข้างต้นก็จะใช้งานได้เช่นกัน

เราใช้ ForEach-Object cmdlet เพื่อวนซ้ำวัตถุสตริงหลายตัวเพื่อรับค่าของคุณสมบัติทั้งหมดดังต่อไปนี้

ใช้นามแฝง gm กับ ForEach-Object Cmdlet:

$object |
gm -MemberType NoteProperty |
Select-Object -ExpandProperty Definition |
ForEach-Object { $_.Split('=')[1] }

เอาท์พุท :

30
John
Williamson

ในตัวอย่างข้างต้น เราได้กล่าวถึงชื่อคุณสมบัติแบบคงที่เพื่อรับค่า ซึ่งถือว่าใช้ได้หากออบเจ็กต์มีคุณสมบัติบางอย่าง แต่ในปัญหาในโลกแห่งความเป็นจริง วัตถุสามารถมีคุณสมบัติได้หลายร้อยรายการ และเป็นการยากที่จะจดจำคุณสมบัติทั้งหมดได้

ในกรณีนั้น เราเขียนสคริปต์ที่ยอมรับชื่อคุณสมบัติเป็นอินพุตของผู้ใช้และดึงค่าของมัน แนวทางใดบ้างที่สามารถนำมาใช้กับกรณีการใช้งานเฉพาะนี้ได้ มาเรียนรู้กันด้านล่าง โปรดจำไว้ว่าสคริปต์จะสร้างข้อผิดพลาดหากผู้ใช้ไม่ได้ระบุชื่อคุณสมบัติ

ใช้ Invoke-Expression Cmdlet

ใช้ Inrigger-Expression cmdlet เพื่อรับค่าคุณสมบัติของออบเจ็กต์ตามชื่อใน PowerShell

ใช้ Cmdlet เรียกใช้นิพจน์:

$propName = Read-Host "Please enter property name"
Invoke-Expression "`$object.$propName"

เอาท์พุท :

Please enter property name: firstName
John

ใช้ Inrigger-Expression cmdlet เพื่อรับค่าคุณสมบัติหลายค่าของวัตถุตามชื่อใน PowerShell

ใช้ Cmdlet เรียกใช้นิพจน์:

$propNames = Read-Host "Enter property names (comma-separated)"
Invoke-Expression "`$object | Select-Object $propNames"

เอาท์พุท :

Enter property names (comma-separated): firstName,age
firstName age
--------- ---
John    30

ในตัวอย่างโค้ดแรก เราใช้ Read-Host cmdlet เพื่อรับชื่อคุณสมบัติหนึ่งชื่อจากผู้ใช้และเก็บไว้ในตัวแปร $propName จากนั้น เราใช้ Inrigger-Expression cmdlet เพื่อประเมินสตริง "$object.$propName" เป็นนิพจน์ PowerShell นิพจน์สตริงนี้เข้าถึงคุณสมบัติที่กำหนดบน $object โดยใช้ค่าของตัวแปร $propName เราใช้ backtick เพื่อหลีกอักขระ $ เพื่อให้สามารถถือเป็นสตริงตัวอักษรแทนการอ้างอิงตัวแปร

รหัสรั้วที่สองนั้นคล้ายกับอันแรก แต่มีชื่อคุณสมบัติหลายชื่อจากผู้ใช้ คั่นด้วยเครื่องหมายจุลภาคและเก็บไว้ในตัวแปร $propNames นอกจากนี้ยังใช้เครื่องหมายย้อนกลับเพื่อหลีกอักขระ $ ในนิพจน์สตริง แต่นิพจน์สตริงคือ $object | เลือกวัตถุ $propNames ในครั้งนี้ ในที่นี้ Invoke-Expression cmdlet จะรันคำสั่งแบบไดนามิกเพื่อดึงคุณสมบัติเฉพาะจาก $object ที่เราไพพ์ไปยัง Select-Object cmdlet ยังไง? $propNames ถูกขยายและใช้เป็นอาร์กิวเมนต์ของ Select-Object cmdlet ซึ่งดึงคุณสมบัติที่กำหนดจาก $object

ใช้บล็อกสคริปต์

ใช้บล็อกสคริปต์เพื่อรับค่าคุณสมบัติของออบเจ็กต์ตามชื่อใน PowerShell

ใช้บล็อกสคริปต์:

$propName = Read-Host "Please enter property name"
$scriptBlock = { param($object) $object.$propName }
& $scriptBlock $object

เอาท์พุท :

Please enter property name: firstName
John

ใช้บล็อกสคริปต์เพื่อรับค่าคุณสมบัติหลายรายการของวัตถุตามชื่อใน PowerShell

ใช้บล็อกสคริปต์:

$propNames = Read-Host "Enter property names (comma-separated but not have space before/after a comma)"
$scriptBlock = { 
                 param($object, $propNames) $object |
                 Select-Object -Property ($propNames -split ',')
               }
& $scriptBlock $object $propNames

เอาท์พุท :

Enter property names (comma-separated but not have space before/after a comma): firstName,age
firstName age
--------- ---
John    30

ในตัวอย่างโค้ดแรก เราใช้ Read-Host cmdlet เพื่อรับชื่อคุณสมบัติหนึ่งชื่อจากผู้ใช้และเก็บไว้ในตัวแปร $propName จากนั้น เราได้สร้างบล็อกสคริปต์โดยใช้ {} และจัดเก็บไว้ในตัวแปร $scriptBlock บล็อกสคริปต์นี้ใช้ฟังก์ชัน param เพื่อยอมรับ $object เป็นอาร์กิวเมนต์และส่งคืนค่าของ $propName บน $object . สุดท้าย เราใช้ตัวดำเนินการ & เพื่อเรียกใช้ $scriptBlock โดยระบุ $object เป็นพารามิเตอร์

ตัวอย่างโค้ดที่สองคล้ายกับโค้ดแรก แต่ใช้ชื่อคุณสมบัติหลายชื่อจากผู้ใช้ซึ่งคั่นด้วยเครื่องหมายจุลภาคและจัดเก็บไว้ในตัวแปร $propNames ที่นี่ ในบล็อกสคริปต์ ฟังก์ชัน param รับสองอาร์กิวเมนต์: $object และ $propNames และส่งคืนค่าของ $propNames บน $object ยังไง? เราใช้ Select-Object กับพารามิเตอร์ -Property เพื่อเลือกคุณสมบัติที่ระบุจากวัตถุที่ไปป์ไป

โปรดทราบว่าตัวดำเนินการ -split ใช้เพื่อแยก $propNames โดยใช้เครื่องหมายจุลภาค (,); ในที่นี้ ใช้ลูกน้ำเป็นตัวคั่น สุดท้าย เราเรียกใช้ $scriptBlock โดยใช้ตัวดำเนินการ & และส่งผ่านตัวแปร $object และ $propNames เป็น พารามิเตอร์

ใช้เครื่องหมายจุดกับตัวแปร

ใช้เครื่องหมายจุดกับตัวแปรเพื่อรับค่าคุณสมบัติเดียวของวัตถุตามชื่อใน PowerShell

ใช้เครื่องหมายจุดกับตัวแปร:

$propName = Read-Host "Please enter property name"
$object.($propName)

เอาท์พุท :

Please enter property name: firstName
John

ใช้เครื่องหมายจุดกับตัวแปรเพื่อรับค่าคุณสมบัติหลายค่าของวัตถุตามชื่อใน PowerShell

ใช้เครื่องหมายจุดกับตัวแปร:

$propNames = Read-Host "Please enter property name  (comma-separated but not have space before/after a comma)"
$propNames -split "," | foreach {$object.($_)}

เอาท์พุท :

Please enter property name  (comma-separated but not have space before/after a comma): firstName,age
John
30

ในตัวอย่างแรก เราใช้ Read-Host cmdlet เพื่อรับชื่อคุณสมบัติจากผู้ใช้และจัดเก็บไว้ในตัวแปร $propName จากนั้น เราใช้เครื่องหมายจุดกับตัวแปรเป็น $object.($propName) เพื่อรับค่าของชื่อคุณสมบัติที่กำหนดสำหรับวัตถุที่ระบุ

ข้อมูลโค้ดที่สองจะคล้ายกับอันแรก แต่ยอมรับชื่อคุณสมบัติหลายชื่อ (คั่นด้วยเครื่องหมายจุลภาค) จากผู้ใช้ และจัดเก็บไว้ในตัวแปร $propNames จากนั้น เราใช้ตัวดำเนินการ -split เพื่อแยก $propNames โดยใช้ , เป็นตัวคั่น หลังจากดำเนินการแยก เราได้อาร์เรย์ของสตริงย่อยที่เราไพพ์ไปยังลูป foreach จากนั้น สำหรับแต่ละรายการของอาร์เรย์สตริงย่อยที่ได้รับ เราใช้เครื่องหมายจุดพร้อมตัวแปร ($_) เพื่อรับค่าของแต่ละคุณสมบัติ

วงเล็บเป็นทางเลือกในขณะที่ใช้เครื่องหมายจุดกับตัวแปร

รับค่าทรัพย์สินที่ซ้อนกันของวัตถุตามชื่อ

เราได้เรียนรู้วิธีสร้างวัตถุโดยใช้ PowerShell ในส่วนการรับค่าคุณสมบัติระดับแรกของวัตถุตามชื่อแล้ว สำหรับคุณสมบัติที่ซ้อนกัน เราสามารถสร้างได้สองวิธี:

1. การใช้ HashTable ที่ซ้อนกัน
2. การใช้ PSCustomObject

เราได้จัดเตรียมไว้ทั้งสองวิธีด้านล่างนี้ คุณสามารถใช้อันใดก็ได้ โซลูชันที่ให้มาทั้งหมดจะใช้ได้กับทั้งสองวิธีในการสร้างคุณสมบัติแบบซ้อน

วัตถุที่มีคุณสมบัติซ้อนกันโดยใช้ Nested HashTable:

$props = $([ordered]@{
    firstName="John"
    lastName="Williamson"
    age=30
    Address = @{
        Street = "245 Main Street"
        City = "Lahore"
    }
})
$object = New-Object PSObject -Property $props
$object

เอาท์พุท :

firstName lastName age Address
--------- -------- --- -------
John   Williamson     30 {City, Street}

วัตถุที่มีคุณสมบัติซ้อนกันโดยใช้ PSCustomObject:

$props = $([ordered]@{
    firstName="John"
    lastName="Williamson"
    age=30
    Address = [pscustomobject]@{
        Street = "245 Main Street"
        City = "Lahore"
    }
})
$object = New-Object PSObject -Property $props
$object

เอาท์พุท :

firstName lastName age Address
--------- -------- --- -------
John   Williamson     30 @{Street=245 Main Street; City=Lahore}

คุณสร้างวัตถุที่มีคุณสมบัติซ้อนกันหรือไม่? จากนั้นเรามาดูวิธีแก้ปัญหากันดีกว่า

ใช้เครื่องหมายจุด

ใช้เครื่องหมายจุดเพื่อรับค่าคุณสมบัติที่ซ้อนกันของวัตถุตามชื่อคุณสมบัติที่ซ้อนกันใน PowerShell

ใช้เครื่องหมายจุด:

$object.Address.City
$object.Address.Street

เอาท์พุท :

Lahore
245 Main Street

ใช้ Select-Object Cmdlet

ใช้ Select-Object cmdlet เพื่อรับค่าคุณสมบัติที่ซ้อนกันของวัตถุตามชื่อคุณสมบัติที่ซ้อนกันใน PowerShell

ใช้ Select-Object Cmdlet:

$object | Select-Object -ExpandProperty Address | Select-Object {$_.City}

เอาท์พุท :

$_.City
-------
Lahore

หรืออีกทางหนึ่ง เราสามารถรับค่าคุณสมบัติ City ได้ดังนี้ แนวทางนี้เหมาะสมที่สุดหากคุณต้องการมีชื่อคุณสมบัติจากการคำนวณแบบกำหนดเอง

ใช้ Select-Object Cmdlet:

$object |
Select-Object -ExpandProperty Address |
Select-Object @{Name='NestedValue';Expression={$_.City}}

เอาท์พุท :

NestedValue
-----------
Lahore

เราได้สำรวจ Select-Object และ -ExpandProperty ในส่วนก่อนหน้า ในตัวอย่างแรก $_.City เป็นชื่อคุณสมบัติจากการคำนวณเริ่มต้น (สร้างขึ้นขณะรันไทม์) ซึ่งเราดึงค่ามา

ในทางกลับกัน ในตัวอย่างที่สอง เราใช้ไวยากรณ์ Select-Object cmdlet @{} เพื่อสร้างชื่อคุณสมบัติที่คำนวณแบบกำหนดเอง (ใช้ได้กับการแสดงชื่อคุณสมบัติที่มีความหมาย ). ภายใน @{} เราใช้ชื่อตัวแปรสองตัว ได้แก่ Name และ Expression โดยที่ Name เป็นคุณสมบัติที่คำนวณได้ ชื่อ. ในทางตรงกันข้าม นิพจน์ ถูกตั้งค่าเป็นนิพจน์ที่ใช้ในการคำนวณค่าของชื่อคุณสมบัติที่คำนวณ

ในกรณีนี้ นิพจน์คือ $_.City ซึ่งหมายความว่าค่าของคุณสมบัติ NestedValue จะเป็นค่าของคุณสมบัติ City ของ วัตถุปัจจุบัน ($_)

ใช้ Get-Variable Cmdlet

ใช้ Get-Variable cmdlet เพื่อรับค่าคุณสมบัติที่ซ้อนกันของวัตถุตามชื่อคุณสมบัติที่ซ้อนกันใน PowerShell

ใช้ Get-Variable Cmdlet:

$varName = "object.Address"
$value = (Get-Variable -Name ($varName.Split('.')[0]) -ValueOnly).
         ($varName.Split('.')[1])
$value.Street
$value.City

เอาท์พุท :

245 Main Street
Lahore

เราเริ่มต้นตัวแปร $varName ด้วยค่า "object.Address" ตัวแปรนี้แสดงถึงคุณสมบัติที่จะเข้าถึงจากวัตถุ PowerShell

จากนั้น เราดึงค่าของคุณสมบัติที่ซ้อนกันที่กำหนดโดย $varName โดยใช้ cmdlet Get-Variable และเครื่องหมายจุด Get-Variable ถูกใช้เพื่อดึงค่าของตัวแปร $object โดยการระบุชื่อตัวแปร "object" เป็นพารามิเตอร์ เรียกใช้คำสั่งเป็น Get-Variable -Name ($variableName.Split('.')[0]) เพื่อดูว่า Get-Variable ส่งคืนอะไรบ้าง

ที่นี่ เราใช้เมธอด Split() เพื่อแยกสตริง "object.Address" ออกเป็นอาร์เรย์ของสตริงย่อยโดยใช้ . เป็นตัวคั่น อาร์เรย์ของสตริงย่อยนี้มีสองรายการ: "object" และ "Address" "object" (สตริงย่อยแรก) ถูกใช้เป็นพารามิเตอร์สำหรับ Get-Variable ซึ่งส่งคืนค่าของตัวแปร $object

"Address" (สตริงย่อยที่สอง) ถูกใช้เป็นชื่อคุณสมบัติเพื่อดึงข้อมูลคุณสมบัติที่ซ้อนกันของ $object สัญกรณ์ดอทถูกใช้เพื่อรับคุณสมบัติที่ซ้อนกันของวัตถุ จากนั้นค่านี้จะถูกเก็บไว้ใน $value

ตอนนี้ $value มีค่าของคุณสมบัติ Address ที่ซ้อนกันของ $object ซึ่งจะเป็นวัตถุ PowerShell อื่นหรือตารางแฮช ขึ้นอยู่กับ แนวทางที่คุณใช้ในการสร้างคุณสมบัติแบบซ้อน โดยมีคุณสมบัติ Street และ City

นั่นคือทั้งหมดที่เกี่ยวกับ PowerShell รับค่าคุณสมบัติของวัตถุตามชื่อ