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

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

მათემატიკური მოქმედებები

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

არითმეტიკული მოქმედებები

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

არითმეტიკული მოქმედებები

ოპერაცია	აღწერა
+	აბრუნებს მისი ორი ოპერანდის მნიშვნელობების ჯამს
-	თუ ორი ოპერანდია, მაშინ მარჯვენა ოპერანდის მნიშვნელობა კლებულობს მარცხენას მნიშვნელობას. თუ არსებობს მხოლოდ მარჯვენა ოპერანდი, მაშინ ოპერაცია აბრუნებს ამ ოპერანდის მნიშვნელობას საპირისპირო ნიშნით.
*	აბრუნებს მისი ორი ოპერანდის მნიშვნელობების ნამრავლს
/	აბრუნებს მარცხენა ოპერანდის მნიშვნელობის მარჯვენა ოპერანდის მნიშვნელობაზე გაყოფის მცურავი წერტილის შედეგს
%	აბრუნებს მთელი რიცხვის ნარჩენს გაყოფილი მარცხენა ოპერანდის მნიშვნელობაზე მარჯვენა ოპერანდის აბსოლუტურ მნიშვნელობაზე

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

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

მატებისა და შემცირების ოპერაციები

PHP-ის სინტაქსის დიდი ნაწილი მომდინარეობს C-დან და C პროგრამისტები ცნობილია ლაკონურობის სიყვარულით და ამაყობენ ამით. C ენიდან აღებული increment და decrement ოპერატორები შესაძლებელს ხდის უფრო მოკლედ წარმოაჩინონ ისეთი გამონათქვამები, როგორიცაა $count = $count + 1, რომლებიც ჩვეულებრივ საკმაოდ ხშირად გვხვდება პროგრამებში.

ინკრემენტის ოპერატორი (++) გამოიყენება ცვლადის მნიშვნელობის დასამატებლად, რომელიც გავლენას ახდენს ოპერაციაზე, ხოლო შემცირების ოპერატორი (--) აკლებს ერთს ამ ცვლადის მნიშვნელობას.

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

PHP კოდი $count = 0; $შედეგი = $count++; echo "$count++ increment-ის შედეგი: ".$result."
"; $count = 0; $result = ++$count; echo "++$count increment-ის შედეგი: ".$result."
";

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

ინკრეტული ოპერაციები

ამ მაგალითში ოპერატორი $result = $count++ სრულიად ექვივალენტურია ოპერატორებთან:

PHP კოდი $შედეგი = $count; $count = $count + 1;

ამასთან ერთად, ოპერატორი $result = ++$count არის შემდეგი ოპერატორების ექვივალენტი:

PHP კოდი $count = $count +1; $შედეგი = $count;

დავალების ოპერატორები

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

PHP კოდი $count = $count * 3;

შეიძლება შემოკლებული იყოს როგორც

PHP კოდი $count *= 3;

მარტივი მათემატიკის ფუნქციები

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

მარტივი PHP მათემატიკის ფუნქციები

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

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

PHP კოდი $შედეგი = min(3, abs(-3), max(მრგვალი(2.7), ჭერი(2.3), იატაკი(3.9)));

შემთხვევითი რიცხვების გენერირება

PHP ენა იყენებს ორ შემთხვევითი რიცხვების გენერატორს (მოწოდებული შესაბამისად ფუნქციების გამოყენებით rand ()და mt_rand()). თითოეული ეს გენერატორი ასოცირდება იმავე მიზნის სამ ფუნქციასთან: საწყისი მნიშვნელობის დაყენების ფუნქცია ( srand ()და mt_srand ()), თავად ფუნქცია შემთხვევითი რიცხვის მისაღებად და ფუნქცია, რომელიც აგროვებს ყველაზე დიდ რიცხვს, რომელიც შეიძლება დაბრუნდეს გენერატორის მიერ (( getrandmax ()და mt_getrandmax())). getrandmax() და mt_getrandmax() ფუნქციები აბრუნებს უდიდეს რიცხვს, რომელიც შეიძლება დაბრუნდეს rand() ან mt_rand() მიერ, რომელიც შემოიფარგლება 32768-ით Windows პლატფორმებზე.

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

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

PHP-ის შემთხვევითი რიცხვების ნებისმიერი გენერატორისთვის (mt_srand() ან srand() ფუნქციის გამოყენებით სათესლე მნიშვნელობის დაყენების ტიპიური გზა არის შემდეგი:

PHP კოდი mt_srand((double)microtime()*1000000);

ეს ოპერატორი ადგენს გენერატორის საწყის მნიშვნელობას, უდრის მიკროწამების რაოდენობას, რომელიც ამ დროისთვის გავიდა ბოლო მთელი წამის დათვლიდან. (ამ განცხადებაში cast გაორმაგება რეალურად აუცილებელია, რადგან microtime() ფუნქცია აბრუნებს სტრიქონს, რომელიც განიხილება როგორც მთელი რიცხვი გამრავლების ოპერაციაში, მაგრამ არა ფუნქციაში პარამეტრების გადაცემის ოპერაციაში.) ჩვენ გირჩევთ, რომ მკითხველმა შეიყვანოს მითითებული ინიციალიზაციის ოპერატორი მაშინაც კი, თუ ამ ოპერატორის დანიშნულება მისთვის სრულიად ნათელი არ არის; ამ განცხადების უბრალოდ განთავსება ყველა PHP გვერდზე, მხოლოდ ერთხელ, შესაბამისი mt_rand() ან rand() ფუნქციის გამოყენებამდე, უზრუნველყოფს, რომ საწყისი წერტილი შეიცვლება და, შესაბამისად, ყოველ ჯერზე წარმოიქმნება განსხვავებული შემთხვევითი თანმიმდევრობა.

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

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

PHP კოდი // ვთქვათ, ჩვენ გვჭირდება შემთხვევითი რიცხვის გენერირება 100.0-დან 120.0-მდე $random = 100.0 + 20.0 * mt_rand() / mt_getrandmax(); ექო $ შემთხვევითი."
"; // მთელი რიცხვების გენერირება (100 - 120); ექო რაუნდი ($ შემთხვევითი);

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

მათემატიკური მუდმივები

PHP ვერსიაში 4.0 იყო მხოლოდ ერთი მათემატიკური მუდმივი აღწერილი დოკუმენტაციაში - M_PI (π-ის მნიშვნელობა, წარმოდგენილი ორმაგი სიზუსტით მცურავი წერტილის რიცხვის სახით). და დაწყებული PHP 4.0.2-ით, დაინერგა მრავალი ახალი მუდმივი. ამ ახალი მუდმივების უმეტესობა დაკავშირებულია π (ან მის ჯერადებთან), e (ან მის ჯერადებთან) და კვადრატულ ფესვებთან; გარდა ამისა, ზოგიერთი მუდმივი მიეკუთვნებოდა სხვა ტიპებს. მაგრამ შემდგომ გამოშვებებში, მრავალი მიზეზის გამო, მუდმივთა სია კვლავ შემცირდა წინასწარ განსაზღვრულ მათემატიკური მუდმივების შედარებით მცირე რაოდენობამდე:

PHP მათემატიკური მუდმივები

მუდმივი	აღწერა
M_PI	π
M_PI_2	π/2
M_PI_4	π/4
M_1_PI	1/π
M_2_PI	2/π
M_2_SQRTPI	2 / sqrt (π)
M_E	ე
M_SQRT2	sqrt (2)
M_SQRT1_2	1 / sqrt (2)
M_LOG2E	log2(e)
M_LOG10E	ჟურნალი (ე)
M_LN2	ლოჯი (2)
M_LN10	ჟურნალი (10)

ნომრის ფორმატის შემოწმება

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

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

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

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

PHP კოდი is_numeric(4); // true is_numeric(25 - 6); // true is_numeric("25"); // true is_numeric("25 - 6"); // false is_int(4); // true is_int(4.2); // false is_int("4"); // false - ეს შემოწმება უფრო მკაცრია, ვიდრე შემოწმება is_numeric() ფუნქციის გამოყენებით is_float(4); // false is_float(4.0); // true is_float(M_PI); // მართალია

რიცხვითი სისტემების კონვერტაცია

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

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

რიცხვების სისტემის კონვერტაციის ფუნქციები

ფუნქცია	აღწერა
BinDec ()	იღებს ერთი სტრიქონის პარამეტრს, რომელიც არის ორობითი მთელი რიცხვი (ბაზის 2 რიცხვი) და აბრუნებს ამ რიცხვის ბაზის 10 სტრიქონის წარმოდგენას
DecBin ()	BinDec()-ის მსგავსია, მაგრამ გარდაიქმნება 10-დან მე-2-მდე
ოქტომბერი ()	BinDec()-ის მსგავსია, მაგრამ გარდაიქმნება ბაზიდან 8-დან 10-მდე
DecOct ()	BinDec()-ის მსგავსია, მაგრამ გარდაიქმნება 10-დან 8-მდე
HexDec ()	BinDec()-ის მსგავსია, მაგრამ გარდაიქმნება ბაზიდან 16-დან 10-მდე
DecHex ()	BinDec()-ის მსგავსია, მაგრამ გარდაიქმნება ბაზიდან 10-დან 16-მდე
base_convert()	იღებს სტრიქონის პარამეტრს (რომელიც წარმოადგენს გადასაყვან მთელ რიცხვს) და ორ მთელ პარამეტრს (ორიგინალი და სასურველი რადიქსი). აბრუნებს სტრიქონს, რომელიც წარმოადგენს გარდაქმნილ რიცხვს. ამ ხაზში 9-ზე მეტი რიცხვები (10-დან 35-მდე) წარმოდგენილია a-z სიმბოლოებით. ორიგინალიც და სასურველი ბაზებიც უნდა იყოს 2-36-ის ფარგლებში

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

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

ექსპონენტები და ლოგარითმები

PHP ენა მოიცავს სტანდარტულ ექსპონენციალურ და ლოგარითმულ ფუნქციებს ორ ჯიშში - 10-ე ბაზაზე მუშაობისთვის და ბაზაზე e (რომლებიც ნაჩვენებია ცხრილში).

PHP უზრუნველყოფს exp() ფუნქციას, რომ e აიყვანოს მოცემულ სიმძლავრემდე, მაგრამ არ არსებობს ერთი პარამეტრიანი ფუნქცია, რომ აიყვანოს 10 მოცემულ სიმძლავრემდე, მაგრამ ამის ნაცვლად შეგიძლიათ გამოიყენოთ pow() ფუნქცია, რომელიც იღებს ორ პარამეტრს, რაც იძლევა 10-ს როგორც პირველი პარამეტრი.

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

PHP კოდი $test_449 = 449.0; $test_449 = pow(10, exp(log(log10($test_449)))); echo "test_449 = $test_449"; // ტესტი_449 = 449

ტრიგონომეტრიული ფუნქციები

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

ტრიგონომეტრიული ფუნქციები

ფუნქცია	აღწერა
pi ()	ის არ იღებს პარამეტრებს და აბრუნებს π (3.1415926535898) სავარაუდო მნიშვნელობას. შეიძლება გამოყენებულ იქნას ურთიერთშენაცვლებით M_PI მუდმივთან
sin ()	იღებს ციფრულ პარამეტრს რადიანებში და აბრუნებს პარამეტრის სინუსს, როგორც ორმაგი სიზუსტის მცურავი წერტილის რიცხვს
cos()	იღებს ციფრულ პარამეტრს რადიანებში და აბრუნებს პარამეტრის კოსინუსს, როგორც ორმაგი სიზუსტის მცურავი წერტილის რიცხვი
tan ()	იღებს ციფრულ პარამეტრს რადიანებში და აბრუნებს პარამეტრის ტანგენტს, როგორც ორმაგი სიზუსტის მცურავი წერტილის რიცხვს
asin ()	იღებს ციფრულ პარამეტრს და აბრუნებს პარამეტრის რკალს რადიანებში. შეყვანები უნდა იყოს -1-დან 1-მდე (ამ დიაპაზონის გარეთ შეყვანის მიმღების ფუნქცია იწვევს NAN შედეგს). შედეგები მერყეობს -π/2-დან π/2-მდე
acos ()	იღებს ციფრულ პარამეტრს და აბრუნებს პარამეტრის რკალის კოსინუსს რადიანებში. შეყვანები უნდა იყოს -1-დან 1-მდე დიაპაზონში (ამ დიაპაზონის გარეთ შეყვანის მიმღები ფუნქცია იწვევს NAN შედეგს. შედეგები არის 0-დან π დიაპაზონში.
ატან ()	იღებს ციფრულ პარამეტრს და აბრუნებს პარამეტრის არქტანგენტს რადიანებში. შედეგები მერყეობს -π/2-დან π/2-მდე

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

PHP კოდი ფუნქცია display_trigonometri ($func_array, $input_array) (// ფუნქციის სათაურის echo " ";) ექო""; // დაბეჭდეთ ცხრილის დარჩენილი ნაწილი foreach($input_array $input-ად) (echo" "; foreach ($func_array როგორც $func) (echo" ";) ექო"";) ექო"

მნიშვნელობა/ფუნქცია	$ fun
".sprintf("%.4f",$input)."	"; printf("%4.4f", $func($input)); echo "

"; ) ჩვენება_ტრიგონომეტრია(მასივი("sin", "cos", "tan"), მასივი (0, M_PI / 6, M_PI / 3, M_PI / 2, M_PI));
PHP-ში ტრიგონომეტრიული ფუნქციების გამოყენების მაგალითი

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

თვითნებური სიზუსტის გაანგარიშება (BC ფუნქციების გამოყენებით)

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

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

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

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

თვითნებური ზუსტი მათემატიკური ფუნქციები (BC ფუნქციები)

ფუნქცია	აღწერა
bcadd ()	იღებს ორ სტრიქონის პარამეტრს, რომლებიც წარმოადგენს რიცხვებს და არასავალდებულო მთელი რიცხვის პარამეტრს, რომელიც მიუთითებს მასშტაბის ფაქტორზე. აბრუნებს პირველი ორი პარამეტრის ჯამს სტრიქონის სახით, შედეგში ათობითი ადგილების რაოდენობა განისაზღვრება პარამეტრით, რომელიც მიუთითებს მასშტაბის ფაქტორზე. თუ პარამეტრი, რომელიც მიუთითებს მასშტაბის ფაქტორზე, არ არის მითითებული, მაშინ გამოიყენება ნაგულისხმევი მასშტაბის ფაქტორი
bcsub ()	მსგავსია bcadd(), გარდა იმისა, რომ აბრუნებს მეორე პარამეტრის პირველს გამოკლების შედეგს
bcmui ()	მსგავსია bcadd(), გარდა იმისა, რომ აბრუნებს მისი პარამეტრების გამრავლების შედეგს
bcdiv ()	მსგავსია bcadd(), გარდა იმისა, რომ აბრუნებს პირველი პარამეტრის მეორეზე გაყოფის შედეგს
bcmod ()	აბრუნებს პირველი პარამეტრის მეორეზე გაყოფის მოდულს (დარჩენილს). იმის გამო, რომ დაბრუნებული მნიშვნელობა არის მთელი რიცხვი, ფუნქცია არ იღებს პარამეტრს, რომელიც მიუთითებს მასშტაბის ფაქტორზე
bcpow ()	ამაღლებს პირველ პარამეტრს მეორე პარამეტრით მითითებულ სიმძლავრემდე. შედეგში ათობითი ადგილების რაოდენობა განისაზღვრება მასშტაბის ფაქტორით, თუ მითითებულია
bcsqrt()	აბრუნებს პარამეტრის კვადრატულ ფესვს ათწილადების რიცხვით, რომელიც განისაზღვრება არასავალდებულო მასშტაბის ფაქტორის მნიშვნელობით
bcscale()	ადგენს ნაგულისხმევი მასშტაბის ფაქტორს BC ფუნქციის შემდგომი ზარებისთვის

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

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

PHP კოდი ამისთვის ($x = 1; $x< 25; $x++) { echo "$x^$x= ".bcpow($x, $x)."
"; } ასტრონომიული სიდიდეების ზუსტი გამოთვლა BC ფუნქციების გამოყენებით

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

მასივების ფორმის დამუშავება 1 2 3 4 5 6 7 8 9 10

ოპერაციები PHP ცვლადებით (ოპერატორები)

განსახორციელებლად სხვადასხვა ჯგუფებია.

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

არითმეტიკული ოპერაციები PHP-ში

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

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

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

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

მატებისა და შემცირების ოპერაციები

PHP, ისევე როგორც C, მხარს უჭერს პრეფიქსის და პოსტფიქსის მატებისა და შემცირების ოპერატორებს.

Postfix increment and decrement ოპერატორები

როგორც C-ში, ეს ოპერატორები ზრდიან ან ამცირებენ ცვლადის მნიშვნელობას და გამოხატულებაში აბრუნებენ ცვლადის მნიშვნელობას $aცვლილებამდე. მაგალითად:

$a=10;
$b=$a++;
ექო "a=$a, b=$b"; // ბეჭდავს a=11, b=10

როგორც ხედავთ, ჯერ ცვლადი $bმნიშვნელობა ენიჭება ცვლადს $a, და მხოლოდ ამის შემდეგ გაიზარდა ბოლო. თუმცა, გამონათქვამი, რომლის მნიშვნელობა ენიჭება ცვლადს $b, შეიძლება უფრო რთული იყოს - ნებისმიერ შემთხვევაში, ზრდა $aმოხდება მხოლოდ დათვლის შემდეგ.

პრეფიქსი increment და decrement ოპერატორები

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

$a=10;
$b=--$a;
ექო "a=$a, b=$b"; // ბეჭდავს a=9, b=9

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

ექო "

პოსტფიქსის ზრდა

" ;
$a = 5;
echo "უნდა იყოს 5:". $a++. "
\n" ;

\n" ;

ექო "

პრეფიქსის ზრდა

" ;
$a = 5;
echo "უნდა იყოს 6:" . ++ $a. "
\n" ;
echo "უნდა იყოს 6:" . $a. "
\n" ;

ექო "

პოსტფიქსის შემცირება

" ;
$a = 5;
echo "უნდა იყოს 5:". $a -- . "
\n" ;

\n" ;

ექო "

პრეფიქსის შემცირება

" ;
$a = 5;
echo "უნდა იყოს 4:" . -- $a. "
\n" ;
echo "უნდა იყოს 4:" . $a. "
\n" ;
?>

სიმებიანი ოპერაციები

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

$a = "გამარჯობა" ;
$b = $a. "სამყარო!" ; // $b შეიცავს სტრიქონს "Hello World!"

$a = "გამარჯობა" ;
$a .= "მსოფლიო!" ; // $a შეიცავს სტრიქონს "Hello World!"
?>

ბიტიური ოპერაციები

ეს ოპერაციები შექმნილია მთელი ცვლადის ბიტების ჯგუფების ფუნქციონირებისთვის (დაყენება/დაყენება/შემოწმება). მთელი რიცხვის ბიტები სხვა არაფერია, თუ არა ბინარული რიცხვების სისტემაში ჩაწერილი ერთი და იგივე რიცხვის ცალკეული ციფრები. მაგალითად, ორობითში რიცხვი 12 გამოიყურებოდა 1100-ით, ხოლო 2 - 10-ს, ასე რომ გამოხატვა 12|2 დაგვიბრუნებს რიცხვს 14 (ორობითი აღნიშვნით 1110). თუ ცვლადი არ არის მთელი რიცხვი, მაშინ ის არის
ჯერ დამრგვალებულია და შემდეგ მასზე გამოიყენება შემდეგი ოპერატორები.

ერთი რიცხვის წარმოსადგენად გამოიყენება 32 ბიტი:

• 0000 0000 0000 0000 0000 0000 0000 0000 არის ნული;
• 0000 0000 0000 0000 0000 0000 0000 0001 არის 1;
• 0000 0000 0000 0000 0000 0000 0000 0010 არის 2;
• 0000 0000 0000 0000 0000 0000 0000 0011 არის 3;
• 0000 0000 0000 0000 0000 0000 0000 0100 არის 4;
• 0000 0000 0000 0000 0000 0000 0000 0101 არის 5;
• 0000 0000 0000 0000 0000 0000 0000 1111 არის 15;

ბიტიური ოპერატორები:

მაგალითი	სახელი	შედეგი
$a & $b	ბიტალურად "და"	დაყენებულია მხოლოდ ის ბიტები, რომლებიც დაყენებულია $a-ში და $b-ში.
$a | $b	ბიტალურად "ან"	ის ბიტები, რომლებიც დაყენებულია $a-ში ან $b-ში, დაყენებულია.
$a^$b	ექსკლუზიური ან	დაყენებულია მხოლოდ ის ბიტები, რომლებიც დაყენებულია მხოლოდ $a-ში ან მხოლოდ $b-ში
~$a	უარყოფა	ის ბიტები, რომლებიც არ არის მითითებული $a-ში, დაყენებულია და პირიქით.
$a<< $b	გადაიტანეთ მარცხნივ	$a ცვლადის ყველა ბიტი გადატანილია $b პოზიციებზე მარცხნივ (თითოეული პოზიცია გულისხმობს "გამრავლებას 2-ზე")
$a >> $b	მარჯვნივ გადაწევა	$a ცვლადის ყველა ბიტი გადატანილია $b პოზიციებზე მარჯვნივ (თითოეული პოზიცია გულისხმობს "გაყოფას 2-ზე")

შედარების ოპერაციები

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

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

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

იხილეთ მასივის შედარება დეტალებისთვის.

შედარების ოპერატორები:

მაგალითი	სახელი	შედეგი
$a == $b	უდრის	მართალითუ $a უდრის $b-ს.
$a === $b	იდენტურად თანაბარი	მართალითუ $a უდრის $b-ს და აქვს იგივე ტიპი. (დამატებულია PHP 4-ში)
$a != $b	არა თანაბარი	მართალითუ $a არ არის $b-ის ტოლი.
$a<>$b	არა თანაბარი	მართალითუ $a არ არის $b-ის ტოლი.
$a !== $b	იდენტური არ არის თანაბარი	მართალითუ $a არ არის $b-ის ტოლი ან თუ ისინი სხვადასხვა ტიპისაა (დამატებულია PHP 4-ში)
$a< $b	ნაკლები	მართალითუ $a მკაცრად ნაკლებია $b-ზე.
$a > $b	მეტი	მართალითუ $a მკაცრად მეტია $b-ზე.
$a<= $b	ნაკლები ან ტოლი	მართალითუ $a არის $b-ზე ნაკლები ან ტოლი.
$a >= $b	მეტი ან ტოლი	მართალითუ $a მეტია ან ტოლია $b-ზე.

ლოგიკური ოპერაციები

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

აქ არის PHP ლოგიკური ოპერატორების ცხრილი:

უნდა აღინიშნოს, რომ ასეთი ოპერატორების შემცველი ლოგიკური გამონათქვამების შეფასება ყოველთვის მიმდინარეობს მარცხნიდან მარჯვნივ და თუ შედეგი უკვე აშკარაა (მაგ. ყალბი&&რაღაცყოველთვის იძლევა ყალბი), მაშინ გამოთვლები წყდება, მაშინაც კი, თუ გამოთქმა შეიცავს ფუნქციის ზარებს. მაგალითად, ოპერატორში $logic = 0&&(time()>100); სტანდარტული ფუნქცია დრო ()არასოდეს დაურეკავს.

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

ინკრემენტის (++) და შემცირების (--) ოპერატორები არ მუშაობს ლოგიკურ ცვლადებთან.

ეკვივალენტობის ოპერატორები

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

$a=10;
$b="10";

და ეს მიუხედავად იმისა, რომ ცვლადი $aწარმოადგენს რიცხვს და $b- ხაზი. ახლა მოდით შევხედოთ ოდნავ განსხვავებულ მაგალითს:

$a=0; // ნული
$b=""; // ცარიელი სტრიქონი
if($a==$b) echo "a და b ტოლია"; // ბეჭდავს "a და b ტოლია"

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

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

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

არითმეტიკული მოქმედებები

+ (დამატების ოპერაცია)

მაგალითად, $a + 5

- (გამოკლების ოპერაცია)

მაგალითად, $a - 5

* (გამრავლება)

მაგალითად, $a * 5

/ (განყოფილება)

მაგალითად, $a / 5

% (გაყოფის დარჩენილი ნაწილის მიღება)

მაგალითად: $a=12; echo $a % 5; // უდრის 2-ს

++ (მნიშვნელობის გაზრდა/გადიდება ერთით)

მაგალითად, ++$a

მნიშვნელოვანია გვესმოდეს განსხვავება გამონათქვამებს ++$a და $a++ შორის. მაგალითად:

$a=12; $b=++$a; // $b უდრის 13 echo $b-ს;

აქ ჯერ ერთი ემატება $a ცვლადის მნიშვნელობას, შემდეგ კი მისი მნიშვნელობა უტოლდება $b ცვლადს. განსხვავებული იქნებოდა, თუ გამოთქმა ასე გამოიყურებოდა: $b=$a++; . აქ ჯერ $a ცვლადის მნიშვნელობა $b ცვლადის ტოლი იყო, შემდეგ კი $a ცვლადის მნიშვნელობა გაიზარდა.

-- (მნიშვნელობის შემცირება/დაკლება ერთით)

მაგალითად, --$a. ასევე, როგორც ნამატის შემთხვევაში, არსებობს ჩაწერის ორი ტიპი: --$a და $a--

დავალების ოპერატორები

უდრის ცვლადს კონკრეტულ მნიშვნელობასთან: $a = 5

დამატება, რასაც მოჰყვება შედეგის მინიჭება. მაგალითად: $a=12; $a += 5; ექო $a; // უდრის 17-ს

გამოკლება, რასაც მოჰყვება შედეგის მინიჭება. მაგალითად: $a=12; $a -= 5; ექო $a; // უდრის 7-ს

გამრავლება, რასაც მოჰყვება შედეგის მინიჭება: $a=12; $a *= 5; ექო $a; // უდრის 60-ს

გაყოფა მოჰყვება შედეგის მინიჭებას: $a=12; $a /= 5; ექო $a; // უდრის 2,4

შეაერთეთ რიგები და მიანიჭეთ შედეგი. ვრცელდება ორ ხაზზე. თუ ცვლადები არ ინახავს სტრიქონებს, არამედ, მაგალითად, რიცხვებს, მაშინ მათი მნიშვნელობები გარდაიქმნება სტრიქონებში და შემდეგ შესრულდება ოპერაცია: $a=12; $a .= 5; ექო $a; // უდრის 125 // იდენტურია $b="12"-ის; $b .="5"; // უდრის 125-ს

გაყოფის ნაშთის მიღება და შემდეგ შედეგის მინიჭება: $a=12; $a %= 5; ექო $a; // უდრის 2-ს

შედარების ოპერაციები

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

თანასწორობის ოპერატორი ადარებს ორ მნიშვნელობას და თუ ისინი ტოლია, აბრუნებს true, წინააღმდეგ შემთხვევაში აბრუნებს false: $a == 5

პირადობის ოპერატორი ასევე ადარებს ორ მნიშვნელობას და თუ ისინი ტოლია, აბრუნებს true, წინააღმდეგ შემთხვევაში აბრუნებს false: $a === 5

ადარებს ორ მნიშვნელობას და თუ ისინი არ არის ტოლი, აბრუნებს true, წინააღმდეგ შემთხვევაში აბრუნებს false: $a != 5

ადარებს ორ მნიშვნელობას და თუ ისინი არ არის ტოლი, აბრუნებს true, წინააღმდეგ შემთხვევაში აბრუნებს false: $a !== 5

ადარებს ორ მნიშვნელობას და თუ პირველი მეტია მეორეზე, მაშინ აბრუნებს true, წინააღმდეგ შემთხვევაში აბრუნებს false: $a > 5

ადარებს ორ მნიშვნელობას და თუ პირველი ნაკლებია მეორეზე, მაშინ აბრუნებს true, წინააღმდეგ შემთხვევაში აბრუნებს false: $a< 5

ადარებს ორ მნიშვნელობას და თუ პირველი მეტია ან ტოლია მეორეზე, მაშინ აბრუნებს true, წინააღმდეგ შემთხვევაში აბრუნებს false: $a >= 5

ადარებს ორ მნიშვნელობას და თუ პირველი არის მეორეზე ნაკლები ან ტოლი, მაშინ აბრუნებს true, წინააღმდეგ შემთხვევაში აბრუნებს false: $a<= 5

თანასწორობისა და იდენტურობის ოპერატორი

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

ცხადია, ცვლადები ინახავს სხვადასხვა ტიპის მნიშვნელობებს. მაგრამ შედარებისას ისინი დაიყვანება იმავე ტიპზე - რიცხვით. ხოლო $a ცვლადი შემცირდება 22-მდე. და ბოლოს, ორივე ცვლადი ტოლი იქნება.

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

$a = ყალბი; $b = 0;

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

$a = "22a"; $b = 22; if($a===$b) echo "თანაბარი"; სხვას ექო "არა თანაბარი";

ახლა ცვლადები არ იქნება თანაბარი.

უტოლობის ოპერატორები != და !== მუშაობენ ანალოგიურად.

ლოგიკური ოპერაციები

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

აბრუნებს true, თუ ორივე შედარების ოპერაცია დააბრუნებს true, წინააღმდეგ შემთხვევაში აბრუნებს false: $a == 5 && $b = 6

&& ოპერაციის მსგავსი: $a == 5 და $b > 6

აბრუნებს true, თუ მინიმუმ ერთი შედარების ოპერაცია დააბრუნებს true, წინააღმდეგ შემთხვევაში აბრუნებს false: $a == 5 || $b = 6

ოპერაციის მსგავსი || : $a< 5 or $b > 6

აბრუნებს true, თუ შედარების ოპერაცია დააბრუნებს false: !($a >= 5)

აბრუნებს true, თუ მხოლოდ ერთი მნიშვნელობა არის true. თუ ორივე მართალია ან არცერთი არ არის ჭეშმარიტი, ბრუნდება false. მაგალითად: $a=12; $b=6; if($a xor $b) echo "true"; სხვას ექო "ცრუ";

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

$a=12; $b=NULL; if($a xor $b) echo "true"; სხვას ექო "ცრუ";

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

ბიტის ოპერაციები

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

& (ლოგიკური გამრავლება)

გამრავლება შესრულებულია ბიტზე და თუ ორივე ოპერანდს აქვს ბიტის მნიშვნელობები 1-ის ტოლი, მაშინ ოპერაცია აბრუნებს 1-ს, წინააღმდეგ შემთხვევაში დაბრუნდება რიცხვი 0, მაგალითად: $a1 = 4; //100 $b1 = 5; //101 echo $a1 & $b1; // უდრის 4-ს

აქ რიცხვი 4 ბინარულ სისტემაში უდრის 100-ს, ხოლო რიცხვი 5 უდრის 101-ს. გაამრავლეთ რიცხვები ბიტალურად და მიიღეთ (1*1, 0*0, 0 *1) = 100, ანუ რიცხვი 4. ათობითი ფორმატში.

| (ლოგიკური დამატება)

ლოგიკური გამრავლების მსგავსად, ოპერაცია ასევე შესრულებულია ორობით ციფრებზე, მაგრამ ახლა ერთი ბრუნდება, თუ მოცემულ ციფრში ერთ რიცხვს მაინც აქვს ერთი. მაგალითად: $a1 = 4; //100 $b1 = 5; //101 ექო $a1 | $b1; // უდრის 5-ს

~ (ლოგიკური უარყოფა)

აბრუნებს ყველა ბიტს: თუ ბიტის მნიშვნელობა არის 1, მაშინ ის ხდება ნული და პირიქით.

$b = 5; ექო ~$b;<

x

x>>y - გადააქვს რიცხვი x მარჯვნივ y ციფრით. მაგალითად, 16>>1 ცვლის რიცხვს 16 (რომელიც ბინარში არის 10000) ერთი ადგილით მარჯვნივ, ასე რომ, შედეგი არის 1000 ან რიცხვი 8 ათწილადში.

სტრიქონების შეერთება

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

$a="გამარჯობა,"; $b=" სამყარო"; ექო $a . $b. "!";

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

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

ცხრილში მოცემულია არითმეტიკული ოპერატორების სია	ოპერატორი	აღწერა
მოაწერეთ ხელი	+	დამატება
ორი მნიშვნელობის დამატება	-	გამოკლება
ერთი მნიშვნელობის გამოკლება მეორისგან	*	გამრავლება
ორი მნიშვნელობის გამრავლება	/	განყოფილება
ერთი მნიშვნელობის მეორეზე გაყოფა	%	გაყოფის დარჩენილი ნაწილის მიღება
ერთი მნიშვნელობის მეორეზე გაყოფა და დარჩენილის დაბრუნება (მოდულის გაყოფა)	++	მატება
რიცხვის ერთით გაზრდის შემოკლება	--	შემცირება
რიცხვის ერთით შემცირების მოკლე ასო	-	უნარული უარყოფა

დადებითი რიცხვის უარყოფითად ან უარყოფითი რიცხვის დადებითად გადაქცევა

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

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

გაყოფის ოპერატორი ("/") აბრუნებს მცურავი წერტილის რიცხვს, თუ ორივე მნიშვნელობა არ არის მთელი რიცხვები (ან სტრიქონები, რომლებიც გარდაიქმნება მთელ რიცხვებად), რომლებიც იყოფა მთელ რიცხვზე, ამ შემთხვევაში იგი აბრუნებს მთელ რიცხვს.
შედეგი2 = $შედეგი2
"; echo "result3 = $result3

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

უნარული უარყოფა

ერთიანი უარყოფის ოპერატორი აღინიშნება ნიშნით "-" და ის ცვლის მისი ერთადერთი ოპერანდის მნიშვნელობას:

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

მატება

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

ნამატის პრეფიქსი ფორმა

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

ნამატის პოსტფიქსის ფორმა

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

შემცირება

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

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

მთელი გაყოფა არის მთელი რიცხვის ნაწილის გამომავალი გაყოფიდან. მაგალითად, თუ 5-ს გავყოფთ 2-ზე, მივიღებთ 2-ს და არა 2,5-ს.

ნარჩენი გაყოფით ყველაფერი განსხვავებულია. ეს არის დარჩენილი ნაწილის გამომავალი, როდესაც იყოფა მთელ რიცხვზე. მაგალითად, იგივე ხუთეულის გაყოფით მიიღებთ არა 2-ს, არამედ 1-ს, რადგან 5-ის 2-ზე გაყოფით მივიღებთ 2-ს, ხოლო დარჩენილი არის 1.

როგორ გავაკეთოთ მთელი რიცხვის გაყოფა PHP-ში

მაგალითად, პითონში ეს დაყოფა ხდება მარტივი ოპერატორის გამოყენებით: "//".

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

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

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

ძველ ვერსიაში, იგივე ფუნქცია ასე გამოიყურება:

ასევე არსებობს მეთოდი ყველა ვერსიისთვის:

როგორ მივმართო?

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

$result = intdiv(10, 3); ექო $შედეგი;

დარჩენილი განყოფილება PHP-ში

PHP-ში გაყოფის მთელი ნაშთების საჩვენებლად, უბრალოდ გამოიყენეთ "%" ოპერატორი.

$i = 10% 3; ექო $i;

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

სად შეიძლება მისი გამოყენება?

PHP-ში მთელი რიცხვების გაყოფის ცოდნა ძალიან გამოგადგებათ, თუ დაგჭირდებათ ორი რიცხვის შედარება, შებრუნებული რიცხვის შექმნა (პოპულარული სავარჯიშო) ან, მაგალითად, პროგრამა სახელად FizzBuzz. მისი არსი იმაში მდგომარეობს, რომ თქვენ უნდა დაწეროთ ციკლი 1-დან 100-მდე, რომელიც ყოფს თითოეულ რიცხვს 3-ზე და 5-ზე. თუ 3-ზე გაყოფილ რიცხვს აქვს ნაშთი 0, მაშინ ვწერთ Fizz, თუ გავყოფთ 5-ზე, მაშინ Buzz და თუ 5-ის და 3-ის გაყოფით დარჩენილი იქნება 0, მაშინ ვწერთ FizzBuzz-ს. ეს არის ძალიან პოპულარული ინტერვიუს ამოცანა. თუ თქვენ თვითონ დაასრულეთ, შეგიძლიათ იამაყოთ საკუთარი თავით.

ან, მაგალითად, მისი ყველა რიცხვი (4, 5, 2) უნდა გამოვიტანოთ 452 რიცხვიდან.

დასკვნა

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

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