yangfan0095 / basis Goto Github PK

/**
 * poll函数 用于执行轮询任务
 * @param {*} fn 用于判断当前状态 是否满足执行回调条件
 * @param {*} calback 满足条件后 执行的回调
 * @param {*} errback 错误回调
 * @param {*} timeout 超时
 * @param {*} interval 默认轮询时间
 */
const poll = (fn, callback, errback, timeout = 10000, interval = 500) => {
  const endTime = Number(new Date()) + timeout;
  interval = interval || 100;
  const __poll = () => {
    if (fn()) {
      callback();
    } else if (Number(new Date()) < endTime) {
      setTimeout(__poll, interval);
    } else {
      errback(new Error(`timed out for ${fn}: `));
    }
  };
  __poll();
};

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
let twoSum = function(nums, target) {
    let res = [];
    for (let i = 0; i < nums.length; i++) {
        let curTemp = isTarget(i, nums, target);
        if (curTemp > -1) {
            res.push(i);
            res.push(curTemp);
            break;
        }
    };
    return res;
};

let isTarget = (index, arr, target) => {
    let flag = -1;
    for (let i = index + 1; i < arr.length; i++) {
        if (arr[i] + arr[index] === target) {
            flag = i;
            break;
        }
    }
    return flag;
}
let nums = [2, 7, 11, 15],
    target = 9;
let result = twoSum(nums, target);
console.log(result);

const babylon = require("babylon");
const types = require("babel-types");

const visitors = {
  File(node, scope) {
    evaluate(node.program, scope);
  },
  Program(program, scope) {
    for (const node of program.body) {
      evaluate(node, scope);
    }
  },
  ExpressionStatement(node, scope) {
    return evaluate(node.expression, scope);
  },
  CallExpression(node, scope) {
    // 获取调用者对象
    const func = evaluate(node.callee, scope);

    // 获取函数的参数
    const funcArguments = node.arguments.map(arg => evaluate(arg, scope));

    // 如果是获取属性的话: console.log
    if (types.isMemberExpression(node.callee)) {
      const object = evaluate(node.callee.object, scope);
      return func.apply(object, funcArguments); // log.apply(console,'hello world')
    }
  },
  MemberExpression(node, scope) {
    const { object, property } = node;

    // 找到对应的属性名
    const propertyName = property.name;

    // 找对对应的对象
    const obj = evaluate(object, scope);

    // 获取对应的值
    const target = obj[propertyName];

    // 返回这个值，如果这个值是function的话，那么应该绑定上下文this
    return typeof target === "function" ? target.bind(obj) : target;
  },
  Identifier(node, scope) {
    // 获取变量的值
    return scope[node.name];
  },
  StringLiteral(node) {
    return node.value;
  }
};

function evaluate(node, scope) {
  const _evalute = visitors[node.type];
  if (!_evalute) {
    throw new Error(`Unknown visitors of ${node.type}`);
  }
  // 递归调用
  return _evalute(node, scope);
}

const code = "console.log('hello world')";

// 生成AST树
const ast = babylon.parse(code);

// 解析AST
// 需要传入执行上下文，否则找不到``console``对象
evaluate(ast, { console: console });