I'm confused about "assigns" what does it do?

Assigns belongs to socket structure as seen here.

assigns allows to set socket assigns value.

As each socket is independant from each others, it is used to store info for a dedicated socket.

eg. Storing user data, or any other related data.

Thanks for your response, @kokolegorille. I’m still not entirely clear on “assigns”, however. All the definitions and docs I see seem to have recursive definitions.

For instance, you wrote “assigns allows to set socket assigns value”. And in the link to the docs that you gave me I see definitions like the following:

assign(socket, key, value)
    Adds key/value pair to socket assigns

Is “assign” ever used outside of sockets? Is it something like a dictionary of key-values? If it is just a dictionary of key-values, then why is it limited to sockets?

Thanks.

There is a similar concept in :plugs conn-struct.

Its a generic mechanism of making both extendable and carry around that is special to the application.

Channels are processes (GenServer), so they have a state, which is the Socket struct. “assigns” is one field of that struct which Phoenix provides for you to store app-specific data. For instance you could store a user ID in assigns when the channel is created (join), then access it later when you receive messages (handle_in), in order to tell who sent it. It’s a plain old map.

“Assigns” is basically the data backpack of the socket or Plug.Conn connection. You’d use it to hold onto data, which you’ll need throughout the lifetime of that connection. One example would be the authentication status (current user). It’s kinda like the session mechanic for http requests, but the session is used to store data between multiple request, while assigns store data for usage within a single request.

Imagine you want to pass some value from your join function in channels to handle_in. You cannot simply assign to a variable:

def join(..., socket) do
  username = "hello"
  {:ok, socket}
end

def handle_in(..., socket) do
  username #=> this will raise
end

So instead, we store it in a data-structure (or assign it to a data structure) and pass the data structure forward:

def join(..., socket) do
  socket = assign(socket, :username, "hello")
  {:ok, socket}
end

def handle_in(..., socket) do
  socket.assigns.username #=> this works
end

The field in itself is a map with atom keys and the stored values.

For anyone looking for a simple walkthrough of using “assigns”, I made a screencast about just that:

https://elixircasts.io/exploring-phoenix-assigns