0Pricing
Frontend Academy · Lezione

provide() e inject() per la dependency injection

Fornire valori in un componente antenato e iniettarli in profondità nell’albero, evitando il prop drilling senza una libreria completa di gestione dello stato

provide() e inject() per la dependency injection è una lezione Frontend Academy 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 Frontend Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Frontend Academy include 4 lezioni in totale.

Il problema del prop drilling

A volte i dati si trovano in un componente antenato e devono raggiungere un discendente molto annidato. Passarli attraverso ogni componente intermedio (prop drilling) è laborioso e fragile.

provide() — Dichiarare un valore

Un antenato chiama provide(key, value) in setup(). Il valore diventa disponibile a tutti i discendenti.

<!-- ParentComponent.vue -->
<script setup>
import { provide, ref } from 'vue';

const theme = ref('dark');
provide('theme', theme);
</script>

inject() — Consumare un valore

Qualsiasi discendente può chiamare inject(key) per leggerlo.

<!-- DeepChild.vue -->
<script setup>
import { inject } from 'vue';

const theme = inject('theme');
</script>

<template>
  <div :class="theme">Theme is: {{ theme }}</div>
</template>

Reattività con ref/reactive

Se fornisce un ref o un oggetto reactive, i discendenti ricevono un valore reattivo: gli aggiornamenti vengono propagati automaticamente.

// Parent
const user = reactive({ name: 'Alice', role: 'admin' });
provide('user', user);

// Anywhere descendant
const user = inject('user');
user.role; // 'admin' — reactive

Chiavi Symbol per evitare collisioni

Le chiavi stringa rischiano di entrare in conflitto nelle app di grandi dimensioni. I Symbol garantiscono l'unicità: li definisca in un file condiviso.

// keys.ts
export const ThemeKey = Symbol('theme');
export const UserKey  = Symbol('user');

// Parent
provide(ThemeKey, ref('dark'));
// Child
const theme = inject(ThemeKey);

Supporto a TypeScript

Utilizzi InjectionKey<T> per garantire la sicurezza dei tipi su entrambi i lati.

import type { InjectionKey, Ref } from 'vue';

export const ThemeKey: InjectionKey<Ref<string>> = Symbol('theme');

// Provider:
provide(ThemeKey, ref('dark'));

// Consumer (type-checked):
const theme = inject(ThemeKey); // Ref<string> | undefined

Valori predefiniti

Se nessun antenato fornisce la chiave, inject restituisce undefined, a meno che non si passi un valore predefinito.

const theme = inject('theme', 'light'); // default if missing
const lazy  = inject('user', () => createDefaultUser(), true); // factory

Provide in sola lettura

Per impedire ai discendenti di modificare lo stato condiviso, lo avvolga con readonly().

import { readonly } from 'vue';

const user = reactive({ name: 'Alice' });
provide('user', readonly(user));
// Children can read but cannot mutate

Provide a livello di app

Fornisca i valori a livello di applicazione, così saranno disponibili ovunque: è utile per i plugin.

// main.ts
import { createApp } from 'vue';
import App from './App.vue';

const app = createApp(App);
app.provide('apiClient', new ApiClient());
app.mount('#app');

Wrapper composable

Avvolga provide/inject in un composable per offrire un'API più semplice ai consumer.

// useTheme.ts
import { inject, type InjectionKey, type Ref } from 'vue';

export const ThemeKey: InjectionKey<Ref<string>> = Symbol('theme');

export function useTheme() {
  const theme = inject(ThemeKey);
  if (!theme) throw new Error('useTheme: no provider in tree');
  return theme;
}

provide/inject e Pinia

provide/inject: leggero, senza librerie, ideale per valori in stile plugin (tema, lingua, utente corrente). Pinia: gestione completa dello stato con DevTools, ottimale per uno stato reattivo a livello di app con aggiornamenti complessi.

Verifica rapida

Qual è il modo consigliato per evitare collisioni tra le chiavi quando si utilizza provide/inject in una grande app Vue?

Riepilogo: provide/inject

L'antenato fornisce, il discendente inietta: niente prop drilling. I valori reattivi (ref/reactive) vengono propagati in modo reattivo. Le chiavi Symbol + InjectionKey consentono un'iniezione sicura rispetto ai tipi e senza collisioni. Valore predefinito come secondo argomento di inject. readonly() impedisce le modifiche. Il provide a livello di app è utile per i plugin condivisi tra app. È un'alternativa leggera a Pinia per i valori in stile plugin.

Domande Frequenti

La lezione «provide() e inject() per la dependency injection» è gratuita?

Sì — il testo completo di «provide() e inject() per la dependency injection» è 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 Frontend Academy, passa a CoddyKit PRO. Il corso Frontend Academy include 4 lezioni in totale.

Cosa imparerò in «provide() e inject() per la dependency injection»?

Fornire valori in un componente antenato e iniettarli in profondità nell’albero, evitando il prop drilling senza una libreria completa di gestione dello stato Eserciti Frontend Academy 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 Frontend Academy?

Non è richiesta alcuna esperienza precedente. Frontend Academy 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 «provide() e inject() per la dependency injection»?

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 Frontend Academy?

Sì. Ogni lezione Frontend Academy 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

  1. provide() e inject() per la dependency injection
  2. Componenti asincroni e Suspense
  3. Direttive personalizzate
  4. Sistema di plugin: app.use()
← Torna a Frontend Academy