Ecco alcuni esempi di cosa puoi fare con la mia (piccola [jslt.min.js] ) JSLT - trasformazioni leggere JavaScript:
https://jsfiddle.net/YSharpLanguage/c7usrpsL/10
( [jslt.min.js] pesa ~ 3.1kb minimizzato )
cioè solo una funzione,
function Per ( subject ) { ... }
... che in realtà imita il modello di elaborazione di XSLT (1.0) .
(cfr. le funzioni interne "trasforma" e "modello", nel corpo di Per)
Quindi, in sostanza, è semplicemente tutto racchiuso in quel singolo function Per ( subject ) { ... }che forgia la sua valutazione sul tipo del suo (anche) unico argomento, per implementare:
1) Oggetto dell'array
creazione / filtraggio / appiattimento / raggruppamento / ordinamento di nodi del nodo , se il soggetto è un array, in cui il nodo risultante (anche un array ) viene esteso e associato a metodi di conseguenza definiti ( solo l' istanza di array restituita della chiamata a Per ( subjectArray )è esteso; ovvero, Array.prototype non viene toccato)
vale a dire, Per :: Array --> Array
(i metodi di estensione dell'array risultanti che hanno nomi autoesplicativi come groupBy, orderBy, flattenBy, ecc. - cfr. l'uso negli esempi)
2) Oggetto della stringa
interpolazione di stringhe , se soggetto è una stringa
("Per" restituisce quindi un oggetto con un metodo map ( source ), che è associato alla stringa del modello soggetto )
vale a dire, Per :: String --> {map :: ( AnyValue --> String )}
per esempio,
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:
"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 ], ", ")
i rendimenti
"Those '0, 1, 2, 3, 4, 5, 6, 7, 8, 9' are our 10 digits."
3) Trasforma soggetto
Trasformazione simile a XSLT , se l'oggetto è un hash con un membro "$" convenzionalmente definito che fornisce l'array di regole di riscrittura (e lo stesso di in (2), "Per" quindi restituisce un oggetto con un metodo map ( source )associato al soggetto trasforma - dove
"ruleName" in Per ( subjectTransform [ , ruleName ])è facoltativo e fornisce funzionalità simili a <xsl: call-template name = "templateName"> ...)
vale a dire, Per :: ( Transform [, ruleName :: String ]) -->{map :: ( AnyValue --> AnyValue )}
con
Trasforma :: {$ :: Matrice di regole di riscrittura [rw.r.] }
( [rw.r.] predicato e coppie di funzioni modello)
ad esempio, dato (... un altro esempio inventato)
// (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)" }
mentre ... (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 identità , in tutti gli altri casi
vale a dire, Per :: T --> T
(cioè, Per === function ( value ) { return value ; })
Nota
in (3) sopra, un "questo" di JavaScript nel corpo di una funzione modello è quindi associato alla trasformazione contenitore / proprietario e al suo insieme di regole (come definito dalla matrice $: [...]) - pertanto, rendendo l'espressione "Per (questo)", in quel contesto, un equivalente funzionalmente vicino agli XSLT
<xsl:apply-templates select="..."/>
'HTH,