Elixir & Phoenix: Scalable Backend Development · Pelajaran

Pencocokan Pola dan Alur Kendali

Kuasai fitur pencocokan pola Elixir yang kuat serta konstruksi alur kendali penting seperti `if`, `case`, dan `cond`.

Pelajaran 3 dari 411 langkah

Pencocokan Pola dan Alur Kendali adalah pelajaran Elixir & Phoenix: Scalable Backend Development gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Elixir & Phoenix: Scalable Backend Development, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Elixir & Phoenix: Scalable Backend Development mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

Intro to Pattern Matching

Pattern matching is the heart of Elixir. Here = is a match operator, not assignment — it makes the left side equal the right.

Basic Variable Matching

The simplest match binds an unbound variable to a value. If it is already bound, Elixir instead checks that the two sides actually match.

defmodule BasicMatchDemo do
  def run do
    # 'a' is unbound, so it's assigned 10
    a = 10
    IO.puts "a is: #{a}"

    # 'b' is unbound, so it's assigned 20
    b = 20
    IO.puts "b is: #{b}"

    # This matches 'a' to the value of 'b' (20)
    # 'a' is re-bound to 20
    a = b
    IO.puts "After a = b, a is: #{a}"
  end
end

BasicMatchDemo.run()

Matching with Literals

Put a literal on the left and the match becomes an assertion: it succeeds only if both sides are equal, otherwise it raises. Handy for validation.

defmodule LiteralMatchDemo do
  def run do
    # This matches because 1 is equal to 1
    1 = 1
    IO.puts "1 = 1 matched successfully!"

    # This matches because 'hello' is equal to 'hello'
    "hello" = "hello"
    IO.puts "'hello' = 'hello' matched successfully!"

    # If you uncomment the line below, it will cause a MatchError
    # 1 = 2
    # IO.puts "This line would not be reached if 1 = 2 failed"
  end
end

LiteralMatchDemo.run()

Deconstructing Tuples

Matching shines on tuples — deconstruct them straight into variables, which is exactly how you unpack {:ok, value} results.

defmodule TupleMatchDemo do
  def run do
    # Match a tuple to extract its elements
    {:person, name, age} = {:person, "Alice", 30}
    IO.puts "Name: #{name}, Age: #{age}"

    # Match a common result tuple
    {:ok, data} = {:ok, "User fetched successfully"}
    IO.puts "Status: ok, Data: #{data}"

    # If you uncomment the line below, it will cause a MatchError
    # {:error, reason} = {:ok, "Success"}
  end
end

TupleMatchDemo.run()

Deconstructing Lists

Deconstruct lists with the [head | tail] pattern: head is the first element, tail the rest. Use _ for parts you do not care about.

defmodule ListMatchDemo do
  def run do
    list = [1, 2, 3, 4, 5]

    # Match head and tail
    [head | tail] = list
    IO.puts "Head: #{head}, Tail: #{inspect tail}"

    # Match specific elements
    [first, second, third | _rest] = list
    IO.puts "First: #{first}, Second: #{second}, Third: #{third}"

    # Match an empty list
    [] = []
    IO.puts "Empty list matched!"
  end
end

ListMatchDemo.run()

The Pin Operator (^)

The pin operator ^ says "do not rebind — match against this variable's current value" instead. Great for asserting equality.

defmodule PinOperatorDemo do
  def run do
    value_a = 10
    value_b = 10

    # This uses the current value of value_a (10) to match against value_b
    # It succeeds because 10 matches 10
    ^value_a = value_b
    IO.puts "Match successful: value_a = #{value_a}, value_b = #{value_b}"

    value_c = 5

    # If you uncomment the line below, it will cause a MatchError
    # because ^value_a (10) is not equal to value_c (5)
    # ^value_a = value_c
    # IO.puts "This line would not be reached if ^value_a = value_c failed"
  end
end

PinOperatorDemo.run()

Simple Conditionals: if/unless

For simple branches use if and its mirror unless, each with an optional else. The cleanest tool for one true/false condition.

defmodule IfUnlessDemo do
  def run do
    number = 7

    if number > 5 do
      IO.puts "Number is greater than 5"
    else
      IO.puts "Number is 5 or less"
    end

    unless rem(number, 2) == 0 do
      IO.puts "Number is odd"
    else
      IO.puts "Number is even"
    end
  end
end

IfUnlessDemo.run()

Handling Multiple Patterns with case

The case expression matches one value against several patterns and runs the first that fits — pattern matching as control flow.

defmodule CaseExpressionDemo do
  def run do
    status = {:ok, "Data loaded"}

    case status do
      {:ok, message} ->
        IO.puts "Success: #{message}"
      {:error, reason} ->
        IO.puts "Failed: #{reason}"
      _ ->
        IO.puts "Unknown status"
    end

    # Another example with a simple value
    grade = "B"
    case grade do
      "A" -> IO.puts "Excellent!"
      "B" -> IO.puts "Good job!"
      _ -> IO.puts "Keep trying!"
    end
  end
end

CaseExpressionDemo.run()

Multiple Conditions with cond

When you have many boolean checks (an if/else-if chain elsewhere), cond runs the first clause whose condition is true.

defmodule CondExpressionDemo do
  def run do
    score = 85

    cond do
      score >= 90 -> IO.puts "Grade: A"
      score >= 80 -> IO.puts "Grade: B"
      score >= 70 -> IO.puts "Grade: C"
      true -> IO.puts "Grade: D or lower" # The 'true' clause acts as a catch-all
    end

    temperature = 25
    cond do
      temperature > 30 -> IO.puts "It's hot!"
      temperature > 20 -> IO.puts "It's warm."
      true -> IO.puts "It's cool."
    end
  end
end

CondExpressionDemo.run()

Pattern Matching Challenge

Consider the following Elixir code snippet:

data = ["apple", {:fruit, "banana"}, "cherry"]
[first, {:fruit, second}, _] = data

What will be the final values of the variables first and second after this code executes?

Recap: Pattern Matching & Control

Recap: = matches, you deconstruct tuples and lists, ^ pins a value, and if/case/cond drive your control flow.

Gratis untuk memulai

Belajar Elixir dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus
12
Pelajaran
48

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pencocokan Pola dan Alur Kendali” gratis?

Ya — teks lengkap “Pencocokan Pola dan Alur Kendali” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Elixir & Phoenix: Scalable Backend Development, upgrade ke CoddyKit PRO. Kursus Elixir & Phoenix: Scalable Backend Development mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Pencocokan Pola dan Alur Kendali”?

Kuasai fitur pencocokan pola Elixir yang kuat serta konstruksi alur kendali penting seperti `if`, `case`, dan `cond`. Kamu berlatih Elixir & Phoenix: Scalable Backend Development dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Elixir & Phoenix: Scalable Backend Development?

Tidak diperlukan pengalaman sebelumnya. Elixir & Phoenix: Scalable Backend Development di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “Pencocokan Pola dan Alur Kendali” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Elixir & Phoenix: Scalable Backend Development ini?

Ya. Setiap pelajaran Elixir & Phoenix: Scalable Backend Development menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Pengantar Bahasa Elixir
  2. Tipe Data dan Operator Dasar
  3. Pencocokan Pola dan Alur Kendali
  4. String, Biner & Sigil di Elixir
← Kembali ke Elixir & Phoenix: Scalable Backend Development