Cross-Browser Solutions: Detection and Generic Functions
- Cross-Browser Issues
- Detecting the User's Browser
- Creating a Custom Object Front End
Like this article? We recommend
Like this article? We recommend
Like this article? We recommend
Cross-Browser Issues
Two facts are vital to anyone who wants or needs to program a Web site for a general audience:
Although most surfers use a version 5 browser (that is to say, Internet Explorer version 5 and higher), there are still a significant number who use a version 4 browser. As I write this, the version 4 browser market share stands at just over 20%.
The object models supported by the three main browser camps—the version 5 browsers, Internet Explorer 4, and Netscape 4—are substantially different.
In other words, if you want to implement DHTML techniques on your site, it's both necessary and difficult to code for all three object models. That's not a great state of affairs, but such is life in the fragmented world of Web programming. The good news is that although cross-browser scripting might be difficult, it is possible, as you'll see in this article.
Before you get that far, however, you should take a step back and make sure that you understand just what "cross-browser" means, particularly within the context of DHTML programming.
What Does "Cross-Browser" Mean?
Ideally, describing a page or script as cross-browser means that the script works identically not only in browsers from different vendors, but also in all the available versions of each vendor's browser and in all the versions of each browser that run on different operating systems (such as the various flavors of Windows, the Mac OS, and Unix). This is why many people prefer the broader term cross-platform.
Those are some pretty big shoes, and, in practice, they can be filled only by the simplest page that uses only the most basic of tags. In the real world, achieving cross-browser status requires making compromises:
You might have to support only a subset of the browser population. The more sophisticated the effect you want, the more browsers you have to leave behind.
You might have to implement only a subset of the available browser functionality. Most newer browsers contain features that simply can't be duplicated in older browsers, and those features have to be abandoned to achieve the cross-browser label. (Although you'll see that there are ways around this, in some cases.)
You might have to be satisfied with creating effects that work substantially the same in your browser subset. It's often possible to create a script that works identically, but "close enough" sometimes has to be good enough. (My own yardstick is a ruthless one: browser market share. If an effect I want isn't working perfectly in a browser with a tiny market share, I'll usually just move on to the next challenge.)
What all of this really means is that your cross-browser scripts will support only the lowest-common browser denominator. In the DHTML world, this usually means Netscape 4 because it has the most limited object model.
Handling Different Browsers
Once you decide to go the cross-browser route, your first step is to decide on the browsers and browser features you want (or need) to support. Once that's done, the next thing you need to decide is how you're going to handle the different browsers. There are three choices: inline branching, page branching, and creating a custom object front end.
Using Inline Branching
Inline branching means using an if() statement or some other control structure to check the browser and then perform some action based on the result. For example, the getElementById() method is a good way to test whether a browser supports the W3C DOM. I have used the following inline branching technique:
if (!document.getElementById) {
return
}
The rest of the code
In other words, if the browser returns undefined from document.getElementById, then the script exits without moving on to the rest of the code, which would likely generate errors or possibly even cause the browser to crash. This is the most drastic scenario, but it's necessary in this case because the code is pure W3C DOM, so there's no way to create the equivalent in another object model.
Most inline branching is more forgiving in that a true result (assuming that you're using an if() test) implements code for one type of browser, and a false result implements the equivalent code for a different browser. Here's some pseudo-code that illustrates this:
if (browser A) {
Code that's specific to browser A
}
else if (browser B) {
Code that's specific to browser B
}
else {
Code for all other browsers
}
Using Page Branching
Page branching is similar in that you first use if() or some other kind of test to determine the user's browser. However, in this case you send the user to an entirely different page based on the result of the test:
if (browser A) {
location.replace(browserA.html)
}
else if (browser B) {
location.replace(browserB.html)
}
else {
location.replace(others.html)
}
Page branching is useful when the different browsers require substantially different scripts or HTML. For example, if your script can be implemented only in Netscape 4 using quite a few <layer> tags, then it's probably a good idea to put the Netscape 4 code and tags in a different page. The downside to this approach is that you end up with (at least) two sets of HTML and JavaScript code to maintain, which is nobody's idea of a good time. For this reason, most site designers use page branching only while it's absolutely necessary.
CAUTION
When implementing page branching, always use the Location object's replace() method to send the user to the browser-specific page. If you don't, then the page with the branching code remains in the user's history list. If he clicks his browser's Back button, he'll return to the branching page and then get rerouted to the browser-specific page every time, resulting in a frustrating "mouse trap." The replace() method removes the branching page from the history list so that the user can't return to it.
Using a Custom Object Front End
A custom object front end is a technique that encapsulates the cross-browser functionality in a set of methods assigned to a custom object. This requires four basic steps:
-
Get a reference to the object you want to work with. This is usually done with inline branching:
-
Create a constructor function for a custom object. This custom object needs to store the actual object you're working with, and it needs to define a custom method for each bit of functionality you want to implement for the actual object. For example, the following constructor function creates a custom move() method, which is handled by a function named move_object():
-
Create the function that handles the custom method. What this function does is use inline branching to run the appropriate method for the browser type. For our custom move() method example, let's say Browser A moves an object using its moveA() method, Browser B uses its moveB() method, and other browsers use the moveOther() method. Given this, here's the move_object() function that handles the custom object's move() method:
-
Call the constructor function to create the custom object that you'll use as a front end:
if (browser A) {
current_object = browser A code that returns the object
}
else if (browser B) {
current_object = browser B code that returns the object
}
else {
current_object = other browser code that returns the object
}
function custom_object(actual_object) {
this.actual_object = actual_object
this.move = move_object
}
function move_object(how_much) {
if (browser A) {
this.actual_object.moveA(how_much)
}
else if (browser B) {
this.actual_object.moveB(how_much)
}
else {
this.actual_object.moveOther(how_much)
}
}
my_object = new custom_object(current_object)
Once you do that, you can then apply the custom object's properties and methods to the object you created:
my_object.move(10)
This technique requires more work to set up, but after that it's extremely easy to use and makes your code much more readable because all the branching occurs elsewhere (particularly if you put the custom object code in an external JavaScript file). This is the method I use to set up my cross-browser functions in this chapter.