¿Detectar Windows de 64 o 32 bits desde el agente de usuario o Javascript?

Quiero ofrecer la versión correcta de una descarga. Las versiones que tengo son:

• Windows de 32 bits
• Windows de 64 bits
• Linux

Detectar Linux usando el campo User Agent es fácil; pero, ¿es posible averiguar de manera confiable si Windows es de 32 bits o de 64 bits?

Los usuarios pueden estar usando navegadores extraños: IE y Firefox son comunes, y probablemente tengamos un usuario de Opera en alguna parte; tal vez un usuario de Chrome también. Sé que Windows 7 de 64 bits se envía con versiones de IE de 32 y 64 bits, y me gustaría enviarles la versión de 64 bits de mi descarga.

(Editado para agregar: sé que debería proporcionar todas las opciones, y lo haré. Pero la gente no lee las opciones . Así que quería proporcionar la descarga correcta de forma predeterminada, para mejorar la usabilidad. Por supuesto, aunque esto es útil si lo hago bien, es extremadamente inútil si lo hago mal. Y por las respuestas hasta ahora, no parece que haya una manera confiable de hacer esto).

Pruebe esto, busque WOW64 (32 bits en 64 bits) o Win64 (nativo de 64 bits) en la cadena de agente de usuario.

    if (navigator.userAgent.indexOf("WOW64") != -1 || 
        navigator.userAgent.indexOf("Win64") != -1 ){
       alert("This is a 64 bit OS");
    } else {
       alert("Not a 64 bit OS");
    }

He hecho algunas pruebas. Aquí están los resultados, espero que ayuden:

MacOS de 64 bits + Safari de 64 bits o Chrome de 32 bits:
window.navigator.platform = MacIntel

Windows de 32 bits + safari:
window.navigator.platform = Win32

Windows de 64 bits + IE de 64 bits:
window.navigator.platform = Win64
window.navigator.cpuClass = x64

Windows de 64 bits + IE de 32 bits:
window.navigator.platform = Win32
window.navigator.cpuClass = x86

Windows de 64 bits + 32 Firefox (o Chrome):
window.navigator.platform = Win32

Linux mint de 32 bits (i686) + firefox:
window.navigator.platform = Linux i686

Ubuntu de 64 bits (x86_64) + Chrome de 32 bits:
window.navigator.platform = Linux i686

Ubuntu de 64 bits + Epifanía de 64 bits:
window.navigator.platform = Linux x86_64

Hasta ahora he usado este código:

deployJava.isWin64OS = function() {
    return navigator.userAgent.indexOf('WOW64')>-1 || window.navigator.platform=='Win64';
};

Analizando alrededor de 14000 agentes de usuario únicos ( desde aquí ), se me ocurrieron las siguientes cadenas para buscar:

• x86_64
• x86-64
• Win64
• x64; (¡Cuidado con el punto y coma! Sin él tendrás falsos positivos).
• amd64
• AMD64
• WOW64
• x64_64

Además, aunque tienen diferentes conjuntos de instrucciones y no son compatibles con Intel x86_64, es posible que desee detectar lo siguiente:

• ia64
• sparc64
• ppc64
• IRIX64

Sin embargo, tenga cuidado, no busque nada que contenga "64" o incluso "x64". Los números de compilación, arañas / bots, bibliotecas, versiones .NET, resoluciones, etc. de Chrome también pueden contener la cadena "x64" sin dejar de ser un sistema operativo de 32 bits (u otro).

Tenga en cuenta que puede buscar todas esas cadenas sin distinción entre mayúsculas y minúsculas.

No he podido encontrar nada en ARM. ¿Quizás alguien más? Edítelo, es un wiki de la comunidad.

Puede comprobar el window.navigator.platformy el window.navigator.cpuClass.

No estoy seguro de su situación, pero consideraría simplemente hacer lo que hacen la mayoría de los otros sitios y dejar que el usuario elija qué descarga obtener. Podrían descargarlo para otra máquina, ponerlo en un dispositivo flash o simplemente querer que la versión de 32 bits se ejecute en su caja de 64 bits. Cualquiera sea la razón, preferiría tener la opción.

La solución más confiable sería crear una aplicación de cargador de 32 bits que detecte la arquitectura y luego descargue e instale la versión adecuada de su aplicación.

Revisé las otras dos respuestas de RC y Pino. Ambos no funcionan debido al mismo problema que sugiere: IE de 32 bits en Windows de 64 bits identificará erróneamente la plataforma como de 32 bits. Como la mayoría de la gente ejecuta IE de 32 bits en Windows de 64 bits (muchos complementos, por ejemplo, Flash no están disponibles en 64 bits), habrá muchas identificaciones inexactas.

Sotavento

No con un 100% de certeza, como dice, el navegador podría ser una versión de 32 bits mientras que el sistema operativo de 64 bits.

Para detectar el navegador, intente con el siguiente código:

<script language=javascript>   
  <!--   
  document.write("CPU :"+window.navigator.cpuClass);   
  //-->   
</script> 

CPU: ia64

Para IE.

http://msdn.microsoft.com/en-us/library/ms531090%28VS.85%29.aspx

Producto comercial: https://www.cyscape.com/showbrow.aspx

Para Windows de 64 bits con IE de 64 bits window.navigator.platform, será "Win64" y window.navigator.cpuClassserá "x64".

Para Windows de 64 bits con IE de 32 bits, window.navigator.platformserá "Win32" y window.navigator.cpuClassserá "x86".

Para Windows de 32 bits, window.navigator.platformserá "Win32" y window.navigator.cpuClassno estará definido (creo).

-

Fuente: Hice una aplicación que usa JavaScript para determinar si alguien está usando un procesador de 32 o 64 bits . Puedes ver el código aquí en GitHub .

Reanudé los resultados de la buena búsqueda anterior en estas funciones JS. Espero que puedan ayudar a todos los presentes a encontrar una respuesta rápida a sus necesidades (¡y también a las mías!)

function get_bits_system_architecture()
{
    var _to_check = [] ;
    if ( window.navigator.cpuClass ) _to_check.push( ( window.navigator.cpuClass + "" ).toLowerCase() ) ;
    if ( window.navigator.platform ) _to_check.push( ( window.navigator.platform + "" ).toLowerCase() ) ;
    if ( navigator.userAgent ) _to_check.push( ( navigator.userAgent + "" ).toLowerCase() ) ;

    var _64bits_signatures = [ "x86_64", "x86-64", "Win64", "x64;", "amd64", "AMD64", "WOW64", "x64_64", "ia64", "sparc64", "ppc64", "IRIX64" ] ;
    var _bits = 32, _i, _c ;
    outer_loop:
    for( var _c = 0 ; _c < _to_check.length ; _c++ )
    {
        for( _i = 0 ; _i < _64bits_signatures.length ; _i++ )
        {
            if ( _to_check[_c].indexOf( _64bits_signatures[_i].toLowerCase() ) != -1 )
            {
               _bits = 64 ;
               break outer_loop;
            }
        }
    }
    return _bits ; 
}


function is_32bits_architecture() { return get_bits_system_architecture() == 32 ? 1 : 0 ; }
function is_64bits_architecture() { return get_bits_system_architecture() == 64 ? 1 : 0 ; }

Pruébalo:

document.write( "Which is my current bits system architecture ? " + get_bits_system_architecture() + "<br>" );

document.write( "Is it 32 bits ? " + ( is_32bits_architecture() ? "YES" : "NO" ) + "<br>" );

document.write( "Is it 64 bits ? " + ( is_64bits_architecture() ? "YES" : "NO" ) );

¡Gracias a todos!

Usé el siguiente código:

var is32BitBrowser = true;
if( window.navigator.cpuClass != null && window.navigator.cpuClass.toLowerCase() == "x64" )
   is32BitBrowser = false;
if( window.navigator.platform.toLowerCase() == "win64" )
   is32BitBrowser = false;

Funcionó en todas partes excepto en las computadoras Mac. Y, desafortunadamente, parece que no es posible obtener esa información a través de JavaScript :(. Sin embargo, se podría hacer un truco más allí. Debido a que Adobe no era compatible con Flash Player en los navegadores x64, puede intentar detectarlo. Si la detección es exitosa, que definitivamente es un navegador de 32 bits, si no, que es un navegador de 32 bits sin complemento flash o un navegador de 64 bits. Debido a que la tasa de penetración de Flash Player es bastante grande (consulte http://www.adobe.com/products/player_census/ flashplayer / version_penetration.html ), esto debería ser lo suficientemente bueno como para detectar al menos el navegador x32 en Mac.

IE de 64 bits en Windows de 64 bits para cualquier navegador Internet Explorer

if (navigator.userAgent.indexOf("MSIE") != -1 && navigator.userAgent.indexOf("Win64") != -1 && navigator.userAgent.indexOf("x64") != -1){

   alert("This is 64 bit browser");

}
else {

   alert("Not 64 bit browser");

}

Tanto window.navigator.cpuClass como window.navigator.platform devuelven la plataforma del navegador. No la plataforma del sistema. Entonces, si está ejecutando un navegador de 32 bits en un sistema de 64 bits, ambas variables devolverán 32 bits. Lo que sería incorrecto.

Encontré esta vieja pregunta y pensé en actualizar con una biblioteca de código abierto reciente que encontré: https://github.com/faisalman/ua-parser-js

Según los documentos, el método getCPU() returns { architecture: '' }, con los siguientes valores posibles: 68k, amd64, arm, arm64, avr, ia32, ia64, irix, irix64, mips, mips64, pa-risc, ppc, sparc, sparc64.