web-dev-qa-db-fra.com

Dans Firebase avec Push (), comment puis-je extraire l'ID unique

J'essaie d'ajouter/de supprimer des entrées d'une base de données Firebase. Je souhaite les répertorier dans un tableau à ajouter/modifier/supprimer (front-end), mais j'ai besoin d'un moyen d'identifier de manière unique chaque entrée afin de le modifier/supprimer. Firebase ajoute un identifiant unique par défaut lors de l'utilisation de Push (), mais je n'ai rien vu qui indique comment sélectionner cet identifiant unique dans la documentation de l'API. Est-ce faisable? Devrais-je utiliser set () à la place pour créer l'identifiant unique?

J'ai rassemblé cet exemple rapide en utilisant leur tutoriel:

<div id='messagesDiv'></div>
<input type='text' class="td-field" id='nameInput' placeholder='Name'>
<input type='text' class="td-field" id='messageInput' placeholder='Message'>
<input type='text' class="td-field" id='categoryInput' placeholder='Category'>
<input type='text' class="td-field" id='enabledInput' placeholder='Enabled'>
<input type='text' class="td-field" id='approvedInput' placeholder='Approved'>
<input type='Button' class="td-field" id='Submit' Value="Revove" onclick="msgRef.remove()">

<script>
var myDataRef = new Firebase('https://unique.firebase.com/');

  $('.td-field').keypress(function (e) {
    if (e.keyCode == 13) {
      var name     = $('#nameInput').val();
      var text     = $('#messageInput').val();
      var category = $('#categoryInput').val();
      var enabled  = $('#enabledInput').val();
      var approved = $('#approvedInput').val();
      myDataRef.Push({name: name, text: text, category: category, enabled: enabled, approved: approved });
      $('#messageInput').val('');
    }
  });
  myDataRef.on('child_added', function(snapshot) {
    var message = snapshot.val();
    displayChatMessage(message.name, message.text, message.category, message.enabled, message.approved);
  });
  function displayChatMessage(name, text, category, enabled, approved, ) {
    $('<div/>').text(text).prepend($('<em/>').text(name+' : '+category +' : '+enabled +' : '+approved+ ' : ' )).appendTo($('#messagesDiv'));
    $('#messagesDiv')[0].scrollTop = $('#messagesDiv')[0].scrollHeight;
  };
</script>

Supposons maintenant que j'ai trois lignes de données:

fred : 1 : 1 : 1 : test message 1
fred : 1 : 1 : 1 : test message 2
fred : 1 : 1 : 1 : test message 3

Comment puis-je identifier de manière unique la rangée 2?

dans la base de données Firebase, ils ressemblent à ceci:

-DatabaseName
    -IuxeSuSiNy6xiahCXa0
        approved: "1"
        category: "1"
        enabled: "1"
        name: "Fred"
        text: "test message 1"
    -IuxeTjwWOhV0lyEP5hf
        approved: "1"
        category: "1"
        enabled: "1"
        name: "Fred"
        text: "test message 2"
    -IuxeUWgBMTH4Xk9QADM
        approved: "1"
        category: "1"
        enabled: "1"
        name: "Fred"
        text: "test message 3"
javascriptjqueryfirebase
51
Front_End_Dev

Pour obtenir le "nom" de tout instantané (dans ce cas, l'ID créé par Push ()), appelez simplement name () comme ceci:

var name = snapshot.name();

Si vous voulez obtenir le nom généré automatiquement par Push (), vous pouvez simplement appeler name () sur la référence renvoyée, comme suit:

var newRef = myDataRef.Push(...);
var newID = newRef.name();

NOTE: snapshot.name() est obsolète. Voir d'autres réponses.

40
Andrew Lee

Pour quiconque trouve cette question et utilise Firebase 3+, la façon d'obtenir les ID uniques d'objet généré automatiquement après Push est d'utiliser la propriété key (not method) sur l'instantané de promesse:

firebase
  .ref('item')
  .Push({...})
  .then((snap) => {
     const key = snap.key 
  })

En savoir plus à ce sujet dans la documentation Firebase .

En passant, ceux qui envisagent de générer leur propre identifiant unique devraient y réfléchir à deux fois. Cela peut avoir des conséquences sur la sécurité et les performances. Si vous n'êtes pas sûr, utilisez l'ID de Firebase. Il contient un horodatage et dispose de fonctionnalités de sécurité prêtes à l'emploi.

En savoir plus ici :

Les clés uniques générées par Push () étant classées par l’heure actuelle, la liste des éléments résultants sera triée par ordre chronologique. Les clés sont également conçues pour être impossibles à deviner (elles contiennent 72 bits d'entropie aléatoires).

46
Dan Mindru

snapshot.name() est obsolète. utilisez key à la place. La propriété key de tout DataSnapshot (à l'exception de celui qui représente la racine d'une Firebase) renverra le nom de clé de l'emplacement qui l'a généré. Dans votre exemple:

myDataRef.on('child_added', function(snapshot) {
    var message = snapshot.val();
    var id = snapshot.key;
    displayChatMessage(message.name, message.text, message.category, message.enabled, message.approved);
});
32
Rima

Pour obtenir uniqueID après Push(), vous devez utiliser cette variante:

// Generate a reference to a new location and add some data using Push()
 var newPostRef = postsRef.Push();
// Get the unique key generated by Push()
var postId = newPostRef.key;

Vous générez une nouvelle Ref lorsque vous Push() et en utilisant .key de cette référence, vous pouvez obtenir uniqueID.

6
Denis Markov

Comme @Rima l’a fait remarquer, key() est le moyen le plus simple d’obtenir la base de feu d’ID affectée à votre Push().

Si, toutefois, vous souhaitez supprimer l’intermédiaire, Firebase a publié un Gist avec son code de génération d’ID. C’est simplement une fonction de l’heure actuelle qui garantit leur unicité, même sans communiquer avec le serveur.

Avec cela, vous pouvez utiliser generateId(obj) et set(obj) pour répliquer la fonctionnalité de Push().

Voici la fonction ID :

/**
 * Fancy ID generator that creates 20-character string identifiers with the following properties:
 *
 * 1. They're based on timestamp so that they sort *after* any existing ids.
 * 2. They contain 72-bits of random data after the timestamp so that IDs won't collide with other clients' IDs.
 * 3. They sort *lexicographically* (so the timestamp is converted to characters that will sort properly).
 * 4. They're monotonically increasing.  Even if you generate more than one in the same timestamp, the
 *    latter ones will sort after the former ones.  We do this by using the previous random bits
 *    but "incrementing" them by 1 (only in the case of a timestamp collision).
 */
generatePushID = (function() {
  // Modeled after base64 web-safe chars, but ordered by ASCII.
  var Push_CHARS = '-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz';

  // Timestamp of last Push, used to prevent local collisions if you Push twice in one ms.
  var lastPushTime = 0;

  // We generate 72-bits of randomness which get turned into 12 characters and appended to the
  // timestamp to prevent collisions with other clients.  We store the last characters we
  // generated because in the event of a collision, we'll use those same characters except
  // "incremented" by one.
  var lastRandChars = [];

  return function() {
    var now = new Date().getTime();
    var duplicateTime = (now === lastPushTime);
    lastPushTime = now;

    var timeStampChars = new Array(8);
    for (var i = 7; i >= 0; i--) {
      timeStampChars[i] = Push_CHARS.charAt(now % 64);
      // NOTE: Can't use << here because javascript will convert to int and lose the upper bits.
      now = Math.floor(now / 64);
    }
    if (now !== 0) throw new Error('We should have converted the entire timestamp.');

    var id = timeStampChars.join('');

    if (!duplicateTime) {
      for (i = 0; i < 12; i++) {
        lastRandChars[i] = Math.floor(Math.random() * 64);
      }
    } else {
      // If the timestamp hasn't changed since last Push, use the same random number, except incremented by 1.
      for (i = 11; i >= 0 && lastRandChars[i] === 63; i--) {
        lastRandChars[i] = 0;
      }
      lastRandChars[i]++;
    }
    for (i = 0; i < 12; i++) {
      id += Push_CHARS.charAt(lastRandChars[i]);
    }
    if(id.length != 20) throw new Error('Length should be 20.');

    return id;
  };
})();
3
Brandon

Vous pouvez mettre à jour l'enregistrement en ajoutant l'ID d'objet à l'aide d'une promesse renvoyée par .then() après la .Push() avec snapshot.key:

const ref = Firebase.database().ref(`/posts`);
ref.Push({ title, categories, content, timestamp})
   .then((snapshot) => {
     ref.child(snap.key).update({"id": snapshot.key})
   });
1
Lew

Comment je l'ai fait comme:

FirebaseDatabase mFirebaseDatabase = FirebaseDatabase.getInstance();
DatabaseReference ref = mFirebaseDatabase.getReference().child("users").child(uid); 

String key = ref.Push().getKey(); // this will fetch unique key in advance
ref.child(key).setValue(classObject);

Vous pouvez maintenant conserver la clé pour une utilisation ultérieure.

0
Deepesh

Si vous souhaitez obtenir la clé unique générée par la méthode firebase Push() pendant ou après l'écriture dans la base de données sans avoir à passer un autre appel, voici comment procéder:

var reference = firebaseDatabase.ref('your/reference').Push()

var uniqueKey = reference.key

reference.set("helllooooo")
.then(() => {

console.log(uniqueKey)



// this uniqueKey will be the same key that was just add/saved to your database



// can check your local console and your database, you will see the same key in both firebase and your local console


})
.catch(err =>

console.log(err)


});

La méthode Push() a une propriété key qui fournit la clé qui vient d'être générée et que vous pouvez utiliser avant, après ou pendant que vous écrivez dans la base de données.

0
Abdulmohsen Alabra