DEV Community

Cover image for Solving the Node.js console.time is not a function error
Megan Lee for LogRocket

Posted on • Originally published at blog.logrocket.com

Solving the Node.js console.time is not a function error

Written by Joseph Mawa✏️

The console.time is not a function error is one of the common errors you will encounter in JavaScript and Node. It is a TypeError and its error message usually takes the following forms:

  • console.time is not a function
  • console.time(...) is not a function

The first error message is usually caused by accidentally modifying the built-in console object or reassigning the console.time property to a value that is not a function.

One of the main causes of the second error is the way JavaScript internally handles Automatic Semicolon Insertion (ASI).

Continue reading to learn more about the two variants of this error, their possible causes, and how to debug them. The examples in this article are available in this GitHub repository. Most of the code that throws errors has been commented out. To view the error messages, you’ll need to uncomment the code before running it.

What is console.time?

The console.time, or console.time(), function is one of the built-in timing functions in Node.js. You can access it via the console interface like in the browser environment.

As its name suggests, console.time is used to time the duration that has elapsed between two events. Internally, it uses Node's high-resolution timer of the built-in process object:

console.time("foo");
Enter fullscreen mode Exit fullscreen mode

The console.time function takes an optional string label as an argument and returns undefined. If you don't explicitly pass a label, the default label will be set to 'default'.

Internally, Node creates a Map data structure whose key is the string label you pass to console.time and its value is the high-resolution time. When you call console.timeEnd, Node gets the duration that has elapsed between the two points in time.

You will get a warning if you invoke console.time with the same argument more than once:

>console.time("foo");
console.time("foo");
Enter fullscreen mode Exit fullscreen mode

The code above will emit the following warning:

(node:16923) Warning: Label 'foo' already exists for console.time()
Enter fullscreen mode Exit fullscreen mode

The console.time function is always used with console.timeEnd, which, as its name suggests, stops the timer and calculates the duration of time that has elapsed since console.time was called:

console.time("foo");

setTimeout(() => {
  console.timeEnd("foo");
}, 1_000);
Enter fullscreen mode Exit fullscreen mode

console.timeEnd takes the string passed to console.time as its first argument. It logs the string label and the duration of time that has elapsed since console.time was called in appropriate units and human-readable format:

foo: 1.007s
Enter fullscreen mode Exit fullscreen mode

Another function in the console family of functions is the console.timeLog function. It also takes the string label passed to console.time as its first argument and any number of additional arguments. It logs the duration that has elapsed along with the additional arguments.

Unlike console.timeEnd, console.timeLog doesn't end the timer:

console.time("foo");

setTimeout(() => {
  console.timeLog("foo", "Inside setTimeout");
  console.timeEnd("foo");
}, 1_000);
Enter fullscreen mode Exit fullscreen mode

If you run the code above, you will get the output below. The elapsed time may be slightly different for you:

foo: 1.005s Inside setTimeout
foo: 1.009s
Enter fullscreen mode Exit fullscreen mode

Common causes of the console.time is not a function error

There are several possible causes of the console.time is not a function error in JavaScript. We’ll explore some of them in this section.

Node.js version incompatibility

The console.time and console.timeEnd functions have shipped since Node v0.1.104. Therefore, version incompatibility may be the least likely reason for the console.time is not a function error.

Nevertheless, you need to be sure you're using the right Node version, especially with their corresponding console.timeLog function. The console.timeLog function shipped much later with Node v10.7.9.

Accidentally modifying the console interface

In JavaScript, most built-in objects and functions are mutable and extensible by design. Therefore, it is not unusual to accidentally modify them. You can use the Object.getOwnPropertyDescriptor static method to determine whether a given property of a built-in JavaScript object can be re-assigned, deleted, or modified:

const propertyDescriptor = Object.getOwnPropertyDescriptor(console, "time");
console.log(propertyDescriptor);
Enter fullscreen mode Exit fullscreen mode

The Object.getOwnPropertyDescriptor static method takes an object and a property as arguments and returns a property descriptor object. The code above will log the object below on the terminal:

{
  value: [Function: time],
  writable: true,
  enumerable: true,
  configurable: true
}
Enter fullscreen mode Exit fullscreen mode

You will notice that the writable property is set to true. Therefore, it is possible to accidentally reassign or modify the value of the console.time property without JavaScript throwing an error.

Let us now reassign console.time to undefined and later call it to trigger the console.time is not a function error like in the example below:

console.time = undefined;
console.time("foo"); 
Enter fullscreen mode Exit fullscreen mode

After the reassignment, calling console.time throws the error like the one shown below:

/path/to/file/index.js:2
console.time("foo"); 
        ^

TypeError: console.time is not a function
    at Object.<anonymous> (/path/to/file/index.js:2:9)
    at Module._compile (node:internal/modules/cjs/loader:1254:14)
    at Module._extensions..js (node:internal/modules/cjs/loader:1308:10)
    at Module.load (node:internal/modules/cjs/loader:1117:32)
    at Module._load (node:internal/modules/cjs/loader:958:12)
    at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:81:12)
    at node:internal/main/run_main_module:23:47

Node.js v18.15.0
Enter fullscreen mode Exit fullscreen mode

Instead of triggering the above error by reassigning its value, you could also modify the console object by deleting the console.time property so that it is removed entirely:

delete console.time;
console.time('foo');
Enter fullscreen mode Exit fullscreen mode

Such modification of built-in methods and objects could be accidental or by a third-party package.

Automatic Semicolon Insertion (ASI) and Immediately Invoked Function Expression (IIFE)

Some JavaScript statements require semicolons to be syntactically correct. However, you don't need to add them explicitly because JavaScript has the built-in Automatic Semicolon Insertion (ASI) feature that fixes some invalid tokens out of the box.

ASI makes the language easier to learn and use. Therefore, it is not uncommon for programmers to exclusively rely on it instead of explicitly adding semicolons themselves.

However, this can sometimes lead to unexpected behavior and hard-to-debug errors. A typical example is when a function invocation without a semicolon at the end of the line is followed by an Immediately Invoked Function Expression (IIFE) like in the example below:

console.time('foo')

(function() {})()
Enter fullscreen mode Exit fullscreen mode

You will get the console.time(...) is not a function error if you execute the code above:

/path/to/file/index.js:1
console.time("foo")(function () {})();
                   ^

TypeError: console.time(...) is not a function
    at Object.<anonymous> (/path/to/file/index.js:1:20)
    at Module._compile (node:internal/modules/cjs/loader:1254:14)
    at Module._extensions..js (node:internal/modules/cjs/loader:1308:10)
    at Module.load (node:internal/modules/cjs/loader:1117:32)
    at Module._load (node:internal/modules/cjs/loader:958:12)
    at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:81:12)
    at node:internal/main/run_main_module:23:47

Node.js v18.15.0
Enter fullscreen mode Exit fullscreen mode

The above error was thrown because console.time returned undefined and we tried to invoke undefined as a function with function() {} as argument. If you use code formatting tools like Prettier, the code we executed above will be formatted into the following:

console.time("foo")(function () {})();
Enter fullscreen mode Exit fullscreen mode

You will notice that the error message in the above stack trace is console.time(...) is not a function. On the other hand, the error message in the stack trace after reassigning console.time to a non-function value in the previous sub-section was console.time is not a function.

The difference between the two error messages is the pair of parentheses and the three periods between them. The error in the previous sub-section was due to reassigning console.time to a non-function value while the above error is due to invoking the return value of console.time, undefined.

Therefore, you need to explicitly insert a semicolon to indicate that console.time("foo") is a separate logical statement from the IIFE:

console.time("foo");
(function () {})();
Enter fullscreen mode Exit fullscreen mode

Executing JavaScript code in a runtime environment that doesn't have the console.time API

The console interface is not part of JavaScript; it is part of the web API. However, Node implements many web APIs, including the console API, for compatibility with the web. Chances are that the runtime in which you're executing the JavaScript code hasn't implemented the console.time function.

Therefore, you may encounter the console.time is not a function error if you execute JavaScript code in a runtime environment that has not implemented the browser-compatible console.time method.

Troubleshooting the console.time is not a function error

Debugging the console.time is not a function error is similar to debugging other JavaScript errors. If you're using a text editor like VS Code, you can add breakpoints at appropriate locations and launch the Node.js debugger.

To know where to add breakpoints, it is always helpful to pay close attention to the stack trace. It will always show a detailed trace of the function or method calls that led to the offending line of code.

You can then add breakpoints at various locations and step through the code one line at a time. As an example, let's assume you have the code below in your project:

try {
  console.time = "foo";
  console.time();
} catch (error) {
  console.log(error.stack);
}
Enter fullscreen mode Exit fullscreen mode

The error stack logged to the console as a result of executing the code above will look like so:

TypeError: console.time is not a function
    at Object.<anonymous> (/path/to/file/index.js:3:11)
    at Module._compile (node:internal/modules/cjs/loader:1254:14)
    at Module._extensions..js (node:internal/modules/cjs/loader:1308:10)
    at Module.load (node:internal/modules/cjs/loader:1117:32)
    at Module._load (node:internal/modules/cjs/loader:958:12)
    at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:81:12)
    at node:internal/main/run_main_module:23:47
Enter fullscreen mode Exit fullscreen mode

You will notice the detailed trace of the method and function calls that led to the error. It displays the file path as well as the line and column numbers. You can use that information to add breakpoints and start debugging your code.

Conclusion

Debugging and dealing with errors is inevitable when writing code. In JavaScript, most built-in objects, functions, and methods are mutable by design.

Therefore, it is not uncommon to accidentally mutate built-in objects like the console interface, resulting in hard-to-debug errors. One of these errors is console.time is not a function.

As already explained, one of the possible causes of this error is mutating the console object or reassigning the console.time property to a non-function value. This could be accidentally or intentionally by a third-party package.

On the other hand, this error could be caused by exclusively relying on JavaScript's built-in Automatic Semicolon Insertion feature to insert semicolons for you. As highlighted above, you will get console.time(...) is not a function error if you have console.time and an Immediately Invoked Function Expression in consecutive lines without a semicolon separating them. Therefore, it's a good practice to be explicit and insert semicolons when writing JavaScript code.


200’s only ✔️ Monitor failed and slow network requests in production

Deploying a Node-based web app or website is the easy part. Making sure your Node instance continues to serve resources to your app is where things get tougher. If you’re interested in ensuring requests to the backend or third party services are successful, try LogRocket.

LogRocket Network Request Monitoring

LogRocket is like a DVR for web apps, recording literally everything that happens on your site. Instead of guessing why problems happen, you can aggregate and report on problematic network requests to quickly understand the root cause.

LogRocket instruments your app to record baseline performance timings such as page load time, time to first byte, slow network requests, and also logs Redux, NgRx, and Vuex actions/state. Start monitoring for free.

Top comments (0)