0Pricing
Elixir & Phoenix: Scalable Backend Development · Lektion

Presence und Live-Datenaktualisierungen

Fügen Sie Ihren Anwendungen Presence-Tracking hinzu und verwalten Sie Live-Datenaktualisierungen für dynamische Benutzeroberflächen.

Presence und Live-Datenaktualisierungen ist eine kostenlose Elixir & Phoenix: Scalable Backend Development-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Elixir & Phoenix: Scalable Backend Development-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Elixir & Phoenix: Scalable Backend Development-Kurs umfasst insgesamt 4 Lektionen.

Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.

What is User Presence?

In real-time applications, presence refers to tracking who is currently online, active, or viewing a specific resource.

  • Think of a chat application showing 'online' status.
  • Or a collaborative document editor indicating who else is viewing or editing.
  • It's crucial for dynamic, interactive user interfaces.

Phoenix.Presence Explained

Phoenix Framework provides a powerful, built-in module called Phoenix.Presence to manage presence information.

  • It leverages Elixir's concurrency and distribution features.
  • It automatically handles users joining, leaving, and even network disconnections.
  • This makes building robust presence features much simpler.

Integrating Presence in Channels

To use Phoenix.Presence, you typically integrate it into your Phoenix Channel modules.

First, ensure your UserSocket defines a pubsub_server (e.g., MyApp.PubSub). Then, within your channel module, you add use Phoenix.Presence.

This mixin provides helpers for tracking and retrieving presence data.

Tracking Users with `track/3`

The core function for adding a user to presence is Phoenix.Presence.track/3.

  • It takes the socket, a unique key (e.g., user ID), and metadata (e.g., username, status).
  • You usually call this in your channel's join/3 callback.
  • When a user joins a channel, they are tracked; when they leave, their presence is automatically removed.

Example: Basic Presence Track

Let's see how track/3 is called when a user joins a channel. We'll simulate a socket for this example.

defmodule MyRoomChannel do
  use Phoenix.Channel
  use Phoenix.Presence

  @impl true
  def join("room:lobby", _payload, socket) do
    # In a real app, user_id would come from auth
    user_id = "user_#{System.unique_integer([:positive])}"
    metadata = %{username: "Guest_#{user_id}", status: "online"}

    # Track the user's presence for this topic
    Phoenix.Presence.track(socket, user_id, metadata)
    IO.puts "User #{user_id} joined and tracked in room:lobby"
    {:ok, socket}
  end

  # Minimal run_example to simulate join
  def run_example do
    mock_socket = %{topic: "room:lobby", assigns: %{}}
    join("room:lobby", %{}, mock_socket)
  end
end

MyRoomChannel.run_example()

Accessing Presence Information

Once users are tracked, you can retrieve their presence information:

  • Phoenix.Presence.list(socket): Returns a map of all presences for the channel's topic.
  • Phoenix.Presence.get_by_key(socket, user_key): Retrieves presence data for a specific user key.

These functions allow you to build dynamic UI elements based on who is online.

Live Data Updates Concept

Beyond just knowing who is online, real-time apps often need to push live data updates to clients.

  • This could be a new chat message, a score update in a game, or a change in a shared item's status.
  • The key is to send structured data to all connected clients on a specific channel topic.
  • Clients then receive this data and update their UI accordingly.

Broadcasting Data with `broadcast!`

You can send live data updates using the broadcast!/3 function (or push/3 for direct messages) from your channel or another process.

  • broadcast!(socket, "event_name", %{data: "payload"}): Sends an event and payload to all clients subscribed to the socket's topic.
  • The "event_name" helps clients differentiate between types of updates.

This is how you keep all connected clients in sync with server-side changes.

Example: Broadcasting Live Data

Here's how you might broadcast a new message to all clients in a room. We simulate the broadcast call.

defmodule MyDataUpdater do
  # We use Phoenix.Channel for its broadcast! helper
  use Phoenix.Channel

  # Function to simulate sending an update
  def send_new_message(topic, sender, text) do
    event = "new_message"
    payload = %{sender: sender, text: text, timestamp: System.system_time(:second)}

    # In a real app, you'd call broadcast! from a channel context
    # or use Phoenix.PubSub.broadcast from a GenServer.
    # For this runnable example, we'll just demonstrate the payload.
    IO.puts "Simulating broadcast to '#{topic}' with event '#{event}' and payload:"
    IO.inspect payload
    :ok
  end

  # To run this example
  def run_example do
    send_new_message("room:lobby", "Alice", "Hello everyone!")
  end
end

MyDataUpdater.run_example()

Presence & Updates Check

Which of the following statements about Phoenix.Presence and live data updates are TRUE?

Summary: Presence & Live Data

Great job! You've learned how Phoenix.Presence simplifies tracking user activity in real-time applications.

  • We covered using Phoenix.Presence.track/3 to mark users as present.
  • You also saw how to retrieve presence information with list/1 and get_by_key/2.
  • Finally, we explored sending dynamic live data updates to clients using broadcast!/3 for interactive UIs.

These tools are fundamental for building engaging real-time features!

Häufig gestellte Fragen

Ist die Lektion „Presence und Live-Datenaktualisierungen“ kostenlos?

Ja — der vollständige Text von „Presence und Live-Datenaktualisierungen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Elixir & Phoenix: Scalable Backend Development-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Elixir & Phoenix: Scalable Backend Development-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Presence und Live-Datenaktualisierungen“?

Fügen Sie Ihren Anwendungen Presence-Tracking hinzu und verwalten Sie Live-Datenaktualisierungen für dynamische Benutzeroberflächen. Du übst Elixir & Phoenix: Scalable Backend Development mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Elixir & Phoenix: Scalable Backend Development zu starten?

Keine Vorkenntnisse erforderlich. Elixir & Phoenix: Scalable Backend Development auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Presence und Live-Datenaktualisierungen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Elixir & Phoenix: Scalable Backend Development-Lektion Code schreiben und ausführen?

Ja. Jede Elixir & Phoenix: Scalable Backend Development-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Einführung in Phoenix Channels
  2. Broadcasting und Pub/Sub-Nachrichten
  3. Presence und Live-Datenaktualisierungen
  4. Authentifizierung und Autorisierung von Channels
← Zurück zu Elixir & Phoenix: Scalable Backend Development