definition improvements, updated functions, added some

Author: morrisjdev

README.md

@@ -97,6 +97,17 @@ var array = ["item1", "item2", "item3", "item4", "no"];
 array.Get(2);
 ```
 
+### Repeat
+
+Repeats an object in the array
+
+```javascript
+var array = ["item1", "item2", "item3", "item4"];
+
+//["item1", "item2", "item3", "item4", "example", "example", "example"]
+array.Repeat("example", 3);
+```
+
 ### ForEach
 
 Executes a method for each item in the array
@@ -225,6 +236,22 @@ array.Count();
 array.Count("i => i.match(/item/gi)");
 ```
 
+### SequenceEqual
+
+Compares to sequences of objects
+
+```javascript
+var array = ["item1", "item2", "item3"];
+var array2 = ["item1", "item2", "item3"];
+var array3 = ["item", "item2", "item3"];
+
+//true
+array.SequenceEqual(array2);
+
+//false
+array.SequenceEqual(array3);
+```
+
 ### Any
 
 Tests if any item is in the array and if set matches the filter
@@ -276,6 +303,30 @@ var array2 = ["item4", "no"];
 array.Concat(array2);
 ```
 
+### Intersect
+
+Combines two arrays but only applies values that are in both arrays
+
+```javascript
+var array = ["item1", "item2", "item3"];
+var array2 = ["item1", "unique", "item2", "item3"];
+
+//["item1", "item2", "item3"]
+array.Intersect(array2);
+```
+
+### Union
+
+Combines two arrays without duplicates
+
+```javascript
+var array = ["item1", "item2", "item3"];
+var array2 = ["item1", "unique", "item2", "item3"];
+
+//["item1", "item2", "item3", "unique"]
+array.Union(array2);
+```
+
 ### Join
 
 Joins the entries by the given char
@@ -292,7 +343,7 @@ array.Join("-", "x => x.length > 2");
 
 ### Aggregate
 
-Combines the entries by your definition
+Combines the entries using a custom function
 
 ```javascript
 var array = ["item1", "item2", "item3", "item4", "no"];
@@ -301,6 +352,32 @@ var array = ["item1", "item2", "item3", "item4", "no"];
 array.Aggregate("(str, item) => item + '-' + item");
 ```
 
+### ToDictionary
+
+Converts the array to a dictionary
+
+```javascript
+var array = [{OtherId: 1, Value: "item1"}, {OtherId: 2, Value: "item2"}];
+
+//{1: {OtherId: 1, Value: "item1"}, 2: {OtherId: 2, Value: "item2"}}
+array.ToDictionary("x => x.OtherId");
+
+//{1: "item1", 2: "item2"}
+array.ToDictionary("x => x.OtherId", "x => x.Value");
+```
+
+### Zip
+
+Combines the entries of two arrays using a custom function
+
+```javascript
+var array = [0, 1, 2, 3, 4];
+var array2 = ["zero", "one", "two", "three"];
+
+//["0 zero", "1 one", "2 two", "3 three"]
+array.Zip(array2, "(x, y) => x + ' ' + y");
+```
+
 ### Reverse
 
 Reverses the array
@@ -386,6 +463,22 @@ array.FirstOrDefault("i => i.match(/item/gi)");
 array.First("i => i == 'notgiven'");
 ```
 
+### Min
+
+Returns the smallest element in array
+
+```javascript
+var array = [0, 8, 1, 5, -3];
+
+//-3
+array.Min();
+
+var array = [{name: "test", age: 3}, {name: "test2", age: 18}];
+
+//{name: "test", age: 3}
+array.Min("x => x.age");
+```
+
 ### Last
 
 Returns the Last item of the array and if a filter was set the last item that matches the filter - Throws an Exception if no item was found
@@ -420,6 +513,22 @@ array.LastOrDefault("i => i.match(/item/gi)");
 array.LastOrDefault("i => i == 'notgiven'");
 ```
 
+### Max
+
+Returns the greates element in array
+
+```javascript
+var array = [0, 8, 1, 5, -3];
+
+//8
+array.Max();
+
+var array = [{name: "test", age: 3}, {name: "test2", age: 18}];
+
+//{name: "test2", age: 18}
+array.Max("x => x.age");
+```
+
 ### Select
 
 Select the properties for a new array
@@ -445,6 +554,41 @@ var array = ["item1", "item2", "item3", "item4"];
 array.Take(2);
 ```
 
+### TakeWhile
+
+Takes entries as long as a condition is true
+
+```javascript
+var array = ["item1", "item2", "item3", "item2", "item4"];
+var item2count = 0;
+
+//["item1", "item2", "item3"]
+array.TakeWhile(function(x){
+	if(x == "item2"){
+		item2count++;
+	}
+
+	return item2count < 2;
+});
+```
+
+This is the basic usage. But if you want conditional executes for e.g. with counting this can get a little bit messy.
+
+```javascript
+var array = ["item1", "item2", "item3", "item2", "item4"];
+
+//["item1", "item2", "item3"]
+array.TakeWhile(function(item, storage){
+	return item != "item2" || storage.count < 1; //Condition
+}, function(storage){
+	storage.count = 0; //Init the Storage
+}, function(item, storage){
+	if(item == "item2"){
+		storage.count++; //After executing the condition
+	}
+});
+```
+
 ### Skip
 
 Skips entries

demo/demo.js

@@ -31,6 +31,15 @@ window.onload = function () {
     Helper.users = Helper.users.Clone();
     Helper.draw();
 };
+var test = [new User(1, "Max", "Mustermann", 18), new User(2, "John", "Doe", 89), new User(2, "John", "Doe", 18)];
+console.log(test.Where(function (x) { return x.Age > 10; }));
+var result = test.Aggregate(function (x, y) {
+    return x += y.Age;
+});
+console.log(result);
+var array = ["item1", "item2", "item3", "item2", "item4"];
+var res2 = array.TakeWhile('(x, s) => x != "item2" || s.c < 1', 's => s.c = 0', '(x, s) => x == "item2" && s.c++');
+console.log(res2);
 //let test: Array<Linq4JS.Entity> = [new testClass("test", 5, 1), new testClass("test5", 3, 2)];
 //console.log(test);
 //console.log("Foreach");

demo/js/app.ts

@@ -45,6 +45,22 @@ window.onload = function () {
     Helper.draw();
 };
 
+let test: Array<User> = [new User(1, "Max", "Mustermann", 18), new User(2, "John", "Doe", 89), new User(2, "John", "Doe", 18)];
+console.log(test.Where(x => x.Age > 10));
+
+let result = test.Aggregate((x, y) => {
+    return x += y.Age;
+});
+
+console.log(result);
+
+
+let array = ["item1", "item2", "item3", "item2", "item4"];
+
+let res2 = array.TakeWhile('(x, s) => x != "item2" || s.c < 1', 's => s.c = 0', '(x, s) => x == "item2" && s.c++');
+
+console.log(res2);
+
 //let test: Array<Linq4JS.Entity> = [new testClass("test", 5, 1), new testClass("test5", 3, 2)];
 //console.log(test);
 

dev/Helper.ts

@@ -1,6 +1,6 @@
 namespace Linq4JS {
     export class Helper {
-        static ConvertStringFunction: Function = function (functionString: string): Function {
+        static ConvertStringFunction = function (functionString: string): any {
 
             if (functionString.length == 0) {
                 throw "Linq4JS: Cannot convert empty string to function";
@@ -23,9 +23,9 @@
             return Function(...varnames, func);
         }
 
-        static ConvertFunction: Function = function (testFunction: any): Function {
+        static ConvertFunction = function<T> (testFunction: any): T {
 
-            let result: Function;
+            let result: T;
 
             if (typeof testFunction == "function") {
                 result = testFunction;
@@ -40,9 +40,9 @@
             return result;
         }
 
-        static OrderCompareFunction: Function = function (valueSelector: Function, a: Linq4JS.Entity, b: Linq4JS.Entity, invert: boolean): number {
-            let value_a: any = valueSelector(a);
-            let value_b: any = valueSelector(b);
+        static OrderCompareFunction = function<T> (valueSelector: (item: T) => any, a: T, b: T, invert: boolean): number {
+            let value_a = valueSelector(a);
+            let value_b = valueSelector(b);
 
             let type = typeof value_a;
 

dev/IArray.ts

@@ -3,40 +3,49 @@
     GroupValue: any;
 
     Clone(): Array<T>;
-    FindIndex(filter: any): number;
+    FindIndex(filter: ((item: T) => boolean) | string): number;
     Get(index: number): T;
-    ForEach(action: any): Array<T>;
-    Update(object: T, primaryKeySelector?: any): Array<T>;
-    UpdateRange(objects: Array<T>, primaryKeySelector?: any): Array<T>;
-    Remove(object: T, primaryKeySelector?: any): Array<T>;
-    RemoveRange(objects: Array<T>, primaryKeySelector?: any): Array<T>;
+    ForEach(action: ((item: T) => boolean | any) | string): Array<T>;
+    Update(object: T, primaryKeySelector?: ((item: T) => any) | string): Array<T>;
+    UpdateRange(objects: Array<T>, primaryKeySelector?: ((item: T) => any) | string): Array<T>;
+    Remove(object: T, primaryKeySelector?: ((item: T) => any) | string): Array<T>;
+    RemoveRange(objects: Array<T>, primaryKeySelector?: ((item: T) => any) | string): Array<T>;
     Add(object: T, generateId?: boolean): Array<T>;
     AddRange(objects: Array<T>): Array<T>;
     Insert(object: T, index: number): Array<T>;
-    Where(filter: any): Array<T>;
+    Where(filter: ((item: T) => boolean) | string): Array<T>;
     Range(start: number, length: number): Array<T>;
-    Count(filter?: any): number;
-    All(filter: any): boolean;
-    Any(filter?: any): boolean;
-    First(filter?: any): T;
-    FirstOrDefault(filter?: any): T;
-    Last(filter?: any): T;
-    LastOrDefault(filter?: any): T;
-    Select(selector: any): any[];
+    Repeat(object: T, count: number): Array<T>;
+    Count(filter?: ((item: T) => boolean) | string): number;
+    All(filter: ((item: T) => boolean) | string): boolean;
+    Any(filter?: ((item: T) => boolean) | string): boolean;
+    First(filter?: ((item: T) => boolean) | string): T;
+    FirstOrDefault(filter?: ((item: T) => boolean) | string): T;
+    Last(filter?: ((item: T) => boolean) | string): T;
+    LastOrDefault(filter?: ((item: T) => boolean) | string): T;
+    Select(selector: ((item: T) => any) | string): any[];
     Take(count: number): Array<T>;
+    TakeWhile(condition: ((item: T, storage?: any) => boolean) | string, initial?: ((storage: any) => void) | string, after?: ((item: T, storage: any) => void) | string): Array<T>;
     Skip(count: number): Array<T>;
-    OrderBy(valueSelector: any): Array<T>;
-    ThenBy(valueSelector: any): Array<T>;
-    OrderByDescending(valueSelector: any): Array<T>;
-    ThenByDescending(valueSelector: any): Array<T>;
-    GroupBy(selector: any): Array<Array<T>>;
+    OrderBy(valueSelector: ((item: T) => any) | string): Array<T>;
+    ThenBy(valueSelector: ((item: T) => any) | string): Array<T>;
+    OrderByDescending(valueSelector: ((item: T) => any) | string): Array<T>;
+    ThenByDescending(valueSelector: ((item: T) => any) | string): Array<T>;
+    Min(valueSelector?: ((item: T) => any) | string): T;
+    Max(valueSelector?: ((item: T) => any) | string): T;
+    GroupBy(selector: ((item: T) => any) | string): Array<Array<T>>;
     Move(oldIndex: number, newIndex: number): Array<T>;
-    Distinct(valueSelector: any, takelast?: boolean): Array<T>;
+    Distinct(valueSelector?: ((item: T) => any) | string): Array<T>;
     Contains(object: T): boolean;
     Concat(array: Array<T>): Array<T>;
-    Join(character: string, selector?: any): string;
-    Aggregate(method: any): string;
+    Intersect(array: Array<T>): Array<T>;
+    Join(character: string, selector?: ((item: T) => any) | string): string;
+    Aggregate(method: ((result: any, item: T) => any) | string, startVal?: any): string;
     Reverse(): Array<T>;
-    Average(selector?: any, filter?: any): number;
-    Sum(selector?: any, filter?: any): number;
+    Average(selector?: ((item: T) => any) | string, filter?: ((item: T) => boolean) | string): number;
+    Sum(selector?: ((item: T) => any) | string, filter?: ((item: T) => boolean) | string): number;
+    SequenceEqual(array: Array<T>): boolean;
+    Zip<T, X>(array: Array<X>, result: ((first: T, second: X) => any) | string): Array<any>;
+    Union(array: Array<T>): Array<T>;
+    ToDictionary(keySelector: ((item: T) => any) | string, valueSelector?: ((item: T) => any) | string): any;
 }

dev/Modules/Aggregate.ts

@@ -1,8 +1,16 @@
-Array.prototype.Aggregate = function<T> (method: any): string {
+Array.prototype.Aggregate = function<T> (method: ((result: any, item: T) => any) | string, startVal?: any): string {
     let that: Array<T> = this;
 
-    let result: string = "";
-    let methodFunction: Function = Linq4JS.Helper.ConvertFunction(method);
+    let result;
+
+    if(startVal != null){
+        result = startVal;
+    }
+    else{
+        result = "";
+    }
+    
+    let methodFunction = Linq4JS.Helper.ConvertFunction<(result: any, item: T) => any>(method);
 
     that.ForEach(function(x){
         result = methodFunction(result, x);

dev/Modules/All.ts

@@ -1,4 +1,4 @@
-Array.prototype.All = function<T> (filter: any): boolean {
+Array.prototype.All = function<T> (filter: ((item: T) => boolean) | string): boolean {
     let that: Array<T> = this;
 
     return that.Count(filter) == that.Count();

dev/Modules/Any.ts

@@ -1,4 +1,4 @@
-Array.prototype.Any = function<T> (filter?: any): boolean {
+Array.prototype.Any = function<T> (filter?: ((item: T) => boolean) | string): boolean {
     let that: Array<T> = this;
 
     return that.Count(filter) > 0;

dev/Modules/Average.ts

@@ -1,4 +1,4 @@
-Array.prototype.Average = function <T>(selector?: any, filter?: any): number {
+Array.prototype.Average = function <T>(selector?: ((item: T) => any) | string, filter?: ((item: T) => boolean) | string): number {
     let that: Array<T> = this;
 
     let result: number = 0;

dev/Modules/Count.ts

@@ -1,4 +1,4 @@
-Array.prototype.Count = function <T>(filter?: any): number {
+Array.prototype.Count = function <T>(filter?: ((item: T) => boolean) | string): number {
     let that: Array<T> = this;
 
     if (filter != null) {