Lodash中有哪些函数式编程工具？请举例说明它们的用法 - 面试题

Lodash提供了丰富的函数式编程工具，以下是关于Lodash函数式编程的详细解答：

Lodash函数式编程概述

Lodash提供了许多函数式编程工具，包括函数组合、柯里化、记忆化等。这些工具可以帮助开发者编写更简洁、更可维护的代码。

1. 函数组合

`_.flow([funcs])`

创建一个函数，该函数从左到右依次执行给定的函数。

javascript
function square(n) {
  return n * n;
}

function addTwo(n) {
  return n + 2;
}

var addSquare = _.flow(addTwo, square);
addSquare(3);
// => 25

// 实际应用：数据转换管道
function processData(data) {
  return _.flow(
    filterActive,
    transformData,
    sortByDate
  )(data);
}

function filterActive(items) {
  return _.filter(items, item => item.active);
}

function transformData(items) {
  return _.map(items, item => ({
    id: item.id,
    name: _.upperFirst(item.name),
    value: _.round(item.value, 2)
  }));
}

function sortByDate(items) {
  return _.orderBy(items, ['createdAt'], ['desc']);
}

`_.flowRight([funcs])`

创建一个函数，该函数从右到左依次执行给定的函数（类似于函数组合）。

javascript
function square(n) {
  return n * n;
}

function addTwo(n) {
  return n + 2;
}

var addSquare = _.flowRight(square, addTwo);
addSquare(3);
// => 25

// 实际应用：验证和处理
function validateAndProcess(input) {
  return _.flowRight(
    processResult,
    validateInput,
    sanitizeInput
  )(input);
}

function sanitizeInput(input) {
  return _.trim(input);
}

function validateInput(input) {
  if (!input) throw new Error('Invalid input');
  return input;
}

function processResult(input) {
  return _.upperFirst(input);
}

2. 函数柯里化

`_.curry(func, [arity=func.length])`

创建一个函数，该函数接受一个或多个参数。如果提供的参数数量少于arity，则返回一个函数，该函数接受剩余的参数。

javascript
var abc = function(a, b, c) {
  return [a, b, c];
};

var curried = _.curry(abc);

curried(1)(2)(3);
// => [1, 2, 3]

curried(1, 2)(3);
// => [1, 2, 3]

curried(1, 2, 3);
// => [1, 2, 3]

// 实际应用：创建可重用的函数
const multiply = (a, b) => a * b;
const double = _.curry(multiply)(2);
const triple = _.curry(multiply)(3);

console.log(double(5)); // => 10
console.log(triple(5)); // => 15

// 实际应用：API请求
const fetchData = (baseUrl, endpoint, params) => {
  return fetch(`${baseUrl}/${endpoint}?${new URLSearchParams(params)}`);
};

const fetchFromAPI = _.curry(fetchData)('https://api.example.com');
const fetchUsers = fetchFromAPI('users');
const fetchPosts = fetchFromAPI('posts');

fetchUsers({ page: 1, limit: 10 });
fetchPosts({ userId: 123 });

`_.curryRight(func, [arity=func.length])`

类似于_.curry，但参数从右到左应用。

javascript
var abc = function(a, b, c) {
  return [a, b, c];
};

var curried = _.curryRight(abc);

curried(3)(2)(1);
// => [1, 2, 3]

curried(3, 2)(1);
// => [1, 2, 3]

curried(3, 2, 1);
// => [1, 2, 3]

`_.partial(func, [partials])`

创建一个函数，该函数调用func时，将部分参数预先填充。

javascript
var greet = function(greeting, punctuation, name) {
  return greeting + ' ' + name + punctuation;
};

var sayHelloTo = _.partial(greet, 'hello', '!');
var sayHelloToFred = sayHelloTo('fred');

sayHelloToFred;
// => 'hello fred!'

// 实际应用：创建特定配置的函数
const fetchWithConfig = _.partial(fetch, {
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer token'
  }
});

fetchWithConfig('https://api.example.com/data');

`_.partialRight(func, [partials])`

类似于_.partial，但部分参数从右侧填充。

javascript
var greet = function(greeting, name, punctuation) {
  return greeting + ' ' + name + punctuation;
};

var greetFred = _.partialRight(greet, 'fred');
var sayHelloToFred = _.partialRight(greetFred, '!');

sayHelloToFred('hello');
// => 'hello fred!'

3. 函数记忆化

`_.memoize(func, [resolver])`

创建一个记忆化函数，缓存函数结果。

javascript
var object = { 'a': 1, 'b': 2 };
var other = { 'c': 3, 'd': 4 };

var values = _.memoize(_.values);
values(object);
// => [1, 2]

values(other);
// => [3, 4]

object.a = 2;
values(object);
// => [1, 2] // 缓存的结果

// 实际应用：缓存计算结果
function fibonacci(n) {
  if (n <= 1) return n;
  return fibonacci(n - 1) + fibonacci(n - 2);
}

const memoizedFibonacci = _.memoize(fibonacci);

console.time('fibonacci');
console.log(fibonacci(40)); // 慢
console.timeEnd('fibonacci');

console.time('memoized');
console.log(memoizedFibonacci(40)); // 快
console.timeEnd('memoized');

// 实际应用：缓存API响应
const fetchUser = _.memoize(async (userId) => {
  const response = await fetch(`/api/users/${userId}`);
  return response.json();
}, userId => userId);

// 第一次调用会发送请求
const user1 = await fetchUser(1);
// 第二次调用会返回缓存
const user2 = await fetchUser(1);

4. 函数包装

`_.wrap(value, [wrapper=identity])`

创建一个函数，该函数将value作为第一个参数传递给wrapper。

javascript
var p = _.wrap(_.escape, function(func, text) {
  return '<p>' + func(text) + '</p>';
});

p('fred, barney, & pebbles');
// => '<p>fred, barney, &amp; pebbles</p>'

// 实际应用：包装日志函数
const logWithTimestamp = _.wrap(console.log, (fn, ...args) => {
  const timestamp = new Date().toISOString();
  fn(`[${timestamp}]`, ...args);
});

logWithTimestamp('User logged in', { userId: 123 });
// => [2024-01-01T00:00:00.000Z] User logged in { userId: 123 }

`_.negate(predicate)`

创建一个函数，该函数对predicate的结果取反。

javascript
function isEven(n) {
  return n % 2 === 0;
}

_.filter([1, 2, 3, 4, 5, 6], _.negate(isEven));
// => [1, 3, 5]

// 实际应用：过滤条件
const isActive = user => user.active;
const isInactive = _.negate(isActive);

const activeUsers = _.filter(users, isActive);
const inactiveUsers = _.filter(users, isInactive);

5. 函数工具

`_.ary(func, [n=func.length])`

创建一个函数，该函数调用func时最多接受n个参数。

javascript
_.map(['6', '8', '10'], _.ary(parseInt, 1));
// => [6, 8, 10]

// 实际应用：限制参数数量
const logFirstTwo = _.ary(console.log, 2);
logFirstTwo('a', 'b', 'c'); // 只输出 'a', 'b'

`_.unary(func)`

创建一个函数，该函数只接受一个参数。

javascript
_.map(['6', '8', '10'], _.unary(parseInt));
// => [6, 8, 10]

// 实际应用：确保函数只接受一个参数
const logFirst = _.unary(console.log);
logFirst('a', 'b', 'c'); // 只输出 'a'

`_.once(func)`

创建一个函数，该函数只能调用一次。

javascript
var initialize = _.once(createApplication);
initialize();
initialize();
// `createApplication` 只调用一次

// 实际应用：单例初始化
let database = null;

const getDatabase = _.once(() => {
  database = connectToDatabase();
  return database;
});

const db1 = getDatabase();
const db2 = getDatabase();
console.log(db1 === db2); // true

`_.before(n, func)`

创建一个函数，该函数最多调用n次。

javascript
_.before(2, function() {
  console.log('called');
})();
// => logs 'called'

_.before(2, function() {
  console.log('called');
})();
// => logs 'called'

_.before(2, function() {
  console.log('called');
})();
// => 不输出

// 实际应用：限制调用次数
const logFirstThree = _.before(3, console.log);

logFirstThree('1'); // 输出
logFirstThree('2'); // 输出
logFirstThree('3'); // 输出
logFirstThree('4'); // 不输出

`_.after(n, func)`

创建一个函数，该函数在调用n次后才会执行。

javascript
var saves = ['profile', 'settings'];

var done = _.after(saves.length, function() {
  console.log('done saving!');
});

_.forEach(saves, function(type) {
  asyncSave({ type: type, complete: done });
});
// => logs 'done saving!' after the two async saves have completed

// 实际应用：等待多个异步操作完成
const waitForAll = (count, callback) => {
  let remaining = count;
  return _.after(count, () => callback());
};

const done = waitForAll(3, () => {
  console.log('All tasks completed');
});

// 模拟异步任务
setTimeout(() => done(), 100);
setTimeout(() => done(), 200);
setTimeout(() => done(), 300);

`_.spread(func, [start=0])`

创建一个函数，该函数将数组作为参数传递给func。

javascript
var say = _.spread(function(who, what) {
  return who + ' says ' + what;
});

say(['fred', 'hello']);
// => 'fred says hello'

// 实际应用：处理数组参数
const max = _.spread(Math.max);
console.log(max([1, 2, 3, 4, 5])); // => 5

const sum = _.spread((...args) => _.sum(args));
console.log(sum([1, 2, 3, 4, 5])); // => 15

实际应用示例

函数式数据处理管道

javascript
class DataPipeline {
  constructor() {
    this.pipeline = [];
  }

  pipe(func) {
    this.pipeline.push(func);
    return this;
  }

  process(data) {
    return _.flow(...this.pipeline)(data);
  }
}

const pipeline = new DataPipeline()
  .pipe(data => _.filter(data, item => item.active))
  .pipe(data => _.map(data, item => ({
    id: item.id,
    name: _.upperFirst(item.name),
    value: _.round(item.value, 2)
  })))
  .pipe(data => _.orderBy(data, ['createdAt'], ['desc']))
  .pipe(data => _.take(data, 10));

const result = pipeline.process(rawData);

函数式API客户端

javascript
class APIClient {
  constructor(baseUrl) {
    this.baseUrl = baseUrl;
  }

  request = _.curry((method, endpoint, params) => {
    const url = `${this.baseUrl}${endpoint}`;
    const options = {
      method,
      headers: {
        'Content-Type': 'application/json'
      }
    };

    if (method === 'GET') {
      url += '?' + new URLSearchParams(params);
    } else {
      options.body = JSON.stringify(params);
    }

    return fetch(url, options).then(res => res.json());
  });

  get = this.request('GET');
  post = this.request('POST');
  put = this.request('PUT');
  delete = this.request('DELETE');

  getUsers = this.get('/users');
  getUser = this.get('/users/:id');
  createUser = this.post('/users');
  updateUser = this.put('/users/:id');
  deleteUser = this.delete('/users/:id');
}

const api = new APIClient('https://api.example.com');

api.getUsers({ page: 1, limit: 10 });
api.getUser({ id: 123 });
api.createUser({ name: 'John', email: 'john@example.com' });

函数式验证器

javascript
class Validator {
  constructor() {
    this.validators = [];
  }

  add(validator) {
    this.validators.push(validator);
    return this;
  }

  validate(data) {
    const results = this.validators.map(validator => validator(data));
    const errors = _.filter(results, result => !result.valid);
    
    return {
      valid: errors.length === 0,
      errors: _.flatMap(errors, error => error.errors)
    };
  }

  static required(field) {
    return data => ({
      valid: !_.isEmpty(data[field]),
      errors: _.isEmpty(data[field]) ? [`${field} is required`] : []
    });
  }

  static minLength(field, length) {
    return data => ({
      valid: data[field] && data[field].length >= length,
      errors: !data[field] || data[field].length < length 
        ? [`${field} must be at least ${length} characters`] 
        : []
    });
  }

  static email(field) {
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    return data => ({
      valid: emailRegex.test(data[field]),
      errors: !emailRegex.test(data[field]) ? [`${field} must be a valid email`] : []
    });
  }
}

const userValidator = new Validator()
  .add(Validator.required('name'))
  .add(Validator.minLength('name', 2))
  .add(Validator.required('email'))
  .add(Validator.email('email'));

const result = userValidator.validate({
  name: 'John',
  email: 'john@example.com'
});

总结

Lodash提供了丰富的函数式编程工具，包括：

函数组合：_.flow、_.flowRight - 将多个函数组合成一个
函数柯里化：_.curry、_.curryRight、_.partial、_.partialRight - 预先填充部分参数
函数记忆化：_.memoize - 缓存函数结果以提高性能
函数包装：_.wrap、_.negate - 包装或修改函数行为
函数工具：_.ary、_.unary、_.once、_.before、_.after、_.spread - 控制函数调用

掌握这些函数式编程工具可以帮助开发者编写更简洁、更可维护、更高效的代码。在实际开发中，建议根据具体需求选择合适的工具，并充分利用函数式编程的优势。