drupal: стандартный способ создания пули из строки

Question

Путь в этом контексте - это строка, которая безопасна для использования в качестве идентификатора, на URL-адресах или в CSS. Например, если у вас есть эта строка:

I'd like to eat at McRunchies! 

Его пробковое будет:

i-d-like-to-eat-at-mcrunchies 

Я хочу знать, есть ли стандартный способ построения таких строк на Drupal (или функции PHP, доступных из Друпал). Точнее, внутри темы Drupal.

Контекст: Я изменяю тему drupal, поэтому html узлов, которые он генерирует, включает их таксономические термины как классы css в их содержащем div. Проблема в том, что некоторые из имен этих терминов не являются допустимыми именами класса css. Мне нужно «убить» их.

Я читал, что некоторые люди просто сделать это:

str_replace(" ", "-", $term->name) 

Это на самом деле не достаточно для меня. Он не заменяет прописные буквы нижним регистром, но что более важно, не заменяет символы не-ascii (например, à или é) их эквивалентами ascii. Он также не удаляет «разделительные строки» с начала и конца.

Есть ли функция в drupal 6 (или php libs), которая предоставляет способ slugify строки и может использоваться в файле template.php темы drupal?

Answer 1

Спасибо за ответы.

В итоге я использовал функцию slug, описанную здесь: http://www.drupalcoder.com/story/554-how-to-create-url-aliases-in-drupal-without-path-module (в конце статьи, вы должны нажать, чтобы увидеть исходный код).

Это делает то, что мне нужно, и пару вещей больше, без необходимости включать внешние модули и тому подобное.

Оклейка код ниже для удобства будущего:

/** 
* Calculate a slug with a maximum length for a string. 
* 
* @param $string 
* The string you want to calculate a slug for. 
* @param $length 
* The maximum length the slug can have. 
* @return 
* A string representing the slug 
*/ 
function slug($string, $length = -1, $separator = '-') { 
    // transliterate 
    $string = transliterate($string); 

    // lowercase 
    $string = strtolower($string); 

    // replace non alphanumeric and non underscore charachters by separator 
    $string = preg_replace('/[^a-z0-9]/i', $separator, $string); 

    // replace multiple occurences of separator by one instance 
    $string = preg_replace('/'. preg_quote($separator) .'['. preg_quote($separator) .']*/', $separator, $string); 

    // cut off to maximum length 
    if ($length > -1 && strlen($string) > $length) { 
    $string = substr($string, 0, $length); 
    } 

    // remove separator from start and end of string 
    $string = preg_replace('/'. preg_quote($separator) .'$/', '', $string); 
    $string = preg_replace('/^'. preg_quote($separator) .'/', '', $string); 

    return $string; 
} 

/** 
* Transliterate a given string. 
* 
* @param $string 
* The string you want to transliterate. 
* @return 
* A string representing the transliterated version of the input string. 
*/ 
function transliterate($string) { 
    static $charmap; 
    if (!$charmap) { 
    $charmap = array(
     // Decompositions for Latin-1 Supplement 
     chr(195) . chr(128) => 'A', chr(195) . chr(129) => 'A', 
     chr(195) . chr(130) => 'A', chr(195) . chr(131) => 'A', 
     chr(195) . chr(132) => 'A', chr(195) . chr(133) => 'A', 
     chr(195) . chr(135) => 'C', chr(195) . chr(136) => 'E', 
     chr(195) . chr(137) => 'E', chr(195) . chr(138) => 'E', 
     chr(195) . chr(139) => 'E', chr(195) . chr(140) => 'I', 
     chr(195) . chr(141) => 'I', chr(195) . chr(142) => 'I', 
     chr(195) . chr(143) => 'I', chr(195) . chr(145) => 'N', 
     chr(195) . chr(146) => 'O', chr(195) . chr(147) => 'O', 
     chr(195) . chr(148) => 'O', chr(195) . chr(149) => 'O', 
     chr(195) . chr(150) => 'O', chr(195) . chr(153) => 'U', 
     chr(195) . chr(154) => 'U', chr(195) . chr(155) => 'U', 
     chr(195) . chr(156) => 'U', chr(195) . chr(157) => 'Y', 
     chr(195) . chr(159) => 's', chr(195) . chr(160) => 'a', 
     chr(195) . chr(161) => 'a', chr(195) . chr(162) => 'a', 
     chr(195) . chr(163) => 'a', chr(195) . chr(164) => 'a', 
     chr(195) . chr(165) => 'a', chr(195) . chr(167) => 'c', 
     chr(195) . chr(168) => 'e', chr(195) . chr(169) => 'e', 
     chr(195) . chr(170) => 'e', chr(195) . chr(171) => 'e', 
     chr(195) . chr(172) => 'i', chr(195) . chr(173) => 'i', 
     chr(195) . chr(174) => 'i', chr(195) . chr(175) => 'i', 
     chr(195) . chr(177) => 'n', chr(195) . chr(178) => 'o', 
     chr(195) . chr(179) => 'o', chr(195) . chr(180) => 'o', 
     chr(195) . chr(181) => 'o', chr(195) . chr(182) => 'o', 
     chr(195) . chr(182) => 'o', chr(195) . chr(185) => 'u', 
     chr(195) . chr(186) => 'u', chr(195) . chr(187) => 'u', 
     chr(195) . chr(188) => 'u', chr(195) . chr(189) => 'y', 
     chr(195) . chr(191) => 'y', 
     // Decompositions for Latin Extended-A 
     chr(196) . chr(128) => 'A', chr(196) . chr(129) => 'a', 
     chr(196) . chr(130) => 'A', chr(196) . chr(131) => 'a', 
     chr(196) . chr(132) => 'A', chr(196) . chr(133) => 'a', 
     chr(196) . chr(134) => 'C', chr(196) . chr(135) => 'c', 
     chr(196) . chr(136) => 'C', chr(196) . chr(137) => 'c', 
     chr(196) . chr(138) => 'C', chr(196) . chr(139) => 'c', 
     chr(196) . chr(140) => 'C', chr(196) . chr(141) => 'c', 
     chr(196) . chr(142) => 'D', chr(196) . chr(143) => 'd', 
     chr(196) . chr(144) => 'D', chr(196) . chr(145) => 'd', 
     chr(196) . chr(146) => 'E', chr(196) . chr(147) => 'e', 
     chr(196) . chr(148) => 'E', chr(196) . chr(149) => 'e', 
     chr(196) . chr(150) => 'E', chr(196) . chr(151) => 'e', 
     chr(196) . chr(152) => 'E', chr(196) . chr(153) => 'e', 
     chr(196) . chr(154) => 'E', chr(196) . chr(155) => 'e', 
     chr(196) . chr(156) => 'G', chr(196) . chr(157) => 'g', 
     chr(196) . chr(158) => 'G', chr(196) . chr(159) => 'g', 
     chr(196) . chr(160) => 'G', chr(196) . chr(161) => 'g', 
     chr(196) . chr(162) => 'G', chr(196) . chr(163) => 'g', 
     chr(196) . chr(164) => 'H', chr(196) . chr(165) => 'h', 
     chr(196) . chr(166) => 'H', chr(196) . chr(167) => 'h', 
     chr(196) . chr(168) => 'I', chr(196) . chr(169) => 'i', 
     chr(196) . chr(170) => 'I', chr(196) . chr(171) => 'i', 
     chr(196) . chr(172) => 'I', chr(196) . chr(173) => 'i', 
     chr(196) . chr(174) => 'I', chr(196) . chr(175) => 'i', 
     chr(196) . chr(176) => 'I', chr(196) . chr(177) => 'i', 
     chr(196) . chr(178) => 'IJ', chr(196) . chr(179) => 'ij', 
     chr(196) . chr(180) => 'J', chr(196) . chr(181) => 'j', 
     chr(196) . chr(182) => 'K', chr(196) . chr(183) => 'k', 
     chr(196) . chr(184) => 'k', chr(196) . chr(185) => 'L', 
     chr(196) . chr(186) => 'l', chr(196) . chr(187) => 'L', 
     chr(196) . chr(188) => 'l', chr(196) . chr(189) => 'L', 
     chr(196) . chr(190) => 'l', chr(196) . chr(191) => 'L', 
     chr(197) . chr(128) => 'l', chr(197) . chr(129) => 'L', 
     chr(197) . chr(130) => 'l', chr(197) . chr(131) => 'N', 
     chr(197) . chr(132) => 'n', chr(197) . chr(133) => 'N', 
     chr(197) . chr(134) => 'n', chr(197) . chr(135) => 'N', 
     chr(197) . chr(136) => 'n', chr(197) . chr(137) => 'N', 
     chr(197) . chr(138) => 'n', chr(197) . chr(139) => 'N', 
     chr(197) . chr(140) => 'O', chr(197) . chr(141) => 'o', 
     chr(197) . chr(142) => 'O', chr(197) . chr(143) => 'o', 
     chr(197) . chr(144) => 'O', chr(197) . chr(145) => 'o', 
     chr(197) . chr(146) => 'OE', chr(197) . chr(147) => 'oe', 
     chr(197) . chr(148) => 'R', chr(197) . chr(149) => 'r', 
     chr(197) . chr(150) => 'R', chr(197) . chr(151) => 'r', 
     chr(197) . chr(152) => 'R', chr(197) . chr(153) => 'r', 
     chr(197) . chr(154) => 'S', chr(197) . chr(155) => 's', 
     chr(197) . chr(156) => 'S', chr(197) . chr(157) => 's', 
     chr(197) . chr(158) => 'S', chr(197) . chr(159) => 's', 
     chr(197) . chr(160) => 'S', chr(197) . chr(161) => 's', 
     chr(197) . chr(162) => 'T', chr(197) . chr(163) => 't', 
     chr(197) . chr(164) => 'T', chr(197) . chr(165) => 't', 
     chr(197) . chr(166) => 'T', chr(197) . chr(167) => 't', 
     chr(197) . chr(168) => 'U', chr(197) . chr(169) => 'u', 
     chr(197) . chr(170) => 'U', chr(197) . chr(171) => 'u', 
     chr(197) . chr(172) => 'U', chr(197) . chr(173) => 'u', 
     chr(197) . chr(174) => 'U', chr(197) . chr(175) => 'u', 
     chr(197) . chr(176) => 'U', chr(197) . chr(177) => 'u', 
     chr(197) . chr(178) => 'U', chr(197) . chr(179) => 'u', 
     chr(197) . chr(180) => 'W', chr(197) . chr(181) => 'w', 
     chr(197) . chr(182) => 'Y', chr(197) . chr(183) => 'y', 
     chr(197) . chr(184) => 'Y', chr(197) . chr(185) => 'Z', 
     chr(197) . chr(186) => 'z', chr(197) . chr(187) => 'Z', 
     chr(197) . chr(188) => 'z', chr(197) . chr(189) => 'Z', 
     chr(197) . chr(190) => 'z', chr(197) . chr(191) => 's', 
     // Euro Sign 
     chr(226) . chr(130) . chr(172) => 'E' 
    ); 
    } 

    // transliterate 
    return strtr($string, $charmap); 
} 

function is_slug($str) { 
    return $str == slug($str); 
} 

Answer 2

Вы можете использовать preg_replace и strtolower:

preg_replace('/[^a-z]/','-', strtolower($term->name)); 

Answer 3

Я бы рекомендовал transliteration module, который использует path_auto. С его помощью вы можете использовать функцию transliteration_get(). Он также преобразует unicode.

Answer 4

я являюсь счастливым пользователем Zen темы, таким образом, я уже встретил эту замечательную функцию, которая приходит с ней: zen_id_safe http://api.lullabot.com/zen_id_safe

это не зависит от какой-либо другой функции темы, так что вы можете просто скопировать его в модуль или темы и использовать его. это довольно маленькая и простая функция, поэтому я просто добавлю ее сюда для удобства.

function zen_id_safe($string) { 
    // Replace with dashes anything that isn't A-Z, numbers, dashes, or underscores. 
    return strtolower(preg_replace('/[^a-zA-Z0-9-]+/', '-', $string)); 
}

Answer 5

Это может помочь, я нахожу, что я делаю это пробок все время, а затем использую номера id как уникальные ключи в своих таблицах.

/** class SlugMaker 
    * 
    * methods to create text slugs for urls 
    * 
    **/ 

class SlugMaker { 

    /** method slugify 
    * 
    * cleans up a string such as a page title 
    * so it becomes a readable valid url 
    * 
    * @param STR a string 
    * @return STR a url friendly slug 
    **/ 

    function slugifyAlnum($str){ 

    $str = preg_replace('#[^0-9a-z ]#i', '', $str); // allow letters, numbers + spaces only 
    $str = preg_replace('#(){2,}#', ' ', $str);  // rm adjacent spaces 
    $str = trim($str) ; 

    return strtolower(str_replace(' ', '-', $str)); // slugify 


    } 


    function slugifyAlnumAppendMonth($str){ 

    $val = $this->slugifyAlnum($str); 

    return $val . '-' . strtolower(date("M")) . '-' . date("Y") ; 

    } 

} 

Используя это и .htaccess правила означает, что вы идете прямо из URL, как:

/статьи/My-хлопки орехом-май-2010

прямо к столу смотреть без необходимо отменить идентификаторы (естественно применяя подходящий фильтр).

При необходимости добавьте или добавьте какую-либо дату, чтобы обеспечить определенную степень уникальности по своему усмотрению.

НТН

Answer 6

Там же это от d7, которые вы можете скопировать в свой проект:

http://api.drupal.org/api/function/drupal_clean_css_identifier/7

Answer 7

Вы можете использовать встроенные функции Drupal, чтобы сделать это.

$string = drupal_clean_css_identifier($string); 
$slug = drupal_html_class($string); 

функции будут делать трюк для вас.