პუნქტუალური დამატება შეტყობინების php. PHP AJAX CRUD: ჩანაწერების შექმნა, წაშლა, რედაქტირება MySQL მონაცემთა ბაზაში

ანალოგიურად, შეგიძლიათ განსაზღვროთ "

• (სამიზნე) - თუ ეს გჭირდებათ
• (target_url) თუ ეს გჭირდებათ თქვენს შეტყობინებაში.
• (სათაური) - ჩვეულებრივ გამოიყენება ობიექტთან მიმართებაში, რომელმაც შექმნა შეტყობინება. მაგალითი: "მომხმარებელმა X-მა გამოაქვეყნა ახალი ფოტო ალბომში Y." ალბომის Y არის სათაური აქ
• (title_url) - ისევე როგორც წინა, ობიექტის url, რომელმაც შექმნა შეტყობინება.
• (შეტყობინება) - ეს პარამეტრი შეიძლება გამოყენებულ იქნას JomSocial ელ.ფოსტის ტექსტში შეტყობინების დასაყენებლად (და ექოზე).

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

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

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

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

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

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

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

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

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

class Message ( /** * შეტყობინების შინაარსი. */ var $content; /** * კონსტრუქტორი შეტყობინების ტექსტის ინიციალიზაციისთვის. * * @param content შეტყობინების შინაარსი */ ფუნქცია Message($content) ($this->content = $ შინაარსი ) /** * დაწერეთ შეტყობინება სესიაზე */ ფუნქცია send() ($_SESSION["session_messages"] = $this->content; ) /** * გაგზავნეთ შეტყობინება გვერდზე */ ფუნქცია გვერდზე. () (echo. " - " . $this->content .
"; } }

$_SESSION ცვლადი გამოიყენება სესიაზე წვდომისთვის.

გაითვალისწინეთ, რომ $_SESSION არის მასივი, ჩვენ ვიყენებთ ამ მასივის მხოლოდ ერთ ელემენტს ინდექსით 'session_message'.

ამ შემთხვევაში საქმე გვაქვს „მასივების მასივთან“ - რასაც ვინახავთ „session_message“ ელემენტში არის მასივი, ეს არის გადაცემული შეტყობინებების სია (რა თქმა უნდა, შეიძლება იყოს რამდენიმე მათგანი).

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

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

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

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

ამის თავიდან აცილება შესაძლებელია სიტუაციის წინასწარ გათვალისწინებით, შეტყობინების ასოციაციური მასივის სახით წარდგენით: $msg['txt'], $msg['kind'], მაშინ ფუნქციის გამოძახებებში იქნება მხოლოდ ერთი პარამეტრი. გრძნობთ, როგორ ცდილობს ეს კლასი გახდეს?

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

შემდეგი კლასი - Inbox - სწორედ ამისთვის არის შექმნილი.

class Inbox ( /** * მიღებული შეტყობინებების მასივი. */ var $messages = array(); /** * კონსტრუქტორში ვიღებთ ყველა მიღებულ შეტყობინებას * და ვშლით მათ სესიიდან. */ ფუნქცია Inbox() ( if (is_array($ _SESSION["session_messages"])) ($messages = $_SESSION["session_messages"]; $co = sizeof($messages); for ($i = 0; $i< $co; $i++) { $this->შეტყობინებები = ახალი შეტყობინება ($messages[$i]); ) ) /* შეტყობინებების მასივის გასუფთავება */ $_SESSION["session_messages"] = array(); ) /** * გვერდზე Inbox-ის შიგთავსის ჩვენება. */ ფუნქცია toPage() ( $co = sizeof($this->messages); if ($co > 0) (echo "შეტყობინება სისტემიდან:
";) ($i = 0; $i< $co; $i++) { $this->შეტყობინებები[$i]->ToPage(); ))))

მოდით ვცადოთ ჩვენი შეტყობინებების სისტემა.

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

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

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

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

აქ ჩვენ ვაწყდებით ორ სირთულეს:

* მე მინდა, რომ შეტყობინებების სია გამოჩნდეს გვერდის კონკრეტულ ნაწილში და თქვენ უკვე იპოვეთ ამისთვის კარგი ადგილი.
პრობლემა ის არის, რომ თქვენ უნდა გაუშვათ $inbox->toPage() ბრძანება ზუსტად იმ მომენტში, რომელიც შეესაბამებოდა შეტყობინებების სიის პოზიციას გვერდზე. თუ ჩვენ გვინდა ამ სიის პოზიციის შეცვლა, მოგვიწევს კოდში შესვლა, მაგრამ ამისთვის პორტალის ჩარჩოს მუდმივად შეცვლა არ არის კარგი. საუკეთესო გამოსავალი იქნება შეტყობინებების გამომავალი ცალკე მოდულის სახით, რომელიც მხოლოდ ის ვიცით, რომ ფრეიმიკზე უნდა იყოს დაკავშირებული.
ანუ გათავისუფლდით მოდულების გაშვების მკაცრი თანმიმდევრობისგან. მართლაც, ვინაიდან Inbox-ის გამომავალი შედეგი არ არის დამოკიდებული სისტემის მუშაობაზე (ამ ეტაპზე ჩვენ უკვე გვაქვს ყველა მონაცემი სესიაზე), მაშინ რატომ არის ზედმეტი სირთულე?
* შეტყობინებების სიის გარეგნობის (დიზაინის) შესანარჩუნებლად, თქვენ უნდა იზრუნოთ HTML კოდზე, რომელიც მყარი კოდირებულია Message და Inbox კლასების toPage() მეთოდებში. როგორც წესი, თქვენ უნდა შეცვალოთ PHP კოდი დიზაინის შესაცვლელად.

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

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

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

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

იდეა არის არა HTML კოდის, არამედ XML სტრუქტურის გენერირება toPage() მეთოდებში. გვერდის დოკუმენტი შეიქმნება სტრიქონის სახით XML კოდით (ის იქნება „ბუფერი“), ხოლო სკრიპტის ბოლო ეტაპზე გამოვიყენებთ XSL ტრანსფორმაციას.

ჯერ წარმოვიდგინოთ, რა შედეგი უნდა მოჰყვეს კოდის ძირითად ნაწილს.

წუთი 57 წამი: 45

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

class Outputable ( /** * XML კონტეინერი (სტრიქონი). */ var $output = ""; /** * მიეცით კონტეინერის შიგთავსი და გაასუფთავეთ კონტეინერი. * * @დააბრუნეთ სტრიქონი XML მონაცემებით */ ფუნქცია getOutput () ( $ out = $this->output; $this->output = ""; return $out; ->output .= $string . "n" ) /** * "აბსტრაქტული" მეთოდი */ ფუნქცია toPage( ) ( ) )

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

Message და Inbox კლასები ოდნავ შეიცვლება - მათ ახლა ორივე უნდა მემკვიდრეობით მიიღონ Outputable-დან, ასევე შეიცვლება toPage() მეთოდებიც.
Message.php

class Message extends Outputable ( /** * შეტყობინების შინაარსი. */ var $content; /** * კონსტრუქტორი შეტყობინების ტექსტის ინიციალიზაციისთვის. * * @param content შეტყობინების შინაარსი */ ფუნქცია Message($content) ( $this->content = $content; this->appendOutput("".$this->content."") )

class Inbox აფართოებს Outputable ( /** * მიღებული შეტყობინებების მასივი. */ var $messages = array(); /** * კონსტრუქტორში ვიღებთ ყველა მიღებულ შეტყობინებას * და ვხსნით მათ სესიიდან. */ ფუნქცია Inbox( ) ( if (is_array ($_SESSION["session_messages"])) ($messages = $_SESSION["session_messages"]; $co = sizeof($messages); for ($i = 0; $i< $co; $i++) { $this->შეტყობინებები = ახალი შეტყობინება ($messages[$i]); ) ) /* შეტყობინებების მასივის გასუფთავება */ $_SESSION["session_messages"] = array(); ) /** * გვერდზე Inbox-ის შიგთავსის ჩვენება. */ ფუნქცია toPage() ($co = sizeof($this->messages); $this->appendOutput(""); for ($i = 0; $i< $co; $i++) { $this->შეტყობინებები[$i]->toPage(); $this->appendOutput($this->შეტყობინებები[$i]->getOutput()); ) $this->appendOutput(""); ))

გამომავალი მეთოდი შეიცვალა - ახლა, გვერდზე პირდაპირ გამოტანის ნაცვლად, გარე წარმოდგენა ამ დროისთვის ინახება Outputable-ში, რომელიც „ზის“ თითოეულ ობიექტში. appendOutput() მეთოდი ემსახურება echo() კონსტრუქციის ჩანაცვლებას. ობიექტის გამოსავლის მისაღებად გამოიყენება getOutput() მეთოდი.

ახლა ვნახოთ რა არის კოდის კლიენტის ნაწილი, რომელიც მოაგვარებს იგივე პრობლემას, როგორც ადრე.
index.php

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

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

შედეგის დასათვალიერებლად, რჩება მხოლოდ XSL შაბლონის მომზადება.
სტილი.xsl

XSLT მაგალითი

რას მივაღწიეთ?

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

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

კიდევ ერთი უპირატესობა არის გამართვის სიმარტივე. თუ სკრიპტს გაუშვით, შეამჩნევთ, რომ თითოეული გვერდი შეიცავს გამართვის გამომავალს - XML ​​პროტოტიპს, რომელიც მნიშვნელოვნად ამარტივებს აპლიკაციების გამართვას.

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

და ბოლოს, გალოპი პერსპექტივების შესახებ:

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

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

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

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

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

ფუნქცია showEditBox(id) ($("#frmAdd"). დამალვა(); var currentMessage = $("#message_" + id + ".message-content").html(); var editMarkUp = ""+currentMessage+" SaveCancel"; $("#message_" + id + ".message-content").html(editMarkUp); ) ფუნქცია cancelEdit(წერილი,id) ($("#message_" + id + " .message-content") .html(გზავნილი $("#frmAdd").show(ფუნქცია callCrudAction(action,id) ($("#loaderIcon").show(); var queryString; switch(action) ( case "add "); : queryString = "action="+action+"&txtmessage="+ $("#txtmessage").val( break case "edit": queryString = "action="+action+"&message_id="+ id + " &txtmessage; ="+ $("#txtmessage_"+id).val(); break; case "delete": queryString = "action="+action+"&message_id="+ id; break; ) jQuery.ajax(( url: " crud_action.php", data:queryString, ტიპი: "POST", success:function(data)( switch(action) ( case "add": $("#comment-list-box").append(data); break ; შესვენება; case "delete": $("#message_"+id).fadeOut(); შესვენება; ) $("#txtmessage").val(""); $("#loaderIcon").დამალვა(); ), შეცდომა:ფუნქცია ()() )); )

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

require_once ("dbcontroller.php"); $db_handle = ახალი DBController(); $action = $_POST["მოქმედება"]; if(!empty($action)) ( switch($action) ( case "add": $result = mysql_query("INSERT INTO comment(ssage) VALUES("".$_POST["txtmessage"].")" ) if($result)($insert_id = mysql_insert_id(); echo "Edit Delete" . $_POST["txtmessage"] "".$_POST["txtmessage"]."" WHERE id=".$_POST["message_id"]); if($result) echo $_POST["txtmessage"]; შესვენება; შემთხვევა "წაშლა": თუ ( !empty($_POST["message_id"])) (mysql_query("DELETE FROM comment WHERE id=".$_POST["message_id"]); ) break) )

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