Skip to content Skip to footer

Snagging the Cursor: Tracking Mouse Position with JavaScript

Ever found yourself itching to know where your user’s cursor is waltzing around on your digital canvas? Whether it’s for a slick custom tooltip, a game, or some interactive data visualization, getting the cursor position in JavaScript is a fundamental trick in a developer’s bag. Let’s dive in and explore how to track down that elusive cursor across different JavaScript environments.

Pure JavaScript: The Vanilla Approach

In the good ol’ days, we’d attach an event listener to the mousemove event and snag the clientX and clientY properties from the event object. This approach is still rock-solid. Check it out:

document.addEventListener('mousemove', event => {
  console.log(`Mouse X: ${event.clientX}, Mouse Y: ${event.clientY}`);

This snippet will log the cursor’s X and Y coordinates relative to the viewport. It’s quick, it’s easy, and it’s supported everywhere. But what if you want the position relative to the entire page, including the part that’s scrolled out of view? No sweat, just swap clientX and clientY with pageX and pageY.

document.addEventListener('mousemove', event => {
  console.log(`Mouse X: ${event.pageX}, Mouse Y: ${event.pageY}`);

jQuery: The Comfortable Old Sweater

Ah, jQuery – it’s like running into an old friend. If you’re working in a codebase that still cherishes jQuery’s concise syntax, you can get the cursor position like so:

$(document).on('mousemove', function(event) {
  console.log(`Mouse X: ${event.pageX}, Mouse Y: ${event.pageY}`);

jQuery normalizes the event object, so you get pageX and pageY for free, even in browsers that don’t support them natively. Neat, huh?

React: The Modern Flair

React has its own way of handling events, but fear not, it’s just as straightforward. In React, you’d set up a mouse move event listener, typically in the useEffect hook to ensure it’s registered after the component mounts.

import React, { useEffect } from 'react';

const CursorTracker = () => {
  useEffect(() => {
    const handleMouseMove = event => {
      console.log(`Mouse X: ${event.clientX}, Mouse Y: ${event.clientY}`);

    document.addEventListener('mousemove', handleMouseMove);

    // Don't forget to clean up
    return () => document.removeEventListener('mousemove', handleMouseMove);
  }, []);

  return <div>Move your mouse around!</div>;

export default CursorTracker;

This component will log the cursor position whenever it moves across the screen. Remember to clean up the event listener when the component unmounts to prevent memory leaks.

Vue.js: The Progressive Touch

Vue.js, with its reactive data system, makes tracking the cursor position almost magical. Here’s how you’d do it in a Vue component:

  <div @mousemove="updateCursorPosition">
    Move your mouse here!

export default {
  data() {
    return {
      cursorX: 0,
      cursorY: 0,
  methods: {
    updateCursorPosition(event) {
      this.cursorX = event.clientX;
      this.cursorY = event.clientY;

By binding an event listener directly in the template, Vue keeps your code declarative and clean. The updateCursorPosition method updates the component’s data properties, which you can then use anywhere in your template.

Angular: The Full-Fledged Framework

Angular brings type safety and structure to the table. To track the cursor position, you’d bind an event listener in your component’s template and update the properties in the corresponding TypeScript class.

import { Component, HostListener } from '@angular/core';

  selector: 'app-cursor-tracker',
  template: '<div>Move your cursor in this area</div>',
export class CursorTrackerComponent {
  cursorX: number;
  cursorY: number;

  @HostListener('document:mousemove', ['$event'])
  onMouseMove(event: MouseEvent) {
    this.cursorX = event.clientX;
    this.cursorY = event.clientY;

The @HostListener decorator is Angular’s way of listening to events. Here, we’re listening for mousemove events on the document, and we update the class properties accordingly.

Svelte: The Compiler Approach

Svelte takes a different approach by moving much of the work to compile time. Here’s how you’d track the cursor position in a Svelte component:

  let cursorX;
  let cursorY;

  function handleMouseMove(event) {
    cursorX = event.clientX;
    cursorY = event.clientY;

<div on:mousemove={handleMouseMove}>
  The cursor is at X: {cursorX}, Y: {cursorY}

With Svelte, you get reactivity out of the box. Just update the variables inside the event handler, and the template will reactively display the new coordinates.

And that’s the first half of our cursor-chasing adventure! We’ve covered how to track the cursor position in pure JavaScript and across several popular frameworks. Whether you’re a fan of the old-school or riding the wave of modern JavaScript, there’s a way for you to get those coordinates.

Stay tuned for the second half where we’ll delve into more advanced scenarios, like dealing with canvas elements and managing performance. Until then, happy coding!

Advanced Cursor Tracking: Canvas, Performance, and Beyond

In the first act of our cursor tracking saga, we covered the basics across different frameworks. Now, let’s up the ante and explore some more advanced techniques, especially when dealing with the HTML <canvas> element and ensuring our applications stay snappy.

Canvas Capers: Tracking Inside the Artisan’s Element

When you’re working with <canvas>, things get a bit more artsy. The cursor’s position needs to be relative to the canvas itself, not just the page or the viewport. Here’s how to calculate that with vanilla JavaScript:

const canvas = document.getElementById('myCanvas');
canvas.addEventListener('mousemove', event => {
  const rect = canvas.getBoundingClientRect();
  const scaleX = canvas.width / rect.width;    // relationship bitmap vs. element for X
  const scaleY = canvas.height / rect.height;  // relationship bitmap vs. element for Y

  const canvasX = (event.clientX - rect.left) * scaleX;
  const canvasY = (event.clientY - * scaleY;

  console.log(`Canvas X: ${canvasX}, Canvas Y: ${canvasY}`);

This snippet takes into account the scaling of the canvas, which can be different if you’ve styled it with CSS. By getting the bounding rectangle of the canvas and its scaling factors, we can accurately pinpoint the cursor.

Performance Pitfalls: Debouncing and Throttling

Mousemove events can fire off faster than a caffeinated squirrel, which can lead to performance issues if your event handler does heavy lifting. To prevent jank, you can debounce or throttle the event handler.

Debouncing ensures that your function only triggers after a certain amount of time has passed without any further trigger, while throttling limits the function to only execute once every specified number of milliseconds.

Here’s a debounced approach using Lodash’s debounce function:

import debounce from 'lodash.debounce';

const handler = debounce(event => {
  console.log(`Mouse X: ${event.clientX}, Mouse Y: ${event.clientY}`);
}, 100);

document.addEventListener('mousemove', handler);

And here’s how you’d throttle using Lodash’s throttle function:

import throttle from 'lodash.throttle';

const handler = throttle(event => {
  console.log(`Mouse X: ${event.clientX}, Mouse Y: ${event.clientY}`);
}, 100);

document.addEventListener('mousemove', handler);

Both methods ensure that your event handler doesn’t run amok and turn your user’s experience into a slideshow.

The Edge Cases: Cross-Browser Quirks and Mobile Devices

Cross-browser compatibility is the bane of many a developer’s existence. While modern browsers have largely standardized the way mouse events work, it’s always good to test your cursor tracking across all the browsers your app supports.

On mobile devices, mousemove events are a different beast, or rather, they’re non-existent. You’ll need to listen for touch events (touchstart, touchmove, touchend) and extract the touch points from the TouchEvent‘s touches or changedTouches lists.

Here’s a quick example:

document.addEventListener('touchmove', event => {
  const touch = event.touches[0];
  console.log(`Touch X: ${touch.clientX}, Touch Y: ${touch.clientY}`);

Remember, touch events can track multiple fingers, so you’ll need to decide how you want to handle multi-touch scenarios.

Wrapping Up: Cursor Tracking for the Future

We’ve now covered a broad spectrum of cursor tracking techniques, from the simple to the complex, and across multiple environments and use cases. Whether you’re building a simple interactive feature or a full-blown game, these tools will help you keep an eye on your user’s cursor with precision and efficiency.

As web technologies continue to evolve, so too will the methods for cursor tracking. Keep an eye on emerging specs and APIs, such as the Pointer Events API, which aims to unify mouse, touch, and pen events into a single model.

Until then, with the knowledge you’ve gained today, you’re well-equipped to add some cursor tracking magic to your applications. So go forth, and may your cursor coordinates always be accurate and your user interactions smooth as silk!