Curl get მეთოდი არ მუშაობს. CURL PHP: რა არის და როგორ გამოვიყენოთ იგი? გაგზავნეთ GET მოთხოვნა ფორმადან

რატომ გვჭირდება PHP CURL?
HTTP GET მოთხოვნების გასაგზავნად, უბრალოდ შეგვიძლია გამოვიყენოთ file_get_contents()მეთოდი.

File_get_contents ("http://site")

მაგრამ POST მოთხოვნის გაგზავნა და შეცდომების დამუშავება არ არიანმარტივია file_get_contents().

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

ნაბიჯი 1). CURL სესიის ინიცირება

$ch = curl_init();

ნაბიჯი 2). გთავაზობთ CURL სესიის ვარიანტებს

Curl_setopt($ch,CURLOPT_URL,"http://site"); curl_setopt($ch,CURLOPT_RETURNTRANSFER,true); //curl_setopt($ch,CURLOPT_HEADER, true); //თუ გინდა სათაურები

CURLOPT_URL-> URL მოსატანად
CURLOPT_HEADER-> სათაურის/არა ჩასართავად
CURLOPT_RETURNTRANSFER-> თუ დაყენებულია true-ზე, მონაცემები გამოტანის ნაცვლად ბრუნდება სტრიქონის სახით.

ნაბიჯი 3).შეასრულეთ CURL სესია

$output=curl_exec($ch);

ნაბიჯი 4).სხდომის დახურვა

Curl_close ($ch);

შენიშვნა: შეგიძლიათ შეამოწმოთ ჩართულია თუ არა CURL/არა შემდეგიკოდი.

If(is_callable("curl_init"))(echo "ჩართულია"; ) else (echo "არ არის ჩართული"; )

1.PHP CURL GET მაგალითი

შეგიძლიათ გამოიყენოთ ქვემოთ მოცემული კოდი GET მოთხოვნის გასაგზავნად.

ფუნქცია httpGet($url) ($ch = curl_init(); curl_setopt($ch,CURLOPT_URL,$url); curl_setopt($ch,CURLOPT_RETURNTRANSFER,true); // curl_setopt($ch,CURLOPT_HEADER, false); curl_exec($ch) curl_close($ch) echo httpGet("http://site");

2.PHP CURL POST მაგალითი

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

ფუნქცია httpPost($url,$params) ( $postData = ""; //შექმენით სახელის მნიშვნელობის წყვილები გამოყოფილი & foreach-ით ($params როგორც $k => $v) ( $postData .= $k . "=".$ v."&"; CURLOPT_HEADER, false($ch, CURLOPT_POST, count($ch, CURLOPT_POSTFIELDS, $output=curl_exec($ch);

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

$params = მასივი ("სახელი" => "Ravishanker Kusuma", "age" => "32", "location" => "ინდოეთი"); echo httpPost("http://site/examples/php/curl-examples/post.php",$params);

3. შემთხვევითი მომხმარებლის აგენტის გაგზავნა მოთხოვნებში

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

ფუნქცია getRandomUserAgent() ( $userAgents=array("Mozilla/5.0 (Windows; U; Windows NT 5.1; en-GB; rv:1.8.1.6) Gecko/20070725 Firefox/2.0.0.6", "Mozilla/4.0 (თავსებადი; MSIE 7.0; Windows NT 5.1), "Mozilla/4.0 (თავსებადი; MSIE 7.0; Windows NT 5.1; .NET CLR 1.1.4322; .NET CLR 2.0.50727; .NET CLR 3.0.04" (Windows NT 6.0; U; en)", "Mozilla/4.0 (თავსებადი; MSIE 6.0; Windows NT 5.1; en) Opera 8.50", "Mozilla/4.0 (თავსებადი; MSIE 6.0; MSIE 5.5; Windows NT 5.1) Opera 7.0 ", "Mozilla/5.0 (Macintosh; U; PPC Mac OS X Mach-O; fr; rv:1.7) Gecko/20040624 Firefox/0.9", "Mozilla/5.0 (Macintosh; U; PPC Mac OS X; en) AppleWebKit /48 (როგორც Gecko) Safari/48"); $შემთხვევითი = rand(0,count($userAgents)-1); დაბრუნება $userAgents[$random];)

გამოყენება CURLOPT_USERAGENT, შეგიძლიათ დააყენოთ მომხმარებლის აგენტის სტრიქონი.

Curl_setopt($ch,CURLOPT_USERAGENT,getRandomUserAgent());

4. გაუმკლავდეს გადამისამართებებს (HTTP 301,302)

URL-ის გადამისამართების დასამუშავებლად დააყენეთ CURLOPT_FOLLOWLOCATION TRUE-ზე. გადამისამართებების მაქსიმალური რაოდენობის კონტროლი შესაძლებელია CURLOPT_MAXREDIRS-ის გამოყენებით.

Curl_setopt($ch,CURLOPT_FOLLOWLOCATION,TRUE); curl_setopt($ch,CURLOPT_MAXREDIRS,2);//მხოლოდ 2 გადამისამართება

5.როგორ გავუმკლავდეთ CURL შეცდომებს

ჩვენ შეგვიძლია გამოვიყენოთ curl_errno(),curl_error() მეთოდები, რათა მივიღოთ ბოლო შეცდომები მიმდინარე სესიისთვის.
curl_error ($ch)-> აბრუნებს შეცდომას, როგორც სტრიქონს
curl_errno ($ch)-> აბრუნებს შეცდომის ნომერს
თქვენ შეგიძლიათ გამოიყენოთ ქვემოთ მოცემული კოდი შეცდომების მოსაგვარებლად.

ფუნქცია httpGetWithErros($url) ($ch = curl_init(); curl_setopt($ch,CURLOPT_URL,$url); curl_setopt($ch,CURLOPT_RETURNTRANSFER,true); $output=curl_exec($ch); if($output == = false) (echo "შეცდომის ნომერი:".curl_errno($ch)."
"; echo "შეცდომის სტრიქონი:".curl_error($ch); ) curl_close($ch); დაბრუნება $output;)

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

რატომ cURL?

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

$content = file_get_contents ("http://www.nettuts.com"); // ან $lines = ფაილი ("http://www.nettuts.com"); // ან readfile ("http://www.nettuts.com");

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

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

ძირითადი სტრუქტურა

• ინიციალიზაცია
• პარამეტრების მინიჭება
• შესრულება და შედეგის მიღება
• მეხსიერების გათავისუფლება

// 1. ინიციალიზაცია $ch = curl_init(); // 2. მიუთითეთ პარამეტრები, მათ შორის url curl_setopt ($ch, CURLOPT_URL, "http://www.nettuts.com"); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); curl_setopt($ch, CURLOPT_HEADER, 0); // 3. მიიღეთ HTML შედეგი $output = curl_exec($ch); // 4. დახურეთ კავშირი curl_close($ch);

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

შეცდომის შემოწმება

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

// ... $გამომავალი = curl_exec($ch); if ($output === FALSE) (echo "cURL შეცდომა: " . curl_error($ch); ) // ...

აქვე გთხოვ, თავადაც შენიშნო მნიშვნელოვანი წერტილი: შედარებისთვის უნდა გამოვიყენოთ "=== false" ნაცვლად "== false". მათთვის, ვინც არ იცის, ეს დაგვეხმარება განვასხვავოთ ცარიელი შედეგი და ლოგიკური მნიშვნელობა false, რაც მიუთითებს შეცდომაზე.

ინფორმაციის მიღება

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

// ... curl_exec($ch); $info = curl_getinfo ($ch); ექო "აიღო". $info["total_time"] . "წამები url-ისთვის". $info["url"]; //...

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

• "url"
• "content_type"
• "http_code"
• "header_size"
• "მოთხოვნის_ ზომა"
• "ფაილის დრო"
• „ssl_verify_result“
• „გადამისამართების_ რაოდენობა“
• „სულ_დრო“
• „namelookup_time“
• „connect_time“
• „წინასწარ გადაცემის_დრო“
• "size_upload"
• "ზომა_ჩამოტვირთვა"
• "speed_download"
• "speed_upload"
• „ჩამოტვირთვა_კონტენტის_სიგრძე“
• "ატვირთვის_შინაარსის_სიგრძე"
• „დაწყების გადაცემის დრო“
• „გადამისამართების_დრო“

გადამისამართების აღმოჩენა ბრაუზერის მიხედვით

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

ჩვენ ვაპირებთ გამოვიყენოთ CURLOPT_HTTPHEADER ვარიანტი ჩვენი გამავალი HTTP სათაურების განსასაზღვრად, მომხმარებლის ბრაუზერის სახელის ჩათვლით და ხელმისაწვდომი ენები. საბოლოოდ ჩვენ შევძლებთ განვსაზღვროთ რომელი საიტები გვიგზავნიან სხვადასხვა URL-ებზე.

// შეამოწმეთ URL $urls = array("http://www.cnn.com", "http://www.mozilla.com", "http://www.facebook.com"); // ბრაუზერების ტესტირება $browsers = array("სტანდარტული" => მასივი ("user_agent" => "Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.1.6) Gecko/20091201 Firefox/3.5 .6 (.NET CLR 3.5.30729)", "language" => "en-us,en;q=0.5"), "iphone" => მასივი ("user_agent" => "Mozilla/5.0 (iPhone; U ; CPU, როგორიცაა Mac OS X; ს.გ. => "Mozilla/4.0 (თავსებადი; MSIE 7.0; Windows NT 5.1; GTB6; .NET CLR 2.0.50727)", "language" => "fr,fr-FR;q=0.5")); foreach ($urls როგორც $url) ( echo "URL: $url\n"; foreach ($browsers როგორც $test_name => $browser) ($ch = curl_init(); // მიუთითეთ url curl_setopt($ch, CURLOPT_URL , $url // მიუთითეთ სათაურები ბრაუზერისთვის curl_setopt($ch, CURLOPT_HTTPHEADER, array("User-Agent: ($browser["user_agent"]), "Accept-Language: ($browser["language"]; )" )); // ჩვენ არ გვჭირდება გვერდის შინაარსი curl_setopt($ch, CURLOPT_NOBODY, 1); // ჩვენ უნდა მივიღოთ HTTP სათაურები curl_setopt($ch, CURLOPT_HEADER, 1); // შედეგების დაბრუნება curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1 $output = curl_exec($ch) იყო თუ არა HTTP გადამისამართება ("!Location: (.*)!"; , $matches) (echo "$test_name: გადამისამართდება $matches\n";) else (echo "$test_name: no redirection\n"; ) ) echo "\n\n";

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

ხრიკი, რომელსაც ამ მაგალითში ვიყენებთ cURL პარამეტრების დასაყენებლად, საშუალებას მოგვცემს მივიღოთ არა გვერდის შინაარსი, არამედ მხოლოდ HTTP სათაურები (შენახული $output-ში). შემდეგი, მარტივი რეგექსის გამოყენებით, შეგვიძლია განვსაზღვროთ, იყო თუ არა სტრიქონი „Location:“ მიღებულ სათაურებში.

როცა გარბიხარ ეს კოდი, თქვენ უნდა მიიღოთ მსგავსი შედეგი:

POST მოთხოვნის შექმნა კონკრეტულ URL-ზე

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

Http://www.google.com/search?q=ruseller

სიმულაციის მიზნით ამ თხოვნას, თქვენ არ გჭირდებათ cURL საშუალებების გამოყენება. თუ სიზარმაცე მთლიანად დაგძლევს, შედეგის მისაღებად გამოიყენეთ ფუნქცია “file_get_contents()”.

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

Http://codeigniter.com/forums/do_search/

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

Print_r ($_POST);

შემდეგ ჩვენ ვქმნით PHP სკრიპტს cURL მოთხოვნის გასაკეთებლად:

$url = "http://localhost/post_output.php"; $post_data = მასივი ("foo" => "ზოლი", "query" => "Nettuts", "action" => "გაგზავნა"); $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, $url); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // მიუთითეთ, რომ გვაქვს POST მოთხოვნა curl_setopt($ch, CURLOPT_POST, 1); // ცვლადების დამატება curl_setopt($ch, CURLOPT_POSTFIELDS, $post_data); $output = curl_exec($ch); curl_close ($ch); ექო $გამომავალი;

ამ სკრიპტის გაშვებისას თქვენ უნდა მიიღოთ ასეთი შედეგი:

ამრიგად, POST მოთხოვნა გაიგზავნა post_output.php სკრიპტზე, რომელიც თავის მხრივ გამოსცემს სუპერგლობალურ $_POST მასივს, რომლის შიგთავსი მივიღეთ cURL-ის გამოყენებით.

ფაილის ატვირთვა

პირველი, მოდით შევქმნათ ფაილი მისი გენერირების მიზნით და გავაგზავნოთ upload_output.php ფაილში:

Print_r ($_FILES);

და აქ არის სკრიპტის კოდი, რომელიც ასრულებს ზემოთ მოცემულ ფუნქციებს:

$url = "http://localhost/upload_output.php"; $post_data = მასივი ("foo" => "ზოლი", // ფაილი ასატვირთად "ატვირთვა" => "@C:/wamp/www/test.zip"); $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, $url); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); curl_setopt($ch, CURLOPT_POST, 1); curl_setopt($ch, CURLOPT_POSTFIELDS, $post_data); $output = curl_exec($ch); curl_close ($ch); ექო $გამომავალი;

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

მრავალი cURL

cURL-ის ერთ-ერთი ყველაზე ძლიერი მხარე არის cURL-ის "მრავალჯერადი" დამმუშავებლის შექმნის შესაძლებლობა. ეს საშუალებას გაძლევთ გახსნათ კავშირი მრავალ URL-თან ერთდროულად და ასინქრონულად.

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

მოდით გადავხედოთ php.net-დან აღებული კოდის მაგალითს:

// რამდენიმე cURL რესურსის შექმნა $ch1 = curl_init(); $ch2 = curl_init(); // მიუთითეთ URL და სხვა პარამეტრები curl_setopt($ch1, CURLOPT_URL, "http://lxr.php.net/"); curl_setopt($ch1, CURLOPT_HEADER, 0); curl_setopt ($ch2, CURLOPT_URL, "http://www.php.net/"); curl_setopt($ch2, CURLOPT_HEADER, 0); //მრავალჯერადი cURL დამმუშავებლის შექმნა $mh = curl_multi_init(); //დაამატე რამდენიმე დამმუშავებელი curl_multi_add_handle($mh,$ch1); curl_multi_add_handle($mh,$ch2); $active = null; //შეასრულეთ გაკეთება ($mrc = curl_multi_exec($mh, $active); ) ხოლო ($mrc == CURLM_CALL_MULTI_PERFORM); while ($active && $mrc ​​== CURLM_OK) ( if (curl_multi_select($mh) != -1) (do ($mrc = curl_multi_exec($mh, $active); ) ხოლო ($mrc == CURLM_CALL_MULTI_PERFORM ) ) //curl_multi_remove_handle-ის დახურვა ($mh, $ch1); curl_multi_remove_handle($mh, $ch2); curl_multi_close ($mh);

იდეა არის ის, რომ შეგიძლიათ გამოიყენოთ მრავალი cURL დამმუშავებელი. მარტივი მარყუჟის გამოყენებით, შეგიძლიათ თვალყური ადევნოთ, რომელი მოთხოვნები ჯერ არ დასრულებულა.

ამ მაგალითში ორი ძირითადი მარყუჟია. პირველი do-while ციკლიიძახებს curl_multi_exec() ფუნქციას. ეს ფუნქცია არ არის დაბლოკილი. ის მუშაობს რაც შეიძლება სწრაფად და აბრუნებს მოთხოვნის სტატუსს. სანამ დაბრუნებული მნიშვნელობა არის მუდმივი „CURLM_CALL_MULTI_PERFORM“, ეს ნიშნავს, რომ სამუშაო ჯერ არ დასრულებულა (მაგალითად, ამჟამად იგზავნება http სათაურები URL-ში); ამიტომ ჩვენ ვაგრძელებთ ამ დაბრუნების მნიშვნელობის შემოწმებას, სანამ არ მივიღებთ განსხვავებულ შედეგს.

შემდეგ ციკლში ჩვენ ვამოწმებთ მდგომარეობას, ხოლო ცვლადი $active = "true". ეს არის curl_multi_exec() ფუნქციის მეორე პარამეტრი. ამ ცვლადის მნიშვნელობა იქნება "true", სანამ ნებისმიერი არსებული ცვლილება აქტიურია. შემდეგ ჩვენ მოვუწოდებთ curl_multi_select() ფუნქციას. მისი შესრულება "დაბლოკილია", მაშინ როცა არის ერთი მაინც აქტიური კავშირიპასუხის მიღებამდე. როდესაც ეს მოხდება, ჩვენ ვუბრუნდებით მთავარ ციკლს, რათა გავაგრძელოთ მოთხოვნების შესრულება.

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

ბმულების შემოწმება WordPress-ში

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

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

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

საბოლოოდ დავიწყოთ. ჯერ უნდა მოვიტანოთ ყველა ბმული მონაცემთა ბაზიდან:

// კონფიგურაცია $db_host = "localhost"; $db_user = "root"; $db_pass = ""; $db_name = "wordpress"; $excluded_domains = მასივი ("localhost", "www.mydomain.com"); $max_connections = 10; // ცვლადების ინიციალიზაცია $url_list = array(); $working_urls = მასივი(); $dead_urls = მასივი(); $not_found_urls = მასივი(); $active = null; // დაუკავშირდით MySQL-ს, თუ (!mysql_connect($db_host, $db_user, $db_pass)) ( die("დაკავშირება ვერ მოხერხდა: " . mysql_error()); ) if (!mysql_select_db($db_name)) ( die("შეუძლია არ აირჩიეთ db: " . mysql_error()); ) // აირჩიეთ ყველა გამოქვეყნებული პოსტი ბმულებით $q = "SELECT post_content FROM wp_posts WHERE post_content LIKE "%href=%" AND post_status = "publish" AND post_type = "post "" ; $r = mysql_query($q) ან die(mysql_error()); while ($d = mysql_fetch_assoc($r)) (// ბმულების მიღება რეგულარული გამონათქვამების გამოყენებით if (preg_match_all("!href=\"(.*?)\"!", $d["post_content"], $ შეესაბამება) ) ( foreach ($ შეესაბამება $url-ს) ( $tmp = parse_url($url); if (in_array($tmp["host"], $excluded_domains)) ( გაგრძელება; ) $url_list = $url; ) ) ) / / ამოიღეთ დუბლიკატები $url_list = array_values(array_unique($url_list)); if (!$url_list) ( die ("URL არ არის შესამოწმებელი"); )

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

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

// 1. მრავალჯერადი დამმუშავებელი $mh = curl_multi_init(); // 2. დაამატეთ URL-ების ნაკრები ($i = 0; $i< $max_connections; $i++) { add_url_to_multi_handle($mh, $url_list); } // 3. инициализация выполнения do { $mrc = curl_multi_exec($mh, $active); } while ($mrc == CURLM_CALL_MULTI_PERFORM); // 4. основной цикл while ($active && $mrc == CURLM_OK) { // 5. если всё прошло успешно if (curl_multi_select($mh) != -1) { // 6. делаем дело do { $mrc = curl_multi_exec($mh, $active); } while ($mrc == CURLM_CALL_MULTI_PERFORM); // 7. если есть инфа? if ($mhinfo = curl_multi_info_read($mh)) { // это значит, что запрос завершился // 8. извлекаем инфу $chinfo = curl_getinfo($mhinfo["handle"]); // 9. мёртвая ссылка? if (!$chinfo["http_code"]) { $dead_urls = $chinfo["url"]; // 10. 404? } else if ($chinfo["http_code"] == 404) { $not_found_urls = $chinfo["url"]; // 11. рабочая } else { $working_urls = $chinfo["url"]; } // 12. чистим за собой curl_multi_remove_handle($mh, $mhinfo["handle"]); // в случае зацикливания, закомментируйте ეს ზარი curl_close ($mhinfo["სახელური"]);

// 13. დაამატეთ ახალი url და გააგრძელეთ მუშაობა, თუ (add_url_to_multi_handle($mh, $url_list)) ( გააკეთეთ ( $mrc ​​= curl_multi_exec($mh, $active); ) ხოლო ($mrc == CURLM_CALL_MULTI_PERFORM); ) ) ) ) // 14. დასრულება curl_multi_close($mh); echo "==მკვდარი URLs==\n"; echo implode("\n",$dead_urls) . "\n\n"; ექო "==404 URL==\n"; echo implode("\n",$not_found_urls) . "\n\n"; echo "==სამუშაო URLs==\n"; echo implode("\n",$working_urls); ფუნქცია add_url_to_multi_handle($mh, $url_list) ( სტატიკური $index = 0; // თუ გვაქვს მეტი url, რომლებიც უნდა მოვიძიოთ, თუ ($url_list[$index]) ( // new curl handler $ch = curl_init(); // მიუთითეთ url curl_setopt ($ch, CURLOPT_URL, $ url_setopt) ($ch, CURLOPT_RETURNTRANSFER, 1, CURLOPT_FOLLOWLOCATION, 10000$); $mh, $ch // გადადით შემდეგ url-ზე $index++ (// ახალი URL-ების დამატება დასრულდა false;

1. აქ შევეცდები დეტალურად აგიხსნათ ყველაფერი. სიაში ნომრები შეესაბამება კომენტარში მოცემულ ნომრებს.
2. 1. მრავალჯერადი დამმუშავებლის შექმნა;
3. 2. add_url_to_multi_handle() ფუნქციას ცოტა მოგვიანებით დავწერთ. ყოველ ჯერზე დარეკვისას დაიწყება ახალი url-ის დამუშავება. თავდაპირველად ვამატებთ 10 ($max_connections) URL-ს;
4. 3. დასაწყებად უნდა გავუშვათ curl_multi_exec() ფუნქცია. სანამ ის დააბრუნებს CURLM_CALL_MULTI_PERFORM-ს, ჩვენ ჯერ კიდევ გვაქვს გასაკეთებელი. ეს ძირითადად კავშირების შესაქმნელად გვჭირდება;
5. 4. შემდეგ მოდის მთავარი ციკლი, რომელიც იმუშავებს მანამ, სანამ გვექნება მინიმუმ ერთი აქტიური კავშირი;
6. 5. curl_multi_select() ჩერდება URL ძიების დასრულებას;
7. 6. კიდევ ერთხელ, ჩვენ უნდა ვაიძულებთ cURL-ს გარკვეული სამუშაოს შესრულებას, კერძოდ, დაბრუნების პასუხის მონაცემების მოძიებას;
8. 7. ინფორმაცია აქ გადამოწმებულია. მოთხოვნის შესრულების შედეგად მასივი დაბრუნდება;
9. 8. დაბრუნებული მასივი შეიცავს cURL დამმუშავებელს. ჩვენ მას გამოვიყენებთ ცალკე cURL მოთხოვნის შესახებ ინფორმაციის შესარჩევად;
10. 9. თუ ბმული მკვდარი იყო, ან სკრიპტის დრო ამოიწურა, მაშინ არ უნდა ვეძებოთ რაიმე http კოდი;
11. 10. თუ ლინკმა დაგვიბრუნა 404 გვერდი, მაშინ http კოდი შეიცავს 404 მნიშვნელობას; 11. თორემ წინ გვაქვსსამუშაო ბმული . (შეგიძლიათ დაამატოთდამატებითი შემოწმებები
12. 12. შემდეგ ჩვენ ვხსნით cURL დამმუშავებელს, რადგან ის აღარ გვჭირდება;
13. 13. ახლა შეგვიძლია დავამატოთ კიდევ ერთი url და გავუშვათ ყველაფერი, რაზეც ადრე ვისაუბრეთ;
14. 14. ამ ეტაპზე სკრიპტი ასრულებს თავის სამუშაოს. ჩვენ შეგვიძლია წავშალოთ ყველაფერი, რაც არ გვჭირდება და შევქმნათ ანგარიში;
15. 15. ბოლოს დავწერთ ფუნქციას, რომელიც დაამატებს url-ს დამმუშავებელს. სტატიკური ცვლადი $index ყოველ ჯერზე გაიზრდება ამ ფუნქციასდაიძახებენ.

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

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

რამდენიმე სიტყვა სხვა სასარგებლო cURL ვარიანტების შესახებ

HTTP ავთენტიფიკაცია

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

$url = "http://www.somesite.com/members/"; $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, $url); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // მიუთითეთ მომხმარებლის სახელი და პაროლი curl_setopt($ch, CURLOPT_USERPWD, "myusername:mypassword"); // თუ გადამისამართება დასაშვებია curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1); // შემდეგ შეინახეთ ჩვენი მონაცემები cURL curl_setopt ($ch, CURLOPT_UNRESTRICTED_AUTH, 1); $output = curl_exec($ch); curl_close ($ch);

FTP ატვირთვა

PHP-ს ასევე აქვს ბიბლიოთეკა FTP-თან მუშაობისთვის, მაგრამ არაფერი გიშლით ხელს აქ cURL ინსტრუმენტების გამოყენებაში:

// გახსენით ფაილი $file = fopen("/path/to/file", "r"); // url უნდა შეიცავდეს შემდეგ შინაარსს $url = "ftp://username: [ელფოსტა დაცულია]:21/გზა/ახალი/ფაილი"; $ch = curl_init(); curl_setopt($ch, CURLOPT_URL, $url); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); curl_setopt($ch, CURLOPT_UPLOAD, 1); curl_setopt($ch, CURLOPT_INFILE, $fp curl_setopt($ch, CURLOPT_INFILESIZE, ფაილის ზომა("/path/to/file") curl_close($ch);

პროქსის გამოყენება

თქვენ შეგიძლიათ შეასრულოთ თქვენი URL მოთხოვნა პროქსის მეშვეობით:

$ch = curl_init(); curl_setopt($ch, CURLOPT_URL,"http://www.example.com"); curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); // მიუთითეთ მისამართი curl_setopt($ch, CURLOPT_PROXY, "11.11.11.11:8080"); // თუ გჭირდებათ მომხმარებლის სახელი და პაროლი curl_setopt($ch, CURLOPT_PROXYUSERPWD,"user:pass"); $output = curl_exec($ch); curl_close ($ch);

გამოძახების ფუნქციები

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

$ch = curl_init(); curl_setopt($ch, CURLOPT_URL,"http://net.tutsplus.com"); curl_setopt($ch, CURLOPT_WRITEFUNCTION,"პროგრესი_ფუნქცია"); curl_exec ($ch); curl_close ($ch); ფუნქცია progress_function($ch,$str) (echo $str; return strlen($str); )

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

დასკვნა

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

გმადლობთ! სასიამოვნო დღეს გისურვებთ!

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

მოკლედ აღვწერ რა არის და რითი მიირთმევენ:

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

რეალური მაგალითი:

თქვენ გაქვთ API, რომელიც ახლახან შეიმუშავეთ და დროა დაიწყოთ მასთან მუშაობა. თქვენ შეგიძლიათ დაწეროთ თქვენი საკუთარი ბიბლიოთეკა ან თუნდაც მინი-კლასი მასთან მუშაობისთვის, მაგრამ (1) დიდ დროს წაგართმევთ და ეს ასეც რომ არ იყოს, სავარაუდოდ, გამოსავალი არ იქნება საუკეთესო, ( 2) მას მუდმივად სჭირდება მხარდაჭერა და გაუმჯობესება. ამ შემთხვევაში, უმჯობესია გამოიყენოთ მზა ხსნარი, რომელსაც მხარს უჭერს დიდი საზოგადოება და Guzzle-ის საცავში უკვე 12 ათასი ვარსკვლავია, რაც ძალიან დასაფასებელია.

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

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

// ქმნის კლიენტს საბაზისო URI-ით $client = new GuzzleHttp\Client(["base_uri" => "http://site/"]); // ახლა თქვენ შეგიძლიათ გაგზავნოთ მოთხოვნა http://bologe-ზე.. Guzzle-ს ახსოვს საბაზისო ბმული და ახლა შეგიძლიათ მხოლოდ შემდეგი გვერდების მითითება მოხერხებულობისთვის $response = $client->request("GET", "about");

მაგარია? ძალიან მომწონს.

Guzzle-ის დოკუმენტაცია საკმაოდ ვრცელია, ყველა ვარიანტის აღწერა შეუძლებელია და ამას მთელი პოსტი სჭირდება, რომელსაც აუცილებლად დავწერ მალე :)

შემდგომი სიტყვა

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

ეს პროგრამული უზრუნველყოფა, რომელიც შედგება ბრძანების სტრიქონისგან და ბიბლიოთეკისგან, რომელიც შექმნილია მონაცემების გადასატანად სხვადასხვა პროტოკოლებზე (HTTP, FTP, POP3, IMAP, SMTP და მრავალი სხვა). ჩვენ განვიხილავთ მხოლოდ ბრძანების სტრიქონს, რომელსაც მის სახელად დავწერთ "curl". მისი გამოყენებით შეძენილი უნარები აადვილებს libcurl ბიბლიოთეკასთან მუშაობის დაუფლებას. გარდა ამისა, ჩვენ შემოვიფარგლებით HTTP მოთხოვნების ფორმირებით: GET და POST.

წინასწარი ინფორმაცია

HTTP პროტოკოლი

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

-v გადამრთველის გამოყენებით, თქვენ ხედავთ ზუსტად რა ბრძანებებს უგზავნის სერვერს curl. ეს გასაღები შესაძლებელს ხდის Curl-სა და ვებ სერვერს შორის ურთიერთქმედების თავისებურებების გაგებას და ეხმარება მოთხოვნის გამართვას.

URL

URL (Uniform Resource Locator) განსაზღვრავს კონკრეტული რესურსის მისამართს ინტერნეტში. მაგალითად, cURL ვებ გვერდის URL იწერება ასე: http://curl.haxx.se.

ფორმები

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

მითითება

დახმარება curl-ისთვის შეგიძლიათ მიიღოთ აკრეფით ბრძანების ხაზი

$ - ბრძანების ხაზი.

მიიღეთ გვერდის შინაარსი (GET)

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

$ curl http://curl.haxx.se

თქვენ მიიღებთ ვებ გვერდის გამოსავალს ტერმინალის ფანჯარაში (უფრო ზუსტად, სტანდარტულ გამომავალზე). ამ გვერდის curl.html ფაილში შესანახად, თქვენ უნდა მიუთითოთ

$ curl http://curl.haxx.se -o "curl.html"

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

გაგზავნეთ GET მოთხოვნა ფორმადან

მოთხოვნის ფორმას შეუძლია გამოიყენოს GET მეთოდი. მაგალითად, ასე:

თუ ამ კოდს გახსნით ბრაუზერში, დაინახავთ ფორმას ტექსტური ველით და ღილაკით წარწერით "OK". თუ თქვენ, მაგალითად, ფორმაში შეიყვანთ "1990" და დააწკაპუნებთ "OK", ბრაუზერი შექმნის ახალ URL-ს, რომელსაც მიჰყვება. ეს URL იქნება სტრიქონი, რომელიც შედგება წინა URL-ისგან და მოთხოვნის სტრიქონისაგან, როგორიცაა: foo.cgi?year=1990&press=OK . ასე რომ, თუ ფორმა განთავსებული იყო მისამართზე www.foo.com/year.html (მისამართი ამოღებულია „ჰაერიდან“!), მაშინ როდესაც დააჭერთ ღილაკს „OK“ გადაგიყვანთ URL-ზე. www.foo.com/foo.cgi?year= 1990&press=OK.

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

$ curl "www.foo.com/foo.cgi?year=1990&press=OK"

POST მეთოდი

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

POST მოთხოვნის წარმომქმნელი ფორმა წინასგან განსხვავდება მხოლოდ გაგზავნის მეთოდით:

curl გამოიმუშავებს POST მოთხოვნას იგივე მონაცემებით შემდეგნაირად:

$ curl -d "year=1990&press=%20OK%20" www.foo.com/foo.cgi

გთხოვთ გაითვალისწინოთ, რომ თქვენს მიერ სერვერზე გაგზავნილი მონაცემები სწორად უნდა იყოს კოდირებული. curl არ გააკეთებს ამას თქვენთვის. მაგალითად, თუ გსურთ, რომ მონაცემები შეიცავდეს სივრცეს, მაშინ ეს სივრცე უნდა შეცვალოთ %20-ით და ა.შ. ეს არის ერთ-ერთი ყველაზე გავრცელებული შეცდომა, რის შედეგადაც მონაცემები არ გადადის ისე, როგორც მოსალოდნელია.

ფაილების ატვირთვა POST-ის გამოყენებით

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

გაითვალისწინეთ, რომ Content-Type დაყენებულია მრავალნაწილიან/ფორმა-მონაცემებზე.

ამ ფორმაში მონაცემების გასაგზავნად curl-ის გამოყენებით, შეიყვანეთ:

$ curl -F ატვირთვა = @localfilename -F დააჭირეთ = OK [ფორმა გვერდის URL]

დამალული ფორმის ველები

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

ფორმის მაგალითი ერთი ხილული და ერთი ფარული ველით:

POST მოთხოვნის გასაგზავნად curl-ით, თქვენ არ გჭირდებათ ფიქრი იმაზე, არის თუ არა ველი დამალული - curl-ისთვის, ყველა ველი ერთნაირია:

$ curl -დ "year=1990&press=OK&person=daniel"[URL]

როგორ გამოიყურება POST მოთხოვნა შიგნიდან?

როდესაც ავსებთ ფორმას curl-ის გამოყენებით და აგზავნით მას სერვერზე, ალბათ გსურთ, რომ curl-ის მიერ გენერირებული POST მოთხოვნა ისეთივე გამოიყურებოდეს, როგორც ბრაუზერის გამოყენებით გაკეთებული.

თქვენი POST მოთხოვნის სანახავად უმარტივესი გზაა ეს:

1. შეინახეთ ვებ გვერდი ფორმაში დისკზე;
2. მეთოდის შეცვლა GET-ზე;
3. დააწკაპუნეთ ღილაკზე „გაგზავნა“ (ასევე შეგიძლიათ შეცვალოთ URL, რომელზედაც გაიგზავნება მონაცემები).

დაინახავთ URL-ზე დართული და სიმბოლოებით გამოყოფილი მონაცემებს? , როგორც მოსალოდნელია GET ფორმების გამოყენებისას.