Como encontrar a versão do Windows na linha de comando do PowerShell

133

Como encontro a versão do Windows que estou usando?

Estou usando o PowerShell 2.0 e tentei:

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

Como eu faço isso?

jrara
fonte
4
Se você estiver visualizando isso em 2019 ou mais, ignore a resposta que está marcada como correta e vá direto para a que está correta . De nada.
precisa saber é o seguinte

Respostas:

186

Como você tem acesso à biblioteca .NET, você pode acessar a OSVersionpropriedade da System.Environmentclasse para obter essas informações. Para o número da versão, existe a Versionpropriedade

Por exemplo,

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

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

Detalhes das versões do Windows podem ser encontradas aqui .

Jeff Mercado
fonte
4
Note que [Environment]::OSVersionfunciona no windows-10 , OSVersion.Version.Majorretorna 10.
yzorg
4
Quando executo, winverele me mostra a versão 1607. Mas o comando powershell acima não fornece 1607. Onde obtenho esse número "1607" no Powershell?
CMCDragonkai
6
@CMCDragonkai(Get-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion" -Name ReleaseId).ReleaseId
Anton Krouglov
3
Este método foi preterido no Windows 8.1. Veja este link para detalhes.
Slogmeister Extraordinaire 8/08
1
@SlogmeisterExtraordinaire O comando [System.Environment]::OSVersionnão foi preterido, o método que ele usa em segundo plano foi preterido. Novas versões do PS estão alterando o comportamento do back-end: github.com/PowerShell/PowerShell/issues/…
Randy
109
  1. Para obter o número da versão do Windows, como Jeff observa em sua resposta , use:

    [Environment]::OSVersion

    Vale ressaltar que o resultado é do tipo [System.Version]; portanto, é possível verificar, por exemplo, o Windows 7 / Windows Server 2008 R2 e posterior com

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

    No entanto, isso não informará se é o Windows cliente ou servidor, nem o nome da versão.

  2. Use a Win32_OperatingSystemclasse do WMI (sempre única instância), por exemplo:

    (Get-WmiObject -class Win32_OperatingSystem).Caption

    retornará algo como

    Microsoft® Windows Server® 2008 Standard

Richard
fonte
61

Infelizmente, a maioria das outras respostas não fornece informações específicas para o Windows 10.

Windows 10 tem versões de seu próprio: 1507, 1511, 1607, 1703, etc . Isto é o que 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

Consulte também a pergunta relacionada sobre superusuário .

Quanto a outras versões do Windows, use systeminfo. Empacotador 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]:...

Saída do Windows 10 para o mesmo 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
Anton Krouglov
fonte
3
Isso é fácil de lembrar winverna área de trabalho e systeminfo no servidor. Durante anos, fiquei desconcertado por não haver uma maneira uniforme de obter essas informações.
MortenB
2
Ótimos links para informações da Microsoft que são realmente úteis. Note-se que, para Win8.1 (e abaixo?) A informação apresentada é: OS Version : 6.3.9600 N/A Build 9600. Portanto, nas versões abaixo do W81, pode ser mais informativo olhar para as versões (sempre esquecidas) do LTSB. Veja saída: (Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion").BuildLabExo que pode ser parecido com: 9600.19179.amd64fre.winblue_ltsb_escrow.181015-1847. Meu palpite é que a 181015peça é a data de compilação, enquanto a 1847versão é de compilação ou lançamento. Você também pode precisar comparar isso com o kernel, hal .
Not2qubit 11/1118
26
Get-WmiObject -Class Win32_OperatingSystem | ForEach-Object -MemberName Caption

Ou jogou golfe

gwmi win32_operatingsystem | % caption

Resultado

Microsoft Windows 7 Ultimate
Steven Penny
fonte
4
É recomendável usar Get-CimInstance em vez de Get-WmiObject no novo código.
Der_Meister 12/01
2
@Der_Meister Isso é verdade apenas para o PSv3 + #
Maximilian Burszley
20

Isso fornecerá a versão completa do Windows (incluindo o número de revisão / compilação), diferente de todas as soluções acima:

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

Resultado:

10.0.10240.16392 (th1_st1.150716-1608)
Ihor Zenich
fonte
5
Esta é a melhor solução para mim, pois está relatando o número da revisão corretamente. Nenhum dos outros é (pelo menos como eu os testei).
precisa saber é o seguinte
6
Esta é a única solução até agora que me permitiu obter o número completo da compilação. No entanto , nem todos os arquivos no system32 são atualizados a cada atualização - por exemplo, meu hal.dll ainda é 10.0.10586.0 (th2_release.151029-1700)exibido, enquanto o winload.exe possui 10.0.10586.63 (th2_release.160104-1513).
precisa saber é o seguinte
2
Aqui está um pequeno script que obtém a versão da dll / exe com a maior data de construção: essência
melak47
6
Isso depende de um detalhe de implementação do lado da Microsoft, que não há garantia de que eles continuarão a fazer. Ele funciona agora, mas você deve evitar confiar nisso se quiser que seu script funcione a longo prazo.
Nick
1
@ Jaykul Bem, eu não concordo, por 2 razões. (1) porque esses números do tipo "1803" nem sempre estão disponíveis (por exemplo, no Win8), então o que deve ser usado lá? (2) Não há razão técnica para que exista apenas uma correta version. O sistema operacional é construído (e atualizado) por partes, ou seja, o Kernel, o HAL, o UBR e os recursos etc. Então, nós realmente devemos exibir todos eles. A esse respeito, eu acho BuildLabEx, Kernele HAL(nessa ordem) seria a maneira mais apropriada de fornecer uma versão mais apropriada . Mas como você parece saber o que está errado , deve postar o que está certo .
not2qubit
18
Get-ComputerInfo | select WindowsProductName, WindowsVersion, OsHardwareAbstractionLayer

retorna

WindowsProductName    WindowsVersion OsHardwareAbstractionLayer
------------------    -------------- --------------------------
Windows 10 Enterprise 1709           10.0.16299.371 
Lars Fosdal
fonte
@ not2qubit Sério? Cerca de 1 segundo no meu Surface Book 2. #
Eric Herlitz
14

Desde o PowerShell 5:

Get-ComputerInfo
Get-ComputerInfo -Property Windows*

Eu acho que esse comando tenta as 1001 maneiras até agora descobertas para coletar informações do sistema ...

Schadowy
fonte
Parte da resposta que recebi disso é estranha ... Estou no Windows 10 1909, mas "WindowsCurrentVersion" é 6.3. Eu acho que seria 10, pois o 6.3 é o Windows 8.1. Caso contrário, eu gosto das informações fornecidas por este comando
Randy
8

Se você deseja diferenciar o Windows 8.1 (6.3.9600) e o Windows 8 (6.2.9200), use

(Get-CimInstance Win32_OperatingSystem).Version 

para obter a versão correta. [Environment]::OSVersionnão funciona corretamente no Windows 8.1 (retorna uma versão do Windows 8).

MoonStom
fonte
Note que [Environment]::OSVersionfunciona no windows-10 , OSVersion.Version.Majorretorna 10.
yzorg
1
Tanto (Get-CimInstance Win32_OperatingSystem).Versione [Environment]::OSVersionfunciona para mim e retornar o mesmo resultado: 6.3.9600.0
VirtualVDX 25/02/16
infelizmente, o 6.3.9600 não é apenas o Windows 8.1, o servidor 2012 R2 também retorna esse mesmo número de compilação.
Bytejunkie 31/03
8

Estou refinando uma das respostas

Eu cheguei a esta pergunta ao tentar corresponder à saída do winver.exe:

Version 1607 (OS Build 14393.351)

Consegui extrair a string de construção com:

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

Resultado: 14393.351

Atualizado : aqui está um script ligeiramente simplificado usando regex

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

Peguei os scripts acima e os aprimorei um pouco para fazer isso:

$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

Para obter um resultado como este:

Microsoft Windows 10 Home Versão de 64 bits: 1709 Compilação: 16299.431 @ {WindowsInstallDateFromRegistry = 18-01-01 2:29:11 AM}

Dica: eu apreciaria uma mão removendo o texto do prefixo da data de instalação para que eu possa substituí-lo por um cabeçalho mais legível.

Ron MVP
fonte
O comando install date demora um pouco para ser executado, então achei um mais rápido: [timezone]::CurrentTimeZone.ToLocalTime(([datetime]'1/1/1970')).AddSeconds($(get-itemproperty "HKLM:\Software\Microsoft\Windows NT\CurrentVersion").InstallDate) é um pouco mais complexo, mas é muito mais rápido. Você pode até deixar de fora a parte do fuso horário:([datetime]'1/1/1970').AddSeconds($(get-itemproperty "HKLM:\Software\Microsoft\Windows NT\CurrentVersion").InstallDate)
Randy
4

Como o MoonStom diz, [Environment]::OSVersionnão funciona corretamente em um Windows 8.1 atualizado (retorna uma versão do Windows 8): link .

Se você quiser diferenciar entre o Windows 8.1 (6.3.9600) e o Windows 8 (6.2.9200), poderá usar (Get-CimInstance Win32_OperatingSystem).Versionpara obter a versão correta. No entanto, isso não funciona no PowerShell 2. Portanto, use o seguinte:

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

Usar:

Get-WmiObject -class win32_operatingsystem -computer computername | Select-Object Caption
Mac
fonte
Também é possível obter o número da versão usando este: Get-WmiObject -class win32_operatingsystem | select Version
KERR
Você pode melhorar esta resposta mostrando a saída.
james.garriss 7/07
4

Se você estiver tentando decifrar as informações que a Microsoft coloca no site de correções, como https://technet.microsoft.com/en-us/library/security/ms17-010.aspx

você precisará de um combo como:

$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 de 64 bits 1703

Michael Joyce
fonte
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
}

Para exibição (ambas as versões):

"{0}  ({1})" -f $windows.Caption, $windows.Version 
Vince Ypma
fonte
2

Para produzir uma saída idêntica ao winver.exe no PowerShell v5 no Windows 10 1809:

$Version = Get-ItemProperty -Path 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\'
"Version $($Version.ReleaseId) (OS Build $($Version.CurrentBuildNumber).$($Version.UBR))"
James Russell
fonte
Também corresponde à versão em "Configurações> Sistema> Sobre" no Windows 10. E acerta a Revisão da versão de atualização, o que muitas das soluções não fazem na minha máquina 👍
Vimes
1
(Get-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion" -Name BuildLabEx).BuildLabEx
Teste
fonte
1

Este é realmente um tópico longo, e provavelmente porque as respostas, embora corretas, não estão resolvendo a questão fundamental. Encontrei este site: Versão e números de compilação, que forneciam uma visão clara do que é o que no mundo do Microsoft Windows.

Como meu interesse é saber com qual sistema operacional exato do Windows estou lidando, deixei de lado a versão arco-íris inteira e, em vez disso, foquei no BuildNumber. O número da compilação pode ser alcançado por:

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

ou pela:

(Get-CimInstance Win32_OperatingSystem).buildNumber

a escolha é sua, da maneira que você preferir. Então, a partir daí, eu poderia fazer algo como:

    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: Como você pode ver, usei o descrito acima apenas para sistemas de servidor, no entanto, ele pode ser facilmente aplicado a estações de trabalho ou mesmo estendido de maneira inteligente para suportar os dois ... mas deixarei isso para você.

Aproveite e divirta-se!

Porky
fonte
0

Isso fornecerá a versão completa e CORRETA (o mesmo número de versão encontrado ao executar o winver.exe) do Windows (incluindo o número de revisão / compilação) REMOTAMENTE ao contrário de todas as outras soluções (testadas no 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
fonte
Eu recebi um erro ao executar isso com 'localhost' e usar o nome do computador real (retornado por 'hostname') no meu localhost - é possível ajustar esta solução para permitir que ela obtenha as informações de uma máquina local sem habilitar serviços etc?
precisa saber é o seguinte
[xxxxxx] A conexão ao servidor remoto xxxxxx falhou com a seguinte mensagem de erro: O cliente não pode se conectar ao destino especificado na solicitação. Verifique se o serviço no destino está em execução e está aceitando solicitações. Consulte os logs e a documentação do serviço WS-Management em execução no destino, mais comumente IIS ou WinRM. Se o destino for o serviço WinRM, execute o seguinte comando no destino para analisar e configurar o serviço WinRM: "winrm quickconfig". Para mais informações, [...]
monojohnny
Trabalhou para mim. Votado. Isso seria um script perfeito se ele iria incluem janelas 10 ID de lançamento - 1507, 1511, 1607 etc.
Anton Krouglov
0

Pesquisei muito para descobrir a versão exata, porque o servidor WSUS mostra a versão errada. O melhor é obter a revisão da chave de 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
Todos
fonte
0

Usando o Windows Powershell, é possível obter os dados necessários da seguinte maneira

Rubrica:

(Get-WmiObject -class Win32_OperatingSystem).Caption

ReleaseId:

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

versão:

(Get-CimInstance Win32_OperatingSystem).version
Dan Steve
fonte
0

[resolvido]

#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-----------------#
Prime Nobel
fonte
Bem-vindo ao SO! Quando você responder uma pergunta, tente explicar um pouco. Nesse caso, há mais 20 respostas. Considere expor seus profissionais.
David García Bodego 26/10/19
0

Você também pode usar algo assim, verificando 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
fonte
-2

Você pode usar python para simplificar as coisas (funciona em todas as versões do Windows e em todas as outras plataformas):

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
fonte
A pergunta é "Como encontrar a versão do Windows na linha de comando do PowerShell ". Esta não é realmente uma resposta para essa pergunta e você deve excluí-la.
Alain O'Dea
-3
$OSVersion = [Version](Get-ItemProperty -Path "$($Env:Windir)\System32\hal.dll" -ErrorAction SilentlyContinue).VersionInfo.FileVersion.Split()[0]

No Windows 10, retorna: 10.0.10586.420

Você pode usar a variável para acessar propriedades para comparação granular

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

Além disso, você pode comparar as versões do sistema operacional usando o seguinte

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