¿Cuál es la mejor manera de detectar un dispositivo móvil?


1652

¿Hay una manera sólida de detectar si un usuario está utilizando un dispositivo móvil en jQuery? ¿Algo similar al atributo CSS @media? Me gustaría ejecutar un script diferente si el navegador está en un dispositivo portátil.

La $.browserfunción jQuery no es lo que estoy buscando.


77
Proporcione una URL móvil específicamente para dispositivos móviles. Así es como la mayoría de los sitios principales manejan los dispositivos móviles. Ver m.google.com .
meagar

66
jQuery no lo hace, y no puede hacer todo. Proporciona el cruce y la manipulación del DOM entre navegadores, animación simple y ajax entre navegadores, y crea un marco esqueleto para que los complementos se desarrollen. Tenga en cuenta las limitaciones de jQuery antes de solicitar específicamente una solución de jQuery.
Yi Jiang

78
Los agentes de usuario son objetivos en constante movimiento, todos los que lean esta publicación deben ser muy cautelosos con la detección de agentes de usuario
Rob

46
¿Qué es un dispositivo 'móvil'? ¿Es un dispositivo compatible con el tacto (incluidos Chrome Pixels y portátiles con Windows 8 con mouse)? ¿Es un dispositivo con una pantalla pequeña (¿qué pasa con los iPads de retina? ¿Es un dispositivo con una CPU lenta? ¿O un dispositivo con una conexión a Internet lenta? Dependiendo de lo que quieras hacer, la respuesta a esta pregunta variará. Apuntar a la resolución de pantalla o tocar es fácil. Si desea servir contenido más pequeño o JS menos intensivo para algunos dispositivos, entonces no hay una bala de plata. Prueba de window.navigator.connection y recurre a (desagradable, malo, mal aconsejado) sniffing de UserAgent. Mis 2 centavos
David Gilbertson

3
@Cole "Cole9" Johnson Mi punto exactamente. Parece que "móvil" se utiliza como un término general para tocar, CPU lenta, red lenta y pantalla pequeña. Pero ninguno de estos son supuestos perfectos. Creo que considerarlos individualmente resultará en un mejor producto que diseñar para un concepto vago de 'móvil'. Por lo tanto, le hago esa pregunta al OP.
David Gilbertson

Respuestas:


2028

Nota del editor: la detección de agentes de usuario no es una técnica recomendada para las aplicaciones web modernas. Vea los comentarios debajo de esta respuesta para confirmar este hecho. Se sugiere utilizar una de las otras respuestas mediante la detección de funciones y / o consultas de medios.


En lugar de usar jQuery, puede usar JavaScript simple para detectarlo:

if( /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent) ) {
 // some code..
}

O puede combinarlos para que sea más accesible a través de jQuery ...

$.browser.device = (/android|webos|iphone|ipad|ipod|blackberry|iemobile|opera mini/i.test(navigator.userAgent.toLowerCase()));

Ahora $.browserregresará "device"para todos los dispositivos anteriores

Nota: $.browsereliminado en jQuery v1.9.1 . Pero puede usar esto usando el código del complemento de migración jQuery


Una versión más completa:

var isMobile = false; //initiate as false
// device detection
if(/(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|ipad|iris|kindle|Android|Silk|lge |maemo|midp|mmp|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows (ce|phone)|xda|xiino/i.test(navigator.userAgent) 
    || /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i.test(navigator.userAgent.substr(0,4))) { 
    isMobile = true;
}

438
La detección de agentes de usuario es una técnica de detección muy simple, las cadenas de agentes de usuario son un objetivo en constante movimiento, no se debe confiar solo en ellas. Las personas que voten por esta publicación deberían considerar investigar más.
Rob el

65
Uno de los problemas con la detección de dispositivos específicos fuera del agente de usuario es que debe recordar actualizar su detección cuando salgan nuevos dispositivos. Esta no es una solución ideal.
ICodeForCoffee

11
¡El navegador Dolphin en Android no envía ninguna de esas cadenas!
feeela

88
Si su usuario es lo suficientemente astuto o los desarrolladores lo suficientemente tontos como para cambiar la cadena del agente de usuario, a quién le importa ...
mattdlockyer

58
Entonces, ¿qué tan móvil considerarías un televisor Android con mouse? ¿Qué tan móvil es una PC con Windows que puede ejecutarse en modo dual (con teclado o como pantalla táctil)? Si hiciste esto antes de que se inventara el iPad, tenías que agregarlo más tarde a todos tus sitios. Próximos sistemas operativos que saldrán: Ubuntu Mobile, FirefoxOS, Tizen ....This.Is.A.Bad.Idea.
FrancescoMM

535

Para mí lo pequeño es hermoso, así que estoy usando esta técnica:

En archivo CSS:

/* Smartphones ----------- */
@media only screen and (max-width: 760px) {
  #some-element { display: none; }
}

En el archivo jQuery / JavaScript:

$( document ).ready(function() {      
    var is_mobile = false;

    if( $('#some-element').css('display')=='none') {
        is_mobile = true;       
    }

    // now I can use is_mobile to run javascript conditionally

    if (is_mobile == true) {
        //Conditional script here
    }
 });

Mi objetivo era tener mi sitio "apto para dispositivos móviles". Así que uso CSS Media Queries mostrar / ocultar elementos dependiendo del tamaño de la pantalla.

Por ejemplo, en mi versión móvil no quiero activar el Me gusta de Facebook, porque carga todas esas imágenes de perfil y otras cosas. Y eso no es bueno para los visitantes móviles. Entonces, además de ocultar el elemento contenedor, también hago esto dentro del bloque de código jQuery (arriba):

if(!is_mobile) {
    (function(d, s, id) {
        var js, fjs = d.getElementsByTagName(s)[0];
        if (d.getElementById(id)) return;
        js = d.createElement(s); js.id = id;
        js.src = "//connect.facebook.net/pt_PT/all.js#xfbml=1&appId=210731252294735";
        fjs.parentNode.insertBefore(js, fjs);
    }(document, 'script', 'facebook-jssdk'));
}

Puedes verlo en acción en http://lisboaautentica.com

Todavía estoy trabajando en la versión móvil, por lo que todavía no se ve como debería, al momento de escribir esto.

Actualización por dekin88

Hay una API de JavaScript incorporada para detectar medios. En lugar de usar la solución anterior, simplemente use lo siguiente:

$(function() {      
    let isMobile = window.matchMedia("only screen and (max-width: 760px)").matches;

    if (isMobile) {
        //Conditional script here
    }
 });

Navegador compatible: http://caniuse.com/#feat=matchmedia

La ventaja de este método es que no solo es más simple y más corto, sino que puede apuntar condicionalmente a diferentes dispositivos como teléfonos inteligentes y tabletas por separado si es necesario sin tener que agregar ningún elemento ficticio en el DOM.


8
¿No necesitas # algún elemento REALMENTE EN EL DOM para que esto funcione?
Rimer

68
-1 La screen.widthpropiedad es global. No es necesario agregar arbitrariamente un elemento al DOM e innecesariamente incorporar consultas de medios CSS. Además, si el navegador está en un escritorio y el usuario cambia el tamaño de la ventana, $is_mobileno se actualizará.
merv

98
¿Por qué no:if( screen.width <= 480 ) { // is mobile }
andrewrjones

23
@andrewrjones Los dispositivos Retina duplican el widthvalor del atributo IIRC. Por lo tanto, un iPhone retina tendrá una widthde 640y una altura de 960en vertical, y una widthde 960y una altura de 640en el paisaje.
Cole Johnson

66

236

Según Mozilla - Detección del navegador utilizando el agente de usuario :

En resumen, recomendamos buscar la cadena "Mobi" en cualquier parte del Agente de usuario para detectar un dispositivo móvil.

Me gusta esto:

if (/Mobi/.test(navigator.userAgent)) {
    // mobile!
}

Esto coincidirá con todos los agentes de usuario de navegador móvil comunes, incluidos Mozilla móvil, Safari, IE, Opera, Chrome, etc.

Actualización para Android

EricL recomienda realizar pruebas Androidcomo agente de usuario también, ya que la cadena de agente de usuario de Chrome para tabletas no incluye "Mobi" (sin embargo, las versiones del teléfono sí lo hacen):

if (/Mobi|Android/i.test(navigator.userAgent)) {
    // mobile!
}

11
¡Gracias por la respuesta! Sin /Mobi/i.test(navigator.userAgent)embargo, prefiero , ya que test () devuelve un booleano.
arminrosu

55
Paradójicamente, FireFox Mobile en un Samsung Galaxy Note 8 no devuelve Mobi y la prueba devolverá falso.
Eirinn

13
El artículo vinculado menciona: Si el dispositivo es lo suficientemente grande como para que no esté marcado con "Mobi", debe servir su sitio de escritorio (que, como práctica recomendada, debería admitir la entrada táctil de todos modos, ya que aparecen más máquinas de escritorio con pantallas táctiles).
QuasarDonkey

2
Esto es mucho mejor que las otras soluciones sugeridas, debería ser la respuesta aceptada en la OMI
RNobel

99
Derp. Gracias. No pude editar mi publicación anterior. Aquí está otra vez:/Mobi/i.test(navigator.userAgent) || /Android/i.test(navigator.userAgent)
EricL

90

Una línea simple y efectiva:

function isMobile() { return ('ontouchstart' in document.documentElement); }

Sin embargo, el código anterior no tiene en cuenta el caso de las computadoras portátiles con pantalla táctil. Por lo tanto, proporciono esta segunda versión, basada en la solución @Julian :

function isMobile() {
  try{ document.createEvent("TouchEvent"); return true; }
  catch(e){ return false; }
}

29
¿Qué pasa con las computadoras portátiles Windows con pantalla táctil?
Chris Cinelli

10
¡La segunda isMobilefunción que proporcionó regresa trueen mi dispositivo destop! (Google Chrome v44.0)
Lucas

12
Este es más un método isTouchSupported que no es realmente una detección móvil.
Barkermn01

3
No todos los teléfonos móviles tienen pantallas táctiles.
Andrew

@LukeP ¿Es refrescante cuando pasa de la emulación móvil al escritorio?
Christian4423

81

Lo que está haciendo al querer detectar un dispositivo móvil es acercarse demasiado a un concepto IMO de "rastreo del navegador". Probablemente sería mucho mejor hacer alguna detección de características. Bibliotecas como http://www.modernizr.com/ pueden ayudar con eso.

Por ejemplo, ¿dónde está la línea entre móvil y no móvil? Se pone cada vez más borrosa cada día.


3
aún así, un usuario podría querer usar "jquery mobile" para esos dispositivos, cualesquiera que sean las características compatibles.
Sirber

99
Por ejemplo, mi problema con "móvil" "no móvil" son mis funciones de transferencia, tengo configurado JS para desactivar las funciones, solo necesito detectarlo
Sam Sussman

44
Aún así, si desea ofrecer una aplicación descargable específica del dispositivo, puede ser útil.
Bastes

3
Depende de la situación, estoy buscando algo que me diga si el usuario está en un dispositivo móvil, para que pueda deshabilitar algunas animaciones pesadas basadas en JavaScript. El rastreo de UA sería mucho más apropiado que tratar de 'detectar' las capacidades de rendimiento de JavaScript del navegador del usuario.
Rick Suggs

99
Mobile vs. Personalmente, desearía que hubiera una manera fácil (y confiable) de obtener el sistema operativo en el que se está ejecutando el navegador actual
nbsp

66

No es jQuery, pero encontré esto: http://detectmobilebrowser.com/

Proporciona scripts para detectar navegadores móviles en varios idiomas, uno de los cuales es JavaScript. Eso puede ayudarlo con lo que está buscando.

Sin embargo, dado que está utilizando jQuery, es posible que desee conocer la colección jQuery.support. Es una colección de propiedades para detectar las capacidades del navegador actual. La documentación está aquí: http://api.jquery.com/jQuery.support/

Como no sé qué es exactamente lo que está tratando de lograr, no sé cuál de estos será el más útil.

Dicho todo esto, creo que su mejor opción es redirigir o escribir un script diferente a la salida utilizando un lenguaje del lado del servidor (si esa es una opción). Como realmente no conoce las capacidades de un navegador móvil x, hacer la detección y la lógica de alteración en el lado del servidor sería el método más confiable. Por supuesto, todo eso es un punto discutible si no puede usar un lenguaje del lado del servidor :)


66
eso no es compatible con iPads. Para admitir iPad, busque ip (hone | od) y "| ad" - por ejemplo ip (hone | od | ad)
Jayson Ragasa

3
Acabo de probar el Javascript de detectmobilebrowser.com/, y NO ESTÁ funcionando para iPad.
Milche Patern

3
@MilchePatern eso se debe a que el script es defectuoso, use iPad en lugar de ipad, luego funciona, tuve el problema en mi Samsung Tab, tuve que usar Android iso android :)
Coen Damen

13
Hay una versión jQuery allí, y funciona perfectamente, pero para la detección de tabletas debe agregar |android|ipad|playbook|silkcomo se describe en la sección sobre (es por diseño)
cprcrack

3
Bueno, sí, una tableta no es un móvil. El sitio se llama dectect navegadores móviles .
Felix Eve

47

A veces se desea saber qué dispositivo de marca está utilizando un cliente para mostrar contenido específico de ese dispositivo, como un enlace a la tienda de iPhone o al mercado de Android. Modernizer es excelente, pero solo muestra las capacidades del navegador, como HTML5 o Flash.

Aquí está mi solución UserAgent en jQuery para mostrar una clase diferente para cada tipo de dispositivo:

/*** sniff the UA of the client and show hidden div's for that device ***/
var customizeForDevice = function(){
    var ua = navigator.userAgent;
    var checker = {
      iphone: ua.match(/(iPhone|iPod|iPad)/),
      blackberry: ua.match(/BlackBerry/),
      android: ua.match(/Android/)
    };
    if (checker.android){
        $('.android-only').show();
    }
    else if (checker.iphone){
        $('.idevice-only').show();
    }
    else if (checker.blackberry){
        $('.berry-only').show();
    }
    else {
        $('.unknown-device').show();
    }
}

Esta solución es de Graphics Maniacs http://graphicmaniacs.com/note/detecting-iphone-ipod-ipad-android-and-blackberry-browser-with-javascript-and-php/


Esto funciona muy bien. Necesitaba deshabilitar una función jQuery que se ejecuta al desplazarse al usar un teléfono iPad o Android y dado que los diversos dispositivos tienen diferentes anchos de pantalla, esta fue una solución simple. Gracias una tonelada.
Eric Allen

El único problema con el uso de la prueba de Android es qué pasa con el rincón que usa el agente de usuario de Android
MayorMonty

Buena respuesta que muestra que no tenemos que ser fundamentalistas en la detección de características.
Fernando

44

Encontré una solución en: http://www.abeautifulsite.net/blog/2011/11/detecting-mobile-devices-with-javascript/ .

var isMobile = {
    Android: function() {
        return navigator.userAgent.match(/Android/i);
    },
    BlackBerry: function() {
        return navigator.userAgent.match(/BlackBerry/i);
    },
    iOS: function() {
        return navigator.userAgent.match(/iPhone|iPad|iPod/i);
    },
    Opera: function() {
        return navigator.userAgent.match(/Opera Mini/i);
    },
    Windows: function() {
        return navigator.userAgent.match(/IEMobile/i);
    },
    any: function() {
        return (isMobile.Android() || isMobile.BlackBerry() || isMobile.iOS() || isMobile.Opera() || isMobile.Windows());
    }
};

Y luego para verificar si se trata de un dispositivo móvil, puede probar usando:

if(isMobile.any()) {
   //some code...
}

Una solución basada en el agente de usuario funciona bien cuando puede estar seguro de que la subcadena se relaciona directamente con el tipo de dispositivo. es decir, iPad = iPad. Sin embargo, ahora hay tantos tipos diferentes de dispositivos (más de 25,000) que el enfoque no es lo suficientemente preciso para la mayoría de los propósitos comerciales. Fundé el proyecto de código abierto 51Degrees.com para proporcionar una alternativa confiable y robusta. Funcionará en JavaScript y también en el lado del servidor. Toda la documentación está aquí ... 51degrees.com/support/documentation
James Rosewell

También utilicé arriba, y estaba funcionando bien para mí, pero ahora no funciona para Android 5.1 y superior, ¿hay algo cambiado en Android 5.1 y superior?
Imran Qamer

if (isMobile.Android ()) {document.getElementById ("myAnchor"). setAttribute ("href", " google.com" ); }
Amranur Rahman el

25

Si por "móvil" te refieres a "pantalla pequeña", uso esto:

var windowWidth = window.screen.width < window.outerWidth ?
                  window.screen.width : window.outerWidth;
var mobile = windowWidth < 500;

En iPhone terminarás con un ancho de pantalla.pantalla de 320. En Android terminarás con un ancho de ventana.outer de 480 (aunque eso puede depender del Android). Los iPads y las tabletas Android devolverán números como 768 para que puedan obtener la vista completa como desearían.


1
¿Por qué no es suficiente 'window.screen.width'? Parece que está tomando el más pequeño de 'window.screen.width' o 'window.outerWidth'. ¿Por qué te importa el 'externalWidth'? ¡Gracias de antemano por la respuesta!
user1330974

16

Si usa Modernizr , es muy fácil de usar Modernizr.touchcomo se mencionó anteriormente.

Sin embargo, prefiero usar una combinación de Modernizr.touchpruebas de agente de usuario, solo para estar seguro.

var deviceAgent = navigator.userAgent.toLowerCase();

var isTouchDevice = Modernizr.touch || 
(deviceAgent.match(/(iphone|ipod|ipad)/) ||
deviceAgent.match(/(android)/)  || 
deviceAgent.match(/(iemobile)/) || 
deviceAgent.match(/iphone/i) || 
deviceAgent.match(/ipad/i) || 
deviceAgent.match(/ipod/i) || 
deviceAgent.match(/blackberry/i) || 
deviceAgent.match(/bada/i));

if (isTouchDevice) {
        //Do something touchy
    } else {
        //Can't touch this
    }

Si no usa Modernizr, simplemente puede reemplazar la Modernizr.touchfunción anterior con('ontouchstart' in document.documentElement)

También tenga en cuenta que probar el agente de usuario iemobilele dará una gama más amplia de dispositivos móviles de Microsoft detectados que Windows Phone.

También vea esta pregunta SO


Y lo mismo en Dart: TouchEvent.supported.
Kai Sellgren

('ontouchstart' in window)es una alternativa a Modernizr.touch, también, hacks.mozilla.org/2013/04/...~~V~~singular~~3rd
JVE999

¡Creo que modernizr es una gran solución!
Bobby Russell

Realmente deberías usar RegEx en |lugar de muchas coincidencias. Tampoco necesitas el toLowerCase()porque tienes el imodificador. Aquí: var isTouchDevice = Modernizr.touch || /iphone|ipod|ipad|android|iemobile|iphone|ipad|ipod|blackberry|bada/i.test(navigator.userAgent);
oriadam

14

No puede confiar navigator.userAgent, no todos los dispositivos revelan su sistema operativo real. En mi HTC, por ejemplo, depende de la configuración (activar / desactivar la "versión móvil"). En http://my.clockodo.com , simplemente utilizamos screen.widthpara detectar dispositivos pequeños. Desafortunadamente, en algunas versiones de Android hay un error con screen.width. Puede combinarlo de esta manera con el UserAgent:

if(screen.width < 500 ||
 navigator.userAgent.match(/Android/i) ||
 navigator.userAgent.match(/webOS/i) ||
 navigator.userAgent.match(/iPhone/i) ||
 navigator.userAgent.match(/iPod/i)) {
alert("This is a mobile device");
}

8
Muchos móviles tienen un ancho de> 1000, especialmente en modo horizontal
oriadam

14

Sé que esta pregunta tiene muchas respuestas, pero por lo que vi, nadie se acerca a la respuesta de la forma en que resolvería esto.

CSS usa el ancho (Consultas de medios) para determinar qué estilos se aplicaron al documento web basado en el ancho. ¿Por qué no usar el ancho en JavaScript?

Por ejemplo, en las consultas de medios de Bootstrap (Mobile First), existen 4 puntos de ajuste / interrupción:

  • Los dispositivos extra pequeños tienen 768 píxeles y menos.
  • Los dispositivos pequeños varían de 768 a 991 píxeles.
  • Los dispositivos medianos varían de 992 a 1199 píxeles.
  • Los dispositivos grandes tienen 1200 píxeles o más.

Podemos usar esto para resolver también nuestro problema de JavaScript.

Primero crearemos una función que obtenga el tamaño de la ventana y devuelva un valor que nos permita ver qué tamaño de dispositivo está visualizando nuestra aplicación:

var getBrowserWidth = function(){
    if(window.innerWidth < 768){
        // Extra Small Device
        return "xs";
    } else if(window.innerWidth < 991){
        // Small Device
        return "sm"
    } else if(window.innerWidth < 1199){
        // Medium Device
        return "md"
    } else {
        // Large Device
        return "lg"
    }
};

Ahora que tenemos configurada la función, podemos llamarla y almacenar el valor:

var device = getBrowserWidth();

Tu pregunta fue

Me gustaría ejecutar un script diferente si el navegador está en un dispositivo portátil.

Ahora que tenemos la información del dispositivo, todo lo que queda es una declaración if:

if(device === "xs"){
  // Enter your script for handheld devices here 
}

Aquí hay un ejemplo en CodePen: http://codepen.io/jacob-king/pen/jWEeWG


Esto funcionó mejor para mí. Como estaba usando bootstrap para algunas páginas de reenvío móvil, esta técnica funcionó bien para redirigir automáticamente desde un reenvío no móvil (no bootstrap) a una página de arranque. Consejo: Encontré un pequeño problema en las herramientas IE11 F12: tenía la emulación activada en F12 Dev Tools para un dispositivo móvil y tuve problemas para detectar el tamaño de la ventana. Lo había redimensionado por debajo del punto de ruptura xs pero lo estaba detectando como md. Tan pronto apagué la emulación de un teléfono y actualicé la página, detectó correctamente el tamaño y en mi código redirigí a una página de arranque.
Jeff Mergler

Eso es lo que estaba buscando por un tiempo. ¡Gracias!
Desarrollador

2
@JacobKing dijiste que Small Devices range from 768 to 991 pixels.esto significa que debería ser window.innerWidth < 992(991 incluido) lo mismo para 1199, debería ser <1200 en su lugar
medBouzid

13

En una línea de javascript:

var isMobile = ('ontouchstart' in document.documentElement && navigator.userAgent.match(/Mobi/));

Si el agente de usuario contiene 'Mobi' (según MDN) y ontouchstart está disponible, entonces es probable que sea un dispositivo móvil.


1
tuvo que /Mobi/.test(navigator.userAgent)... matchno lo hizo por mí
BananaAcid

12

Me sorprende que nadie haya señalado un buen sitio: http://detectmobilebrowsers.com/ Tiene un código listo en diferentes idiomas para la detección móvil (incluidos, entre otros):

  • apache
  • ÁSPID
  • C#
  • IIS
  • JavaScript
  • NGINX
  • PHP
  • Perl
  • Pitón
  • Rieles

Y si también necesita detectar las tabletas, simplemente consulte la sección Acerca de para obtener un parámetro RegEx adicional.

Las tabletas Android, iPads, Kindle Fires y PlayBooks no se detectan por diseño. Para agregar soporte para tabletas, agregue |android|ipad|playbook|silka la primera expresión regular.


Para mí estaba funcionando, ¿puede ser más específico qué código usa y dónde parece ser un problema?
Maksim Luzik

esa página es respuesta, de todas las demás respuestas son copiar y pegar de esa página
Rubén Ruíz

11

Si no está particularmente preocupado por las pantallas pequeñas, puede usar la detección de ancho / alto. De esta forma, si el ancho es inferior a un cierto tamaño, el sitio móvil se activa. Puede que no sea la forma perfecta, pero probablemente será la más fácil de detectar para múltiples dispositivos. Es posible que deba colocar uno específico para el iPhone 4 (gran resolución).


9

Para agregar una capa adicional de control, uso el almacenamiento HTML5 para detectar si está usando almacenamiento móvil o almacenamiento de escritorio. Si el navegador no admite almacenamiento, tengo una matriz de nombres de navegador móvil y comparo el agente de usuario con los navegadores de la matriz.

Es bastante simple Aquí está la función:

// Used to detect whether the users browser is an mobile browser
function isMobile() {
    ///<summary>Detecting whether the browser is a mobile browser or desktop browser</summary>
    ///<returns>A boolean value indicating whether the browser is a mobile browser or not</returns>

    if (sessionStorage.desktop) // desktop storage 
        return false;
    else if (localStorage.mobile) // mobile storage
        return true;

    // alternative
    mobile = ['iphone','ipad','android','blackberry','nokia','opera mini','windows mobile','windows phone','iemobile','tablet','mobi']; 
    var ua=navigator.userAgent.toLowerCase();
    for (var i in mobile) if (ua.indexOf(mobile[i]) > -1) return true;

    // nothing found.. assume desktop
    return false;
}

1
su suposición basada en localStorage es bastante interesante, ¿puede proporcionar una gama de dispositivos o navegadores compatibles que coincidan correctamente con su script? Estoy interesado en encontrar una solución para esta pregunta que hice, e intentar detectar navegadores de tabletas móviles puede ser una solución interesante
Gruber

9

Si se encuentra que solo verificar navigator.userAgentno siempre es confiable. Se puede lograr una mayor confiabilidad al verificar también navigator.platform. Una modificación simple a una respuesta anterior parece funcionar mejor:

if (/Android|webOS|iPhone|iPad|iPod|BlackBerry/i.test(navigator.userAgent) ||
   (/Android|webOS|iPhone|iPad|iPod|BlackBerry/i.test(navigator.platform))) {
    // some code...
}

55
No se debe permitir la votación arbitraria de una respuesta sin dejar un comentario. En el mejor de los casos, es grosero.
Mark

8

Te aconsejo que revises http://wurfl.io/

En pocas palabras, si importa un pequeño archivo JavaScript:

<script type='text/javascript' src="//wurfl.io/wurfl.js"></script>

Te quedarás con un objeto JSON que se parece a:

{
 "complete_device_name":"Google Nexus 7",
 "is_mobile":true,
 "form_factor":"Tablet"
}

(Eso supone que está utilizando un Nexus 7, por supuesto) y podrá hacer cosas como:

if(WURFL.is_mobile) {
    //dostuff();
}

Esto es lo que estás buscando.

Descargo de responsabilidad: trabajo para la empresa que ofrece este servicio gratuito.


¡Wurfl no pudo detectar nexus7 y iPad mini!
Jacob

Algo no está bien en el Nexus 7. ¿Está seguro de que no tenía la parodia de Nexus de la cadena UA en la configuración? en lo que respecta al iPad mini, sí, eso es muy difícil de distinguir del otro iPad, pero todavía fue reconocido como iPad, ¿verdad? ¿Eres tú quien rechazó mi publicación?
Luca Passani

No, el mini iPad fue detectado como un dispositivo de escritorio
Jacob

7

Echa un vistazo a esta publicación , proporciona un fragmento de código realmente agradable para saber qué hacer cuando se detectan dispositivos táctiles o qué hacer si se llama al evento touchstart:

$(function(){
  if(window.Touch) {
    touch_detect.auto_detected();
  } else {
    document.ontouchstart = touch_detect.surface;
  }
}); // End loaded jQuery
var touch_detect = {
  auto_detected: function(event){
    /* add everything you want to do onLoad here (eg. activating hover controls) */
    alert('this was auto detected');
    activateTouchArea();
  },
  surface: function(event){
    /* add everything you want to do ontouchstart here (eg. drag & drop) - you can fire this in both places */
    alert('this was detected by touching');
    activateTouchArea();
  }
}; // touch_detect
function activateTouchArea(){
  /* make sure our screen doesn't scroll when we move the "touchable area" */
  var element = document.getElementById('element_id');
  element.addEventListener("touchstart", touchStart, false);
}
function touchStart(event) {
  /* modularize preventing the default behavior so we can use it again */
  event.preventDefault();
}

'ontouchstart' in document.documentElementes probablemente una mejor prueba de soporte táctil que window.Touch. Aún mejor, use Modernizr.js ( modernizr.com ) porque he pensado mucho tratando de hacer una detección táctil correcta. Puede ver su código de detección táctil en modernizr.com/downloads/modernizr.js si ve el código de desarrollo y busca "táctil".
robocat

3
La detección táctil me ha metido en problemas, porque algunas nuevas computadoras portátiles con Windows 8 detectan como pantallas táctiles en Chrome, lo que lleva a resultados extraños.
JWarner

6

Aquí hay una función que puede usar para obtener una respuesta verdadera / falsa sobre si está ejecutando en un navegador móvil. Sí, es un buscador de navegador, pero a veces eso es exactamente lo que necesita.

function is_mobile() {
    var agents = ['android', 'webos', 'iphone', 'ipad', 'blackberry'];
    for(i in agents) {
        if(navigator.userAgent.match('/'+agents[i]+'/i')) {
            return true;
        }
    }
    return false;
}

1
Eso no detectará muchos navegadores móviles, especialmente Chrome móvil. Probablemente también fallará en algunos de: Opera Mobile, Firefox mobile, Opera Mini, varios navegadores móviles chinos populares, etc.
robocat

¡No necesitas forpara esto! + Olvidaste crear un RegExp. Aquí hay uno más simple:return !!navigator.userAgent.match(new RegExp(agents.join('|'),'i'))
oriadam

6

Todas las respuestas usan user-agent para detectar el navegador, pero la detección de dispositivos basada en user-agent no es una solución muy buena, mejor es detectar funciones como el dispositivo táctil (en el nuevo jQuery se eliminan $.browsery usan $.supporten su lugar).

Para detectar dispositivos móviles, puede verificar los eventos táctiles:

function is_touch_device() {
  return 'ontouchstart' in window // works on most browsers 
      || 'onmsgesturechange' in window; // works on ie10
}

Tomado de ¿Cuál es la mejor manera de detectar un dispositivo de 'pantalla táctil' usando JavaScript?


44
Desafortunadamente, esto no es confiable y de todos modos regresa trueen computadoras de escritorio con pantallas táctiles. stucox.com/blog/you-cant-detect-a-touchscreen
JustAMartin

1
No olvide las computadoras portátiles con pantallas táctiles y experiencias completas de navegador. :-)
Mike Kormendy

este puede no ser el camino a seguir para verificar si es un dispositivo móvil o no, pero como dice el nombre de su función, es perfecto verificar si hay dispositivos táctiles. +1 de mi parte ;-)
Kathara

6

Sugeriría usar el siguiente combo de cadenas para verificar si se usa el tipo de dispositivo.

Según la cadena de documentación de Mozilla,Mobi se recomienda. Pero, algunas de las tabletas antiguas no devuelven verdadero si solo Mobise usa, por lo tanto, también deberíamos usar Tabletcadenas.

Del mismo modo, por estar en el lado seguro iPady las iPhonecadenas también podrían usarse para verificar el tipo de dispositivo.

La mayoría de los nuevos dispositivos volverían solo truepara la Mobicadena.

if (/Mobi|Tablet|iPad|iPhone/.test(navigator.userAgent)) {
    // do something
}

3
Tuve que agregar "Android" para trabajar en tabletas. Tendré que ajustar pero me gusta el enfoque.
Andy

6

Puede usar la consulta de medios para poder manejarla fácilmente.

isMobile = function(){
    var isMobile = window.matchMedia("only screen and (max-width: 760px)");
    return isMobile.matches ? true : false
}

Me gusta este enfoque, saqué window.matchMedia("(pointer:coarse)").matches;una respuesta diferente.
Jason Lydon

6

Gran respuesta gracias. Pequeña mejora para admitir Windows phone y Zune:

if (navigator.userAgent.match(/Android/i) ||
  navigator.userAgent.match(/webOS/i) ||
  navigator.userAgent.match(/iPhone/i) ||
  navigator.userAgent.match(/iPad/i) ||
  navigator.userAgent.match(/iPod/i) ||
  navigator.userAgent.match(/BlackBerry/) ||
  navigator.userAgent.match(/Windows Phone/i) ||
  navigator.userAgent.match(/ZuneWP7/i)
) {
  // some code
  self.location = "top.htm";
}

Yo diría que esta es la solución más simple (quizás no la mejor) si está tratando de manejar eventos de desplazamiento / arrastre para dispositivos móviles. Utilizo algo como esto para crear un booleano "isMobile" que luego se verifica para cada evento de desplazamiento / desplazamiento del mouse. Esos son mis dos centavos, de todos modos. Agregar más bibliotecas js o código que requiera la interacción del usuario no tiene mucho sentido para mí; corrígeme si me equivoco.
MeanMatt

3
Como estás usando expresiones regulares, en realidad if (navigator.userAgent.match(/Android|webOS|iPhone|iPad|etc/)){self.location = "top.htm"}
úsalas

5

Utilizar este:

/**  * jQuery.browser.mobile (http://detectmobilebrowser.com/)  * jQuery.browser.mobile will be true if the browser is a mobile device  **/ (function(a){jQuery.browser.mobile=/android.+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|symbian|treo|up\.(browser|link)|vodafone|wap|windows (ce|phone)|xda|xiino/i.test(a)||/1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|e\-|e\/|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(di|rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|xda(\-|2|g)|yas\-|your|zeto|zte\-/i.test(a.substr(0,4))})(navigator.userAgent||navigator.vendor||window.opera);

Entonces usa esto:

if(jQuery.browser.mobile)
{
   console.log('You are using a mobile device!');
}
else
{
   console.log('You are not using a mobile device!');
}

5

Función simple basada en http://detectmobilebrowser.com/

function isMobile() {
    var a = navigator.userAgent||navigator.vendor||window.opera;
    return /(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows (ce|phone)|xda|xiino/i.test(a)||/1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i.test(a.substr(0,4));
}

5
<script>
  function checkIsMobile(){
      if(navigator.userAgent.indexOf("Mobile") > 0){
        return true;
      }else{
        return false;
      }
   }
</script>

Si pasa a cualquier navegador y trata de obtener navigator.userAgent, obtendremos la información del navegador de la siguiente manera:

Mozilla / 5.0 (Macintosh; Intel Mac OS X 10_13_1) AppleWebKit / 537.36 (KHTML, como Gecko) Chrome / 64.0.3282.186 Safari / 537.36

Lo mismo si haces en el móvil, recibirás seguimiento

Mozilla / 5.0 (Linux; Android 8.1.0; Pixel Build / OPP6.171019.012) AppleWebKit / 537.36 (KHTML, como Gecko) Chrome / 61.0.3163.98 Mobile Safari / 537.36

Cada navegador móvil tendrá un agente de uso con una cadena que contenga "Móvil". Por lo tanto, estoy usando el fragmento anterior en mi código para verificar si el agente de usuario actual es web / móvil. Según el resultado, haré los cambios necesarios.


4

yo uso esto

if(navigator.userAgent.search("mobile")>0 ){
         do something here
}

4

¿Qué tal mobiledetect.net ?

Otras soluciones parecen demasiado básicas. Esta es una clase PHP ligera. Utiliza la cadena de User-Agent combinada con encabezados HTTP específicos para detectar el entorno móvil. También puede beneficiarse de Mobile Detect utilizando cualquiera de los complementos de terceros disponibles para: WordPress, Drupal, Joomla, Magento, etc.


¿Porque la pregunta pedía jQuery?
Craicerjack

3

No se debe confiar solo en las cadenas de agente de usuario. La solución a continuación funcionará en todas las situaciones.

function isMobile(a) {
  return (/(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino/i.test(a) || /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i.test(a.substr(0, 4)));
}

y llama a esta función:

isMobile(navigator.userAgent || navigator.vendor || window.opera)
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.