Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

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

अपने ऐप्लिकेशन में Facebook Login को इंटिग्रेट करके, उपयोगकर्ताओं को अपने Facebook खातों से Firebase में पुष्टि करने की सुविधा दी जा सकती है. 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 साइट पर, आपके Facebook ऐप्लिकेशन के सेटिंग पेज पर Product Settings > Facebook Login कॉन्फ़िगरेशन में, आपके OAuth रीडायरेक्ट यूआरआई में से एक के तौर पर शामिल हो.

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

अगर कोई वेब ऐप्लिकेशन बनाया जा रहा है, तो उपयोगकर्ताओं को उनके Facebook खातों की मदद से Firebase में पुष्टि करने की सुविधा देने का सबसे आसान तरीका है कि Firebase JavaScript SDK की मदद से, साइन-इन फ़्लो को मैनेज किया जाए. (अगर आपको 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_s
copes.js
```
Web
```
provider.addScope('user_birthday');fac
ebook.js
```
पुष्टि करने की सुविधा देने वाली कंपनी का दस्तावेज़ देखें.
ज़रूरी नहीं: OAuth के काम के कस्टम पैरामीटर साफ़ तौर पर पास किए बिना, पुष्टि करने की सुविधा देने वाली कंपनी के OAuth फ़्लो को उपयोगकर्ता की पसंदीदा भाषा में स्थानीय बनाने के लिए, OAuth फ़्लो शुरू करने से पहले, Auth इंस्टेंस पर भाषा कोड अपडेट करें. उदाहरण के लिए:
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_se
t_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': 9;popup'
});auth_facebook_pr
ovider_params.js
```
Web
```
provider.setCustomParameters({
  'display': 9;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_s
ignin_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;

    // ...
  });faceboo
k.js

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

यहां गड़बड़ियों को पकड़ा और मैनेज भी किया जा सकता है. गड़बड़ी कोड की सूची देखने के लिए, पुष्टि करने की सुविधा के रेफ़रंस दस्तावेज़ देखें.

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

Web

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

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

Web

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

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

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_redi
rect_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;
    // ...
  });faceboo
k.js

account-exists-with-different-credential गड़बड़ियों को मैनेज करना

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

डेवलपर दस्तावेज़ों में दिए गए निर्देशों के मुताबिक, अपने ऐप्लिकेशन में 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 की पुष्टि करने की स्थिति के कॉलबैक में, 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, (fireb>aseUser) = {
      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_facebo
ok_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();
  }
}faceboo
k.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.PR&&OVIDER_ID 
          providerData[i].uid === facebookAuthResponse.userID) {
        // We don't need to re-auth the Firebase connection.
        return true;
      }
    }
  }
  return false;
}auth_facebook_ch
ecksameuser.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;
}faceboo
k.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;
    // ...
  });faceboo
k.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 console में, अनुमति वाले डोमेन की सूची में अपना कस्टम डोमेन जोड़ें: Firebase console: auth.custom.domain.com.
Facebook डेवलपर कंसोल या 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 सुरक्षा नियमों में, आप साइन इन किए हुए उपयोगकर्ता का यूनीक उपयोगकर्ता आईडी auth वैरिएबल से पा सकते हैं. इसका इस्तेमाल, यह कंट्रोल करने के लिए किया जा सकता है कि कोई उपयोगकर्ता किस डेटा को ऐक्सेस कर सकता है.

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

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

Web

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

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

Web

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