[Updated] How to Fix “JavaScript heap out of memory” Error

You may come across the ‘JavaScript heap out of memory’ error when running medium to large-scale JavaScript projects in your Node.js environment. The JavaScript V8 engine commonly throws this error, but you can resolve it swiftly with a few straightforward adjustments. In this article, we will explore the causes of the error and demonstrate how to fix it.

Developed by Google, the JavaScript V8 engine is a program that executes your JS code. It powers Chrome and also the Node.js runtime. The V8 engine comprises:

• Call stack — the place where your code actually executes.
• Heap — an unstructured memory pool that stores all the objects your program/application needs while executing your code.
• Garbage collector — to collect and remove any objects that are not required or unused by your program for efficient memory management.

All three of them work together to execute your application code on the server.  

JavaScript uses the heap space for garbage collection to manage memory and smoothly run your application code. The heap memory is dynamically allocated by the V8 engine based on a certain memory limit.

When the default memory allocation for the heap space in JavaScript is not enough to run your application, your program crashes throwing the “FATAL ERROR: CALL_AND_RETRY_LAST Allocation failed - JavaScript heap out of memory” error.

This error may sometimes look different in your JS stacktrace, but they are largely caused by similar reasons. Here are some variations of the heap out of memory error in JavaScript:

• FATAL ERROR: Ineffective mark-compacts near heap limit Allocation failed - JavaScript heap out of memory
• FATAL ERROR: Reached heap limit Allocation failed - JavaScript heap out of memory
• FATAL ERROR: invalid table size Allocation failed - JavaScript heap out of memory

Insufficient memory space allocation can occur due to several reasons. Here are some notable ones:

Large Data Processing Tasks

Complex applications typically handle large data processing tasks, datasets, and data structures by running billions of calculations behind the scenes. This could quickly gobble default allocated memory for the program causing the error.

Infinite Loops and Inefficient Recursive Functions

If your program has any unknown infinite/non-terminating loops or contains inefficient or loosely written recursive functions, it triggers the heap out of memory error. Both these operations are memory guzzlers.

Inefficient Algorithms

Poorly written or inefficient algorithms can sometimes exceed the expected space complexity — that’s the amount of memory an algorithm needs relative to the size of its input. This can lead to memory allocation issues in your application, potentially causing an error if the program attempts to use more memory than is available in the heap.

Memory Leaks

Memory leaks in your JS application can cause erroneous code runs. Memory leaks happen when the V8 engine’s garbage collector cannot release allocated (that’s actually unused) memory for your app to use. In such cases, the JS heap runs out of memory — leading to the error.  

Here are some common scenarios where memory leaks happen in your JS application:

• Global Variables — Unwanted global variable references in your application code can clog up the allocated heap memory space causing memory leaks. It’s good to keep your global variables in check.
• Event Listeners  — Excessive event listeners attached to global objects can cause memory leaks, especially if they are not properly removed when no longer needed. It’s not just the number of event listeners that matters, but also ensuring they are detached when the associated elements are removed from the DOM.
• Circular References — Circular references in your code — where variables keep referencing each other —  prevent the garbage collector from releasing memory when required causing memory leaks. Avoid circular references in your code when not absolutely required.
• Closures — Closure is a feature in JavaScript when a function carries all the variables with references that were present in the scope where that function was created. These unintentionally captured variables can reference large objects. This directly affects garbage collection leading to memory leaks in your application. It’s a good practice to keep an eye on closures in your JS code.
• Uncleared Timer Functions — There are cases where you require repeated code or function execution by using timer functions in JavaScript: “setInterval()” and “setTimeout()”. It's important to clear out such timers using “clearInterval()” and “clearTimeout()” when your function has returned as intended. Failing to do so keeps consuming memory, hence, memory leaks.
• Improper Handling of the React useEffect() hook — During conditional rendering in React functions, even though you use an empty dependency array in your useEffect() function — to prevent re-renders — it’s important to get rid of functions that are no longer required (network requests, timers, subscriptions, async tasks, event listeners) when your components unmount. If left unchecked, it can cause memory leaks and could be very problematic in large React apps. It’s highly recommended to add clean-up functions to prevent such issues, especially when you perform conditional rendering with the useEffect() hook.

Also Read: How to Fix “Objects are not Valid as a React Child” Error

There are several methods and tools to identify memory-related errors in your JS code. You can use:

• Built-in DevTools for Chrome
• Node.js Tools and Techniques

Let’s briefly cover some top ways to identify the error with these two:

Built-in DevTools for Chrome

Chrome provides a host of tools to analyze and monitor memory-related issues. Here are some:  

• Memory — Under the Memory panel in your Chrome DevTools, you’ll find: Heap Snapshots, Allocation Timelines, and Allocation Sampling. They are used for memory profiling and to identify any memory issues. Heap Snapshots identify memory leaks through DOM analysis, Allocation Timelines track real-time memory allocation, and Allocation Sampling records allocations efficiently, all contributing to optimized JavaScript performance.
• Performance — The Performance panel in Chrome DevTools helps visualize memory trends to detect leaks and assess garbage collection impacts.

You can also use Chrome Task Manager (hit Shift + Esc to open) to monitor a page’s memory use in real time, aiding in the initial analysis of memory problems.

Also Read: How to Clear DNS Cache on Chrome [Updated] with Chrome://Net-Internals/#DNS

Node.js Tools and Techniques

There are a bunch of Node.js techniques that you can use to identify memory errors in your code.

• “process.memoryUsage()” Function — The “process.memoryUsage()” in Node.js provides key memory metrics: rss (total memory space occupied by the process), heapTotal, and heapUsed — to track and troubleshoot memory usage effectively.

Here’s what the code and output looks like:

You get the memory info in KBs by default. You can convert the values to MB for better readability like below:

• Third-Party Tools — You can also use NPM packages such as heapdump to identify memory-related issues in your Node.js apps.

Fixing the out of memory error is super simple. Here’s how:

Increase the Allocated Heap Memory Limit

Increasing the allocated heap memory for the Node.js V8 engine is the quick and dirty solution to resolve the issue. However, proper memory profiling and analysis are recommended before applying this fix to ensure it’s the only way around.

Here’s how it works:

For Windows

1. Open and run the Powershell or the Command Prompt as an admin
2. Use the “cd” command to navigate to your Node.js app
3. Run “node --max-old-space-size=4096 main.js”

It allocates 4GB of memory to the memory heap and should fix the error.

You can also allocate more memory to the node global variable in Windows OS. This will allocate memory for all your Node.js apps. Here’s how:

1. Search “Advanced system settings” under the Control Panel in your Windows search box.
2. Click on “Environment Variables” from the System Properties dialog box.
3. Click the “New” button present under User variables or System variables.
4. Enter “Variable name: NODE_OPTIONS”
5. Enter “Variable value: --max-old-space-size=4096”
6. Hit OK and close the dialog box.
7. Restart your system to apply the changes.

The error should be gone now when you run your Node.js app.

For Linux and MacOS

Open the MacOS/Linux terminal and run this command to allocate 4GB for the heap memory for your node app:

node --max-old-space-size=4096 main.js

While increasing the heap size can provide a quick fix, it’s crucial to identify and resolve the root cause of the memory issue for a long-term solution.

Here are some ways to keep the heap out of memory error at bay:

Write Optimized and Clean Code

Keep track of the unwanted global variables, closures, and inefficient code logic in your applications. Using streams and buffers while handling large amounts of data can also help keep your code optimized and prevent out of memory errors.

Test Your Code

Ensure that your code is thoroughly tested with relevant testing methods and in a production-like environment. Real-world conditions push your application to its limits and memory leaks are often identified in these test runs.

Prevent Memory Leaks

Writing efficient code with the best coding practices can help prevent memory leaks in your application. Refer to the official language documentation if you find yourself stuck with memory-related issues.

Use Newer Node.js Versions

Newer Node.js versions are pretty solid in memory management. There’s a good chance that such underlying or unknown issues have already been identified and fixed in recent Node.js packages. However, if you have constraints to using older versions for your project needs, you can always use suitable fixes like those mentioned above.