How can I stop Powershell filtering from converting my array to string?

To complement my comment and vonPryz's answer

PowerShell 'unravels' one-element arrays when returning from a function or scriptblock into a single scalar, in this case a string.

To prevent that from interfering with the rest of the code which expects an array, no matter if it is empty or has only one element, you can force the output to become an array by wrapping it inside @().

In your case,

($list | ? {$_ -ne "B"})

would return the single element A, turned into a scalar String, while

@($list | ? {$_ -ne "B"}).GetType().Name

returns an array (Object[]) with just one element in it.

While what the other two answers say usually works, it won't work in all cases.

Take, for example, this case:

@(
    @('single-element-array') | 
        ForEach-Object { "$_".Trim() } |
        Sort-Object -Unique
) | ConvertTo-Json

The result will simply be:

"single-element-array"

First, that code above looks silly, but, assume that you had queried for some data and the result was a single element array, whose element may consist of whitespace or is $null, and you wanted to ensure that the value collapses to '', hence the "$_".Trim(). OK, with that out of the way, the resulting JSON is probably not what one would expect coming from other programming languages such as C#.

Much as described by the other answers, since this expression flows through a pipeline, the same rules as described by others apply, and the resulting object is "unwrapped".

Typically, a function implements a pipeline as follows:

function Some-Function {
    [CmdletBinding()]
    Param (
        [Parameter(Mandatory, ValueFromPipeline)]
        [object[]] $InputObject
    )

    Begin {
        # This block is optional
    }

    Process {
        # This block is optional, too, but is required
        # to process pipelined objects

        foreach ($o in $Object) {
            # do something
        }
    }

    End {
        # This block is optional IF a Process block
        # is defined.

        # If no Begin, Process, or End blocks are defined,
        # the code after the parameters is assumed to be
        # an End block, which effectively turns the function
        # into a PowerShell 2.0 filter function.

        # When data is piped into this function, and a Process
        # block exists, the value of $InputObject in this block
        # is the very last item that was piped in.
        # In cases where the pipeline is not being used, $InputObject
        # is the value of the parameter as passed to the function.
    }
}

To use the above:

$Stuff | Some-Function

In a function like this, using the pipeline, values are processed serially. Each value in $Stuff is piped into the function. If the function has a Begin block, that runs once, before any value is processed from parameters passed in via the pipeline, i.e. other non-pipelined parameter values are available in the Begin block. The Process block is then executed once for each value pipelined in. Finally, if the function has an End block, that is run at the very end after all values piped in have been processed.

So, why use a foreach statement in the Process block? To handle when the function is called thusly:

Some-Function -InputObject $Stuff

In this invocation, the entire array of $Stuff is passed by parameter to the function. So, in order to process the data correctly, a foreach loop in the Process block is used. And this should now give you the information you need to know how to circumvent the problem in my first example. In order for that example to run correctly, it needs to be done as follows:

ConvertTo-JSON -InputObject @(
    @('single-element-array') |
        ForEach-Object { "$_".Trim() } |
        Sort-Object -Unique
)

And this results in the expected JSON:

[
  "single-element-array"
]

Hope that helps to clarify the issue.