sanitize

package module

v1.3.5 Latest Latest Go to latest Published: Mar 25, 2025 License: Apache-2.0 Imports: 5 Imported by: 29

Details

Valid go.mod file
Redistributable license
Tagged version
Stable version
Learn more about best practices

Repository

github.com/mrz1836/go-sanitize

Links

Open Source Insights

README ¶

go-sanitize

Simple library of sanitation methods for data sanitation and reduction

Installation

go-sanitize requires a supported release of Go.

go get -u github.com/mrz1836/go-sanitize

Documentation

View the generated documentation

Library Deployment

goreleaser for easy binary or library deployment to GitHub and can be installed via: brew install goreleaser.

The .goreleaser.yml file is used to configure goreleaser.

Use make release-snap to create a snapshot version of the release, and finally make release to ship to production.

Makefile Commands

View all makefile commands

make help

List of all current commands:

all                  Runs multiple commands
clean                Remove previous builds and any test cache data
clean-mods           Remove all the Go mod cache
coverage             Shows the test coverage
godocs               Sync the latest tag with GoDocs
help                 Show this help message
install              Install the application
install-go           Install the application (Using Native Go)
lint                 Run the golangci-lint application (install if not found)
release              Full production release (creates release in Github)
release              Runs common.release then runs godocs
release-snap         Test the full release (build binaries)
release-test         Full production test release (everything except deploy)
replace-version      Replaces the version in HTML/JS (pre-deploy)
tag                  Generate a new tag and push (tag version=0.0.0)
tag-remove           Remove a tag if found (tag-remove version=0.0.0)
tag-update           Update an existing tag to current commit (tag-update version=0.0.0)
test                 Runs vet, lint and ALL tests
test-ci              Runs all tests via CI (exports coverage)
test-ci-no-race      Runs all tests via CI (no race) (exports coverage)
test-ci-short        Runs unit tests via CI (exports coverage)
test-short           Runs vet, lint and tests (excludes integration tests)
uninstall            Uninstall the application (and remove files)
update-linter        Update the golangci-lint package (macOS only)
vet                  Run the Go vet application

Examples & Tests

All unit tests and examples run via GitHub Actions and uses Go version 1.18.x. View the configuration file.

Run all tests (including any integration tests)

make test

Benchmarks

Run the Go benchmarks:

make bench

Code Standards

Read more about this Go project's code standards.

Usage

View the examples
View the benchmarks
View the tests

Maintainers


MrZ

Contributing

View the contributing guidelines and please follow the code of conduct.

How can I help?

All kinds of contributions are welcome 🙌! The most basic way to show your support is to star 🌟 the project, or to raise issues 💬. You can also support this project by becoming a sponsor on GitHub 👏 or by making a bitcoin donation to ensure this journey continues indefinitely! 🚀

License

Documentation ¶

Overview ¶

Package sanitize (go-sanitize) implements a simple library of various sanitation methods for data transformation.

This package provides a collection of functions to sanitize and transform different types of data, such as strings, URLs, email addresses, and more. It is designed to help developers clean and format input data to ensure it meets specific criteria and is safe for further processing.

Features: - Sanitize alpha and alphanumeric characters - Sanitize Bitcoin and Bitcoin Cash addresses - Custom regex-based sanitization - Sanitize decimal numbers and scientific notation - Sanitize domain names, email addresses, and IP addresses - Remove HTML/XML tags and scripts - Sanitize URIs and URLs - Handle XSS attack strings

Usage: To use this package, simply import it and call the desired sanitization function with the input data. Each function is documented with examples in the `sanitize_test.go` file.

Example:

package main

import (
    "fmt"
    "github.com/yourusername/go-sanitize"
)

func main() {
    input := "<script>alert('test');</script>"
    sanitized := sanitize.XSS(input)
    fmt.Println(sanitized) // Output: >alert('test');</
}

If you have any suggestions or comments, please feel free to open an issue on this project's GitHub page.

Index ¶

func Alpha(original string, spaces bool) string
func AlphaNumeric(original string, spaces bool) string
func BitcoinAddress(original string) string
func BitcoinCashAddress(original string) string
func Custom(original string, regExp string) string
func Decimal(original string) string
func Domain(original string, preserveCase bool, removeWww bool) (string, error)
func Email(original string, preserveCase bool) string
func FirstToUpper(original string) string
func FormalName(original string) string
func HTML(original string) string
func IPAddress(original string) string
func Numeric(original string) string
func PathName(original string) string
func Punctuation(original string) string
func ScientificNotation(original string) string
func Scripts(original string) string
func SingleLine(original string) string
func Time(original string) string
func URI(original string) string
func URL(original string) string
func XML(original string) string
func XSS(original string) string

Constants ¶

This section is empty.

Variables ¶

This section is empty.

Functions ¶

func Alpha ¶

func Alpha(original string, spaces bool) string

Alpha returns a string containing only alphabetic characters (a-z, A-Z). If the `spaces` parameter is set to true, spaces will be preserved in the output.

Parameters: - original: The input string to be sanitized. - spaces: A boolean flag indicating whether spaces should be preserved.

Returns: - A sanitized string containing only alphabetic characters and, optionally, spaces.

Example:

input := "Hello, World! 123"
result := sanitize.Alpha(input, true)
fmt.Println(result) // Output: "Hello World"

View more examples in the `sanitize_test.go` file.

Example ¶

ExampleAlpha example using Alpha() and no spaces flag

fmt.Println(sanitize.Alpha("Example String!", false))

Output:

ExampleString

Example (WithSpaces) ¶

ExampleAlpha_withSpaces example using Alpha with spaces flag

fmt.Println(sanitize.Alpha("Example String!", true))

Output:

Example String

func AlphaNumeric ¶

func AlphaNumeric(original string, spaces bool) string

AlphaNumeric returns a string containing only alphanumeric characters (a-z, A-Z, 0-9). If the `spaces` parameter is set to true, spaces will be preserved in the output.

Parameters: - original: The input string to be sanitized. - spaces: A boolean flag indicating whether spaces should be preserved.

Returns: - A sanitized string containing only alphanumeric characters and, optionally, spaces.

Example:

input := "Hello, World! 123"
result := sanitize.AlphaNumeric(input, true)
fmt.Println(result) // Output: "Hello World 123"

View more examples in the `sanitize_test.go` file.

Example ¶

ExampleAlphaNumeric example using AlphaNumeric() with no spaces

fmt.Println(sanitize.AlphaNumeric("Example String 2!", false))

Output:

ExampleString2

Example (WithSpaces) ¶

ExampleAlphaNumeric_withSpaces example using AlphaNumeric() with spaces

fmt.Println(sanitize.AlphaNumeric("Example String 2!", true))

Output:

Example String 2

func BitcoinAddress ¶ added in v1.0.5

func BitcoinAddress(original string) string

BitcoinAddress returns a sanitized string containing only valid characters for a Bitcoin address. This function removes any characters that are not part of the accepted Bitcoin address format.

Parameters: - original: The input string to be sanitized.

Returns: - A sanitized string containing only valid Bitcoin address characters.

Example:

input := "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa!@#"
result := sanitize.BitcoinAddress(input)
fmt.Println(result) // Output: "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"

View more examples in the `sanitize_test.go` file.

Example ¶

ExampleBitcoinAddress example using BitcoinAddress()

fmt.Println(sanitize.BitcoinAddress(":1K6c7LGpdB8LwoGNVfG51dRV9UUEijbrWs!"))

Output:

1K6c7LGpdB8LwoGNVfG51dRV9UUEijbrWs

func BitcoinCashAddress ¶ added in v1.0.6

func BitcoinCashAddress(original string) string

BitcoinCashAddress returns a sanitized string containing only valid characters for a Bitcoin Cash address (cashaddr format). This function removes any characters that are not part of the accepted Bitcoin Cash address format.

Parameters: - original: The input string to be sanitized.

Returns: - A sanitized string containing only valid Bitcoin Cash address characters.

Example:

input := "bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a!@#"
result := sanitize.BitcoinCashAddress(input)
fmt.Println(result) // Output: "bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a"

View more examples in the `sanitize_test.go` file.

Example ¶

ExampleBitcoinCashAddress example using BitcoinCashAddress() `cashaddr`

fmt.Println(sanitize.BitcoinAddress("qze7yy2au5vuznvn8lzj5y0j5t066vhs75e3m0eptz!"))

Output:

qze7yy2au5vuznvn8zj5yj5t66vhs75e3meptz

func Custom ¶

func Custom(original string, regExp string) string

Custom uses a custom regex string and returns the sanitized result. This function allows for flexible sanitization based on user-defined regular expressions.

Parameters: - original: The input string to be sanitized. - regExp: A string representing the custom regular expression to be used for sanitization.

Returns: - A sanitized string based on the provided regular expression.

Example:

input := "Hello, World! 123"
customRegExp := `[^a-zA-Z\s]`
result := sanitize.Custom(input, customRegExp)
fmt.Println(result) // Output: "Hello World"

View more examples in the `sanitize_test.go` file.

Example ¶

ExampleCustom example using Custom() using an alpha regex

fmt.Println(sanitize.Custom("Example String 2!", `[^a-zA-Z]`))

Output:

ExampleString

Example (Numeric) ¶

ExampleCustom_numeric example using Custom() using a numeric regex

fmt.Println(sanitize.Custom("Example String 2!", `[^0-9]`))

Output:

2

func Decimal ¶

func Decimal(original string) string

Decimal returns a sanitized string containing only decimal/float values, including positive and negative numbers. This function removes any characters that are not part of the accepted decimal format.

Parameters: - original: The input string to be sanitized.

Returns: - A sanitized string containing only decimal/float values.

Example:

input := "The price is -123.45 USD"
result := sanitize.Decimal(input)
fmt.Println(result) // Output: "-123.45"

View more examples in the `sanitize_test.go` file.

Example ¶

ExampleDecimal example using Decimal() for a positive number

fmt.Println(sanitize.Decimal("$ 99.99!"))

Output:

99.99

Example (Negative) ¶

ExampleDecimal_negative example using Decimal() for a negative number

fmt.Println(sanitize.Decimal("$ -99.99!"))

Output:

-99.99

func Domain ¶

func Domain(original string, preserveCase bool, removeWww bool) (string, error)

Domain returns a properly formatted hostname or domain name. This function can preserve the case of the original input or convert it to lowercase, and optionally remove the "www" subdomain.

Parameters: - original: The input string to be sanitized. - preserveCase: A boolean flag indicating whether to preserve the case of the original input. - removeWww: A boolean flag indicating whether to remove the "www" subdomain.

Returns: - A sanitized string containing a valid hostname or domain name. - An error if the URL parsing fails.

Example:

input := "www.Example.com"
result, err := sanitize.Domain(input, false, true)
if err != nil {
    log.Fatal(err)
}
fmt.Println(result) // Output: "example.com"

View more examples in the `sanitize_test.go` file.

Example ¶

ExampleDomain example using Domain()

fmt.Println(sanitize.Domain("https://www.Example.COM/?param=value", false, false))

Output:

www.example.com <nil>

Example (PreserveCase) ¶

ExampleDomain_preserveCase example using Domain() and preserving the case

fmt.Println(sanitize.Domain("https://www.Example.COM/?param=value", true, false))

Output:

www.Example.COM <nil>

Example (RemoveWww) ¶

ExampleDomain_removeWww example using Domain() and removing the www subdomain

fmt.Println(sanitize.Domain("https://www.Example.COM/?param=value", false, true))

Output:

example.com <nil>

func Email ¶

func Email(original string, preserveCase bool) string

Email returns a sanitized email address string. Email addresses are forced to lowercase and removes any mail-to prefixes.

Parameters: - original: The input string to be sanitized. - preserveCase: A boolean flag indicating whether to preserve the case of the original input.

Returns: - A sanitized string containing a valid email address.

Example:

input := "MailTo:Example@DOMAIN.com"
result := sanitize.Email(input, false)
fmt.Println(result) // Output: "example@domain.com"

View more examples in the `sanitize_test.go` file.

Example ¶

ExampleEmail example using Email()

fmt.Println(sanitize.Email("mailto:Person@Example.COM", false))

Output:

person@example.com

Example (PreserveCase) ¶

ExampleEmail_preserveCase example using Email() and preserving the case

fmt.Println(sanitize.Email("mailto:Person@Example.COM", true))

Output:

Person@Example.COM

func FirstToUpper ¶

func FirstToUpper(original string) string

FirstToUpper overwrites the first letter as an uppercase letter and preserves the rest of the string.

This function is useful for formatting strings where the first character needs to be capitalized, such as names or titles.

Parameters: - original: The input string to be formatted.

Returns: - A string with the first letter converted to uppercase.

Example:

input := "hello world"
result := sanitize.FirstToUpper(input)
fmt.Println(result) // Output: "Hello world"

View more examples in the `sanitize_test.go` file.

Example ¶

ExampleFirstToUpper example using FirstToUpper()

fmt.Println(sanitize.FirstToUpper("this works"))

Output:

This works

func FormalName ¶

func FormalName(original string) string

FormalName returns a sanitized string containing only characters recognized in formal names or surnames. This function removes any characters that are not part of the accepted formal name format.

Parameters: - original: The input string to be sanitized.

Returns: - A sanitized string containing only valid formal name characters.

Example:

input := "John D'oe, Jr."
result := sanitize.FormalName(input)
fmt.Println(result) // Output: "John Doe Jr"

View more examples in the `sanitize_test.go` file.

Example ¶

ExampleFormalName example using FormalName()

fmt.Println(sanitize.FormalName("John McDonald Jr.!"))

Output:

John McDonald Jr.

func HTML ¶

func HTML(original string) string

HTML returns a string without any HTML tags. This function removes all HTML tags from the input string, leaving only the text content.

Parameters: - original: The input string containing HTML tags to be sanitized.

Returns: - A sanitized string with all HTML tags removed.

Example:

input := "<div>Hello <b>World</b>!</div>"
result := sanitize.HTML(input)
fmt.Println(result) // Output: "Hello World!"

View more examples in the `sanitize_test.go` file.

Example ¶

ExampleHTML example using HTML()

fmt.Println(sanitize.HTML("<body>This Works?</body>"))

Output:

This Works?

func IPAddress ¶

func IPAddress(original string) string

IPAddress returns a sanitized IP address string for both IPv4 and IPv6 formats. This function removes any invalid characters from the input string and attempts to parse it as an IP address. If the input string does not contain a valid IP address, an empty string is returned.

Parameters: - original: The input string to be sanitized.

Returns: - A sanitized string containing a valid IP address, or an empty string if the input is not a valid IP address.

Example:

input := "192.168.1.1!@#"
result := sanitize.IPAddress(input)
fmt.Println(result) // Output: "192.168.1.1"

View more examples in the `sanitize_test.go` file.

Example ¶

ExampleIPAddress example using IPAddress() for IPV4 address

fmt.Println(sanitize.IPAddress(" 192.168.0.1 "))

Output:

192.168.0.1

Example (Ipv6) ¶

ExampleIPAddress_ipv6 example using IPAddress() for IPV6 address

fmt.Println(sanitize.IPAddress(" 2602:305:bceb:1bd0:44ef:fedb:4f8f:da4f "))

Output:

2602:305:bceb:1bd0:44ef:fedb:4f8f:da4f

func Numeric ¶

func Numeric(original string) string

Numeric returns a string containing only numeric characters (0-9). This function removes any characters that are not digits from the input string.

Parameters: - original: The input string to be sanitized.

Returns: - A sanitized string containing only numeric characters.

Example:

input := "Phone: 123-456-7890"
result := sanitize.Numeric(input)
fmt.Println(result) // Output: "1234567890"

View more examples in the `sanitize_test.go` file.

Example ¶

ExampleNumeric example using Numeric()

fmt.Println(sanitize.Numeric("This:123 + 90!"))

Output:

12390

func PathName ¶

func PathName(original string) string

PathName returns a formatted path-compliant name. This function removes any characters that are not valid in file or directory names, ensuring the resulting string is safe to use as a path component.

Parameters: - original: The input string to be sanitized.

Returns: - A sanitized string containing only valid path name characters.

Example:

input := "file:name/with*invalid|chars"
result := sanitize.PathName(input)
fmt.Println(result) // Output: "filenamewithinvalidchars"

View more examples in the `sanitize_test.go` file.

Example ¶

ExampleNumeric example using PathName()

fmt.Println(sanitize.PathName("/This-Works_Now-123/!"))

Output:

This-Works_Now-123

func Punctuation ¶

func Punctuation(original string) string

Punctuation returns a string with basic punctuation preserved. This function removes any characters that are not standard punctuation or alphanumeric characters, ensuring the resulting string contains only valid punctuation and alphanumeric characters.

Parameters: - original: The input string to be sanitized.

Returns: - A sanitized string containing only valid punctuation and alphanumeric characters.

Example:

input := "Hello, World! How's it going? (Good, I hope.)"
result := sanitize.Punctuation(input)
fmt.Println(result) // Output: "Hello, World! How's it going? (Good, I hope.)"

View more examples in the `sanitize_test.go` file.

Example ¶

ExamplePunctuation example using Punctuation()

fmt.Println(sanitize.Punctuation(`[@"Does" 'this' work?@] this too`))

Output:

"Does" 'this' work? this too

func ScientificNotation ¶ added in v1.3.1

func ScientificNotation(original string) string

ScientificNotation returns a sanitized string containing only valid characters for scientific notation. This function removes any characters that are not part of the accepted scientific notation format, including digits (0-9), decimal points, and the characters 'e', 'E', '+', and '-'.

Parameters: - original: The input string to be sanitized.

Returns: - A sanitized string containing only valid scientific notation characters.

Example:

input := "The value is 1.23e+10 and 4.56E-7."
result := sanitize.ScientificNotation(input)
fmt.Println(result) // Output: "1.23e+104.56E-7"

View more examples in the `sanitize_test.go` file.

Example ¶

ExampleDecimal example using Decimal() for a positive number

fmt.Println(sanitize.ScientificNotation("$ 1.096e-3!"))

Output:

1.096e-3

func Scripts ¶

func Scripts(original string) string

Scripts removes all script, iframe, embed, and object tags from the input string. This function is designed to sanitize input by removing potentially harmful tags that can be used for cross-site scripting (XSS) attacks or other malicious purposes.

Parameters: - original: The input string containing HTML or script tags to be sanitized.

Returns: - A sanitized string with all script, iframe, embed, and object tags removed.

Example:

input := "<script>alert('test');</script><iframe src='example.com'></iframe>"
result := sanitize.Scripts(input)
fmt.Println(result) // Output: "alert('test');"

View more examples in the `sanitize_test.go` file.

Example ¶

ExampleScripts example using Scripts()

fmt.Println(sanitize.Scripts(`Does<script>This</script>Work?`))

Output:

DoesWork?

func SingleLine ¶

func SingleLine(original string) string

SingleLine returns a single line string by removing all carriage returns, line feeds, tabs, vertical tabs, and form feeds. This function is useful for sanitizing input that should be represented as a single line of text, ensuring that any multi-line or formatted input is condensed into a single line.

Parameters: - original: The input string to be sanitized.

Returns: - A sanitized string with all line breaks and whitespace characters replaced by a single space.

Example:

input := "This is a\nmulti-line\tstring."
result := sanitize.SingleLine(input)
fmt.Println(result) // Output: "This is a multi-line string."

View more examples in the `sanitize_test.go` file.

Example ¶

ExampleSingleLine example using SingleLine()

fmt.Println(sanitize.SingleLine(`Does
This
Work?`))

Output:

Does This Work?

func Time ¶

func Time(original string) string

Time returns just the time part of the string. This function removes any characters that are not valid in a time format (HH:MM or HH:MM:SS), ensuring the resulting string contains only valid time characters.

Parameters: - original: The input string to be sanitized.

Returns: - A sanitized string containing only valid time characters.

Example:

input := "t00:00d -EST"
result := sanitize.Time(input)
fmt.Println(result) // Output: "00:00"

View more examples in the `sanitize_test.go` file.

Example ¶

ExampleTime example using Time()

fmt.Println(sanitize.Time(`Time 01:02:03!`))

Output:

01:02:03

func URI ¶

func URI(original string) string

URI returns a sanitized string containing only valid URI characters. This function removes any characters that are not part of the accepted URI format, including alphanumeric characters, dashes, underscores, slashes, question marks, ampersands, equals signs, hashes, and percent signs.

Parameters: - original: The input string to be sanitized.

Returns: - A sanitized string containing only valid URI characters.

Example:

input := "Test?=what! &this=that"
result := sanitize.URI(input)
fmt.Println(result) // Output: "Test?=what&this=that"

View more examples in the `sanitize_test.go` file.

Example ¶

ExampleURI example using URI()

fmt.Println(sanitize.URI("/This/Works?^No&this"))

Output:

/This/Works?No&this

func URL ¶

func URL(original string) string

URL returns a formatted URL-friendly string. This function removes any characters that are not part of the accepted URL format, including alphanumeric characters, dashes, underscores, slashes, colons, periods, question marks, ampersands, at signs, equals signs, hashes, and percent signs.

Parameters: - original: The input string to be sanitized.

Returns: - A sanitized string containing only valid URL characters.

Example:

input := "https://Example.com/This/Works?^No&this"
result := sanitize.URL(input)
fmt.Println(result) // Output: "https://Example.com/This/Works?No&this"

View more examples in the `sanitize_test.go` file.

Example ¶

ExampleURL example using URL()

fmt.Println(sanitize.URL("https://Example.com/This/Works?^No&this"))

Output:

https://Example.com/This/Works?No&this

func XML ¶

func XML(original string) string

XML returns a string without any XML tags. This function removes all XML tags from the input string, leaving only the text content. It is an alias for the HTML function, which performs the same operation.

Parameters: - original: The input string containing XML tags to be sanitized.

Returns: - A sanitized string with all XML tags removed.

Example:

input := `<?xml version="1.0" encoding="UTF-8"?><note>Something</note>`
result := sanitize.XML(input)
fmt.Println(result) // Output: "Something"

View more examples in the `sanitize_test.go` file.

Example ¶

ExampleXML example using XML()

fmt.Println(sanitize.XML("<xml>This?</xml>"))

Output:

This?

func XSS ¶

func XSS(original string) string

XSS removes known XSS attack strings or script strings. This function sanitizes the input string by removing common XSS attack vectors, such as script tags, eval functions, and JavaScript protocol handlers.

Parameters: - original: The input string to be sanitized.

Returns: - A sanitized string with known XSS attack vectors removed.

Example:

input := "<script>alert('test');</script>"
result := sanitize.XSS(input)
fmt.Println(result) // Output: ">alert('test');</"

View more examples in the `sanitize_test.go` file.

Example ¶

ExampleXSS example using XSS()

fmt.Println(sanitize.XSS("<script>This?</script>"))

Output:

>This?</

Types ¶

This section is empty.

Source Files ¶

View all Source files

sanitize.go

Directories ¶

Path	Synopsis
examples Package main is an example of how to use the sanitize package	Package main is an example of how to use the sanitize package

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL

README ¶

go-sanitize

Table of Contents

Installation

Documentation

Examples & Tests

Benchmarks

Code Standards

Usage

Maintainers

Contributing

How can I help?

License

Documentation ¶

Overview ¶

Index ¶

Examples ¶

Constants ¶

Variables ¶

Functions ¶

func Alpha ¶

func AlphaNumeric ¶

func BitcoinAddress ¶ added in v1.0.5

func BitcoinCashAddress ¶ added in v1.0.6

func Custom ¶

func Decimal ¶

func Domain ¶

func Email ¶

func FirstToUpper ¶

func FormalName ¶

func HTML ¶

func IPAddress ¶

func Numeric ¶

func PathName ¶

func Punctuation ¶

func ScientificNotation ¶ added in v1.3.1

func Scripts ¶

func SingleLine ¶

func Time ¶

func URI ¶

func URL ¶

func XML ¶

func XSS ¶

Types ¶

Source Files ¶

Directories ¶