Comment conserver des données dans une application Electron?

Il y a un module NPM que j'ai écrit appelé Electron-JSON-storage qui est destiné à abstraire cela et à fournir une interface agréable et facile au développeur.

Le module lit/écrit en interne JSON vers / depuis 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"
    });

});

Les vues Electron sont construites avec Webkit qui vous donne accès à l'api localstorage 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 si vous avez besoin d'un accès au stockage à partir du script principal, vous pouvez utiliser l'un des nombreux modules de stockage basés sur les nœuds. Personnellement, j'aime lowdb.

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

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

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

Readme:

Installation

$ npm install --save electron-storage

Utilisation

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

API

Stockage.get(filePath, cb)

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

Stockage.obtenir (chemin de fichier)

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

Stockage.set(filePath, données, cb)

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

Stockage.set(filePath, données)

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

Stockage.isPathExists (chemin, cb)

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

Stockage.isPathExists (chemin)

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

Il y a un bon module pour stocker les données utilisateur dans elecron. Il 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 de nombreuses fonctionnalités et il y a beaucoup d'avantages par rapport à window.localStorage

Il existe une pléthore de façons de persistance des données qui peuvent être utilisées dans Electron et 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 de l'application, vous pouvez utiliser des mécanismes simples tels que des fichiers plats 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 ORMs).

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

Vous pouvez opter pour Indexeddb, qui est probablement adapté aux besoins des applications côté client en raison de:

• son mécanisme de versioning intégré. Les applications côté Client sont souvent confrontées à la fragmentation des versions, car les utilisateurs ne mettent généralement pas à jour vers une nouvelle version en même temps. Donc, vérifier la version de la base de données existante et mettre à jour en conséquence est une bonne idée.
• c'est schemaless, ce qui permet d'ajouter plus 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, sauf si vous créez de nouveaux indices.
• Il prend en charge de larges plages de données: types de base ainsi que des données blob (fichier, images)

Dans l'Ensemble c'est un bon choix. La seule mise en garde est que l'api navigator.storage.persist ne fonctionne pas sur Electron, ce qui signifie que les cœurs chromium peuvent automatiquement effacer indexeddb pour récupérer de l'espace disque lorsque le stockage est sous tension.