How can I tell if a specified folder is in my PATH using PowerShell?

Question

How can I tell if a specified folder is in my PATH using PowerShell?

A function like this would be great:

function FolderIsInPATH($Path_to_directory) {
    # If the directory is in PATH, return true, otherwise false
}

Answer 1

Going off this question, you don't need a function for this but can retrieve this with $Env:Path:

$Env:Path -split ";" -contains $directory

The -contains operator is case-insensitive which is a bonus. It could be useful placing this in a function to ensure trailing slashes are trimmed, but that's uncommon:

function inPath($directory) {
    return ($Env:Path -split ';').TrimEnd('\') -contains $directory.TrimEnd('\')
}

Answer 2

There's a bunch of answers that do a $path.Split(";") or $path -split ";" that will probably be fine for 99.9% of real-world scenarios, but there's a comment on the accepted answer on a similar question here by Joey that says:

Will fail with quoted paths that contain semicolons.

Basically, it's a bit of an edge case, but this is a perfectly valid PATH on Windows:

c:\temp;"c:\my ; path";c:\windows

so here's a hot mess of code to address that...

function Test-IsInPath
{
    param( [string] $Path, [string] $Folder )

    # we're going to treat the path as a csv record, but we
    # need to know how many columns there are so we can create
    # some fake header names. this might give a higher count
    # than the real value if there *are* quoted folders with
    # semicolons in them, but that's not really an issue
    $columnCount = $Path.Length - $Path.Replace(";","").Length

    # generate the list of column names. the actual names
    # don't matter - it's just so ConvertFrom-Csv treats our
    # PATH as a data row instead of a header row
    $headers = 0..$columnCount

    # parse the PATH as a csv record using ";" as a delimiter
    $obj = $path | ConvertFrom-Csv -header $headers -delimiter ";"

    # extract an array of all the values (i.e. folders)
    # in the record we just parsed
    $entries = $obj.psobject.properties.value

    # check if the folder we're looking for is in the list
    return $entries.Contains($Folder)

}

Whether this is a "better" answer than the simple split approach depends on whether you expect to have quoted folders that contain semicolons in your PATH or not :-)...

Example usage:

PS C:\> Test-IsInPath -Path $env:PATH -Folder "c:\temp"
False

PS C:\> Test-IsInPath -Path "c:\temp;`"c:\my ; path`";c:\windows" -Folder "c:\temp"
True

PS C:\> Test-IsInPath -Path "c:\temp;`"c:\my ; path`";c:\windows" -Folder "c:\my ; path"
True

---

Notes

• what this still doesn't solve is paths that end (or don't end) with a trailing "\" - e.g. testing for C:\temp when the PATH contains C:\temp\ and vice versa.

• it also doesn't address any of the other myriad exceptions to path handling listed here: How to check if a directory exists in %PATH%

Answer 3

I would go for something like this

function FolderIsInPATH {
    param (
        [parameter(Mandatory=$true)]
        [ValidateNotNullOrEmpty()]$your_searched_folder
        [parameter(Mandatory=$true)]
        [ValidateNotNullOrEmpty()]$Path
    )
    
    $Folders = Get-Childitem -Path $Path -Directory

    foreach ($Folder in $Folders) {
        if ($Folder.Name -eq $your_searched_folder) {
            ##Folder found
        } else {
            ##folder not found
        }
    }
}

Answer 4

You can get your PATH using [Environment]::GetEnvironmentVariables()

[Environment]::GetEnvironmentVariables()

Or if you want to get the user environment variables:

[Environment]::GetEnvironmentVariables("User")

Next, get the PATH variable:

$Path = [Environment]::GetEnvironmentVariables().Path # returns the PATH

Then check if the specified folder is in your PATH:

$Path.Contains($Path_to_directory + ";")

The function put together:

function FolderIsInPath($Path_to_directory) {
    return [Environment]::GetEnvironmentVariables("User").Path.Contains($Path_to_directory + ";")
}

However, this function is case-sensitive. You can use String.ToLower() to make it not case-sensitive.

function FolderIsInPath($Path_to_directory) {
    return [Environment]::GetEnvironmentVariables("User").Path.ToLower().Contains($Path_to_directory.ToLower() + ";")
}

Now call your function like this:

FolderIsInPath("C:\\path\\to\\directory")

Note that the path must be absolute.

As pointed out in mclayton's comment, this function won't work for the last path variable. To address this issue, simply add a ; to the end of the path. Your function would now look like this.

function FolderIsInPath($Path_to_directory) {
    return [Environment]::GetEnvironmentVariables("User").Path.ToLower() + ";".Contains($Path_to_directory.ToLower() + ";")
}