N3.js
v1.23.0
Die N3.JS-Bibliothek ist eine Implementierung der RDF.JS-Low-Level-Spezifikation, mit der Sie RDF in JavaScript problemlos verarbeiten können. Es bietet:
Parsen und Schreiben ist:
Für Node.js ist N3.JS als NPM -Paket.
$ npm install n3 const N3 = require ( 'n3' ) ; N3.JS arbeitet nahtlos in Browsern über Webpack oder Browserify. Wenn Sie mit diesen Tools nicht vertraut sind, können Sie WebPack: Erstellen eines Bündels lesen - Erste Schritte oder Einführung in das Browserify . Sie müssen ein "UMD -Bundle" erstellen und einen Namen angeben (zB mit der Option -s N3 in Browserify).
Sie können es auch über CDN laden:
< script src =" https://unpkg.com/n3/browser/n3.min.js " > </ script > N3.js folgt der Spezifikation mit niedriger Ebene rdf.js.
N3.DataFactory gibt Ihnen die Werksfunktionen, um Dreifach und Quads zu erstellen:
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 ) ; // enIm Rest dieses Dokuments behandeln wir "Triple" und "Quads" gleichermaßen: Wir gehen davon aus, dass ein Quad einfach ein Triple in einem benannten oder Standarddiagramm ist.
N3.Parser transformiert Turtle, Trig, N-Trapfen oder N-Quads-Dokument in Quads durch einen Rückruf:
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 ) ;
} ) ; Das erste Argument des Rückrufs ist ein optionaler Fehlerwert, das zweite ist ein Quad. Wenn es keine Quads mehr gibt, wird der Rückruf ein letztes Mal mit null für quad und einem Hash von Präfixen als drittes Argument aufgerufen.
Alternativ kann ein Objekt geliefert werden, wo onQuad , onPrefix und onComment verwendet werden, um quads , prefixes und comments wie folgt zuzuhören:
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 ) ; } ,
} ) ;Wenn keine Rückrufe zur Verfügung gestellt werden, kommt es synchron, ein Array von Quads zurückzugeben:
const parser = new N3 . Parser ( ) ;
// An array of resultant Quads
const quadArray = parser . parse ( tomAndJerry ) ; Standardmäßig analysiert N3.Parser ein zulässiger Superet von Turtle, Trig, N-Triples und N-Quads.
Für strikte Kompatibilität mit einer dieser Sprachen geben Sie ein format über die Schöpfung weiter:
const parser1 = new N3 . Parser ( { format : 'N-Triples' } ) ;
const parser2 = new N3 . Parser ( { format : 'application/trig' } ) ; Notation3 (N3) wird nur durch das format unterstützt:
const parser3 = new N3 . Parser ( { format : 'N3' } ) ;
const parser4 = new N3 . Parser ( { format : 'Notation3' } ) ;
const parser5 = new N3 . Parser ( { format : 'text/n3' } ) ; Es ist möglich, die Basis -IRI des Dokuments bereitzustellen, die Sie analysieren möchten. Dies geschieht durch Übergabe eines baseIRI -Arguments über die Schöpfung:
const parser = new N3 . Parser ( { baseIRI : 'http://example.org/' } ) ; Standardmäßig wird N3.Parser leere Knotenbezeichnungen mit einem b{digit}_ Präfix präfixen. Dies geschieht, um Kollisionen von nicht verwandten leeren Knoten mit identischen Etiketten zu verhindern. Das blankNodePrefix -Konstruktor -Argument kann verwendet werden, um das Präfix zu ändern, oder, wenn sie auf eine leere Zeichenfolge festgelegt werden, das Präfix vollständig deaktivieren:
const parser = new N3 . Parser ( { blankNodePrefix : '' } ) ; N3.Parser kann Node.js -Streams analysieren, während sie wachsen, und gibt Quads zurück, sobald sie bereit sind.
const parser = new N3 . Parser ( ) ,
rdfStream = fs . createReadStream ( 'cartoons.ttl' ) ;
parser . parse ( rdfStream , console . log ) ; N3.StreamParser ist ein Node.js -Stream und die Implementierung von Rdf.js Sink. Diese Lösung ist ideal, wenn Ihr Verbraucher langsamer ist, da die Quelldaten nur gelesen werden, wenn der Verbraucher bereit ist.
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 ;
} Ein dediziertes prefix signalisiert jedes Präfix mit prefix und term . Ein dediziertes comment kann aktiviert werden, indem comments: true im n3.StreamParser -Konstruktor.
N3.Writer serialisiert Quads als RDF -Dokument. Schreiben Sie Quads über 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 ) ) ; Standardmäßig schreibt N3.Writer Schildkröte (oder Trig, wenn sich einige Quads in einer genannten Grafik befinden).
Um N-Traples (oder N-Quads) stattdessen zu schreiben, geben Sie ein format über die Schöpfung weiter:
const writer1 = new N3 . Writer ( { format : 'N-Triples' } ) ;
const writer2 = new N3 . Writer ( { format : 'application/trig' } ) ; N3.Writer kann auch Quads in einen Node.js -Stream über addQuad schreiben.
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 ( ) ; N3.StreamWriter ist ein Node.js -Stream und RDF.JS Sink Implementierung.
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 ) ; Vielleicht möchten Sie die […] und die Liste (…) Schildkröte und Trigg. Ein Streaming -Schriftsteller kann diese jedoch nicht automatisch erstellen: Die Kurznotierungen sind nur möglich, wenn keine leeren Knoten oder Listenköpfe später verwendet werden, was nur am Ende des Streams endgültig bestimmt werden kann.
Mit den blank und list können Sie sie stattdessen manuell erstellen:
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 können Sie Dreifachspeicher speichern und schnell finden.
In diesem Beispiel erstellen wir ein neues Geschäft und fügen die Triple hinzu :Pluto a :Dog. und :Mickey a :Mouse .
Dann finden wir Dreifach mit :Mickey als Thema.
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 ) ;Wenn Sie mehrere Geschäfte verwenden, können Sie den Speicherverbrauch reduzieren, indem Sie einen Entitätsindex teilen:
const entityIndex = new N3 . EntityIndex ( ) ;
const store1 = new N3 . Store ( [ ] , { entityIndex } ) ;
const store2 = new N3 . Store ( [ ] , { entityIndex } ) ;Dataset Dieser Speicher haftet an der Dataset , die die folgenden Eigenschaften enthüllt
Attribute:
size -Eine nicht negative Ganzzahl, die die Anzahl der Quads im Satz angibt.Methoden:
add - Fügt dem Datensatz das angegebene Quad hinzu. Bestehende Quads, wie in Quad.equals definiert, werden ignoriert.delete - Entfernt das angegebene Quad aus dem Datensatz.has - bestimmt, ob ein Datensatz ein bestimmtes Quad enthält.match - Gibt einen neuen Datensatz zurück, der aus allen Quads in der aktuellen Instanz besteht, die den angegebenen Argumenten entspricht.[Symbol.iterator] - Implementiert das Iteratorprotokoll, um die Iteration über alle quads im Datensatz wie im obigen Beispiel zu ermöglichen. Der Speicher implementiert neben der Standard Dataset (Dokumentation) die folgenden Manipulationsmethoden:
addQuad ein Quad einfügenaddQuads zum Einfügen einer Reihe von Quads hinzufügenremoveQuad um ein Quad zu entfernenremoveQuads um eine Reihe von Quads zu entfernenremove um einen Quadsstrom zu entfernenremoveMatches um alle Quads zu entfernen, die dem angegebenen Muster entsprechendeleteGraph um alle Quads mit der angegebenen Grafik zu entfernencreateBlankNode gibt einen nicht verwendeten leeren Knotenkennung zurückDer Store enthält die folgenden Suchmethoden (Dokumentation):
match gibt einen Stream und einen Generator von Quads zurück, der dem angegebenen Muster entsprichtgetQuads gibt eine Reihe von Quads zurück, die dem angegebenen Muster entsprechencountQuads zählt die Anzahl der Quads, die dem angegebenen Muster entsprechenforEach führt einen Rückruf auf allen passenden Quads ausevery kehrt zurück, ob ein Rückruf für passende Quads immer wahr zurückgibtsome geben zurück, ob ein Rückruf für passende Quads mindestens einmal true zurückkehrtgetSubjects gibt eine Reihe von einzigartigen Probanden zurück, die in passenden Quads auftretenforSubjects führt einen Rückruf zu einzigartigen Themen aus, die in passenden Quads auftretengetPredicates gibt eine Reihe von einzigartigen Prädikaten zurück, die im passenden Quad auftretenforPredicates führt einen Rückruf von einzigartigen Prädikaten aus, die in passenden Quads auftretengetObjects gibt eine Reihe einzigartiger Objekte zurück, die im passenden Quad auftretenforObjects führen einen Rückruf von einzigartigen Objekten aus, die in passenden Quads auftretengetGraphs gibt eine Reihe von einzigartigen Grafiken zurück, die im passenden Quad auftretenforGraphs führen einen Rückruf für eindeutige Diagramme aus, die in passenden Quads auftreten N3.js unterstützt die Argumentation wie folgt:
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 ) ;Hinweis : N3.Js unterstützt derzeit nur Regeln mit grundlegenden Graphenmustern in der Prämisse und Schlussfolgerung. Eingebaute und rückwärts kasping werden nicht unterstützt. Für einen RDF/JS-Reasator, der alle Merkmale von Notation3 unterstützt, siehe Eye-JS.
Der N3.JS -Parser und der Schriftsteller sind mit den folgenden W3C -Spezifikationen vollständig kompatibel:
Darüber hinaus unterstützt der N3.JS -Parser auch Notation3 (N3) (noch keine offizielle Spezifikation).
Der N3.JS-Parser und der Schriftsteller sind auch vollständig mit den RDF-Stern-Varianten der W3C-Spezifikationen kompatibel.
Der Standardmodus ist zulässig und ermöglicht eine Mischung verschiedener Syntaxe, einschließlich RDF-Stern. Geben Sie eine format mit dem Namen oder MIME-Typ eines Formats für strenger, fehlerintoleranter Verhalten an den Konstruktor weiter. Wenn eine Formatkette star oder * (z. B. turtlestar oder TriG* ) enthält, wird die RDF-Stern-Unterstützung für dieses Format aktiviert.
Die N3.JS -Submodule sind mit den folgenden RDF.JS -Schnittstellen kompatibel:
N3.DataFactory implementiert DataFactoryTerm und eines von NamedNode , BlankNode , Literal , Variable , DefaultGraphTerm , Triple und Quad erstelltN3.StreamParser implementiert Stream und SinkN3.StreamWriter implementiert Stream und SinkN3.Store implementiert Store Source Sink DatasetCore Die N3.JS -Bibliothek wird von Ruben Verborgh urheberrechtlich geschützt und unter der MIT -Lizenz veröffentlicht.
Beiträge sind willkommen, und Fehlerberichte oder Zuganfragen sind immer hilfreich. Wenn Sie vorhaben, eine größere Funktion zu implementieren, kontaktieren Sie mich zuerst.
