# Collect.js 教程

> 原文： [http://zetcode.com/javascript/collectjs/](http://zetcode.com/javascript/collectjs/)

Collect.js 教程展示了如何使用 Collect.js 库处理 JavaScript 中的数组和对象。

## Collect.js

Collect.js 是用于处理数组和对象的流畅，便捷的包装器。 它是 Laravel 集合的接口。 它包含许多使数据处理更加容易的函数。

Collect.js 帮助程序员编写更简洁，更易于维护的 JavaScript 代码。

## Collect.js 安装

首先，我们安装 Collect.js 库。

```js
$ npm init
$ npm i collect.js

```

`collect.js`库与`npm`一起本地安装。

## `collect()`函数

我们将带有`collect()`的 JavaScript 数组转换为一个集合，并对该集合应用函数。 最后，我们使用`all()`或`toArray()`返回底层数组。

## Collect.js `all()`与`toArray`

`all()`和`toArray()`函数从集合中返回基础数组。 这两个函数之间的区别在于`toArray()`函数还将嵌套的集合转换为数组（如果存在）。

`all_toarray.js`

```js
const collect = require('collect.js');

const nums1 = [1, 2, 3];
const nums2 = [4, 5, 6];

const data = collect([collect(nums1), 
    collect(nums2)]);

console.log(data.all());
console.log(data.toArray());

```

该示例显示了两个函数之间的区别。

```js
$ node all_toarray.js
[ Collection { items: [ 1, 2, 3 ] },
    Collection { items: [ 4, 5, 6 ] } ]
[ [ 1, 2, 3 ], [ 4, 5, 6 ] ]

```

这是输出。 我们可以看到在第二个示例中，嵌套集合被转换为数组。

## Collect.js `count()`

`count()`函数计算集合中元素的数量。

`count_elements.js`

```js
const collect = require('collect.js');

const nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

const data = collect(nums);

const nOfElements = data.count();

console.log(`There are ${nOfElements} elements`);

```

该示例计算数组中值的数量。

```js
$ node count_elements.js
Therea are 10 elements

```

## Collect.js `unique()`

`unique()`函数返回集合中的所有唯一项。

`unique.js`

```js
const collect = require('collect.js');

const nums = [1, 1, 1, 2, 4, 4, 5];

const data = collect(nums);
const unique_data = data.unique();

console.log(unique_data.all()); 

```

该示例显示数组的唯一值。

```js
const unique_data = data.unique();

```

我们使用`unique()`从集合中获取所有唯一值。

```js
console.log(unique_data.all()); 

```

`all()`函数返回该集合表示的基础数组。

```js
$ node unique.js
[ 1, 2, 4, 5 ]

```

这是输出。

## `first`

第一个函数返回通过给定真值测试的集合中的第一个元素，或者仅返回第一个值。

`first_fun.js`

```js
const collect = require('collect.js');

const nums = [1, 2, -3, 4, -5, 6, 7, 8];
const data = collect(nums);

let fval = data.first();
console.log(fval);

let fneg = data.first(e => e < 0);
console.log(fneg);

```

该示例打印第一个值和第一个负值。

```js
$ node first_fun.js
1
-3

```

这是输出。

## `firstWhere`

`firstWhere`函数返回具有给定键/值对的集合中的第一个元素。

`firstwhere_fun.js`

```js
const collect = require('collect.js');

const users = [
    { name: 'John', city: 'London', born: '2001-04-01' },
    { name: 'Lenny', city: 'New York', born: '1997-12-11' },
    { name: 'Andrew', city: 'Boston', born: '1987-02-22' },
    { name: 'Peter', city: 'Prague', born: '1936-03-24' },
    { name: 'Anna', city: 'Bratislava', born: '1973-11-18' },
    { name: 'Albert', city: 'Bratislava', born: '1940-12-11' },
    { name: 'Adam', city: 'Trnava', born: '1983-12-01' },
    { name: 'Robert', city: 'Bratislava', born: '1935-05-15' },
    { name: 'Robert', city: 'Prague', born: '1998-03-14' }
];

const data = collect(users);

let fval = data.firstWhere('city', 'Bratislava');
console.log(fval);

```

该示例打印出居住在布拉迪斯拉发的第一位用户。

```js
$ node firstwhere_fun.js
{ name: 'Anna', city: 'Bratislava', born: '1973-11-18' }

```

这是输出。

## Collect.js `avg()`

`avg()`函数返回集合中所有项目的平均值。

`average.js`

```js
const collect = require('collect.js');

const nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

const data = collect(nums);

console.log(data.avg());

```

该程序将打印数字数组的平均值。

## `min`和`max()`

`min`和`max()`函数分别返回最小值和最大值。

`min_max.js`

```js
const collect = require('collect.js');

const nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

const data = collect(nums);

console.log(`Minimum: ${data.min()}`);
console.log(`Maximum: ${data.max()}`);

```

程序打印数字数组的最小值和最大值。

```js
$ node min_max.js
Minimum: 1
Maximum: 10

```

这是输出。

## Collect.js `median`

`median()`函数返回中位数。 中位数是数据集的中间值。

`median_fun.js`

```js
const collect = require('collect.js');

const nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

const data = collect(nums);

console.log(data.median());

```

该示例显示数字数组的中位数。

```js
$ node median.js
5.5

```

如果没有中间值，则按照我们的情况计算中间两个值的平均值。

## Collect.js `each`

`each()`函数遍历集合中的项目，并将每个项目传递给回调。

`each_fun.js`

```js
const collect = require('collect.js');

const nums = [1, 2, 3, 4, 5];
let sum = 0;

const data = collect(nums);

data.each((item) => {
    sum += item;
});

console.log(`The sum of values: ${sum}`);

```

我们使用`each()`函数计算值的总和。

```js
$ node each_fun.js
The sum of values: 15

```

这是输出。

## Collect.js `eachSpread`

`eachSpread()`函数遍历集合的项目，将每个嵌套的项目值传递给给定的回调。

`eachspread_fun.js`

```js
const collect = require('collect.js');

const users = [
    ['John Doe', 'gardener'], ['Peter Smith', 'programmer'],
    ['Lucy Black', 'teacher']
];

const data = collect(users);

data.eachSpread((user, occupation) => {
    console.log(`${user} is a ${occupation}`);
});

```

该示例使用`eachSpread()`函数对嵌套数组进行迭代。

```js
$ node eachspread_fun.js
John Doe is a gardener
Peter Smith is a programmer
Lucy Black is a teacher

```

这是输出。

## Collect.js `map()`

`map()`函数将给定的回调函数应用于每个元素，从而形成新的修改项集合。

`map_fun.js`

```js
const collect = require('collect.js');

const nums = [1, 2, 3, 4, 5];

const data = collect(nums);

const tr_data = data.map(e => e * 2);

console.log(tr_data.all());

```

在示例中，我们通过将每个值乘以 2 来创建修改后的集合。

```js
$ node  map_fun.js
[ 2, 4, 6, 8, 10 ]

```

这是输出。

## Collect.js `mapInto`

`mapInto()`函数遍历集合并根据元素创建对象。

`mapinto_fun.js`

```js
const collect = require('collect.js');

const User = function (name, age) {
    this.name = name;
    this.age = age;
};

const users = [
    { name: 'John Doe', age: 34 },
    { name: 'Peter Smith', age: 43 },
    { name: 'Bruce Long', age: 40 },
    { name: 'Lucy White', age: 54 },
];

const data = collect(users);

const objects = data.mapInto(User);

console.log(objects.all());

```

在示例中，我们借助`mapInto()`函数将 JSON 对象文字转换为 JavaScript 对象。

```js
$ node mapinto_fun.js
[ User { name: { name: 'John Doe', age: 34 }, age: 0 },
    User { name: { name: 'Peter Smith', age: 43 }, age: 1 },
    User { name: { name: 'Bruce Long', age: 40 }, age: 2 },
    User { name: { name: 'Lucy White', age: 54 }, age: 3 } ]

```

这是输出。

## Collect.js `filter()`

`filter()`函数使用给定的回调函数过滤集合，仅保留那些通过给定的真实性测试的项目。

`finter_fun.js`

```js
const collect = require('collect.js');

const nums = [-1, 2, -3, 4, -5, 6, 7, 8, -9, 0];
const data = collect(nums);

const filtered = data.filter((val, key) => val > 0); 

console.log(filtered.all());

```

该示例滤除正值。

```js
$ node finter_fun.js
[ 2, 4, 6, 7, 8 ]

```

这是输出。

```js
$ npm i moment

```

在下面的示例中，我们还需要`moment.js`库。

`filter_fun2.js`

```js
const collect = require('collect.js');
const moment = require('moment');

const users = [
    { name: 'John', city: 'London', born: '2001-04-01' },
    { name: 'Lenny', city: 'New York', born: '1997-12-11' },
    { name: 'Andrew', city: 'Boston', born: '1987-02-22' },
    { name: 'Peter', city: 'Prague', born: '1936-03-24' },
    { name: 'Anna', city: 'Bratislava', born: '1973-11-18' },
    { name: 'Albert', city: 'Bratislava', born: '1940-12-11' },
    { name: 'Adam', city: 'Trnava', born: '1983-12-01' },
    { name: 'Robert', city: 'Bratislava', born: '1935-05-15' },
    { name: 'Robert', city: 'Prague', born: '1998-03-14' }
];

const data = collect(users);

let res = data.filter((val, key) => getAge(val.born) > 40);
console.log(res.all());

function getAge(dt) {

    return moment.duration(moment() - moment(dt, 'YYYY-MM-DD', true)).years();
}

```

该示例过滤出年龄超过 40 岁的用户。

```js
$ node filter_fun2.js
[ { name: 'Peter', city: 'Prague', born: '1936-03-24' },
    { name: 'Anna', city: 'Bratislava', born: '1973-11-18' },
    { name: 'Albert', city: 'Bratislava', born: '1940-12-11' },
    { name: 'Robert', city: 'Bratislava', born: '1935-05-15' } ]

```

列表中有四个人大于四十岁。

## Collect.js `shuffle()`

`shuffle()`函数随机重组集合中的项目。

`shuffle.js`

```js
const collect = require('collect.js');

const nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

const data = collect(nums);

const shuffled = data.shuffle();

console.log(shuffled.all());

```

该示例重新排列数组。

```js
$ node shuffling.js
[ 6, 4, 3, 7, 5, 10, 1, 9, 8, 2 ]

```

这是一个示例输出。

## Collect.js `random()`

`random()`函数从集合中返回一个随机元素。

`random_fun.js`

```js
const collect = require('collect.js');

let nums = [1, 2, 3, 4, 5, 6, 7, 8];

const data = collect(nums);

let r1 = data.random();
console.log(r1);

let r2 = data.random(2);
console.log(r2.all());

```

该示例从一个数字数组中选择一个随机值和两个随机值。

```js
$ node random_fun.js
6
[ 4, 2 ]

```

这是输出。

## Collect.js `sortBy()`

`sortBy()`函数通过给定的键对集合进行排序。

`sortby_fun.js`

```js
const collect = require('collect.js');

const users = [
    { name: 'John Doe', occupation: 'gardener' },
    { name: 'Adam Forsythe', occupation: 'writer' },
    { name: 'Peter Smith', occupation: 'programmer' },
    { name: 'Lucy Black', occupation: 'teacher' }
];

const data = collect(users);

const sorted1 = data.sortBy('name');
console.log(sorted1.all());

const sorted2 = data.sortBy('occupation');
console.log(sorted2.all());

```

该程序通过提供的键对对象数组进行排序。

```js
$ node sortby_fun.js
[ { name: 'Adam Forsythe', occupation: 'writer' },
  { name: 'John Doe', occupation: 'gardener' },
  { name: 'Lucy Black', occupation: 'teacher' },
  { name: 'Peter Smith', occupation: 'programmer' } ]
[ { name: 'John Doe', occupation: 'gardener' },
  { name: 'Peter Smith', occupation: 'programmer' },
  { name: 'Lucy Black', occupation: 'teacher' },
  { name: 'Adam Forsythe', occupation: 'writer' } ]

```

数组通过`name`和`occupation`键排序。

## `nth()`

`nth()`函数返回集合中的每个第 n 个元素。

`nth_fun.js`

```js
const collect = require('collect.js');

const nums = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'];

const data = collect(nums);

console.log(data.nth(2).all());
console.log(data.nth(3).all());
console.log(data.nth(4).all());

```

该示例返回数组的第二，第三和第四个元素。

```js
$ node nth_fun.js
[ 'a', 'c', 'e', 'g' ]
[ 'a', 'd', 'g' ]
[ 'a', 'e' ]

```

这是输出。

## Collect.js `chunk()`

`chunk()`函数将集合分成给定大小的较小部分。

`chunk_fun.js`

```js
const collect = require('collect.js');

const nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

const data = collect(nums);
const chunks = data.chunk(4);

console.log(chunks.toArray());

```

该示例将数组分为包含四个元素的部分。

```js
$ node chunk_fun.js
[ [ 1, 2, 3, 4 ], [ 5, 6, 7, 8 ], [ 9, 10 ] ]

```

这是输出。

```js
node flatten_fun.js
[ 4, 5, 6, 7, 8, 9, 10 ]

```

这是输出。

## Collect.js `dif()`

`dif()`函数将一个集合与另一个集合进行比较。 它从原始集合中返回第二个集合中不存在的值。

`diff_fun.js`

```js
const collect = require('collect.js');

const nums = [1, 2, 3, 4];
const nums2 = [3, 4, 5, 6];

const data = collect(nums);
const data2 = collect(nums2);

const difference = data.diff(data2);

console.log(difference.all());

```

该示例返回两个数组之间的差。

```js
$ node diff_fun.js
[ 1, 2 ]

```

这是输出。

## Collect.js `partition()`

`partition()`函数将集合的元素分为两部分：通过给定条件的元素和不通过给定条件的元素。

`partition_fun.js`

```js
const collect = require('collect.js');

const nums = [-1, 2, 3, -4, 5, 7, -2];

const data = collect(nums);

const [positive, negative] = data.partition(e => {
    return e < 0 && e != 0;
});

console.log(positive.all());
console.log(negative.all());

```

该示例使用`partition`函数将正值与负值分开。

```js
$ node partition_fun.js
[ -1, -4, -2 ]
[ 2, 3, 5, 7 ]

```

这是输出。

## Collect.js `pluck()`

`pluck()`函数检索给定键的所有值。

`pluck_fun.js`

```js
const collect = require('collect.js');

const users = [
    { name: 'John', city: 'London', born: '2001-04-01' },
    { name: 'Lenny', city: 'New York', born: '1997-12-11' },
    { name: 'Andrew', city: 'Boston', born: '1987-02-22' },
    { name: 'Peter', city: 'Prague', born: '1936-03-24' },
    { name: 'Anna', city: 'Bratislava', born: '1973-11-18' },
    { name: 'Albert', city: 'Bratislava', born: '1940-12-11' },
    { name: 'Adam', city: 'Trnava', born: '1983-12-01' },
    { name: 'Robert', city: 'Bratislava', born: '1935-05-15' },
    { name: 'Robert', city: 'Prague', born: '1998-03-14' }
];

let data = collect(users);

let names = data.pluck('name');
console.log(names.all());

let cities = data.pluck('city');
console.log(cities.all());

```

该示例从`users`对象的数组中打印所有名称和城市。 由于名称和城市在重复，因此我们使用`unique()`使其具有唯一性。

```js
$ node pluck_fun.js
[ 'John',
    'Lenny',
    'Andrew',
    'Peter',
    'Anna',
    'Albert',
    'Adam',
    'Robert' ]
[ 'London', 'New York', 'Boston', 'Prague', 'Bratislava', 'Trnava' ]

```

这是输出。

## Collect.js `implode()`

`implode()`函数通过给定字符将集合的元素连接在一起。

`implode_fun.js`

```js
const collect = require('collect.js');

const nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

const data = collect(nums);

let output = data.implode('-');
console.log(output);

```

该示例使用'-'字符连接元素。

当我们处理对象时，我们需要指定用于连接元素的键。

`implode_fun2.js`

```js
const collect = require('collect.js');

const users = [
    { name: 'John Doe', occupation: 'gardener' },
    { name: 'Adam Forsythe', occupation: 'writer' },
    { name: 'Peter Smith', occupation: 'programmer' },
    { name: 'Lucy Black', occupation: 'teacher' }
];

const data = collect(users);

let output = data.implode('name', ',');
console.log(output);

```

该示例将对象`users`数组中的名称连接在一起。

```js
$ node implode_fun2.js
John Doe,Adam Forsythe,Peter Smith,Lucy Black

```

这是输出。

## Collect.js `reduce`

`reduce`函数将集合减小为单个值，将每次迭代的结果传递到后续迭代中。 该函数的第一个参数是累加器或进位，第二个参数是当前元素。

`reduce_fun.js`

```js
const collect = require('collect.js');

const nums = [1, 2, 3, 4, 5, 6];

const data = collect(nums);

const val = data.reduce((c, e) => { return e += c });
console.log(val);

const val2 = data.chunk(2).reduce((c, e) => { 
    return c + e.get(0) * e.get(1) 
}, 0);

console.log(val2);

```

该程序使用`reduce()`函数来计算总和和值乘积之和。

```js
const val2 = data.chunk(2).reduce((c, e) => { 
    return c + e.get(0) * e.get(1) 
}, 0);

```

借助`chunk()`函数，我们计算对的乘积之和：`1 * 2 + 3 * 4 + 5 * 6`。

```js
$ node reduce_fun.js
21
44

```

这是输出。

## Collect.js `tap`

`tap`函数将集合传递给给定的回调，使我们可以在特定点挂接到集合中，并在不影响集合本身的情况下对项目执行某些操作。

`tap_fun.js`

```js
const collect = require('collect.js');

const nums = [1, 3, 2, 6, 5, 4];
const data = collect(nums);

const val = data.sort()
        .tap((col) => console.log(col.all()))
        .chunk(2)
        .tap((col) => console.log(col.toArray()))
        .reduce((c, e) => c + e.get(0) * e.get(1));

console.log(val);

```

该示例对集合进行排序，将其分块并最终缩小它。 在此过程中，我们会挂接操作以查看结果。

```js
$ node tap_fun.js
[ 1, 2, 3, 4, 5, 6 ]
[ [ 1, 2 ], [ 3, 4 ], [ 5, 6 ] ]
44

```

这是输出。

## `every`

`every`函数验证集合中的所有元素均通过给定的真实性测试。

`every_fun.js`

```js
const collect = require('collect.js');

const words = ['forest', 'wood', 'sky', 'cloud'];

const data = collect(words);

if (data.every(e => e.length > 2)){

    console.log('Each word has more than 2 letters');
} else {

    console.log('There is at least one word that does not have more than 2 letters');
}

```

该程序将验证集合中的每个单词是否包含两个以上的字符。

```js
$ node every_fun.js
Each word has more than 2 letters

```

该集合通过了真相测试。

## Collect.js `groupBy()`

`groupBy()`函数通过给定的键对集合的项目进行分组。

`groupby_fun.js`

```js
const collect = require('collect.js');

const users = [
    { name: 'John', city: 'London', born: '2001-04-01' },
    { name: 'Lenny', city: 'New York', born: '1997-12-11' },
    { name: 'Andrew', city: 'Boston', born: '1987-02-22' },
    { name: 'Peter', city: 'Prague', born: '1936-03-24' },
    { name: 'Anna', city: 'Bratislava', born: '1973-11-18' },
    { name: 'Albert', city: 'Bratislava', born: '1940-12-11' },
    { name: 'Adam', city: 'Trnava', born: '1983-12-01' },
    { name: 'Robert', city: 'Bratislava', born: '1935-05-15' },
    { name: 'Robert', city: 'Prague', born: '1998-03-14' }
];

const data = collect(users);

let cityGroups = data.groupBy('city');

cityGroups.each((group, city) => {

    console.log(city);

    group.each(e => {

        let { name, city, born } = e;
        console.log(`${name} ${born}`);
    });
});

```

该示例按城市对用户进行分组。

```js
$ node groupby_fun.js
London
John 2001-04-01
New York
Lenny 1997-12-11
Boston
Andrew 1987-02-22
Prague
Peter 1936-03-24
Robert 1998-03-14
Bratislava
Anna 1973-11-18
Albert 1940-12-11
Robert 1935-05-15
Trnava
Adam 1983-12-01

```

这是输出。

在本教程中，我们介绍了 Collect.js JavaScript 库。

您可能也对以下相关教程感兴趣： [Ramda 教程](/javascript/ramda/)， [JSON 服务器教程](/javascript/jsonserver/)， [Moment.js 教程](/javascript/momentjs/)， [Lodash 教程](/javascript/lodash/)。