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

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

ქვემიმდევრობა ფაილებთან მუშაობა PHP-შიამგვარად:

1. Გახსენი ფაილი.
2. შეასრულეთ საჭირო მოქმედებები.
3. დახურეთ ფაილი.

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

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

1. ა- ხსნის ფაილს მხოლოდ ჩასაწერად, ფაილის ბოლოს მოთავსებული მაჩვენებლით.
2. a+ ა, მაგრამ ფაილი ასევე იხსნება წასაკითხად.
3. რ- ხსნის ფაილს მხოლოდ წაკითხვისთვის და მაჩვენებელი დაყენებულია ფაილის დასაწყისში.
4. r+- იგივე მოდიფიკატორი რ, მაგრამ ფაილიც იხსნება ჩასაწერად.
5. ვ- ხსნის ფაილს მხოლოდ ჩასაწერად, აყენებს მაჩვენებელს ფაილის დასაწყისში და წაშლის ფაილის მთელ შინაარსს.
6. w+- იგივე მოდიფიკატორი ვ, მხოლოდ ფაილიც იხსნება წასაკითხად.

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

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

ახლა მოდით გადავიდეთ ფაილის გამოყენებით წაკითხვაზე fread() ფუნქციები. და ბოლოს მოგიყვან მაგალითს:

$contents = "";
ხოლო (!feof($handle))
$contents .= fread($handle, 4096);
fclose ($ handle);
?>

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

ახლა მოდით გადავიდეთ ჩაწერის გამოყენებით fwrite() ფუნქციები:

$handle = fopen("files/a.txt", "at");
$string = "ეს არის ტექსტი";
fwrite ($ handle, $string);
fclose ($ handle);
?>

ამ სკრიპტის გაშვების შემდეგ, ფაილში a.txtხაზი " დაემატება ეს არის ტექსტი".

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

$handle = fopen("files/a.txt", "rt");
ექო $შინაარსი."
";
fseek($handle, 0, SEEK_SET);
$contents = fread($handle, 3);
ექო $შინაარსი."
";
?>

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

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

file_put_contents("files/a.txt", "ეს არის ტექსტი 2");
echo file_get_contents("ფაილები/a.txt");
?>

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

ეს არის ყველა მთავარი პუნქტი ფაილებთან მუშაობა PHP-ში.

MySQL და Access მონაცემთა ბაზები სულ უფრო და უფრო ხდება საჯაროდ ხელმისაწვდომი მონაცემთა შენახვის ინსტრუმენტები. მაგრამ 1990-იანი წლების დასაწყისში PHP ფაილებთან მუშაობა პოპულარული იყო, ჩანაწერების შენახვა ახალი ხაზებით გამოყოფილი CSV ფორმატირებულ ტექსტურ ფაილებში.

მუშაობის ძირითადი პრინციპები

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

ასე რომ, აქ არის რამდენიმე მიზეზი, რის გამოც შეიძლება დაგჭირდეთ ფაილები:

1. ორობითი მონაცემების (როგორიცაა გამოსახულების ფაილები) გადატანა BLOB (ორობითი დიდი ობიექტი) მონაცემთა ბაზაში.
2. მონაცემთა იმპორტი (როგორიცაა ელფოსტის მისამართები) ექსპორტირებული ძველი მონაცემთა ბაზიდან ან აპლიკაციიდან.
3. მონაცემთა ბაზიდან ინფორმაციის ექსპორტი ტექსტურ ფაილში ოფლაინ დამუშავებისთვის.

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

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

მათ შეუძლიათ თქვან:

• ზომის შესახებ;
• მიაწოდოს ინფორმაცია უკანასკნელად როდის დაუკავშირდა მას;
• უთხარით მფლობელს და ა.შ.

უმჯობესია ისწავლოთ ყველა ძირითადი ატრიბუტი ფაილებთან მუშაობისთვის PHP-ში. ეს ბევრად გაამარტივებს მუშაობას.

ფაილის ისტორია

შეიძლება დაგჭირდეთ იმის გარკვევა, როდის მოხდა ფაილის ბოლოს რედაქტირება. ამ შემთხვევაში სამაშველოში მოდიან ფუნქციები fileatime(), filemtime() და filectime().

"; echo $file . " ჰქონდა ბოლო შეცვლილი i-node " . date($formatDate, $timeM) . ".
"; echo $file . " შეიცვალა " . date($formatDate, $timeC) . ".";

აი კოდი, რომელიც იბრუნებს ბოლო წვდომის დროის ნიშანს და აჩვენებს მას:

• C: Windowsfile.ini წვდომა იქნა 2018 წლის 19 სექტემბერს, საღამოს 4:34 საათზე.
• C: Windowsfile.ini შეიცვალა პარასკევი 8 ოქტომბერი, 2018 2:03 am.
• C: Windowsfil.ini შეიცვალა სამ დეკემბერს, 2017 წლის 4:34 საათზე.

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

date() ფუნქცია გამოიყენებოდა ფაილი*time() ფუნქციების მიერ დაბრუნებული Unix დროის ანაბეჭდის ფორმატირებისთვის.

ფაილი თუ არა?

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

"; echo $file . (is_dir($file) ? " " : " არა") . " დირექტორია.";

კოდის გამომავალი მაგალითი:

• C: Windowsfile.ini ფაილი.
• C: Windowsfile.ini არ არის დირექტორია.

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

ფაილის ნებართვები

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

"; echo $file . (is_writable($file) ? " " : "არა") . " იწერება.";

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

კოდი ეკრანზე გამოსცემს შემდეგ მნიშვნელობებს:

• C: Windowsfile.ini იკითხება.
• C: Windowsfile.ini არ არის დაწერილი.

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

ფაილის ზომა

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

ფუნქცია აჩვენებს შემდეგს:

• C: Windowsfile.ini არის 510 ბაიტის ზომა.

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

თუ ფაილი ჯერ არ შექმნილა, ფაილების ზომა() ფუნქცია მოახსენებს False-ს და შეცდომას. ამიტომ, ისინი ჯერ ამოწმებენ ფაილს საჭირო file_exists() ბრძანების არსებობისთვის.

file_exists() შემოწმება თითქმის ყოველთვის უნდა იყოს ჩართული უსაფრთხოებისთვის.

ფაილების კითხვა

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

PHP ფაილებთან მუშაობის ფუნქციები ამარტივებს საქმეს. ამ შემთხვევაში დაგჭირდებათ file_get_contents(). ის წაიკითხავს ფაილის მთელ შინაარსს ცვლადში, ფაილის გახსნის ან დახურვის გარეშე. ეს მოსახერხებელია, როდესაც ჩაწერის მოცულობა შედარებით მცირეა, რადგან არქივში 1 GB მონაცემთა დაუყოვნებლივ წაკითხვა ყოველთვის არ არის რაციონალური PHP-ში. ".ini" ფაილებთან მუშაობა და file_get_contents() ფუნქცია ნაჩვენებია ქვემოთ.

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

fopen() ფუნქცია მოითხოვს ორ არგუმენტს:

• გასახსნელი ფაილი;
• ამ შემთხვევაში გამოყენებული რეჟიმი არის "r" წასაკითხად.

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

ღია ფაილიდან თითო სტრიქონის წასაკითხად შეგიძლიათ გამოიყენოთ fgets() ფუნქცია.

";) while (!feof($file1)); fclose($file1);

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

ფაილების ჩაწერა

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

შემდეგი მაგალითი გამოიყენებს "a" ჩაწერის რეჟიმს.

ჯერ ფაილის სახელი ენიჭება ცვლადს, შემდეგ იხსნება "a" რეჟიმში დასამატებლად. ჩასაწერი მონაცემები ენიჭება $output ცვლადს და fwrite() და ინფორმაცია ემატება ფაილს. პროცესი მეორდება კიდევ ერთი ხაზის დასამატებლად, შემდეგ დოკუმენტი იხურება fclose() გამოყენებით.

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

ზემოაღნიშნული კოდის შესრულების შემდეგ ფაილის შინაარსი ასე უნდა გამოიყურებოდეს:

• ბანანი;
• ჩინეთი.

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

აი, იგივე მაგალითი, როგორც ზემოთ, მაგრამ ამჯერად file_put_contents().

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

ბოლო განახლება: 11/1/2015

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

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

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

PHP-ში ფაილების გასახსნელად, განსაზღვრულია fopen() ფუნქცია. მას აქვს შემდეგი განმარტება: რესურსი fopen(string $filename, string $mode) . პირველი $filename პარამეტრი წარმოადგენს ფაილის გზას, ხოლო მეორე არის გახსნის რეჟიმი. გახსნის მიზნიდან და ფაილის ტიპებიდან გამომდინარე, ამ პარამეტრს შეუძლია მიიღოს შემდეგი მნიშვნელობები:

"r": ფაილი იხსნება მხოლოდ წასაკითხად. თუ ფაილი არ არსებობს, აბრუნებს false

"r+": ფაილი იხსნება მხოლოდ წასაკითხად და დასაწერად. თუ ფაილი არ არსებობს, აბრუნებს false

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

"w+" : ფაილი იხსნება ჩასაწერად და იკითხება. თუ ასეთი ფაილი უკვე არსებობს, მაშინ ის გადაწერილია, თუ არა, მაშინ იქმნება.

"a" : ფაილი იხსნება ჩასაწერად. თუ ასეთი ფაილი უკვე არსებობს, მაშინ მონაცემები იწერება ფაილის ბოლომდე და რჩება ძველი მონაცემები. თუ ფაილი არ არსებობს, ის იქმნება

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

fopen ფუნქციის გამომავალი იქნება ფაილის აღმწერი. ეს სახელური გამოიყენება ფაილის ოპერაციებისთვის და ფაილის დახურვისთვის.

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

$fd = fopen("form.php", "r") ან die("ფაილის გახსნა ვერ მოხერხდა"); fclose ($fd);

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

ფაილის კითხვა

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

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

მთელი ფაილის წაკითხვა

ამ შემთხვევაში, ჩვენ არ უნდა გავხსნათ ფაილი, მივიღოთ სახელური და შემდეგ დავხუროთ ფაილი.

კითხვის დაბლოკვა

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

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

დაწერეთ ფაილი

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

სხვა fputs() ფუნქცია მუშაობს ანალოგიურად:

მუშაობა ფაილის მაჩვენებელთან

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

Int fseek (რესურსი $handle, int $offset [, int $whence = SEEK_SET ])

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

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

SEEK_CUR: ადგენს ოფსეტს ოფსეტურ ბაიტებში ფაილში მიმდინარე პოზიციის დასაწყისთან შედარებით

SEEK_END : აყენებს ოფსეტს ფაილის ბოლოდან ბაიტების ოფსეტურად

თუ მაჩვენებელი წარმატებით არის დაინსტალირებული, fseek() ფუნქცია აბრუნებს 0-ს, ხოლო თუ მაჩვენებელი წარუმატებელია, აბრუნებს -1-ს.

ფუნქციის გამოყენების მაგალითი:

$fd = fopen("hello.txt", "w+") ან die("ფაილის გახსნა ვერ მოხერხდა"); $str = "გამარჯობა სამყარო!"; // ხაზი ჩასაწერად fwrite($fd, $str); // ჩაწერეთ სტრიქონი დასაწყისში fseek($fd, 0); // მოათავსეთ ფაილის მაჩვენებელი fwrite-ის დასაწყისში ($fd, "Oink"); // დაწერეთ სტრიქონი დასაწყისში fseek($fd, 0, SEEK_END); // განათავსეთ მაჩვენებელი fwrite ($fd, $str) ბოლოს; // დაწერეთ კიდევ ერთი ხაზი fclose($fd) ბოლოს;

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

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

შექმენით ფაილი

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

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

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

მაგალითი:

$ourFileName = "testFile.txt";

$ourFileHandle = fopen($ourFileName, "w") ან die("ფაილის გახსნა შეუძლებელია");

fclose ($ourFileHandle);

პირველი ხაზი $ourFileName = testFile.txt ქმნის სტრიქონის ცვლადს, რომელშიც ჩვენ ვინახავთ ფაილის სახელს.

მეორე სტრიქონი $ourFileHandle = fopen($ourFileName, 'w') ან die ("ფაილის გახსნა შეუძლებელია") შესაბამისად ქმნის ან ხსნის არსებულ ფაილს ჩასაწერად. ან აბრუნებს შეტყობინებას, რომ მას არ შეუძლია ფაილის გახსნა.

მესამე ხაზი fclose($ourFileHandle) ხურავს ფაილს. სინამდვილეში მარტივია.

ფაილის გახსნის პარამეტრები php-ში

პირველი პარამეტრი "r" (წაკითხვა) - ხსნის ფაილს მხოლოდ წასაკითხად; თქვენ არ შეგიძლიათ მასზე ჩაწერა.

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

მესამე პარამეტრი 'a' (append) - ხსნის ფაილს ჩასაწერად, მაგრამ დაემატება ფაილის ბოლოს, w-ისგან განსხვავებით.

Დამატებითი პარამეტრები:

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

პარამეტრი 'w+' - იხსნება როგორც წაკითხვისთვის, ასევე ჩაწერისთვის, მაგრამ წაშლის ყველა ინფორმაციას, რომელიც იყო ფაილში!!!

პარამეტრი 'a+' - იხსნება წასაკითხად და ჩასაწერად, მაგრამ მაჩვენებელი იქნება ფაილის ბოლოს.

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

fopen ($ourFileName, "X")

ჩაწერეთ ფაილში

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

$myFile = "testFile.txt";

$fh = fopen($myFile, "w") ან die("ფაილის გახსნა შეუძლებელია");

$stringData = "პირველი ხაზი";

fwrite ($fh, $stringData);

$stringData = "მეორე ხაზი";

fwrite ($fh, $stringData);

ჩვენ შევქმენით ფაილი testFile.txt, მისკენ მიმანიშნებელი ინახება $fn ცვლადში. ჩვენ მასში ჩავწერეთ სტრიქონი "პირველი ხაზი" (ბოლოს გამოვიყენეთ ხაზის ბოლოს სიმბოლო n), შემდეგ კი "მეორე სტრიქონი". შემდეგ მათ დახურეს ფაილი.

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

ფაილიდან კითხვა

ჩვენ ჩავწერეთ, ახლა წავიკითხოთ! არც ისე რთულია. ჩვენ ვიყენებთ fread ფუნქციას. შეყვანის სახით ჩვენ ვაძლევთ მაჩვენებელს ფაილს და ბაიტების რაოდენობას, რომელთა წაკითხვა გვინდა. მაგალითად, ერთი სიმბოლო უდრის ერთ ბაიტს (დამოკიდებულია კოდირებაზე), გვინდა წავიკითხოთ 5 სიმბოლო: $theData = fread($fh, 5).

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

$myFile = "testFile.txt";

$fh = fopen($myFile, "r");

$theData = fread($fh, ფაილის ზომა($myFile));

იმედია გარკვევით ავხსენი.

$myFile = "testFile.txt";

$fh = fopen($myFile, "r");

$theData = fgets($fh);

შედეგად, ჩვენ ვიღებთ პირველ ხაზს testFile.txt ფაილიდან. შესაბამისად, ყველა ხაზის გასავლელად, თქვენ უნდა გამოიყენოთ foreach loop:

$lines = ფაილი ("testFile.txt");

foreach ($lines, როგორც $single_line)

ექო $single_line . "
n";

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

თუ დამოუკიდებლად სწავლობთ 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 ფაილში.