सुरक्षा नोटिस: हमें सुरक्षा से जुड़ी एक समस्या का पता चला है. यह समस्या तीसरे पक्ष की कुछ लाइब्रेरी (इसमें polyfill.io शामिल है) का इस्तेमाल करने वाली वेबसाइटों पर असर डाल सकती है. इस समस्या की वजह से, वेबसाइट पर आने वाले लोगों को कभी-कभी अपनी वेबसाइट के मालिक की जानकारी या अनुमति के बिना ही, दूसरी वेबसाइट पर रीडायरेक्ट कर दिया जाता है. हमारे कई JavaScript सैंपल में, पहले से polyfill.io
स्क्रिप्ट का एलान शामिल था. हमने इसे अपने सैंपल से हटा दिया है. अगर आपने हमारे JavaScript सैंपल का इस्तेमाल किया है और इनमें यह एलान शामिल है, तो हमारा सुझाव है कि आप इस एलान को हटा दें.
Maps JavaScript API v2, 26 मई, 2021 से उपलब्ध नहीं होगा. इस वजह से, आपकी साइट के v2 मैप काम करना बंद कर देंगे और JavaScript की गड़बड़ियां दिखेंगी. अपनी साइट पर मैप का इस्तेमाल जारी रखने के लिए, Maps JavaScript API v3 पर माइग्रेट करें. इस गाइड से, आपको इन प्रोसेस को पूरा करने में मदद मिलेगी.
खास जानकारी
हर ऐप्लिकेशन की माइग्रेशन प्रोसेस थोड़ी अलग होती है. हालांकि, कुछ ऐसे चरण हैं जो सभी प्रोजेक्ट के लिए एक जैसे हैं:
- नई सुरक्षा कुंजी पाएं. Maps JavaScript API अब
कुंजियों को मैनेज करने के लिए,
Google Cloud Console का इस्तेमाल करता है. अगर अब भी v2 कुंजी का इस्तेमाल किया जा रहा है, तो माइग्रेशन की प्रक्रिया शुरू करने से पहले, अपनी नई एपीआई कुंजी ज़रूर डाउनलोड कर लें.
- अपना एपीआई बूटस्ट्रैप अपडेट करें. ज़्यादातर ऐप्लिकेशन, Maps JavaScript API v3 को इस कोड के साथ लोड करेंगे:
<script src="//maps.googleapis.com/maps/api/js?key=YOUR_API_KEY"></script>
- अपना कोड अपडेट करें. कितना बदलाव करना होगा, यह आपके आवेदन पर निर्भर करेगा. सामान्य बदलावों में ये शामिल हैं:
- हमेशा google.maps नेमस्पेस का रेफ़रंस दें. वर्शन 3 में,
सभी Maps JavaScript API कोड को ग्लोबल नेमस्पेस के बजाय
google.maps.*
नेमस्पेस में सेव किया जाता है. इस प्रोसेस के तहत, ज़्यादातर ऑब्जेक्ट के नाम भी बदल दिए गए हैं. उदाहरण के लिए, GMap2
के बजाय, अब आप google.maps.Map
को लोड करेंगे.
- पुराने तरीकों की सभी रेफ़रंस हटाएं. सामान्य कामों के लिए इस्तेमाल होने वाले कई तरीकों को हटा दिया गया है. जैसे,
GDownloadURL
और GLog
.
इस सुविधा को तीसरे पक्ष की सुविधाओं की लाइब्रेरी से बदलें या अपने कोड से इन पहचान फ़ाइलों को हटाएं.
- (ज़रूरी नहीं) अपने कोड में लाइब्रेरी जोड़ें. कई सुविधाओं को यूटिलिटी लाइब्रेरी में बाहर ले जाया गया है, ताकि हर ऐप्लिकेशन को एपीआई के सिर्फ़ उन हिस्सों को लोड करना पड़े जिनका इस्तेमाल किया जाएगा.
- (ज़रूरी नहीं) v3 एक्सटर्न का इस्तेमाल करने के लिए अपने प्रोजेक्ट को कॉन्फ़िगर करें.
v3 एक्सटर्नल का इस्तेमाल, क्लोज़र
कंपाइलर से आपके कोड की पुष्टि करने या अपने आईडीई में ऑटोकंप्लीट करने के लिए किया जा सकता है.
बेहतर कंपाइलेशन और एक्सटर्न
के बारे में ज़्यादा जानें.
- जांच करें और फिर से दोहराएं. अब भी आपको कुछ काम करना है. हालांकि, अच्छी बात यह है कि आप अपने नए v3 मैप ऐप्लिकेशन को इस्तेमाल करने के लिए तैयार हैं!
Maps JavaScript API के वर्शन 3 में बदलाव
माइग्रेट करने की योजना बनाने से पहले, आपको Maps JavaScript API v2 और Maps JavaScript API v3 के बीच
अंतर को समझने के लिए कुछ समय देना होगा. Maps JavaScript API का सबसे नया वर्शन शुरुआत से लिखा गया है. इसमें JavaScript
प्रोग्रामिंग की आधुनिक तकनीकों, लाइब्रेरी के ज़्यादा इस्तेमाल, और आसान एपीआई पर फ़ोकस किया गया है.
इस एपीआई में कई नई सुविधाएं जोड़ी गई हैं. साथ ही, कई
जानी-पहचानी सुविधाओं को बदला गया है या हटा दिया गया है. इस सेक्शन में, दोनों रिलीज़ के बीच के
कुछ मुख्य अंतर को हाइलाइट किया गया है.
v3 एपीआई में किए गए कुछ बदलावों में ये शामिल हैं:
- व्यवस्थित मुख्य लाइब्रेरी. कई पूरक फ़ंक्शन को
लाइब्रेरी में भेज दिया गया है.
इससे Core API के लिए, लोड और पार्स करने में लगने वाले समय को कम किया जा सकता है.
इससे आपका मैप किसी भी डिवाइस पर तेज़ी से लोड होता है.
- पॉलीगॉन रेंडरिंग और मार्कर प्लेसमेंट जैसी कई सुविधाओं की बेहतर परफ़ॉर्मेंस.
- मोबाइल प्रॉक्सी और कॉर्पोरेट फ़ायरवॉल में इस्तेमाल किए जाने वाले शेयर किए गए पतों को बेहतर तरीके से शामिल करने के लिए,
क्लाइंट-साइड
इस्तेमाल करने की सीमाओं का एक नया तरीका.
- कई आधुनिक
ब्राउज़र और मोबाइल ब्राउज़र के लिए सहायता जोड़ी गई. Internet Explorer 6 पर काम नहीं करता.
इसे हटा दिया गया है.
- अलग-अलग कामों के लिए इस्तेमाल की जाने वाली हेल्पर क्लास (
GLog
या
GDownloadUrl
) को हटाया गया. आज-कल, कई बेहतरीन JavaScript लाइब्रेरी मौजूद हैं जो एक जैसी सुविधाएं देती हैं,
जैसे कि
बंद या
jQuery.
- HTML5 Street View लागू करना, जो किसी भी मोबाइल डिवाइस पर लोड हो जाएगा.
- कस्टम
Street View अपनी फ़ोटो के साथ पैनोरामा दिखाता है. इससे आपको स्की स्लोप, बिक्री के लिए उपलब्ध घरों या अन्य दिलचस्प जगहों के पैनोरामा शेयर करने का विकल्प मिलता है.
- स्टाइल वाले Maps कस्टमाइज़ेशन की मदद से, बेस मैप पर दिखने वाले एलिमेंट को बदला जा सकता है, ताकि वे आपकी यूनीक विज़ुअल स्टाइल से मेल खाएं.
- कई नई सेवाओं के लिए सहायता, जैसे कि
ElevationService
और डिस्टेंस
मैट्रिक्स.
- बेहतर दिशा-निर्देश सेवाओं में अन्य रास्ते, रूट
ऑप्टिमाइज़ेशन (
यात्रा करने वाले सेल्सपर्सन की समस्या के लिए अनुमानित समाधान), साइकल चलाने के निर्देश (
साइकल से यात्रा की लेयर के साथ), सार्वजनिक परिवहन के निर्देश, और
खींचने और छोड़ने लायक निर्देश मिलते हैं.
- यह एक अपडेट किया गया जियोकोडिंग फ़ॉर्मैट है, जो जियोकोडिंग एपीआई v2 के
accuracy
मान से ज़्यादा सटीक टाइप जानकारी देता है.
- एक ही मैप पर कई
जानकारी
Windows के लिए सहायता
आपका ऐप्लिकेशन अपग्रेड किया जा रहा है
आपकी नई कुंजी
Maps JavaScript API v3, v2 के एक नए कुंजी सिस्टम का इस्तेमाल करता है. हो सकता है कि आपके ऐप्लिकेशन के साथ पहले से ही
v3 कुंजी का इस्तेमाल किया जा रहा हो. ऐसे में, किसी बदलाव की ज़रूरत नहीं है. पुष्टि करने के लिए, उस
यूआरएल की जांच करें जिससे Maps JavaScript API को
key
पैरामीटर के लिए लोड किया जाता है. अगर कुंजी की वैल्यू 'ABQIAA' से शुरू होती है, तो इसका मतलब है कि
v2 कुंजी का इस्तेमाल किया जा रहा है. अगर आपके पास v2 कुंजी है, तो आपको माइग्रेशन के दौरान v3 कुंजी पर अपग्रेड करना होगा.
ऐसा करने पर:
Maps JavaScript API v3 को लोड करते समय कुंजी पास की जाती है.
एपीआई पासकोड जनरेट करने के बारे में ज़्यादा जानें.
ध्यान दें कि अगर आप Google Maps API for Work के ग्राहक हैं, तो हो सकता है कि आपके पास key
पैरामीटर के बजाय, client
पैरामीटर के साथ क्लाइंट आईडी का इस्तेमाल करने का विकल्प हो. Client-ID, अब भी Maps JavaScript API v3 में काम करते हैं. इन्हें अपग्रेड करने की ज़रूरत नहीं है.
एपीआई लोड हो रहा है
अपने कोड में सबसे पहले, आपको एपीआई को लोड करने का तरीका
शामिल करना होगा. वर्शन 2 में, http://maps.google.com/maps
के अनुरोध के ज़रिए Maps JavaScript API को लोड किया जाता है. अगर Maps JavaScript API v3 को लोड किया जा रहा है, तो आपको ये बदलाव
करने होंगे:
//maps.googleapis.com/maps/api/js
से एपीआई लोड करें
file
पैरामीटर हटाएं.
- अपनी नई v3 कुंजी से
key
पैरामीटर को अपडेट करें. Google Maps API for Work के ग्राहकों को
client
पैरामीटर का इस्तेमाल करना चाहिए.
- (सिर्फ़ Google Maps Platform के प्रीमियम प्लान के लिए) पक्का करें कि
client
पैरामीटर दिया गया हो, जैसा कि
Google Maps Platform के प्रीमियम प्लान की डेवलपर गाइड में बताया गया है.
- नए वर्शन का अनुरोध करने के लिए,
v
पैरामीटर को हटाएं या
v3 वर्शन
स्कीम के मुताबिक, इसकी वैल्यू बदलें.
- (ज़रूरी नहीं)
hl
पैरामीटर को
language
से बदलें और इसकी वैल्यू को सुरक्षित रखें.
- (ज़रूरी नहीं)
ज़रूरी
लाइब्रेरी लोड करने के लिए,
libraries
पैरामीटर जोड़ें.
सबसे आसान मामले में, v3 बूटस्ट्रैप सिर्फ़ आपका एपीआई कुंजी पैरामीटर तय करेगा:
<script src="//maps.googleapis.com/maps/api/js?key=YOUR_API_KEY"></script>
नीचे दिए गए उदाहरण में, Maps JavaScript एपीआई v2 के सबसे नए वर्शन का अनुरोध जर्मन भाषा में किया गया है:
<script src="//maps.google.com/maps?file=api&v=2.x&key=YOUR_API_KEY&hl=de"></script>
नीचे दिया गया उदाहरण, v3 के लिए एक मिलता-जुलता अनुरोध है.
<script src="//maps.googleapis.com/maps/api/js?key=YOUR_API_KEY&language=de"></script>
पेश है google.maps नेमस्पेस
Maps JavaScript API v3 में शायद सबसे ज़्यादा ध्यान देने लायक बदलाव google.maps
नेमस्पेस के बारे में है. v2 एपीआई,
डिफ़ॉल्ट रूप से ग्लोबल नेमस्पेस में सभी ऑब्जेक्ट को शामिल करता है. इस वजह से, नाम तय करने के लिए
टकराव हो सकते हैं. वर्शन 3 में, सभी ऑब्जेक्ट
google.maps
नेमस्पेस में मौजूद होते हैं.
अपने ऐप्लिकेशन को v3 पर माइग्रेट करते समय, नए नेमस्पेस का इस्तेमाल करने के लिए
आपको अपना कोड बदलना होगा. माफ़ करें, "G" खोजने के बाद उसे "google.maps." से बदलने का कोई फ़ायदा नहीं है. हालांकि, अपने कोड की समीक्षा करते समय इसे लागू करना अच्छा रहता है. नीचे v2 और v3 में
मिलती-जुलती क्लास के कुछ उदाहरण दिए गए हैं.
v2 |
v3 |
GMap2 |
google.maps.Map |
GLatLng |
google.maps.LatLng |
GInfoWindow |
google.maps.InfoWindow |
GMapOptions |
google.map.MapOptions |
G_API_VERSION |
google.maps.version |
GPolyStyleOptions |
google.maps.PolygonOptions or
google.maps.PolylineOptions |
पुराना कोड हटाया जा रहा है
वर्शन 2 में मौजूद ज़्यादातर फ़ंक्शन, Maps JavaScript API v3 में काम करते हैं. हालांकि, कुछ ऐसी क्लास हैं जो अब काम नहीं करती. माइग्रेशन के दौरान, आपको इन क्लास की जगह तीसरे पक्ष की यूटिलिटी लाइब्रेरी का इस्तेमाल करना होगा या अपने कोड से इन रेफ़रंस को हटा देना चाहिए. JavaScript की कई बेहतरीन लाइब्रेरी मौजूद हैं, जो एक जैसी सुविधाएं देती हैं. जैसे, Closure या
jQuery.
Maps JavaScript API v3 में नीचे दी गई क्लास एक जैसी नहीं हैं:
GBounds | GLanguage |
GBrowserIsCompatible | GLayer |
GControl | GLog |
GControlAnchor | GMercatorProjection |
GControlImpl | GNavLabelControl |
GControlPosition | GObliqueMercator |
GCopyright | GOverlay |
GCopyrightCollection | GPhotoSpec |
GDownloadUrl | GPolyEditingOptions |
GDraggableObject | GScreenOverlay |
GDraggableObjectOptions | GStreetviewFeatures |
GFactualGeocodeCache | GStreetviewLocation |
GGeoAddressAccuracy | GStreetviewOverlay |
GGeocodeCache | GStreetviewUserPhotosOptions |
GGoogleBar | GTileLayerOptions |
GGoogleBarAdsOptions | GTileLayerOverlayOptions |
GGoogleBarLinkTarget | GTrafficOverlayOptions |
GGoogleBarListingTypes | GUnload |
GGoogleBarOptions | GXml |
GGoogleBarResultList | GXmlHttp |
GInfoWindowTab | GXslt |
GKeyboardHandler |
|
तुलना कोड
आइए, दो आसान ऐप्लिकेशन की तुलना करते हैं, जो v2 और v3 एपीआई के साथ लिखे गए हैं.
<!DOCTYPE html>
<html>
<head>
<script src="//maps.google.com/maps?file=api&v=2&key=YOUR_API_KEY"></script>
<style>
html, body, #map { height: 100%; margin: 0; }
</style>
<script>
function initialize() {
if (GBrowserIsCompatible()) {
var map = new GMap2(
document.getElementById('map'));
map.setCenter(new GLatLng(37.4419, -122.1419), 13);
map.setUIToDefault();
map.addOverlay(new GMarker(new GLatLng(37.4419, -122.1419)));
}
}
</script>
</head>
<body onload="initialize()" onunload="GUnload()">
<div id="map"></div>
</body>
</html>
<!DOCTYPE html>
<html>
<head>
<script src="//maps.googleapis.com/maps/api/js?key=YOUR_API_KEY"></script>
<style>
html, body, #map { height: 100%; margin: 0; }
</style>
<script>
function initialize() {
var map = new google.maps.Map(
document.getElementById('map'), {
center: new google.maps.LatLng(37.4419, -122.1419),
zoom: 13,
mapTypeId: google.maps.MapTypeId.ROADMAP
});
var marker = new google.maps.Marker({
position: new google.maps.LatLng(37.4419, -122.1419),
map: map
});
}
google.maps.event.addDomListener(window, 'load', initialize);
</script>
</head>
<body>
<div id="map"></div>
</body>
</html>
जैसा कि आपको दिख रहा है, दोनों ऐप्लिकेशन के बीच कई अंतर हैं. अहम बदलावों में ये शामिल हैं:
- जिस पते से एपीआई लोड किया गया है उसे बदल दिया गया है.
- अब v3 में
GBrowserIsCompatible()
और GUnload()
तरीके की ज़रूरत नहीं है. इसलिए, इन्हें एपीआई से हटा दिया गया है.
GMap2
ऑब्जेक्ट को एपीआई में मुख्य ऑब्जेक्ट के तौर पर,
google.maps.Map
से बदल दिया जाता है.
- प्रॉपर्टी अब विकल्प क्लास के ज़रिए लोड की जाती हैं. ऊपर दिए गए उदाहरण में, हमने इनलाइन
MapOptions
ऑब्जेक्ट की मदद से, मैप लोड करने के लिए ज़रूरी तीन प्रॉपर्टी — center
, zoom
, और mapTypeId
को सेट किया है.
- वर्शन 3 में, डिफ़ॉल्ट यूज़र इंटरफ़ेस (यूआई) डिफ़ॉल्ट रूप से चालू होता है. इसे बंद करने के लिए,
MapOptions
ऑब्जेक्ट में
disableDefaultUI
प्रॉपर्टी को
'सही है' पर सेट करें.
खास जानकारी
यहां, आपको Maps JavaScript API के वर्शन 2 से v3 में माइग्रेट करने में शामिल कुछ अहम चीज़ों की जानकारी मिल जाएगी.
आपको कुछ और जानकारी की ज़रूरत पड़ सकती है. हालांकि, यह आपके ऐप्लिकेशन पर निर्भर
करती है. इन सेक्शन में, हमने कुछ खास मामलों में माइग्रेशन से जुड़े निर्देश शामिल किए हैं. इसके अलावा, ऐसे कई संसाधन हैं
जो अपग्रेड की प्रोसेस के दौरान आपके लिए मददगार हो सकते हैं.
- Maps JavaScript API v3
डेवलपर के लिए दस्तावेज़
, एपीआई के काम करने के तरीके और उसके बारे में ज़्यादा जानकारी पाने की सबसे सही जगह है.
- Maps JavaScript API v3
रेफ़रंस
की मदद से, v3 API में नई क्लास और तरीकों के बारे में ज़्यादा जानकारी पाई जा सकती है.
- Stack Overflow कम्यूनिटी, कोड से जुड़े सवाल पूछने का एक बेहतरीन प्लैटफ़ॉर्म है. साइट पर, Maps JavaScript API से जुड़े सवालों और जवाबों के लिए,
'google-maps'
या 'google-maps-api-3' टैग का इस्तेमाल किया जाता है.
- Google Maps Platform के प्रीमियम प्लान के ग्राहक,
Google Maps Platform के प्रीमियम प्लान के
दस्तावेज़ पढ़ना चाहेंगे.
- एपीआई में हुए नए बदलावों के बारे में जानने के लिए, Google जियो डेवलपर ब्लॉग एक बेहतरीन तरीका है.
अगर इस लेख के बारे में आपको कोई समस्या है या आपका कोई सवाल है, तो कृपया इस पेज पर सबसे ऊपर दिए गए
सुझाव/राय दें या शिकायत करें लिंक का इस्तेमाल करें.
इस सेक्शन में, Maps JavaScript API के वर्शन 2 और 3, दोनों की सबसे लोकप्रिय सुविधाओं की ज़्यादा जानकारी दी गई है. पहचान के हर सेक्शन को अलग-अलग पढ़ने के लिए डिज़ाइन किया गया है. हमारा सुझाव है कि आप इस रेफ़रंस को पूरा न पढ़ें. इसके बजाय, अलग-अलग मामलों के हिसाब से माइग्रेट करने के लिए, इस कॉन्टेंट का इस्तेमाल करें.
- इवेंट - इवेंट को रजिस्टर और मैनेज करना.
- कंट्रोल - मैप पर दिखने वाले नेविगेशन
कंट्रोल में बदलाव करना.
- ओवरले - मैप पर
ऑब्जेक्ट जोड़ना और उनमें बदलाव करना.
- मैप टाइप - बुनियादी मैप बनाने वाली टाइल.
- लेयर - ग्रुप के तौर पर कॉन्टेंट जोड़ना या उसमें बदलाव करना, जैसे कि KML या ट्रैफ़िक लेयर.
- सेवाएं - Google की जियोकोडिंग, दिशा-निर्देशों या Street View सेवाओं के साथ काम करना.
इवेंट
Maps JavaScript API v3 का इवेंट मॉडल, v2 के जैसा ही है.
हालांकि, इस मॉडल में काफ़ी बदलाव हुए हैं.
एमवीसी की सहायता के लिए नया इवेंट
v3 API, एमवीसी की स्थिति में हुए बदलावों को दिखाने के लिए नए तरह का इवेंट जोड़ता है. अब
दो तरह के इवेंट उपलब्ध हैं:
- उपयोगकर्ता इवेंट (जैसे कि "क्लिक" माउस इवेंट) को
डीओएम से Maps JavaScript API में भेजा जाता है. ये इवेंट, स्टैंडर्ड डीओएम इवेंट से अलग और
अलग होते हैं.
- एमवीसी की स्थिति में बदलाव की सूचनाएं, Maps API ऑब्जेक्ट में होने वाले बदलावों को दिखाती हैं
और इन्हें
property_changed
कन्वेंशन का इस्तेमाल करके नाम दिया जाता है.
हर Maps API ऑब्जेक्ट, नाम वाले कई इवेंट एक्सपोर्ट करता है. किसी
खास इवेंट में दिलचस्पी रखने वाले ऐप्लिकेशन को उन इवेंट के लिए, इवेंट लिसनर को रजिस्टर करना चाहिए.
साथ ही, उन इवेंट के मिलने पर कोड चलाना चाहिए. Maps JavaScript API
v2 और 3, दोनों में इवेंट-ड्रिवन तरीका एक जैसा ही है.
हालांकि, नेमस्पेस को GEvent
से बदलकर
google.maps.event
कर दिया गया है:
GEvent.addListener(map, 'click', function() {
alert('You clicked the map.');
});
google.maps.event.addListener(map, 'click', function() {
alert('You clicked the map.');
});
इवेंट लिसनर को हटाया जा रहा है
परफ़ॉर्मेंस की वजह से, बेहतर होगा कि जब इवेंट लिसनर की ज़रूरत न हो,
तब आप उसे हटा दें. इवेंट लिसनर को हटाने का तरीका, वर्शन 2 और
v3 की तरह ही काम करता है:
- इवेंट लिसनर बनाने पर, एक ओपेक ऑब्जेक्ट (v2 में GEventListener
और v3 में MapsEventListener
) दिखता है.
- जब आपको इवेंट लिसनर को हटाना हो, तो इवेंट लिसनर को हटाने के लिए, इस ऑब्जेक्ट को
removeListener()
तरीके (v2 में GEvent.removeListener()
या v3 में google.maps.event.removeListener()
) पर
पास करें.
डीओएम इवेंट को सुना जा रहा है
अगर आपको डीओएम (डॉक्यूमेंट ऑब्जेक्ट मॉडल)
इवेंट को कैप्चर करके उनका जवाब देना है, तो v3 में google.maps.event.addDomListener()
स्टैटिक तरीका होता है. यह तरीका, v2
के GEvent.addDomListener()
तरीके की तरह है.
इवेंट में पास किए गए तर्क इस्तेमाल करना
यूज़र इंटरफ़ेस (यूआई) इवेंट की वजह से अक्सर ऐसे इवेंट आर्ग्युमेंट पास किए जाते हैं जिन्हें
इवेंट लिसनर ऐक्सेस कर सकता है. वर्शन 3 में ज़्यादातर इवेंट आर्ग्युमेंट को आसान बना दिया गया है, ताकि वे एपीआई में मौजूद ऑब्जेक्ट पर
ज़्यादा एक जैसे बने रहें. (ज़्यादा जानकारी के लिए,
v3 का रेफ़रंस
देखें.)
v3 इवेंट लिसनर में कोई overlay
तर्क मौजूद नहीं है. अगर आपने
v3 मैप पर click
इवेंट रजिस्टर किया है, तो कॉलबैक
सिर्फ़ तब होगा, जब उपयोगकर्ता बुनियादी मैप पर क्लिक करेगा. अगर आपको उन क्लिक पर प्रतिक्रिया देने की ज़रूरत है,
तो क्लिक किए जा सकने वाले ओवरले पर अतिरिक्त कॉलबैक रजिस्टर किए जा सकते हैं.
// Passes an overlay argument when clicking on a map
var map = new GMap2(document.getElementById('map'));
map.setCenter(new GLatLng(-25.363882, 131.044922), 4);
map.setUIToDefault();
GEvent.addListener(map,'click', function(overlay, latlng) {
if (latlng) {
var marker = new GMarker(latlng);
map.addOverlay(marker);
}
});
// Passes only an event argument
var myOptions = {
center: new google.maps.LatLng(-25.363882, 131.044922),
zoom: 4,
mapTypeId: google.maps.MapTypeId.ROADMAP
};
var map = new google.maps.Map(document.getElementById('map'),
myOptions);
google.maps.event.addListener(map, 'click', function(event) {
var marker = new google.maps.Marker({
position: event.latLng,
map: map
});
});
कंट्रोल
Maps JavaScript API, यूज़र इंटरफ़ेस (यूआई) कंट्रोल दिखाता है. इनकी मदद से,
उपयोगकर्ता आपके मैप से इंटरैक्ट कर सकते हैं. इस एपीआई का इस्तेमाल करके, अपने हिसाब से ये कंट्रोल
दिखाए जा सकते हैं.
कंट्रोल टाइप में बदलाव
v3 API की मदद से, control
टाइप में कुछ बदलाव किए गए हैं.
- v3 API अतिरिक्त
मैप टाइप
के साथ काम करता है. इसमें इलाके के मैप और पसंद के मुताबिक मैप टाइप जोड़ने की सुविधा शामिल है.
- v2 हैरारकी कंट्रोल,
GHierarchicalMapTypeControl
अब उपलब्ध नहीं है.
google.maps.MapTypeControlStyle.HORIZONTAL_BAR
कंट्रोल का इस्तेमाल करके,
ऐसा ही असर पाया जा सकता है.
GMapTypeControl
के वर्शन 2 में दिया गया हॉरिज़ॉन्टल लेआउट, v3 में उपलब्ध नहीं है.
मैप पर कंट्रोल जोड़ना
Maps JavaScript API v2 की मदद से, आपको अपने मैप ऑब्जेक्ट के addControl()
तरीके से, मैप
में कंट्रोल जोड़ने होंगे. वर्शन 3 में, कंट्रोल को सीधे ऐक्सेस करने या उनमें बदलाव करने के बजाय,
उनसे जुड़े MapOptions
ऑब्जेक्ट में बदलाव किया जाता है. नीचे दिए गए
सैंपल में, इन कंट्रोल को जोड़ने के लिए, मैप को पसंद के मुताबिक
बनाने का तरीका बताया गया है:
- वे बटन जो उपयोगकर्ता को उपलब्ध मैप टाइप के बीच टॉगल करने की सुविधा देते हैं
- मैप का स्केल
var map = new GMap2(document.getElementById('map'));
map.setCenter(new GLatLng(-25.363882, 131.044922), 4);
// Add controls
map.addControl(new GMapTypeControl());
map.addControl(new GScaleControl());
var myOptions = {
center: new google.maps.LatLng(-25.363882, 131.044922),
zoom: 4,
mapTypeId: google.maps.MapTypeId.ROADMAP,
// Add controls
mapTypeControl: true,
scaleControl: true
};
var map = new google.maps.Map(document.getElementById('map'),
myOptions);
मैप पर स्थिति निर्धारण नियंत्रण
वर्शन 3 में पोज़िशनिंग कंट्रोल में बहुत ज़्यादा बदलाव हुए हैं. वर्शन 2 में, addControl()
वाला तरीका एक वैकल्पिक दूसरा पैरामीटर लेता है
जिसकी मदद से आप मैप के कोनों के हिसाब से कंट्रोल की जगह तय कर सकते हैं.
वर्शन 3 में, कंट्रोल के विकल्पों की position
प्रॉपर्टी के ज़रिए, कंट्रोल की पोज़िशन सेट की जाती है. इन कंट्रोल की पोज़िशनिंग
बिलकुल नहीं होती है. इसके बजाय, एपीआई तय की गई सीमाओं (जैसे, मैप के साइज़) के तहत, कंट्रोल को
मौजूदा मैप एलिमेंट के आस-पास "फ़्लो" करके, सोच-समझकर लेआउट तैयार करता है.
इससे यह पक्का होता है कि डिफ़ॉल्ट कंट्रोल, आपके कंट्रोल के साथ काम करते हैं.
ज़्यादा जानकारी के लिए, v3 में पोज़िशनिंग कंट्रोल करना देखें.
ऊपर दिए गए सैंपल में से, इन कोड की जगह बदलने वाले कंट्रोल:
var map = new GMap2(document.getElementById('map'));
map.setCenter(new GLatLng(-25.363882, 131.044922), 4);
// Add map type control
map.addControl(new GMapTypeControl(), new GControlPosition(
G_ANCHOR_TOP_LEFT, new GSize(10, 10)));
// Add scale
map.addControl(new GScaleControl(), new GControlPosition(
G_ANCHOR_BOTTOM_RIGHT, new GSize(20, 20)));
var myOptions = {
center: new google.maps.LatLng(-25.363882, 131.044922),
zoom: 4,
mapTypeId: google.maps.MapTypeId.ROADMAP,
// Add map type control
mapTypeControl: true,
mapTypeControlOptions: {
style: google.maps.MapTypeControlStyle.HORIZONTAL_BAR,
position: google.maps.ControlPosition.TOP_LEFT
},
// Add scale
scaleControl: true,
scaleControlOptions: {
position: google.maps.ControlPosition.BOTTOM_RIGHT
}
};
var map = new google.maps.Map(document.getElementById('map'),
myOptions);
कस्टम कंट्रोल
Maps JavaScript API का इस्तेमाल करके, नेविगेशन के लिए अपने हिसाब से कंट्रोल बनाए जा सकते हैं.
v2 एपीआई के साथ कंट्रोल को पसंद के मुताबिक बनाने के लिए, आपको
GControl
क्लास को सब-क्लास करना होगा. साथ ही,
initialize()
और getDefaultPosition()
तरीकों के लिए हैंडलर तय करना होगा.
v3 में GControl
क्लास के बराबर नहीं है. इसके बजाय,
कंट्रोल को डीओएम एलिमेंट के तौर पर दिखाया जाता है. v3 एपीआई के साथ कस्टम कंट्रोल जोड़ने के लिए,
Node
(जैसे,
<div>
एलिमेंट) के चाइल्ड के तौर पर,
कंस्ट्रक्टर में कंट्रोल के लिए एक डीओएम स्ट्रक्चर बनाएं और किसी भी
डीओएम इवेंट को हैंडल करने के लिए, इवेंट लिसनर को जोड़ें. अपने मैप पर कस्टम कंट्रोल का इंस्टेंस जोड़ने के लिए, मैप की controls[position]
कलेक्शन में Node
को दबाएं.
HomeControl
क्लास को लागू करने के बाद, जो
ऊपर बताई गई इंटरफ़ेस से जुड़ी ज़रूरी शर्तों का पालन करता है (ज़्यादा जानकारी के लिए
कस्टम कंट्रोल दस्तावेज़ देखें), नीचे दिए गए कोड सैंपल में
मैप में कस्टम कंट्रोल जोड़ने का तरीका बताया गया है.
map.addControl(new HomeControl(),
GControlPosition(G_ANCHOR_TOP_RIGHT, new GSize(10, 10)));
var homeControlDiv = document.createElement('DIV');
var homeControl = new HomeControl(homeControlDiv, map);
map.controls[google.maps.ControlPosition.TOP_RIGHT].push(
homeControlDiv);
ओवरले
ओवरले उन ऑब्जेक्ट को दिखाते हैं जिन्हें पॉइंट, लाइन, इलाके या ऑब्जेक्ट के कलेक्शन को दिखाने के लिए मैप में "जोड़ा" जाता है.
ओवरले जोड़ना और हटाना
ओवरले से दिखाए जाने वाले ऑब्जेक्ट के टाइप, v2 और v3 में एक जैसे ही होते हैं. हालांकि, इन्हें अलग-अलग तरीके से हैंडल किया जाता है.
v2 एपीआई के ओवरले को मैप में जोड़ा और उससे हटाया गया. इसके लिए, GMap2
ऑब्जेक्ट के addOverlay()
और removeOverlay()
तरीकों का इस्तेमाल किया गया. वर्शन 3 में, आप इससे जुड़े ओवरले विकल्प क्लास की map
प्रॉपर्टी के ज़रिए, ओवरले को
मैप असाइन करते हैं.
आप ओवरले ऑब्जेक्ट पर सीधे
setMap()
तरीके को कॉल करके, ओवरले जोड़ या हटा भी सकते हैं. साथ ही, अपनी पसंद के मुताबिक मैप
तय कर सकते हैं. मैप प्रॉपर्टी को null
पर सेट करने से, ओवरले हट जाता है.
वर्शन 3 में कोई clearOverlays()
तरीका मौजूद नहीं है.
अगर आपको ओवरले का कोई सेट मैनेज करना है, तो आपको ओवरले को होल्ड करने के लिए एक कलेक्शन बनाना होगा. इसके बाद, इस अरे का इस्तेमाल करके, अरे में हर ओवरले पर
setMap()
को कॉल किया जा सकता है. अगर आपको इन्हें हटाने की ज़रूरत है, तो null
को पास करना होगा.
खींचने और छोड़ने लायक मार्कर
डिफ़ॉल्ट रूप से, मार्कर पर क्लिक किया जा सकता है, लेकिन उन्हें खींचा नहीं जा सकता. नीचे दिए गए दो सैंपल,
खींचने और छोड़ने लायक मार्कर जोड़ते हैं:
var myLatLng = new GLatLng(-25.363882, 131.044922);
var map = new GMap2(document.getElementById('map'));
map.setCenter(myLatLng, 4);
var marker = new GMarker(latLng, {
draggable: true
});
map.addOverlay(marker);
var myLatLng = new google.maps.LatLng(-25.363882, 131.044922);
var map = new google.maps.Map(
document.getElementById('map'), {
center: myLatLng,
zoom: 4,
mapTypeId: google.maps.MapTypeId.ROADMAP
});
var marker = new google.maps.Marker({
position: myLatLng,
draggable: true,
map: map
});
आइकॉन
डिफ़ॉल्ट मार्कर की जगह पर दिखाने के लिए कस्टम आइकॉन तय किया जा सकता है.
वर्शन 2 में कस्टम इमेज का इस्तेमाल करने के लिए, G_DEFAULT_ICON type
से GIcon
इंस्टेंस बनाया जा सकता है और उसमें बदलाव किया जा सकता है. अगर
आपकी इमेज डिफ़ॉल्ट आइकॉन से बड़ी या छोटी है, तो आपको
इसकी जानकारी देने के लिए GSize
इंस्टेंस का इस्तेमाल करना होगा.
v3 API इस प्रोसेस को बहुत आसान बनाता है.
बस मार्कर की icon
प्रॉपर्टी को अपनी पसंद के मुताबिक इमेज के यूआरएल पर सेट करें और एपीआई आइकॉन का
साइज़ अपने-आप सेट कर देगा.
Maps JavaScript API, कॉम्प्लेक्स आइकॉन के लिए भी सहायता उपलब्ध कराता है.
कॉम्प्लेक्स आइकॉन में कई टाइल और जटिल आकार शामिल हो सकते हैं. इसके अलावा, यह "स्टैक का क्रम" तय कर सकते हैं कि दूसरे ओवरले के मुकाबले इमेज को कैसा दिखना चाहिए. वर्शन 2 में मार्कर में कोई आकार जोड़ने के लिए, आपको हर
GIcon
इंस्टेंस में अतिरिक्त प्रॉपर्टी के बारे में बताना होगा. साथ ही, इसे GMarker
कंस्ट्रक्टर के विकल्प के तौर पर
पास करना होगा. v3 में, इस तरह से बताए गए आइकॉन को अपनी icon
प्रॉपर्टी को Icon
टाइप के ऑब्जेक्ट पर सेट करना चाहिए.
वर्शन 3 में मार्कर की परछाई काम नहीं करती.
नीचे दिए गए उदाहरणों में, ऑस्ट्रेलिया के बोंडाई बीच पर समुद्र का झंडा दिखाया गया है. इसमें आइकॉन के पारदर्शी हिस्से पर क्लिक नहीं किया जा सकता:
var map = new GMap2(document.getElementById('map'));
map.setCenter(new GLatLng(-25.363882, 131.044922), 4);
map.setUIToDefault();
var flagIcon = new GIcon(G_DEFAULT_ICON);
flagIcon.image = '/images/beachflag.png';
flagIcon.imageMap = [1, 1, 1, 20, 18, 20, 18 , 1];
var bbLatLng = new GLatLng(-33.890542, 151.274856);
map.addOverlay(new GMarker(bbLatLng, {
icon: flagIcon
}));
var map = new google.maps.Map(
document.getElementById('map'), {
center: new google.maps.LatLng(-25.363882, 131.044922),
zoom: 4,
mapTypeId: google.maps.MapTypeId.ROADMAP
});
var shape = {
coord: [1, 1, 1, 20, 18, 20, 18 , 1],
type: 'poly'
};
var bbLatLng = new google.maps.LatLng(-33.890542, 151.274856);
var bbMarker = new google.maps.Marker({
icon: '/images/beachflag.png'
shape: shape,
position: bbLatLng,
map: map
});
पॉलीलाइन
पॉलीलाइन में LatLng
की एक कैटगरी होती है. साथ ही, इसमें लाइन सेगमेंट की एक सीरीज़ होती है, जो उन जगहों को क्रम में जोड़ती है.
v3 में Polyline
ऑब्जेक्ट बनाना और दिखाना, v2 में GPolyline
ऑब्जेक्ट का इस्तेमाल करने जैसा ही है. नीचे दिए गए नमूने,
ज़्यूरिख से लेकर सिंगापुर तक जाने के लिए, सेमी-पारदर्शी, तीन पिक्सल चौड़ी, जियोडेसिक पॉलीलाइन
बनाते हैं:
var polyline = new GPolyline(
[
new GLatLng(47.3690239, 8.5380326),
new GLatLng(1.352083, 103.819836),
new GLatLng(-33.867139, 151.207114)
],
'#FF0000', 3, 0.5, {
geodesic: true
});
map.addOverlay(polyline);
var polyline = new google.maps.Polyline({
path: [
new google.maps.LatLng(47.3690239, 8.5380326),
new google.maps.LatLng(1.352083, 103.819836),
new google.maps.LatLng(-33.867139, 151.207114)
],
strokeColor: '#FF0000',
strokeOpacity: 0.5,
strokeWeight: 3,
geodesic: true
});
polyline.setMap(map);
कोड में बदली गई पॉलीलाइन
कोड में बदली गई पॉलीलाइन से सीधे Polyline
ऑब्जेक्ट बनाने के लिए, v3 में कोई सुविधा मौजूद नहीं है. इसके बजाय, जियोमेट्री लाइब्रेरी
पॉलीलाइन को कोड में बदलने और डिकोड करने के तरीके उपलब्ध कराती है. इस लाइब्रेरी को लोड करने के तरीके के बारे में ज़्यादा जानकारी के लिए, v3 Maps API में लाइब्रेरी देखें.
नीचे दिए गए उदाहरण, कोड में बदली गई एक ही पॉलीलाइन बनाते हैं. v3 कोड, google.maps.geometry.encoding
नेमस्पेस के
decodePath()
तरीके का इस्तेमाल करता है.
var polyline = new GPolyline.fromEncoded({
points: 'kwb`Huqbs@ztzwGgvpdQbw}uEoif`H',
levels: 'PPP',
zoomFactor: 2,
numLevels: 18,
color: '#ff0000',
opacity: 0.8,
weight: 3
});
map.addOverlay(polyline);
var polyline = new google.maps.Polyline({
path: google.maps.geometry.encoding.decodePath(
'kwb`Huqbs@ztzwGgvpdQbw}uEoif`H'),
strokeColor: '#FF0000',
strokeOpacity: 0.5,
strokeWeight: 3,
});
polyline.setMap(map);
पॉलीगॉन
बहुभुज किसी बंद लूप के भीतर क्षेत्र को परिभाषित करता है. बहुत हद तक Polyline
ऑब्जेक्ट की तरह, Polygon
ऑब्जेक्ट में भी एक क्रम में कई पॉइंट होते हैं. v3
Polygon
क्लास, v2
GPolygon
क्लास की तरह ही है. इसमें एक अपवाद है कि अब आपको लूप को बंद करने के लिए, पाथ के आखिर में शुरुआती वर्टेक्स
को दोहराने की ज़रूरत नहीं है. v3 API
किसी भी पॉलीगॉन को अपने-आप बंद कर देगा. इसके लिए, वह एक स्ट्रोक बनाएगा, जो आखिरी निर्देशांक को वापस पहले निर्देशांक से जोड़ते हैं. नीचे दिए गए कोड स्निपेट
बरमूडा त्रिभुज को दिखाने वाला एक पॉलीगॉन बनाते हैं:
var map = new GMap2(document.getElementById('map'));
map.setCenter(new GLatLng(24.886436, -70.268554), 5);
var bermudaTriangle = new GPolygon(
[
new GLatLng(25.774252, -80.190262),
new GLatLng(18.466465, -66.118292),
new GLatLng(32.321384, -64.75737),
new GLatLng(25.774252, -80.190262)
],
'#FF0000', 2, 0.8, '#FF0000', 0.35);
map.addOverlay(bermudaTriangle);
var map = new google.maps.Map(document.getElementById('map'), {
center: new google.maps.LatLng(24.886436, -70.268554),
mapTypeId: google.maps.MapTypeId.TERRAIN,
zoom: 5
});
var bermudaTriangle = new google.maps.Polygon({
paths: [
new google.maps.LatLng(25.774252, -80.190262),
new google.maps.LatLng(18.466465, -66.118292),
new google.maps.LatLng(32.321384, -64.75737)
],
strokeColor: '#FF0000',
strokeWeight: 2,
strokeOpacity: 0.8,
fillColor: '#FF0000',
fillOpacity: 0.35
});
bermudaTriangle.setMap(map);
उपयोगकर्ता के बदलाव किए जा सकने वाले आकार
पॉलीलाइन और पॉलीगॉन को उपयोगकर्ताओं के लिए बदलाव किया जा सकता है. ये कोड स्निपेट एक जैसे होते हैं:
map.addOverlay(polyline);
polyline.enableEditing();
polyline.setMap(map);
polyline.setEditable(true);
ड्रॉइंग की बेहतर सुविधाओं के लिए, v3 दस्तावेज़ में
ड्रॉइंग लाइब्रेरी देखें.
जानकारी विंडो
InfoWindow
में, मैप के ऊपर फ़्लोटिंग विंडो में कॉन्टेंट दिखाया गया है. v2 और v3 जानकारी विंडो के बीच कुछ मुख्य अंतर हैं:
- v2 API हर मैप पर सिर्फ़
GInfoWindow
के साथ काम करता है, जबकि
v3 API हर मैप पर एक साथ कई InfoWindow
इस्तेमाल कर सकता है.
- मैप पर क्लिक करने के बाद, v3
InfoWindow
खुला रहेगा. मैप पर क्लिक करने पर, v2 GInfoWindow
अपने-आप बंद हो जाता है. Map
ऑब्जेक्ट में click
लिसनर जोड़कर, v2
व्यवहार को एम्युलेट किया जा सकता है.
- v3 API, टैब किए गए
InfoWindow
के लिए नेटिव सहायता
नहीं देता है.
ग्राउंड ओवरले
मैप पर इमेज रखने के लिए, आपको
GroundOverlay
ऑब्जेक्ट का इस्तेमाल करना चाहिए. किसी GroundOverlay
का कंस्ट्रक्टर, v2 और v3 में एक जैसा होता है: यह किसी इमेज के यूआरएल और इमेज की सीमाओं को पैरामीटर के तौर पर बताता है.
इस उदाहरण में, मैप पर नेवार्क, न्यूजर्सी के पुराने मैप को ओवरले के तौर पर दिखाया गया है:
var bounds = new GLatLngBounds(
new GLatLng(40.716216, -74.213393),
new GLatLng(40.765641, -74.139235));
var overlay = new GGroundOverlay(
'http://lib.utexas.edu/maps/historical/newark_nj_1922.jpg',
bounds);
map.addOverlay(overlay);
var bounds = new google.maps.LatLngBounds(
new google.maps.LatLng(40.716216, -74.213393),
new google.maps.LatLng(40.765641, -74.139235));
var overlay = new google.maps.GroundOverlay(
'http://lib.utexas.edu/maps/historical/newark_nj_1922.jpg',
bounds);
overlay.setMap(map);
मैप के टाइप
v2 और v3 में उपलब्ध मैप के टाइप थोड़े अलग होते हैं, लेकिन
सभी बेसिक मैप टाइप, एपीआई के दोनों वर्शन में उपलब्ध होते हैं. डिफ़ॉल्ट रूप से, v2
स्टैंडर्ड "पेंट की गई" रोड मैप टाइल का इस्तेमाल करता है. हालांकि, google.maps.Map
ऑब्जेक्ट बनाते समय, v3 के लिए एक खास तरह का मैप होना ज़रूरी है.
सामान्य मैप प्रकार
चार बुनियादी मैप टाइप, v2 और v3, दोनों में उपलब्ध हैं:
MapTypeId.ROADMAP
(G_NORMAL_MAP
को बदल देता है)
रोड मैप व्यू दिखाता है.
MapTypeId.SATELLITE
(G_SATELLITE_MAP
को बदल देता है)
Google Earth की सैटलाइट इमेज दिखाता है.
MapTypeId.HYBRID
(G_HYBRID_MAP
को बदल देता है)
सामान्य और सैटलाइट व्यू का मिश्रण दिखाता है.
MapTypeId.TERRAIN
(G_PHYSICAL_MAP
को बदल देता है)
इलाके की जानकारी के आधार पर फ़िज़िकल मैप दिखाता है.
नीचे मैप को इलाके के व्यू पर सेट करने के v2 और v3 का उदाहरण दिया गया है:
map.setMapType(G_PHYSICAL_MAP);
map.setMapTypeId(google.maps.MapTypeId.TERRAIN);
Maps JavaScript API v3 में आम तौर पर कम इस्तेमाल होने वाले मैप
टाइप में भी कुछ बदलाव किए गए हैं:
- Earth के अलावा, खूबसूरत पिंडों की मैप टाइल, v3 API में मैप टाइप के तौर पर उपलब्ध नहीं हैं. हालांकि, इन्हें पसंद के मुताबिक मैप टाइप के तौर पर ऐक्सेस किया जा सकता है, जैसा कि इस उदाहरण में दिखाया गया है.
- वर्शन 3 में ऐसा कोई खास मैप टाइप नहीं है जो v2 से
G_SATELLITE_3D_MAP
टाइप को बदल दे. इसके बजाय,
इस लाइब्रेरी का इस्तेमाल करके, अपने v3 मैप में Google Earth प्लगिन को इंटिग्रेट किया जा सकता है.
Zoom पर ली गई ज़्यादा से ज़्यादा तस्वीरें
उपग्रह से ली गई तस्वीरें ज़्यादा ज़ूम लेवल पर हमेशा उपलब्ध नहीं होती हैं. अगर आपको यह जानना है कि ज़ूम का लेवल सेट करने से पहले, आपको ज़्यादा से ज़्यादा कितना ज़ूम करना है, तो google.maps.MaxZoomService
क्लास इस्तेमाल करें. यह क्लास, v2 से GMapType.getMaxZoomAtLatLng()
तरीके को बदल देती है.
var point = new GLatLng(
180 * Math.random() - 90, 360 * Math.random() - 180);
var map = new GMap2(document.getElementById("map"));
map.setUIToDefault();
map.setCenter(point);
map.setMapType(G_HYBRID_MAP);
map.getCurrentMapType().getMaxZoomAtLatLng(point,
function(response) {
if (response.status) {
map.setZoom(response.zoom);
} else {
alert("Error in Max Zoom Service.");
}
});
var myLatlng = new google.maps.LatLng(
180 * Math.random() - 90, 360 * Math.random() - 180);
var map = new google.maps.Map(
document.getElementById("map"),{
zoom: 0,
center: myLatlng,
mapTypeId: google.maps.MapTypeId.HYBRID
});
var maxZoomService = new google.maps.MaxZoomService();
maxZoomService.getMaxZoomAtLatLng(
myLatlng,
function(response) {
if (response.status == google.maps.MaxZoomStatus.OK) {
map.setZoom(response.zoom);
} else {
alert("Error in Max Zoom Service.");
}
});
आसमान से ली गई तस्वीरों का संग्रह
वर्शन 3 में एरियल इमेजरी चालू करने पर कंट्रोल, v2
GLargeZoomControl3D
कंट्रोल की तरह ही होते हैं. साथ ही, इसमें एक और इंटरस्टीशियल
रोटेट कंट्रोल होता है, जो काम करने वाले निर्देशों का पालन करता है.
इस मैप पर, फ़िलहाल उन शहरों को ट्रैक किया जा सकता है जहां 45° तस्वीरें मौजूद हैं. 45° वाली तस्वीरों का संग्रह उपलब्ध होने पर, Maps API सैटलाइट बटन में
एक सबमेन्यू विकल्प जोड़ दिया जाता है.
लेयर
मैप पर लेयर ऐसे ऑब्जेक्ट होते हैं जिनमें एक या उससे ज़्यादा ओवरले होते हैं. उन्हें एक इकाई के तौर पर इस्तेमाल किया जा सकता है और आम तौर पर,
चीज़ों के कलेक्शन को दिखाया जा सकता है.
इस्तेमाल की जा सकने वाली लेयर
v3 API कई अलग-अलग लेयर का ऐक्सेस देता है. ये लेयर
v2 GLayer
क्लास को इन मामलों में ओवरलैप करते हैं:
-
KmlLayer
ऑब्जेक्ट, KML और Geoआरएसएस एलिमेंट को
v3 ओवरले में रेंडर करता है. इससे, v2
GeoXml
लेयर के जैसा वर्शन मिलता है.
TrafficLayer
ऑब्जेक्ट, ट्रैफ़िक की स्थिति दिखाने वाली
लेयर को रेंडर करता है. यह, v2 GTrafficOverlay
ओवरले की तरह है.
ये लेयर, v2 से अलग हैं. दोनों के बीच के अंतर के बारे में
नीचे बताया गया है. इन्हें setMap()
को कॉल करके मैप में जोड़ा जा सकता है.
साथ ही, इन्हें Map
ऑब्जेक्ट पास करके,
लेयर में जोड़ा जा सकता है.
साथ काम करने वाली लेयर के बारे में ज़्यादा जानकारी,
लेयर दस्तावेज़ में उपलब्ध है.
KML और GeoRSS लेयर
Maps JavaScript API, भौगोलिक जानकारी दिखाने के लिए KML और GeoRSS डेटा फ़ॉर्मैट पर काम करता है. अगर आप KML या GeoRSS फ़ाइलों को मैप में शामिल करना चाहते हैं, तो उन्हें
सार्वजनिक तौर पर ऐक्सेस किया जा सकता है. वर्शन 3 में, ये डेटा फ़ॉर्मैट KmlLayer
के इंस्टेंस का इस्तेमाल करके दिखाए जाते हैं, जो GGeoXml
ऑब्जेक्ट को v2 से बदल देता है.
KML को रेंडर करते समय v3 API ज़्यादा सुविधाजनक होता है. इससे आपको
InfoWindows को दबाने और क्लिक रिस्पॉन्स में बदलाव करने में मदद मिलती है. ज़्यादा जानकारी के लिए, v3 KML और GeoRSS लेयर दस्तावेज़ देखें.
KmlLayer
को रेंडर करते समय,
साइज़ और जटिलता की पाबंदियां लागू होती हैं. इस बारे में ज़्यादा जानकारी के लिए,
Kmllayer दस्तावेज़
देखें.
नीचे दिए गए सैंपल KML फ़ाइल को लोड करने के तरीके की तुलना करते हैं.
geoXml = new GGeoXml(
'https://googlearchive.github.io/js-v2-samples/ggeoxml/cta.kml');
map.addOverlay(geoXml);
var layer = new google.maps.KmlLayer(
'https://googlearchive.github.io/js-v2-samples/ggeoxml/cta.kml', {
preserveViewport: true
});
layer.setMap(map);
ट्रैफ़िक लेयर
v3 की मदद से, TrafficLayer
ऑब्जेक्ट का इस्तेमाल करके, अपने मैप पर रीयल-टाइम ट्रैफ़िक की जानकारी (जहां यह सुविधा काम करती है) जोड़ी जा सकती है. ट्रैफ़िक की जानकारी,
अनुरोध किए जाने के समय के लिए दी जाती है. ये उदाहरण
मुंबई के लिए ट्रैफ़िक की जानकारी दिखाते हैं:
var map = new GMap2(document.getElementById('map'));
map.setCenter(new GLatLng(34.0492459, -118.241043), 13);
map.setUIToDefault();
var trafficOptions = {incidents:false};
trafficInfo = new GTrafficOverlay(trafficOptions);
map.addOverlay(trafficInfo);
var map = new google.maps.Map(
document.getElementById('map'), {
center: new google.maps.LatLng(34.0492459, -118.241043),
mapTypeId: google.maps.MapTypeId.ROADMAP,
zoom: 13
});
var trafficLayer = new google.maps.TrafficLayer();
trafficLayer.setMap(map);
वर्शन 2 से अलग, v3 में TrafficLayer
कंस्ट्रक्टर के लिए कोई विकल्प मौजूद नहीं है. वर्शन 3 में घटनाएं उपलब्ध नहीं हैं.
सेवाएं
जियोकोडिंग
Maps JavaScript API, उपयोगकर्ता के इनपुट से डाइनैमिक तौर पर, जियोकोडिंग पतों के लिए geocoder
ऑब्जेक्ट देता है. अगर आपको स्टैटिक और जाने-पहचाने पतों को जियोकोड करना है, तो जियोकोडिंग एपीआई का दस्तावेज़ देखें.
जियोकोडिंग एपीआई को काफ़ी बेहतर
तरीके से अपग्रेड किया गया है और इसमें नई सुविधाएं जोड़ी गई हैं.
साथ ही, डेटा दिखाने के तरीके में भी बदलाव किया गया है.
v2 एपीआई में मौजूद GClientGeocoder
में, फ़ॉरवर्ड करने और रिवर्स जियोकोडिंग के लिए दो अलग-अलग तरीके उपलब्ध कराए गए. साथ ही, जियोकोडिंग की सुविधा को बेहतर बनाने के लिए दो अलग-अलग तरीके उपलब्ध कराए गए. वहीं दूसरी ओर, v3
Geocoder
ऑब्जेक्ट में सिर्फ़ geocode()
तरीका काम करता है. इसमें, इनपुट के शब्दों वाली लिटरल वैल्यू
(जियोकोडिंग
अनुरोध ऑब्जेक्ट के रूप में) और कॉलबैक के तरीके की ज़रूरत होती है. अनुरोध में टेक्स्ट वाले address
एट्रिब्यूट या LatLng
ऑब्जेक्ट शामिल हैं या नहीं, इसके आधार पर जियोकोडिंग एपीआई फ़ॉरवर्ड या रिवर्स जियोकोडिंग रिस्पॉन्स देगा. जियोकोडिंग के अनुरोध में अतिरिक्त फ़ील्ड भेजकर आप जियोकोडिंग के तरीके को प्रभावित कर सकते हैं:
- टेक्स्ट वाले
address
को शामिल करने से, फ़ॉरवर्ड जियोकोडिंग शुरू हो जाती है. यह getLatLng()
तरीके को कॉल करने के बराबर है.
latLng
ऑब्जेक्ट शामिल करने से, रिवर्स जियोकोडिंग ट्रिगर होता है. यह getLocations()
तरीके को कॉल करने के बराबर है.
bounds
एट्रिब्यूट को शामिल करने पर, व्यूपोर्ट
मापदंड तय करने की सुविधा चालू हो जाती है. यह setViewport()
तरीके को कॉल करने की तरह ही काम करती है.
region
एट्रिब्यूट को शामिल करने पर, क्षेत्र का कोड तय करने की सुविधा चालू हो जाती है. यह setBaseCountryCode()
तरीके को कॉल करने की तरह ही काम करता है.
वर्शन 3 में जियोकोडिंग के रिस्पॉन्स, v2 रिस्पॉन्स से काफ़ी अलग हैं. v3 API,
नेस्ट किए गए उस स्ट्रक्चर की जगह ले लेता है जिसका इस्तेमाल v2 ज़्यादा फ़्लैट स्ट्रक्चर से करता है.
इस स्ट्रक्चर को पार्स करना आसान है. इसके अलावा, v3 जवाबों में ज़्यादा जानकारी दी जाती है: हर नतीजे में कई पते वाले कॉम्पोनेंट होते हैं. इनसे, हर नतीजे के रिज़ॉल्यूशन को बेहतर तरीके से समझने में मदद मिलती है.
इस कोड के लिए टेक्स्ट वाला पता दिया जाता है और जियोकोड की मदद से पहला नतीजा दिखाया जाता है:
var geocoder = new GClientGeocoder();
var infoPanel;
var map;
var AccuracyDescription = [
'Unknown accuracy', 'country level accuracy',
'region level accuracy', 'sub-region level accuracy',
'town level accuracy', 'post code level accuracy',
'street level accuracy', 'intersection level accuracy',
'address level accuracy', 'premise level accuracy',
];
function geocode_result_handler(response) {
if (!response || response.Status.code != 200) {
alert('Geocoding failed. ' + response.Status.code);
} else {
var bounds = new GLatLngBounds(new GLatLng(
response.Placemark[0].ExtendedData.LatLonBox.south,
response.Placemark[0].ExtendedData.LatLonBox.west
), new GLatLng(
response.Placemark[0].ExtendedData.LatLonBox.north,
response.Placemark[0].ExtendedData.LatLonBox.east
));
map.setCenter(bounds.getCenter(),
map.getBoundsZoomLevel(bounds));
var latlng = new GLatLng(
response.Placemark[0].Point.coordinates[1],
response.Placemark[0].Point.coordinates[0]);
infoPanel.innerHTML += '<p>1st result is <em>' +
// No info about location type
response.Placemark[0].address +
'</em> of <em>' +
AccuracyDescription[response.Placemark[0].
AddressDetails.Accuracy] +
'</em> at <tt>' + latlng + '</tt></p>';
var marker_title = response.Placemark[0].address +
' at ' + latlng;
map.clearOverlays();
var marker = marker = new GMarker(
latlng,
{'title': marker_title}
);
map.addOverlay(marker);
}
}
function geocode_address() {
var address = document.getElementById('input-text').value;
infoPanel.innerHTML = '<p>Original address: ' + address + '</p>';
geocoder.getLocations(address, geocode_result_handler);
}
function initialize() {
map = new GMap2(document.getElementById('map'));
map.setCenter(new GLatLng(38, 15), 2);
map.setUIToDefault();
infoPanel = document.getElementById('info-panel');
}
var geocoder = new google.maps.Geocoder();
var infoPanel;
var map;
var marker;
function geocode_result_handler(result, status) {
if (status != google.maps.GeocoderStatus.OK) {
alert('Geocoding failed. ' + status);
} else {
map.fitBounds(result[0].geometry.viewport);
infoPanel.innerHTML += '<p>1st result for geocoding is <em>' +
result[0].geometry.location_type.toLowerCase() +
'</em> to <em>' +
result[0].formatted_address + '</em> of types <em>' +
result[0].types.join('</em>, <em>').replace(/_/, ' ') +
'</em> at <tt>' + result[0].geometry.location +
'</tt></p>';
var marker_title = result[0].formatted_address +
' at ' + latlng;
if (marker) {
marker.setPosition(result[0].geometry.location);
marker.setTitle(marker_title);
} else {
marker = new google.maps.Marker({
position: result[0].geometry.location,
title: marker_title,
map: map
});
}
}
}
function geocode_address() {
var address = document.getElementById('input-text').value;
infoPanel.innerHTML = '<p>Original address: ' + address + '</p>';
geocoder.geocode({'address': address}, geocode_result_handler);
}
function initialize() {
map = new google.maps.Map(document.getElementById('map'), {
center: new google.maps.LatLng(38, 15),
zoom: 2,
mapTypeId: google.maps.MapTypeId.HYBRID
});
infoPanel = document.getElementById('info-panel');
}
निर्देश
Maps JavaScript API v3, निर्देशों का हिसाब लगाने के लिए, v2
की GDirections
क्लास को
DirectionsService
क्लास से बदल देता है.
वर्शन 3 में route()
वाला तरीका, v2 एपीआई के load()
और loadFromWaypoints()
, दोनों तरीकों को बदल देता है. इस तरीके में, इनपुट की शर्तों के साथ एक DirectionsRequest
ऑब्जेक्ट लिटरल
होता है. साथ ही, रिस्पॉन्स मिलने पर एक कॉलबैक तरीका काम करता है. इस ऑब्जेक्ट लिटरल में विकल्प दिए जा सकते हैं,
जो v2 में GDirectionsOptions
ऑब्जेक्ट लिटरल की तरह होते हैं.
Maps JavaScript API v3 में, निर्देश के लिए अनुरोध सबमिट करने के टास्क को रेंडरिंग अनुरोधों के टास्क से अलग कर दिया गया है. इसे अब DirectionsRenderer
क्लास के साथ मैनेज किया जाता है. आपके पास किसी
DirectionsRenderer
ऑब्जेक्ट को किसी भी मैप या
DirectionsResult
ऑब्जेक्ट से जोड़ने के लिए, उसके setMap()
और
setDirections()
तरीकों का इस्तेमाल करने का विकल्प है. रेंडरर एक
MVCObject
है, इसलिए यह अपनी प्रॉपर्टी में होने वाले किसी भी बदलाव का पता लगा लेगा और
उससे जुड़े निर्देश बदलने पर मैप को अपडेट कर देगा.
इस कोड में बताया गया है कि किसी पते से पैदल चलने के रास्तों का इस्तेमाल करके, किसी खास जगह तक पैदल जाने की जानकारी का अनुरोध कैसे किया जाए. ध्यान दें कि सिर्फ़
वर्शन 3, डबलिन के चिड़ियाघर में पैदल चलने के रास्ते में, पैदल जाने की जानकारी दे सकता है.
var map;
var directions;
var directionsPanel;
function initialize() {
var origin = new google.maps.LatLng(53.348172, -6.297285);
var destination = new google.maps.LatLng(53.355502, -6.30557);
directionsPanel = document.getElementById("route");
map = new GMap2(document.getElementById('map'));
map.setCenter(origin, 10);
map.setUIToDefault();
directions = new GDirections(map, directionsPanel);
directions.loadFromWaypoints(
[origin, destination], {
travelMode: 'G_TRAVEL_MODE_WALKING',
});
}
var map;
var directionsRenderer;
var directionsService = new google.maps.DirectionsService();
function initialize() {
var origin = new google.maps.LatLng(53.348172, -6.297285);
var destination = new google.maps.LatLng(53.355502, -6.30557);
directionsRenderer = new google.maps.DirectionsRenderer();
map = new google.maps.Map(
document.getElementById('map'), {
center: origin,
zoom: 10,
mapTypeId: google.maps.MapTypeId.ROADMAP
});
directionsRenderer.setPanel(document.getElementById("route"));
directionsRenderer.setMap(map);
directionsService.route({
origin: origin,
destination: destination,
travelMode: google.maps.DirectionsTravelMode.WALKING
}, function(result, status) {
if (status == google.maps.DirectionsStatus.OK) {
directionsRenderer.setDirections(result);
}
});
}
स्ट्रीट व्यू
Google Street View अपने कवरेज एरिया में तय की गई जगहों से इंटरैक्टिव, 360° व्यू उपलब्ध कराता है. v3 API, मूल रूप से ब्राउज़र में Street View के साथ काम करता है. वहीं, v2 में Street View की तस्वीरें दिखाने के लिए Flash® प्लगिन की ज़रूरत होती है.
Street View की इमेज, v3 में
StreetViewPanorama
ऑब्जेक्ट या v2 में
GStreetviewPanorama
ऑब्जेक्ट का इस्तेमाल करके काम करती हैं. इन क्लास के इंटरफ़ेस अलग-अलग हैं, लेकिन इनकी भूमिका एक जैसी होती है: div
कंटेनर को Street View की तस्वीरों से कनेक्ट करना और आपको Street View पैनोरामा की जगह और POV बताने की सुविधा देना.
function initialize() {
var fenwayPark = new GLatLng(42.345573, -71.098326);
panoramaOptions = {
latlng: fenwayPark,
pov: {
heading: 35,
pitch: 5,
zoom: 1
}
};
var panorama = new GStreetviewPanorama(
document.getElementById('pano'),
panoramaOptions);
GEvent.addListener(myPano, "error", handleNoFlash);
}
function handleNoFlash(errorCode) {
if (errorCode == FLASH_UNAVAILABLE) {
alert('Error: Your browser does not support Flash');
return;
}
}
function initialize() {
var fenway = new google.maps.LatLng(42.345573, -71.098326);
var panoramaOptions = {
position: fenway,
pov: {
heading: 35,
pitch: 5,
zoom: 1
}
};
var panorama = new google.maps.StreetViewPanorama(
document.getElementById('pano'),
panoramaOptions);
}
v3 में मौजूद StreetViewService
ऑब्जेक्ट या v2 में मौजूद ऐसे ही GStreetviewClient
ऑब्जेक्ट से, Street View के डेटा को सीधे तौर पर ऐक्सेस किया जा सकता है. दोनों ही Street View के डेटा को वापस पाने या उसकी उपलब्धता देखने के लिए मिलते-जुलते इंटरफ़ेस उपलब्ध कराते हैं. साथ ही, इनसे जगह या पैनोरामा आईडी के हिसाब से खोजने की सुविधा भी मिलती है.
वर्शन 3 में, Street View की सुविधा डिफ़ॉल्ट रूप से चालू रहती है. मैप में
Street View पेगमैन कंट्रोल दिखेगा और एपीआई, Street View पैनोरामा दिखाने के लिए मैप के डीवी का फिर से इस्तेमाल करेगा. नीचे दिया गया कोड बताता है कि कैसे Street View पैनोरामा को अलग-अलग डीव में बांटकर,
v2 के व्यवहार को एम्युलेट किया जा सकता है.
var marker;
var panoClient = new GStreetviewClient();
function initialize() {
if (GBrowserIsCompatible()) {
var myPano = new GStreetviewPanorama(
document.getElementById('pano'));
GEvent.addListener(myPano, 'error', handleNoFlash);
var map = new GMap2(document.getElementById('map'));
map.setCenter(new GLatLng(42.345573, -71.098326), 16);
map.setUIToDefault();
GEvent.addListener(map, 'click', function(overlay, latlng) {
if (marker) {
marker.setLatLng(latlng);
} else {
marker = new GMarker(latlng);
map.addOverlay(marker);
}
var nearestPano = panoClient.getNearestPanorama(
latlng, processSVData);
});
function processSVData(panoData) {
if (panoData.code != 200) {
alert("Panorama data not found for this location.");
}
var latlng = marker.getLatLng();
var dLat = latlng.latRadians()
- panoData.location.latlng.latRadians();
var dLon = latlng.lngRadians()
- panoData.location.latlng.lngRadians();
var y = Math.sin(dLon) * Math.cos(latlng.latRadians());
var x = Math.cos(panoData.location.latlng.latRadians()) *
Math.sin(latlng.latRadians()) -
Math.sin(panoData.location.latlng.latRadians()) *
Math.cos(latlng.latRadians()) * Math.cos(dLon);
var bearing = Math.atan2(y, x) * 180 / Math.PI;
myPano.setLocationAndPOV(panoData.location.latlng, {
yaw: bearing
});
}
function handleNoFlash(errorCode) {
if (errorCode == FLASH_UNAVAILABLE) {
alert('Error: Your browser does not support Flash');
return;
}
}
}
}
// Load the API with libraries=geometry
var map;
var marker;
var panorama;
var sv = new google.maps.StreetViewService();
function radians(degrees) { return Math.PI * degrees / 180.0 };
function initialize() {
panorama = new google.maps.StreetViewPanorama(
document.getElementById("pano"));
map = new google.maps.Map(
document.getElementById('map'), {
center: new google.maps.LatLng(42.345573, -71.098326),
mapTypeId: google.maps.MapTypeId.ROADMAP,
zoom: 16
});
google.maps.event.addListener(map, 'click', function(event) {
if (!marker) {
marker = new google.maps.Marker({
position: event.latLng,
map: map
});
} else {
marker.setPosition(event.latLng);
}
sv.getPanoramaByLocation(event.latLng, 50, processSVData);
});
}
function processSVData(panoData, status) {
if (status == google.maps.StreetViewStatus.OK) {
alert("Panorama data not found for this location.");
}
var bearing = google.maps.geometry.spherical.computeHeading(
panoData.location.latLng, marker.getPosition());
panorama.setPano(panoData.location.pano);
panorama.setPov({
heading: bearing,
pitch: 0,
zoom: 1
});
panorama.setVisible(true);
marker.setMap(panorama);
}