Cómo encontrar la versión de Windows desde la línea de comandos de PowerShell


133

¿Cómo encuentro qué versión de Windows estoy usando?

Estoy usando PowerShell 2.0 y probé:

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

¿Cómo hago esto?


44
Si está viendo esto en 2019+, ignorar la respuesta que está marcada como correcta e ir directamente a la que es correcta . De nada.
BrainSlugs83

Respuestas:


186

Como tiene acceso a la biblioteca .NET, puede acceder a la OSVersionpropiedad de la System.Environmentclase para obtener esta información. Para el número de versión, existe la Versionpropiedad.

Por ejemplo,

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

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

Los detalles de las versiones de Windows se pueden encontrar aquí .


44
Tenga [Environment]::OSVersionen cuenta que funciona en windows-10 , OSVersion.Version.Majordevuelve 10.
yzorg

44
Cuando ejecuto winverme muestra la versión 1607. Pero el comando de PowerShell anterior no da 1607. ¿Dónde obtengo este número "1607" en Powershell?
CMCDragonkai

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

3
Este método quedó en desuso a partir de Windows 8.1. Vea este enlace para más detalles.
Slogmeister Extraordinaire

1
@SlogmeisterExtraordinaire El comando [System.Environment]::OSVersionno ha quedado en desuso, el método que utiliza en segundo plano ha quedado en desuso. Las nuevas versiones de PS están cambiando el comportamiento del backend: github.com/PowerShell/PowerShell/issues/…
Randy

109
  1. Para obtener el número de versión de Windows, como Jeff señala en su respuesta , use:

    [Environment]::OSVersion

    Vale la pena señalar que el resultado es de tipo [System.Version], por lo que es posible verificar, por ejemplo, Windows 7 / Windows Server 2008 R2 y posterior con

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

    Sin embargo, esto no le dirá si es cliente o servidor de Windows, ni el nombre de la versión.

  2. Utilice la Win32_OperatingSystemclase de WMI (siempre instancia única), por ejemplo:

    (Get-WmiObject -class Win32_OperatingSystem).Caption

    devolverá algo como

    Microsoft® Windows Server® 2008 Standard


61

Lamentablemente, la mayoría de las otras respuestas no proporcionan información específica de Windows 10.

Windows 10 tiene versiones de su propia: 1507, 1511, 1607, 1703, etc . Esto es lo que winvermuestra.

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 también la pregunta relacionada sobre superusuario .

En cuanto al uso de otras versiones de Windows systeminfo. Envoltura 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]:...

Salida de Windows 10 para el mismo 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
Esto es fácil de recordar winveren el escritorio y systeminfo en el servidor. Me ha desconcertado durante años que no hay una manera uniforme de obtener esta información.
MortenB

2
Grandes enlaces a la información de MS que es realmente útil. Cabe señalar que para Win8.1 (y por debajo?) La información que se muestra es: OS Version : 6.3.9600 N/A Build 9600. Entonces, en las versiones debajo de W81, puede ser más informativo mirar las versiones (siempre pasadas por alto) de LTSB. Ver salida de:(Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion").BuildLabEx lo que puede verse como: 9600.19179.amd64fre.winblue_ltsb_escrow.181015-1847. Mi conjetura es que la 181015parte es la fecha de creación, mientras que el 1847es la acumulación o la liberación de la versión. También es posible que deba comparar esto con el núcleo, hal .
not2qubit

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

O golf

gwmi win32_operatingsystem | % caption

Resultado

Microsoft Windows 7 Ultimate

44
Se recomienda usar Get-CimInstance en lugar de Get-WmiObject en el nuevo código.
Der_Meister

2
@Der_Meister Eso solo es cierto para PSv3 +
Maximilian Burszley

20

Esto te dará el versión completa de Windows (incluido el número de revisión / compilación) a diferencia de todas las soluciones anteriores:

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

Resultado:

10.0.10240.16392 (th1_st1.150716-1608)

55
En lo que a mí respecta, esta es la mejor solución, ya que informa el número de revisión correctamente. Ninguno de los otros es (al menos como los he probado).
BStateham

66
Esta es la única solución hasta ahora que me ha permitido obtener el número de compilación completo. Sin embargo , no todos los archivos en system32 se actualizan con cada actualización; por ejemplo, mi hal.dll todavía se muestra 10.0.10586.0 (th2_release.151029-1700), mientras que winload.exe sí 10.0.10586.63 (th2_release.160104-1513).
melak47

2
Aquí hay un guión poco que obtiene la versión de la dll / exe con la fecha más alto de construcción: GIST
melak47

66
Esto se basa en un detalle de implementación por parte de Microsoft que no hay garantía de que continúen haciendo. Funciona ahora, pero debe evitar confiar en esto si desea que su script funcione a largo plazo.
Nick

1
@ Jaykul Bueno, no estoy de acuerdo, por 2 razones. (1) porque esos números como "1803" no siempre están disponibles (por ejemplo, en Win8), entonces, ¿qué se debe usar allí? (2) No hay una razón técnica por la que debería haber solo una correcta version. El sistema operativo está construido (y actualizado) por partes, es decir, el kernel, el HAL, el UBR y las características, etc. Entonces, realmente deberíamos mostrarlos todos. En ese sentido, creo BuildLabEx, Kernely HAL(en ese orden) sería la forma más adecuada de dar una versión más adecuada . Pero como parece saber lo que está mal , debe publicar lo que está bien .
not2qubit

18
Get-ComputerInfo | select WindowsProductName, WindowsVersion, OsHardwareAbstractionLayer

devoluciones

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

@ not2qubit ¿En serio? Aproximadamente 1 segundo en mi Surface Book 2.
Eric Herlitz

14

Desde PowerShell 5:

Get-ComputerInfo
Get-ComputerInfo -Property Windows*

Creo que este comando intenta las 1001 formas diferentes descubiertas hasta ahora para recopilar información del sistema ...


Parte de la respuesta que obtuve de esto es extraña ... Estoy en Windows 10 1909, pero "WindowsCurrentVersion" es 6.3. Creo que sería 10, ya que 6.3 es Windows 8.1. De lo contrario, me gusta la información proporcionada por este comando
Randy

8

Si desea diferenciar entre Windows 8.1 (6.3.9600) y Windows 8 (6.2.9200) use

(Get-CimInstance Win32_OperatingSystem).Version 

para obtener la versión adecuada. [Environment]::OSVersionno funciona correctamente en Windows 8.1 (devuelve una versión de Windows 8).


Tenga [Environment]::OSVersionen cuenta que funciona en windows-10 , OSVersion.Version.Majordevuelve 10.
yzorg

1
Ambos (Get-CimInstance Win32_OperatingSystem).Versiony [Environment]::OSVersionfunciona para mí y devuelven el mismo resultado: 6.3.9600.0
VirtualVDX

desafortunadamente 6.3.9600 no es solo Win 8.1, el servidor 2012 R2 también devuelve este mismo número de compilación.
bytejunkie

8

Estoy refinando una de las respuestas

Llegué a esta pregunta al intentar hacer coincidir la salida de winver.exe:

Version 1607 (OS Build 14393.351)

Pude extraer la cadena de compilación con:

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

Resultado: 14393.351

Actualizado : Aquí hay un script ligeramente simplificado que usa expresiones regulares

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

5

Tomé las secuencias de comandos anteriores y las modifiqué un poco para llegar a esto:

$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 obtener un resultado como este:

Microsoft Windows 10 Home Versión de 64 bits: 1709 Compilación: 16299.431 @ {WindowsInstallDateFromRegistry = 18-01-01 2:29:11 AM}

Sugerencia: agradecería que elimine el texto del prefijo de la fecha de instalación para poder reemplazarlo con un encabezado más legible.


El comando de fecha de instalación tarda un tiempo en ejecutarse, así que encontré uno más rápido: [timezone]::CurrentTimeZone.ToLocalTime(([datetime]'1/1/1970')).AddSeconds($(get-itemproperty "HKLM:\Software\Microsoft\Windows NT\CurrentVersion").InstallDate) es un poco más complejo, pero se ejecuta mucho más rápido. Incluso podría dejar de lado la zona horaria:([datetime]'1/1/1970').AddSeconds($(get-itemproperty "HKLM:\Software\Microsoft\Windows NT\CurrentVersion").InstallDate)
Randy

4

Como dice MoonStom, [Environment]::OSVersionno funciona correctamente en un Windows 8.1 actualizado (devuelve una versión de Windows 8): enlace .

Si desea diferenciar entre Windows 8.1 (6.3.9600) y Windows 8 (6.2.9200), puede usar (Get-CimInstance Win32_OperatingSystem).Versionpara obtener la versión adecuada. Sin embargo, esto no funciona en PowerShell 2. Así que usa esto:

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

4

Utilizar:

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

También puede obtener el número de versión usando esto: Get-WmiObject -class win32_operatingsystem | seleccione Versión
KERR

Puede mejorar esta respuesta mostrando la salida.
james.garriss

4

Si está tratando de descifrar información, MS coloca su sitio de parcheo como https://technet.microsoft.com/en-us/library/security/ms17-010.aspx

Necesitarás un 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


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 visualización (ambas versiones):

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

2

Para producir una salida idéntica a winver.exe en PowerShell v5 en Windows 10 1809:

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

También coincide con la versión en "Configuración> Sistema> Acerca de" en Windows 10. Y obtiene la Revisión de actualización de compilación correcta, que muchas de las soluciones no tienen en mi máquina 👍
Vimes

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

1

Este es realmente un hilo largo, y probablemente porque las respuestas, aunque correctas, no resuelven la pregunta fundamental. Encontré este sitio: Versión y números de compilación que proporcionaban una descripción clara de qué es qué en el mundo de Microsoft Windows.

Dado que mi interés es saber con qué sistema operativo Windows exacto estoy tratando, dejé a un lado la versión completa del arco iris y en su lugar me concentré en el BuildNumber. El número de compilación puede alcanzarse ya sea por:

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

o por:

(Get-CimInstance Win32_OperatingSystem).buildNumber

la elección es suya de la forma que prefiera. Entonces desde allí podría hacer algo en la línea de:

    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 puede ver, utilicé lo anterior solo para sistemas de servidor, sin embargo, podría aplicarse fácilmente a estaciones de trabajo o incluso ampliarse inteligentemente para admitir ambos ... pero se lo dejo a usted.

¡Disfruta y diviértete!


0

Esto le dará la versión completa y CORRECTA (el mismo número de versión que encuentra cuando ejecuta winver.exe) de Windows (incluido el número de revisión / compilación) REMOTAMENTE a diferencia de todas las otras soluciones (probadas en 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"
    }
}

Recibí un error al ejecutar esto con 'localhost' y usar el nombre real de la computadora (como lo devolvió 'hostname') en mi localhost: ¿es posible ajustar esta solución para permitirle obtener la información de una máquina local sin habilitar servicios, etc.?
monojohnny

[xxxxxx] La conexión al servidor remoto xxxxxx falló con el siguiente mensaje de error: El cliente no puede conectarse al destino especificado en la solicitud. Verifique que el servicio en el destino se esté ejecutando y acepte solicitudes. Consulte los registros y la documentación del servicio WS-Management que se ejecuta en el destino, más comúnmente IIS o WinRM. Si el destino es el servicio WinRM, ejecute el siguiente comando en el destino para analizar y configurar el servicio WinRM: "winrm quickconfig". Para más información, [...]
monojohnny

Trabajó para mi. Votado Sería una secuencia de comandos perfecta si incluyera Windows 10 ID de lanzamiento - 1507, 1511, 1607 etc.
Anton Krouglov

0

Busqué mucho para averiguar la versión exacta, porque el servidor WSUS muestra la versión incorrecta. Lo mejor es obtener una revisión de la clave 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

0

Con Windows Powershell, es posible obtener los datos que necesita de la siguiente manera

Subtítulo:

(Get-WmiObject -class Win32_OperatingSystem).Caption

ReleaseId:

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

versión:

(Get-CimInstance Win32_OperatingSystem).version

0

[resuelto]

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

Bienvenido a SO! Cuando responda una pregunta, intente explicar un poco. En este caso, hay 20 respuestas más, así que considera exponer a los profesionales tuyos.
David García Bodego

0

También puede usar algo como esto, marcando 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

Puede usar python para simplificar las cosas (funciona en todas las versiones de Windows y todas las demás 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

La pregunta es "Cómo encontrar la versión de Windows desde la línea de comandos de PowerShell ". Esta no es realmente una respuesta a esa pregunta y debería considerar eliminarla.
Alain O'Dea

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

En devoluciones de Windows 10: 10.0.10586.420

Luego puede usar la variable para acceder a las propiedades para la comparación granular

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

Además, puede comparar las versiones del sistema operativo utilizando lo siguiente

If ([Version]$OSVersion -ge [Version]"6.1")
   {
       #Do Something
   }
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.