rt/snapraid
1
0
Fork 0
mirror of https://github.com/amadvance/snapraid.git synced 2026-10-26 02:49:02 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Clarify double-star wildcard matching behavior in pattern documentation

Browse source
This commit is contained in:
Andrea Mazzoleni 2026-08-26 14:38:06 +02:00
parent 76e8ae2498
commit f9b31db1a7
42 changed files with 561 additions and 525 deletions
Download patch file Download diff file Expand all files Collapse all files

27
doc/snapraid-de.1
View file

@ -2091,18 +2091,19 @@ Schrägstrich, was ihn für den Abgleich innerhalb einer einzelnen Pfadkomponent
geeignet macht. Dies ist das Standardverhalten von Wildcards, das vom Shell\-
Globbing bekannt ist.
.PP
Der Doppelstern \`**\` ist mächtiger; er entspricht jeder Folge von
Zeichen einschließlich Verzeichnistrennzeichen. Dies ermöglicht es Mustern, über
mehrere Verzeichnisebenen hinweg übereinzustimmen. Wenn \`**\` direkt in
ein Muster eingebettet ist, kann es null oder mehr Zeichen einschließlich Schrägstrichen zwischen
dem umgebenden wörtlichen Text entsprechen.
Der Doppelstern\-Platzhalter \`**\` entspricht nur dann über Verzeichnistrennzeichen
hinweg, wenn er an ein Verzeichnistrennzeichen angrenzt (einem Schrägstrich
vorangestellt oder nachgestellt). In dieser Form entspricht er null oder mehr
Zeichen über Verzeichnisebenen hinweg. Zum Beispiel entspricht \`foo/**/bar\` den
Pfaden \`foo/bar\`, \`foo/a/bar\` und \`foo/a/b/bar\`; \`**/build\` entspricht \`build\`
und \`foo/bar/build\`; und \`src/**.js\` entspricht \`src/main.js\` und
\`src/ui/components/main.js\`.
Die alleinstehende Form \`/**/\` wird nicht als vollständiges Muster akzeptiert.
.PP
Die wichtigste Verwendung von \`**\` ist in der speziellen Form \`/**/\`. Dies entspricht
null oder mehr vollständigen Verzeichnisebenen, was es möglich macht, Dateien
in jeder Tiefe eines Verzeichnisbaums abzugleichen, ohne die genaue Pfadstruktur zu kennen.
Zum Beispiel entspricht das Muster \`src/**/main.js\` dem Pfad \`src/main.js\` (Überspringen
von null Verzeichnissen), \`src/ui/main.js\` (Überspringen eines Verzeichnisses) und
\`src/ui/components/main.js\` (Überspringen von zwei Verzeichnissen).
Wenn \`**\` nicht an einen Schrägstrich angrenzt, verhält er sich wie \`*\` und
entspricht keinen Verzeichnistrennzeichen. Zum Beispiel entspricht \`**.jpg\`
der Datei \`photo.jpg\` im aktuellen Verzeichnis, nicht jedoch \`dir/photo.jpg\`.
Verwenden Sie für diesen Zweck \`**/*.jpg\`.
.PP
Zeichenklassen mit eckigen Klammern \`[]\` entsprechen einem einzelnen Zeichen aus einer
bestimmten Menge oder einem Bereich. Wie die anderen Einzelzeichenmuster
@ -2111,8 +2112,8 @@ ein Ausrufezeichen.
.PP
Der grundlegende Unterschied, den man sich merken sollte, ist, dass \`*\`, \`?\` und Zeichenklassen
alle Verzeichnisgrenzen respektieren und nur innerhalb einer einzelnen Pfadkomponente
übereinstimmen, während \`**\` das einzige Muster ist, das über Verzeichnistrennzeichen
hinweg übereinstimmen kann.
übereinstimmen, während \`**\` nur dann über Verzeichnistrennzeichen hinweg übereinstimmen kann,
wenn es an einen Schrägstrich angrenzt.
.PP
Es gibt vier verschiedene Arten von Mustern:
.TP

27
doc/snapraid-de.d
View file

@ -1685,18 +1685,19 @@ Muster (Pattern)
geeignet macht. Dies ist das Standardverhalten von Wildcards, das vom Shell-
Globbing bekannt ist.
Der Doppelstern `**` ist mächtiger; er entspricht jeder Folge von
Zeichen einschließlich Verzeichnistrennzeichen. Dies ermöglicht es Mustern, über
mehrere Verzeichnisebenen hinweg übereinzustimmen. Wenn `**` direkt in
ein Muster eingebettet ist, kann es null oder mehr Zeichen einschließlich Schrägstrichen zwischen
dem umgebenden wörtlichen Text entsprechen.
Der Doppelstern-Platzhalter `**` entspricht nur dann über Verzeichnistrennzeichen
hinweg, wenn er an ein Verzeichnistrennzeichen angrenzt (einem Schrägstrich
vorangestellt oder nachgestellt). In dieser Form entspricht er null oder mehr
Zeichen über Verzeichnisebenen hinweg. Zum Beispiel entspricht `foo/**/bar` den
Pfaden `foo/bar`, `foo/a/bar` und `foo/a/b/bar`; `**/build` entspricht `build`
und `foo/bar/build`; und `src/**.js` entspricht `src/main.js` und
`src/ui/components/main.js`.
Die alleinstehende Form `/**/` wird nicht als vollständiges Muster akzeptiert.
Die wichtigste Verwendung von `**` ist in der speziellen Form `/**/`. Dies entspricht
null oder mehr vollständigen Verzeichnisebenen, was es möglich macht, Dateien
in jeder Tiefe eines Verzeichnisbaums abzugleichen, ohne die genaue Pfadstruktur zu kennen.
Zum Beispiel entspricht das Muster `src/**/main.js` dem Pfad `src/main.js` (Überspringen
von null Verzeichnissen), `src/ui/main.js` (Überspringen eines Verzeichnisses) und
`src/ui/components/main.js` (Überspringen von zwei Verzeichnissen).
Wenn `**` nicht an einen Schrägstrich angrenzt, verhält er sich wie `*` und
entspricht keinen Verzeichnistrennzeichen. Zum Beispiel entspricht `**.jpg`
der Datei `photo.jpg` im aktuellen Verzeichnis, nicht jedoch `dir/photo.jpg`.
Verwenden Sie für diesen Zweck `**/*.jpg`.
Zeichenklassen mit eckigen Klammern `[]` entsprechen einem einzelnen Zeichen aus einer
bestimmten Menge oder einem Bereich. Wie die anderen Einzelzeichenmuster
@ -1705,8 +1706,8 @@ Muster (Pattern)
Der grundlegende Unterschied, den man sich merken sollte, ist, dass `*`, `?` und Zeichenklassen
alle Verzeichnisgrenzen respektieren und nur innerhalb einer einzelnen Pfadkomponente
übereinstimmen, während `**` das einzige Muster ist, das über Verzeichnistrennzeichen
hinweg übereinstimmen kann.
übereinstimmen, während `**` nur dann über Verzeichnistrennzeichen hinweg übereinstimmen kann,
wenn es an einen Schrägstrich angrenzt.
Es gibt vier verschiedene Arten von Mustern:

27
doc/snapraid-de.txt
View file

@ -1798,18 +1798,19 @@ Schrägstrich, was ihn für den Abgleich innerhalb einer einzelnen Pfadkomponent
geeignet macht. Dies ist das Standardverhalten von Wildcards, das vom Shell-
Globbing bekannt ist.
Der Doppelstern `**` ist mächtiger; er entspricht jeder Folge von
Zeichen einschließlich Verzeichnistrennzeichen. Dies ermöglicht es Mustern, über
mehrere Verzeichnisebenen hinweg übereinzustimmen. Wenn `**` direkt in
ein Muster eingebettet ist, kann es null oder mehr Zeichen einschließlich Schrägstrichen zwischen
dem umgebenden wörtlichen Text entsprechen.
Der Doppelstern-Platzhalter `**` entspricht nur dann über Verzeichnistrennzeichen
hinweg, wenn er an ein Verzeichnistrennzeichen angrenzt (einem Schrägstrich
vorangestellt oder nachgestellt). In dieser Form entspricht er null oder mehr
Zeichen über Verzeichnisebenen hinweg. Zum Beispiel entspricht `foo/**/bar` den
Pfaden `foo/bar`, `foo/a/bar` und `foo/a/b/bar`; `**/build` entspricht `build`
und `foo/bar/build`; und `src/**.js` entspricht `src/main.js` und
`src/ui/components/main.js`.
Die alleinstehende Form `/**/` wird nicht als vollständiges Muster akzeptiert.
Die wichtigste Verwendung von `**` ist in der speziellen Form `/**/`. Dies entspricht
null oder mehr vollständigen Verzeichnisebenen, was es möglich macht, Dateien
in jeder Tiefe eines Verzeichnisbaums abzugleichen, ohne die genaue Pfadstruktur zu kennen.
Zum Beispiel entspricht das Muster `src/**/main.js` dem Pfad `src/main.js` (Überspringen
von null Verzeichnissen), `src/ui/main.js` (Überspringen eines Verzeichnisses) und
`src/ui/components/main.js` (Überspringen von zwei Verzeichnissen).
Wenn `**` nicht an einen Schrägstrich angrenzt, verhält er sich wie `*` und
entspricht keinen Verzeichnistrennzeichen. Zum Beispiel entspricht `**.jpg`
der Datei `photo.jpg` im aktuellen Verzeichnis, nicht jedoch `dir/photo.jpg`.
Verwenden Sie für diesen Zweck `**/*.jpg`.
Zeichenklassen mit eckigen Klammern `[]` entsprechen einem einzelnen Zeichen aus einer
bestimmten Menge oder einem Bereich. Wie die anderen Einzelzeichenmuster
@ -1818,8 +1819,8 @@ ein Ausrufezeichen.
Der grundlegende Unterschied, den man sich merken sollte, ist, dass `*`, `?` und Zeichenklassen
alle Verzeichnisgrenzen respektieren und nur innerhalb einer einzelnen Pfadkomponente
übereinstimmen, während `**` das einzige Muster ist, das über Verzeichnistrennzeichen
hinweg übereinstimmen kann.
übereinstimmen, während `**` nur dann über Verzeichnistrennzeichen hinweg übereinstimmen kann,
wenn es an einen Schrägstrich angrenzt.
Es gibt vier verschiedene Arten von Mustern:

27
doc/snapraid-es.1
View file

@ -2050,18 +2050,19 @@ barra diagonal, lo que lo hace adecuado para buscar coincidencias dentro de un s
componente de ruta. Este es el comportamiento estándar de los comodines familiar
del globbing de la shell.
.PP
el doble asterisco \`**\` es más potente, coincide con cualquier secuencia de
caracteres, incluidos los separadores de directorios. Esto permite que los patrones coincidan
a través de múltiples niveles de directorio. Cuando \`**\` aparece incrustado directamente en
un patrón, puede coincidir con cero o más caracteres, incluidas las barras diagonales entre
el texto literal circundante.
El comodín de doble asterisco \`**\` coincide a través de los separadores de
directorios solo cuando es adyacente a un separador de directorios (precedido
o seguido por una barra diagonal). En esta forma, coincide con cero o más
caracteres a través de niveles de directorio. Por ejemplo, \`foo/**/bar\`
coincide con \`foo/bar\`, \`foo/a/bar\` y \`foo/a/b/bar\`; \`**/build\` coincide con
\`build\` y \`foo/bar/build\`; y \`src/**.js\` coincide con \`src/main.js\` y
\`src/ui/components/main.js\`.
La forma independiente \`/**/\` no se acepta como un patrón completo.
.PP
El uso más importante de \`**\` es en la forma especial \`/**/\`. Esta coincide con
cero o más niveles de directorio completos, lo que permite que los archivos coincidan
a cualquier profundidad en un árbol de directorios sin conocer la estructura exacta de la ruta.
Por ejemplo, el patrón \`src/**/main.js\` coincide con \`src/main.js\` (saltando
cero directorios), \`src/ui/main.js\` (saltando un directorio) y
\`src/ui/components/main.js\` (saltando dos directorios).
Cuando \`**\` no es adyacente a una barra diagonal, se comporta como \`*\` y no
coincide con los separadores de directorios. Por ejemplo, \`**.jpg\` coincide
con \`photo.jpg\` en el directorio actual, pero no coincide con \`dir/photo.jpg\`.
Use \`**/*.jpg\` para ese propósito.
.PP
Las clases de caracteres que utilizan corchetes \`[]\` coinciden con un solo carácter de un
conjunto o rango especificado. Al igual que los otros patrones de un solo carácter,
@ -2070,8 +2071,8 @@ un signo de exclamación.
.PP
La distinción fundamental que debe recordar es que \`*\`, \`?\` y las clases de caracteres
respetan los límites de los directorios y solo coinciden dentro de un único
componente de ruta, mientras que \`**\` es el único patrón que puede coincidir a través de
los separadores de directorios.
componente de ruta, mientras que \`**\` solo puede coincidir a través de los separadores
de directorios cuando es adyacente a una barra diagonal.
.PP
Hay cuatro tipos diferentes de patrones:
.TP

27
doc/snapraid-es.d
View file

@ -1655,18 +1655,19 @@ Patrones (Pattern)
componente de ruta. Este es el comportamiento estándar de los comodines familiar
del globbing de la shell.
el doble asterisco `**` es más potente, coincide con cualquier secuencia de
caracteres, incluidos los separadores de directorios. Esto permite que los patrones coincidan
a través de múltiples niveles de directorio. Cuando `**` aparece incrustado directamente en
un patrón, puede coincidir con cero o más caracteres, incluidas las barras diagonales entre
el texto literal circundante.
El comodín de doble asterisco `**` coincide a través de los separadores de
directorios solo cuando es adyacente a un separador de directorios (precedido
o seguido por una barra diagonal). En esta forma, coincide con cero o más
caracteres a través de niveles de directorio. Por ejemplo, `foo/**/bar`
coincide con `foo/bar`, `foo/a/bar` y `foo/a/b/bar`; `**/build` coincide con
`build` y `foo/bar/build`; y `src/**.js` coincide con `src/main.js` y
`src/ui/components/main.js`.
La forma independiente `/**/` no se acepta como un patrón completo.
El uso más importante de `**` es en la forma especial `/**/`. Esta coincide con
cero o más niveles de directorio completos, lo que permite que los archivos coincidan
a cualquier profundidad en un árbol de directorios sin conocer la estructura exacta de la ruta.
Por ejemplo, el patrón `src/**/main.js` coincide con `src/main.js` (saltando
cero directorios), `src/ui/main.js` (saltando un directorio) y
`src/ui/components/main.js` (saltando dos directorios).
Cuando `**` no es adyacente a una barra diagonal, se comporta como `*` y no
coincide con los separadores de directorios. Por ejemplo, `**.jpg` coincide
con `photo.jpg` en el directorio actual, pero no coincide con `dir/photo.jpg`.
Use `**/*.jpg` para ese propósito.
Las clases de caracteres que utilizan corchetes `[]` coinciden con un solo carácter de un
conjunto o rango especificado. Al igual que los otros patrones de un solo carácter,
@ -1675,8 +1676,8 @@ Patrones (Pattern)
La distinción fundamental que debe recordar es que `*`, `?` y las clases de caracteres
respetan los límites de los directorios y solo coinciden dentro de un único
componente de ruta, mientras que `**` es el único patrón que puede coincidir a través de
los separadores de directorios.
componente de ruta, mientras que `**` solo puede coincidir a través de los separadores
de directorios cuando es adyacente a una barra diagonal.
Hay cuatro tipos diferentes de patrones:

27
doc/snapraid-es.txt
View file

@ -1768,18 +1768,19 @@ barra diagonal, lo que lo hace adecuado para buscar coincidencias dentro de un s
componente de ruta. Este es el comportamiento estándar de los comodines familiar
del globbing de la shell.
el doble asterisco `**` es más potente, coincide con cualquier secuencia de
caracteres, incluidos los separadores de directorios. Esto permite que los patrones coincidan
a través de múltiples niveles de directorio. Cuando `**` aparece incrustado directamente en
un patrón, puede coincidir con cero o más caracteres, incluidas las barras diagonales entre
el texto literal circundante.
El comodín de doble asterisco `**` coincide a través de los separadores de
directorios solo cuando es adyacente a un separador de directorios (precedido
o seguido por una barra diagonal). En esta forma, coincide con cero o más
caracteres a través de niveles de directorio. Por ejemplo, `foo/**/bar`
coincide con `foo/bar`, `foo/a/bar` y `foo/a/b/bar`; `**/build` coincide con
`build` y `foo/bar/build`; y `src/**.js` coincide con `src/main.js` y
`src/ui/components/main.js`.
La forma independiente `/**/` no se acepta como un patrón completo.
El uso más importante de `**` es en la forma especial `/**/`. Esta coincide con
cero o más niveles de directorio completos, lo que permite que los archivos coincidan
a cualquier profundidad en un árbol de directorios sin conocer la estructura exacta de la ruta.
Por ejemplo, el patrón `src/**/main.js` coincide con `src/main.js` (saltando
cero directorios), `src/ui/main.js` (saltando un directorio) y
`src/ui/components/main.js` (saltando dos directorios).
Cuando `**` no es adyacente a una barra diagonal, se comporta como `*` y no
coincide con los separadores de directorios. Por ejemplo, `**.jpg` coincide
con `photo.jpg` en el directorio actual, pero no coincide con `dir/photo.jpg`.
Use `**/*.jpg` para ese propósito.
Las clases de caracteres que utilizan corchetes `[]` coinciden con un solo carácter de un
conjunto o rango especificado. Al igual que los otros patrones de un solo carácter,
@ -1788,8 +1789,8 @@ un signo de exclamación.
La distinción fundamental que debe recordar es que `*`, `?` y las clases de caracteres
respetan los límites de los directorios y solo coinciden dentro de un único
componente de ruta, mientras que `**` es el único patrón que puede coincidir a través de
los separadores de directorios.
componente de ruta, mientras que `**` solo puede coincidir a través de los separadores
de directorios cuando es adyacente a una barra diagonal.
Hay cuatro tipos diferentes de patrones:

27
doc/snapraid-fr.1
View file

@ -2088,18 +2088,19 @@ barre oblique, ce qui la rend adaptée à la recherche de correspondances au sei
composant de chemin. Il s\'agit du comportement standard des jokers familier du
\[dq]globbing\[dq] shell.
.PP
La double étoile \`**\` est plus puissante, elle correspond à n\'importe quelle séquence de
caractères, y compris les séparateurs de répertoires. Cela permet aux motifs de correspondre
sur plusieurs niveaux de répertoires. Lorsque \`**\` apparaît directement intégré dans
un motif, il peut correspondre à zéro ou plusieurs caractères, y compris les barres obliques entre
le texte littéral environnant.
Le caractère générique double étoile \`**\` ne correspond à travers les
séparateurs de répertoires que lorsqu\'il est adjacent à un séparateur de
répertoires (précédé ou suivi d\'une barre oblique). Sous cette forme, il
correspond à zéro ou plusieurs caractères sur plusieurs niveaux de
répertoires. Par exemple, \`foo/**/bar\` correspond à \`foo/bar\`, \`foo/a/bar\`
et \`foo/a/b/bar\` ; \`**/build\` correspond à \`build\` et \`foo/bar/build\` ; et
\`src/**.js\` correspond à \`src/main.js\` et \`src/ui/components/main.js\`.
La forme autonome \`/**/\` n\'est pas acceptée comme un motif complet.
.PP
L\'utilisation la plus importante de \`**\` est sous la forme spéciale \`/**/\`. Celle\-ci correspond à
zéro ou plusieurs niveaux de répertoires complets, ce qui permet de faire correspondre des fichiers
à n\'importe quelle profondeur dans une arborescence de répertoires sans connaître la structure exacte du chemin.
Par exemple, le motif \`src/**/main.js\` correspond à \`src/main.js\` (saut de
zéro répertoire), \`src/ui/main.js\` (saut d\'un répertoire), et
\`src/ui/components/main.js\` (saut de deux répertoires).
Lorsque \`**\` n\'est pas adjacent à une barre oblique, il se comporte comme \`*\`
et ne correspond pas aux séparateurs de répertoires. Par exemple, \`**.jpg\`
correspond à \`photo.jpg\` dans le répertoire actuel, mais ne correspond pas à
\`dir/photo.jpg\`. Utilisez \`**/*.jpg\` à cette fin.
.PP
Les classes de caractères utilisant des crochets \`[]\` correspondent à un seul caractère d\'un
ensemble ou d\'une plage spécifiés. Comme les autres motifs à caractère unique, elles
@ -2108,8 +2109,8 @@ d\'un point d\'exclamation.
.PP
La distinction fondamentale à retenir est que \`*\`, \`?\` et les classes de caractères
respectent tous les limites des répertoires et ne correspondent qu\'au sein d\'un seul
composant de chemin, alors que \`**\` est le seul motif qui peut correspondre à travers
les séparateurs de répertoires.
composant de chemin, alors que \`**\` ne peut correspondre à travers les séparateurs
de répertoires que lorsqu\'il est adjacent à une barre oblique.
.PP
Il existe quatre types de motifs différents :
.TP

27
doc/snapraid-fr.d
View file

@ -1693,18 +1693,19 @@ Motif (Pattern)
composant de chemin. Il s'agit du comportement standard des jokers familier du
"globbing" shell.
La double étoile `**` est plus puissante, elle correspond à n'importe quelle séquence de
caractères, y compris les séparateurs de répertoires. Cela permet aux motifs de correspondre
sur plusieurs niveaux de répertoires. Lorsque `**` apparaît directement intégré dans
un motif, il peut correspondre à zéro ou plusieurs caractères, y compris les barres obliques entre
le texte littéral environnant.
Le caractère générique double étoile `**` ne correspond à travers les
séparateurs de répertoires que lorsqu'il est adjacent à un séparateur de
répertoires (précédé ou suivi d'une barre oblique). Sous cette forme, il
correspond à zéro ou plusieurs caractères sur plusieurs niveaux de
répertoires. Par exemple, `foo/**/bar` correspond à `foo/bar`, `foo/a/bar`
et `foo/a/b/bar` ; `**/build` correspond à `build` et `foo/bar/build` ; et
`src/**.js` correspond à `src/main.js` et `src/ui/components/main.js`.
La forme autonome `/**/` n'est pas acceptée comme un motif complet.
L'utilisation la plus importante de `**` est sous la forme spéciale `/**/`. Celle-ci correspond à
zéro ou plusieurs niveaux de répertoires complets, ce qui permet de faire correspondre des fichiers
à n'importe quelle profondeur dans une arborescence de répertoires sans connaître la structure exacte du chemin.
Par exemple, le motif `src/**/main.js` correspond à `src/main.js` (saut de
zéro répertoire), `src/ui/main.js` (saut d'un répertoire), et
`src/ui/components/main.js` (saut de deux répertoires).
Lorsque `**` n'est pas adjacent à une barre oblique, il se comporte comme `*`
et ne correspond pas aux séparateurs de répertoires. Par exemple, `**.jpg`
correspond à `photo.jpg` dans le répertoire actuel, mais ne correspond pas à
`dir/photo.jpg`. Utilisez `**/*.jpg` à cette fin.
Les classes de caractères utilisant des crochets `[]` correspondent à un seul caractère d'un
ensemble ou d'une plage spécifiés. Comme les autres motifs à caractère unique, elles
@ -1713,8 +1714,8 @@ Motif (Pattern)
La distinction fondamentale à retenir est que `*`, `?` et les classes de caractères
respectent tous les limites des répertoires et ne correspondent qu'au sein d'un seul
composant de chemin, alors que `**` est le seul motif qui peut correspondre à travers
les séparateurs de répertoires.
composant de chemin, alors que `**` ne peut correspondre à travers les séparateurs
de répertoires que lorsqu'il est adjacent à une barre oblique.
Il existe quatre types de motifs différents :

27
doc/snapraid-fr.txt
View file

@ -1806,18 +1806,19 @@ barre oblique, ce qui la rend adaptée à la recherche de correspondances au sei
composant de chemin. Il s'agit du comportement standard des jokers familier du
"globbing" shell.
La double étoile `**` est plus puissante, elle correspond à n'importe quelle séquence de
caractères, y compris les séparateurs de répertoires. Cela permet aux motifs de correspondre
sur plusieurs niveaux de répertoires. Lorsque `**` apparaît directement intégré dans
un motif, il peut correspondre à zéro ou plusieurs caractères, y compris les barres obliques entre
le texte littéral environnant.
Le caractère générique double étoile `**` ne correspond à travers les
séparateurs de répertoires que lorsqu'il est adjacent à un séparateur de
répertoires (précédé ou suivi d'une barre oblique). Sous cette forme, il
correspond à zéro ou plusieurs caractères sur plusieurs niveaux de
répertoires. Par exemple, `foo/**/bar` correspond à `foo/bar`, `foo/a/bar`
et `foo/a/b/bar` ; `**/build` correspond à `build` et `foo/bar/build` ; et
`src/**.js` correspond à `src/main.js` et `src/ui/components/main.js`.
La forme autonome `/**/` n'est pas acceptée comme un motif complet.
L'utilisation la plus importante de `**` est sous la forme spéciale `/**/`. Celle-ci correspond à
zéro ou plusieurs niveaux de répertoires complets, ce qui permet de faire correspondre des fichiers
à n'importe quelle profondeur dans une arborescence de répertoires sans connaître la structure exacte du chemin.
Par exemple, le motif `src/**/main.js` correspond à `src/main.js` (saut de
zéro répertoire), `src/ui/main.js` (saut d'un répertoire), et
`src/ui/components/main.js` (saut de deux répertoires).
Lorsque `**` n'est pas adjacent à une barre oblique, il se comporte comme `*`
et ne correspond pas aux séparateurs de répertoires. Par exemple, `**.jpg`
correspond à `photo.jpg` dans le répertoire actuel, mais ne correspond pas à
`dir/photo.jpg`. Utilisez `**/*.jpg` à cette fin.
Les classes de caractères utilisant des crochets `[]` correspondent à un seul caractère d'un
ensemble ou d'une plage spécifiés. Comme les autres motifs à caractère unique, elles
@ -1826,8 +1827,8 @@ d'un point d'exclamation.
La distinction fondamentale à retenir est que `*`, `?` et les classes de caractères
respectent tous les limites des répertoires et ne correspondent qu'au sein d'un seul
composant de chemin, alors que `**` est le seul motif qui peut correspondre à travers
les séparateurs de répertoires.
composant de chemin, alors que `**` ne peut correspondre à travers les séparateurs
de répertoires que lorsqu'il est adjacent à une barre oblique.
Il existe quatre types de motifs différents :

27
doc/snapraid-it.1
View file

@ -2072,18 +2072,19 @@ slash in avanti, rendendolo adatto per la corrispondenza all\'interno di un sing
componente del percorso. Questo è il comportamento standard dei wildcard familiare
dal globbing della shell.
.PP
Il doppio asterisco \`**\` è più potente, corrisponde a qualsiasi sequenza di
caratteri inclusi i separatori di directory. Ciò consente ai pattern di corrispondere
attraverso più livelli di directory. Quando \`**\` appare inserito direttamente in
un pattern, può corrispondere a zero o più caratteri inclusi gli slash tra
il testo letterale circostante.
Il carattere jolly doppio asterisco \`**\` corrisponde attraverso i separatori
di directory solo quando è adiacente a un separatore di directory (preceduto
o seguito da uno slash). In questa forma, corrisponde a zero o più caratteri
attraverso i livelli di directory. Per esempio, \`foo/**/bar\` corrisponde a
\`foo/bar\`, \`foo/a/bar\` e \`foo/a/b/bar\`; \`**/build\` corrisponde a \`build\` e
\`foo/bar/build\`; e \`src/**.js\` corrisponde a \`src/main.js\` e
\`src/ui/components/main.js\`.
La forma autonoma \`/**/\` non è accettata come pattern completo.
.PP
L\'uso più importante di \`**\` è nella forma speciale \`/**/\`. Questa corrisponde a
zero o più livelli di directory completi, rendendo possibile la corrispondenza di file
a qualsiasi profondità in un albero di directory senza conoscere l\'esatta struttura del percorso.
Per esempio, il pattern \`src/**/main.js\` corrisponde a \`src/main.js\` (saltando
zero directory), \`src/ui/main.js\` (saltando una directory), e
\`src/ui/components/main.js\` (saltando due directory).
Quando \`**\` non è adiacente a uno slash, si comporta come \`*\` e non
corrisponde ai separatori di directory. Per esempio, \`**.jpg\` corrisponde a
\`photo.jpg\` nella directory corrente, ma non corrisponde a \`dir/photo.jpg\`.
Usa \`**/*.jpg\` per questo scopo.
.PP
Le classi di caratteri che usano le parentesi quadre \`[]\` corrispondono a un singolo carattere da un
set o intervallo specificato. Come gli altri pattern a carattere singolo, esse
@ -2092,8 +2093,8 @@ un punto esclamativo.
.PP
La distinzione fondamentale da ricordare è che \`*\`, \`?\` e le classi di caratteri
rispettano tutti i confini delle directory e corrispondono solo all\'interno di un singolo
componente del percorso, mentre \`**\` è l\'unico pattern che può corrispondere attraverso
i separatori di directory.
componente del percorso, mentre \`**\` può corrispondere attraverso i separatori di directory
solo quando è adiacente a uno slash.
.PP
Esistono quattro diversi tipi di pattern:
.TP

27
doc/snapraid-it.d
View file

@ -1666,18 +1666,19 @@ Pattern
componente del percorso. Questo è il comportamento standard dei wildcard familiare
dal globbing della shell.
Il doppio asterisco `**` è più potente, corrisponde a qualsiasi sequenza di
caratteri inclusi i separatori di directory. Ciò consente ai pattern di corrispondere
attraverso più livelli di directory. Quando `**` appare inserito direttamente in
un pattern, può corrispondere a zero o più caratteri inclusi gli slash tra
il testo letterale circostante.
Il carattere jolly doppio asterisco `**` corrisponde attraverso i separatori
di directory solo quando è adiacente a un separatore di directory (preceduto
o seguito da uno slash). In questa forma, corrisponde a zero o più caratteri
attraverso i livelli di directory. Per esempio, `foo/**/bar` corrisponde a
`foo/bar`, `foo/a/bar` e `foo/a/b/bar`; `**/build` corrisponde a `build` e
`foo/bar/build`; e `src/**.js` corrisponde a `src/main.js` e
`src/ui/components/main.js`.
La forma autonoma `/**/` non è accettata come pattern completo.
L'uso più importante di `**` è nella forma speciale `/**/`. Questa corrisponde a
zero o più livelli di directory completi, rendendo possibile la corrispondenza di file
a qualsiasi profondità in un albero di directory senza conoscere l'esatta struttura del percorso.
Per esempio, il pattern `src/**/main.js` corrisponde a `src/main.js` (saltando
zero directory), `src/ui/main.js` (saltando una directory), e
`src/ui/components/main.js` (saltando due directory).
Quando `**` non è adiacente a uno slash, si comporta come `*` e non
corrisponde ai separatori di directory. Per esempio, `**.jpg` corrisponde a
`photo.jpg` nella directory corrente, ma non corrisponde a `dir/photo.jpg`.
Usa `**/*.jpg` per questo scopo.
Le classi di caratteri che usano le parentesi quadre `[]` corrispondono a un singolo carattere da un
set o intervallo specificato. Come gli altri pattern a carattere singolo, esse
@ -1686,8 +1687,8 @@ Pattern
La distinzione fondamentale da ricordare è che `*`, `?` e le classi di caratteri
rispettano tutti i confini delle directory e corrispondono solo all'interno di un singolo
componente del percorso, mentre `**` è l'unico pattern che può corrispondere attraverso
i separatori di directory.
componente del percorso, mentre `**` può corrispondere attraverso i separatori di directory
solo quando è adiacente a uno slash.
Esistono quattro diversi tipi di pattern:

27
doc/snapraid-it.txt
View file

@ -1779,18 +1779,19 @@ slash in avanti, rendendolo adatto per la corrispondenza all'interno di un singo
componente del percorso. Questo è il comportamento standard dei wildcard familiare
dal globbing della shell.
Il doppio asterisco `**` è più potente, corrisponde a qualsiasi sequenza di
caratteri inclusi i separatori di directory. Ciò consente ai pattern di corrispondere
attraverso più livelli di directory. Quando `**` appare inserito direttamente in
un pattern, può corrispondere a zero o più caratteri inclusi gli slash tra
il testo letterale circostante.
Il carattere jolly doppio asterisco `**` corrisponde attraverso i separatori
di directory solo quando è adiacente a un separatore di directory (preceduto
o seguito da uno slash). In questa forma, corrisponde a zero o più caratteri
attraverso i livelli di directory. Per esempio, `foo/**/bar` corrisponde a
`foo/bar`, `foo/a/bar` e `foo/a/b/bar`; `**/build` corrisponde a `build` e
`foo/bar/build`; e `src/**.js` corrisponde a `src/main.js` e
`src/ui/components/main.js`.
La forma autonoma `/**/` non è accettata come pattern completo.
L'uso più importante di `**` è nella forma speciale `/**/`. Questa corrisponde a
zero o più livelli di directory completi, rendendo possibile la corrispondenza di file
a qualsiasi profondità in un albero di directory senza conoscere l'esatta struttura del percorso.
Per esempio, il pattern `src/**/main.js` corrisponde a `src/main.js` (saltando
zero directory), `src/ui/main.js` (saltando una directory), e
`src/ui/components/main.js` (saltando due directory).
Quando `**` non è adiacente a uno slash, si comporta come `*` e non
corrisponde ai separatori di directory. Per esempio, `**.jpg` corrisponde a
`photo.jpg` nella directory corrente, ma non corrisponde a `dir/photo.jpg`.
Usa `**/*.jpg` per questo scopo.
Le classi di caratteri che usano le parentesi quadre `[]` corrispondono a un singolo carattere da un
set o intervallo specificato. Come gli altri pattern a carattere singolo, esse
@ -1799,8 +1800,8 @@ un punto esclamativo.
La distinzione fondamentale da ricordare è che `*`, `?` e le classi di caratteri
rispettano tutti i confini delle directory e corrispondono solo all'interno di un singolo
componente del percorso, mentre `**` è l'unico pattern che può corrispondere attraverso
i separatori di directory.
componente del percorso, mentre `**` può corrispondere attraverso i separatori di directory
solo quando è adiacente a uno slash.
Esistono quattro diversi tipi di pattern:

24
doc/snapraid-ja.1
View file

@ -1848,17 +1848,18 @@ ZFSでは標準の \`.zfs/snapshot/\` が使用されます。
単一のパスコンポーネント内での一致に適しています。これは、シェルの
グロブでおなじみの標準的なワイルドカードの動作です。
.PP
ダブルアスタリスク \`**\` はより強力で、ディレクトリ区切り文字を含む
任意の文字列に一致します。これにより、パターンが複数のディレクトリレベルを
またいで一致できるようになります。\`**\` がパターン内に直接埋め込まれている場合、
周囲のリテラルテキストの間にあるスラッシュを含む0文字以上の文字に一致します。
ダブルアスタリスクのワイルドカード \`**\` は、ディレクトリ区切り文字に隣接
している場合（スラッシュの前または後にある場合）にのみ、ディレクトリ区切り
文字をまたいで一致します。この形式では、複数のディレクトリレベルにわたって
0個以上の文字に一致します。例えば、\`foo/**/bar\` は \`foo/bar\`、\`foo/a/bar\`、
および \`foo/a/b/bar\` に一致し、\`**/build\` は \`build\` および \`foo/bar/build\` に
一致し、\`src/**.js\` は \`src/main.js\` および \`src/ui/components/main.js\` に一致します。
単独の形式 \`/**/\` は完全なパターンとして受け入れられません。
.PP
\`**\` の最も重要な使い方は、特別な形式である \`/**/\` です。これは
0個以上の完全なディレクトリレベルに一致し、正確なパス構造を知らなくても、
ディレクトリツリー内の任意の深さにあるファイルと一致させることができます。
例えば、パターン \`src/**/main.js\` は \`src/main.js\`（ディレクトリを0個スキップ）、
\`src/ui/main.js\`（1個スキップ）、\`src/ui/components/main.js\`（2個スキップ）
に一致します。
\`**\` がスラッシュに隣接していない場合、\`*\` と同様に動作し、ディレクトリ区切り
文字には一致しません。例えば、\`**.jpg\` はカレントディレクトリ内の \`photo.jpg\` に
一致しますが、\`dir/photo.jpg\` には一致しません。その目的には \`**/*.jpg\` を
使用してください。
.PP
角括弧 \`[]\` を使用した文字クラスは、指定されたセットまたは範囲の
任意の1文字に一致します。他の単一文字パターンと同様に、
@ -1867,7 +1868,8 @@ ZFSでは標準の \`.zfs/snapshot/\` が使用されます。
.PP
覚えておくべき根本的な違いは、\`*\`、\`?\`、および文字クラスはすべて
ディレクトリの境界を尊重し、単一のパスコンポーネント内でのみ一致するのに対し、
\`**\` はディレクトリ区切り文字をまたいで一致できる唯一のパターンであるということです。
\`**\` はスラッシュに隣接している場合にのみディレクトリ区切り文字を
またいで一致できるということです。
.PP
4つの異なる種類のパターンがあります。
.TP

24
doc/snapraid-ja.d
View file

@ -1453,17 +1453,18 @@ Name{number}
単一のパスコンポーネント内での一致に適しています。これは、シェルの
グロブでおなじみの標準的なワイルドカードの動作です。
ダブルアスタリスク `**` はより強力で、ディレクトリ区切り文字を含む
任意の文字列に一致します。これにより、パターンが複数のディレクトリレベルを
またいで一致できるようになります。`**` がパターン内に直接埋め込まれている場合、
周囲のリテラルテキストの間にあるスラッシュを含む0文字以上の文字に一致します。
ダブルアスタリスクのワイルドカード `**` は、ディレクトリ区切り文字に隣接
している場合（スラッシュの前または後にある場合）にのみ、ディレクトリ区切り
文字をまたいで一致します。この形式では、複数のディレクトリレベルにわたって
0個以上の文字に一致します。例えば、`foo/**/bar` は `foo/bar`、`foo/a/bar`、
および `foo/a/b/bar` に一致し、`**/build` は `build` および `foo/bar/build` に
一致し、`src/**.js` は `src/main.js` および `src/ui/components/main.js` に一致します。
単独の形式 `/**/` は完全なパターンとして受け入れられません。
`**` の最も重要な使い方は、特別な形式である `/**/` です。これは
0個以上の完全なディレクトリレベルに一致し、正確なパス構造を知らなくても、
ディレクトリツリー内の任意の深さにあるファイルと一致させることができます。
例えば、パターン `src/**/main.js` は `src/main.js`（ディレクトリを0個スキップ）、
`src/ui/main.js`（1個スキップ）、`src/ui/components/main.js`（2個スキップ）
に一致します。
`**` がスラッシュに隣接していない場合、`*` と同様に動作し、ディレクトリ区切り
文字には一致しません。例えば、`**.jpg` はカレントディレクトリ内の `photo.jpg` に
一致しますが、`dir/photo.jpg` には一致しません。その目的には `**/*.jpg` を
使用してください。
角括弧 `[]` を使用した文字クラスは、指定されたセットまたは範囲の
任意の1文字に一致します。他の単一文字パターンと同様に、
@ -1472,7 +1473,8 @@ Name{number}
覚えておくべき根本的な違いは、`*`、`?`、および文字クラスはすべて
ディレクトリの境界を尊重し、単一のパスコンポーネント内でのみ一致するのに対し、
`**` はディレクトリ区切り文字をまたいで一致できる唯一のパターンであるということです。
`**` はスラッシュに隣接している場合にのみディレクトリ区切り文字を
またいで一致できるということです。
4つの異なる種類のパターンがあります。

24
doc/snapraid-ja.txt
View file

@ -1566,17 +1566,18 @@ ZFSでは標準の `.zfs/snapshot/` が使用されます。
単一のパスコンポーネント内での一致に適しています。これは、シェルの
グロブでおなじみの標準的なワイルドカードの動作です。
ダブルアスタリスク `**` はより強力で、ディレクトリ区切り文字を含む
任意の文字列に一致します。これにより、パターンが複数のディレクトリレベルを
またいで一致できるようになります。`**` がパターン内に直接埋め込まれている場合、
周囲のリテラルテキストの間にあるスラッシュを含む0文字以上の文字に一致します。
ダブルアスタリスクのワイルドカード `**` は、ディレクトリ区切り文字に隣接
している場合（スラッシュの前または後にある場合）にのみ、ディレクトリ区切り
文字をまたいで一致します。この形式では、複数のディレクトリレベルにわたって
0個以上の文字に一致します。例えば、`foo/**/bar` は `foo/bar`、`foo/a/bar`、
および `foo/a/b/bar` に一致し、`**/build` は `build` および `foo/bar/build` に
一致し、`src/**.js` は `src/main.js` および `src/ui/components/main.js` に一致します。
単独の形式 `/**/` は完全なパターンとして受け入れられません。
`**` の最も重要な使い方は、特別な形式である `/**/` です。これは
0個以上の完全なディレクトリレベルに一致し、正確なパス構造を知らなくても、
ディレクトリツリー内の任意の深さにあるファイルと一致させることができます。
例えば、パターン `src/**/main.js` は `src/main.js`（ディレクトリを0個スキップ）、
`src/ui/main.js`（1個スキップ）、`src/ui/components/main.js`（2個スキップ）
に一致します。
`**` がスラッシュに隣接していない場合、`*` と同様に動作し、ディレクトリ区切り
文字には一致しません。例えば、`**.jpg` はカレントディレクトリ内の `photo.jpg` に
一致しますが、`dir/photo.jpg` には一致しません。その目的には `**/*.jpg` を
使用してください。
角括弧 `[]` を使用した文字クラスは、指定されたセットまたは範囲の
任意の1文字に一致します。他の単一文字パターンと同様に、
@ -1585,7 +1586,8 @@ ZFSでは標準の `.zfs/snapshot/` が使用されます。
覚えておくべき根本的な違いは、`*`、`?`、および文字クラスはすべて
ディレクトリの境界を尊重し、単一のパスコンポーネント内でのみ一致するのに対し、
`**` はディレクトリ区切り文字をまたいで一致できる唯一のパターンであるということです。
`**` はスラッシュに隣接している場合にのみディレクトリ区切り文字を
またいで一致できるということです。
4つの異なる種類のパターンがあります。

24
doc/snapraid-ko.1
View file

@ -1893,17 +1893,18 @@ ZFS에서는 표준 \`.zfs/snapshot/\` 이 사용됩니다.
내에서의 일치에 적합합니다. 이는 쉘 글로빙에서 익숙한 표준 와일드카드
동작입니다.
.PP
이중 별표 \`**\`는 더 강력하며 디렉토리 구분 기호를 포함한 모든 문자
시퀀스와 일치합니다. 이를 통해 패턴이 여러 디렉토리 수준에서 일치할 수
있습니다. \`**\`가 패턴 내에 직접 포함된 경우, 주변 리터럴 텍스트 사이의
슬래시를 포함하여 0개 이상의 문자와 일치할 수 있습니다.
이중 별표 와일드카드 \`**\`는 디렉토리 구분 기호에 인접해 있는 경우(슬래시
앞이나 뒤에 오는 경우)에만 디렉토리 구분 기호를 가로질러 일치합니다.
이 형식에서는 여러 디렉토리 수준에 걸쳐 0개 이상의 문자와 일치합니다.
예를 들어, \`foo/**/bar\`는 \`foo/bar\`, \`foo/a/bar\` 및 \`foo/a/b/bar\`와 일치하고,
\`**/build\`는 \`build\` 및 \`foo/bar/build\`와 일치하며, \`src/**.js\`는 \`src/main.js\` 및
\`src/ui/components/main.js\`와 일치합니다.
독립형 형식인 \`/**/\`는 완전한 패턴으로 허용되지 않습니다.
.PP
\`**\`의 가장 중요한 용도는 특수 형식인 \`/**/\`입니다. 이는 0개 이상의
전체 디렉토리 수준과 일치하므로 정확한 경로 구조를 모르더라도
디렉토리 트리의 모든 깊이에서 파일과 일치시킬 수 있습니다.
예를 들어, \`src/**/main.js\` 패턴은 \`src/main.js\`(0개의 디렉토리 건너뜀),
\`src/ui/main.js\`(1개의 디렉토리 건너뜀), \`src/ui/components/main.js\`
(2개의 디렉토리 건너뜀)와 일치합니다.
\`**\`가 슬래시에 인접하지 않은 경우 \`*\`처럼 작동하며 디렉토리 구분 기호와
일치하지 않습니다. 예를 들어, \`**.jpg\`는 현재 디렉토리의 \`photo.jpg\`와는
일치하지만 \`dir/photo.jpg\`와는 일치하지 않습니다. 해당 용도로는 \`**/*.jpg\`를
사용하십시오.
.PP
대괄호 \`[]\`를 사용하는 문자 클래스는 지정된 세트 또는 범위에서
단일 문자와 일치합니다. 다른 단일 문자 패턴과 마찬가지로 디렉토리
@ -1912,7 +1913,8 @@ ZFS에서는 표준 \`.zfs/snapshot/\` 이 사용됩니다.
.PP
기억해야 할 근본적인 차이점은 \`*\`, \`?\` 및 문자 클래스는 모두
디렉토리 경계를 준수하고 단일 경로 구성 요소 내에서만 일치하는 반면,
\`**\`는 디렉토리 구분 기호를 가로질러 일치할 수 있는 유일한 패턴이라는 것입니다.
\`**\`는 슬래시에 인접해 있는 경우에만 디렉토리 구분 기호를 가로질러
일치할 수 있다는 것입니다.
.PP
네 가지 유형의 패턴이 있습니다:
.TP

24
doc/snapraid-ko.d
View file

@ -1498,17 +1498,18 @@ Name{number}
내에서의 일치에 적합합니다. 이는 쉘 글로빙에서 익숙한 표준 와일드카드
동작입니다.
이중 별표 `**`는 더 강력하며 디렉토리 구분 기호를 포함한 모든 문자
시퀀스와 일치합니다. 이를 통해 패턴이 여러 디렉토리 수준에서 일치할 수
있습니다. `**`가 패턴 내에 직접 포함된 경우, 주변 리터럴 텍스트 사이의
슬래시를 포함하여 0개 이상의 문자와 일치할 수 있습니다.
이중 별표 와일드카드 `**`는 디렉토리 구분 기호에 인접해 있는 경우(슬래시
앞이나 뒤에 오는 경우)에만 디렉토리 구분 기호를 가로질러 일치합니다.
이 형식에서는 여러 디렉토리 수준에 걸쳐 0개 이상의 문자와 일치합니다.
예를 들어, `foo/**/bar`는 `foo/bar`, `foo/a/bar` 및 `foo/a/b/bar`와 일치하고,
`**/build`는 `build` 및 `foo/bar/build`와 일치하며, `src/**.js`는 `src/main.js` 및
`src/ui/components/main.js`와 일치합니다.
독립형 형식인 `/**/`는 완전한 패턴으로 허용되지 않습니다.
`**`의 가장 중요한 용도는 특수 형식인 `/**/`입니다. 이는 0개 이상의
전체 디렉토리 수준과 일치하므로 정확한 경로 구조를 모르더라도
디렉토리 트리의 모든 깊이에서 파일과 일치시킬 수 있습니다.
예를 들어, `src/**/main.js` 패턴은 `src/main.js`(0개의 디렉토리 건너뜀),
`src/ui/main.js`(1개의 디렉토리 건너뜀), `src/ui/components/main.js`
(2개의 디렉토리 건너뜀)와 일치합니다.
`**`가 슬래시에 인접하지 않은 경우 `*`처럼 작동하며 디렉토리 구분 기호와
일치하지 않습니다. 예를 들어, `**.jpg`는 현재 디렉토리의 `photo.jpg`와는
일치하지만 `dir/photo.jpg`와는 일치하지 않습니다. 해당 용도로는 `**/*.jpg`를
사용하십시오.
대괄호 `[]`를 사용하는 문자 클래스는 지정된 세트 또는 범위에서
단일 문자와 일치합니다. 다른 단일 문자 패턴과 마찬가지로 디렉토리
@ -1517,7 +1518,8 @@ Name{number}
기억해야 할 근본적인 차이점은 `*`, `?` 및 문자 클래스는 모두
디렉토리 경계를 준수하고 단일 경로 구성 요소 내에서만 일치하는 반면,
`**`는 디렉토리 구분 기호를 가로질러 일치할 수 있는 유일한 패턴이라는 것입니다.
`**`는 슬래시에 인접해 있는 경우에만 디렉토리 구분 기호를 가로질러
일치할 수 있다는 것입니다.
네 가지 유형의 패턴이 있습니다:

24
doc/snapraid-ko.txt
View file

@ -1611,17 +1611,18 @@ ZFS에서는 표준 `.zfs/snapshot/` 이 사용됩니다.
내에서의 일치에 적합합니다. 이는 쉘 글로빙에서 익숙한 표준 와일드카드
동작입니다.
이중 별표 `**`는 더 강력하며 디렉토리 구분 기호를 포함한 모든 문자
시퀀스와 일치합니다. 이를 통해 패턴이 여러 디렉토리 수준에서 일치할 수
있습니다. `**`가 패턴 내에 직접 포함된 경우, 주변 리터럴 텍스트 사이의
슬래시를 포함하여 0개 이상의 문자와 일치할 수 있습니다.
이중 별표 와일드카드 `**`는 디렉토리 구분 기호에 인접해 있는 경우(슬래시
앞이나 뒤에 오는 경우)에만 디렉토리 구분 기호를 가로질러 일치합니다.
이 형식에서는 여러 디렉토리 수준에 걸쳐 0개 이상의 문자와 일치합니다.
예를 들어, `foo/**/bar`는 `foo/bar`, `foo/a/bar` 및 `foo/a/b/bar`와 일치하고,
`**/build`는 `build` 및 `foo/bar/build`와 일치하며, `src/**.js`는 `src/main.js` 및
`src/ui/components/main.js`와 일치합니다.
독립형 형식인 `/**/`는 완전한 패턴으로 허용되지 않습니다.
`**`의 가장 중요한 용도는 특수 형식인 `/**/`입니다. 이는 0개 이상의
전체 디렉토리 수준과 일치하므로 정확한 경로 구조를 모르더라도
디렉토리 트리의 모든 깊이에서 파일과 일치시킬 수 있습니다.
예를 들어, `src/**/main.js` 패턴은 `src/main.js`(0개의 디렉토리 건너뜀),
`src/ui/main.js`(1개의 디렉토리 건너뜀), `src/ui/components/main.js`
(2개의 디렉토리 건너뜀)와 일치합니다.
`**`가 슬래시에 인접하지 않은 경우 `*`처럼 작동하며 디렉토리 구분 기호와
일치하지 않습니다. 예를 들어, `**.jpg`는 현재 디렉토리의 `photo.jpg`와는
일치하지만 `dir/photo.jpg`와는 일치하지 않습니다. 해당 용도로는 `**/*.jpg`를
사용하십시오.
대괄호 `[]`를 사용하는 문자 클래스는 지정된 세트 또는 범위에서
단일 문자와 일치합니다. 다른 단일 문자 패턴과 마찬가지로 디렉토리
@ -1630,7 +1631,8 @@ ZFS에서는 표준 `.zfs/snapshot/` 이 사용됩니다.
기억해야 할 근본적인 차이점은 `*`, `?` 및 문자 클래스는 모두
디렉토리 경계를 준수하고 단일 경로 구성 요소 내에서만 일치하는 반면,
`**`는 디렉토리 구분 기호를 가로질러 일치할 수 있는 유일한 패턴이라는 것입니다.
`**`는 슬래시에 인접해 있는 경우에만 디렉토리 구분 기호를 가로질러
일치할 수 있다는 것입니다.
네 가지 유형의 패턴이 있습니다:

26
doc/snapraid-pl.1
View file

@ -1970,18 +1970,18 @@ ukośniku, co czyni ją odpowiednią do dopasowywania w obrębie jednego
składnika ścieżki. Jest to standardowe zachowanie symboli wieloznacznych znane
z globbingu powłoki (shell).
.PP
Podwójna gwiazdka \`**\` jest potężniejsza, dopasowuje dowolną sekwencję
znaków, w tym separatory katalogów. Pozwala to wzorcom dopasowywać się
na wielu poziomach katalogów. Gdy \`**\` pojawia się bezpośrednio wewnątrz
wzorca, może dopasować zero lub więcej znaków, w tym ukośniki między
otaczającym tekstem dosłownym.
Symbol wieloznaczny podwójnej gwiazdki \`**\` dopasowuje się poprzez separatory
katalogów tylko wtedy, gdy sąsiaduje z separatorem katalogów (jest poprzedzony
lub zakończony ukośnikiem). W tej formie dopasowuje zero lub więcej znaków
na wielu poziomach katalogów. Na przykład \`foo/**/bar\` dopasowuje \`foo/bar\`,
\`foo/a/bar\` oraz \`foo/a/b/bar\`; \`**/build\` dopasowuje \`build\` oraz
\`foo/bar/build\`; a \`src/**.js\` dopasowuje \`src/main.js\` oraz
\`src/ui/components/main.js\`.
Samodzielna forma \`/**/\` nie jest akceptowana jako kompletny wzorzec.
.PP
Najważniejszym zastosowaniem \`**\` jest specjalna forma \`/**/\`. Dopasowuje ona
zero lub więcej pełnych poziomów katalogów, umożliwiając dopasowanie plików
na dowolnej głębokości w drzewie katalogów bez znajomości dokładnej struktury ścieżki.
Na przykład wzorzec \`src/**/main.js\` pasuje do \`src/main.js\` (pomijając
zero katalogów), \`src/ui/main.js\` (pomijając jeden katalog) oraz
\`src/ui/components/main.js\` (pomijając dwa katalogi).
Gdy \`**\` nie sąsiaduje z ukośnikiem, zachowuje się jak \`*\` i nie dopasowuje
separatorów katalogów. Na przykład \`**.jpg\` dopasowuje \`photo.jpg\` w bieżącym
katalogu, ale nie pasuje do \`dir/photo.jpg\`. W tym celu należy użyć \`**/*.jpg\`.
.PP
Klasy znaków używające nawiasów kwadratowych \`[]\` dopasowują pojedynczy znak z
określonego zestawu lub zakresu. Podobnie jak inne wzorce pojedynczych znaków,
@ -1990,8 +1990,8 @@ wykrzyknika.
.PP
Podstawową różnicą, o której należy pamiętać, jest to, że \`*\`, \`?\` i klasy znaków
wszystkie respektują granice katalogów i dopasowują się tylko w obrębie jednego
składnika ścieżki, podczas gdy \`**\` jest jedynym wzorcem, który może dopasowywać się poprzez
separatory katalogów.
składnika ścieżki, podczas gdy \`**\` może dopasowywać się poprzez separatory
katalogów tylko wtedy, gdy sąsiaduje z ukośnikiem.
.PP
Istnieją cztery różne typy wzorców:
.TP

26
doc/snapraid-pl.d
View file

@ -1575,18 +1575,18 @@ Wzorce (Pattern)
składnika ścieżki. Jest to standardowe zachowanie symboli wieloznacznych znane
z globbingu powłoki (shell).
Podwójna gwiazdka `**` jest potężniejsza, dopasowuje dowolną sekwencję
znaków, w tym separatory katalogów. Pozwala to wzorcom dopasowywać się
na wielu poziomach katalogów. Gdy `**` pojawia się bezpośrednio wewnątrz
wzorca, może dopasować zero lub więcej znaków, w tym ukośniki między
otaczającym tekstem dosłownym.
Symbol wieloznaczny podwójnej gwiazdki `**` dopasowuje się poprzez separatory
katalogów tylko wtedy, gdy sąsiaduje z separatorem katalogów (jest poprzedzony
lub zakończony ukośnikiem). W tej formie dopasowuje zero lub więcej znaków
na wielu poziomach katalogów. Na przykład `foo/**/bar` dopasowuje `foo/bar`,
`foo/a/bar` oraz `foo/a/b/bar`; `**/build` dopasowuje `build` oraz
`foo/bar/build`; a `src/**.js` dopasowuje `src/main.js` oraz
`src/ui/components/main.js`.
Samodzielna forma `/**/` nie jest akceptowana jako kompletny wzorzec.
Najważniejszym zastosowaniem `**` jest specjalna forma `/**/`. Dopasowuje ona
zero lub więcej pełnych poziomów katalogów, umożliwiając dopasowanie plików
na dowolnej głębokości w drzewie katalogów bez znajomości dokładnej struktury ścieżki.
Na przykład wzorzec `src/**/main.js` pasuje do `src/main.js` (pomijając
zero katalogów), `src/ui/main.js` (pomijając jeden katalog) oraz
`src/ui/components/main.js` (pomijając dwa katalogi).
Gdy `**` nie sąsiaduje z ukośnikiem, zachowuje się jak `*` i nie dopasowuje
separatorów katalogów. Na przykład `**.jpg` dopasowuje `photo.jpg` w bieżącym
katalogu, ale nie pasuje do `dir/photo.jpg`. W tym celu należy użyć `**/*.jpg`.
Klasy znaków używające nawiasów kwadratowych `[]` dopasowują pojedynczy znak z
określonego zestawu lub zakresu. Podobnie jak inne wzorce pojedynczych znaków,
@ -1595,8 +1595,8 @@ Wzorce (Pattern)
Podstawową różnicą, o której należy pamiętać, jest to, że `*`, `?` i klasy znaków
wszystkie respektują granice katalogów i dopasowują się tylko w obrębie jednego
składnika ścieżki, podczas gdy `**` jest jedynym wzorcem, który może dopasowywać się poprzez
separatory katalogów.
składnika ścieżki, podczas gdy `**` może dopasowywać się poprzez separatory
katalogów tylko wtedy, gdy sąsiaduje z ukośnikiem.
Istnieją cztery różne typy wzorców:

26
doc/snapraid-pl.txt
View file

@ -1688,18 +1688,18 @@ ukośniku, co czyni ją odpowiednią do dopasowywania w obrębie jednego
składnika ścieżki. Jest to standardowe zachowanie symboli wieloznacznych znane
z globbingu powłoki (shell).
Podwójna gwiazdka `**` jest potężniejsza, dopasowuje dowolną sekwencję
znaków, w tym separatory katalogów. Pozwala to wzorcom dopasowywać się
na wielu poziomach katalogów. Gdy `**` pojawia się bezpośrednio wewnątrz
wzorca, może dopasować zero lub więcej znaków, w tym ukośniki między
otaczającym tekstem dosłownym.
Symbol wieloznaczny podwójnej gwiazdki `**` dopasowuje się poprzez separatory
katalogów tylko wtedy, gdy sąsiaduje z separatorem katalogów (jest poprzedzony
lub zakończony ukośnikiem). W tej formie dopasowuje zero lub więcej znaków
na wielu poziomach katalogów. Na przykład `foo/**/bar` dopasowuje `foo/bar`,
`foo/a/bar` oraz `foo/a/b/bar`; `**/build` dopasowuje `build` oraz
`foo/bar/build`; a `src/**.js` dopasowuje `src/main.js` oraz
`src/ui/components/main.js`.
Samodzielna forma `/**/` nie jest akceptowana jako kompletny wzorzec.
Najważniejszym zastosowaniem `**` jest specjalna forma `/**/`. Dopasowuje ona
zero lub więcej pełnych poziomów katalogów, umożliwiając dopasowanie plików
na dowolnej głębokości w drzewie katalogów bez znajomości dokładnej struktury ścieżki.
Na przykład wzorzec `src/**/main.js` pasuje do `src/main.js` (pomijając
zero katalogów), `src/ui/main.js` (pomijając jeden katalog) oraz
`src/ui/components/main.js` (pomijając dwa katalogi).
Gdy `**` nie sąsiaduje z ukośnikiem, zachowuje się jak `*` i nie dopasowuje
separatorów katalogów. Na przykład `**.jpg` dopasowuje `photo.jpg` w bieżącym
katalogu, ale nie pasuje do `dir/photo.jpg`. W tym celu należy użyć `**/*.jpg`.
Klasy znaków używające nawiasów kwadratowych `[]` dopasowują pojedynczy znak z
określonego zestawu lub zakresu. Podobnie jak inne wzorce pojedynczych znaków,
@ -1708,8 +1708,8 @@ wykrzyknika.
Podstawową różnicą, o której należy pamiętać, jest to, że `*`, `?` i klasy znaków
wszystkie respektują granice katalogów i dopasowują się tylko w obrębie jednego
składnika ścieżki, podczas gdy `**` jest jedynym wzorcem, który może dopasowywać się poprzez
separatory katalogów.
składnika ścieżki, podczas gdy `**` może dopasowywać się poprzez separatory
katalogów tylko wtedy, gdy sąsiaduje z ukośnikiem.
Istnieją cztery różne typy wzorców:

27
doc/snapraid-pt.1
View file

@ -2008,18 +2008,19 @@ barra invertida, tornando\-o adequado para correspondência dentro de um único
componente de caminho. Este é o comportamento padrão de curinga familiar do
globbing de shell.
.PP
O asterisco duplo \`**\` é mais poderoso, ele corresponde a qualquer sequência de
caracteres, incluindo separadores de diretórios. Isso permite que os padrões correspondam
em vários níveis de diretório. Quando o \`**\` aparece incorporado diretamente em
um padrão, ele pode corresponder a zero ou mais caracteres, incluindo barras entre
o texto literal circundante.
O curinga de asterisco duplo \`**\` corresponde através de separadores de
diretório apenas quando for adjacente a um separador de diretório (precedido
ou seguido por uma barra). Nessa forma, ele corresponde a zero ou mais
caracteres através de níveis de diretório. Por exemplo, \`foo/**/bar\`
corresponde a \`foo/bar\`, \`foo/a/bar\` e \`foo/a/b/bar\`; \`**/build\` corresponde a
\`build\` e \`foo/bar/build\`; e \`src/**.js\` corresponde a \`src/main.js\` e
\`src/ui/components/main.js\`.
A forma avulsa \`/**/\` não é aceita como um padrão completo.
.PP
O uso mais importante do \`**\` é na forma especial \`/**/\`. Isso corresponde a
zero ou mais níveis de diretório completos, tornando possível corresponder arquivos
em qualquer profundidade em uma árvore de diretórios sem conhecer a estrutura exata do caminho.
Por exemplo, o padrão \`src/**/main.js\` corresponde a \`src/main.js\` (pulando
zero diretórios), \`src/ui/main.js\` (pulando um diretório) e
\`src/ui/components/main.js\` (pulando dois diretórios).
Quando \`**\` não for adjacente a uma barra, ele se comporta como \`*\` e não
corresponde a separadores de diretório. Por exemplo, \`**.jpg\` corresponde a
\`photo.jpg\` no diretório atual, mas não corresponde a \`dir/photo.jpg\`. Use
\`**/*.jpg\` para essa finalidade.
.PP
Classes de caracteres usando colchetes \`[]\` correspondem a um único caractere de um
conjunto ou intervalo especificado. Como os outros padrões de caractere único, elas
@ -2028,8 +2029,8 @@ um ponto de exclamação.
.PP
A distinção fundamental a ser lembrada é que \`*\`, \`?\` e classes de caracteres
respeitam os limites do diretório e correspondem apenas dentro de um único
componente de caminho, enquanto \`**\` é o único padrão que pode corresponder através de
separadores de diretório.
componente de caminho, enquanto \`**\` só pode corresponder através de separadores
de diretório quando for adjacente a uma barra.
.PP
Existem quatro tipos diferentes de padrões:
.TP

27
doc/snapraid-pt.d
View file

@ -1613,18 +1613,19 @@ Padrão (Pattern)
componente de caminho. Este é o comportamento padrão de curinga familiar do
globbing de shell.
O asterisco duplo `**` é mais poderoso, ele corresponde a qualquer sequência de
caracteres, incluindo separadores de diretórios. Isso permite que os padrões correspondam
em vários níveis de diretório. Quando o `**` aparece incorporado diretamente em
um padrão, ele pode corresponder a zero ou mais caracteres, incluindo barras entre
o texto literal circundante.
O curinga de asterisco duplo `**` corresponde através de separadores de
diretório apenas quando for adjacente a um separador de diretório (precedido
ou seguido por uma barra). Nessa forma, ele corresponde a zero ou mais
caracteres através de níveis de diretório. Por exemplo, `foo/**/bar`
corresponde a `foo/bar`, `foo/a/bar` e `foo/a/b/bar`; `**/build` corresponde a
`build` e `foo/bar/build`; e `src/**.js` corresponde a `src/main.js` e
`src/ui/components/main.js`.
A forma avulsa `/**/` não é aceita como um padrão completo.
O uso mais importante do `**` é na forma especial `/**/`. Isso corresponde a
zero ou mais níveis de diretório completos, tornando possível corresponder arquivos
em qualquer profundidade em uma árvore de diretórios sem conhecer a estrutura exata do caminho.
Por exemplo, o padrão `src/**/main.js` corresponde a `src/main.js` (pulando
zero diretórios), `src/ui/main.js` (pulando um diretório) e
`src/ui/components/main.js` (pulando dois diretórios).
Quando `**` não for adjacente a uma barra, ele se comporta como `*` e não
corresponde a separadores de diretório. Por exemplo, `**.jpg` corresponde a
`photo.jpg` no diretório atual, mas não corresponde a `dir/photo.jpg`. Use
`**/*.jpg` para essa finalidade.
Classes de caracteres usando colchetes `[]` correspondem a um único caractere de um
conjunto ou intervalo especificado. Como os outros padrões de caractere único, elas
@ -1633,8 +1634,8 @@ Padrão (Pattern)
A distinção fundamental a ser lembrada é que `*`, `?` e classes de caracteres
respeitam os limites do diretório e correspondem apenas dentro de um único
componente de caminho, enquanto `**` é o único padrão que pode corresponder através de
separadores de diretório.
componente de caminho, enquanto `**` só pode corresponder através de separadores
de diretório quando for adjacente a uma barra.
Existem quatro tipos diferentes de padrões:

27
doc/snapraid-pt.txt
View file

@ -1726,18 +1726,19 @@ barra invertida, tornando-o adequado para correspondência dentro de um único
componente de caminho. Este é o comportamento padrão de curinga familiar do
globbing de shell.
O asterisco duplo `**` é mais poderoso, ele corresponde a qualquer sequência de
caracteres, incluindo separadores de diretórios. Isso permite que os padrões correspondam
em vários níveis de diretório. Quando o `**` aparece incorporado diretamente em
um padrão, ele pode corresponder a zero ou mais caracteres, incluindo barras entre
o texto literal circundante.
O curinga de asterisco duplo `**` corresponde através de separadores de
diretório apenas quando for adjacente a um separador de diretório (precedido
ou seguido por uma barra). Nessa forma, ele corresponde a zero ou mais
caracteres através de níveis de diretório. Por exemplo, `foo/**/bar`
corresponde a `foo/bar`, `foo/a/bar` e `foo/a/b/bar`; `**/build` corresponde a
`build` e `foo/bar/build`; e `src/**.js` corresponde a `src/main.js` e
`src/ui/components/main.js`.
A forma avulsa `/**/` não é aceita como um padrão completo.
O uso mais importante do `**` é na forma especial `/**/`. Isso corresponde a
zero ou mais níveis de diretório completos, tornando possível corresponder arquivos
em qualquer profundidade em uma árvore de diretórios sem conhecer a estrutura exata do caminho.
Por exemplo, o padrão `src/**/main.js` corresponde a `src/main.js` (pulando
zero diretórios), `src/ui/main.js` (pulando um diretório) e
`src/ui/components/main.js` (pulando dois diretórios).
Quando `**` não for adjacente a uma barra, ele se comporta como `*` e não
corresponde a separadores de diretório. Por exemplo, `**.jpg` corresponde a
`photo.jpg` no diretório atual, mas não corresponde a `dir/photo.jpg`. Use
`**/*.jpg` para essa finalidade.
Classes de caracteres usando colchetes `[]` correspondem a um único caractere de um
conjunto ou intervalo especificado. Como os outros padrões de caractere único, elas
@ -1746,8 +1747,8 @@ um ponto de exclamação.
A distinção fundamental a ser lembrada é que `*`, `?` e classes de caracteres
respeitam os limites do diretório e correspondem apenas dentro de um único
componente de caminho, enquanto `**` é o único padrão que pode corresponder através de
separadores de diretório.
componente de caminho, enquanto `**` só pode corresponder através de separadores
de diretório quando for adjacente a uma barra.
Existem quatro tipos diferentes de padrões:

27
doc/snapraid-ro.1
View file

@ -1968,18 +1968,19 @@ bara oblică (/), ceea ce îl face potrivit pentru potrivirea în cadrul unei si
componente a căii. Acesta este comportamentul standard al metacaracterelor, familiar
din shell globbing.
.PP
Asteriscul dublu \`**\` este mai puternic, se potrivește cu orice secvență de
caractere, inclusiv separatori de directoare. Acest lucru permite modelelor să se potrivească
pe mai multe niveluri de directoare. Când \`**\` apare inserat direct într\-un
model, se poate potrivi cu zero sau mai multe caractere, inclusiv slash\-uri între
textul literal înconjurător.
Metacaracterul asterisc dublu \`**\` se potrivește peste separatorii de
directoare numai atunci când este adiacent unui separator de directoare
(precedat sau urmat de o bară oblică). În această formă, se potrivește cu
zero sau mai multe caractere pe mai multe niveluri de directoare. De exemplu,
\`foo/**/bar\` se potrivește cu \`foo/bar\`, \`foo/a/bar\` și \`foo/a/b/bar\`;
\`**/build\` se potrivește cu \`build\` și \`foo/bar/build\`; iar \`src/**.js\` se
potrivește cu \`src/main.js\` și \`src/ui/components/main.js\`.
Forma de sine stătătoare \`/**/\` nu este acceptată ca un model complet.
.PP
Cea mai importantă utilizare a lui \`**\` este în forma specială \`/**/\`. Aceasta se potrivește cu
zero sau mai multe niveluri complete de directoare, făcând posibilă potrivirea fișierelor
la orice adâncime într\-un arbore de directoare fără a cunoaște structura exactă a căii.
De exemplu, modelul \`src/**/main.js\` se potrivește cu \`src/main.js\` (sărind
peste zero directoare), \`src/ui/main.js\` (sărind peste un director) și
\`src/ui/components/main.js\` (sărind peste două directoare).
Când \`**\` nu este adiacent unei bare oblice, se comportă ca \`*\` și nu se
potrivește cu separatorii de directoare. De exemplu, \`**.jpg\` se potrivește cu
\`photo.jpg\` în directorul curent, dar nu se potrivește cu \`dir/photo.jpg\`.
Folosiți \`**/*.jpg\` în acest scop.
.PP
Clasele de caractere care utilizează paranteze pătrate \`[]\` se potrivesc cu un singur caracter dintr\-un
set sau interval specificat. La fel ca și celelalte modele de un singur caracter, acestea
@ -1988,8 +1989,8 @@ un semn de exclamare.
.PP
Distincția fundamentală de reținut este că \`*\`, \`?\` și clasele de caractere
respectă toate limitele directoarelor și se potrivesc doar în cadrul unei singure
componente a căii, în timp ce \`**\` este singurul model care se poate potrivi peste
separatorii de directoare.
componente a căii, în timp ce \`**\` se poate potrivi peste separatorii de directoare
numai atunci când este adiacent unei bare oblice.
.PP
Există patru tipuri diferite de modele:
.TP

27
doc/snapraid-ro.d
View file

@ -1573,18 +1573,19 @@ Model (Pattern)
componente a căii. Acesta este comportamentul standard al metacaracterelor, familiar
din shell globbing.
Asteriscul dublu `**` este mai puternic, se potrivește cu orice secvență de
caractere, inclusiv separatori de directoare. Acest lucru permite modelelor să se potrivească
pe mai multe niveluri de directoare. Când `**` apare inserat direct într-un
model, se poate potrivi cu zero sau mai multe caractere, inclusiv slash-uri între
textul literal înconjurător.
Metacaracterul asterisc dublu `**` se potrivește peste separatorii de
directoare numai atunci când este adiacent unui separator de directoare
(precedat sau urmat de o bară oblică). În această formă, se potrivește cu
zero sau mai multe caractere pe mai multe niveluri de directoare. De exemplu,
`foo/**/bar` se potrivește cu `foo/bar`, `foo/a/bar` și `foo/a/b/bar`;
`**/build` se potrivește cu `build` și `foo/bar/build`; iar `src/**.js` se
potrivește cu `src/main.js` și `src/ui/components/main.js`.
Forma de sine stătătoare `/**/` nu este acceptată ca un model complet.
Cea mai importantă utilizare a lui `**` este în forma specială `/**/`. Aceasta se potrivește cu
zero sau mai multe niveluri complete de directoare, făcând posibilă potrivirea fișierelor
la orice adâncime într-un arbore de directoare fără a cunoaște structura exactă a căii.
De exemplu, modelul `src/**/main.js` se potrivește cu `src/main.js` (sărind
peste zero directoare), `src/ui/main.js` (sărind peste un director) și
`src/ui/components/main.js` (sărind peste două directoare).
Când `**` nu este adiacent unei bare oblice, se comportă ca `*` și nu se
potrivește cu separatorii de directoare. De exemplu, `**.jpg` se potrivește cu
`photo.jpg` în directorul curent, dar nu se potrivește cu `dir/photo.jpg`.
Folosiți `**/*.jpg` în acest scop.
Clasele de caractere care utilizează paranteze pătrate `[]` se potrivesc cu un singur caracter dintr-un
set sau interval specificat. La fel ca și celelalte modele de un singur caracter, acestea
@ -1593,8 +1594,8 @@ Model (Pattern)
Distincția fundamentală de reținut este că `*`, `?` și clasele de caractere
respectă toate limitele directoarelor și se potrivesc doar în cadrul unei singure
componente a căii, în timp ce `**` este singurul model care se poate potrivi peste
separatorii de directoare.
componente a căii, în timp ce `**` se poate potrivi peste separatorii de directoare
numai atunci când este adiacent unei bare oblice.
Există patru tipuri diferite de modele:

27
doc/snapraid-ro.txt
View file

@ -1686,18 +1686,19 @@ bara oblică (/), ceea ce îl face potrivit pentru potrivirea în cadrul unei si
componente a căii. Acesta este comportamentul standard al metacaracterelor, familiar
din shell globbing.
Asteriscul dublu `**` este mai puternic, se potrivește cu orice secvență de
caractere, inclusiv separatori de directoare. Acest lucru permite modelelor să se potrivească
pe mai multe niveluri de directoare. Când `**` apare inserat direct într-un
model, se poate potrivi cu zero sau mai multe caractere, inclusiv slash-uri între
textul literal înconjurător.
Metacaracterul asterisc dublu `**` se potrivește peste separatorii de
directoare numai atunci când este adiacent unui separator de directoare
(precedat sau urmat de o bară oblică). În această formă, se potrivește cu
zero sau mai multe caractere pe mai multe niveluri de directoare. De exemplu,
`foo/**/bar` se potrivește cu `foo/bar`, `foo/a/bar` și `foo/a/b/bar`;
`**/build` se potrivește cu `build` și `foo/bar/build`; iar `src/**.js` se
potrivește cu `src/main.js` și `src/ui/components/main.js`.
Forma de sine stătătoare `/**/` nu este acceptată ca un model complet.
Cea mai importantă utilizare a lui `**` este în forma specială `/**/`. Aceasta se potrivește cu
zero sau mai multe niveluri complete de directoare, făcând posibilă potrivirea fișierelor
la orice adâncime într-un arbore de directoare fără a cunoaște structura exactă a căii.
De exemplu, modelul `src/**/main.js` se potrivește cu `src/main.js` (sărind
peste zero directoare), `src/ui/main.js` (sărind peste un director) și
`src/ui/components/main.js` (sărind peste două directoare).
Când `**` nu este adiacent unei bare oblice, se comportă ca `*` și nu se
potrivește cu separatorii de directoare. De exemplu, `**.jpg` se potrivește cu
`photo.jpg` în directorul curent, dar nu se potrivește cu `dir/photo.jpg`.
Folosiți `**/*.jpg` în acest scop.
Clasele de caractere care utilizează paranteze pătrate `[]` se potrivesc cu un singur caracter dintr-un
set sau interval specificat. La fel ca și celelalte modele de un singur caracter, acestea
@ -1706,8 +1707,8 @@ un semn de exclamare.
Distincția fundamentală de reținut este că `*`, `?` și clasele de caractere
respectă toate limitele directoarelor și se potrivesc doar în cadrul unei singure
componente a căii, în timp ce `**` este singurul model care se poate potrivi peste
separatorii de directoare.
componente a căii, în timp ce `**` se poate potrivi peste separatorii de directoare
numai atunci când este adiacent unei bare oblice.
Există patru tipuri diferite de modele:

27
doc/snapraid-ru.1
View file

@ -1973,18 +1973,19 @@ SnapRAID управляет тремя конкретными снимками,
компонента пути. Это стандартное поведение подстановочных знаков, знакомое
по оболочке (shell).
.PP
Двойная звездочка \`**\` более мощная, она соответствует любой последовательности
символов, включая разделители каталогов. Это позволяет шаблонам соответствовать
нескольким уровням каталогов. Когда \`**\` появляется непосредственно в
шаблоне, она может соответствовать нулю или более символам, включая косые черты между
окружающим буквальным текстом.
Символ подстановки двойная звездочка \`**\` сопоставляется через разделители
каталогов только тогда, когда он примыкает к разделителю каталогов (перед ним
или после него стоит косая черта). В этой форме он соответствует нулю или
более символам на нескольких уровнях каталогов. Например, \`foo/**/bar\`
соответствует \`foo/bar\`, \`foo/a/bar\` и \`foo/a/b/bar\`; \`**/build\` соответствует
\`build\` и \`foo/bar/build\`; а \`src/**.js\` соответствует \`src/main.js\` и
\`src/ui/components/main.js\`.
Автономная форма \`/**/\` не принимается в качестве полного шаблона.
.PP
Наиболее важным использованием \`**\` является специальная форма \`/**/\`. Она соответствует
нулю или более полным уровням каталогов, что позволяет сопоставлять файлы
на любой глубине в дереве каталогов, не зная точной структуры пути.
Например, шаблон \`src/**/main.js\` соответствует \`src/main.js\` (пропуск
ноля каталогов), \`src/ui/main.js\` (пропуск одного каталога) и
\`src/ui/components/main.js\` (пропуск двух каталогов).
Когда \`**\` не примыкает к косой черте, он ведет себя как \`*\` и не
соответствует разделителям каталогов. Например, \`**.jpg\` соответствует
\`photo.jpg\` в текущем каталоге, но не соответствует \`dir/photo.jpg\`. Для этой
цели используйте \`**/*.jpg\`.
.PP
Классы символов с использованием квадратных скобок \`[]\` соответствуют одному символу из
заданного набора или диапазона. Как и другие односимвольные шаблоны, они
@ -1993,8 +1994,8 @@ SnapRAID управляет тремя конкретными снимками,
.PP
Фундаментальное различие, которое следует помнить, заключается в том, что \`*\`, \`?\` и классы
символов соблюдают границы каталогов и соответствуют только внутри одного
компонента пути, в то время как \`**\` — единственный шаблон, который может соответствовать
через разделители каталогов.
компонента пути, в то время как \`**\` может соответствовать через разделители
каталогов только тогда, когда примыкает к косой черте.
.PP
Существует четыре различных типа шаблонов:
.TP

27
doc/snapraid-ru.d
View file

@ -1580,18 +1580,19 @@ Name{number}
компонента пути. Это стандартное поведение подстановочных знаков, знакомое
по оболочке (shell).
Двойная звездочка `**` более мощная, она соответствует любой последовательности
символов, включая разделители каталогов. Это позволяет шаблонам соответствовать
нескольким уровням каталогов. Когда `**` появляется непосредственно в
шаблоне, она может соответствовать нулю или более символам, включая косые черты между
окружающим буквальным текстом.
Символ подстановки двойная звездочка `**` сопоставляется через разделители
каталогов только тогда, когда он примыкает к разделителю каталогов (перед ним
или после него стоит косая черта). В этой форме он соответствует нулю или
более символам на нескольких уровнях каталогов. Например, `foo/**/bar`
соответствует `foo/bar`, `foo/a/bar` и `foo/a/b/bar`; `**/build` соответствует
`build` и `foo/bar/build`; а `src/**.js` соответствует `src/main.js` и
`src/ui/components/main.js`.
Автономная форма `/**/` не принимается в качестве полного шаблона.
Наиболее важным использованием `**` является специальная форма `/**/`. Она соответствует
нулю или более полным уровням каталогов, что позволяет сопоставлять файлы
на любой глубине в дереве каталогов, не зная точной структуры пути.
Например, шаблон `src/**/main.js` соответствует `src/main.js` (пропуск
ноля каталогов), `src/ui/main.js` (пропуск одного каталога) и
`src/ui/components/main.js` (пропуск двух каталогов).
Когда `**` не примыкает к косой черте, он ведет себя как `*` и не
соответствует разделителям каталогов. Например, `**.jpg` соответствует
`photo.jpg` в текущем каталоге, но не соответствует `dir/photo.jpg`. Для этой
цели используйте `**/*.jpg`.
Классы символов с использованием квадратных скобок `[]` соответствуют одному символу из
заданного набора или диапазона. Как и другие односимвольные шаблоны, они
@ -1600,8 +1601,8 @@ Name{number}
Фундаментальное различие, которое следует помнить, заключается в том, что `*`, `?` и классы
символов соблюдают границы каталогов и соответствуют только внутри одного
компонента пути, в то время как `**` — единственный шаблон, который может соответствовать
через разделители каталогов.
компонента пути, в то время как `**` может соответствовать через разделители
каталогов только тогда, когда примыкает к косой черте.
Существует четыре различных типа шаблонов:

27
doc/snapraid-ru.txt
View file

@ -1693,18 +1693,19 @@ SnapRAID управляет тремя конкретными снимками,
компонента пути. Это стандартное поведение подстановочных знаков, знакомое
по оболочке (shell).
Двойная звездочка `**` более мощная, она соответствует любой последовательности
символов, включая разделители каталогов. Это позволяет шаблонам соответствовать
нескольким уровням каталогов. Когда `**` появляется непосредственно в
шаблоне, она может соответствовать нулю или более символам, включая косые черты между
окружающим буквальным текстом.
Символ подстановки двойная звездочка `**` сопоставляется через разделители
каталогов только тогда, когда он примыкает к разделителю каталогов (перед ним
или после него стоит косая черта). В этой форме он соответствует нулю или
более символам на нескольких уровнях каталогов. Например, `foo/**/bar`
соответствует `foo/bar`, `foo/a/bar` и `foo/a/b/bar`; `**/build` соответствует
`build` и `foo/bar/build`; а `src/**.js` соответствует `src/main.js` и
`src/ui/components/main.js`.
Автономная форма `/**/` не принимается в качестве полного шаблона.
Наиболее важным использованием `**` является специальная форма `/**/`. Она соответствует
нулю или более полным уровням каталогов, что позволяет сопоставлять файлы
на любой глубине в дереве каталогов, не зная точной структуры пути.
Например, шаблон `src/**/main.js` соответствует `src/main.js` (пропуск
ноля каталогов), `src/ui/main.js` (пропуск одного каталога) и
`src/ui/components/main.js` (пропуск двух каталогов).
Когда `**` не примыкает к косой черте, он ведет себя как `*` и не
соответствует разделителям каталогов. Например, `**.jpg` соответствует
`photo.jpg` в текущем каталоге, но не соответствует `dir/photo.jpg`. Для этой
цели используйте `**/*.jpg`.
Классы символов с использованием квадратных скобок `[]` соответствуют одному символу из
заданного набора или диапазона. Как и другие односимвольные шаблоны, они
@ -1713,8 +1714,8 @@ SnapRAID управляет тремя конкретными снимками,
Фундаментальное различие, которое следует помнить, заключается в том, что `*`, `?` и классы
символов соблюдают границы каталогов и соответствуют только внутри одного
компонента пути, в то время как `**` — единственный шаблон, который может соответствовать
через разделители каталогов.
компонента пути, в то время как `**` может соответствовать через разделители
каталогов только тогда, когда примыкает к косой черте.
Существует четыре различных типа шаблонов:

25
doc/snapraid-sv.1
View file

@ -1971,18 +1971,17 @@ snedstrecket, vilket gör den lämplig för matchning inom en enskild
sökvägskomponent. Detta är det standardbeteende för jokertecken som är
bekant från skal\-globbing.
.PP
Den dubbla stjärnan \`**\` är mer kraftfull; den matchar valfri teckensekvens
inklusive katalogavgränsare. Detta gör att mönster kan matcha över
flera katalognivåer. När \`**\` förekommer direkt i ett mönster kan det
matcha noll eller fler tecken inklusive snedstreck mellan den
omkringliggande bokstavliga texten.
Jokertecknet med dubbelstjärna \`**\` matchar över katalogavgränsare endast när
det gränsar till en katalogavgränsare (föregås eller efterföljs av ett
snedstreck). I denna form matchar det noll eller fler tecken över flera
katalognivåer. Till exempel matchar \`foo/**/bar\` sökvägarna \`foo/bar\`,
\`foo/a/bar\` och \`foo/a/b/bar\`; \`**/build\` matchar \`build\` och \`foo/bar/build\`;
och \`src/**.js\` matchar \`src/main.js\` och \`src/ui/components/main.js\`.
Den fristående formen \`/**/\` accepteras inte som ett fullständigt mönster.
.PP
Den viktigaste användningen av \`**\` är i den speciella formen \`/**/\`. Detta matchar
noll eller flera kompletta katalognivåer, vilket gör det möjligt att matcha filer
på valfritt djup i ett katalogträd utan att känna till den exakta sökvägsstrukturen.
Till exempel matchar mönstret \`src/**/main.js\` filerna \`src/main.js\` (hoppar över
noll kataloger), \`src/ui/main.js\` (hoppar över en katalog) och
\`src/ui/components/main.js\` (hoppar över två kataloger).
När \`**\` inte gränsar till ett snedstreck beter det sig som \`*\` och matchar
inte katalogavgränsare. Till exempel matchar \`**.jpg\` filen \`photo.jpg\` i den
aktuella katalogen, men inte \`dir/photo.jpg\`. Använd \`**/*.jpg\` för detta ändamål.
.PP
Teckenklasser som använder hakparenteser \`[]\` matchar ett enskilt tecken från en
angiven uppsättning eller ett intervall. Precis som de andra mönstren för enskilda
@ -1991,8 +1990,8 @@ negering med ett utropstecken.
.PP
Den grundläggande skillnaden att komma ihåg är att \`*\`, \`?\` och teckenklasser
alla respekterar kataloggränser och endast matchar inom en enskild
sökvägskomponent, medan \`**\` är det enda mönstret som kan matcha över
katalogavgränsare.
sökvägskomponent, medan \`**\` endast kan matcha över katalogavgränsare när det
gränsar till ett snedstreck.
.PP
Det finns fyra olika typer av mönster:
.TP

25
doc/snapraid-sv.d
View file

@ -1576,18 +1576,17 @@ Mönster (Pattern)
sökvägskomponent. Detta är det standardbeteende för jokertecken som är
bekant från skal-globbing.
Den dubbla stjärnan `**` är mer kraftfull; den matchar valfri teckensekvens
inklusive katalogavgränsare. Detta gör att mönster kan matcha över
flera katalognivåer. När `**` förekommer direkt i ett mönster kan det
matcha noll eller fler tecken inklusive snedstreck mellan den
omkringliggande bokstavliga texten.
Jokertecknet med dubbelstjärna `**` matchar över katalogavgränsare endast när
det gränsar till en katalogavgränsare (föregås eller efterföljs av ett
snedstreck). I denna form matchar det noll eller fler tecken över flera
katalognivåer. Till exempel matchar `foo/**/bar` sökvägarna `foo/bar`,
`foo/a/bar` och `foo/a/b/bar`; `**/build` matchar `build` och `foo/bar/build`;
och `src/**.js` matchar `src/main.js` och `src/ui/components/main.js`.
Den fristående formen `/**/` accepteras inte som ett fullständigt mönster.
Den viktigaste användningen av `**` är i den speciella formen `/**/`. Detta matchar
noll eller flera kompletta katalognivåer, vilket gör det möjligt att matcha filer
på valfritt djup i ett katalogträd utan att känna till den exakta sökvägsstrukturen.
Till exempel matchar mönstret `src/**/main.js` filerna `src/main.js` (hoppar över
noll kataloger), `src/ui/main.js` (hoppar över en katalog) och
`src/ui/components/main.js` (hoppar över två kataloger).
När `**` inte gränsar till ett snedstreck beter det sig som `*` och matchar
inte katalogavgränsare. Till exempel matchar `**.jpg` filen `photo.jpg` i den
aktuella katalogen, men inte `dir/photo.jpg`. Använd `**/*.jpg` för detta ändamål.
Teckenklasser som använder hakparenteser `[]` matchar ett enskilt tecken från en
angiven uppsättning eller ett intervall. Precis som de andra mönstren för enskilda
@ -1596,8 +1595,8 @@ Mönster (Pattern)
Den grundläggande skillnaden att komma ihåg är att `*`, `?` och teckenklasser
alla respekterar kataloggränser och endast matchar inom en enskild
sökvägskomponent, medan `**` är det enda mönstret som kan matcha över
katalogavgränsare.
sökvägskomponent, medan `**` endast kan matcha över katalogavgränsare när det
gränsar till ett snedstreck.
Det finns fyra olika typer av mönster:

25
doc/snapraid-sv.txt
View file

@ -1689,18 +1689,17 @@ snedstrecket, vilket gör den lämplig för matchning inom en enskild
sökvägskomponent. Detta är det standardbeteende för jokertecken som är
bekant från skal-globbing.
Den dubbla stjärnan `**` är mer kraftfull; den matchar valfri teckensekvens
inklusive katalogavgränsare. Detta gör att mönster kan matcha över
flera katalognivåer. När `**` förekommer direkt i ett mönster kan det
matcha noll eller fler tecken inklusive snedstreck mellan den
omkringliggande bokstavliga texten.
Jokertecknet med dubbelstjärna `**` matchar över katalogavgränsare endast när
det gränsar till en katalogavgränsare (föregås eller efterföljs av ett
snedstreck). I denna form matchar det noll eller fler tecken över flera
katalognivåer. Till exempel matchar `foo/**/bar` sökvägarna `foo/bar`,
`foo/a/bar` och `foo/a/b/bar`; `**/build` matchar `build` och `foo/bar/build`;
och `src/**.js` matchar `src/main.js` och `src/ui/components/main.js`.
Den fristående formen `/**/` accepteras inte som ett fullständigt mönster.
Den viktigaste användningen av `**` är i den speciella formen `/**/`. Detta matchar
noll eller flera kompletta katalognivåer, vilket gör det möjligt att matcha filer
på valfritt djup i ett katalogträd utan att känna till den exakta sökvägsstrukturen.
Till exempel matchar mönstret `src/**/main.js` filerna `src/main.js` (hoppar över
noll kataloger), `src/ui/main.js` (hoppar över en katalog) och
`src/ui/components/main.js` (hoppar över två kataloger).
När `**` inte gränsar till ett snedstreck beter det sig som `*` och matchar
inte katalogavgränsare. Till exempel matchar `**.jpg` filen `photo.jpg` i den
aktuella katalogen, men inte `dir/photo.jpg`. Använd `**/*.jpg` för detta ändamål.
Teckenklasser som använder hakparenteser `[]` matchar ett enskilt tecken från en
angiven uppsättning eller ett intervall. Precis som de andra mönstren för enskilda
@ -1709,8 +1708,8 @@ negering med ett utropstecken.
Den grundläggande skillnaden att komma ihåg är att `*`, `?` och teckenklasser
alla respekterar kataloggränser och endast matchar inom en enskild
sökvägskomponent, medan `**` är det enda mönstret som kan matcha över
katalogavgränsare.
sökvägskomponent, medan `**` endast kan matcha över katalogavgränsare när det
gränsar till ett snedstreck.
Det finns fyra olika typer av mönster:

27
doc/snapraid-uk.1
View file

@ -2143,18 +2143,19 @@ SnapRAID керує трьома конкретними знімками, \`stab
компонента шляху. Це стандартна поведінка підстановочних знаків, знайома
з командної оболонки (shell globbing).
.PP
Подвійна зірочка \`**\` є потужнішою, вона відповідає будь\-якій послідовності
символів, включаючи роздільники каталогів. Це дозволяє шаблонам відповідати
кільком рівням каталогів. Коли \`**\` з\'являється безпосередньо в шаблоні,
вона може відповідати нулю або більше символам, включаючи косі риски між
оточуючим літеральним текстом.
Символ підстановки подвійна зірочка \`**\` зіставляється через роздільники
каталогів лише тоді, коли він прилягає до роздільника каталогів (перед ним або
після нього стоїть скісна риска). У цій формі він відповідає нулю або більше
символам на кількох рівнях каталогів. Наприклад, \`foo/**/bar\` відповідає
\`foo/bar\`, \`foo/a/bar\` та \`foo/a/b/bar\`; \`**/build\` відповідає \`build\` та
\`foo/bar/build\`; а \`src/**.js\` відповідає \`src/main.js\` та
\`src/ui/components/main.js\`.
Окрема форма \`/**/\` не приймається як повний шаблон.
.PP
Найважливішим використанням \`**\` є спеціальна форма \`/**/\`. Вона відповідає
нулю або більше повним рівням каталогів, що дозволяє зіставляти файли
на будь\-якій глибині в дереві каталогів, не знаючи точної структури шляху.
Наприклад, шаблон \`src/**/main.js\` відповідає \`src/main.js\` (пропуск
нуля каталогів), \`src/ui/main.js\` (пропуск одного каталогу) та
\`src/ui/components/main.js\` (пропуск двох каталогів).
Коли \`**\` не прилягає до скісної риски, він поводиться як \`*\` і не відповідає
роздільникам каталогів. Наприклад, \`**.jpg\` відповідає \`photo.jpg\` у поточному
каталозі, але не відповідає \`dir/photo.jpg\`. Для цієї мети використовуйте
\`**/*.jpg\`.
.PP
Класи символів із використанням квадратних дужок \`[]\` відповідають одному символу з
визначеного набору або діапазону. Як і інші односимвольні шаблони, вони
@ -2163,8 +2164,8 @@ SnapRAID керує трьома конкретними знімками, \`stab
.PP
Фундаментальна відмінність, яку слід пам\'ятати, полягає в тому, що \`*\`, \`?\` та класи символів
усі дотримуються меж каталогів і відповідають лише в межах одного компонента
шляху, тоді як \`**\` — єдиний шаблон, який може відповідати через роздільники
каталогів.
шляху, тоді як \`**\` може відповідати через роздільники каталогів лише тоді,
коли прилягає до скісної риски.
.PP
Існує чотири різні типи шаблонів:
.TP

27
doc/snapraid-uk.d
View file

@ -1739,18 +1739,19 @@ Name{number}
компонента шляху. Це стандартна поведінка підстановочних знаків, знайома
з командної оболонки (shell globbing).
Подвійна зірочка `**` є потужнішою, вона відповідає будь-якій послідовності
символів, включаючи роздільники каталогів. Це дозволяє шаблонам відповідати
кільком рівням каталогів. Коли `**` з'являється безпосередньо в шаблоні,
вона може відповідати нулю або більше символам, включаючи косі риски між
оточуючим літеральним текстом.
Символ підстановки подвійна зірочка `**` зіставляється через роздільники
каталогів лише тоді, коли він прилягає до роздільника каталогів (перед ним або
після нього стоїть скісна риска). У цій формі він відповідає нулю або більше
символам на кількох рівнях каталогів. Наприклад, `foo/**/bar` відповідає
`foo/bar`, `foo/a/bar` та `foo/a/b/bar`; `**/build` відповідає `build` та
`foo/bar/build`; а `src/**.js` відповідає `src/main.js` та
`src/ui/components/main.js`.
Окрема форма `/**/` не приймається як повний шаблон.
Найважливішим використанням `**` є спеціальна форма `/**/`. Вона відповідає
нулю або більше повним рівням каталогів, що дозволяє зіставляти файли
на будь-якій глибині в дереві каталогів, не знаючи точної структури шляху.
Наприклад, шаблон `src/**/main.js` відповідає `src/main.js` (пропуск
нуля каталогів), `src/ui/main.js` (пропуск одного каталогу) та
`src/ui/components/main.js` (пропуск двох каталогів).
Коли `**` не прилягає до скісної риски, він поводиться як `*` і не відповідає
роздільникам каталогів. Наприклад, `**.jpg` відповідає `photo.jpg` у поточному
каталозі, але не відповідає `dir/photo.jpg`. Для цієї мети використовуйте
`**/*.jpg`.
Класи символів із використанням квадратних дужок `[]` відповідають одному символу з
визначеного набору або діапазону. Як і інші односимвольні шаблони, вони
@ -1759,8 +1760,8 @@ Name{number}
Фундаментальна відмінність, яку слід пам'ятати, полягає в тому, що `*`, `?` та класи символів
усі дотримуються меж каталогів і відповідають лише в межах одного компонента
шляху, тоді як `**` — єдиний шаблон, який може відповідати через роздільники
каталогів.
шляху, тоді як `**` може відповідати через роздільники каталогів лише тоді,
коли прилягає до скісної риски.
Існує чотири різні типи шаблонів:

27
doc/snapraid-uk.txt
View file

@ -1852,18 +1852,19 @@ SnapRAID керує трьома конкретними знімками, `stabl
компонента шляху. Це стандартна поведінка підстановочних знаків, знайома
з командної оболонки (shell globbing).
Подвійна зірочка `**` є потужнішою, вона відповідає будь-якій послідовності
символів, включаючи роздільники каталогів. Це дозволяє шаблонам відповідати
кільком рівням каталогів. Коли `**` з'являється безпосередньо в шаблоні,
вона може відповідати нулю або більше символам, включаючи косі риски між
оточуючим літеральним текстом.
Символ підстановки подвійна зірочка `**` зіставляється через роздільники
каталогів лише тоді, коли він прилягає до роздільника каталогів (перед ним або
після нього стоїть скісна риска). У цій формі він відповідає нулю або більше
символам на кількох рівнях каталогів. Наприклад, `foo/**/bar` відповідає
`foo/bar`, `foo/a/bar` та `foo/a/b/bar`; `**/build` відповідає `build` та
`foo/bar/build`; а `src/**.js` відповідає `src/main.js` та
`src/ui/components/main.js`.
Окрема форма `/**/` не приймається як повний шаблон.
Найважливішим використанням `**` є спеціальна форма `/**/`. Вона відповідає
нулю або більше повним рівням каталогів, що дозволяє зіставляти файли
на будь-якій глибині в дереві каталогів, не знаючи точної структури шляху.
Наприклад, шаблон `src/**/main.js` відповідає `src/main.js` (пропуск
нуля каталогів), `src/ui/main.js` (пропуск одного каталогу) та
`src/ui/components/main.js` (пропуск двох каталогів).
Коли `**` не прилягає до скісної риски, він поводиться як `*` і не відповідає
роздільникам каталогів. Наприклад, `**.jpg` відповідає `photo.jpg` у поточному
каталозі, але не відповідає `dir/photo.jpg`. Для цієї мети використовуйте
`**/*.jpg`.
Класи символів із використанням квадратних дужок `[]` відповідають одному символу з
визначеного набору або діапазону. Як і інші односимвольні шаблони, вони
@ -1872,8 +1873,8 @@ SnapRAID керує трьома конкретними знімками, `stabl
Фундаментальна відмінність, яку слід пам'ятати, полягає в тому, що `*`, `?` та класи символів
усі дотримуються меж каталогів і відповідають лише в межах одного компонента
шляху, тоді як `**` — єдиний шаблон, який може відповідати через роздільники
каталогів.
шляху, тоді як `**` може відповідати через роздільники каталогів лише тоді,
коли прилягає до скісної риски.
Існує чотири різні типи шаблонів:

20
doc/snapraid-zh.1
View file

@ -1765,22 +1765,24 @@ SnapRAID 在每个数据子卷根目录下的隐藏目录中管理三个特定
它在正斜杠处停止，因此适用于匹配单个路径组件内的内容。
这是 Shell 通配符中常见的标准行为。
.PP
双星号 \`**\` 功能更强大，它可以匹配任何字符序列，包括目录分隔符。
这允许模式匹配跨越多个目录层级。当 \`**\` 直接嵌入在模式中时，
它可以匹配零个或多个字符，包括周围文字文本之间的斜杠。
双星号通配符 \`**\` 仅在与目录分隔符相邻时（前面或后面有斜杠）才能跨越
目录分隔符进行匹配。在此形式下，它可以跨越多个目录层级匹配零个或多个字符。
例如，\`foo/**/bar\` 匹配 \`foo/bar\`、\`foo/a/bar\` 和 \`foo/a/b/bar\`；
\`**/build\` 匹配 \`build\` 和 \`foo/bar/build\`；\`src/**.js\` 匹配 \`src/main.js\`
和 \`src/ui/components/main.js\`。
单独的形式 \`/**/\` 不被接受为完整的模式。
.PP
\`**\` 最重要的用法是特殊形式 \`/**/\`。它可以匹配零个或多个完整的目录层级，
从而可以在不知道确切路径结构的情况下，匹配目录树中任何深度的文件。
例如，模式 \`src/**/main.js\` 匹配 \`src/main.js\`（跳过零个目录）、
\`src/ui/main.js\`（跳过一个目录）以及 \`src/ui/components/main.js\`
（跳过两个目录）。
当 \`**\` 不与斜杠相邻时，其行为类似于 \`*\`，不会匹配目录分隔符。例如，
\`**.jpg\` 匹配当前目录中的 \`photo.jpg\`，但不会匹配 \`dir/photo.jpg\`。
如需匹配子目录中的文件，请使用 \`**/*.jpg\`。
.PP
使用方括号 \`[]\` 的字符类匹配指定集合或范围内的单个字符。
与其他单字符模式一样，它们不匹配目录分隔符。字符类支持使用
感叹号进行范围指定和否定。
.PP
需要记住的根本区别是，\`*\`、\`?\` 和字符类都遵循目录边界，
并且仅在单个路径组件内匹配，而 \`**\` 是唯一可以跨越目录分隔符匹配的模式。
并且仅在单个路径组件内匹配，而 \`**\` 仅在与斜杠相邻时才能跨越
目录分隔符进行匹配。
.PP
有四种不同类型的模式：
.TP

20
doc/snapraid-zh.d
View file

@ -1370,22 +1370,24 @@ Name{number}
它在正斜杠处停止，因此适用于匹配单个路径组件内的内容。
这是 Shell 通配符中常见的标准行为。
双星号 `**` 功能更强大，它可以匹配任何字符序列，包括目录分隔符。
这允许模式匹配跨越多个目录层级。当 `**` 直接嵌入在模式中时，
它可以匹配零个或多个字符，包括周围文字文本之间的斜杠。
双星号通配符 `**` 仅在与目录分隔符相邻时（前面或后面有斜杠）才能跨越
目录分隔符进行匹配。在此形式下，它可以跨越多个目录层级匹配零个或多个字符。
例如，`foo/**/bar` 匹配 `foo/bar`、`foo/a/bar` 和 `foo/a/b/bar`；
`**/build` 匹配 `build` 和 `foo/bar/build`；`src/**.js` 匹配 `src/main.js`
和 `src/ui/components/main.js`。
单独的形式 `/**/` 不被接受为完整的模式。
`**` 最重要的用法是特殊形式 `/**/`。它可以匹配零个或多个完整的目录层级，
从而可以在不知道确切路径结构的情况下，匹配目录树中任何深度的文件。
例如，模式 `src/**/main.js` 匹配 `src/main.js`（跳过零个目录）、
`src/ui/main.js`（跳过一个目录）以及 `src/ui/components/main.js`
（跳过两个目录）。
当 `**` 不与斜杠相邻时，其行为类似于 `*`，不会匹配目录分隔符。例如，
`**.jpg` 匹配当前目录中的 `photo.jpg`，但不会匹配 `dir/photo.jpg`。
如需匹配子目录中的文件，请使用 `**/*.jpg`。
使用方括号 `[]` 的字符类匹配指定集合或范围内的单个字符。
与其他单字符模式一样，它们不匹配目录分隔符。字符类支持使用
感叹号进行范围指定和否定。
需要记住的根本区别是，`*`、`?` 和字符类都遵循目录边界，
并且仅在单个路径组件内匹配，而 `**` 是唯一可以跨越目录分隔符匹配的模式。
并且仅在单个路径组件内匹配，而 `**` 仅在与斜杠相邻时才能跨越
目录分隔符进行匹配。
有四种不同类型的模式：

20
doc/snapraid-zh.txt
View file

@ -1483,22 +1483,24 @@ SnapRAID 在每个数据子卷根目录下的隐藏目录中管理三个特定
它在正斜杠处停止，因此适用于匹配单个路径组件内的内容。
这是 Shell 通配符中常见的标准行为。
双星号 `**` 功能更强大，它可以匹配任何字符序列，包括目录分隔符。
这允许模式匹配跨越多个目录层级。当 `**` 直接嵌入在模式中时，
它可以匹配零个或多个字符，包括周围文字文本之间的斜杠。
双星号通配符 `**` 仅在与目录分隔符相邻时（前面或后面有斜杠）才能跨越
目录分隔符进行匹配。在此形式下，它可以跨越多个目录层级匹配零个或多个字符。
例如，`foo/**/bar` 匹配 `foo/bar`、`foo/a/bar` 和 `foo/a/b/bar`；
`**/build` 匹配 `build` 和 `foo/bar/build`；`src/**.js` 匹配 `src/main.js`
和 `src/ui/components/main.js`。
单独的形式 `/**/` 不被接受为完整的模式。
`**` 最重要的用法是特殊形式 `/**/`。它可以匹配零个或多个完整的目录层级，
从而可以在不知道确切路径结构的情况下，匹配目录树中任何深度的文件。
例如，模式 `src/**/main.js` 匹配 `src/main.js`（跳过零个目录）、
`src/ui/main.js`（跳过一个目录）以及 `src/ui/components/main.js`
（跳过两个目录）。
当 `**` 不与斜杠相邻时，其行为类似于 `*`，不会匹配目录分隔符。例如，
`**.jpg` 匹配当前目录中的 `photo.jpg`，但不会匹配 `dir/photo.jpg`。
如需匹配子目录中的文件，请使用 `**/*.jpg`。
使用方括号 `[]` 的字符类匹配指定集合或范围内的单个字符。
与其他单字符模式一样，它们不匹配目录分隔符。字符类支持使用
感叹号进行范围指定和否定。
需要记住的根本区别是，`*`、`?` 和字符类都遵循目录边界，
并且仅在单个路径组件内匹配，而 `**` 是唯一可以跨越目录分隔符匹配的模式。
并且仅在单个路径组件内匹配，而 `**` 仅在与斜杠相邻时才能跨越
目录分隔符进行匹配。
有四种不同类型的模式：

27
doc/snapraid.1
View file

@ -1976,20 +1976,19 @@ forward slash, making it suitable for matching within a single path
component. This is the standard wildcard behavior familiar from shell
globbing.
.PP
The double star \`**\` is more powerful, it matches any sequence of
characters including directory separators. This allows patterns to match
across multiple directory levels. When \`**\` appears embedded directly in
a pattern, it can match zero or more characters including slashes between
the surrounding literal text.
.PP
The most important use of \`**\` is in the special form \`/**/\`. This matches
zero or more complete directory levels, making it possible to match files
at any depth in a directory tree without knowing the exact path structure.
For example, the pattern \`src/**/main.js\` matches \`src/main.js\` (skipping
zero directories), \`src/ui/main.js\` (skipping one directory), and
\`src/ui/components/main.js\` (skipping two directories).
The double star \`**\` wildcard matches across directory separators only
when it is adjacent to a directory separator (preceded or followed by a
slash). In this form, it matches zero or more characters across directory
levels. For example, \`foo/**/bar\` matches \`foo/bar\`, \`foo/a/bar\`, and
\`foo/a/b/bar\`; \`**/build\` matches \`build\` and \`foo/bar/build\`; and
\`src/**.js\` matches \`src/main.js\` and \`src/ui/components/main.js\`.
The standalone form \`/**/\` is not accepted as a complete pattern.
.PP
When \`**\` is not adjacent to a slash, it behaves like \`*\` and does not
match directory separators. For example, \`**.jpg\` matches \`photo.jpg\`
within the current directory, but does not match \`dir/photo.jpg\`. Use
\`**/*.jpg\` for that purpose.
.PP
Character classes using square brackets match a single character from a
specified set or range. Like the other single character patterns, they do
not match directory separators. Classes support ranges and negation using
@ -1997,8 +1996,8 @@ an exclamation mark.
.PP
The fundamental distinction to remember is that \`*\`, \`?\`, and character
classes all respect directory boundaries and only match within a single path
component, while \`**\` is the only pattern that can match across directory
separators.
component, while \`**\` can match across directory separators only when
adjacent to a slash.
.PP
There are four different types of patterns:
.TP

27
doc/snapraid.d
View file

@ -1581,20 +1581,19 @@ Pattern
component. This is the standard wildcard behavior familiar from shell
globbing.
The double star `**` is more powerful, it matches any sequence of
characters including directory separators. This allows patterns to match
across multiple directory levels. When `**` appears embedded directly in
a pattern, it can match zero or more characters including slashes between
the surrounding literal text.
The most important use of `**` is in the special form `/**/`. This matches
zero or more complete directory levels, making it possible to match files
at any depth in a directory tree without knowing the exact path structure.
For example, the pattern `src/**/main.js` matches `src/main.js` (skipping
zero directories), `src/ui/main.js` (skipping one directory), and
`src/ui/components/main.js` (skipping two directories).
The double star `**` wildcard matches across directory separators only
when it is adjacent to a directory separator (preceded or followed by a
slash). In this form, it matches zero or more characters across directory
levels. For example, `foo/**/bar` matches `foo/bar`, `foo/a/bar`, and
`foo/a/b/bar`; `**/build` matches `build` and `foo/bar/build`; and
`src/**.js` matches `src/main.js` and `src/ui/components/main.js`.
The standalone form `/**/` is not accepted as a complete pattern.
When `**` is not adjacent to a slash, it behaves like `*` and does not
match directory separators. For example, `**.jpg` matches `photo.jpg`
within the current directory, but does not match `dir/photo.jpg`. Use
`**/*.jpg` for that purpose.
Character classes using square brackets match a single character from a
specified set or range. Like the other single character patterns, they do
not match directory separators. Classes support ranges and negation using
@ -1602,8 +1601,8 @@ Pattern
The fundamental distinction to remember is that `*`, `?`, and character
classes all respect directory boundaries and only match within a single path
component, while `**` is the only pattern that can match across directory
separators.
component, while `**` can match across directory separators only when
adjacent to a slash.
There are four different types of patterns:

27
doc/snapraid.txt
View file

@ -1694,20 +1694,19 @@ forward slash, making it suitable for matching within a single path
component. This is the standard wildcard behavior familiar from shell
globbing.
The double star `**` is more powerful, it matches any sequence of
characters including directory separators. This allows patterns to match
across multiple directory levels. When `**` appears embedded directly in
a pattern, it can match zero or more characters including slashes between
the surrounding literal text.
The most important use of `**` is in the special form `/**/`. This matches
zero or more complete directory levels, making it possible to match files
at any depth in a directory tree without knowing the exact path structure.
For example, the pattern `src/**/main.js` matches `src/main.js` (skipping
zero directories), `src/ui/main.js` (skipping one directory), and
`src/ui/components/main.js` (skipping two directories).
The double star `**` wildcard matches across directory separators only
when it is adjacent to a directory separator (preceded or followed by a
slash). In this form, it matches zero or more characters across directory
levels. For example, `foo/**/bar` matches `foo/bar`, `foo/a/bar`, and
`foo/a/b/bar`; `**/build` matches `build` and `foo/bar/build`; and
`src/**.js` matches `src/main.js` and `src/ui/components/main.js`.
The standalone form `/**/` is not accepted as a complete pattern.
When `**` is not adjacent to a slash, it behaves like `*` and does not
match directory separators. For example, `**.jpg` matches `photo.jpg`
within the current directory, but does not match `dir/photo.jpg`. Use
`**/*.jpg` for that purpose.
Character classes using square brackets match a single character from a
specified set or range. Like the other single character patterns, they do
not match directory separators. Classes support ranges and negation using
@ -1715,8 +1714,8 @@ an exclamation mark.
The fundamental distinction to remember is that `*`, `?`, and character
classes all respect directory boundaries and only match within a single path
component, while `**` is the only pattern that can match across directory
separators.
component, while `**` can match across directory separators only when
adjacent to a slash.
There are four different types of patterns: