ფაილებთან მუშაობა php-ში: გახსნა, წერა, კითხვა. Php შექმენით ფაილი, წაიკითხეთ და დაწერეთ Php მონაცემების მიღება ფაილიდან

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

თუ თქვენ მუშაობთ ადგილობრივად თქვენს კომპიუტერზე, შეგიძლიათ თავად დააყენოთ უფლებები: დააწკაპუნეთ მაუსის მარჯვენა ღილაკით საქაღალდეზე და აირჩიეთ "თვისებები". უმეტეს ვებ მასპინძლებზე ჩვეულებრივ არის მხოლოდ ერთი საქაღალდე ჩაწერის ნებართვით. მას ხშირად უწოდებენ "cgi-bin", "log", "databases" და ა.შ. თუ თქვენი ვებ ჰოსტი ამის საშუალებას იძლევა, შეგიძლიათ თავად დააყენოთ უფლებები. ჩვეულებრივ, შეგიძლიათ დააწკაპუნოთ მარჯვენა ღილაკით თქვენს FTP კლიენტის საქაღალდეზე და აირჩიოთ "თვისებები" ან "ნებართვები" ან მსგავსი რამ. ქვემოთ მოყვანილი სკრინშოტი აჩვენებს, როგორ გამოიყურება FileZilla-ში.

აგრეთვე იხილეთ თქვენი ვებ მასპინძლების მხარდაჭერის გვერდები.

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

ტექსტური ფაილის გახსნა დასაწერად

როგორც ტექსტური ფაილის წაკითხვისას, ფუნქცია გამოიყენება წერისას, მაგრამ ამჯერად რეჟიმი დაყენებულია "w" (ჩაწერა) ან "a" (დამატება).

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

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

ჯერ ვცადოთ ამ ტექსტური ფაილის გახსნა ჩასაწერად:

// გახსენით ტექსტური ფაილი // ტექსტური ფაილის დახურვა fclose($f); ?>

მაგალითი 1: ტექსტურ ფაილში სტრიქონის ჩაწერა

სტრიქონის დასაწერად უნდა გამოვიყენოთ ფუნქცია:

<span>ტექსტურ ფაილში ჩაწერა</span> // გახსენით ტექსტური ფაილი $f = fopen("textfile.txt", "w"); // ტექსტის სტრიქონის დაწერა fwrite ($f, "PHP არის სახალისო!"); // ტექსტური ფაილის დახურვა fclose($f); echo fgets($f); fclose($f); ?>

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

მაგალითი 2: ტექსტის ბლოკის დამატება ტექსტურ ფაილში

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

<span>ტექსტურ ფაილში ჩაწერა</span> // გახსენით ტექსტური ფაილი $f = fopen("textfile.txt", "w"); // ტექსტის დაწერა fwrite($f, $_POST["ტექსტის ბლოკი"]); // ტექსტური ფაილის დახურვა fclose($f); // გახსენით ფაილი წასაკითხად და წაიკითხეთ სტრიქონი $f = fopen("textfile.txt", "r");// წაიკითხეთ ტექსტი echo fgets($f); fclose($f); ?>

შემდეგ გაკვეთილებში ჩვენ განვიხილავთ მონაცემთა შენახვის სხვა გზას: მონაცემთა ბაზებს.

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

ფუნქცია fopen ()არსებობს რამდენიმე რეჟიმი, რომლითაც იხსნება ფაილები, აქ არის მათი ცხრილი:

fopen()-ისთვის შესაძლო რეჟიმების სია
რეჟიმი აღწერა
'რ' ხსნის ფაილს მხოლოდ წასაკითხად; ათავსებს მაჩვენებელს ფაილის დასაწყისში.
'r+' ხსნის ფაილს კითხვისა და წერისთვის; ათავსებს მაჩვენებელს ფაილის დასაწყისში.
"ვ" ხსნის ფაილს მხოლოდ ჩასაწერად; ათავსებს მაჩვენებელს ფაილის დასაწყისში და წყვეტს ფაილს ნულოვან სიგრძეზე. თუ ფაილი არ არსებობს, ის ცდილობს მის შექმნას.
'w+' ხსნის ფაილს კითხვისა და წერისთვის; ათავსებს მაჩვენებელს ფაილის დასაწყისში და წყვეტს ფაილს ნულოვან სიგრძეზე. თუ ფაილი არ არსებობს, ის ცდილობს მის შექმნას.
"ა" ხსნის ფაილს მხოლოდ ჩასაწერად; ათავსებს მაჩვენებელს ფაილის ბოლოს. თუ ფაილი არ არსებობს, ის ცდილობს მის შექმნას. ამ რეჟიმში ფუნქცია fseek ()არ გამოიყენება, ჩანაწერები ყოველთვის ემატება.
'a+' ხსნის ფაილს კითხვისა და წერისთვის; ათავსებს მაჩვენებელს ფაილის ბოლოს. თუ ფაილი არ არსებობს, ის ცდილობს მის შექმნას. ამ რეჟიმში ფუნქცია fseek ()გავლენას ახდენს მხოლოდ წაკითხვის ადგილმდებარეობაზე, ჩანაწერები ყოველთვის ემატება.
'x' ქმნის და ხსნის მხოლოდ წერისთვის; ათავსებს მაჩვენებელს ფაილის დასაწყისში. თუ ფაილი უკვე არსებობს, დარეკეთ fopen ()მარცხით მთავრდება, დაბრუნდება ცრუდა მისცემს დონის შეცდომას E_გაფრთხილება. თუ ფაილი არ არსებობს, ის შეეცდება მის შექმნას. ეს დროშების მითითების ტოლფასია O_EXCL|O_CREATშიდა სისტემის ზარისთვის ღია (2).
'x+' ქმნის და ხსნის კითხვისა და წერისთვის; წინააღმდეგ შემთხვევაში აქვს იგივე ქცევა, რაც 'x'.
"გ" ხსნის ფაილს მხოლოდ ჩასაწერად. თუ ფაილი არ არსებობს, ის იქმნება. თუ ფაილი არსებობს, მაშინ ის არ არის შეკვეცილი (განსხვავებით "ვ"), და ამ ფუნქციის გამოძახება არ იწვევს შეცდომას (როგორც ეს ხდება 'x'). ფაილის მაჩვენებელი დაყენდება ფაილის დასაწყისში. ეს შეიძლება სასარგებლო იყოს, თუ გსურთ ფაილის ჩაკეტვა (იხ ფარა ()) შეცვლამდე, გამოყენების დღიდან "ვ"შეუძლია ფაილის შეკვეცა დაბლოკვის მიღებამდე (თუ გსურთ ფაილის შეკვეცა, შეგიძლიათ გამოიყენოთ ფუნქცია ftruncate ()დაბლოკვის მოთხოვნის შემდეგ).
'c+' ხსნის ფაილს კითხვისა და წერისთვის; წინააღმდეგ შემთხვევაში აქვს იგივე ქცევა, რაც "გ".

თქვენ შეგიძლიათ დაამატოთ კიდევ ორი ​​მნიშვნელობა რეჟიმს:
ბ- ფაილი იხსნება ორობით რეჟიმში
ტ- ფაილი იხსნება ტექსტის სახით

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

"; else echo "მონაცემების ჩაწერა ვერ მოხერხდა!
"; //ფაილის დახურვა fclose($file); ) ფუნქცია fileread($filename)( //გზა ფაილისკენ $path = "files/".$filename.".txt"; //გახსენით ფაილი წასაკითხად $file = fopen($path,"r"); // თუ ფაილი წარმატებით გაიხსნა if($file)( // შემდეგ სანამ ფაილი ბოლომდე არ მიაღწევს, ხოლო (!feof($file)) ( // წაიკითხეთ მონაცემები ფაილიდან $read = fgets ($file); // და აჩვენეთ ტექსტი ეკრანზე echo $read."
"; ) ) // თუ ფაილი არ გაიხსნა, მაშინ შეატყობინეთ სხვაგვარად ექო "შეცდომა ფაილის გახსნისას
"; // დახურეთ ფაილი fclose($file); ) // შექმენით ფაილი fcreate("test","გამარჯობა ყველას!"); // წაიკითხეთ მონაცემები ფაილიდან fileread("test"); ?>

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

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

როგორ ვიმუშაოთ php ფაილებთან

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

PHP ექსპერტი რედაქტორი;
. Dreamweaver;
. Eclipse PHP Development;
. PHPEdit.

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

ფაილის გადამოწმება

სანამ php ფაილში ჩაწერთ, უნდა დარწმუნდეთ, რომ ის არსებობს და შემდეგ გახსენით და გააკეთეთ საჭირო რედაქტირება. ამისათვის შეგიძლიათ გამოიყენოთ file_exists() ფუნქცია; თუ ის ადასტურებს არსებობას, მაშინ პასუხი TRUE დაბრუნდება რედაქტორის ფანჯარაში, წინააღმდეგ შემთხვევაში - FALSE.
კიდევ ერთი ფუნქცია is_file() შეუძლია შეგატყობინოთ, რომ შესაძლებელია მონაცემების ჩაწერა php ფაილში. ის უფრო საიმედოა ვიდრე file_exits და პროგრამისტების უმეტესობა იყენებს is_file-ს დასაწყებად. მას შემდეგ რაც დაადასტურებთ ფაილის არსებობას, შეგიძლიათ დაიწყოთ მასთან მუშაობა.

ფაილში ცვლილებების შეტანა

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

Int - მანიპულატორი;
. სტრიქონი არის ცვლადი.

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

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

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

// გახსენით ტექსტური ფაილი
$f = fopen("text.txt", "w");
// ტექსტის სტრიქონის დაწერა
fwrite($f, "გამარჯობა! დღე მშვიდობისა!");
// ტექსტური ფაილის დახურვა
fclose($f);

ამ მაგალითში text.txt არის დოკუმენტის სახელი. შეგიძლიათ სხვანაირად უწოდოთ: „გამარჯობა! Კარგი დღე! - ტექსტის მაგალითი, ის შეიძლება იყოს სრულიად თვითნებური. ყველა ცვლილება ავტომატურად ინახება ღია ფაილში.

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

16.5K

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

php ფაილები

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

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

  • Dreamweaver.
  • PHPEdit.
  • Eclipse PHP განვითარება.
PHP-ზე დაფუძნებული ვებსაიტების შექმნისას შეიძლება დაგჭირდეთ პროგრამის კოდის ხელახლა გამოყენება. ასეთ სიტუაციებში მოსახერხებელია სხვა ფაილში მდებარე მზა გადაწყვეტილებების დაკავშირება. ამისთვის გამოიყენება მოიცავს კონსტრუქცია. მისი სინტაქსია:

ფაილის სახელის ჩათვლით

კავშირის მაგალითი:

ჩართული ფაილი:


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

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

ფაილების გახსნა და დახურვა

php-ში ფაილებთან ყველა ოპერაცია ხორციელდება რამდენიმე ეტაპად:

  • ფაილის გახსნა;
  • შინაარსის რედაქტირება;
  • ფაილის დახურვა.

fopen() ფუნქცია გამოიყენება ფაილის გასახსნელად. მისი სინტაქსია:

int fopen (სტრიქონის ფაილის სახელი, სტრიქონის რეჟიმი [, int use_include_path])

მიღებული არგუმენტები:

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

  • სიმებიანი რეჟიმი - მიუთითებს ფაილის გახსნის რეჟიმზე. არგუმენტით მიღებული მნიშვნელობები:
  • r – ფაილი იხსნება მხოლოდ წასაკითხად, ფაილის მაჩვენებელი დაყენებულია დასაწყისში;
  • r+ – ფაილი ღიაა წასაკითხად და ჩასაწერად;
  • w – ქმნის ახალ ფაილს მხოლოდ ჩასაწერად. თუ ფაილი იგივე სახელით უკვე არსებობს, მასში არსებული ყველა მონაცემი ავტომატურად იშლება;
  • w+ - ქმნის ახალ ფაილს ჩასაწერად და წასაკითხად. როდესაც ასეთი ფაილი არსებობს, მისი მონაცემები მთლიანად გადაიწერება ახლით;
  • a – ფაილი ღიაა ჩასაწერად. მაჩვენებელი მითითებულია ბოლოს. ანუ php ფაილში ჩაწერა დაიწყება არა თავიდან, არამედ ბოლოდან;
  • a+ – გახსენით ფაილი წაკითხვის-ჩაწერის რეჟიმში. ჩაწერა დაიწყება ბოლოდან;
  • b – ორობითი მონაცემების შემცველ ფაილთან მუშაობის რეჟიმი (ორობითი რიცხვების სისტემაში). ეს რეჟიმი ხელმისაწვდომია მხოლოდ Windows ოპერაციულ სისტემაზე.

ფაილზე წვდომის დასახურად გამოიყენეთ fclose() ფუნქცია. Სინტაქსი:

int fclose (int ფაილი), სადაც int ფაილი არის სახელური საიტის დახურვისთვის.

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

მაგალითი:

ფაილების კითხვა და წერა

ფაილის მთლიანი შინაარსის უბრალოდ საჩვენებლად, readfile() ფუნქცია იდეალურია. მისი სინტაქსია:

readfile (სტრიქონის ფაილის სახელი), სადაც string ფაილის სახელი არის სტრიქონის ფაილის სახელი (არა სახელური).


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

int fpassthru (int ფაილი)

ფუნქცია მოითხოვს ფაილის გახსნას და დახურვას. მაგალითი:

შედეგი წინას მსგავსია.

php-ში ფაილებთან მუშაობის ფუნქციები საშუალებას გაძლევთ წაიკითხოთ შინაარსი ხაზ-სტრიქონით და სიმბოლოთი სიმბოლოთი:

  • string fgets (int ფაილი, int სიგრძე)– ფუნქცია კითხულობს სიგრძის სტრიქონს. მაგალითი:

  • სიმებიანი ფრედ (int ფაილი, int სიგრძე)- მოქმედება წინას იდენტურია.

ფაილში ტექსტური მონაცემების ჩასაწერად, არსებობს ორი იდენტური ფუნქცია:

  • int fputs (int ფაილი, სტრიქონი [, int სიგრძე])
  • int fwrite (int ფაილი, სტრიქონი [, int სიგრძე])

ფუნქციები წერენ ფაილში int ფაილში მითითებული სიგრძის int სიგრძის სტრიქონს ( არჩევითი არგუმენტი). მაგალითი:

ფაილების შექმნა და წაშლა

php ფაილის შესაქმნელად, შეგიძლიათ გამოიყენოთ fopen() ფუნქცია "w" ან "w+" წვდომის რეჟიმში. ან touch() ფუნქცია. ის ადგენს ფაილის შეცვლის დროს. თუ არ არის ელემენტი მოძიებული სახელით, ის შეიქმნება. მისი სინტაქსი.

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

Ძირითადი შენიშვნები

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

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

არსებითი გარემოება

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

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

წაიკითხეთ და შეცვალეთ საკუთარი თავი

შეიძლება თუ არა პროგრამამ შეიცვალოს თავისი თავი, ანუ შეიძლება სკრიპტის გაუმჯობესება? დღემდე ეს კითხვა ბევრს აინტერესებს. მაგრამ ამოცანა ბევრად უფრო პრაქტიკულად ჟღერს: PHP კითხულობს PHP ფაილს. დეველოპერს ყოველთვის არ შეუძლია გადაჭრას კონკრეტული პრობლემა კონკრეტული კოდის დაწერით. ზოგჯერ საჭიროა მისი შეცვლა, როდესაც ვიზიტორი მოდის საიტზე და აყალიბებს კითხვას, რომელიც არ იყო გათვალისწინებული განვითარების ეტაპზე.

როგორც ყველა სხვა შემთხვევაში, პირველ რიგში, თქვენ უნდა გახსნათ ფაილი. არ აქვს მნიშვნელობა ეს ფაილი არსებობს თუ არა. თუ ცნობილია, რომ ფაილი არსებობს (file_exists() ფუნქცია იძლევა დადებით პასუხს), fopen() ფუნქცია გამოიყენება წვდომით 'r', 'r+', 'a', 'a+'. თუ ფაილი ჯერ არ არსებობს, მაშინ წვდომით 'a', 'a+', 'w', 'w+'. ფაილის გახსნის შედეგი იქნება მისი აღმწერი. ფაილი იხურება fclose() ფუნქციით.

მოსახერხებელია PHP-ის გამოყენება ფაილის მასივში წასაკითხად, როდესაც არ არის საჭირო მისი დამუშავება წაკითხვის დროს.

თუ (ფაილი_არსებობს ($fName)) (

$aLines = ფაილი ($fName)

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

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

$fvs = fopen ($fName, "r")

while ((ცრუ !== ($cLine = fgets($fvs, 2000)))) (

$cLines .= "
" . $i . "). $cLine

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

შედეგების შენახვა

მიღებული და განახლებული ინფორმაცია იწერება ფაილში fputs() ფუნქციის სტრიქონ-სტრიქონით ან მთლიანად file_put_contents() ფუნქციით.

$fName = $_SERVER["DOCUMENT_ROOT"] . "/tmp/scData.php"

$fvs = fopen ($fName, "a")

ფარა ($fvs, LOCK_EX)

$cLine = "1 ხაზი". chr(10)

fputs ($fvs, $cLine)

$cLine = "2 ხაზი" . chr(10)

fputs ($fvs, $cLine)

ფარა ($fvs, LOCK_UN)

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

$file = " scData.php "

$cContents = file_get_contents ($ფაილი)

// ჩანაწერის დამატება

$cContents .= "ახალი ჩანაწერი\n"

// ჩაწერეთ ფაილი უკან

file_put_contents ($file, $cContents)

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

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

PHP-ის, MySQl-ის, JavaScript-ის და განსაკუთრებით ბრაუზერების დამახასიათებელი მახასიათებელი: ჩუმად დაუშვას გარკვეული შეცდომები. „არ არის აღიარებული, არ გაკეთებულა...“ არ არის ძალიან კარგი პრაქტიკა ინფორმაციული ტექნოლოგიების უახლესი კუთხით, მაგრამ ის ასწავლის დეველოპერებს არ დაუშვან შეცდომები და დაწერონ სუფთა, მაღალი ხარისხის კოდი, რაც ასევე არ არის ცუდი.

PHP და რეალურ დოკუმენტებთან მუშაობა

PHP PHP ფაილის კითხვა, რა თქმა უნდა, პრაქტიკული ინტერესია, მაგრამ ეს არის პროგრამირების სფერო. მომხმარებელს და საიტის სტუმარს აინტერესებს გამოყენებითი ხასიათის ინფორმაცია, რომლის ნახვას იგი მიჩვეულია ცხრილებისა და დოკუმენტების სახით, კერძოდ, *.xlsx და *.docx ფაილის ფორმატებში. ეს არის ფაილები MS Excel და MS Word ფორმატში.

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

PHPExcel და PHPWord ბიბლიოთეკები შემუშავებულია ასეთ ფაილებთან მუშაობისთვის. თუმცა, *.xlsx და *.docx ფაილების შინაარსი წარმოდგენილია OOXML სტანდარტში, ანუ რეალური, გასაგები დოკუმენტი წარმოდგენილია zip არქივში. Zip არქივი არის ფაილების ნაკრები, მათ შორის სურათები, ობიექტები, ფორმულები და ჩანართები სხვა პროგრამებიდან. ტექსტური ფაილები აქ წარმოდგენილია აღწერილობებით ტეგების სახით. ასეთი ფაილის წაკითხვა საკმარისი არ არის; თქვენ უნდა გააანალიზოთ ის, რომ მიიღოთ შინაარსი და სტრუქტურა გამოსაყენებლად და შესაცვლელად.

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

Excel ცხრილები

include_once 'PhpOffice/PhpExcel/IOFactory.php'

ფუნქცია scGetExcelFile($xls)(

$objPHPExcel = PHPExcel_IOFactory::load($xls)

$objPHPExcel->setActiveSheetIndex(0)

//ეს მასივი შეიცავს სტრიქონების მასივებს

$aSheet = $objPHPExcel->getActiveSheet()

$მასივი = მასივი()

//მკურნალობა

foreach($aSheet->getRowIterator() როგორც $row)(

$cellIterator = $row->getCellIterator()

foreach ($cellIterator როგორც $cell)(

array_push($item, iconv("utf-8", "cp1251", $cell->getCalculatedValue()))

array_push ($მასივი, $item)

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

Word დოკუმენტები

მხოლოდ ორი ხაზი:

$oWord = ახალი \PhpOffice\PhpWord\PhpWord()

$oDocx = $this->oWord->loadTemplate ($cFileName)

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

$zipClass = ახალი ZipArchive()

$zipClass->ღია($this->tempFileName)

// წაიკითხეთ დოკუმენტის მთელი შინაარსი

ამისთვის ($i=0; $i<$zipClass->numFiles; $i++) (

$cNameIn = $zipClass->getNameIndex($i)

$cNameInExt = substr($cNameIn, -4)

if (($cNameInExt == ".xml") || ($cNameInExt == "rels")) (

// ფაილები გაფართოებებით ".xml" და ".xml.rels" ინახება დოკუმენტის ცხრილში

// თითოეული xml ხაზი იწერება უნიკალური ნომრით თანმიმდევრობით

$cBodyIn = $zipClass->getFromName($cNameIn)

$cBodyInLen = strlen($cBodyIn)

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

$cNameOnly = substr($cNameIn, strrpos($cNameIn, "/") + 1)

$zipClass->getFromName($cNameIn, $cWorkPath); // შინაარსი ფაილად

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

ტექსტური ფაილები, სხვა ცხოვრება

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

ვინაიდან არსებობს კლიენტი და სერვერი (პირველში დომინირებს JavaScript, მეორეში PHP), მაშინ ქუქიების და სესიების მექანიზმებიც კი ვერ უმკლავდებიან სკრიპტებს, გვერდებს ან გარკვეულ პროცესებს შორის ინფორმაციის გადაცემის საჭიროებას.

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

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

თუ ფიქრობთ იმაზე, რომ ტექსტური ფაილი არის დეველოპერის შინაარსი და სტრუქტურა, PHP ფაილი არის ინტერპრეტაციის სინტაქსი პლუს დეველოპერის ლოგიკა, ხოლო „ტეგირებული“ აღწერილობები html, css, xml უფრო სემანტიკური ელემენტებია, მაგრამ რეგულირდება. სტატიკური სტანდარტებით. შეიძლება მივიდეს დასკვნამდე, რომ ალბათ დროა ფაილებმა ახალი შინაარსი შეიძინონ და ამან თავად უნდა განსაზღვროს მათი ხარისხი და გამოყენების ლოგიკა. სწორედ იმიტომ, რომ პროგრამირება ჯერ არ არის მზად მისი განვითარების შემდეგი ეტაპისთვის, ფაილები დღეს რჩება უბრალოდ ფაილებად, რომლებსაც დეველოპერი ქმნის და განსაზღვრავს მათ გამოყენებას.

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



 

შეიძლება სასარგებლო იყოს წაკითხვა: