javascript
// 定义策略对象
const searchStrategies = {
title: function(text, query) {
if (!text || !query) return 0;
const normalizedText = text.toLowerCase();
const normalizedQuery = query.toLowerCase();

if (normalizedText.includes(normalizedQuery)) {
  // 标题完全匹配给予高分
  return normalizedText === normalizedQuery ? 100 : 
         normalizedText.startsWith(normalizedQuery) ? 80 : 60;
}
return 0;

},

keywords: function(keywords, query) {
if (!keywords || !Array.isArray(keywords)) return 0;
const matchCount = keywords.filter(kw =>
kw.toLowerCase().includes(query.toLowerCase())
).length;

return matchCount > 0 ? Math.min(matchCount * 25, 100) : 0;

},

description: function(desc, query) {
if (!desc || !query) return 0;
const words = desc.split(/\s+/);
const queryLower = query.toLowerCase();
let score = 0;

words.forEach(word => {
  if (word.toLowerCase().includes(queryLower)) {
    score += 5;
  }
});

return Math.min(score, 70); // 描述权重略低于标题

},

content: function(content, query) {
if (!content || !query) return 0;
const regex = new RegExp(query.replace(/[.*+?^${}()|[]\]/g, '\$&'), 'gi');
const matches = content.match(regex);
const frequency = matches ? matches.length : 0;

// 正文按出现频率计分，最多90分
return Math.min(frequency * 10, 90);

}
};

上面的代码定义了四个独立的策略函数，每个都专注于某一类数据的匹配逻辑。它们结构清晰、职责单一，并且可以独立测试。接下来我们需要一个“上下文”来协调这些策略的调用：

javascript
class SearchContext {
constructor(strategies) {
this.strategies = strategies;
}

execute(field, data, query) {
const strategy = this.strategies[field];
if (!strategy) {
throw new Error(No strategy defined for field: ${field});
}
return strategy(data, query);
}

// 动态添加新策略
addStrategy(name, fn) {
this.strategies[name] = fn;
}
}

现在我们可以这样使用：

javascript
const searcher = new SearchContext(searchStrategies);

// 模拟一篇文章数据
const article = {
title: "JavaScript策略模式详解",
keywords: ["JavaScript", "设计模式", "策略模式"],
description: "深入探讨JavaScript中的策略模式应用",
content: "策略模式是一种行为设计模式，它能让你定义一系列算法..."
};

const query = "策略";

const scores = {
title: searcher.execute('title', article.title, query),
keywords: searcher.execute('keywords', article.keywords, query),
description: searcher.execute('description', article.description, query),
content: searcher.execute('content', article.content, query)
};

console.log(scores);
// 输出类似：{ title: 60, keywords: 25, description: 15, content: 20 }

这个例子展示了策略模式最直观的优势：算法即插即用。假如未来产品需求变化，要求增加“作者名”作为新的搜索维度，我们只需新增一个策略函数并注册到上下文中，而无需修改任何已有逻辑。

更进一步，策略模式还能帮助我们实现运行时的动态决策。例如，可以根据用户偏好或设备性能实时切换排序算法：

javascript
const sortingStrategies = {
quickSort: (arr) => arr.sort((a, b) => a - b), // 简化表示
mergeSort: (arr) => { /* 更稳定的实现 / }, heapSort: (arr) => { / 适合大数据集 */ }
};

// 根据数组大小自动选择最优策略
function adaptiveSort(arr) {
const context = new SearchContext(sortingStrategies);
const strategy = arr.length > 1000 ? 'heapSort' : 'quickSort';
return context.execute(strategy, arr);
}

策略模式的本质，是将“做什么”和“怎么做”解耦。它鼓励我们以对象的方式思考算法，而不是将其硬编码在流程控制语句中。这种思维方式转变带来的好处远不止于减少if-else嵌套——更重要的是，它让我们的代码具备了面对变化时的从容。

真正的工程之美，不在于写出多复杂的代码，而在于用最自然的方式解决复杂的问题。策略模式正是这样一种返璞归真的智慧：把每一个算法当作平等的公民对待，让系统在运行时自由选择最适合的那个。