Creating a Slugify Function in Different Programming Languages: A Beginner's Guide

In web development, it's common to convert a string into a URL-friendly format, which is called "slugification." For example, transforming the title of a blog post like "Hello World!" into "hello-world" helps make the URL both readable and SEO-friendly. This process is known as "slugifying" a string.

In this article, we'll explore how to create a simple slugify function in some of the most popular programming languages, such as PHP, Go, Rust, Python, C, C++, and others. Whether you're a beginner in coding or an experienced developer curious about different languages, you'll find this guide helpful as we break down the slugification process step by step.

What Is Slugification?

Slugification involves taking a string of text, typically a title or name, and converting it into a string suitable for use in a URL. This usually includes converting to lowercase, replacing spaces with hyphens, and removing any special characters.

For example, the string:

Hello World!

Would become:

hello-world

Slugifying in JavaScript (Node.js)

function slugify(str) {
    return str
        .toLowerCase()              // Convert the string to lowercase
        .trim()                     // Remove whitespace from both ends
        .replace(/[^\w\s-]/g, '')   // Remove all non-word characters (letters, digits, etc.)
        .replace(/\s+/g, '-')       // Replace spaces with hyphens
        .replace(/-+/g, '-');       // Replace multiple hyphens with a single hyphen
}

console.log(slugify('Hello World!')); // Output: hello-world

Slugifying in PHP

function slugify($string) {
    // Convert string to lowercase
    $string = strtolower($string);

    // Remove non-word characters (letters, numbers, spaces, and hyphens)
    $string = preg_replace('/[^\w\s-]/', '', $string);

    // Replace spaces and multiple hyphens with a single hyphen
    $string = preg_replace('/\s+/', '-', $string);
    $string = preg_replace('/-+/', '-', $string);

    // Trim hyphens from the beginning and end
    return trim($string, '-');
}

echo slugify('Hello World!'); // Output: hello-world

Slugifying in Go

package main

import (
	"fmt"
	"regexp"
	"strings"
)

func slugify(s string) string {
	// Convert to lowercase
	s = strings.ToLower(s)

	// Remove non-alphanumeric characters (except for spaces and hyphens)
	re := regexp.MustCompile(`[^\w\s-]`)
	s = re.ReplaceAllString(s, "")

	// Replace spaces with hyphens
	s = strings.ReplaceAll(s, " ", "-")

	// Remove consecutive hyphens
	re = regexp.MustCompile(`-+`)
	s = re.ReplaceAllString(s, "-")

	// Trim hyphens
	return strings.Trim(s, "-")
}

func main() {
	fmt.Println(slugify("Hello World!")) // Output: hello-world
}

Slugifying in Rust

fn slugify(input: &str) -> String {
    let slug = input
        .to_lowercase()          // Convert to lowercase
        .replace(|c: char| !c.is_alphanumeric() && c != ' ', "") // Remove non-alphanumeric characters
        .replace(' ', "-")       // Replace spaces with hyphens
        .replace("--", "-")      // Replace consecutive hyphens
        .trim_matches('-')       // Trim leading and trailing hyphens
        .to_string();

    slug
}

fn main() {
    let slug = slugify("Hello World!");
    println!("{}", slug);  // Output: hello-world
}

Slugifying in TypeScript

function slugify(str: string): string {
    return str
        .toLowerCase()                  // Convert to lowercase
        .trim()                          // Trim spaces from both ends
        .replace(/[^\w\s-]/g, '')        // Remove all non-word characters
        .replace(/\s+/g, '-')            // Replace spaces with hyphens
        .replace(/-+/g, '-');            // Replace multiple hyphens with one
}

console.log(slugify('Hello World!')); // Output: hello-world

Slugifying in Python

import re

def slugify(string):
    # Convert to lowercase
    string = string.lower()
    # Remove non-word characters (except for spaces and hyphens)
    string = re.sub(r'[^\w\s-]', '', string)
    # Replace spaces with hyphens
    string = re.sub(r'\s+', '-', string)
    # Remove multiple hyphens
    string = re.sub(r'-+', '-', string)
    # Trim leading and trailing hyphens
    return string.strip('-')

print(slugify("Hello World!"))  # Output: hello-world

Slugifying in C

C doesn't have built-in string manipulation libraries as rich as higher-level languages, so you'll need to handle the string processing manually:

#include <stdio.h>
#include <ctype.h>
#include <string.h>

void slugify(char *str) {
    int i = 0, j = 0;
    int hyphen = 0;

    // Convert string to lowercase and process it
    while (str[i]) {
        if (isalnum(str[i])) {
            str[j++] = tolower(str[i]);
            hyphen = 0;
        } else if (isspace(str[i]) && !hyphen) {
            str[j++] = '-';
            hyphen = 1;
        }
        i++;
    }

    // Remove trailing hyphen, if any
    if (j > 0 && str[j - 1] == '-') {
        j--;
    }

    str[j] = '\0';
}

int main() {
    char input[] = "Hello World!";
    slugify(input);
    printf("%s\n", input);  // Output: hello-world
    return 0;
}

Slugifying in C++

C++ has the Standard Library that makes string manipulation easier than in C:

#include <iostream>
#include <algorithm>
#include <cctype>

std::string slugify(const std::string& input) {
    std::string result;
    bool lastHyphen = false;

    for (char ch : input) {
        if (std::isalnum(ch)) {
            result += std::tolower(ch);
            lastHyphen = false;
        } else if (std::isspace(ch) && !lastHyphen) {
            result += '-';
            lastHyphen = true;
        }
    }

    // Remove trailing hyphen, if any
    if (!result.empty() && result.back() == '-') {
        result.pop_back();
    }

    return result;
}

int main() {
    std::string input = "Hello World!";
    std::string slug = slugify(input);
    std::cout << slug << std::endl;  // Output: hello-world
    return 0;
}

Slugifying in Ruby

In Ruby, string manipulation tasks like slugifying are quite simple, thanks to its powerful built-in methods and the use of regular expressions.

def slugify(string)
  # Convert to lowercase
  string = string.downcase
  # Remove non-word characters (except spaces and hyphens)
  string = string.gsub(/[^\w\s-]/, '')
  # Replace spaces with hyphens
  string = string.gsub(/\s+/, '-')
  # Remove multiple hyphens and trim leading/trailing hyphens
  string = string.gsub(/-+/, '-').strip
end

puts slugify("Hello World!")  # Output: hello-world

Understanding the Common Pattern

While the syntax may differ between programming languages, the general process for slugifying a string remains the same:

1. Convert the string to lowercase.
2. Remove any characters that aren’t letters, numbers, spaces, or hyphens.
3. Replace spaces with hyphens.
4. Remove any consecutive hyphens.
5. Trim any leading or trailing hyphens.

Each language handles these steps in its own way, but the logic remains consistent. Python, with its rich libraries, handles slugification concisely, while C requires a more hands-on approach. C++ strikes a balance, offering more convenience while still maintaining control over the string manipulation process.

Support Us