Ecco alcuni esempi di cosa puoi fare con il mio (piccolo [jslt.min.js] ) JSLT - JavaScript Lightweight Transforms:
link
( [jslt.min.js] pesa ~ 3.1kb minified )
cioè, una sola funzione,
function Per ( subject ) { ... }
... che imita in realtà il modello di elaborazione XSLT (1.0) .
(vedi le funzioni interne "transform" e "template", nel corpo di Per)
Quindi, in sostanza, è semplicemente tutto il tutto racchiuso in quel singolo function Per ( subject ) { ... } che forks la sua valutazione sul tipo del suo argomento (anche) univoco, da implementare, sia:
1) Matrice soggetto
creazione / filtraggio / appiattimento / raggruppamento / ordinamento / etc di nodeset, se subject è un array, dove il risultante nodeset (una Array pure) viene esteso con, e associato a metodi denominati di conseguenza ( solo l'istanza Array restituita alla chiamata a Per ( subjectArray ) viene estesa, ovvero, Array.prototype non viene toccato)
vale a dire, Per :: Matrice --> Matrice
(i metodi di estensione di Array risultanti con nomi autoesplicativi come, groupBy, orderBy, flattenBy, ecc. - cf. l'uso negli esempi)
2) Stringa soggetto
interpolazione stringa , se subject è una stringa
("Per" restituisce quindi un oggetto con un metodo map ( source ) , che è associato al soggetto modello stringa)
cioè, Per :: Stringa --> {map :: ( AnyValue --> Stringa )}
per es.,
Per("Hi honey, my name is {last}. {first}, {last}.").map({ "first": "James", "last": "Bond" })
rendimenti:
"Hi honey, my name is Bond. James, Bond."
mentre uno dei
Per("Those '{*}' are our 10 digits.").map([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ])
o
Per("Those '{*}' are our 10 digits.").map(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
produce lo stesso risultato:
"Those '0123456789' are our 10 digits."
ma solo
Per("Those '{*}' are our 10 digits.").map([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ], ", ")
rendimenti
"Those '0, 1, 2, 3, 4, 5, 6, 7, 8, 9' are our 10 digits."
3) Trasforma soggetto
Trasformazione simile allo XSLT , se il soggetto è un hash con un membro convenzionalmente definito "$" che fornisce l'array di regole di riscrittura (e lo stesso di ( 2), "Per" restituisce quindi un oggetto con un metodo map ( source ) associato alla trasformazione dell'oggetto - dove
"ruleName" in Per ( subjectTransform [ , ruleName ]) è facoltativo e offre funzionalità simili a < xsl: call-template name="templateName" > ...)
cioè, Per :: ( Trasforma [ ruleName :: Stringa ]) --> {map :: ( AnyValue --> AnyValue )}
con
Trasforma : {$ :: Array delle regole di riscrittura [rw.r.] }
( [rw.r.] predicato e coppie di funzioni template)
per esempio, dato (... un altro esempio forzato)
// (A "Member" must have first and last names, and a gender)
function Member(obj) {
return obj.first && obj.last && obj.sex;
}
var a_transform = { $: [
//...
[ [ Member ], // (alike <xsl:template match="...">...)
function(member) {
return {
li: Per("{first} {last}").map(member) +
" " +
Per(this).map({ gender: member.sex })
};
}
],
[ [ function(info) { return info.gender; } ], // (alike <xsl:template match="...">...)
function(info) { return Per("(gender: {gender})").map(info); }
],
[ [ "betterGenderString" ], // (alike <xsl:template name="betterGenderString">...)
function(info) {
info.pronoun = info.pronoun || "his/her";
return Per("({pronoun} gender is {gender})").map(info);
}
]
//...
] };
poi
Per(a_transform).map({ "first": "John", "last": "Smith", "sex": "Male" })
rendimenti:
{ "li": "John Smith (gender: Male)" }
while ... (molto simile <xsl:call-template name="betterGenderString">... )
"James Bond... " +
Per(a_transform, "betterGenderString").map({ "pronoun": "his", "gender": "Male" })
rendimenti:
"James Bond... (his gender is Male)"
e
"Someone... " +
Per(a_transform, "betterGenderString").map({ "gender": "Male or Female" })
rendimenti:
"Someone... (his/her gender is Male or Female)"
4) Altrimenti
la funzione di identità , in tutti gli altri casi
cioè, Per :: T --> T
(cioè, Per === function ( value ) { return value ; } )
Nota
in (3) sopra, un "questo" di JavaScript nel corpo di una funzione template è quindi legato al contenitore / proprietario Transform e al suo insieme di regole (come definito da $: [ ...] array) - quindi, facendo dell'espressione "Per (this)", in quel contesto, un equivalente funzionalmente simile a XSLT
<xsl:apply-templates select="..."/>
'HTH,