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

¿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?

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

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

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

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

O golf

gwmi win32_operatingsystem | % caption

Resultado

Microsoft Windows 7 Ultimate

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)

Get-ComputerInfo | select WindowsProductName, WindowsVersion, OsHardwareAbstractionLayer

devoluciones

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

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

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

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 }

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.

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

Utilizar:

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

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

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 

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

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

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!

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

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

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

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

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

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

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