linqjs记录

在LINQ.js中，你可以使用一系列方法来操作数组。以下是一些常见的LINQ.js数组方法：

教程:https://medium.com/swlh/data-manipulation-in-javascript-using-linq-f3759e00aceb

1.Enumerable.From(array)：将普通数组转换为可查询的LINQ.js数组对象。

2.Where(predicate)：根据指定的条件选择数组中的元素。

$$\ast \ast where(predicate:(element:T,index:number)=>boolean):IEnumerable<T>;\ast \ast$$

var filteredArray = Enumerable.From(array).Where((x)=> x > 5).ToArray();

3.Select(selector)：对数组中的每个元素应用指定的转换函数，返回一个新的数组。

3. 以下每个元素都乘以2

var transformedArray = Enumerable.From(array).Select((x)=> x * 2).ToArray();

var result = Enumerable.from(array).select((user, index) => ({...user,id: index + 1})).toArray();

A… select和where的区别如下：

在linq.js中，select和where是用于查询和筛选数据的两个关键字。它们的区别如下：1. Select：Select用于选择查询结果中的特定字段。它类似于SQL中的SELECT子句。使用Select关键字，你可以指定要从查询结果中返回的字段，并对这些字段进行转换或操作。例如，你可以使用Select来选择一个对象的某个属性，或者对查询结果进行计算或转换。2. Where：Where用于根据条件筛选出符合条件的数据。它类似于SQL中的WHERE子句。使用Where关键字，你可以指定一个条件表达式，用来过滤查询结果中的数据。只有满足条件的数据才会被包含在结果中。简而言之，Select用于选择特定字段并对其进行转换或操作，而Where用于筛选符合特定条件的数据。下面是一个示例，演示如何在linq.js中使用Select和Where：假设有一个包含学生信息的数组students，每个学生对象都有name和age两个属性。现在我们想选择年龄大于18岁的学生的姓名，可以使用以下代码：var students = [{ name: 'Alice', age: 19 },{ name: 'Bob', age: 17 },{ name: 'Charlie', age: 20 },{ name: 'David', age: 18 }
];var result = Enumerable.From(students).Where(function(student) {return student.age > 18;}).Select(function(student) {return student.name;}).ToArray();console.log(result); // 输出: ["Alice", "Charlie"]
在上面的代码中，Where函数用于筛选出年龄大于18岁的学生，而Select函数用于选择学生的姓名。最后，ToArray函数将结果转换为一个数组，方便输出或进一步操作。希望这个解释对你有帮助！如果有任何问题，请随时提问。

4.OrderBy(keySelector)：按照指定的键选择器对数组进行升序排序。

var sortedArray = Enumerable.From(array).OrderBy(function(x) {return x;
}).ToArray();

5.OrderByDescending(keySelector)：按照指定的键选择器对数组进行降序排序。

var sortedArray = Enumerable.From(array).OrderByDescending(function(x) {return x;
}).ToArray();

6.Reverse()：反转数组中的元素顺序。

var reversedArray = Enumerable.From(array).Reverse().ToArray();

7.Skip(count)：跳过数组中的前几个元素。

var skippedArray = Enumerable.From(array).Skip(2).ToArray();

8.Take(count)：选择数组中的前几个或者前几条元素。

var takenArray = Enumerable.From(array).Take(3).ToArray();

9.groupBy：指定的键进行分组。

公式

groupBy<TKey, TElement, TResult, TCompare>(keySelector: (element: T) => TKey, elementSelector: (element: T) => TElement, resultSelector: (key: TKey, element: IEnumerable<TElement>) => TResult, compareSelector: (element: TKey) => TCompare): IEnumerable<TResult>;

let arr = [{ id: 1, name: '' }, { id: 2, name: '测试2' }, { id: 3, name: '测试3' }, { id: 4, name: '测试4' }]const cdrev = Enumerable.from(arr).where((c) =>c.name).groupBy((pet) => pet.id,(pet) => pet,(key, group) => ({key: key,receiveact: group.sum((p) => p.id),})).toArray();

下面逐步解释代码的作用：

1. 创建一个包含对象的数组arr：

   let arr = [{ id: 1, name: '' }, { id: 2, name: '测试2' }, { id: 3, name: '测试3' }, { id: 4, name: '测试4' }]
   

2. 使用Enumerable.from方法将数组转换为可查询的对象：

   const cdrev = Enumerable.from(arr)
   

3. 使用where方法进行筛选，只包含name属性不为空的对象：

   .where((c) => c.name)
   

4. 使用groupBy方法按指定的键进行分组。这里使用id作为键：

   .groupBy((pet) => pet.id,(pet) => pet,(key, group) => ({key: key,receiveact: group.sum((p) => p.id),})
   )
   

   • 第一个参数 (pet) => pet.id 是分组的键，表示按照对象的id属性进行分组。
   • 第二个参数 (pet) => pet 是一个转换函数，它定义了每个分组中的元素应该是什么。
   • 第三个参数 (key, group) => ({ key: key, receiveact: group.sum((p) => p.id) }) 是一个聚合函数，它定义了如何聚合每个分组的结果。在这里，我们将分组的键作为key属性，然后计算每个分组中所有元素的id属性的和作为receiveact属性。

5. 最后，使用toArray方法将分组的结果转换为数组：

   .toArray();
   

总结起来，给定一个包含对象的数组，该代码会筛选出name属性不为空的对象，并根据id属性对它们进行分组。然后，对每个分组中的元素进行聚合，生成一个包含key和receiveact属性的对象数组。希望这样的解释对你有帮助！

10.过滤和筛选数据

使用 linq.js，你可以使用 Enumerable.from() 方法将数组转换为可查询的对象，然后使用链式调用来过滤和筛选数据。

首先，你需要引入 linq.js 库。然后，你可以使用以下代码来重写你的循环：

	// const iftypetwolist = [];// for (let i = 0; i < list.length; i++) {// 	const it = list[i];// 	if (it.children && it.children.length == 0 && it.ftype == 2) {// 		iftypetwolist.push(it.taskmanagerid);// 		iftypetwolist.push(it.taskacterid);// 	}// }import * as Enumerable from 'linq';
const iftypetwolist = Enumerable.from(list).where(it => it.children && it.children.length === 0 && it.ftype === 2).selectMany(it => [it.taskmanagerid, it.taskacterid]).distinct().where(it => it !== 0 && it.toString() !== 'null').orderBy(it => it).toArray();

在上面的代码中，Enumerable.from(list) 将 list 数组转换为可查询的对象。然后，使用 where() 方法来过滤数据，只保留满足条件的元素。接下来，使用 selectMany() 方法来选择并展开每个元素的 taskmanagerid 和 taskacterid 属性，并将它们放入一个新的数组中。然后，使用 distinct() 方法来去重，保留唯一的元素。接着，使用 where() 方法来过滤掉值为 0 或字符串为 ‘null’ 的元素。最后，使用 orderBy() 方法来对数组进行排序，并使用 toArray() 方法将查询结果转换回数组形式。

现在，iftypeonelist 和 iftypetwolist 数组将包含符合条件的元素，并且已经去重、过滤和排序，与你的原始循环的结果相同。

11.distinct() 方法来去重，

条目10有案例

12.groupBy分组

$$groupBy<TKey,TElement,TResult,TCompare>(keySelector:(element:T)=>TKey,elementSelector:(element:T)=>TElement,resultSelector:(key:TKey,element:IEnumerable<TElement>)=>TResult,compareSelector:(element:TKey)=>TCompare):IEnumerable<TResult>;$$

单字段分组

var array = [{id: 1, name: 'Order 1', product: 'Ford'},{id: 1, name: 'Order 1', product: 'BMW'},{id: 2, name: 'Order 2', product: 'Toyota'},{id: 2, name: 'Order 2', product: 'Skoda'},{id: 2, name: 'Order 2', product: 'Fiat'}
];
var result = Enumerable.from(array).groupBy(g => g.name,element => element,(key, items) => ({key, items: items.toArray()})).toArray()

多字段分组

.groupBy(g => ({ g.name, g.id })),element => element,(key, items) => ({key, items: items.toArray()})).toArray();

这段代码是使用Vue.js中的groupBy函数对一个数组进行分组操作。

1. groupBy函数接受三个参数：一个用于分组的键函数、一个用于选择分组元素的函数和一个用于处理每个分组的函数。

2. 第一个参数(pet) => pet.id是一个箭头函数，它定义了如何从数组中的每个元素中提取一个键。在这个例子中，我们使用pet.id作为键来分组。

3. 第二个参数(pet) => pet是一个箭头函数，它定义了如何选择分组元素。在这个例子中，我们选择了整个pet对象作为分组元素。

4. 第三个参数(key, group) => ({ key: key, receiveact: group.sum((p) => p.id) })是一个箭头函数，它定义了如何处理每个分组。在这个例子中，我们创建了一个新的对象，其中包含两个属性：key和receiveact。

5. key属性是分组的键，它的值是第一个参数(pet) => pet.id提取的键。

6. receiveact属性是对每个分组中的元素进行求和操作的结果。在这个例子中，我们使用了group.sum((p) => p.id)来计算每个分组中pet.id的总和。

总结一下，这段代码的作用是将一个数组按照pet.id进行分组，并计算每个分组中pet.id的总和。最终返回一个包含分组键和总和的对象数组。

let arr = [{ id: 1, name: '测试1' },{ id: 2, name: '测试2' },{ id: 3, name: '测试3' },{ id: 4, name: '测试4' },];const cdrev = Enumerable.from(arr).where((c) => {if (c.name) {return c;}}).groupBy((pet) => pet.name,//选择以哪个键分组(pet) => pet,(key, group) => ({key: key,//此时的key等于 pet.namereceiveact: group.sum((p) => p.id),})).toArray();
//以下代码自动返回对象
.groupBy((pet) => pet.billid,(pet) => pet,(key, group) => ({key: key,fname: '',billno: '',pid: 0,fcount: group.count(),plantotal: ~~group.sum((p) => p.plantotal),plantotalaftertax: ~~group.sum((p) => p.plantotalaftertax),invoicetotal: ~~group.sum((p) => p.invoicetotal),invoicetotalaftertax: ~~group.sum((p) => p.invoicetotalaftertax),receiveact: 0,receiveactaftertax: 0,percent: 0,}))
//第二种请概况,也可以只构建分组let result = Enumerable.from(arr).groupBy((item: any) => item.bigarea).select((group) => ({bigarea: group.key,questionid: id,childern: group.groupBy((item: any) => item.city).select((cityGroup: any) => ({city: cityGroup.key,childern: cityGroup.groupBy((it: any) => it.brand).select((ftypeGroup: any) => ({brand: ftypeGroup.key,plannedNum: ftypeGroup.count(),childern: ftypeGroup.toArray(),})).toArray(),})).toArray(),})).toArray();const allQuestionnaireUserList = Enumerable.from(allQuestionnaireUser).groupBy((item: any) => item.questionid).toObject((group) => group.key,(group) => group.toArray());
//分组后设置,属性名// [// 	{ ftype: 1, name: '1111' },// 	{ ftype: 1, name: '2222' },// 	{ ftype: 2, name: '333333' },// ];
let groupedByFtype = Enumerable.from(rawData.value).groupBy((x: any) => x.ftype).select((g: any) => ({ftype: g.key,children: g.toArray(),})).toArray();

//原来数组
const originalArray = [{ id: 1, name: '222' },{ id: 2, name: '3333' },{ id: 1, name: 333 },
];
//结果对象{1: [{ id: 1, name: '222' },{ id: 1, name: 333 }],2: [{ id: 2, name: '3333' }],}const allQuestionnaireUserList = Enumerable.from(allQuestionnaireUser).groupBy((item: any) => item.id).toObject((group) => group.key,(group) => group.toArray());

13.将for循环改为linq写法

	let ftypeArr = [];for (let i = 0; i < groupedByFtype.length; i++) {const el = groupedByFtype[i];let obj = { label: '', value: i + 1 };obj.label = el.ftype;ftypeArr.push(obj);}let ftypeArr = Enumerable.range(0, groupedByFtype.length).select((i) => {let el = groupedByFtype[i];return { label: el.ftype, value: i + 1 };}).toArray();使用LINQ.js实现上述代码可以按照以下步骤进行：1. 首先，确保已经引入了LINQ.js库。2. 使用LINQ.js的`Enumerable.Range`方法创建一个从0到`groupedByFtype.length - 1`的整数序列。3. 使用`Enumerable.Select`方法对整数序列进行映射，将每个整数`i`转换为一个包含`label`和`value`属性的对象。4. 在映射函数中，设置`label`属性为`groupedByFtype[i].ftype`，设置`value`属性为`i + 1`。5. 使用`Enumerable.ToArray`方法将LINQ查询结果转换为数组。下面是使用LINQ.js实现的代码：```javascript
let ftypeArr = Enumerable.Range(0, groupedByFtype.length).Select(i => {let el = groupedByFtype[i];return { label: el.ftype, value: i + 1 };}).ToArray();
```这样，你就可以使用LINQ.js来实现相同的功能了。

13.0 selectMany:将属性展开为一个扁平的数组(将一个属性对应的值(数组)直接变成循环的数组)

	// let arr = [];// for (let i = 0; i < typePullDownList.value.length; i++) {// 	const el = typePullDownList.value[i];// 	if (el.value == e) {// 		arr = el.children;// 		break;// 	}// }// let cityArr = Enumerable.from(arr)// 	.groupBy((x: any) => x.city)// 	.select((g: any) => ({// 		city: g.key || '未设置城市',// 		children: g.toArray(),// 	}))// 	.select((el, i) => ({// 		label: el.city,// 		value: i + 1,// 		children: el.children,// 	}))// 	.toArray();let cityArr = Enumerable.from(typePullDownList.value).where((el) => el.value == e).selectMany((el) => el.children).groupBy((x: any) => x.city).select((g: any) => ({city: g.key || '未设置城市',children: g.toArray(),})).select((el, i) => ({label: el.city,value: i + 1,children: el.children,})).toArray();解释:	在这个合并后的代码中，我们首先使用`where`方法筛选出`typePullDownList.value`中`value`属性等于`e`的元素。然后，我们使用`selectMany`方法将这些元素的`children`属性展开为一个扁平的数组。接下来，我们使用`groupBy`将数组按照`city`属性进行分组。然后，我们使用`select`将每个分组转换为一个对象，其中包含`city`和`children`属性。接着，我们使用`select`将每个对象转换为一个新的对象，其中包含`label`、`value`和`children`属性。最后，我们使用`toArray`将结果转换为一个数组。请注意，我们还添加了一个条件来检查`city`属性是否存在，如果不存在，则将其设置为'未设置城市'。这样可以确保在没有城市属性的情况下，仍然可以正确地生成结果数组。

13.1:常用for循环(firstOrDefault)

let name;
for (let i = 0; i < typePullDownList.value.length; i++) {const element = typePullDownList.value[i];if (element.value == typePullDownId.value) {name = element.label;break}
}使用LINQ.js可以将上述代码转换为以下形式：```javascript
let name = Enumerable.From(typePullDownList.value).Where(element => element.value == typePullDownId.value).Select(element => element.label).FirstOrDefault();
```这里的`Enumerable.From`方法将数组`typePullDownList.value`转换为一个可查询的集合。然后使用`Where`方法筛选出`value`属性等于`typePullDownId.value`的元素。接着使用`Select`方法选择`label`属性，并最后使用`FirstOrDefault`方法获取第一个匹配的元素的`label`属性值。请确保在使用LINQ.js之前先引入该库。

14.去重(.distinct())

	itemsmineidarr.value = Enumerable.from(datamod).select('tid') // 选择'tid'属性.distinct() // 去重.toArray(); // 转换为数组

15.first (返回集合的第一个元素。如果集合中不存在任何元素，则应用程序将抛出异常。如果集合为空，则返回默认值。)

var array = [
{name: 'ondrej', lastname: 'hlouzek', age: 38},
{name: 'jakub', lastname: 'hlouzek', age: 39}
];var result = Enumerable.from(array).orderBy(o => o.name).first();

16.last (返回集合的最后一个元素。如果集合中不存在任何元素，则应用程序将抛出异常。如果集合为空，LastorDefault返回默认值。)

var array = [
{name: 'ondrej', lastname: 'hlouzek', age: 38},
{name: 'jakub', lastname: 'hlouzek', age: 39}
];var result = Enumerable.from(array).orderBy(o => o.name).last();

17.single (只有当应用该方法的集合只有一个元素时，该方法才返回一个对象。在singleOrDefault的情况下，只有当它所应用的集合返回单个元素或空集合时，它才返回一个对象。如果集合包含2个或更多元素，则。抛出异常。)

var array = [
{name: 'ondrej', lastname: 'hlouzek', age: 38}
];
var result = Enumerable.from(array).single();

18.take(此方法返回指定数量的记录。它通常被用来与orderBy方法一起。)

var array = [{name: 'Order 1', cost: 15233},{name: 'Order 2', cost: 33533},{name: 'Order 3', cost: 23511},{name: 'Order 4', cost: 11244},{name: 'Order 5', cost: 44432}
];
var result = Enumerable.from(array).orderBy(o => o.cost).take(2).toArray();

19.contains 类似includes (配合where,条件是contains方法。您可以使用此函数搜索特定的值列表。在本例中，我要查找两个特定的文档号。)

$$contains(value:T):boolean;$$

//查找array中documentNumber在numbers中的数据var array = [{documentNumber: '140710', createdDate: '2019-11-01', contract: '', total: 242.64,	reference: 'PRIMARK MILAN RCW LAURENCE TAYLOR'},{documentNumber: '140352', createdDate: '2019-11-02', contract: 'PRI19/00050',	total: 22865.90, reference: '***GF WHC***'},{documentNumber: '140120', createdDate: '2019-11-02', contract: 'PRI19/00052',	total: 17732.70, reference: '***GF WHC***'},{documentNumber: '140117', createdDate: '2019-11-03', contract: 'PRI19/00011',	total: 15982.80, reference: '***GF WHC***'},{documentNumber: '139977', createdDate: '2019-11-04', contract: '', total:	7314.98,	reference: '***FIRST FLOOR RCW&PERIMETER***'},{documentNumber: '139976', createdDate: '2019-11-08', contract: 'PRI19/00028',	total: 10147.23, reference: ''},{documentNumber: '139971', createdDate: '2019-11-13', contract: '', total: 16285.72, reference: '***FIRST FLOOR CD ATRIUMS***'}, {documentNumber: '139968', createdDate: '2019-11-15', contract: '', total: 8111.79, reference: '***FIRST FLOOR B-FRAMES***'},{documentNumber: '139817', createdDate: '2019-11-18', contract: 'PRI19/00052', total: 5190.59, reference: '***GF RCW&RET***'},{documentNumber: '139617', createdDate: '2019-11-23', contract: 'PRI19/00052', total: 14378.54, reference: '*****GROUND FLOOR CD*****'}];var numbers = ['139976', '139971'];
var result = Enumerable.from(array)
.where(w => Enumerable.from(numbers).contains(w.documentNumber))
.toArray();
//结果:[ {documentNumber: '139976', createdDate: '2019-11-08', contract: 'PRI19/00028',	total: 10147.23, reference: ''},//{documentNumber: '139971', createdDate: '2019-11-13', contract: '', total: 16285.72, reference: '***FIRST FLOOR CD //ATRIUMS***'}] 

20.all (只有当所有元素都满足指定的条件时，all方法才返回true)

$$all(predicate:(element:T)=>boolean):boolean;$$

var array = [1, 2, 3, 4, 5];var allGreaterThanZero = Enumerable.from(array).all(element => element > 0);console.log(allGreaterThanZero); // 输出 true

21.any (any方法只有在没有元素满足谓词中指定的条件时才返回数据。)

22.GroupJoin(基于键相等关系将两个序列的元素关联起来，并将结果分组。)

$$groupJoin<TInner,TKey,TResult>(inner:IEnumerable<TInner>,outerKeySelector:(outer:T)=>TKey,innerKeySelector:(inner:TInner)=>TKey,resultSelector:(outer:T,inner:IEnumerable<TInner>)=>TResult,compareSelector?:(obj:T)=>TKey):IEnumerable<TResult>;$$

var orders = [{id: 1, name: 'Order 1'}
];
var orderItems = [{ orderId: 1, product: 'Ford' },{ orderId: 1, product: 'BMW' }
]
var result = Enumerable.from(orders).groupJoin(Enumerable.from(orderItems),pk => pk.id,fk => fk.orderId,(order, items) => ({...order, items: items.toArray()})).toArray();

23.聚合函数(Aggregation functions)

min(selector?: (element: T) => number): number;
max(selector?: (element: T) => number): number;
average(selector?: (element: T) => number): number;    
count(predicate?: (element: T, index: number) => boolean): number;
sum(selector?: (element: T) => number): number;

可以将以下类型的aggfunc (selector ?: (element: T) => number): number聚合函数应用于IEnumerable<T>集合:
min-返回集合中的最小值
Max -返回集合中的最大值
average-返回集合中的平均值
Count -返回集合中元素的个数
Sum -返回集合中元素的和

var orderItems = [{ orderId: 1, product: 'Ford', cost: 10000 },{ orderId: 1, product: 'BMW', cost: 30000 },{ orderId: 2, product: 'Toyota', cost: 20000 }, { orderId: 2, product: 'Skoda', cost: 8000 },{ orderId: 2, product: 'Fiat', cost: 6000 }
]
var result = Enumerable.from(orderItems).groupBy(g => g.orderId).select(s => ({orderId: s.key(),max: s.max(m => m.cost),min: s.min(m => m.cost),avg: s.average(m => m.cost),  count: s.count(),sum: s.sum(s => s.cost)
})).toArray();

效果图

24.MaxBy, MinBy(返回数组中,根据某个属性判断返回某行元素)

$$constresult=Enumerable.from(orders).maxBy(s=>s.total);$$

查询查找列(红色列)中的最大值，并返回整个行(黄色行)。

25.Zip用于连接两个集合

zip<U, TResult>(second: IEnumerable<U>, resultSelector: (first: T, second: U, index: number) => TResult): IEnumerable<TResult>

export const orders = [{ id: 1, name: 'Order 1', createdDate: '2020.8.1' },{ id: 2, name: 'Order 2', createdDate: '2020.8.2' },{ id: 3, name: 'Order 3', createdDate: '2020.8.5' },{ id: 3, name: 'Order 3', createdDate: '2020.8.5' },];export const orderItems = [{ row: 1, cost: 20000 },{ row: 2, cost: 30000 },{ row: 3, cost: 40000 },{ row: 4, cost: 50000 },]const result = Enumerable.from(orders).zip(orderItems, (left, right) => ({ ...left, ...right })).toArray();

26.forEach

Enumerable.from(array).forEach(f => console.log(`item ${f}`);

27.多字段排序

排序命令如下:

orderBy—第一个按升序排序的命令

orderbydescent—第一个按降序排序的命令

thenBy—下一个按升序排序的命令

thenbydescent—下一个按降序排序的命令

Enumerable.from(array).orderByDescending(o => o.lastname).thenBy(o => o.name).thenByDescending(o => o.age)

28.Inner Join 求两个集合的交集(1:1,1:N,…)

公式

join<TInner, TKey, TResult>(inner: IEnumerable<TInner>, outerKeySelector: (outer: T) => TKey, innerKeySelector: (inner: TInner) => TKey, resultSelector: (outer: T, inner: TInner) => TResult, compareSelector?: (obj: T) => TKey): IEnumerable<TResult>;

只有当记录存在于两端(集合、表)时，内部连接才返回数据。如果其中一侧或另一侧的记录缺失，则该记录将不会被返回。

.join命令用于实现内部连接。左右集合(表)的连接是使用主键和外键来解决的。只要在左侧和右侧找到匹配，就返回连接的记录。根据图片。左边是主键Id= 1，右边是外键OrderId = 1 pk 1 = fk 1。在这种情况下，返回两行，其中左侧根据右侧的行重复。这是一个类型1:N连接。

结果

29.Left Join

左外连接是返回第一个集合的每个元素的连接，而不管它在第二个集合中是否有任何相关元素。您可以使用LINQ通过对组连接的结果调用DefaultIfEmpty方法来执行左外连接。

在实践中，最常见的情况是连接两个数据源。这是一个连接，只有在主键和外键之间存在连接时，辅助资源才会连接到主资源。主要来源保持不变

const result = Enumerable.from(orders).groupJoin(Enumerable.from(orderItems),pk => pk.id,fk => fk.orderId,(left, right) => ({...left, right})).selectMany(m => m.right.defaultIfEmpty(),(left, right) => ({...left, ...right})).toArray();

结果

可以封装成函数

export const LeftJoin = (source, inner, pk, fk, result) => Enumerable.from(source).groupJoin(Enumerable.from(inner),s => pk(s),i => fk(i),(left, right) => ({left, right})).selectMany(m => m.right.defaultIfEmpty(),(prev, right) => result(prev.left, right));

30.Right join 右外连接

右外连接是第二个集合的每个元素所在的连接返回，不管它在第一个元素中是否有任何相关元素收集。方法来执行右外连接在组连接的结果上使用DefaultIfEmpty方法。

右连接与左连接完全相反。这是一个连接，只有当主键和外键之间存在链接时，主资源才会连接到辅助资源。二次源保持不变。

与leftJoin的情况一样，LINQ中没有rightJoin函数，因此我们将使用LINQ自己编写它。

Enumerable.prototype.rightJoin = function(inner, pk, fk, result) {return RightJoin(this, inner, pk, fk, result);
}

结果如下

const result = Enumerable.from(orders).rightJoin(Enumerable.from(orderItems),pk => pk.id,fk => fk.orderId,(left, right) => ({...left, ...right})
).toArray();

31.Full outer join 合并两个表

当左表 (table1) 或右表 (table2) 记录中有匹配项时，FULL OUTER JOIN 关键字将返回所有记录。

它基本上同时执行左连接和右连接。因此，将显示来自左集合和右集合的所有记录。同样，在LINQ中没有调用完全外部连接的等效组件，因此我们编写自己的组件。正如您将看到的，完整的外部连接将是我们已经创建的LeftJoin和RightJoin方法的组合。

export const FullOuterJoin = (source, inner, pk, fk, result) => {var left = LeftJoin(source, inner, pk, fk, result);var right = RightJoin(source, inner, pk, fk, result);return left.unionDistinct(right);
}

我们将用fulllouterjoin方法扩展Enumerable

Enumerable.prototype.fullOuterJoin = function(inner, pk, fk, result) {return FullOuterJoin(this, inner, pk, fk, result);
}

即使左侧的记录Id = 3在右侧没有相应的记录，右侧的记录Userld = 4在左侧没有相应的记录，它们仍然会在结果集合中。结果如下: