haro
1.0.0
Haro ist ein moderner unveränderlicher Datenspeicher mit ES6 -Funktionen. Es ist nicht optimiert und bietet eine "Plug-and-Play" -Lösung für die Modellierung, Suche und Verwaltung von Daten auf dem Client oder Server (in RAM). Es handelt sich um eine teilweise persistente Datenstruktur, indem die Versionssätze von Datensätzen in versions (MVCC) gewartet werden.
Alle Methoden sind synchron.
Die Haro -Indizes haben die folgende Strukturkarte Map (field/property) > Map (value) > Set (PKs) die eine schnelle und einfache Suche sowie Inspektion ermöglicht. Indizes können unabhängig von del() & set() -Operationen verwaltet werden, beispielsweise können Sie träge neue Indizes über reindex(field) oder sortBy(field) erstellen.
Haro hat mit seinen Tests 100% Codeabdeckung.
----------|---------|----------|---------|---------|-------------------------------------------------------------------------------------------------------
File | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s
----------|---------|----------|---------|---------|-------------------------------------------------------------------------------------------------------
All files | 100 | 83.56 | 100 | 100 |
haro.cjs | 100 | 83.56 | 100 | 100 | 49-75,108,163-175,192,224-228,242,264,266,274,308,326,353-354,359-361,375-378,380,437,475,482,486-496
----------|---------|----------|---------|---------|------------------------------------------------------------------------------------------------------- Der benannte Export ist haro und die benannte Klasse Exported ist Haro .
import { haro } from 'haro' ; const { haro } = require ( 'haro' ) ; Haro nimmt zwei optionale Argumente ein, das erste ist eine Array von Datensätzen, die asynchron eingestellt werden können, und der zweite ist ein Konfigurationsdeskriptor.
const storeDefaults = haro ( ) ;
const storeRecords = haro ( [ { name : 'John Doe' , age : 30 } , { name : 'Jane Doe' , age : 28 } ] ) ;
const storeCustom = haro ( null , { key : 'id' } ) ; const store = haro ( null , { index : [ 'name' , 'age' ] } ) ,
data = [ { name : 'John Doe' , age : 30 } , { name : 'Jane Doe' , age : 28 } ] ;
const records = store . batch ( data , 'set' ) ;
console . log ( records [ 0 ] ) ; // [$uuid, {name: 'John Doe', age: 30}]
console . log ( store . size ) ; // 2
console . log ( store . find ( { age : 28 } ) ) ; // [[$uuid, {name: 'Jane Doe', age: 28}]]
console . log ( store . search ( / ^ja / i , 'name' ) ) ; // [[$uuid, {name: 'Jane Doe', age: 28}]]
console . log ( store . search ( arg => age < 30 , 'age' ) ) ; // [[$uuid, {name: 'Jane Doe', age: 28}]] const store = haro ( ) ;
let arg ;
arg = store . set ( null , { abc : true } ) ;
arg = store . set ( arg [ 0 ] , { abc : false } ) ;
arg = store . set ( arg [ 0 ] , { abc : true } ) ;
store . versions . get ( arg [ 0 ] ) . forEach ( i => console . log ( i [ 0 ] ) ) ; // {abc: true}, {abc: false} Ein Benchmark ist im Repository enthalten und ist nützlich, um zu messen, wie Haro auf verschiedenen Hardware und Software ausgeführt wird.
time to batch insert data: 6.7825 ms
datastore record count: 1000
name indexes: 1000
testing time to 'find()' a record (first one is cold):
0.063375ms
0.004583ms
0.002417ms
0.003459ms
0.001916ms
testing time to 'search(regex, index)' for a record (first one is cold):
0.147792ms
0.051209ms
0.050958ms
0.051125ms
0.052166ms
time to override data: 0.361709 ms
testing time to 'search(regex, index)' on overridden data for a record (first one is cold):
0.053083ms
0.051916ms
0.027459ms
0.0275ms
0.032292ms
Funktion
Event -Hörer für vor einem Stapelvorgang erhält type , data .
Funktion
Ereignishörer für vor dem Löschen des Datenspeichers.
Funktion
Event -Hörer für bevor ein Datensatz gelöscht wird, erhält key , batch .
Funktion
Ereignishörer für bevor ein Datensatz festgelegt ist, erhält key , data .
Array
Array von Werten zum Index. Zusammengesetzte Indizes werden unter Verwendung des Standard -Trennzeichens ( this.delimiter ) unterstützt. Nichtübereinstimmungen in Verbundwerkstoffen führen zu leeren Werten.
Beispiel für Felder/Eigenschaften zum Index:
const store = haro ( null , { index : [ 'field1' , 'field2' , 'field1|field2|field3' ] } ) ;Saite
Optionale Object , die als Map verwendet werden soll, standardmäßig zu einer Version 4 UUID falls nicht angegeben oder gefunden.
Beispiel für die Angabe des Primärschlüssels:
const store = haro ( null , { key : 'field' } ) ;Boolean
Protokolle persistente Speichernachrichten in console , Standard ist true .
Funktion
Event -Hörer für einen Stapeloperation erhält zwei Argumente ['Typ', Array ].
Funktion
Ereignishörer zum Löschen des Datenspeichers.
Funktion
Event -Hörer für den Löschung eines Datensatzes erhält die Datensatzschlüssel.
Funktion
Ereignishörer, wenn der Datenspeicher den gesamten Datensatz ändert, empfängt eine String , die die geänderten ( indexes oder records ) benennt.
Funktion
Ereignishörer für die Einstellung eines Datensatzes erhält ein Array .
Boolean
Aktivieren/Deaktivieren von MVCC -Stilversionen von Datensätzen, Standard ist false . Versionen werden in Sets für eine einfache Iteration gespeichert.
Beispiel für die Aktivierung der Versioning:
const store = haro ( null , { versioning : true } ) ; Karte
Map der Datensätze, aktualisiert von del() & set() .
Karte
Karte der Indizes, bei denen Kartenschlüssel enthalten sind.
Array
Array, das die Reihenfolge this.data darstellt.
Nummer
Anzahl der Datensätze im Datenspeicher.
Karte
Map von Sets , die von set() aktualisiert wurden.
Array
Das erste Argument muss ein Array sein, und das zweite Argument muss del oder set werden.
const haro = require ( 'haro' ) ,
store = haro ( null , { key : 'id' , index : [ 'name' ] } ) ,
nth = 100 ,
data = [ ] ;
let i = - 1 ;
while ( ++ i < nth ) {
data . push ( { id : i , name : 'John Doe' + i } ) ;
}
// records is an Array of Arrays
const records = store . batch ( data , 'set' ) ;selbst
Entfernt alle Schlüssel-/Wertpaare aus dem Datenspeicher.
Beispiel für das Löschen eines Datenspeichers:
const store = haro ( ) ;
// Data is added
store . clear ( ) ;Undefiniert
Löscht den Datensatz.
Beispiel für das Löschen eines Datensatzes:
const store = haro ( ) ,
rec = store . set ( null , { abc : true } ) ;
store . del ( rec [ 0 ] ) ;
console . log ( store . size ) ; // 0Array oder Objekt
Gibt die Datensätze oder Indexe des Datenspeichers als veränderliches Array oder Object zurück, um die Absicht der Wiederverwendung/persistierenden Speicher zu erhalten, ohne sich auf einen Adapter zu verlassen, der den Datensatz zerstören würde.
const store = haro ( ) ;
// Data is loaded
const records = store . dump ( ) ;
const indexes = store . dump ( 'indexes' ) ;
// Save records & indexesMappiterator
Gibt ein neues Iterator zurück, das ein Array von [key, value] für jedes Element im Map in der Einfügungsreihenfolge enthält.
Beispiel für das Löschen eines Datensatzes:
const store = haro ( ) ;
let item , iterator ;
// Data is added
iterator = store . entries ( ) ;
item = iterator . next ( ) ;
do {
console . log ( item . value ) ;
item = iterator . next ( ) ;
} while ( ! item . done ) ;Array
Gibt ein Array von Arrays mit der Form [key, value] zurück für Datensätze, die true an callbackFn(value, key) zurückgegeben wurden.
Beispiel für die Filterung eines Datenspeichers:
const store = haro ( ) ;
// Data is added
store . filter ( function ( value ) {
return value . something === true ;
} ) ;Array
Gibt eine Array von Arrays zurück, die durch indizierte Werte gefunden wurden, die dem where übereinstimmen.
Beispiel für das Finden eines Datensatzes mit einer Identitätsübereinstimmung:
const store = haro ( null , { index : [ 'field1' ] } ) ;
// Data is added
store . find ( { field1 : 'some value' } ) ;Undefiniert
Rufen Sie für jedes im Map vorhandene Schlüsselwertpaar in der Insertionsreihenfolge callbackFn einmal auf. Wenn für forEach ein thisArg -Parameter bereitgestellt wird, wird er als this Wert für jeden Rückruf verwendet.
Beispiel für das Löschen eines Datensatzes:
const store = haro ( ) ;
store . set ( null , { abc : true } ) ;
store . forEach ( function ( value , key ) {
console . log ( key ) ;
} ) ;Array
Ruft den Datensatz als Array mit der Form [key, value] ab.
Beispiel für einen Datensatz mit einem bekannten Primärschlüsselwert:
const store = haro ( ) ;
// Data is added
store . get ( 'keyValue' ) ;Boolean
Gibt einen Boolean zurück, der angibt, ob der Datenspeicher key enthält.
Beispiel für die Überprüfung eines Datensatzes mit einem bekannten Primärschlüsselwert:
const store = haro ( ) ;
// Data is added
store . has ( 'keyValue' ) ; // true or falseMappiterator
Gibt ein neues Iterator zurück, das die Schlüssel für jedes Element im Map in der Einfügungsreihenfolge enthält. "
Beispiel für einen Iterator und die Protokollierung der Ergebnisse:
const store = haro ( ) ;
let item , iterator ;
// Data is added
iterator = store . keys ( ) ;
item = iterator . next ( ) ;
do {
console . log ( item . value ) ;
item = iterator . next ( ) ;
} while ( ! item . done ) ;Array
Gibt ein Array von Arrays mit der Form [key, value] für den entsprechenden Bereich von Datensätzen zurück.
Beispiel für das Pagieren eines Datensatzes:
const store = haro ( ) ;
let ds1 , ds2 ;
// Data is added
console . log ( store . size ) ; // >10
ds1 = store . limit ( 0 , 10 ) ; // [0-9]
ds2 = store . limit ( 10 , 10 ) ; // [10-19]
console . log ( ds1 . length === ds2 . length ) ; // true
console . log ( JSON . stringify ( ds1 [ 0 ] [ 1 ] ) === JSON . stringify ( ds2 [ 0 ] [ 1 ] ) ) ; // falseArray
Gibt ein Array der Rückgabe von callbackFn(value, key) zurück. Wenn raw true ist, wird ein Array zurückgegeben.
Beispiel für die Zuordnung eines Datenspeichers:
const store = haro ( ) ;
// Data is added
store . map ( function ( value ) {
return value . property ;
} ) ;Boolean
Dies soll in einer gepaarten Überschreibung der Indizes und Datensätze verwendet werden, sodass Sie den Promise Codepfad einer batch() einfügen oder load() vermeiden können. Akzeptiert einen optionalen dritten Parameter, um die Transformation durchzuführen, um die Probleme mit der Cross -Domänen zu vereinfachen.
Beispiel für die Überschreiben eines Datenspeichers:
const store = haro ( ) ;
store . override ( { 'field' : { 'value' : [ 'pk' ] } } , "indexes" ) ;Array
Führt eine inspirierte Funktion Array.reduce() gegen den Data Store ( Map ) aus.
Beispiel für die Filterung eines Datenspeichers:
const store = haro ( ) ;
// Data is added
store . reduce ( function ( accumulator , value , key ) {
accumulator [ key ] = value ;
return accumulator ;
} , { } ) ;Haro
Indexiert den Datenspeicher, der aufgerufen wird, wenn der Wert des index geändert wird.
Beispiel für die Zuordnung eines Datenspeichers:
const store = haro ( ) ;
// Data is added
// Creating a late index
store . reindex ( 'field3' ) ;
// Recreating indexes, this should only happen if the store is out of sync caused by developer code.
store . reindex ( ) ;Array
Gibt eine Array von Arrays mit der Form [key, value] von Datensätzen zurück, die entsprechend arg . Wenn arg eine Function ist (Parameter sind value und index ), wird eine Übereinstimmung vorgenommen, wenn das Ergebnis true ist. Wenn arg ein RegExp ist, muss der Feldwert .test() als true , sonst muss der Wert eine Identitätsübereinstimmung sein. Der index kann eine String oder Array von Strings sein. Wenn nicht geliefert, wird dies standardmäßig in this.index geliefert.
Indexierte Arrays , die mit einem RegExp getestet werden, werden als Komma String behandelt, z. B. ['hockey', 'football'] wird zu 'hockey, football' für die RegExp .
Beispiel für die Suche mit einer Prädikatfunktion:
const store = haro ( null , { index : [ 'name' , 'age' ] } ) ,
data = [ { name : 'John Doe' , age : 30 } , { name : 'Jane Doe' , age : 28 } ] ;
store . batch ( data , 'set' )
console . log ( store . search ( function ( age ) {
return age < 30 ;
} , 'age' ) ) ; // [[$uuid, {name: 'Jane Doe', age: 28}]]Objekt
Aufzeichnung im Datenspeicher. Wenn key false ist, wird eine Version 4 UUID generiert.
Wenn override true ist, wird der vorhandene Datensatz anstelle von geändert.
Beispiel für das Erstellen eines Datensatzes:
const store = haro ( null , { key : 'id' } ) ,
record = store . set ( null , { id : 1 , name : 'John Doe' } ) ;
console . log ( record ) ; // [1, {id: 1, name: 'Jane Doe'}]Array
Gibt ein Array des Datenspeichers zurück, sortiert nach callbackFn .
Beispiel für das Sortieren wie ein Array :
const store = haro ( null , { index : [ 'name' , 'age' ] } ) ,
data = [ { name : 'John Doe' , age : 30 } , { name : 'Jane Doe' , age : 28 } ] ;
store . batch ( data , 'set' )
console . log ( store . sort ( ( a , b ) => a < b ? - 1 : ( a > b ? 1 : 0 ) ) ) ; // [{name: 'Jane Doe', age: 28}, {name: 'John Doe', age: 30}]Array
Gibt ein Array von Arrays mit der Form [key, value] von Datensätzen zurück, die nach einem Index sortiert sind.
Beispiel für die Sortierung nach einem Index:
const store = haro ( null , { index : [ 'name' , 'age' ] } ) ,
data = [ { name : 'John Doe' , age : 30 } , { name : 'Jane Doe' , age : 28 } ] ;
store . batch ( data , 'set' )
console . log ( store . sortBy ( 'age' ) ) ; // [[$uuid, {name: 'Jane Doe', age: 28}], [$uuid, {name: 'John Doe', age: 30}]]Array
Gibt ein Array des Datenspeichers zurück.
Beispiel für das Casting zu einem Array :
const store = haro ( ) ,
data = [ { name : 'John Doe' , age : 30 } , { name : 'Jane Doe' , age : 28 } ] ;
store . batch ( data , 'set' )
console . log ( store . toArray ( ) ) ; // [{name: 'John Doe', age: 30}, {name: 'Jane Doe', age: 28}]Mappiterator
Gibt ein neues Iterator zurück, das die Werte für jedes Element im Map in der Einfügungsreihenfolge enthält.
Beispiel für die Iterierung der Werte:
const store = haro ( ) ,
data = [ { name : 'John Doe' , age : 30 } , { name : 'Jane Doe' , age : 28 } ] ;
store . batch ( data , 'set' )
const iterator = store . values ( ) ;
let item = iterator . next ( ) ;
while ( ! item . done ) {
console . log ( item . value ) ;
item = iterator . next ( ) ;
} ;Array
Ideal für den Umgang mit einem zusammengesetzten Index, der eine Array von Werten enthält, die bei der Verwendung find() die Übereinstimmung mit einem einzelnen Wert unmöglich machen würde.
const store = haro ( null , { key : 'guid' , index : [ 'name' , 'name|age' , 'age' ] } ) ,
data = [ { guid : 'abc' , name : 'John Doe' , age : 30 } , { guid : 'def' , name : 'Jane Doe' , age : 28 } ] ;
store . batch ( data , 'set' ) ;
console . log ( store . where ( { name : 'John Doe' , age : 30 } ) ) ; // [{guid: 'abc', name: 'John Doe', age: 30}] Copyright (C) 2024 Jason Mulligan lizenziert gemäß der BSD-3-Lizenz
