easter_date() in JavaScript

Here's an alternative method based on an algorithm that R. Sivaraman adapted for the Gregorian Calendar from an algorithm originally developed by J. Meeus for the Julian calendar (cf. https://en.wikipedia.org/wiki/Computus).

It seems like a more elegant and intuitive solution than the Gauss algorithm which has already been mentioned. At least it shaves off a few steps (only 5 total plus the JS date methods) and uses fewer variables (only 4 total plus the month, date, and year).

function computus( y ) {

        var date, a, b, c, m, d;

        // Instantiate the date object.
        date = new Date;

        // Set the timestamp to midnight.
        date.setHours( 0, 0, 0, 0 );

        // Set the year.
        date.setFullYear( y );

        // Find the golden number.
        a = y % 19;

        // Choose which version of the algorithm to use based on the given year.
        b = ( 2200 <= y && y <= 2299 ) ?
            ( ( 11 * a ) + 4 ) % 30 :
            ( ( 11 * a ) + 5 ) % 30;

        // Determine whether or not to compensate for the previous step.
        c = ( ( b === 0 ) || ( b === 1 && a > 10 ) ) ?
            ( b + 1 ) :
            b;

        // Use c first to find the month: April or March.
        m = ( 1 <= c && c <= 19 ) ? 3 : 2;

        // Then use c to find the full moon after the northward equinox.
        d = ( 50 - c ) % 31;

        // Mark the date of that full moon—the "Paschal" full moon.
        date.setMonth( m, d );

        // Count forward the number of days until the following Sunday (Easter).
        date.setMonth( m, d + ( 7 - date.getDay() ) );

        // Gregorian Western Easter Sunday
        return date;

    }

For example:

console.log( computus( 2016 ) ); // Date 2016-03-27T05:00:00.000Z

According to this:-

function Easter(Y) {
    var C = Math.floor(Y/100);
    var N = Y - 19*Math.floor(Y/19);
    var K = Math.floor((C - 17)/25);
    var I = C - Math.floor(C/4) - Math.floor((C - K)/3) + 19*N + 15;
    I = I - 30*Math.floor((I/30));
    I = I - Math.floor(I/28)*(1 - Math.floor(I/28)*Math.floor(29/(I + 1))*Math.floor((21 - N)/11));
    var J = Y + Math.floor(Y/4) + I + 2 - C + Math.floor(C/4);
    J = J - 7*Math.floor(J/7);
    var L = I - J;
    var M = 3 + Math.floor((L + 40)/44);
    var D = L + 28 - 31*Math.floor(M/4);

    return padout(M) + '.' + padout(D);
}

function padout(number) { return (number < 10) ? '0' + number : number; }

Example usage:-

document.write(Easter(1997));

In case you need to know if its easter(sunday) right now, you can use this function. (This was what I searched for):

    function isEasterSunday() {
      var curdate = new Date();
      var year = curdate.getFullYear();
      var a = year % 19;
      var b = Math.floor(year / 100);
      var c = year % 100;
      var d = Math.floor(b / 4); 
      var e = b % 4;
      var f = Math.floor((b + 8) / 25);
      var g = Math.floor((b - f + 1) / 3); 
      var h = (19 * a + b - d - g + 15) % 30;
      var i = Math.floor(c / 4);
      var k = c % 4;
      var l = (32 + 2 * e + 2 * i - h - k) % 7;
      var m = Math.floor((a + 11 * h + 22 * l) / 451);
      var n0 = (h + l + 7 * m + 114)
      var n = Math.floor(n0 / 31) - 1;
      var p = n0 % 31 + 1;
      var date = new Date(year,n,p);
      return ((curdate.getMonth() == date.getMonth())&&(curdate.getDate() == date.getDate()));
    }

Using the 'Laurent Longre' Algorithm

The following is based on the Laurent Longre algorithm.

It works starting from the year 1583 (the start of the Gregorian calendar) onwards.

The output is an array in the form of [year, month, day].

//===========================================================
function easterDateLLongre(Y) {
  let M=3, G= Y % 19+1, C= ~~(Y/100)+1, L=~~((3*C)/4)-12,
      E=(11*G+20+ ~~((8*C+5)/25)-5-L)%30, D;
  E<0 && (E+=30);
  (E==25 && G>11 || E==24) && E++;
  (D=44-E)<21 && (D+=30);
  (D+=7-(~~((5*Y)/4)-L-10+D)%7)>31 && (D-=31,M=4);
  return [Y, M, D];
  }
//===========================================================


//======================= Tests =====================
console.log(easterDateLLongre(1583)); // [1583, 4, 10]
console.log(easterDateLLongre(1853)); // [1853, 3, 27]
console.log(easterDateLLongre(2021)); // [2021, 4, 4]
console.log(easterDateLLongre(2700)); // [2700, 4, 1]