इस पेज का अनुवाद Cloud Translation API से किया गया है.

JavaScript के साथ Facebook लॉगिन का इस्तेमाल करके पुष्टि करें

अपने ऐप्लिकेशन में Facebook लॉगिन जोड़कर अपने उपयोगकर्ताओं को उनके Facebook खातों का इस्तेमाल करके, Firebase की पुष्टि करने की अनुमति दें. साइन इन फ़्लो को पूरा करने के लिए, Firebase SDK टूल का इस्तेमाल करके या तो Facebook लॉगिन को इंटिग्रेट किया जा सकता है. इसके अलावा, Facebook लॉगिन फ़्लो को मैन्युअल तरीके से कॉपी करके Firebase को ऐक्सेस टोकन भेजा जा सकता है.

शुरू करने से पहले

Firebase को अपने JavaScript प्रोजेक्ट में जोड़ें.
Facebook के लिए डेवलपर की साइट पर, अपने ऐप्लिकेशन के लिए ऐप्लिकेशन आईडी और ऐप्लिकेशन सीक्रेट पाएं.
Facebook में लॉगिन करने की सुविधा चालू करें:
1. Firebase कंसोल में, पुष्टि करें सेक्शन खोलें.
2. साइन इन करने का तरीका टैब पर, Facebook साइन इन करने का तरीका चालू करें. इसके बाद, Facebook से मिला ऐप्लिकेशन आईडी और ऐप्लिकेशन सीक्रेट तय करें.
3. इसके बाद, पक्का करें कि प्रॉडक्ट सेटिंग > Facebook लॉगिन कॉन्फ़िगरेशन में, डेवलपर के लिए Facebook साइट पर आपके Facebook ऐप्लिकेशन के सेटिंग पेज पर, OAuth रीडायरेक्ट यूआरआई (जैसे, my-app-12345.firebaseapp.com/__/auth/handler) को आपके OAuth रीडायरेक्ट यूआरआई में से एक के तौर पर शामिल किया गया है.

Firebase SDK टूल की मदद से साइन-इन की प्रोसेस को मैनेज करना

अगर आप कोई वेब ऐप्लिकेशन बना रहे हैं, तो Firebase JavaScript SDK टूल की मदद से साइन-इन फ़्लो को मैनेज करना, अपने उपयोगकर्ताओं के Facebook खातों का इस्तेमाल करके Firebase से पुष्टि करने का सबसे आसान तरीका है. (अगर आपको Node.js या बिना ब्राउज़र वाले एनवायरमेंट में किसी उपयोगकर्ता की पुष्टि करनी है, तो आपको मैन्युअल तरीके से साइन-इन फ़्लो मैनेज करना होगा.)

Firebase JavaScript SDK टूल से साइन इन फ़्लो को मैनेज करने के लिए, यह तरीका अपनाएं:

Facebook प्रोवाइडर ऑब्जेक्ट का इंस्टेंस बनाएं:
Web

ट्री-शेक किए जा सकने वाले मॉड्यूलर वेब एपीआई के बारे में ज़्यादा जानें और नेमस्पेसेड एपीआई से अपग्रेड करें.
```
import { FacebookAuthProvider } from "firebase/auth";

const provider = new FacebookAuthProvider();auth_facebook_provider_create.js
```
Web
```
var provider = new firebase.auth.FacebookAuthProvider();facebook.js
```
ज़रूरी नहीं: OAuth 2.0 के ऐसे अन्य दायरे तय करें जिनका अनुरोध आपको पुष्टि करने वाली कंपनी से करना है. स्कोप जोड़ने के लिए, addScope को कॉल करें. उदाहरण के लिए:
Web

ट्री-शेक किए जा सकने वाले मॉड्यूलर वेब एपीआई के बारे में ज़्यादा जानें और नेमस्पेसेड एपीआई से अपग्रेड करें.
```
provider.addScope('user_birthday');auth_facebook_provider_scopes.js
```
Web
```
provider.addScope('user_birthday');facebook.js
```
पुष्टि करने की सेवा देने वाली कंपनी का दस्तावेज़ देखें.
ज़रूरी नहीं: काम के कस्टम OAuth पैरामीटर साफ़ तौर पर पास किए बिना, सेवा देने वाले के OAuth फ़्लो को उपयोगकर्ता की पसंदीदा भाषा में लोकलाइज़ करने के लिए, OAuth फ़्लो शुरू करने से पहले, ऑथराइज़ेशन इंस्टेंस पर भाषा कोड को अपडेट करें. उदाहरण के लिए:
Web

ट्री-शेक किए जा सकने वाले मॉड्यूलर वेब एपीआई के बारे में ज़्यादा जानें और नेमस्पेसेड एपीआई से अपग्रेड करें.
```
import { getAuth } from "firebase/auth";

const auth = getAuth();
auth.languageCode = 'it';
// To apply the default browser preference instead of explicitly setting it.
// auth.useDeviceLanguage();auth_set_language_code.js
```
Web
```
firebase.auth().languageCode = 'it';
// To apply the default browser preference instead of explicitly setting it.
// firebase.auth().useDeviceLanguage();index.js
```
ज़रूरी नहीं: कस्टम OAuth प्रोवाइडर के ऐसे अतिरिक्त पैरामीटर तय करें जिन्हें आपको OAuth अनुरोध के साथ भेजना है. कोई कस्टम पैरामीटर जोड़ने के लिए, शुरू की गई सेवा देने वाली कंपनी के उस ऑब्जेक्ट के साथ setCustomParameters को कॉल करें जिसमें वह कुंजी मौजूद हो जो OAuth की सेवा देने वाली कंपनी के दस्तावेज़ और उससे जुड़ी वैल्यू में बताया गया हो. उदाहरण के लिए:
Web

ट्री-शेक किए जा सकने वाले मॉड्यूलर वेब एपीआई के बारे में ज़्यादा जानें और नेमस्पेसेड एपीआई से अपग्रेड करें.
```
provider.setCustomParameters({
  'display': 'popup'
});auth_facebook_provider_params.js
```
Web
```
provider.setCustomParameters({
  'display': 'popup'
});facebook.js
```
रिज़र्व किए गए ज़रूरी OAuth पैरामीटर की अनुमति नहीं है. इन्हें अनदेखा कर दिया जाएगा. ज़्यादा जानकारी के लिए, पुष्टि करने वाली कंपनी का रेफ़रंस देखें.

Facebook प्रोवाइडर ऑब्जेक्ट का इस्तेमाल करके, Firebase से पुष्टि करें. उपयोगकर्ताओं को पॉप-अप विंडो खोलकर या साइन-इन पेज पर रीडायरेक्ट करके, उनके Facebook खातों से साइन इन करने के लिए कहा जा सकता है. मोबाइल डिवाइस पर रीडायरेक्ट करने के तरीके को प्राथमिकता दी जाती है.

पॉप-अप विंडो की मदद से साइन इन करने के लिए, signInWithPopup पर कॉल करें:

Web

import { getAuth, signInWithPopup, FacebookAuthProvider } from "firebase/auth";

const auth = getAuth();
signInWithPopup(auth, provider)
  .then((result) => {
    // The signed-in user info.
    const user = result.user;

    // This gives you a Facebook Access Token. You can use it to access the Facebook API.
    const credential = FacebookAuthProvider.credentialFromResult(result);
    const accessToken = credential.accessToken;

    // IdP data available using getAdditionalUserInfo(result)
    // ...
  })
  .catch((error) => {
    // Handle Errors here.
    const errorCode = error.code;
    const errorMessage = error.message;
    // The email of the user's account used.
    const email = error.customData.email;
    // The AuthCredential type that was used.
    const credential = FacebookAuthProvider.credentialFromError(error);

    // ...
  });auth_facebook_signin_popup.js

Web

firebase
  .auth()
  .signInWithPopup(provider)
  .then((result) => {
    /** @type {firebase.auth.OAuthCredential} */
    var credential = result.credential;

    // The signed-in user info.
    var user = result.user;
    // IdP data available in result.additionalUserInfo.profile.
      // ...

    // This gives you a Facebook Access Token. You can use it to access the Facebook API.
    var accessToken = credential.accessToken;

    // ...
  })
  .catch((error) => {
    // Handle Errors here.
    var errorCode = error.code;
    var errorMessage = error.message;
    // The email of the user's account used.
    var email = error.email;
    // The firebase.auth.AuthCredential type that was used.
    var credential = error.credential;

    // ...
  });facebook.js

यह भी ध्यान में रखें कि आपके पास Facebook की सेवा देने वाली कंपनी के OAuth टोकन को फिर से पाने का विकल्प है. इस टोकन का इस्तेमाल, Facebook API की मदद से अतिरिक्त डेटा फ़ेच करने के लिए किया जा सकता है.

यहां पर गड़बड़ियों का पता लगाकर उन्हें ठीक भी किया जा सकता है. गड़बड़ी कोड की सूची के लिए, आधिकारिक रेफ़रंस दस्तावेज़ पर एक नज़र डालें.

साइन-इन पेज पर रीडायरेक्ट करके साइन इन करने के लिए, signInWithRedirect को कॉल करें: `signInWithredirect` का इस्तेमाल करते समय सबसे सही तरीके अपनाएं.

Web

import { getAuth, signInWithRedirect } from "firebase/auth";

const auth = getAuth();
signInWithRedirect(auth, provider);auth_signin_redirect.js

Web

firebase.auth().signInWithRedirect(provider);index.js

इसके बाद, पेज लोड होने पर getRedirectResult पर कॉल करके, Facebook की सेवा देने वाली कंपनी का OAuth टोकन भी वापस पाया जा सकता है:

Web

import { getAuth, getRedirectResult, FacebookAuthProvider } from "firebase/auth";

const auth = getAuth();
getRedirectResult(auth)
  .then((result) => {
    // This gives you a Facebook Access Token. You can use it to access the Facebook API.
    const credential = FacebookAuthProvider.credentialFromResult(result);
    const token = credential.accessToken;

    const user = result.user;
    // IdP data available using getAdditionalUserInfo(result)
    // ...
  }).catch((error) => {
    // Handle Errors here.
    const errorCode = error.code;
    const errorMessage = error.message;
    // The email of the user's account used.
    const email = error.customData.email;
    // AuthCredential type that was used.
    const credential = FacebookAuthProvider.credentialFromError(error);
    // ...
  });auth_facebook_signin_redirect_result.js

Web

firebase.auth()
  .getRedirectResult()
  .then((result) => {
    if (result.credential) {
      /** @type {firebase.auth.OAuthCredential} */
      var credential = result.credential;

      // This gives you a Facebook Access Token. You can use it to access the Facebook API.
      var token = credential.accessToken;
      // ...
    }
    // The signed-in user info.
    var user = result.user;
    // IdP data available in result.additionalUserInfo.profile.
      // ...
  }).catch((error) => {
    // Handle Errors here.
    var errorCode = error.code;
    var errorMessage = error.message;
    // The email of the user's account used.
    var email = error.email;
    // The firebase.auth.AuthCredential type that was used.
    var credential = error.credential;
    // ...
  });facebook.js

अलग-अलग क्रेडेंशियल के साथ खाता-मौजूद है से जुड़ी गड़बड़ियों को मैनेज करना

अगर आपने Firebase कंसोल में हर ईमेल पते के लिए एक खाता सेटिंग चालू की है, तो जब कोई उपयोगकर्ता, सेवा देने वाली किसी कंपनी (जैसे Facebook) में साइन इन करने की कोशिश करता है और ऐसे ईमेल का इस्तेमाल करता है जो Firebase का इस्तेमाल करने वाले किसी दूसरे व्यक्ति (जैसे कि Google) के लिए पहले से मौजूद है, तो AuthCredential ऑब्जेक्ट (Facebook ऐक्सेस टोकन) के साथ गड़बड़ी auth/account-exists-with-different-credential की गड़बड़ी दिखेगी. सेवा देने वाली अनुमानित कंपनी में साइन इन करने के लिए, उपयोगकर्ता को पहले मौजूदा कंपनी (Google) में साइन इन करना होगा. इसके बाद, उसे पहले वाले AuthCredential (Facebook ऐक्सेस टोकन) से लिंक करना होगा.

signInWithPopup का इस्तेमाल करने पर, कोड से auth/account-exists-with-different-credential गड़बड़ियों को ठीक किया जा सकता है. इसका उदाहरण नीचे दिया गया है:

import {
  getAuth,
  linkWithCredential,
  signInWithPopup,
  FacebookAuthProvider,
} from "firebase/auth";

try {
  // Step 1: User tries to sign in using Facebook.
  let result = await signInWithPopup(getAuth(), new FacebookAuthProvider());
} catch (error) {
  // Step 2: User's email already exists.
  if (error.code === "auth/account-exists-with-different-credential") {
    // The pending Facebook credential.
    let pendingCred = error.credential;

    // Step 3: Save the pending credential in temporary storage,

    // Step 4: Let the user know that they already have an account
    // but with a different provider, and let them choose another
    // sign-in method.
  }
}

// ...

try {
  // Step 5: Sign the user in using their chosen method.
  let result = await signInWithPopup(getAuth(), userSelectedProvider);

  // Step 6: Link to the Facebook credential.
  // TODO: implement `retrievePendingCred` for your app.
  let pendingCred = retrievePendingCred();

  if (pendingCred !== null) {
    // As you have access to the pending credential, you can directly call the
    // link method.
    let user = await linkWithCredential(result.user, pendingCred);
  }

  // Step 7: Continue to app.
} catch (error) {
  // ...
}

रीडायरेक्ट मोड

इस गड़बड़ी को रीडायरेक्ट मोड में इसी तरह से हैंडल किया जाता है. इसमें अंतर यह है कि पेज के रीडायरेक्ट के बीच पेंडिंग क्रेडेंशियल को कैश मेमोरी में सेव किया जाता है (उदाहरण के लिए, सेशन स्टोरेज का इस्तेमाल करके).

Facebook खाते का इस्तेमाल करके भी Firebase की पुष्टि की जा सकती है. इसके लिए, Facebook लॉगिन JavaScript SDK टूल की मदद से साइन-इन फ़्लो मैनेज करें:

डेवलपर दस्तावेज़ में दिए गए निर्देशों का पालन करके, अपने ऐप्लिकेशन में Facebook लॉगिन को इंटिग्रेट करें. अपने Facebook ऐप्लिकेशन आईडी के साथ Facebook लॉगिन को कॉन्फ़िगर करना न भूलें:
```
<script src="//connect.facebook.net/en_US/sdk.js"></script>
<script>
  FB.init({
    /**********************************************************************
     * TODO(Developer): Change the value below with your Facebook app ID. *
     **********************************************************************/
    appId: '<YOUR_FACEBOOK_APP_ID>',
    status: true,
    xfbml: true,
    version: 'v2.6',
  });
</script>
```
हमने Facebook की पुष्टि की स्थिति पर भी, लिसनर की सुविधा सेटअप की है:
```
FB.Event.subscribe('auth.authResponseChange', checkLoginState);
```
Facebook लॉगिन इंटिग्रेट करने के बाद, अपने वेब पेजों पर Facebook लॉगिन बटन जोड़ें:
```
<fb:login-button
  data-auto-logout-link="true"
  scope="public_profile,email"
  size="large"
></fb:login-button>
```

Facebook के पुष्टि की स्थिति वाले कॉलबैक में, Facebook के पुष्टि करने वाले रिस्पॉन्स से, Firebase क्रेडेंशियल और साइन-इन Firebase में पुष्टि करने के लिए इस्तेमाल होने वाले टोकन को एक्सचेंज करें:

Web

import { getAuth, onAuthStateChanged, signInWithCredential, signOut, FacebookAuthProvider } from "firebase/auth";
const auth = getAuth();

function checkLoginState(response) {
  if (response.authResponse) {
    // User is signed-in Facebook.
    const unsubscribe = onAuthStateChanged(auth, (firebaseUser) => {
      unsubscribe();
      // Check if we are already signed-in Firebase with the correct user.
      if (!isUserEqual(response.authResponse, firebaseUser)) {
        // Build Firebase credential with the Facebook auth token.
        const credential = FacebookAuthProvider.credential(
            response.authResponse.accessToken);

        // Sign in with the credential from the Facebook user.
        signInWithCredential(auth, credential)
          .catch((error) => {
            // Handle Errors here.
            const errorCode = error.code;
            const errorMessage = error.message;
            // The email of the user's account used.
            const email = error.customData.email;
            // The AuthCredential type that was used.
            const credential = FacebookAuthProvider.credentialFromError(error);
            // ...
          });
      } else {
        // User is already signed-in Firebase with the correct user.
      }
    });
  } else {
    // User is signed-out of Facebook.
    signOut(auth);
  }
}auth_facebook_callback.js

Web

function checkLoginState(response) {
  if (response.authResponse) {
    // User is signed-in Facebook.
    var unsubscribe = firebase.auth().onAuthStateChanged((firebaseUser) => {
      unsubscribe();
      // Check if we are already signed-in Firebase with the correct user.
      if (!isUserEqual(response.authResponse, firebaseUser)) {
        // Build Firebase credential with the Facebook auth token.
        var credential = firebase.auth.FacebookAuthProvider.credential(
            response.authResponse.accessToken);

        // Sign in with the credential from the Facebook user.
        firebase.auth().signInWithCredential(credential)
          .catch((error) => {
            // Handle Errors here.
            var errorCode = error.code;
            var errorMessage = error.message;
            // The email of the user's account used.
            var email = error.email;
            // The firebase.auth.AuthCredential type that was used.
            var credential = error.credential;
            // ...
          });
      } else {
        // User is already signed-in Firebase with the correct user.
      }
    });
  } else {
    // User is signed-out of Facebook.
    firebase.auth().signOut();
  }
}facebook.js

साथ ही, फिर से पुष्टि करने की ज़रूरत न होने से बचने के लिए, आपको यह भी देखना चाहिए कि Facebook उपयोगकर्ता ने पहले से Firebase में साइन इन नहीं किया है या नहीं:

Web

import { FacebookAuthProvider } from "firebase/auth";

function isUserEqual(facebookAuthResponse, firebaseUser) {
  if (firebaseUser) {
    const providerData = firebaseUser.providerData;
    for (let i = 0; i < providerData.length; i++) {
      if (providerData[i].providerId === FacebookAuthProvider.PROVIDER_ID &&
          providerData[i].uid === facebookAuthResponse.userID) {
        // We don't need to re-auth the Firebase connection.
        return true;
      }
    }
  }
  return false;
}auth_facebook_checksameuser.js

Web

function isUserEqual(facebookAuthResponse, firebaseUser) {
  if (firebaseUser) {
    var providerData = firebaseUser.providerData;
    for (var i = 0; i < providerData.length; i++) {
      if (providerData[i].providerId === firebase.auth.FacebookAuthProvider.PROVIDER_ID &&
          providerData[i].uid === facebookAuthResponse.userID) {
        // We don't need to re-auth the Firebase connection.
        return true;
      }
    }
  }
  return false;
}facebook.js

बेहतर सुविधा: Node.js में Firebase की मदद से पुष्टि करें

Node.js ऐप्लिकेशन में Firebase की मदद की पुष्टि करने के लिए:

उपयोगकर्ता के Facebook खाते से साइन इन करें और उसका Facebook ऐक्सेस टोकन पाएं. उदाहरण के लिए, उपयोगकर्ता को किसी ब्राउज़र में, मैन्युअल तरीके से साइन-इन फ़्लो को मैनेज करना सेक्शन में बताए गए तरीके से साइन इन करना होगा. हालांकि, क्लाइंट ऐप्लिकेशन में ऐक्सेस टोकन का इस्तेमाल करने के बजाय, उसे अपने Node.js ऐप्लिकेशन पर भेजें.

उपयोगकर्ता का Facebook ऐक्सेस टोकन मिलने के बाद, उसका इस्तेमाल करके कोई क्रेडेंशियल ऑब्जेक्ट बनाएं. इसके बाद, उपयोगकर्ता को क्रेडेंशियल के साथ साइन इन करें:

Web

import { getAuth, signInWithCredential, FacebookAuthProvider } from "firebase/auth";

// Sign in with the credential from the Facebook user.
const auth = getAuth();
signInWithCredential(auth, credential)
  .then((result) => {
    // Signed in 
    const credential = FacebookAuthProvider.credentialFromResult(result);
  })
  .catch((error) => {
    // Handle Errors here.
    const errorCode = error.code;
    const errorMessage = error.message;
    // The email of the user's account used.
    const email = error.customData.email;
    // The AuthCredential type that was used.
    const credential = FacebookAuthProvider.credentialFromError(error);
    // ...
  });auth_facebook_signin_credential.js

Web

// Sign in with the credential from the Facebook user.
firebase.auth().signInWithCredential(credential)
  .then((result) => {
    // Signed in       
    var credential = result.credential;
    // ...
  })
  .catch((error) => {
    // Handle Errors here.
    var errorCode = error.code;
    var errorMessage = error.message;
    // The email of the user's account used.
    var email = error.email;
    // The firebase.auth.AuthCredential type that was used.
    var credential = error.credential;
    // ...
  });facebook.js

Chrome एक्सटेंशन में Firebase की मदद से पुष्टि करें

अगर आप Chrome एक्सटेंशन ऐप्लिकेशन बना रहे हैं, तो ऑफ़स्क्रीन दस्तावेज़ गाइड देखें.

प्रोजेक्ट बनाते समय, Firebase आपके प्रोजेक्ट के लिए एक यूनीक सबडोमेन का प्रावधान करेगा: https://my-app-12345.firebaseapp.com.

इसका इस्तेमाल, OAuth में साइन इन करने के लिए रीडायरेक्ट करने के तरीके के तौर पर भी किया जाएगा. उस डोमेन को उन सभी OAuth कंपनियों के लिए अनुमति दी जानी चाहिए जिन पर OAuth की सेवा काम करती है. हालांकि, इसका मतलब यह है कि उपयोगकर्ताओं को Facebook में साइन इन करते समय, ऐप्लिकेशन पर वापस रीडायरेक्ट करने से पहले वह डोमेन दिख सकता है: जारी रखें: https://my-app-12345.firebaseapp.com.

अगर आपको अपना सबडोमेन नहीं दिखाना है, तो Firebase होस्टिंग की मदद से, कस्टम डोमेन सेट अप करें:

अपने डोमेन को होस्टिंग के लिए सेट अप करना में पहले से लेकर तीसरे चरण तक का पालन करें. जब आप अपने डोमेन के मालिकाना हक की पुष्टि करते हैं, तो होस्टिंग सेवा आपके कस्टम डोमेन के लिए एक एसएसएल सर्टिफ़िकेट का प्रावधान करती है.
Firebase कंसोल में मौजूद अनुमति वाले डोमेन की सूची में अपना कस्टम डोमेन जोड़ें: auth.custom.domain.com.
Facebook डेवलपर कंसोल या OAuth सेटअप पेज में, रीडायरेक्ट पेज के यूआरएल को वाइटलिस्ट करें. यह यूआरएल आपके कस्टम डोमेन से ऐक्सेस किया जा सकेगा: https://auth.custom.domain.com/__/auth/handler.

JavaScript लाइब्रेरी शुरू करते समय, authDomain फ़ील्ड का इस्तेमाल करके अपना कस्टम डोमेन बताएं:

var config = {
  apiKey: '...',
  // Changed from 'my-app-12345.firebaseapp.com'.
  authDomain: 'auth.custom.domain.com',
  databaseURL: 'https://my-app-12345.firebaseio.com',
  projectId: 'my-app-12345',
  storageBucket: 'my-app-12345.appspot.com',
  messagingSenderId: '1234567890'
};
firebase.initializeApp(config);

अगले चरण

जब कोई उपयोगकर्ता पहली बार साइन इन करता है, तो एक नया उपयोगकर्ता खाता बनाया जाता है और उपयोगकर्ता के क्रेडेंशियल से लिंक किया जाता है. इन क्रेडेंशियल में उपयोगकर्ता नाम और पासवर्ड, फ़ोन नंबर या पुष्टि करने वाली सेवा की जानकारी शामिल है. यह नया खाता आपके Firebase प्रोजेक्ट के हिस्से के तौर पर सेव किया जाता है. साथ ही, इसका इस्तेमाल आपके प्रोजेक्ट के हर ऐप्लिकेशन में किसी उपयोगकर्ता की पहचान करने के लिए किया जा सकता है. भले ही, उपयोगकर्ता ने किसी भी तरह से साइन इन किया हो.

हमारा सुझाव है कि आप अपने ऐप्लिकेशन में, उपयोगकर्ता की पुष्टि की स्थिति जानने के लिए Auth ऑब्जेक्ट पर एक ऑब्ज़र्वर सेट करें. इसके बाद, User ऑब्जेक्ट से उपयोगकर्ता की प्रोफ़ाइल की बुनियादी जानकारी पाई जा सकती है. उपयोगकर्ताओं को मैनेज करें देखें.
अपने Firebase रीयल टाइम डेटाबेस और Cloud Storage के सुरक्षा नियमों में, auth वैरिएबल से साइन-इन किए हुए उपयोगकर्ता का यूनीक यूज़र आईडी पाया जा सकता है और उसका इस्तेमाल करके यह कंट्रोल किया जा सकता है कि उपयोगकर्ता कौनसा डेटा ऐक्सेस कर सकता है.

आप पुष्टि करने वाली सेवा देने वाली कंपनियों के क्रेडेंशियल को किसी मौजूदा उपयोगकर्ता खाते से लिंक करके, उपयोगकर्ताओं को अपने ऐप्लिकेशन में साइन इन करने की अनुमति दे सकते हैं.

किसी उपयोगकर्ता को साइन आउट करने के लिए, signOut पर कॉल करें:

Web

import { getAuth, signOut } from "firebase/auth";

const auth = getAuth();
signOut(auth).then(() => {
  // Sign-out successful.
}).catch((error) => {
  // An error happened.
});auth_sign_out.js

Web

firebase.auth().signOut().then(() => {
  // Sign-out successful.
}).catch((error) => {
  // An error happened.
});index.js

JavaScript के साथ Facebook लॉगिन का इस्तेमाल करके पुष्टि करें

शुरू करने से पहले

Firebase SDK टूल की मदद से साइन-इन की प्रोसेस को मैनेज करना

Web

Web

Web

Web

Web

Web

Web

Web

Web

Web

Web

Web

Web

Web

अलग-अलग क्रेडेंशियल के साथ खाता-मौजूद है से जुड़ी गड़बड़ियों को मैनेज करना

पॉप-अप मोड

रीडायरेक्ट मोड

बेहतर सुविधा: साइन-इन की प्रोसेस को मैन्युअल तरीके से मैनेज करना

Web

Web

Web

Web

बेहतर सुविधा: Node.js में Firebase की मदद से पुष्टि करें

Web

Web

Chrome एक्सटेंशन में Firebase की मदद से पुष्टि करें

Facebook में साइन इन करने के लिए रीडायरेक्ट डोमेन को पसंद के मुताबिक बनाना

अगले चरण

Web

Web