fast-copy vs rfdc
Deep Cloning Utilities for JavaScript Objects
Search packages..
fast-copyrfdcSimilar Packages:

Deep Cloning Utilities for JavaScript Objects

fast-copy and rfdc are both high-performance libraries designed to create deep copies of JavaScript objects. They aim to provide faster alternatives to naive recursive cloning or JSON-based serialization/deserialization, especially for complex nested data structures. Both avoid common pitfalls like circular references (though with different strategies) and support a wide range of JavaScript types beyond plain objects and arrays.

Npm Package Weekly Downloads Trend

3 Years

Github Stars Ranking

Stat Detail

Package
Downloads
Stars
Size
Issues
Publish
License
fast-copy01,166161 kB04 months agoMIT
rfdc069527.1 kB222 years agoMIT

Deep Cloning Showdown: fast-copy vs rfdc

When you need to duplicate complex JavaScript objects without sharing references, JSON.parse(JSON.stringify(obj)) quickly falls short—it fails on functions, undefined, Date objects, RegExp, Map, Set, and circular structures. That’s where dedicated deep clone libraries like fast-copy and rfdc come in. Both promise speed and correctness, but they take very different approaches. Let’s dig into how they behave in real code.

🧪 Supported Data Types: What Can You Clone?

fast-copy supports a wide range of built-in JavaScript types:

  • Plain objects and arrays
  • Date, RegExp
  • Map, Set
  • ArrayBuffer, DataView, and all typed arrays (Int8Array, Float64Array, etc.)
  • null, undefined, functions (copied as-is, not deeply cloned)
// fast-copy: Handles advanced types
import copy from 'fast-copy';

const original = {
  date: new Date('2023-01-01'),
  regex: /hello/g,
  map: new Map([['key', 'value']]),
  set: new Set([1, 2, 3]),
  buffer: new Uint8Array([1, 2, 3]).buffer
};

const cloned = copy(original);
console.log(cloned.date instanceof Date); // true
console.log(cloned.map.get('key'));        // 'value'

rfdc (Really Fast Deep Clone) focuses only on JSON-compatible types:

  • Plain objects and arrays
  • Strings, numbers, booleans, null
  • Does NOT support: Date, RegExp, Map, Set, ArrayBuffer, functions, or undefined
// rfdc: Throws on unsupported types
import rfdc from 'rfdc';
const clone = rfdc();

const original = {
  date: new Date(),
  regex: /test/
};

// This throws: "Cannot clone non-plain object"
// const cloned = clone(original);

💡 If your data includes anything beyond basic objects and primitives, rfdc will fail. fast-copy won’t.

🔁 Circular References: Safe or Strict?

fast-copy uses a WeakMap to track seen objects and safely handles circular references by preserving the cycle in the clone.

// fast-copy: Circular reference handled gracefully
import copy from 'fast-copy';

const obj = { name: 'parent' };
obj.self = obj;

const cloned = copy(obj);
console.log(cloned.self === cloned); // true — cycle preserved

rfdc does not support circular references. Attempting to clone a circular structure throws an error immediately.

// rfdc: Circular reference throws
import rfdc from 'rfdc';
const clone = rfdc();

const obj = { name: 'parent' };
obj.self = obj;

// Throws: "Circular reference detected"
// const cloned = clone(obj);

This makes rfdc unsuitable for cloning arbitrary object graphs (e.g., DOM-like trees, state machines), while fast-copy remains robust.

⚡ Performance: Speed vs Safety Trade-off

rfdc is optimized for one thing: cloning plain objects as fast as possible. It avoids type checks and feature detection to minimize overhead. If your data is strictly JSON-like, it’s often the fastest option available.

// rfdc: Minimal overhead for plain data
import rfdc from 'rfdc';
const clone = rfdc();

const data = { users: [{ id: 1, name: 'Alice' }] };
const fastClone = clone(data); // Extremely fast

fast-copy pays a small performance cost to support more types and circular references. But for most real-world apps, the difference is negligible—and the safety is worth it.

// fast-copy: Slightly slower but safer
import copy from 'fast-copy';

const data = { users: [{ id: 1, name: 'Alice' }] };
const safeClone = copy(data); // Still very fast, but more capable

In benchmarks with plain objects, rfdc typically wins. But once you add Date or Map, fast-copy is the only viable choice.

🛠️ API Design: Simplicity vs Configuration

Both libraries have simple APIs, but differ slightly:

fast-copy exports a single function:

import copy from 'fast-copy';
const result = copy(source);

rfdc exports a factory function that returns a reusable clone function (to avoid repeated setup):

import rfdc from 'rfdc';
const clone = rfdc(); // Create once
const result = clone(source); // Reuse

This design lets rfdc optimize internal state per clone instance, but adds a tiny bit of ceremony.

🧩 Real-World Usage Guidance

Use rfdc when:

  • You control the data shape and know it’s plain objects/arrays/primitives
  • You’re in a hot path (e.g., Redux middleware, game loop) where every microsecond counts
  • You can guarantee no circular references exist
// Example: Cloning API response data
const clone = rfdc();
const apiData = await fetch('/data').then(r => r.json());
const localCopy = clone(apiData); // Safe and fast

Use fast-copy when:

  • You’re building a library or framework that must handle unknown input
  • Your state includes Date, Map, or other non-plain objects
  • You work with recursive data structures (e.g., ASTs, tree UIs)
  • You prefer “it just works” over shaving off microseconds
// Example: Cloning complex app state
import copy from 'fast-copy';

const appState = {
  user: { lastLogin: new Date() },
  cache: new Map(),
  config: { theme: 'dark' }
};

const backup = copy(appState); // Works without surprises

📌 Summary Table

Featurefast-copyrfdc
Plain objects✅ Yes✅ Yes (fastest)
Date, RegExp✅ Yes❌ Throws
Map, Set✅ Yes❌ Throws
Typed arrays✅ Yes❌ Throws
Circular refs✅ Preserved safely❌ Throws
Zero dependencies✅ Yes✅ Yes
APIcopy(obj)rfdc()()

💡 Final Takeaway

Think of rfdc as a race car: stripped down, blazing fast, but only drives on smooth tracks. fast-copy is a rugged SUV: slightly heavier, but handles mud, snow, and off-road terrain without breaking down.

If you’re certain your data is simple and clean, rfdc gives you peak performance. But in most real applications—where data comes from APIs, user input, or third-party libraries—fast-copy’s resilience and broader compatibility make it the safer, more practical choice.

How to Choose: fast-copy vs rfdc

  • fast-copy:

    Choose fast-copy if you need a zero-dependency, modern deep clone that handles a broad set of JavaScript types including Date, RegExp, Map, Set, ArrayBuffer, and typed arrays out of the box. It uses a WeakMap to safely handle circular references without throwing errors, making it suitable for general-purpose deep cloning in applications where data structure complexity is unknown or varied.

  • rfdc:

    Choose rfdc if raw speed is your top priority and you're primarily working with plain objects, arrays, and primitive values. It's optimized for minimal overhead and fastest possible execution on standard JSON-like data, but it does not support advanced types like Map, Set, or Date and will throw an error if it encounters circular references.

Similar Npm Packages to fast-copy

fast-copy is a high-performance deep copy utility for JavaScript objects. It is designed to efficiently clone objects while preserving their structure and properties, making it an excellent choice for applications that require frequent object copying. Fast-copy is particularly useful in scenarios where performance is critical, such as in state management or when working with large datasets. Its simplicity and speed make it a popular choice among developers looking for a reliable cloning solution.

There are several alternatives to fast-copy that also provide object cloning capabilities. Here are a few notable ones:

  • clone is a straightforward utility for deep cloning JavaScript objects. It offers a simple API and is easy to use, making it a good choice for developers who need a basic cloning solution without any additional complexity. While it may not be as fast as fast-copy, it is still a reliable option for many use cases where performance is not the primary concern.
  • immer is a library that allows developers to work with immutable state in a more convenient way. While its primary purpose is not cloning, it provides a powerful mechanism for producing new state by applying changes to a draft state. Immer is particularly useful in state management scenarios, such as with Redux, where immutability is essential. If you are looking for a solution that combines cloning with immutability, immer is an excellent choice.
  • rfdc (Really Fast Deep Clone) is another high-performance deep cloning library. It focuses on speed and efficiency, making it a strong competitor to fast-copy. Rfdc is particularly beneficial for scenarios where performance is critical, and it supports cloning of various data types, including arrays and objects. If you need a fast and reliable deep cloning solution, rfdc is worth considering.

To see how fast-copy compares with clone, immer, and rfdc, check out the comparison: Comparing clone vs fast-copy vs immer vs rfdc.

Similar Npm Packages to rfdc

rfdc is a fast and efficient deep copy library for JavaScript. It is designed to create deep copies of objects and arrays while maintaining high performance. Unlike some traditional deep copy methods, rfdc is optimized for speed and memory usage, making it an excellent choice for applications that require frequent cloning of complex data structures. Its minimalistic API allows developers to easily integrate it into their projects without any overhead.

While rfdc provides a robust solution for deep copying, there are alternatives available that also cater to similar needs. One notable alternative is:

  • fast-copy. This library is another high-performance deep copy utility that aims to provide a fast and reliable way to clone JavaScript objects and arrays. fast-copy is designed to handle a wide range of data types, including nested objects and arrays, while ensuring that the copied data retains its structure and integrity. It is particularly useful for applications that require efficient data manipulation and cloning, similar to rfdc. If you are looking for a library that balances performance and ease of use, fast-copy is a solid option.

To see how rfdc compares with fast-copy, check out the comparison: Comparing rfdc vs fast-copy.

README for fast-copy

fast-copy

A blazing fast deep object copier

Table of contents

Usage

import { copy } from 'fast-copy';
import { deepEqual } from 'fast-equals';

const object = {
  array: [123, { deep: 'value' }],
  map: new Map([
    ['foo', {}],
    [{ bar: 'baz' }, 'quz'],
  ]),
};

const copiedObject = copy(object);

console.log(copiedObject === object); // false
console.log(deepEqual(copiedObject, object)); // true

API

copy

Deeply copy the object passed.

import { copy } from 'fast-copy';

const copied = copy({ foo: 'bar' });

copyStrict

Deeply copy the object passed, but with additional strictness when replicating the original object:

  • Properties retain their original property descriptor
  • Non-enumerable keys are copied
  • Non-standard properties (e.g., keys on arrays / maps / sets) are copied
import { copyStrict } from 'fast-copy';

const object = { foo: 'bar' };
object.nonEnumerable = Object.defineProperty(object, 'bar', {
  enumerable: false,
  value: 'baz',
});

const copied = copy(object);

NOTE: This method is significantly slower than copy, so it is recommended to only use this when you have specific use-cases that require it.

createCopier

Create a custom copier based on the type-specific method overrides passed, as well as configuration options for how copies should be performed. This is useful if you want to squeeze out maximum performance, or perform something other than a standard deep copy.

import { createCopier } from 'fast-copy';
import { LRUCache } from 'lru-cache';

const copyShallowStrict = createCopier({
  createCache: () => new LRUCache(),
  methods: {
    array: (array) => [...array],
    map: (map) => new Map(map.entries()),
    object: (object) => ({ ...object }),
    set: (set) => new Set(set.values()),
  },
  strict: true,
});

createCache

Method that creates the internal cache in the Copier state. Defaults to creating a new WeakMap instance.

methods

Methods used for copying specific object types. A list of the methods and which object types they handle:

  • array => Array
  • arrayBuffer=> ArrayBuffer, Float32Array, Float64Array, Int8Array, Int16Array, Int32Array, Uint8Array, Uint8ClampedArray, Uint16Array, Uint32Array, Uint64Array
  • blob => Blob
  • dataView => DataView
  • date => Date
  • error => Error, AggregateError, EvalError, RangeError, ReferenceError, SyntaxError, TypeError, URIError
  • map => Map
  • object => Object, or any custom constructor
  • regExp => RegExp
  • set => Set

Each method has the following contract:

type InternalCopier<Value> = (value: Value, state: State) => Value;

interface State {
  Constructor: any;
  cache: WeakMap;
  copier: InternalCopier<any>;
  prototype: any;
}
Copier state
cache

If you want to maintain circular reference handling, then you'll need the methods to handle cache population for future lookups:

function shallowlyCloneArray<Value extends any[]>(
  value: Value,
  state: State
): Value {
  const clone = [...value];

  state.cache.set(value, clone);

  return clone;
}
copier

copier is provided for recursive calls with deeply-nested objects.

function deeplyCloneArray<Value extends any[]>(
  value: Value,
  state: State
): Value {
  const clone = [];

  state.cache.set(value, clone);

  value.forEach((item) => state.copier(item, state));

  return clone;
}

Note above I am using forEach instead of a simple map. This is because it is highly recommended to store the clone in cache eagerly when deeply copying, so that nested circular references are handled correctly.

Constructor / prototype

Both Constructor and prototype properties are only populated with complex objects that are not standard objects or arrays. This is mainly useful for custom subclasses of these globals, or maintaining custom prototypes of objects.

function deeplyCloneSubclassArray<Value extends CustomArray>(
  value: Value,
  state: State
): Value {
  const clone = new state.Constructor();

  state.cache.set(value, clone);

  value.forEach((item) => clone.push(item));

  return clone;
}

function deeplyCloneCustomObject<Value extends CustomObject>(
  value: Value,
  state: State
): Value {
  const clone = Object.create(state.prototype);

  state.cache.set(value, clone);

  Object.entries(value).forEach(([k, v]) => (clone[k] = v));

  return clone;
}

strict

Enforces strict copying of properties, which includes properties that are not standard for that object. An example would be a named key on an array.

NOTE: This creates a copier that is significantly slower than "loose" mode, so it is recommended to only use this when you have specific use-cases that require it.

Types supported

The following object types are deeply cloned when they are either properties on the object passed, or the object itself:

  • Array
  • ArrayBuffer
  • Boolean primitive wrappers (e.g., new Boolean(true))
  • Blob
  • Buffer
  • DataView
  • Date
  • Float32Array
  • Float64Array
  • Int8Array
  • Int16Array
  • Int32Array
  • Map
  • Number primitive wrappers (e.g., new Number(123))
  • Object
  • RegExp
  • Set
  • String primitive wrappers (e.g., new String('foo'))
  • Uint8Array
  • Uint8ClampedArray
  • Uint16Array
  • Uint32Array
  • React components
  • Custom constructors

The following object types are copied directly, as they are either primitives, cannot be cloned, or the common use-case implementation does not expect cloning:

  • AsyncFunction
  • AsyncGenerator
  • Boolean primitives
  • Error
  • Function
  • Generator
  • GeneratorFunction
  • Number primitives
  • Null
  • Promise
  • String primitives
  • Symbol
  • Undefined
  • WeakMap
  • WeakSet

Circular objects are supported out of the box. By default, a cache based on WeakSet is used, but if WeakSet is not available then a fallback is used. The benchmarks quoted below are based on use of WeakSet.

Aspects of default copiers

Inherently, what is considered a valid copy is subjective because of different requirements and use-cases. For this library, some decisions were explicitly made for the default copiers of specific object types, and those decisions are detailed below. If your use-cases require different handling, you can always create your own custom copier with createCopier.

Error references are copied directly, instead of creating a new *Error object

While it would be relatively trivial to copy over the message and stack to a new object of the same Error subclass, it is a common practice to "override" the message or stack, and copies would not retain this mutation. As such, the original reference is copied.

The constructor of the original object is used, instead of using known globals

Starting in ES2015, native globals can be subclassed like any custom class. When copying, we explicitly reuse the constructor of the original object. However, the expectation is that these subclasses would have the same constructur signature as their native base class. This is a common community practice, but there is the possibility of inaccuracy if the contract differs.

Generator objects are copied, but still reference the original generator's state

Generator objects are specific types of iterators, but appear like standard objects that just have a few methods (next, throw, return). These methods are bound to the internal state of the generator, which cannot be copied effectively. Normally this would be treated like other "uncopiable" objects and simply pass the reference through, however the "validation" of whether it is a generator object or a standard object is not guaranteed (duck-typing) and there is a runtime cost associated with. Therefore, the simplest path of treating it like a standard object (copying methods to a new object) was taken.

Benchmarks

Simple objects

Small number of properties, all values are primitives

┌────────────────────┬────────────────┐
│ Name               │ Ops / sec      │
├────────────────────┼────────────────┤
│ fast-copy          │ 4606103.720559 │
├────────────────────┼────────────────┤
│ lodash.cloneDeep   │ 2575175.39241  │
├────────────────────┼────────────────┤
│ clone              │ 2172921.6353   │
├────────────────────┼────────────────┤
│ ramda              │ 1919715.448951 │
├────────────────────┼────────────────┤
│ fast-clone         │ 1576610.693318 │
├────────────────────┼────────────────┤
│ deepclone          │ 1173500.05884  │
├────────────────────┼────────────────┤
│ fast-copy (strict) │ 1049310.47701  │
└────────────────────┴────────────────┘
Fastest was "fast-copy".

Complex objects

Large number of properties, values are a combination of primitives and complex objects

┌────────────────────┬───────────────┐
│ Name               │ Ops / sec     │
├────────────────────┼───────────────┤
│ fast-copy          │ 235511.4532   │
├────────────────────┼───────────────┤
│ deepclone          │ 142976.849406 │
├────────────────────┼───────────────┤
│ clone              │ 125026.837887 │
├────────────────────┼───────────────┤
│ ramda              │ 114216.98158  │
├────────────────────┼───────────────┤
│ fast-clone         │ 111388.215547 │
├────────────────────┼───────────────┤
│ fast-copy (strict) │ 77683.900047  │
├────────────────────┼───────────────┤
│ lodash.cloneDeep   │ 71343.431983  │
└────────────────────┴───────────────┘
Fastest was "fast-copy".

Big data

Very large number of properties with high amount of nesting, mainly objects and arrays

Testing big data object...
┌────────────────────┬────────────┐
│ Name               │ Ops / sec  │
├────────────────────┼────────────┤
│ fast-copy          │ 325.548627 │
├────────────────────┼────────────┤
│ fast-clone         │ 257.913886 │
├────────────────────┼────────────┤
│ deepclone          │ 158.228042 │
├────────────────────┼────────────┤
│ lodash.cloneDeep   │ 153.520966 │
├────────────────────┼────────────┤
│ fast-copy (strict) │ 126.027381 │
├────────────────────┼────────────┤
│ clone              │ 123.383641 │
├────────────────────┼────────────┤
│ ramda              │ 35.507959  │
└────────────────────┴────────────┘
Fastest was "fast-copy".

Circular objects

Testing circular object...
┌────────────────────┬────────────────┐
│ Name               │ Ops / sec      │
├────────────────────┼────────────────┤
│ fast-copy          │ 1344790.296938 │
├────────────────────┼────────────────┤
│ deepclone          │ 1127781.641192 │
├────────────────────┼────────────────┤
│ lodash.cloneDeep   │ 894679.711048  │
├────────────────────┼────────────────┤
│ clone              │ 892911.50594   │
├────────────────────┼────────────────┤
│ fast-copy (strict) │ 821339.44828   │
├────────────────────┼────────────────┤
│ ramda              │ 615222.946985  │
├────────────────────┼────────────────┤
│ fast-clone         │ 0              │
└────────────────────┴────────────────┘
Fastest was "fast-copy".

Special objects

Custom constructors, React components, etc

┌────────────────────┬──────────────┐
│ Name               │ Ops / sec    │
├────────────────────┼──────────────┤
│ fast-copy          │ 86875.694416 │
├────────────────────┼──────────────┤
│ clone              │ 73525.671381 │
├────────────────────┼──────────────┤
│ lodash.cloneDeep   │ 63280.563976 │
├────────────────────┼──────────────┤
│ fast-clone         │ 52991.064016 │
├────────────────────┼──────────────┤
│ ramda              │ 31770.652317 │
├────────────────────┼──────────────┤
│ deepclone          │ 24253.795114 │
├────────────────────┼──────────────┤
│ fast-copy (strict) │ 19112.538416 │
└────────────────────┴──────────────┘
Fastest was "fast-copy".
npm-compare.com is an independent website designed to help developers choose the most suitable npm packages. We are not affiliated with npm, Inc, the official website for the npm registry. Note that npm is a registered trademark of npm, Inc. Please share your feedback via our GitHub repository. For more details, please refer to our Terms & Privacy.