Use a for loop (or a foreach loop that iterates over the array index...same difference). I don't know of any system variable that holds the current array index inside a foreach loop, and I don't think one exists.

# example array
$array = "A", "B", "C"
$item = "B"
0..($array.Count - 1) | Where { $array[item }

mjolinor's answer is conceptually elegant, but slow with large arrays, presumably due to having to build a parallel array of indices first (which is also memory-inefficient).

It is conceptually similar to the following LINQ-based solution (PSv3+), which is more memory-efficient and about twice as fast, but still slow:

$arr = 'A','D','B','D','C','E','D','F'
[Linq.Enumerable]::Where(
 [Linq.Enumerable]::Range(0, $arr.Length), 
   [Func[int, bool]] { param(arr[$i] -eq 'D' }
)

While any PowerShell looping solution is ultimately slow compared to a compiled language, the following alternative, while more verbose, is still much faster with large arrays:

PS C:\> & { param(val)
         $i = 0
         foreach (arr) { if (val) { $i } ++$i }
        } ('A','D','B','D','C','E','D','F') 'D'
1
3
6

Note:

• Perhaps surprisingly, this solution is even faster than Matt's solution, which calls [array]::IndexOf() in a loop instead of enumerating all elements.

• Use of a script block (invoked with call operator & and arguments), while not strictly necessary, is used to prevent polluting the enclosing scope with helper variable $i.

• The foreach statement is faster than the Foreach-Object cmdlet (whose built-in aliases are % and, confusingly, also foreach).

• Simply (implicitly) outputting $i for each match makes PowerShell collect multiple results in an array.

  • If only one index is found, you'll get a scalar [int] instance instead; wrap the whole command in @(...) to ensure that you always get an array.

• While $i by itself outputs the value of $i, ++$i by design does NOT (though you could use (++$i) to achieve that, if needed).

• Unlike Array.IndexOf(), PowerShell's -eq operator is case-insensitive by default; for case-sensitivity, use -ceq instead.

It's easy to turn the above into a (simple) function (note that the parameters are purposely untyped, for flexibility):

function get-IndicesOf($Array, $Value) {
  $i = 0
  foreach (Array) { 
    if (Value) { $i } 
    ++$i
  }
}

# Sample call
PS C:\> get-IndicesOf ('A','D','B','D','C','E','D','F') 'D'
1
3
6

doesn't look like there is an indexOf() method for array in powershell, which is what you're looking for.

This is more cumbersome, but should work:

$i = 0
    while ($i -lt $a.length)
    {
        if ($a[$i] -eq $input)
        {
            return $i
        }
    $i++
    }

The way that .NET by default compares things is just not as forgiving as PowerShell is!

[array]::IndexOf($array, $reference) will go through the array and return the current index when it encounters an item for which the following is true:

$item.Equals($reference)

... which is NOT necessarily the same as doing

$item -eq $reference

For simple values, like numbers and dates and so on, Equals() works exactly like -eq:

PS C:\> $a = 1
PS C:\> $b = 1
PS C:\> $a.Equals($b)  # $true

... which is the reason your first example works as expected!

For more complex objects though, Equals() works a bit differently. Both values MUST refer to the same object, it's not enough that they have similar or even identical values:

PS C:\> $a = New-Object object
PS C:\> $b = New-Object object
PS C:\> $a.Equals($b)    # $false

In the example above, $a and $b are similar (if not identical) - they're both empty objects - but they are not the same object.

Similarly, if we test with your input values, they aren't the same either:

PS C:\> $a = Get-Item "C:\"
PS C:\> $b = "C:\"
PS C:\> $a.Equals($b)    # $false

One of the reasons they can't be considered the same, as AdminOfThings excellently explains, is type mismatch - but PowerShell's comparison operators can help us here!

You'll notice that this works:

PS C:\> $a = Get-Item "C:\"
PS C:\> $b = "C:\"
PS C:\> $b -eq $a
True

That's because the behavior of -eq depends on the left-hand operand. In the example above, "C:\" is a string, so PowerShell converts $a to a string, and all of a sudden the comparison is more like "C:\".Equals("C:\")!

With this in mind, you could create your own Find-IndexOf function to do $reference -eq $item (or any other comparison mechanism you'd like) with a simple for() loop:

function Find-IndexOf
{
  param(
    [array]$Array,
    [object]$Value
  )

  for($idx = 0; $idx -lt $Array.Length; $idx++){
    if($Value -eq $Array[$idx]){
      return $idx
    }
  }

  return -1
}

Now you'd be able to do:

PS C:\> $array = @('','PowerShell is case-insensitive by default')
PS C:\> $value = 'POWERsheLL iS cASe-InSenSItIVe BY deFAuLt'
PS C:\> Find-IndexOf -Array $array -Value $value
1

Or:

PS C:\> $array = Get-ChildItem C:\images
PS C:\> $value = 'C:\images\image123.png'
PS C:\> Find-IndexOf -Array $array -Value $value
5

Adding comparison against a specific property on each of the array items (like the file's Name in your example), we end up with something like this:

function Find-IndexOf
{
  param(
    [array]$Array,
    [object]$Value,
    [string]$Property
  )

  if($Property){
    for($idx = 0; $idx -lt $Array.Length; $idx++){
      if($Value -eq $Array[$idx].$Property){
        return $idx
      }
    }
  }
  else {
    for($idx = 0; $idx -lt $Array.Length; $idx++){
      if($Value -eq $Array[$idx]){
        return $idx
      }
    }
  }

  return -1
}

Find-IndexOf -Array @(Get-ChildItem C:\images) -Value image123.png -Property Name

.NET has some handy utility methods for this sort of thing in System.Array:

PS> $a = 'a','b','c'
PS> [array]::IndexOf($a, 'b')
1
PS> [array]::IndexOf($a, 'c')
2

Good points on the above approach in the comments. Besides "just" finding an index of an item in an array, given the context of the problem, this is probably more suitable:

$letters = { 'A', 'B', 'C' }
$letters | % {$i=0} {"Value:$_ Index:$i"; $i++}

Foreach (%) can have a Begin sciptblock that executes once. We set an index variable there and then we can reference it in the process scripblock where it gets incremented before exiting the scriptblock.