PowerShell help also has “about” topics; the ones you need for your example are about_Operators and about_Comparison_Operators. To see which “about” topics are available, use Get-Help about_*. You may need to Update-Help before the help will be available. See the online help for Get-Help.

^{ETA: If you need to run Update-Help, you will need to do it in an elevated (run-as-admin) PowerShell.}

To add to Jeff Zeitlin’s helpful answer:

Unfortunately, there is no built-in way to directly retrieve operator-specific help content as of PowerShell (Core) 7 v7.5.

While Get-Help does offer substring-based search and filtering by category (-Category HelpFile limits the search to the conceptual about_* topics), it is usually too blunt a tool to find the single topic / subsection thereof that is of interest:

• The substring is used verbatim, and only one may be passed.
• The search is slow.

For instance,

# Note the need to quote '-replace', so that it isn't mistaken for one
# of Get-Help's parameter names. The argument positionally binds to -Name.
Get-Help '-replace' -Category HelpFile

yields:

Name                              Category  Module                    Synopsis
----                              --------  ------                    --------
about_Comparison_Operators        HelpFile
about_Operators                   HelpFile
about_Operator_Precedence         HelpFile
about_PSItem                      HelpFile
about_Regular_Expressions         HelpFile

That is, if more than one topic matches the search, a list of matching topics is shown, and, as you can see, while the topic of interest, about_Comparison_Operators, was among the results, other topics that mention the operator were matched too.

GitHub issue #11339 is a feature request to bring focused lookup of operator documentation to PowerShell, by introducing support for -Category Operator, so that you could then use:

# WISHFUL THINKING as of PowerShell 7.5:
# Get focused help on the -replace operator
# (may alternatively be passed as '-replace').
Get-Help replace -Category Operator

Custom function Show-OperatorHelp can fill the gap for now:

Assuming the function is defined, here are example uses:

# Opens the home (overview) page for all PowerShell operators
Show-OperatorHelp

# Lists all operators in the console, 
# along with their friendly names and categories.
Show-OperatorHelp -List

# Opens the help topic (section) for the -replace operator.
# Equivalent of 
    Show-OperatorHelp -Name '-replace'
# because you omit the initial '-'; if you do specify it, quote the entire argument.
Show-OperatorHelp replace

# Opens the help topic (section) for @(...), the array-subexpression operator.
# Note the need for quoting.
Show-OperatorHelp '@()'

# Copy the URL pointing to the relevant section of the relevant
# help topic to the clipboard
Show-OperatorHelp split -CopyUrl

# Ditto, but do so in the form of a Markdown link.
Show-OperatorHelp split -CopyLink

Note:

• The function operates on online help content only, i.e. the results will open in your web browser (hence the use of the standard verb Show).

• For convenience, it is advisable to also define a short alias, say shoh.

• While the source code for the function is below, I instead suggest downloading it from this Gist:

  • Assuming you have looked at the linked Gist’s source code to ensure that it is safe (which I can personally assure you of, but you should always check), you can install it directly as follows:

    irm https://gist.github.com/mklement0/146f3202a810a74cb54a2d353ee4003f/raw/Show-OperatorHelp.ps1 | iex
    

  • This instantly defines the function in your current session, and also prints instructions on how to make it available in future sessions.

  • Only the Gist, not the source code below, will be maintained going forward.

Show-OperatorHelp function source code:

function Show-OperatorHelp {
    <#
.SYNOPSIS
Shows documentation for PowerShell's operators.

.DESCRIPTION
Navigates to operator-specific or -related online help topics in your default 
web browser.

Invoke argument-less to see the operators overview help topic.
-Precedence shows the topic about operator precedence.
-QuotingRules shows the topic about string literals and quoting.
-Name <name> targets a specific operator.

.PARAMETER Name
The name of an operator.

Note that most names must be passed *in quotes* for syntactic reasons;
e.g., '-match' instead of -match
However, you may omit the initial '-', in which case you needn't quote.

Disambiguation:
* Use '[0]' for the indexing operator, and '[int]' for the cast / type-constraint
  operator.
* Use '.' for the member-access operator, and '. ' for the dot-sourcing operator.
* Use '&' for the call operator, and ' &' for the background operator.
* Use '@' for the splatting operator, and '@()' for the array-subexpression
  operator.

Use -List to see all names.

.PARAMETER Precedence
Opens the help topic that describes operator precedence.

.PARAMETER List
Parameter description

.PARAMETER QuotingRules
Opens the help topic that describes the quoting rules and syntax for
string literals.

.PARAMETER CopyLink
Instead of opening the topic page in the default browser, copies a Markdown 
link to it to the clipboard; e.g.:

`.`, the [member access operator](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_Operators#member-access-operator-)

.PARAMETER Version
Specify a specific PowerShell version number (e.g., 7 or 5.1) for which to
display the requested help topic.
By default, the executing engine's version number is used.

.EXAMPLE
Show-OperatorHelp

Opens the home (overview) page for all PowerShell operators.

.EXAMPLE
Show-OperatorHelp replace

Opens the help topic (section) for the -replace operator.
Equivalent of: Show-OperatorHelp -Name '-replace'

.EXAMPLE
Show-OperatorHelp -List

Lists all operators, along with their friendly names and categories.

.EXAMPLE
Show-OperatorHelp -Precedence

Shows the help topic about operator precedence.

.EXAMPLE
Show-OperatorHelp like -CopyLink

Copies a Markdown link to the online help topic for the -like operator to
the clipboard.

.NOTES
License: MIT
Author:  Michael Klement <[email protected]>

Showing local, in-console information is currently not possible, because
the text-only help topics do not allow for targeted navigation the way that
the online topics do.
#>

    [CmdletBinding(DefaultParameterSetName = 'HomePage', SupportsShouldProcess, PositionalBinding = $false)]
    param (
        [Parameter(ParameterSetName = 'Name', Mandatory, Position = 0)]
        [string] $Name
        ,
        [Parameter(ParameterSetName = 'Precedence')]
        [switch] $Precedence
        ,
        [Parameter(ParameterSetName = 'List')]
        [Alias('ListAvailable')]
        [switch] $List
        ,
        [Parameter(ParameterSetName = 'QuotingRules')]
        [Alias('StringLiterals')]
        [switch] $QuotingRules
        ,
        [Parameter(ParameterSetName = 'Name')]
        [Parameter(ParameterSetName = 'Precedence')]
        [Parameter(ParameterSetName = 'QuotingRules')]
        [Parameter(ParameterSetName = 'HomePage')]
        [Alias('cp')]
        [switch] $CopyLink
        ,
        [Parameter(ParameterSetName = 'Name')]
        [Parameter(ParameterSetName = 'Precedence')]
        [Parameter(ParameterSetName = 'QuotingRules')]
        [Parameter(ParameterSetName = 'HomePage')]
        [string] $Version # PowerShell version
    )

    # Default to the executing PowerShell engine's version.
    # Note: If no "?view=powershell-<ver>" query string is present,
    #       the currently highest stable version overall is targeted. 
    $explicitVersionRequested = $PSBoundParameters.ContainsKey('Version')
    if ($explicitVersionRequested) {
        $verObj = $Version -as [version]
        if (-not $verObj) { $verObj = "$Version.0" -as [version] }
        if (-not $verObj) { Throw "Unrecognized PowerShell version number: $Version" }
    }
    else {
        $verObj = $PSVersionTable.PSVersion
    }
    $Version = ('{0}.{1}' -f $verObj.Major, $verObj.Minor) -replace '.0$'

    # Table gleaned from https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_Operator_Precedence, with subsequent cleanup and massaging:
    #  * In-page anchors (HTML) determined manually.
    #  * .Category value is a custom categorization loosely based on the wording in the help topics.
    $opTable = [ordered] @{
        # about_Arithmetic_Operators
        '-'            = [pscustomobject] @{ Name = '-'; FriendlyName = 'subtraction / sign inversion'; Topic = 'about_Arithmetic_Operators'; Category = 'Arithmetic' } 
        '*'            = [pscustomobject] @{ Name = '*'; FriendlyName = 'multiplication / string replication'; Topic = 'about_Arithmetic_Operators'; Category = 'Arithmetic' } 
        '/'            = [pscustomobject] @{ Name = '/'; FriendlyName = 'division'; Topic = 'about_Arithmetic_Operators'; Category = 'Arithmetic' } 
        '%'            = [pscustomobject] @{ Name = '%'; FriendlyName = 'modulus'; Topic = 'about_Arithmetic_Operators'; Category = 'Arithmetic' } 
        '+'            = [pscustomobject] @{ Name = '+'; FriendlyName = 'addition / string concatenation'; Topic = 'about_Arithmetic_Operators'; Category = 'Arithmetic' } 
        '-shl'         = [pscustomobject] @{ Name = '-shl'; FriendlyName = 'bitwise left-shift'; Topic = 'about_Arithmetic_Operators'; Anchor = 'bitwise-operators'; Category = 'Bitwise' } 
        '-shr'         = [pscustomobject] @{ Name = '-shr'; FriendlyName = 'bitwise right-shift'; Topic = 'about_Arithmetic_Operators'; Anchor = 'bitwise-operators'; Category = 'Bitwise' } 
        '-band'        = [pscustomobject] @{ Name = '-band'; FriendlyName = 'bitwise AND'; Topic = 'about_Arithmetic_Operators'; Anchor = 'bitwise-operators'; Category = 'Bitwise' } 
        '-bor'         = [pscustomobject] @{ Name = '-bor'; FriendlyName = 'bitwise OR'; Topic = 'about_Arithmetic_Operators'; Anchor = 'bitwise-operators'; Category = 'Bitwise' } 
        '-bxor'        = [pscustomobject] @{ Name = '-bxor'; FriendlyName = 'bitwise XOR'; Topic = 'about_Arithmetic_Operators'; Anchor = 'bitwise-operators'; Category = 'Bitwise' } 
        '-bNot'        = [pscustomobject] @{ Name = '-bNot'; FriendlyName = 'bitwise complement'; Topic = 'about_Arithmetic_Operators'; Anchor = 'bitwise-operators'; Category = 'Bitwise' } 
        # about_Assignment_Operators
        '='            = [pscustomobject] @{ Name = '='; FriendlyName = 'assignment'; Topic = 'about_Assignment_Operators'; Category = 'Assignment' } 
        '+='           = [pscustomobject] @{ Name = '+='; FriendlyName = 'compound assignment'; Topic = 'about_Assignment_Operators'; Category = 'Assignment' } 
        '-='           = [pscustomobject] @{ Name = '-='; FriendlyName = 'compound assignment'; Topic = 'about_Assignment_Operators'; Category = 'Assignment' } 
        '*='           = [pscustomobject] @{ Name = '*='; FriendlyName = 'compound assignment'; Topic = 'about_Assignment_Operators'; Category = 'Assignment' } 
        '/='           = [pscustomobject] @{ Name = '/='; FriendlyName = 'compound assignment'; Topic = 'about_Assignment_Operators'; Category = 'Assignment' } 
        '%='           = [pscustomobject] @{ Name = '%='; FriendlyName = 'compound assignment'; Topic = 'about_Assignment_Operators'; Category = 'Assignment' } 
        '++'           = [pscustomobject] @{ Name = '++'; FriendlyName = 'increment'; Topic = 'about_Assignment_Operators'; Category = 'Assignment' } 
        '--'           = [pscustomobject] @{ Name = '--'; FriendlyName = 'decrement'; Topic = 'about_Assignment_Operators'; Category = 'Assignment' } 
        # about_Comparison_Operators
        '-eq'          = [pscustomobject] @{ Name = '-eq'; FriendlyName = 'equality'; Topic = 'about_Comparison_Operators'; Anchor = '-eq'; Category = 'Equality' } 
        '-ne'          = [pscustomobject] @{ Name = '-ne'; FriendlyName = 'inequality'; Topic = 'about_Comparison_Operators'; Anchor = '-ne'; Category = 'Equality' } 
        '-gt'          = [pscustomobject] @{ Name = '-gt'; FriendlyName = 'greater-than'; Topic = 'about_Comparison_Operators'; Anchor = '-gt'; Category = 'Equality' } 
        '-ge'          = [pscustomobject] @{ Name = '-ge'; FriendlyName = 'greater-than-or-equal'; Topic = 'about_Comparison_Operators'; Anchor = '-gt'; Category = 'Equality' } 
        '-lt'          = [pscustomobject] @{ Name = '-lt'; FriendlyName = 'less-than'; Topic = 'about_Comparison_Operators'; Anchor = '-lt'; Category = 'Equality' } 
        '-le'          = [pscustomobject] @{ Name = '-le'; FriendlyName = 'less-than-or-equal'; Topic = 'about_Comparison_Operators'; Anchor = '-le'; Category = 'Equality' } 
        '-like'        = [pscustomobject] @{ Name = '-like'; FriendlyName = 'wildcard matching'; Topic = 'about_Comparison_Operators'; Anchor = '-like'; Category = 'Matching' } 
        '-notlike'     = [pscustomobject] @{ Name = '-notlike'; FriendlyName = 'negated wildcard matching'; Topic = 'about_Comparison_Operators'; Anchor = '-notlike'; Category = 'Matching' } 
        '-match'       = [pscustomobject] @{ Name = '-match'; FriendlyName = 'regular-expression matching'; Topic = 'about_Comparison_Operators'; Anchor = '-match-and--notmatch'; Category = 'Matching' } 
        '-notmatch'    = [pscustomobject] @{ Name = '-notmatch'; FriendlyName = 'negated regular-expression matching'; Topic = 'about_Comparison_Operators'; Anchor = '-match-and--notmatch'; Category = 'Matching' } 
        '-replace'     = [pscustomobject] @{ Name = '-replace'; FriendlyName = 'regular-expression-based string replacement'; Topic = 'about_Comparison_Operators'; Anchor = 'replacement-operator'; Category = 'String' } 
        '-in'          = [pscustomobject] @{ Name = '-in'; FriendlyName = 'LHS contained in RHS'; Topic = 'about_Comparison_Operators'; Anchor = '-in'; Category = 'Containment' } 
        '-notIn'       = [pscustomobject] @{ Name = '-notIn'; FriendlyName = 'LHS not contained in collection'; Topic = 'about_Comparison_Operators'; Anchor = '-notin'; Category = 'Containment' } 
        '-contains'    = [pscustomobject] @{ Name = '-contains'; FriendlyName = 'collection contains RHS'; Topic = 'about_Comparison_Operators'; Anchor = '-contains'; Category = 'Containment' } 
        '-notContains' = [pscustomobject] @{ Name = '-notContains'; FriendlyName = 'collection doesn''t contain RHS'; Topic = 'about_Comparison_Operators'; Anchor = '-notcontains'; Category = 'Containment' } 
        # about_Join
        '-join'        = [pscustomobject] @{ Name = '-join'; FriendlyName = 'string joining'; Topic = 'about_Join'; Category = 'String' } 
        # about_Split
        '-split'       = [pscustomobject] @{ Name = '-split'; FriendlyName = 'string splitting'; Topic = 'about_Split'; Category = 'String' } 
        # about_Logical_Operators
        '-not'         = [pscustomobject] @{ Name = '-not'; FriendlyName = 'logical NOT'; Topic = 'about_Logical_Operators'; Category = 'Logical' } 
        '!'            = [pscustomobject] @{ Name = '!'; FriendlyName = 'logical NOT'; Topic = 'about_Logical_Operators'; Category = 'Logical' } 
        '-and'         = [pscustomobject] @{ Name = '-and'; FriendlyName = 'logical AND'; Topic = 'about_Logical_Operators'; Category = 'Logical' } 
        '-or'          = [pscustomobject] @{ Name = '-or'; FriendlyName = 'logical OR'; Topic = 'about_Logical_Operators'; Category = 'Logical' } 
        '-xor'         = [pscustomobject] @{ Name = '-xor'; FriendlyName = 'logical XOR'; Topic = 'about_Logical_Operators'; Category = 'Logical' } 
        # about_Operators
        '$()'          = [pscustomobject] @{ Name = '$()'; FriendlyName = 'subexpression'; Topic = 'about_Operators'; Anchor = 'subexpression-operator--'; Category = 'Evaluation' } 
        '@()'          = [pscustomobject] @{ Name = '@()'; FriendlyName = 'array-subexpression'; Topic = 'about_Operators'; Anchor = 'array-subexpression-operator--'; Category = 'Evaluation' } 
        '()'           = [pscustomobject] @{ Name = '()'; FriendlyName = 'grouping'; Topic = 'about_Operators'; Anchor = 'grouping-operator--'; Category = 'Evaluation' } 
        '. '           = [pscustomobject] @{ Name = '.'; FriendlyName = 'dot-sourcing'; Topic = 'about_Operators'; Anchor = 'dot-sourcing-operator-'; Category = 'Execution'; LookupName = "'. '" }   # Sadly, we have to use '. ' to distinguish it from the member-access operator
        '&'            = [pscustomobject] @{ Name = '&'; FriendlyName = 'call'; Topic = 'about_Operators'; Anchor = 'call-operator-'; Category = 'Execution' }
        ' &'           = [pscustomobject] @{ Name = '&'; FriendlyName = 'background'; Topic = 'about_Operators'; Anchor = 'background-operator-'; Category = 'Execution'; LookupName = "' &'" } # Sadly, we have to use ' &' to distinguish it from the call operator
        '&&'           = [pscustomobject] @{ Name = '&&'; FriendlyName = 'pipeline-chain AND'; Topic = 'about_Pipeline_Chain_Operators'; Category = 'Pipeline' }
        '||'           = [pscustomobject] @{ Name = '||'; FriendlyName = 'pipeline-chain OR'; Topic = 'about_Pipeline_Chain_Operators'; Category = 'Pipeline' }
        '|'            = [pscustomobject] @{ Name = '|'; FriendlyName = 'pipeline'; Topic = 'about_Operators'; Anchor = 'pipeline-operator-'; Category = 'Pipeline' }
        '.'            = [pscustomobject] @{ Name = '.'; FriendlyName = 'member-access'; Topic = 'about_Operators'; Anchor = 'member-access-operator-'; Category = 'Object' } 
        '::'           = [pscustomobject] @{ Name = '::'; FriendlyName = 'static member-access'; Topic = 'about_Operators'; Anchor = 'static-member-operator-'; Category = 'Object' } 
        '[0]'          = [pscustomobject] @{ Name = '[0]'; FriendlyName = 'index'; Topic = 'about_Operators'; Anchor = 'index-operator--'; Category = 'Object' } 
        '[int]'        = [pscustomobject] @{ Name = '[int]'; FriendlyName = 'cast / type constraint'; Topic = 'about_Operators'; Anchor = 'cast-operator--'; Category = 'Type' } 
        ','            = [pscustomobject] @{ Name = ','; FriendlyName = 'array constructor'; Topic = 'about_Operators'; Anchor = 'comma-operator-'; Category = 'Array' } 
        '..'           = [pscustomobject] @{ Name = '..'; FriendlyName = 'range'; Topic = 'about_Operators'; Anchor = 'range-operator-'; Category = 'Array' } 
        '-f'           = [pscustomobject] @{ Name = '-f'; FriendlyName = 'format'; Topic = 'about_Operators'; Anchor = 'format-operator--f'; Category = 'String' } 
        '?:'           = [pscustomobject] @{ Name = '?:'; FriendlyName = 'ternary conditional'; Topic = 'about_Operators'; Anchor = 'ternary-operator--if-true--if-false'; Category = 'Conditional' }            # v7+
        '??'           = [pscustomobject] @{ Name = '??'; FriendlyName = 'null-coalescing'; Topic = 'about_Operators'; Anchor = 'null-coalescing-operator-'; Category = 'Conditional' }                          # v7+
        '??='          = [pscustomobject] @{ Name = '??='; FriendlyName = 'null-coalescing assignment'; Topic = 'about_Operators'; Anchor = 'null-coalescing-assignment-operator-'; Category = 'Conditional' }   # v7+
        '?.'           = [pscustomobject] @{ Name = '?.'; FriendlyName = 'null-conditional'; Topic = 'about_Operators'; Anchor = 'null-conditional-operators--and-'; Category = 'Conditional' }                  # v7.1+
        '?[]'          = [pscustomobject] @{ Name = '?[]'; FriendlyName = 'null-conditional'; Topic = 'about_Operators'; Anchor = 'null-conditional-operators--and-'; Category = 'Conditional' }                 # v7.1+
        # about_Redirection
        '>'            = [pscustomobject] @{ Name = '>'; FriendlyName = 'redirection'; Topic = 'about_Redirection'; Category = 'Stream' }
        '>>'           = [pscustomobject] @{ Name = '>>'; FriendlyName = 'appending redirection'; Topic = 'about_Redirection'; Category = 'Stream' }
        # about_Type_Operators
        '-is'          = [pscustomobject] @{ Name = '-is'; FriendlyName = 'type(-inheritance) / interface test'; Topic = 'about_Type_Operators'; Category = 'Type' } 
        '-isnot'       = [pscustomobject] @{ Name = '-isnot'; FriendlyName = 'negated type(-inheritance) / interface test'; Topic = 'about_Type_Operators'; Category = 'Type' } 
        '-as'          = [pscustomobject] @{ Name = '-as'; FriendlyName = 'conditional type conversion'; Topic = 'about_Type_Operators'; Category = 'Type' } 
        # --- Not covered by an operator help topic, but could be considered one.
        # about_Splatting
        '@'            = [pscustomobject] @{ Name = '@'; FriendlyName = 'splatting'; Topic = 'about_Splatting'; Category = 'ArgumentPassing' } 
        # 
        '--%'          = [pscustomobject] @{ Name = '--%'; FriendlyName = 'stop-parsing symbol'; Topic = 'about_Parsing'; Category = 'ArgumentPassing' }
    }

    # As a courtesy, interpret variations of quotes / quoting styles passed as -Name as if -Quoting had been passed instead.
    $parameterSetNameInEffect = $PSCmdlet.ParameterSetName
    if ($Name -replace 's' -match '^(?:''''?|""?|@''(''@)?|@"("@)?)$') {
        $parameterSetNameInEffect = 'QuotingRules'  
    }

    $url = ''

    switch ($parameterSetNameInEffect) {

        'Name' {

            $warning = ''
    
            # See if the name matches an entry as-is.
            # Note: We don't trim the name yet, because we need to suport '. ' to 
            #       disambiguate the dot-sourcing from the member-access operaror.
            $entry = $opTable[$Name]

            # If '.' was passed, warn about member-access / dot-sourcing ambiguity.
            if ($Name -eq '.') {
                $warning = "Defaulting to member-access operator; for the dot-sourcing operator, pass '. '"
            }
            elseif ($Name -eq '&') {
                $warning = "Defaulting to call operator; for the background operator, pass ' &'"
            }
            elseif ($Name.Trim() -eq '@') {
                $warning = "Defaulting to splatting operator; for the array-subexpression operator, pass '@()'; for here-strings, pass '@`"`"@' or -QuotingRules"
            }
            elseif (-not $entry) {   
                # Remove any spaces, to support name variations such as '( )', '[ ]'
                $normalizedName = $Name -replace ' '
            }

            if (-not $entry) {
                # If not, try prepending "-", to allow users to specify 'replace' instead of '-replace', for instance.
                $entry = $opTable["-$normalizedName"]
            }
            if (-not $entry) {
                # Variations of redirection operators.
                if ($entry -match '^[d*]?>>?(&d?)') {
                    $entry = $opTable['>']
                }
            }
            if (-not $entry) {
                # Map case variants to their unqualified form; e.g. '-ireplace' -> '-replace'
                $baseName = $normalizedName -replace '^(?=-?)[ci](?=[a-z])'
                if ($baseName -ne $normalizedName) {
                    if ($baseName -notlike '-*') { $baseName = '-' + $baseName }
                    $entry = $opTable[$baseName]
                }
            }
            if (-not $entry -and $normalizedName -like '`[*`]') {
                # varations of referring to the index / cast / type-constraint operator
                $bracketName = $normalizedName
                if ($bracketName -eq '[]') {
                    $bracketName = '[0]' # default to indexer, but warn
                    $warning = "Defaulting to index operator; for the cast / type-constraint operators, pass '[int]'"
                }
                elseif ($bracketName -match '^[(d+|[''"].*[''"])]$') {
                    $bracketName = '[0]' # indexer - numeric or string
                }
                else {
                    $bracketName = '[int]' # cast
                }
                $entry = $opTable[$bracketName]
            }

            if (-not $entry) {
                Throw "Not a recognized operator: $Name"
            }
            elseif ($warning) {
                Write-Warning $warning
            }

            $url = "https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/" + $entry.Topic
            if ($entry.Anchor) {
                $url += '#' + $entry.Anchor
            }
            break
        }

        'Precedence' {
            $url = 'https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_Operator_Precedence'
            break
        }

        'QuotingRules' {
            $url = 'https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_Quoting_Rules'
            break
        }

        'HomePage' {
            $url = 'https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_Operators'
            break
        }

        'List' {
            # List the operators table below.
        }

        Default { Throw "What are you doing here?" }
    }

    # Insert a query-string component fo the PS version whose version-specific topic to show.
    # When copying a Markdown link, we only include a version if one was explicitly passed.
    if ($url -and ($explicitVersionRequested -or -not $CopyLink)) {
        $versionQueryString = '?view=powershell-' + $Version
        if ($url.Contains('#')) {
            $url = $url -replace '(#.+)$', ($versionQueryString + '$1')
        }
        else {
            $url += $versionQueryString
        }
    }

    # -WhatIf support.
    if (-not $PSCmdlet.ShouldProcess((("`n" + $url + "`n"), "List all operators")[$parameterSetNameInEffect -eq 'List'])) { return }

    if ($parameterSetNameInEffect -eq 'List') {

        $opTable.Values | Select-Object Name, FriendlyName, Category, LookupName | Sort-Object Category, Name

    }
    else {

        if ($CopyLink) {

            # Construct a Markdown link.
            $mdLink = '`{0}`, the [{1} operator]({2})' -f $entry.Name, $entry.FriendlyName, $url

            # Copy to the clipboard.
            Write-Verbose "Copying URL as Markdown links to clipboard: $mdLink"
            Set-Clipboard $mdLink

        }
        else {

            Write-Verbose "Navigating to: $url"
            Start-Process $url

        }
    
    }

}