Google आपकी पसंदीदा भाषा में कॉन्टेंट का अनुवाद करने के लिए, एआई टेक्नोलॉजी का इस्तेमाल करता है. एआई से मिले अनुवादों में गलतियां हो सकती हैं.

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

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

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

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

Firebase SDK की मदद से, साइन-इन फ़्लो को मैनेज करना

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

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

Facebook provider ऑब्जेक्ट का इंस्टेंस बनाएं:

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 फ़्लो शुरू करने से पहले Auth इंस्टेंस पर भाषा का कोड अपडेट करें. इससे आपको 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 provider ऑब्जेक्ट का इस्तेमाल करके, 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 की मदद से, अतिरिक्त डेटा फ़ेच करने के लिए किया जा सकता है.

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

साइन-इन पेज पर रीडायरेक्ट करके साइन इन करने के लिए, 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

ध्यान दें: Facebook एचटीटीपीएस का इस्तेमाल करना ज़रूरी बनाता है और असुरक्षित होस्ट से लॉगिन करने की अनुमति नहीं देता. http://localhost ऑरिजिन के साथ डेवलपमेंट मोड में Facebook का इस्तेमाल करते समय, आपको यह पक्का करना होगा कि इस Facebook ऐप्लिकेशन के लिए डेवलपमेंट मोड चालू हो. इसके अलावा, सिर्फ़ Facebook के टेस्ट खातों से साइन इन करने की अनुमति होगी.

account-exists-with-different-credential गड़बड़ियों को ठीक करना

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

signInWithPopup का इस्तेमाल करने पर, 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 Login JavaScript SDK की मदद से साइन-इन फ़्लो को मैनेज करें:

डेवलपर दस्तावेज़ में दिए गए निर्देशों का पालन करके, Facebook Login को अपने ऐप्लिकेशन में इंटिग्रेट करें. Facebook Login को अपने 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 Login को इंटिग्रेट करने के बाद, अपने वेब पेजों पर Facebook Login बटन जोड़ें:
```
<fb:login-button
  data-auto-logout-link="true"
  scope="public_profile,email"
  size="large"
></fb:login-button>
```

Facebook auth state callback में, Facebook के auth response से मिले auth token को 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 की सुविधा देने वाली सभी कंपनियों के लिए अनुमति देनी होगी. हालांकि, इसका मतलब यह है कि उपयोगकर्ताओं को Facebook में साइन इन करते समय यह डोमेन दिख सकता है. इसके बाद, उन्हें वापस ऐप्लिकेशन पर रीडायरेक्ट किया जाएगा: जारी रखें: https://my-app-12345.firebaseapp.com.

अपने सबडोमेन को दिखने से रोकने के लिए, Firebase Hosting की मदद से कस्टम डोमेन सेट अप किया जा सकता है:

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

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

var config = {
  apiKey: '...',
  // Changed from 'PROJECT_ID.firebaseapp.com'.
  authDomain: 'auth.custom.domain.com',
  databaseURL: 'https://PROJECT_ID.firebaseio.com',
  projectId: 'PROJECT_ID',
  storageBucket: 'PROJECT_ID.firebasestorage.app',
  messagingSenderId: 'SENDER_ID'
};
firebase.initializeApp(config);

अगले चरण

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

अपने ऐप्लिकेशन में, उपयोगकर्ता की पुष्टि की स्थिति जानने का सबसे सही तरीका यह है कि Auth ऑब्जेक्ट पर एक ऑब्ज़र्वर सेट करें. इसके बाद, आपको User ऑब्जेक्ट से उपयोगकर्ता की प्रोफ़ाइल की बुनियादी जानकारी मिल सकती है. उपयोगकर्ताओं को मैनेज करना लेख पढ़ें.
Firebase Realtime Database और Cloud Storage सुरक्षा नियमों में, आपको ये काम करने की सुविधा मिलती है: साइन इन किए हुए उपयोगकर्ता का यूनीक User-ID, 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