कैसे लिखने के लिए एक पार्सर का निर्माण करने के लिए जावास्क्रिप्ट AST MemberExpression अभिव्यक्ति के लिए एक.बी[सी.d][e].एफ[जी[h[मैं.j]]]?

Question 1

निम्नलिखित लाइनों के साथ कैसे करने के लिए स्पष्ट रूप से प्रतिनिधित्व करते हैं.बी[सी.d][e].एफ[जी[h[मैं.j]]] एक वस्तु के रूप में पेड़?, कैसे आप लिखने के लिए एक एल्गोरिथ्म उत्पन्न करने के लिए है कि जे एस AST से अभिव्यक्ति a.b[c.d][e].f[g[h[i.j]]]? मैं कोशिश कर रहा हूँ लिखने के लिए एक पार्सर उत्पन्न करने के लिए कुछ प्रकार की वस्तु संरचना से इस अभिव्यक्ति (आदर्श रूप में अधिक से अधिक सहज जे एस AST MemberExpression एक है, इसलिए है कि अन्य प्रश्न). मैं होगा की तरह देखने के लिए कैसे एल्गोरिथ्म काम करता है का निर्माण करने के लिए जावास्क्रिप्ट MemberExpression पेड़.

वर्तमान में मैं इस तरह के एल्गोरिथ्म उत्पन्न करने के लिए किसी प्रकार का पेड़ (लेकिन यह लगता है के लिए गलत हो वर्तमान में):

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]
}

वांछित परिणाम है, यह (या एक बेहतर, अधिक सहज ज्ञान युक्त डेटा संरचना अगर तुम इतने झुका रहे हैं बनाने के लिए एक):

{
  "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
}

कारण है कि मैं संघर्ष कर रहा हूँ (आंशिक रूप से) है, मैं यह पसंद नहीं है MemberExpression पेड़ की संरचना है, यह पिछड़े लग रहा है और नहीं बहुत सहज है । तो अगर आप का निर्माण एक सरल और अधिक सरल डेटा संरचना है कि आदर्श होगा (कि अन्य प्रश्न), लेकिन अगर नहीं है तो बस एक एल्गोरिथ्म का निर्माण करने के लिए इस मिल जाएगा मुझे जा रहा है ।

निजी तौर पर, मैं नहीं बल्कि कोशिश उत्पन्न करने के लिए इस संरचना, के रूप में मैं खोजने के लिए इसे और अधिक सहज ज्ञान युक्त:

{
  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'
                }
              ]
            }
          ]
        }
      ]
    }
  ]
}

लेकिन या तो एक मेरे लिए काम करता है (या दोनों).

जाने के लिए अगर हम एक दूसरे के साथ, अपने अगले समस्या हो जाएगा कि कैसे परिवर्तित करने के लिए कि डेटा संरचना में MemberExpression पेड़/डेटा संरचना है :) लेकिन मैं कोशिश करते हैं और है कि अपने आप को । तो शायद यह बेहतर करने के लिए का निर्माण MemberExpression में इस सवाल है, तो मैं काम कर सकते हैं कि.

Question 2

अलग-अलग स्ट्रिंग के समूहों में वस्तु और गुण के पहले के स्तर की तरह,
```
[
    "a",
    "b",
    "[c.d]",
    "[e]",
    "f",
    "[g[h[i.j]]]"
]
```
प्राप्त वस्तु
1. पिछले आइटम के रूप में संपत्ति.
2. यदि संपत्ति के साथ शुरू ब्रैकेट सेट computed करने के लिए true और पट्टी से संपत्ति के आसपास कोष्ठक ।
3. वापसी के साथ एक वस्तु
  - type: "MemberExpression" ,
  - object वस्तु के साथ (2.),
  - property परिणाम के साथ बुला के मुख्य समारोह getAST (1.),
  - computed.

function getAST(string) {

    function getObject(parts) {
        if (parts.length === 1) return { type: "Identifier", name: parts[0] };

        let property = parts.pop(),
            computed = false;

        if (property.startsWith('[')) {
            computed = true;
            property = property.slice(1, -1);
        }

        return {
            type: "MemberExpression",
            object: getObject(parts),
            property: getAST(property),
            computed
        };
    }

    let i = 0,
        dot,
        bracket,
        parts = [];

    while (i < string.length) {
        dot = string.indexOf('.', i);
        bracket = string.indexOf('[', i);

        if (dot !== -1 && (bracket === -1 || dot < bracket)) {
            const temp = string.slice(i, dot);
            if (temp) parts.push(temp);
            i = dot + 1;
            continue;
        }

        if (bracket !== -1 && (dot === -1 || bracket < dot)) {
            const temp = string.slice(i, bracket);
            if (temp) parts.push(temp);
            i = bracket;

            let open = 1,
                j = i;

            while (++j < string.length) {
                if (string[j] === '[') open++;
                if (string[j] === ']') open--;
                if (!open) break;
            }

            j++;
            parts.push(string.slice(i, j));

            i = j;
            continue;
        }
        parts.push(string.slice(i));
        break;
    }

    return getObject(parts);
}

console.log(getAST('a.b[c.d][e].f[g[h[i.j]]]'));

.as-console-wrapper { max-height: 100% !important; top: 0; }

Nina Scholz · Answer 1 · 2021-11-24T07:30:42

अलग-अलग स्ट्रिंग के समूहों में वस्तु और गुण के पहले के स्तर की तरह,
```
[
    "a",
    "b",
    "[c.d]",
    "[e]",
    "f",
    "[g[h[i.j]]]"
]
```
प्राप्त वस्तु
1. पिछले आइटम के रूप में संपत्ति.
2. यदि संपत्ति के साथ शुरू ब्रैकेट सेट computed करने के लिए true और पट्टी से संपत्ति के आसपास कोष्ठक ।
3. वापसी के साथ एक वस्तु
  - type: "MemberExpression" ,
  - object वस्तु के साथ (2.),
  - property परिणाम के साथ बुला के मुख्य समारोह getAST (1.),
  - computed.

function getAST(string) {

    function getObject(parts) {
        if (parts.length === 1) return { type: "Identifier", name: parts[0] };

        let property = parts.pop(),
            computed = false;

        if (property.startsWith('[')) {
            computed = true;
            property = property.slice(1, -1);
        }

        return {
            type: "MemberExpression",
            object: getObject(parts),
            property: getAST(property),
            computed
        };
    }

    let i = 0,
        dot,
        bracket,
        parts = [];

    while (i < string.length) {
        dot = string.indexOf('.', i);
        bracket = string.indexOf('[', i);

        if (dot !== -1 && (bracket === -1 || dot < bracket)) {
            const temp = string.slice(i, dot);
            if (temp) parts.push(temp);
            i = dot + 1;
            continue;
        }

        if (bracket !== -1 && (dot === -1 || bracket < dot)) {
            const temp = string.slice(i, bracket);
            if (temp) parts.push(temp);
            i = bracket;

            let open = 1,
                j = i;

            while (++j < string.length) {
                if (string[j] === '[') open++;
                if (string[j] === ']') open--;
                if (!open) break;
            }

            j++;
            parts.push(string.slice(i, j));

            i = j;
            continue;
        }
        parts.push(string.slice(i));
        break;
    }

    return getObject(parts);
}

console.log(getAST('a.b[c.d][e].f[g[h[i.j]]]'));

.as-console-wrapper { max-height: 100% !important; top: 0; }

कैसे लिखने के लिए एक पार्सर का निर्माण करने के लिए जावास्क्रिप्ट AST MemberExpression अभिव्यक्ति के लिए एक.बी[सी.d][e].एफ[जी[h[मैं.j]]]?

सवाल

सबसे अच्छा जवाब

अन्य भाषाओं में

यह पृष्ठ अन्य भाषाओं में है

इस श्रेणी में लोकप्रिय

लोकप्रिय सवाल इस श्रेणी में