Fusión nula en powershell

Sí, PowerShell tiene un operador coalescente null real, o al menos un operador que es capaz de tal comportamiento. Ese operador es -ne:

# Format:
# ($a, $b, $c -ne $null)[0]
($null, 'alpha', 1 -ne $null)[0]

# Output:
alpha

Es un poco más versátil que un operador coalescente nulo, ya que crea una matriz de todos los elementos no nulos:

$items = $null, 'alpha', 5, 0, '', @(), $null, $true, $false
$instances = $items -ne $null
[string]::Join(', ', ($instances | ForEach-Object -Process { $_.GetType() }))

# Result:
System.String, System.Int32, System.Int32, System.String, System.Object[],
System.Boolean, System.Boolean

-eq funciona de manera similar, lo cual es útil para contar entradas nulas:

($null, 'a', $null -eq $null).Length

# Result:
2

Pero de todos modos, aquí hay un caso típico para reflejar C # ' s ?? operador:

'Filename: {0}' -f ($filename, 'Unknown' -ne $null)[0] | Write-Output

Explicación

Esta explicación se basa en una sugerencia de edición de un usuario anónimo. ¡Gracias, quienquiera que seas!

Basado en el orden de operaciones, esto funciona en el siguiente orden:

1. El operador , crea una matriz de valores a probar.
2. El operador -ne filtra cualquier elemento de la matriz que coincida con el valor especificado--en este caso, null. El resultado es una matriz de valores no nulos en el mismo ordenar como la matriz creada en el paso 1.
3. [0] se utiliza para seleccionar el primer elemento de la matriz filtrada.

Simplificando eso:

1. Crear una matriz de valores posibles, en orden preferido
2. Excluir todos los valores nulos de la matriz
3. Tome el primer elemento de la matriz resultante

Advertencias

A diferencia del operador coalescente null de C#, cada expresión posible será evaluada, ya que el primer paso es crear un matriz.

Esto es solo la mitad de una respuesta a la primera mitad de la pregunta, por lo que una cuarta respuesta si se quiere, pero hay una alternativa mucho más simple al operador de coalescencia null siempre que el valor predeterminado que desea usar sea en realidad el valor predeterminado para el tipo:

string s = myval ?? "";

Se puede escribir en Powershell como:

([string]myval)

O

int d = myval ?? 0;

Se traduce a Powershell:

([int]myval)

Encontré el primero de estos útiles al procesar un elemento xml que podría no existir y que si existió podría tener espacios en blanco no deseados alrededor de él:

$name = ([string]$row.td[0]).Trim()

El cast to string protege contra que el elemento sea nulo y evita cualquier riesgo de que Trim() falle.

Si instala el Módulo Powershell Community Extensions entonces puede usar:

?? es el alias de Invoke-NullCoalescing.

$s = ?? {$myval}  {"New Value"}

?: es el alias de Invoke-Ternary.

$x = ?: {$myval -eq $null} {""} {$otherval}

$null, $null, 3 | Select -First 1

Devuelve

3

function coalesce {
   Param ([string[]]$list)
   #$default = $list[-1]
   $coalesced = ($list -ne $null)
   $coalesced[0]
 }
 function coalesce_empty { #COALESCE for empty_strings

   Param ([string[]]$list)
   #$default = $list[-1]
   $coalesced = (($list -ne $null) -ne '')[0]
   $coalesced[0]
 }

A menudo encuentro que también necesito tratar la cadena vacía como null cuando uso coalesce. Terminé escribiendo una función para esto, que usa la solución de Zenexer para coalescer para la coalescencia null simple, y luego usé Keith Hill para verificar null o empty, y agregué eso como una bandera para que mi función pudiera hacer ambas cosas.

Una de las ventajas de esta función es que también maneja tener todos los elementos nulos (o vacíos), sin lanzar una excepción. También se puede utilizar para muchas variables de entrada arbitrarias, gracias a cómo PowerShell maneja las entradas de matriz.

function Coalesce([string[]] $StringsToLookThrough, [switch]$EmptyStringAsNull) {
  if ($EmptyStringAsNull.IsPresent) {
    return ($StringsToLookThrough | Where-Object { $_ } | Select-Object -first 1)
  } else {
    return (($StringsToLookThrough -ne $null) | Select-Object -first 1)
  }  
}

Esto produce los siguientes resultados de la prueba:

Null coallesce tests:
1 (w/o flag)  - empty/null/'end'                 : 
1 (with flag) - empty/null/'end'                 : end
2 (w/o flag)  - empty/null                       : 
2 (with flag) - empty/null                       : 
3 (w/o flag)  - empty/null/$false/'end'          : 
3 (with flag) - empty/null/$false/'end'          : False
4 (w/o flag)  - empty/null/"$false"/'end'        : 
4 (with flag) - empty/null/"$false"/'end'        : False
5 (w/o flag)  - empty/'false'/null/"$false"/'end': 
5 (with flag) - empty/'false'/null/"$false"/'end': false

Código de prueba:

Write-Host "Null coalesce tests:"
Write-Host "1 (w/o flag)  - empty/null/'end'                 :" (Coalesce '', $null, 'end')
Write-Host "1 (with flag) - empty/null/'end'                 :" (Coalesce '', $null, 'end' -EmptyStringAsNull)
Write-Host "2 (w/o flag)  - empty/null                       :" (Coalesce('', $null))
Write-Host "2 (with flag) - empty/null                       :" (Coalesce('', $null) -EmptyStringAsNull)
Write-Host "3 (w/o flag)  - empty/null/`$false/'end'          :" (Coalesce '', $null, $false, 'end')
Write-Host "3 (with flag) - empty/null/`$false/'end'          :" (Coalesce '', $null, $false, 'end' -EmptyStringAsNull)
Write-Host "4 (w/o flag)  - empty/null/`"`$false`"/'end'        :" (Coalesce '', $null, "$false", 'end')
Write-Host "4 (with flag) - empty/null/`"`$false`"/'end'        :" (Coalesce '', $null, "$false", 'end' -EmptyStringAsNull)
Write-Host "5 (w/o flag)  - empty/'false'/null/`"`$false`"/'end':" (Coalesce '', 'false', $null, "$false", 'end')
Write-Host "5 (with flag) - empty/'false'/null/`"`$false`"/'end':" (Coalesce '', 'false', $null, "$false", 'end' -EmptyStringAsNull)

Lo más cercano que puedo conseguir es: $s = $myval |?? "new value"

Implementé el operador de coalescencia null para lo anterior de la siguiente manera:

function NullCoalesc {
    param (
        [Parameter(ValueFromPipeline=$true)]$Value,
        [Parameter(Position=0)]$Default
    )

    if ($Value) { $Value } else { $Default }
}

Set-Alias -Name "??" -Value NullCoalesc

El operador ternario condicional podría implementarse de manera similar.

function ConditionalTernary {
    param (
        [Parameter(ValueFromPipeline=$true)]$Value,
        [Parameter(Position=0)]$First,
        [Parameter(Position=1)]$Second
    )

    if ($Value) { $First } else { $Second }
}

Set-Alias -Name "?:" -Value ConditionalTernary

Y se usa como: $x = ($myval -eq $null) |?: "" $otherval