基本数据类型与运算符
探索原子、列表、元组和映射等 Elixir 基本数据类型，并学习使用基本运算符。
基本数据类型与运算符 是 CoddyKit 上的免费 Elixir & Phoenix: Scalable Backend Development 课时。 这是第 2 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 Elixir & Phoenix: Scalable Backend Development 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Elixir & Phoenix: Scalable Backend Development 课程共包含 4 节课。
本课时的部分内容尚未翻译，以英文显示。
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.
常见问题解答
「基本数据类型与运算符」课时是免费的吗？
是的 — 「基本数据类型与运算符」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Elixir & Phoenix: Scalable Backend Development 课程的其余内容，请升级到 CoddyKit PRO。 Elixir & Phoenix: Scalable Backend Development 课程共包含 4 节课。
「基本数据类型与运算符」这节课中我会学到什么？
探索原子、列表、元组和映射等 Elixir 基本数据类型，并学习使用基本运算符。 你通过在浏览器中直接运行的动手代码来练习 Elixir & Phoenix: Scalable Backend Development，全天候 AI 导师会在你学习这节课的过程中回答你的问题。
学习 Elixir & Phoenix: Scalable Backend Development 需要有经验吗？
无需任何先前经验。CoddyKit 上的 Elixir & Phoenix: Scalable Backend Development 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 2 节课，共 4 节。
「基本数据类型与运算符」课时需要多长时间？
大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。
我能在这节 Elixir & Phoenix: Scalable Backend Development 课中编写并运行代码吗？
能。每节 Elixir & Phoenix: Scalable Backend Development 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。