Détecter IE version (antérieure à la v9) en JavaScript
Je souhaite rediriger les utilisateurs de notre site Web vers une page d'erreur s'ils utilisent une version de Internet Explorer antérieure à la v9. Il ne faut tout simplement pas notre temps et notre argent pour supporter IE pre-v9. Les utilisateurs de tous les autres navigateurs non-IE vont bien et ne devraient pas être renvoyés. 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
}
}
Ce code fera-t-il l'affaire?
Pour éviter quelques commentaires qui viendront probablement à mon sens:
- Oui, je sais que les utilisateurs peuvent créer leur chaîne
useragent. Je ne suis pas concerné. - Oui, je sais que les professionnels de la programmation préfèrent rechercher des fonctionnalités plutôt que des navigateurs, mais je ne pense pas que cette approche soit logique dans ce cas. Je sais déjà que tous les navigateurs (pertinents) autres qu'IE prennent en charge les fonctionnalités dont j'ai besoin et que tous les navigateurs
pre-v9 IEne les prennent pas. La vérification fonction par caractéristique sur tout le site serait un gaspillage. - Oui, je sais qu'une personne essayant d'accéder au site à l'aide de
IE v1(ou> = 20) ne verrait pas "badBrowser" défini sur true et que la page d'avertissement ne s'afficherait pas correctement. C'est un risque que nous sommes prêts à prendre. - Oui, je sais que Microsoft a des "commentaires conditionnels" qui peuvent être utilisés pour une détection précise de la version du navigateur. IE ne prend plus en charge les commentaires conditionnels à partir de
IE 10, ce qui rend cette approche absolument inutile.
Y a-t-il d'autres problèmes évidents à connaître?
C'est ma manière préférée de le faire. Cela donne un contrôle maximum. (Remarque: les instructions conditionnelles ne sont prises en charge que dans IE5 - 9.)
Commencez par configurer correctement vos classes
<!DOCTYPE html>
<!--[if lt IE 7]> <html class="lt-ie9 lt-ie8 lt-ie7"> <![endif]-->
<!--[if IE 7]> <html class="lt-ie9 lt-ie8"> <![endif]-->
<!--[if IE 8]> <html class="lt-ie9"> <![endif]-->
<!--[if gt IE 8]><!--> <html> <!--<![endif]-->
<head>
Ensuite, vous pouvez simplement utiliser CSS pour créer des exceptions de style ou, si vous le souhaitez, vous pouvez ajouter du 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));
Merci à Paul Irish .
Renvoie la version IE ou, à défaut, IE, renvoie 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
}
Si personne d'autre n'a ajouté une méthode addEventLister- et que vous utilisez le mode de navigateur approprié, vous pouvez rechercher IE 8 ou moins avec
if (window.attachEvent && !window.addEventListener) {
// "bad" IE
}
Utilisez des commentaires conditionnels. Vous essayez de détecter les utilisateurs de IE <9 et les commentaires conditionnels fonctionneront dans ces navigateurs; dans les autres navigateurs (IE> = 10 et non-IE), les commentaires seront traités comme des commentaires HTML normaux, comme c.
Exemple HTML:
<!--[if lt IE 9]>
WE DON'T LIKE YOUR BROWSER
<![endif]-->
Vous pouvez également le faire uniquement avec un script, si vous avez besoin de:
var div = document.createElement("div");
div.innerHTML = "<!--[if lt IE 9]><i></i><![endif]-->";
var isIeLessThan9 = (div.getElementsByTagName("i").length == 1);
if (isIeLessThan9) {
alert("WE DON'T LIKE YOUR BROWSER");
}
Pour détecter facilement MSIE (v6 - v7 - v8 - v9 - v10 - v11):
if (navigator.userAgent.indexOf('MSIE') !== -1 || navigator.appVersion.indexOf('Trident/') > 0) {
// MSIE
}
Voici comment 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
}
Pour filtrer de manière fiable les versions IE8 et antérieures, la vérification des objets globaux peut être utilisée:
if (document.all && !document.addEventListener) {
alert('IE8 or lower');
}
Cette fonction renverra le numéro de version principale IE sous la forme d'un entier, ou undefined si le navigateur n'est pas Internet Explorer. Ceci, comme toutes les solutions d'agent d'utilisateur, est sujet à l'usurpation d'agent d'utilisateur (qui est une fonctionnalité officielle de IE depuis la version 8).
function getIEVersion() {
var match = navigator.userAgent.match(/(?:MSIE |Trident\/.*; rv:)(\d+)/);
return match ? parseInt(match[1]) : undefined;
}
Détecter IE dans JS à l'aide de 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;
}());
Détection de la version IE à l'aide de la détection de fonctionnalités (IE6 +, les navigateurs antérieurs à IE6 sont détectés comme étant 6, renvoie null pour les navigateurs non IE):
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éé un dépôt bower/npm pour votre confort: ie-version
Mettre à jour:
une version plus compacte peut être écrite sur une ligne comme suit:
return window.ActiveXObject === undefined ? null : !window.XMLHttpRequest ? 6 : !document.querySelector ? 7 : !document.addEventListener ? 8 : !window.atob ? 9 : !document.__proto__ ? 10 : 11;
Cela fonctionne pour moi. Je l'utilise comme une redirection vers une page qui explique pourquoi nous n'aimons pas <IE9 et fournit des liens vers les navigateurs que nous préférons.
<!--[if lt IE 9]>
<meta http-equiv="refresh" content="0;URL=http://google.com">
<![endif]-->
Votre code peut effectuer la vérification, mais comme vous le pensiez, si quelqu'un tente d'accéder à votre page à l'aide de IE v1 ou> v19, l'erreur ne sera pas résolue. La vérification avec une expression Regex similaire à celle ci-dessous peut donc être effectuée en toute sécurité :
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
}
Les commentaires conditionnels ne sont plus pris en charge dans IE à partir de la version 10, comme indiqué sur la page de référence Microsoft .
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);puis utilisez:
if((ieDetector.isIE) && (ieDetector.Version <= 9))
{
}
Pour 10 et 11:
Vous pouvez utiliser js et ajouter une classe au format HTML pour conserver la norme de 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 utilisez une lib comme bowser:
Ou modernizr pour la détection de fonctionnalité:
Pour détecter Internet Explorer 10 | 11, vous pouvez utiliser ce petit script immédiatement après la balise body:
Dans mon cas, j'utilise la bibliothèque jQuery chargée en 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>
Cela a été répondu à mort, mais c'est tout ce dont vous avez besoin.
!!navigator.userAgent.match(/msie\s[5-8]/i)
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
}
Selon Microsoft , la meilleure solution est la suivante:
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 );
}
J'aime ç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>
Cette approche de détection de IE combine les forces et évite les faiblesses de la réponse de jKey en utilisant des commentaires conditionnels et de la réponse de Owen en utilisant des agents utilisateurs.
- l’approche de jKey fonctionne jusqu’à la version 9 et ne craint pas l’usurpation d’agent utilisateur dans IE 8 & 9.
L'approche d'Owen peut échouer sur IE 5 et 6 (en signalant 7) et est susceptible de falsification d'ACU, mais elle peut détecter IE versions> = 10 (incluant également 12, ce qui postdate la réponse d'Owen).
// ---------------------------------------------------------- // 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 = '<!--[if gt IE ' + (++v) + ']><i></i><![endif]-->', 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 des classes utiles dans votre document contenant la version IE:
if (ie) {
document.documentElement.className += ' ie' + ie;
if (ie < 9)
document.documentElement.className += ' ieLT9';
}
Notez qu'il détecte le mode de compatibilité utilisé si IE est en mode de compatibilité. Notez également que la version IE est surtout utile pour les anciennes versions (<10); les versions les plus récentes sont plus conformes aux normes et il est probablement préférable de rechercher des fonctionnalités utilisant quelque chose comme modernizr.js.
ou 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]
J'ai fait un mélange de soulignement pratique pour cela.
_.isIE(); // Any version of IE?
_.isIE(9); // IE 9?
_.isIE([7,8,9]); // IE 7, 8 or 9?
_.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));<script src="https://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.8.3/underscore-min.js"></script>Je vais recommander de ne pas réécrire ce code pour la énième fois. Je vous recommanderais d'utiliser la bibliothèque Conditionizr ( http://conditionizr.com/ ), capable de tester des versions spécifiques IE, ainsi que d'autres navigateurs, systèmes d'exploitation, et même la présence ou l'absence des écrans de la rétine.
N'incluez le code que pour les tests spécifiques dont vous avez besoin et vous bénéficiez également d'une bibliothèque testée qui a subi de nombreuses itérations (et qu'il serait facile de mettre à niveau sans mettre à jour votre code).
Il s'intègre également parfaitement à Modernizr, qui peut gérer tous les cas dans lesquels il est préférable de tester une fonctionnalité spécifique plutôt qu'un navigateur spécifique.
Le code ci-dessous identifie la version 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;
}
Ça 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);
}
// 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
Détecter IE et ses versions est on ne peut plus simple, et vous avez juste besoin d’un peu de Javascript natif/vanille:
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;
}
Et 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 en mode/vue de compatibilité inférieure, et documentMode est la propriété de IE.
if (!document.addEventListener) {
// ie8
} else if (!window.btoa) {
// ie9
}
// others
Je me rends compte que je suis un peu en retard pour la fête ici, mais je vérifiais un moyen simple en une ligne de donner des informations sur le fait qu'un navigateur est IE et quelle version de 10 était la version précédente. Je n'ai pas codé cela pour la version 11, alors il faudra peut-être un petit amendement pour cela.
Quel que soit le code utilisé, il fonctionne comme un objet doté d'une propriété et d'une méthode et s'appuie sur la détection d'objet plutôt que sur l'objet de navigation (qui est extrêmement défectueux car il peut être usurpé).
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 des commentaires conditionnels avec la méthode isIE.detectedVersion() qui retourne un nombre compris entre 5 et 10. Je suppose que tout ce qui est inférieur à 6 et que vous êtes sur un ancien territoire scolaire sérieux et que vous ferez autre chose plus costaud qu'un one-liner et rien de plus de 10 et vous êtes sur un nouveau territoire. J'ai lu quelque chose sur le fait qu'IE11 ne prend pas en charge les commentaires conditionnels mais je n'ai pas fait une enquête complète, c'est peut-être pour une date ultérieure.
Quoi qu'il en soit, dans l'état actuel des choses, et pour une seule ligne, cela couvrira les bases de la détection de navigateur et de version IE. C'est loin d'être parfait, mais c'est petit et facilement amendable.
Juste pour référence, et si quelqu'un a un doute sur la façon de réellement mettre en œuvre cela, alors le conditionnel suivant devrait 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());
}
Le script JS le plus complet que j'ai trouvé pour rechercher les versions de IE est http://www.pinlady.net/PluginDetect/IE/ . La bibliothèque entière se trouve à http://www.pinlady.net/PluginDetect/Browsers/ .
Avec IE10, les instructions conditionnelles ne sont plus prises en charge.
Avec IE11, l'agent utilisateur ne contient plus MSIE. De plus, l'utilisation de l'agent utilisateur n'est pas fiable car elle peut être modifiée.
En utilisant le script PluginDetect JS, vous pouvez détecter pour IE et détecter les versions exactes en utilisant un code très spécifique et bien conçu qui cible des versions spécifiques de IE. Ceci est très utile lorsque vous vous souciez de la version de navigateur avec laquelle vous travaillez.
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érifiez ici ==>
var ieVersion = getIEVersion();
if(ieVersion < 0){
//Not IE
}
//A version of IE
En savoir plus sur le navigateur de navigateur https://developer.mozilla.org/en-US/docs/Web/API/Window/navigator
var isIE9OrBelow = function()
{
return /MSIE\s/.test(navigator.userAgent) && parseFloat(navigator.appVersion.split("MSIE")[1]) < 10;
}
Ne compliquez pas trop ces choses simples. Utilisez simplement un commentaire conditionnel JScript clair et simple. C'est le plus rapide, car il ajoute zéro code aux navigateurs non-IE pour la détection et sa compatibilité remonte aux versions de IE avant que les commentaires conditionnels HTML ne soient pris en charge. En bref,
var IE_version=(-1/*@cc_on,@_jscript_version@*/);
Méfiez-vous des minificateurs: la plupart (si ce n'est tous) prendront le commentaire conditionnel spécial pour un commentaire régulier et le supprimeront
Fondamentalement, le code ci-dessus définit la valeur de IE_version sur la version de IE que vous utilisez, ou -1 f que vous n'utilisez pas IE. Une démonstration en direct:
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 conditionnels ne sont visibles que dans les anciennes versions d'Internet Explorer et que IE définit @_jscript_version sur la version du navigateur. Par exemple, si vous utilisez Internet Explorer 7, alors @_jscript_version sera défini sur 7; ainsi, le javascript post-traité qui sera exécuté ressemblera en réalité à ceci:
var IE_version=(-1,7);
qui est évalué à 7.
Les fenêtres exécutées IE10 seront mises à jour automatiquement vers IE11 + et seront normalisées W3C
De nos jours, nous n'avons pas besoin de supporter 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>