Elixir & Phoenix: Scalable Backend Development · Aula

Visões, Modelos e Fundamentos do LiveView

Renderize conteúdo dinâmico usando visões e modelos do Phoenix e tenha uma introdução ao poder do Phoenix LiveView.

Visões, Modelos e Fundamentos do LiveView é uma aula grátis de Elixir & Phoenix: Scalable Backend Development no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Elixir & Phoenix: Scalable Backend Development, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Elixir & Phoenix: Scalable Backend Development inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

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!

Perguntas Frequentes

A aula “Visões, Modelos e Fundamentos do LiveView” é grátis?

Sim — o texto completo de “Visões, Modelos e Fundamentos do LiveView” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Elixir & Phoenix: Scalable Backend Development, atualize para CoddyKit PRO. O curso de Elixir & Phoenix: Scalable Backend Development inclui 4 aulas no total.

O que vou aprender em “Visões, Modelos e Fundamentos do LiveView”?

Renderize conteúdo dinâmico usando visões e modelos do Phoenix e tenha uma introdução ao poder do Phoenix LiveView. Você pratica Elixir & Phoenix: Scalable Backend Development com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Elixir & Phoenix: Scalable Backend Development?

Nenhuma experiência prévia é necessária. Elixir & Phoenix: Scalable Backend Development no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Visões, Modelos e Fundamentos do LiveView”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Elixir & Phoenix: Scalable Backend Development?

Sim. Cada aula de Elixir & Phoenix: Scalable Backend Development inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Configuração e Estrutura de Projetos Phoenix
Roteamento, Controladores e Plugs
Visões, Modelos e Fundamentos do LiveView
Funcionalidades em Tempo Real com Phoenix Channels

← Voltar para Elixir & Phoenix: Scalable Backend Development