"არ გამოიყენოთ goto განცხადება"- ასე გვითხრეს აკადემიის მასწავლებლებმა და მართლაც, ეს ოპერატორი კოდს სრულ არეულობაში აქცევს. PHP დეველოპერებმა პრობლემა რადიკალურად გადაჭრეს - ის უბრალოდ არ არსებობს PHP3 და PHP4-ში. რითი იყვნენ ისინი თავდაპირველად მოტივირებული? იქნებ მათ სურდათ ყველა ჩვენგანში დანერგვა სწორი პროგრამირების სტილი? კარგად, შეიძლება ითქვას, რომ მათ სრულიად მიაღწიეს წარმატებას - ჩვენ ყველანი უკვე მიჩვეულები ვართ, ანუ მთლიანად დავკარგეთ ამ ოპერატორის ჩვევა, შესაძლოა ეს საუკეთესოც იყოს, რადგან ერთ დროს მომიწია ლოგიკური კონსტრუქციის მოფიქრება, რომელიც სრულად კომპენსირებულია ეს ყველაზე სამწუხარო წადი.
არ ვიცი, როგორ არის ეს ვინმესთვის, მაგრამ ჩემთვის განსაკუთრებით ხშირად გამიჩნდა სურვილი, გამომეყენებინა goto html ფორმის დამმუშავებლის შექმნისას, როდესაც მომხმარებლისგან სერვერზე იგზავნება უამრავი მონაცემი, რაც php სკრიპტმა უნდა შეამოწმეთ ეტაპობრივად. ეს პროცესი, როგორც წესი, რამდენიმე ეტაპად მიმდინარეობს: თავად ფორმის დაბეჭდვა, მიღებული მონაცემების შემოწმება, წინასწარი ჩვენება და, მაგალითად, შენახვა. უფრო მეტიც, ზოგიერთი ეტაპი შეიძლება განმეორდეს: თუ მონაცემთა გადამოწმებამ კარგად ვერ ჩაიარა, გადავდივართ ფორმის ბეჭდვაზე, ან თუ წინასწარი ჩვენება მომხმარებლისთვის არ შეესაბამება, მას შეუძლია დაუბრუნდეს მონაცემთა შეყვანას. მოკლედ, კოდის ზოგიერთი ნაწილი შეიძლება გამოყენებულ იქნას მრავალჯერ. ამ პირობებში ფუნქციების გამოყენება ასევე არც თუ ისე მოსახერხებელია - უამრავი შეყვანის და გამომავალი ცვლადია, ფუნქციამ უნდა შეასრულოს ძალიან რთული მოქმედებები, ის ზოგადად მოუხერხებლად გამოდის და კოდის წაკითხვა მკვეთრად ეცემა.
და მე მოვიფიქრე ეს დიზაინი.
კეთება( შეცვლა ($action) ( ნაგულისხმევი: შესვენება ; საქმე "PRINT_FORM" : ძირითადი ფორმის ბეჭდვა შესვენება ; შემთხვევა "CHECK_FORM" : მონაცემების სისწორის შემოწმება შესვენება ; შემთხვევა "PREVIEW_FORM" : გადახედვა შესვენება ; შემთხვევა "SAVE_FORM" : მონაცემთა შენახვა შესვენება ; ) ხოლო (ჭეშმარიტი) ; |
აქ არის ძირითადი მრავალჯერადი შერჩევის ოპერატორი შეცვლაგაუთავებელ მარყუჟში ჩაკეტილი გავაკეთოთ-ხოლო– ამ გზით ვაჯგუფებთ საჭირო მოქმედებებს სექციებად საქმე: შესვენება;და ჩვენ შეგვიძლია შეუზღუდავად გადავიდეთ ერთი განყოფილებიდან მეორეზე. განყოფილებაში ნაგულისხმევი:მოსახერხებელია მონაცემთა წინასწარი ანალიზის გაკეთება, მაგალითად, თუ მაშინ არ არის შეყვანილი მონაცემები $action = 'PRINT_FORM'დაბეჭდეთ ფორმა, თუ ეს შესაძლებელია, მაგალითად $_POST ['გაგზავნა']შემდეგ მიღებულ მონაცემებს ვაგზავნით დასამუშავებლად $action = 'CHECK_FORM'. კონტროლის გადაცემა გადამრთველ ბლოკებს შორის ხდება ცვლადის შეცვლით $ აქცია, კარგად, გამოდით ციკლიდან გამოყენებით შესვენება 2; ან გასასვლელი;
მაგალითად, ძირითადი ფორმის ბეჭდვის ბლოკში შეგიძლიათ უსაფრთხოდ მოათავსოთ შესვენება 2;რადგან ფორმის გამომავალი ვარაუდობს სცენარის დასასრულს.
დიზაინი არის ძალიან მოქნილი და იკითხება. მაგრამ არის ერთი ნაკლი - თუ მონაცემები არასწორად არის დამუშავებული, შეიძლება აღმოჩნდეთ გაუთავებელი მარყუჟში და სკრიპტი იყინება - უსიამოვნოა 30 წამამდე ლოდინი.
მოდით დავაწესოთ ლიმიტი ოპერატორის ციკლების რაოდენობაზე გავაკეთოთ-ხოლო 20 საკმარისია. ახლა, თუ რამეს დავამატებთ, სკრიპტი 20 რევოლუციას შეასრულებს, გაჩერდება და გამოსცემს საგანგებო გაფრთხილებას.
ძალიან მოსახერხებელია ასეთი კონსტრუქციის გამართვა - მხოლოდ ოპერატორის შემდეგ swithამობეჭდეთ $action ცვლადი და მივიღებთ ბლოკის შესრულების სრულ თანმიმდევრობას.
DO ( // ყოველი ციკლის დასაწყისში ვბეჭდავთ შესრულებული განყოფილების სახელს //, ძალიან მოსახერხებელია echo $action-ის გამართვისთვის." "; SWITCH ($action) ( ნაგულისხმევი: შესვენება; შემთხვევა "PRINT_FORM": /* ამობეჭდეთ ძირითადი ფორმა */ შესვენება; შემთხვევა "CHECK_FORM": /* შეამოწმეთ მონაცემები სწორია */ შესვენება; შემთხვევა "PREVIEW_FORM": /* გადახედვა * / break ;< 20) or die("Принудительный останов цикла"));
ᲙᲔᲗᲔᲑᲐ ( // ყოველი ციკლის დასაწყისში ვბეჭდავთ სახელს // შესრულებული განყოფილება ძალიან მოსახერხებელია გამართვისთვის ექო $მოქმედება . "";< / strong > SWITCH ($action) ( ნაგულისხმევი: შესვენება ; საქმე "PRINT_FORM" : დაბეჭდეთ ძირითადი ფორმა შესვენება ; |
RxGroovy-ს აქვს რამდენიმე Do ვარიანტი.
- ჯავადოკი:
- ჯავადოკი:
- ჯავადოკი:
doOnRequest ოპერატორი (ახალი RxGroovy 1.1-ში) არეგისტრირებს მოქმედებას, რომელიც გამოიძახება, როდესაც დამკვირვებელი ითხოვს დამატებით ელემენტებს მიღებული დაკვირვებიდან. ეს მოქმედება პარამეტრად იღებს იმ ნივთების რაოდენობას, რომლებსაც დამკვირვებელი ითხოვს.
- ჯავადოკი:
- ჯავადოკი:
- ჯავადოკი:
- ჯავადოკი:
- ჯავადოკი:
ადრე
- ჯავადოკი:
შემდეგმიღებული Observable მთავრდება, ნორმალურად თუ შეცდომით.
კოდის ნიმუში
def ნომრები = Observable.from(); numbers.finallyDo(( println("საბოლოოდ"); )).subscribe(( println(it); ), // onNext ( println("შეცდომა:" + it.getMessage()); ), // onError ( println ("მიმდევრობა დასრულებულია" ) // onCompleted);
1 2 3 4 5 თანმიმდევრობა დასრულდა ბოლოს
- ჯავადოკი:
RxJava-ს აქვს რამდენიმე Do ვარიანტი.
doOnEach ოპერატორი საშუალებას გაძლევთ დაადგინოთ გამოძახება, რომელსაც მიღებული Observable დაურეკავს ყოველ ჯერზე, როდესაც ის გამოსცემს ელემენტს. თქვენ შეგიძლიათ გადაიტანოთ ეს გამოძახება ან მოქმედების სახით, რომელიც თავის ერთადერთ პარამეტრად იღებს შეტყობინებების onNext მრავალფეროვნებას, ან შეგიძლიათ გადასცეთ დამკვირვებელს, რომლის onNext მეთოდს დაერქმევა ისე, თითქოს მას გამოწერილი აქვს Observable.
- ჯავადოკი:
- ჯავადოკი:
doOnNext ოპერატორი ძალიან ჰგავს doOnEach(Action1) გარდა იმისა, რომ მოქმედება, რომელსაც თქვენ გადასცემთ პარამეტრად, არ იღებს შეტყობინებას, არამედ უბრალოდ იღებს ემიტირებული ელემენტს.
კოდის ნიმუში
Observable.just(1, 2, 3).doOnNext(new Action1
შემდეგი: 1 შეცდომა: ელემენტი აჭარბებს მაქსიმალურ მნიშვნელობას
- ჯავადოკი:
doOnRequest ოპერატორი (ახალი RxJava 1.1-ში) არეგისტრირებს მოქმედებას, რომელიც გამოიძახება, როდესაც დამკვირვებელი ითხოვს დამატებით ელემენტებს მიღებული დაკვირვებიდან. ეს მოქმედება პარამეტრად იღებს იმ ნივთების რაოდენობას, რომლებსაც დამკვირვებელი ითხოვს.
- ჯავადოკი:
doOnSubscribe ოპერატორი არეგისტრირებს მოქმედებას, რომელიც გამოიძახება ყოველთვის, როცა დამკვირვებელი გამოიწერს მიღებულ Observable-ს.
- ჯავადოკი:
doOnUnsubscribe ოპერატორი რეგისტრირებს მოქმედებას, რომელიც გამოიძახება, როდესაც დამკვირვებელი გააუქმებს გამოწერას მიღებული Observable-დან.
- ჯავადოკი:
ოპერატორი doOnCompleted არეგისტრირებს მოქმედებას, რომელიც გამოიძახება, თუ მიღებული Observable ნორმალურად მთავრდება, დარეკავს onCompleted.
- ჯავადოკი:
doOnError ოპერატორი რეგისტრირებს მოქმედებას, რომელიც გამოიძახება, თუ მიღებული Observable არანორმალურად წყდება და გამოიძახებს onError-ს. ამ მოქმედებას გადაეცემა Throwable, რომელიც წარმოადგენს შეცდომას.
- ჯავადოკი:
ოპერატორი doOnTerminate არეგისტრირებს მოქმედებას, რომელსაც დაერქმევა just ადრემიღებული Observable მთავრდება, ნორმალურად თუ შეცდომით.
- ჯავადოკი:
საბოლოოდDo მოძველებულია RxJava 1.1.1-დან, იგივე ქცევით doAfterTerminate-ის სასარგებლოდ.
საბოლოოდDo ოპერატორი არეგისტრირებს მოქმედებას, რომელსაც დაერქმევა just შემდეგმიღებული Observable მთავრდება, ნორმალურად თუ შეცდომით.
- ჯავადოკი:
ოპერატორი doAfterTerminate არეგისტრირებს მოქმედებას, რომელსაც დაერქმევა just შემდეგმიღებული Observable მთავრდება, ნორმალურად თუ შეცდომით.
- ჯავადოკი:
RxJS ახორციელებს ძირითად Do ოპერატორს, როგორც do ან tap (ერთი და იგივე ოპერატორის ორი სახელი). თქვენ გაქვთ ორი არჩევანი, თუ როგორ გამოიყენოთ ეს ოპერატორი:
- თქვენ შეგიძლიათ გადასცეთ იგი Observer-ს, ამ შემთხვევაში do/tap გამოიძახებს ამ Observer-ის მეთოდებს, თითქოს ამ Observer-მა გამოიწერა მიღებული Observable.
- თქვენ შეგიძლიათ გაიაროთ 1-3 ინდივიდუალური ფუნქციის ნაკრები (შემდეგ, ერთიშეცდომა და დასრულებული), რომელსაც do/tap გამოიძახებს მისი რომელიმე დამკვირვებლის ანალოგიურად დასახელებულ ფუნქციებთან ერთად.
კოდის ნიმუში
/* დამკვირვებლის გამოყენებით */ var observer = Rx.Observer.create(function (x) ( console.log("შემდეგი გააკეთე: %s", x); ), ფუნქცია (err) ( console.log("Do Error : %s", err); ), ფუნქცია () ( console.log("Do Completed"); )); var წყარო = Rx.Observable.range(0, 3) .do(დამკვირვებელი); var subscription = source.subscribe(function (x) ( console.log ("შემდეგი: %s", x); ), ფუნქცია (err) ( console.log ("შეცდომა: %s", err); ), ფუნქცია () ( console.log ("დასრულებულია"); ));
/* ფუნქციის გამოყენებით */ var source = Rx.Observable.range(0, 3) .do(function (x) ( console.log("Do Next:", x); ), ფუნქცია (err) ( console. log("Do Error:", err ), function () (consol.log("Do Completed"); )); var subscription = source.subscribe(function (x) ( console.log ("შემდეგი: %s", x); ), ფუნქცია (err) ( console.log ("შეცდომა: %s", err); ), ფუნქცია () ( console.log ("დასრულებულია"); ));
გააკეთე შემდეგი: 0 შემდეგი: 0 გააკეთე შემდეგი: 1 შემდეგი: 1 გააკეთე შემდეგი: 2 შემდეგი: 2 გააკეთე დასრულებული დასრულდა
RxJS ასევე ახორციელებს doOnNext ან tapOnNext (ერთი და იგივე ოპერატორის ორი სახელი). ეს არის Do-ს სპეციალიზებული ფორმა, რომელიც პასუხობს მხოლოდ onNext შემთხვევას, თქვენ მიერ პარამეტრად მოწოდებული გამოძახების ფუნქციის გამოძახებით. თქვენ ასევე შეგიძლიათ სურვილისამებრ გადასცეთ მეორე პარამეტრი, რომელიც იქნება "ეს" ობიექტი თქვენი გამოძახების ფუნქციის თვალსაზრისით მისი შესრულებისას.
კოდის ნიმუში
var source = Rx.Observable.range(0, 3) .doOnNext(function () ( this.log("Do Next: %s", x); ), console); var subscription = source.subscribe(function (x) ( console.log ("შემდეგი: %s", x); ), ფუნქცია (err) ( console.log ("შეცდომა: %s", err); ), ფუნქცია () ( console.log ("დასრულებულია"); ));
გააკეთე შემდეგი: 0 შემდეგი: 0 გააკეთე შემდეგი: 1 შემდეგი: 1 გააკეთე შემდეგი: 2 შემდეგი: 2 დასრულდა
RxJS ასევე ახორციელებს doOnError ან tapOnError (ერთი და იგივე ოპერატორის ორი სახელი). ეს არის Do-ს სპეციალიზებული ფორმა, რომელიც პასუხობს მხოლოდ ერთი შეცდომის შემთხვევაში, თქვენ მიერ პარამეტრად მოწოდებული გამოძახების ფუნქციის გამოძახებით. თქვენ ასევე შეგიძლიათ სურვილისამებრ გადასცეთ მეორე პარამეტრი, რომელიც იქნება "ეს" ობიექტი თქვენი გამოძახების ფუნქციის თვალსაზრისით მისი შესრულებისას.
კოდის ნიმუში
var source = Rx.Observable.throw(new Error()); .doOnError(function (err) ( this.log ("Do Error: %s", err); ), console); var subscription = source.subscribe(function (x) ( console.log ("შემდეგი: %s", x); ), ფუნქცია (err) ( console.log ("შეცდომა: %s", err); ), ფუნქცია () ( console.log ("დასრულებულია"); ));
Do Error: Error Error: Error
RxJS ასევე ახორციელებს doOnCompleted ან tapOnCompleted (ერთი და იგივე ოპერატორის ორი სახელი). ეს არის Do-ს სპეციალიზებული ფორმა, რომელიც პასუხობს მხოლოდ onCompleted საქმეს, თქვენ მიერ პარამეტრად მოწოდებული გამოძახების ფუნქციის გამოძახებით. თქვენ ასევე შეგიძლიათ სურვილისამებრ გადასცეთ მეორე პარამეტრი, რომელიც იქნება "ეს" ობიექტი თქვენი გამოძახების ფუნქციის თვალსაზრისით მისი შესრულებისას.
კოდის ნიმუში
var source = Rx.Observable.range(0, 3) .doOnCompleted(function () ( this.log ("Do Completed"); ), console); var subscription = source.subscribe(function (x) ( console.log ("შემდეგი: %s", x); ), ფუნქცია (err) ( console.log ("შეცდომა: %s", err); ), ფუნქცია () ( console.log ("დასრულებულია"); ));
შემდეგი: 0 შემდეგი: 1 შემდეგი: 2 დასრულება დასრულდა
RxJS ასევე ახორციელებს საბოლოო ოპერატორს. მას სჭირდება ფუნქცია, რომელიც გამოიძახება მას შემდეგ, რაც მიღებული Observable დასრულდება, იქნება ეს ჩვეულებრივ (onCompleted) თუ არანორმალურად (onError).
კოდის ნიმუში
var source = Rx.Observable.throw(new Error()) .finally(function () ( console.log("Finally"); )); var subscription = source.subscribe(ფუნქცია (x) ( console.log ("შემდეგი: " + x); ), ფუნქცია (err) ( console.log ("შეცდომა: " + err);), ფუნქცია () (კონსოლი .log ("დასრულებულია");
შეცდომა: შეცდომა საბოლოოდ
do / tap , doOnNext / tapOnNext , doOnError / tapOnError , doOnCompleted / tapOnCompleted და ბოლოს გვხვდება თითოეულ შემდეგ განაწილებაში:
- rx.js
- rx.all.js
- rx.all.compat.js
- rx.compat.js
- rx.lite.js
- rx.lite.compat.js
RxPHP ახორციელებს ამ ოპერატორს ისე, როგორც ამას აკეთებს.
იწვევს მოქმედებას თითოეული ელემენტისთვის დაკვირვებადი თანმიმდევრობისთვის და იწვევს მოქმედებას დაკვირვებადი მიმდევრობის მოხდენილი ან განსაკუთრებული შეწყვეტის შემდეგ. ეს მეთოდი შეიძლება გამოყენებულ იქნას გამართვის, ჟურნალის და ა.შ. შეკითხვის ქცევა შეტყობინებების ნაკადის ჩაჭრით მილსადენზე შეტყობინებებისთვის თვითნებური მოქმედებების გასაშვებად. do-ს გამოყენებისას მნიშვნელოვანია გაითვალისწინოთ, რომ დამკვირვებელმა შეიძლება მიიღოს დამატებითი მოვლენები ნაკადის დასრულების ან შეცდომის შემდეგ (როგორიცაა განმეორების გამოყენებისას ან ხელახლა გამოწერისას). თუ თქვენ იყენებთ Observable-ს, რომელიც აფართოებს AbstractObservable-ს, თქვენ არ მიიღებთ ამ მოვლენებს. ამ განსაკუთრებული შემთხვევისთვის გამოიყენეთ DoObserver. doOnNext, doOnError და doOnCompleted იყენებს DoObserver-ს შინაგანად და მიიღებს ამ დამატებით მოვლენებს.
კოდის ნიმუში
//from https://github.com/ReactiveX/RxPHP/blob/master/demo/do/do.php $source = \Rx\Observable::range(0, 3) ->do(ფუნქცია ($x) ( echo "გააკეთე შემდეგი:", $x, PHP_EOL; ), ფუნქცია (Throwable $err) ( echo "Do Error:", $err->getMessage(), PHP_EOL; ), ფუნქცია () (echo "Do Completed" , PHP_EOL )); $subscription = $source->subscribe($stdoutObserver);
Do Next:0 შემდეგი მნიშვნელობა: 0 Do Next:1 შემდეგი მნიშვნელობა: 1 Do Next:2 შემდეგი მნიშვნელობა: 2 Do Completed Complete!
RxPHP-ს ასევე აქვს ოპერატორი doOnError.
კოდის ნიმუში
//დან https://github.com/ReactiveX/RxPHP/blob/master/demo/do/doOnError.php $source = \Rx\Observable::error(new Exception("Oops")) ->doOnError(ფუნქცია (Throwable $err) (echo "Do Error:", $err->getMessage(), PHP_EOL; )); $subscription = $source->subscribe($stdoutObserver);
შეცდომის გაკეთება: ოჰ, გამონაკლისი: უი
RxPHP-ს ასევე აქვს ოპერატორი doOnCompleted.
კოდის ნიმუში
//from https://github.com/ReactiveX/RxPHP/blob/master/demo/do/doOnCompleted.php $source = \Rx\Observable::empty() ->doOnCompleted(ფუნქცია () ( echo "DoOnCompleted ", PHP_EOL; )); $subscription = $source->subscribe($stdoutObserver);
დაასრულეთ დასრულებული!
RxPHP ასევე აქვს ოპერატორი საბოლოოდ.
გამოიძახებს მითითებულ ფუნქციას, როდესაც წყარო დასრულდება ან შეცდომით.
კოდის ნიმუში
//from https://github.com/ReactiveX/RxPHP/blob/master/demo/finally/finally.php Rx\Observable::range(1, 3) ->finally(function() (echo "Finally\n "; )) ->გამოწერა($stdoutObserver);
შემდეგი მნიშვნელობა: 1 შემდეგი მნიშვნელობა: 2 შემდეგი მნიშვნელობა: 3 სრული! ბოლოს და ბოლოს
//from https://github.com/ReactiveX/RxPHP/blob/master/demo/finally/finally-error.php Rx\Observable::range(1, 3) ->map(function($value) ( if ($value == 2) ( გადაყარეთ ახალი \Exception("შეცდომა"); ) დააბრუნეთ $value )) ->finally(function() (echo "Finally\n"; )) ->გამოწერა ($stdoutObserver) ;
შემდეგი მნიშვნელობა: 1 გამონაკლისი: შეცდომა საბოლოოდ
ანიჭებს მითითებულ PHP ფუნქციას მითითებულ ჰუკზე. მითითებული ფუნქცია გააქტიურდება მოვლენის მომენტში, რომელიც თავის მხრივ ამოქმედდება do_action()-ის გამოყენებით.
ჰუკი, რომელზეც ფუნქცია მიმაგრებულია, იქმნება (ინიციალიზებულია) do_action() ფუნქციის გამოყენებით.
მოქმედებები, ფილტრებისგან განსხვავებით (add_filter()), საჭიროა გარკვეული მოქმედებების შესასრულებლად საჭირო დროს, ხოლო ფილტრები გადასცემენ და იღებენ უკან მონაცემებს, რომლებიც შემდეგ გამოიყენება.
არაოფიციალურად: ფილტრები არის იგივე მოვლენები, ისინი ზუსტად ერთნაირად მუშაობენ და მათი გამოყენება შესაძლებელია როგორც ივენთები (add_filter()-ის ნაცვლად შეგიძლიათ გამოიყენოთ add_action() ფუნქცია და პირიქით). მაგალითად, შეგიძლიათ დააბრუნოთ მიღებული მონაცემები მისი შეცვლის გარეშე, მაგრამ დამატებით შეასრულოთ გარკვეული ოპერაცია (მაგალითად, ჩაწერა მონაცემთა ბაზაში). მართალია, ეს ძალიან იშვიათად არის საჭირო. ყველა იმ ადგილას, სადაც აუცილებელია ძრავის კოდში ჩარევა, დეველოპერები ცდილობენ განჭვრიტონ და ჩასვან მოვლენა ამ ადგილას.
✈ 1 დრო = 0.000018s = ძალიან სწრაფად| 50000 ჯერ = 0.07 ს = სინათლის სიჩქარე| PHP 7.0.8, WP 4.7
კაკვები არ არის.
ბრუნდება
ყოველთვის მართალია.
გამოყენება
add_action ($tag, $function_to_add, $priority, $accepted_args); $ tag (სტრიქონი) (აუცილებელია)მოქმედების სახელწოდება, რომელსაც დავამაგრებთ ფუნქციას. $function_to_add (სტრიქონი/დახურვა) (აუცილებელია)ფუნქციის დასახელება, რომელიც უნდა გამოიძახოს მოქმედების გაშვებისას, ე.ი. ფუნქცია, რომელსაც ვამაგრებთ კაუჭზე. ფუნქციის გადაცემის ფორმატი ჩვეულებრივ არის სტრიქონი, . $პრიორიტეტი (ნომერი)ფუნქციის შესრულების პრიორიტეტი. თუ უფრო მეტი ფუნქცია "მიმაგრებულია" იმავე კაუჭზე, მაშინ პრიორიტეტი განისაზღვრება მათი შესრულების თანმიმდევრობით. უფრო მცირე რიცხვი ნიშნავს, რომ ის უფრო ადრეა შესრულებული, ე.ი. 10 შესრულდება 20-მდე.ნაგულისხმევი: 10$accepted_args (ნომერი)არგუმენტების რაოდენობა, რომელსაც ფუნქცია იღებს. რა თქმა უნდა, მოქმედებამ უნდა გაიაროს ამ რაოდენობის არგუმენტები.
ნაგულისხმევი: 1
მაგალითები
#1 რეგულარული კაკალი
ახალი პოსტის გამოქვეყნებისას წერილს გამოგიგზავნით მეგობრებს:
Add_action ("გამოქვეყნების_პოსტი", "ელფოსტა_მეგობრები"); ფუნქცია email_friends($post_ID)($friends = " [ელფოსტა დაცულია], [ელფოსტა დაცულია]"; wp_mail($friends, "sally"-ს ბლოგი განახლებულია", "მე უბრალოდ დავდე რაღაც ჩემს ბლოგზე: http://blog.example.com"); დაბრუნება $post_ID; )
ანალოგიურად, შეგიძლიათ დაარეგისტრიროთ ეს hook add_filter():
Add_filter("publish_post", "email_friends");
#2 კამათის მიღება
do_action() გადასცემს არგუმენტს ფუნქციას და მისი გამოყენება შესაძლებელია. წინა მაგალითში ეს იყო პოსტის ID, მაგრამ ჩვენ არ გამოგვიყენებია, ამიტომ არ დაგვჭირდა. ახლა, მაგალითი იმისა, თუ როგორ გამოვიყენოთ მიღებული არგუმენტი:
Add_action("comment_id_not_found", "echo_comment_id", 10, 1); ფუნქცია echo_comment_id($comment_ID)(echo "მე ახლახან მივიღე". $comment_ID; )
#3 ანონიმური ფუნქცია
თქვენ შეგიძლიათ გადასცეთ ანონიმური ფუნქცია, როგორც გამოძახების ფუნქცია, მაგალითად:
Add_action("wp_head", ფუნქცია())(echo "something"; ));
ასეთი ანონიმური ფუნქციები არ მუშაობს PHP ამაჩქარებლებთან.
#4 მოვლენის დამატება PHP კლასიდან
თუ მოვლენისთვის გჭირდებათ PHP კლასის მეთოდის გამოყენება, მაშინ მეორე არგუმენტში, ფუნქციის სახელის ნაცვლად, უნდა მიუთითოთ მასივი, სადაც პირველი არგუმენტი არის კლასის სახელი (სტატიკური მეთოდისთვის) ან კლასის მაგალითი (public მეთოდისთვის), ხოლო მეორე არის ამ კლასის მეთოდის სახელი.
კლასის მაგალითი არის $this ცვლადში:
// კლასის მეთოდის დაკავშირება კლასის გარეთ add_action("wp_head", array("My_Class", "my_static_method")); class My_Class ( საჯარო ფუნქცია __construct() (// კლასის მეთოდის დაკავშირება კლასში add_action("save_post", array($this, "my_public_method")); add_action("save_post", array(__CLASS__, "my_static_method")) ) საჯარო ფუნქცია my_public_method ($post_id) ( // ფუნქციის კოდი ) სტატიკური ფუნქცია my_static_method ($post_id) ( // ფუნქციის კოდი ) )
შენიშვნები
იმის გასარკვევად, თუ რამდენ არგუმენტს გადის მოქმედება, იპოვეთ იგი კოდში და ნახეთ. მაგალითად, აქ მოცემულია 2 არგუმენტი:
Do_action ("შენახვა_პოსტი", $post_ID, $post);
და ასეთი კაუჭისთვის, ჰუკის კოდი ასე გამოიყურება:
Add_action("post_save", "my_save_post", 10, 2);
და ფუნქციას ექნება 2 არგუმენტი:
ფუნქცია my_save_post($post_ID, $post)(// ფუნქციის კოდი აქ)
ქმნის მოვლენას (ჰუკი თვითნებური ფუნქციისთვის). იმისათვის, რომ ფუნქციამ იმუშაოს მოვლენის დროს, ის უნდა იყოს დაკავშირებული ამ მოვლენასთან add_action() ფუნქციის გამოყენებით.
გარდა მოვლენებისა, WP-ს აქვს ფილტრებიც, მუშაობის პრინციპი იგივეა. ერთადერთი განსხვავება ისაა, რომ ფილტრმა უნდა დააბრუნოს მიღებული ცვლადი, ე.ი. ის ფილტრავს (ცვლის) მონაცემებს და ღონისძიება საშუალებას გაძლევთ გაუშვათ მორგებული ფუნქცია ღონისძიების გაშვებისას. ფილტრები გაშვებულია application_filters() ფუნქციის გამოყენებით
✈ 1 დრო = 0.00007s = ძალიან სწრაფად| 50000 ჯერ = 0.03 s = სინათლის სიჩქარე
კაკვები არ არის.
ბრუნდება
არაფერს აბრუნებს.
გამოყენება
do_action ($tag, $arg_a, $arg_b, ...); $ tag (სტრიქონი) (აუცილებელია)შექმნის კაკლის სახელი. $arg_a არგუმენტის მნიშვნელობა, რომელიც გადაეცემა.$arg_b (სტრიქონი / მასივი / რიცხვი / ობიექტი / ლოგიკური)კიდევ ერთი არგუმენტის აზრი...
ნაგულისხმევი: არგუმენტი არ არსებობს$arg_с (სტრიქონი / მასივი / რიცხვი / ობიექტი / ლოგიკური)თქვენ შეგიძლიათ უსასრულო რაოდენობის არგუმენტები გადასცეთ ფუნქციას...
მაგალითები
#1. გამოყენების მაგალითი
ამ ფუნქციის გამოყენება შესაძლებელია დანამატებში, თემებში და ა.შ., როდესაც თქვენ გჭირდებათ საკუთარი თავის ინექცია კოდის შესრულების პროცესში სხვაგან. მაგალითად, ჩვენ დავაინსტალირეთ „hook“ (do_action) დანამატში და ჩვენ „დავიჭერთ“ მას functions.php ფაილიდან იმ მომენტში, როდესაც ჩვენი „hook“ გააქტიურდება.
ვთქვათ, ჩვენ გამოვიყენეთ ეს კოდი დანამატში:
ახლა ჩვენ შეგვიძლია გავაკეთოთ გარკვეული მოქმედება do_action ფუნქციის გაშვების მომენტში და ამავდროულად შეგვიძლია აღვწეროთ ჩვენი მოქმედება, მაგალითად, functions.php ფაილიდან, მასში შემდეგი კოდის განთავსება:
ფუნქცია do_my_hook($a, $b)( // თუ გადაცემული $a ცვლადი მართალია, // მაშინ, მაგალითად, წაშალეთ პოსტი 10 if($a===true) wp_delete_post(10); // და შემდეგ უბრალოდ ეკრანის ექოზე ცვლადის ჩვენება "
".$b; // აჩვენებს მეორე ცვლადის მნიშვნელობას) // დაარეგისტრირეთ კაკალი // add_action($tag, $function_to_add, $priority, $accepted_args); add_action("my_hook", "do_my_hook", 10 , 2);
მოქმედებები განსხვავდება ფილტრებისგან იმით, რომ მოქმედებით მიღებული მონაცემები არ უბრუნდება ფუნქციას და არ გამოიყენება იქ მომავალში, არამედ უბრალოდ გადაეცემა Hook ფუნქციაში გამოსაყენებლად.
კოდი გააკეთე მოქმედება: wp-includes/plugin.php WP 5.2.2
do_action ($args); array_pop ($wp_current_filter); )ჩვენ შევქმენით საფუძველი მომავალი მოდულისთვის, რომელიც იქნება აღიარებული WordPress სისტემის მიერ. დღეს ჩვენ პირდაპირ შევცვლით სისტემის ძირითად ფუნქციონირებას.
ამაში დაგვეხმარება „კაკვების“, „მოვლენების“ (მოქმედებების) და ფილტრების (ფილტრების) სისტემა. ეს სამი კონცეფცია არის ყველა WordPress მოდულის საფუძველი.
კაკვები
WordPress-ში არის ორი ტიპის კაკვები:
- სამოქმედო კაკალი:კოდში აღნიშნავს ადგილს, რომელიც ახორციელებს გარკვეულ მოქმედებას, მაგალითად, საჭიროა გარკვეული მონაცემების შეყვანა და მონაცემთა ბაზაში შენახვა.
- ფილტრის კაკალი:აღნიშნავს ფილტრს, რომელიც შეცვლის გარკვეულ მნიშვნელობას (ცვლადი), ასე რომ მომავალში კოდი გამოიყენებს შეცვლილ მნიშვნელობას.
მოქმედებები
მოვლენებთან (მოქმედებებთან) მუშაობა
WordPress-ში მოვლენების მართვის ზოგადი ლოგიკა მარტივია:
- მონიშნეთ ადგილი, სადაც მოქმედება უნდა შესრულდეს სამოქმედო კაკლის გამოყენებით საჭირო პარამეტრებით.
- შექმენით ფუნქცია, რომელიც შეასრულებს სასურველ მოქმედებებს Hook-ის მიერ გადაცემული პარამეტრების გამოყენებით.
- დაარეგისტრირეთ ღონისძიება, რომელიც განხორციელდება კაკლის გასროლისას, კონკრეტული პრიორიტეტით.
- როდესაც WordPress ჩატვირთავს გვერდს და იპოვის კაუჭს, სისტემა შეასრულებს ყველა ფუნქციას, რომელიც რეგისტრირებულია ამ კაუჭზე.
პირველი პუნქტის შესასრულებლად, სისტემა უზრუნველყოფს "do_action" ფუნქციას:
Do_action ($tag, $arg_1, $arg_2, ... , $arg_n);
იგი იღებს შემდეგ არგუმენტებს: $tag – “hook”-ის სახელი, $arg_1, $arg_2, ..., $arg_n – პარამეტრები, რომლებითაც გამოიძახება ფუნქცია. შეიძლება იყოს ნებისმიერი რაოდენობის არგუმენტი, ან 0.
თავად სისტემას აქვს უკვე განსაზღვრული მრავალი კაუჭი:
Do_action ("დაწყება");
ეს არის ძალიან მარტივი მაგალითი დამატებითი არგუმენტების გარეშე. ეს Hook ამოქმედდება, როდესაც სისტემის უმეტესი ნაწილი უკვე კონფიგურირებულია და დროა შექმნათ თქვენი საკუთარი ობიექტები, კატეგორიები, პოსტები და ა.შ.
Do_action ("შენახვა_პოსტი", $post_id, $post);
ამ მაგალითში, Hook ამოქმედდება, როდესაც პოსტი ინახება ორი არგუმენტით post_id - პოსტის იდენტიფიკატორი და პოსტი - თავად პოსტი.
ჰუკების შექმნა ხელმისაწვდომია ნებისმიერი დეველოპერისთვის საკუთარი მოდულის (ან თემის) შესაქმნელად. ამის წყალობით, ჩვენ გვაქვს ძლიერი ინსტრუმენტი სისტემის ქცევის გასაკონტროლებლად.
Do_action ("my_truly_custom_hook");
მას შემდეგ რაც შევქმენით hook და დავწერთ ფუნქციას, ჩვენ უნდა დავარეგისტრიროთ ფუნქცია "add_action"-ის გამოყენებით.
Add_action($tag, $function_to_add, $priority, $accepted_args_number);
ფუნქცია 'add_action' იღებს ორ აუცილებელ პარამეტრს: $tag: შესაბამისი hook-ის სახელი და $function_to_add: გამოსაძახებელი ფუნქციის სახელი. დანარჩენი ორი პარამეტრი არასავალდებულოა: $priority: მთელი რიცხვი ცვლადი, რომელიც განსაზღვრავს ფუნქციის შესრულების თანმიმდევრობას (ნაგულისხმევი არის 10), $accepted_args_number: არგუმენტების რაოდენობა, რომელსაც ფუნქცია იღებს (ნაგულისხმევი არის 1).
მოდით შევხედოთ მაგალითს მთელი პროცესის გასაგებად. ვთქვათ, გვინდა დავამატო პატარა შეტყობინება ჩვენი ვებსაიტის ბოლოში. ჩვენ შეგვიძლია გამოვიყენოთ 'wp_footer' hook ამისთვის, რადგან ეს არის კოდის აუცილებელი ნაწილი, რომელსაც იყენებს ყველა თემა.
ფუნქცია msp_helloworld_footer_notice())(echo "
ამ მაგალითში ჩვენ შევქმენით ფუნქცია, რომელიც უბრალოდ ასახავს გაფრთხილების მარკირებას და დარეგისტრირდა 'wp_footer'-ით. მას შემდეგ რაც ამ კოდს დავამატებთ ჩვენს დანამატის ფაილს (იხ. წინა), ჩვენ ვნახავთ შედეგს გვერდზე:
WordPress Plugin Alert
ფილტრებთან მუშაობა
ფილტრები მუშაობს ისევე, როგორც მოვლენები. მაგრამ ფილტრები არ ასრულებენ მხოლოდ კოდის კონკრეტულ ნაწილს, ისინი ცვლიან მათზე გადაცემულ მნიშვნელობებს. ეს ნიშნავს, რომ თითოეულ ფილტრს აქვს ასოცირებული მნიშვნელობა (ცვლადი), რომელზეც ის მუშაობს.
ფილტრის ფუნქცია მიიღებს ამ მნიშვნელობას და გარდაქმნის მას შემდგომი გამოყენებისთვის. ფილტრის კაკვები ოდნავ განსხვავდება სამოქმედო კაკვებისგან.
Apply_filters($tag, $value_to_filter, $arg_1, $arg_2, ... , $arg_n);
'apply_filter' ფუნქცია ქმნის ფილტრის კაუჭს სახელწოდებით $tag და საჭირო პარამეტრს $value_to_filter (ეს შეიძლება ცარიელი იყოს, მაგრამ უნდა იყოს დეკლარირებული). დარჩენილი არჩევითი არგუმენტები მუშაობს ისევე, როგორც მოვლენებისთვის.
Filter_function($value_to_filter, $arg_1, $arg_2, ... , $arg_n)(//ფილტრი დააბრუნებს $value_to_filter; //მნიშვნელობა უნდა დაბრუნდეს)
ეს არის ფილტრის "ჩონჩხი", რომელიც აჩვენებს, რომ ფილტრი უნდა:
- მიიღეთ მინიმუმ 1 არგუმენტი;
- დააბრუნეთ შეცვლილი მნიშვნელობა.
ფუნქცია 'add_filter' არეგისტრირებს ფუნქციას სახელით, რომელიც შეიცავს $function_to_add $tag hook-ს. დარჩენილი არგუმენტები - $priority და $accepted_args - მუშაობს ისევე, როგორც ღონისძიების კაუჭებისთვის.
მოდით შევხედოთ მაგალითს: მოდულის საერთო ამოცანაა პოსტის ბოლოს რაიმეს დამატება. თუ ყურადღებით დავაკვირდებით ფუნქციას "the_content", რომელიც გამოიყენება პოსტის შინაარსის საჩვენებლად, ჩვენ ვიპოვით შემდეგ კაუჭს:
$content = application_filters ("the_content", $content);
მისი გამოყენებით ჩვენ შეგვიძლია მარტივად დავამატოთ რაღაც პოსტის ბოლოს.
ფუნქცია msp_helloworld_post_footer($content) ($content .= "
"; დაბრუნება $content; ) add_filter("the_content", "msp_helloworld_post_footer", 100);გაითვალისწინეთ, რომ ჩვენ ვიყენებთ დიდ რიცხვს პრიორიტეტულად, რათა უზრუნველყოს ყველა სტანდარტული ფილტრის შესრულება „msp_helloworld_post_footer“-ის შესრულებამდე. კოდის ჩართვის შემდეგ ჩვენს დანამატში ვნახავთ შედეგს:
როგორ მოვძებნოთ კაკალი
ახლა ჩვენ გვესმის, რომ გარკვეული მოქმედებების შესასრულებლად, უნდა ვიცოდეთ არსებული კაკვების შესახებ.
WordPress Codex გთავაზობთ კაკვების ჩამონათვალს ფილტრებისთვის და ქმედებების მითითების და ფილტრის მითითების მოვლენებისთვის.
დამატებითი მოქმედებები კაკვებით
ისევე, როგორც დამატებისას, კაკლის ამოღება შესაძლებელია მსგავსი სინტაქსის გამოყენებით.
თქვენ შეგიძლიათ წაშალოთ მსგავსი მოვლენები:
Remove_action ($tag, $function_to_remove, $priority, $accepted_args); ამოღება_ყველა_მოქმედება ($tag, $პრიორიტეტი);
როგორც თქვენ მიხვდით, „remove_action“ აშორებს კონკრეტულ მოვლენას, რომელიც რეგისტრირებულა მოცემული ჰუკისთვის (არგუმენტების პრიორიტეტი და რაოდენობა უნდა იყოს მითითებული სწორად, როგორც ეს მითითებული იყო რეგისტრაციის დროს), ხოლო „remove_all_actions“ ეხმარება ამოიღოს ყველა მოვლენა, რომელიც რეგისტრირებულია ჰუკისთვის ( თუ პრიორიტეტი გამოტოვებულია, ფუნქცია წაშლის ყველა მოვლენას).
ფილტრები შეიძლება წაიშალოს იმავე გზით:
Remove_filter($tag, $function_to_remove, $priority, $accepted_args); წაშლა_ყველა_ფილტრები ($tag, $პრიორიტეტი);
WordPress მოდულის API ასევე უზრუნველყოფს ფუნქციებს იმის შესამოწმებლად, არის თუ არა ფუნქცია რეგისტრირებული მოცემულ კაუჭზე:
აქვს_მოქმედება ($tag, $function_to_check); აქვს_ფილტრი ($tag, $function_to_check);
ორივე ფუნქცია ამოწმებს არის თუ არა მოცემული ფუნქცია რეგისტრირებული კაუჭისთვის და წარმატების შემთხვევაში აბრუნებს true, წინააღმდეგ შემთხვევაში flase. ფუნქციის შიგნით გვაქვს შესაძლებლობა შევამოწმოთ, რომ კაუჭმა მას უწოდა:
If ("hook_to_check_name" === მიმდინარე_ფილტრი())()
მიუხედავად სახელისა "current_filter" მუშაობს არა მხოლოდ ფილტრებით, არამედ მოვლენებთანაც.
არა ტრივიალური მაგალითი
მოდით გავაცოცხლოთ ჩვენი მოდულის „ჩონჩხი“, რომელიც ბოლო გაკვეთილზე მოვამზადეთ.
მოდით შეავსოთ 'core.php' ფაილი (ჩვენი მოდულის ძირითადი ნაწილი, რომელიც შეიცავს ფუნქციების დიდ ნაწილს) კოდით, რომელიც გადაჭრის პრობლემას, რომელიც რეალურად შეიძლება წარმოიშვას მუშაობის დროს. ამის გადასაჭრელად ჩვენ გამოვიყენებთ მოქმედებებს და ფილტრებს.
ნება მიეცით თქვენს WordPress საიტს მიიღოს შეტყობინებები სხვადასხვა ავტორისგან სტუმრებისგან, მაგრამ არ გაძლევთ საშუალებას შექმნათ ანგარიშები. ეს ნიშნავს, რომ მომხმარებელი, რომელმაც პოსტი გამოაქვეყნა და რეალური ავტორი სხვადასხვა ხალხია და ჩვენ უნდა დავრწმუნდეთ, რომ ავტორი მითითებულია პოსტში. ჩვენ შეგვიძლია ამის გაკეთება ტაქსონომიის გამოყენებით.
შევქმნათ ჩვენი ტაქსონომია ავტორის სახელისა და მოკლე ბიოგრაფიის დასამუშავებლად. ჩვენ შევძლებთ გამოვიყენოთ ავტორის სახელი, როგორც სხვა ტაქსონომიური ტერმინები (ტაგები, მაგალითად) პოსტში. კოდი:
/** დაარეგისტრირე ფილტრები და მოვლენები **/ ფუნქცია msp_helloworld_init())( add_action("init", "msp_helloworld_taxonomies"); add_filter("the_content", "msp_helloworld_author_block_filter"); add_action ("plugins_loaded", "msp_helloworld_init"); /** ტაქსონომია **/ ფუნქცია msp_helloworld_taxonomies())( $args = array("labels" => array("name" => "სტუმარი ავტორები", "singular_name" => "სტუმარი ავტორი"), "show_in_nav_menus" = > false register_taxonomy("gauthor", array("post"), $args ) /** ავტორის ბლოკის მარკირება **/ ფუნქცია msp_helloworld_author_block())( გლობალური $post; $author_terms = wp_get_object_terms($post->ID, "gauthor" if(empty($author_terms)) return $name = stripslashes ($author_terms->name) = esc_url(get_term_link ($author_terms)); $out = "
"; დაბრუნება $out; ) /** დაამატეთ მარკირება პოსტის ბოლოს **/ ფუნქცია msp_helloworld_author_block_filter($content)( if(is_single()) $content .= msp_helloworld_author_block(); დააბრუნეთ $content; ) /** დაამატეთ CSS კლასი პოსტში **/ ფუნქცია msp_helloworld_post_class($post_class)( გლობალური $post; $author_terms = wp_get_object_terms($post->ID, "gauthor"); if(!empty($author_terms))($post_hors = "gaut ";) დააბრუნეთ $post_class)როგორც ხედავთ, ჩვენ შევქმენით ფუნქცია, რომ დაარეგისტრიროთ ჩვენი ტაქსონომია და მივამაგროთ იგი "init" კაუჭთან. შემდეგი, ჩვენ შევქმენით შაბლონი, რომელიც პასუხისმგებელია ავტორის ბლოკის ჩვენებაზე WordPress ფუნქციის „wp_get_object_terms“ გამოყენებით. შემდეგ ჩვენ ჩავსვით ბლოკი ავტორის შესახებ ინფორმაციის შესახებ პოსტის ბოლოს „the_content“ ფილტრის გამოყენებით. და ბოლოს, ჩვენ დავამატეთ ჩვენი საკუთარი CSS კლასი. შედეგი:
