Warum gibt dir *. * Mir alle Dateien und Ordner?

Wenn ich dir *.*es starte, entstehen unerwartete Ergebnisse. Sogar Dateien und Ordner ohne Punkt im Namen werden aufgelistet. Zum Beispiel

C:\>dir *.*
 Volume in drive C is System
 Volume Serial Number is AC0A-29DA

 Directory of C:\

14-03-2017  05:17 PM             8,192 ntuser.dat
03-01-2017  07:10 PM    <DIR>          Perl520
28-03-2017  10:13 AM    <DIR>          Program Files
28-03-2017  10:13 AM    <DIR>          Program Files (x86)
04-01-2017  03:25 PM    <JUNCTION>     Python27 [C:\Program Files\Anaconda]
06-02-2017  10:16 PM    <DIR>          SAP
28-03-2017  04:10 PM               152 useragent.log
03-01-2017  03:04 PM    <DIR>          Users
16-03-2017  04:24 PM    <DIR>          VM
22-03-2017  11:13 AM    <DIR>          Windows
               2 File(s)          8,344 bytes
               8 Dir(s)  270,172,966,912 bytes free

Warum ist das so? Gibt es eine Möglichkeit, nur Dateien mit einem Punkt aufzulisten?

Ich schreibe diese Antwort, weil OP Folgendes betont hat:

Was mich interessiert ist, warum *.*alle Dateien übereinstimmen, wie in der Frage angegeben

Der DIRBefehl stammt aus einer Zeit, in der:

1. Punkt (.) War als Zeichen in Datei- oder Ordnernamen nicht zulässig
2. Datei- und Ordnernamen waren auf 8 Zeichen für Namen und 3 Zeichen für Erweiterungen beschränkt

Nach diesem Standard *.*bedeutete dies daher, egal wie der Name und welche Erweiterung auch immer war . Dabei handelt es sich nicht um eine Zeichenfolge mit einem ".", Die Zeichen vor oder nach dem "." Enthalten kann oder nicht. .

Microsoft-Richtlinien gewährleisten die Abwärtskompatibilität. Daher wird diese Auslegung *.*beibehalten.

In Windows PowerShell *.*bedeutet dies jedoch eine Zeichenfolge mit einem ".", Die möglicherweise Zeichen vor oder nach dem "." .

Warum ist das so?

Man könnte eine Antwort auf " Warum ist das so? " Im Wildcards- Artikel finden:

The * wildcard will match any sequence of characters
               (0 or more, including NULL characters)

The ? wildcard will match a single character
               (or a NULL at the end of a filename)

…

Regeln für den Wildcard-Abgleich

• *Stimmt im Allgemeinen mit 0 oder mehr Zeichen überein, mit einer Ausnahme (siehe nächste Regel). Es steht dem nicht-gierigen Platzhalter frei, so viele oder so wenige Zeichen zuzuordnen, wie für den Rest der Maske erforderlich sind.

• *.Am Ende der Maske werden 0 oder mehr Zeichen mit Ausnahme von {dot} gefunden. Tatsächlich gilt die Regel für eine beliebige Anzahl von {Punkt} und {Leerzeichen} zwischen dem * und dem Terminal {Punkt}. Der reguläre Ausdruck für diesen Begriff lautet"[*][. ]*[.]$"

• ?Stimmt mit 0 oder einem Zeichen überein, außer mit {dot}. Die einzige Übereinstimmung mit 0 Zeichen besteht darin, dass das Ende des Namens oder die Position vor einem {Punkt} angegeben wird. Das Fragezeichen kann auch mehrmals verwendet werden, um mehr als ein Zeichen zu finden.

Implikation . Der letzte {Punkt} in einem Datei- / Ordnernamen trennt den Basisnamen und die Erweiterung. Damit

• dir *.zeigt alle Einzelteile mit keiner Erweiterung und
• dir *.*Zeigt alle Elemente mit einer Erweiterung von null oder mehr Zeichen an .

Streng genommen dir *.werden alle Elemente ohne Punkt ( .) im Namen angezeigt . (Übrigens, Benennen von Dateien, Pfaden und Namespaces MSDN-Artikel besagt ausdrücklich, dass " es akzeptabel ist, einen Punkt als erstes Zeichen eines Namens anzugeben ".)

Gibt es eine Möglichkeit, nur Dateien mit einem Punkt aufzulisten?

Ich glaube nicht Es gibt jedoch eine Problemumgehung mit einem passenden regulären Ausdruck.

PowerShell (Komplettlösung bei Verwendung in einer Powershell-Konsole):

:: PowerShell - no extension, full syntax
PowerShell -c "Get-ChildItem | Where-Object {$_.Name -match '^.[^\.]*$'}"
:: PowerShell -    extension, alias syntax
PowerShell -c "dir | ? {$_.Name -match '^..*\...*$'}"

Cmd (nur eine Idee, könnte etwas Ausarbeitung erfordern):

:: CMD/batch - no extension
for /F "delims=" %%G in ('dir /OGN /B ^| findstr "^.[^\.]*$"') do @echo %%~tG %%~aG %%~zG %%~nxG
:: CMD/batch -    extension
for /F "delims=" %%G in ('dir /OGN /B ^| findstr "^..*\...*$"') do @echo %%~tG %%~aG %%~zG %%~nxG

Nachtrag: Bonus und Erklärung

Eine intuitive Vermutung, Namedie verkettet ist BaseNameund Extension nicht gilt . Das folgende Skript beweist die Verwendung cmdund die PowerShellKernfunktionen, und der seltsame ^..*\...*$ reguläre Ausdruck wird aus den Ergebnissen abgeleitet.

@ECHO OFF
SETLOCAL EnableExtensions DisableDelayedExpansion
set "_workingDirectory=%~1"
if "%_workingDirectory%"=="%tmp%\tests_SU_1193102" (
  >NUL 2>&1 (
      mkdir "%_workingDirectory%"
      pushd "%_workingDirectory%"
      rem make directories
      mkdir     .Fldr-Ext
      mkdir     aFldr-Ext
      mkdir     .Fldr.Ext
      mkdir     aFldr.Ext
      rem create files
      copy  NUL .File-Ext 
      copy  NUL aFile-Ext 
      copy  NUL .File.Ext 
      copy  NUL aFile.Ext
      popd
  )
) else if "%_workingDirectory%"=="" set "_workingDirectory=%CD%"
pushd "%_workingDirectory%"
set "_first=ItemName  Attributes    BaseName Extension"
echo ON
::                        dir /OGN | findstr "Ext$"
for /F "delims=" %%G in ('dir /OGN /B') do @((if defined _first (echo %_first%&echo(&set "_first="))&echo %%~nxG %%~aG  %%~nG   %%~xG)
::   Get-ChildItem | Select-Object -Property Mode, BaseName, Extension, Name
PowerShell -c "dir | select -pr Name, Mode, BaseName, Extension | sort -pr @{Expression='Mode';Descending=$true}, @{Expression='Name';Descending=$false}"

Ausgabe :

==> D:\bat\BaseName_vs_Extension.bat "%tmp%\tests_SU_1193102"

==> for /F "delims=" %G in ('dir /OGN /B') do @((if defined _first (echo ItemName  Attributes   BaseName Extension  & echo(  & set "_first=" ) )  & echo %~nxG %~aG     %~nG    %~xG )
ItemName  Attributes    BaseName Extension

.Fldr.Ext d----------   .Fldr   .Ext
.Fldr-Ext d----------           .Fldr-Ext
aFldr.Ext d----------   aFldr   .Ext
aFldr-Ext d----------   aFldr-Ext
.File.Ext --a--------   .File   .Ext
.File-Ext --a--------           .File-Ext
aFile.Ext --a--------   aFile   .Ext
aFile-Ext --a--------   aFile-Ext

==> PowerShell -c "dir | select -pr Name, Mode, BaseName, Extension | sort -pr @{Expression='Mode';Descending=$true}, @{Expression='Name';Descending=$false}"

Name      Mode   BaseName  Extension
----      ----   --------  ---------
.Fldr.Ext d----- .Fldr.Ext .Ext
.Fldr-Ext d----- .Fldr-Ext .Fldr-Ext
aFldr.Ext d----- aFldr.Ext .Ext
aFldr-Ext d----- aFldr-Ext
.File.Ext -a---- .File     .Ext
.File-Ext -a----           .File-Ext
aFile.Ext -a---- aFile     .Ext
aFile-Ext -a---- aFile-Ext

Vergleichen Sie die Definition der BaseNameEigenschaft, die für Dateien und Ordner unterschiedlich ist:

PS D:\PShell> Get-ChildItem | Get-Member -Name BaseName | Format-List -property TypeName, Definition


TypeName   : System.IO.DirectoryInfo
Definition : System.Object BaseName {get=$this.Name;}

TypeName   : System.IO.FileInfo
Definition : System.Object BaseName {get=if ($this.Extension.Length -gt 
             0){$this.Name.Remove($this.Name.Length - 
             $this.Extension.Length)}else{$this.Name};}

Meine ursprüngliche Antwort basierte auf einem unverzeihlichen Missverständnis:

Lesen Sie dir /?, verwenden Sie dir /A:-D:

Ein anderer Ansatz: findstrRegex anwenden alsdir *.* | findstr /V "<.*>"

Gibt es eine Möglichkeit, nur Dateien mit einem Punkt aufzulisten?

Sie können Dateinamen mit einem Punkt abgleichen <, indem Sie den undokumentierten Platzhalter verwenden , der entweder einer Folge von 0 oder mehr Zeichen im Basisnamen oder einer Folge von 0 oder mehr Zeichen in der Erweiterung entspricht:

dir "<.<"

Denken <Sie daran, dass dies auch ein Metazeichen ist. Sie müssen es daher immer dann zitieren oder maskieren, wenn Sie es in einem Muster aus der Befehlsshell verwenden.

Der Befehlszeileninterpreter sieht " . " Als "Alle Basisdateinamen" mit "Alle Erweiterungen". Eine leere Erweiterung ist immer noch eine Erweiterung , daher wird sie mit der Liste abgeglichen und zurückgegeben. Wie andere erklärt haben, ist dies ein Kater aus früheren Versionen von Windows und MS-DOS.

Wenn Sie gerne mit PowerShell suchen, ist das Auffinden dieser Dateien viel einfacher. Beachten Sie, dass "dir" in PowerShell ein Alias ​​für das Cmdlet "Get-ChildItem" ist.

So finden Sie alle Dateien (keine Verzeichnisse / Ordner) mit einer Erweiterung (z. B. "myfile.txt", aber nicht "FileWithNoExt"):

dir -af | Where {$_.Name -match "\."}

Der Schalter "-af" ist eine Abkürzung für "-File", wodurch die Rückgabeobjekte nur auf Dateien beschränkt werden. "-ad" würde nur Verzeichnisse erhalten. Das "\." bedeutet "ein buchstäbliches Punktzeichen". Ohne den umgekehrten Schrägstrich würde der Punkt mit jedem Zeichen übereinstimmen, wie es der reguläre reguläre Ausdruck vorsieht.

So rufen Sie alle Dateien ab, in denen der Name einen Punkt ohne die Erweiterung sowie eine Erweiterung enthielt (z. B. "myDocument_v1.1.doc", aber nicht "myfile.txt"):

dir -af | Where {$_.BaseName -match "\."}

Beachten Sie jedoch, dass dies eine Datei mit dem Namen ".archive" mit einem vorangestellten Punkt ausschließt. Dies liegt daran, dass es so behandelt wird, als hätte es keinen Basisnamen und die Erweiterung "archive". Wenn Sie diese einbeziehen möchten:

dir -af | Where {$_.BaseName -match "\.|^$"}

Hier lautet das Übereinstimmungsmuster "Ein Literalpunkt, OR (|) BeginningOfString (^) gefolgt von EndOfString ($) (dh eine leere Zeichenfolge)". Da eine Datei nicht gleichzeitig einen leeren Basisnamen und eine leere Erweiterung haben kann, werden die Dateien mit einem Punkt beginnend gefunden.

Wenn Sie obigen Befehl eingeben, dann hier: * (dies ist eine Wild Card , das jede Folge von Zeichen bedeutet) gefolgt von einem Punkt , gefolgt von * könnte dies alle Dateien als Show interpretiert werden , die Namen haben wie (.) (Jede Folge von Zeichen ). (eine beliebige Folge von Zeichen), was außerdem bedeutet, dass alle Dateien mit einer beliebigen Erweiterung angezeigt werden.