Détecter la version de IE (avant v9) en JavaScript

Je veux rebondir les utilisateurs de notre site web à une page d'erreur si ils utilisent une version de Internet Explorer avant v9. C'est juste pas la peine de notre temps et de l'argent pour soutenir IE pre-v9. Les utilisateurs de tous les autres non-IE navigateurs sont très bien et ne devrait pas être sans provision. Voici le code proposé:

if(navigator.appName.indexOf("Internet Explorer")!=-1){     //yeah, he's using IE
    var badBrowser=(
        navigator.appVersion.indexOf("MSIE 9")==-1 &&   //v9 is ok
        navigator.appVersion.indexOf("MSIE 1")==-1  //v10, 11, 12, etc. is fine too
    );

    if(badBrowser){
        //navigate to error page
    }
}

Sera présent code faire l'affaire?

À la tête de quelques commentaires qui seront probablement à venir à ma façon:

Oui, je sais que les utilisateurs puissent se forger leur useragent chaîne. Je ne suis pas concerné.
Oui, je sais que la programmation des pros préfèrent flairer la fonction de soutien au lieu de navigateur-type, mais je ne ressens pas cette approche a du sens dans ce cas. Je sais déjà que tous (les) non-IE des navigateurs prennent en charge les fonctionnalités dont j'ai besoin et que tous les pre-v9 IE les navigateurs ne le font pas. Vérification de la fonctionnalité par fonctionnalité sur tout le site serait un gaspillage.
Oui, je sais que quelqu'un essaie d'accéder au site en utilisant IE v1 (ou >= 20) ne serait pas obtenir 'badBrowser' la valeur true et que la page d'avertissement de ne pas être affichées correctement. C'est un risque que nous sommes prêts à prendre.
Oui, je sais que Microsoft a "commentaires conditionnels" qui peut être utilisé pour préciser la version du navigateur de détection. IE ne supporte plus les commentaires conditionnels comme de IE 10, ce qui rend cette approche tout à fait inutile.

Tout autre problème évident d'être au courant?

"C'est juste pas la peine de notre temps et de l'argent pour soutenir IE pré-v9". Je souhaite que je pourrais le faire.
Fondé sur le point [2] je ne vais pas suggérer Modernizr (en.wikipedia.org/wiki/Modernizr) - tout le monde a tracer une ligne dans le sable quelque part - mais IE9 semble comme une ligne haute
Nous avons un petit auditoire captif. Pratiquement tous les utilisateurs utilisent décent navigateurs à l'exception de quelques WinXP gars qui ne sont pas admissibles à la mise à niveau vers IE9. Ce sont les mecs qui je suis ciblage avec ce message d'erreur.
Une idée intéressante. Donc, à l'aide de "commentaires conditionnels" dans IE 10 ne cause pas de IE10 pour étouffer? Il va juste être ignoré? Si oui, alors ce que vous dites fait beaucoup de sens.
Les commentaires conditionnels sont juste des commentaires. Seul IE interprète comme des particuliers. IE10+ ne le fais plus.
Les commentaires conditionnels seront traités exactement de la même façon par IE 10 en tant que non-IE navigateurs. Ils sont valides HTML commentaires seront traités comme tels. Je suis d'accord avec Andreas et pense que les commentaires conditionnels est le chemin à parcourir.
La documentation officielle qui dit que IE10+ ne sont pas compatibles avec les commentaires conditionnels: blogs.msdn.com/b/ie/archive/2011/07/06/... - Grâce à: stackoverflow.com/a/9900331/320399
La réponse sélectionnée est incorrecte et ne marche pas pour ie11. voir ma réponse
Qui se soucie si IE10 prend en charge les commentaires conditionnels si ce n'est pas l'un des navigateurs que vous essayez de détecter? Vous n'avez pas besoin de détecter si c'est IE 9 ou supérieur, vous avez seulement besoin de détecter si c'est IE8 ou moins. Votre erreur est de penser que vous avez besoin de comprendre ce que c'est dans le but de comprendre ce que ça ne l'est pas. Ce n'est pas vrai. Vous n'avez pas besoin de détecter IE10, vous avez seulement besoin de savoir que ce n'est PAS IE8 (ou inférieur). Tout code que vous mettez dans un lt IE 9 conditionnelle sera exécuté dans IE8 et ci-dessous et nulle part ailleurs. Aussi simple que cela. C'est la seule chose que Microsoft n'a droit avec IE.
Seulement deux mois de plus avant que nous puissions danser sur IE8 est grave... j'espère que c'est juste quelques années avant que nous puissions tous fossé IE prise en charge...

InformationsquelleAutor Chad Decker | 2012-06-09

353

C'est ma façon préférée de le faire. Il offre un maximum de contrôle. (Remarque: les instructions Conditionnelles ne sont pris en charge dans IE5 - 9.)

D'abord configurer votre ie classes correctement
```
<!DOCTYPE html>



 <html>     
<head>
```
Alors vous pouvez simplement utiliser CSS pour faire style exceptions, ou, si vous le souhaitez, vous pouvez ajouter un peu de JavaScript simple:
```
(function ($) {
    "use strict";

    //Detecting IE
    var oldIE;
    if ($('html').is('.lt-ie7, .lt-ie8, .lt-ie9')) {
        oldIE = true;
    }

    if (oldIE) {
        //Here's your JS for IE..
    } else {
        //..And here's the full-fat code for everyone else
    }

}(jQuery));
```
Grâce à Paul Irish.
- Étant donné que l'OP a demandé purement JavaScript solution, je crois que la réponse par @Tim vers le Bas ci-dessous est la meilleure, car elle n'implique pas de changer le code HTML existant, et en plus c'est pas à l'aide de jQuery: stackoverflow.com/a/10965203/134120
- J'obtiens une erreur avec ce sur w3 html validator: Error: Saw <html
InformationsquelleAutor Jezen Thomas
161

Retour version de IE ou si pas IE return false
```
function isIE () {
  var myNav = navigator.userAgent.toLowerCase();
  return (myNav.indexOf('msie') != -1) ? parseInt(myNav.split('msie')[1]) : false;
}
```
Exemple:
```
if (isIE () == 8) {
 //IE8 code
} else {
 //Other versions IE or not IE
}
```
ou
```
if (isIE () && isIE () < 9) {
 //is IE version less than 9
} else {
 //is IE 9 and later or not IE
}
```
ou
```
if (isIE()) {
 //is IE
} else {
 //Other browser
}
```
- Ne fonctionne pas pour IE11. À partir de IE 11, ils ont changé la chaîne de l'agent utilisateur pour "mozilla/5.0 (windows nt 6.3; wow64; trident/7.0; .net4.0e; .net4.0c; media center pc 6.0; .net clr 3.5.30729; .net clr 2.0.50727; .net clr 3.0.30729; rv:11.0) like gecko"
- Veuillez noter que dans FF "false < 9" est "vrai". Donc, l'état doit être if (isIE () && isIE () < 9) {
- ie 10 a été coup de pied un 7.
- peut-être qu'il était en cours d'exécution dans IE7 en mode standard? msdn.microsoft.com/en-us/library/ie/cc196988(v=vs. 85).aspx
- pour le faire fonctionner, j'ai dû faire quelque chose comme ceci: jsfiddle.net/4pbdm
- La approuvée réponse est comment détecter la version de IE en HTML. Ceci répond à la question d'origine.
- Cela fonctionne pour toutes les versions IE stackoverflow.com/a/21712356
- Ce sont des ouvrages pour IE9 et IE8.. Merci!
- Ne fonctionne pas pour Microsoft Edge 38.xxx , return false
- Microsoft Edge n'est pas Internet Explorer. Donc, pour en revenir faux semble être la bonne chose pour elle de le faire.
- yah a obtenu. merci.
InformationsquelleAutor weroro
120

Si personne d'autre a ajouté une addEventLister-méthode et que vous utilisez le bon mode navigateur, alors vous pouvez le vérifier IE 8 ou moins, avec
```
if (window.attachEvent && !window.addEventListener) {
    //"bad" IE
}
```
Héritage Internet Explorer et attachEvent (MDN)
- Cela semble être le moyen le plus efficace pour détecter IE <= 8 entièrement en JavaScript et est idéal pour les gens comme moi qui étaient à la recherche d'un moyen de le faire.
- cela mérite plus upvotes .
- Super! Cette détecte également IE9 en Mode Quirks, qui est ce que j'ai été à la recherche pour.
- Bien que ce soit un "facile à utiliser" solution, il comporte des risques. N'importe qui dans votre société (qui n'est pas conscient de votre solution) peut mettre en œuvre "addEventListener" ou "attachEvent" pour faire face au manque de dans internet explorer 8. Et puis, votre code d'arrêt de travail.
- Et ce n'est pas de travail?
- Ce tests pour IE8. Pourquoi diable devrait-il retourner la valeur true sur IE11?
- oups. ne voit pas que l'OP veut avant ie9. la suppression de.
InformationsquelleAutor Andreas
114

Utiliser les commentaires conditionnels. Vous essayez de détecter les utilisateurs de IE < 9 et les commentaires conditionnels travailleront dans ces navigateurs; dans d'autres navigateurs (IE >= 10 et non-IE), les commentaires seront traités comme normale commentaires HTML, qui est ce qu'ils sont.

Exemple HTML:
```

```
Vous pouvez également le faire uniquement avec des script, si vous avez besoin de:
```
var div = document.createElement("div");
div.innerHTML = "";
var isIeLessThan9 = (div.getElementsByTagName("i").length == 1);
if (isIeLessThan9) {
    alert("WE DON'T LIKE YOUR BROWSER");
}
```
- La version JavaScript de @Tim de Down réponse a très bien fonctionné pour moi. J'ai utilisé BrowserStack de le tester avec Windows 7 et IE 8, 9, 10 et 11, Mac OS X Snow Leopard avec Safari 5.1, Firefox 28.0, Chrome 33,0 et de l'Opéra 20.0; iPhone 5 Mobile Safari, Android et Samsung Galaxy Tab 2 10.1 4.0. Comme prévu, seulement IE8 a déclaré qu'il était IeLessThan9. Nice!
InformationsquelleAutor Tim Down
55

Pour détecter MSIE (v6 - v7 - v8 - v9 - v10 - v11) facilement :
```
if (navigator.userAgent.indexOf('MSIE') !== -1 || navigator.appVersion.indexOf('Trident/') > 0) {
   //MSIE
}
```
- Utile pour détecter les IE10, car il ne supporte pas les commentaires conditionnels. Ne fonctionne pas dans IE11, mais IE11 a généralement un bon comportement
- - Je modifier ma réponse à l'appui de IE10 et IE11.
- Enfin une réponse qui n'a pas conférence sur l'utilisation de la fonctionnalité de détection et répond vraiment à la question.
InformationsquelleAutor EpokK
30

Ici est la façon dont AngularJS vérifie pour IE
```
/**
 * documentMode is an IE-only property
 * http://msdn.microsoft.com/en-us/library/ie/cc196988(v=vs.85).aspx
 */
var msie = document.documentMode;

if (msie < 9) {
    //code for IE < 9
}
```
- Wow c'est tellement plus simple que tous le conditionnel les commentaires! Pas de limitations de cela?
- selon les docs, IE8+ prend en charge cette propriété donc, je pense, devrait être suffisant pour la plupart des cas.
- Par la référence MSDN, "Quand le document n'a pas encore été déterminé, documentMode renvoie une valeur de zéro (0). Cela se produit généralement lorsqu'un document est en cours de chargement." Est-ce à dire que vous ne pourriez pas obtenir une réponse valable à l'intérieur d'un script chargé dans <head>?
- Je pense que vous pouvez résoudre le problème en vérifiant la valeur de la fenêtre.onload lorsque le document est déjà chargé.
InformationsquelleAutor iurii
27

Fiable filtre IE8 et plus, la vérification des objets globaux peut être utilisé:
```
if (document.all && !document.addEventListener) {
    alert('IE8 or lower');
}
```
- document.tous - et Pas pris en charge dans IE 11 - msdn.microsoft.com/en-us/library/ie/ms537434%28v=vs.85%29.aspx
- Ce qui est bien si vous essayez de test pour IE<9 - la si la condition sera fausse.
InformationsquelleAutor Beaudinn Greve
16

Cette fonction retourne le IE numéro de version majeure comme un entier, ou undefined si le navigateur n'est pas Internet Explorer. Cela, comme tout agent utilisateur des solutions, est suceptible d'utilisateur de l'usurpation d'agent (qui a été un dispositif officiel de l'ei depuis la version 8).
```
function getIEVersion() {
    var match = navigator.userAgent.match(/(?:MSIE |Trident\/.*; rv:)(\d+)/);
    return match ? parseInt(match[1]) : undefined;
}
```
- Owen, comment l'utiliser en pratique? Comment récupérer la valeur de retour? J'ai essayé console.log(!!match && parseInt(match[1])), console.log(parseInt(match[1])) et console.log(match), mais pas de résultat avec l'un d'eux.
- Obtenir la valeur renvoyée par l'appel de la fonction elle-même getIEVersion(). Par exemple: if (getIEVersion() < 9) {/* IE 8 or below */} if (!getIEVersion()) {/* Not IE */}
InformationsquelleAutor Owen

La détection de la version de IE à l'aide de la fonctionnalité de détection (IE6+, navigateurs avant IE6 sont détectés comme 6, renvoie la valeur null pour les non-IE navigateurs):

var ie = (function (){
    if (window.ActiveXObject === undefined) return null; //Not IE
    if (!window.XMLHttpRequest) return 6;
    if (!document.querySelector) return 7;
    if (!document.addEventListener) return 8;
    if (!window.atob) return 9;
    if (!document.__proto__) return 10;
    return 11;
})();

Edit: j'ai créé une charmille/mnp repo pour votre confort: ie-version

Mise à jour:

une version plus compacte peut être écrite sur une seule ligne comme:

return window.ActiveXObject === undefined ? null : !window.XMLHttpRequest ? 6 : !document.querySelector ? 7 : !document.addEventListener ? 8 : !window.atob ? 9 : !document.__proto__ ? 10 : 11;

C'est ce que je cherche, merci. Mais comment détecter IE 6?
aller sur le lien...
voir mise à jour de réponse
ok, merci pour vous.

InformationsquelleAutor Gabriel Llamas

Détecter IE en JS en utilisant les commentaires conditionnels

//----------------------------------------------------------
//A short snippet for detecting versions of IE in JavaScript
//without resorting to user-agent sniffing
//----------------------------------------------------------
//If you're not in IE (or IE version is less than 5) then:
//    ie === undefined
//If you're in IE (>=5) then you can determine which version:
//    ie === 7; //IE7
//Thus, to detect IE:
//    if (ie) {}
//And to detect the version:
//    ie === 6 //IE6
//    ie > 7 //IE8, IE9 ...
//    ie < 9 //Anything less than IE9
//----------------------------------------------------------

//UPDATE: Now using Live NodeList idea from @jdalton

var ie = (function(){

    var undef,
        v = 3,
        div = document.createElement('div'),
        all = div.getElementsByTagName('i');

    while (
        div.innerHTML = '<!--[if gt IE ' + (++v) + ']><i></i><![endif]-->',
        all[0]
    );

    return v > 4 ? v : undef;

}());

C'est à peu près le même que ma réponse.
Peut-être, mais cette réponse est un peu plus complet (il vous indique le numéro de version), et est bien commenté. En outre, le lien au début de cette réponse conduit à une Gist avec plusieurs des commentaires et des informations et des variations intéressantes sur cette technique.
Juste des points. J'ai adapté la mine à la question, mais n'ai pas citer la source.

InformationsquelleAutor jKey

12

Cela fonctionne pour moi. Je l'utilise comme une redirection vers une page qui explique pourquoi nous n'aimons pas les < IE9 et fournir des liens vers les navigateurs que nous préférons.
```

```
- Ohw, c'est un sale une seule. J'ai utiliser une méthode favorable à, afficher un div avec les regards de IE et d'avertissement lorsque le visiteur clic dessus, l'utilisateur va browsehappy.com
InformationsquelleAutor iconMatrix
10

Votre code peut faire le vérifier, mais comme vous avez pensé, si quelqu'un tente d'accéder à votre page en utilisant IE v1 ou > v19 ne sera pas obtenir de l'erreur, donc peut-être plus sûre de faire le chèque avec la Regex expression comme ce code ci-dessous:
```
var userAgent = navigator.userAgent.toLowerCase();
//Test if the browser is IE and check the version number is lower than 9
if (/msie/.test(userAgent) && 
    parseFloat((userAgent.match(/.*(?:rv|ie)[\/: ](.+?)([ \);]|$)/) || [])[1]) < 9) {
  //Navigate to error page
}
```
- Ce n'est pas une bonne réponse. UA-sniffing est pas fiable. Plus à ce sujet ici: modernizr.com/docs
- Parfois UA-sniffing est le chemin à parcourir: github.com/Modernizr/Modernizr/issues/538
InformationsquelleAutor Fong-Wan Chau

Commentaires conditionnels ne sont plus pris en charge dans IE à partir de la Version 10 comme indiqué sur la Microsoft page de référence.

JS:

var ieDetector = function() {
var browser = { //browser object
verIE: null,
docModeIE: null,
verIEtrue: null,
verIE_ua: null
},
tmp;
tmp = document.documentMode;
try {
document.documentMode = "";
} catch (e) {};
browser.isIE = typeof document.documentMode == "number" || eval("/*@cc_on!@*/!1");
try {
document.documentMode = tmp;
} catch (e) {};
//We only let IE run this code.
if (browser.isIE) {
browser.verIE_ua =
(/^(?:.*?[^a-zA-Z])??(?:MSIE|rv\s*\:)\s*(\d+\.?\d*)/i).test(navigator.userAgent || "") ?
parseFloat(RegExp.$1, 10) : null;
var e, verTrueFloat, x,
obj = document.createElement("div"),
CLASSID = [
"{45EA75A0-A269-11D1-B5BF-0000F8051515}", //Internet Explorer Help
"{3AF36230-A269-11D1-B5BF-0000F8051515}", //Offline Browsing Pack
"{89820200-ECBD-11CF-8B85-00AA005B4383}"
];
try {
obj.style.behavior = "url(#default#clientcaps)"
} catch (e) {};
for (x = 0; x < CLASSID.length; x++) {
try {
browser.verIEtrue = obj.getComponentVersion(CLASSID[x], "componentid").replace(/,/g, ".");
} catch (e) {};
if (browser.verIEtrue) break;
};
verTrueFloat = parseFloat(browser.verIEtrue || "0", 10);
browser.docModeIE = document.documentMode ||
((/back/i).test(document.compatMode || "") ? 5 : verTrueFloat) ||
browser.verIE_ua;
browser.verIE = verTrueFloat || browser.docModeIE;
};
return {
isIE: browser.isIE,
Version: browser.verIE
};
}();
document.write('isIE: ' + ieDetector.isIE + "<br />");
document.write('IE Version Number: ' + ieDetector.Version);

alors utiliser:

if((ieDetector.isIE) && (ieDetector.Version <= 9))
{
}

C'était la seule chose qui a travaillé sur le net, au moins la humongus de choses que j'ai essayé...merci 😉
Ce code est bon, mais ne peut pas détecter le mode affichage de compatibilité. Je suis sur IE 11 à l'aide de compatibilité vue dans IE 8, et ce code donne toujours version 11 EDIT: Ce code est INCROYABLE! haha, il donne un objet avec tout à l'intérieur. Version 11 mais docModeIR est égal à 9. Merci!

InformationsquelleAutor Arnold.Krumins

5

Pour ie 10 et 11:

Vous pouvez utiliser js et ajouter une classe dans le html pour le maintien de la norme de les commentaires conditionnels:
```
  var ua = navigator.userAgent,
doc = document.documentElement;
if ((ua.match(/MSIE 10.0/i))) {
doc.className = doc.className + " ie10";
} else if((ua.match(/rv:11.0/i))){
doc.className = doc.className + " ie11";
}
```
Ou utiliser une lib comme bowser:

https://github.com/ded/bowser

Ou modernizr pour la détection de fonctionnalité:

http://modernizr.com/
- J'ai essayé quelques scripts et des solutions, mais rien n'a fonctionné. Puis j'ai compris bowser dans le projet et il a travaillé. Donc pour ce qui suggère bowser.
InformationsquelleAutor Liko
3

Pour détecter Internet Explorer 10 et 11, vous pouvez utiliser ce petit script immédiatement après la balise body:

Dans mon cas, j'ai utiliser la bibliothèque jQuery est chargé dans la tête.
```
<!DOCTYPE HTML>
<html>
<head>
<script src="//code.jquery.com/jquery-1.11.0.min.js"></script>
</head>
<body>
<script>if (navigator.appVersion.indexOf('Trident/') != -1) $("body").addClass("ie10");</script>
</body>
</html>
```
- J'aime cette grâce, je n'ai besoin de détecter de 10 ou 11 ans que je n'ai pas de support des versions antérieures
- IE9 est également trident, mais pas de même avec le support de CSS. Votre détection pense est d'au moins 10, mais ce n'est pas correct.
InformationsquelleAutor Brian
3

Ce qui a été répondu à mort, mais c'est tout ce dont vous avez besoin.
```
!!navigator.userAgent.match(/msie\s[5-8]/i)
```
- Aussi, ici, est un bac à sable montrant que l'expression régulière pattern contre les plus fréquentes IE chaînes d'agent utilisateur: regex101.com/r/lC6oP3/1
- Ce code renvoie false sur IE11...
- Mais il est censé le faire, n'est-ce pas? OP voulais tester < 9...
InformationsquelleAutor Timothy Perez

var Browser = new function () {
var self = this;
var nav = navigator.userAgent.toLowerCase();
if (nav.indexOf('msie') != -1) {
self.ie = {
version: toFloat(nav.split('msie')[1])
};
};
};
if(Browser.ie && Browser.ie.version > 9)
{
//do something
}

InformationsquelleAutor Berezh

Selon Microsoft, à la suite est la meilleure solution, il est également très simple:

function getInternetExplorerVersion()
//Returns the version of Internet Explorer or a -1
//(indicating the use of another browser).
{
var rv = -1; //Return value assumes failure.
if (navigator.appName == 'Microsoft Internet Explorer')
{
var ua = navigator.userAgent;
var re  = new RegExp("MSIE ([0-9]{1,}[\.0-9]{0,})");
if (re.exec(ua) != null)
rv = parseFloat( RegExp.$1 );
}
return rv;
}
function checkVersion()
{
var msg = "You're not using Internet Explorer.";
var ver = getInternetExplorerVersion();
if ( ver > -1 )
{
if ( ver >= 8.0 ) 
msg = "You're using a recent copy of Internet Explorer."
else
msg = "You should upgrade your copy of Internet Explorer.";
}
alert( msg );
}

Ne fonctionne pas pour IE11. Je sais que c'est vieux la réponse.
En effet, et juste au cas où quelqu'un d'autre terres d'essayer d'utiliser ce qui précède, le code dans un plus tard, la réponse n'travail pour IE11 ( stackoverflow.com/a/26375930/1129926). Mais méfiez-vous, ça va marcher pour IE12, etc.? Ligne du bas est, de son mieux pour tenir compte de ces temporaires hacks et ils sont susceptibles d'échouer plus tard que les nouvelles versions de navigateurs sortir (je ne mentionne même pas le Bord).

InformationsquelleAutor AHH

1

Je vais vous recommandons de ne pas réécrire ce code pour la énième fois. Je vous recommande d'utiliser le Conditionizr bibliothèque ( http://conditionizr.com/ ), qui est capable de tests spécifiques pour les versions IE ainsi que d'autres navigateurs, systèmes d'exploitation, et même la présence ou l'absence de la Rétine affiche.

Inclure le code uniquement pour les tests dont vous avez besoin et vous obtenez également l'avantage d'une testé la bibliothèque qui a été à travers de nombreuses itérations (et qui serait facile à mettre à jour sans casser votre code).

Il a également mailles bien avec Modernizr qui permet de traiter tous les cas où vous êtes mieux de test pour une capacité spécifique plutôt que d'un navigateur spécifique.

InformationsquelleAutor John Munsch

Je fais comme ça:

<script>
function isIE () {
var myNav = navigator.userAgent.toLowerCase();
return (myNav.indexOf('msie') != -1) ? parseInt(myNav.split('msie')[1]) : false;
}    
var ua = window.navigator.userAgent;
//Internet Explorer | if | 9-11
if (isIE () == 9) {
alert("Shut down this junk! | IE 9");
} else if (isIE () == 10){
alert("Shut down this junk! | IE 10");
} else if (ua.indexOf("Trident/7.0") > 0) {
alert("Shut down this junk! | IE 11");
}else{
alert("Thank god it's not IE!");
}
</script>

InformationsquelleAutor Julio Cesar Boaroli

1

Cette approche pour la détection IE combine les points forts et évite les faiblesses de jKey de la réponse à l'aide de commentaires conditionnels et Owen réponse de l'utilisateur en utilisant des agents.
- jKey l'approche des œuvres jusqu'à la version 9 et le système immunitaire de l'utilisateur de l'usurpation d'agent dans IE 8 & 9.
- Owen approche ne peut échouer sur IE 5 & 6 (7 rapports) et est sensible à l'UA d'usurpation d'identité, mais il peut détecter les versions IE >= 10 (qui inclut désormais des 12, qui est postérieure à Owen de réponse).
```
//----------------------------------------------------------
//A short snippet for detecting versions of IE
//----------------------------------------------------------
//If you're not in IE (or IE version is less than 5) then:
//    ie === undefined
//Thus, to detect IE:
//    if (ie) {}
//And to detect the version:
//    ie === 6 //IE6
//    ie > 7 //IE8, IE9 ...
//----------------------------------------------------------
var ie = (function(){
var v = 3,
div = document.createElement('div'),
all = div.getElementsByTagName('i');
while (
div.innerHTML = '',
all[0]
);
if (v <= 4) { //Check for IE>9 using user agent
var match = navigator.userAgent.match(/(?:MSIE |Trident\/.*; rv:|Edge\/)(\d+)/);
v = match ? parseInt(match[1]) : undefined;
}
return v;
}());
```
Ceci peut être utilisé pour définir les classes utiles à votre document contenant la version de IE:
```
    if (ie) {
document.documentElement.className += ' ie' + ie;
if (ie < 9)
document.documentElement.className += ' ieLT9';
}
```
Noter qu'il détecte le mode de compatibilité être utilisé, si IE est en mode de compatibilité. Notez également que la version de IE est surtout utile pour les versions plus anciennes (<10); les versions supérieures sont plus conformes aux normes et il est probablement mieux au lieu de vérifier les fonctionnalités en utilisant quelque chose comme modernizr.js.

InformationsquelleAutor jtbr

J'ai fait une pratique de soulignement mixin pour cela.

_.isIE();        //Any version of IE?
_.isIE(9);       //IE 9?
_.isIE([7,8,9]); //IE 7, 8 or 9?

JS:

_.mixin({
isIE: function(mixed) {
if (_.isUndefined(mixed)) {
mixed = [7, 8, 9, 10, 11];
} else if (_.isNumber(mixed)) {
mixed = [mixed];
}
for (var j = 0; j < mixed.length; j++) {
var re;
switch (mixed[j]) {
case 11:
re = /Trident.*rv\:11\./g;
break;
case 10:
re = /MSIE\s10\./g;
break;
case 9:
re = /MSIE\s9\./g;
break;
case 8:
re = /MSIE\s8\./g;
break;
case 7:
re = /MSIE\s7\./g;
break;
}
if (!!window.navigator.userAgent.match(re)) {
return true;
}
}
return false;
}
});
console.log(_.isIE());
console.log(_.isIE([7, 8, 9]));
console.log(_.isIE(11));

HTML:

<script src="https://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.8.3/underscore-min.js"></script>

InformationsquelleAutor danrichards

ou tout simplement

//  IE 10: ua = 'Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; Trident/6.0)'; 
//  IE 11: ua = 'Mozilla/5.0 (Windows NT 6.3; Trident/7.0; rv:11.0) like Gecko'; 
//Edge 12: ua = 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.71 Safari/537.36 Edge/12.0'; 
//Edge 13: ua = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2486.0 Safari/537.36 Edge/13.10586'; 
var isIE = navigator.userAgent.match(/MSIE|Trident|Edge/)
var IEVersion = ((navigator.userAgent.match(/(?:MSIE |Trident.*rv:|Edge\/)(\d+(\.\d+)?)/)) || []) [1]

InformationsquelleAutor Giacomo

0

Le plus complet du JS script que j'ai trouvé pour vérifier les versions d'IE est http://www.pinlady.net/PluginDetect/IE/. L'ensemble de la bibliothèque est à http://www.pinlady.net/PluginDetect/Browsers/.

Avec IE10, les instructions conditionnelles sont plus pris en charge.

Avec IE11, l'agent de l'utilisateur ne contient plus de MSIE. Aussi, à l'aide de l'agent utilisateur n'est pas fiable parce que cela peut être modifié.

À l'aide de la PluginDetect JS script, vous pouvez détecter pour IE et de détecter les versions exactes en utilisant très spécifique et très bien conçue code qui cible spécifiquement les versions IE. Ceci est très utile lorsque vous vous souciez exactement quelle version de navigateur que vous travaillez avec.

InformationsquelleAutor PressingOnAlways
0

Je me rends compte que je suis un peu en retard à la fête ici, mais j'avais été vérifier sur une simple ligne de façon à fournir des commentaires sur l'opportunité d'un navigateur est IE et quelle version de 10 descente. Je n'ai pas codé ce pour la version 11, donc peut-être un peu de modification sera nécessaire pour cela.

Cependant, c'est le code, il fonctionne comme un objet qui a une propriété et une méthode et s'appuie sur la détection d'objet plutôt que de le raclage de l'objet navigator (qui est massivement des lacunes, car il peut être usurpée).
```
var isIE = { browser:/*@cc_on!@*/false, detectedVersion: function () { return (typeof window.atob !== "undefined") ? 10 : (typeof document.addEventListener !== "undefined") ? 9 : (typeof document.querySelector !== "undefined") ? 8 : (typeof window.XMLHttpRequest !== "undefined") ? 7 : (typeof document.compatMode !== "undefined") ? 6 : 5; } };
```
L'utilisation est isIE.browser une propriété qui retourne un booléen et s'appuie sur les commentaires conditionnels de la méthode isIE.detectedVersion() qui renvoie un nombre entre 5 et 10. Je fais l'hypothèse que tout ce qui est inférieur à 6, et vous êtes sérieux old school territoire et vous aurez quelque chose de plus costaud qu'une seule ligne et de tout ce qui dépasse 10 et vous êtes dans de nouveaux territoires. J'ai lu quelque chose à propos de IE11 en ne soutenant pas les commentaires conditionnels, mais je n'ai pas une enquête, c'est peut-être pour une date ultérieure.

De toute façon, comme il est, et pour une seule ligne, il couvrira les bases de navigateur IE et la détection de la version. Il est loin d'être parfait, mais il est petit et facilement modifié.

Juste pour la référence, et si quelqu'un a un doute sur la façon de mettre en œuvre ce la conditionnels suivants devraient vous aider.
```
var isIE = { browser:/*@cc_on!@*/false, detectedVersion: function () { return (typeof window.atob !== "undefined") ? 10 : (typeof document.addEventListener !== "undefined") ? 9 : (typeof document.querySelector !== "undefined") ? 8 : (typeof window.XMLHttpRequest !== "undefined") ? 7 : (typeof document.compatMode !== "undefined") ? 6 : 5; } };
/* testing IE */
if (isIE.browser) {
alert("This is an IE browser, with a detected version of : " + isIE.detectedVersion());
}
```
InformationsquelleAutor Ric

La détection d'IE et de ses versions ne pouvait pas être plus facile, et tous vous avez besoin est un peu de natif/vanille Javascript:

var uA = navigator.userAgent;
var browser = null;
var ieVersion = null;
if (uA.indexOf('MSIE 6') >= 0) {
browser = 'IE';
ieVersion = 6;
}
if (uA.indexOf('MSIE 7') >= 0) {
browser = 'IE';
ieVersion = 7;
}
if (document.documentMode) { //as of IE8
browser = 'IE';
ieVersion = document.documentMode;
}

C'est une façon de l'utiliser:

if (browser == 'IE' && ieVersion <= 9) 
document.documentElement.className += ' ie9-';

Fonctionne dans toutes les versions IE, y compris les versions supérieures, dans le bas-Compatibilité Affichage/Mode, et documentMode est IE propriétaire.

InformationsquelleAutor Frank Conijn

Si vous avez besoin de delect IE version du Navigateur, alors vous pouvez suivre ci-dessous de code. Ce code fonctionne bien pour la version IE6 à IE11

<!DOCTYPE html>
<html>
<body>
<p>Click on Try button to check IE Browser version.</p>
<button onclick="getInternetExplorerVersion()">Try it</button>
<p id="demo"></p>
<script>
function getInternetExplorerVersion() {
var ua = window.navigator.userAgent;
var msie = ua.indexOf("MSIE ");
var rv = -1;
if (msie > 0 || !!navigator.userAgent.match(/Trident.*rv\:11\./))      //If Internet Explorer, return version number
{               
if (isNaN(parseInt(ua.substring(msie + 5, ua.indexOf(".", msie))))) {
//For IE 11 >
if (navigator.appName == 'Netscape') {
var ua = navigator.userAgent;
var re = new RegExp("Trident/.*rv:([0-9]{1,}[\.0-9]{0,})");
if (re.exec(ua) != null) {
rv = parseFloat(RegExp.$1);
alert(rv);
}
}
else {
alert('otherbrowser');
}
}
else {
//For < IE11
alert(parseInt(ua.substring(msie + 5, ua.indexOf(".", msie))));
}
return false;
}}
</script>
</body>
</html>

InformationsquelleAutor Nimesh

Fenêtre s'exécute IE10 sera automatiquement mise à jour à IE11+ et seront normalisés W3C

Aujourd'hui, nous n'avons pas besoin de soutien IE8-

    <!DOCTYPE html>
<!--[if lt IE 9]><html class="ie ie8"><![endif]-->
<!--[if IE 9]><html class="ie ie9"><![endif]-->
<!--[if (gt IE 9)|!(IE)]><!--><html><!--<![endif]-->
<head>
...
<!--[if lt IE 8]><meta http-equiv="Refresh" content="0;url=/error-browser.html"><![endif]--
...
</head>

InformationsquelleAutor xicooc

var isIE9OrBelow = function()
{
return /MSIE\s/.test(navigator.userAgent) && parseFloat(navigator.appVersion.split("MSIE")[1]) < 10;
}

InformationsquelleAutor xicooc

if (!document.addEventListener) {
//ie8
} else if (!window.btoa) {
//ie9
}
//others

InformationsquelleAutor Bruce

//Detect ie <= 10
var ie = /MSIE ([0-9]+)/g.exec(window.navigator.userAgent)[1] || undefined;
console.log(ie);
//Return version ie or undefined if not ie or ie > 10

InformationsquelleAutor Liberateur

Ci-dessous codepen identifie la version de IE dans tous les cas (IE<=9, IE10, IE11 et IE/Edge)

function detectIE() {
var ua = window.navigator.userAgent;
var msie = ua.indexOf('MSIE ');
if (msie > 0) {
//IE 10 or older => return version number
return parseInt(ua.substring(msie + 5, ua.indexOf('.', msie)), 10);
}
var trident = ua.indexOf('Trident/');
if (trident > 0) {
//IE 11 => return version number
var rv = ua.indexOf('rv:');
return parseInt(ua.substring(rv + 3, ua.indexOf('.', rv)), 10);
}
var edge = ua.indexOf('Edge/');
if (edge > 0) {
//Edge (IE 12+) => return version number
return parseInt(ua.substring(edge + 5, ua.indexOf('.', edge)), 10);
}
//other browser
return false;
}

ref: https://codepen.io/gapcode/pen/vEJNZN

InformationsquelleAutor jeetaz

0

Ne pas trop compliquer des choses simples. Il suffit d'utiliser un simple et JScript commentaire conditionnel. Il est le plus rapide, car cela ajoute à zéro code de non-IE navigateurs pour la détection, et il a compatibilité datant de versions d'IE avant de HTML les commentaires conditionnels ont été pris en charge. En bref,
```
var IE_version=(-1/*@cc_on,@_jscript_version@*/);
```
Méfiez-vous des minifiers: la plupart (si pas tous) sera l'erreur de l'spéciale commentaire conditionnel pour un commentaire, et le supprimer

Fondamentalement, puis au-dessus de code définit la valeur de IE_version à la version d'internet explorer que vous utilisez, ou -1 si vous n'êtes pas en utilisant IE. Une démonstration en direct:

JS:
```
var IE_version=(-1/*@cc_on,@_jscript_version@*/);
if (IE_version!==-1){
document.write("<h1>You are using Internet Explorer " + IE_version + "</h1>");
} else {
document.write("<h1>You are not using a version of Internet Explorer less than 11</h1>");
}
```
Cela fonctionne sur la base du fait que les commentaires ne sont visibles que dans les anciennes versions d'Internet Explorer, et IE ensembles @_jscript_version à la version du navigateur. Par exemple, si vous utilisez Internet Explorer 7, puis @_jscript_version sera mis à 7, ainsi, la postprocessed javascript qui sera exécutée en fait ressembler à ceci:
```
var IE_version=(-1,7);
```
qui obtient évalué à 7.

InformationsquelleAutor

Il m'a aidé à

function IsIE8Browser() {
var rv = -1;
var ua = navigator.userAgent;
var re = new RegExp("Trident\/([0-9]{1,}[\.0-9]{0,})");
if (re.exec(ua) != null) {
rv = parseFloat(RegExp.$1);
}
return (rv == 4);
}

InformationsquelleAutor Pablo

function getIEVersion(){
if (/MSIE |Trident\//.test( navigator.userAgent )=== false) return -1;
/**[IE <=9]*/
var isIE9L = typeof ( window.attachEvent ) === 'function' && !( Object.prototype.toString.call( window.opera ) == '[object Opera]' ) ? true : false;
var re;
if(isIE9L){
re = new RegExp( "MSIE ([0-9]{1,}[\.0-9]{0,})" );
if(re.exec( navigator.userAgent ) !== null)
return parseFloat( RegExp.$1 );
return -1;
}
/**[/IE <=9]*/
/** [IE >= 10]*/
if(navigator.userAgent.indexOf( 'Trident/' ) > -1){
re = new RegExp( "rv:([0-9]{1,}[\.0-9]{0,})" );
if(re.exec( navigator.userAgent ) !== null)
return parseFloat( RegExp.$1 );
return -1;
}
/**[/IE >= 10]*/
return -1;
};

Vérifier ici ==>

var ieVersion = getIEVersion();
if(ieVersion < 0){
//Not IE
}
//A version of IE

En savoir plus sur navigateur navigator
https://developer.mozilla.org/en-US/docs/Web/API/Window/navigator

InformationsquelleAutor RKTUXYN

-1

À L'Aide De JQuery:

http://tanalin.com/en/articles/ie-version-js/

À L'Aide De C#:
```
var browser = Request.Browser.Browser;
```
- Mauvais forum, peut-être?
InformationsquelleAutor Krish_Teja
-1

Solution Simple arrêter de penser navigateur et de les utiliser l'année.
```
var year = eval(today.getYear());
if(year < 1900 )
{alert('Good to go: All browsers and IE 9 & >');}
else
{alert('Get with it and upgrade your IE to 9 or >');}
```
- Pourriez-vous nous expliquer pourquoi vous pensez que ce serait le travail.
InformationsquelleAutor James Gray

Vous devez vous connecter pour publier un commentaire.