Valor de retorno de la función en PowerShell

Desarrollé una función de PowerShell que realiza una serie de acciones que implican el aprovisionamiento de sitios de SharePoint Team. En última instancia, quiero que la función devuelva la URL del sitio aprovisionado como una Cadena, así que al final de mi función tengo el siguiente código:

$rs = $url.ToString();
return $rs;

El código que llama a esta función se ve así:

$returnURL = MyFunction -param 1 ...

Así que espero una cadena, sin embargo, no lo es. En cambio, es un objeto de tipo System.Management.Automation.PSMethod. ¿Por qué devuelve ese tipo en lugar de un tipo de cadena?

PowerShell tiene una semántica de retorno realmente extraña, al menos cuando se ve desde una perspectiva de programación más tradicional. Hay dos ideas principales para entender:

• Toda la salida se captura y se devuelve.
• La palabra clave return realmente solo indica un punto de salida lógico

Por lo tanto, los siguientes dos bloques de script harán exactamente lo mismo:

$a = "Hello, World"
return $a

$a = "Hello, World"
$a
return

La variable $ a en el segundo ejemplo se deja como salida en la tubería y, como se mencionó, se devuelve toda la salida. De hecho, en el segundo ejemplo, podría omitir el retorno por completo y obtendría el mismo comportamiento (el retorno estaría implícito a medida que la función se completa y sale de forma natural).

Sin más de su definición de función, no puedo decir por qué está obteniendo un objeto PSMethod. Supongo que probablemente tengas algo en línea que no se está capturando y se está colocando en la tubería de salida.

También vale la pena señalar que probablemente no necesite esos puntos y comas, a menos que esté anidando varias expresiones en una sola línea.

Puede leer más sobre la semántica de retorno en la página about_Return en TechNet, o invocando el help returncomando desde PowerShell.

Esta parte de PowerShell es probablemente el aspecto más estúpido. Cualquier salida extraña generada durante una función contaminará el resultado. A veces no hay salida, y luego, en algunas condiciones, hay otra salida no planificada, además de su valor de retorno planificado.

Entonces, elimino la asignación de la llamada a la función original, de modo que el resultado termina en la pantalla, y luego paso hasta que algo que no planeé aparece en la ventana del depurador (usando el ISE de PowerShell ).

Incluso cosas como reservar variables en ámbitos externos causan resultados, como lo [boolean]$isEnabledcual escupirá molestamente un False a menos que lo haga [boolean]$isEnabled = $false.

Otra buena es la $someCollection.Add("thing")que escupe el nuevo recuento de colecciones.

Con PowerShell 5 ahora tenemos la capacidad de crear clases. Cambie su función a una clase, y return solo devolverá el objeto inmediatamente anterior. Aquí hay un ejemplo muy simple.

class test_class {
    [int]return_what() {
        Write-Output "Hello, World!"
        return 808979
    }
}
$tc = New-Object -TypeName test_class
$tc.return_what()

Si esta fuera una función, el resultado esperado sería

Hello World
808979

pero como clase, lo único que se devuelve es el entero 808979. Una clase es como una garantía de que solo devolverá el tipo declarado o nulo.

Como solución, he estado devolviendo el último objeto en la matriz que obtienes de la función ... No es una gran solución, pero es mejor que nada:

someFunction {
   $a = "hello"
   "Function is running"
   return $a
}

$b = someFunction
$b = $b[($b.count - 1)]  # Or
$b = $b[-1]              # Simpler

Con todo, una forma más lineal de escribir lo mismo podría ser:

$b = (someFunction $someParameter $andAnotherOne)[-1]

Paso un objeto Hashtable simple con un solo miembro de resultado para evitar la locura de retorno, ya que también quiero enviar a la consola. Actúa a través del pase por referencia.

function sample-loop($returnObj) {
  for($i = 0; $i -lt 10; $i++) {
    Write-Host "loop counter: $i"
    $returnObj.result++
  }
}

function main-sample() {
  $countObj = @{ result = 0 }
  sample-loop -returnObj $countObj
  Write-Host "_____________"
  Write-Host "Total = " ($countObj.result)
}

main-sample

Puedes ver ejemplos reales de uso en mi proyecto GitHub unpackTunes .

Es difícil de decir sin mirar el código. Asegúrese de que su función no devuelva más de un objeto y que capture los resultados de otras llamadas. ¿Qué obtienes por:

@($returnURL).count

De todos modos, dos sugerencias:

Lanza el objeto a una cadena:

...
return [string]$rs

O simplemente enciérrelo entre comillas dobles, igual que arriba pero más corto para escribir:

...
return "$rs"

La descripción de Luke de los resultados de la función en estos escenarios parece ser correcta. Solo deseo comprender la causa raíz y el equipo del producto PowerShell haría algo al respecto. Parece ser bastante común y me ha costado demasiado tiempo de depuración.

Para solucionar este problema, he estado usando variables globales en lugar de devolver y usar el valor de la llamada a la función.

Aquí hay otra pregunta sobre el uso de variables globales: establecer una variable global de PowerShell desde una función donde el nombre de la variable global es una variable que se pasa a la función

Lo siguiente simplemente devuelve 4 como respuesta. Cuando reemplaza las expresiones de agregar para cadenas, devuelve la primera cadena.

Function StartingMain {
  $a = 1 + 3
  $b = 2 + 5
  $c = 3 + 7
  Return $a
}

Function StartingEnd($b) {
  Write-Host $b
}

StartingEnd(StartingMain)

Esto también se puede hacer para una matriz. El siguiente ejemplo devolverá "Texto 2"

Function StartingMain {
  $a = ,@("Text 1","Text 2","Text 3")
  Return $a
}

Function StartingEnd($b) {
  Write-Host $b[1]
}

StartingEnd(StartingMain)

Tenga en cuenta que debe llamar a la función debajo de la función misma. De lo contrario, la primera vez que se ejecute devolverá un error que no sabe qué es "StartingMain".

Las respuestas existentes son correctas, pero a veces no estás devolviendo algo explícitamente con a Write-Outputo a return, sin embargo, hay un valor misterioso en los resultados de la función. Esta podría ser la salida de una función integrada comoNew-Item

PS C:\temp> function ContrivedFolderMakerFunction {
>>    $folderName = [DateTime]::Now.ToFileTime()
>>    $folderPath = Join-Path -Path . -ChildPath $folderName
>>    New-Item -Path $folderPath -ItemType Directory
>>    return $true
>> }
PS C:\temp> $result = ContrivedFolderMakerFunction
PS C:\temp> $result


    Directory: C:\temp


Mode                LastWriteTime         Length Name
----                -------------         ------ ----
d-----         2/9/2020   4:32 PM                132257575335253136
True

Todo ese ruido extra de la creación del directorio se está recopilando y emitiendo en la salida. La manera fácil de mitigar esto es agregar | Out-Nullal final de la New-Itemdeclaración, o puede asignar el resultado a una variable y simplemente no usar esa variable. Se vería así ...

PS C:\temp> function ContrivedFolderMakerFunction {
>>    $folderName = [DateTime]::Now.ToFileTime()
>>    $folderPath = Join-Path -Path . -ChildPath $folderName
>>    New-Item -Path $folderPath -ItemType Directory | Out-Null
>>    # -or-
>>    $throwaway = New-Item -Path $folderPath -ItemType Directory 
>>    return $true
>> }
PS C:\temp> $result = ContrivedFolderMakerFunction
PS C:\temp> $result
True

New-Itemes probablemente el más famoso de estos, pero otros incluyen todos los StringBuilder.Append*()métodos, así como el SqlDataAdapter.Fill()método.