haro
1.0.0
Haro เป็นที่เก็บข้อมูลที่ไม่เปลี่ยนรูปแบบทันสมัยที่สร้างขึ้นด้วยคุณสมบัติ ES6 มันไม่ได้เปิดตัวและเสนอโซลูชัน "ปลั๊กและเล่น" สำหรับการสร้างแบบจำลองการค้นหาและการจัดการข้อมูลบนไคลเอนต์หรือเซิร์ฟเวอร์ (ใน RAM) มันเป็นโครงสร้างข้อมูลที่ถาวรบางส่วนโดยการบำรุงรักษาชุดของระเบียนใน versions (MVCC)
วิธีการทั้งหมดเป็นแบบซิงโครนัส
ดัชนี HARO มี Map (field/property) > Map (value) > Set (PKs) ซึ่งอนุญาตให้ค้นหาได้อย่างรวดเร็วและง่ายดายรวมถึงการตรวจสอบ ดัชนีสามารถจัดการได้อย่างอิสระจากการดำเนินงาน del() & set() ตัวอย่างเช่นคุณสามารถสร้างดัชนีใหม่อย่างเกียจคร้านผ่าน reindex(field) หรือ sortBy(field)
HARO มีการครอบคลุมรหัส 100% พร้อมการทดสอบ
----------|---------|----------|---------|---------|-------------------------------------------------------------------------------------------------------
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
----------|---------|----------|---------|---------|------------------------------------------------------------------------------------------------------- การส่งออกที่มีชื่อคือ haro และการส่งออกคลาสที่มีชื่อคือ Haro
import { haro } from 'haro' ; const { haro } = require ( 'haro' ) ; Haro ใช้อาร์กิวเมนต์เสริมสองข้อแรกคือ Array ของระเบียนที่จะตั้งค่าแบบอะซิงโครนัสและที่สองคือตัวบ่งชี้การกำหนดค่า
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} เกณฑ์มาตรฐานรวมอยู่ในพื้นที่เก็บข้อมูลและมีประโยชน์สำหรับการประเมินว่าฮาโรจะทำงานอย่างไรกับฮาร์ดแวร์และซอฟต์แวร์ที่แตกต่างกัน
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
การทำงาน
ฟังเหตุการณ์ก่อนการดำเนินการแบทช์จะได้รับ type data
การทำงาน
ฟังเหตุการณ์ก่อนที่จะล้างข้อมูลที่เก็บข้อมูล
การทำงาน
ผู้ฟังเหตุการณ์ก่อนที่จะถูกลบบันทึกได้รับ key batch
การทำงาน
ฟังเหตุการณ์สำหรับก่อนที่จะตั้งค่าบันทึกรับ key data
อาร์เรย์
อาร์เรย์ของค่าเป็นดัชนี ดัชนีคอมโพสิตได้รับการสนับสนุนโดยใช้ตัวคั่นเริ่มต้น ( this.delimiter ) การไม่จับคู่ภายในคอมโพสิตส่งผลให้ค่าว่างเปล่า
ตัวอย่างของฟิลด์/คุณสมบัติเป็นดัชนี:
const store = haro ( null , { index : [ 'field1' , 'field2' , 'field1|field2|field3' ] } ) ;สาย
คีย์ Object เสริมที่จะใช้เป็นคีย์ Map เริ่มต้นไปยังเวอร์ชัน 4 UUID หากไม่ได้ระบุหรือพบ
ตัวอย่างของการระบุคีย์หลัก:
const store = haro ( null , { key : 'field' } ) ;บูลีน
บันทึกข้อความเก็บข้อมูลแบบถาวรเป็น console ค่าเริ่มต้นเป็น true
การทำงาน
ผู้ฟังเหตุการณ์สำหรับการดำเนินการแบทช์ได้รับสองอาร์กิวเมนต์ ['ประเภท' Array ]
การทำงาน
ผู้ฟังเหตุการณ์เพื่อล้างข้อมูลที่เก็บข้อมูล
การทำงาน
ผู้ฟังเหตุการณ์เมื่อมีการลบบันทึกจะได้รับคีย์บันทึก
การทำงาน
ฟังเหตุการณ์สำหรับเมื่อที่เก็บข้อมูลเปลี่ยนชุดข้อมูลทั้งหมดจะได้รับการตั้งชื่อ String สิ่งที่เปลี่ยนแปลง ( indexes หรือ records )
การทำงาน
ผู้ฟังเหตุการณ์เมื่อมีการตั้งค่าบันทึกจะได้รับ Array
บูลีน
เปิด/ปิดใช้งานการกำหนดเวอร์ชันสไตล์ MVCC ของบันทึกค่าเริ่มต้นเป็น false เวอร์ชันจะถูกเก็บไว้ใน Sets เพื่อการทำซ้ำง่าย
ตัวอย่างการเปิดใช้งานเวอร์ชัน:
const store = haro ( null , { versioning : true } ) ; แผนที่
Map ของระเบียนอัปเดตโดย del() & set()
แผนที่
แผนที่ของดัชนีซึ่งเป็นชุดที่มีปุ่มแผนที่
อาร์เรย์
อาร์เรย์แสดงถึงคำสั่งของ this.data data
ตัวเลข
จำนวนระเบียนในดาต้าสโตร์
แผนที่
Map ของ Sets บันทึกที่อัปเดตโดย set()
อาร์เรย์
อาร์กิวเมนต์แรกจะต้องเป็น Array และอาร์กิวเมนต์ที่สองจะต้องเป็น del หรือ set
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' ) ;ตัวเอง
ลบคู่คีย์/ค่าทั้งหมดออกจากที่เก็บข้อมูล
ตัวอย่างการล้างข้อมูล:
const store = haro ( ) ;
// Data is added
store . clear ( ) ;ไม่ได้กำหนด
ลบบันทึก
ตัวอย่างการลบบันทึก:
const store = haro ( ) ,
rec = store . set ( null , { abc : true } ) ;
store . del ( rec [ 0 ] ) ;
console . log ( store . size ) ; // 0อาร์เรย์ หรือ วัตถุ
ส่งคืนระเบียนหรือดัชนีของที่เก็บข้อมูลเป็น Array หรือ Object ที่ไม่แน่นอนสำหรับความตั้งใจที่จะนำกลับมาใช้ใหม่/จัดเก็บถาวรโดยไม่ต้องพึ่งพาอะแดปเตอร์ซึ่งจะแยกชุดข้อมูล
const store = haro ( ) ;
// Data is loaded
const records = store . dump ( ) ;
const indexes = store . dump ( 'indexes' ) ;
// Save records & indexesเครื่องพาย
ส่งคืนวัตถุ Iterator ซ้ำใหม่ที่มีอาร์เรย์ของ [key, value] สำหรับแต่ละองค์ประกอบในวัตถุ Map ในลำดับการแทรก
ตัวอย่างการลบบันทึก:
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 ของ Arrays คู่ที่มีรูปร่าง [key, value] สำหรับบันทึกที่ส่งคืน true ไปยัง callbackFn(value, key)
ตัวอย่างการกรองที่เก็บข้อมูล:
const store = haro ( ) ;
// Data is added
store . filter ( function ( value ) {
return value . something === true ;
} ) ;อาร์เรย์
ส่งคืน Array ของ Arrays สองครั้งที่พบโดยค่าที่จัดทำดัชนีตรงกับ where
ตัวอย่างการค้นหาบันทึกที่มีการจับคู่ข้อมูลประจำตัว:
const store = haro ( null , { index : [ 'field1' ] } ) ;
// Data is added
store . find ( { field1 : 'some value' } ) ;ไม่ได้กำหนด
การ callbackFn หนึ่งครั้งสำหรับคู่คีย์-ค่าแต่ละคู่ที่อยู่ในวัตถุ Map ตามลำดับการแทรก หากมีการจัดเตรียมพารามิเตอร์ thisArg ให้กับ forEach มันจะถูกใช้เป็นค่า this สำหรับการโทรกลับแต่ละครั้ง
ตัวอย่างการลบบันทึก:
const store = haro ( ) ;
store . set ( null , { abc : true } ) ;
store . forEach ( function ( value , key ) {
console . log ( key ) ;
} ) ;อาร์เรย์
รับเร็กคอร์ดเป็น Array คู่ที่มีรูปร่าง [key, value]
ตัวอย่างการรับบันทึกด้วยค่าคีย์หลักที่รู้จัก:
const store = haro ( ) ;
// Data is added
store . get ( 'keyValue' ) ;บูลีน
ส่งคืน Boolean ที่ระบุว่าที่เก็บข้อมูลมี key หรือไม่
ตัวอย่างการตรวจสอบบันทึกที่มีค่าคีย์หลักที่รู้จัก:
const store = haro ( ) ;
// Data is added
store . has ( 'keyValue' ) ; // true or falseเครื่องพาย
ส่งคืนวัตถุ Iterator ใหม่ที่มีคีย์สำหรับแต่ละองค์ประกอบในวัตถุ Map ในลำดับการแทรก '
ตัวอย่างการรับตัววนซ้ำและบันทึกผลลัพธ์:
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 ของ Arrays คู่ที่มีรูปร่าง [key, value] สำหรับช่วงบันทึกที่สอดคล้องกัน
ตัวอย่างของการแบ่งแยกชุดข้อมูล:
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 ] ) ) ; // falseอาร์เรย์
ส่งคืน Array ของผลตอบแทนของ callbackFn(value, key) หาก raw เป็น true Array จะถูกส่งคืน
ตัวอย่างการแมปข้อมูล:
const store = haro ( ) ;
// Data is added
store . map ( function ( value ) {
return value . property ;
} ) ;บูลีน
สิ่งนี้มีความหมายว่าจะใช้ในการแทนที่ดัชนีและบันทึกที่จับคู่เช่นคุณสามารถหลีกเลี่ยงเส้นทางรหัสตาม Promise ของ batch() แทรกหรือ load() ยอมรับพารามิเตอร์ที่สามที่เป็นตัวเลือกเพื่อทำการแปลงเพื่อลดความซับซ้อนของปัญหาโดเมนข้าม
ตัวอย่างของการแทนที่ที่เก็บข้อมูล:
const store = haro ( ) ;
store . override ( { 'field' : { 'value' : [ 'pk' ] } } , "indexes" ) ;อาร์เรย์
เรียกใช้ฟังก์ชั่นที่ได้รับแรงบันดาลใจจาก Array.reduce() กับ Data Store ( Map )
ตัวอย่างการกรองที่เก็บข้อมูล:
const store = haro ( ) ;
// Data is added
store . reduce ( function ( accumulator , value , key ) {
accumulator [ key ] = value ;
return accumulator ;
} , { } ) ;Haro
จัดทำดัชนีที่เก็บข้อมูลอีกครั้งหากเปลี่ยนค่าของ index
ตัวอย่างการแมปข้อมูล:
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 ของ Arrays สองครั้งที่มีรูปร่าง [key, value] ของบันทึกที่พบการจับคู่ arg หาก arg เป็น Function (พารามิเตอร์คือ value และ index ) การจับคู่จะถูกสร้างขึ้นหากผลลัพธ์เป็น true ถ้า arg เป็น RegExp ค่าฟิลด์จะต้อง .test() เป็น true อื่น ๆ ค่าจะต้องตรงกับตัวตน พารามิเตอร์ index อาจเป็น String หรือ Array ของ Strings หากไม่ได้ให้ค่าเริ่มต้นไปยัง this.index
Arrays ที่จัดทำดัชนีซึ่งทดสอบด้วย RegExp จะได้รับการปฏิบัติเป็น String ที่คั่นด้วยเครื่องหมายจุลภาคเช่น ['hockey', 'football'] กลายเป็น 'hockey, football' สำหรับ RegExp
ตัวอย่างของการค้นหาด้วยฟังก์ชั่นภาคแสดง:
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}]]วัตถุ
บันทึกในที่เก็บข้อมูล หาก key เป็น false เวอร์ชัน 4 UUID จะถูกสร้างขึ้น
หาก override เป็น true บันทึกที่มีอยู่จะถูกแทนที่แทนการแก้ไข
ตัวอย่างการสร้างบันทึก:
const store = haro ( null , { key : 'id' } ) ,
record = store . set ( null , { id : 1 , name : 'John Doe' } ) ;
console . log ( record ) ; // [1, {id: 1, name: 'Jane Doe'}]อาร์เรย์
ส่งคืนอาร์เรย์ของที่เก็บข้อมูลเรียงตาม callbackFn
ตัวอย่างของการเรียงลำดับเช่น 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 ของ Arrays คู่ที่มีรูปร่าง [key, value] ของระเบียนที่เรียงลำดับตามดัชนี
ตัวอย่างของการเรียงลำดับโดยดัชนี:
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 :
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}]เครื่องพาย
ส่งคืนวัตถุ Iterator ใหม่ที่มีค่าสำหรับแต่ละองค์ประกอบในวัตถุ Map ในลำดับการแทรก
ตัวอย่างการวนซ้ำค่า:
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 ของค่าซึ่งจะทำให้การจับคู่กับค่าเดียวที่เป็นไปไม่ได้เมื่อใช้ find()
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}] ลิขสิทธิ์ (c) 2024 Jason Mulligan ได้รับใบอนุญาตภายใต้ใบอนุญาต BSD-3
