Comment puis-je vérifier si wscript/cscript s'exécute sur x64 système d'exploitation hôte?

Je suis en cours d'exécution d'un script VBScript qui peuvent s'exécuter sous Windows x64. J'ai besoin de lire une clé de registre à partir de la 32 bits de la partie de la base de registre. Pour que je voie de l'utilisation de HKLM\Software\Wow6432Node\xyz au lieu de HKLM\Software\xyz. Comment puis-je vérifier si le script est exécuté sous x64?

OriginalL'auteur vividos | 2009-02-17

3

Je ne suis pas sûr que vous devez vérifier si le script est en cours d'exécution sous x64.

Essayez de lire à partir de HKLM\Software\Wow6432Node\xyz, si cela échoue, essayez de lire à partir de HKLM\Software\xyz, si cela échoue, votre clé de registre n'existe pas, prendre des mesures appropriées.

Bien sûr, si votre conception est plus compliqué (par exemple, vous écrivez une valeur dans la clé de registre si elle n'existe pas) alors que la suggestion ne fonctionne pas.

Ici est un VBScript pour l'examen du système d'exploitation. Vous aurez probablement aussi besoin d'une explication de la Propriétés disponibles à partir de la Classe Win32_OperatingSystem
```
strComputer = "."
Set objWMIService = GetObject("winmgmts:\\" & strComputer & "\root\cimv2")        

Set colOperatingSystems = objWMIService.ExecQuery _
    ("Select * from Win32_OperatingSystem")

For Each objOperatingSystem in colOperatingSystems
    msg = objOperatingSystem.Caption & " " & _
            objOperatingSystem.Version & " " & _
                objOperatingSystem.OSArchitecture
    msgbox msg
Next
```
Notez que pour Windows XP et 2003, OSArchitecture n'est pas disponible, dans ce cas, vous aurez probablement à examiner, soit le Caption ou Version pour déterminer si votre OS est en 64 bits.

Vous pouvez également utiliser quelque chose comme cette selon le niveau de complexité dont vous avez besoin.

Je suis juste en train de lire à partir d'une clé spécifique, de sorte que le test pour la lecture à partir du nœud dans Wow6432Node est assez. Merci!

OriginalL'auteur Grant Wagner

Même sur la version 64 bits de Windows, vous script execute en mode 32 bits.

Vous pouvez utiliser le code suivant pour déterminer réel bit de mode, vous script en cours d'exécution sur:

option explicit

function Determine64BitMode
    dim Shell, Is64BitOs
    set Shell = CreateObject("WScript.Shell")
    on error resume next
    Shell.RegRead "HKLM\Software\Microsoft\Windows\CurrentVersion\ProgramFilesDir (x86)"
    Is64BitOs = Err.Number = 0
    on error goto 0
    if Is64BitOs then
        Determine64BitMode = InStr(Shell.RegRead("HKLM\Software\Microsoft\Windows\CurrentVersion\ProgramFilesDir"), "(x86)") = 0
    else
        Determine64BitMode = false
    end if
end function

dim ExecutingIn64BitMode
ExecutingIn64BitMode = Determine64BitMode
if ExecutingIn64BitMode then
    MsgBox "64 bit"
else
    MsgBox "32 bit"
end if

OriginalL'auteur Michael Vlasov

Vous de ne pas mentionner ce que l'API que vous utilisez pour lire à partir du registre. Par exemple, si vous utilisez le WMI StdRegProv de classe, vous pouvez utiliser le __ProviderArchitecture drapeau à une demande d'accès au registre 32 bits de la ruche, peu importe si le script est exécuté sous 32-bit ou 64-bit de Windows Script Host. Cette technique est décrite dans la Demandant de Données WMI sur une Plate-forme 64 bits article de MSDN.

Voici un exemple de lecture à partir de la 32 bits de registre:

strComputer = "."
Const HKLM = &h80000002

''# Specify the required registry bitness
Set oCtx = CreateObject("WbemScripting.SWbemNamedValueSet")
oCtx.Add "__ProviderArchitecture", 32
oCtx.Add "__RequiredArchitecture", True

''# Load the 32-bit registry provider
Set oLocator = CreateObject("WbemScripting.SWbemLocator")
Set oWMI = oLocator.ConnectServer(strComputer, "root\default",,,,,, oCtx)
Set oReg = oWMI.Get("StdRegProv") 

''# Specify input parameters for the GetStringValue method call
Set oInParams = oReg.Methods_("GetStringValue").InParameters
oInParams.hDefKey     = HKLM
oInParams.sSubKeyName = "Software\xyz"
oInParams.sValueName  = "foobar"

''# Read a string value from the registry
Set oOutParams = oReg.ExecMethod_("GetStringValue", oInParams,, oCtx)
WScript.Echo oOutParams.sValue

Notez aussi que, dans ce cas, la clé de 32 bits noms doivent être spécifiées de manière habituelle comme HKLM\Software\xyz au lieu de HKLM\Software\Wow6432Node\xyz.

OriginalL'auteur Helen

Ici est une solution basée sur la base de connaissances Microsoft article Comment Vérifier Si un Ordinateur Exécute Une version 32 Bits ou 64 Bits du Système d'Exploitation:

Function Is64BitOS()
    Is64BitOS = Not(Is32BitOS())
End Function

Function Is32BitOS()
    Const sRegKey = "HKLM\HARDWARE\DESCRIPTION\System\CentralProcessorFunction Is64BitOS()
Is64BitOS = Not(Is32BitOS())
End Function
Function Is32BitOS()
Const sRegKey = "HKLM\HARDWARE\DESCRIPTION\System\CentralProcessor\0"
Const sIdentifierValue = "Identifier"
Const sPlatformIDValue = "Platform ID"
Dim oSh : Set oSh = CreateObject("WScript.Shell")
Dim sIdentifier, nPlatformID
sIdentifier = oSh.RegRead(sRegKey & "\" & sIdentifierValue)
nPlatformID = oSh.RegRead(sRegKey & "\" & sPlatformIDValue)
Set oSh = Nothing
If InStr(sIdentifier, "x86") > 0 And nPlatformID = 32 Then
Is32BitOS = True
Else
Is32BitOS = False
End if
End Function
"
    Const sIdentifierValue = "Identifier"
    Const sPlatformIDValue = "Platform ID"

    Dim oSh : Set oSh = CreateObject("WScript.Shell")
    Dim sIdentifier, nPlatformID

    sIdentifier = oSh.RegRead(sRegKey & "\" & sIdentifierValue)
    nPlatformID = oSh.RegRead(sRegKey & "\" & sPlatformIDValue)

    Set oSh = Nothing

    If InStr(sIdentifier, "x86") > 0 And nPlatformID = 32 Then
        Is32BitOS = True
    Else
        Is32BitOS = False
    End if
End Function

SOLUTION ALTERNATIVE

Une alternative et plus concis solution qui rend l'utilisation de WMI peut être trouvé ici.

OriginalL'auteur DavidRR

Une solution très simple consiste à vérifier si (virtuel) dossier C:\Windows\sysnative existent. Ce dossier n'existe que dans les processus 32 Bits, voir Redirecteur De Système De Fichier

Set fso = CreateObject("Scripting.FileSystemObject")
Set wshShell = CreateObject( "WScript.Shell" )

If fso.FolderExists(wshShell.ExpandEnvironmentStrings("%windir%") & "\sysnative" ) Then
    WScript.Echo "You are running in 32-Bit Mode"
Else
    WScript.Echo "You are running in 64-Bit Mode"
End if

Note, ne fonctionne que sur Windows Server 2003 et Windows XP ou supérieur.

OriginalL'auteur Wernfried Domscheit

Cela montre à la fois le système et les processus d'architectures:

Option Explicit
Dim WshShell, WshEnv
Set WshShell = WScript.CreateObject("WScript.Shell")
Set WshEnv = WshShell.Environment("System")
MsgBox "System: " & WshEnv("PROCESSOR_ARCHITECTURE")
Set WshEnv = WshShell.Environment("Process")
MsgBox "Process: " & WshEnv("PROCESSOR_ARCHITECTURE")

Il suffit de cocher celui que vous avez besoin pour <> "x86".

OriginalL'auteur Michel de Ruiter

Vous devez vous connecter pour publier un commentaire.