Variables in powershell are context sensitive. If I define a function like:

$bar = "Hi"
function foo {
   $bar = "Hey!"
}
$bar <-- returns "Hi"

Then the $bar variable is not available to me outside that function. To make variables available outside of functions then you can control the scope of a function. If I set a variable in a function using the script or global prefix then the variable will be available for the whole script or globally in powershell runspace. See here:

function foo {
   $script:fooVar = "world"
}

function bar {
   foo
   $global:barVar = "Hello " + $fooVar
}

The variable $fooVar in the foo function will be available to all other functions within the script due to the scope prefix script of the variable $fooVar. The barVar function will be available globally in the runspace. I.e. when your script has finished the variable is still present back at the command line and even to other scripts.

As you can see in the bar function I first call foo and then use the foovVar variable. When I use the $fooVar variable I don't have to specify the $script:fooVar, I can if I want to but it's not necessary.

These are all valid variable assignments:

script:bbb = 123
$global:ccc = 123 

So in your case use $script:source and $script:target or $global:source and $global:target. For more info run the following command:

Help About_Scope

this is a function that gets user input, asks if it is correct, repeats if NOT correct, and finally sends the text out to the caller.

function Get-ExchangeGroupName
    {
    $Prompt = 'Please enter the Group name '

    $Choice = ''
    while ($Choice -eq '')
        {
        $Choice = Read-Host $Prompt
        Write-Host ('You entered [ {0} ].' -f $Choice)
        $YesNo = Read-Host '    Is that correct? [n/y]'
        if ($YesNo -eq 'y')
            {
            # send the result out to the caller
            $Choice
            }
            else
            {
            $Choice = ''
            }
        }
    } # function Get-ExchangeGroupName

$ChosenGroupName = Get-ExchangeGroupName
''
$ChosenGroupName

output with n & y responses to "is that correct?" ...

Please enter the Group name : qwerty
You entered [ qwerty ].
    Is that correct? [n/y]: n
Please enter the Group name : AlfaBravo
You entered [ AlfaBravo ].
    Is that correct? [n/y]: y

AlfaBravo

To aid future maintenance, I’ve got my user management script calling another script to get the address information for different offices, which should pass back the right info to be used in the AD user management.

So, if add-user.ps1 gets the variable $ADOffice=“New York” it calls get-OfficeAddress.ps1 where a switch statement passes back the correct street address, state, and zip code.

Then add-user.ps1 goes on to make the appropriate changes to the target user in the AD.

It looks like this:

add-user.ps1

Param(
    [Parameter( Mandatory = $false)]
    [string]$ADoffice = "New York" 
    )

&("C:\Scripts\User Mgmt Automation\get-OfficeAddress.ps1") $ADoffice

Then get-OfficeAddress.ps1 picks that up like so:

switch ($Office)
      {
         "Albany" {
         $ADstreetAddress="123 Main Street" 
         $ADcity="Albany" 
         $ADstate="NY"
         $ADpostalCode="123456"
          }
         "New York"{
         $ADstreetAddress="1313 Mockingbird Lane" 
         $ADcity="New York" 
         $ADstate="NY"
         $ADpostalCode="131313"
          }
         }

Write-Host $ADoffice,$ADstreetAddress,$ADcity,$ADstate,$ADpostalCode

The screen output shows the results on the screen fine, but I don’t know how to pass those variables back into ad-user.ps1 just after the call to get-OfficeAddress.ps1

Could you point me in the right direction, please?

Hello

In my form, I declare my radio buttons, textboxes etc.

In my group, I have a series of radiobuttons, so I am using the .Add_Click{whichoption} on the group to indicate that if a group item is clicked (radiobutton), it will run a function.

The function simply says that :

function whichoption{
#Check that there is a computername entered before assigning a value
If($Compname = $txtsetUACComp.Text) {
If($rdoOption1.checked) {$UACoption = 1}
If($rdoOption2.checked) {$UACoption = 2}
If($rdoOption3.checked) {$UACoption = 3}
If($rdoOption4.checked) {$UACoption = 4}
}
}

Once the whichoption function has run, I call another function that requires parameters (-computername and -option). This option also requires credentials So I have use the following in order to prompt for Credentials (inside the function).

$c=Get-credential
$Username = $c.UserName

Im using:

[System.Windows.MessageBox]::Show(($CompName) + ", " + $UACOption)

to see what values have been passed, and it is always blank ($compName and $UACOption do not have values).

So this leads me to believe it is a scoping issue.

I have attempted to use:

Function whichoption() {
If($txtsetUACComp.Text) {
$grpOptions.Enabled = $True #don't enable radiobuttons until a computername is typed in.
$Global:CompName = $Script:txtsetUACComp.Text + $txtsetUACComp.Text
if($rdoOption1.checked) {$Global:UACOption = 1 + $UACOption}
if($rdoOption2.checked) {$Global:UACOption = 2 + $UACOption}
if($rdoOption3.checked) {$Global:UACOption = 3 + $UACOption}
if($rdoOption4.checked) {$Global:UACOption = 4 + $UACOption}
return $UACOption
}
}

But the same results.

The function I am calling has the following parameters:

Param ([String] $Script:CompName, [int] $Script:UACOption)

And the command to call the function is:

$btnUAC.Add_Click({ChangeUAC -Computername $Script:CompName -Option $Script:UACOption})

Any suggestions?

Thank You

Terry

Parameters in calls to functions in PowerShell (all versions) are space-separated, not comma-separated. Also, the parentheses are entirely unnecessary and will cause a parse error in PowerShell 2.0 (or later) if Set-StrictMode -Version 2 or higher is active. Parenthesised arguments are used in .NET methods only.

function foo($a, $b, $c) {
   "a: $a; b: $b; c: $c"
}

Execute:

foo 1 2 3

Output:

a: 1; b: 2; c: 3

Variables in PowerShell are scoped, meaning they only exist for the duration of the function that they're created in.

What you'll want to do is create a function that returns the string values:

function Get-PSNames
{
  'tiny'
  'jommy'
}

You can then assign them to your own variables when you call the function:

$tony,$tlony = Get-PSNames

And pass them as arguments to your other function:

function Get-PSAdded([string]$Name, [string]$OtherName)
{
  # Remember to use the same variable names you used when defining the function's parameters
  $Name + $OtherName
}

# call the function 
$tony,$tlony = Get-PSNames

$newName = Get-PSAdded -Name $tony -OtherName $tlony

The $arg[] array appears to lose scope inside the ForEach-Object.

function foo($arg1, $arg2)
{
  echo $arg1
  echo $arg2.FullName
}

echo "0: $($args[0])"
echo "1: $($args[1])"
$zero = $args[0]
$one = $args[1]
$items = get-childitem $args[1] 
$items | foreach-object {
    echo "inner 0: $($zero)"
    echo "inner 1: $($one)"
}

If you want a function with parameters you need to define the parameters. You may also want to use the canonical Verb-Noun form for your function name (see here for a list of approved verbs).

Simple approach:

function Deploy-WindowsTemplate($Cluster, $VMHost) {
    foreach ($image in $winimage) {
        $templatename = $image, $Cluster -join "_"
        ...
    }
}

More advanced approach:

function Deploy-WindowsTemplate {
    [CmdletBinding()]
    Param(
        [Parameter(Mandatory=$true)]
        [string]$Cluster,
        [Parameter(Mandatory=$true)]
        [string]$VMHost
    )

    foreach ($image in $winimage) {
        $templatename = $image, $Cluster -join "_"
        ...
    }
}

If you want you could also go without parameters and use the automatic variable $args, although I wouldn't recommend that.

function Deploy-WindowsTemplate {
    foreach ($image in $winimage) {
        $templatename = $image, $args[0] -join "_"
        ...
    }
}

Note, however, that when calling a function parameter/argument values are separated by whitespace, not commas. They can be passed as positional parameters (by default in the order the parameters were defined)

Deploy-WindowsTemplate $wincluster $vmhostwin

or named parameters

Deploy-WindowsTemplate -Cluster $wincluster -VMHost $vmhostwin

Comma-separated values are passed as a single array argument.

Deploy-WindowsTemplate $wincluster, $vmhostwin
#                      ^^^^^^^^^^^^^^^^^^^^^^^
#                           one argument!

When creating functions in Powershell and using the param code, the params will define what parameters you can use.

In your code, you have the following:

   param(
            $apiHost = '........',
            $apiEndpoint = $pathApi,
            $requestMethod = 'GET'
    )

This means, your function __Main now has 3 parameters, -ApiHost, -ApiEndpoint and -requestMethod.

You have not specified $pathApi, so your function does not get the parameter passed to it, and thus it is empty.

If you however change your request to the following:

__main -apiEndpoint "/ad/user/id"

It will start working as expected.

Alternatively, change the param function as follows:

   param(
            $apiHost = '........',
            $pathApi = '',
            $requestMethod = 'GET'
    )

    $apiEndpoint = $pathApi

Keep in mind, that when working with restapi's, you usually want to add a / to the end of the path. If you don't, POST may not work.