Funzioni, moduli e pipelining
Impari a definire funzioni, organizzare il codice in moduli e usare l’operatore pipe per trasformare i dati in modo chiaro.
Funzioni, moduli e pipelining è una lezione Elixir & Phoenix: Scalable Backend Development gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Elixir & Phoenix: Scalable Backend Development, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Elixir & Phoenix: Scalable Backend Development include 4 lezioni in totale.
Introduzione alle funzioni di Elixir
In Elixir, le funzioni sono gli elementi costitutivi dei programmi. Ricevono input, eseguono operazioni e restituiscono output.
Le funzioni di Elixir sono progettate per essere pure: non modificano i dati al di fuori del proprio ambito e producono sempre lo stesso output a parità di input. Questo rende il codice prevedibile e più facile da comprendere.
Definire funzioni pubbliche
Le funzioni pubbliche si definiscono usando la parola chiave def. È possibile chiamarle da qualsiasi punto dell'applicazione, purché facciano parte di un modulo.
Creiamo una semplice funzione che somma due numeri:
defmodule MathOperations do
def add(a, b) do
a + b
end
end
IO.puts "Sum of 5 and 3: #{MathOperations.add(5, 3)}"Definire funzioni private
A volte servono funzioni di supporto da utilizzare solo internamente a un modulo. Per queste funzioni si usa la parola chiave defp.
Le funzioni private non possono essere chiamate direttamente dall'esterno del modulo in cui sono definite. Questo aiuta a incapsulare la logica.
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.Arity e clausole delle funzioni
Con arity si indica il numero di argomenti accettati da una funzione. Elixir consente di definire più clausole con lo stesso nome ma con arity diverse o pattern diversi per gli argomenti.
Questo permette di usare un potente pattern matching (presentato in una lezione precedente) per gestire in modo chiaro scenari diversi all'interno di un'unica definizione di funzione.
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")Funzioni anonime
Le funzioni anonime (dette anche lambda) sono funzioni prive di nome. Vengono spesso usate quando si deve passare una funzione come argomento a un'altra funzione o per operazioni brevi e occasionali.
Si definiscono usando la parola chiave fn.
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)}"Organizzare il codice con i moduli
In Elixir, i moduli sono contenitori per organizzare funzioni e dati correlati. Aiutano a evitare conflitti tra nomi e rendono il codice più strutturato e manutenibile.
Un modulo si definisce usando la parola chiave defmodule. È prassi comune iniziare i nomi dei moduli con una lettera maiuscola, secondo le convenzioni di denominazione di Elixir.
Creare il primo modulo
Inseriamo la funzione add in un modulo chiamato Calculator. In questo modo è chiaro che la funzione add fa parte di un insieme di operazioni relative a una calcolatrice.
defmodule Calculator do
def add(a, b) do
a + b
end
def subtract(a, b) do
a - b
end
end
IO.puts "Module defined!"Chiamare le funzioni di un modulo
Per chiamare una funzione definita all'interno di un modulo, si usa il nome del modulo, seguito da un punto (.) e quindi dal nome della funzione con i relativi argomenti.
Questa denominazione esplicita aiuta a capire da dove proviene una funzione.
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)}"Introduzione all'operatore pipe `|>`
L'operatore pipe |> è una delle funzionalità più apprezzate di Elixir. Rende incredibilmente leggibili le sequenze di chiamate a funzioni, facendo passare i dati da una funzione alla successiva.
Lo si può considerare come il modo di prendere il risultato dell'espressione a sinistra e passarlo come primo argomento alla chiamata di funzione a destra.
Il pipelining in azione
Invece di annidare le chiamate come function_c(function_b(function_a(data))), l'operatore pipe consente di scriverle come data |> function_a() |> function_b() |> function_c().
Il codice si legge come una sequenza di passaggi, rendendo molto più chiare le trasformazioni complesse dei dati.
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}"Verifichi la Sua comprensione
Quali delle seguenti affermazioni sulle funzioni, sui moduli e sull'operatore pipe di Elixir sono vere?
Riepilogo: funzioni, moduli e pipe
Ottimo lavoro! In questa lezione ha appreso gli elementi essenziali per organizzare e trasformare i dati in Elixir:
- Come definire funzioni pubbliche (`def`) e private (`defp`).
- L'importanza dei moduli (`defmodule`) per strutturare il codice.
- Come l'operatore pipe (`|>`) migliori notevolmente la leggibilità delle trasformazioni sequenziali dei dati.
Questi concetti sono fondamentali per scrivere applicazioni Elixir chiare, manutenibili e funzionali. Continui a esercitarsi!
Impara Elixir con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 12
- Lezioni
- 48
Domande Frequenti
La lezione «Funzioni, moduli e pipelining» è gratuita?
Sì — il testo completo di «Funzioni, moduli e pipelining» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Elixir & Phoenix: Scalable Backend Development, passa a CoddyKit PRO. Il corso Elixir & Phoenix: Scalable Backend Development include 4 lezioni in totale.
Cosa imparerò in «Funzioni, moduli e pipelining»?
Impari a definire funzioni, organizzare il codice in moduli e usare l’operatore pipe per trasformare i dati in modo chiaro. Eserciti Elixir & Phoenix: Scalable Backend Development con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Elixir & Phoenix: Scalable Backend Development?
Non è richiesta alcuna esperienza precedente. Elixir & Phoenix: Scalable Backend Development su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.
Quanto tempo richiede la lezione «Funzioni, moduli e pipelining»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Elixir & Phoenix: Scalable Backend Development?
Sì. Ogni lezione Elixir & Phoenix: Scalable Backend Development include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Funzioni, moduli e pipelining
- Utilizzo delle collezioni enumerabili
- Ricorsione e funzioni di ordine superiore
- Valutazione lazy con il modulo Stream