Stack Overflow 如何生成 SEO 友好的 URL？

Question

什么是一个好的完整的 正则表达式 或其他一些可以采用标题的过程：

如何将标题更改为 URL 的一部分，例如 Stack Overflow？

并将其转换为

how-do-you-change-a-title-to-be-part-of-the-url-like-stack-overflow

StackOverflow 上 SEO 友好的 URL 中使用的内容？

我使用的开发环境是 Ruby on Rails，但是如果还有其他一些特定于平台的解决方案（.NET、PHP、Django），我也很想看到这些。

我确信我（或其他读者）会在不同的平台上遇到同样的问题。

我正在使用自定义路由，我主要想知道如何将字符串更改为删除所有特殊字符，全部小写，并替换所有空格。

Answer 1

有一个名为 PermalinkFu 的小型 Rub​​y on Rails 插件，可以执行此操作。 转义方法将转换为字符串适用于 URL。 看一下代码； 这个方法很简单。

要删除非 ASCII 字符，它使用 iconv 库将其转换为 'ascii//ignore/ /translit' 来自 'utf-8'。 然后空格变成破折号，所有内容都小写，等等。

Answer 2

Brian 的 Ruby 代码：

title.downcase.strip.gsub(/\ /, '-').gsub(/[^\w\-]/, '')

downcase 将字符串转换为小写，strip 删除前导和尾随空格，第一个 gsub 调用 g< /em>lobally 用破折号替换空格，第二个删除所有不是字母或破折号的内容。

Answer 3

不不不。 你们都错了。 除了变音符号之外，你已经到达了那里，但是亚洲字符呢（Ruby 开发者没有考虑他们的 nihonjin 弟兄们）。

Firefox 和 Safari 都在 URL 中显示非 ASCII 字符，坦率地说，它们看起来很棒。 很高兴支持像“http://somewhere.com/news/read/お前たちはaホじゃないかい'。

这里有一些 PHP 代码可以做到这一点，但我只是编写了它，还没有对其进行压力测试。

<?php
    function slug($str)
    {
        $args = func_get_args();
        array_filter($args);  //remove blanks
        $slug = mb_strtolower(implode('-', $args));

        $real_slug = '';
        $hyphen = '';
        foreach(SU::mb_str_split($slug) as $c)
        {
            if (strlen($c) > 1 && mb_strlen($c)===1)
            {
                $real_slug .= $hyphen . $c;
                $hyphen = '';
            }
            else
            {
                switch($c)
                {
                    case '&':
                        $hyphen = $real_slug ? '-and-' : '';
                        break;
                    case 'a':
                    case 'b':
                    case 'c':
                    case 'd':
                    case 'e':
                    case 'f':
                    case 'g':
                    case 'h':
                    case 'i':
                    case 'j':
                    case 'k':
                    case 'l':
                    case 'm':
                    case 'n':
                    case 'o':
                    case 'p':
                    case 'q':
                    case 'r':
                    case 's':
                    case 't':
                    case 'u':
                    case 'v':
                    case 'w':
                    case 'x':
                    case 'y':
                    case 'z':

                    case 'A':
                    case 'B':
                    case 'C':
                    case 'D':
                    case 'E':
                    case 'F':
                    case 'G':
                    case 'H':
                    case 'I':
                    case 'J':
                    case 'K':
                    case 'L':
                    case 'M':
                    case 'N':
                    case 'O':
                    case 'P':
                    case 'Q':
                    case 'R':
                    case 'S':
                    case 'T':
                    case 'U':
                    case 'V':
                    case 'W':
                    case 'X':
                    case 'Y':
                    case 'Z':

                    case '0':
                    case '1':
                    case '2':
                    case '3':
                    case '4':
                    case '5':
                    case '6':
                    case '7':
                    case '8':
                    case '9':
                        $real_slug .= $hyphen . $c;
                        $hyphen = '';
                        break;

                    default:
                       $hyphen = $hyphen ? $hyphen : ($real_slug ? '-' : '');
                }
            }
        }
        return $real_slug;
    }

示例：

$str = "~!@#$%^&*()_+-=[]\{}|;':\",./<>?\n\r\t\x07\x00\x04 コリン ~!@#$%^&*()_+-=[]\{}|;':\",./<>?\n\r\t\x07\x00\x04 トーマス ~!@#$%^&*()_+-=[]\{}|;':\",./<>?\n\r\t\x07\x00\x04 アーノルド ~!@#$%^&*()_+-=[]\{}|;':\",./<>?\n\r\t\x07\x00\x04";
echo slug($str);

输出：
コrin-and-トーマsu-and-アーノルド

“-and-”是因为 & 变成了“-and-”。

Answer 4

我将代码移植到 TypeScript 中。 它可以很容易地适应 JavaScript。

我正在向 String 原型添加一个 .contains 方法，如果您的目标是最新的浏览器或 ES6，则可以使用 .includes 代替。

if (!String.prototype.contains) {
    String.prototype.contains = function (check) {
        return this.indexOf(check, 0) !== -1;
    };
}

declare interface String {
    contains(check: string): boolean;
}

export function MakeUrlFriendly(title: string) {
            if (title == null || title == '')
                return '';

            const maxlen = 80;
            let len = title.length;
            let prevdash = false;
            let result = '';
            let c: string;
            let cc: number;
            let remapInternationalCharToAscii = function (c: string) {
                let s = c.toLowerCase();
                if ("àåáâäãåą".contains(s)) {
                    return "a";
                }
                else if ("èéêëę".contains(s)) {
                    return "e";
                }
                else if ("ìíîïı".contains(s)) {
                    return "i";
                }
                else if ("òóôõöøőð".contains(s)) {
                    return "o";
                }
                else if ("ùúûüŭů".contains(s)) {
                    return "u";
                }
                else if ("çćčĉ".contains(s)) {
                    return "c";
                }
                else if ("żźž".contains(s)) {
                    return "z";
                }
                else if ("śşšŝ".contains(s)) {
                    return "s";
                }
                else if ("ñń".contains(s)) {
                    return "n";
                }
                else if ("ýÿ".contains(s)) {
                    return "y";
                }
                else if ("ğĝ".contains(s)) {
                    return "g";
                }
                else if (c == 'ř') {
                    return "r";
                }
                else if (c == 'ł') {
                    return "l";
                }
                else if (c == 'đ') {
                    return "d";
                }
                else if (c == 'ß') {
                    return "ss";
                }
                else if (c == 'Þ') {
                    return "th";
                }
                else if (c == 'ĥ') {
                    return "h";
                }
                else if (c == 'ĵ') {
                    return "j";
                }
                else {
                    return "";
                }
            };

            for (let i = 0; i < len; i++) {
                c = title[i];
                cc = c.charCodeAt(0);

                if ((cc >= 97 /* a */ && cc <= 122 /* z */) || (cc >= 48 /* 0 */ && cc <= 57 /* 9 */)) {
                    result += c;
                    prevdash = false;
                }
                else if ((cc >= 65 && cc <= 90 /* A - Z */)) {
                    result += c.toLowerCase();
                    prevdash = false;
                }
                else if (c == ' ' || c == ',' || c == '.' || c == '/' || c == '\\' || c == '-' || c == '_' || c == '=') {
                    if (!prevdash && result.length > 0) {
                        result += '-';
                        prevdash = true;
                    }
                }
                else if (cc >= 128) {
                    let prevlen = result.length;
                    result += remapInternationalCharToAscii(c);
                    if (prevlen != result.length) prevdash = false;
                }
                if (i == maxlen) break;
            }

            if (prevdash)
                return result.substring(0, result.length - 1);
            else
                return result;
        }

Answer 5

重写 Jeff 的代码使其更加简洁

    public static string RemapInternationalCharToAscii(char c)
    {
        var s = c.ToString().ToLowerInvariant();

        var mappings = new Dictionary<string, string>
        {
            { "a", "àåáâäãåą" },
            { "c", "çćčĉ" },
            { "d", "đ" },
            { "e", "èéêëę" },
            { "g", "ğĝ" },
            { "h", "ĥ" },
            { "i", "ìíîïı" },
            { "j", "ĵ" },
            { "l", "ł" },
            { "n", "ñń" },
            { "o", "òóôõöøőð" },
            { "r", "ř" },
            { "s", "śşšŝ" },
            { "ss", "ß" },
            { "th", "Þ" },
            { "u", "ùúûüŭů" },
            { "y", "ýÿ" },
            { "z", "żźž" }
        };

        foreach(var mapping in mappings)
        {
            if (mapping.Value.Contains(s))
                return mapping.Key;
        }

        return string.Empty;
    }

Answer 6

我喜欢这种不使用 正则表达式 的方式，因此我将其移植到 PHP 中。 我刚刚添加了一个名为 is_ Between 的函数来检查字符：

function is_between($val, $min, $max)
{
    $val = (int) $val; $min = (int) $min; $max = (int) $max;

    return ($val >= $min && $val <= $max);
}

function international_char_to_ascii($char)
{
    if (mb_strpos('àåáâäãåa', $char) !== false)
    {
        return 'a';
    }

    if (mb_strpos('èéêëe', $char) !== false)
    {
        return 'e';
    }

    if (mb_strpos('ìíîïi', $char) !== false)
    {
        return 'i';
    }

    if (mb_strpos('òóôõö', $char) !== false)
    {
        return 'o';
    }

    if (mb_strpos('ùúûüuu', $char) !== false)
    {
        return 'u';
    }

    if (mb_strpos('çccc', $char) !== false)
    {
        return 'c';
    }

    if (mb_strpos('zzž', $char) !== false)
    {
        return 'z';
    }

    if (mb_strpos('ssšs', $char) !== false)
    {
        return 's';
    }

    if (mb_strpos('ñn', $char) !== false)
    {
        return 'n';
    }

    if (mb_strpos('ýÿ', $char) !== false)
    {
        return 'y';
    }

    if (mb_strpos('gg', $char) !== false)
    {
        return 'g';
    }

    if (mb_strpos('r', $char) !== false)
    {
        return 'r';
    }

    if (mb_strpos('l', $char) !== false)
    {
        return 'l';
    }

    if (mb_strpos('d', $char) !== false)
    {
        return 'd';
    }

    if (mb_strpos('ß', $char) !== false)
    {
        return 'ss';
    }

    if (mb_strpos('Þ', $char) !== false)
    {
        return 'th';
    }

    if (mb_strpos('h', $char) !== false)
    {
        return 'h';
    }

    if (mb_strpos('j', $char) !== false)
    {
        return 'j';
    }
    return '';
}

function url_friendly_title($url_title)
{
    if (empty($url_title))
    {
        return '';
    }

    $url_title = mb_strtolower($url_title);

    $url_title_max_length   = 80;
    $url_title_length       = mb_strlen($url_title);
    $url_title_friendly     = '';
    $url_title_dash_added   = false;
    $url_title_char = '';

    for ($i = 0; $i < $url_title_length; $i++)
    {
        $url_title_char     = mb_substr($url_title, $i, 1);

        if (strlen($url_title_char) == 2)
        {
            $url_title_ascii    = ord($url_title_char[0]) * 256 + ord($url_title_char[1]) . "\r\n";
        }
        else
        {
            $url_title_ascii    = ord($url_title_char);
        }

        if (is_between($url_title_ascii, 97, 122) || is_between($url_title_ascii, 48, 57))
        {
            $url_title_friendly .= $url_title_char;

            $url_title_dash_added = false;
        }
        elseif(is_between($url_title_ascii, 65, 90))
        {
            $url_title_friendly .= chr(($url_title_ascii | 32));

            $url_title_dash_added = false;
        }
        elseif($url_title_ascii == 32 || $url_title_ascii == 44 || $url_title_ascii == 46 || $url_title_ascii == 47 || $url_title_ascii == 92 || $url_title_ascii == 45 || $url_title_ascii == 47 || $url_title_ascii == 95 || $url_title_ascii == 61)
        {
            if (!$url_title_dash_added && mb_strlen($url_title_friendly) > 0)
            {
                $url_title_friendly .= chr(45);

                $url_title_dash_added = true;
            }
        }
        else if ($url_title_ascii >= 128)
        {
            $url_title_previous_length = mb_strlen($url_title_friendly);

            $url_title_friendly .= international_char_to_ascii($url_title_char);

            if ($url_title_previous_length != mb_strlen($url_title_friendly))
            {
                $url_title_dash_added = false;
            }
        }

        if ($i == $url_title_max_length)
        {
            break;
        }
    }

    if ($url_title_dash_added)
    {
        return mb_substr($url_title_friendly, 0, -1);
    }
    else
    {
        return $url_title_friendly;
    }
}

Answer 7

stackoverflow 解决方案非常棒，但现代浏览器（不包括 IE，像往常一样）现在可以很好地处理 utf8 编码：

所以我升级了建议的解决方案：

public static string ToFriendlyUrl(string title, bool useUTF8Encoding = false)
{
    ...

        else if (c >= 128)
        {
            int prevlen = sb.Length;
            if (useUTF8Encoding )
            {
                sb.Append(HttpUtility.UrlEncode(c.ToString(CultureInfo.InvariantCulture),Encoding.UTF8));
            }
            else
            {
                sb.Append(RemapInternationalCharToAscii(c));
            }
    ...
}

Pastebin 上的完整代码

编辑：这是 RemapInternationalCharToAscii 方法的代码（pastebin 中缺少该方法）。

Answer 8

这是我的 Jeff 代码版本（速度较慢，但​​写起来很有趣）：

public static string URLFriendly(string title)
{
    char? prevRead = null,
        prevWritten = null;

    var seq = 
        from c in title
        let norm = RemapInternationalCharToAscii(char.ToLowerInvariant(c).ToString())[0]
        let keep = char.IsLetterOrDigit(norm)
        where prevRead.HasValue || keep
        let replaced = keep ? norm
            :  prevWritten != '-' ? '-'
            :  (char?)null
        where replaced != null
        let s = replaced + (prevRead == null ? ""
            : norm == '#' && "cf".Contains(prevRead.Value) ? "sharp"
            : norm == '+' ? "plus"
            : "")
        let _ = prevRead = norm
        from written in s
        let __ = prevWritten = written
        select written;

    const int maxlen = 80;  
    return string.Concat(seq.Take(maxlen)).TrimEnd('-');
}

public static string RemapInternationalCharToAscii(string text)
{
    var seq = text.Normalize(NormalizationForm.FormD)
        .Where(c => CharUnicodeInfo.GetUnicodeCategory(c) != UnicodeCategory.NonSpacingMark);

    return string.Concat(seq).Normalize(NormalizationForm.FormC);
}

我的测试字符串：

" 我喜欢 C#、F#、C++ 和...焦糖布丁！！！他们看到我编码...他们讨厌'...试图抓住我肮脏的编码...“

Answer 9

您可以使用以下辅助方法。 它可以转换 Unicode 字符。

public static string ConvertTextToSlug(string s)
{
    StringBuilder sb = new StringBuilder();

    bool wasHyphen = true;

    foreach (char c in s)
    {
        if (char.IsLetterOrDigit(c))
        {
            sb.Append(char.ToLower(c));
            wasHyphen = false;
        }
        else
            if (char.IsWhiteSpace(c) && !wasHyphen)
            {
                sb.Append('-');
                wasHyphen = true;
            }
    }

    // Avoid trailing hyphens
    if (wasHyphen && sb.Length > 0)
        sb.Length--;

    return sb.ToString().Replace("--","-");
}

Answer 10

现在所有浏览器都能很好地处理 utf8 编码，因此您可以使用 WebUtility.UrlEncode 方法，类似于 HttpUtility.UrlEncode 由 @giamin 使用，但它在 Web 应用程序之外工作。

Answer 11

这是我的杰夫代码版本。 我进行了以下更改：

• 连字符以可以添加的方式附加，然后需要删除，因为它是字符串中的最后一个字符。 也就是说，我们永远不需要“my-slug-”。 这意味着需要额外的字符串分配来在这种边缘情况下删除它。 我已经通过延迟连字符解决了这个问题。 如果您将我的代码与 Jeff 的代码进行比较，则逻辑很容易理解。
• 他的方法纯粹是基于查找的，并且错过了我在研究 Stack Overflow 时在示例中发现的许多字符。 为了解决这个问题，我首先执行标准化过程（又名 Meta Stack Overflow 问题中提到的排序规则 从完整（配置文件）URL 中删除的非 US-ASCII 字符），然后忽略可接受范围之外的任何字符。 这在大多数情况下都有效……
• 如果不起作用，我还必须添加一个查找表。 如上所述，某些字符在标准化时不会映射到低 ASCII 值。 我没有放弃这些，而是​​得到了一份手动的例外列表，这无疑充满了漏洞，但总比没有好。 规范化代码的灵感来自 Jon Hanna 在 Stack Overflow 问题中的精彩帖子如何删除字符串上的重音符号？。

• 大小写转换现在也是可选的。

  公共静态类Slug 
    { 
        公共静态字符串创建（布尔toLower，参数字符串[]值） 
        { 
            返回 Create(toLower, String.Join("-", 值)); 
        } 
  
        /// <摘要> 
        /// 创建一个 slug。 
        /// 参考： 
        /// http://www.unicode.org/reports/tr15/tr15-34.html 
        /// https://meta.stackexchange.com/questions/7435/non-us-ascii-characters-dropped-from-full-profile-url/7696#7696 
        /// https://stackoverflow.com/questions/25259/how-do-you-include-a-webpage-title-as-part-of-a-webpage-url/25486#25486 
        /// https://stackoverflow.com/questions/3769457/how-can-i-remove-accents-on-a-string 
        ///  
        /// ; 
        /// ; 
        /// ; 
        公共静态字符串创建（布尔toLower，字符串值） 
        { 
            如果（值==空） 
                返回 ””; 
  
            var 标准化 = value.Normalize(NormalizationForm.FormKD); 
  
            常量 int 最大长度 = 80; 
            int len = 标准化. 长度; 
            布尔 prevDash = false; 
            var sb = new StringBuilder(len); 
            字符c； 
  
            for (int i = 0; i < len; i++) 
            { 
                c = 归一化[i]； 
                if ((c >= 'a' && c <= 'z') || (c >= '0' && c <= '9')) 
                { 
                    if (上一个短划线) 
                    { 
                        sb.Append('-'); 
                        prevDash = false; 
                    } 
                    sb.Append(c); 
                } 
                否则 if (c >= 'A' && c <= 'Z') 
                { 
                    if (上一个短划线) 
                    { 
                        sb.Append('-'); 
                        prevDash = false; 
                    } 
                    // 转换为小写的棘手方法 
                    if (至下) 
                        sb.Append((char)(c | 32)); 
                    别的 
                        sb.Append(c); 
                } 
                else if (c == ' ' || c == ',' || c == '.' || c == '/' || c == '\\' || c == '-' | | c == '_' || c == '=') 
                { 
                    if (!prevDash && sb.Length > 0) 
                    { 
                        prevDash = true; 
                    } 
                } 
                别的 
                { 
                    字符串交换 = ConvertEdgeCases(c, toLower); 
  
                    if（交换！= null） 
                    { 
                        if (上一个短划线) 
                        { 
                            sb.Append('-'); 
                            prevDash = false; 
                        } 
                        sb.追加（交换）； 
                    } 
                } 
  
                if (sb.Length == maxlen) 
                    休息; 
            } 
            返回 sb.ToString(); 
        } 
  
        静态字符串 ConvertEdgeCases(char c, bool toLower) 
        { 
            字符串交换=空； 
            开关（c） 
            { 
                案例“我”： 
                    交换=“我”； 
                    休息; 
                案例“l”： 
                    交换=“l”； 
                    休息; 
                案例“Ł”： 
                    交换 = 降低？   “二”; 
                    休息; 
                案例“D”： 
                    交换=“d”； 
                    休息; 
                案例“ß”： 
                    交换=“SS”； 
                    休息; 
                案例“ø”： 
                    交换=“o”； 
                    休息; 
                案例“Þ”： 
                    交换=“第”； 
                    休息; 
            } 
            返回掉期； 
        } 
    } 
    

有关更多详细信息、单元测试以及 Facebook 的 URL 方案比 Stack Overflows 更聪明，我有一个 我的博客上的扩展版本 。

Answer 12

T-SQL 实现，改编自 dbo.UrlEncode：

CREATE FUNCTION dbo.Slug(@string varchar(1024))
RETURNS varchar(3072)
AS
BEGIN
    DECLARE @count int, @c char(1), @i int, @slug varchar(3072)

    SET @string = replace(lower(ltrim(rtrim(@string))),' ','-')

    SET @count = Len(@string)
    SET @i = 1
    SET @slug = ''

    WHILE (@i <= @count)
    BEGIN
        SET @c = substring(@string, @i, 1)

        IF @c LIKE '[a-z0-9--]'
            SET @slug = @slug + @c

        SET @i = @i +1
    END

    RETURN @slug
END

Answer 13

我对 Ruby 或 Rails 不太了解，但在 Perl 中，这就是我会做的：

my $title = "How do you change a title to be part of the url like Stackoverflow?";

my $url = lc $title;   # Change to lower case and copy to URL.
$url =~ s/^\s+//g;     # Remove leading spaces.
$url =~ s/\s+$//g;     # Remove trailing spaces.
$url =~ s/\s+/\-/g;    # Change one or more spaces to single hyphen.
$url =~ s/[^\w\-]//g;  # Remove any non-word characters.

print "$title\n$url\n";

我只是做了一个快速测试，它似乎有效。 希望这相对容易翻译成 Ruby。

Answer 14

我不熟悉 Ruby on Rails，但以下是（未经测试的）PHP 代码。 如果您发现它有用，您可以很快地将其转换为 Ruby on Rails。

$sURL = "This is a title to convert to URL-format. It has 1 number in it!";
// To lower-case
$sURL = strtolower($sURL);

// Replace all non-word characters with spaces
$sURL = preg_replace("/\W+/", " ", $sURL);

// Remove trailing spaces (so we won't end with a separator)
$sURL = trim($sURL);

// Replace spaces with separators (hyphens)
$sURL = str_replace(" ", "-", $sURL);

echo $sURL;
// outputs: this-is-a-title-to-convert-to-url-format-it-has-1-number-in-it

我希望这有帮助。

Answer 15

我们是这样做的。 请注意，边缘条件可能比您第一眼意识到的要多。

这是第二个版本，性能提高了 5 倍（是的，我对它进行了基准测试）。 我想我应该优化它，因为这个函数每页可以调用数百次。

/// <summary>
/// Produces optional, URL-friendly version of a title, "like-this-one". 
/// hand-tuned for speed, reflects performance refactoring contributed
/// by John Gietzen (user otac0n) 
/// </summary>
public static string URLFriendly(string title)
{
    if (title == null) return "";

    const int maxlen = 80;
    int len = title.Length;
    bool prevdash = false;
    var sb = new StringBuilder(len);
    char c;

    for (int i = 0; i < len; i++)
    {
        c = title[i];
        if ((c >= 'a' && c <= 'z') || (c >= '0' && c <= '9'))
        {
            sb.Append(c);
            prevdash = false;
        }
        else if (c >= 'A' && c <= 'Z')
        {
            // tricky way to convert to lowercase
            sb.Append((char)(c | 32));
            prevdash = false;
        }
        else if (c == ' ' || c == ',' || c == '.' || c == '/' || 
            c == '\\' || c == '-' || c == '_' || c == '=')
        {
            if (!prevdash && sb.Length > 0)
            {
                sb.Append('-');
                prevdash = true;
            }
        }
        else if ((int)c >= 128)
        {
            int prevlen = sb.Length;
            sb.Append(RemapInternationalCharToAscii(c));
            if (prevlen != sb.Length) prevdash = false;
        }
        if (i == maxlen) break;
    }

    if (prevdash)
        return sb.ToString().Substring(0, sb.Length - 1);
    else
        return sb.ToString();
}

要查看此替换的代码的先前版本（但在功能上等效，并且速度快 5 倍），请查看本文的修订历史记录（单击日期链接）。

此外，此处还可以找到 RemapInternationalCharToAscii 方法源代码。

Answer 16

我知道这是一个非常老的问题，但由于现在大多数浏览器支持unicode url，我在XRegex中找到了一个很好的解决方案，可以将除字母之外的所有内容（在所有语言中都转换为“-”） ）。

这可以用多种编程语言来完成。

模式是 \\p{^L}+，然后您只需使用它来将所有非字母替换为“-”。

Node.js 中使用 xregex 模块的工作示例。

var text = 'This ! can @ have # several $ letters % from different languages such as עברית or Español';

var slugRegEx = XRegExp('((?!\\d)\\p{^L})+', 'g');

var slug = XRegExp.replace(text, slugRegEx, '-').toLowerCase();

console.log(slug) ==> "this-can-have-several-letters-from-different-languages-such-as-עברית-or-español"

Answer 17

您需要设置一个自定义路由，将 URL 指向将处理它的控制器。 由于您使用的是 Ruby on Rails，因此这里是使用其路由引擎的简介。

在 Ruby 中，您将需要一个您已经知道的正则表达式，下面是要使用的正则表达式：

def permalink_for(str)
    str.gsub(/[^\w\/]|[!\(\)\.]+/, ' ').strip.downcase.gsub(/\ +/, '-')
end

Answer 18

您还可以使用此 JavaScript 函数以形式生成 slug（该函数基于/复制自 Django）：

function makeSlug(urlString, filter) {
    // Changes, e.g., "Petty theft" to "petty_theft".
    // Remove all these words from the string before URLifying

    if(filter) {
        removelist = ["a", "an", "as", "at", "before", "but", "by", "for", "from",
        "is", "in", "into", "like", "of", "off", "on", "onto", "per",
        "since", "than", "the", "this", "that", "to", "up", "via", "het", "de", "een", "en",
        "with"];
    }
    else {
        removelist = [];
    }
    s = urlString;
    r = new RegExp('\\b(' + removelist.join('|') + ')\\b', 'gi');
    s = s.replace(r, '');
    s = s.replace(/[^-\w\s]/g, ''); // Remove unneeded characters
    s = s.replace(/^\s+|\s+$/g, ''); // Trim leading/trailing spaces
    s = s.replace(/[-\s]+/g, '-'); // Convert spaces to hyphens
    s = s.toLowerCase(); // Convert to lowercase
    return s; // Trim to first num_chars characters
}

Answer 19

为了更好地衡量，这里是 WordPress 中的 PHP 函数，它可以做到这一点...我认为 WordPress 是使用花哨链接的更流行的平台之一。

    function sanitize_title_with_dashes($title) {
            $title = strip_tags($title);
            // Preserve escaped octets.
            $title = preg_replace('|%([a-fA-F0-9][a-fA-F0-9])|', '---$1---', $title);
            // Remove percent signs that are not part of an octet.
            $title = str_replace('%', '', $title);
            // Restore octets.
            $title = preg_replace('|---([a-fA-F0-9][a-fA-F0-9])---|', '%$1', $title);
            $title = remove_accents($title);
            if (seems_utf8($title)) {
                    if (function_exists('mb_strtolower')) {
                            $title = mb_strtolower($title, 'UTF-8');
                    }
                    $title = utf8_uri_encode($title, 200);
            }
            $title = strtolower($title);
            $title = preg_replace('/&.+?;/', '', $title); // kill entities
            $title = preg_replace('/[^%a-z0-9 _-]/', '', $title);
            $title = preg_replace('/\s+/', '-', $title);
            $title = preg_replace('|-+|', '-', $title);
            $title = trim($title, '-');
            return $title;
    }

该函数以及一些支持函数可以在 wp-includes/formatting.php 中找到。

Answer 20

如果您使用 Rails Edge，则可以依赖 Inflector.parametrize - 这是文档中的示例：

  class Person
    def to_param
      "#{id}-#{name.parameterize}"
    end
  end

  @person = Person.find(1)
  # => #<Person id: 1, name: "Donald E. Knuth">

  <%= link_to(@person.name, person_path(@person)) %>
  # => <a href="/person/1-donald-e-knuth">Donald E. Knuth</a>

此外，如果您需要处理更多外来字符，例如以前版本的 Rails 中的重音符号 (éphémère)，您可以混合使用 PermalinkFu 和 变音符号：

DiacriticsFu::escape("éphémère")
=> "ephemere"

DiacriticsFu::escape("räksmörgås")
=> "raksmorgas"

Answer 21

假设您的模型类具有 title 属性，您可以简单地重写模型中的 to_param 方法，如下所示：

def to_param
  title.downcase.gsub(/ /, '-')
end

这一集 Railscast 包含所有详细信息。 您还可以使用以下命令确保标题仅包含有效字符：

validates_format_of :title, :with => /^[a-z0-9-]+$/,
                    :message => 'can only contain letters, numbers and hyphens'