fichier batch pour vérifier l'OS 64bit ou 32bit
Puis-je vérifier si la machine actuelle exécute 64 bits OS ou 32 bits _ {OS dans un fichier de traitement par lots?
MODIFIER:
Trouvé ceci en ligne et cela m'est assez bon maintenant:
Il s'agit du moyen correct 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 repose sur aucune variable d'environnement ni sur aucun nom de dossier, mais vérifie directement dans le registre.
Comme indiqué dans un fichier de commandes complet ci-dessous, il définit une variable d'environnement OS égale à 32BIT ou 64BIT que vous pouvez utiliser à votre guise.
@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'un des éléments suivants:
:CheckOS
IF EXIST "%PROGRAMFILES(X86)%" (GOTO 64BIT) ELSE (GOTO 32BIT)
:64BIT
echo 64-bit...
GOTO END
:32BIT
echo 32-bit...
GOTO END
:END
ou je définis 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 plaît ...
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 > StringCheck.txt
If %ERRORLEVEL% == 0 (
Echo "This is 32 Bit Operating system"
) ELSE (
Echo "This is 64 Bit Operating System"
)
*** End ***
reference http://support.Microsoft.com/kb/556009
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
Exécutez le ci-dessous dans l'invite de commande:
Démarrer -> Exécuter -> Tapez cmd et entrez la commande ci-dessous dans la zone 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
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'un IF THEN ELSE Batch Construct.
Aucune des réponses ici ne fonctionnait dans mon cas (processeur 64 bits mais système d'exploitation 32 bits), alors voici la solution qui a fonctionné pour moi:
(set | find "ProgramFiles(x86)" > NUL) && (echo "%ProgramFiles(x86)%" | find "x86") > NUL && set bits=64 || set bits=32
Si le script peut être exécuté sous Administrateur, il peut 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
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 Windows, mais vous donnera l'architecture du processeur. Lors de l'exécution d'une version 32 bits de Windows sur un processeur 64 bits, vous obtiendrez un résultat erroné (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 armer
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é 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 vérification de l'existence du dossier posera également des problèmes s'il reste des éléments d'une installation précédente (ou si un utilisateur l'a créé à dessein).
Après beaucoup d'essais et d'erreurs, j'ai réussi à obtenir quelques exemples de travail différents, mais le coup d'envoi a eu lieu lorsque le lot a été lancé sur un système d'exploitation 64 bits sur un CMD 32 bits. En fin de compte, c’était le chèque le plus simple que j’ai pu obtenir au travail, qui fonctionne sous Win2k-Win8 32/64 . Un grand merci également à Phil qui m’a aidée dans cette tâche.
set bit64=n
if /I %Processor_Architecture%==AMD64 set bit64=y
if /I "%PROCESSOR_ARCHITEW6432%"=="AMD64" set bit64=y
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)
Il s’agit d’un one-liner qui aura %errorlevel% de 0 pour 64 bits, 1 pour les non-64 bits. Je ne peux pas en garantir le fonctionnement sur toutes les versions de Windows, mais montre une méthode pour le déterminer. Vous pouvez ajouter plusieurs findstrqueries si vous connaissez toutes les possibilités à rechercher.
set | findstr /i processo.*64 > nul 2>&1
En gros, vous videz les variables d'environnement et utilisez une expression régulière pour rechercher un élément contenant "processo" + "64" quelque part dans sa ligne. La tuyauterie sert uniquement à supprimer les lignes correspondantes. Si je le changeais en set | findstr /i processo.*64 > nul 2>&1 sur mon équipement actuel, le résultat serait le suivant:
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 point de départ et les affiner pour répondre à vos besoins. J'ai fini par utiliser ces noms de variables d'environnement connus, car il était plus fiable dans les différentes versions majeures de Windows avec lesquelles je travaillais.
De nombreuses commandes DOS dans les différentes versions de Windows sont similaires mais peuvent prendre en charge des paramètres différents. 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éterminera si la machine exécute 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 en fonction de la version de Windows détectée. Notez que, pour distinguer correctement les versions les plus récentes de Windows Server des versions grand public de Windows, ce fichier de commandes est plus compliqué que les fichiers de commandes visibles 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 voudrez peut-être accéder à la version imprimée de ce conseil au fur et à mesure que certaines lignes se suivent):
@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 en tant que% WINDIR%\whichvers.bat
4) Maintenant, à l’invite de commande, entrez:
qui
Ceci affichera la version de Windows que vous utilisez.
REMARQUES:
Le raisonnement pour utiliser la commande SYSTEMINFO plutôt que de s'appuyer sur la commande VER est parce que Windows Server 2008 "partage" les numéros de version avec d'autres versions de Windows (voir Microsoft). Par conséquent, s’appuyer 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 un ordinateur de Windows Server 2008 ou Windows Server 2008 R2.
La création de% TEMP%\osname.txt est uniquement due au fait que je n’ai pas pu placer les résultats de systeminfo | trouvez "Nom du système d'exploitation" directement dans la commande for/f - il n'aime pas les commandes redirigées. Vous trouverez peut-être un moyen plus facile de récupérer les informations de SYSTEMINFO. Si tel est le cas, veuillez commenter.
La variable d'environnement% vers% a des espaces de début. Je pourrais les supprimer avec un fichier de commandes plus long, mais dans ce cas ce n'est pas nécessaire.
Le fichier de commandes détecte pour SYSTEMINFO comme il le suppose si la détection dépasse l’ancienne détection du système d’exploitation. La version en cours d’exécution de Windows est encore plus ancienne et n’a pas cet utilitaire. Sous Windows 7 64 bits, il se trouve toujours dans le dossier% SystemRoot%\System32. Si les versions ultérieures de Windows deviennent uniquement 64 bits, il est possible que ce fichier de commandes soit mis à jour.
Revenez à la page Windows XP et DOS.
Je fais habituellement ce qui suit:
: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 x86 et 0x00000020(32) ci-dessus indiquent que la version du système d'exploitation est 32 bits.
Voici une version concise de Nice:
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)" pour prouver quoi que ce soit: un logiciel malveillant peut facilement créer ce répertoire sur une machine 32 bits. Utilisez plutôt les variables d'environnement PROCESSOR_ARCHITECTURE et PROCESSOR_ARCHITEW6432.