Create a deep copy of x: everything is copied recursively, resulting in a fully independent object. For example, deep-copying an array produces a new array whose elements are deep copies of the original elements. Calling deepcopy on an object should generally have the same effect as serializing and then deserializing it.

As a special case, functions can only be actually deep-copied if they are anonymous, otherwise they are just copied. The difference is only relevant in the case of closures, i.e. functions which may contain hidden internal references.

While it isn't normally necessary, user-defined types can override the default deepcopy behavior by defining a specialized version of the function deepcopy_internal(x::T, dict::ObjectIdDict) (which shouldn't otherwise be used), where T is the type to be specialized for, and dict keeps track of objects copied so far within the recursion. Within the definition, deepcopy_internal should be used in place of deepcopy, and the dict variable should be updated as appropriate before returning.


julia> foo = [1,2,3];
julia> dict = {"a"=>foo};
julia> bar = copy(dict)
Dict{Any,Any} with 1 entry:
    "a" => [1,2,3]
julia> baz = deepcopy(dict)
Dict{Any,Any} with 1 entry:
    "a" => [1,2,3]
julia> foo[1] = 42;
julia> bar
Dict{Any,Any} with 1 entry:
    "a" => [42,2,3]
julia> baz
Dict{Any,Any} with 1 entry:
    "a" => [1,2,3]

See Also

User Contributed Notes

Add a Note

The format of note supported is markdown, use triple backtick to start and end a code block.

*Required Field

Checking you are not a robot: