หน้าแรก>การเขียนโปรแกรมที่เกี่ยวข้อง>ซอร์สโค้ดอื่น ๆ
ดาวน์โหลด

ฟ้าผ่าอย่างรวดเร็วแบบอะซิงโครนัสสตรีมมิ่ง RDF สำหรับ JavaScript

สร้างสถานะ

ไลบรารี N3.JS เป็นการใช้งานข้อกำหนดระดับต่ำ RDF.JS ที่ให้คุณจัดการ RDF ใน JavaScript ได้อย่างง่ายดาย ข้อเสนอ:

  • การแยกวิเคราะห์ สาม/สี่เหลี่ยมจากเต่า, Trig, N-triples, N-Quads, RDF-Star และ Notation3 (N3)
  • การเขียน Triples/Quads ไปยัง Turtle, Trig, N-triples, N-Quads และ RDF-Star
  • การจัดเก็บ ของอเนกประสงค์/สี่เหลี่ยมในหน่วยความจำ

การแยกวิเคราะห์และการเขียนคือ:

  • - ASYNCHRONOUS - TIPLES จะมาถึงโดยเร็วที่สุด
  • - สตรีมมิ่ง - สตรีมจะแยกวิเคราะห์เมื่อข้อมูลเข้ามาดังนั้นคุณสามารถแยกวิเคราะห์ไฟล์ที่ใหญ่กว่าหน่วยความจำ
  • ⚡ เร็ว - อเนกประสงค์กำลังบินด้วยความเร็วสูง

การติดตั้ง

สำหรับ node.js, n3.js มาเป็นแพ็คเกจ NPM 

$ npm install n3
 const N3 = require ( 'n3' ) ;

N3.JS ทำงานได้อย่างราบรื่นในเบราว์เซอร์ผ่าน WebPack หรือ Browserify หากคุณไม่คุ้นเคยกับเครื่องมือเหล่านี้คุณสามารถอ่าน webpack: การสร้างชุด - เริ่มต้น หรือ แนะนำให้รู้จักกับเบราว์เซอร์ คุณจะต้องสร้าง "Bundle UMD" และจัดหาชื่อ (เช่นตัวเลือก -s N3 ใน Browserify)

นอกจากนี้คุณยังสามารถโหลดผ่าน CDN: 

 < script src =" https://unpkg.com/n3/browser/n3.min.js " > </ script >

การสร้าง triples/quads

N3.JS ติดตามข้อมูลจำเพาะระดับต่ำ RDF.JS

N3.DataFactory จะให้ฟังก์ชั่นโรงงานเพื่อสร้างสามและสี่เท่า: 

 const { DataFactory } = N3 ;
const { namedNode , literal , defaultGraph , quad } = DataFactory ;
const myQuad = quad (
  namedNode ( 'https://ruben.verborgh.org/profile/#me' ) , // Subject
  namedNode ( 'http://xmlns.com/foaf/0.1/givenName' ) ,    // Predicate
  literal ( 'Ruben' , 'en' ) ,                              // Object
  defaultGraph ( ) ,                                      // Graph
) ;
console . log ( myQuad . termType ) ;              // Quad
console . log ( myQuad . value ) ;                 // ''
console . log ( myQuad . subject . value ) ;         // https://ruben.verborgh.org/profile/#me
console . log ( myQuad . object . value ) ;          // Ruben
console . log ( myQuad . object . datatype . value ) ; // http://www.w3.org/1999/02/22-rdf-syntax-ns#langString
console . log ( myQuad . object . language ) ;       // en

ในส่วนที่เหลือของเอกสารนี้เราจะปฏิบัติต่อ“ สาม” และ“ ลี่” อย่างเท่าเทียมกัน: เราคิดว่ารูปสี่เหลี่ยมเป็นเพียงสามในกราฟที่มีชื่อหรือเริ่มต้น

การแยกวิเคราะห์

จากเอกสาร RDF ถึง Quads

N3.Parser แปลงเอกสาร Trig, N-triples หรือ N-Quads เป็นรูปสี่เหลี่ยมจัตุรัสผ่านการโทรกลับ: 

 const tomAndJerry = `PREFIX c: <http://example.org/cartoons#>
  # Tom is a cat
  c:Tom a c:Cat.
  c:Jerry a c:Mouse;
    c:smarterThan c:Tom.`

const parser = new N3 . Parser ( ) ;

parser . parse ( tomAndJerry ,
  ( error , quad , prefixes ) => {
    if ( quad )
      console . log ( quad ) ;
    else
      console . log ( "# That's all, folks!" , prefixes ) ;
  } ) ;

อาร์กิวเมนต์แรกของการโทรกลับเป็นค่าข้อผิดพลาดที่เป็นตัวเลือกที่สองคือรูปสี่เหลี่ยม หากไม่มีสี่เท่าการเรียกกลับจะถูกเรียกใช้ครั้งสุดท้ายด้วย null สำหรับ quad และแฮชของคำนำหน้าเป็นอาร์กิวเมนต์ที่สาม

อีกทางเลือกหนึ่งสามารถจัดหาวัตถุได้โดยที่ onQuad , onPrefix และ onComment ถูกใช้เพื่อฟัง quads prefixes และ comments ดังต่อไปนี้: 

 const parser = new N3 . Parser ( ) ;

parser . parse ( tomAndJerry , {
  // onQuad (required) accepts a listener of type (quad: RDF.Quad) => void
  onQuad : ( err , quad ) => { console . log ( quad ) ; } ,
  // onPrefix (optional) accepts a listener of type (prefix: string, iri: NamedNode) => void
  onPrefix : ( prefix , iri ) => { console . log ( prefix , 'expands to' , iri . value ) ; } ,
  // onComment (optional) accepts a listener of type (comment: string) => void
  onComment : ( comment ) => { console . log ( '#' , comment ) ; } ,
} ) ;

หากไม่มีการโทรกลับการแยกวิเคราะห์จะเกิดขึ้นแบบซิงโครนัสส่งคืนอาร์เรย์ของสี่เหลี่ยม: 

 const parser = new N3 . Parser ( ) ;

// An array of resultant Quads
const quadArray = parser . parse ( tomAndJerry ) ;

โดยค่าเริ่มต้น N3.Parser จะวิเคราะห์ superset ที่อนุญาตของเต่า, trig, n-triples และ n-quads
สำหรับความเข้ากันได้อย่างเข้มงวดกับภาษาใด ๆ เหล่านั้นให้ผ่านอาร์กิวเมนต์ format เมื่อสร้าง: 

 const parser1 = new N3 . Parser ( { format : 'N-Triples' } ) ;
const parser2 = new N3 . Parser ( { format : 'application/trig' } ) ;

Notation3 (N3) ได้รับการสนับสนุนผ่านอาร์กิวเมนต์ format เท่านั้น : 

 const parser3 = new N3 . Parser ( { format : 'N3' } ) ;
const parser4 = new N3 . Parser ( { format : 'Notation3' } ) ;
const parser5 = new N3 . Parser ( { format : 'text/n3' } ) ;

เป็นไปได้ที่จะให้ฐาน IRI ของเอกสารที่คุณต้องการแยกวิเคราะห์ สิ่งนี้ทำได้โดยการผ่านข้อโต้แย้ง baseIRI เมื่อมีการสร้าง: 

 const parser = new N3 . Parser ( { baseIRI : 'http://example.org/' } ) ;

โดยค่าเริ่มต้น N3.Parser จะนำหน้าป้ายโหนดว่างเปล่าด้วยคำนำหน้า b{digit}_ สิ่งนี้ทำเพื่อป้องกันการชนของโหนดว่างเปล่าที่ไม่เกี่ยวข้องกับฉลากเหมือนกัน อาร์กิวเมนต์ blankNodePrefix constructor สามารถใช้ในการแก้ไขคำนำหน้าหรือหากตั้งค่าเป็นสตริงว่างให้ปิดการใช้งานคำนำหน้าอย่างสมบูรณ์: 

 const parser = new N3 . Parser ( { blankNodePrefix : '' } ) ;

จากสตรีม RDF ถึง Quads

N3.Parser สามารถแยกวิเคราะห์ node.js สตรีมเมื่อพวกเขาเติบโตขึ้นกลับไปตามสี่อย่างทันทีที่พวกเขาพร้อม 

 const parser = new N3 . Parser ( ) ,
      rdfStream = fs . createReadStream ( 'cartoons.ttl' ) ;
parser . parse ( rdfStream , console . log ) ;

N3.StreamParser เป็นสตรีม Node.js และการใช้งาน Sink Sink RDF.JS โซลูชันนี้เหมาะอย่างยิ่งหากผู้บริโภคของคุณช้าลงเนื่องจากข้อมูลต้นฉบับจะอ่านเฉพาะเมื่อผู้บริโภคพร้อมเท่านั้น 

 const streamParser = new N3 . StreamParser ( ) ,
      rdfStream = fs . createReadStream ( 'cartoons.ttl' ) ;
rdfStream . pipe ( streamParser ) ;
streamParser . pipe ( new SlowConsumer ( ) ) ;

function SlowConsumer ( ) {
  const writer = new require ( 'stream' ) . Writable ( { objectMode : true } ) ;
  writer . _write = ( quad , encoding , done ) => {
    console . log ( quad ) ;
    setTimeout ( done , 1000 ) ;
  } ;
  return writer ;
}

เหตุการณ์ prefix โดยเฉพาะส่งสัญญาณทุกคำนำหน้าพร้อม prefix และอาร์กิวเมนต์ term เหตุการณ์ comment เฉพาะสามารถเปิดใช้งานได้โดยการตั้งค่า comments: true ในตัวสร้าง N3.Streamparser

การเขียน

จากลี่ถึงสตริง

N3.Writer ทำให้เป็นลำดับสี่เป็นเอกสาร RDF เขียนล้ำผ่าน addQuad 

 const writer = new N3 . Writer ( { prefixes : { c : 'http://example.org/cartoons#' } } ) ; // Create a writer which uses `c` as a prefix for the namespace `http://example.org/cartoons#`
writer . addQuad ( quad (
  namedNode ( 'http://example.org/cartoons#Tom' ) ,   // Subject
  namedNode ( 'http://example.org/cartoons#name' ) ,  // Predicate
  literal ( 'Tom' )                                  // Object
) ) ;
writer . end ( ( error , result ) => console . log ( result ) ) ;

โดยค่าเริ่มต้น N3.Writer เขียนเต่า (หรือ trig หากมีสี่เท่าอยู่ในกราฟที่มีชื่อ)
หากต้องการเขียน N-triples (หรือ n-quads) แทนให้ส่งอาร์กิวเมนต์ format เมื่อสร้าง: 

 const writer1 = new N3 . Writer ( { format : 'N-Triples' } ) ;
const writer2 = new N3 . Writer ( { format : 'application/trig' } ) ;

จากลี่ไปจนถึงสตรีม RDF

N3.Writer ยังสามารถเขียน quads ไปยังสตรีม node.js ผ่าน addQuad 

 const writer = new N3 . Writer ( process . stdout , { end : false , prefixes : { c : 'http://example.org/cartoons#' } } ) ;
writer . addQuad (
  namedNode ( 'http://example.org/cartoons#Tom' ) ,                   // Subject
  namedNode ( 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type' ) ,   // Predicate
  namedNode ( 'http://example.org/cartoons#Cat' )                    // Object
) ;
writer . addQuad ( quad (
  namedNode ( 'http://example.org/cartoons#Tom' ) ,     // Subject
  namedNode ( 'http://example.org/cartoons#name' ) ,  // Predicate
  literal ( 'Tom' )                                    // Object
) ) ;
writer . end ( ) ;

จากสตรีมรูปสี่เหลี่ยมไปจนถึงสตรีม RDF

N3.StreamWriter เป็นสตรีม Node.js และการใช้งาน Sink Sink 

 const streamParser = new N3 . StreamParser ( ) ,
      inputStream = fs . createReadStream ( 'cartoons.ttl' ) ,
      streamWriter = new N3 . StreamWriter ( { prefixes : { c : 'http://example.org/cartoons#' } } ) ;
inputStream . pipe ( streamParser ) ;
streamParser . pipe ( streamWriter ) ;
streamWriter . pipe ( process . stdout ) ;

โหนดและรายการว่างเปล่า

คุณอาจต้องการใช้ […] และรายการ (…) สัญลักษณ์ของเต่าและทริก อย่างไรก็ตามนักเขียนสตรีมมิ่งไม่สามารถสร้างสิ่งเหล่านี้ได้โดยอัตโนมัติ: สัญลักษณ์ชวเลขเป็นไปได้ก็ต่อเมื่อไม่ได้ใช้โหนดว่างเปล่าหรือหัวรายการในภายหลังซึ่งสามารถกำหนดได้เฉพาะในตอนท้ายของสตรีม

ฟังก์ blank และ list อนุญาตให้คุณสร้างด้วยตนเองแทน: 

 const writer = new N3 . Writer ( { prefixes : { c : 'http://example.org/cartoons#' ,
                                       foaf : 'http://xmlns.com/foaf/0.1/' } } ) ;
writer . addQuad (
  writer . blank (
    namedNode ( 'http://xmlns.com/foaf/0.1/givenName' ) ,
    literal ( 'Tom' , 'en' ) ) ,
  namedNode ( 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type' ) ,
  namedNode ( 'http://example.org/cartoons#Cat' )
) ;
writer . addQuad ( quad (
  namedNode ( 'http://example.org/cartoons#Jerry' ) ,
  namedNode ( 'http://xmlns.com/foaf/0.1/knows' ) ,
  writer . blank ( [ {
    predicate : namedNode ( 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type' ) ,
    object :    namedNode ( 'http://example.org/cartoons#Cat' ) ,
  } , {
    predicate : namedNode ( 'http://xmlns.com/foaf/0.1/givenName' ) ,
    object :    literal ( 'Tom' , 'en' ) ,
  } ] )
) ) ;
writer . addQuad (
  namedNode ( 'http://example.org/cartoons#Mammy' ) ,
  namedNode ( 'http://example.org/cartoons#hasPets' ) ,
  writer . list ( [
    namedNode ( 'http://example.org/cartoons#Tom' ) ,
    namedNode ( 'http://example.org/cartoons#Jerry' ) ,
  ] )
) ;
writer . end ( ( error , result ) => console . log ( result ) ) ;

การเก็บ

N3.Store ช่วยให้คุณสามารถจัดเก็บอเนกประสงค์ไว้ในหน่วยความจำและค้นหาได้อย่างรวดเร็ว

ในตัวอย่างนี้เราสร้างร้านค้าใหม่และเพิ่มอเนกประสงค์ :Pluto a :Dog. และ :Mickey a :Mouse
จากนั้นเราพบสามครั้งด้วย :Mickey เป็นหัวเรื่อง 

 const store = new N3 . Store ( ) ;
store . add (
  quad (
    namedNode ( 'http://ex.org/Pluto' ) ,
    namedNode ( 'http://ex.org/type' ) ,
    namedNode ( 'http://ex.org/Dog' )
  )
) ;
store . add (
  quad (
    namedNode ( 'http://ex.org/Mickey' ) ,
    namedNode ( 'http://ex.org/type' ) ,
    namedNode ( 'http://ex.org/Mouse' )
  )
) ;

// Retrieve all quads
for ( const quad of store )
  console . log ( quad ) ;
// Retrieve Mickey's quads
for ( const quad of store . match ( namedNode ( 'http://ex.org/Mickey' ) , null , null ) )
  console . log ( quad ) ;

หากคุณใช้หลายร้านค้าคุณสามารถลดการใช้หน่วยความจำโดยอนุญาตให้พวกเขาแบ่งปันดัชนีเอนทิตี: 

 const entityIndex = new N3 . EntityIndex ( ) ;
const store1 = new N3 . Store ( [ ] , { entityIndex } ) ;
const store2 = new N3 . Store ( [ ] , { entityIndex } ) ;

อินเตอร์เฟส Dataset

ร้านนี้ยึดติดกับอินเตอร์เฟส Dataset ซึ่งเปิดเผยคุณสมบัติต่อไปนี้

คุณลักษณะ:

  • size -จำนวนเต็มที่ไม่เป็นลบที่ระบุจำนวนของสี่เหลี่ยมในชุด

วิธีการ:

  • add - เพิ่ม Quad ที่ระบุลงในชุดข้อมูล ลี่ที่มีอยู่ตามที่กำหนดไว้ใน Quad.equals จะถูกละเว้น
  • delete - ลบ Quad ที่ระบุออกจากชุดข้อมูล
  • has - กำหนดว่าชุดข้อมูลมีรูปสี่เหลี่ยมหรือไม่
  • match - ส่งคืนชุดข้อมูลใหม่ที่ประกอบด้วยสี่เหลี่ยมจัตุรัสทั้งหมดในอินสแตนซ์ปัจจุบันที่ตรงกับอาร์กิวเมนต์ที่กำหนด
  • [Symbol.iterator] - ใช้โปรโตคอลตัววนซ้ำเพื่ออนุญาตให้วนซ้ำผ่าน quads ทั้งหมดในชุดข้อมูลดังในตัวอย่างด้านบน

นอกจากนี้และการลบสี่เหลี่ยมจัตุรัส

ร้านค้าใช้วิธีการจัดการต่อไปนี้นอกเหนือจากอินเตอร์เฟส Dataset มาตรฐาน (เอกสาร):

  • addQuad เพื่อแทรกหนึ่ง quad
  • addQuads เพื่อแทรกอาร์เรย์ของ Quads
  • removeQuad เพื่อลบหนึ่ง quad
  • removeQuads เพื่อลบอาร์เรย์ของ quads
  • remove เพื่อลบสตรีมของ Quads
  • removeMatches เพื่อลบสี่จั่วทั้งหมดที่ตรงกับรูปแบบที่กำหนด
  • deleteGraph เพื่อลบ Quads ทั้งหมดด้วยกราฟที่กำหนด
  • createBlankNode ส่งคืนตัวระบุโหนดเปล่าที่ไม่ได้ใช้งาน

กำลังค้นหาจวกหรือเอนทิตี

ร้านค้ามีวิธีการค้นหาต่อไปนี้ (เอกสาร):

  • match ส่งคืนสตรีมและเครื่องกำเนิดไฟฟ้าของลี่ที่ตรงกับรูปแบบที่กำหนด
  • getQuads ส่งคืนอาร์เรย์ของลี่ที่ตรงกับรูปแบบที่กำหนด
  • countQuads นับจำนวนสี่เท่าที่ตรงกับรูปแบบที่กำหนด
  • forEach เรียกใช้การโทรกลับในการจับคู่ทั้งหมด
  • every การส่งคืนไม่ว่าจะเป็นการโทรกลับในการจับคู่สี่เหลี่ยมเสมอกลับมาจริง
  • some ส่งคืนไม่ว่าการโทรกลับในการจับคู่สี่จะส่งคืนจริงอย่างน้อยหนึ่งครั้ง
  • getSubjects ส่งคืนอาเรย์ของวิชาที่ไม่ซ้ำกันที่เกิดขึ้นในการจับคู่สี่เหลี่ยม
  • forSubjects เรียกใช้การโทรกลับในวิชาที่ไม่ซ้ำกันที่เกิดขึ้นในการจับคู่ quads
  • getPredicates ส่งคืนอาร์เรย์ของเพรดิเคตที่ไม่ซ้ำกันที่เกิดขึ้นในการจับคู่ quad
  • forPredicates เรียกใช้การโทรกลับในเพรดิเคตที่ไม่ซ้ำกันที่เกิดขึ้นในการจับคู่ quads
  • getObjects ส่งคืนอาร์เรย์ของวัตถุที่ไม่ซ้ำกันที่เกิดขึ้นในการจับคู่ Quad
  • forObjects เรียกใช้การโทรกลับบนวัตถุที่ไม่ซ้ำกันที่เกิดขึ้นในการจับคู่สี่เหลี่ยม
  • getGraphs ส่งคืนอาร์เรย์ของกราฟที่ไม่ซ้ำกันที่เกิดขึ้นในการจับคู่ Quad
  • forGraphs เรียกใช้การโทรกลับบนกราฟที่ไม่ซ้ำกันที่เกิดขึ้นในการจับคู่สี่เหลี่ยม

การให้เหตุผล

N3.JS สนับสนุนการใช้เหตุผลดังนี้: 

 import { Reasoner , Store , Parser } from 'n3' ;

const parser = new Parser ( { format : 'text/n3' } ) ;
const rules = `
{
  ?s a ?o .
  ?o <http://www.w3.org/2000/01/rdf-schema#subClassOf> ?o2 .
} => {
  ?s a ?o2 .
} .
`

const rulesDataset = new Store ( parser . parse ( rules ) ) ;
const dataset = new Store ( /* Dataset */ )

// Applies the rules to the store; mutating it
const reasoner = new Reasoner ( store ) ;
reasoner . reason ( rules ) ;

หมายเหตุ : ปัจจุบัน N3.JS รองรับกฎที่มีรูปแบบกราฟพื้นฐานในหลักฐานและข้อสรุป ไม่ได้ รับการสนับสนุนในตัวและการยึดแบบย้อนหลัง สำหรับผู้ให้เหตุผล RDF/JS ที่รองรับคุณสมบัติการใช้เหตุผลทั้งหมดของ Notation3 ดูที่ Eye-JS

ความเข้ากันได้

ข้อกำหนดรูปแบบ

ตัวแยกวิเคราะห์และนักเขียน N3.JS เข้ากันได้อย่างสมบูรณ์กับข้อกำหนด W3C ต่อไปนี้:

  • RDF 1.1 Turtle - Earl Report
  • RDF 1.1 Trig - รายงาน Earl
  • RDF 1.1 N-Triples-Earl Report
  • RDF 1.1 N-Quads-Earl Report

นอกจากนี้ตัวแยกวิเคราะห์ N3.JS ยังรองรับ Notation3 (N3) (ยังไม่มีข้อกำหนดอย่างเป็นทางการ)

ตัวแยกวิเคราะห์และนักเขียน N3.JS นั้นเข้ากันได้กับตัวแปร RDF-Star ของข้อกำหนด W3C

โหมดเริ่มต้นนั้นอนุญาตและอนุญาตให้มีการผสมผสานของไวยากรณ์ที่แตกต่างกันรวมถึง RDF-Star ส่งตัวเลือก format ไปยังตัวสร้างที่มีชื่อหรือประเภท MIME ของรูปแบบสำหรับพฤติกรรมที่เข้มงวดและไม่ จำกัด หากสตริงรูปแบบมี star หรือ * (เช่น turtlestar หรือ TriG* ) การสนับสนุน RDF-Star สำหรับรูปแบบนั้นจะถูกเปิดใช้งาน

ข้อกำหนดส่วนต่อประสาน

submodules n3.JS เข้ากันได้กับอินเตอร์เฟส RDF.JS ต่อไปนี้:

  • N3.DataFactory ใช้ DataFactory
    • คำศัพท์ที่สร้าง Term ศัพท์และหนึ่งใน NamedNode , BlankNode , Literal Variable , DefaultGraph
    • triples/quads ที่สร้างใช้ Term Triple และ Quad
  • N3.StreamParser ใช้ Stream และ Sink
  • N3.StreamWriter ใช้ Stream และ Sink
  • N3.Store ใช้ Source Sink จาน Store เก็บข้อมูล DatasetCore

ใบอนุญาตและผลงาน

ห้องสมุด N3.JS ได้รับลิขสิทธิ์โดย Ruben Verborgh และเปิดตัวภายใต้ใบอนุญาต MIT

ยินดีต้อนรับการมีส่วนร่วมและรายงานข้อผิดพลาดหรือคำขอดึงมีประโยชน์เสมอ หากคุณวางแผนที่จะใช้ฟีเจอร์ขนาดใหญ่ควรติดต่อฉันก่อน

ขยาย
ข้อมูลเพิ่มเติม
แอปที่เกี่ยวข้อง
แนะนำสำหรับคุณ
ข้อมูลที่เกี่ยวข้อง ทั้งหมด