cach dang ky m88 |

PHP programing - Phần 1 Làm việc với Chuỗi và ký tự trong php

Trong phần thứ nhất này chúng ta sẽ tìm hiểu các hàm xử chuỗi và ký tự trong PHP.

1. Chuyển đổi chữ hoa và chữ thường

Để chuyển đổi chữ thường thành chữ HOA, ta dùng hàm strtoupper($str). Ngược lại, ta dùng hàm strtolower($str) để chuyển đổi chữ HOA thành chữ thường. Các hàm này rất quan trọng trong việc sử lý các thông tin do người dùng nhập vào.
<?
    $str = "hello! i'm come from zendvn.";
    echo $upper = strtoupper($str);
    echo $lower = strtolower($upper);
?>
Như vậy nếu chỉ muốn chuẩn hóa ký tự đầu tiên thôi thì làm thế nào? Chúng ta thử xem hàm ucfirst($str) có công dụng thế nào nhé!
<?
    $str = "hello! i'm come from zendvn.";
    echo $ucf   = ucfirst($str);
?>
Ngoài ra còn hàm ucwords($str): chuyển đổi tất cả các ký tự đầu của các từ trong một chuỗi.
<?
    $str = "hello! i'm come from zendvn.";
    echo $ucf   = ucwords($str);
?>

2. Kiểm tra giá trị của một chuỗi

Khi người dùng nhập thông tin vào một field, làm thế nào để chúng ta kiểm tra thông tin trong field đó?
Muốn kiểm tra giá trị của một chuỗi có tồn tại hay không, ta dùng hàm isset($str). Có rỗng hay không, ta dùng hàm empty($str) và hàm trim($str) để cắt bỏ khoảng trắng dư thừa bên trái & bên phải của chuỗi.
<?
    $str = "    ";
    echo "<hr />";
    echo (!isset($str) || trim($str) == "") ? "Empty" : "Not empty";
    echo "<hr />";
    echo (empty($str)) ? "Empty 1" : "Not empty 1";
    echo "<hr />";
?>

3. Xóa bỏ các ký tự trong một chuỗi

Để cắt bỏ một từ tại vị trí nào đó trong một chuỗi, ta dùng hàm substr(string str,int start, [int length]). Đây là một hàm không thể thiếu trong các thao tác về chuỗi.
<?
    echo "<hr />";
    echo $str = "Vietnam Zend Framework - PHP script - Open Source";
    echo "<hr />";
    //Cắt bỏ 10 ký tự đầu
    //Out put: nd Framework - PHP script - Open Source
    echo substr($str,10);
    echo "<hr />";
    //Bắt đầu từ ký tự thứ 10, lấy 5 ký tự
    //Out put: nd Fr
    echo substr($str,10,5);
    echo "<hr />";
    //Cắt bỏ 10 ký tự cuối
    //Out put: Vietnam Zend Framework - PHP script - O
    echo substr($str,0,-10);
?>

4. Đảo ngược, lặp, xóa bỏ khoảng trắng dư thừa trong một chuỗi

- Đảo ngược: strrev($str)
<?
    echo $str = "Vietnam Zend Framework - PHP script - Open Source";
    echo "<hr />";
    //Out put: Vietnam Zend Framework - PHP script - Open Source
    echo strrev($str);
    echo "<hr />";
?>
- Lặp: str_repeat($str, 10)
<?
    echo $str = "Vietnam";
    echo "<hr />";
    //Out put: VietnamVietnamVietnamVietnamVietnam
    echo str_repeat($str, 5);
    echo "<hr />";
?>
Để xóa bỏ khoảng trắng dư thừa trong một chuỗi ta dùng regular expression để tìm và thay thế nhiều ký tự khoảng trắng thành một ký tự khoảng trắng.
<?
    echo "<hr />";
    $str = "  Vietnam      Zend Framework - PHP         script -                Open Source      ";
    echo "<pre>";print_r($str);echo "</pre>";
    echo "<hr />";
    //Out put: Vietnam Zend Framework - PHP script - Open Source
    echo ereg_replace('[[:space:]]+', ' ', trim($str));
    echo "<hr />";
?>

5. Cắt xén một chuỗi

Để cắt một chuỗi dài thành chuỗi ngắn, ta có thể phối hợp hàm substr() với các hàm khác.
<?
    function truncateString($str, $maxChars=40, $holder="...") {
        // check string length
        // truncate if necessary
        if (strlen($str) > $maxChars)        return trim(substr($str, 0, $maxChars)) . $holder;
        else  return $str;
    }
    echo $str = "Vietnam Zend Framework - PHP script - Open Source";   echo "<hr />";
    //Out put: Vietnam Zend Framewo... >>>
    echo truncateString($str,20,"... >>>");      echo "<hr />";
?>

Tuy nhiên, hàm trên chưa thực sự hoàn hảo cho lắm, đôi lúc nó lại làm sai nghĩa của câu. Chúng ta hãy xem hàm sau

<?
    function truncateString_($str, $len, $charset="UTF-8"){
        $str = html_entity_decode($str, ENT_QUOTES, $charset);   
        if(mb_strlen($str, $charset)> $len){
            $arr = explode(' ', $str);
            $str = mb_substr($str, 0, $len, $charset);
            $arrRes = explode(' ', $str);
            $last = $arr[count($arrRes)-1];
            unset($arr);
            if(strcasecmp($arrRes[count($arrRes)-1], $last))   unset($arrRes[count($arrRes)-1]);
          return implode(' ', $arrRes)."...";   
       }
        return $str;
    }
    echo $str = "Chiếc túi xinh xắn có thể đựng đủ phụ kiện nhỏ nhắn của các quý cô.";      echo "<hr />";
    //Out put: Chiếc túi xinh xắn...
    echo truncateString_($str,20);      echo "<hr />";
?>

6. Chuyển đổi ký tự ra mã ASCII và ngược lại

- ASCII -> chuỗi: chr(int ascii)
<?
    for ($i = '0'; $i<'130'; $i++) {
        echo "chr('".$i."') = ".chr($i)."<br />";
    }
?>
- Chuỗi -> ASCII: ord(string ch)
<?php
    // define character
    $char = "\r";
    // retrieve ASCII code
    // result: 13
    $asc = ord($char);
    echo $asc."<hr />";
?>

7. Chia một chuỗi lớn ra nhiều chuỗi nhỏ

Để chia nhỏ một chuỗi, ta sử dụng hàm str_split(string str, int length)
<?
    echo $str ="Vietnam Zend Framework - PHP script - Open Source";
    $arr =  str_split($str,10);
    echo "<pre>";
    print_r($arr);
    echo "</pre>";
?>
Tuy nhiên, nếu muốn tách một chuỗi có nhiều phần tử ta dùng hàm explode(string separator, string str,int limit)
<?
    echo $str ="Bơ, Sữa, Đường, Muối, Bột, Kem";
    $arr =  explode(",",$str);
    echo "<pre>";
    print_r($arr);
    echo "</pre>";
?>

8. Nối nhiều chuỗi nhỏ thành một chuỗi lớn

Để ghép nối các chuỗi nhỏ, ta dùng hàm implode(string glue,array pieces)
<?
    $arr = array("Muỗi","Bọ","Kiến","Ruồi","Gà","Mèo","Chuột","Chó","Dê");
    $str = implode(" ",$arr);
    echo "<pre>";
    print_r($arr);
    echo "</pre>";
    echo $str;
?>

9. Trích xuất thông tin của một URLs

Để trích xuất các thành phần của một URLs như giao thức, tên miền, đường dẫn, hoặc một thành phần quan trọng khác, ta dùng hàm parse_url(string url)
Sau khi trích xuất url, gán vào một biến nào đó ví dụ $data, lúc này ta có thể dễ dàng truy xuất các phần tử của url (ví dụ: $data['host'])
<?
    echo "<hr />";
    echo $url = "http://www.zend.vn/forum/viewtopic.php?f=27&t=378&p=2446";
    echo "<hr />";
    $data = parse_url($url);
    echo "host: ".$data['host'];
    echo "<hr />";
    foreach ($data as $k=>$v) {
        echo "$k: $v <br />";
    }
?>

10. Đếm số từ trong một đoạn văn bản

Việc đếm số từ trong một câu đôi khi lại trở lên quan trọng, các bạn thử coi ví dụ sau nhé!
<?
    $text = "Fans of the 1980 group will ";

    //C1:
    $words  = preg_split('#[^0-9A-Za-z']+#', $text, -1, PREG_SPLIT_NO_EMPTY);
    echo count($words) . " words";//6 words

    //C2
    $numWords = str_word_count($text);
    echo $numWords . " words";//5 words
?>

11. Tìm kiếm chuỗi ký tự sử dụng Regular expression

Để kiểm tra xem một chuỗi nào đó có tồn tại trong đoạn text mà bạn đang có hay không, ta dùng một số hàm trong PHP, hãy xem ví dụ sau:
<?
    $html = "I'm <b>tired</b> and so I <b>must</b> go <a href='http://domain'>home</a> now";

    echo ereg("<b>(.*)+</b>", $html) ? "Match" : "No match";// result: "Match"
    echo preg_match("#<b>(.*?)<\/b>#i", $html) ? "Match" : "No match";
?>
Ở trên, mình sử dụng phương thức:
int ereg ( string $pattern , string $string [, array &$regs ] )
và
int preg_match ( string $pattern , string $subject [, array &$matches [, int $flags = 0 [, int $offset = 0 ]]] )

12. Đếm số ký tự tìm được trong một đoạn văn bản

Để đếm, ta có thể dùng hàm preg_match_all(), hãy xem ví dụ dưới đây:
<?php
    $html = "I'm <b>tired</b> and so I <b>must</b> go <a href='http://domain'>home</a> now";

    //Đếm số ký tự nằm trong thẻ <b></b>
    preg_match_all("/<b>(.*?)<\/b>/i", $html, &$matches);
    echo sizeof($matches[0]) . " occurrence(s)";// result: "2 occurrence(s)"
?>
Ngoài ra, bạn cũng có thể dùng phương thức sau để đếm số ký tự trong một đoạn văn bản
<?php
    //Đếm số ký tự hee trong một chuỗi
    $text = "ha ha ho hee hee ha ho hee hee ho ho ho ha hee";
    echo substr_count($text, "hee") . " occurrence(s)";// result: "5 occurrence(s)"
?>

13. Thay thế một ký tự mẫu trong đoạn văn bản

Để thay thế một số ký tự này thành một số ký tự khác, bạn thường làm thế nào? dùng str_replace()!
Vậy nếu muốn thay thế bất cứ ký tự nào đó nằm trong thẻ <b>...?</b> thì sao nhỉ? Hãy xem ví dụ sau đây:
Tô đậm ZendVN training:
<?php
    $str = "Welcome to ZendVN training";
    echo $newStr = str_replace("ZendVN training", "<strong>ZendVN training</strong>", $str);
?>
Thêm chữ online vào sau từ ZendVN training:
<?php
    echo $newStr = str_replace("ZendVN training", "ZendVN training online", $str);
?>

14. Mã hóa đoạn chuỗi sử dụng md5 và sha1

<?php
    $str = "ZendVN training online";
    echo md5($str);
    echo sha1($str);
?>

15. Mã hóa một chuỗi sử dụng One-Way Encryption

Sử dụng hàm crypt để mã hóa một chuỗi, với hàm này, chuỗi được mã hóa sẽ không thể giải mã.
<?php
    $password = "train";
    $salt = "ZendVN";
    echo crypt($password, $salt);//ZewY3Kd6p.DqA
?>
Ví dụ:
<?php
    $password = "who are you";
    $salt = "ZendVN";
    echo $cipher = crypt($password, $salt);//Zeaacm35jLcZk

    $input = "i am anonymus";
    echo ($cipher == crypt($input, $salt)) ? "Passwords match" : "Passwords don't match";

    $input = "who are you";
    echo ($cipher == crypt($input, $salt)) ? "Passwords match" : "Passwords don't match";
?>

16. Mã hóa một chuỗi sử dụng Two-Way Encryption

Với phương thức mã hóa 2 chiều này, bạn có thể mã hóa và giải mã theo phương thức đã được định nghĩa sẵn
<?php
    /**
    * delete.all
    * --------------------------------
    * Hàm mã hóa
    */
    function encryptString($plaintext, $key) {
        srand((double) microtime() * 1000000);
        $iv = mcrypt_create_iv(mcrypt_get_iv_size(MCRYPT_BLOWFISH, MCRYPT_MODE_CFB),MCRYPT_RAND);
        $cipher = mcrypt_encrypt(MCRYPT_BLOWFISH, $key, $plaintext, MCRYPT_MODE_CFB, $iv);
        return $iv . $cipher;
    }
    /**
    * delete.all
    * --------------------------------
    * Hàm giải mã
    */
    function decryptString($ciphertext, $key) {
        $iv = substr($ciphertext, 0, mcrypt_get_iv_size(MCRYPT_BLOWFISH, MCRYPT_MODE_CFB));
        $cipher = substr($ciphertext,mcrypt_get_iv_size(MCRYPT_BLOWFISH, MCRYPT_MODE_CFB));
        return mcrypt_decrypt(MCRYPT_BLOWFISH, $key, $cipher,MCRYPT_MODE_CFB, $iv);
    }

    $key = "ZendVN";

    $input = "three paces west, up the hill, turn nor-nor-west and fire through the left eye socket";
    echo '<br>Chuỗi nhập vào: '.$input;

    echo '<br>Kết quả mã hóa: ';
    echo $ciphertext = encryptString($input, $key);

    echo '<br>Kết quả giải mã: ';
    echo $cleartext = decryptString($ciphertext, $key);
?>

17. Tạo mật khẩu ngẫu nhiên

Bạn muốn hệ thống tự tạo mật khẩu một cách ngẫu nhiêu? hãy thử sử dụng các cách dưới đây xem thế nào nhé!

Bước 1: Tạo file Password.php
<?php
    /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */

    /**
    * Class to create passwords
    *
    * PHP versions 4 and 5
    *
    * LICENSE: This source file is subject to version 3.0 of the PHP license
    * that is available through the world-wide-web at the following URI:
    * http://www.php.net/license/3_0.txt.  If you did not receive a copy of
    * the PHP License and are unable to obtain it through the web, please
    * send a note to 
 This email address is being protected from spambots. You need JavaScript enabled to view it.
  so we can mail you a copy immediately.
    *
    * @category   Text
    * @package    Text_Password
    * @author     Martin Jansen <
 This email address is being protected from spambots. You need JavaScript enabled to view it.
 >
    * @author     Olivier Vanhoucke <
 This email address is being protected from spambots. You need JavaScript enabled to view it.
 >
    * @copyright  2004-2005 Martin Jansen, Olivier Vanhoucke
    * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
    * @version    CVS: $Id: Password.php,v 1.18 2008/11/30 13:38:56 mj Exp $
    * @link       http://pear.php.net/package/Text_Password
    */

    /**
    * Number of possible characters in the password
    */
    $GLOBALS['_Text_Password_NumberOfPossibleCharacters'] = 0;

    /**
    * Main class for the Text_Password package
    *
    * @category   Text
    * @package    Text_Password
    * @author     Martin Jansen <
 This email address is being protected from spambots. You need JavaScript enabled to view it.
 >
    * @author     Olivier Vanhoucke <
 This email address is being protected from spambots. You need JavaScript enabled to view it.
 >
    * @copyright  2004-2005 Martin Jansen, Olivier Vanhoucke
    * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
    * @version    Release: @package_version@
    * @link       http://pear.php.net/package/Text_Password
    */
    class Text_Password {

        /**
         * Create a single password.
         *
         * @access public
         * @param  integer Length of the password.
         * @param  string  Type of password (pronounceable, unpronounceable)
         * @param  string  Character which could be use in the
         *                 unpronounceable password ex : 'ABCDEFG'
         *                 or numeric, alphabetical or alphanumeric.
         * @return string  Returns the generated password.
         */
        function create($length = 10, $type = 'pronounceable', $chars = '')
        {
            switch ($type) {
            case 'unpronounceable' :
                return Text_Password::_createUnpronounceable($length, $chars);

            case 'pronounceable' :
            default :
                return Text_Password::_createPronounceable($length);
            }
        }

        /**
         * Create multiple, different passwords
         *
         * Method to create a list of different passwords which are
         * all different.
         *
         * @access public
         * @param  integer Number of different password
         * @param  integer Length of the password
         * @param  string  Type of password (pronounceable, unpronounceable)
         * @param  string  Character which could be use in the
         *                 unpronounceable password ex : 'A,B,C,D,E,F,G'
         *                 or numeric, alphabetical or alphanumeric.
         * @return array   Array containing the passwords
         */
        function createMultiple($number, $length = 10, $type = 'pronounceable', $chars = '')
        {
            $passwords = array();

            while ($number > 0) {
                while (true) {
                    $password = Text_Password::create($length, $type, $chars);
                    if (!in_array($password, $passwords)) {
                        $passwords[] = $password;
                        break;
                    }
                }
                $number--;
            }
            return $passwords;
        }

        /**
         * Create password from login
         *
         * Method to create password from login
         *
         * @access public
         * @param  string  Login
         * @param  string  Type
         * @param  integer Key
         * @return string
         */
        function createFromLogin($login, $type, $key = 0)
        {
            switch ($type) {
            case 'reverse':
                return strrev($login);

            case 'shuffle':
                return Text_Password::_shuffle($login);

            case 'xor':
                return Text_Password::_xor($login, $key);

            case 'rot13':
                return str_rot13($login);

            case 'rotx':
                return Text_Password::_rotx($login, $key);

            case 'rotx++':
                return Text_Password::_rotxpp($login, $key);

            case 'rotx--':
                return Text_Password::_rotxmm($login, $key);

            case 'ascii_rotx':
                return Text_Password::_asciiRotx($login, $key);

            case 'ascii_rotx++':
                return Text_Password::_asciiRotxpp($login, $key);

            case 'ascii_rotx--':
                return Text_Password::_asciiRotxmm($login, $key);
            }
        }

        /**
         * Create multiple, different passwords from an array of login
         *
         * Method to create a list of different password from login
         *
         * @access public
         * @param  array   Login
         * @param  string  Type
         * @param  integer Key
         * @return array   Array containing the passwords
         */
        function createMultipleFromLogin($login, $type, $key = 0)
        {
            $passwords = array();
            $number    = count($login);
            $save      = $number;

            while ($number > 0) {
                while (true) {
                    $password = Text_Password::createFromLogin($login[$save - $number], $type, $key);
                    if (!in_array($password, $passwords)) {
                        $passwords[] = $password;
                        break;
                    }
                }
                $number--;
            }
            return $passwords;
        }

        /**
         * Helper method to create password
         *
         * Method to create a password from a login
         *
         * @access private
         * @param  string  Login
         * @param  integer Key
         * @return string
         */
        function _xor($login, $key)
        {
            $tmp = '';

            for ($i = 0; $i < strlen($login); $i++) {
                $next = ord($login{$i}) ^ $key;
                if ($next > 255) {
                    $next -= 255;
                } elseif ($next < 0) {
                    $next += 255;
                }
                $tmp .= chr($next);
            }

            return $tmp;
        }

        /**
         * Helper method to create password
         *
         * Method to create a password from a login
         * lowercase only
         *
         * @access private
         * @param  string  Login
         * @param  integer Key
         * @return string
         */
        function _rotx($login, $key)
        {
            $tmp = '';
            $login = strtolower($login);

            for ($i = 0; $i < strlen($login); $i++) {
                if ((ord($login{$i}) >= 97) && (ord($login{$i}) <= 122)) { // 65, 90 for uppercase
                    $next = ord($login{$i}) + $key;
                    if ($next > 122) {
                        $next -= 26;
                    } elseif ($next < 97) {
                        $next += 26;
                    }
                    $tmp .= chr($next);
                } else {
                    $tmp .= $login{$i};
                }
            }

            return $tmp;
        }

        /**
         * Helper method to create password
         *
         * Method to create a password from a login
         * lowercase only
         *
         * @access private
         * @param  string  Login
         * @param  integer Key
         * @return string
         */
        function _rotxpp($login, $key)
        {
            $tmp = '';
            $login = strtolower($login);

            for ($i = 0; $i < strlen($login); $i++, $key++) {
                if ((ord($login{$i}) >= 97) && (ord($login{$i}) <= 122)) { // 65, 90 for uppercase
                    $next = ord($login{$i}) + $key;
                    if ($next > 122) {
                        $next -= 26;
                    } elseif ($next < 97) {
                        $next += 26;
                    }
                    $tmp .= chr($next);
                } else {
                    $tmp .= $login{$i};
                }
            }

            return $tmp;
        }

        /**
         * Helper method to create password
         *
         * Method to create a password from a login
         * lowercase only
         *
         * @access private
         * @param  string  Login
         * @param  integer Key
         * @return string
         */
        function _rotxmm($login, $key)
        {
            $tmp = '';
            $login = strtolower($login);

            for ($i = 0; $i < strlen($login); $i++, $key--) {
                if ((ord($login{$i}) >= 97) && (ord($login{$i}) <= 122)) { // 65, 90 for uppercase
                    $next = ord($login{$i}) + $key;
                    if ($next > 122) {
                        $next -= 26;
                    } elseif ($next < 97) {
                        $next += 26;
                    }
                    $tmp .= chr($next);
                } else {
                    $tmp .= $login{$i};
                }
            }

            return $tmp;
        }

        /**
         * Helper method to create password
         *
         * Method to create a password from a login
         *
         * @access private
         * @param  string  Login
         * @param  integer Key
         * @return string
         */
        function _asciiRotx($login, $key)
        {
            $tmp = '';

            for ($i = 0; $i < strlen($login); $i++) {
                $next = ord($login{$i}) + $key;
                if ($next > 255) {
                    $next -= 255;
                } elseif ($next < 0) {
                    $next += 255;
                }
                switch ($next) { // delete white space
                case 0x09:
                case 0x20:
                case 0x0A:
                case 0x0D:
                    $next++;
                }
                $tmp .= chr($next);
            }

            return $tmp;
        }

        /**
         * Helper method to create password
         *
         * Method to create a password from a login
         *
         * @access private
         * @param  string  Login
         * @param  integer Key
         * @return string
         */
        function _asciiRotxpp($login, $key)
        {
            $tmp = '';

            for ($i = 0; $i < strlen($login); $i++, $key++) {
                $next = ord($login{$i}) + $key;
                if ($next > 255) {
                    $next -= 255;
                } elseif ($next < 0) {
                    $next += 255;
                }
                switch ($next) { // delete white space
                case 0x09:
                case 0x20:
                case 0x0A:
                case 0x0D:
                    $next++;
                }
                $tmp .= chr($next);
            }

            return $tmp;
        }

        /**
         * Helper method to create password
         *
         * Method to create a password from a login
         *
         * @access private
         * @param  string  Login
         * @param  integer Key
         * @return string
         */
        function _asciiRotxmm($login, $key)
        {
            $tmp = '';

            for ($i = 0; $i < strlen($login); $i++, $key--) {
                $next = ord($login{$i}) + $key;
                if ($next > 255) {
                    $next -= 255;
                } elseif ($next < 0) {
                    $next += 255;
                }
                switch ($next) { // delete white space
                case 0x09:
                case 0x20:
                case 0x0A:
                case 0x0D:
                    $next++;
                }
                $tmp .= chr($next);
            }

            return $tmp;
        }

        /**
         * Helper method to create password
         *
         * Method to create a password from a login
         *
         * @access private
         * @param  string  Login
         * @return string
         */
        function _shuffle($login)
        {
            $tmp = array();

            for ($i = 0; $i < strlen($login); $i++) {
                $tmp[] = $login{$i};
            }

            shuffle($tmp);

            return implode($tmp, '');
        }

        /**
         * Create pronounceable password
         *
         * This method creates a string that consists of
         * vowels and consonats.
         *
         * @access private
         * @param  integer Length of the password
         * @return string  Returns the password
         */
        function _createPronounceable($length)
        {

            $retVal = '';

            /**
             * List of vowels and vowel sounds
             */
            $v = array('a', 'e', 'i', 'o', 'u', 'ae', 'ou', 'io',
                       'ea', 'ou', 'ia', 'ai'
                       );

            /**
             * List of consonants and consonant sounds
             */
            $c = array('b', 'c', 'd', 'g', 'h', 'j', 'k', 'l', 'm',
                       'n', 'p', 'r', 's', 't', 'u', 'v', 'w',
                       'tr', 'cr', 'fr', 'dr', 'wr', 'pr', 'th',
                       'ch', 'ph', 'st', 'sl', 'cl'
                       );

            $v_count = 12;
            $c_count = 29;

            $GLOBALS['_Text_Password_NumberOfPossibleCharacters'] = $v_count + $c_count;

            for ($i = 0; $i < $length; $i++) {
                $retVal .= $c[mt_rand(0, $c_count-1)] . $v[mt_rand(0, $v_count-1)];
            }

            return substr($retVal, 0, $length);
        }

        /**
         * Create unpronounceable password
         *
         * This method creates a random unpronounceable password
         *
         * @access private
         * @param  integer Length of the password
         * @param  string  Character which could be use in the
         *                 unpronounceable password ex : 'ABCDEFG'
         *                 or numeric, alphabetical or alphanumeric.
         * @return string  Returns the password
         */
        function _createUnpronounceable($length, $chars)
        {
            $password = '';

            /**
             * List of character which could be use in the password
             */
             switch($chars) {

             case 'alphanumeric':
                 $chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
                 $GLOBALS['_Text_Password_NumberOfPossibleCharacters'] = 62;
                 break;

             case 'alphabetical':
                 $chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
                 $GLOBALS['_Text_Password_NumberOfPossibleCharacters'] = 52;
                 break;

             case 'numeric':
                 $chars = '0123456789';
                 $GLOBALS['_Text_Password_NumberOfPossibleCharacters'] = 10;
                 break;

             case '':
                 $chars = '_#@%&ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
                 $GLOBALS['_Text_Password_NumberOfPossibleCharacters'] = 67;
                 break;

             default:
                 /**
                  * Some characters shouldn't be used
                  */
                 $chars = trim($chars);
                 $chars = str_replace(array('+', '|', '$', '^', '/', '\', ','), '', $chars);

                 $GLOBALS['_Text_Password_NumberOfPossibleCharacters'] = strlen($chars);
             }

             /**
              * Generate password
              */
             for ($i = 0; $i < $length; $i++) {
                 $num = mt_rand(0, $GLOBALS['_Text_Password_NumberOfPossibleCharacters'] - 1);
                 $password .= $chars{$num};
             }

             /**
              * Return password
              */
             return $password;
        }
    }
?>
Bước 2: Sử dụng phương thức tạo password

<?php
    //include "Password.php";
    $tp = new Text_Password();

    /**
    * delete.all
    * --------------------------------
    * Tạo ngẫu nhiên theo mặc định
    */
    echo '<br>'.$tp->create();

    /**
    * delete.all
    * --------------------------------
    * Tạo ngẫu nhiên với 5 ký tự
    */
    echo '<br>'.$tp->create(5);

    /**
    * delete.all
    * --------------------------------
    * Tạo ngẫu nhiên với 7 ký tự và các ký tự phức tạp hơn
    */
    echo '<br>'.$tp->create(7, 'unpronounceable');

    /**
    * delete.all
    * --------------------------------
    * Tạo ngẫu nhiên với 12 ký tự và các ký tự phức tạp hơn, bao gồm cả chữ và số
    */
    echo '<br>'.$tp->create(12, 'unpronounceable', 'alphanumeric');

    /**
    * delete.all
    * --------------------------------
    * Tạo ngẫu nhiên với 5 ký tự và các ký tự phức tạp hơn, bao gồm các ký tự được định nghĩa trước
    */
    echo '<br>'.$tp->create(5, 'unpronounceable', 'i,j,k,l,m,n,o,p');
?>

Thanh toán:

Trao đổi backlink :
thiet ke website binh duong | thiết kế web tại bình dương |

quang cao google tai binh duong | quang ba web o binh duong |