[1,2,3].map(n => n+1);

[1,2,3].map(function(n){  return n + 1;})

// 词法分析器,接收字符串返回token数组export const tokenizer = (code) => {    // 储存 token 的数组    const tokens  = [];    // 指针    let current = 0;    while (current < code.length) {        // 获取指针指向的字符        const char = code[current];        // 我们先处理单字符的语法单元 类似于`;` `(` `)`等等这种        if (char === '(' || char === ')') {            tokens.push({                type: 'parens',                value: char,            });            current ++;            continue;        }        // 我们接着处理标识符,标识符一般为以字母、_、$开头的连续字符        if (/[a-zA-Z\$\_]/.test(char)) {            let value = '';            value += char;            current ++;            // 如果是连续字那么将其拼接在一起,随后指针后移            while (/[a-zA-Z0-9\$\_]/.test(code[current]) && current < code.length) {                value += code[current];                current ++;            }            tokens.push({                type: 'identifier',                value,            });            continue;        }        // 处理空白字符        if (/\s/.test(char)) {            let value = '';            value += char;            current ++;            //道理同上            while (/\s]/.test(code[current]) && current < code.length) {                value += code[current];                current ++;            }            tokens.push({                type: 'whitespace',                value,            });            continue;        }        // 处理逗号分隔符        if (/,/.test(char)) {            tokens.push({                type: ',',                value: ',',            });            current ++;            continue;        }        // 处理运算符        if (/=|\+|>/.test(char)) {            let value = '';            value += char;            current ++;            while (/=|\+|>/.test(code[current])) {                value += code[current];                current ++;            }            // 当 = 后面有 > 时为箭头函数而非运算符            if (value === '=>') {                tokens.push({                    type: 'ArrowFunctionExpression',                    value,                });                continue;            }            tokens.push({                type: 'operator',                value,            });            continue;        }        // 如果碰到我们词法分析器以外的字符,则报错        throw new TypeError('I dont know what this character is: ' + char);    }    return tokens;};

const parser = tokens => {    // 声明一个全时指针，它会一直存在    let current = -1;    // 声明一个暂存栈,用于存放临时指针    const tem = [];    // 指针指向的当前token    let token = tokens[current];    const parseDeclarations = () => {        // 暂存当前指针        setTem();        // 指针后移        next();        // 如果字符为'const'可见是一个声明        if (token.type === 'identifier' && token.value === 'const') {            const declarations = {                type: 'VariableDeclaration',                kind: token.value            };            next();            // const 后面要跟变量的,如果不是则报错            if (token.type !== 'identifier') {                throw new Error('Expected Variable after const');            }            // 我们获取到了变量名称            declarations.identifierName = token.value;            next();            // 如果跟着 '=' 那么后面应该是个表达式或者常量之类的,额外判断的代码就忽略了,直接解析函数表达式            if (token.type === 'operator' && token.value === '=') {                declarations.init = parseFunctionExpression();            }            return declarations;        }    };    const parseFunctionExpression = () => {        next();        let init;        // 如果 '=' 后面跟着括号或者字符那基本判断是一个表达式        if (            (token.type === 'parens' && token.value === '(') ||            token.type === 'identifier'        ) {            setTem();            next();            while (token.type === 'identifier' || token.type === ',') {                next();            }            // 如果括号后跟着箭头,那么判断是箭头函数表达式            if (token.type === 'parens' && token.value === ')') {                next();                if (token.type === 'ArrowFunctionExpression') {                    init = {                        type: 'ArrowFunctionExpression',                        params: [],                        body: {}                    };                    backTem();                    // 解析箭头函数的参数                    init.params = parseParams();                    // 解析箭头函数的函数主体                    init.body = parseExpression();                } else {                    backTem();                }            }        }        return init;    };    const parseParams = () => {        const params = [];        if (token.type === 'parens' && token.value === '(') {            next();            while (token.type !== 'parens' && token.value !== ')') {                if (token.type === 'identifier') {                    params.push({                        type: token.type,                        identifierName: token.value                    });                }                next();            }        }        return params;    };    const parseExpression = () => {        next();        let body;        while (token.type === 'ArrowFunctionExpression') {            next();        }        // 如果以(开头或者变量开头说明不是 BlockStatement,我们以二元表达式来解析        if (token.type === 'identifier') {            body = {                type: 'BinaryExpression',                left: {                    type: 'identifier',                    identifierName: token.value                },                operator: '',                right: {                    type: '',                    identifierName: ''                }            };            next();            if (token.type === 'operator') {                body.operator = token.value;            }            next();            if (token.type === 'identifier') {                body.right = {                    type: 'identifier',                    identifierName: token.value                };            }        }        return body;    };    // 指针后移的函数    const next = () => {        do {            ++current;            token = tokens[current]                ? tokens[current]                : { type: 'eof', value: '' };        } while (token.type === 'whitespace');    };    // 指针暂存的函数    const setTem = () => {        tem.push(current);    };    // 指针回退的函数    const backTem = () => {        current = tem.pop();        token = tokens[current];    };    const ast = {        type: 'Program',        body: []    };    while (current < tokens.length) {        const statement = parseDeclarations();        if (!statement) {            break;        }        ast.body.push(statement);    }    return ast;};