GoMoji

When using GoMoji, keep the following security and technical constraints in mind:

• Not a Sanitizer: GoMoji is a string-processing library, not a security sanitizer. Do not use it to prevent XSS or injection attacks; use a dedicated HTML/markup sanitizer for that.
• Grapheme Clusters: Detection and replacement operate on Unicode grapheme clusters. Do not assume that one code point equals one visible symbol.
• Variation Selectors: Variation selectors are stripped during processing to normalize output. If your application requires preserving exact variation selectors, avoid using RemoveEmojis or Replace* methods.
• Untrusted Output: When using ReplaceEmojisWithSlug, treat the resulting string as untrusted user-controlled input and escape/encode it appropriately for your output context.

To use GoMoji in your Go project, ensure you have Go 1.11 or higher installed, then run the following command to add the module to your dependencies:

go get -u github.com/forPelevin/gomoji

GoMoji allows you to detect and remove emojis from strings. Here is a minimal example of how to check for emoji presence and remove them:

package main

import (
    "fmt"
    "github.com/forPelevin/gomoji"
)

func main() {
    s := "Hello 👋 world 🦋"
    fmt.Println(gomoji.ContainsEmoji(s)) // true
    fmt.Println(gomoji.RemoveEmojis(s))  // "Hello  world "
}

Use these core functions to manipulate emoji content in strings:

• ContainsEmoji(s string) bool: Returns true if the string contains any emoji.
• FindAll(s string) []Emoji: Returns a slice of Emoji structs containing all unique emojis found in the string.
• CollectAll(s string) []Emoji: Returns a slice of Emoji structs for all emojis found, including repeats, preserving their order.
• RemoveEmojis(s string) string: Returns the string with all emojis removed.

// Check for emojis
hasEmoji := gomoji.ContainsEmoji("hello world 🤗")

// Find all unique emojis
emojis := gomoji.FindAll("🧖 hello 🦋 world")

// Remove emojis
cleaned := gomoji.RemoveEmojis("🧖 hello 🦋 world")

You can look up metadata for a specific emoji character using GetInfo. This returns an Emoji struct containing details like the slug, Unicode name, and group. If the input is not a valid emoji, it returns ErrStrNotEmoji.

info, err := gomoji.GetInfo("🦋")
if err == nil {
    fmt.Println(info.Slug)        // "butterfly"
    fmt.Println(info.UnicodeName) // "E3.0 butterfly"
    fmt.Println(info.Group)       // "Animals & Nature"
}

GoMoji provides several ways to replace emojis with different types of content:

• ReplaceEmojisWith(s string, c rune) string: Replaces every emoji with a single specified character (rune).
• ReplaceEmojisWithSlug(s string) string: Replaces every emoji with its unique text slug (e.g., 🦋 becomes butterfly).
• ReplaceEmojisWithFunc(s string, replacer func(Emoji) string) string: Replaces every emoji using a custom callback function that receives the Emoji struct.

// Replace with a specific character
replaced := gomoji.ReplaceEmojisWith("🧖 hello 🦋 world", '_')

// Replace with slugs
slugs := gomoji.ReplaceEmojisWithSlug("🧖 hello 🦋 world")

// Replace with custom function
custom := gomoji.ReplaceEmojisWithFunc("🧖 hello 🦋 world", func(em gomoji.Emoji) string {
    return em.Slug
})

The Emoji struct represents the metadata associated with an emoji character:

type Emoji struct {
    Slug        string `json:"slug"`        // Unique identifier
    Character   string `json:"character"`   // The emoji character
    UnicodeName string `json:"unicode_name"` // Official Unicode name
    CodePoint   string `json:"code_point"`  // Unicode code point
    Group       string `json:"group"`       // Emoji group category
    SubGroup    string `json:"sub_group"`    // Emoji subgroup category
}

Use GetInfo(emoji string) (Emoji, error) to retrieve the metadata for a specific emoji character or cluster. If the provided string is not a recognized emoji, it returns ErrStrNotEmoji.

info, err := gomoji.GetInfo("🚀")
if err != nil {
    if errors.Is(err, gomoji.ErrStrNotEmoji) {
        fmt.Println("Not an emoji")
    }
}
fmt.Printf("Name: %s, CodePoint: %s\n", info.UnicodeName, info.CodePoint)

The library provides two ways to extract emojis from a string:

1. CollectAll(s string) []Emoji: Returns all occurrences of emojis found in the string. If an emoji appears multiple times, it will appear multiple times in the resulting slice.
2. FindAll(s string) []Emoji: Returns a unique set of emojis found in the string. It uses a map internally to ensure no duplicate emoji entities are returned.

// Returns every instance found
instances := gomoji.CollectAll("😀😀 test 😀") 

// Returns only unique emojis found
unique := gomoji.FindAll("😀😀 test 😀") 

Call AllEmojis() []Emoji to get a sorted slice of all emoji entities supported by the library's internal provider.

all := gomoji.AllEmojis()
for _, em := range all {
    fmt.Printf("%s: %s\n", em.Character, em.Slug)
}

Use ContainsEmoji(s string) bool to determine if a given string contains any emoji characters. It efficiently skips ASCII-only strings and uses grapheme segmentation to identify complex emoji clusters.

if gomoji.ContainsEmoji("Hello 🚀") {
    fmt.Println("String contains emojis!")
}