Come trovare la versione di Windows dalla riga di comando di PowerShell


133

Come trovo quale versione di Windows sto usando?

Sto usando PowerShell 2.0 e ho provato:

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

Come faccio a fare questo?


4
Se stai vedendo questo in 2019+, ignorare la risposta che è contrassegnata come corretta e andare direttamente al quello che è corretto . Prego.
BrainSlugs83

Risposte:


186

Dato che hai accesso alla libreria .NET, puoi ottenere la OSVersionproprietà della System.Environmentclasse per ottenere queste informazioni. Per il numero di versione, c'è la Versionproprietà.

Per esempio,

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

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

I dettagli delle versioni di Windows sono disponibili qui .


4
Nota che [Environment]::OSVersionfunziona in windows-10 , OSVersion.Version.Majorrestituisce 10.
yzorg

4
Quando winvereseguo mi mostra la versione 1607. Ma il comando powershell sopra non fornisce 1607. Dove posso trovare questo numero "1607" in Powershell?
CMCDragonkai,

6
@CMCDragonkai(Get-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion" -Name ReleaseId).ReleaseId
Anton Krouglov,

3
Questo metodo è stato deprecato a partire da Windows 8.1. Vedi questo link per i dettagli.
Slogmeister Extraordinaire,

1
@SlogmeisterExtraordinaire Il comando [System.Environment]::OSVersionnon è stato deprecato, il metodo utilizzato in background è stato deprecato. Le nuove versioni di PS stanno cambiando il comportamento del backend: github.com/PowerShell/PowerShell/issues/…
Randy

109
  1. Per ottenere il numero di versione di Windows, come osserva Jeff nella sua risposta , utilizzare:

    [Environment]::OSVersion

    Vale la pena notare che il risultato è di tipo [System.Version], quindi è possibile verificare, ad esempio, Windows 7 / Windows Server 2008 R2 e versioni successive con

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

    Tuttavia, questo non ti dirà se si tratta di Windows client o server, né il nome della versione.

  2. Utilizzare la Win32_OperatingSystemclasse WMI (sempre singola istanza), ad esempio:

    (Get-WmiObject -class Win32_OperatingSystem).Caption

    restituirà qualcosa di simile

    Microsoft® Windows Server® 2008 Standard


61

Sfortunatamente la maggior parte delle altre risposte non fornisce informazioni specifiche per Windows 10.

Windows 10 ha versioni proprie: 1507, 1511, 1607, 1703, ecc . Questo è ciò che winvermostra.

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

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

Vedi anche la domanda relativa al superutente .

Come per le altre versioni di Windows utilizzare systeminfo. Wrapper 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]:...

Output di Windows 10 per lo stesso comando:

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

3
Questo è facile da ricordare winversul desktop e systeminfo sul server. Mi ha sconcertato per anni che non esiste un modo uniforme per ottenere queste informazioni.
MortenB,

2
Ottimi collegamenti alle informazioni MS che sono effettivamente utili. Va notato che, per Win8.1 (e sotto?) Informazioni mostrata è: OS Version : 6.3.9600 N/A Build 9600. Pertanto, nelle versioni inferiori a W81, potrebbe essere più informativo guardare le versioni (sempre trascurate) di LTSB. Vedere uscita dal: (Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion").BuildLabExche possono apparire come: 9600.19179.amd64fre.winblue_ltsb_escrow.181015-1847. La mia ipotesi è che la 181015parte è la data di compilazione, mentre 1847è la versione build o release. Potrebbe anche essere necessario confrontare questo con il kernel, hal .
not2qubit,

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

O golf

gwmi win32_operatingsystem | % caption

Risultato

Microsoft Windows 7 Ultimate

4
Si consiglia di utilizzare Get-CimInstance invece di Get-WmiObject nel nuovo codice.
Der_Meister,

2
@Der_Meister Questo è vero solo per PSv3 +
Maximilian Burszley

20

Questo ti darà la versione completa di Windows (incluso il numero di revisione / build) a differenza di tutte le soluzioni sopra:

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

Risultato:

10.0.10240.16392 (th1_st1.150716-1608)

5
Questa è la soluzione migliore per quanto mi riguarda in quanto riporta correttamente il numero di revisione. Nessuno degli altri lo è (almeno come li ho testati).
BStateham,

6
Questa è l'unica soluzione finora che mi ha permesso di ottenere il numero di build completo. Tuttavia , non tutti i file in system32 vengono aggiornati con ogni aggiornamento, ad esempio il mio hal.dll mostra ancora 10.0.10586.0 (th2_release.151029-1700), mentre winload.exe ha 10.0.10586.63 (th2_release.160104-1513).
melak47,

2
Ecco un piccolo script che ottiene la versione dalla dll / exe con la data di costruzione più alta: gist
melak47

6
Ciò si basa su un dettaglio dell'implementazione da parte di Microsoft che non è garantito che continueranno a fare. Funziona ora ma dovresti evitare di fare affidamento su questo se vuoi che lo script funzioni a lungo termine.
Nick,

1
@Jaykul Beh, non sono d'accordo, per 2 motivi. (1) perché quei numeri simili a "1803" non sono sempre disponibili (ad esempio su Win8), quindi cosa dovrebbe essere usato lì? (2) Non vi è alcun motivo tecnico per cui ci dovrebbe essere solo uno corretto version. Il sistema operativo è costruito (e aggiornato) da parti, ad esempio Kernel, HAL, UBR, e le funzionalità ecc. Quindi dovremmo davvero visualizzarle tutte. A tale proposito BuildLabEx, penso , Kernele HAL(in questo ordine) sarebbe il modo più appropriato per fornire una versione più corretta . Ma poiché sembri sapere cosa è sbagliato , dovresti pubblicare ciò che è giusto .
not2qubit,

18
Get-ComputerInfo | select WindowsProductName, WindowsVersion, OsHardwareAbstractionLayer

ritorna

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

@ not2qubit Davvero? Circa 1 secondo sul mio Surface Book 2.
Eric Herlitz,

14

Da PowerShell 5:

Get-ComputerInfo
Get-ComputerInfo -Property Windows*

Penso che questo comando provi praticamente i 1001 modi diversi finora scoperti per raccogliere informazioni sul sistema ...


Parte della risposta che ho avuto da questo è strano ... Sono su Windows 10 1909, ma "WindowsCurrentVersion" è 6.3. Penserei che sarebbe 10, come 6.3 è Windows 8.1. Altrimenti, mi piacciono le informazioni fornite da questo comando
Randy,

8

Se si desidera distinguere tra Windows 8.1 (6.3.9600) e Windows 8 (6.2.9200) utilizzare

(Get-CimInstance Win32_OperatingSystem).Version 

per ottenere la versione corretta. [Environment]::OSVersionnon funziona correttamente in Windows 8.1 (restituisce una versione di Windows 8).


Nota che [Environment]::OSVersionfunziona in windows-10 , OSVersion.Version.Majorrestituisce 10.
yzorg

1
Entrambi (Get-CimInstance Win32_OperatingSystem).Versione [Environment]::OSVersionfunziona per me e restituiscono lo stesso risultato: 6.3.9600.0
VirtualVDX

sfortunatamente il 6.3.9600 non è solo Win 8.1, anche il server 2012 R2 restituisce lo stesso numero di build.
bytejunkie,

8

Sto perfezionando uno dei risposte

Ho raggiunto questa domanda durante il tentativo di abbinare l'output di winver.exe:

Version 1607 (OS Build 14393.351)

Sono stato in grado di estrarre la stringa di build con:

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

Risultato: 14393.351

Aggiornato : ecco uno script leggermente semplificato usando regex

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

5

Ho preso gli script sopra e li ho modificati un po 'per trovare questo:

$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

Per ottenere un risultato come questo:

Versione a 64 bit di Microsoft Windows 10 Home: 1709 Build: 16299.431 @ {WindowsInstallDateFromRegistry = 18-01-01 2:29:11 AM}

Suggerimento: apprezzerei una mano che toglie il testo del prefisso dalla data di installazione in modo da poterlo sostituire con un'intestazione più leggibile.


Il comando install date richiede un po 'di tempo per essere eseguito, quindi ne ho trovato uno più veloce: [timezone]::CurrentTimeZone.ToLocalTime(([datetime]'1/1/1970')).AddSeconds($(get-itemproperty "HKLM:\Software\Microsoft\Windows NT\CurrentVersion").InstallDate) è un po' più complesso, ma funziona molto più velocemente. Potresti anche essere in grado di tralasciare la parte del fuso orario:([datetime]'1/1/1970').AddSeconds($(get-itemproperty "HKLM:\Software\Microsoft\Windows NT\CurrentVersion").InstallDate)
Randy,

4

Come dice MoonStom, [Environment]::OSVersionnon funziona correttamente su Windows 8.1 aggiornato (restituisce una versione di Windows 8): link .

Se si desidera distinguere tra Windows 8.1 (6.3.9600) e Windows 8 (6.2.9200), è possibile utilizzare (Get-CimInstance Win32_OperatingSystem).Versionper ottenere la versione corretta. Tuttavia, questo non funziona in PowerShell 2. Quindi usa questo:

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

4

Uso:

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

Puoi anche ottenere il numero di versione usando questo: Get-WmiObject -class win32_operatingsystem | seleziona Versione
KERR

È possibile migliorare questa risposta mostrando l'output.
james.garriss

4

Se si sta tentando di decifrare le informazioni che MS inserisce nel proprio sito di patching come https://technet.microsoft.com/en-us/library/security/ms17-010.aspx

avrai bisogno di una combo come:

$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


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
}

Per la visualizzazione (entrambe le versioni):

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

2

Per produrre un output identico a winver.exe in PowerShell v5 su Windows 10 1809:

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

Inoltre corrisponde alla versione in "Impostazioni> Sistema> Informazioni su" in Windows 10. E ottiene l'aggiornamento Build Revision giusto, che molte delle soluzioni non hanno sulla mia macchina 👍
Vimes

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

1

Questo è davvero un filo lungo, e probabilmente perché le risposte seppur corrette non stanno risolvendo la domanda fondamentale. Mi sono imbattuto in questo sito: versione e numeri di build che hanno fornito una chiara panoramica di ciò che è nel mondo di Microsoft Windows.

Poiché il mio interesse è sapere con quale esatto sistema operativo Windows mi occupo, ho lasciato da parte l'intera versione arcobaleno e invece mi sono concentrato su BuildNumber. Il numero di build può essere ottenuto tramite:

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

o da:

(Get-CimInstance Win32_OperatingSystem).buildNumber

a te la scelta in qualunque modo preferisci. Quindi da lì ho potuto fare qualcosa del genere:

    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

Nota: Come puoi vedere, ho usato quanto sopra solo per i sistemi server, tuttavia potrebbe essere facilmente applicato a workstation o anche abilmente esteso per supportare entrambi ... ma lo lascerò a te.

Divertiti e divertiti!


0

Questo ti fornirà la versione completa e CORRETTA (lo stesso numero di versione che trovi quando esegui winver.exe) di Windows (incluso il numero di revisione / build) A differenza di tutte le altre soluzioni (testato su 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"
    }
}

Ho riscontrato un errore durante l'esecuzione di questo comando con "localhost" e l'utilizzo del nome effettivo del computer (come restituito da "hostname") sul mio localhost - è possibile modificare questa soluzione per consentirgli di ottenere le informazioni da un computer locale senza abilitare i servizi ecc.?
monojohnny,

[xxxxxx] Connessione al server remoto xxxxxx non riuscita con il seguente messaggio di errore: Il client non può connettersi alla destinazione specificata nella richiesta. Verificare che il servizio sulla destinazione sia in esecuzione e accetti le richieste. Consultare i registri e la documentazione per il servizio WS-Management in esecuzione sulla destinazione, più comunemente IIS o WinRM. Se la destinazione è il servizio WinRM, eseguire il comando seguente sulla destinazione per analizzare e configurare il servizio WinRM: "winrm quickconfig". Per ulteriori informazioni, [...]
monojohnny

Ha funzionato per me. Upvoted. Sarebbe uno script perfetto se includesse l'id di rilascio di Windows 10 - 1507, 1511, 1607 ecc.
Anton Krouglov,

0

Ho cercato molto per scoprire la versione esatta, perché il server WSUS mostra la versione sbagliata. La cosa migliore è ottenere la revisione dal KEY del registro 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

0

Utilizzando Windows Powershell, è possibile ottenere i dati necessari nel modo seguente

Didascalia:

(Get-WmiObject -class Win32_OperatingSystem).Caption

ReleaseId:

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

versione:

(Get-CimInstance Win32_OperatingSystem).version

0

[Risolto]

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

Benvenuti in SO! Quando rispondi a una domanda, prova a spiegare un po '. In questo caso, ci sono altre 20 risposte, quindi considera di esporre i tuoi pro.
David García Bodego,

0

Puoi anche usare qualcosa di simile, controllando 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"}

-2

Puoi usare Python per semplificare le cose (funziona su tutte le versioni di Windows e su tutte le altre piattaforme):

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

La domanda è "Come trovare la versione di Windows dalla riga di comando di PowerShell ". Questa non è davvero una risposta a quella domanda e dovresti considerare di eliminarla.
Alain O'Dea,

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

Su Windows 10 ritorna: 10.0.10586.420

È quindi possibile utilizzare la variabile per accedere alle proprietà per il confronto granulare

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

Inoltre, è possibile confrontare le versioni del sistema operativo utilizzando quanto segue

If ([Version]$OSVersion -ge [Version]"6.1")
   {
       #Do Something
   }
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.