C# - Regex pour les chemins de fichier par exemple C:\test\test.exe

Je suis actuellement à la recherche d'une expression régulière qui peut aider à valider un chemin de fichier par exemple:

C:\test\test2\test.exe
  • Vous pouvez poster ce que vous avez essayé jusqu'à présent et quelques échantillons d'entrée et de sortie attendue?
  • Avez-vous besoin de l'appui des chemins d'accès UNC comme \\server\share\file.txt?
  • la regex C:\\test\\test2\\test\.exe valide votre chemin.
  • Non, pas vraiment, bien que ne dirais pas non
  • Je veux valider un générique chemin, c'était seulement un exemple.
InformationsquelleAutor Dan | 2011-06-20
  1. 30

    J'ai décidé de poster cette réponse, qui n'est d'utiliser une expression régulière.

    ^(?:[a-zA-Z]\:|\\\\[\w\.]+\\[\w.$]+)\\(?:[\w]+\\)*\w([\w.])+$

    Travaux pour ces:

    \\test\test$\TEST.xls
\\server\share\folder\myfile.txt
\\server\share\myfile.txt
\\123.123.123.123\share\folder\myfile.txt
c:\folder\myfile.txt
c:\folder\myfileWithoutExtension

    Edit: Ajout d'un exemple d'utilisation:

    if (Regex.IsMatch (text, @"^(?:[a-zA-Z]\:|\\\\[\w\.]+\\[\w.$]+)\\(?:[\w]+\\)*\w([\w.])+$"))
{
  //Valid
}

    *Edit: * C'est un rapprochement des chemins que vous avez pu voir. Si possible, il est probablement préférable d'utiliser le Chemin de la classe ou de la classe FileInfo pour voir si un fichier ou un dossier existe.

    • Merci, n'oubliez pas de source où vous faites les choses à partir d' 😉
    • Il a écrit pour ma propre édification. Amusant!
    • merci pour le partage.
    • Ne fonctionne pas pour \\test\test$\TEST.xls - problème avec le caractère $ il y a probablement d'autres mauvais cas.
    • merci de remarquer que les cas. J'ai amélioré ma réponse, mais vous avez probablement raison sur les autres cas de bord.
    • Votre expression régulière ne fonctionnera PAS si votre chemin / nom de fichier contient des espaces vides: Regex.IsMatch(@"c:\your folder\sub folder\your file.txt", @"^(?:[a-zA-Z]\:|\\\\[\w\.]+\\[\w.$]+)\\(?:[\w]+\\)*\w([\w.])+$")
    • Votre expression ne fonctionnera pas si votre chemin est ".", exemple: "C:\folder.folder\folder.txt"
    • ne pas travailler avec c:\banana\..\something.exe

    InformationsquelleAutor agent-j
  2. 24

    Je vous conseille d'utiliser le Chemin de classe au lieu d'une Regex si votre objectif est de travailler avec des noms de fichiers.

    Par exemple, vous pouvez appeler Chemin d'accès.GetFullPath pour "vérifier" un chemin, comme il déclenche une ArgumentException si le chemin contient des caractères non valides, ainsi que d'autres exceptiosn si le chemin est trop long, etc. Cela permettra de gérer l'ensemble des règles, ce qui sera difficile à obtenir correct avec une Regex.

    • 59 secondes avant que ma réponse de la même chose, la Bosse de vitesse!
    • Pourriez-vous fournir un exemple de validation s'il vous plaît?
    • voici un exemple, notez que le chemin UNC ou local: si(dans le Répertoire.Existe(Chemin D'Accès.GetDirectoryName(@"C:\Windows\win.ini"))) { /*Répertoire existe et valide*/ }
    InformationsquelleAutor Reed Copsey
  3. 9

    C'est une expression régulière pour Windows chemins:

    (^([a-z]|[A-Z]):(?=\\(?![
    (^([a-z]|[A-Z]):(?=\\(?![\0-\37<>:"/\\|?*])|\/(?![\0-\37<>:"/\\|?*])|$)|^\\(?=[\\\/][^\0-\37<>:"/\\|?*]+)|^(?=(\\|\/)$)|^\.(?=(\\|\/)$)|^\.\.(?=(\\|\/)$)|^(?=(\\|\/)[^\0-\37<>:"/\\|?*]+)|^\.(?=(\\|\/)[^\0-\37<>:"/\\|?*]+)|^\.\.(?=(\\|\/)[^\0-\37<>:"/\\|?*]+))((\\|\/)[^\0-\37<>:"/\\|?*]+|(\\|\/)$)*()$
    -7<>:"/\\|?*])|\/(?![
    (^([a-z]|[A-Z]):(?=\\(?![\0-\37<>:"/\\|?*])|\/(?![\0-\37<>:"/\\|?*])|$)|^\\(?=[\\\/][^\0-\37<>:"/\\|?*]+)|^(?=(\\|\/)$)|^\.(?=(\\|\/)$)|^\.\.(?=(\\|\/)$)|^(?=(\\|\/)[^\0-\37<>:"/\\|?*]+)|^\.(?=(\\|\/)[^\0-\37<>:"/\\|?*]+)|^\.\.(?=(\\|\/)[^\0-\37<>:"/\\|?*]+))((\\|\/)[^\0-\37<>:"/\\|?*]+|(\\|\/)$)*()$
    -<>:"    /\\|?*])|$)|^\\(?=[\\\/][^
    (^([a-z]|[A-Z]):(?=\\(?![\0-\37<>:"/\\|?*])|\/(?![\0-\37<>:"/\\|?*])|$)|^\\(?=[\\\/][^\0-\37<>:"/\\|?*]+)|^(?=(\\|\/)$)|^\.(?=(\\|\/)$)|^\.\.(?=(\\|\/)$)|^(?=(\\|\/)[^\0-\37<>:"/\\|?*]+)|^\.(?=(\\|\/)[^\0-\37<>:"/\\|?*]+)|^\.\.(?=(\\|\/)[^\0-\37<>:"/\\|?*]+))((\\|\/)[^\0-\37<>:"/\\|?*]+|(\\|\/)$)*()$
    -7<>:"/\\|?*]+)|^(?=(\\|\/)$)|^\.(?=(\\|\/)$)|^\.\.(?=(\\|\/)$)|^(?=(\\|\/)[^
    (^([a-z]|[A-Z]):(?=\\(?![\0-\37<>:"/\\|?*])|\/(?![\0-\37<>:"/\\|?*])|$)|^\\(?=[\\\/][^\0-\37<>:"/\\|?*]+)|^(?=(\\|\/)$)|^\.(?=(\\|\/)$)|^\.\.(?=(\\|\/)$)|^(?=(\\|\/)[^\0-\37<>:"/\\|?*]+)|^\.(?=(\\|\/)[^\0-\37<>:"/\\|?*]+)|^\.\.(?=(\\|\/)[^\0-\37<>:"/\\|?*]+))((\\|\/)[^\0-\37<>:"/\\|?*]+|(\\|\/)$)*()$
    -<>:"    /\\|?*]+)|^\.(?=(\\|\/)[^
    (^([a-z]|[A-Z]):(?=\\(?![\0-\37<>:"/\\|?*])|\/(?![\0-\37<>:"/\\|?*])|$)|^\\(?=[\\\/][^\0-\37<>:"/\\|?*]+)|^(?=(\\|\/)$)|^\.(?=(\\|\/)$)|^\.\.(?=(\\|\/)$)|^(?=(\\|\/)[^\0-\37<>:"/\\|?*]+)|^\.(?=(\\|\/)[^\0-\37<>:"/\\|?*]+)|^\.\.(?=(\\|\/)[^\0-\37<>:"/\\|?*]+))((\\|\/)[^\0-\37<>:"/\\|?*]+|(\\|\/)$)*()$
    -7<>:"/\\|?*]+)|^\.\.(?=(\\|\/)[^
    (^([a-z]|[A-Z]):(?=\\(?![\0-\37<>:"/\\|?*])|\/(?![\0-\37<>:"/\\|?*])|$)|^\\(?=[\\\/][^\0-\37<>:"/\\|?*]+)|^(?=(\\|\/)$)|^\.(?=(\\|\/)$)|^\.\.(?=(\\|\/)$)|^(?=(\\|\/)[^\0-\37<>:"/\\|?*]+)|^\.(?=(\\|\/)[^\0-\37<>:"/\\|?*]+)|^\.\.(?=(\\|\/)[^\0-\37<>:"/\\|?*]+))((\\|\/)[^\0-\37<>:"/\\|?*]+|(\\|\/)$)*()$
    -<>:"    /\\|?*]+))((\\|\/)[^
    (^([a-z]|[A-Z]):(?=\\(?![\0-\37<>:"/\\|?*])|\/(?![\0-\37<>:"/\\|?*])|$)|^\\(?=[\\\/][^\0-\37<>:"/\\|?*]+)|^(?=(\\|\/)$)|^\.(?=(\\|\/)$)|^\.\.(?=(\\|\/)$)|^(?=(\\|\/)[^\0-\37<>:"/\\|?*]+)|^\.(?=(\\|\/)[^\0-\37<>:"/\\|?*]+)|^\.\.(?=(\\|\/)[^\0-\37<>:"/\\|?*]+))((\\|\/)[^\0-\37<>:"/\\|?*]+|(\\|\/)$)*()$
    -7<>:"/\\|?*]+|(\\|\/)$)*()$

    Et c'est pour UNIX/Linux chemins

    ^\/$|(^(?=\/)|^\.|^\.\.)(\/(?=[^/
    ^\/$|(^(?=\/)|^\.|^\.\.)(\/(?=[^/\0])[^/\0]+)*\/?$
    ])[^/
    ^\/$|(^(?=\/)|^\.|^\.\.)(\/(?=[^/\0])[^/\0]+)*\/?$
    ]+)*\/?$

    Voici mes tests:

    Gagner Regex

    Unix Regex

    Ces œuvres avec Javascript

    MODIFIER
    J'ai ajouté des chemins relatifs, (../, ./, ../quelque chose)

    EDIT 2
    J'ai ajouté des chemins de départ avec un tilde pour unix, (~/, ~, ~/quelque chose)

    • pourriez-vous s'il vous plaît également faire une modification pour les chemins comme dans ~/ ?
    • Fait! 🙂
    InformationsquelleAutor monkeythedev
  4. 7

    La proposition de l'un n'est pas vraiment bon, celui que j'construire pour XSD, il est spécifique de Windows:

    ^(?:[a-zA-Z]\:(\\|\/)|file\:\/\/|\\\\|\.(\/|\\))([^\\\/\:\*\?\<\>\"\|]+(\\|\/){0,1})+$
    • correction - être supprimer " dans le cas contraire déclenche une erreur lors de l'utilisation
    • Ce un a mieux fonctionné pour moi (a détecté tous les chemins d'accès UNC que j'ai envoyé), mais je ne suis pas assez familier avec la regex pour savoir si les " doit être supprimé ou échappé (par exemple, changé à "" pour vb.net). Je n'ai pas réellement voir une différence dans les tests, la regex travaillé dans les deux sens.
    • Cette échoue pour C:/ (aussi avec une barre oblique inverse). Version fixe: ^(?:[A-Z]\:|\.|(?:file\:\/\/|\\\\)[^\\\/\:\*\?\<\>\"\|]+)(?:(?:\\|\/)[^\\\/\:\*\?\<\>\"\|]+)*(?:\\|\/)?$. Celui-ci fonctionne sous l'hypothèse que dans le cas \\name, C:\name, et file://name pour toutes les occurences de name les mêmes règles s'appliquent (c'est à dire name ne peut contenir aucun des caractères de \/:*?<>"|.
    • les chemins d'accès relatifs? par exemple, si le chemin commence par ..
    InformationsquelleAutor Alexander
  5. 4

    Essayez celui-ci pour Windows et Linux: ((?:[a-zA-Z]\:){0,1}(?:[\\/][\w.]+){1,})

    • si c'est un chemin relatif? par exemple, commence avec ..? btw, je l'ai essayé et il ne correspond à une partie du chemin
    • Le schéma ci-dessus manque un '\' autre le " / " pour être reconnu comme l'expression régulière pattern. Le modèle devrait ressembler à ça: ((?:[a-zA-Z]\:){0,1}(?:[\\\/][\w.]+){1,})
    InformationsquelleAutor ryan
  6. 4

    J'utilise cette expression pour la capture de fichier valide/les chemins de dossier de windows (y compris les Unc et %variable%), à l'exclusion de les chemins de la racine, comme "C:\" ou "\\serverName"

    ^(([a-zA-Z]:|\\\\\w[ \w\.]*)(\\\w[ \w\.]*|\\%[ \w\.]+%+)+|%[ \w\.]+%(\\\w[ \w\.]*|\\%[ \w\.]+%+)*)

    cette expression ne correspond pas à les espaces dans le chemin d'accès pour les éléments,

    • "C:\program les fichiers" correspond
    • "C:\ pathWithLeadingSpace" ne correspond pas

    variables sont autorisés à n'importe quel niveau

    • %program files%" correspond
    • "C:\my chemin d'accès à l'intérieur des espaces\%mon var avec des espaces intérieurs%" correspond
    • quid des parents chemins?
    • un argument valable. L' "A:-Z:/\\ServerName" préfixe seraient nécessaires pour être rendu facultatif.
    InformationsquelleAutor Federico Destefanis
  7. 1
    regex CmdPrompt("^([A-Z]:[^\<\>\:\"\|\?\*]+)");

    Fondamentalement, nous recherchons tout ce qui n'est pas dans la liste des interdits de Chemin d'accès Windows Caractères:

    < (less than)
> (greater than)
: (colon)
" (double quote)
| (vertical bar or pipe)
? (question mark)
* (asterisk)
    • pourriez-vous ajouter un lien vers la source s'il vous plaît?
    • Pour être pédant: caractères de 0 à 32 ne sont pas autorisés.
    InformationsquelleAutor Bill
  8. 0

    J'ai trouvé le plus de réponses ici à être un peu frappé ou manquer.

    A trouvé une bonne solution ici:

    https://social.msdn.microsoft.com/forums/vstudio/en-US/31d2bc84-c948-4914-8a9d-97b9e788b341/validate-a-network-folder-path

    Remarque* - ce n'est que pour les partages réseau, pas de fichiers locaux

    Réponse:

    string pattern = @"^\\{2}[\w-]+(\\{1}(([\w-][\w-\s]*[\w-]+[$$]?)|([\w-][$$]?$)))+";
string[] names = { @"\\my-network\somelocation", @"\\my-network\\somelocation", 
    @"\\\my-network\somelocation", @"my-network\somelocation",
     @"\\my-network\\somelocation",@"\\my-network\somelocation\aa\dd",
     @"\\my-network\somelocation\",@"\\my-network\\somelocation"};
foreach (string name in names)
{
 if (Regex.IsMatch(name, pattern))
 {
  Console.WriteLine(name);
   //Directory.Exists function to check if file exists
 }
}
    InformationsquelleAutor Steve
  9. 0

    Alexandre Réponse + les Chemins d'accès Relatifs

    Alexander a le plus de bonne réponse à ce jour puisqu'il prend en charge les espaces dans les noms de fichier (c'est à dire C:\Program Files (x86)\ correspondra)... Ceci vise à inclure les chemins relatifs en tant que bien.

    Par exemple, vous pouvez faire cd / ou cd \ et il fait la même chose.

    De plus, si vous êtes actuellement dans C:\some\path\to\some\place et vous tapez l'une de ces commandes, vous vous retrouvez à C:\

    Encore plus, vous devriez envisager de chemins, qui commence par '/' comme un chemin de la racine (pour le lecteur en cours).

    (?:[a-zA-Z]:(\|/)|file://|\\|.(/|\)|/)([^,\/:*\?\<>\"\|]+(\|/){0,1})

    Une version Modifiée d'Alexandre réponse, cependant, nous incluons les chemins sont relatifs à aucun / ou lettre de lecteur, ainsi que / avec pas de lettre de lecteur (par rapport à ce disque en tant que root).

    InformationsquelleAutor Decoded