İşlevler, Modüller ve Boru Hattı Kullanımı
İşlev tanımlamayı, kodu modüller hâlinde düzenlemeyi ve açık veri dönüşümleri için pipe işleçini kullanmayı öğrenin.
İşlevler, Modüller ve Boru Hattı Kullanımı, CoddyKit'te ücretsiz bir Elixir & Phoenix: Scalable Backend Development dersidir. Bu, 4 dersinin 1. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Elixir & Phoenix: Scalable Backend Development öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Elixir & Phoenix: Scalable Backend Development kursu toplamda 4 dersten oluşur.
Bu dersin bazı bölümleri henüz çevrilmemiş olup İngilizce olarak gösterilmektedir.
Introduction to Elixir Functions
In Elixir, functions are the building blocks of your programs. They take inputs, perform operations, and return outputs.
Elixir functions are designed to be pure: they don't change data outside their scope and always produce the same output for the same input. This makes your code predictable and easier to reason about.
Defining Public Functions
You define public functions using the def keyword. These functions can be called from anywhere within your application, provided they are part of a module.
Let's create a simple function that adds two numbers:
defmodule MathOperations do
def add(a, b) do
a + b
end
end
IO.puts "Sum of 5 and 3: #{MathOperations.add(5, 3)}"Defining Private Functions
Sometimes you need helper functions that should only be used internally within a module. For these, you use the defp keyword.
Private functions cannot be called directly from outside their defining module. This helps encapsulate logic.
defmodule SecretOperations do
defp secret_add(a, b) do
a + b + 10 # A 'secret' addition
end
def public_operation(x, y) do
secret_add(x, y)
end
end
IO.puts "Result of public operation: #{SecretOperations.public_operation(2, 3)}"
# SecretOperations.secret_add(1, 2) would cause an error if called directly outside the module.Function Arity and Clauses
Arity refers to the number of arguments a function takes. Elixir allows you to define multiple function clauses with the same name but different arities or different patterns for arguments.
This enables powerful pattern matching (covered in a previous lesson) to handle different scenarios cleanly within a single function definition.
defmodule Greeter do
def greet("Alice"), do: "Hello, Alice!"
def greet(name), do: "Hi there, #{name}!"
end
IO.puts Greeter.greet("Alice")
IO.puts Greeter.greet("Bob")Anonymous Functions
Anonymous functions (also called lambdas) are functions without a name. They are often used when you need to pass a function as an argument to another function, or for short, one-off operations.
You define them using the fn keyword.
adder = fn a, b -> a + b end
multiplier = fn x, y -> x * y end
IO.puts "Anonymous add: #{adder.(10, 20)}"
IO.puts "Anonymous multiply: #{multiplier.(4, 5)}"Organizing Code with Modules
Modules in Elixir are containers for organizing related functions and data. They help prevent naming conflicts and make your code more structured and maintainable.
You define a module using the defmodule keyword. It's common practice for module names to start with an uppercase letter, following Elixir's naming conventions.
Creating Your First Module
Let's put our add function inside a module called Calculator. This makes it clear that the add function is part of a set of calculator-related operations.
defmodule Calculator do
def add(a, b) do
a + b
end
def subtract(a, b) do
a - b
end
end
IO.puts "Module defined!"Calling Module Functions
To call a function defined within a module, you use the module's name, followed by a dot (.), and then the function name with its arguments.
This explicit naming helps you understand where a function comes from.
defmodule Calculator do
def add(a, b), do: a + b
def subtract(a, b), do: a - b
end
IO.puts "10 + 5 = #{Calculator.add(10, 5)}"
IO.puts "10 - 5 = #{Calculator.subtract(10, 5)}"Introducing the Pipe Operator `|>`
The pipe operator |> is one of Elixir's most beloved features. It makes sequences of function calls incredibly readable, flowing data from one function to the next.
Think of it as taking the result of the expression on the left and passing it as the first argument to the function call on the right.
Pipelining in Action
Instead of nesting function calls like function_c(function_b(function_a(data))), the pipe operator lets you write it as data |> function_a() |> function_b() |> function_c().
This reads like a series of steps, making complex data transformations much clearer.
defmodule DataProcessor do
def double(x), do: x * 2
def add_five(x), do: x + 5
def to_string(x), do: to_string(x)
end
result = 10
|> DataProcessor.double()
|> DataProcessor.add_five()
|> DataProcessor.to_string()
IO.puts "Processed result: #{result}"Check Your Understanding
Which of the following statements about Elixir functions, modules, and the pipe operator are true?
Recap: Functions, Modules & Pipes
Great job! In this lesson, you learned the essentials of organizing and transforming data in Elixir:
- How to define public (`def`) and private (`defp`) functions.
- The importance of modules (`defmodule`) for structuring your code.
- How the pipe operator (`|>`) dramatically improves readability for sequential data transformations.
These concepts are fundamental to writing clear, maintainable, and functional Elixir applications. Keep practicing!
Sıkça Sorulan Sorular
“İşlevler, Modüller ve Boru Hattı Kullanımı” dersi ücretsiz mi?
Evet — “İşlevler, Modüller ve Boru Hattı Kullanımı” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Elixir & Phoenix: Scalable Backend Development kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Elixir & Phoenix: Scalable Backend Development kursu toplamda 4 dersten oluşur.
“İşlevler, Modüller ve Boru Hattı Kullanımı” dersinde ne öğreneceğim?
İşlev tanımlamayı, kodu modüller hâlinde düzenlemeyi ve açık veri dönüşümleri için pipe işleçini kullanmayı öğrenin. Elixir & Phoenix: Scalable Backend Development ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.
Elixir & Phoenix: Scalable Backend Development öğrenmeye başlamak için deneyim gerekli mi?
Önceden deneyim gerekmez. CoddyKit'te Elixir & Phoenix: Scalable Backend Development, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 1. dersidir.
“İşlevler, Modüller ve Boru Hattı Kullanımı” dersi ne kadar sürer?
Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.
Bu Elixir & Phoenix: Scalable Backend Development dersinde kod yazıp çalıştırabilir miyim?
Evet. Her Elixir & Phoenix: Scalable Backend Development dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.
Bu kursun tüm dersleri
- İşlevler, Modüller ve Boru Hattı Kullanımı
- Sayılabilir Koleksiyonlarla Çalışma
- Özyineleme ve Üst Düzey İşlevler
- Stream Modülüyle Tembel Değerlendirme