Wie kann überprüft werden, ob ein bestimmter Pfad möglicherweise ein Kind eines anderen Pfads ist?

Ich versuche herauszufinden, ob der angegebene Pfad ein mögliches Kind eines anderen Pfads mit Java ist. Beide Pfade sind möglicherweise nicht vorhanden.

Sagen c:\Program Files\My Company\test\My App ist ein mögliches Kind von c:\Program Files.

Aktuell mache ich das mit

boolean myCheck(File maybeChild, File possibleParent)
{
    return maybeChild.getAbsolutePath().startsWith( possibleParent.getAbsolutePath());
}

Sie können auch verwenden java.nio.file.Path um dies viel einfacher zu tun. Der java.nio.file.Path.startsWith Methode scheint alle möglichen Fälle zu behandeln.

Beispiel:

private static void isChild(Path child, String parentText) {
    Path parent = Paths.get(parentText).toAbsolutePath();
    System.out.println(parentText + " = " + child.startsWith(parent));
}

public static void main(String[] args) {
    Path child = Paths.get("/FolderA/FolderB/File").toAbsolutePath();
    isChild(child, "/FolderA/FolderB/File");
    isChild(child, "/FolderA/FolderB/F");
    isChild(child, "/FolderA/FolderB");
    isChild(child, "/FolderA/Folder");
    isChild(child, "/FolderA");
    isChild(child, "/Folder");
    isChild(child, "/");
    isChild(child, "");
}

Ausgang:

/FolderA/FolderB/File = true
/FolderA/FolderB/F = false
/FolderA/FolderB = true
/FolderA/Folder = false
/FolderA = true
/Folder = false
/ = true
 = false

Wenn Sie mehr Zuverlässigkeit benötigen, können Sie verwenden toRealPath anstatt toAbsolutePath.

File parent = maybeChild.getParentFile();
while ( parent != null ) {
  if ( parent.equals( possibleParent ) )
    return true;
  parent = parent.getParentFile();
}
return false;

Abgesehen davon, dass die Pfade möglicherweise nicht existieren (und die Kanonisierung möglicherweise nicht gelingt), sieht dies nach einem vernünftigen Ansatz aus, der im einfachen Fall funktionieren sollte.

Vielleicht möchten Sie sich das Aufrufen ansehen getParentFile() auf dem “vielleicht Kind” in einer Schleife und testet bei jedem Schritt, ob es mit dem Elternteil übereinstimmt. Sie können den Vergleich auch kurzschließen, wenn das übergeordnete Verzeichnis kein (echtes) Verzeichnis ist.

Vielleicht etwas wie das Folgende:

boolean myCheck(File maybeChild, File possibleParent) throws IOException
{
    final File parent = possibleParent.getCanonicalFile();
    if (!parent.exists() || !parent.isDirectory()) {
        // this cannot possibly be the parent
        return false;
    }

    File child = maybeChild.getCanonicalFile();
    while (child != null) {
        if (child.equals(parent)) {
            return true;
        }
        child = child.getParentFile();
    }
    // No match found, and we've hit the root directory
    return false;
}

Beachten Sie, dass, wenn Sie möchten, dass die untergeordnete Beziehung ist strikt (dh ein Verzeichnis ist kein Kind von sich selbst) können Sie den Anfangsbuchstaben ändern child Zuweisung auf Zeile 9 zu sein child.getParentFile() Die erste Prüfung findet also im enthaltenden Verzeichnis des untergeordneten Elements statt.

Dies wird für Ihr Beispiel funktionieren. Es wird auch zurückkehren true wenn das Kind ein relativer Pfad ist (was oft wünschenswert ist.)

boolean myCheck(File maybeChild, File possibleParent)
{
    URI parentURI = possibleParent.toURI();
    URI childURI = maybeChild.toURI();
    return !parentURI.relativize(childURI).isAbsolute();
}

Das wird wahrscheinlich so funktionieren, wie es ist, obwohl ich es verwenden würde getCanonicalPath() statt getAbsolutePath(). Dies sollte alle seltsamen Pfade wie normalisieren x/../y/z die sonst das Matching vermasseln würden.

maybeChild.getCanonicalPath().startsWith( possibleParent.getCanonicalPath() );

Achten Sie auf relative Pfade! Ich denke, die einfachste Lösung ist ungefähr so:

public boolean myCheck(File maybeChild, File possibleParent) {
  if (requestedFile.isAbsolute) {
    return possibleParent.resolve(maybeChild).normalize().toAbsolutePath.startsWith(possibleParent.normalize().toAbsolutePath)
  } else {
    return maybeChild.normalize().toAbsolutePath.startsWith(possibleParent.normalize().toAbsolutePath)
  }
}

In Scala können Sie einen ähnlichen Ansatz haben:

val baseDir = Paths.get("/home/luvar/tmp")
val baseDirF = baseDir.toFile
//val requestedFile = Paths.get("file1")
val requestedFile = Paths.get("../.viminfo")
val fileToBeRead = if (requestedFile.isAbsolute) {
  requestedFile
} else {
  baseDir.resolve(requestedFile)
}
fileToBeRead.toAbsolutePath
baseDir.toAbsolutePath
fileToBeRead.normalize()
baseDir.normalize()
val isSubpath = fileToBeRead.normalize().toAbsolutePath.startsWith(baseDir.normalize().toAbsolutePath)