How is small integer overflow avoided in Javascript

Suppose you had an 8 bit unsigned number.

Here are a selection of digital and binary representations:

1: 00000001

2: 00000010

15: 00001111

255: 11111111

If you have 255 and add 1, what happens? There's no more bits, so it wraps around to

0: 00000000

Here's a demonstration in C# using uint (an unsigned 32-bit integer)

using System;

public class Program
{
    public static void Main()
    {
        uint n = 4294967294;
        for(int i = 0; i < 4; ++i)
        {
            n = n + 1;
            Console.WriteLine("n = {0}", n); 
        }

    }
}

This will output:

n = 4294967294
n = 4294967295
n = 0
n = 1

This is the problem you don't get in javascript.

For example:

var n = 9007199254740991;
var m = n + 1;
var p = m + 1;
alert('n = ' + n + ' and m = ' + m + ' and p = ' + p);

You will see:

n = 9007199254740991 and m = 9007199254740992 and p = 9007199254740992

Rather than wrapping around, your number representations will shed accuracy.

Note that this 'shedding accuracy' behavior is not unique to javascript, it's what you expect from floating-point data types. Another .NET example:

using System;

public class Program
{
    public static void Main()
    {
        float n = 16777214; // 2^24 - 2
        for(int i = 0; i < 4; ++i) 
        {
            Console.WriteLine(string.Format("n = {0}", n.ToString("0")));
            Console.WriteLine("(n+1) - n = {0}", (n+1)-n);
            n = n + 1;                
        }
    }
}

This will output:

n = 16777210
(n+1) - n = 1
n = 16777220
(n+1) - n = 1
n = 16777220
(n+1) - n = 0
n = 16777220
(n+1) - n = 0