Search for a command to run...
I'm Vinay Chhabra, a Full-Stack Developer and Software Engineer specializing in React.js, Node.js, and Magento 2. On Hashnode, I share insights on tech trends, development strategies, and e-commerce solutions.
No comments yet. Be the first to comment.
Higher-order functions in JavaScript are functions that can accept other functions as arguments or return functions as output. They enable a functional programming style, allowing developers to write concise, expressive code that is both flexible and...
Hey everyone! Ever thought about the fun side of JavaScript? Well, get ready because we’re about to uncover some cool and quirky facts about this awesome coding language! JavaScript isn’t just about writing code; it’s full of surprises and interestin...
Did you miss a deadline for your Git commit? No worries! Here’s a quick fix: Stage Your Changes: Before committing to Git, you’ll need to stage your changes. This involves adding the files you want to commit to the staging area using the git add co...
Streamlining Default Value Assignments: The Power of Nullish Coalescing Operator in JavaScript
JavaScript is a powerful language widely used for web development, and optimizing its performance is crucial for delivering fast and responsive web applications. One essential aspect of performance optimization is accurately measuring the time taken by code execution. In this blog post, we’ll delve into the performance.now() method, which is a valuable tool for precise timing measurements in JavaScript.
Introduced as part of the Performance API, performance.now() is a high-resolution timing method available in modern web browsers. It provides a timestamp representing the current time in milliseconds with microsecond precision. Unlike Date.now(), which returns a timestamp based on the system clock, performance.now() offers a monotonically increasing value, ensuring accuracy even if the system clock is adjusted.
The performance.now() method is straightforward to use. You call it to retrieve a timestamp representing the current time, typically before and after the code segment you want to measure. By subtracting the start time from the end time, you can determine the elapsed time taken by the code execution.
/*
Write a function that calculates the time (in seconds) it takes for the JS code to calculate sum from 1 to n, given n as the input.
Try running it for
1. Sum from 1-100
2. Sum from 1-100000
3. Sum from 1-1000000000
*/
function calculateTime(n) {
let sum;
let start = performance.now();
for (let i = 1; i <= n; i++) {
sum = (sum || 0) + i;
}
let timeConsumed = performance.now() - start;
console.log(timeConsumed);
}
console.log("--------first 100-------");
calculateTime(100);
console.log("--------second 100000-------");
calculateTime(100000);
console.log("--------third 1000000000-------");
calculateTime(1000000000);
//Output
// --------first 100-------
// 0.34654200077056885
// --------second 100000-------
// 1.0555000305175781
// --------third 1000000000-------
// 1612.8575830459595
High Precision:performance.now() offers microsecond precision, making it suitable for measuring short durations accurately. This level of precision is essential for performance analysis and optimization, especially in latency-sensitive applications.
Monotonic Clock: The timestamps provided by performance.now() are monotonically increasing, meaning they always move forward and never decrease, even if the system clock is adjusted. This ensures reliability in timing measurements, particularly in scenarios where the system clock may be subject to changes.
Consistency Across Environments: Unlike some timing methods based on the system clock, performance.now() provides consistent timing data across different environments and platforms. This consistency makes it reliable for performance profiling and benchmarking across various browsers and devices.
When using performance.now() for performance measurement, consider the following best practices:
Always measure the time before and after the code segment you want to evaluate to capture the entire duration accurately.
Avoid using performance.now() for time-critical operations within performance-sensitive code blocks, as it incurs some overhead.
Use performance.now() in conjunction with other performance-related methods provided by the Performance API, such as performance.mark() and performance.measure(), for more detailed performance analysis.
In summary, performance.now() is a valuable tool for precise timing measurements in JavaScript. Its high precision, monotonic clock behavior, and consistency across environments make it well-suited for performance optimization tasks. By leveraging performance.now() effectively, developers can gain insights into code execution times, identify performance bottlenecks, and optimize their applications for better user experiences.
By incorporating performance.now() into your performance monitoring and optimization workflows, you can take proactive steps to enhance the performance and responsiveness of your JavaScript applications.