ოპერაციები PHP ცვლილებებით (ოპერატორები). რიცხვების კრუნჩხვა და მათემატიკური ოპერაციები Php-ში დასრულებულია
პროგრამები, რომლებსაც სჭირდებათ მოწინავე რიცხვითი, სამეცნიერო ან სტატისტიკური გამოთვლების წარმოება, ნაკლებად სავარაუდოა, რომ ჩემი ინტერნეტ სცენარი ამ როლისთვის მიმზიდველ კანდიდატად დაინახონ. თუმცა, მიუხედავად იმისა, რაც ითქვა, PHP გთავაზობთ ფუნქციების შესანიშნავ კომპლექტს, რომელიც მოიცავს მათემატიკური ამოცანების უმეტესობას, რომლებიც წარმოიქმნება ინტერნეტისთვის სკრიპტების შექმნის პროცესში. გარდა ამისა, PHP ენა უზრუნველყოფს რამდენიმე მოწინავე შესაძლებლობებს, როგორიცაა მაღალი სიზუსტის რიცხვების არითმეტიკა, ასევე ჰეშირების ბიბლიოთეკებისა და კრიპტოგრაფიული ბიბლიოთეკების ფუნქციები.
PHP ენის შემქმნელებმა მიიღეს სრულიად პრაიმინგის მიდგომა და არ გაუკეთებიათ ხშირი ტესტები დანიშნული ნიშნისთვის განკუთვნილი ბორბლების ხელახლა გასაშვებად. მარჯვნივ, არის ბევრი ფუნდამენტური მათემატიკური ფუნქცია, რომლებიც გვხვდება PHP-ში და უბრალოდ ამ ფუნქციების ანალოგების ირგვლივ შეფუთულია C-ში.
მათემატიკური მოქმედებები
მათემატიკური ოპერაციების უმეტესობა ჩვენს PHP-ში ხდება ფუნქციების სახით და არა ოპერაციების სახით. განახლების ოპერაციის გარდა, PHP იყენებს ხუთ ოპერაციას მარტივი არითმეტიკული ოპერაციების შესასრულებლად, ასევე მალსახმობების ოპერაციებს, რომლებიც საშუალებას გაძლევთ დაამატოთ მეტი მოკლე გამონათქვამები ნამატებსა და შემცირებაზე, ასევე დავალებებს.
არითმეტიკული მოქმედებები
ხუთი ძირითადი არითმეტიკული ოპერაცია მოიცავს იმ ოპერაციებს, რომლებიც ხორციელდება ნებისმიერ მრავალფუნქციურ კალკულატორში, ისევე როგორც ოპერაციის ქვემოდულს (%). არითმეტიკული მოქმედებების მოკლე აღწერა მოცემულია ცხრილში:
| Ოპერაცია | აღწერა |
|---|---|
| + | აბრუნებს მისი ორი ოპერანდის მნიშვნელობების ჯამს |
| - | ვინაიდან ორი ოპერანდია, მარჯვენა ოპერანდის მნიშვნელობა ექვემდებარება მარცხენას მნიშვნელობას. თუ არ არის მარჯვენა ოპერანდი, ოპერაცია აბრუნებს ოპერანდის მნიშვნელობას საპირისპირო ნიშნით. |
| * | აბრუნებს მისი ორი ოპერანდის მნიშვნელობას |
| / | აბრუნებს მარცხენა ოპერანდის მნიშვნელობის მცურავი წერტილის შედეგს მარჯვენა ოპერანდის მნიშვნელობით |
| % | ბრუნავს მარცხენა ოპერანდის მთელი მნიშვნელობის ნამეტს მარჯვენა ოპერანდის აბსოლუტური მნიშვნელობით |
როდესაც პირველი სამი აღწერილი არითმეტიკული ოპერაცია (+,-,*) ამოღებულია პროგრამიდან, კვალი ემატება, ასე რომ, როდესაც ეს ოპერაციები ამოღებულია, წარმოიქმნება მცურავი წერტილის მნიშვნელობის გაფართოებული ტიპი μ-მდე გაზრდილი სიზუსტით. ან მეტი რიცხვი. ეს მნიშვნელოვანია აღინიშნოს: თუ ოპერაციის ოპერანდი მოიცავს მთელ რიცხვებს, მაშინ შედეგი არის მთელი რიცხვი, და თუ გსურთ, რომ ერთ-ერთი ოპერანდი იყოს თანაბარი სიზუსტის მცურავი წერტილიანი რიცხვი, მაშინ შედეგი არის მცურავი- პუნქტის ნომერი სამხედრო სიზუსტით. იგივე ტიპის გაფართოება ხელმისაწვდომია ქვეგანყოფილების საბოლოო მუშაობის დროს; გარდა ამისა, არსებობს ისეთი დამატებითი ეფექტი, რომ შედეგი ხდება მცურავი წერტილის რიცხვი გაზრდილი სიზუსტით, რადგან დაყოფა არ მუშაობს ზედმეტი (მთლიანად).
მოდული (%) ოპერაცია PHP-ში იღებს მთელ რიცხვ ოპერანდებს და ეს ოპერაცია შემოიფარგლება დაბალი სიზუსტით მცურავი წერტილის რიცხვებით და ციფრები პირველ რიგში გარდაიქმნება მთელ რიცხვებად (ამ შემთხვევაში, არა დარტყმული ნაწილები). ასეთი ოპერაციის შედეგი არის მთელი რიცხვი.
მატებისა და შემცირების ოპერაციები
მნიშვნელოვანია, რომ PHP ენის სინტაქსი გამარტივებულია C ენისგან, ხოლო C პროგრამები განთქმულია წერის სიყვარულით და დაწერილია C ენაზე. გაზრდისა და შემცირების ოპერაციები, აღებული C ენიდან, საშუალებას გაძლევთ უფრო მოკლედ წარმოადგინოთ გამონათქვამები, როგორიცაა $count = $count + 1, რომლებიც ხშირად გამოიყენება პროგრამებში.
გაზრდის ოპერაცია (++) გამოიყენება ცვლილების მნიშვნელობაზე ერთის დასამატებლად, რომელიც აფართოებს ოპერაციას, ხოლო შემცირების ოპერაცია (--) ერთს უმატებს ცვლილების მნიშვნელობას.
ამ ორი ოპერაციის კანს ორი სახეობა აქვს - სუფიქსნუ(ამ ფორმით ოპერაციის ნიშანი განლაგებულია უშუალოდ ცვლილების უკან, როგორც ოპერაცია ფართოვდება) და პრეფიქსი(ამ ფორმით ოპერაციის ნიშანი მოთავსებულია უშუალოდ ცვლილების წინ, რადგან ოპერაცია ფართოვდება). ორივე სხვადასხვა ტიპს შეიძლება ჰქონდეს ერთი და იგივე გვერდითი ეფექტი, ცვლილების მნიშვნელობის შეცვლისას, ხოლო სუფიქსისა და პრეფიქსის ოპერაციები ატრიალებენ სხვადასხვა მნიშვნელობებს, როდესაც ვიკორისტულია. სუფიქსის ოპერაცია მუშაობს ისე, რომ ცვალებადი მნიშვნელობა იცვლება მნიშვნელობის ბრუნვის შემდეგ, ხოლო პრეფიქსის ოპერაცია მუშაობს ისე, რომ მნიშვნელობა თავდაპირველად იცვლება და შემდეგ ცვალებადი მნიშვნელობა ბრუნავს ახალ მნიშვნელობაზე enny. მითითებული მნიშვნელობის იდენტიფიცირება შესაძლებელია ოპერატორებისთვის მინიჭებული შემცირების და ზრდის ოპერაციების გამოყენებით:
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;მარტივი მათემატიკური ფუნქციები
პროგრამის შედგენის შემდეგი ეტაპი, იმის შესაბამისად, რომ არითმეტიკული ოპერაციები სტაგნაციას განიცდის, ვრცელდება უამრავ სხვადასხვა ფუნქციაზე. ფუნქციები საშუალებას გაძლევთ გადაჭრათ ისეთი პრობლემები, როგორიცაა ერთი რიცხვითი ტიპიდან მეორეზე გადაყვანა (დაყოფილი სტატია „მონაცემთა ტიპები“) და მოძებნოთ რიცხვების ნაკრების მინიმალური და მაქსიმალური რაოდენობა. ქვემოთ მოცემულ ცხრილში მოცემულია მარტივი მათემატიკური ფუნქციები:
| ფუნქცია | აღწერა |
|---|---|
| იატაკი () | იღებს ერთ ფაქტობრივ პარამეტრს (ჩვეულებრივ, ცვლადი სიზუსტის მცურავი წერტილის რიცხვს) და აბრუნებს უდიდეს მთელ რიცხვს, რომელიც უფრო მცირეა ან უფრო ძველია ვიდრე რეალურ პარამეტრს (დამრგვალებულია ქვემოთ) |
| ჭერი () | ეს ფუნქციები შემცირებულია სიტყვა ჭერისთვის. ფუნქცია იღებს ერთ ფაქტობრივ პარამეტრს (ჩვეულებრივ, მაღალი სიზუსტის მცურავი წერტილის რიცხვს) და აბრუნებს უმცირეს მთელ რიცხვს, რომელიც უფრო დიდია ან დაბალია ვიდრე რეალურ პარამეტრზე (დამრგვალებულია ზემოთ) |
| რაუნდი () | იღებს ერთ ფაქტობრივ პარამეტრს (მნიშვნელობა არის ცვლადის სიზუსტის მცურავი წერტილის რიცხვი) და აბრუნებს უახლოეს მთელ რიცხვს |
| abs () | რიცხვის აბსოლუტური მნიშვნელობა. თუ ციფრულ ფაქტობრივ პარამეტრს აქვს უარყოფითი მნიშვნელობა, ფუნქცია აბრუნებს დადებით რიცხვს; თუ ფაქტობრივი პარამეტრი დადებითია, ფუნქცია თავად აბრუნებს ფაქტობრივ პარამეტრს |
| წთ() | ის იღებს იმდენივე ფაქტობრივ ციფრულ პარამეტრს (ან მინიმუმ ერთს) და აბრუნებს რეალური პარამეტრების უმცირეს მნიშვნელობას |
| max() | ის იღებს იმდენივე ფაქტობრივ ციფრულ პარამეტრს (ან მინიმუმ ერთს) და აბრუნებს რეალური პარამეტრების უდიდეს მნიშვნელობას |
მაგალითად, კანის ვირუსის შედეგი 3-ზე მეტია, კანის ვირუსის დარჩენილი მნიშვნელობა ფუნქციის დაჭერით ასევე 3-ზე მეტია:
PHP კოდი $შედეგი = min(3, abs(-3), max(მრგვალი(2.7), ჭერი(2.3), იატაკი(3.9))));Viroblennya of vipadkovyh ნომრები
PHP-ში არის ორი შემთხვევითი რიცხვების გენერატორი (დააწკაპუნეთ აქ დამატებითი ფუნქციისთვის rand ()і mt_rand()). ერთი და იგივე მნიშვნელობის სამი ფუნქცია დაკავშირებულია ამ გენერატორების კანთან: კობის მნიშვნელობის დაყენების ფუნქცია ( srand ()і mt_srand ()), ფუნქცია თავისთავად არის ფუნქცია, რომელიც ირჩევს უდიდეს მთელ რიცხვს, რომელიც შეიძლება შემობრუნდეს გენერატორის მიერ (( getrandmax ()і mt_getrandmax())). getrandmax() და mt_getrandmax() ფუნქციები ატრიალებენ ყველაზე დიდი რიცხვის მნიშვნელობებს, რომლებიც შეიძლება შემოტრიალდეს rand() ან mt_rand()-ით, Windows პლატფორმებზე ეს მნიშვნელობა თან ერთვის მნიშვნელობით 32768.
კონკრეტული ფუნქციის არჩევა ფსევდოცვლადის რიცხვების გენერირებისთვის, როგორიცაა ფუნქცია rand(), შეიძლება მოიძებნოს, რომელშიც ბიბლიოთეკები გამოიყენება PHP ინტერპრეტატორის შედგენისთვის. გარდა ამისა, mt_rand() გენერატორში ყოველთვის გამოიყენება ფსევდოცვლადი რიცხვების გენერირების ფუნქცია (mt - შემოკლება Mersenne Twister-ისთვის) და mt_rand() ფუნქციის ოპერატიული დოკუმენტაციის ავტორი ადასტურებს, რომ ეს ფუნქცია I' მ ასევე უფრო შვედური და უფრო ჰიპ (კრიპტოგრაფიის თვალსაზრისით), არა rand (). ჩვენ არ გვაქვს საფუძველი ეჭვი შევიტანოთ ამ მტკიცებების სიმართლეში, ამიტომ ჩვენ პატივს ვცემთ mt_rand () ფუნქციის უკეთ გამოყენებას, ვიდრე rand ( ).
სხვადასხვა პლატფორმისთვის PHP-ის სხვადასხვა ვერსიის გამოყენებისას, როგორც ჩანს, ფუნქციები rand() და mt_rand() წარმოქმნიან ერთი შეხედვით საკმაოდ სასიამოვნო რიცხვებს, თავდაპირველი მნიშვნელობის მითითების გარეშე. ასეთ მტერს არ უნდა ენდო. უპირველეს ყოვლისა, პროგრამები, რომლებსაც აქვთ შემთხვევითი რიცხვების გენერირების ფუნქცია cob მნიშვნელობის მითითების გარეშე, ძალიან ადვილია სხვა პლატფორმებზე გადატანა და, სხვა სიტყვებით რომ ვთქვათ, გარანტირებულია მინიჭებული ფუნქციების საიმედო მოქმედება cob მნიშვნელობის მითითების გარეშე.
ტიპიური მეთოდი cob მნიშვნელობის მითითებისთვის PHP-ის ნებისმიერი cob რიცხვების გენერატორისთვის (mt_srand() ან srand() ფუნქციების გამოყენებით) არის შემდეგი:
PHP კოდი mt_srand((double)microtime()*1000000);ეს ოპერატორი განსაზღვრავს გენერატორის საათის მნიშვნელობას, რომელიც უდრის მიკროწამების რაოდენობას, რომელიც გადის საათამდე დარჩენილი მთელი წამიდან. (ამ ოპერატორის გადაცემა Double-ის ტიპზე არ არის საჭირო, რადგან ფუნქცია microtime() აბრუნებს მწკრივს, რომელიც განიხილება როგორც მთელი რიცხვი გამრავლების ოპერაციაში და არა პარამეტრების გადაცემის ოპერაციაში.) რეკომენდებულია წაკითხვა და ოპერატორის შეყვანა. cob მნიშვნელობის დასაზუსტებლად, მე არ მესმის ამ ოპერატორის მნიშვნელობა; თქვენ შეგიძლიათ უბრალოდ მოათავსოთ ეს ოპერატორი გვერდის PHP მხარეს, მხოლოდ ერთხელ, დაქვემდებარებული ფუნქციების mt_rand() ან rand() წინ და ეს ოპერატორი უზრუნველყოფს, რომ წერტილის შეცვლა დაშვებულია და სხვაობა სწრაფად და შემთხვევით შეიცვლება. თანმიმდევრობები.
კობის ღირებულების განსაზღვრის ეს სპეციფიკური მეთოდი ღრმად იყო გააზრებული ამ ფაჰივციების მიერ, რომლებიც სრულად გაიგებენ ფსევდო სიმძლავრის რიცხვების წარმოქმნის ყველა ნიუანსს, ასე რომ, როდესაც უკვე გააკეთეს ყველაფერი, ისინი კვლავ დაკარგავენ ყველაზე ძვირფას ნაწილს. ნებისმიერი ლოკალური პროგრამის გამოცნობის ნებისმიერი მცდელობა, ეს უფრო "სახიფათოა".
ცხადია, ფსევდო-მცურავი რიცხვების ბრუნვის ფუნქცია შექმნილია მხოლოდ მთელი რიცხვების დასაბრუნებლად, შემდეგ კი შემთხვევითი მთელი რიცხვი მოცემული დიაპაზონიდან ადვილად შეიძლება გარდაიქმნას მსგავს რიცხვად მცურავი წერტილით (ვთქვათ, რიცხვი დიაპაზონიდან ID-მდე 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 (ან მისი მნიშვნელობის ჯერადამდე) და ასევე კვადრატულ ფესვებამდე; გარდა ამისა, ეს მუდმივები სხვა ტიპებამდე არსებობდა. ბოლო გამოშვებებში, მრავალი მიზეზის გამო, მუდმივთა სია კიდევ ერთხელ შემცირდა მითითებულ მათემატიკური მუდმივების თანაბრად მცირე რაოდენობამდე:
| მუდმივი | აღწერა |
|---|---|
| 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 - მოცემულია suvorich-ის გადამოწმება, დამატებითი ფუნქციის ქვედა ვერიფიკაცია არის_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-ე და ფუძეზე მუშაობისთვის (როგორც ნაჩვენებია ცხრილში).
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 () | იღებს ციფრულ პარამეტრს რადიანებში და აბრუნებს პარამეტრის ტანგენტს ცვლადი სიზუსტის მცურავი წერტილის სახით |
| როგორც() | იღებს ციფრულ პარამეტრს და აბრუნებს პარამეტრის რკალს რადიანებში. შეყვანის მონაცემები უნდა იყოს -1-დან 1-მდე დიაპაზონში (შეყვანის მონაცემების უარყოფის ფუნქცია, რომელიც ხვდება ამ დიაპაზონს, გამოიწვევს NAN-ის უარყოფას). შედეგები მერყეობს -π/2-დან π/2-მდე დიაპაზონში |
| acos () | იღებს ციფრულ პარამეტრს და აბრუნებს პარამეტრის რკალის კოსინუსს რადიანებში. შეყვანის მონაცემები უნდა იყოს -1-დან 1-მდე დიაპაზონში (შეყვანის მონაცემების ამოღების ფუნქციაა NAN-ის ამოღება. შედეგები არის 0-დან π-მდე დიაპაზონში. |
| რუჯი() | იღებს ციფრულ პარამეტრს და აბრუნებს პარამეტრის არქტანგენსს რადიანებში. შედეგები მერყეობს -π/2-დან π/2-მდე დიაპაზონში |
ქვემოთ მოცემულია დაკეცილი ცხრილის მაგალითი „სტანდარტული“ ფუნქციების ტრიგონომეტრიული ფუნქციების გამოსათვლელად:
PHP კოდი ფუნქცია display_trigonometri ($func_array, $input_array) (// ფუნქციის სათაურის echo "| ღირებულება/ფუნქცია | $ fun | ";) ექო"
|---|---|
| ".sprintf("%.4f",$input)." | "; foreach ($func_array როგორც $func) (echo""; printf("%4.4f", $func($input)); echo " | ";) ექო"
PHP-ში ტრიგონომეტრიული ფუნქციების გამოყენების საფუძველი ტანგენტის თუნდაც დიდი (ან არცთუ უმნიშვნელო) მნიშვნელობების ამოღება განპირობებულია იმით, რომ თეორიულად ნიშნები ნულის ტოლია, მაგრამ სინამდვილეში წილადები ნულიდან იყოფა დამრგვალების გამო.
გაანგარიშება საკმარისი სიზუსტით (BC ფუნქციების გამოყენებით)
ცვლადი სიზუსტის მთელი რიცხვები და მცურავი წერტილის ტიპები შესაფერისია მათემატიკური ამოცანების უმეტესობისთვის, რომლებიც წარმოიქმნება ინტერნეტის კომპიუტერულ სკრიპტებში, ასევე კანის შესანახად. ამ დამატებითი ტიპებით წარმოდგენილი მნიშვნელობა გადადის კომპიუტერის მეხსიერებაში, ასე რომ ამ ტიპის რიცხვების წარმოდგენის ზომები და სიზუსტე აუცილებლად აწესებს შეზღუდვებს.
წარმოუდგენელია, რომ ამ ტიპის მნიშვნელობების ზუსტი დიაპაზონი შეიძლება იყოს სერვერის კომპიუტერის არქიტექტურაში, ხოლო მთელი რიცხვების მნიშვნელობები შეიძლება მერყეობდეს -2 31 -1-დან 2 31 -1-მდე, ხოლო რიცხვები მცურავი წერტილით არის თანაბარი სიზუსტით და შეუძლია რიცხვების წარმოდგენა სავარაუდო სიზუსტით. არსებობს 13-დან 14-მდე მეათე ციფრი. მეორეს მხრივ, უფრო მაღალი ამოცანისთვის, რაც იწვევს მონაცემთა უფრო ფართო დიაპაზონს და უფრო დიდ სიზუსტეს, ჩვენს PHP გადაცემას მათემატიკური ფუნქციები გონივრული სიზუსტით(ასევე უწოდებენ BC ფუნქციებს - საანგარიშო უტილიტას სახელით მნიშვნელოვანი სიზუსტით, Unix სისტემის მახასიათებლებზე დაყრდნობით).
შეიძლება აღმოჩნდეს, რომ საკმარისი სიზუსტის ფუნქციები არ შედის PHP თარჯიმნის კომპილაციაში, განსაკუთრებით იმ შემთხვევაში, თუ მომხმარებელი ახორციელებს დამოუკიდებლად ასეთ კომპილაციას, რისთვისაც მომხმარებელი პასუხისმგებელია იცოდეს, რომ კორექტირების ეტაპზე ამ კონფიგურაციაში აუცილებელია. საწყობის პარამეტრების ჩართვის მიზნით --enable-bcmath. იმის შესამოწმებლად, თუ ვის აქვს წვდომა მინიჭებულ ფუნქციებზე, სცადეთ გამოთვალოთ გამოთქმა bcadd("1","1"). თუ შეცდომის შესახებ შეტყობინება წაიშლება, რომელიც მოიცავს დაუზუსტებელ ფუნქციას, მოგიწევთ კონფიგურაციის ხელახლა კონფიგურაცია და PHP თარჯიმანის ხელახლა შედგენა.
BC ფუნქციებში, როგორც პარამეტრებსა და მნიშვნელობებში, რომლებიც ბრუნავს, ბრუნდება არა რიცხვითი ტიპები მოცემული ფიქსირებული მნიშვნელობებით, არამედ რიგები. Dovzhin რიგების PHP ენაზე ფრაგმენტები შემოიფარგლება ხელმისაწვდომი მეხსიერების რაოდენობით, განლაგებაში გამოჩენილმა რიცხვებმა შეიძლება გამოიწვიოს dowzhin. ძირითადი გამოთვლები ტარდება ათეულ წელიწადში და ბევრი ვარაუდი არსებობს იმის შესახებ, თუ როგორ შეუძლიათ ადამიანებს თავი დააღწიონ ცხვრისა და ქაღალდის დახმარებით (რადგან ადამიანებს შეუძლიათ რაც შეიძლება სწრაფად მოაგროვონ ტერპენები). BC ფუნქციები, რომლებიც მოქმედებენ მთელი რიცხვებით, მოქმედებენ ზუსტად და საშუალებას გაძლევთ გამოთვალოთ იმდენი ციფრი, რამდენიც საჭიროა, ხოლო ფუნქციებში, რომლებიც მოქმედებენ რიცხვებით ცურვის წერტილით, გამოთვლები გამოითვლება სიზუსტით მოცემულ წერტილამდე მხოლოდ ათობით გამონადენი. დამატებითი ინფორმაცია BC-ის ფუნქციების შესახებ შეგიძლიათ იხილოთ ქვემოთ მოცემულ ცხრილში:
| ფუნქცია | აღწერა |
|---|---|
| bcadd () | იღებს ორ სერიის პარამეტრს, რომლებიც წარმოადგენს რიცხვებს, და საჭირო მთელი რიცხვის პარამეტრს, რომელიც წარმოადგენს მასშტაბის მულტიპლიკატორის მნიშვნელობებს. ატრიალებს პირველი ორი პარამეტრის ჯამს მწკრივის ხედში, შედეგად მეათე პოზიციების რაოდენობა, რაც მითითებულია პარამეტრით მასშტაბის მულტიპლიკატორის მნიშვნელობებით. ვინაიდან პარამეტრი ეფუძნება მასშტაბის მულტიპლიკატორის მნიშვნელობებს და არა ამოცანებს, ამოცანები იცვლება მასშტაბის მულტიპლიკატორით |
| bcsub () | მსგავსია bcadd(), გარდა იმისა, რომ ის აბრუნებს სხვა პარამეტრის შედეგს პირველიდან |
| bcmui () | მსგავსია bcadd(), გარდა იმისა, რომ ის აბრუნებს მისი პარამეტრების გამრავლების შედეგს |
| bcdiv () | მსგავსია bcadd(), გარდა იმისა, რომ ის აბრუნებს პირველი პარამეტრის შედეგს მეორეზე |
| bcmod () | აბრუნებს მოდულს (ჭარბი) პირველი პარამეტრის ქვეგანყოფილებიდან მეორეზე. შებრუნებული მნიშვნელობის ფრაგმენტები გარდაიქმნება მთლიან ტიპად; ფუნქცია არ იღებს პარამეტრს მასშტაბის მულტიპლიკატორის მნიშვნელობებთან. |
| bcpow () | დაამატეთ პირველი პარამეტრი საფეხურებს, სხვა პარამეტრის მითითებით. შედეგში მეათე პოზიციების რაოდენობა მითითებულია მასშტაბის მულტიპლიკატორით, როგორც ამოცანებში |
| bcsqrt() | აბრუნებს პარამეტრის კვადრატულ ფესვს მეათედების რაოდენობაში, რაც შეესაბამება არასავალდებულო მასშტაბის მულტიპლიკატორის მნიშვნელობებს. |
| bcscale() | ადგენს სკალირების ფაქტორს BC ფუნქციის შემდეგი დაწკაპუნებებისთვის |
ამ ფუნქციების უმეტესობა დარჩენილ პარამეტრს იღებს არასავალდებულო სკალირების ფაქტორად (მთლიანი რიცხვი), რაც ნიშნავს პოზიციის რამდენი მეათედი შედის შედეგში. ვინაიდან ასეთი პარამეტრი არ არის ამოცანა, მაშინ მასშტაბის მულტიპლიკატორი გამოიყენება მასშტაბის მულტიპლიკატორის დასადგენად, რომელიც, თავის მხრივ, შეიძლება დაინსტალირდეს bcscale() ფუნქციის გამოყენებით. ამ მნიშვნელობისთვის მითითებული მნიშვნელობა (მნიშვნელობა, რომელიც განისაზღვრება, თუ სკრიპტი არ აჩერებს bcscale() ფუნქციის გამოძახებას) ასევე შეიძლება მითითებული იყოს php.ini ინიციალიზაციის ფაილში.
ქვემოთ მოცემულია vicor ფუნქციის მაგალითი საკმარისი სიზუსტით მთელი არითმეტიკული მოქმედებების ზუსტი გამოთვლისთვის. Vikonanny შეურაცხმყოფელი კოდი:
PHP კოდი ამისთვის ($x = 1; $x< 25; $x++) { echo "$x$x= ".bcpow($x, $x).""; }
უფრო ზუსტად, ასტრონომიული სიდიდეების გამოთვლა დამატებითი ფუნქციის გამოყენებით ძვ.წ თუ ამ გამოთვლებისთვის PHP მთელი რიცხვის ტიპის გამოყენებით, მაშინ მთელი რიცხვის გადაფასება მოხდება გაანგარიშების დასრულებამდე დიდი ხნით ადრე, ამიტომ გაფართოების ციკლის მეორე ნაწილში მათ შეიმუშავეს უახლოესი რიცხვის მცურავი წერტილით აღების მეთოდი.
მასივი დამუშავების ფორმები 1 2 3 4 5 6 7 8 9 10ლოგიკური ოპერაციები წარმოდგენილია პროგრამირების ყველა ენაზე. PHPბრალი არ არის. გარდა მარტივი საგნისა, გამრავლება, შეკრება და აშკარაობა ჩნდება სრულიად რიცხვობრივ და ზედმეტ საგანში, რომლებზეც ახლა ვისაუბრებთ და ასევე გავაანალიზებთ მათ, ვიკორისტსა და ანგარიშს კონდახებს.
ინტეგრალური ჰემი ნიშნავს მთლიანი ნაწილის ჰემის სახით ჩვენებას. მაგალითად, თუ 5-ს გავყოფთ 2-ზე, გამოვაკლებთ 2-ს და არა 2,5-ს.
ძალიან ბევრი დაყოფით, ყველაფერი სხვაგვარადაა. ბოლოში არის ჭარბი მთელი რიცხვი. მაგალითად, იგივე ხუთეულის გაყოფით თქვენ გამოაკლებთ არა 2-ს, არამედ 1-ს, შესაბამისად, 5-ს 2-ზე გავყოფთ, ვაკლებთ 2-ს და ვამატებთ 1-ს ნამეტს.
როგორ დაიპყროთ მთელი ქვეველი PHP-ში
მაგალითად, პითონში ეს ქვეველი განისაზღვრება მარტივი ოპერატორის გამოყენებით: "//".
Და ში PHPფულის გამომუშავება არც ისე ადვილი იქნება, მაგრამ ეს პროცესი არ გაძლევთ საშუალებას გაიგოთ მეტი თქვენი ენის შესახებ.
აღვნიშნოთ კონდახი, როგორ შეიძლება მისი განხორციელება.
უ PHPმეშვიდე ვერსიაში ფუნქცია ასე გამოიყურება:
Intdiv();
ძველ ვერსიაში ეს ფუნქცია ასე გამოიყურება:
იგივე მეთოდი მუშაობს ყველა ვერსიისთვის:
სართული ();
როგორ მოვაწყოთ?
მაგალითად, ავიღოთ პირველი ფუნქცია და გადავწყვიტოთ დასრულება დაახლოებით იგივე გზით.
$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-ს. ეს კიდევ უფრო პოპულარულია ინტერნეტში. რადგან შენ თვითონ დაწერე, შეგიძლია დაწერო საკუთარ თავზე.
ან, მაგალითად, შეგვიძლია გამოვიყენოთ ნომერი 452 ყველა ნომრის დასაბეჭდად (4, 5, 2).
ვისნოვოკი
სიგიჟემდე, დარიჩინისა და გახეხილი ხილის მთელი და ზედმეტი ნაწილი ხშირად გამოდის და მათი ამორჩევა არც ისე ადვილია, როგორც პითონში, მაგრამ მაინც მნიშვნელოვანია.
ახლა თქვენ იმყოფებით ვიდეო პროგრამასთან უფრო ახლოს PHPდა მომავალში კიდევ უფრო დაუახლოვდებით, რადგან ასე გულმოდგინედ გადალახავთ სირთულეებს.
ოპერაციები PHP ცვლილებებით (ოპერატორები)
ამ მიზნით გამოიყენეთ სხვადასხვა ჯგუფები.
ოპერატორი არის ის, რაც შედგება ერთი ან მეტი მნიშვნელობისაგან (ვირაზივი, როგორც ამბობენ პროგრამირების ჟარგონში), რომელიც შეიძლება გამოითვალოს ახალ მნიშვნელობად (მაშასადამე, მთელი სტრუქტურა შეიძლება ჩაითვალოს ვირაზად). შედეგი აჩვენებს, რომ ფუნქციები ან სხვა სტრუქტურები, რომლებიც ატრიალებენ მნიშვნელობებს (მაგალითად, ბეჭდვა ()) - ოპერატორების მიერ, ფიზიკური სტრუქტურების ამოხსნის მიზნით (მაგ. echo ()), რადგან ისინი არაფერს აქცევენ.
არითმეტიკული ოპერაციები PHP-ში
გახსოვთ სკოლის არითმეტიკული ჩასაფრებები? Move ქვედა ოპერატორები იგივეს აკეთებენ.
ოპერაცია ("/") ქვეშ ყოველთვის აბრუნებს მეტყველების ტიპს, რაც ნიშნავს, რომ მნიშვნელობები არის მთელი (ან რიგები, რომლებიც გარდაიქმნება მთელ რიცხვებად). წინააღმდეგ შემთხვევაში, შედეგი განსხვავებული იქნება.
დანაყოფში ჭარბი რაოდენობის გამოთვლის ოპერაცია " % ის მუშაობს მხოლოდ მთელ რიცხვებთან, ამიტომ მისი წილადების კონდენსაციამ შეიძლება გამოიწვიოს არასწორი შედეგი.
Mozhlive vikoristannya თაღები. ზოგიერთი მათემატიკური მოქმედების პრიორიტეტი სხვებთან შედარებით და პრიორიტეტების შეცვლა, როდესაც არითმეტიკული გამონათქვამების ვიკორისტანის თაღები შეესაბამება ძირითად მათემატიკურ წესებს.
მატებისა და შემცირების ოპერაციები
PHP, ისევე როგორც C, მხარს უჭერს პრეფიქსის და პოსტფიქსის მატებისა და შემცირების ოპერატორებს.
პოსტფიქსის ოპერატორები ზრდისა და შემცირებისთვის
როგორც ენაში, ეს ოპერატორები ზრდის ან ცვლის ცვლადის მნიშვნელობებს, ხოლო ენაში ატრიალებენ ცვლადის მნიშვნელობებს. $aშეცვლამდე. Მაგალითად:
$a=10;
$b=$a++;
ექო "a=$a, b=$b"; // შეიყვანეთ a = 11, b = 10
როგორც თქვენ ამბობთ, ახალი სიმინდი $bმიიღო ცვლილების ღირებულება $a, შემდეგ კი დანარჩენი გაიზარდა. მაშასადამე, გამოდის, რომ რომლის მნიშვნელობას ენიჭება ცვლადი $b, ეს შეიძლება იყოს უფრო რთული - ნებისმიერ დროს, ზრდა $aამ გაანგარიშების შემდეგ მეტი იქნება.
პრეფიქსი ოპერატორები ზრდისა და შემცირებისთვის
ასევე არის მატებისა და შემცირების ოპერატორები, რომლებიც მითითებულია და არა ცვლილების სახელის შემდეგ. ცხადია, შეცვალეთ ცვლილების მნიშვნელობა ცვლილების შემდეგ. კონდახი:
$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 – ce 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 - ce 15;
ბიტიური ოპერატორები:
| კონდახი | სახელი | შედეგი |
|---|---|---|
| $a & $b | ბიტალურად "i" | ერთადერთი ბიტი, რომელიც დაინსტალირებულია არის $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. |
ლოგიკური ოპერაციები
ლოგიკური ოპერატორები გამოიყენება ინკლუზიურად ლოგიკურ არგუმენტებთან მუშაობისთვის და ასევე როტაციისთვის ყალბიან კიდევ მართალია.
მოდით შევქმნათ PHP ლოგიკური ოპერატორების ცხრილი:
მნიშვნელოვანია აღინიშნოს, რომ ლოგიკური გამონათქვამების გაანგარიშება, რის გამოც ასეთი ოპერატორები ყოველთვის მარჯვნივ მიდიან, რის შედეგადაც შედეგი უკვე აშკარაა (მაგ. ყალბი&& არისყოველთვის იძლევა ყალბი), შემდეგ გამოთვლები წყდება, თითქოს ვირუსს აქვს ფუნქცია. მაგალითად, ოპერატორში $logic = 0&&(time()>100); სტანდარტული ფუნქცია დრო ()საერთოდ არ დაურეკავს.
ფრთხილად იყავით ლოგიკურ ოპერაციებთან - არ დაივიწყოთ სიმბოლოს მოგება. პატივისცემის აღსადგენად, მაგალითად, | і || - ორი სრულიად განსხვავებული ოპერატორი, რომელთაგან ერთს შეუძლია ნებისმიერი რიცხვის პოტენციურად როტაცია, ხოლო მეორე - მხოლოდ ყალბიі მართალია.
ზრდის (++) და შემცირების (--) ოპერატორები არ მუშაობს ლოგიკური ცვლილებებით.
ეკვივალენტობის ოპერატორები
PHP-ს, PHP4-დან დაწყებული, აქვს იგივე გათანაბრების ოპერატორი - თანასწორობის სამმაგი ნიშანი ===
,
ან შებრუნების ოპერატორი ჩართულია. PHP-ს შეუძლია მოითმინოს დაყენება იმ წერტილამდე, სადაც რიგები ირიბად გარდაიქმნება რიცხვებად და ზუსტად ასე.
მაგალითად, შეურაცხმყოფელი კოდი აჩვენებს, რომ ცვლილებების მნიშვნელობა უფრო მნიშვნელოვანი ხდება:
$a=10;
$b = "10";
და მათ არ აინტერესებთ ისინი, ვინც ბოროტია $a¢ ნომერი და $b- რიგი. ახლა მოდით გადავხედოთ სხვა კონდახს:
$a=0; // ნულ
$b=""; // ცარიელი ნაკერი
if($a==$b) ექო "a და b რეგიონები"; // ამობეჭდეთ "a და b რეგიონები"
მე მინდა $aі $bცხადია, მათ არ სურთ ამ სიტყვის ყველაზე გავრცელებული აზრის თქმა, სკრიპტში ნათქვამია, რომ სურნელს ერიდებიან. რატომ ხარ ასე აღელვებული? მარჯვნივ არის ის, რომ სანამ ლოგიკური ოპერატორის ერთ-ერთი ოპერანდი შეიძლება განიხილებოდეს როგორც რიცხვი, ორი ოპერანდი შეიძლება განიხილებოდეს როგორც რიცხვი. ამ შემთხვევაში, ცარიელი მწკრივი გარდაიქმნება 0
რომელიც შემდეგ უდრის ნულს. გასაკვირი არ არის, რომ ოპერატორი ექოიკითხე.
პრობლემაში დომინირებს ეკვივალენტობის ოპერატორი ===
(სამმაგი ეჭვიანობა). ეს უბრალოდ უდრის ორ განმარტებას, ან მათ ტიპებს. მოდით გადავიწეროთ ჩვენი მაგალითი ამ ოპერატორის ვებსაიტიდან.
PHP-ს აქვს ყველა ძირითადი მათემატიკური ოპერაცია. როგორც ოპერანდები შეიძლება გამოყენებულ იქნას როგორც სამიზნეები, ასევე მეტყველების რიცხვები.
| ოპერატორი | Ნიშანი | აღწერა |
|---|---|---|
| დოდავანია | + | დაამატეთ ორი მნიშვნელობა |
| Vіdnіmannya | - | ერთი მნიშვნელობის მეორისგან აღება |
| გამრავლება | * | გაამრავლეთ ორი მნიშვნელობა |
| პოდილ | / | დაყავით ერთი მნიშვნელობა მეორეზე |
| ზედმეტი ამოიღეთ ქვემოდან | % | ერთი მნიშვნელობის დაყოფა მეორეზე და შებრუნებული ჭარბი (გაყოფილი მოდულით) |
| მატება | ++ | რიცხვის ერთით შემცირება |
| შემცირება | -- | რიცხვის ერთით შეცვლის მალსახმობი ჩანაწერი |
| Unarne zaperechernya | - | დადებითი რიცხვის უარყოფითად ან უარყოფითი რიცხვის დადებითად გადაქცევა |
ოპერატორების დაყოფა, გამრავლება, ქვეგანყოფილება, ქვეგანყოფილება მოდულის მიხედვით და შეკრება
ოპერატორები ერთდროული, გამრავლება, ქვედაყოფა, ქვემოდული და შეკრება ახსნილია ისევე, როგორც მათემატიკაში. აქ მნიშვნელოვანია პატივი მივაგოთ როგორც მოდულო, ისე სუბმოდულო ოპერატორების ოპერატორებს.
ქვეოპერატორი ("/") ატრიალებს რიცხვს მცურავი წერტილით, გარდა იმ მწკრივებისა, რომლებიც შეიცავს მთელ რიცხვებს (ან რიგებს, რომლებიც გარდაიქმნება მთელ რიცხვებად), რომლებიც იყოფა მთელ რიცხვებად - რომლის მწკრივში ბრუნავს მთელი მნიშვნელობა. .
შედეგი2 = $შედეგი2
"; echo "result3 = $result3
result4 = $result4"; ?>
მოდულოებით გაყოფისას ოპერანდები გარდაიქმნება მთელ რიცხვებად (ნაწილობრივი ნაწილები ამოღებული) მოქმედების დასაწყისში. ოპერაციის შედეგი იგივეა, რაც გაყოფა:
Unarne zaperechernya
ერთიანი აღრიცხვის ოპერატორი მითითებულია "-" ნიშნით და ცვლის მისი ერთი ოპერანდის მნიშვნელობას ჩამოთვლაზე:
ამ შემთხვევაში, მრგვალი მკლავები არ არის საჭირო, რადგან უნივერსალურ ჩაკეტვას აქვს უმაღლესი პრიორიტეტი, მაგრამ ისინი ხელს უწყობენ კოდის ორგანიზებას ისე, რომ ცხადი იყოს, რომ არის ადგილი -5 და 4 რიცხვების დამატების ადგილი.
მატება
ზრდის ოპერატორი მითითებულია ნიშნით ++ და შეიძლება გაფართოვდეს ოპერანდის ორივე მხარეს, რომელზეც ის მუშაობს. ღირებულება იზრდება ერთით, ისევე როგორც ღირებულების დამატება. რეალური შედეგი დამოკიდებულია იმაზე, იყო თუ არა ოპერატორი სტაგნაციამდე ოპერანდამდე თუ მის შემდეგ, რომლითაც იგი სტაგნაციას განიცდიდა. ეს ოპერატორი ხშირად ცვლის ცვლილებებს და ის ხშირად გვხვდება მარყუჟების შუაში (მარყუჟები მოგვიანებით იქნება განხილული).
პრეფიქსის ფორმა გაზრდისთვის
პრეფიქსის ფორმა- თუ ინკრემენტის ოპერატორი გაიზარდა ოპერანდამდე, აღნიშვნის ეს ფორმა ნიშნავს, რომ ნამატი ჯერ გაიზრდება: ოპერანდის მნიშვნელობა იზრდება ერთით და მხოლოდ ამის შემდეგ იზრდება ინსტრუქცია:
პოსტფიქსის ფორმა ნამატისთვის
პოსტფიქსის ფორმარამდენჯერმე იწერება განსხვავებულად - ნამატი ფართოვდება ყოველ ჯერზე ოპერანდის შემდეგ. პოსტფიქსის სახით, პირველი ცვლადის ოპერანდის ჩაწერა აბრუნებს მეორე მნიშვნელობას, სანამ ბოლო მნიშვნელობა არ გაიზრდება ერთით:
შემცირება
შემცირების ოპერატორი აღინიშნება ნიშნით - , ხოლო ნამატი ოპერატორის შეცვლისას ის იცვლება და ზოგჯერ არ იზრდება მისი ოპერანდის მნიშვნელობა ერთით. შემცირება ასევე იძლევა პრეფიქსის და პოსტფიქსის აღნიშვნის საშუალებას:
ლოგიკური ოპერაციები არსებობს პროგრამირების ყველა ენაზე და 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-ზე გაყოფის შემდეგ ზედმეტს გამოვაკლებთ 0-ს, მაშინ ვწერთ FizzBuzz-ს. ეს კიდევ უფრო პოპულარულია ინტერნეტში. რადგან შენ თვითონ დაწერე, შეგიძლია დაწერო საკუთარ თავზე.
ან, მაგალითად, შეგვიძლია გამოვიყენოთ ნომერი 452 ყველა ნომრის დასაბეჭდად (4, 5, 2).
ვისნოვოკი
სიგიჟემდე, დარიჩინისა და გახეხილი ხილის მთელი და ზედმეტი ნაწილი ხშირად გამოდის და მათი ამორჩევა არც ისე ადვილია, როგორც პითონში, მაგრამ მაინც მნიშვნელოვანია.
ახლა თქვენ ერთი ნაბიჯით მიუახლოვდებით PHP პროგრამირების სწავლას და მომავალში კიდევ უფრო დაუახლოვდებით, რადგან ძალიან ცდილობთ სირთულეების გადალახვას.
