oficial - gmail electron app

¿Cómo persistir los datos en una aplicación electrónica?

Question

He estado recorriendo la documentación de Electron para intentar averiguar cómo conservar los datos en una aplicación de Electron. Por ejemplo, en iOS o OS X, puede usar NSUserDefaults para almacenar configuraciones y preferencias de usuario. Me gustaría hacer algo similar. ¿Cómo puedo persistir los datos en una aplicación electrónica?

Answer 1

Hay un módulo NPM que escribí llamado electron-json-storage que está destinado a abstraer esto y proporcionar una interfaz agradable y fácil para el desarrollador.

El módulo lee / escribe JSON internamente en / desde 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"
    });

});

Answer 2

Hay un módulo agradable para almacenar datos de usuario en elecron. Se llama github.com/sindresorhus/electron-store .

Instalación

$ npm install --save electron-storage

Uso de la muestra (copiado de la página github.com/sindresorhus/electron-store )

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

Este módulo tiene muchas características y hay muchas ventajas sobre window.localStorage

Answer 3

Hay un módulo que proporciona métodos simples para obtener y configurar archivos json en este directorio, crea subdirectorios si es necesario y admite devoluciones de llamada y promesas:

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

Léame:

Instalación

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

uso

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

API

storage.get (filePath, cb)

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

storage.get (filePath)

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

storage.set (filePath, data, cb)

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

storage.set (filePath, data)

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

storage.isPathExists (ruta, cb)

$ npm install electron-store

storage.isPathExists (ruta)

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

Answer 4

Hay una gran cantidad de formas de persistencia de datos que se pueden usar en Electron y elegir el enfoque correcto depende esencialmente de su (s) caso (s) de uso. Si solo se trata de guardar la configuración de la aplicación, entonces puede usar mecanismos simples como archivos planos o API de almacenamiento HTML5, para requisitos de datos avanzados, debe optar por soluciones de base de datos a gran escala como MySQL o MongoDB (con o sin ORM).

Puede consultar esta lista de métodos / herramientas para conservar datos en aplicaciones de Electron.

Answer 5

Las vistas electrónicas se crean con Webkit, que le da acceso a la API localstorage basada en la web. Bueno para el almacenamiento de configuraciones simples y fáciles.

Si necesita algo más potente o necesita acceso de almacenamiento desde el script principal, puede usar uno de los numerosos módulos de almacenamiento basados ​​en nodos. Personalmente me gusta el lowdb .

Con la mayoría de los módulos de almacenamiento de nodos, deberá proporcionar una ubicación de archivo. Tratar:

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

Answer 6

Puede ir a Indexeddb, que es más adecuado para las necesidades de la aplicación del lado del cliente debido a:

• Su mecanismo de versionado incorporado. Las aplicaciones del lado del cliente a menudo se enfrentan a la fragmentación de la versión, ya que los usuarios no suelen actualizar a la nueva versión al mismo tiempo. Por lo tanto, comprobar la versión de la base de datos existente y actualizarla es una buena idea.
• Es incomprensible, lo que permite la flexibilidad de agregar más datos al almacenamiento del cliente (lo cual sucede con bastante frecuencia en mi experiencia) sin tener que actualizar la base de datos a una nueva versión, a menos que cree nuevos índices.
• Admite amplios rangos de datos: tipos básicos y datos de blob (archivo, imágenes)

En general, es una buena opción. La única advertencia es que la interfaz navigator.storage.persist no funciona en Electron, lo que significa que los núcleos de cromo pueden eliminar automáticamente indexeddb para recuperar espacio en el disco cuando el almacenamiento está bajo presión.

Answer 7

NeDB es la única herramienta sugerida o presentada como una base de datos persistente integrada para Electron by Electron, actualmente. - http://electron.atom.io/community/

También podría ser útil almacenar las configuraciones del usuario si las configuraciones son complejas.

¿Por qué NeDB podría ser una mejor solución en este caso?

Integrado o en la base de datos de memoria para Node.js, nw.js, Electron y navegadores, 100% JavaScript, sin dependencia binaria. API es un subconjunto de MongoDB y es bastante rápido. - NeDB

Creando o cargando una base de datos:

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

Insertando un documento:

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
});

Encontrar documentos:

// 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 lista continua...