fichier de commandes pour vérifier le système d’exploitation 64 bits ou 32 bits

Il s’agit de la manière correcte d’effectuer la vérification selon la référence de la base de connaissances de Microsoft ( http://support.microsoft.com/kb/556009 ) que j’ai réédité en une seule ligne de code.

Il ne s’appuie sur aucune variable d’environnement ou nom de dossier et vérifie plutôt directement dans le registre.

Comme indiqué dans un fichier batch complet ci-dessous, il définit une variable d’environnement OS égale à 32BIT ou 64BIT que vous pouvez utiliser comme vous le souhaitez.

@echo OFF reg Query "HKLM\Hardware\Description\System\CentralProcessor\0" | find /i "x86" > NUL && set OS=32BIT || set OS=64BIT if %OS%==32BIT echo This is a 32bit operating system if %OS%==64BIT echo This is a 64bit operating system 

J’utilise l’une des méthodes suivantes:

 :CheckOS IF EXIST "%PROGRAMFILES(X86)%" (GOTO 64BIT) ELSE (GOTO 32BIT) :64BIT echo 64-bit... GOTO END :32BIT echo 32-bit... GOTO END :END 

ou j’ai défini la variable bit , que j’utiliserai plus tard dans mon script pour exécuter la configuration correcte.

 :CheckOS IF EXIST "%PROGRAMFILES(X86)%" (set bit=x64) ELSE (set bit=x86) 

ou…

 :CheckOS IF "%PROCESSOR_ARCHITECTURE%"=="x86" (set bit=x86) else (set bit=x64) 

J’espère que cela t’aides.

Semble fonctionner si vous ne faites que ceux-ci:

 echo "%PROCESSOR_ARCHITECTURE%" 

J’ai trouvé ce script qui fera des choses spécifiques en fonction de l’architecture du système d’exploitation (x64 ou x86):

 @echo off echo Detecting OS processor type if "%PROCESSOR_ARCHITECTURE%"=="AMD64" goto 64BIT echo 32-bit OS \\savdaldpm01\ProtectionAgents\RA\3.0.7558.0\i386\DPMAgentInstaller_x86 /q goto END :64BIT echo 64-bit OS \\savdaldpm01\ProtectionAgents\RA\3.0.7558.0\amd64\DPMAgentInstaller_x64 /q :END "C:\Program Files\Microsoft Data Protection Manager\DPM\bin\setdpmserver.exe" -dpmservername sa 

Essayez de trouver un moyen sans GOTO s’il vous plait …

Pour ceux qui travaillent avec des systèmes Unix, uname -m fera l’affaire.

 *** Start *** @echo off Set RegQry=HKLM\Hardware\Description\System\CentralProcessor\0 REG.exe Query %RegQry% > checkOS.txt Find /i "x86" < CheckOS.txt > SsortingngCheck.txt If %ERRORLEVEL% == 0 ( Echo "This is 32 Bit Operating system" ) ELSE ( Echo "This is 64 Bit Operating System" ) *** End *** 

référence http://support.microsoft.com/kb/556009

Exécutez le ci-dessous dans l’invite de commande:

Démarrer -> Exécuter -> Tapez cmd et entrez la commande ci-dessous dans la boîte noire résultante:

 wmic os get osarchitecture 

‘ProgramFiles (x86)’ est une variable d’environnement définie automatiquement par cmd.exe (versions 32 bits et 64 bits) sur les ordinateurs Windows 64 bits uniquement. Essayez ceci:

 @ECHO OFF echo Check operating system ... if defined PROGRAMFILES(X86) ( echo 64-bit sytem detected ) else ( echo 32-bit sytem detected ) pause 

 PROCESSOR_ARCHITECTURE=x86 

Apparaîtra sur Win32, et

 PROCESSOR_ARCHITECTURE=AMD64 

apparaîtra pour Win64.

Si vous exécutez de manière perverse le processus cmd.exe 32 bits, Windows présente deux variables d’environnement:

 PROCESSOR_ARCHITECTURE=x86 PROCESSOR_ARCHITEW6432=AMD64 

Voici mon préféré, une bombe logique 🙂

 ::32/64Bit Switch ECHO %PROCESSOR_ARCHITECTURE%|FINDSTR AMD64>NUL && SET ARCH=AMD64 || SET ARCH=x86 ECHO %ARCH% PAUSE 

Avec les AND ( && ) et les OR ( || ), il s’agit d’une construction par lots IF THEN ELSE .

Après beaucoup d’essais et d’erreurs, j’ai réussi à obtenir quelques exemples de travail différents, mais le coup de fouet a été le lancement du lot sur un OS 64 bits sur un CMD 32 bits. Au final, c’était la vérification la plus simple que je pouvais faire, qui fonctionne sous Win2k-Win8 32/64. Merci aussi à Phil qui m’a aidé.

 set bit64=n if /I %Processor_Architecture%==AMD64 set bit64=y if /I "%PROCESSOR_ARCHITEW6432%"=="AMD64" set bit64=y 

Si le script peut s’exécuter sous Administrator, il peut alors utiliser la commande wmi.

 FOR /f "tokens=2 delims==" %%f IN ('wmic os get osarchitecture /value ^| find "="') DO SET "OS_ARCH=%%f" IF "%OS_ARCH%"=="32-bit" GOTO :32bit IF "%OS_ARCH%"=="64-bit" GOTO :64bit ECHO OS Architecture %OS_ARCH% is not supported! EXIT 1 :32bit ECHO "32 bit Operating System" GOTO :SUCCESS :64bit ECHO "64 bit Operating System" GOTO :SUCCESS :SUCCESS EXIT 0 

Aucune des réponses ne fonctionnait dans mon cas (processeur 64 bits mais OS 32 bits), voici donc la solution qui a fonctionné pour moi:

 (set | find "ProgramFiles(x86)" > NUL) && (echo "%ProgramFiles(x86)%" | find "x86") > NUL && set bits=64 || set bits=32 

Voici une belle version concise:

 set isX64=False && if /I "%PROCESSOR_ARCHITECTURE%"=="AMD64" ( set isX64=True ) else ( if /I "%PROCESSOR_ARCHITEW6432%"=="AMD64" ( set isX64=True ) ) echo %isX64% 

N’utilisez pas le répertoire “Program Files (x86)” comme élément de preuve: les logiciels malveillants peuvent facilement créer ce répertoire sur une machine 32 bits. Utilisez plutôt les variables d’environnement PROCESSOR_ARCHITECTURE et PROCESSOR_ARCHITEW6432.

De nombreuses commandes DOS dans les différentes versions de Windows sont similaires mais peuvent prendre en charge différents parameters. De plus, les nouvelles versions de Windows peuvent prendre en charge de nouvelles commandes ou supprimer les anciennes. Ainsi, si vous souhaitez écrire un fichier de commandes pouvant s’exécuter sur différents types de machines, il peut s’avérer utile de déterminer la version de Windows sur laquelle le fichier de commandes est exécuté. De cette façon, le fichier de commandes peut exécuter des commandes appropriées au système d’exploitation.

Le fichier de commandes suivant détermine si l’ordinateur exécute ou non Windows 7, Windows Server 2008, Windows Vista, Windows Server 2003, Windows XP, Windows 2000 ou Windows NT. Il peut facilement être modifié pour prendre en charge d’autres versions de Windows si nécessaire ou pour définir une variable d’environnement basée sur la version de Windows détectée. Notez que pour que ce fichier de commandes détecte correctement les nouvelles versions de Windows Server et les versions grand public de Windows, il est plus compliqué que les fichiers de commandes que vous pouvez voir ailleurs. J’ai expliqué le raisonnement ci-dessous.

1) Ouvrez une fenêtre du Bloc-notes.

2) Copiez le texte suivant dans le Bloc-notes (vous souhaiterez peut-être accéder à la version imprimée de cette astuce).

 @echo off ver | find "2003" > nul if %ERRORLEVEL% == 0 goto ver_2003 ver | find "XP" > nul if %ERRORLEVEL% == 0 goto ver_xp ver | find "2000" > nul if %ERRORLEVEL% == 0 goto ver_2000 ver | find "NT" > nul if %ERRORLEVEL% == 0 goto ver_nt if not exist %SystemRoot%\system32\systeminfo.exe goto warnthenexit systeminfo | find "OS Name" > %TEMP%\osname.txt FOR /F "usebackq delims=: tokens=2" %%i IN (%TEMP%\osname.txt) DO set vers=%%i echo %vers% | find "Windows 7" > nul if %ERRORLEVEL% == 0 goto ver_7 echo %vers% | find "Windows Server 2008" > nul if %ERRORLEVEL% == 0 goto ver_2008 echo %vers% | find "Windows Vista" > nul if %ERRORLEVEL% == 0 goto ver_vista goto warnthenexit :ver_7 :Run Windows 7 specific commands here. echo Windows 7 goto exit :ver_2008 :Run Windows Server 2008 specific commands here. echo Windows Server 2008 goto exit :ver_vista :Run Windows Vista specific commands here. echo Windows Vista goto exit :ver_2003 :Run Windows Server 2003 specific commands here. echo Windows Server 2003 goto exit :ver_xp :Run Windows XP specific commands here. echo Windows XP goto exit :ver_2000 :Run Windows 2000 specific commands here. echo Windows 2000 goto exit :ver_nt :Run Windows NT specific commands here. echo Windows NT goto exit :warnthenexit echo Machine undetermined. :exit 

3) Enregistrez le fichier sous% WINDIR% \ whatvers.bat

4) Maintenant, depuis l’invite de commande, entrez:

quevers

Cela affichera la version de Windows que vous utilisez.

REMARQUES:

1. Le raisonnement pour utiliser la commande SYSTEMINFO plutôt que de s’appuyer sur la commande VER est que Windows Server 2008 “partage” les numéros de version avec d’autres versions de Windows (voir Microsoft). Ainsi, le fait de compter sur un «numéro de version» de 6.0 pour détecter Windows Vista ou 6.1 afin de détecter Windows 7 ne permet pas de différencier une machine de Windows Server 2008 ou Windows Server 2008 R2.

2. La création de% TEMP% \ osname.txt est uniquement parce que je n’ai pas pu placer les résultats de systeminfo | trouver “Nom du système d’exploitation” directement dans la commande for / f – il n’aime pas les commandes de canalisation. Vous pouvez trouver un moyen plus simple de gérer la saisie des informations de SYSTEMINFO – si oui, veuillez commenter.

3. La variable d’environnement% vers% a des espaces en tête. Je pourrais les supprimer avec un fichier de commandes plus long, mais dans ce cas, ce n’est pas nécessaire.

4. Le fichier de commandes détecte SYSTEMINFO car, à supposer qu’il dépasse les anciennes détections du système d’exploitation, la version en cours d’exécution de Windows est encore plus ancienne et ne disposera pas de cet utilitaire. Sous Windows 7 64 bits, il se trouve toujours dans le dossier% SystemRoot% \ system32. Si les versions ultérieures de Windows ne sont que 64 bits, ce fichier de commandes doit être mis à jour.

Revenez à la page Windows XP et DOS.

Je fais généralement les choses suivantes:

 :Check_Architecture if /i "%processor_architecture%"=="x86" ( IF NOT DEFINED PROCESSOR_ARCHITEW6432 ( REM Run 32 bit command ) ELSE ( REM Run 64 bit command ) ) else ( REM Run 64 bit command ) 

Vous pouvez utiliser l’emplacement de registre suivant pour vérifier si l’ordinateur exécute le système d’exploitation Windows 32 ou 64 bits:

 HKLM\HARDWARE\DESCRIPTION\System\CentralProcessor\0 

Vous verrez les entrées de registre suivantes dans le volet de droite:

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

Les versions x86 et 0x00000020(32) ci-dessus 0x00000020(32) indiquent que la version du système d’exploitation est 32 bits.

 set bit=64 IF NOT DEFINED PROGRAMFILES(X86) ( set "PROGRAMFILES(X86)=%PROGRAMFILES%" set bit=32 ) REM Example 1: REG IMPORT Install%bit%.reg (all compatibility) REM Example 2: CD %PROGRAMFILES(X86)% (all compatibility) 

Je ne comprends vraiment pas certaines des réponses données ici (désolé pour cela). La réponse la plus votée, par exemple, ne renvoie pas l’architecture de Windows, mais l’architecture du processeur. En exécutant une version 32 bits de Windows sur un processeur 64 bits, vous obtiendrez un résultat incorrect (il s’agit d’une requête sur le matériel utilisé).

L’option la plus sûre consiste à interroger la valeur BuildLabEx à partir du registre.

Déterminer x86 (intel) ou x86-64 (amd)

 reg query "HKLM\Software\Microsoft\Windows NT\CurrentVersion" /v "BuildLabEx" | >nul find /i ".x86fre." && set "_ARCH_=x86" || set "_ARCH_=x86-64" 

Déterminer x86 (intel), x86-64 (amd) ou arm

 set "_ARCH_=unknown" reg query "HKLM\Software\Microsoft\Windows NT\CurrentVersion" /v "BuildLabEx" | >nul find /i ".x86fre." && set "_ARCH_=x86" reg query "HKLM\Software\Microsoft\Windows NT\CurrentVersion" /v "BuildLabEx" | >nul find /i ".amd64fre." && set "_ARCH_=x86-64" reg query "HKLM\Software\Microsoft\Windows NT\CurrentVersion" /v "BuildLabEx" | >nul find /i ".armfre." && set "_ARCH_=arm" 

Une option alternative (mentionnée précédemment)

 if defined ProgramFiles(x86) ( set "_ARCH_=x86-64" ) else ( set "_ARCH_=x86" ) 

Le problème avec ce dernier est que lorsque vous gâchez vos variables, vous ne pouvez pas utiliser cette méthode. La recherche de l’existence du dossier entraînera également des problèmes lorsqu’il y a des rests d’une installation précédente (ou qu’un utilisateur a créé le dossier à dessein).

Ceci est une ligne %errorlevel% qui aura %errorlevel% de 0 pour 64 bits, 1 pour non-64 bits. Je ne peux pas garantir qu’il fonctionne sur toutes les versions de Windows, mais montre une méthode pour le déterminer. Vous pouvez append plusieurs requêtes findstr si vous connaissez toutes les possibilités de recherche.

set | findstr /i processo.*64 > nul 2>&1

Fondamentalement, vous jetez les variables d’environnement et utilisez une expression régulière pour rechercher quelque chose qui a ” processo ” + ” 64 ” quelque part dans sa ligne. La tuyauterie est juste pour supprimer les lignes correspondantes. Si je l’ai changé pour set | findstr /i processo.*64 > nul 2>&1 set | findstr /i processo.*64 > nul 2>&1 sur mon appareil actuel, ce serait le résultat:

  C:\Windows\System32>set | findstr /i processo.*64 

 PROCESSOR_ARCHITECTURE=AMD64 PROCESSOR_IDENTIFIER=Intel64 Family 6 Model 158 Stepping 9, GenuineIntel 

Ceci est un one-liner pour voir si votre processeur est un AMD 64 bits

set | findstr /i processo.*amd.*64 > nul 2>&1

Vous pouvez les prendre comme sharepoint départ et les affiner pour vos besoins. J’ai fini par utiliser ce nom sur des noms de variables d’environnement connus car il était plus fiable sur différentes versions majeures de Windows avec lesquelles je travaillais.

 If $SYSTEM_os_arch==x86 ( Echo OS is 32bit ) else ( ECHO OS is 64bit ) 

La manière correcte , comme l’écrit SAM, est la suivante:

reg Query “HKLM \ Matériel \ Description \ System \ CentralProcessor \ 0” / v “Identifiant” | find / i “x86″> NUL && set OS = 32BIT || définir OS = 64BIT

mais avec / v “Identifiant” un peu correct.

FYI, essayez de ne pas utiliser% PROCESSOR_ARCHITECTURE% car SCCM a apporté une modification autour de la version 2012 qui lance toujours les packages / programmes sous un processus 32 bits (il peut installer x64 mais les variables d’environnement apparaîtront comme x86). J’utilise maintenant;

IF EXIST “% SystemDrive% \ Program Files (x86)” GOTO X64

Jack

 set "_os=64" if "%PROCESSOR_ARCHITECTURE%"=="x86" (if not defined PROCESSOR_ARCHITEW6432 set "_os=32") 

Basé sur: https://blogs.msdn.microsoft.com/david.wang/2006/03/27/howto-detect-process-bitness/

et http://ss64.com/nt/syntax-64bit.html