Detecta si la versión actual de Windows es de 32 bits o 64 bits

Créalo o no, mi instalador es tan viejo que no tiene una opción para detectar la versión de 64 bits de Windows.

¿Hay una llamada a Windows DLL o (incluso mejor) una variable de entorno que daría esa información para Windows XP y Windows Vista?

Una posible solución

Veo que Wikipedia afirma que la versión de 64 bits de Windows XP y Windows Vista tiene una variable de entorno única: %ProgramW6432% , así que supongo que estaría vacía en Windows de 32 bits.

Esta variable apunta al directorio Program Files , que almacena todo el progtwig instalado de Windows y otros. El valor predeterminado en los sistemas en inglés es C:\Program Files . En las ediciones de 64 bits de Windows (XP, 2003, Vista), también hay %ProgramFiles(x86)% que tiene como valor predeterminado C:\Program Files (x86) y %ProgramW6432% cuyo valor predeterminado es C:\Program Files . El %ProgramFiles% sí mismo depende de si el proceso que solicita la variable de entorno es en sí mismo de 32 bits o de 64 bits (esto es causado por la redirección de Windows-en-Windows de 64 bits).

Consulte la secuencia de comandos por lotes que figura en Cómo verificar si la computadora está ejecutando un sistema operativo de 32 o 64 bits . También incluye instrucciones para verificar esto en el Registro:

Puede usar la siguiente ubicación de registro para verificar si la computadora está ejecutando 32 o 64 bit del sistema operativo Windows:

 HKLM\HARDWARE\DESCRIPTION\System\CentralProcessor\0 

Verá las siguientes entradas de registro en el panel derecho:

 Identifier REG_SZ x86 Family 6 Model 14 Stepping 12 Platform ID REG_DWORD 0x00000020(32) 

Los anteriores “x86” y “0x00000020 (32)” indican que la versión del sistema operativo es de 32 bits.

Para buscar una versión de Windows de 64 bits en un cuadro de comando, utilizo la siguiente plantilla:

test.bat:

 @echo off if defined ProgramFiles(x86) ( @echo yes @echo Some 64-bit work ) else ( @echo no @echo Some 32-bit work ) 

ProgramFiles(x86) es una variable de entorno definida automáticamente por cmd.exe (versiones de 32 bits y de 64 bits) solo en máquinas con Windows de 64 bits.

Aquí hay un código Delphi para verificar si su progtwig se ejecuta en un sistema operativo de 64 bits:

 function Is64BitOS: Boolean; {$IFNDEF WIN64} type TIsWow64Process = function(Handle:THandle; var IsWow64 : BOOL) : BOOL; stdcall; var hKernel32 : Integer; IsWow64Process : TIsWow64Process; IsWow64 : BOOL; {$ENDIF} begin {$IFDEF WIN64} //We're a 64-bit application; obviously we're running on 64-bit Windows. Result := True; {$ELSE} // We can check if the operating system is 64-bit by checking whether // we are running under Wow64 (we are 32-bit code). We must check if this // function is implemented before we call it, because some older 32-bit // versions of kernel32.dll (eg. Windows 2000) don't know about it. // See "IsWow64Process", http://msdn.microsoft.com/en-us/library/ms684139.aspx Result := False; hKernel32 := LoadLibrary('kernel32.dll'); if hKernel32 = 0 then RaiseLastOSError; try @IsWow64Process := GetProcAddress(hkernel32, 'IsWow64Process'); if Assigned(IsWow64Process) then begin if (IsWow64Process(GetCurrentProcess, IsWow64)) then begin Result := IsWow64; end else RaiseLastOSError; end; finally FreeLibrary(hKernel32); end; {$ENDIf} end; 

Probé la solución que sugerí en mi pregunta:

Probado para la variable de entorno de Windows: ProgramW6432

Si no está vacío, entonces es Windows de 64 bits.

De un script por lotes:

 IF PROCESSOR_ARCHITECTURE == x86 AND PROCESSOR_ARCHITEW6432 NOT DEFINED THEN // OS is 32bit ELSE // OS is 64bit END IF 

Usando la API de Windows:

 if (GetSystemWow64Directory(Directory, MaxDirectory) > 0) // OS is 64bit else // OS is 32bit 

Fuentes:

  1. HOWTO: detectar bitness de proceso
  2. Función GetSystemWow64Directory

Si puede hacer llamadas a la API, intente utilizar GetProcAddress / GetModuleHandle para verificar la existencia de IsWow64Process, que solo está presente en el sistema operativo Windows que tiene versiones de 64 bits.

También podría probar la variable de entorno ProgramFiles (x86) utilizada en Vista / 2008 para compatibilidad con versiones anteriores, pero no estoy 100% seguro acerca de XP-64 o 2003-64.

¡Buena suerte!

Lo usé en un script de inicio de sesión para detectar Windows de 64 bits

si “% ProgramW6432%” == “% ProgramFiles%” goto is64flag

Para un VBScript / WMI one-liner que recupera el número de bits reales (32 o 64) del sistema operativo o del hardware, consulte http://csi-windows.com/toolkit/csi-getosbits

No sé qué idioma está usando, pero .NET tiene la variable de entorno PROCESSOR_ARCHITEW6432 si el sistema operativo es de 64 bits.

Si todo lo que desea saber es si su aplicación está ejecutando 32 bits o 64 bits, puede verificar IntPtr.Size . Será 4 si se ejecuta en modo de 32 bits y 8 si se está ejecutando en modo de 64 bits.

Quiero agregar lo que uso en scripts de shell (pero puedo usarlo fácilmente en cualquier idioma) aquí. La razón es que algunas de las soluciones aquí no funcionan como WoW64, algunas usan cosas que en realidad no son para eso (verificando si hay una carpeta * (x86)) o no funcionan en scripts cmd. Siento que esta es la forma “correcta” de hacerlo, y debería ser segura incluso en futuras versiones de Windows.

  @echo off if /i %processor_architecture%==AMD64 GOTO AMD64 if /i %PROCESSOR_ARCHITEW6432%==AMD64 GOTO AMD64 rem only defined in WoW64 processes if /i %processor_architecture%==x86 GOTO x86 GOTO ERR :AMD64 rem do amd64 stuff GOTO EXEC :x86 rem do x86 stuff GOTO EXEC :EXEC rem do arch independent stuff GOTO END :ERR rem I feel there should always be a proper error-path! @echo Unsupported architecture! pause :END 

No sé en qué versión de Windows existe, pero en Windows Vista y más tarde esto se ejecuta:

 Function Is64Bit As Boolean Dim x64 As Boolean = System.Environment.Is64BitOperatingSystem If x64 Then Return true Else Return false End If End Function 

Muchas respuestas mencionan llamar a IsWoW64Process() o funciones relacionadas. Esta no es la forma correcta . Debería usar GetNativeSystemInfo() que fue diseñado para este propósito. Aquí hay un ejemplo:

 SYSTEM_INFO info; GetNativeSystemInfo(&info); if (info.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64) { // It's a 64-bit OS } 

También vea: https://msdn.microsoft.com/en-us/library/windows/desktop/ms724340%28v=vs.85%29.aspx

Cª#:

 public bool Is64bit() { return Marshal.SizeOf(typeof(IntPtr)) == 8; } 

En VB.NET :

 Public Function Is64bit() As Boolean If Marshal.SizeOf(GetType(IntPtr)) = 8 Then Return True Return False End Function 

Yo uso esto:

 @echo off if "%PROCESSOR_ARCHITECTURE%"=="AMD64" ( echo 64 BIT ) else ( echo 32 BIT ) 

Funciona en Windows XP, lo probó en Windows XP Professional 64 bit y 32 bit.

Sé que esto es antiguo, pero esto es lo que uso para detectar Win764

 On Error Resume Next Set objWSHShell = CreateObject("WScript.Shell") strWinVer = objWSHShell.RegRead("HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\BuildLabEx") If len(strWinVer) > 0 Then arrWinVer = Split(strWinVer,".") strWinVer = arrWinVer(2) End If Select Case strWinVer Case "x86fre" strWinVer = "Win7" Case "amd64fre" strWinVer = "Win7 64-bit" Case Else objWSHShell.Popup("OS Not Recognized") WScript.Quit End Select 

Probé el siguiente archivo por lotes en Windows 7 x64 / x86 y Windows XP x86 y está bien, pero aún no he probado Windows XP x64, pero probablemente funcione:

 If Defined ProgramW6432 (Do x64 stuff or end if you are aiming for x86) else (Do x86 stuff or end if you are aiming for x64) 

Con Windows Powershell, si la siguiente expresión devuelve verdadero, entonces es un sistema operativo de 64 bits:

(([Array](Get-WmiObject -Class Win32_Processor | Select-Object AddressWidth))[0].AddressWidth -eq 64)

Esto fue tomado y modificado de: http://depsharee.blogspot.com/2011/06/how-do-detect-operating-system.html (Método # 3). He probado esto en Win7 de 64 bits (en sesiones de 32 y 64 bits de PowerShell) y en XP de 32 bits.

La mejor manera es simplemente verificar si hay dos directorios de archivos de progtwig, ‘Archivos de progtwig’ y ‘Archivos de progtwig (x86)’. La ventaja de este método es que puede hacerlo cuando el o / s no se está ejecutando, por ejemplo si la máquina no se ha iniciado y desea reinstalar el sistema operativo

Curiosamente, si uso

 get-wmiobject -class Win32_Environment -filter "Name='PROCESSOR_ARCHITECTURE'" 

Obten AMD64 tanto en ISE de 32 bits como de 64 bits (en Win7 de 64 bits).

Otra forma creada por eGerman que usa números PE de ejecutables comstackdos (no se basa en registros de registro o variables de entorno):

 @echo off &setlocal call :getPETarget "%SystemRoot%\explorer.exe" if "%=ExitCode%" EQU "00008664" ( echo x64 ) else ( if "%=ExitCode%" EQU "0000014C" ( echo x32 ) else ( echo undefined ) ) goto :eof :getPETarget FilePath :: ~~~~~~~~~~~~~~~~~~~~~~ :: Errorlevel :: 0 Success :: 1 File Not Found :: 2 Wrong Magic Number :: 3 Out Of Scope :: 4 No PE File :: ~~~~~~~~~~~~~~~~~~~~~~ :: =ExitCode :: CPU identifier setlocal DisableDelayedExpansion set "File=%~1" set Cmp="%temp%\%random%.%random%.1KB" set Dmp="%temp%\%random%.%random%.dmp" REM write 1024 times 'A' into a temporary file if exist "%File%" ( >%Cmp% ( for /l %%i in (1 1 32) do !Dmp! ( for /f "skip=1 tokens=1,2 delims=: " %%i in ('fc /b "!File!" !Cmp!^|findstr /vbi "FC:"') do ( set /a "Y=0x%%i" for /l %%k in (!X! 1 !Y!) do echo 41 set /a "X=Y+2" echo %%j ) ) del !Cmp! REM read certain values out of the HEX dump set "err="  

Aquí hay un método más simple para los scripts por lotes

  @echo off goto %PROCESSOR_ARCHITECTURE% :AMD64 echo AMD64 goto :EOF :x86 echo x86 goto :EOF 

Verifique en el Registro la existencia de HKLM \ SOFTWARE \ Wow6432Node – Si está allí, el sistema es de 64 bits – 32 bits, de lo contrario.