web-dev-qa-db-fra.com

Comment conserver des données dans une application Electron?

J'ai parcouru la documentation Electron pour essayer de comprendre comment conserver des données dans une application Electron. Par exemple, dans iOS ou OS X, vous pouvez utiliser NSUserDefaults pour stocker les paramètres et les préférences de l'utilisateur. Je voudrais faire quelque chose de similaire. Comment puis-je conserver des données dans une application Electron?

electron
32
Andrew

NeDB est le seul outil suggéré ou décrit en tant que base de données persistante intégrée pour Electron par Electron, actuellement. - http://electron.atom.io/community/

Il peut également être utile de stocker les paramètres utilisateur si ceux-ci sont complexes.

Pourquoi NeDB pourrait être une meilleure solution sur ce cas?

Base de données persistante ou en mémoire intégrée pour Node.js, nw.js, Electron et les navigateurs, JavaScript à 100%, aucune dépendance binaire. L'API est un sous-ensemble de MongoDB et est très rapide. - NeDB

Création ou chargement d'une base de données: 

var Datastore = require('nedb')
  , db = new Datastore({ filename: 'path/to/datafile', autoload: true });
// You can issue commands right away

Insertion d'un document: 

var doc = { hello: 'world'
               , n: 5
               , today: new Date()
               , nedbIsAwesome: true
               , notthere: null
               , notToBeSaved: undefined  // Will not be saved
               , fruits: [ 'Apple', 'orange', 'pear' ]
               , infos: { name: 'nedb' }
               };

db.insert(doc, function (err, newDoc) {   // Callback is optional
  // newDoc is the newly inserted document, including its _id
  // newDoc has no key called notToBeSaved since its value was undefined
});

Recherche de documents: 

// Finding all inhabited planets in the solar system
db.find({ system: 'solar', inhabited: true }, function (err, docs) {
  // docs is an array containing document Earth only
});

La liste continue...

Mise à jour - septembre 2019

À partir de 2019, ce n'est plus la réponse valable. Voir les réponses de @ jviotti et @ Tharanga ci-dessous.

29
mertyildiran

J'ai écrit un module NPM appelé electron-json-storage qui est censé résumer ce problème et fournir une interface simple et agréable au développeur.

Le module lit/écrit en interne JSON dans/à partir de app.getPath('userData'):

const storage = require('electron-json-storage');

// Write
storage.set('foobar', { foo: 'bar' }).then(function() {

    // Read
    storage.get('foobar').then(function(object) {
        console.log(object.foo);
        // will print "bar"
    });

});
17
jviotti

Il existe un module Nice pour stocker les données utilisateur dans elecron. Cela s'appelle magasin d'électrons .

Installation

$ npm install electron-store

Exemple d'utilisation (copié à partir de github page)

const Store = require('electron-store');
const store = new Store();

store.set('Unicorn', '????');
console.log(store.get('Unicorn'));
//=> '????'

// Use dot-notation to access nested properties
store.set('foo.bar', true);
console.log(store.get('foo'));
//=> {bar: true}

store.delete('Unicorn');
console.log(store.get('Unicorn'));
//=> undefined

Ce module a beaucoup de fonctionnalités et il y a beaucoup de avantages par rapport à window.localStorage

8
Tharanga

Les vues Electron sont construites avec Webkit qui vous donne accès à l’API de stockage local basée sur le Web. Bon pour le stockage des paramètres simples et faciles.

Si vous avez besoin de quelque chose de plus puissant ou d'un accès au stockage à partir du script principal, vous pouvez utiliser l'un des nombreux modules de stockage basés sur des nœuds. Personnellement j'aime lowdb .

Avec la plupart des modules de stockage de nœuds, vous devez fournir un emplacement de fichier. Essayer:

var app = require('app');
app.getPath('userData');
8
Teak

Il existe un module qui donne des méthodes simples pour obtenir et définir des fichiers json dans ce répertoire, crée des sous-répertoires si nécessaire et prend en charge les rappels et les promesses:

https://github.com/ran-y/electron-storage

Lisez-moi:

Installation

$ npm install --save electron-storage

usage

const storage = require('electron-storage');

API

storage.get (chemin_fichier, cb)

storage.get(filePath, (err, data) => {
  if (err) {
    console.error(err)
  } else {
    console.log(data);
  }
});

storage.get (chemin de fichier)

storage.get(filePath)
.then(data => {
  console.log(data);
})
.catch(err => {
  console.error(err);
});

storage.set (filePath, data, cb)

storage.set(filePath, data, (err) => {
  if (err) {
    console.error(err)
  }
});

storage.set (chemin_fichier, données)

storage.set(filePath, data)
.then(data => {
  console.log(data);
})
.catch(err => {
  console.error(err);
});

storage.isPathExists (chemin, cb)

storage.isPathExists(path, (itDoes) => {
  if (itDoes) {
    console.log('pathDoesExists !')
  }
});

storage.isPathExists (chemin)

storage.isPathExists(path)
.then(itDoes => {
  if (itDoes) {
    console.log('pathDoesExists !')
  }
});
5
Yoni

Vous pouvez choisir Indexeddb, qui convient le mieux aux besoins d'applications côté client en raison de:

  • Son mécanisme de version intégré. Les applications côté client sont souvent confrontées à une fragmentation des versions, les utilisateurs ne mettant généralement pas à jour leur nouvelle version en même temps. Donc, vérifier la version de la base de données existante et la mettre à jour en conséquence est une bonne idée.
  • C'est sans schéma, ce qui permet d'ajouter davantage de données au stockage du client (ce qui arrive assez souvent dans mon expérience) sans avoir à mettre à jour la base de données vers une nouvelle version, à moins de créer de nouveaux index.
  • Il supporte une large gamme de données: types de base ainsi que des données de blob (fichier, images)

Dans l'ensemble c'est un bon choix. Le seul inconvénient est que les cœurs en chrome peuvent effacer automatiquement indexeddb pour récupérer de l'espace disque lorsque le stockage est saturé si navigator.storage.persist n'est pas défini ou lorsque la machine hôte tombe en panne, laissant indexeddb dans un état corrompu.

2
vuamitom

Comme la dernière version de NeDB date d'il y a 4 ans et qu'il y a de nombreux problèmes en suspens, je ne le recommanderais pas. Mais il y a beaucoup d'autres alternatives que vous pouvez utiliser maintenant.

https://github.com/pubkey/rxdb (nombreuses fonctionnalités, requêtes observables)

https://github.com/pouchdb/pouchdb (simple mais de nombreux problèmes en suspens)

https://github.com/techfort/LokiJS (uniquement stockage en mémoire)

https://github.com/typicode/lowdb (bon pour les jeux de données simples et petits)

2
pubkey

Il existe une multitude de méthodes de persistance des données utilisables dans Electron. Le choix de la bonne approche dépend essentiellement de vos cas d'utilisation. S'il ne s'agit que d'enregistrer les paramètres d'application, vous pouvez utiliser des mécanismes simples tels que des fichiers à plat ou des API de stockage HTML5. Pour les exigences de données avancées, vous devez opter pour des solutions de base de données à grande échelle telles que MySQL ou MongoDB (avec ou sans ORM).

Vous pouvez consulter cette liste de méthodes/outils pour conserver les données dans les applications Electron

0
Ahmed Bouchefra