Nasledujúce pozdĺž línie , Ako predstavovali.b[c.d][e].f[g[h[i.j]]] ako objekt strom?, ako by ste napísať algoritmus na generovanie, že JS AST z výrazu a.b[c.d][e].f[g[h[i.j]]]? Snažím sa písať parser vytvárať nejakú štruktúru objektov z tohto prejavu (ideálne viac intuitívne ako JS AST MemberExpression jeden preto, že inú otázku). By som chcel vidieť, ako algoritmus funguje na výstavbu JavaScript MemberExpression strom.
V súčasnosti som tento druh algoritmus na generovanie nejaký strom (ale to sa zdá byť nesprávne v súčasnosti):
const patterns = [
[/^[a-z][a-z0-9]*(?:-[a-z0-9]+)*/, 'name'],
[/^\[/, 'open'],
[/^\]/, 'close'],
[/^\./, 'stem']
]
console.log(parsePath('a.b[c.d][e].f[g[h[i.j]]]'))
function parsePath(str) {
let node
let nest = []
let result = nest
let stack = [nest]
while (str.length) {
nest = stack[stack.length - 1]
p:
for (let pattern of patterns) {
let match = str.match(pattern[0])
if (match) {
if (pattern[1] === 'name') {
node = {
form: `term`,
name: match[0],
link: []
}
nest.push(node)
} else if (pattern[1] === 'stem') {
stack.push(node.link)
} else if (pattern[1] === 'open') {
node = {
form: 'read',
link: []
}
nest.push(node)
stack.push(node.link)
} else if (pattern[1] === 'close') {
stack.pop()
}
str = str.substr(match[0].length)
break p
}
}
}
return result[0]
}Požadovaný výsledok je tento (alebo lepšie, viac intuitívne štruktúry údajov, ak ste tak naklonené na vytvorenie jedného):
{
"type": "MemberExpression",
"object": {
"type": "MemberExpression",
"object": {
"type": "MemberExpression",
"object": {
"type": "MemberExpression",
"object": {
"type": "MemberExpression",
"object": {
"type": "Identifier",
"name": "a"
},
"property": {
"type": "Identifier",
"name": "b"
},
"computed": false
},
"property": {
"type": "MemberExpression",
"object": {
"type": "Identifier",
"name": "c"
},
"property": {
"type": "Identifier",
"name": "d"
},
"computed": false
},
"computed": true
},
"property": {
"type": "Identifier",
"name": "e"
},
"computed": true
},
"property": {
"type": "Identifier",
"name": "f"
},
"computed": false
},
"property": {
"type": "MemberExpression",
"object": {
"type": "Identifier",
"name": "g"
},
"property": {
"type": "MemberExpression",
"object": {
"type": "Identifier",
"name": "h"
},
"property": {
"type": "MemberExpression",
"object": {
"type": "Identifier",
"name": "i"
},
"property": {
"type": "Identifier",
"name": "j"
},
"computed": false
},
"computed": true
},
"computed": true
},
"computed": true
}
Dôvod, prečo som sa usiloval (čiastočne), je mi nepáči tento MemberExpression stromová štruktúra, je to dozadu pocit a nie veľmi intuitívne. Tak ak by ste mohli postaviť jednoduchšie, priamočiarejšie dátové štruktúry, ktoré by bolo ideálne (to bola druhá otázka), ale ak nie, tak len algoritmus na zostrojenie to by sa mi deje.
Osobne by som sa skôr snaží vytvárať tejto štruktúry, ako som si to viac intuitívne:
{
type: 'site',
site: [
{
type: 'term',
term: 'a'
},
{
type: 'term',
term: 'b'
},
{
type: 'sink',
sink: [
{
type: 'term',
term: 'c'
},
{
type: 'term',
term: 'd'
}
]
},
{
type: 'sink',
sink: [
{
type: 'term',
term: 'e'
}
]
},
{
type: 'term',
term: 'f'
},
{
type: 'sink',
sink: [
{
type: 'term',
term: 'g'
},
{
type: 'sink',
sink: [
{
type: 'term',
term: 'h'
},
{
type: 'sink',
sink: [
{
type: 'term',
term: 'i'
},
{
type: 'term',
term: 'j'
}
]
}
]
}
]
}
]
}
Ale buď jeden pracuje pre mňa (alebo oboje).
Ak ideme s druhom, môj ďalší problém bude, ako previesť túto štruktúru dát do MemberExpression strom/dátové štruktúry :) Ale budem sa snažiť a robiť, že sám ako prvý. Tak je to asi lepšie postaviť MemberExpression v tejto otázke, potom môžem pracovať mimo to.