Quelle est la manière la meilleure et la plus rapide de détecter si vous exécutez une version 32 ou 64 bits de Windows Server à partir de la ligne de commande?

(Cygwin est installé)

Un moyen un peu plus rapide serait de vérifier l'existence du répertoire% ProgramFiles (x86)%. S'il existe, vous exécutez 64 bits, s'il n'existe pas, vous exécutez 32 bits.

One-liner rapide:

if exist "%ProgramFiles(x86)%" echo 64-bit

Cela sortira 64-bitsi le répertoire existe. Cela échouerait, cependant, s'il n'existait pas en tant que variable mais qu'il existait en tant que répertoire (en tant que% ProgramFiles (x86)%).

Vous pouvez également utiliser l'outil de recherche pour avoir un moyen plus précis de déterminer le témoin.

set | find "ProgramFiles(x86)"

ou en utilisant la systeminfocommande précédemment

systeminfo | find /I "System type"

(inclus /Ipour fonctionner sous XP / 2003/2008 / etc)

Que diriez-vous:

echo %PROCESSOR_ARCHITECTURE%

Cela renverra x86 sur les systèmes 32 bits et AMD64 (ou IA64 ) sur les systèmes 64 bits.

systeminfo 

Il énumérera un peu, environ 10 champs en bas, il y en a un appelé Type de système. Cela vous dira si c'est x86 ou x64

systeminfo | find /I "System type"

Cela dépend des paramètres régionaux et est lent .

echo %PROCESSOR_ARCHITECTURE%

Notez que c'est x86 en 32 bits cmd.exe.

Façon correcte:

set Arch=x64
if "%PROCESSOR_ARCHITECTURE%" == "x86" ( 
    if not defined PROCESSOR_ARCHITEW6432 set Arch=x86
) 

Autre moyen de vérifier avec une requête WMI:

PowerShell:

(gwmi win32_computersystem).SystemType

CMD:

wmic OS get OSArchitecture 

Extrait d'ici: http://www.sysadmit.com/2015/10/windows-como-saber-si-es-de-32-o-64-bits.html

Il existe de nombreuses façons de vérifier l'architecture du processeur sous Windows:

• Le moyen le plus rapide, le plus simple et le plus compatible pour vérifier l'architecture du processeur dans au moins Windows 2000 et versions ultérieures consiste à examiner la PROCESSOR_ARCHITECTURE variable d'environnement :

  echo %PROCESSOR_ARCHITECTURE%

• Cependant, cela peut donner des résultats différents, selon la façon dont l'invite de commande est ouverte. Pour éviter d'obtenir des «résultats inattendus» dus à WoW64 , vous pouvez le lire directement à partir du registre (Microsoft a fait pas moins de deux fautes de frappe dans la clé ):

  reg query "HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Environment" /v PROCESSOR_ARCHITECTURE

• Microsoft suggère également de lire la banque d'informations sur le matériel à partir du registre:

  reg query "HKLM\Hardware\Description\System\CentralProcessor\0" /v Identifier

• Vous pouvez également vérifier l'existence de la version x86 du Program Filesrépertoire (ou de la variable d'environnement qui le pointe) car elle n'existerait que sur un système 64 bits. Contrairement à la PROCESSOR_ARCHITECTUREvariable, cela ne dépend pas de la façon dont l'invite de commandes est exécutée, car le répertoire existe (ou non), quelle que soit la façon dont l'invite est ouverte:

  • ::via env-var
if not defined ProgramFiles(x86) echo 32-bit

  • ::via file-system
if not exist "%systemdrive%\Program Files (x86)" echo 32-bit

Ces méthodes peuvent être combinées dans un seul fichier de commandes (par exemple, cpuinfo.bat) et fournissent un moyen agréable et rapide de vérifier le système à partir d'une invite de commandes Windows NT standard sans avoir à recourir à l'exécution d'autres programmes ou frameworks.

Cela a été testé sur des systèmes 32 bits et Intel 64 bits (veuillez tester sur AMD64), donnant des résultats corrects en <1 seconde:

@echo off

echo PROCESSOR_ARCHITECTURE var:
echo %PROCESSOR_ARCHITECTURE% | find /i "x86" > nul
if %errorlevel%==0 (
    echo   32-bit
) else (
    echo   64-bit
)
echo.

echo PROCESSOR_ARCHITECTURE reg:
reg query "HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Environment" /v PROCESSOR_ARCHITECTURE | find /i "x86" > nul
if %errorlevel%==0 (
    echo   32-bit
) else (
    echo   64-bit
)
echo.

echo CentralProcessor reg:
reg query "HKLM\Hardware\Description\System\CentralProcessor\0" | find /i "x86" > nul
if %errorlevel%==0 (
    echo   32-bit
) else (
    echo   64-bit
)
echo.

echo ProgramFiles(x86) var:
if not defined ProgramFiles(x86) (
    echo   32-bit
) else (
    echo   64-bit
)
echo.

echo ProgramFiles(x86) dir:
if not exist "%systemdrive%\Program Files (x86)" (
    echo   32-bit
) else (
    echo   64-bit
)
echo.

SOLUTION GÉNÉRIQUE

J'ai vraiment dû creuser cela et avoir un vrai regard sur WMI.

La meilleure option à mon avis est d'utiliser simplement cette chaîne PowerShell

(Get-WmiObject win32_ComputerSystem -ComputerName $ComputerName).SystemType

Cela fonctionne même avec les anciens Windows 2003 et XP

La réponse sera l'une des

• PC basé sur X86
• PC x64

PC x64

Ou si vous revenez à certains outils cmd à l'ancienne

wmic computersystem get systemtype

Bien que ce ne soit pas la réponse idéale, et systeminfo.exedevrait être votre méthode préférée pour déterminer le type de système, c'est-à-dire 32 bits ou 64 bits, cette solution s'exécute un peu plus rapidement si vous ne voulez pas attendre pour systeminfo.exeterminer son travail.

La commande:

reg.exe query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion" | find "BuildLabEx"

Avec les modifications correctes apportées à la requête de registre et à la chaîne de recherche, vous pouvez également vérifier les versions du système d'exploitation depuis Windows 95. systeminfo.exeest plus exacte et la manière correcte d'interroger reg.exe queryest plus rapide et plus rétrocompatible.

Meilleure SOLUTION:

Méthode 1:
(validation en deux étapes avec PROCESSOR_ARCHITECTUREet PROCESSOR_ARCHITEW6432)

set Arch=x64
if "%PROCESSOR_ARCHITECTURE%" == "x86" ( 
    if not defined PROCESSOR_ARCHITEW6432 set Arch=x86
) 


if %Arch% == "x64"  (
    msg * "yessss"
) else  (
    msg * "noooo"
)

Méthode 2:

reg Query "HKLM\Hardware\Description\System\CentralProcessor\0" | find /i "x32" > NUL && set OS=32BIT || set OS=64BIT

if %OS%==32BIT echo "YESSS"
if %OS%==64BIT echo "NOOO"

source: /superuser//a/293143/249349

À l'aide de l'interface WMI, sous l'invite de commandes. Ouvrez l'invite de commandes en tant qu'administrateur, tapez wmic OS get OSArchitectureet appuyez surEnter