Quels caractères sont interdits dans les noms de répertoire Windows et Linux?

Je sais que / est illégal sous Linux, et ce qui suit est illégal sous Windows (je pense) * . " / \ [ ] : ; | ,

Que manque-t-il d'autre?

J'ai besoin d'un guide complet, cependant, et qui prend en compte les caractères codés sur deux octets. Le lien avec des ressources extérieures me convient.

Je dois d'abord créer un répertoire sur le système de fichiers en utilisant un nom qui peut contenir des caractères interdits, je prévois donc de remplacer ces caractères par des traits de soulignement. J'ai ensuite besoin d'écrire ce répertoire et son contenu dans un fichier zip (en utilisant Java), donc tout conseil supplémentaire concernant les noms des répertoires zip serait apprécié.

Un «guide complet» des caractères de noms de fichiers interdits ne fonctionnera pas sous Windows car il réserve les noms de fichiers ainsi que les caractères. Oui, les caractères comme * " ?et autres sont interdits, mais il existe un nombre infini de noms composés uniquement de caractères valides qui sont interdits. Par exemple, les espaces et les points sont des caractères de nom de fichier valides, mais les noms composés uniquement de ces caractères sont interdits.

Windows ne fait pas de distinction entre les majuscules et les minuscules, vous ne pouvez donc pas créer un dossier nommé As'il en aexiste déjà un. Pire, les noms apparemment autorisés comme PRNet CON, et bien d'autres, sont réservés et non autorisés. Windows a également plusieurs restrictions de longueur; un nom de fichier valide dans un dossier peut devenir invalide s'il est déplacé vers un autre dossier. Les règles de dénomination des fichiers et des dossiers se trouvent sur les documents Microsoft.

Vous ne pouvez pas, en général, utiliser du texte généré par l'utilisateur pour créer des noms de répertoire Windows. Si vous souhaitez autoriser les utilisateurs à quoi que ce soit le nom qu'ils veulent, vous devez créer des noms sûrs comme A, AB, A2et al., Stocker des noms générés par les utilisateurs et leurs équivalents de chemin dans un fichier de données d'application, et effectuer la cartographie de chemin dans votre application.

Si vous devez absolument autoriser les noms de dossiers générés par l'utilisateur, la seule façon de savoir s'ils ne sont pas valides consiste à intercepter les exceptions et à supposer que le nom n'est pas valide. Même cela est lourd de dangers, car les exceptions levées pour l'accès refusé, les lecteurs hors ligne et l'espace disque manquent avec celles qui peuvent être levées pour des noms non valides. Vous ouvrez une énorme boîte de mal.

Restons simples et répondons d'abord à la question.

1. Les caractères ASCII imprimables interdits sont:

   • Linux / Unix:

     / (forward slash)
     

   • Les fenêtres:

     < (less than)
     > (greater than)
     : (colon - sometimes works, but is actually NTFS Alternate Data Streams)
     " (double quote)
     / (forward slash)
     \ (backslash)
     | (vertical bar or pipe)
     ? (question mark)
     * (asterisk)
     

2. Caractères non imprimables

   Si vos données proviennent d'une source qui autoriserait les caractères non imprimables, il y a plus à vérifier.

   • Linux / Unix:

     0 (NULL byte)
     

   • Les fenêtres:

     0-31 (ASCII control characters)
     

   Remarque: Bien qu'il soit légal sous les systèmes de fichiers Linux / Unix de créer des fichiers avec des caractères de contrôle dans le nom de fichier, cela peut être un cauchemar pour les utilisateurs de traiter ces fichiers .

3. Noms de fichiers réservés

   Les noms de fichiers suivants sont réservés:

   • Les fenêtres:

     CON, PRN, AUX, NUL 
     COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9
     LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, LPT9
     

     (à la fois seuls et avec des extensions de fichiers arbitraires, par exemple LPT1.txt).

4. Autres règles

   • Les fenêtres:

     Les noms de fichiers ne peuvent pas se terminer par un espace ou un point.

Sous Linux et d'autres systèmes liés à Unix, il n'y a que deux caractères qui ne peuvent pas apparaître dans le nom d'un fichier ou d'un répertoire, ce sont NUL '\0'et slash '/'. La barre oblique, bien sûr, peut apparaître dans un nom de chemin, séparant les composants du répertoire.

Selon la rumeur ^1, Steven Bourne (de renommée `` shell '') avait un répertoire contenant 254 fichiers, un pour chaque lettre (code de caractère) qui peut apparaître dans un nom de fichier (à l'exclusion de /, '\0'le nom .était le répertoire actuel, bien sûr ). Il a été utilisé pour tester le shell Bourne et faire des ravages routiniers sur des programmes imprudents tels que des programmes de sauvegarde.

D'autres personnes ont couvert les règles de Windows.

Notez que MacOS X possède un système de fichiers insensible à la casse.

Lorsque Steve Bourne écrivait son shell Unix (qui est devenu le Bourne shell), il a créé un répertoire de 254 fichiers avec des noms à un caractère, un pour chaque valeur d'octet sauf '\0'et slash, les deux caractères qui ne peuvent pas apparaître dans Unix noms de fichiers. Il a utilisé ce répertoire pour toutes sortes de tests de correspondance de modèles et de tokenisation. (Le répertoire de test a bien sûr été créé par un programme.) Pendant des années après, ce répertoire a été le fléau des programmes d'arborescence de fichiers; il les a testés jusqu'à la destruction.

^{Notez que le répertoire doit avoir contenu des entrées .et .., par conséquent, il s'agissait sans doute de 253 fichiers (et de 2 répertoires), ou 255 entrées de nom, plutôt que de 254 fichiers. Cela n'affecte pas l'efficacité de l'anecdote, ni les tests minutieux qu'elle décrit.}

Au lieu de créer une liste noire de personnages, vous pouvez utiliser une liste blanche . Tout bien considéré, la plage de caractères qui a du sens dans un contexte de nom de fichier ou de répertoire est assez courte, et à moins que vous n'ayez des exigences de dénomination très spécifiques, vos utilisateurs ne le retiendront pas contre votre application s'ils ne peuvent pas utiliser la table ASCII entière.

Cela ne résout pas le problème des noms réservés dans le système de fichiers cible, mais avec une liste blanche, il est plus facile d'atténuer les risques à la source.

Dans cet esprit, il s'agit d'une gamme de personnages qui peuvent être considérés comme sûrs:

• Lettres (az AZ) - Caractères Unicode également, si nécessaire
• Chiffres (0-9)
• Souligner (_)
• Trait d'union (-)
• Espace
• Point (.)

Et tous les caractères de sécurité supplémentaires que vous souhaitez autoriser. Au-delà de cela, il vous suffit d'appliquer certaines règles supplémentaires concernant les espaces et les points . Cela suffit généralement:

• Le nom doit contenir au moins une lettre ou un chiffre (pour éviter uniquement les points / espaces)
• Le nom doit commencer par une lettre ou un chiffre (pour éviter les points / espaces en tête)
• Le nom ne peut pas se terminer par un point ou un espace (il suffit de les rogner s'ils sont présents, comme le fait Explorer)

Cela permet déjà des noms assez complexes et absurdes. Par exemple, ces noms seraient possibles avec ces règles et seraient des noms de fichiers valides sous Windows / Linux:

• A...........ext
• B -.- .ext

En substance, même avec si peu de caractères sur la liste blanche, vous devez toujours décider de ce qui a du sens et valider / ajuster le nom en conséquence. Dans l'une de mes applications, j'ai utilisé les mêmes règles que ci-dessus, mais j'ai supprimé les points et les espaces en double.

Le moyen le plus simple pour que Windows vous dise la réponse est d'essayer de renommer un fichier via l'Explorateur et de taper / pour le nouveau nom. Windows affichera une boîte de message vous indiquant la liste des caractères illégaux.

A filename cannot contain any of the following characters:
    \ / : * ? " < > | 

https://support.microsoft.com/en-us/kb/177506

Eh bien, ne serait-ce qu'à des fins de recherche, alors votre meilleur pari est de regarder cette entrée Wikipedia sur les noms de fichiers .

Si vous souhaitez écrire une fonction portable pour valider l'entrée utilisateur et créer des noms de fichiers en fonction de cela, la réponse courte est non . Jetez un oeil à un module portable comme File :: Spec de Perl pour avoir un aperçu de tous les sauts nécessaires pour accomplir une tâche aussi "simple".

Pour Windows, vous pouvez le vérifier à l'aide de PowerShell

$PathInvalidChars = [System.IO.Path]::GetInvalidPathChars() #36 chars

Pour afficher les codes UTF-8, vous pouvez convertir

$enc = [system.Text.Encoding]::UTF8
$PathInvalidChars | foreach { $enc.GetBytes($_) }

$FileNameInvalidChars = [System.IO.Path]::GetInvalidFileNameChars() #41 chars

$FileOnlyInvalidChars = @(':', '*', '?', '\', '/') #5 chars - as a difference

Dans Windows 10 (2019), les caractères suivants sont interdits par une erreur lorsque vous essayez de les taper:

Un nom de fichier ne peut contenir aucun des caractères suivants:

\ / : * ? " < > |

Voici l'implémentation ac # pour Windows basée sur la réponse de Christopher Oezbek

Il a été rendu plus complexe par le booléen containsFolder, mais nous espérons qu'il couvre tout

/// <summary>
/// This will replace invalid chars with underscores, there are also some reserved words that it adds underscore to
/// </summary>
/// <remarks>
/// /programming/1976007/what-characters-are-forbidden-in-windows-and-linux-directory-names
/// </remarks>
/// <param name="containsFolder">Pass in true if filename represents a folder\file (passing true will allow slash)</param>
public static string EscapeFilename_Windows(string filename, bool containsFolder = false)
{
    StringBuilder builder = new StringBuilder(filename.Length + 12);

    int index = 0;

    // Allow colon if it's part of the drive letter
    if (containsFolder)
    {
        Match match = Regex.Match(filename, @"^\s*[A-Z]:\\", RegexOptions.IgnoreCase);
        if (match.Success)
        {
            builder.Append(match.Value);
            index = match.Length;
        }
    }

    // Character substitutions
    for (int cntr = index; cntr < filename.Length; cntr++)
    {
        char c = filename[cntr];

        switch (c)
        {
            case '\u0000':
            case '\u0001':
            case '\u0002':
            case '\u0003':
            case '\u0004':
            case '\u0005':
            case '\u0006':
            case '\u0007':
            case '\u0008':
            case '\u0009':
            case '\u000A':
            case '\u000B':
            case '\u000C':
            case '\u000D':
            case '\u000E':
            case '\u000F':
            case '\u0010':
            case '\u0011':
            case '\u0012':
            case '\u0013':
            case '\u0014':
            case '\u0015':
            case '\u0016':
            case '\u0017':
            case '\u0018':
            case '\u0019':
            case '\u001A':
            case '\u001B':
            case '\u001C':
            case '\u001D':
            case '\u001E':
            case '\u001F':

            case '<':
            case '>':
            case ':':
            case '"':
            case '/':
            case '|':
            case '?':
            case '*':
                builder.Append('_');
                break;

            case '\\':
                builder.Append(containsFolder ? c : '_');
                break;

            default:
                builder.Append(c);
                break;
        }
    }

    string built = builder.ToString();

    if (built == "")
    {
        return "_";
    }

    if (built.EndsWith(" ") || built.EndsWith("."))
    {
        built = built.Substring(0, built.Length - 1) + "_";
    }

    // These are reserved names, in either the folder or file name, but they are fine if following a dot
    // CON, PRN, AUX, NUL, COM0 .. COM9, LPT0 .. LPT9
    builder = new StringBuilder(built.Length + 12);
    index = 0;
    foreach (Match match in Regex.Matches(built, @"(^|\\)\s*(?<bad>CON|PRN|AUX|NUL|COM\d|LPT\d)\s*(\.|\\|$)", RegexOptions.IgnoreCase))
    {
        Group group = match.Groups["bad"];
        if (group.Index > index)
        {
            builder.Append(built.Substring(index, match.Index - index + 1));
        }

        builder.Append(group.Value);
        builder.Append("_");        // putting an underscore after this keyword is enough to make it acceptable

        index = group.Index + group.Length;
    }

    if (index == 0)
    {
        return built;
    }

    if (index < built.Length - 1)
    {
        builder.Append(built.Substring(index));
    }

    return builder.ToString();
}

Au 18/04/2017, aucune simple liste noire ou blanche de caractères et de noms de fichiers n'apparaissait parmi les réponses à ce sujet - et il existe de nombreuses réponses.

La meilleure suggestion que j'ai pu trouver était de laisser l'utilisateur nommer le fichier comme il l'entend. Utiliser un gestionnaire d'erreurs lorsque l'application essaie d'enregistrer le fichier, intercepter toutes les exceptions, supposer que le nom de fichier est à blâmer (évidemment après s'être assuré que le chemin d'enregistrement était correct également), et demander à l'utilisateur un nouveau nom de fichier. Pour de meilleurs résultats, placez cette procédure de vérification dans une boucle qui se poursuit jusqu'à ce que l'utilisateur réussisse ou abandonne. Fonctionné le mieux pour moi (au moins en VBA).

Bien que les seuls caractères Unix illégaux puissent être /et NULL, bien qu'une certaine considération pour l'interprétation en ligne de commande devrait être incluse.

Par exemple, même s'il peut être légal de nommer un fichier 1>&2ou 2>&1sous Unix, des noms de fichiers comme celui-ci peuvent être mal interprétés lorsqu'ils sont utilisés sur une ligne de commande.

De même, il peut être possible de nommer un fichier $PATH, mais lorsque vous essayez d'y accéder à partir de la ligne de commande, le shell se traduira $PATHpar sa valeur de variable.

Des difficultés à définir ce qui est légal ou non ont déjà été abordées et des listes blanches ont été suggérées . Mais Windows prend en charge les caractères supérieurs à 8 bits . Wikipédia déclare que (par exemple) le

la lettre de modification deux-points [( voir 7. ci-dessous ) est] parfois utilisée dans les noms de fichiers Windows car elle est identique aux deux points dans la police Segoe UI utilisée pour les noms de fichiers. Le deux-points [ASCII hérité] lui-même n'est pas autorisé.

Par conséquent, je veux présenter une approche beaucoup plus libérale utilisant des caractères Unicode pour remplacer ceux "illégaux". J'ai trouvé le résultat dans mon cas d'utilisation comparable beaucoup plus lisible. Regardez par exemple dans ce bloc . De plus, vous pouvez même restaurer le contenu d'origine à partir de cela. Les choix et recherches possibles sont fournis dans la liste suivante:

1. Au lieu de *( U+002A * ASTERISK), vous pouvez utiliser l' un des nombreux répertoriés, par exemple U+2217 ∗ (ASTERISK OPERATOR)ouFull Width Asterisk U+FF0A ＊
2. Au lieu de ., vous pouvez utiliser l'un d' eux , par exemple⋅ U+22C5 dot operator
3. Au lieu de ", vous pouvez utiliser “ U+201C english leftdoublequotemark(Alternatives voir ici )
4. Au lieu de /( / SOLIDUS U+002F), vous pouvez utiliser ∕ DIVISION SLASH U+2215(d'autres ici )
5. Au lieu de \( \ U+005C Reverse solidus), vous pouvez utiliser ⧵ U+29F5 Reverse solidus operator( plus )
6. Au lieu de [( U+005B Left square bracket) et ]( U+005D Right square bracket), vous pouvez utiliser par exemple U+FF3B［ FULLWIDTH LEFT SQUARE BRACKETet U+FF3D ］FULLWIDTH RIGHT SQUARE BRACKET(à partir d' ici , plus de possibilités ici )
7. Au lieu de :, vous pouvez utiliser U+2236 ∶ RATIO (for mathematical usage)ou U+A789 ꞉ MODIFIER LETTER COLON, (voir deux - points (lettre) , parfois utilisé dans les noms de fichiers Windows car il est identique au deux-points dans la police d' interface utilisateur Segoe utilisée pour les noms de fichiers. Le deux-points lui-même n'est pas autorisé) (voir ici )
8. Au lieu de ;, vous pouvez utiliser U+037E ; GREEK QUESTION MARK(voir ici )
9. Pour |, il y a quelques bons substituts tels que: U+0964 । DEVANAGARI DANDA, U+2223 ∣ DIVIDESou U+01C0 ǀ LATIN LETTER DENTAL CLICK( Wikipedia ). Les personnages de dessin de boîte contiennent également diverses autres options.
10. Au lieu de ,( , U+002C COMMA), vous pouvez utiliser par exemple ‚ U+201A SINGLE LOW-9 QUOTATION MARK(voir ici )
11. Pour ?( U+003F ? QUESTION MARK), ce sont de bons candidats: U+FF1F ？ FULLWIDTH QUESTION MARKou U+FE56 ﹖ SMALL QUESTION MARK(de lui re , deux autres de Symboles Bloc , recherchez « question »)

Lors de la création de raccourcis Internet dans Windows, pour créer le nom de fichier, il ignore les caractères illégaux, à l'exception de la barre oblique, qui est convertie en moins.

Dans les shells Unix, vous pouvez citer presque tous les caractères entre guillemets simples '. Excepté le guillemet simple lui-même, et vous ne pouvez pas exprimer de caractères de contrôle, car il \n'est pas développé. L'accès au guillemet simple lui-même à partir d'une chaîne entre guillemets est possible, car vous pouvez concaténer des chaînes avec des guillemets simples et doubles, comme ceux 'I'"'"'m'qui peuvent être utilisés pour accéder à un fichier appelé "I'm"(les guillemets doubles sont également possibles ici).

Vous devez donc éviter tous les caractères de contrôle, car ils sont trop difficiles à saisir dans le shell. Le reste est toujours drôle, en particulier les fichiers commençant par un tiret, car la plupart des commandes les lisent comme des options, sauf si vous avez deux tirets --avant ou si vous les spécifiez avec ./, ce qui masque également le début -.

Si vous voulez être gentil, n'utilisez aucun des caractères que le shell et les commandes typiques utilisent comme éléments syntaxiques, parfois dépendant de la position, donc par exemple vous pouvez toujours utiliser -, mais pas comme premier caractère; de même avec ., vous ne pouvez l'utiliser comme premier caractère que lorsque vous le pensez ("fichier caché"). Quand vous êtes méchant, vos noms de fichiers sont des séquences d'échappement VT100 ;-), de sorte qu'un ls brouille la sortie.

J'avais le même besoin et recherchais des recommandations ou des références standard et suis tombé sur ce fil. Ma liste noire actuelle de caractères à éviter dans les noms de fichiers et de répertoires est la suivante:

$CharactersInvalidForFileName = {
    "pound" -> "#",
    "left angle bracket" -> "<",
    "dollar sign" -> "$",
    "plus sign" -> "+",
    "percent" -> "%",
    "right angle bracket" -> ">",
    "exclamation point" -> "!",
    "backtick" -> "`",
    "ampersand" -> "&",
    "asterisk" -> "*",
    "single quotes" -> "“",
    "pipe" -> "|",
    "left bracket" -> "{",
    "question mark" -> "?",
    "double quotes" -> "”",
    "equal sign" -> "=",
    "right bracket" -> "}",
    "forward slash" -> "/",
    "colon" -> ":",
    "back slash" -> "\\",
    "lank spaces" -> "b",
    "at sign" -> "@"
};