Определение геолокации в JavaScript: методы и готовые решения

if ("geolocation" in navigator) {
// Геолокация доступна
} else {
// Браузер не поддерживает геолокацию
}

navigator.geolocation.getCurrentPosition(
function(position) {
const latitude = position.coords.latitude;
const longitude = position.coords.longitude;
console.log(`Широта: ${latitude}, Долгота: ${longitude}`);
},
function(error) {
console.error("Ошибка получения местоположения:", error.message);
},
{
enableHighAccuracy: true, // Запросить высокую точность
timeout: 5000, // Тайм-аут в миллисекундах
maximumAge: 0 // Не использовать кэшированные данные
}
);

function trackUserLocation(onUpdate, onError) {
if (!("geolocation" in navigator)) {
onError && onError(new Error("Геолокация не поддерживается браузером"));
return null;
}

const watchId = navigator.geolocation.watchPosition(
position => {
const { latitude, longitude, accuracy } = position.coords;
onUpdate({ latitude, longitude, accuracy });
},
error => {
onError && onError(error);
},
{
enableHighAccuracy: true,
timeout: 10000,
maximumAge: 60000 // Используем кэшированные данные не старше минуты
}
);

return watchId; // Возвращаем ID для возможности остановки отслеживания
}

// Пример использования:
const watchId = trackUserLocation(
location => {
console.log(`Местоположение обновлено: ${location.latitude}, ${location.longitude}`);
},
error => {
console.error(`Ошибка геолокации: ${error.message}`);
}
);

// Для остановки отслеживания:
// navigator.geolocation.clearWatch(watchId);

function calculateDistance(lat1, lon1, lat2, lon2) {
const R = 6371; // Радиус Земли в километрах
const dLat = (lat2 – lat1) * Math.PI / 180;
const dLon = (lon2 – lon1) * Math.PI / 180;

const a = 
Math.sin(dLat / 2) * Math.sin(dLat / 2) +
Math.cos(lat1 * Math.PI / 180) * Math.cos(lat2 * Math.PI / 180) * 
Math.sin(dLon / 2) * Math.sin(dLon / 2);

const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 – a));
const distance = R * c; // Расстояние в километрах

return distance;
}

// Пример использования:
// const distance = calculateDistance(55.7558, 37.6173, 59.9343, 30.3351);
// console.log(`Расстояние между Москвой и Санкт-Петербургом: ${distance} км`);

function getLocationWithPrompt(message = "Разрешите доступ к геолокации для улучшения работы сервиса") {
return new Promise((resolve, reject) => {
// Показываем пользовательское сообщение перед запросом геолокации
if (confirm(message)) {
navigator.geolocation.getCurrentPosition(
position => resolve({
lat: position.coords.latitude,
lng: position.coords.longitude,
accuracy: position.coords.accuracy
}),
error => reject(error),
{ enableHighAccuracy: true, timeout: 10000 }
);
} else {
reject(new Error("Пользователь отказался предоставить геолокацию"));
}
});
}

// Использование с async/await:
// async function showNearbyPlaces() {
// try {
// const location = await getLocationWithPrompt();
// console.log(`Получены координаты: ${location.lat}, ${location.lng}`);
// // Здесь код для отображения мест поблизости
// } catch (error) {
// console.error("Не удалось получить местоположение:", error.message);
// }
// }

function isUserInZone(userLat, userLng, zoneLat, zoneLng, radiusKm) {
const distance = calculateDistance(userLat, userLng, zoneLat, zoneLng);
return distance <= radiusKm;
}

// Пример использования:
// navigator.geolocation.getCurrentPosition(position => {
// const inDeliveryZone = isUserInZone(
// position.coords.latitude,
// position.coords.longitude,
// 55.7558, // Центр зоны доставки (например, центр Москвы)
// 37.6173,
// 10 // Радиус зоны доставки в км
// );
//
// if (inDeliveryZone) {
// console.log("Вы находитесь в зоне доставки!");
// } else {
// console.log("К сожалению, вы находитесь вне зоны доставки");
// }
// });

function getLocation() {
return new Promise((resolve, reject) => {
if (!("geolocation" in navigator)) {
reject(new Error("Геолокация не поддерживается вашим браузером"));
return;
}

navigator.geolocation.getCurrentPosition(
resolve,
(error) => {
switch(error.code) {
case error.PERMISSION_DENIED:
reject(new Error("Вы отклонили запрос на геолокацию. Для использования этой функции разрешите доступ к местоположению в настройках браузера."));
break;

case error.POSITION_UNAVAILABLE:
reject(new Error("Информация о вашем местоположении недоступна. Проверьте подключение к интернету или GPS."));
break;

case error.TIMEOUT:
reject(new Error("Превышено время ожидания при получении местоположения. Попробуйте еще раз."));
break;

default:
reject(new Error(`Неизвестная ошибка: ${error.message}`));
}
},
{
enableHighAccuracy: true,
timeout: 15000,
maximumAge: 300000 // 5 минут
}
);
});
}

// Использование с фолбэком на IP-геолокацию
async function getUserLocationWithFallback() {
try {
const position = await getLocation();
return {
source: "browser_geolocation",
latitude: position.coords.latitude,
longitude: position.coords.longitude,
accuracy: position.coords.accuracy
};
} catch (geoError) {
console.warn("Не удалось получить геолокацию через браузер:", geoError.message);

// Фолбэк на IP-геолокацию
try {
const response = await fetch('https://ipapi.co/json/');
const ipData = await response.json();

return {
source: "ip_geolocation",
latitude: ipData.latitude,
longitude: ipData.longitude,
accuracy: 5000, // Примерная точность IP-геолокации в метрах
city: ipData.city,
country: ipData.country_name
};
} catch (ipError) {
throw new Error("Не удалось определить местоположение ни через браузер, ни через IP");
}
}
}

async function getLocationByIP() {
try {
const response = await fetch('https://ipapi.co/json/');
if (!response.ok) {
throw new Error('Сервис IP-геолокации недоступен');
}

const data = await response.json();
return {
latitude: data.latitude,
longitude: data.longitude,
city: data.city,
region: data.region,
country: data.country_name,
accuracy: 'low', // IP-геолокация обычно имеет низкую точность
source: 'ip'
};
} catch (error) {
console.error('Ошибка IP-геолокации:', error);
return null;
}
}

function getLocationByWiFi() {
return new Promise((resolve, reject) => {
navigator.geolocation.getCurrentPosition(
position => resolve({
latitude: position.coords.latitude,
longitude: position.coords.longitude,
accuracy: position.coords.accuracy,
source: 'wifi'
}),
error => reject(error),
{
enableHighAccuracy: false, // Отключаем высокую точность для использования Wi-Fi вместо GPS
timeout: 10000,
maximumAge: 600000 // 10 минут
}
);
});
}

// Пример с Yandex Maps API
function getLocationByYandexMaps() {
return new Promise((resolve, reject) => {
// Предполагается, что API Яндекс.Карт уже загружен
if (typeof ymaps === 'undefined') {
reject(new Error('Yandex Maps API не загружен'));
return;
}

ymaps.ready(() => {
ymaps.geolocation.get({
provider: 'yandex',
mapStateAutoApply: true
}).then(result => {
const position = result.geoObjects.position;
resolve({
latitude: position[0],
longitude: position[1],
city: result.geoObjects.get(0).properties.get('description'),
country: result.geoObjects.get(0).properties.get('metaDataProperty.GeocoderMetaData.AddressDetails.Country.CountryName'),
source: 'yandex_maps'
});
}).catch(error => {
reject(error);
});
});
});
}

// Этот метод обычно обрабатывается самим Geolocation API,
// но можно настроить специальные параметры для приоритизации сотовых сетей
function getLocationByCellTowers() {
return new Promise((resolve, reject) => {
navigator.geolocation.getCurrentPosition(
position => resolve({
latitude: position.coords.latitude,
longitude: position.coords.longitude,
accuracy: position.coords.accuracy,
source: 'cell_network'
}),
reject,
{
enableHighAccuracy: false,
timeout: 5000,
maximumAge: 0,
// На некоторых устройствах этот параметр может влиять на выбор источника геолокации
// (неофициальный параметр, работает не во всех браузерах)
preferCellNetwork: true
}
);
});
}

function saveLocationToStorage(location) {
const locationData = {
latitude: location.latitude,
longitude: location.longitude,
timestamp: Date.now()
};
localStorage.setItem('userLocation', JSON.stringify(locationData));
}

function getLocationFromStorage() {
const storedLocation = localStorage.getItem('userLocation');
if (!storedLocation) return null;

const locationData = JSON.parse(storedLocation);
const ageInHours = (Date.now() – locationData.timestamp) / (1000 * 60 * 60);

// Если данные старше 24 часов, считаем их устаревшими
if (ageInHours > 24) return null;

return {
latitude: locationData.latitude,
longitude: locationData.longitude,
timestamp: locationData.timestamp,
accuracy: 'unknown', // Точность неизвестна для сохраненных данных
source: 'local_storage'
};
}

async function getLocationCascade() {
try {
// 1. Сначала пробуем Geolocation API
const browserGeo = await new Promise((resolve, reject) => {
navigator.geolocation.getCurrentPosition(
pos => resolve({ 
latitude: pos.coords.latitude, 
longitude: pos.coords.longitude,
accuracy: pos.coords.accuracy,
source: 'browser_gps'
}),
error => reject(error),
{ enableHighAccuracy: true, timeout: 10000 }
);
});

saveLocationToStorage(browserGeo); // Сохраняем для будущего использования
return browserGeo;

} catch (error) {
console.warn("Не удалось получить геолокацию через браузер:", error.message);

try {
// 2. Пробуем IP-геолокацию
const ipGeo = await getLocationByIP();
if (ipGeo) {
saveLocationToStorage(ipGeo);
return ipGeo;
}

throw new Error("IP-геолокация не удалась");
} catch (ipError) {
console.warn("IP-геолокация не удалась:", ipError.message);

// 3. Пробуем получить локальное сохраненное местоположение
const storedGeo = getLocationFromStorage();
if (storedGeo) {
return storedGeo;
}

// 4. Если все не удалось, возвращаем null или дефолтное местоположение
return {
latitude: 55.7558, // Например, центр Москвы как дефолтное местоположение
longitude: 37.6173,
accuracy: 'unknown',
source: 'default'
};
}
}
}

// Функция для поиска ближайших мест из массива доступных локаций
function findNearbyPlaces(userLat, userLng, places, maxDistance = 10) {
return places.filter(place => {
const distance = calculateDistance(
userLat, userLng, 
place.latitude, place.longitude
);
place.distance = distance; // Добавляем расстояние к объекту
return distance <= maxDistance;
}).sort((a, b) => a.distance – b.distance); // Сортируем по возрастанию расстояния
}

// Пример использования:
navigator.geolocation.getCurrentPosition(position => {
const nearbyPlaces = findNearbyPlaces(
position.coords.latitude,
position.coords.longitude,
[
{ name: "Кафе Утро", latitude: 55.7539, longitude: 37.6208 },
{ name: "Ресторан Вечер", latitude: 55.7527, longitude: 37.6179 },
{ name: "Бар Ночь", latitude: 55.7511, longitude: 37.6197 }
]
);

console.log("Ближайшие места:", nearbyPlaces);
// Вывод на страницу, например:
// nearbyPlaces.forEach(place => {
// document.getElementById('places-list').innerHTML += 
// `<li>${place.name} – ${place.distance.toFixed(2)} км</li>`;
// });
});

async function personalizeContentByLocation() {
try {
const location = await getLocationCascade(); // Функция из предыдущего раздела

// Определение страны/региона для персонализации
const response = await fetch(`https://nominatim.openstreetmap.org/reverse?format=json&lat=${location.latitude}&lon=${location.longitude}&zoom=10`);
const data = await response.json();

const country = data.address.country;
const city = data.address.city || data.address.town;

// Примеры персонализации
if (country === "Россия") {
document.getElementById('currency').textContent = "₽";
document.querySelector('.greeting').textContent = `Добрый день, ${city || 'путешественник'}!`;

// Загрузка локальных новостей или предложений
fetchLocalNews(city);
} else if (country === "США") {
document.getElementById('currency').textContent = "$";
document.querySelector('.greeting').textContent = `Welcome, visitor from ${city || 'abroad'}!`;
}

// Персонализация по часовому поясу
const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
adjustContentForTimezone(timezone);

} catch (error) {
console.error("Не удалось персонализировать контент:", error);
// Показываем дефолтную версию страницы
}
}

function adjustContentForTimezone(timezone) {
const now = new Date();
const hours = now.getHours();

// Подстройка контента в зависимости от времени суток
if (hours >= 5 && hours < 12) {
document.body.classList.add('morning-theme');
document.getElementById('time-greeting').textContent = "Доброе утро!";
} else if (hours >= 12 && hours < 18) {
document.body.classList.add('day-theme');
document.getElementById('time-greeting').textContent = "Добрый день!";
} else {
document.body.classList.add('evening-theme');
document.getElementById('time-greeting').textContent = "Добрый вечер!";
}
}

function calculateDeliveryCost(userLat, userLng, storeLat, storeLng) {
const distanceKm = calculateDistance(userLat, userLng, storeLat, storeLng);

// Базовая стоимость доставки
let cost = 150; // рублей

// Дополнительная стоимость за каждый километр свыше 5 км
if (distanceKm > 5) {
cost += (distanceKm – 5) * 30;
}

// Ограничение максимальной стоимости
return Math.min(cost, 500);
}

// Использование при оформлении заказа
document.getElementById('calculate-delivery').addEventListener('click', () => {
navigator.geolocation.getCurrentPosition(
position => {
const cost = calculateDeliveryCost(
position.coords.latitude, 
position.coords.longitude,
55.7539, // координаты магазина/ресторана
37.6208
);

document.getElementById('delivery-cost').textContent = `${cost} ₽`;
},
error => {
console.error("Ошибка при определении местоположения:", error);
document.getElementById('delivery-cost').textContent = "Не удалось рассчитать стоимость";
}
);
});

class RouteTracker {
constructor() {
this.positions = [];
this.distance = 0;
this.watchId = null;
this.isTracking = false;
}

startTracking() {
if (this.isTracking) return;

this.isTracking = true;
this.positions = [];
this.distance = 0;

this.watchId = navigator.geolocation.watchPosition(
position => this.handlePosition(position),
error => console.error("Ошибка отслеживания:", error),
{
enableHighAccuracy: true,
timeout: 10000,
maximumAge: 0
}
);

return this.watchId;
}

stopTracking() {
if (!this.isTracking) return;

navigator.geolocation.clearWatch(this.watchId);
this.isTracking = false;
this.watchId = null;

return {
distance: this.distance,
positions: this.positions,
startTime: this.positions[0]?.timestamp,
endTime: this.positions[this.positions.length – 1]?.timestamp
};
}

handlePosition(position) {
const newPosition = {
latitude: position.coords.latitude,
longitude: position.coords.longitude,
accuracy: position.coords.accuracy,
timestamp: position.timestamp
};

// Если это не первая позиция, рассчитываем расстояние
if (this.positions.length > 0) {
const prevPosition = this.positions[this.positions.length – 1];
const segmentDistance = calculateDistance(
prevPosition.latitude, prevPosition.longitude,
newPosition.latitude, newPosition.longitude
);

// Игнорируем слишком маленькие перемещения (могут быть погрешностью)
if (segmentDistance > 0.005) { // > 5 метров
this.distance += segmentDistance;
this.positions.push(newPosition);

// Вызываем коллбэк для обновления UI
if (this.onPositionUpdate) {
this.onPositionUpdate({
currentPosition: newPosition,
totalDistance: this.distance,
positions: this.positions
});
}
}
} else {
// Первая позиция
this.positions.push(newPosition);
if (this.onPositionUpdate) {
this.onPositionUpdate({
currentPosition: newPosition,
totalDistance: 0,
positions: this.positions
});
}
}
}

// Метод для отрисовки маршрута на карте (пример для Leaflet.js)
drawRouteOnMap(mapId) {
if (!this.positions.length) return;

// Предполагается, что у вас уже инициализирована карта
const map = L.map(mapId).setView(
[this.positions[0].latitude, this.positions[0].longitude], 
15
);

L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png').addTo(map);

// Создаем линию маршрута
const routePoints = this.positions.map(pos => [pos.latitude, pos.longitude]);
L.polyline(routePoints, { color: 'blue', weight: 5 }).addTo(map);

// Маркеры начала и конца маршрута
L.marker([this.positions[0].latitude, this.positions[0].longitude])
.bindPopup('Начало маршрута')
.addTo(map);

const lastPos = this.positions[this.positions.length – 1];
L.marker([lastPos.latitude, lastPos.longitude])
.bindPopup('Конец маршрута')
.addTo(map);
}
}

// Пример использования:
const tracker = new RouteTracker();

// Обработчик обновления позиции
tracker.onPositionUpdate = data => {
document.getElementById('distance').textContent = 
`${data.totalDistance.toFixed(2)} км`;
};

// Кнопки управления
document.getElementById('start-tracking').addEventListener('click', () => {
tracker.startTracking();
});

document.getElementById('stop-tracking').addEventListener('click', () => {
const summary = tracker.stopTracking();

// Вывод итогов
const duration = (summary.endTime – summary.startTime) / 1000 / 60; // минуты
document.getElementById('summary').innerHTML = `
<p>Расстояние: ${summary.distance.toFixed(2)} км</p>
<p>Время: ${duration.toFixed(0)} мин</p>
<p>Средняя скорость: ${(summary.distance / (duration / 60)).toFixed(2)} км/ч</p>
`;

// Отрисовка маршрута
tracker.drawRouteOnMap('route-map');
});

class GeoFencing {
constructor() {
this.zones = [];
this.watchId = null;
this.isMonitoring = false;
}

addZone(id, name, lat, lng, radiusKm, actions) {
this.zones.push({
id,
name,
latitude: lat,
longitude: lng,
radius: radiusKm,
actions, // Функции, выполняемые при входе в зону
entered: false // Флаг, был ли пользователь в зоне
});
}

startMonitoring() {
if (this.isMonitoring) return;

this.isMonitoring = true;
this.watchId = navigator.geolocation.watchPosition(
position => this.checkZones(position),
error => console.error("Ошибка мониторинга геозон:", error),
{
enableHighAccuracy: true,
timeout: 10000,
maximumAge: 60000 // 1 минута
}
);
}

stopMonitoring() {
if (!this.isMonitoring) return;

navigator.geolocation.clearWatch(this.watchId);
this.isMonitoring = false;
this.watchId = null;

// Сбрасываем флаги входа в зоны
this.zones.forEach(zone => zone.entered = false);
}

checkZones(position) {
const userLat = position.coords.latitude;
const userLng = position.coords.longitude;

this.zones.forEach(zone => {
const isInZone = this.isPointInZone(
userLat, userLng, 
zone.latitude, zone.longitude, 
zone.radius
);

// Если вошел в зону и раньше не был в ней
if (isInZone && !zone.entered) {
zone.entered = true;
console.log(`Вход в зону: ${zone.name}`);

// Выполняем действия при входе в зону
if (typeof zone.actions.onEnter === 'function') {
zone.actions.onEnter(zone);
}
}
// Если вышел из зоны, в которой был
else if (!isInZone && zone.entered) {
zone.entered = false;
console.log(`Выход из зоны: ${zone.name}`);

// Выполняем действия при выходе из зоны
if (typeof zone.actions.onExit === 'function') {
zone.actions.onExit(zone);
}
}
});
}

isPointInZone(userLat, userLng, zoneLat, zoneLng, radiusKm) {
const distance = calculateDistance(userLat, userLng, zoneLat, zoneLng);
return distance <= radiusKm;
}
}

// Пример использования для маркетинговой кампании:
const geoFencing = new GeoFencing();

// Добавляем зоны интереса
geoFencing.addZone(
1, 
"Торговый центр", 
55.7539, 
37.6208, 
0.5, // 500 метров радиус
{
onEnter: zone => {
// Показываем уведомление
showNotification(`Специальное предложение в ${zone.name}!`, 
"Покажите это сообщение на кассе и получите скидку 10%");

// Открываем промо-страницу
// window.open('/promo/shopping-center');
},
onExit: zone => {
// Можем отслеживать выход из зоны для аналитики
sendAnalytics('zone_exit', { zoneId: zone.id, zoneName: zone.name });
}
}
);

// Добавляем еще зоны...

// Функция для показа уведомления
function showNotification(title, message) {
if ('Notification' in window && Notification.permission === 'granted') {
new Notification(title, { body: message });
} else if ('Notification' in window && Notification.permission !== 'denied') {
Notification.requestPermission().then(permission => {
if (permission === 'granted') {
new Notification(title, { body: message });
}
});
}
}

// Запускаем мониторинг при загрузке страницы
document.addEventListener('DOMContentLoaded', () => {
// Запрашиваем разрешение на уведомления
if ('Notification' in window) {
Notification.requestPermission();
}

// Начинаем мониторинг геозон
geoFencing.startMonitoring();
});