Comment trouver la version de Windows à partir de la ligne de commande PowerShell

Comment trouver la version de Windows que j'utilise?

J'utilise PowerShell 2.0 et j'ai essayé:

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

Comment puis-je faire cela?

Puisque vous avez accès à la bibliothèque .NET, vous pouvez accéder à la OSVersionpropriété de la System.Environmentclasse pour obtenir ces informations. Pour le numéro de version, il y a la Versionpropriété.

Par exemple,

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

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

Les détails des versions de Windows peuvent être trouvés ici .

1. Pour obtenir le numéro de version de Windows, comme Jeff le note dans sa réponse , utilisez:

   [Environment]::OSVersion

   Il est à noter que le résultat est de type [System.Version], il est donc possible de vérifier, par exemple, Windows 7 / Windows Server 2008 R2 et versions ultérieures avec

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

   Cependant cela ne vous dira pas s'il s'agit de Windows client ou serveur, ni le nom de la version.

2. Utilisez la Win32_OperatingSystemclasse de WMI (toujours une seule instance), par exemple:

   (Get-WmiObject -class Win32_OperatingSystem).Caption

   retournera quelque chose comme

   Microsoft® Windows Server® 2008 Standard

Malheureusement, la plupart des autres réponses ne fournissent pas d'informations spécifiques à Windows 10.

Windows 10 a des versions de son propre: 1507, 1511, 1607, 1703, etc . C'est ce que winvermontre.

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

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

Voir également la question relative au superutilisateur .

Comme pour les autres versions de Windows, utilisez systeminfo. Emballage Powershell:

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]:...

Sortie Windows 10 pour la même commande:

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

Ou golfé

gwmi win32_operatingsystem | % caption

Résultat

Microsoft Windows 7 Ultimate

Cela vous donnera la version complète de Windows (y compris le numéro de révision / build) contrairement à toutes les solutions ci-dessus:

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

Résultat:

10.0.10240.16392 (th1_st1.150716-1608)

Get-ComputerInfo | select WindowsProductName, WindowsVersion, OsHardwareAbstractionLayer

Retour

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

Depuis PowerShell 5:

Get-ComputerInfo
Get-ComputerInfo -Property Windows*

Je pense que cette commande essaie à peu près les 1001 façons différentes découvertes jusqu'à présent pour collecter des informations système ...

Si vous souhaitez faire la différence entre Windows 8.1 (6.3.9600) et Windows 8 (6.2.9200), utilisez

(Get-CimInstance Win32_OperatingSystem).Version 

pour obtenir la bonne version. [Environment]::OSVersionne fonctionne pas correctement sous Windows 8.1 (il renvoie une version de Windows 8).

J'affine une des réponses

J'ai atteint cette question en essayant de faire correspondre la sortie de winver.exe:

Version 1607 (OS Build 14393.351)

J'ai pu extraire la chaîne de construction avec:

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

Résultat: 14393.351

Mise à jour : voici un script légèrement simplifié utilisant regex

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

J'ai pris les scripts ci-dessus et les ai légèrement modifiés pour arriver à ceci:

$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

Pour obtenir un résultat comme celui-ci:

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

Astuce: j'apprécierais une main dépouillant le texte du préfixe de la date d'installation afin que je puisse le remplacer par un en-tête plus lisible.

Comme le dit MoonStom, [Environment]::OSVersionne fonctionne pas correctement sur un Windows 8.1 mis à niveau (il renvoie une version de Windows 8): lien .

Si vous souhaitez faire la différence entre Windows 8.1 (6.3.9600) et Windows 8 (6.2.9200), vous pouvez utiliser (Get-CimInstance Win32_OperatingSystem).Versionpour obtenir la version appropriée. Cependant, cela ne fonctionne pas dans PowerShell 2. Utilisez donc ceci:

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

Utilisation:

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

Si vous essayez de déchiffrer les informations que MS met sur leur site de correctifs tel que https://technet.microsoft.com/en-us/library/security/ms17-010.aspx

vous aurez besoin d'un combo tel que:

$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 Famille 64 bits 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
}

Pour l'affichage (les deux versions):

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

Pour produire une sortie identique à winver.exe dans PowerShell v5 sous 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

C'est vraiment un long fil, et probablement parce que les réponses, bien que correctes, ne résolvent pas la question fondamentale. Je suis tombé sur ce site: numéros de version et de build qui ont fourni un aperçu clair de ce qui est quoi dans le monde de Microsoft Windows.

Étant donné que mon intérêt est de savoir avec quel système d'exploitation Windows je m'occupe, j'ai laissé de côté la version entière de l'arc-en-ciel et je me suis plutôt concentré sur le BuildNumber. Le numéro de build peut être atteint soit par:

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

ou par:

(Get-CimInstance Win32_OperatingSystem).buildNumber

le choix vous appartient, quelle que soit la manière dont vous le préférez. Donc, à partir de là, je pourrais faire quelque chose du genre:

    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

Remarque: comme vous pouvez le voir, j'ai utilisé ce qui précède uniquement pour les systèmes de serveur, mais il pourrait facilement être appliqué aux postes de travail ou même intelligemment étendu pour prendre en charge les deux ... mais je vous laisse cela.

Profitez et amusez-vous!

Cela vous donnera la version complète et CORRECT (le même numéro de version que vous trouvez lorsque vous exécutez winver.exe) de Windows (y compris le numéro de révision / build) À DISTANCE contrairement à toutes les autres solutions (testées sur 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"
    }
}

J'ai beaucoup cherché pour trouver la version exacte, car le serveur WSUS affiche la mauvaise version. Le mieux est d'obtenir la révision de la clé de registre UBR.

    $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

En utilisant Windows Powershell, il est possible d'obtenir les données dont vous avez besoin de la manière suivante

Légende:

(Get-WmiObject -class Win32_OperatingSystem).Caption

ReleaseId:

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

version:

(Get-CimInstance Win32_OperatingSystem).version

[résolu]

#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-----------------#

Vous pouvez également utiliser quelque chose comme ça, en vérifiant OSVersion.Version.Major:

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"}

Vous pouvez utiliser python, pour simplifier les choses (fonctionne sur toutes les versions de Windows et toutes les autres plates-formes):

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]

Sur Windows 10 renvoie: 10.0.10586.420

Vous pouvez ensuite utiliser la variable pour accéder aux propriétés pour une comparaison granulaire

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

En outre, vous pouvez comparer les versions du système d'exploitation à l'aide des éléments suivants

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