Elixir & Phoenix: Scalable Backend Development · Lektion

Views, Templates und LiveView-Grundlagen

Rendern Sie dynamische Inhalte mit Phoenix-Views und -Templates und erhalten Sie eine Einführung in die Möglichkeiten von Phoenix LiveView.

Views, Templates und LiveView-Grundlagen 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.

Unlocking Dynamic Content

Web applications aren't static! You need ways to display changing data, like user profiles or product lists. This is where views and templates come in.

They work together to transform raw data from your application into the beautiful HTML that users see in their browsers.

Views: Your Data's Designer

In Phoenix, a View is an Elixir module responsible for preparing data before it's rendered into a template. Think of it as a middleman between your controller and the final HTML.

Views can:

Format dates or numbers.
Create dynamic links or URLs.
Transform complex data structures into simpler ones for display.

Templates: Crafting HTML

Templates are files (often with a .eex extension or using the ~H sigil) that combine standard HTML with embedded Elixir code. Elixir's templating engine, EEx (Embedded Elixir), allows you to inject dynamic content.

<%= expression %>: Evaluates an Elixir expression and outputs its result directly into the HTML.
<% expression %>: Evaluates an Elixir expression but does NOT output its result. Useful for control flow like loops or conditionals.

The Rendering Flow in Action

Here's a simplified look at how Phoenix renders a page:

A Controller action receives an HTTP request.
The Controller calls render/3 (e.g., render(conn, "index.html", assigns)), passing data as 'assigns'.
The corresponding View module (e.g., PageView) receives these assigns and can apply helper functions.
The Template file (e.g., index.html.eex) uses the prepared assigns to generate the final HTML.
This HTML is then sent back to the user's browser.

EEx in Action: Dynamic Greeting

Let's see how EEx processes dynamic data. This Elixir script simulates a template rendering a value passed to it.

defmodule MyTemplateRenderer do
  def render_greeting(name) do
    template_string = "<h1>Hello, <%= name %>!</h1>"
    EEx.eval_string(template_string, [name: name])
  end
end

IO.puts MyTemplateRenderer.render_greeting("CoddyKit Learner")

Introducing Phoenix LiveView

Imagine building highly interactive web interfaces without writing a single line of JavaScript. That's the magic of Phoenix LiveView!

LiveView allows you to render dynamic, real-time user interfaces entirely on the server, using WebSockets for communication. It brings the power of server-side Elixir directly to your frontend interactions.

LiveView's Core: `mount` & `render`

Every Phoenix LiveView module typically defines at least two key functions:

mount/3: This function is called when the LiveView is first initialized. It's used to set up the initial state (known as 'assigns') of your LiveView.
render/1: Takes the current assigns and returns a special HEEx template (using the ~H sigil) to generate the HTML. This function is called automatically whenever the LiveView's state changes.

Adding Interaction: Events

LiveView handles user events (like clicks or form submissions) by sending messages over the WebSocket back to the server. You attach special phx- attributes to your HTML elements to trigger these events.

phx-click="event_name": Triggers a server-side event when the element is clicked.
handle_event/3: A callback function in your LiveView module that receives and processes these events, updating the LiveView's state (assigns).

Simple LiveView Counter Concept

Here's a simplified look at a LiveView that implements a basic counter. Notice how handle_event updates the @count assign, which automatically re-renders the template.

defmodule MyAppWeb.CounterLive do
  use Phoenix.LiveView, layout: {MyAppWeb.LayoutView, :live}

  def mount(_params, _session, socket) do
    {:ok, assign(socket, :count, 0)}
  end

  def render(assigns) do
    ~H"""
    <h1>Count: <%= @count %></h1>
    <button phx-click="increment">Increment</button>
    """
  end

  def handle_event("increment", _value, socket) do
    {:noreply, update(socket, :count, &(&1 + 1))}
  end
end

Check Your Understanding

In Phoenix, what is the primary purpose of a View module?

Recap: Views, Templates, LiveView

You've learned how Phoenix uses Views to prepare data and Templates (EEx/HEEx) to render dynamic HTML. We also introduced Phoenix LiveView, a powerful tool for building interactive UIs with Elixir, minimizing the need for client-side JavaScript.

Understanding these components is key to building dynamic and engaging web applications with Phoenix. Next, you might explore more advanced LiveView features or dive into data persistence with Ecto!

Häufig gestellte Fragen

Ist die Lektion „Views, Templates und LiveView-Grundlagen“ kostenlos?

Ja — der vollständige Text von „Views, Templates und LiveView-Grundlagen“ 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 „Views, Templates und LiveView-Grundlagen“?

Rendern Sie dynamische Inhalte mit Phoenix-Views und -Templates und erhalten Sie eine Einführung in die Möglichkeiten von Phoenix LiveView. 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 „Views, Templates und LiveView-Grundlagen“?

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

Phoenix-Projekt einrichten und strukturieren
Routing, Controller und Plugs
Views, Templates und LiveView-Grundlagen
Echtzeitfunktionen mit Phoenix Channels

← Zurück zu Elixir & Phoenix: Scalable Backend Development