'browser detection'에 해당되는 글 1건

  1. 2010.06.03 [펌] IE Browser Detection

[펌] IE Browser Detection

ITWeb/스크랩 2010.06.03 11:03

원문링크

 

Understanding User-Agent Strings

This topic describes the user-agent string, which identifies your browser and provides certain system details to servers hosting the Web sites you visit. The topic also shows how to view your user-agent string, summarizes tokens used by recent versions of Windows Internet Explorer, and documents registry keys that affect the user-agent string.

This topic contains the following sections.

Introduction

When you visit a Web page, your browser sends the user-agent string to the server hosting the site that you are visiting. This string indicates which browser you are using, its version number, and details about your system, such as operating system and version. The Web server can use this information to provide content that is tailored for your specific browser.

Because certain non-Microsoft sites add additional details to the user-agent string, it is important to understand the user-agent string. This article explains the user-agent string, lists the values from recent Internet Explorer versions, and documents registry keys that modify the user-agent string.

Understanding the User-Agent String

When you request a Web page, your browser sends a number of headers to the server hosting the site that you are visiting. Each header contains details that help the server determine the best way to provide the information that you requested. The user-agent header identifies the application requesting the information from the server. The user-agent string can contain optional details called tokens, which must be enclosed in parentheses and vary among programs. Internet Explorer uses tokens to describe additional details about your computer system.

The following figure shows a sample user-agent string reported by Internet Explorer that highlights its tokens.

Typical Internet Explorer user-agent string

For historical reasons, Internet Explorer identifies itself as a Mozilla 4.0 browser.

The sample user-agent string contains three tokens.

  1. The Compatibility flag ("compatible") is used by most modern browsers. It indicates that Internet Explorer is compatible with a common set of features.

  2. The Version token identifies the browser and contains the version number. The version token in the example ("MSIE 7.0") identifies Internet Explorer 7.

  3. The Platform token identifies your operating system and contains the version number. The platform token in the example ("Windows NT 6.0") indicates Windows Vista.

In the example, Internet Explorer is the user agent. However, other programs also provide user-agent strings when contacting servers over the Internet. For example, the Windows RSS Platform provides the following user-agent header when requesting RSS data.

Windows-RSS-Platform/1.0 (MSIE 7.0; Windows NT 5.1)

Like the user-agent string for Internet Explorer, this user-agent header provides details about your system.

Alternate tokens can appear in the user-agent string for a number of reasons; usually, they identify optional features installed on your system. For example, an "SV1" token appears in the user-agent string of a Windows XP user who has installed Windows XP Service Pack 2 (SP2). It is also important to note that certain non-Microsoft parties modify the user-agent string for their own purposes.

Note  To protect your privacy, you should periodically review your user-agent string and verify its contents.

For information on other headers communicated to Web servers, see the World Wide Web Consortium RFC 2616, Section 14: Header Field Definitions World Wide Web link.

Viewing the User-Agent String

To view your browser's user-agent string, type the following into the address bar.

javascript:alert(navigator.userAgent)

Note that this is case sensitive.

When you do this, a dialog box displays your user-agent string, as shown in the following figure.

User-agent string displayed in dialog box

Tip  If you are using a recent version of Windows, you can copy your user-agent string to the Clipboard by pressing CTRL+C before you close the dialog box.

Internet Explorer User-Agent Tokens

This section summarizes the tokens used by recent versions of Internet Explorer, which places three tokens in the user-agent string by default.

  1. Version tokens
  2. Platform tokens
  3. Feature tokens

In general, version tokens begin with MSIE and are followed by the version number of the browser. Many pre-release versions append the letter "b" to the version number. The following table lists the version tokens used in recent versions of Internet Explorer.

Version token Description
MSIE 8.0 Internet Explorer 8 (pre-release)
MSIE 7.0 Internet Explorer 7
MSIE 7.0b Internet Explorer 7 (Beta 1 pre-release only)
MSIE 6.0 Microsoft Internet Explorer 6
MSIE 6.0b Internet Explorer 6 (pre-release)
MSIE 5.5 Internet Explorer 5.5
MSIE 5.01 Internet Explorer 5.01
MSIE 5.0 Internet Explorer 5
MSIE 5.0b1 Internet Explorer 5 (pre-release)
MSIE 4.01 Internet Explorer 4.01

Platform tokens describe your operating system. The following table lists Internet Explorer platform tokens for the last several versions of Windows.

Platform token Description
Windows NT 6.0 Windows Vista
Windows NT 5.2 Windows Server 2003; Windows XP x64 Edition
Windows NT 5.1 Windows XP
Windows NT 5.01 Windows 2000, Service Pack 1 (SP1)
Windows NT 5.0 Windows 2000
Windows NT 4.0 Microsoft Windows NT 4.0
Windows 98; Win 9x 4.90 Windows Millennium Edition (Windows Me)
Windows 98 Windows 98
Windows 95 Windows 95
Windows CE Windows CE

Certain optional components can also modify the user-agent string; the following table shows common ones. Be aware that many other applications also modify the user-agent string. Because of this, a comprehensive list is not possible. If you find additional tokens in your user-agent string, you should investigate them in more detail.

Token Description
.NET CLR .NET Framework common language run time, followed by the version number.
SV1 Internet Explorer 6 with enhanced security features (Windows XP SP2 and Windows Server 2003 only).
Tablet PC Tablet services are installed; number indicates the version number.
Win64; IA64 System has a 64-bit processor (Intel).
Win64; x64 System has a 64-bit processor (AMD).
WOW64 A 32-bit version of Internet Explorer is running on a 64-bit processor.

User-Agent Registry Keys

When you install certain Windows components, such as the Microsoft .NET Framework or Windows XP SP2, tokens are added to the user-agent string. This is done by adding tokens to the following registry keys.

HKEY_LOCAL_MACHINE (or HKEY_CURRENT_USER)
     SOFTWARE
          Microsoft
               Windows
                    CurrentVersion
                         Internet Settings
                              User Agent
                                   Pre Platform
                                        Token = Value
                                   Post Platform
                                        Token = Value

The Pre-Platform and Post-Platform keys contain values whose names appear before and after the Platform token, respectively. For example, if a string value is added to the Post-Platform key, the name appears after the platform token in the user-agent string. Multiple tokens added to either key appear in an unpredictable order.

You can also override certain tokens of the user-agent string by adding values to the following registry key.

HKEY_LOCAL_MACHINE (or HKEY_CURRENT_USER)
     SOFTWARE
          Microsoft
               Windows
                    CurrentVersion
                         Internet Settings
                              5.0
                                   User Agent
                                        (default) = "Mozilla/4.0"
                                        Compatible = "compatible"
                                        Platform = "Windows NT 5.1"
                                        Version = "MSIE 6.0"
                                        Pre Platform
                                             Token = Value
                                        Post Platform
                                             Token = Value

The default value of the User-Agent key replaces the application name and application version tokens reported in the user-agent string. Note that the first seven characters are used for the application name, and the remaining characters specify the application version token.

The Compatible, Platform, and Version values replace the corresponding tokens in the user-agent string.

Additional tokens can be added to the user-agent string by using the Registry Editor to create new string values under the Pre-Platform key or Post-Platform key. The value name should be the complete token; the value data is ignored. Tokens added to the Pre-Platform key appear before the platform token in the final user-agent string. Tokens added to the Post-Platform key appear after the platform token in the final user-agent string. Multiple tokens in either the Pre-Platform key or Post-Platform key are displayed in an unpredictable order.

Note  If the browser is open when these keys are changed, the changes do not take effect until all browser windows are closed; this includes applications hosting the WebBrowser Control. Be aware that applications hosting the WebBrowser Control can override the Internet Explorer user-agent string without modifying it. For more information, see PRB: WebBrowser Control Clients Share Global Settings.

Related Topics

 


Detecting Internet Explorer More Effectively

This topic demonstrates how to detect current and future versions of Windows Internet Explorer more effectively.

This topic contains the following sections.

Introduction

Many Web designers use browser detection techniques to ensure that their sites display properly when viewed with specific browsers. Some browser detection techniques encounter problems when viewed with later versions of the browser they're tailored for. For example, many Web designers used Cascading Style Sheets (CSS) rules that relied on the implementation of CSS in Microsoft Internet Explorer 6 to detect that version of the browser. When Internet Explorer 7 provided additional support for the CSS, Level 2 (CSS2) standard, many of these rules (also known as "CSS hacks") failed to detect the new version of the browser. As a result, sites that relied on these rules no longer displayed as intended. When using browser detection techniques, use techniques that support current and future versions of the browser you're targeting.

This topic examines four different ways to detect Internet Explorer and also provides a brief look at alternatives to browser detection. Advantages of each technique are reviewed and suggestions are offered for effective use. In addition, examples demonstrate techniques that support current and future versions of Internet Explorer.

Parsing the User-Agent String

The most common way to detect Internet Explorer is to use client-side scripting to parse the user-agent string and extract the version number from the version token. The following example shows the preferred way to do this with JavaScript.

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 );
}

As you review this example, please note the following:

  • A regular expression extracts the version number from the user-agent version token. Regular expressions let you specify optional conditions to match, so that you can match a larger number of version tokens, not just those that match a strict set of conditions.

  • The version number extracted from the version token is formally converted to a numeric value. Care must be taken because pre-release versions of Internet Explorer typically add letters to the version token. For example, the version token for pre-release versions of Internet Explorer 7 was "MSIE 7.0b."

  • The checkVersion() function verifies that the browser is version 8.0 or later. This ensures that the welcome message is displayed for those using newer versions of the browser.

This example properly detects most versions of Internet Explorer, but only if scripting is enabled. However, the user-agent string is dynamic; it can be changed by the end user, by browser extensions, and by operating system updates. As a result, there's no guarantee that the user-agent string accurately reflects the browser being used. The next sections show techniques that may be more effective alternatives.

Note  It is not recommended that you block access to content based on the user-agent string of the browser. If you do have to offer different content to different versions of the browser due to improved capabilities, you want to ensure that future versions of the browser are not blocked. Serving content based solely on the user-agent string is often an unreliable way to detect the full capabilities of the browser.

For more information about the user-agent string and Internet Explorer's user-agent tokens, see Understanding User-Agent Strings.

Using Conditional Comments

If you are specifically interested in Internet Explorer, conditional comments might be a more appropriate choice. The following example shows an effective way to use conditional comments to display custom content.

<!--[if gte IE 8]>
<p>You're using a recent version of Internet Explorer.</p>
<![endif]-->

<!--[if lt IE 7]>
<p>Hm. You should upgrade your copy of Internet Explorer.</p>
<![endif]-->

<![if !IE]>
<p>You're not using Internet Explorer.</p>
<![endif]>

Like the earlier JavaScript example, this example makes sure the current version is greater than or equal to a specified version number. This ensures that the content designed for the current version of the browser is properly displayed in a future version.

This example carefully combines downlevel-revealed and downlevel-hidden conditional comments to ensure that each message appears only for the intended browsers.

Because conditional comments do not rely on JavaScript, they are effective even if the user has disabled scripting. Unlike the user-agent string, conditional comments are typically updated when the browser is upgraded. This makes them more reliable than user-agent strings. However, because no other browser currently supports conditional comments, they are limited to Internet Explorer. Depending on your needs, this may be an advantage or a disadvantage.

For more information about conditional comments, see About Conditional Comments.

Detecting Features

For many Web sites, detecting a browser's features is the preferred form of browser detection because it allow the Web developer to focus on the general capabilities of a browser, rather than the specific details of each browser release. The following example demonstrates a simple form of feature detection.

if (XMLHttpRequest)
{
    // This browser implements this feature. 
}

Feature detection tends to support a broader range of browsers. In addition, should a browser implement the feature you're interested in, your content will be delivered without requiring changes to your browser detection technique. As a result, techniques that focus on features tend to require less maintenance than techniques that rely on environmental factors, such as the user-agent string. In addition, they tend to work across a wider variety of browser devices, including screen readers, mobile devices, and so on.

Use care when creating or using browser detection techniques that attempt to detect a browser based on unsupported functionality. If a future version of the browser implements the missing feature, it's entirely possible your site may not display as intended.

Using the ASP.NET HttpBrowserCapabilities Object

ASP.NET developers can use the HttpBrowserCapabilities object to detect and respond to almost any browser. In addition, alternate content is not sent to the end-user's browser. The following example shows how to detect Internet Explorer from an ASP.NET application using C#.

private float getInternetExplorerVersion()
{
  // Returns the version of Internet Explorer or a -1
  // (indicating the use of another browser).
  float rv = -1;
  System.Web.HttpBrowserCapabilities browser = Request.Browser;
  if (browser.Browser == "IE")
    rv = (float)(browser.MajorVersion + browser.MinorVersion);
  return rv;
}

private void Page_Load(object sender, System.EventArgs e)
{
  string msg;
  double ver = getInternetExplorerVersion();
  if (ver > 0.0)
  {
    if (ver >= 7.0) 
      msg = "You're using a recent version of Internet Explorer.";
    else
      msg = "You should upgrade your copy of Internet Explorer.";
  } 
  else
    msg = "You're not using Internet Explorer.";

  Label1.Text = msg;
}

Because the HttpBrowserCapabilities object parses the user-agent string for you, you can use the MajorVersion and MinorVersion properties to determine the current version of the browser. Unlike the JavaScript examples, these properties are numeric; MajorVersion returns an integer value, and MinorVersion returns a double value. Depending on the language used to implement your ASP.NET application, however, you might still have to typecast these property values to the data type you're using. To illustrate, the C# example converts MajorValue to the floating point value returned by the function.

For more information about the HttpBrowserCapabilities object, see HOW TO: Determine the Browser Version in ASP.NET or Browser Sniffing in ASP.NET World Wide Web link.

Alternatives to Browser Detection

If you use browser detection because Internet Explorer doesn't appear to support a particular feature, an alternate approach may be more effective. Before implementing new (or revising existing) browser detection, it may be worthwhile to consider one of the following approaches to solve the underlying problem.

  • Internet Explorer allows Web developers to choose between various document compatibility modes that affect the way the browser interprets and displays content. If you are not seeing the results you expect, a different document compatibility mode may provide the results you seek. For more information, see Defining Document Compatibility.

    You may want to consider using the Developer Tools to preview your pages in different document compatibility modes or to experiment with different ways to achieve various visual and layout effects. It's entirely possible there's another way to accomplish the same result.

  • If the Document Object Model (DOM) doesn't support a feature that you need, you may be able to add the feature using DOM mutable prototypes.

  • If none of the previous suggestions apply, it may be worthwhile to consider using an alternate approach.

Summary

If you must detect the browsers that view your Web sites, follow effective practices: plan for future browser releases, convert values appropriately, and design techniques to fail gracefully. Doing so will reduce the long-term maintenance of your site and help ensure that your site functions properly when viewed with newer versions of Internet Explorer and other browsers.

신고
Trackback 0 : Comment 0