Google Maps API 3

CHAPTER 2 ■ TRANSFERRING FROM VERSION 2 TO 3
Extensive Use of Object Literals
Another difference is that in v3 object literals are almost exclusively used to pass parameters. I think that
this is brilliant since it makes the API consistent and makes it really easy to extend. Version 2 also used
objects and object literals to pass parameters but to a lesser extent and less consistently.
For example, when creating a new marker, all parameters are passed as an object literal, including
the position:
var marker = new google.maps.Marker({
position: new google.maps.LatLng(40.756, -73.986),
map: map,
title: 'A marker'
});
This makes the API both more consistent and more easily extendable. Imagine, for example, that in
the future a need arises for a parameter that adds a marker at several locations on the same map.
Extending the API with this would then be as simple as adding a positions property to the options object
that would take an array of google.maps.LatLng objects as its value. This addition would feel natural and
wouldn’t break any other functionality.
■ Warning When creating an object literal, be sure not to have a comma after the last property since it will make
Internet Explorer choke.
Asynchronous by Nature
The v2 API relied heavily on synchronous method calls. This made it hard to modularize the API and was
probably the biggest reason for the total remake. The new API is asynchronous by nature, which allows it
to be modularized.
What’s the point of modularizing the API? The answer is simply performance. The old API had to
load big parts of the API before displaying a simple map, even parts of the API that weren’t used.
The new API being modularized only needs to load the necessary parts before initializing the map.
Therefore, the perceived performance is much better; in other words, the map shows up on the web
page much faster.
Synchronous vs. Asynchronous
When using the synchronous method, everything happens in a sequence. If you call methodA, it must
finish running before methodB is invoked. If the methods instead are asynchronous, you can call methodA
and methodB, and they can run parallel to each other.
Consider this example where you invoke two methods after one another:
methodA();
methodB();
methodA takes longer than methodB to run. Figure 2-1 shows how they would execute using
synchronous vs. asynchronous method calls.
8