0Pricing
Elixir & Phoenix: Scalable Backend Development · Leçon

Types de données et opérateurs de base

Découvrez les types de données fondamentaux d’Elixir, comme les atomes, les listes, les tuples et les maps, et apprenez à utiliser les opérateurs de base.

Types de données et opérateurs de base est une leçon Elixir & Phoenix: Scalable Backend Development gratuite sur CoddyKit. Ceci est la leçon 2 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.

Data Types & Operators Intro

Every program rests on data types (what you can store) and operators (the symbols that act on it). Let us meet Elixir core.

Numbers: Integers & Floats

Elixir has two number types: integers like 42 and floats like 3.14. Standard math works on both, as this snippet shows.

defmodule NumbersDemo do
  def run() do
    integer_num = 42
    float_num = 3.14159

    IO.puts "Integer: #{integer_num}"
    IO.puts "Float: #{float_num}"
    IO.puts "Sum: #{integer_num + 10.0}"
  end
end

NumbersDemo.run()

Booleans: True, False, Nil

Truth values are true and false. Note nil for "no value" — and that both false and nil are falsy; everything else is truthy.

defmodule BooleansDemo do
  def run() do
    is_active = true
    has_error = false
    no_value = nil

    IO.puts "Is Active? #{is_active}"
    IO.puts "Has Error? #{has_error}"
    IO.puts "No Value? #{no_value}"

    if no_value do
      IO.puts "This won't print."
    else
      IO.puts "nil is falsy!"
    end
  end
end

BooleansDemo.run()

Atoms: Unique Identifiers

An atom is a constant whose name is its own value, like :ok. They are fast to compare and ideal as status codes and map keys.

defmodule AtomsDemo do
  def run() do
    status = :ok
    type = :user

    IO.puts "Current status: #{status}"
    IO.puts "User type: #{type}"

    if status == :ok do
      IO.puts "Operation successful!"
    end
  end
end

AtomsDemo.run()

Strings: Text Data

An Elixir string is a UTF-8 binary in double quotes, so it handles any language. Join strings with the <> operator.

defmodule StringsDemo do
  def run() do
    greeting = "Hello"
    name = "CoddyKit"
    message = greeting <> ", " <> name <> "!"

    IO.puts message
    IO.puts "String length: " <> to_string(String.length(message))
  end
end

StringsDemo.run()

Lists: Ordered Collections

A list is an ordered, square-bracketed collection that can mix types. It is the functional workhorse, fast to prepend to at the head.

defmodule ListsDemo do
  def run() do
    my_list = [1, 2, 3, :hello, "world"]
    another_list = [4, 5]

    IO.puts "Original list: " <> inspect(my_list)
    IO.puts "Concatenated list: " <> inspect(my_list ++ another_list)
    IO.puts "Head of list: " <> inspect(hd(my_list))
    IO.puts "Tail of list: " <> inspect(tl(my_list))
  end
end

ListsDemo.run()

Tuples: Fixed-Size Collections

A tuple is a fixed-size collection in curly braces. You see it everywhere for grouped returns like {:ok, result} or {:error, reason}.

defmodule TuplesDemo do
  def run() do
    person_info = {"Alice", 30, :female}
    result_tuple = {:ok, "Data fetched"}

    IO.puts "Person: " <> inspect(person_info)
    IO.puts "Result: " <> inspect(result_tuple)

    # Accessing elements (0-indexed)
    IO.puts "Name: " <> elem(person_info, 0)
  end
end

TuplesDemo.run()

Maps: Key-Value Pairs

A map holds key-value pairs in %{} — usually atom keys for speed. Reach for it whenever you model structured records or config.

defmodule MapsDemo do
  def run() do
    user = %{name: "Bob", age: 25, city: "New York"}

    IO.puts "User: " <> inspect(user)
    IO.puts "User's name: #{user.name}"

    # Updating a map
    updated_user = %{user | age: 26}
    IO.puts "Updated age: #{updated_user.age}"
  end
end

MapsDemo.run()

Arithmetic Operators

Elixir gives you the usual arithmetic operators, plus div and rem for integers. Heads up: / always returns a float.

defmodule ArithmeticDemo do
  def run() do
    IO.puts "5 + 3 = #{5 + 3}"
    IO.puts "10 - 4 = #{10 - 4}"
    IO.puts "6 * 7 = #{6 * 7}"
    IO.puts "10 / 3 = #{10 / 3}"  # Float division
    IO.puts "10 div 3 = #{10 div 3}" # Integer division
    IO.puts "10 rem 3 = #{10 rem 3}" # Remainder
  end
end

ArithmeticDemo.run()

Comparison Operators

Comparison operators return a boolean. Use == for value equality, but === when type matters too — 1 === 1.0 is false.

defmodule ComparisonDemo do
  def run() do
    IO.puts "5 == 5: #{5 == 5}"
    IO.puts "5 != 10: #{5 != 10}"
    IO.puts "5 < 10: #{5 < 10}"
    IO.puts "10 >= 10: #{10 >= 10}"
    IO.puts "1 == 1.0: #{1 == 1.0}" # True (value equality)
    IO.puts "1 === 1.0: #{1 === 1.0}" # False (type strictness)
  end
end

ComparisonDemo.run()

Check Your Understanding

Consider the following Elixir code snippet:

result = 10 div 3
status = :ok
message = "Value is #{result}"
comparison = (result > 3) == true

IO.puts "#{message}, Status: #{status}, Comparison: #{comparison}"

What will be the final output of this code?

Check Your Understanding (Revised)

Consider the following Elixir code snippet:

result = 10 div 3
status = :ok
message = "Value is #{result}"
comparison = (result > 3)

IO.puts "#{message}, Status: #{status}, Comparison: #{comparison}"

What will be the final output of this code?

Recap: Data Types & Operators

Recap: integers and floats, booleans plus nil, atoms, strings, lists, tuples, maps, and the operators that drive them. These are your Elixir foundation.

Questions Fréquemment Posées

La leçon « Types de données et opérateurs de base » est-elle gratuite ?

Oui — le texte complet de « Types de données et opérateurs de base » 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 « Types de données et opérateurs de base » ?

Découvrez les types de données fondamentaux d’Elixir, comme les atomes, les listes, les tuples et les maps, et apprenez à utiliser les opérateurs de base. 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 2 sur 4.

Combien de temps prend la leçon « Types de données et opérateurs de base » ?

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

  1. Introduction au langage Elixir
  2. Types de données et opérateurs de base
  3. Correspondance de motifs et flux de contrôle
  4. Chaînes, binaires et sigils en Elixir
← Retour à Elixir & Phoenix: Scalable Backend Development