如何在Julia语言中实现类似append!()的函数？

Great question! Let's clear up a key misconception first: the ! at the end of a function name isn't a "pointer" in the low-level sense—it's just a community naming convention that signals to callers: "this function will modify one or more of its input arguments". The actual ability to alter the original variable comes from how Julia handles mutable data types, not the ! itself.

How It Works Under the Hood #

Julia has two broad categories of types:

• Immutable types (like Int, String, Tuple): When you pass these to a function, the function gets a copy—changes inside the function won't affect the original variable.
• Mutable types (like Array, Dict, or custom mutable structs): When you pass these, the function receives a reference to the original object. Modifying the object's internal state will directly change the original variable outside the function.

Building a Custom append!()-Style Function #

Let's start with a simple version that mimics append!() for arrays. We'll call it my_append! to follow the naming convention:

function my_append!(target::Vector, items...)
    # Iterate over all provided items and add them to the target array
    for item in items
        push!(target, item)
    end
    # By convention, we return the modified object (enables method chaining)
    return target
end

Testing It Out #

Use it just like you would append!():

my_array = [1, 2, 3]
my_append!(my_array, 4, 5, "Julia")

println(my_array)  # Output: [1, 2, 3, 4, 5, "Julia"]

The original my_array is modified because Vector is a mutable type—our function is directly altering its internal elements.

Extending to Custom Mutable Types #

You can apply the same logic to your own custom mutable structures. Let's create a simple list type and add a my_append! method for it:

# Define a custom mutable list
mutable struct SimpleList
    elements::Vector{Any}
end

# Implement append logic for our SimpleList
function my_append!(list::SimpleList, items...)
    for item in items
        push!(list.elements, item)
    end
    return list
end

# Test the custom implementation
my_list = SimpleList(["apple", "banana"])
my_append!(my_list, "cherry", 42)

println(my_list.elements)  # Output: ["apple", "banana", "cherry", 42]

Key Takeaways #

• The ! is just a convention, not syntax that enables mutation. Always use it for functions that modify inputs to follow Julia community norms.
• Mutation only works with mutable types—immutable values can't be changed in-place, so functions that work with them will return new values instead of modifying originals.
• To build such functions, simply operate directly on the mutable input object's internal state; no special pointer syntax is needed.

内容的提问来源于stack exchange，提问作者hexal