drupal: standardowy sposób tworzenia pliku z ciągu znaków

Question

Ślimak w tym kontekście jest łańcuchem, którego można bezpiecznie używać jako identyfikatora na adresach URL lub css. Na przykład, jeśli masz ten ciąg:

I'd like to eat at McRunchies! 

Jego ślimak będzie:

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

Chcę wiedzieć, czy istnieje standardowy sposób budowania takich strun Drupal (lub funkcji PHP dostępnych Drupal). Dokładniej, wewnątrz tematu Drupala.

Kontekst: Modyfikuję motyw drupal, aby html generowanych przez niego węzłów zawierał ich terminy taksonomiczne jako klasy css w swoim zawierającym div. Problem polega na tym, że niektóre z tych nazw terminów nie są prawidłowymi nazwami css. Muszę je "zmiękczyć".

Czytałem, że niektórzy ludzie po prostu to zrobić:

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

To naprawdę nie jest dla mnie za mało. Nie zastępuje wielkich liter literami, ale, co ważniejsze, nie zastępuje znaków ascii (takich jak or lub é) przez ich odpowiedniki ascii. Nie usuwa również "ciągów separujących" od początku i końca.

Czy istnieje funkcja w drupal 6 (lub php libs), która zapewnia sposób na ograniczenie ciągu znaków i może być używana w pliku template.php motywu drupal?

Answer 1

Dzięki za odpowiedzi.

Skończyło się na użyciu funkcji slug wyjaśnionej tutaj: http://www.drupalcoder.com/story/554-how-to-create-url-aliases-in-drupal-without-path-module (na końcu artykułu, należy kliknąć, aby zobaczyć kod źródłowy).

To robi to, czego potrzebuję i kilka rzeczy więcej, bez potrzeby dołączania modułów zewnętrznych i tym podobnych.

Wklejanie poniższy kod do łatwego odniesienia przyszłość:

/** 
* 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

Można użyć preg_replace i strtolower:

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

Answer 3

Polecam transliteration module który wykorzystuje path_auto. Dzięki niemu możesz użyć funkcji transliteration_get(). Dokonuje także transformacji w Unicode.

Answer 4

jestem zadowolony Zen motyw użytkownika, więc poznałem tę wspaniałą funkcję, która mu towarzyszy: zen_id_safe http://api.lullabot.com/zen_id_safe

to nie zależy od jakiejkolwiek innej funkcji rozrywki, więc można po prostu skopiować go do modułu lub motyw i użyj go. jest to dość mała i prosta funkcja, więc po prostu wkleję ją tutaj dla wygody.

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

To może pomóc, uważam, że robię to cały czas teraz, zamiast używać numerów identyfikacyjnych jako unikalnych kluczy w moich tabelach.

/** 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") ; 

    } 

} 

Korzystanie z tej zasady i .htaccess oznacza przejść bezpośrednio z adresu URL, takich jak:

/Artykuły/My-pop-nakrętki-maj-2010

prosto do stołu patrzeć bez konieczność odkodowania identyfikatorów (stosowanie odpowiedniego filtra w sposób naturalny).

Dodaj lub dodaj dowolną datę opcjonalnie, aby wymusić stopień wyjątkowości.

HTH

Answer 6

Jest też ten z D7, który można skopiować do projektu:

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

Answer 7

można użyć wbudowanych funkcji Drupal to zrobić.

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

funkcje zrobią dla Ciebie.