ड्रूपल: स्ट्रिंग से एक स्लग बनाने के लिए मानक तरीका

Question

इस संदर्भ पर एक स्लग एक स्ट्रिंग है जो यूआरएल या सीएसएस पर पहचानकर्ता के रूप में उपयोग करने के लिए सुरक्षित है। उदाहरण के लिए, अगर आप इस स्ट्रिंग है:

I'd like to eat at McRunchies! 

इसके स्लग होगा:

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

मैं है कि क्या वहाँ ड्रुपल (या php Drupal से उपलब्ध कार्यों पर इस तरह श्रृंखला के निर्माण के लिए एक मानक तरीका जानना चाहते हैं)। अधिक सटीक, एक Drupal विषय के अंदर।

संदर्भ: मैं एक ड्रोपल थीम को संशोधित कर रहा हूं ताकि नोड्स के एचटीएमएल के एचटीएमएल में उनके वर्गीकरण शब्द को उनके युक्त div पर सीएसएस कक्षाएं शामिल हों। समस्या यह है कि उनमें से कुछ शब्द 'नाम वैध सीएसएस वर्ग के नाम नहीं हैं। मुझे उन्हें "slugify" करने की जरूरत है।

मैं पढ़ा है कि कुछ लोगों को बस ऐसा करते हैं:

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

यह वास्तव में मेरे लिए एक पर्याप्त है। यह अपरकेस अक्षरों को डाउनकेस के साथ प्रतिस्थापित नहीं करता है, लेकिन अधिक महत्वपूर्ण बात यह है कि गैर-एसीआई अक्षरों (जैसे à या é) को उनके एसीआई समकक्षों द्वारा प्रतिस्थापित नहीं किया जाता है। यह शुरुआत और अंत से "विभाजक तार" को भी नहीं हटाता है।

क्या ड्रोपल 6 (या PHP libs) में कोई फ़ंक्शन है जो स्ट्रिंग को स्लगिफाइफ़ करने का एक तरीका प्रदान करता है, और ड्रोपल थीम की टेम्पलेट.एफ़.पी.पी. फ़ाइल पर इसका उपयोग किया जा सकता है?

Answer 1

जवाब के लिए धन्यवाद। http://www.drupalcoder.com/story/554-how-to-create-url-aliases-in-drupal-without-path-module (लेख के अंत में, आप स्रोत कोड को देखने के लिए क्लिक करें):

मैं का उपयोग कर slug समारोह यहां बताए समाप्त हो गया।

यह बाहरी मॉड्यूल और इसी तरह की आवश्यकता के बिना मुझे जो कुछ चाहिए और कुछ और चीजें करता है।

आसान भविष्य में संदर्भ के लिए नीचे दिए गए कोड पेस्ट करना:

/** 
* 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() फ़ंक्शन का उपयोग कर सकते हैं। यह यूनिकोड परिवर्तन भी करता है।

Answer 4

मैं एक खुश ज़ेन विषय उपयोगकर्ता हूँ, इस प्रकार मैं इस अद्भुत समारोह है कि इसके साथ आता है मिले हैं: 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

यह मदद कर सकता है, मुझे लगता है कि मैं अब हर समय यह स्लगिंग कर रहा हूं बल्कि आईडी नंबरों को मेरी टेबल में अद्वितीय कुंजी के रूप में उपयोग करता हूं।

/** 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 नियमों का उपयोग मतलब है कि आप की तरह एक यूआरएल से सीधे जाना:

/लेख/मेरी-पॉप्स-पागल-मई-2010

सीधे मेज पर के माध्यम से बिना ऊपर देखो आईडी को अनैप करने के लिए (स्वाभाविक रूप से उपयुक्त फ़िल्टर लागू करना)।

अपनी इच्छानुसार विशिष्टता की डिग्री को लागू करने के लिए वैकल्पिक रूप से किसी प्रकार की तारीख को संलग्न या प्रीपेड करें।

HTH

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); 

फ़ंक्शंस आपके लिए चाल करेगा।