PowerShell: files as objects, switch parameters and hashtables

Much of PowerShell is a shell like any other with a different spelling: variables, conditions, loops, a pipe. Two things are not. The first is the file system: Get-ChildItem hands you file objects, so a file's size, date and extension are properties you ask for, not columns you cut out of a line of text. The second is the hashtable, a key–value store that turns "how many per …" and "which has the most …" questions into a few lines.

This page takes both from the ground up, together with the script parameters that go with them: switches, default values and arrays. It assumes you can write a basic script – a param() block, Test-Path, a loop over Get-Content; if not, start with the introduction to PowerShell.

The idea in one sentence: stop parsing text when PowerShell already has the value – a file knows its own Length, a date knows how to compare itself, and a hashtable knows whether it has seen a key before.

The files used on this page

curl --create-dirs -o "#1" "https://laszlonemes.com/files/computer-systems/powershell-files-hashtables/{mixed_files/README,mixed_files/app.log,mixed_files/archive.TXT,mixed_files/big.log,mixed_files/data.csv,mixed_files/notes.txt,mixed_files/prices.csv,mixed_files/todo.txt,neptun_codes.txt,read.me,print_log.txt,patients_messy.txt,numbers_spaces.txt}"

curl.exe --create-dirs -o "#1" "https://laszlonemes.com/files/computer-systems/powershell-files-hashtables/{mixed_files/README,mixed_files/app.log,mixed_files/archive.TXT,mixed_files/big.log,mixed_files/data.csv,mixed_files/notes.txt,mixed_files/prices.csv,mixed_files/todo.txt,neptun_codes.txt,read.me,print_log.txt,patients_messy.txt,numbers_spaces.txt}"

Work in the directory that holds these files, and run your scripts from inside PowerShell 7 (pwsh), not from bash: an array parameter such as txt,csv only arrives as an array when PowerShell itself parses the command line.

Files are objects

In a Unix shell a file listing is text. To get the sizes you have to know that in the output of ls -l the size is the fifth column, cut it out, and hope no file name contains a space. Or you start a separate program for every question: one for the size, another for the date, a third for filtering.

# bash: the size is "the fifth column" of a line of text
ls -l mixed_files | awk '{ print $5, $9 }'

Get-ChildItem returns one object per file, and the object's data has names (Fig. 1): $file.Length is a number, $file.LastWriteTime is a date. Nothing has to be counted, cut or converted.

$file = Get-Item mixed_files/notes.txt

$file.Name              # notes.txt
$file.BaseName          # notes       (the name without the extension)
$file.Extension         # .txt        (with the dot; an empty string for README)
$file.Length            # 60          (bytes – a number, not text)
$file.LastWriteTime     # a date object, not a string
$file.FullName          # the absolute path

Get-Item gives the object of one path; Get-ChildItem gives the entries of a directory. By default that includes subdirectories – add -File whenever you mean files, or the first directory in the list breaks your size arithmetic.

Get-ChildItem -Path mixed_files                  # files and directories
Get-ChildItem -Path mixed_files -File            # files only
Get-ChildItem -Path mixed_files -Directory       # directories only
Get-ChildItem -Path mixed_files -File -Recurse   # files in the whole tree below it

foreach ($file in Get-ChildItem -Path mixed_files -File) {
    Write-Output "$($file.Name): $($file.Length) bytes"
}

Dates and sizes

LastWriteTime and the result of Get-Date are date objects. They have methods (AddDays, AddHours, ToString with a format) and they compare with the usual operators – "modified in the last 7 days" is a single -ge.

$now = Get-Date                          # this moment, as a date object
$limit = $now.AddDays(-7)                # the same moment, seven days ago

$file.LastWriteTime -ge $limit           # True if modified in the last 7 days: dates compare like numbers
$file.LastWriteTime.ToString('yyyy-MM-dd HH:mm')    # 2026-11-11 14:45

$file.LastWriteTime = $now.AddDays(-10)  # the property can be assigned too: the file is now "ten days old"

Sizes are plain numbers of bytes. PowerShell understands the suffixes KB, MB and GB on a number, in a script and on the command line alike:

1KB                          # 1024
1MB                          # 1048576
$file.Length -gt 1KB         # is the file larger than 1024 bytes?

A pipeline of files

Because objects travel through the pipe, every stage can refer to a property by name. Where-Object filters, Sort-Object orders, Select-Object picks properties or the first few items, Measure-Object adds up. Inside the braces, $_ is the object passing through (Fig. 2).

Get-ChildItem -Path mixed_files -File |
    Where-Object { $_.Length -gt 50 } |
    Sort-Object -Property Length -Descending |
    Select-Object -Property Name, Length

Name      Length
----      ------
big.log     3360
app.log       84
notes.txt     60

Get-ChildItem mixed_files -File | Where-Object Length -gt 50      # one property, one comparison: no { } and no $_
Get-ChildItem mixed_files -File | Measure-Object -Property Length -Sum    # Count: 8, Sum: 3656

When the result goes into a variable, wrap the pipeline in @( ). A pipeline returns an array for several items, the bare item for one, and nothing for none; @( ) makes it an array in all three cases, so the code after it doesn't have to care.

$large = @(Get-ChildItem -Path mixed_files -File | Where-Object { $_.Length -gt 1KB })

$large.Count          # 1 – an array with one element; without @( ) it would be a bare file object,
                      #     and with no match at all it would be $null

Creating, copying, moving and deleting

The cmdlets that change the file system follow the Verb-Noun pattern and all work on an item – a file or a directory.

Two details make such a script behave. New-Item returns the object it created, and anything a script returns is printed – pipe it into Out-Null to keep the output clean. And build paths with Join-Path instead of gluing strings with a slash: it uses the separator of the system it runs on.

$userDir = Join-Path -Path $TargetDir -ChildPath $id          # users/RVR55V – users\RVR55V on Windows

if (-not (Test-Path -Path $userDir -PathType Container)) {    # only if it isn't there yet
    New-Item -Path $userDir -ItemType Directory | Out-Null    # Out-Null: don't print the new directory
}

Aliases: which ones work everywhere

Cmdlets have short names, and at the prompt they save typing: dir for Get-ChildItem, gc for Get-Content, ? for Where-Object, % for ForEach-Object. The aliases fall into two groups, and only one of them is the same on every system.

The last group is the trap. On Windows ls is Get-ChildItem and returns file objects. On Linux and macOS PowerShell leaves the name alone, so ls is /bin/ls and returns lines of text. A string has a Length too – the number of its characters – so the filter still runs and silently answers a different question (Fig. 3).

ls | Where-Object Length -gt 50               # Windows: the large files. Linux, macOS: nothing
Get-ChildItem | Where-Object Length -gt 50    # the large files, everywhere

Switches, defaults and array parameters

A switch

An option that is either there or not – -Recurse, -Force, -WhatIf – is a parameter of type [switch]. It takes no value: it is $true when the caller writes it and $false when not, and PowerShell finds it wherever it stands on the command line. Your own scripts get one the same way. A typical use: a script that only shows its result by default, and changes the file when asked to.

param(
    [string]$File,
    [switch]$InPlace            # no value: written = $true, left out = $false
)

# ... $codes: the cleaned lines of $File ...

if ($InPlace) {
    Set-Content -Path $File -Value $codes -Encoding UTF8     # change the file itself
} else {
    Write-Output $codes                                      # only show the result
}

./tidy_codes.ps1 codes.txt              # $InPlace is $false: prints, the file is untouched
./tidy_codes.ps1 codes.txt -InPlace     # $InPlace is $true: rewrites codes.txt
./tidy_codes.ps1 -InPlace codes.txt     # a switch can stand anywhere

Writing back into the file you have just read is safe here, as long as the lines are already in a variable when the writing starts. No temporary file is needed.

A default value – and "was it given at all?"

= "." after a parameter is its default. A typed parameter without a default is never empty: a missing [int] is 0, which is also a perfectly valid value – so if (-not $Days) can't tell "left out" from "zero". $PSBoundParameters holds the parameters the caller really passed; ask it.

param(
    [int]$Days,                       # no default: 0 when it is left out
    [string]$Directory = "."          # default: the current directory
)

if (-not $PSBoundParameters.ContainsKey('Days')) {    # "was it passed?" – not "is it non-zero?"
    Write-Error "Usage: $($MyInvocation.MyCommand.Name) <days> [directory]"
    exit 1
}

An array parameter

Square brackets after the type make it an array: [string[]], [int[]]. The caller separates the elements with commas; a space starts the next parameter.

param(
    [string]$Directory,
    [string[]]$Extensions             # an array: txt,csv
)

./sort_by_extension.ps1 test_dir txt,csv      # $Extensions has two elements
./sort_by_extension.ps1 test_dir txt csv      # WRONG: only txt arrives; csv is a separate argument and is ignored

Inside the script, $Extensions -contains 'txt' asks whether a value is in the array – no loop needed – and -notcontains is its negation. Like every comparison in PowerShell they ignore case.

Random values

Get-Random returns a random whole number below -Maximum. Together with the fact that a string can be indexed like an array, that is all a password generator needs: pick a random position in a string of allowed characters, as many times as the password is long.

Get-Random -Maximum 6                 # a whole number from 0 to 5
Get-Random -Minimum 1 -Maximum 7      # 1 to 6: the maximum itself is never returned

$characters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
$characters[0]                                           # a – a string can be indexed like an array
$characters[(Get-Random -Maximum $characters.Length)]    # one random character

Hashtables: counting and summing per key

A hashtable stores one value per key, and the key can be any text – a name, a month, an extension. It is what other languages call a dictionary or a map, and what bash calls an associative array. One property makes it pleasant for counting: a key that isn't there yet reads as $null, and $null + 12 is 12, so the first addition needs no special case.

$pages = @{}                                           # an empty hashtable

$pages['Toth Eszter'] = $pages['Toth Eszter'] + 12     # a missing key is $null, and $null + 12 = 12
$pages['Toth Eszter'] = $pages['Toth Eszter'] + 25     # 37

$pages['Toth Eszter']                                  # 37 – the value stored under a key
$pages.Count                                           # 1  – the number of keys
$pages.Keys                                            # every key, in no particular order
$pages.ContainsKey('Varga Dora')                       # False

Sum per key, then the maximum

A print server keeps a log, print_log.txt↓: who printed, how many pages, on which printer. The same person shows up in several lines.

Toth Eszter, 12, lab-2
Varga Dora, 30, library
Balogh Mate, 4, lab-1
Toth Eszter, 25, library

Szalai Anna, 18, lab-2
Varga Dora, 9, lab-1
Toth Eszter,8,lab-2

Who printed the most pages? The answer takes two loops. The first reads the lines and adds each page count to the value stored under the name (Fig. 4):

foreach ($line in Get-Content -Path $File -Encoding UTF8) {
    $line = $line.Trim()
    if ($line -eq '') { continue }

    $name, $count, $printer = $line -split ','      # three fields, three variables
    $name = $name.Trim()                            # "Toth Eszter" – the space inside stays
    $count = "$count".Trim()                        # " 12" → "12"

    $pages[$name] = $pages[$name] + [int]$count     # [int]: the field is still text
}

The second loop walks the keys and remembers the largest value seen so far – the maximum search you have written in every language:

$maxKey = ""
$maxCount = 0

foreach ($key in $pages.Keys) {
    if ($pages[$key] -gt $maxCount) {
        $maxCount = $pages[$key]
        $maxKey = $key
    }
}

Write-Output "$maxKey - $maxCount"      # Toth Eszter - 45

The keys come out in no particular order – never rely on it. For a report, pass the keys through Sort-Object and loop over the result:

foreach ($name in ($pages.Keys | Sort-Object)) {
    Write-Output "${name}: $($pages[$name])"      # the braces keep the colon out of the variable name
}

Balogh Mate: 4
Szalai Anna: 18
Toth Eszter: 45
Varga Dora: 39

A composite key

"The most common illness per month" counts pairs: month and illness together. A hashtable has one key per entry, so glue the two fields into one string with a separator that can't occur in either – 10:fejfájás – and split it again when you read the keys back (Fig. 5).

$key = "${month}:$illness"            # "10:fejfájás" – one string made of two fields
$counts[$key] = $counts[$key] + 1

$month, $illness = $key -split ':'    # and apart again, when you read the keys back

The same with Group-Object

In a pipeline, Group-Object does the counting loop for you: it collects equal items and returns one object per group, with the properties Name (the key), Count and Group (the items themselves). If you know the Unix pipeline sort | uniq -c, this is its counterpart – except that the result isn't text you have to take apart again.

$words = 'apple', 'pear', 'apple', 'plum', 'pear', 'apple'

$words | Group-Object | Sort-Object -Property Count -Descending | Select-Object -Property Name, Count

Name  Count
----  -----
apple     3
pear      2
plum      1

A hashtable goes through a pipeline too, once you ask for its entries with GetEnumerator(). Each entry has a Key and a Value, so the maximum search becomes a sort:

$top = $pages.GetEnumerator() | Sort-Object -Property Value -Descending | Select-Object -First 1
Write-Output "$($top.Key) - $($top.Value)"      # Toth Eszter - 45

Practice

Fourteen tasks in four groups, and a larger one to finish. Each has an expected result to check yourself against, and a hint with the approach and the lines that matter – the script is yours to write, so try before you open it.

• —check the parameters, and that the input file or directory exists (Test-Path)
• —error messages go through Write-Error, and the script stops with exit 1
• —read text files with Get-Content -Encoding UTF8, .Trim() every line and skip the empty ones
• —full cmdlet names, no aliases

Files and directories

PS> ./create_user_dirs.ps1 neptun_codes.txt read.me
Created: users/RVR55V
Created: users/ASD32B
Created: users/abc123
Created: users/GFGDDD
Created: users/AS55VF
WARNING: Invalid identifier skipped: 'TOOLONG1'
WARNING: Invalid identifier skipped: 'ab-12c'
Created: users/X1Y2Z3
6 directory(ies) created, 0 already existed, 2 invalid identifier(s)

if ($id -notmatch '^[A-Za-z0-9]{6}$') {       # exactly six letters or digits
    Write-Warning "Invalid identifier skipped: '$id'"
    $invalid++
    continue
}

$userDir = Join-Path -Path $TargetDir -ChildPath $id
# ... create $userDir only if Test-Path -PathType Container says it is missing ...
Copy-Item -Path $ReadmeFile -Destination $userDir     # on every run: an older copy is overwritten

PS> ./generate_passwords.ps1 neptun_codes.txt passwords.txt
WARNING: Invalid identifier skipped: 'TOOLONG1'
WARNING: Invalid identifier skipped: 'ab-12c'
6 password(s) of length 12 written to 'passwords.txt'
PS> Get-Content passwords.txt
RVR55V 2i064gPPF1B8
ASD32B ZkZhOQfckbbL
abc123 svDqCYsu7jkt
GFGDDD rfKwS1otaZ9Z
AS55VF nZXvNNIJPoDg
X1Y2Z3 28G19NiET0Hi

function New-Password {
    param([int]$Length)

    $characters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
    $password = ""
    for ($i = 0; $i -lt $Length; $i++) {
        $password += $characters[(Get-Random -Maximum $characters.Length)]
    }
    return $password
}

-join ($characters.ToCharArray() | Get-Random -Count $Length)

PS> Copy-Item mixed_files test_dir -Recurse
PS> ./sort_by_extension.ps1 test_dir txt,csv
Moved: archive.TXT -> txt/
Moved: data.csv -> csv/
Moved: notes.txt -> txt/
Moved: prices.csv -> csv/
Moved: todo.txt -> txt/
5 file(s) moved

$extension = $file.Extension.TrimStart('.').ToLower()     # ".TXT" → "txt", README → ""

if ($Extensions -notcontains $extension) {
    continue                                              # not asked for, or no extension: the file stays
}

$targetDir = Join-Path -Path $Directory -ChildPath $extension
# ... create $targetDir if it is missing ...
Move-Item -Path $file.FullName -Destination $targetDir

PS> (Get-Item mixed_files/todo.txt).LastWriteTime = (Get-Date).AddDays(-10)
PS> ./modified_within_days.ps1 7 mixed_files
2026-11-11 14:45  app.log
2026-11-11 14:45  archive.TXT
2026-11-11 14:45  big.log
2026-11-11 14:45  data.csv
2026-11-11 14:45  notes.txt
2026-11-11 14:45  prices.csv
2026-11-11 14:45  README
7 file(s) modified in the last 7 day(s)

$limit = (Get-Date).AddDays(-$Days)

foreach ($file in Get-ChildItem -Path $Directory -File) {
    if ($file.LastWriteTime -ge $limit) {
        $modified = $file.LastWriteTime.ToString('yyyy-MM-dd HH:mm')
        Write-Output "$modified  $($file.Name)"
    }
}

PS> ./larger_than.ps1 50 mixed_files
3360 bytes  big.log
84 bytes  app.log
60 bytes  notes.txt
3 file(s) larger than 50 bytes
PS> ./larger_than.ps1 1KB mixed_files
3360 bytes  big.log
1 file(s) larger than 1024 bytes

param(
    [long]$MinSize,                   # [long]: a 64-bit integer; 1KB on the command line arrives as 1024
    [string]$Directory = "."
)

$largeFiles = @(Get-ChildItem -Path $Directory -File |
    Where-Object { $_.Length -gt $MinSize } |
    Sort-Object -Property Length -Descending)

Parameters and switches

PS> ./tidy_codes.ps1 neptun_codes.txt
WARNING: Invalid identifier skipped: 'TOOLONG1'
WARNING: Invalid identifier skipped: 'ab-12c'
ABC123
AS55VF
ASD32B
GFGDDD
RVR55V
X1Y2Z3
PS> Copy-Item neptun_codes.txt test.txt
PS> ./tidy_codes.ps1 test.txt -InPlace
WARNING: Invalid identifier skipped: 'TOOLONG1'
WARNING: Invalid identifier skipped: 'ab-12c'
6 identifier(s) written back to 'test.txt'

$codes += $code.ToUpper()                 # inside the loop, after the validation
…
$codes = @($codes | Sort-Object)          # @( ): still an array when a single code is left

if ($InPlace) {
    Set-Content -Path $File -Value $codes -Encoding UTF8
    Write-Output "$($codes.Count) identifier(s) written back to '$File'"
} else {
    Write-Output $codes
}

(Get-Content $File) |                                  # the ( ) are required: read everything first
    ForEach-Object { $_.Trim().ToUpper() } |
    Where-Object { $_ -match '^[A-Z0-9]{6}$' } |
    Sort-Object |
    Set-Content $File

PS> ./times_table.ps1 7 -UpTo 3
7 x 1 = 7
7 x 2 = 14
7 x 3 = 21
PS> ./times_table.ps1
Write-Error: Usage: times_table.ps1 <number> [up to]

param(
    [int]$Number,
    [int]$UpTo = 10
)

if (-not $PSBoundParameters.ContainsKey('Number')) { … }     # 0 is a number too: ./times_table.ps1 0 must work

foreach ($i in 1..$UpTo) {
    Write-Output "$Number x $i = $($Number * $i)"
}

Hashtables and grouping

PS> ./most_pages.ps1 print_log.txt
Toth Eszter - 45

$printer = "$printer".Trim()
$pages[$printer] = $pages[$printer] + [int]$count      # library: 55, lab-2: 38, lab-1: 13

PS> ./most_common_illness_per_month.ps1 patients_messy.txt
WARNING: Invalid line skipped: 'Név, Dátum, Betegség'
WARNING: Invalid line skipped: 'Hibás Sor'
Month 05: lábfájás (3 patient(s))
Month 09: gyomorpanaszok (2 patient(s))
Month 10: fejfájás (3 patient(s))
Month 11: megfázás (3 patient(s))

$name, $date, $illness = $line -split ','

$date = "$date".Trim()                                      # "$date": a missing field is $null, and $null has no Trim()
$illness = "$illness".ToLower() -replace '[^\p{L}]', ''     # "  Fejfájás." → "fejfájás"

if ($date -notmatch '^[0-9]{4}-[0-9]{2}-[0-9]{2}$' -or $illness -eq '') {
    Write-Warning "Invalid line skipped: '$line'"
    continue
}

$month = $date.Substring(5, 2)                              # characters 5 and 6 of 2023-10-13: "10"
$key = "${month}:$illness"
$counts[$key] = $counts[$key] + 1

foreach ($key in $counts.Keys) {
    $month, $illness = $key -split ':'

    if ($counts[$key] -gt $maxCount[$month]) {    # a month not seen yet is $null – any count beats it
        $maxCount[$month] = $counts[$key]
        $maxIllness[$month] = $illness
    }
}

foreach ($month in ($maxCount.Keys | Sort-Object)) {
    Write-Output "Month ${month}: $($maxIllness[$month]) ($($maxCount[$month]) patient(s))"
}

$records = foreach ($line in Get-Content -Path $File -Encoding UTF8) {
    # ... clean and validate as before ...
    [pscustomobject]@{ Month = $month; Illness = $illness }
}

$records | Group-Object -Property Month | Sort-Object -Property Name | ForEach-Object {
    $top = $_.Group | Group-Object -Property Illness |
        Sort-Object -Property Count -Descending | Select-Object -First 1
    Write-Output "Month $($_.Name): $($top.Name) ($($top.Count) patient(s))"
}

PS> ./per_extension.ps1 mixed_files
.csv: 2 file(s), 79 bytes
.log: 2 file(s), 3444 bytes
.txt: 3 file(s), 105 bytes
(none): 1 file(s), 28 bytes

$extension = $file.Extension.ToLower()             # ".TXT" and ".txt" are one key
if ($extension -eq '') { $extension = '(none)' }

$count[$extension] = $count[$extension] + 1
$bytes[$extension] = $bytes[$extension] + $file.Length

Get-ChildItem -Path $Directory -File | Group-Object { $_.Extension.ToLower() } | ForEach-Object {
    $sum = ($_.Group | Measure-Object -Property Length -Sum).Sum      # $_.Group: the files of this group
    Write-Output "$($_.Name): $($_.Count) file(s), $sum bytes"
}

Strings and numbers are objects too

PS> ./number_stats.ps1 numbers_spaces.txt
WARNING: Line 6: 'abc' is not an integer, skipped
WARNING: Line 8: '1.5' is not an integer, skipped
Count: 6
Smallest: -4
Largest: 100
Average: 22.17
PS> Get-Content sorted_numbers.txt
-4
3
7
12
15
100

$numbers += [int]$line                 # collect numbers, not strings: as text, "100" sorts before "9"
…
$stats = $numbers | Measure-Object -Minimum -Maximum -Average

$stats.Count                           # 6
[math]::Round($stats.Average, 2)       # 22.17

Set-Content -Path sorted_numbers.txt -Value ($numbers | Sort-Object) -Encoding UTF8

Get-Content -Path $File -Encoding UTF8 |
    Sort-Object -Property Length -Descending |
    Select-Object -First 1

if ($line -match 'request ([0-9]+) processed in ([0-9]+) ms') {
    $request = $Matches[1]           # the first ( ) group: 051
    $ms = [int]$Matches[2]           # the second one, as a number: 97
}

A larger one

Common mistakes

Summary

file object

what Get-ChildItem and Get-Item return: Name, Extension, Length, LastWriteTime, FullName

date object

a point in time with methods (AddDays, ToString); compares with -ge, -lt

switch

a [switch] parameter: no value, true when present

hashtable

@{} – one value per key; a missing key reads as $null

composite key

two fields glued into one key with a separator: 10:fejfájás

Group-Object

groups equal items and counts them: Name, Count, Group

• —Ask the object: $file.Length, $file.Extension, $file.LastWriteTime – and always Get-ChildItem -File when you mean files.
• —Dates compare like numbers; (Get-Date).AddDays(-7) is "a week ago". Sizes take KB, MB, GB.
• —Create only what is missing (Test-Path), build paths with Join-Path, silence New-Item with Out-Null, rehearse deletes with -WhatIf.
• —ls, cat, cp, mv, rm and sort are aliases only on Windows – full cmdlet names in scripts.
• —Options are [switch] parameters, optional values have defaults, and $PSBoundParameters.ContainsKey() tells you what was really passed.
• —Per-key questions: clean the key, $h[$k] = $h[$k] + n, then a maximum search or a sorted loop over the keys.
• —Never assign to a hashtable inside a loop over its own keys – loop over @($h.Keys).

Further reading

• —about_Hash_Tables – everything a hashtable can do, including ordered ones ([ordered]@{}).
• —about_Functions_Advanced_Parameters – parameter types, defaults, switches and validation attributes.
• —about_Regular_Expressions – the regex dialect of -match and -replace, \p{L} included.
• —Get-ChildItem – all its parameters; the same page from the terminal: Get-Help Get-ChildItem -Examples.
• —Get-ChildItem | Get-Member lists every property and method of a file object, right in the terminal.
• —regex101 – try a pattern and have each piece explained; choose the ".NET (C#)" flavour for PowerShell.