The prototype design pattern is used to create clones of a base object, so let's see some practical examples written in Swift.

This is also a creational design pattern, it is useful when you have a very basic configuration for an object and you'd like to give (clone) those predefined values to another one. Basically you're making clones from a prototype objects. 😊😊😊

This approach has some benefits, one is for example that you don't have to subclass, but you can configure clones individually. This also means that you can remove a bunch of boilerplate (configuration) code if you are going to use prototypes. 🤔

As you can see the implementation is just a few lines of code. You only need a default initializer and a clone method. Everything will be pre-configured for the prototype object in the init method and you can make your clones using the clone method, but that's pretty obvious at this point... 🤐

Let's take a look at one more example:

The prototype design pattern is also helpful if you are planning to have snapshots of a given state. For example in a drawing app, you could have a shape class as a proto, you can start adding paths to it, and at some point at time you could create a snapshot from it. You can continue to work on the new object, but this will give you the ability to return to a saved state at any point of time in the future. 🎉

That's it about the prototype design pattern (in Swift | in a nuthsell). 🐿

External sources