So finden Sie die Windows-Version über die PowerShell-Befehlszeile

Wie finde ich die verwendete Windows-Version?

Ich verwende PowerShell 2.0 und habe versucht:

PS C:\> ver
The term 'ver' is not recognized as the name of a cmdlet, function, script file, or operable program. Check the spelling of the name, or if a path was included, verify tha
t the path is correct and try again.
At line:1 char:4
+ ver <<<< 
    + CategoryInfo          : ObjectNotFound: (ver:String) [], CommandNotFoundException
    + FullyQualifiedErrorId : CommandNotFoundException

Wie mache ich das?

Da Sie Zugriff auf die .NET-Bibliothek haben, können Sie auf die OSVersionEigenschaft der System.EnvironmentKlasse zugreifen , um diese Informationen abzurufen. Für die Versionsnummer gibt es die VersionEigenschaft.

Beispielsweise,

PS C:\> [System.Environment]::OSVersion.Version

Major  Minor  Build  Revision
-----  -----  -----  --------
6      1      7601   65536

Details zu Windows-Versionen finden Sie hier .

1. Verwenden Sie Folgendes , um die Windows-Versionsnummer zu erhalten, wie Jeff in seiner Antwort feststellt :

   [Environment]::OSVersion

   Es ist erwähnenswert, dass das Ergebnis vom Typ ist [System.Version], sodass Sie beispielsweise nach Windows 7 / Windows Server 2008 R2 und höher mit suchen können

   [Environment]::OSVersion.Version -ge (new-object 'Version' 6,1)

   Dies sagt Ihnen jedoch weder, ob es sich um Client- oder Server-Windows handelt, noch den Namen der Version.

2. Verwenden Sie die WMI- Win32_OperatingSystemKlasse (immer eine einzelne Instanz), zum Beispiel:

   (Get-WmiObject -class Win32_OperatingSystem).Caption

   wird so etwas wie zurückgeben

   Microsoft® Windows Server® 2008 Standard

Leider enthalten die meisten anderen Antworten keine spezifischen Informationen für Windows 10.

Windows 10 hat Versionen für sich: 1507, 1511, 1607, 1703, etc . Das winverzeigt es.

Powershell:
(Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion").ReleaseId

Command prompt (CMD.EXE):
Reg Query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion" /v ReleaseId

Siehe auch verwandte Frage zum Superuser .

Wie für andere Windows-Versionen verwenden systeminfo. Powershell Wrapper:

PS C:\> systeminfo /fo csv | ConvertFrom-Csv | select OS*, System*, Hotfix* | Format-List


OS Name             : Microsoft Windows 7 Enterprise
OS Version          : 6.1.7601 Service Pack 1 Build 7601
OS Manufacturer     : Microsoft Corporation
OS Configuration    : Standalone Workstation
OS Build Type       : Multiprocessor Free
System Type         : x64-based PC
System Locale       : ru;Russian
Hotfix(s)           : 274 Hotfix(s) Installed.,[01]: KB2849697,[02]: KB2849697,[03]:...

Windows 10-Ausgabe für denselben Befehl:

OS Name             : Microsoft Windows 10 Enterprise N 2016 LTSB
OS Version          : 10.0.14393 N/A Build 14393
OS Manufacturer     : Microsoft Corporation
OS Configuration    : Standalone Workstation
OS Build Type       : Multiprocessor Free
System Type         : x64-based PC
System Directory    : C:\Windows\system32
System Locale       : en-us;English (United States)
Hotfix(s)           : N/A

Get-WmiObject -Class Win32_OperatingSystem | ForEach-Object -MemberName Caption

Oder Golf gespielt

gwmi win32_operatingsystem | % caption

Ergebnis

Microsoft Windows 7 Ultimate

Dadurch erhalten Sie im Gegensatz zu allen oben genannten Lösungen die Vollversion von Windows (einschließlich der Revisions- / Build-Nummer) :

(Get-ItemProperty -Path c:\windows\system32\hal.dll).VersionInfo.FileVersion

Ergebnis:

10.0.10240.16392 (th1_st1.150716-1608)

Get-ComputerInfo | select WindowsProductName, WindowsVersion, OsHardwareAbstractionLayer

kehrt zurück

WindowsProductName    WindowsVersion OsHardwareAbstractionLayer
------------------    -------------- --------------------------
Windows 10 Enterprise 1709           10.0.16299.371 

Seit PowerShell 5:

Get-ComputerInfo
Get-ComputerInfo -Property Windows*

Ich denke, dieser Befehl versucht so ziemlich die 1001 verschiedenen Wege, die bisher entdeckt wurden, um Systeminformationen zu sammeln ...

Wenn Sie zwischen Windows 8.1 (6.3.9600) und Windows 8 (6.2.9200) unterscheiden möchten, verwenden Sie

(Get-CimInstance Win32_OperatingSystem).Version 

um die richtige Version zu bekommen. [Environment]::OSVersionfunktioniert in Windows 8.1 nicht richtig (es wird eine Windows 8-Version zurückgegeben).

Ich verfeinere eine der Antworten

Ich habe diese Frage erreicht, als ich versucht habe, die Ausgabe von winver.exe abzugleichen:

Version 1607 (OS Build 14393.351)

Ich konnte den Build-String extrahieren mit:

,((Get-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion" -Name BuildLabEx).BuildLabEx -split '\.') | % {  $_[0..1] -join '.' }  

Ergebnis: 14393.351

Aktualisiert : Hier ist ein leicht vereinfachtes Skript mit Regex

(Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion").BuildLabEx -match '^[0-9]+\.[0-9]+' |  % { $matches.Values }

Ich habe die obigen Skripte genommen und sie ein wenig optimiert, um Folgendes zu finden:

$name=(Get-WmiObject Win32_OperatingSystem).caption
$bit=(Get-WmiObject Win32_OperatingSystem).OSArchitecture

$vert = " Version:"
$ver=(Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion").ReleaseId

$buildt = " Build:"
$build= (Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion").BuildLabEx -match '^[0-9]+\.[0-9]+' |  % { $matches.Values }

$installd = Get-ComputerInfo -Property WindowsInstallDateFromRegistry

Write-host $installd
Write-Host $name, $bit, $vert, $ver, `enter code here`$buildt, $build, $installd

So erhalten Sie ein Ergebnis:

Microsoft Windows 10 Home 64-Bit-Version: 1709 Build: 16299.431 @ {WindowsInstallDateFromRegistry = 18-01-01 02:29:11 AM}

Hinweis: Ich würde es begrüßen, wenn eine Hand den Präfixtext vom Installationsdatum entfernt, damit ich ihn durch einen besser lesbaren Header ersetzen kann.

Wie MoonStom sagt, [Environment]::OSVersionfunktioniert es unter einem aktualisierten Windows 8.1 nicht richtig (es gibt eine Windows 8-Version zurück): link .

Wenn Sie zwischen Windows 8.1 (6.3.9600) und Windows 8 (6.2.9200) unterscheiden möchten, können (Get-CimInstance Win32_OperatingSystem).VersionSie die richtige Version verwenden. In PowerShell 2 funktioniert dies jedoch nicht. Verwenden Sie also Folgendes:

$version = $null
try {
    $version = (Get-CimInstance Win32_OperatingSystem).Version
}
catch {
    $version = [System.Environment]::OSVersion.Version | % {"{0}.{1}.{2}" -f $_.Major,$_.Minor,$_.Build}
}

Verwenden:

Get-WmiObject -class win32_operatingsystem -computer computername | Select-Object Caption

Wenn Sie versuchen, Informationen zu entschlüsseln, stellt MS eine Patch-Site wie https://technet.microsoft.com/en-us/library/security/ms17-010.aspx bereit

Sie benötigen eine Kombination wie:

$name=(Get-WmiObject Win32_OperatingSystem).caption $bit=(Get-WmiObject Win32_OperatingSystem).OSArchitecture $ver=(Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion").ReleaseId Write-Host $name, $bit, $ver

Microsoft Windows 10 Home 64-Bit 1703

Windows PowerShell 2.0:

$windows = New-Object -Type PSObject |
           Add-Member -MemberType NoteProperty -Name Caption -Value (Get-WmiObject -Class Win32_OperatingSystem).Caption -PassThru |
           Add-Member -MemberType NoteProperty -Name Version -Value [Environment]::OSVersion.Version                     -PassThru

Windows PowerShell 3.0:

$windows = [PSCustomObject]@{
    Caption = (Get-WmiObject -Class Win32_OperatingSystem).Caption
    Version = [Environment]::OSVersion.Version
}

Zur Anzeige (beide Versionen):

"{0}  ({1})" -f $windows.Caption, $windows.Version 

So erzeugen Sie eine identische Ausgabe wie winver.exe in PowerShell v5 unter Windows 10 1809:

$Version = Get-ItemProperty -Path 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\'
"Version $($Version.ReleaseId) (OS Build $($Version.CurrentBuildNumber).$($Version.UBR))"

(Get-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion" -Name BuildLabEx).BuildLabEx

Dies ist wirklich ein langer Thread, und wahrscheinlich, weil die richtigen Antworten die grundlegende Frage nicht lösen. Ich bin auf diese Site gestoßen : Versions- und Build-Nummern , die einen klaren Überblick über das, was in der Microsoft Windows-Welt ist, bieten.

Da ich wissen möchte, mit welchem ​​Windows-Betriebssystem ich es genau zu tun habe, habe ich die gesamte Version rainbow beiseite gelassen und mich stattdessen auf die BuildNumber konzentriert. Die Build-Nummer kann entweder erreicht werden durch:

([Environment]::OSVersion.Version).Build

oder von:

(Get-CimInstance Win32_OperatingSystem).buildNumber

Sie haben die Wahl, wie Sie es bevorzugen. Von dort aus konnte ich also Folgendes tun:

    switch ((Get-CimInstance Win32_OperatingSystem).BuildNumber) 
{
    6001 {$OS = "W2K8"}
    7600 {$OS = "W2K8R2"}
    7601 {$OS = "W2K8R2SP1"}    
    9200 {$OS = "W2K12"}
    9600 {$OS = "W2K12R2"}
    14393 {$OS = "W2K16v1607"}
    16229 {$OS = "W2K16v1709"}
    default { $OS = "Not Listed"}

}
Write-Host "Server system: $OS" -foregroundcolor Green

Hinweis: Wie Sie sehen, habe ich das oben Genannte nur für Serversysteme verwendet, es kann jedoch problemlos auf Workstations angewendet oder sogar geschickt erweitert werden, um beide zu unterstützen ... aber das überlasse ich Ihnen.

Habe Spaß!

Dadurch erhalten Sie die vollständige und RICHTIGE (dieselbe Versionsnummer, die Sie beim Ausführen von winver.exe finden) Windows-Version (einschließlich Revisions- / Build-Nummer) FERN im Gegensatz zu allen anderen Lösungen (getestet unter Windows 10):

Function Get-OSVersion {
Param($ComputerName)
    Invoke-Command -ComputerName $ComputerName -ScriptBlock {
        $all = @()
        (Get-Childitem c:\windows\system32) | ? Length | Foreach {

            $all += (Get-ItemProperty -Path $_.FullName).VersionInfo.Productversion
        }
        $version = [System.Environment]::OSVersion.Version
        $osversion = "$($version.major).0.$($version.build)"
        $minor = @()
        $all | ? {$_ -like "$osversion*"} | Foreach {
            $minor += [int]($_ -replace".*\.")
        }
        $minor = $minor | sort | Select -Last 1

        return "$osversion.$minor"
    }
}

Ich habe viel gesucht, um die genaue Version herauszufinden, da der WSUS-Server die falsche Version anzeigt. Am besten holen Sie sich eine Revision vom UBR-Registrierungsschlüssel.

    $WinVer = New-Object –TypeName PSObject
$WinVer | Add-Member –MemberType NoteProperty –Name Major –Value $(Get-ItemProperty -Path 'Registry::HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion' CurrentMajorVersionNumber).CurrentMajorVersionNumber
$WinVer | Add-Member –MemberType NoteProperty –Name Minor –Value $(Get-ItemProperty -Path 'Registry::HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion' CurrentMinorVersionNumber).CurrentMinorVersionNumber
$WinVer | Add-Member –MemberType NoteProperty –Name Build –Value $(Get-ItemProperty -Path 'Registry::HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion' CurrentBuild).CurrentBuild
$WinVer | Add-Member –MemberType NoteProperty –Name Revision –Value $(Get-ItemProperty -Path 'Registry::HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion' UBR).UBR
$WinVer

Mit Windows Powershell können Sie die benötigten Daten auf folgende Weise abrufen

Bildbeschriftung:

(Get-WmiObject -class Win32_OperatingSystem).Caption

ReleaseId:

(Get-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion" -Name ReleaseId).ReleaseId

Ausführung:

(Get-CimInstance Win32_OperatingSystem).version

[gelöst]

#copy all the code below:
#save file as .ps1 run and see the magic

 Get-WmiObject -Class Win32_OperatingSystem | ForEach-Object -MemberName Caption
 (Get-CimInstance Win32_OperatingSystem).version


#-------------comment-------------#
#-----finding windows version-----#

$version= (Get-CimInstance Win32_OperatingSystem).version
$length= $version.Length
$index= $version.IndexOf(".")
[int]$windows= $version.Remove($index,$length-2)  
$windows
#-----------end------------------#
#-----------comment-----------------#

Sie können auch so etwas verwenden, indem Sie OSVersion.Version.Major überprüfen:

IF ([System.Environment]::OSVersion.Version.Major -ge 10) {Write-Host "Windows 10 or above"}
IF ([System.Environment]::OSVersion.Version.Major -lt 10) {Write-Host "Windows 8.1 or below"}

Sie können Python verwenden, um die Dinge zu vereinfachen (funktioniert auf allen Windows-Versionen und allen anderen Plattformen):

import platform

print(platform.system()) # returns 'Windows', 'Linux' etc.
print(platform.release()) # returns for Windows 10 or Server 2019 '10'

if platform.system() = 'Windows':
    print(platform.win32_ver()) # returns (10, 10.0.17744, SP0, Multiprocessor Free) on windows server 2019

$OSVersion = [Version](Get-ItemProperty -Path "$($Env:Windir)\System32\hal.dll" -ErrorAction SilentlyContinue).VersionInfo.FileVersion.Split()[0]

Unter Windows 10 wird Folgendes zurückgegeben: 10.0.10586.420

Sie können dann die Variable verwenden, um auf Eigenschaften für einen detaillierten Vergleich zuzugreifen

$OSVersion.Major equals 10
$OSVersion.Minor equals 0
$OSVersion.Build equals 10586
$OSVersion.Revision equals 420

Darüber hinaus können Sie Betriebssystemversionen wie folgt vergleichen

If ([Version]$OSVersion -ge [Version]"6.1")
   {
       #Do Something
   }