go>> handy>> 返回
项目作者： miguelpragier

项目描述 ：
GO Golang Utilities and helpers like validators and string formatters
高级语言： Go
项目地址: git://github.com/miguelpragier/handy.git
创建时间： 2018-06-13T13:10:07Z
项目社区：https://github.com/miguelpragier/handy
开源协议：MIT License
下载


GitHub GitHub
Go Report Card
Coverage Status Build Status Mentioned in Awesome Go
CircleCI
Go Version

Handy Go utilities

GO Golang Utilities and helpers like validators, sanitizers and string formatters

Requires GO v>=1.14

Dependencies

None, since v1.1.1

Documentation :green_book:
GoDocs
Quality :point_left:
GoCover

Functions

  1. // CheckEmail returns true if the given sequence is a valid email address
  2. // See https://tools.ietf.org/html/rfc2822#section-3.4.1 for details about email address anatomy
  3. func CheckEmail(email string) bool {}
  5. // CheckNewPassword Run some basic checks on new password strings, based on given options
  6. // This routine requires at least 4 (four) characters
  7. // Example requiring only basic minimum lenght: CheckNewPassword("lalala", "lalala", 10, CheckNewPasswordComplexityLowest)
  8. // Example requiring number and symbol: CheckNewPassword("lalala", "lalala", 10, CheckNewPasswordComplexityRequireNumber|CheckNewPasswordComplexityRequireSymbol)
  9. func CheckNewPassword(password, passwordConfirmation string, minimumLenght uint, flagComplexity uint8) uint8 {
  11. // StringHash simply generates a SHA256 hash from the given string
  12. func StringHash(s string) string {}
  14. // OnlyLetters returns only the letters from the given string, after strip all the rest ( numbers, spaces, etc. )
  15. func OnlyLetters(sequence string) string {}
  17. // OnlyDigits returns only the numbers from the given string, after strip all the rest ( letters, spaces, etc. )
  18. func OnlyDigits(sequence string) string {}
  20. // OnlyLettersAndNumbers returns only the letters and numbers from the given string, after strip all the rest, like spaces and special symbols.
  21. func OnlyLettersAndNumbers(sequence string) string {}
  23. // RandomInt returns a rondom integer within the given (inclusive) range
  24. func RandomInt(min, max int) int {}
  26. // StringAsFloat tries to convert a string to float, and if it can't, just returns zero
  27. // It's limited to one billion
  28. func StringAsFloat(s string, decimalSeparator, thousandsSeparator rune) float64 {}
  30. // StringAsInteger returns the integer value extracted from string, or zero
  31. func StringAsInteger(s string) int {}
  33. // Between checks if param n in between low and high integer params
  34. func Between(n, low, high int) bool {}
  36. // Tif is a simple implementation of the dear ternary IF operator
  37. func Tif(condition bool, tifThen, tifElse interface{}) interface{} {}
  39. // Truncate limits the length of a given string, trimming or not, according parameters
  40. func Truncate(s string, maxLen int, trim bool) string {}
  42. // Transform handles a string according given flags/parametrization, as follows:
  43. // Available Flags to be used alone or combined:
  44. //    TransformNone - Does nothing. It's only for truncation.
  45. //    TransformFlagTrim - Trim spaces before and after proccess the input
  46. //    TransformFlagLowerCase - Change string case to lower
  47. //    TransformFlagUpperCase - Change string case to upper
  48. //    TransformFlagOnlyDigits - Filter/strip all but digits
  49. //    TransformFlagOnlyLetters - Filter/strip all but letters
  50. //    TransformFlagOnlyLettersAndDigits - Filter/strip all but numbers and letters. Removes spaces, punctuation and special symbols
  51. //     TransformFlagHash - Apply handy.StringHash() routine to string
  52. func Transform(s string, maxLen int, transformFlags uint8) string {}
  54. // MatchesAny returns true if any of the given items matches ( equals ) the subject ( search parameter )
  55. func MatchesAny(search interface{}, items ...interface{}) bool {}
  57. // HasOnlyNumbers returns true if the sequence is entirely numeric
  58. func HasOnlyNumbers(sequence string) bool {}
  60. // HasOnlyNumbers returns true if the sequence is entirely composed by letters
  61. func HasOnlyLetters(sequence string) bool {}
  63. // TrimLen returns the runes count after trim the spaces
  64. func TrimLen(text string) int {}
  66. // CheckMinLen verifies if the rune-count is greater then or equal the given minimum
  67. // It returns true if the given string has length greater than or equal than minLength parameter
  68. func CheckMinLen(value string, minLength int) bool {}
  70. // IsNumericType checks if an interface's concrete type corresponds to some of golang native numeric types
  71. func IsNumericType(x interface{}) bool {}
  73. // Bit returns only uint8(0) or uint8(1).
  74. // It receives an interface, and when it's a number, and when this number is 0 (zero) it returns 0. Otherwise it returns 1 (one)
  75. // If the interface is not a number, it returns 0 (zero)
  76. func Bit(x interface{}) uint8 {}
  78. // Boolean returns the bool version/interpretation of some value;
  79. // It receives an interface, and when this is a number, Boolean() returns flase of zero and true for different from zero.
  80. // If it's a string, try to find "1", "T", "TRUE" to return true.
  81. // Any other case returns false
  82. func Boolean(x interface{}) bool {}
  84. // Reverse returns the given string written backwards, with letters reversed.
  85. func Reverse(s string) string {}
  87. // CheckPersonName returns true if the name contains at least two words, one >= 3 chars and one >=2 chars.
  88. // I understand that this is a particular criteria, but this is the OpenSourceMagic, where you can change and adapt to your own specs.
  89. func CheckPersonName(name string, acceptEmpty bool) uint8 {}
  91. // InArray searches for "item" in "array" and returns true if it's found
  92. // This func resides here alone only because its long size.
  93. // TODO Embrace/comprise all native scalar/primitive types
  94. func InArray(array interface{}, item interface{}) bool {}
  96. // ArrayDifferenceAtoB returns the items from A that doesn't exist in B
  97. func ArrayDifferenceAtoB(a, b []int) []int {}
  99. // ArrayDifference returns all items that doesn't exist in both given arrays
  100. func ArrayDifference(a, b []int) []int {}
  103. /* DateTime Routines */
  105. // DateTimeAsString formats time.Time variables as strings, considering the format directive
  106. func DateTimeAsString(dt time.Time, format string) string {}
  108. // StringAsDateTime converts a date-time string using given format string and return it as time.Time
  109. func StringAsDateTime(s string, format string) time.Time {}
  111. // CheckDate validates a date using the given format
  112. func CheckDate(format, dateTime string) bool {
  114. // CheckDate returns true if given sequence is a valid date in format yyyymmdd
  115. // The function removes non-digit characteres like "yyyy/mm/dd" or "yyyy-mm-dd", filtering to "yyyymmdd"
  116. func CheckDateYMD(yyyymmdd string) bool {}
  118. // YMDasDateUTC returns a valid UTC time from the given yyymmdd-formatted sequence
  119. func YMDasDateUTC(yyyymmdd string, utc bool) (time.Time, error) {}
  121. // YMDasDate returns a valid time from the given yyymmdd-formatted sequence
  122. func YMDasDate(yyyymmdd string) (time.Time, error) {}
  124. // ElapsedMonths returns the number of elapsed months between two given dates
  125. func ElapsedMonths(from, to time.Time) int {}
  127. // ElapsedYears returns the number of elapsed years between two given dates
  128. func ElapsedYears(from, to time.Time) int {}
  130. // YearsAge returns the number of years past since a given date
  131. func YearsAge(birthdate time.Time) int {}
  133. /* Brazilian specific routines */
  135. // CheckCPF returns true if the given sequence is a valid cpf
  136. // CPF is the Brazilian TAXPayerID document for persons
  137. func CheckCPF(cpf string) bool {}
  139. // CheckCNPJ returns true if the cnpj is valid
  140. // Thanks to https://gopher.net.br/validacao-de-cpf-e-cnpj-em-go/
  141. // CNPJ is the Brazilian TAXPayerID document for companies
  142. func CheckCNPJ(cnpj string) bool {}
  144. // AmountAsWord receives an int64 e returns the value as its text representation
  145. // Today I have only the PT-BR text.
  146. // Ex: AmountAsWord(129) => "cento e vinte e nove"
  147. // Supports up to one trillion and does not add commas.
  148. func AmountAsWord(n int64) string {}
  150. /* Web/HTTP Specific Routines */
  152. // HTTPRequestAsString gets a parameter coming from a http request as string, truncated to maxLenght
  153. // Only maxLenght >= 1 is considered. Otherwise, it's ignored
  154. func HTTPRequestAsString(r *http.Request, key string, maxLenght int, transformOptions ...uint8) string {}
  156. // HTTPRequestAsInteger gets a parameter coming from a http request as an integer
  157. // It tries to guess if it's a signed/negative integer
  158. func HTTPRequestAsInteger(r *http.Request, key string) int {}
  160. // HTTPRequestAsFloat64 gets a parameter coming from a http request as float64 number
  161. // You have to inform the decimal separator symbol.
  162. // If decimalSeparator is period, engine considers thousandSeparator is comma, and vice-versa.
  163. func HTTPRequestAsFloat64(r *http.Request, key string, decimalSeparator rune) float64 {}
  165. /* Other Routines  */
  167. // CheckPersonNameResult returns a meaningful message describing the code generated bu CheckPersonName
  168. // The routine considers the given idiom. The fallback is in english
  169. func CheckPersonNameResult(idiom string, r uint8) string {}
  171. // CheckNewPasswordResult returns a meaningful message describing the code generated bu CheckNewPassword()
  172. // The routine considers the given idiom. The fallback is in english
  173. func CheckNewPasswordResult(idiom string, r uint8) string {}