console.time is not a function
errorThe 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.
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");
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");
The code above will emit the following warning:
(node:16923) Warning: Label 'foo' already exists for console.time()
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);
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
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);
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
console.time is not a function
errorThere are several possible causes of the console.time is not a function
error in JavaScript. We’ll explore some of them in this section.
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.
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);
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 }
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");
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
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');
Such modification of built-in methods and objects could be accidental or by a third-party package.
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() {})()
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
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 () {})();
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 () {})();
console.time
APIThe 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.
console.time is not a function
errorDebugging 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); }
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
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.
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.
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 is like a DVR for web and mobile apps, recording literally everything that happens while a user interacts with your app. 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.
Hey there, want to help make our blog better?
Join LogRocket’s Content Advisory Board. You’ll help inform the type of content we create and get access to exclusive meetups, social accreditation, and swag.
Sign up nowLearn how to manage memory leaks in Rust, avoid unsafe behavior, and use tools like weak references to ensure efficient programs.
Bypass anti-bot measures in Node.js with curl-impersonate. Learn how it mimics browsers to overcome bot detection for web scraping.
Handle frontend data discrepancies with eventual consistency using WebSockets, Docker Compose, and practical code examples.
Efficient initializing is crucial to smooth-running websites. One way to optimize that process is through lazy initialization in Rust 1.80.