I want to bounce users of our web site to an error page if they're using a version of Internet Explorer prior to v9. It's just not worth our time and money to support IE pre-v9. Users of all other non-IE browsers are fine and shouldn't be bounced. Here's the proposed code:
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
}
}
Will this code do the trick?
To head off a few comments that will probably be coming my way:
useragent string. I'm not concerned.pre-v9 IE browsers don't. Checking feature by feature throughout the site would be a waste.IE v1 (or >= 20) wouldn't get 'badBrowser' set to true and the warning page wouldn't be displayed properly. That's a risk we're willing to take.IE 10, rendering this approach absolutely useless.Any other obvious issues to be aware of?
This question is related to
javascript
internet-explorer
user-agent
browser-detection
It helped me
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);
}
Don't over complicate such simple things. Just use a plain and simple JScript conditional comment. It is the fastest because it adds zero code to non-IE browsers for the detection, and it has compatibility dating back to versions of IE before HTML conditional comments were supported. In short,
var IE_version=(-1/*@cc_on,@_jscript_version@*/);
Beware of minifiers: most (if not all) will mistake the special conditional comment for a regular comment, and remove it
Basically, then above code sets the value of IE_version to the version of IE you are using, or -1 f you are not using IE. A live demonstration:
var IE_version=(-1/*@cc_on,@_jscript_version@*/);_x000D_
if (IE_version!==-1){_x000D_
document.write("<h1>You are using Internet Explorer " + IE_version + "</h1>");_x000D_
} else {_x000D_
document.write("<h1>You are not using a version of Internet Explorer less than 11</h1>");_x000D_
}This works based on the fact that conditional comments are only visible in older versions of Internet Explorer, and IE sets @_jscript_version to the version of the browser. For example, if you are using Internet Explorer 7, then @_jscript_version will be set to 7, thus, the postprocessed javascript that will be executed will actually look like this:
var IE_version=(-1,7);
which gets evaluated to 7.
Window runs IE10 will be auto update to IE11+ and will be standardized W3C
Nowaday, we don't need to support 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>
To reliably filter IE8 and older, checking global objects can be used:
if (document.all && !document.addEventListener) {
alert('IE8 or lower');
}
The most comprehensive JS script I found to check for versions of IE is http://www.pinlady.net/PluginDetect/IE/. The entire library is at http://www.pinlady.net/PluginDetect/Browsers/.
With IE10, conditional statements are no longer supported.
With IE11, the user agent no longer contains MSIE. Also, using the user agent is not reliable because that can be modified.
Using the PluginDetect JS script, you can detect for IE and detect the exact versions by using very specific and well-crafted code that targets specific IE versions. This is very useful when you care exactly what version of browser you are working with.
I'm going to recommend not rewriting this code for the umpteenth time. I would recommend you use the Conditionizr library (http://conditionizr.com/) which is capable of testing for specific IE versions as well as other browsers, operating systems, and even the presence or absence of Retina displays.
Include the code for only the specific tests you need and you also gain the benefit of a tested library which has been through many iterations (and which would be easy to upgrade without breaking your code).
It also meshes nicely with Modernizr which can handle all of those cases where you are better off testing for a specific capability rather than a specific browser.
For ie 10 and 11:
You can use js and add a class in html to maintain the standard of conditional comments:
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";
}
Or use a lib like bowser:
Or modernizr for feature detection:
According to Microsoft, following is the best solution, it is also very 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 );
}
The below codepen identifies IE version in all cases (IE<=9, IE10, IE11 and 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;
}
This function will return the IE major version number as an integer, or undefined if the browser isn't Internet Explorer. This, like all user agent solutions, is suceptible to user agent spoofing (which has been an official feature of IE since version 8).
function getIEVersion() {
var match = navigator.userAgent.match(/(?:MSIE |Trident\/.*; rv:)(\d+)/);
return match ? parseInt(match[1]) : undefined;
}
If nobody else has added an addEventLister-method and you're using the correct browser mode then you could check for IE 8 or less with
if (window.attachEvent && !window.addEventListener) {
// "bad" IE
}
To detect MSIE (v6 - v7 - v8 - v9 - v10 - v11) easily :
if (navigator.userAgent.indexOf('MSIE') !== -1 || navigator.appVersion.indexOf('Trident/') > 0) {
// MSIE
}
Simple solution stop thinking browser and use the year.
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 >');}
If you need to delect IE Browser version then you can follow below code. This code working well for version IE6 to 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>
Detecting IE version using feature detection (IE6+, browsers prior to IE6 are detected as 6, returns null for non-IE browsers):
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: I've created a bower/npm repo for your convenience: ie-version
Update:
a more compact version can be written in one line as:
return window.ActiveXObject === undefined ? null : !window.XMLHttpRequest ? 6 : !document.querySelector ? 7 : !document.addEventListener ? 8 : !window.atob ? 9 : !document.__proto__ ? 10 : 11;
Using JQuery:
http://tanalin.com/en/articles/ie-version-js/
Using C#:
var browser = Request.Browser.Browser;
I realise I am a little late to the party here, but I had been checking out a simple one line way to provide feedback on whether a browser is IE and what version from 10 down it was. I haven't coded this for version 11, so perhaps a little amendment will be needed for that.
However this is the code, it works as an object that has a property and a method and relies on object detection rather than scraping the navigator object (which is massively flawed as it can be spoofed).
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; } };
The usage is isIE.browser a property that returns a boolean and relies on conditional comments the method isIE.detectedVersion() which returns a number between 5 and 10. I am making the assumption that anything lower than 6 and you are in serious old school territory and you will something more beefy than a one liner and anything higher than 10 and you are in to newer territory. I have read something about IE11 not supporting conditional comments but I've not fully investigated, that is maybe for a later date.
Anyway, as it is, and for a one liner, it will cover the basics of IE browser and version detection. It's far from perfect, but it is small and easily amended.
Just for reference, and if anyone is in any doubt on how to actually implement this then the following conditional should help.
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());
}
Here is the way AngularJS checks for 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
}
This works for me. I use it as a redirect to a page that explains why we don't like < IE9 and provide links to browsers we prefer.
<!--[if lt IE 9]>
<meta http-equiv="refresh" content="0;URL=http://google.com">
<![endif]-->
Conditional comments are no longer supported in IE as of Version 10 as noted on the Microsoft reference page.
var ieDetector = function() {_x000D_
var browser = { // browser object_x000D_
_x000D_
verIE: null,_x000D_
docModeIE: null,_x000D_
verIEtrue: null,_x000D_
verIE_ua: null_x000D_
_x000D_
},_x000D_
tmp;_x000D_
_x000D_
tmp = document.documentMode;_x000D_
try {_x000D_
document.documentMode = "";_x000D_
} catch (e) {};_x000D_
_x000D_
browser.isIE = typeof document.documentMode == "number" || eval("/*@cc_on!@*/!1");_x000D_
try {_x000D_
document.documentMode = tmp;_x000D_
} catch (e) {};_x000D_
_x000D_
// We only let IE run this code._x000D_
if (browser.isIE) {_x000D_
browser.verIE_ua =_x000D_
(/^(?:.*?[^a-zA-Z])??(?:MSIE|rv\s*\:)\s*(\d+\.?\d*)/i).test(navigator.userAgent || "") ?_x000D_
parseFloat(RegExp.$1, 10) : null;_x000D_
_x000D_
var e, verTrueFloat, x,_x000D_
obj = document.createElement("div"),_x000D_
_x000D_
CLASSID = [_x000D_
"{45EA75A0-A269-11D1-B5BF-0000F8051515}", // Internet Explorer Help_x000D_
"{3AF36230-A269-11D1-B5BF-0000F8051515}", // Offline Browsing Pack_x000D_
"{89820200-ECBD-11CF-8B85-00AA005B4383}"_x000D_
];_x000D_
_x000D_
try {_x000D_
obj.style.behavior = "url(#default#clientcaps)"_x000D_
} catch (e) {};_x000D_
_x000D_
for (x = 0; x < CLASSID.length; x++) {_x000D_
try {_x000D_
browser.verIEtrue = obj.getComponentVersion(CLASSID[x], "componentid").replace(/,/g, ".");_x000D_
} catch (e) {};_x000D_
_x000D_
if (browser.verIEtrue) break;_x000D_
_x000D_
};_x000D_
verTrueFloat = parseFloat(browser.verIEtrue || "0", 10);_x000D_
browser.docModeIE = document.documentMode ||_x000D_
((/back/i).test(document.compatMode || "") ? 5 : verTrueFloat) ||_x000D_
browser.verIE_ua;_x000D_
browser.verIE = verTrueFloat || browser.docModeIE;_x000D_
};_x000D_
_x000D_
return {_x000D_
isIE: browser.isIE,_x000D_
Version: browser.verIE_x000D_
};_x000D_
_x000D_
}();_x000D_
_x000D_
document.write('isIE: ' + ieDetector.isIE + "<br />");_x000D_
document.write('IE Version Number: ' + ieDetector.Version);then use:
if((ieDetector.isIE) && (ieDetector.Version <= 9))
{
}
Return IE version or if not IE return false
function isIE () {
var myNav = navigator.userAgent.toLowerCase();
return (myNav.indexOf('msie') != -1) ? parseInt(myNav.split('msie')[1]) : false;
}
Example:
if (isIE () == 8) {
// IE8 code
} else {
// Other versions IE or not IE
}
or
if (isIE () && isIE () < 9) {
// is IE version less than 9
} else {
// is IE 9 and later or not IE
}
or
if (isIE()) {
// is IE
} else {
// Other browser
}
if (!document.addEventListener) {
// ie8
} else if (!window.btoa) {
// ie9
}
// others
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
}
I made a convenient underscore mixin for this.
_.isIE(); // Any version of IE?
_.isIE(9); // IE 9?
_.isIE([7,8,9]); // IE 7, 8 or 9?
_.mixin({_x000D_
isIE: function(mixed) {_x000D_
if (_.isUndefined(mixed)) {_x000D_
mixed = [7, 8, 9, 10, 11];_x000D_
} else if (_.isNumber(mixed)) {_x000D_
mixed = [mixed];_x000D_
}_x000D_
for (var j = 0; j < mixed.length; j++) {_x000D_
var re;_x000D_
switch (mixed[j]) {_x000D_
case 11:_x000D_
re = /Trident.*rv\:11\./g;_x000D_
break;_x000D_
case 10:_x000D_
re = /MSIE\s10\./g;_x000D_
break;_x000D_
case 9:_x000D_
re = /MSIE\s9\./g;_x000D_
break;_x000D_
case 8:_x000D_
re = /MSIE\s8\./g;_x000D_
break;_x000D_
case 7:_x000D_
re = /MSIE\s7\./g;_x000D_
break;_x000D_
}_x000D_
_x000D_
if (!!window.navigator.userAgent.match(re)) {_x000D_
return true;_x000D_
}_x000D_
}_x000D_
_x000D_
return false;_x000D_
}_x000D_
});_x000D_
_x000D_
console.log(_.isIE());_x000D_
console.log(_.isIE([7, 8, 9]));_x000D_
console.log(_.isIE(11));<script src="https://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.8.3/underscore-min.js"></script>var isIE9OrBelow = function()
{
return /MSIE\s/.test(navigator.userAgent) && parseFloat(navigator.appVersion.split("MSIE")[1]) < 10;
}
Your code can do the check, but as you thought, if someone try to access your page using IE v1 or > v19 will not get the error, so might be more safely do the check with Regex expression like this code below:
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
}
Detecting IE and its versions couldn't be easier, and all you need is a bit of native/vanilla 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;
}
And this is a way to use it:
if (browser == 'IE' && ieVersion <= 9)
document.documentElement.className += ' ie9-';
.
Works in all IE versions, including higher versions in lower Compatability View/Mode, and documentMode is IE proprietary.
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;
};
Check here ==>
var ieVersion = getIEVersion();
if(ieVersion < 0){
//Not IE
}
//A version of IE
Learn more about browser navigator https://developer.mozilla.org/en-US/docs/Web/API/Window/navigator
// 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
To detect Internet Explorer 10|11 you can use this little script immediatelly after body tag:
In my case i use jQuery library loaded in head.
<!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>
Detect IE in JS using conditional comments
// ----------------------------------------------------------
// 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;
}());
This approach to detecting IE combines the strengths and avoids the weaknesses of jKey's answer using conditional comments and Owen's answer using user agents.
Owen's approach can fail on IE 5 & 6 (reporting 7) and is susceptible to UA spoofing, but it can detect IE versions >= 10 (now also including 12, which postdates Owen's answer).
// ----------------------------------------------------------
// 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;
}());
This can be used to set useful classes to your document containing the IE version:
if (ie) {
document.documentElement.className += ' ie' + ie;
if (ie < 9)
document.documentElement.className += ' ieLT9';
}
Note that it detects the compatibility mode being used, if IE is in compatability mode. Also note that IE version is mostly useful for older versions (<10); higher versions are more standards-compliant and it's probably better to instead check for features using something like modernizr.js.
Use conditional comments. You're trying to detect users of IE < 9 and conditional comments will work in those browsers; in other browsers (IE >= 10 and non-IE), the comments will be treated as normal HTML comments, which is what they are.
Example HTML:
<!--[if lt IE 9]>
WE DON'T LIKE YOUR BROWSER
<![endif]-->
You can also do this purely with script, if you need:
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");
}
This has been answered to death, but this is all you need.
!!navigator.userAgent.match(/msie\s[5-8]/i)
I do like that:
<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>
or simply
// 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]
Source: Stackoverflow.com