Input data size

JavaScriptJunior~3 min read

1. The core idea

The more input data, the longer the code takes to run, unless the algorithm scales efficiently.

The size of the input directly affects:

execution time (CPU load);
memory usage;
the number of input/output (I/O) operations;
the number of iterations and recursion depth.

This dependency is usually expressed through asymptotic complexity (Big O), how fast the execution time grows as the input grows.

2. A simple visualization

Algorithm	Complexity	What it means	Example
O(1)	constant	doesn't depend on data size	index access `arr[0]`
O(log n)	logarithmic	grows slowly	binary search
O(n)	linear	time grows proportionally to the number of elements	a `for` loop over an array
O(n log n)	quasi-linear	moderate growth	`Array.sort()`
O(n²)	quadratic	explosive growth with large data	nested loops
O(2ⁿ)	exponential	grows catastrophically	recursive Fibonacci
O(n!)	factorial	infeasible for large n	permutations

3. Examples in JavaScript

O(1) - independent of size

javascript

const arr = [1, 2, 3, 4, 5];
console.log(arr[3]); // instant, whether it's 5 or 5 million elements

O(n) - linear dependency

javascript

function sum(arr) {
  return arr.reduce((acc, num) => acc + num, 0);
}

sum([1, 2, 3]);           // ~3 operations
sum(new Array(1000000));  // ~1,000,000 operations

The bigger the array, the more time it takes.

O(n²) - quadratic growth

javascript

function allPairs(arr) {
  for (let i = 0; i < arr.length; i++) {
    for (let j = 0; j < arr.length; j++) {
      // some operation
    }
  }
}

If n = 1000, that's roughly 1,000,000 operations. If n = 10,000, it's already 100,000,000.

O(2ⁿ) - exponential growth

javascript

function fib(n) {
  if (n <= 1) return n;
  return fib(n - 1) + fib(n - 2);
}

fib(30); // fine
fib(45); // already slow!

The growth is explosive. At 100 elements, it's simply infeasible to compute.

4. How growing input affects performance

Input size	O(1)	O(log n)	O(n)	O(n²)	O(2ⁿ)
10	fast	fast	fast	fast	fast
100	fast	fast	fast	moderate	slow
1,000	fast	fast	moderate	slow	critical
100,000	fast	fast	slow	critical	critical

Conclusion: with small data everything "flies", but as the volume grows, "inefficient" code starts to explode in execution time.

5. Performance in different scenarios

Task type	Example	How data size affects it
Iterating an array	`map`, `filter`, `reduce`	linear
Searching an array	`arr.includes()`	linear
Looking up an object / Map	`obj[key]`, `map.get()`	almost O(1)
Sorting	`arr.sort()`	O(n log n)
Comparing nested structures	deep object comparison	can be O(n²)
Rendering in React	large lists, tables	time grows with DOM size
Database queries	without an index -> O(n)	more rows means slower

6. Practical effects

CPU load grows - operations take longer;
memory usage increases - especially when copying or storing large structures;
the event loop gets blocked - the UI "hangs";
FPS drops - animations get choppy;
the GC (garbage collector) runs more often -> lag.

7. How to improve performance as data grows

Problem	Solution
Loops take too long	Break into chunks (`setTimeout`, `requestIdleCallback`)
Complex filters/searches	Use `Set`, `Map`, indexes
Frequent repeated computations	Memoization
Too many elements in the DOM	Virtualization (`react-window`, `infinite scroll`)
Frequent array re-creation	Use mutations carefully
Large JSON	Stream reading (`ReadableStream`)

Summary

The larger the input data, the more the asymptotic complexity of the algorithm and the load on memory/CPU show up.

Data size grows	-> Affects
Number of iterations	Execution time
Recursion depth	Risk of stack overflow
Number of objects	Memory usage
List / array length	Number of re-renders (in React)
Volume of I/O	Delay from network / disk

Short Answer

Interview ready

Premium

A concise answer to help you respond confidently on this topic during an interview.