0Pricing
Elixir & Phoenix: Scalable Backend Development · Lektion

Grundlegende Datentypen und Operatoren

Erkunden Sie grundlegende Elixir-Datentypen wie Atome, Listen, Tupel und Maps und lernen Sie, grundlegende Operatoren zu verwenden.

Grundlegende Datentypen und Operatoren ist eine kostenlose Elixir & Phoenix: Scalable Backend Development-Lektion auf CoddyKit. Dies ist Lektion 2 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.

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.

Häufig gestellte Fragen

Ist die Lektion „Grundlegende Datentypen und Operatoren“ kostenlos?

Ja — der vollständige Text von „Grundlegende Datentypen und Operatoren“ 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 „Grundlegende Datentypen und Operatoren“?

Erkunden Sie grundlegende Elixir-Datentypen wie Atome, Listen, Tupel und Maps und lernen Sie, grundlegende Operatoren zu verwenden. 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 2 von 4.

Wie lange dauert die Lektion „Grundlegende Datentypen und Operatoren“?

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

  1. Einführung in die Sprache Elixir
  2. Grundlegende Datentypen und Operatoren
  3. Pattern Matching und Kontrollfluss
  4. Strings, Binärdaten und Sigils in Elixir
← Zurück zu Elixir & Phoenix: Scalable Backend Development