თუ თქვენ გჭირდებათ თქვენი ვებსაიტის ერთ-ერთი განყოფილება ხელმისაწვდომი გახადოთ შეზღუდული, მაგრამ დაუზუსტებელი ადამიანთა წრეებისთვის, ამის გაკეთების ყველაზე მარტივი გზაა მომხმარებლების რეგისტრაცია და ავტორიზაცია. მომხმარებლების ავტორიზაციის მრავალი გზა არსებობს. თქვენ შეგიძლიათ გამოიყენოთ როგორც ვებ სერვერის ინსტრუმენტები, ასევე პროგრამირების ენის ინსტრუმენტები. ჩვენ ვისაუბრებთ შემთხვევაზე, როდესაც გამოიყენება PHP სესიები.
თქვენ ალბათ გსურთ ნახოთ ამ ფორმის შექმნის უფრო თანამედროვე გზა. მე ჯერ კიდევ არ ვგეგმავ მის სრულად წარდგენას თანამედროვე და შესაბამისი გზით, მაგრამ თქვენ ხედავთ, რომ უკუკავშირის ფორმა შეიძლება შეიქმნას PHP-ში ობიექტზე ორიენტირებული ტექნიკის გამოყენებით.
პირველ რიგში, მოდით განვიხილოთ ყველა ის ნაბიჯი, რომელსაც შემდეგ გადავდგამთ. რა გვჭირდება კიდეც? ჩვენ გვჭირდება სკრიპტი, რომელიც დაარეგისტრირებს მომხმარებელს, ავტორიზაციას გაუწევს მომხმარებელს, ავტორიზაციის შემდეგ სადღაც გადამისამართებს მომხმარებელს. ასევე დაგვჭირდება გვერდის შექმნა, რომელიც დაცული იქნება არაავტორიზებული მომხმარებლების წვდომისგან. რეგისტრაციისა და ავტორიზაციისთვის დაგვჭირდება HTML ფორმების შექმნა. ჩვენ შევინახავთ ინფორმაციას რეგისტრირებული მომხმარებლების შესახებ მონაცემთა ბაზაში. ეს ნიშნავს, რომ ჩვენ ჯერ კიდევ გვჭირდება სკრიპტი DBMS-თან დასაკავშირებლად. მთელი ჩვენი სამუშაო შესრულდება ფუნქციებით, რომლებსაც ჩვენ თვითონ ვწერთ. ჩვენ შევინახავთ ამ ფუნქციებს ცალკე ფაილში.
ასე რომ, ჩვენ გვჭირდება შემდეგი ფაილები:
- კავშირი DBMS-თან;
- საბაჟო ფუნქციები;
- ავტორიზაცია;
- რეგისტრაცია;
- დაცული გვერდი;
- მომხმარებლის გამორთვის სკრიპტი;
- სკრიპტი, რომელიც ამოწმებს მომხმარებლის ავტორიზაციის სტატუსს;
- სტილის ფურცელი ჩვენი გვერდების უმარტივესი დიზაინისთვის.
ეს ყველაფერი უაზრო იქნება, თუ მონაცემთა ბაზაში შესაბამისი ცხრილი არ გექნებათ. გაუშვით თქვენი DBMS მართვის ინსტრუმენტი (PhpMyAdmin ან ბრძანების ხაზი, რომელიც უფრო მოსახერხებელია) და განახორციელეთ მასში შემდეგი მოთხოვნა:
შექმენით ცხრილი `მომხმარებლები` (`id` int(11) NOT NULL AUTO_INCREMENT, `login` char(16) NOT NULL, `პაროლი` char(40) NOT NULL, `reg_date` დროის შტამპი NOT NULL DEFAULT CURRENT_TIMEYSTAMP, PRI id`)) ENGINE=MyISAM DEFAULT CHARSET=utf8 AUTO_INCREMENT=1 ;
მე დავასახელებ ჩვენს სკრიპტის ფაილებს ასე (ისინი ყველა იქნება ერთ დირექტორიაში):
- database.php;
- ფუნქციები.php;
- login.php;
- რეგისტრაცია.php;
- index.php;
- გამოსვლა.php;
- checkAuth.php;
- სტილი.css.
თითოეული მათგანის მიზანი, დარწმუნებული ვარ, თქვენთვის გასაგებია. დავიწყოთ DBMS-თან დაკავშირების სკრიპტით. თქვენ უკვე ნახეთ. უბრალოდ შეინახეთ ამ სკრიპტის კოდი ფაილში, სახელწოდებით database.php. ჩვენ გამოვაცხადებთ მორგებულ ფუნქციებს functions.php ფაილში. როგორ იმუშავებს ეს ყველაფერი? არაავტორიზებული მომხმარებელი ცდილობს შევიდეს დაცულ დოკუმენტზე index.php, სისტემა ამოწმებს ავტორიზებულია თუ არა მომხმარებელი, თუ მომხმარებელი არ არის ავტორიზებული, ის გადამისამართებულია ავტორიზაციის გვერდზე. შესვლის გვერდზე მომხმარებელმა უნდა ნახოს ავტორიზაციის ფორმა. Მოდი გავაკეთოთ ეს.
რეგისტრაცია.
ახლა ჩვენს ფორმას გარკვეული ფორმა უნდა მიეცეს. ამავე დროს, ჩვენ განვსაზღვრავთ წესებს სხვა ელემენტებისთვის. ველოდები წინ, სრულად წარმოგიდგენთ სტილის ფურცლის შინაარსს.
/* style.css ფაილი */ .row ( margin-bottom:10px; width:220px;) .row label ( display:block; font-weight:bold; ) .row input.text (font-size:1.2em; padding:2px 5px;) .to_reg ( font-size:0.9em; ) .instruction (font-size:0.8em; ფერი:#aaaaaa; margin-left:2px; კურსორი:default; ) .error (ფერი:წითელი; ზღვარი მარცხნივ: 3 პიქსელი;)
თუ ყველაფერი სწორად გაკეთდა, ბრაუზერში უნდა გქონდეთ შემდეგი:
რა თქმა უნდა, ჯერ ერთი დარეგისტრირებული მომხმარებელი არ გვყავს და იმისათვის, რომ შეხვიდეთ, უნდა დარეგისტრირდეთ. მოდით გავაკეთოთ სარეგისტრაციო ფორმა.
თქვენ ალბათ შენიშნეთ, რომ HTML კოდში არის PHP ცვლადები. ეს არის ფორმების ტექსტური ველების ატრიბუტების შინაარსი, შეცდომების საჩვენებლად შექმნილი კონტეინერების შიგთავსი. მაგრამ ჩვენ ამ ცვლადების ინიციალიზაცია არ გაგვიკეთებია. Მოდი გავაკეთოთ ეს.
ფორმის ტეგის მოქმედების ატრიბუტში არ არის მითითებული პარამეტრი. ამ შემთხვევაში, ფორმის მონაცემების წარდგენისას, ის დამუშავდება იმავე სკრიპტით, საიდანაც გაიგზავნა. ეს ნიშნავს, რომ ჩვენ უნდა დავწეროთ კოდი, რომელიც ამუშავებს ფორმის მონაცემებს. მაგრამ ჯერ მოდით განვიხილოთ მათი დამუშავების ალგორითმი.
ჩვენ გვჭირდება შესვლისა და პაროლის ველები, რომ არ იყოს ცარიელი. შემდეგ თქვენ უნდა შეამოწმოთ შესვლა მოთხოვნებთან შესაბამისობისთვის. პაროლი ასევე უნდა აკმაყოფილებდეს აღწერილ მოთხოვნებს და ხელახლა მითითებული პაროლი უნდა ემთხვეოდეს მას და გარდა ამისა, ისინი უნდა იყოს იდენტური. თუ რომელიმე ეს პირობა არ არის დაკმაყოფილებული, ფორმის მონაცემების დამუშავება უნდა შეწყდეს, შესაბამისი გაფრთხილება უნდა ჩაიწეროს შეცდომის შეტყობინებების მასივში და ის უნდა იყოს ნაჩვენები მომხმარებლისთვის. მომხმარებლის მოხერხებულობისთვის ჩვენ შევინახავთ მის მიერ შეყვანილ შესვლას (თუ მან მიუთითა) $fields მასივში მისი მნიშვნელობის ჩაწერით.
თუ ყველაფერი კარგადაა, თქვენი ბრაუზერის ფანჯარაში, როდესაც თქვენ შედიხართ register.php დოკუმენტზე, უნდა ნახოთ მსგავსი რამ: 
ახლა, ვთქვათ, მომხმარებელმა დააჭირა რეგისტრაციის ღილაკს და არ შეავსო ფორმის ველები. ჩვენი ალგორითმის მიხედვით, შესვლა და პაროლი არ შეიძლება იყოს ცარიელი. თუ ეს პირობა არ დაკმაყოფილდება, რეგისტრაცია შეუძლებელია. ჩვენ გვახსოვს, რომ ფორმის მონაცემების დამუშავება ხდება მიმდინარე სცენარში. ეს ნიშნავს, რომ ჩვენ უნდა შევცვალოთ მისი კოდი შესაბამისი შემოწმებების დამატებით. მოდით დაუყოვნებლივ განვიხილოთ შემდეგი შემოწმებები. თუ თქვენ შეიტანეთ როგორც შესვლა, ასევე პაროლი, უნდა შეამოწმოთ მათი შესაბამისობა მითითებულ მოთხოვნებთან. შესვლისა და პაროლის დასადასტურებლად ჩვენ შევქმნით საბაჟო ფუნქციებს functions.php ფაილში.
/** * functions.php * ფაილი მორგებული ფუნქციებით */ // დააკავშირეთ ფაილი დაკავშირების პარამეტრებით DBMS-თან require_once("database.php"); // მომხმარებლის სახელის ფუნქციის შემოწმება checkLogin($str) ( // ცვლადის ინიცირება შესაძლო შეცდომის შეტყობინებით $error = ""; // თუ შესვლის ხაზი აკლია, დააბრუნეთ შეცდომის შეტყობინება if(!$str) ( $error = "თქვენ არ შეიყვანეთ მომხმარებლის სახელი"; დააბრუნეთ $error; ) /** * შეამოწმეთ მომხმარებლის სახელი რეგულარული გამონათქვამების გამოყენებით * შესვლა არ უნდა იყოს 4-ზე ნაკლები, არა უმეტეს 16 სიმბოლოზე * ის უნდა შეიცავდეს ლათინური ანბანის სიმბოლოებს, რიცხვები, * შეიძლება შეიცავდეს სიმბოლოებს "_", "-", "." */ $pattern = "/^[-_.a-z\d](4,16)$/i"; $result = preg_match ($pattern, $str) ; // თუ შემოწმება ვერ მოხერხდა, დააბრუნეთ შეცდომის შეტყობინება if(!$result) ( $error = "არასწორი სიმბოლოები მომხმარებლის სახელში ან მომხმარებლის სახელი ძალიან მოკლეა (გრძელი)"; დააბრუნეთ $error; ) // თუ ყველაფერი კარგადაა, დააბრუნეთ მნიშვნელობა true return true; ) // მომხმარებლის პაროლის ფუნქციის შემოწმება checkPassword($str) ( // ცვლადის ინიცირება შესაძლო შეცდომის შეტყობინებით $error = ""; // თუ არსებობს შესვლის ხაზი არ არის, დააბრუნეთ შეცდომის შეტყობინება if(!$ str) ( $error = "თქვენ არ შეიყვანეთ პაროლი"; დაბრუნება $error; ) /** * შეამოწმეთ მომხმარებლის პაროლი რეგულარული გამონათქვამების გამოყენებით * პაროლი არ უნდა იყოს 6-ზე მოკლე, არაუმეტეს 16 სიმბოლოზე * ის უნდა შეიცავდეს ლათინურ სიმბოლოებს, რიცხვებს, * შეიძლება შეიცავდეს სიმბოლოებს "_", "!", " (", ")" */ $pattern = "/^[_!)(.a-z\d](6,16)$/i"; $result = preg_match($pattern, $str); // თუ შემოწმება არ გავიდა, დააბრუნეთ შეცდომის შეტყობინება if(!$result) ( $error = "არასწორი სიმბოლოები მომხმარებლის პაროლში ან პაროლი ძალიან მოკლეა (გრძელი)"; დააბრუნეთ $error; ) // თუ ყველაფერი კარგადაა, დააბრუნეთ მნიშვნელობა true აბრუნებს true;)
ახლა ჩვენ უნდა შევცვალოთ register.php ფაილი, რათა ჩართოთ ჩვენ მიერ გამოცხადებული ფუნქციები. სკრიპტს დავამატებთ პირობას, რომელიც ამოწმებს არის თუ არა დაჭერილი რეგისტრაციის ღილაკი. ამ პირობის ფარგლებში იწყება შესვლისა და პაროლების შემოწმება. თუ რომელიმე შემოწმება ვერ მოხერხდა, ჩვენ კვლავ ვაჩვენებთ ფორმას და ვაჩვენებთ შეცდომის შეტყობინებას. თუ შეცდომები არ არის, ვარეგისტრირებთ მომხმარებელს, აღარ ვაჩვენებთ სარეგისტრაციო ფორმას, ვაცნობთ მომხმარებელს წარმატებული რეგისტრაციის შესახებ და header() ფუნქციის გამოყენებით გადავიყვანთ ავტორიზაციის ფორმაზე.
თქვენ წარმატებით დარეგისტრირდით სისტემაში. ახლა თქვენ გადამისამართდებით შესვლის გვერდზე. თუ ეს არ მოხდა, გადადით მასზე პირდაპირი ბმულის გამოყენებით.
"; header("განახლება: 5; URL = login.php"); ) // წინააღმდეგ შემთხვევაში შეატყობინეთ მომხმარებელს სხვა შეცდომის შესახებ ($errors["full_error"] = $reg; ) ) ) ?>სკრიპტში კიდევ ერთი ახალი ფუნქცია უნდა გენახათ - register(). მაგრამ ჩვენ ჯერ არ გამოგვიცხადებია. Მოდი გავაკეთოთ ეს.
// მომხმარებლის რეგისტრაციის ფუნქციის რეგისტრაცია ($login, $password) ( // ცვლადის ინიცირება შესაძლო შეცდომის შეტყობინებით $error = ""; // თუ არ არის შესვლის ხაზი, დააბრუნეთ შეცდომის შეტყობინება if(!$login) ( $error = "შესვლა არ არის მითითებული"; return $error; ) elseif(!$password) ( $error = "პაროლი არ არის მითითებული"; return $error; ) // შეამოწმეთ თუ მომხმარებელი უკვე დარეგისტრირებულია // დაკავშირება DBMS connect() ; // დაწერეთ შეკითხვის string $sql = "SELECT `id` FROM `users` WHERE `login`="" . $login . """; // შეკითხვის გაკეთება მონაცემთა ბაზაში $query = mysql_query ($sql) ან die( ""); // ჩვენ ვუყურებთ ამ შესვლის მომხმარებელთა რაოდენობას, თუ არის ერთი მაინც, // ვაბრუნებთ შეცდომის შეტყობინებას if(mysql_num_rows($query) > 0) ($error = "მითითებული შესვლის მომხმარებელი უკვე დარეგისტრირებულია"; დააბრუნეთ $ შეცდომა; ) // თუ ასეთი მომხმარებელი არ არის, დაარეგისტრირეთ // ჩაწერეთ შეკითხვის string $sql = "INSERT INTO `users` (`id`,` login`,`password`) VALUES (NULL, "" . $login . " ","" . $პაროლი. "")"; // შეიტანეთ მოთხოვნა მონაცემთა ბაზაში $query = mysql_query($sql) ან die("
მომხმარებლის დამატება შეუძლებელია: " . mysql_error() . ". შეცდომა მოხდა ხაზში " . __LINE__ ."
"); // არ დაგავიწყდეთ გათიშოთ DBMS-დან mysql_close(); // დააბრუნეთ მნიშვნელობა true, რაც მიუთითებს მომხმარებლის წარმატებული რეგისტრაციის დაბრუნებაზე true; )თუ ყველაფერი კარგადაა, თქვენი მომხმარებელი დარეგისტრირდება. შეგიძლიათ შეამოწმოთ ფორმა. სცადეთ დაარეგისტრიროთ მომხმარებლები იგივე ლოგინებით. წარმატებული რეგისტრაციის შემდეგ, მომხმარებელი გადამისამართდება ავტორიზაციის ფორმაზე. ადრე ჩვენ უბრალოდ შევქმენით მარკირება ამ ფორმის საჩვენებლად. ვინაიდან მის ქმედების ატრიბუტში არ არის მითითებული პარამეტრი, ფორმის მიერ წარმოდგენილი მონაცემები დამუშავდება იმავე სკრიპტით. ეს ნიშნავს, რომ ჩვენ უნდა დავწეროთ კოდი დამუშავებისთვის და დავამატოთ იგი login.php დოკუმენტში.
თუ სისტემაში არ ხართ რეგისტრირებული, დარეგისტრირდით.
თქვენ ალბათ შენიშნეთ, რომ ავტორიზაციის სკრიპტში ახლა გვაქვს კიდევ ერთი უცნობი ფუნქცია - autorization(). ეს ფუნქცია უნდა აძლევდეს მომხმარებლის ავტორიზაციას, ჯერ შეამოწმეთ არის თუ არა რეგისტრირებული მომხმარებელი იგივე შესვლისა და პაროლით მონაცემთა ბაზაში. თუ ასეთი მომხმარებელი ვერ მოიძებნა, ავტორიზაცია გაუქმდება და გამოჩნდება წარუმატებლობის შეტყობინება. თუ შემოწმება წარმატებულია, ავტორიზაციის() ფუნქცია დაიწყებს სესიას და ჩაწერს მასში მომხმარებლის შესვლისა და პაროლის მნიშვნელობებს, აცნობებს სკრიპტს, რომ ავტორიზაცია წარმატებული იყო და სკრიპტი მომხმარებელს გადამისამართებს დაცულ რესურსის გვერდზე.
/ ** * მომხმარებლის ავტორიზაციის ფუნქცია. * მომხმარებლის ავტორიზაცია განხორციელდება * PHP სესიების გამოყენებით. */ ფუნქციის ავტორიზაცია ($login, $password) ( // ცვლადის ინიციალიზაცია შესაძლო შეცდომის შეტყობინებით $error = ""; // თუ არ არის შესვლის ხაზი, დააბრუნეთ შეცდომის შეტყობინება if(!$login) ( $error = " შესვლა არ არის მითითებული"; return $error; ) elseif(!$password) ( $error = "პაროლი არ არის მითითებული"; return $error; ) // შეამოწმეთ თუ მომხმარებელი უკვე დარეგისტრირებულია // დაკავშირება DBMS Connect( ); // ჩვენ უნდა შევამოწმოთ არის თუ არა ასეთი მომხმარებელი რეგისტრირებულთა შორის // შეადგინეთ შეკითხვის string $sql = "SELECT `id` FROM `users` WHERE `login`="".$login."" AND ` პაროლი`="".$პაროლი ."""; // შეასრულეთ მოთხოვნა $query = mysql_query($sql) ან die("
შეკითხვის შესრულება შეუძლებელია: " . mysql_error() . ". შეცდომა მოხდა ხაზში " . __LINE__ ."
"); // თუ მომხმარებელი არ არის ასეთი მონაცემებით, დააბრუნეთ შეცდომის შეტყობინება if(mysql_num_rows($query) == 0) ($error = "მომხმარებელი მითითებული მონაცემებით არ არის რეგისტრირებული"; დააბრუნეთ $error; ) // თუ მომხმარებელი არსებობს, დაიწყეთ სესია session_start(); // და ჩაწერეთ მასში მომხმარებლის შესვლა და პაროლი // ამისთვის ვიყენებთ სუპერგლობალურ მასივს $_SESSION $_SESSION["login"] = $login; $_SESSION[ "პაროლი"] = $პაროლი; / / არ დაგავიწყდეთ დახუროთ კავშირი მონაცემთა ბაზასთან mysql_close(); // დააბრუნეთ true, რათა მიუთითოთ წარმატებული მომხმარებლის ავტორიზაციის დაბრუნება true; )როდესაც მომხმარებელი ეშვება დაცულ გვერდზე, თქვენ უნდა შეამოწმოთ მისი ავტორიზაციის მონაცემების სისწორე. ამისათვის ჩვენ გვჭირდება სხვა მორგებული ფუნქცია. მოდით დავარქვათ checkAuth() . მისი ამოცანა იქნება მომხმარებლის ავტორიზაციის მონაცემების გადამოწმება ჩვენს მონაცემთა ბაზაში შენახულებთან. თუ მონაცემები არ ემთხვევა, მომხმარებელი გადამისამართდება შესვლის გვერდზე.
ფუნქცია checkAuth($login, $password) ( // თუ არ არის შესვლა ან პაროლი, დააბრუნეთ false if(!$login || !$password) return false; // შეამოწმეთ არის თუ არა ასეთი მომხმარებელი რეგისტრირებული // დაკავშირება DBMS connect(); // შეადგინეთ შეკითხვის სტრიქონი $sql = "SELECT `id` FROM `users` WHERE `login`="".$login."" AND `password`="".$პაროლი.""" ; // შეასრულეთ მოთხოვნა $ query = mysql_query ($sql) ან die ("
შეკითხვის შესრულება შეუძლებელია: " . mysql_error() . ". შეცდომა მოხდა ხაზში " . __LINE__ ."
"); // თუ ასეთი მონაცემებით მომხმარებელი არ არის, დააბრუნეთ false; if(mysql_num_rows($query) == 0) ( return false; ) // არ დაგავიწყდეთ დახუროთ კავშირი მონაცემთა ბაზასთან mysql_close(); // წინააღმდეგ შემთხვევაში დააბრუნეთ ჭეშმარიტი დაბრუნება true;)ახლა, როდესაც მომხმარებელი მივიდა დაცულ გვერდზე, ჩვენ უნდა გამოვიძახოთ ფუნქცია ავტორიზაციის მონაცემების შესამოწმებლად. ჩვენ განვათავსებთ ზარის და გადამოწმების სკრიპტს ცალკე checkAuth.php ფაილში და დავაკავშირებთ მას იმ გვერდებთან, რომლებიც დაიხურება საზოგადოებისთვის.
/** * მომხმარებლის ავტორიზაციის შემოწმების სკრიპტი */ // დაიწყეთ სესია, საიდანაც ამოვიღებთ ავტორიზებული მომხმარებლების შესვლას და პაროლს session_start(); // დააკავშირეთ ფაილი მორგებული ფუნქციებით require_once("functions.php"); /** * იმის დასადგენად, არის თუ არა მომხმარებელი ავტორიზებული, საჭიროა * შევამოწმოთ არის თუ არა მონაცემთა ბაზაში ჩანაწერები მისი შესვლის * და პაროლისთვის. ამისათვის ჩვენ გამოვიყენებთ მორგებულ ფუნქციას *, რათა შევამოწმოთ შესული მომხმარებლის მონაცემების სისწორე. * თუ ეს ფუნქცია დააბრუნებს false-ს, მაშინ ავტორიზაცია არ არის. * თუ ავტორიზაცია არ არის, ჩვენ უბრალოდ გადამისამართებთ * მომხმარებელს ავტორიზაციის გვერდზე. */ // თუ სესია შეიცავს როგორც შესვლის, ასევე პაროლის მონაცემებს, // შეამოწმეთ ისინი if(isset($_SESSION["login"]) && $_SESSION["login"] && isset($_SESSION["პაროლი" ]) && $_SESSION["პაროლი"]) ( // თუ არსებული მონაცემების შემოწმება ვერ მოხერხდა, if(!checkAuth($_SESSION["login"], $_SESSION["პაროლი"])) ( // გადამისამართეთ მომხმარებელი შესვლის გვერდის სათაურზე( "location: login.php"); // შეაჩერე სკრიპტის გასასვლელის შესრულება; ) ) // თუ არ არის მონაცემები მომხმარებლის შესვლის ან პაროლის შესახებ, // ჩვენ ვვარაუდობთ, რომ არ არის ავტორიზაცია, ჩვენ გადამისამართებთ მომხმარებელს // ავტორიზაციის გვერდზე სხვა ( header ("location: login.php"); // შეაჩერე სკრიპტის გასვლის შესრულება; )
ახლა მოდით შევქმნათ კოდი ჩვენი უსაფრთხო გვერდისთვის. ეს საკმაოდ მარტივი იქნება.
წარმატებული ავტორიზაცია.
თქვენ შეხვედით უსაფრთხო გვერდზე. შეგიძლიათ გამოხვიდეთ.
როგორც ხედავთ, დაცულ დოკუმენტში ჩვენ შევიტანთ მხოლოდ ერთ ფაილს - checkAuth.php. ყველა სხვა ფაილი დაკავშირებულია სხვა სკრიპტებში. ამიტომ, ჩვენი კოდი არ გამოიყურება რთული. ჩვენ მოვაწყვეთ მომხმარებლების რეგისტრაცია და ავტორიზაცია. ახლა თქვენ უნდა მისცეთ მომხმარებლებს გასვლის უფლება. ამისათვის ჩვენ შევქმნით სკრიპტს logout.php ფაილში.
/ ** * მომხმარებლის გამოსვლის სკრიპტი. ვინაიდან მომხმარებლები * შედიან სესიების მეშვეობით, მათი შესვლა და პაროლი * ინახება $_SESSION სუპერგლობალურ მასივში. სისტემიდან * გასასვლელად, უბრალოდ გაანადგურეთ $_SESSION["login"] და $_SESSION["პაროლი"] მასივის * მნიშვნელობები, რის შემდეგაც ჩვენ * გადავიყვანთ მომხმარებელს შესვლის გვერდზე */ // Be აუცილებლად დაიწყებთ სესიას session_start(); unset($_SESSION["შესვლა"]); unset($_SESSION["პაროლი"]); header ("location: login.php");
მომხმარებლის რეგისტრაციის, ავტორიზაციის და გადამოწმების სკრიპტი მზად არის. თქვენ შეგიძლიათ გამოიყენოთ იგი თქვენთვის, შეავსოთ იგი, შეცვალოთ იგი თქვენს საჭიროებებზე. თუ თქვენ გაქვთ რაიმე შეკითხვები, შეგიძლიათ დასვათ ისინი კომენტარებში. თქვენ შეგიძლიათ ჩამოტვირთოთ აქ განხილული ყველა ფაილი, შეფუთული ერთ არქივში.
P.S. ვიცი, რომ ობიექტზე ორიენტირებული კოდის დაწერა ჯობია, ვიცი, რომ არ ღირს პაროლის მკაფიო ტექსტში გადაცემა და შენახვა, რომ მონაცემთა ბაზაში შეტანილი ინფორმაცია წინასწარ უნდა შემოწმდეს. Მე ვიცი. ამაზე აქ არ ვისაუბრებ.
გამარჯობა! ახლა ჩვენ შევეცდებით განვახორციელოთ საიტზე უმარტივესი რეგისტრაცია PHP + MySQL გამოყენებით. ამისათვის Apache უნდა იყოს დაინსტალირებული თქვენს კომპიუტერში. ჩვენი სკრიპტის მუშაობის პრინციპი ნაჩვენებია ქვემოთ.
1. დავიწყოთ მონაცემთა ბაზაში მომხმარებლების ცხრილის შექმნით. ის შეიცავს მომხმარებლის მონაცემებს (შესვლა და პაროლი). მოდით გადავიდეთ phpmyadmin-ზე (თუ თქვენ ქმნით მონაცემთა ბაზას თქვენს კომპიუტერზე http://localhost/phpmyadmin/). შექმენით ცხრილი მომხმარებლები, მას ექნება 3 ველი.
მე ვქმნი mysql მონაცემთა ბაზაში, შეგიძლიათ შექმნათ სხვა მონაცემთა ბაზაში. შემდეგი, დააყენეთ მნიშვნელობები, როგორც ფიგურაში:
2. საჭიროა ამ ცხრილთან დაკავშირება.მოდით შევქმნათ ფაილი bd.php. მისი შინაარსი:
$db = mysql_connect("თქვენი MySQL სერვერი","შესვლა ამ სერვერზე","პაროლი ამ სერვერისთვის");
mysql_select_db ("ბაზის სახელი, რომელსაც ვუკავშირდებით", $db);
?>
ჩემს შემთხვევაში ასე გამოიყურება:
$db = mysql_connect("localhost","user","1234");
mysql_select_db("mysql",$db);
?>
Გადარჩენა bd.php.
დიდი! მონაცემთა ბაზაში გვაქვს ცხრილი და მასთან კავშირი. ახლა თქვენ შეგიძლიათ დაიწყოთ გვერდის შექმნა, რომელზეც მომხმარებლები დატოვებენ თავიანთ მონაცემებს.
3. შექმენით reg.php ფაილი შინაარსით (ყველა კომენტარი შიგნით):
რეგისტრაცია
4. შექმენით ფაილი, რომელიც შეიტანს მონაცემებს მონაცემთა ბაზაში და შეინახავს მომხმარებელს. save_user.php(კომენტარები შიგნით):
{
}
//თუ შესვლა და პაროლი შეყვანილია, მაშინ ჩვენ ვამუშავებთ მათ ისე, რომ ტეგები და სკრიპტები არ იმუშაოს, თქვენ არასოდეს იცით, რა შეიძლება შეიყვანონ ხალხმა
//დამატებითი ადგილების ამოღება
$login = trim($login);
$პაროლი = მორთვა ($პაროლი);
// დაკავშირება მონაცემთა ბაზასთან
// შეამოწმეთ მომხმარებლის არსებობის იგივე შესვლა
$result = mysql_query("SELECT id FROM users WHERE login="$login"",$db);
თუ (! ცარიელი ($myrow["id"])) (
exit("ბოდიში, თქვენ მიერ შეყვანილი შესვლა უკვე რეგისტრირებულია. გთხოვთ შეიყვანოთ სხვა შესვლა.");
}
// თუ ეს ასე არ არის, მაშინ შეინახეთ მონაცემები
$result2 = mysql_query ("INSERT INTO მომხმარებლებს (შესვლა, პაროლი) VALUES ("$login","$პაროლი")");
// შეამოწმეთ არის თუ არა შეცდომები
თუ ($result2=="TRUE")
{
echo "თქვენ წარმატებით დარეგისტრირდით! ახლა შეგიძლიათ შეხვიდეთ საიტზე. მთავარი გვერდი";
}
სხვა (
echo "შეცდომა! თქვენ არ ხართ დარეგისტრირებული.";
}
?>
5. ახლა ჩვენს მომხმარებლებს შეუძლიათ რეგისტრაცია!შემდეგი, თქვენ უნდა შექმნათ "კარი" უკვე დარეგისტრირებული მომხმარებლებისთვის საიტზე შესასვლელად. index.php(კომენტარები შიგნით) :
// მთელი პროცედურა მუშაობს სესიებში. ეს არის სადაც მომხმარებლის მონაცემები ინახება საიტზე ყოფნისას. ძალიან მნიშვნელოვანია მათი გაშვება გვერდის დასაწყისში!!!
session_start();
?>
მთავარი გვერდი
// შეამოწმეთ, არის თუ არა შესვლის და მომხმარებლის ID ცვლადები ცარიელი
თუ (ცარიელი ($_SESSION["შესვლა"]) ან ცარიელი ($_SESSION["id"]))
{
// თუ ცარიელია, მაშინ ჩვენ არ ვაჩვენებთ ბმულს
echo "თქვენ შესული ხართ როგორც სტუმარი
ეს ბმული ხელმისაწვდომია მხოლოდ დარეგისტრირებული მომხმარებლებისთვის";
}
სხვა
{
ფაილში index.phpჩვენ გამოვაჩენთ ბმულს, რომელიც ღია იქნება მხოლოდ დარეგისტრირებული მომხმარებლებისთვის. ეს არის სკრიპტის მთელი აზრი - შეზღუდოს წვდომა ნებისმიერ მონაცემზე.
6. რჩება ფაილი შეყვანილი შესვლისა და პაროლის გადამოწმებით. testreg.php (კომენტარები შიგნით):
session_start();// მთელი პროცედურა მუშაობს სესიებზე. ეს არის სადაც მომხმარებლის მონაცემები ინახება საიტზე ყოფნისას. ძალიან მნიშვნელოვანია მათი გაშვება გვერდის დასაწყისში!!!
if (isset($_POST["login"])) ($login = $_POST["login"]; if ($login == "") ( unset($login);) ) //შეიყვანეთ ავტორის მიერ შეყვანილი შესვლა მომხმარებელი შევიდა $login ცვლადში, თუ ის ცარიელია, მაშინ გაანადგურეთ ცვლადი
if (isset($_POST["პაროლი"])) ($პაროლი=$_POST["პაროლი"]; if ($password =="") ( გაუქმება ($პაროლი);) )
//ჩადეთ მომხმარებლის მიერ შეყვანილი პაროლი $password ცვლადში, თუ ის ცარიელია, გაანადგურეთ ცვლადი
თუ (ცარიელი($login) ან ცარიელი($პაროლი)) //თუ მომხმარებელმა არ შეიყვანა შესვლა ან პაროლი, მაშინ ჩვენ გამოვცდებით შეცდომას და ვაჩერებთ სკრიპტს
{
exit ("თქვენ არ შეიყვანეთ ყველა ინფორმაცია, დაბრუნდით და შეავსეთ ყველა ველი!");
}
//თუ შესვლა და პაროლი შეყვანილია, მაშინ ჩვენ ვამუშავებთ მათ ისე, რომ ტეგები და სკრიპტები არ იმუშაოს, თქვენ არასოდეს იცით, რა შეიძლება შეიყვანონ ხალხმა
$login = stripslashes ($login);
$login = htmlspecialchars($login);
$პაროლი = stripslashes ($პაროლი);
$პაროლი = htmlspecialchars($პაროლი);
//დამატებითი ადგილების ამოღება
$login = trim($login);
$პაროლი = მორთვა ($პაროლი);
// დაკავშირება მონაცემთა ბაზასთან
include("bd.php");// bd.php ფაილი უნდა იყოს იმავე საქაღალდეში, როგორც ყველა სხვა, თუ არ არის, უბრალოდ შეცვალეთ გზა
$result = mysql_query("SELECT * FROM users WHERE login="$login"",$db); //ამოიღეთ მონაცემთა ბაზიდან მომხმარებლის შესახებ ყველა მონაცემი შეყვანილი ლოგინით
$myrow = mysql_fetch_array ($ შედეგი);
თუ (ცარიელი ($myrow["პაროლი"]))
{
//თუ მომხმარებელი შეყვანილი ლოგინით არ არსებობს
}
სხვა (
//თუ არსებობს, მაშინ შეამოწმეთ პაროლები
თუ ($myrow["პაროლი"]==$პაროლი) (
//თუ პაროლები ემთხვევა, მაშინ ჩვენ ვიწყებთ სესიას მომხმარებლისთვის! შეგიძლიათ მიულოცოთ, ის შევიდა!
$_SESSION["login"]=$myrow["login"];
$_SESSION["id"]=$myrow["id"];//ეს მონაცემები გამოიყენება ძალიან ხშირად, ასე რომ, შესული მომხმარებელი "გაატარებს მას"
echo "თქვენ წარმატებით შეხვედით საიტზე! მთავარ გვერდზე";
}
სხვა (
//თუ პაროლები არ ემთხვევა
გასვლა ("ბოდიში, თქვენ მიერ შეყვანილი შესვლა ან პაროლი არასწორია.");
}
}
?>
კარგი, ახლა ყველაფერი დასრულდა! გაკვეთილი შეიძლება იყოს მოსაწყენი, მაგრამ ძალიან სასარგებლო. აქ ნაჩვენებია მხოლოდ რეგისტრაციის იდეა, შემდეგ შეგიძლიათ გააუმჯობესოთ იგი: დაამატეთ დაცვა, დიზაინი, მონაცემთა ველები, ავატარების ჩატვირთვა, ანგარიშიდან გასვლა (ამისთვის უბრალოდ გაანადგურეთ ცვლადები სესიიდან ფუნქციით. დაუყენებელი) და ასე შემდეგ. Წარმატებები!
ყველაფერი შევამოწმე, მუშაობს გამართულად!
წევრობაზე დაფუძნებული საიტის შექმნა თავიდან რთული ამოცანაა. თუ თქვენ ოდესმე გინდოდათ ამის გაკეთება დამოუკიდებლად, მაშინ დანებდით, როდესაც დაიწყეთ ფიქრი, თუ როგორ აპირებთ ამის გაერთიანებას თქვენი PHP უნარების გამოყენებით, მაშინ ეს სტატია თქვენთვისაა. ჩვენ ვაპირებთ გაგაცნობთ წევრობაზე დაფუძნებული საიტის შექმნის ყველა ასპექტს, პაროლით დაცული წევრების უსაფრთხო ზონით.
მთელი პროცესი შედგება ორი დიდი ნაწილისგან: მომხმარებლის რეგისტრაცია და მომხმარებლის ავტორიზაცია. პირველ ნაწილში ჩვენ ვაპირებთ სარეგისტრაციო ფორმის შექმნას და მონაცემთა MySQL მონაცემთა ბაზაში შენახვას. მეორე ნაწილში ჩვენ შევქმნით შესვლის ფორმას და გამოვიყენებთ მომხმარებლებს უსაფრთხო ზონაში წვდომის საშუალებას.
ჩამოტვირთეთ კოდი
რეგისტრაციის/შესვლის სისტემის სრული კოდის ჩამოტვირთვა შეგიძლიათ ქვემოთ მოცემული ბმულიდან:
კონფიგურაცია და ატვირთვა
ReadMe ფაილი შეიცავს დეტალურ ინსტრუქციებს.
Გააღე source\include\membersite_config.phpშეიყვანეთ ტექსტურ რედაქტორში და განაახლეთ კონფიგურაცია. (მონაცემთა ბაზის შესვლა, თქვენი ვებსაიტის სახელი, თქვენი ელექტრონული ფოსტის მისამართი და ა.შ.).
ატვირთეთ მთელი დირექტორია შინაარსი. შეამოწმეთ register.php ფორმის გაგზავნით.
სარეგისტრაციო ფორმა
მომხმარებლის ანგარიშის შესაქმნელად საჭიროა მომხმარებლისგან მინიმალური რაოდენობის ინფორმაციის შეგროვება. ჩვენ გვჭირდება მისი სახელი, მისი ელექტრონული ფოსტის მისამართი და სასურველი მომხმარებლის სახელი და პაროლი. რა თქმა უნდა, ამ ეტაპზე შეგვიძლია მოვითხოვოთ მეტი ინფორმაცია, მაგრამ გრძელი ფორმა ყოველთვის გამორთვაა. ამიტომ შემოვიფარგლოთ მხოლოდ იმ სფეროებით.
აქ არის რეგისტრაციის ფორმა:
ასე რომ, ჩვენ გვაქვს ტექსტური ველები სახელის, ელ.ფოსტისა და პაროლისთვის. გაითვალისწინეთ, რომ ჩვენ ვიყენებთ უკეთესი გამოყენებისთვის.
ფორმის დადასტურება
ამ ეტაპზე კარგი იდეაა შევიტანოთ რაიმე ფორმის ვალიდაციის კოდი, ასე რომ, ჩვენ დავრწმუნდებით, რომ გვაქვს ყველა საჭირო მონაცემი მომხმარებლის ანგარიშის შესაქმნელად. ჩვენ უნდა შევამოწმოთ არის თუ არა სახელი და ელ. ფოსტა და პაროლი შევსებული და არის თუ არა ელფოსტა სათანადო ფორმატში.
ფორმის წარდგენის დამუშავება
ახლა ჩვენ უნდა დავამუშაოთ წარდგენილი ფორმის მონაცემები.
აქ არის თანმიმდევრობა (იხილეთ ფაილი fg_membersite.php გადმოწერილ წყაროში):
ფუნქცია RegisterUser() ( if(!isset($_POST["გამოგზავნილია"])) ( return false; ) $formvars = array(); if(!$this->ValidateRegistrationSubmission()) ( return false; ) $this- >CollectRegistrationSubmission($formvars); if(!$this->SaveToDatabase($formvars)) ( return false; ) if(!$this->SendUserConfirmationEmail($formvars)) ( return false; ) $this->SendAdminIntimationEmail($ formvars); დაბრუნება true;)
პირველ რიგში, ჩვენ ვამოწმებთ ფორმის გაგზავნას. შემდეგ ვაგროვებთ და „ვასუფთავებთ“ ფორმის წარდგენის მონაცემებს (ეს ყოველთვის გააკეთეთ ელფოსტის გაგზავნამდე, მონაცემთა ბაზაში შენახვამდე და ა.შ.). ფორმის წარდგენის შემდეგ ინახება მონაცემთა ბაზაში. ჩვენ ვუგზავნით ელ.წერილს მომხმარებელს დადასტურების მოთხოვნით. შემდეგ ჩვენ ვაცნობთ ადმინს, რომ მომხმარებელი დარეგისტრირდა.
მონაცემთა ბაზაში შენახვა
ახლა, როდესაც ჩვენ შევიკრიბეთ ყველა მონაცემი, უნდა შევინახოთ იგი მონაცემთა ბაზაში.
აი, როგორ ვინახავთ ფორმის წარდგენის მონაცემთა ბაზაში.
ფუნქცია SaveToDatabase(&$formvars) ( if(!$this->DBLlogin()) ( $this->HandleError("მონაცემთა ბაზის შესვლა ვერ მოხერხდა!"); return false; ) if(!$this->Ensuretable()) ( return false; ) if(!$this->IsFieldUnique($formvars,"email")) ($this->HandleError("ეს ელფოსტა უკვე დარეგისტრირებულია"); return false; ) if(!$this->IsFieldUnique( $formvars,"username")) ( $this->HandleError ("ეს მომხმარებლის სახელი უკვე გამოიყენება. გთხოვთ, სცადოთ სხვა მომხმარებლის სახელი"); დააბრუნეთ false; ) if(!$this->InsertIntoDB($formvars)) ($this- >HandleError ("მონაცემთა ბაზაში ჩასმა ვერ მოხერხდა!"); დაბრუნება false; ) დაბრუნება true; )
გაითვალისწინეთ, რომ თქვენ დააკონფიგურირეთ მონაცემთა ბაზის შესვლის დეტალები Memberite_config.php ფაილში. უმეტეს შემთხვევაში, შეგიძლიათ გამოიყენოთ "localhost" მონაცემთა ბაზის ჰოსტისთვის.
შესვლის შემდეგ ვრწმუნდებით, რომ ცხრილი არსებობს.(თუ არა, სკრიპტი შექმნის საჭირო ცხრილს).
შემდეგ ჩვენ დავრწმუნდებით, რომ მომხმარებლის სახელი და ელფოსტა უნიკალურია. თუ ის უნიკალური არ არის, შეცდომას ვუბრუნებთ მომხმარებელს.
მონაცემთა ბაზის ცხრილის სტრუქტურა
ეს არის მაგიდის სტრუქტურა. CreateTable() ფუნქცია fg_membersite.php ფაილში ქმნის ცხრილს. აქ არის კოდი:
function CreateTable() ( $qry = "შექმენით ცხრილი $this->tablename (". "id_user INT NOT NULL AUTO_INCREMENT ," "სახელი VARCHAR(128) NOT NULL ," "ელფოსტა VARCHAR(64) NOT NULL," " "ტელეფონის_ნომერი VARCHAR(16) NOT NULL ," "username VARCHAR(16) NOT NULL ," "პაროლი VARCHAR(32) NOT NULL ," "დაადასტურეთ კოდი VARCHAR(32)", "PRIMARY KEY (id_user)." ")"; if(( !mysql_query($qry,$this->კავშირი)) ($this->HandleDBError("შეცდომა ცხრილის შექმნისას \nშეკითხვა იყო\n$qry"); დაბრუნება false; ) დაბრუნება true; )
id_user ველი შეიცავს მომხმარებლის უნიკალურ id-ს და ასევე არის ცხრილის ძირითადი გასაღები. გაითვალისწინეთ, რომ ჩვენ დავუშვებთ 32 სიმბოლოს პაროლის ველში. ჩვენ ამას ვაკეთებთ იმიტომ, რომ უსაფრთხოების დამატებითი ზომაა, ჩვენ ვინახავთ პაროლს მონაცემთა ბაზაში დაშიფრული MD5-ის გამოყენებით. გთხოვთ გაითვალისწინოთ, რომ იმის გამო, რომ MD5 არის ცალმხრივი დაშიფვრის მეთოდი, ჩვენ ვერ შევძლებთ პაროლის აღდგენას იმ შემთხვევაში, თუ მომხმარებელი დაივიწყებს მას.
რეგისტრაციის ჩასმა მაგიდაზე
აქ არის კოდი, რომელსაც ვიყენებთ მონაცემთა ბაზაში ჩასასმელად. ჩვენ გვექნება ყველა მონაცემი ხელმისაწვდომი $formvars მასივში.
ფუნქცია InsertIntoDB(&$formvars) ($confirmcode = $this->MakeConfirmationMd5($formvars["email"]); $insert_query = "insert into ".$this->tablename."(სახელი, ელფოსტა, მომხმარებლის სახელი, პაროლი, დადასტურების კოდი) მნიშვნელობები ("" . $this->SanitizeForSQL($formvars["name"]). "", "" . $this->SanitizeForSQL($formvars["email"]) . "", "" $ this->SanitizeForSQL($formvars["მომხმარებლის სახელი"]) . "", "" . md5($formvars["პაროლი"]) . "", "" . $confirmcode . "")"; if(! mysql_query ( $insert_query ,$this->connection)) ( $this->HandleDBError("შეცდომა ცხრილში მონაცემთა ჩასმისას\nquery:$insert_query"); დაბრუნება false; ) return true; )
გაითვალისწინეთ, რომ ჩვენ ვიყენებთ PHP ფუნქციას md5() პაროლის დაშიფვრად მონაცემთა ბაზაში ჩასმამდე.
ასევე, ჩვენ ვაკეთებთ უნიკალურ დადასტურების კოდს მომხმარებლის ელ.ფოსტის მისამართიდან.
ელფოსტის გაგზავნა
ახლა, როდესაც ჩვენ გვაქვს რეგისტრაცია ჩვენს მონაცემთა ბაზაში, ჩვენ გამოგიგზავნით დადასტურების ელ.წერილს მომხმარებელს. მომხმარებელმა უნდა დააჭიროს ბმულს დამადასტურებელ ელფოსტაში რეგისტრაციის პროცესის დასასრულებლად.
ფუნქცია SendUserConfirmationEmail(&$formvars) ($mailer = new PHPMailer(); $mailer->CharSet = "utf-8"; $mailer->AddAddress($formvars["email"],$formvars["name"]) $mailer->Subject = "თქვენი რეგისტრაცია ".$this->sitename; $mailer->From = $this->GetFromAddress(); $confirmcode = urlencode($this->MakeConfirmationMd5($formvars["email" ])); $confirm_url = $this->GetAbsoluteURLFolder()."/confirmreg.php?code=".$confirmcode; $mailer->Body ="გამარჯობა.$formvars["name"]."\r\ n\r\n". "გმადლობთ რეგისტრაციისთვის ".$this->sitename."\r\n". "გთხოვთ დააწკაპუნოთ ქვემოთ მოცემულ ბმულზე თქვენი რეგისტრაციის დასადასტურებლად.\r\n." "$confirm_url\r \n". "\r\n". "პატივისცემით,\r\n". "Webmaster\r\n". $this->sitename; if(!$mailer->Send()) ($this-> HandleError ("რეგისტრაციის დამადასტურებელი ელ. ფოსტის გაგზავნა ვერ მოხერხდა."); დაბრუნება false; ) დაბრუნება true; )
განახლებები
2012 წლის 9 იანვარი
პაროლის აღდგენა/პაროლის შეცვლა ფუნქციები დაემატა
კოდი ახლა გაზიარებულია GitHub-ზე.
Კეთილი იყოს თქვენი დაბრუნებაUserFullName(); ?>!
ლიცენზია
კოდი გაზიარებულია LGPL ლიცენზიით. მისი გამოყენება თავისუფლად შეგიძლიათ კომერციულ თუ არაკომერციულ ვებსაიტებზე.
არ არის დაკავშირებული პოსტები.
კომენტარები ამ ჩანაწერზე დახურულია.
ბოლოს შეცვლილია 2019 წლის 23 ივლისს ვინსის მიერ.
მომხმარებლის რეგისტრაცია ან დარეგისტრირება მრავალი ვებ აპლიკაციის განუყოფელი ნაწილია და მნიშვნელოვანია მისი სწორად მიღება აპლიკაციის წარმატებისთვის. ეს არის თქვენი აპლიკაციასთან მომხმარებლის ჩართულობის საწყისი წერტილი.
ეს უნდა იყოს რაც შეიძლება მარტივი საუკეთესო UI / UX-ით. მომხმარებლის რეგისტრაციის ფუნქციის დანერგვა PHP-ის გამოყენებით მარტივი ამოცანაა და მე გაგაცნობთ ამ სტატიაში მოცემულ მაგალითებს.
რა არის შიგნით?
როგორ მუშაობს PHP მომხმარებლის რეგისტრაციის მაგალითი?
ეს მაგალითი კოდი შეიძლება დაიყოს 3 ნაწილად.
- მომხმარებლის ინფორმაციის მიღება HTML ფორმის საშუალებით.
- მომხმარებლის მიერ წარმოდგენილი ინფორმაციის გადამოწმება ფორმის გაგზავნაზე.
- მონაცემთა ბაზის დამუშავება რეგისტრირებული მომხმარებლის მონაცემთა ბაზაში გადასარჩენად ვალიდაციის შემდეგ.
მესამე ნაბიჯი შესრულდება მას შემდეგ, რაც დავრწმუნდებით, რომ მომხმარებელი უკვე არ არის დამატებული. ეს მონაცემთა უნიკალურობის ვალიდაცია განხორციელდება მათ მიერ შეყვანილი ელფოსტისა და მომხმარებლის სახელის საფუძველზე.
რეგისტრაციის დროს ჩვენ ზოგადად ვაგროვებთ მომხმარებლის ინფორმაციას, რომლებიც მზად არიან დარეგისტრირდნენ ჩვენს აპლიკაციაში. ზოგიერთი მათგანი იქნება სავალდებულო, ნაწილი კი არჩევითი.
ასე რომ, ეს ფუნქცია შეიძლება ასევე შეიცავდეს ვალიდაციის ნაწილს, რათა უზრუნველყოს მომხმარებლის მონაცემების სიცარიელე და ფორმატი. დადასტურება შეიძლება განხორციელდეს კლიენტის ან სერვერის მხარეს.
სერვერის მხარეს ვალიდაცია ყოველთვის უკეთესია. თქვენ შეგიძლიათ აირჩიოთ ის კლიენტის მხარეს, ასევე მომხმარებლების მოხერხებულობისთვის. მაგრამ სერვერის მხარეს ყოფნა არ არის სურვილისამებრ და მინიმალური მოთხოვნაა.
ფაილის სტრუქტურა
HTML ფორმა, რომელიც საშუალებას აძლევს მომხმარებელს დარეგისტრირდეს
ამ მაგალითში რეგისტრაციის ფორმა შეიცავს ველებს მომხმარებლის სახელი, სახელი (საჩვენებელი სახელი), პაროლი და ელფოსტა. მას ასევე აქვს პაროლის დადასტურების ველი, რომელიც მომხმარებელს საშუალებას აძლევს ხელახლა შეიყვანოს პაროლი დადასტურებისთვის. ამ ორი პაროლის შედარება მოგვიანებით მოხდება .
ამ ფორმის გაგზავნით, მომხმარებელი ეთანხმება პირობებს. ასე რომ, ჩამრთველი ველი ემატება რეგისტრაციის ღილაკამდე მის უზრუნველსაყოფად.
და სტილებია,
ტექსტი ( font-family: Arial; ფერი: #333; font-size: 0.95em; ) .form-head (ფერი: #191919; font-weight: normal; font-weight: 400; margin: 0; text-align : ცენტრი; შრიფტის ზომა: 1.8em;) .error-message ( padding: 7px 10px; ფონი: #fff1f2; კონტური: #ffd5da 1px მყარი; ფერი: #d6001c; საზღვრის რადიუსი: 4px; ზღვარი: 30px 10px 0p ; ). #ffffff; საზღვრების დაშორება: საწყისი; ზღვარი: 15 პიქსელი ავტო; სიტყვა-შესვენება: წყვეტა-სიტყვა; ცხრილის განლაგება: ავტომატური; ხაზის სიმაღლე: 1.8 მ; ფერი: #333; საზღვრის რადიუსი: 4 პიქსელი; შიგთავსი : 20px 40px; სიგანე: 380px; კონტური: 1px მყარი; საზღვრის ფერი: #e5e6e9 #dfe0e4 #d0d1d5; ) .demo-table .label (ფერი: #888888; ) .demo-table .pding-colum 1 0px; ) .demo-input-box ( padding: 13px; კონტური: #CCC 1px მყარი; საზღვრის რადიუსი: 4px; სიგანე: 100%; ) .btnრეგისტრაცია ( padding: 13px; background-color: #5d9cec; ფერი: #f5f7fa; კურსორი: მაჩვენებელი; საზღვარი-რადიუსი: 4px; სიგანე: 100%; საზღვარი: #5791da 1px მყარი; შრიფტის ზომა: 1.1em; ) .response-text (მაქსიმალური სიგანე: 380 პიქსელი; შრიფტის ზომა: 1.5 ემ; ტექსტის გასწორება: ცენტრში; ფონი: #fff3de; შიგთავსი: 42 პიქსელი; საზღვრის რადიუსი: 3 პიქსელი; საზღვარი: #f5e9d4 1 პიქსელი; მყარი შრიფტი-ოჯახი : arial; ხაზის სიმაღლე: 34px; ზღვარი: 15px ავტო; ) .ტერმინები (ზღვარი-ქვედა: 5px; )
როგორ გადავამოწმოთ მომხმარებლის ინფორმაცია ფორმის გაგზავნაზე
ამ მაგალითში დამატებულია სერვერის ფორმის ვალიდაციის სკრიპტი მომხმარებლის რეგისტრაციის მონაცემების დასადასტურებლად. ეს PHP ვალიდაციის სკრიპტი გამოიძახება რეგისტრაციის ფორმის გაგზავნისას.
ეს სკრიპტი ამოწმებს ფორმის ყველა ველს, რათა შეამოწმოს თითოეული ველის სიცარიელე. შემდეგ ის ამოწმებს მომხმარებლის ელფოსტის ფორმატს PHP filter_var() ფუნქციის გამოყენებით.
ვინაიდან რეგისტრაცია მოიცავს პაროლის დადასტურების ფუნქციას, პაროლის შედარება მოხდება ამ მაგალითის ამ ნაწილში.
დაბოლოს, ვალიდაციის სკრიპტი შეამოწმებს, ეთანხმება თუ არა მომხმარებელი ტერმინსა და პირობებს ფორმის შესაბამისი ველის შემოწმებით.
მას შემდეგ რაც ყველა ვალიდაცია დასრულდება ლოგიკური ჭეშმარიტების დაბრუნებით, მაშინ მოხდება ფაქტობრივი რეგისტრაციის პროცესი.
ფუნქცია validateMember() ($valid = true; $errorMessage = array(); foreach ($_POST როგორც $key => $value) (if (ცარიელი($_POST[$key])) ($valid = false; ) ) if($valid == true) (if ($_POST["პაროლი"] != $_POST["confirm_password"]) ($errorMessage = "პაროლი უნდა იყოს იგივე."; $valid = false; ) if (! isset ($error_message)) ( if (! filter_var ($_POST["userEmail"], FILTER_VALIDATE_EMAIL)) ( $errorMessage = "არასწორი ელფოსტის მისამართი."; $valid = false; ) ) if (! isset( $error_message)) ( if (! isset($_POST["terms"])) ( $errorMessage = "მიიღეთ პირობები და პირობები."; $valid = false; ) ) ) else ($errorMessage = "ყველა ველი სავალდებულოა. "; ) if ($valid == false) ( return $errorMessage; ) დაბრუნება; )
PHP MySQL კოდი მონაცემთა ბაზაში შესასვლელად რეგისტრირებული მომხმარებლის შესანახად
სერვერის მხრიდან მომხმარებლის ფორმის ვალიდაცია
ეს არის PHP შესვლის წერტილი, რომელიც ამუშავებს სერვერის მხარეს არსებულ ყველა სკრიპტს ფორმის დასადასტურებლად და მონაცემთა ბაზის ოპერაციების დასამუშავებლად, ვალიდაციის შედეგის საფუძველზე.
validateMember ($username, $displayName, $password, $email); if (ცარიელი($errorMessage)) ( $memberCount = $member->isMemberExists($username, $email); if ($memberCount == 0) ( $insertId = $member->insertMemberRecord($username, $displayName, $ პაროლი, $email); if (! ცარიელი ($insertId)) ( header ("მდებარეობა: thankyou.php"); ) ) else ($errorMessage = "მომხმარებელი უკვე არსებობს."; ) ) ) ?>
შეამოწმეთ, არის თუ არა მომხმარებელი უკვე
isMemberExists() ფუნქცია გამოიყენება მომხმარებლის მონაცემების უნიკალურობის შესამოწმებლად მათი ელფოსტისა და მომხმარებლის სახელის საფუძველზე. თუ იქ შეყვანილი მომხმარებლის სახელი ან ელფოსტა არსებობს მომხმარებლის მონაცემთა ბაზაში, მაშინ რეგისტრაციის პროცესი შეჩერდება დაბრუნებით და დადასტურებით.
ეს აღიარება აცნობებს, რომ "მომხმარებელი უკვე არსებობს". კოდი არის
ფუნქცია isMemberExists($username, $email) ( $query = "select * FROM registered_users WHERE user_name = ? OR email = ?"; $paramType = "ss"; $paramArray = მასივი ($username, $email); $memberCount = $this->ds->numRows ($query, $paramType, $paramArray); დააბრუნეთ $memberCount;)
ჩადეთ წევრის მონაცემები მონაცემთა ბაზაში
თუ ის დააბრუნებს 0-ს, ეს ნიშნავს, რომ ასეთი მომხმარებლები არ არსებობენ შეყვანილი ელ. ფოსტით ან მომხმარებლის სახელით. ასე რომ, რეგისტრაციის მონაცემები შეიტანება მონაცემთა ბაზაში. შემდეგი კოდი გვიჩვენებს წევრის ჩასმის მეთოდს.
ფუნქცია insertMemberRecord($username, $displayName, $password, $email) ( $passwordHash = md5($password); $query = "INSERT INTO registered_users (user_name, display_name, პაროლი, ელფოსტა) VALUES (?, ?, ?, ? $paramType = "ssss"; $paramArray = მასივი ($username, $displayName, $passwordHash, $email); $insertId = $this->ds->insert($query, $paramType, $paramArray); დააბრუნეთ $insertId;)
DataSource.php
ეს არის მონაცემთა წყაროს ზოგადი კლასი PHP-ში მონაცემთა ბაზის ოპერაციების შესასრულებლად. იგი მოიცავს ფუნქციებს მონაცემთა ბაზის დასაკავშირებლად და სხვადასხვა მოთხოვნების შესასრულებლად მონაცემთა ბაზის შედეგის მისაღებად, მწკრივების დათვლის, ჩასმის შესასრულებლად და სხვა.
მონაცემთა წყაროს ეს კლასი ზოგადია და რაც შეიძლება მარტივია. ის ეფექტურია და მე მას ვიყენებ ჩემს უმეტესობაში მიკრო პროექტებსა და გაკვეთილებში. თქვენ თავისუფლად შეგიძლიათ ჩამოტვირთოთ და გამოიყენოთ იგი.
მნიშვნელოვანი ის არის არასოდეს დაგავიწყდეთ მომზადებული განცხადებების გამოყენება. ის გეხმარებათ დაიცვათ SQL ინექციის შეტევები და ეს არის პირველი ნაბიჯი ვებ აპლიკაციაში უსაფრთხოების განხორციელების თვალსაზრისით.
conn = $this->getConnection(); ) /** * თუ საჭიროა კავშირის ობიექტი, გამოიყენეთ ეს მეთოდი და მიიღეთ წვდომა მასზე. * წინააღმდეგ შემთხვევაში, გამოიყენეთ ქვემოთ მოცემული მეთოდები ჩასართავად / განახლებისთვის / და ა.შ. * * @return \mysqli */ საჯარო ფუნქცია getConnection() ($conn = new \mysqli(self::HOST, self::USERNAME, self::PASSWORD, self::DATABASENAME); if (mysqli_connect_errno()) (trigger_error ("ბაზებთან დაკავშირების პრობლემა."); ) $conn->set_charset("utf8"); დაბრუნება $conn; ) /** * მონაცემთა ბაზის შედეგების მისაღებად * @param string $query * @param string $paramType * @ პარამ მასივი $paramArray * @return მასივი */ საჯარო ფუნქცია აირჩიეთ($query, $paramType="", $paramArray=array()) ($stmt = $this->conn->prepare($query); if(! ცარიელი ($paramType) && !empty($paramArray)) ($this->bindQueryParams($sql, $paramType, $paramArray); ) $stmt->execute();$result = $stmt->get_result(); if ($result->num_rows > 0) ( while ($row = $result->fetch_assoc()) ( $resultset = $row; ) ) if (! ცარიელი ($resultset)) ( return $resultset; ) ) / ** * * @param string $query * @param string $paramType * @param მასივი $paramArray * @return int */ საჯარო ფუნქციის ჩასმა ($query, $paramType, $paramArray) ($query) ჩასმა; $stmt = $this->conn->prepare($query); $this->bindQueryParams($stmt, $paramType, $paramArray); $stmt->execute(); $insertId = $stmt->insert_id; დაბრუნება $insertId; ) /** * შეკითხვის შესასრულებლად * @param string $query * @param string $paramType * @param array $paramArray */ საჯარო ფუნქციის შესრულება($query, $paramType="", $paramArray=array()) ( $ stmt = $this->conn->prepare($query); if(!empty($paramType) && !empty($paramArray)) ($this->bindQueryParams($stmt, $paramType="", $paramArray= array()); ) $stmt->execute(); ) /** * 1. ამზადებს პარამეტრის დაკავშირებას * 2. პარამეტრების მიბმა sql განცხადებაში * @param string $stmt * @param string $paramType * @param მასივი $ paramArray */ საჯარო ფუნქცია bindQueryParams($stmt, $paramType, $paramArray=array()) ( $paramValueReference = & $paramType; for ($i = 0; $i< count($paramArray); $i ++) { $paramValueReference = & $paramArray[$i]; } call_user_func_array(array($stmt, "bind_param"), $paramValueReference); } /** * To get database results * @param string $query * @param string $paramType * @param array $paramArray * @return array */ public function numRows($query, $paramType="", $paramArray=array()) { $stmt = $this->conn->prepare($query); if(!empty($paramType) && !empty($paramArray)) ($this->bindQueryParams($stmt, $paramType, $paramArray); ) $stmt->execute(); $stmt->store_result(); $recordCount = $stmt->num_rows; დაბრუნება $recordCount; ))
მონაცემთა ბაზის სკრიპტი
მონაცემთა ბაზის ამ სკრიპტს აქვს შექმნის განაცხადი registered_users ცხრილისთვის. შემოიტანეთ ეს სკრიპტი თქვენს განვითარების გარემოში ამ კოდის გასაშვებად.
ცხრილის სტრუქტურა `რეგისტრირებული_მომხმარებლებისთვის` -- შექმენით ცხრილი, თუ არ არსებობს `რეგისტრირებული_მომხმარებლები` (`id` int(8) NOT NULL AUTO_INCREMENT, `user_name` varchar(255) NOT NULL, `first_name` varchar(255) NOT NULL, last_name` varchar(255) NOT NULL, `პაროლი` varchar(25) NOT NULL, `ელფოსტა` varchar(55) NOT NULL, `გენდერი` varchar(20) NOT NULL, PRIMARY KEY (`id`));
თუ სარეგისტრაციო ფორმის ვალიდაცია ვერ მოხერხდა, მაშინ შეცდომის შესახებ შეტყობინება გამოჩნდება მომხმარებლისთვის, როგორც ქვემოთ.
კომენტარები „PHP მომხმარებლის რეგისტრაციის ფორმაზე (დარეგისტრირება) MySQL მონაცემთა ბაზით“
გამარჯობა ვინსი, მე მივიღებ შემდეგ შეცდომებს რეგისტრაციის კოდის გაშვებისას, გთხოვთ დამეხმაროთ.
INSERT INTO registered_users (user_name, display_name, password, email) VALUES (?, ?, ?, ?)
გაფრთხილება: call_user_func_array() მოელის, რომ პარამეტრი 1 იქნება სწორი გამოძახება, პირველი მასივის წევრი არ არის სწორი კლასის სახელი ან ობიექტი C:\xampp\htdocs\PHP\JAMII-CASH\DataSource.php 136 ხაზზე.
საბედისწერო შეცდომა: დაუკავებელი შეცდომა: წევრის ფუნქციის execute() გამოძახება ლოგიკურზე C:\xampp\htdocs\PHP\JAMII-CASH\DataSource.php:99 დასტას კვალი: #0 C:\xampp\htdocs\PHP\JAMII -CASH\Member.php(83): Phppot\DataSource->insert('INSERT INTO reg...', 'ssss', Array) #1 C:\xampp\htdocs\PHP\JAMII-CASH\index.php (20 ): Phppot\Member->insertMemberRecord('chuki10', 'Ray', '202020', 'raf.yah.s.1@gma...') #2 (მთავარი) გადაყრილი C:\xampp\htdocs\ PHP\ JAMII-CASH\DataSource.php 99 ხაზზე
საიტზე მომხმარებლების რეგისტრაციისა და ავტორიზაციის ფუნქცია ხორციელდება შემდეგნაირად: როდესაც მომხმარებელი დარეგისტრირდება საიტზე, ის ავსებს სარეგისტრაციო ფორმას, რომელშიც მიუთითებს სხვადასხვა მონაცემებს, მათ შორის ლოგინს და პაროლს. ფორმა აგზავნის ამ მონაცემებს სერვერზე და იწერება მონაცემთა ბაზაში.
- მომხმარებელი ავტორიზაციის ფორმაში შეაქვს შესვლას და პაროლს და უგზავნის სერვერს.
- სერვერი ამოწმებს არის თუ არა მონაცემთა ბაზაში მომხმარებელი იგივე შესვლისა და პაროლით.
- თუ მომხმარებელი იპოვეს, ამის შესახებ ინფორმაცია ჩაიწერება სესიაში ან ქუქიში.
- საიტის გვერდებზე კეთდება შემოწმება, შეიცავს თუ არა სესია მონაცემებს, რომლითაც მომხმარებელი ავტორიზებულია და, აქედან გამომდინარე, გვერდი ამა თუ იმ ფორმით არის ნაჩვენები.
სესიაზე, თქვენ შეგიძლიათ არა მხოლოდ მიუთითოთ ავტორიზაციის ფაქტი, არამედ ჩაწეროთ მომხმარებლის ზოგიერთი მონაცემი გვერდზე გამოსატანად, მაგალითად, სახელი ან მეტსახელი. გადაწყვეტილება იმის შესახებ, გამოვიყენოთ თუ არა სესიები ან ქუქიები, მიიღება საიტის მიხედვით. თუ საიტი შეიცავს მნიშვნელოვან ინფორმაციას, მაშინ უმჯობესია გამოიყენოთ სესიები, რადგან ბევრად უფრო რთულია სხვისი რეგისტრაციის მონაცემების გარკვევა.
ავტორიზაციისა და რეგისტრაციის ფორმები
ავტორიზაციის ფორმა ჩვეულებრივ მდებარეობს მთავარ გვერდზე, ან შეიძლება იყოს საიტის ყველა გვერდზე. ძირითადად, ცალკე გვერდი იქმნება სარეგისტრაციო ფორმისთვის. ჩვენ შევქმნით მხოლოდ ერთ გვერდს, რომელიც შეიცავს ორივე ფორმას და მასზე გამოჩნდება მომხმარებლის მონაცემები. ამ დროისთვის ის შეიცავს მხოლოდ HTML კოდს, მაგრამ ჩვენ დაუყოვნებლივ შევქმნით PHP ფაილს, რადგან მომავალში ეს იქნება სკრიპტი. მოდით ვუწოდოთ მას formreg.php. გვერდის კოდი იქნება ასეთი:
formreg.php:
რეგისტრაცია
ჩვენ ჩავწერთ მომხმარებლის რეგისტრაციის მონაცემებს მომხმარებლების ცხრილში. თუ ჯერ არ გაქვთ ასეთი ცხრილი, შექმენით იგი. ის უნდა შეიცავდეს ველებს id, login და pas. ჩვენ არ გამოვიყენებთ სხვა ველებს. თუ ისინი ცხრილში არიან, ცარიელი დარჩებიან.
register.php:
3 |
$login=$_POST["შესვლა"]; $pas=$_POST["პაროლი"]; $db=mysqli_connect("localhost", "root", "", "mybase"); $query="INSERT INTO users (login, pas) VALUES ("$login", "$pas""); $result=mysqli_query($db, $query); if ($result) header("Location: formreg.php"); mysqli_close ($db); |
მე-9 სტრიქონზე დავაყენეთ ის, რომ დაბრუნდეს ფორმების გვერდზე. ვინაიდან სკრიპტის შესრულება და გვერდის გადატვირთვა ძალიან სწრაფად ხდება ლოკალურ სერვერზე, ვიზუალურად ისე გამოიყურება, თითქოს არაფერი ხდება, როდესაც დააჭირეთ ღილაკს "რეგისტრაცია". რეალურ საიტებზე, ისინი ჩვეულებრივ გადადიან სპეციალურ გვერდზე, სადაც მოცემულია ინფორმაცია, რომ მომხმარებელი რეგისტრირებულია და რეგისტრაციის მონაცემები. სცადეთ შესვლა და ნახეთ თუ არა ახალი ჩანაწერები მონაცემთა ბაზაში.
ავტორიზაცია
ავტორიზაციის ფორმა სერვერზე აწარმოებს autorization.php ფაილს. ეს სკრიპტი იღებს შესვლას და ძირითად როლს და ამოწმებს არსებობს თუ არა ასეთი მომხმარებელი. თუ არსებობს, მაშინ შესვლა ჩაიწერება სესიაზე. თუ ასეთი მომხმარებელი ვერ მოიძებნა, ამის შესახებ ინფორმაცია ჩაიწერება სესიაზე. ეს აუცილებელია იმისთვის, რომ გვერდი, რომელიც გაიხსნება სკრიპტის შესრულების შემდეგ, მიიღებს ამ ინფორმაციას და აჩვენებს შეტყობინებას არასწორი შესვლის ან პაროლის შეყვანის შესახებ. სკრიპტის კოდი ასეთია:
autorization.php:
3 | session_start(); $login=$_POST["შესვლა"]; $pas=$_POST["პაროლი"]; $db=mysqli_connect("localhost", "root", "", "mybase"); $query="SELECT * FROM users WHERE login="$login" AND BINARY pass="$pas""; $result=mysqli_query($db, $query); if (mysqli_num_rows($result)) $_SESSION["login"]=$login; else $_SESSION["login"]="er შესვლა"; header ("Location: formreg.php"); mysqli_close ($db); |
მე-7 სტრიქონში გენერირებულია მოთხოვნა ფორმიდან მიღებული შესვლისა და პაროლით ხაზის ასარჩევად. საკვანძო სიტყვა BINARY იწერება pas ველის წინ. საჭიროა ისე, რომ ამ ველის გამოყენებით შედარებისას გათვალისწინებული იყოს სიმბოლოების შემთხვევა. თუ თქვენ გჭირდებათ საქმის გათვალისწინება შესვლის შედარებისას, მაშინ BINARY უნდა დაიწეროს მის წინ. მაგალითი ითხოვს ყველა ველის არჩევას. პრაქტიკაში შეგიძლიათ აირჩიოთ მხოლოდ ის ველები, რომელთა მონაცემების ჩვენება დაგჭირდებათ გვერდზე.
შედეგის მიღების შემდეგ მოწმდება არის თუ არა მითითებული ჩანაწერი ნაპოვნი. თუ არის ჩანაწერი, მაშინ შესვლა ჩაიწერება სესიაზე. თუ მომხმარებელი ვერ მოიძებნა, მაშინ შესვლის ნაცვლად იწერება სტრიქონი „er login“. თქვენ შეგიძლიათ დაწეროთ სხვა ტექსტი, მაგრამ დარწმუნებული უნდა იყოთ, რომ ის არ ემთხვევა არცერთ შესვლას. შემდეგ უბრუნდებით გვერდზე ფორმებით.
საიტის გვერდები უნდა შეიცავდეს კოდს, რომელიც ამოწმებს არის თუ არა შესვლა სესიაზე. და აქედან გამომდინარე, განისაზღვრება, თუ როგორ უნდა გამოიყურებოდეს გვერდი. ჩვენს მაგალითში მხოლოდ ერთი გვერდია. ჩვენ ჩავატარებთ მასზე ტესტს. მხოლოდ კოდი დაიყოფა ორ ნაწილად. სესია უნდა გაიხსნას რაიმე მონაცემის გამოტანამდე, ანუ HTML კოდის წინ. ამიტომ, ეს ნაწილი მდებარეობს გვერდის დასაწყისში. და დანარჩენი კოდი არის ტეგის შიგნით
, რადგან ის ამატებს გვერდს კონტენტს. დაამატეთ შემდეგი ხაზი გვერდის ზედა ნაწილში:თუ სესიაზე შესვლაა, მაგრამ ის შეიცავს ხაზს „er login“, მაშინ გამოჩნდება შეტყობინება, რომ შესვლა ან პაროლი არასწორია. შეტყობინების ჩვენების შემდეგ, შესვლა ცარიელი ხდება. ეს კეთდება ისე, რომ შეტყობინება გამოჩნდეს მხოლოდ ერთხელ და არ გამოჩნდეს სხვა გვერდებზე გადასვლისას. თუ შესვლა განსხვავებულია, მაშინ მომხმარებელი ავტორიზებულია და გვერდი იქმნება როგორც რეგისტრირებული მომხმარებლებისთვის. თუ შესვლა არ არის, მაშინ ჯერ არ ყოფილა ავტორიზაცია და გვერდი ნაჩვენებია დაურეგისტრირებელი მომხმარებლებისთვის.
ჩვენ განვიხილეთ მხოლოდ სარეგისტრაციო და ავტორიზაციის ფუნქციის შექმნის ზოგადი პრინციპი. რეალურ საიტებზე ეს უფრო რთულია. ფორმები უნდა იყოს ნაჩვენები მხოლოდ არაავტორიზებული მომხმარებლებისთვის. გარდა ამისა, თქვენ უნდა დაამატოთ ღილაკი "გასვლა", რომელიც აუქმებს ავტორიზაციას. რეგისტრაციისას თქვენ უნდა შეამოწმოთ ფორმა, შეამოწმოთ შესვლის უნიკალურობა და დაამატოთ პაროლის დადასტურება.