min.go

Documentation: github.com/thoas/go-funk

     1  package funk
     2  
     3  import "strings"
     4  
     5  // MinInt validates the input, compares the elements and returns the minimum element in an array/slice.
     6  // It accepts []int
     7  // It returns int
     8  func MinInt(i []int) int {
     9  	if len(i) == 0 {
    10  		panic("arg is an empty array/slice")
    11  	}
    12  	var min int
    13  	for idx := 0; idx < len(i); idx++ {
    14  		item := i[idx]
    15  		if idx == 0 {
    16  			min = item
    17  			continue
    18  		}
    19  		if item < min {
    20  			min = item
    21  		}
    22  	}
    23  	return min
    24  }
    25  
    26  // MinInt8 validates the input, compares the elements and returns the minimum element in an array/slice.
    27  // It accepts []int8
    28  // It returns int8
    29  func MinInt8(i []int8) int8 {
    30  	if len(i) == 0 {
    31  		panic("arg is an empty array/slice")
    32  	}
    33  	var min int8
    34  	for idx := 0; idx < len(i); idx++ {
    35  		item := i[idx]
    36  		if idx == 0 {
    37  			min = item
    38  			continue
    39  		}
    40  		if item < min {
    41  			min = item
    42  		}
    43  	}
    44  	return min
    45  }
    46  
    47  // MinInt16 validates the input, compares the elements and returns the minimum element in an array/slice.
    48  // It accepts []int16
    49  // It returns int16
    50  func MinInt16(i []int16) int16 {
    51  	if len(i) == 0 {
    52  		panic("arg is an empty array/slice")
    53  	}
    54  	var min int16
    55  	for idx := 0; idx < len(i); idx++ {
    56  		item := i[idx]
    57  		if idx == 0 {
    58  			min = item
    59  			continue
    60  		}
    61  		if item < min {
    62  			min = item
    63  		}
    64  	}
    65  	return min
    66  }
    67  
    68  // MinInt32 validates the input, compares the elements and returns the minimum element in an array/slice.
    69  // It accepts []int32
    70  // It returns int32
    71  func MinInt32(i []int32) int32 {
    72  	if len(i) == 0 {
    73  		panic("arg is an empty array/slice")
    74  	}
    75  	var min int32
    76  	for idx := 0; idx < len(i); idx++ {
    77  		item := i[idx]
    78  		if idx == 0 {
    79  			min = item
    80  			continue
    81  		}
    82  		if item < min {
    83  			min = item
    84  		}
    85  	}
    86  	return min
    87  }
    88  
    89  // MinInt64 validates the input, compares the elements and returns the minimum element in an array/slice.
    90  // It accepts []int64
    91  // It returns int64
    92  func MinInt64(i []int64) int64 {
    93  	if len(i) == 0 {
    94  		panic("arg is an empty array/slice")
    95  	}
    96  	var min int64
    97  	for idx := 0; idx < len(i); idx++ {
    98  		item := i[idx]
    99  		if idx == 0 {
   100  			min = item
   101  			continue
   102  		}
   103  		if item < min {
   104  			min = item
   105  		}
   106  	}
   107  	return min
   108  }
   109  
   110  // MinFloat32 validates the input, compares the elements and returns the minimum element in an array/slice.
   111  // It accepts []float32
   112  // It returns float32
   113  func MinFloat32(i []float32) float32 {
   114  	if len(i) == 0 {
   115  		panic("arg is an empty array/slice")
   116  	}
   117  	var min float32
   118  	for idx := 0; idx < len(i); idx++ {
   119  		item := i[idx]
   120  		if idx == 0 {
   121  			min = item
   122  			continue
   123  		}
   124  		if item < min {
   125  			min = item
   126  		}
   127  	}
   128  	return min
   129  }
   130  
   131  // MinFloat64 validates the input, compares the elements and returns the minimum element in an array/slice.
   132  // It accepts []float64
   133  // It returns float64
   134  func MinFloat64(i []float64) float64 {
   135  	if len(i) == 0 {
   136  		panic("arg is an empty array/slice")
   137  	}
   138  	var min float64
   139  	for idx := 0; idx < len(i); idx++ {
   140  		item := i[idx]
   141  		if idx == 0 {
   142  			min = item
   143  			continue
   144  		}
   145  		if item < min {
   146  			min = item
   147  		}
   148  	}
   149  	return min
   150  }
   151  
   152  // MinString validates the input, compares the elements and returns the minimum element in an array/slice.
   153  // It accepts []string
   154  // It returns string
   155  func MinString(i []string) string {
   156  	if len(i) == 0 {
   157  		panic("arg is an empty array/slice")
   158  	}
   159  	var min string
   160  	for idx := 0; idx < len(i); idx++ {
   161  		item := i[idx]
   162  		if idx == 0 {
   163  			min = item
   164  			continue
   165  		}
   166  		min = compareStringsMin(min, item)
   167  	}
   168  	return min
   169  }
   170  
   171  func compareStringsMin(min, current string) string {
   172  	r := strings.Compare(strings.ToLower(min), strings.ToLower(current))
   173  	if r < 0 {
   174  		return min
   175  	}
   176  	return current
   177  }
   178
View as plain text