Collegamento dei dati utente all'autenticazione
Colleghi gli ID degli utenti autenticati alle corrispondenti voci di dati nel Realtime Database per offrire contenuti personalizzati
Collegamento dei dati utente all'autenticazione è una lezione Firebase Auth & Realtime Database Apps 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 Firebase Auth & Realtime Database Apps, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Firebase Auth & Realtime Database Apps include 4 lezioni in totale.
Parti di questa lezione non sono ancora state tradotte e vengono mostrate in inglese.
Link Auth & Database
Why connect user authentication with your database? It's crucial for building personalized and secure applications.
By linking, you can:
- Store user-specific data like profiles or settings.
- Control access to data based on who is logged in.
- Create personalized experiences for each user.
Accessing the User's UID
Every authenticated user in Firebase has a unique User ID (UID). This ID is your key to linking their authentication status to their data.
You can get the current user's UID from the currentUser object after a user signs in.
<!-- Assume Firebase SDKs are loaded -->
<!-- and firebase.initializeApp() has been called -->
<script>
// Listen for authentication state changes
firebase.auth().onAuthStateChanged(user => {
if (user) {
const uid = user.uid;
console.log("Current User UID:", uid);
// Example: Display UID in a web element
// document.getElementById('user-uid').innerText = uid;
} else {
console.log("No user signed in.");
}
});
</script>UID as Your Database Key
Once you have the UID, you can use it as a unique identifier in your Firebase Realtime Database paths. This creates a secure and organized way to store user-specific data.
Think of it like a folder for each user, named after their UID:
/users/{UID}/profile/users/{UID}/preferences
Storing First User Data
Let's store some basic profile information for a signed-in user. We'll use the user's UID to create a unique path in the database.
This example stores a username and email under /users/{uid}.
<!-- Assume Firebase SDKs loaded & initialized -->
<script>
const user = firebase.auth().currentUser;
if (user) {
const uid = user.uid;
const userRef = firebase.database().ref('users/' + uid);
userRef.set({
username: "JaneDoe",
email: user.email, // Use auth email
createdAt: firebase.database.ServerValue.TIMESTAMP
})
.then(() => {
console.log("User data saved successfully!");
})
.catch(error => {
console.error("Error saving user data:", error);
});
} else {
console.log("No user signed in to save data for.");
}
</script>Your User Data Structure
After the previous code runs, your Realtime Database might look something like this:
{
"users": {
"YOUR_USER_UID_HERE": {
"username": "JaneDoe",
"email": "janedoe@example.com",
"createdAt": 1678886400000
}
}
}Each user gets their own top-level key under /users, making it easy to manage their data.
Reading User-Specific Data
To retrieve personalized content, you simply read from the path constructed with the current user's UID. This ensures they only see their own information.
Here's how to fetch the profile data we just stored:
<!-- Assume Firebase SDKs loaded & initialized -->
<script>
const user = firebase.auth().currentUser;
if (user) {
const uid = user.uid;
const userRef = firebase.database().ref('users/' + uid);
userRef.on('value', (snapshot) => {
const userData = snapshot.val();
if (userData) {
console.log("User Data:", userData);
console.log("Username:", userData.username);
} else {
console.log("No user data found for this UID.");
}
}, (error) => {
console.error("Error reading user data:", error);
});
} else {
console.log("No user signed in to read data for.");
}
</script>Updating User Profile
Users might want to change their profile information. You can easily update specific fields within their UID's data path using the update() method.
This updates only the username field without affecting others.
<!-- Assume Firebase SDKs loaded & initialized -->
<script>
const user = firebase.auth().currentUser;
if (user) {
const uid = user.uid;
const userRef = firebase.database().ref('users/' + uid);
userRef.update({
username: "Jane_The_Explorer" // Update only username
})
.then(() => {
console.log("Username updated successfully!");
})
.catch(error => {
console.error("Error updating username:", error);
});
} else {
console.log("No user signed in to update data for.");
}
</script>Handling Missing Data
It's important to always check if a user is signed in (firebase.auth().currentUser is not null) before trying to access their UID or database path.
Also, when reading data, check if snapshot.val() returns actual data or null. This prevents errors if a user's data hasn't been created yet.
Linking Best Practices
For efficiency and scalability, consider these tips:
- Keep UIDs consistent: Always use the authenticated UID as the primary key for user data.
- Denormalize for lookups: If you often need a user's name next to another piece of data (e.g., a post), store a copy of the name with the post instead of always querying the user profile.
- Security Rules: Use Realtime Database Security Rules to enforce that only the authenticated user can read/write their own data. (More on this in a later lesson!)
Quick Check: User Data
You want to store a user's favorite color in the Realtime Database, ensuring it's linked to their authenticated profile. Which path correctly uses the user's UID as a key?
Recap: Connecting User Data
In this lesson, you learned how to effectively link authenticated users to their specific data in the Firebase Realtime Database.
- We accessed the unique User ID (UID).
- We used the UID as a key in the database path.
- We practiced storing and reading user-specific information.
- We covered important considerations for handling missing data.
This foundational skill is vital for building personalized and secure applications!
Domande Frequenti
La lezione «Collegamento dei dati utente all'autenticazione» è gratuita?
Sì — il testo completo di «Collegamento dei dati utente all'autenticazione» è 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 Firebase Auth & Realtime Database Apps, passa a CoddyKit PRO. Il corso Firebase Auth & Realtime Database Apps include 4 lezioni in totale.
Cosa imparerò in «Collegamento dei dati utente all'autenticazione»?
Colleghi gli ID degli utenti autenticati alle corrispondenti voci di dati nel Realtime Database per offrire contenuti personalizzati Eserciti Firebase Auth & Realtime Database Apps 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 Firebase Auth & Realtime Database Apps?
Non è richiesta alcuna esperienza precedente. Firebase Auth & Realtime Database Apps 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 «Collegamento dei dati utente all'autenticazione»?
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 Firebase Auth & Realtime Database Apps?
Sì. Ogni lezione Firebase Auth & Realtime Database Apps 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
- Collegamento dei dati utente all'autenticazione
- Profili utente in tempo reale
- Modifica collaborativa dei dati
- Accesso ai dati utente basato sui ruoli