git/lancet
1
0
Fork 0
mirror of https://github.com/duke-git/lancet.git synced 2026-02-04 12:52:28 +08:00
Code Issues Projects Releases Wiki Activity
Files
4595a94b4c6e83005eb49a0c264bc85c5d070ae3
lancet/docs/validator.md
dudaodong 4595a94b4c update doc
2024-12-04 10:40:18 +08:00

23 KiB
Raw Blame History

Validator

Package validator contains some functions for data validation.

Source:

https://github.com/duke-git/lancet/blob/v1/validator/validator.go

Usage:

import (
    "github.com/duke-git/lancet/validator"
)

Index

Documentation

ContainChinese

Check if the string contain mandarin chinese.

Signature:

func ContainChinese(s string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    res1 := validator.ContainChinese("你好")
    fmt.Println(res1) //true

    res2 := validator.ContainChinese("你好hello")
    fmt.Println(res2) //true

    res3 := validator.ContainChinese("hello")
    fmt.Println(res3) //false
}

ContainLetter

Check if the string contain at least one letter.

Signature:

func ContainLetter(str string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    res1 := validator.ContainLetter("1bc")
    fmt.Println(res1) //true

    res2 := validator.ContainLetter("123")
    fmt.Println(res2) //false

    res3 := validator.ContainLetter("&@#$%^&*")
    fmt.Println(res3) //false
}

ContainLower

Check if the string contain at least one lower case letter a-z.

Signature:

func ContainLower(str string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    res1 := validator.ContainLower("1bc")
    fmt.Println(res1) //true

    res2 := validator.ContainLower("123")
    fmt.Println(res2) //false

    res3 := validator.ContainLower("1BC")
    fmt.Println(res3) //false
}

ContainUpper

Check if the string contain at least one upper case letter A-Z.

Signature:

func ContainUpper(str string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    res1 := validator.ContainUpper("1bc")
    fmt.Println(res1) //false

    res2 := validator.ContainUpper("123")
    fmt.Println(res2) //false

    res3 := validator.ContainUpper("1BC")
    fmt.Println(res3) //true
}

IsAlpha

Check if the string contains only letters (a-zA-Z).

Signature:

func IsAlpha(s string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    res1 := validator.IsAlpha("abc")
    fmt.Println(res1) //true

    res2 := validator.IsAlpha("1bc")
    fmt.Println(res2) //false

    res3 := validator.IsAlpha("")
    fmt.Println(res3) //false
}

IsAllUpper

Check if string is all upper case letters A-Z.

Signature:

func IsAllUpper(str string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    res1 := validator.IsAllUpper("ABC")
    fmt.Println(res1) //true

    res2 := validator.IsAllUpper("aBC")
    fmt.Println(res2) //false
}

IsAllLower

Check if string is all lower case letters a-z.

Signature:

func IsAllLower(str string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    res1 := validator.IsAllLower("abc")
    fmt.Println(res1) //true

    res2 := validator.IsAllLower("abC")
    fmt.Println(res2) //false
}

IsBase64

Check if the string is base64 string.

Signature:

func IsBase64(base64 string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    res1 := validator.IsBase64("aGVsbG8=")
    fmt.Println(res1) //true

    res2 := validator.IsBase64("123456")
    fmt.Println(res2) //false
}

IsChineseMobile

Check if the string is valid chinese mobile number.

Signature:

func IsChineseMobile(mobileNum string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    res1 := validator.IsChineseMobile("13263527980")
    fmt.Println(res1) //true

    res2 := validator.IsChineseMobile("434324324")
    fmt.Println(res2) //false
}

IsChineseIdNum

Check if the string is chinese id number.

Signature:

func IsChineseIdNum(id string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    res1 := validator.IsChineseIdNum("210911192105130715")
    fmt.Println(res1) //true

    res2 := validator.IsChineseIdNum("123456")
    fmt.Println(res2) //false
}

IsChinesePhone

Check if the string is chinese phone number.

Signature:

func IsChinesePhone(phone string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    res1 := validator.IsChinesePhone("010-32116675")
    fmt.Println(res1) //true

    res2 := validator.IsChinesePhone("123-87562")
    fmt.Println(res2) //false
}

IsCreditCard

Check if the string is credit card.

Signature:

func IsCreditCard(creditCart string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    res1 := validator.IsCreditCard("4111111111111111")
    fmt.Println(res1) //true

    res2 := validator.IsCreditCard("123456")
    fmt.Println(res2) //false
}

IsDns

Check if the string is valid dns.

Signature:

func IsDns(dns string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    res1 := validator.IsDns("abc.com")
    fmt.Println(res1) //true

    res2 := validator.IsDns("a.b.com")
    fmt.Println(res2) //false

    res3 := validator.IsDns("http://abc.com")
    fmt.Println(res3) //false
}

IsEmail

Check if the string is email address.

Signature:

func IsEmail(email string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    res1 := validator.IsEmail("abc@xyz.com")
    fmt.Println(res1) //true

    res2 := validator.IsEmail("a.b@@com")
    fmt.Println(res2) //false
}

IsEmptyString

Check if the string is empty or not.

Signature:

func IsEmptyString(s string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    res1 := validator.IsEmptyString("")
    fmt.Println(res1) //true

    res2 := validator.IsEmptyString("abc")
    fmt.Println(res2) //false
}

IsInt

Check if the value is integer(int, unit) or not.

Signature:

func IsInt(v interface{}) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    result1 := validator.IsInt("")
    result2 := validator.IsInt("3")
    result3 := validator.IsInt(0.1)
    result4 := validator.IsInt(0)

    fmt.Println(result1)
    fmt.Println(result2)
    fmt.Println(result3)
    fmt.Println(result4)

    // Output:
    // false
    // false
    // false
    // true
}

IsFloat

Check if the value is float(float32, float34) or not.

Signature:

func IsFloat(v interface{}) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    result1 := validator.IsFloat("")
    result2 := validator.IsFloat("3")
    result3 := validator.IsFloat(0)
    result4 := validator.IsFloat(0.1)

    fmt.Println(result1)
    fmt.Println(result2)
    fmt.Println(result3)
    fmt.Println(result4)

    // Output:
    // false
    // false
    // false
    // true
}

IsNumber

Check if the value is number(integer, float) or not.

Signature:

func IsNumber(v interface{}) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    result1 := validator.IsNumber("")
    result2 := validator.IsNumber("3")
    result3 := validator.IsNumber(0.1)
    result4 := validator.IsNumber(0)

    fmt.Println(result1)
    fmt.Println(result2)
    fmt.Println(result3)
    fmt.Println(result4)

    // Output:
    // false
    // false
    // true
    // true
}

IsIntStr

Check if the string can convert to a integer.

Signature:

func IsIntStr(s string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    fmt.Println(validator.IsIntStr("+3")) //true
    fmt.Println(validator.IsIntStr("-3")) //true
    fmt.Println(validator.IsIntStr("3.")) //false
    fmt.Println(validator.IsIntStr("abc")) //false
}

IsFloatStr

Check if the string can convert to a float.

Signature:

func IsFloatStr(s string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    fmt.Println(validator.IsFloatStr("")) //false
    fmt.Println(validator.IsFloatStr("12a")) //false
    fmt.Println(validator.IsFloatStr("3.")) //true
    fmt.Println(validator.IsFloatStr("+3.")) //true
    fmt.Println(validator.IsFloatStr("-3.")) //true
    fmt.Println(validator.IsFloatStr("12")) //true
}

IsNumberStr

Check if the string can convert to a number.

Signature:

func IsNumberStr(s string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    fmt.Println(validator.IsNumberStr("")) //false
    fmt.Println(validator.IsNumberStr("12a")) //false
    fmt.Println(validator.IsNumberStr("3.")) //true
    fmt.Println(validator.IsNumberStr("+3.")) //true
    fmt.Println(validator.IsNumberStr("-3.")) //true
    fmt.Println(validator.IsNumberStr("+3e2")) //true
}

IsJSON

Check if the string is valid JSON.

Signature:

func IsJSON(str string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    fmt.Println(validator.IsJSON("")) //false
    fmt.Println(validator.IsJSON("abc")) //false
    fmt.Println(validator.IsJSON("{}")) //true
    fmt.Println(validator.IsJSON("[]")) //true
    fmt.Println(validator.IsJSON("123")) //true
    fmt.Println(validator.IsJSON("{\"name\": \"test\"}")) //true
}

IsRegexMatch

Check if the string match the regexp.

Signature:

func IsRegexMatch(s, regex string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    fmt.Println(validator.IsRegexMatch("abc", `^[a-zA-Z]+$`)) //true
    fmt.Println(validator.IsRegexMatch("1ab", `^[a-zA-Z]+$`)) //false
    fmt.Println(validator.IsRegexMatch("", `^[a-zA-Z]+$`)) //false
}

IsIp

Check if the string is a ip address.

Signature:

func IsIp(ipstr string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    fmt.Println(validator.IsIp("127.0.0.1")) //true
    fmt.Println(validator.IsIp("::0:0:0:0:0:0:1")) //true
    fmt.Println(validator.IsIp("127.0.0")) //false
    fmt.Println(validator.IsIp("127")) //false
}

IsIpV4

Check if the string is a ipv4 address.

Signature:

func IsIpV4(ipstr string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    fmt.Println(validator.IsIpV4("127.0.0.1")) //true
    fmt.Println(validator.IsIpV4("::0:0:0:0:0:0:1")) //false
    fmt.Println(validator.IsIpV4("127.0.0")) //false
    fmt.Println(validator.IsIpV4("127")) //false
}

IsIpV6

Check if the string is a ipv6 address.

Signature:

func IsIpV6(ipstr string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    fmt.Println(validator.IsIpV6("127.0.0.1")) //false
    fmt.Println(validator.IsIpV6("::0:0:0:0:0:0:1")) //true
    fmt.Println(validator.IsIpV6("127.0.0")) //false
    fmt.Println(validator.IsIpV6("127")) //false
}

IsStrongPassword

Check if the string is strong password (alpha(lower+upper) + number + special chars(!@#$%^&*()?><)).

Signature:

func IsStrongPassword(password string, length int) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    fmt.Println(validator.IsStrongPassword("abc", 3)) //false
    fmt.Println(validator.IsStrongPassword("abc123", 6)) //false
    fmt.Println(validator.IsStrongPassword("abcABC", 6)) //false
    fmt.Println(validator.IsStrongPassword("abcABC123@#$", 16)) //false
    fmt.Println(validator.IsStrongPassword("abcABC123@#$", 12)) //true
}

IsUrl

Check if the string is url.

Signature:

func IsUrl(str string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    fmt.Println(validator.IsUrl("http://abc.com")) //true
    fmt.Println(validator.IsUrl("abc.com")) //true
    fmt.Println(validator.IsUrl("a.b.com")) //true
    fmt.Println(validator.IsUrl("abc")) //false
}

IsWeakPassword

Check if the string is weak password（only letter or only number or letter + number） .

Signature:

func IsWeakPassword(password string, length int) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    fmt.Println(validator.IsWeakPassword("abc")) //true
    fmt.Println(validator.IsWeakPassword("123")) //true
    fmt.Println(validator.IsWeakPassword("abc123")) //true
    fmt.Println(validator.IsWeakPassword("abc123@#$")) //false
}

IsZeroValue

Checks if passed value is a zero value.

Signature:

func IsZeroValue(value interface{}) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    fmt.Println(validator.IsZeroValue(nil)) //true
    fmt.Println(validator.IsZeroValue(0)) //true
    fmt.Println(validator.IsZeroValue("")) //true
    fmt.Println(validator.IsZeroValue([]int)) //true
    fmt.Println(validator.IsZeroValue(interface{})) //true

    fmt.Println(validator.IsZeroValue("0")) //false
    fmt.Println(validator.IsZeroValue("nil")) //false
}

IsGBK

Checks if data encoding is gbk(Chinese character internal code extension specification). this function is implemented by whether double bytes fall within the encoding range of gbk,while each byte of utf-8 encoding format falls within the encoding range of gbk.Therefore, utf8.valid() should be called first to check whether it is not utf-8 encoding and then call IsGBK() to check gbk encoding. like the example.

Signature:

func IsGBK(data []byte) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    data := []byte("你好")

    // check utf8 first
    if utf8.Valid(data) {
        fmt.Println("data encoding is utf-8")
    }else if(validator.IsGBK(data)) {
        fmt.Println("data encoding is GBK")
    }
    fmt.Println("data encoding is unknown")
}

IsASCII

Checks if string is all ASCII char.

Signature:

func IsASCII(str string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    result1 := validator.IsASCII("ABC")
    result2 := validator.IsASCII("123")
    result3 := validator.IsASCII("")
    result4 := validator.IsASCII("😄")
    result5 := validator.IsASCII("你好")

    fmt.Println(result1)
    fmt.Println(result2)
    fmt.Println(result3)
    fmt.Println(result4)
    fmt.Println(result5)

    // Output:
    // true
    // true
    // true
    // false
    // false
}

IsPrintable

Checks if string is all printable chars.

Signature:

func IsPrintable(str string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    result1 := validator.IsPrintable("ABC")
    result2 := validator.IsPrintable("{id: 123}")
    result3 := validator.IsPrintable("")
    result4 := validator.IsPrintable("😄")
    result5 := validator.IsPrintable("\u0000")

    fmt.Println(result1)
    fmt.Println(result2)
    fmt.Println(result3)
    fmt.Println(result4)
    fmt.Println(result5)

    // Output:
    // true
    // true
    // true
    // true
    // false
}

IsBin

Checks if a give string is a valid binary value or not.

Signature:

func IsBin(v string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    result1 := validator.IsBin("0101")
    result2 := validator.IsBin("0b1101")
    result3 := validator.IsBin("b1101")
    result4 := validator.IsBin("1201")

    fmt.Println(result1)
    fmt.Println(result2)
    fmt.Println(result3)
    fmt.Println(result4)

    // Output:
    // true
    // true
    // false
    // false
}

IsHex

Checks if a give string is a valid hexadecimal value or not.

Signature:

func IsHex(v string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    result1 := validator.IsHex("0xabcde")
    result2 := validator.IsHex("0XABCDE")
    result3 := validator.IsHex("cdfeg")
    result4 := validator.IsHex("0xcdfeg")

    fmt.Println(result1)
    fmt.Println(result2)
    fmt.Println(result3)
    fmt.Println(result4)

    // Output:
    // true
    // true
    // false
    // false
}

IsBase64URL

Checks if a give string is a valid URL-safe Base64 encoded string.

Signature:

func IsBase64URL(v string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    result1 := validator.IsBase64URL("SAGsbG8sIHdvcmxkIQ")
    result2 := validator.IsBase64URL("SAGsbG8sIHdvcmxkIQ==")
    result3 := validator.IsBase64URL("SAGsbG8sIHdvcmxkIQ=")
    result4 := validator.IsBase64URL("SAGsbG8sIHdvcmxkIQ===")

    fmt.Println(result1)
    fmt.Println(result2)
    fmt.Println(result3)
    fmt.Println(result4)

    // Output:
    // true
    // true
    // false
    // false
}

IsJWT

Checks if a give string is is a valid JSON Web Token (JWT).

Signature:

func IsJWT(v string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    result1 := validator.IsJWT("eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibWVzc2FnZSI6IlB1dGluIGlzIGFic29sdXRlIHNoaXQiLCJpYXQiOjE1MTYyMzkwMjJ9.wkLWA5GtCpWdxNOrRse8yHZgORDgf8TpJp73WUQb910")
    result2 := validator.IsJWT("abc")

    fmt.Println(result1)
    fmt.Println(result2)

    // Output:
    // true
    // false
}

IsVisa

Checks if a give string is a valid visa card nubmer or not.

Signature:

func IsVisa(v string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    result1 := validator.IsVisa("4111111111111111")
    result2 := validator.IsVisa("123")

    fmt.Println(result1)
    fmt.Println(result2)

    // Output:
    // true
    // false
}

IsMasterCard

Checks if a give string is a valid mastercard nubmer or not.

Signature:

func IsMasterCard(v string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    result1 := validator.IsMasterCard("5425233430109903")
    result2 := validator.IsMasterCard("4111111111111111")

    fmt.Println(result1)
    fmt.Println(result2)

    // Output:
    // true
    // false
}

IsAmericanExpress

Checks if a give string is a valid american express nubmer or not.

Signature:

func IsAmericanExpress(v string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    result1 := validator.IsAmericanExpress("342883359122187")
    result2 := validator.IsAmericanExpress("3782822463100007")

    fmt.Println(result1)
    fmt.Println(result2)

    // Output:
    // true
    // false
}

IsVisa

Checks if a give string is a valid union pay nubmer or not.

Signature:

func IsUnionPay(v string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    result1 := validator.IsUnionPay("6221263430109903")
    result2 := validator.IsUnionPay("3782822463100007")

    fmt.Println(result1)
    fmt.Println(result2)

    // Output:
    // true
    // false
}

IsChinaUnionPay

Checks if a give string is a valid china union pay nubmer or not.

Signature:

func IsChinaUnionPay(v string) bool

Example:

import (
    "fmt"
    "github.com/duke-git/lancet/validator"
)

func main() {
    result1 := validator.IsChinaUnionPay("6250941006528599")
    result2 := validator.IsChinaUnionPay("3782822463100007")

    fmt.Println(result1)
    fmt.Println(result2)

    // Output:
    // true
    // false
}
Reference in New Issue View Git Blame Copy Permalink