Elixir & Phoenix: Scalable Backend Development · Leçon

Vues, modèles et bases de LiveView

Affichez du contenu dynamique avec les vues et les modèles Phoenix, puis découvrez la puissance de Phoenix LiveView.

Vues, modèles et bases de LiveView est une leçon Elixir & Phoenix: Scalable Backend Development gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Elixir & Phoenix: Scalable Backend Development, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Elixir & Phoenix: Scalable Backend Development comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

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!

Questions Fréquemment Posées

La leçon « Vues, modèles et bases de LiveView » est-elle gratuite ?

Oui — le texte complet de « Vues, modèles et bases de LiveView » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Elixir & Phoenix: Scalable Backend Development, passe à CoddyKit PRO. Le cours Elixir & Phoenix: Scalable Backend Development comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Vues, modèles et bases de LiveView » ?

Affichez du contenu dynamique avec les vues et les modèles Phoenix, puis découvrez la puissance de Phoenix LiveView. Tu pratiques Elixir & Phoenix: Scalable Backend Development avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Elixir & Phoenix: Scalable Backend Development ?

Aucune expérience préalable n'est requise. Elixir & Phoenix: Scalable Backend Development sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Vues, modèles et bases de LiveView » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Elixir & Phoenix: Scalable Backend Development ?

Oui. Chaque leçon Elixir & Phoenix: Scalable Backend Development inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Configuration et structure d’un projet Phoenix
Routage, contrôleurs et Plugs
Vues, modèles et bases de LiveView
Fonctionnalités en temps réel avec les Channels Phoenix

← Retour à Elixir & Phoenix: Scalable Backend Development