Catalyst中的这个冒号是什么意思

sotol

sub do_post : Local {     my ($self, $c) = @_;     $c->form(       validate => [['EQUAL_TO',$c->captcha_string]]     )   }

suntoltti

同问

churchmice

method的attribute
以前见过lock和lvalue
声明为lvalue的则sub的结果可以做为一个作值返回，直接的后果就是你可以给这个sub赋值
Local不知 ，难道返回的结果是一个Local类型的值？

sotol

这是在http://www.perlchina.org/上面看到的

关于:的语法解释，可以在具体点不，还是第一次见到

churchmice

我错了
仔细看了一下
那个是catalyst里面特有的
共有Global Local Private三种属性
我也不懂

churchmice

看这个
http://dev.catalyst.perl.org/docs/Catalyst/Manual/Intro.html

1. 
   
2. Action types
   
3. 
   
4. Catalyst supports several types of actions:
   
5. Literal (Path actions)
   
6.     package MyApp::Controller::My::Controller;
   
7.     sub bar : Path('foo/bar') { }
   
8. 
   
9. Literal Path actions will act relative to their current namespace. The above example matches only http://localhost:3000/my/controller/foo/bar. If you start your path with a forward slash, it will match from the root. Example:
   
10.     package MyApp::Controller::My::Controller;
    
11.     sub bar : Path('/foo/bar') { }
    
12. 
    
13. Matches only http://localhost:3000/foo/bar.
    
14.     package MyApp::Controller::My::Controller;
    
15.     sub bar : Path { }
    
16. 
    
17. By leaving the Path definition empty, it will match on the namespace root. The above code matches http://localhost:3000/my/controller.
    
18. Regex
    
19.     sub bar : Regex('^item(\d+)/order(\d+)$') { }
    
20. 
    
21. Matches any URL that matches the pattern in the action key, e.g. http://localhost:3000/item23/order42. The '' around the regexp is optional, but perltidy likes it. :)
    
22. 
    
23. Regex matches act globally, i.e. without reference to the namespace from which it is called, so that a bar method in the MyApp::Controller::Catalog::Order::Process namespace won't match any form of bar, Catalog, Order, or Process unless you explicitly put this in the regex. To achieve the above, you should consider using a LocalRegex action.
    
24. LocalRegex
    
25.     sub bar : LocalRegex('^widget(\d+)$') { }
    
26. 
    
27. LocalRegex actions act locally. If you were to use bar in MyApp::Controller::Catalog, the above example would match urls like http://localhost:3000/catalog/widget23.
    
28. 
    
29. If you omit the ``^'' from your regex, then it will match any depth from the controller and not immediately off of the controller name. The following example differs from the above code in that it will match http://localhost:3000/catalog/foo/widget23 as well.
    
30.     package MyApp::Controller::Catalog;
    
31.     sub bar : LocalRegex('widget(\d+)$') { }
    
32. 
    
33. For both LocalRegex and Regex actions, if you use capturing parentheses to extract values within the matching URL, those values are available in the $c->req->captures array. In the above example, ``widget23'' would capture ``23'' in the above example, and $c->req->captures->[0] would be ``23''. If you want to pass arguments at the end of your URL, you must use regex action keys. See URL Path Handling below.
    
34. Top-level (Global)
    
35.     package MyApp::Controller::Foo;
    
36.     sub foo : Global { }
    
37. 
    
38. Matches http://localhost:3000/foo. The function name is mapped directly to the application base. You can provide an equivalent function in this case by doing the following:
    
39.     package MyApp::Controller::Root
    
40.     sub foo : Local { }
    
41. Namespace-Prefixed (Local)
    
42.     package MyApp::Controller::My::Controller;
    
43.     sub foo : Local { }
    
44. 
    
45. Matches http://localhost:3000/my/controller/foo.
    
46. 
    
47. This action type indicates that the matching URL must be prefixed with a modified form of the component's class (package) name. This modified class name excludes the parts that have a pre-defined meaning in Catalyst (``MyApp::Controller'' in the above example), replaces ``::'' with ``/'', and converts the name to lower case. See Components for a full explanation of the pre-defined meaning of Catalyst component class names.
    
48. Chained
    
49. Catalyst also provides a method to build and dispatch chains of actions, like
    
50.     sub catalog : Chained : CaptureArgs(1) {
    
51.         my ( $self, $c, $arg ) = @_;
    
52.         ...
    
53.     }
    
54.     sub item : Chained('catalog') : Args(1) {
    
55.         my ( $self, $c, $arg ) = @_;
    
56.         ...
    
57.     }
    
58. 
    
59. to handle a /catalog/*/item/* path. For further information about this dispatch type, please see the Catalyst::DispatchType::Chained manpage.
    
60. 
    
61. Private
    
62.     sub foo : Private { }
    
63. 
    
64. Matches no URL, and cannot be executed by requesting a URL that corresponds to the action key. Private actions can be executed only inside a Catalyst application, by calling the forward method:
    
65.     $c->forward('foo');
    
66. 
    
67. See Flow Control for a full explanation of forward. Note that, as discussed there, when forwarding from another component, you must use the absolute path to the method, so that a private bar method in your MyApp::Controller::Catalog::Order::Process controller must, if called from elsewhere, be reached with $c->forward('/catalog/order/process/bar').
    
68. Args
    
69. Args is not an action type per se, but an action modifier - it adds a match restriction to any action it's provided to, requiring only as many path parts as are specified for the action to be valid - for example in MyApp::Controller::Foo,
    
70.   sub bar :Local
    
71. 
    
72. would match any URL starting /foo/bar/. To restrict this you can do
    
73.   sub bar :Local :Args(1)
    
74. 
    
75. to only match /foo/bar/*/
    
76. 
    
77. 
    
78. Note: After seeing these examples, you probably wonder what the point is of defining names for regex and path actions. Every public action is also a private one, so you have one unified way of addressing components in your forwards.
    
79. 
    
80. Built-in Private Actions
    
81. 
    
82. In response to specific application states, Catalyst will automatically call these built-in private actions in your application class:
    
83. default : Private
    
84. Called when no other action matches. Could be used, for example, for displaying a generic frontpage for the main app, or an error page for individual controllers.
    
85. 
    
86. If default isn't acting how you would expect, look at using a Literal Path action (with an empty path string). The difference is that Path takes arguments relative from the namespace and default always takes arguments relative from the root, regardless of what controller it's in. Indeed, this is now the recommended way of handling default situations; the default private controller should be considered deprecated.
    
87. 
    
88. index : Private
    
89. index is much like default except that it takes no arguments and it is weighted slightly higher in the matching process. It is useful as a static entry point to a controller, e.g. to have a static welcome page. Note that it's also weighted higher than Path.
    
90. 
    
91. begin : Private
    
92. Called at the beginning of a request, before any matching actions are called.
    
93. 
    
94. end : Private
    
95. Called at the end of a request, after all matching actions are called.
    
96. 
    
97. 
    
98. Built-in actions in controllers/autochaining
    
99.     Package MyApp::Controller::Foo;
    
100.     sub begin : Private { }
     
101.     sub default : Private { }
     
102.     sub auto : Private { }
     
103. 
     
104. You can define built-in private actions within your controllers as well. The actions will override the ones in less-specific controllers, or your application class. In other words, for each of the three built-in private actions, only one will be run in any request cycle. Thus, if MyApp::Controller::Catalog::begin exists, it will be run in place of MyApp::begin if you're in the catalog namespace, and MyApp::Controller::Catalog::Order::begin would override this in turn.
     
105. auto : Private
     
106. In addition to the normal built-in actions, you have a special action for making chains, auto. Such auto actions will be run after any begin, but before your action is processed. Unlike the other built-ins, auto actions do not override each other; they will be called in turn, starting with the application class and going through to the most specific class. This is the reverse of the order in which the normal built-ins override each other.
     
107. 
     
108. 
     
109. Here are some examples of the order in which the various built-ins would be called:
     
110. for a request for /foo/foo
     
111.   MyApp::begin
     
112.   MyApp::auto
     
113.   MyApp::Controller::Foo::default # in the absence of MyApp::Controller::Foo::Foo
     
114.   MyApp::end
     
115. for a request for /foo/bar/foo
     
116.   MyApp::Controller::Foo::Bar::begin
     
117.   MyApp::auto
     
118.   MyApp::Controller::Foo::auto
     
119.   MyApp::Controller::Foo::Bar::auto
     
120.   MyApp::Controller::Foo::Bar::default # for MyApp::Controller::Foo::Bar::foo
     
121.   MyApp::Controller::Foo::Bar::end
     
122. 
     
123. The auto action is also distinguished by the fact that you can break out of the processing chain by returning 0. If an auto action returns 0, any remaining actions will be skipped, except for end. So, for the request above, if the first auto returns false, the chain would look like this:
     
124. for a request for /foo/bar/foo where first auto returns false
     
125.   MyApp::Controller::Foo::Bar::begin
     
126.   MyApp::auto
     
127.   MyApp::Controller::Foo::Bar::end
     
128. 
     
129. An example of why one might use this is an authentication action: you could set up a auto action to handle authentication in your application class (which will always be called first), and if authentication fails, returning 0 would skip any remaining methods for that URL.
     
130. 
     
131. Note: Looking at it another way, auto actions have to return a true value to continue processing! You can also die in the auto action; in that case, the request will go straight to the finalize stage, without processing further actions.
     

复制代码

sotol

还是没搞懂，sub bar :Local，我是想更多了解一点这样的函数声明是个什么语法，比如一般看到的函数声明是sub bar {}是这样的，也就是它们之间的区别吧

福瑞哈哥

就是来声明一个属性。属性可以自定义，你要编程指定这个属性的含义。

hitsubunnu

原帖由 福瑞哈哥 于 2008-5-24 18:52 发表
就是来声明一个属性。属性可以自定义，你要编程指定这个属性的含义。

能给举个例子 详细讲讲吗

flw

原帖由 hitsubunnu 于 2008-5-24 18:56 发表

能给举个例子 详细讲讲吗

举个例子：比如一楼那个。