drupal: modo standard per creare una lumaca da una stringa

Question

Una lumaca su questo contesto è una stringa che è sicura da usare come identificatore, su URL o css. Ad esempio, se si dispone di questa stringa:

I'd like to eat at McRunchies! 

sua slug sarebbe:

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

Voglio sapere se c'è un modo standard di costruzione di tali stringhe su Drupal (o funzioni PHP disponibili da Drupal). Più precisamente, all'interno di un tema Drupal.

Contesto: Sto modificando un tema drupal in modo che l'html dei nodi che genera includa i loro termini di tassonomia come classi css sul loro div contenitore. Il problema è che alcuni dei nomi di questi termini non sono nomi di classi css validi. Ho bisogno di "ipnotizzarli".

Ho letto che alcune persone semplicemente fanno questo:

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

Questo non è davvero un abbastanza per me. Non sostituisce le lettere maiuscole con il downcase, ma, soprattutto, non sostituisce i caratteri non ascii (come à o é) con i loro equivalenti ascii. Inoltre non rimuove le "stringhe di separazione" dall'inizio e dalla fine.

Esiste una funzione in drupal 6 (o nelle librerie php) che fornisce un modo per eseguire lo slug di una stringa e può essere utilizzata su un file template.php di un tema drupal?

Answer 1

Grazie per le risposte.

Ho finito per utilizzare la funzione slug spiegata qui: http://www.drupalcoder.com/story/554-how-to-create-url-aliases-in-drupal-without-path-module (alla fine dell'articolo, è necessario fare clic per visualizzare il codice sorgente).

Questo fa ciò di cui ho bisogno e un paio di cose in più, senza dover includere moduli esterni e simili.

incollando il codice qui sotto per un facile riferimento futuro:

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

è possibile utilizzare un preg_replace e strtolower:

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

Answer 3

consiglierei il transliteration module che utilizza path_auto. Con esso è possibile utilizzare la funzione transliteration_get(). Trasforma anche unicode.

Answer 4

Sono un utente felice Zen tema, così che ho incontrato questa meravigliosa funzione che viene con esso: zen_id_safe http://api.lullabot.com/zen_id_safe

non dipende da alcuna altra funzione tema, in modo da poter basta copiarlo al modulo o tema e usarlo. è una funzione piuttosto piccola e semplice, quindi la incollo qui per comodità.

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

Questo potrebbe aiutare, trovo che sto facendo questo slugging tutto il tempo ora piuttosto che utilizzare i numeri di identificazione come chiavi univoche nelle mie tabelle.

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

    } 

} 

Utilizzando questo e .htaccess regole significa che si va direttamente da un URL del tipo:

/articoli/I miei-pop-noci-mag-2010

dritto fino alla tabella di guardare in alto senza dover rimuovere gli ID (applicando un filtro adatto in modo naturale).

Aggiungere o anteporre un tipo di data facoltativamente al fine di imporre un grado di univocità come desiderato.

HTH

Answer 6

C'è anche questo da d7 cui è possibile copiare al progetto:

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

Answer 7

È possibile utilizzare costruito in funzioni di Drupal per fare questo.

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

funzioni faranno il trucco per voi.