JavaScript基于V8引擎进行函数性能优化秘籍

function loadX(o) { 
  return o.x;
}

var o = { x: 1, y: 3 };
var o1 = { x: 3, y: 6 };

for (var i = 0; i < 90000; i++) {
  loadX(o);
  loadX(o1);
}

function Point(x, y) {
  this.x = x;
  this.y = y;
}

// 创建多个Point实例
const p1 = new Point(1, 2);
const p2 = new Point(3, 4);

const obj = { x: 1 };
obj.y = 2; // 隐藏类变更

// 反模式：使用arguments
function sum() {
  let total = 0;
  for (let i = 0; i < arguments.length; i++) {
    total += arguments[i];
  }
  return total;
}

// 优化版本：明确参数
function sum(a, b, c) {
  return a + b + c;
}

function sum(...numbers) {
  return numbers.reduce((acc, val) => acc + val, 0);
}

// 反模式：在热点路径中使用try/catch
function parseJSON(json) {
  try {
    return JSON.parse(json);
  } catch (e) {
    return null;
  }
}

// 优化方案：将try/catch移到外层
function parseJSON(json) {
    return JSON.parse(json);
}
function safeParseJSON(json) {
  try {
    return parseJSON(json);
  } catch (e) {
    return null;
  }
}

// 保持参数类型稳定
function attack(character, target, damage) {
  // 确保target始终是对象，damage始终是数字
  if (typeof damage !== 'number' || !target || typeof target !== 'object') {
    throw new Error('Invalid parameter types');
  }
  target.health -= damage;
  return target;
}

// 反模式 - 每次调用都会重新解析
const dynamicFunc = new Function('a', 'b', 'return a + b');

// 优化方案 - 预编译静态函数
function add(a, b) {
  // 添加类型检查可进一步提高优化效果
  return a + b; 
}

// 传统函数 - 需要额外保存this引用
const self = this;
items.map(function(item) {
  return self.process(item);
});

// 优化为箭头函数 - 自动绑定词法作用域
items.map(item => {
  // 复杂逻辑可以拆分成多行
  const processed = this.preProcess(item);
  return this.finalProcess(processed);
});

// 反模式：复杂函数难以优化
function processData(data) {
  // 验证逻辑
  if(!data || typeof data !== 'object') return;
  
  // 转换逻辑
  const result = {};
  for(const key in data) {
    result[key] = transformValue(data[key]);
  }
  
  // 后处理逻辑
  return finalize(result);
}

// 优化方案：拆分为小函数
function validate(data) {
  return data && typeof data === 'object';
}

function transform(data) {
  return Object.keys(data).reduce((acc, key) => {
    acc[key] = transformValue(data[key]);
    return acc;
  }, {});
}

function processData(data) {
  if (!validate(data)) return null;
  const transformed = transform(data);
  return finalize(transformed);
}

function setup() {
  const largeData = getLargeData(); // 大数据集
  const listeners = []; // 事件监听器集合
  
  const handleEvent = () => {
    // 使用largeData
    process(largeData);
  };
  
  // 添加事件监听
  window.addEventListener('resize', handleEvent);
  listeners.push(() => {
    window.removeEventListener('resize', handleEvent);
  });
  
  // 清理函数
  return function cleanup() {
    // 1. 移除所有事件监听
    listeners.forEach(fn => fn());
    
    // 2. 释放大数据引用
    largeData = null;
    
    // 3. 清空数组
    listeners.length = 0;
  };
}

function calculateCartTotal(cartItems) {
  let total = 0;
  for (let item of cartItems) {
    let itemPrice = item.price;
    if (item.discount) {  // 折扣计算
      itemPrice *= (1 - item.discount);
    }
    total += itemPrice;
  }
  total += calculateTax(total);  // 税费计算
  total += calculateShippingFee(cartItems);  // 运费计算
  return total;
}

// 计算单个商品最终价格（含折扣）
function calculateItemPrice(item) {
  let itemPrice = item.price;
  if (item.discount) {
    itemPrice *= (1 - item.discount);  // 应用折扣
  }
  return Number(itemPrice.toFixed(2));  // 保留两位小数
}

// 计算税费（示例税率10%）
function calculateTax(subtotal) {
  return subtotal * 0.1;  // 实际项目中税率应从配置获取
}

// 计算运费（基于商品数量）
function calculateShippingFee(cartItems) {
  return cartItems.length > 5 ? 10 : 5;  // 超过5件运费10元
}

// 主计算函数
function calculateCartTotal(cartItems) {
  // 计算商品小计
  let subtotal = 0;
  for (let item of cartItems) {
    subtotal += calculateItemPrice(item);
  }
  
  // 计算税费
  let tax = calculateTax(subtotal);
  
  // 计算运费
  let shippingFee = calculateShippingFee(cartItems);
  
  // 返回最终总价
  return subtotal + tax + shippingFee;
}

// 测试用例示例
const testItems = [
  {price: 100, discount: 0.1},
  {price: 50, discount: null},
  {price: 200, discount: 0.2}
];
console.log(calculateCartTotal(testItems));  // 应输出正确结果

// 优化前：混合了同步和异步操作
function processUserData(userId, callback) {
  // 同步阻塞操作会冻结事件循环
  // 在大型应用中可能导致严重性能问题
  const user = db.getUserSync(userId); // 同步阻塞
  
  // 回调地狱问题，嵌套层级过深
  processData(user, (err, result) => {
    if (err) return callback(err);
    callback(null, result);
  });
}

// 优化后：全异步流程
async function processUserData(userId) {
  try {
    // 使用异步非阻塞操作
    // 释放事件循环处理其他请求
    const user = await db.getUser(userId); // 异步非阻塞
    
    // 使用async/await使代码更线性易读
    return await processData(user);
  } catch (err) {
    // 统一错误处理
    logger.error('处理用户数据失败:', {
      userId,
      error: err.stack
    });
    throw err; // 向上抛出错误
  }
}

// 使用示例
processUserData('12345')
  .then(data => console.log('处理结果:', data))
  .catch(err => console.error('处理失败:', err));

node --prof app.js

node --prof-process isolate-0x1234567890-v8.log > processed.txt

node --trace-opt --trace-deopt app.js

console.profile('API请求性能分析');
// 要分析的代码块，例如：
await fetchDataFromAPI();
console.profileEnd();

// 引入benchmark.js库
const Benchmark = require('benchmark');

// 创建测试套件
const suite = new Benchmark.Suite('String Search Comparison');

// 添加测试用例1：使用正则表达式
suite.add('RegExp#test', function() {
  /o/.test('Hello World!'); // 测试字符串中是否包含字母o
})
// 添加测试用例2：使用字符串方法
.add('String#indexOf', function() {
  'Hello World!'.indexOf('o') > -1; // 使用indexOf查找字母o
})
// 添加测试用例3：使用includes方法
.add('String#includes', function() {
  'Hello World!'.includes('o'); // ES6新增的includes方法
})
// 每个测试用例完成后的回调
.on('cycle', function(event) {
  console.log(String(event.target)); // 输出测试结果
})
// 所有测试完成后的回调
.on('complete', function() {
  console.log('Fastest is ' + this.filter('fastest').map('name'));
})
// 运行测试套件
.run({ 'async': true }); // 异步模式运行