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

133

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?

jrara
la source
4
Si vous consultez ceci en 2019+, ignorez la réponse marquée comme correcte et passez directement à celle qui est correcte . De rien.
BrainSlugs83

Réponses:

186

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 .

Jeff Mercado
la source
4
Notez que [Environment]::OSVersionfonctionne dans Windows-10 , OSVersion.Version.Majorrenvoie 10.
yzorg
4
Quand je l'exécute, winveril me montre la version 1607. Mais la commande PowerShell ci-dessus ne donne pas 1607. Où puis-je obtenir ce numéro "1607" dans Powershell?
CMCDragonkai
6
@CMCDragonkai(Get-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion" -Name ReleaseId).ReleaseId
Anton Krouglov
3
Cette méthode est obsolète à partir de Windows 8.1. Voir ce lien pour plus de détails.
Slogmeister Extraordinaire
1
@SlogmeisterExtraordinaire La commande [System.Environment]::OSVersionn'est pas obsolète, la méthode qu'elle utilise en arrière-plan est obsolète. Les nouvelles versions PS modifient le comportement du backend: github.com/PowerShell/PowerShell/issues
Randy
109
  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

Richard
la source
61

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
Anton Krouglov
la source
3
C'est facile à retenir winversur le bureau et systeminfo sur le serveur. Cela m'a déconcerté pendant des années qu'il n'y ait pas de moyen uniforme d'obtenir ces informations.
MortenB
2
Excellents liens vers des informations MS réellement utiles. Il convient de noter que pour Win8.1 (et au- dessous?) L'info est montré: OS Version : 6.3.9600 N/A Build 9600. Ainsi, dans les versions inférieures à W81, il peut être plus instructif de regarder les versions LTSB (toujours négligées). Voir sortie: ce (Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion").BuildLabExqui peut ressembler à : 9600.19179.amd64fre.winblue_ltsb_escrow.181015-1847. Je suppose que la 181015partie est la date de construction, alors que la version 1847est de construction ou de publication. Vous devrez peut-être également comparer cela à kernel, hal .
not2qubit
26
Get-WmiObject -Class Win32_OperatingSystem | ForEach-Object -MemberName Caption

Ou golfé

gwmi win32_operatingsystem | % caption

Résultat

Microsoft Windows 7 Ultimate
Steven Penny
la source
4
Il est recommandé d'utiliser Get-CimInstance au lieu de Get-WmiObject dans le nouveau code.
Der_Meister
2
@Der_Meister Ce n'est vrai que pour PSv3 +
Maximilian Burszley
20

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)
Ihor Zenich
la source
5
C'est la meilleure solution en ce qui me concerne car elle indique correctement le numéro de révision. Aucun des autres ne l'est (du moins comme je les ai testés).
BStateham le
6
C'est la seule solution à ce jour qui m'a permis d'obtenir le numéro de version complet. Cependant , tous les fichiers de system32 ne sont pas mis à jour à chaque mise à jour - par exemple, mon hal.dll s'affiche toujours 10.0.10586.0 (th2_release.151029-1700), tandis que winload.exe l'a 10.0.10586.63 (th2_release.160104-1513).
melak47
2
Voici un petit script qui obtient la version de la dll / exe avec la date de construction la plus élevée: gist
melak47
6
Cela repose sur un détail d'implémentation du côté de Microsoft, ce qu'il n'y a aucune garantie qu'ils continueront à le faire. Cela fonctionne maintenant mais vous devriez éviter de vous fier à cela si vous voulez que votre script fonctionne à long terme.
Nick
1
@Jaykul Eh bien, je ne suis pas d'accord, pour 2 raisons. (1) parce que ces nombres semblables à "1803" ne sont pas toujours disponibles (par exemple sur Win8), que faut-il donc utiliser? (2) Il n'y a aucune raison technique pour qu'il n'y en ait qu'une seule correcte version. Le système d'exploitation est construit (et mis à jour) par parties, c'est-à-dire le noyau, la HAL, l'UBR et les fonctionnalités, etc. Donc, nous devrions vraiment les afficher toutes. À cet égard, je pense BuildLabEx, Kernelet HAL(dans cet ordre) serait le moyen le plus approprié de donner une version plus appropriée . Mais puisque vous semblez savoir ce qui ne va pas , vous devez publier ce qui est juste .
not2qubit
18
Get-ComputerInfo | select WindowsProductName, WindowsVersion, OsHardwareAbstractionLayer

Retour

WindowsProductName    WindowsVersion OsHardwareAbstractionLayer
------------------    -------------- --------------------------
Windows 10 Enterprise 1709           10.0.16299.371 
Lars Fosdal
la source
@ not2qubit Vraiment? Environ 1 seconde sur mon Surface Book 2.
Eric Herlitz
14

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

Schadowy
la source
Une partie de la réponse que j'en ai obtenue est étrange ... Je suis sous Windows 10 1909, mais "WindowsCurrentVersion" est 6.3. Je pense que ce serait 10, car 6.3 est Windows 8.1. Sinon, j'aime les informations fournies par cette commande
Randy
8

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).

MoonStom
la source
Notez que cela [Environment]::OSVersionfonctionne dans Windows-10 , OSVersion.Version.Majorrenvoie 10.
yzorg
1
Les deux (Get-CimInstance Win32_OperatingSystem).Versionet [Environment]::OSVersionœuvres pour moi et le même résultat: 6.3.9600.0
VirtualVDX
malheureusement 6.3.9600 n'est pas seulement Win 8.1, le serveur 2012 R2 renvoie également ce même numéro de build.
bytejunkie
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 }
Tarifs
la source
5

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.

Ron MVP
la source
La commande de date d'installation prend un certain temps à s'exécuter, alors j'en ai trouvé une plus rapide: [timezone]::CurrentTimeZone.ToLocalTime(([datetime]'1/1/1970')).AddSeconds($(get-itemproperty "HKLM:\Software\Microsoft\Windows NT\CurrentVersion").InstallDate) elle est un peu plus complexe, mais elle s'exécute beaucoup plus rapidement. Vous pourrez peut-être même omettre la partie du fuseau horaire:([datetime]'1/1/1970').AddSeconds($(get-itemproperty "HKLM:\Software\Microsoft\Windows NT\CurrentVersion").InstallDate)
Randy
4

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}
}
mhu
la source
4

Utilisation:

Get-WmiObject -class win32_operatingsystem -computer computername | Select-Object Caption
Mac
la source
Peut également obtenir le numéro de version en utilisant ceci: Get-WmiObject -class win32_operatingsystem | sélectionnez Version
KERR
Vous pouvez améliorer cette réponse en affichant la sortie.
james.garriss
4

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

Michael Joyce
la source
2

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 
Vince Ypma
la source
2

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))"
James Russell
la source
En outre, il correspond à la version dans "Paramètres> Système> À propos de" dans Windows 10. Et obtient la mise à jour de la révision de la version correcte, ce que beaucoup de solutions ne font pas sur ma machine 👍
Vimes
1
(Get-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion" -Name BuildLabEx).BuildLabEx
Tester
la source
1

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!

Porky
la source
0

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"
    }
}
PowerShellGirl
la source
J'ai eu une erreur en exécutant cela avec 'localhost' et en utilisant le nom réel de l'ordinateur (tel que renvoyé par 'hostname') sur mon hôte local - est-il possible de modifier cette solution pour lui permettre d'obtenir les informations d'une machine locale sans activer les services, etc.?
monojohnny
[xxxxxx] La connexion au serveur distant xxxxxx a échoué avec le message d'erreur suivant: Le client ne peut pas se connecter à la destination spécifiée dans la demande. Vérifiez que le service sur la destination est en cours d'exécution et accepte les demandes. Consultez les journaux et la documentation du service WS-Management exécuté sur la destination, le plus souvent IIS ou WinRM. Si la destination est le service WinRM, exécutez la commande suivante sur la destination pour analyser et configurer le service WinRM: "winrm quickconfig". Pour plus d'informations, [...]
monojohnny
A travaillé pour moi. Vote positif. Ce serait un script parfait s'il incluait l'ID de version de Windows 10 - 1507, 1511, 1607 etc.
Anton Krouglov
0

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
Ali
la source
0

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
Dan Steve
la source
0

[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-----------------#
Premier Nobel
la source
Bienvenue à SO! Lorsque vous répondez à une question, essayez d'expliquer un peu. Dans ce cas, il y a 20 autres réponses, alors pensez à exposer vos avantages.
David García Bodego
0

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"}
KERR
la source
-2

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
Ruben Kelevra
la source
La question est "Comment trouver la version Windows à partir de la ligne de commande PowerShell ". Ce n'est pas vraiment une réponse à cette question et vous devriez envisager de la supprimer.
Alain O'Dea
-3
$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
   }
GraceSolutions
la source