Added find index and it's test

Author: p9ejAyeirtj

README.md

@@ -26,6 +26,16 @@ users := []User{{Id: 10, Name: "Go"}, {Id: 11, Name: "Lang"}}
 
 ```
 
+### Find
+
+```
+user, err := js.Find(users, func(user User, index int) bool {
+    return user.Id == 10
+})
+// {Id: 10, Name: "Go"}
+
+```
+
 ### Filter
 
 ```

find_index_test.go

@@ -0,0 +1,39 @@
+package js_array_method
+
+import "testing"
+
+func TestFindIndexWithCallback(t *testing.T) {
+	users := []User{{Id: 10, Name: "John"}, {Id: 11, Name: "Doe"}, {Id: 12, Name: "Sabrina"}}
+
+	index := FindIndex(users, func(user User, _ int) bool {
+		return user.Name == "Doe"
+	})
+
+	if index == -1 || index == 2 {
+		t.Errorf("Expected 1 got %d", index)
+	}
+
+	index = FindIndex(users, func(user User, _ int) bool {
+		return user.Name == "creator"
+	})
+
+	if index != -1 {
+		t.Errorf("Expected -1 got %d", index)
+	}
+}
+
+func TestFindIndexWithoutCallback(t *testing.T) {
+	users := []string{"User1", "User2", "User3", "User4"}
+
+	index := FindIndex(users, "User1")
+
+	if index != 0 {
+		t.Errorf("Expected 0 got %d", index)
+	}
+
+	index = FindIndex(users, "User5")
+
+	if index != -1 {
+		t.Errorf("Expected -1 got %d", index)
+	}
+}

find_test.go

@@ -5,21 +5,21 @@ import "testing"
 func TestFindWithStructSlice(t *testing.T) {
 	users := []User{{Id: 10, Name: "Go"}, {Id: 11, Name: "Lang"}}
 
-	user := Find(users, func(user User, index int) bool {
+	user, err := Find(users, func(user User, index int) bool {
 		return user.Id == 10
 	})
 
 	expected := "Go"
 
-	if user.Name != expected {
+	if err != nil {
 		t.Errorf("Expected %s received %s", expected, user.Name)
 	}
 }
 
 func TestFindWithStringSlice(t *testing.T) {
 	var slices = []string{"Go", "Typescript", "Nodejs"}
 
-	ln := Find(slices, "Go")
+	ln, _ := Find(slices, "Go")
 
 	expected := "Go"
 

js_array_method.go

@@ -1,10 +1,15 @@
 package js_array_method
 
 import (
-	"fmt"
-	"reflect"
+	"errors"
 )
 
+func Foreach[T any](input []T, callback func(element T, index int)) {
+	for index, value := range input {
+		callback(value, index)
+	}
+}
+
 func Map[T any, U any](input []T, callback func(element T, index int) U) []U {
 	var output []U
 
@@ -50,60 +55,36 @@ func Reduce[T any, U any](input []T, callback func(pre U, current T, index int)
 // conditions can be callback or a value
 // callback has two parameter one is element and another is index
 // callback must return true or false
-func Find[T any](input []T, conditions interface{}) T {
+func Find[T any](input []T, conditions interface{}) (T, error) {
 	var item T
-	conditionType := getType(conditions)
-	for index, value := range input {
-		if conditionType == "func" && callCallback(conditions, value, index) {
-			item = value
-			break
-		} else if conditionType != "func" && compareValue(conditions, value) {
-			item = value
-			break
-		}
-	}
+	index := FindIndex(input, conditions)
 
-	return item
-}
-
-func Foreach[T any](input []T, callback func(element T, index int)) {
-	for index, value := range input {
-		callback(value, index)
+	if index < 0 {
+		return item, errors.New("nothing found")
 	}
-}
 
-func callCallback[T any](conditions interface{}, value T, index int) bool {
-	res := reflect.ValueOf(conditions).Call([]reflect.Value{reflect.ValueOf(value), reflect.ValueOf(index)})
+	item = input[index]
 
-	return res[0].Bool()
+	return item, nil
 }
 
-func compareValue[T any](conditions interface{}, value T) bool {
-	res := reflect.ValueOf(conditions).String()
-	return res == fmt.Sprintf("%v", value)
-}
-
-func getType(conditions interface{}) string {
-	return reflect.TypeOf(conditions).Kind().String()
-}
-
-func calculateEveryElement[T any](input []T, conditions interface{}) []bool {
-	output := []bool{}
-
+// conditions can be callback or a value
+// callback has two parameter one is element and another is index
+// callback must return true or false
+func FindIndex[T any](input []T, conditions interface{}) int {
+	var itemIndex int = -1
 	conditionType := getType(conditions)
 	for index, value := range input {
-		result := false
-		if conditionType == "func" {
-			result = callCallback(conditions, value, index)
-		} else {
-			result = compareValue(conditions, value)
-		}
-		if result {
-			output = append(output, true)
+		if conditionType == "func" && callCallback(conditions, value, index) {
+			itemIndex = index
+			break
+		} else if conditionType != "func" && compareValue(conditions, value) {
+			itemIndex = index
+			break
 		}
 	}
 
-	return output
+	return itemIndex
 }
 
 // conditions can be callback or a value
@@ -126,14 +107,8 @@ func Some[T any](input []T, conditions interface{}) any {
 // callback has two parameter one is element and another is index
 // callback must return true or false
 func Includes[T any](input []T, conditions interface{}) bool {
-	result := Find(input, conditions)
-
-	if getType(result) == "struct" && reflect.ValueOf(result).IsZero() {
-		return false
-	} else if getType(result) != "struct" && fmt.Sprintf("%v", result) == "" {
-		return false
-	}
-	return true
+	result := FindIndex(input, conditions)
+	return result >= 0
 }
 
 func Reverse[T any](input []T) []T {

util.go

@@ -0,0 +1,40 @@
+package js_array_method
+
+import (
+	"fmt"
+	"reflect"
+)
+
+func callCallback[T any](conditions interface{}, value T, index int) bool {
+	res := reflect.ValueOf(conditions).Call([]reflect.Value{reflect.ValueOf(value), reflect.ValueOf(index)})
+
+	return res[0].Bool()
+}
+
+func compareValue[T any](conditions interface{}, value T) bool {
+	res := reflect.ValueOf(conditions).String()
+	return res == fmt.Sprintf("%v", value)
+}
+
+func getType(conditions interface{}) string {
+	return reflect.TypeOf(conditions).Kind().String()
+}
+
+func calculateEveryElement[T any](input []T, conditions interface{}) []bool {
+	output := []bool{}
+
+	conditionType := getType(conditions)
+	for index, value := range input {
+		result := false
+		if conditionType == "func" {
+			result = callCallback(conditions, value, index)
+		} else {
+			result = compareValue(conditions, value)
+		}
+		if result {
+			output = append(output, true)
+		}
+	}
+
+	return output
+}