0Pricing
Elixir & Phoenix: Scalable Backend Development · レッスン

関数、モジュール、パイプライン

関数の定義、モジュールへのコード整理、パイプ演算子による明快なデータ変換を学びます。

「関数、モジュール、パイプライン」はCoddyKit上の無料Elixir & Phoenix: Scalable Backend Developmentレッスンです。 これはレッスン1/4です。 下記で完全なレッスンを無料で読むことができます。その後、ブラウザ内の組み込みコードエディタと24時間対応のAIチューターでハンズオン演習できます。 これはElixir & Phoenix: Scalable Backend Development学習パスの一部であり、ウェブとCoddyKitアプリ全体で進捗が同期されます。 Elixir & Phoenix: Scalable Backend Developmentコースには全4レッスンが含まれています。

このレッスンの一部はまだ翻訳されておらず、英語で表示されています。

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!

よくある質問

「関数、モジュール、パイプライン」レッスンは無料ですか？

はい。「関数、モジュール、パイプライン」の完全なテキストはこのウェブで無料で読めます。インタラクティブに演習し（組み込みコードエディタと24時間対応のAIチューター）、Elixir & Phoenix: Scalable Backend Developmentコースの残りをアンロックするには、CoddyKit PROにアップグレードしてください。 Elixir & Phoenix: Scalable Backend Developmentコースには全4レッスンが含まれています。

「関数、モジュール、パイプライン」で何を学びますか？

関数の定義、モジュールへのコード整理、パイプ演算子による明快なデータ変換を学びます。 ブラウザで直接実行するハンズオンコードでElixir & Phoenix: Scalable Backend Developmentを演習し、24時間対応のAIチューターがレッスンを進める中での質問に答えます。

Elixir & Phoenix: Scalable Backend Developmentを始めるのに経験は必要ですか？

事前経験は必要ありません。CoddyKitのElixir & Phoenix: Scalable Backend Developmentは初級者から上級者向けに構成されているため、ここから始めるか最初から始めて、自分のペースで進むことができます。 これはレッスン1/4です。

「関数、モジュール、パイプライン」レッスンにはどのくらい時間がかかりますか？

ほとんどのCoddyKitレッスンは約5～10分かかります。各レッスンはコンパクトでインタラクティブなので、着実に進歩し、ウェブとアプリ全体で正確に前回の場所から再開できます。

このElixir & Phoenix: Scalable Backend Developmentレッスンでコードを書いて実行できますか？

はい。すべてのElixir & Phoenix: Scalable Backend Developmentレッスンに組み込みコードエディタが含まれているため、ブラウザでリアルコードを書いて実行し、即座のAIフィードバックを取得できます。ローカル設定は不要です。

このコースのすべてのレッスン

  1. 関数、モジュール、パイプライン
  2. Enumerableコレクションの操作
  3. 再帰と高階関数
  4. Streamモジュールによる遅延評価
← Elixir & Phoenix: Scalable Backend Developmentに戻る