blocks|key|3354011|text|不幸的是，private只适用于实例方法。在类中获取私有“静态”方法的一般方法是这样做：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3354012|class+<<+self
++private

++def+foo()
+++....
++end
end|code-block|syntax|javascript|3354013|诚然，我还没有尝试过在模块中做这件事。|3354014|entityMap^0|5|7|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

Unfortunately, <code>private</code> only applies to instance methods. The general way to get private "static" methods in a class is to do something like:

<pre><code>class &lt;&lt; self
 private

 def foo()
 ....
 end
end
</code></pre>

Admittedly I haven't played with doing this in modules.

blocks|key|355990|text|当模块混合在一起时，您可以使用"included“方法来做一些奇特的事情。我想这就是你想要的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|355991|module+Foo
++def+self.included(base)
++++class+<<+base+
++++++def+public_method
++++++++puts+"public+method"
++++++end
++++++def+call_private
++++++++private_method
++++++end
++++++private
++++++def+private_method
++++++++puts+"private"
++++++end
++++end
++end
end

class+Bar
++include+Foo
end

Bar.public_method

begin
++Bar.private_method
rescue
++puts+"couldn't+call+private+method"
end

Bar.call_private|code-block|syntax|javascript|355992|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can use the "included" method to do fancy things when a module is mixed in. This does about what you want I think:

<pre><code>module Foo
 def self.included(base)
 class &lt;&lt; base 
 def public_method
 puts "public method"
 end
 def call_private
 private_method
 end
 private
 def private_method
 puts "private"
 end
 end
 end
end

class Bar
 include Foo
end

Bar.public_method

begin
 Bar.private_method
rescue
 puts "couldn't call private method"
end

Bar.call_private
</code></pre>

blocks|key|359323|text|还有Module.private_class_method，可以说它表达了更多的意图。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|359324|module+Foo
++def+self.included(base)
++++base.instance_eval+do
++++++def+method_name
++++++++#+...
++++++end
++++++private_class_method+:method_name
++++end
++end
end|code-block|syntax|javascript|359325|对于问题中的代码：|359326|module+Thing
++def+self.pub;+puts+"Public+method";+end
++def+self.priv;+puts+"Private+method";+end
++private_class_method+:priv
end|359327|Ruby+2.1或更高版本：|359328|module+Thing
++def+self.pub;+puts+"Public+method";+end
++private_class_method+def+self.priv;+puts+"Private+method";+end
end|359329|entityMap^0|2|R|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|10|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|S|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|T|$]]

There's also <code>Module.private_class_method</code>, which arguably expresses more intent.

<pre><code>module Foo
 def self.included(base)
 base.instance_eval do
 def method_name
 # ...
 end
 private_class_method :method_name
 end
 end
end
</code></pre>

For the code in the question:

<pre><code>module Thing
 def self.pub; puts "Public method"; end
 def self.priv; puts "Private method"; end
 private_class_method :priv
end
</code></pre>

Ruby 2.1 or newer:

<pre><code>module Thing
 def self.pub; puts "Public method"; end
 private_class_method def self.priv; puts "Private method"; end
end
</code></pre>

blocks|key|3354077|text|我认为最好的方法(主要是如何编写现有的库)是通过在模块中创建一个处理所有逻辑的类，该模块只提供了一个方便的方法，例如|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3354078|module+GTranslate
++class+Translator
++++def+perform(text)
++++++translate(text)
++++end

++++private

++++def+translate(text)
++++++#+do+some+private+stuff+here
++++end
++end

++def+self.translate(text)
++++t+=+Translator.new
++++t.perform(text)
++end
end|code-block|syntax|javascript|3354079|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I think the best way (and mostly how existing libs are written) to do this is by creating a class within the module that deals with all the logic, and the module just provides a convenient method, e.g.
<pre><code>module GTranslate
 class Translator
 def perform(text)
 translate(text)
 end

 private

 def translate(text)
 # do some private stuff here
 end
 end

 def self.translate(text)
 t = Translator.new
 t.perform(text)
 end
end
</code></pre>

blocks|key|356082|text|将方法作为lambda存储在类变量/常量中是怎么回事？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|356083|module+MyModule
++@@my_secret_method+=+lambda+{
++++#+...
++}
++#+...
end|code-block|syntax|javascript|356084|对于测试：|356085|更新:这段代码在6年后的巨大更新，展示了声明私有方法d的更清晰的方法|offset|length|style|BOLD|CODE|356086|module+A
++@@L+=+lambda{+"@@L"+}
++def+self.a+;+@@L[]+;+end
++def+self.b+;+a+;+end

++class+<<+self
++++def+c+;+@@L[]+;+end
++++private
++++def+d+;+@@L[]+;+end
++end
++def+self.e+;+c+;+end
++def+self.f+;+self.c+;+end
++def+self.g+;+d+;+end
++def+self.h+;+self.d+;+end

++private
++def+self.i+;+@@L[]+;+end
++class+<<+self
++++def+j+;+@@L[]+;+end
++end

++public
++def+self.k+;+i+;+end
++def+self.l+;+self.i+;+end
++def+self.m+;+j+;+end
++def+self.n+;+self.j+;+end
end

for+expr+in+%25w{+A.a+A.b+A.c+A.d+A.e+A.f+A.g+A.h+A.i+A.j+A.k+A.l+A.m+A.n+}
++puts+"#{expr}+=>+#{begin+;+eval+expr+;+rescue+=>+e+;+e+;+end}"
end|356087|在这里我们可以看到：|356088|A.a+=>+@@L
A.b+=>+@@L
A.c+=>+@@L
A.d+=>+private+method+`d'+called+for+A:Module
A.e+=>+@@L
A.f+=>+@@L
A.g+=>+@@L
A.h+=>+private+method+`d'+called+for+A:Module
A.i+=>+@@L
A.j+=>+@@L
A.k+=>+@@L
A.l+=>+@@L
A.m+=>+@@L
A.n+=>+@@L|356089|1)+@@L不能从外部访问，但几乎可以从任何地方访问|356090|2)+class+<<+self+;+private+;+def使用self.成功地使方法d无法从外部和内部访问，但没有它就不能访问--这很奇怪|356091|3)+private+;+self.和private+;+class+<<+self不会使方法成为私有方法--无论有没有self.，它们都可以访问|356092|entityMap^0|0|0|0|0|H|Q|1|0|0|0|0|3|3|0|3|T|Y|5|19|1|0|3|F|J|N|1O|5|0^^$0|@$1|2|3|4|5|6|7|13|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|15|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|16|8|@$K|17|L|18|M|N]|$K|19|L|1A|M|O]]|9|@]|A|$]]|$1|P|3|Q|5|D|7|1B|8|@]|9|@]|A|$E|F]]|$1|R|3|S|5|6|7|1C|8|@]|9|@]|A|$]]|$1|T|3|U|5|D|7|1D|8|@]|9|@]|A|$E|F]]|$1|V|3|W|5|6|7|1E|8|@$K|1F|L|1G|M|O]]|9|@]|A|$]]|$1|X|3|Y|5|6|7|1H|8|@$K|1I|L|1J|M|O]|$K|1K|L|1L|M|O]|$K|1M|L|1N|M|O]]|9|@]|A|$]]|$1|Z|3|10|5|6|7|1O|8|@$K|1P|L|1Q|M|O]|$K|1R|L|1S|M|O]|$K|1T|L|1U|M|O]]|9|@]|A|$]]|$1|11|3|-4|5|6|7|1V|8|@]|9|@]|A|$]]]|12|$]]

What's about storing methods as lambdas within class variables/constants?

<pre><code>module MyModule
 @@my_secret_method = lambda {
 # ...
 }
 # ...
end
</code></pre>

For test: 
UPD: huge update of this code after 6 years shows cleaner way to declare private method <code>d</code>

<pre><code>module A
 @@L = lambda{ "@@L" }
 def self.a ; @@L[] ; end
 def self.b ; a ; end

 class &lt;&lt; self
 def c ; @@L[] ; end
 private
 def d ; @@L[] ; end
 end
 def self.e ; c ; end
 def self.f ; self.c ; end
 def self.g ; d ; end
 def self.h ; self.d ; end

 private
 def self.i ; @@L[] ; end
 class &lt;&lt; self
 def j ; @@L[] ; end
 end

 public
 def self.k ; i ; end
 def self.l ; self.i ; end
 def self.m ; j ; end
 def self.n ; self.j ; end
end

for expr in %w{ A.a A.b A.c A.d A.e A.f A.g A.h A.i A.j A.k A.l A.m A.n }
 puts "#{expr} =&gt; #{begin ; eval expr ; rescue =&gt; e ; e ; end}"
end
</code></pre>

Here we see that:

<pre><code>A.a =&gt; @@L
A.b =&gt; @@L
A.c =&gt; @@L
A.d =&gt; private method `d' called for A:Module
A.e =&gt; @@L
A.f =&gt; @@L
A.g =&gt; @@L
A.h =&gt; private method `d' called for A:Module
A.i =&gt; @@L
A.j =&gt; @@L
A.k =&gt; @@L
A.l =&gt; @@L
A.m =&gt; @@L
A.n =&gt; @@L
</code></pre>

1) <code>@@L</code> can not be accesses from outside but is accessible from almost everywhere 
2) <code>class &lt;&lt; self ; private ; def</code> successfully makes the method <code>d</code> inaccessible from outside and from inside with <code>self.</code> but not without it -- this is weird 
3) <code>private ; self.</code> and <code>private ; class &lt;&lt; self</code> do not make methods private -- they are accessible both with and without <code>self.</code>

blocks|key|3141258|text|一种很好的方式是这样的|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3141259|module+MyModule
++class+<<+self
++++def+public_method
++++++#+you+may+call+the+private+method+here
++++++tmp+=+private_method
++++++:public
++++end

++++private+def+private_method
++++++:private
++++end
++end
end

#+calling+from+outside+the+module
puts+MyModule::public_method|code-block|syntax|javascript|3141260|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

A nice way is like this

<pre class="lang-rb prettyprint-override"><code>module MyModule
 class &lt;&lt; self
 def public_method
 # you may call the private method here
 tmp = private_method
 :public
 end

 private def private_method
 :private
 end
 end
end

# calling from outside the module
puts MyModule::public_method
</code></pre>

blocks|key|3354207|text|module+Writer
++class+<<+self
++++def+output(s)
++++++puts+upcase(s)
++++end

++++private

++++def+upcase(s)
++++++s.upcase
++++end
++end
end

Writer.output+"Hello+World"
#+->+HELLO+WORLD

Writer.upcase+"Hello+World"
#+->+so.rb:16:in+`<main>':+private+method+`upcase'+called+for+Writer:Module+(NoMethodError)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3354208|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>module Writer
 class &lt;&lt; self
 def output(s)
 puts upcase(s)
 end

 private

 def upcase(s)
 s.upcase
 end
 end
end

Writer.output "Hello World"
# -&gt; HELLO WORLD

Writer.upcase "Hello World"
# -&gt; so.rb:16:in `&lt;main&gt;': private method `upcase' called for Writer:Module (NoMethodError)
</code></pre>

blocks|key|3141288|text|创建私有模块或类|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3141289|常量永远不是私有的。但是，可以创建模块或类而不将其分配给常量。|3141290|因此，:private_class_method的另一种选择是创建一个私有模块或类，并在其上定义公共方法。|offset|length|style|CODE|3141291|module+PublicModule
++def+self.do_stuff(input)
++++@private_implementation.do_stuff(input)
++end

++@private_implementation+=+Module.new+do
++++def+self.do_stuff(input)
++++++input.upcase+#+or+call+other+methods+on+module
++++end
++end
end|code-block|syntax|javascript|3141292|用法：|3141293|PublicModule.do_stuff("whatever")+#+=>+"WHATEVER"|3141294|请参阅Module.new和Class.new的文档。|3141295|entityMap|0|LINK|mutability|MUTABLE|url|https://ruby-doc.org/core-2.2.0/Module.html#method-c-new|1|https://ruby-doc.org/core-2.2.0/Class.html#method-c-new^0|0|0|3|L|0|0|0|0|3|A|0|E|9|1|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|15|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|16|8|@$F|17|G|18|H|I]]|9|@]|A|$]]|$1|J|3|K|5|L|7|19|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Q|3|R|5|L|7|1B|8|@]|9|@]|A|$M|N]]|$1|S|3|T|5|6|7|1C|8|@]|9|@$F|1D|G|1E|1|1F]|$F|1G|G|1H|1|1I]]|A|$]]|$1|U|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|11]]|12|$5|X|Y|Z|A|$10|13]]]]

<h2>Make a private module or class</h2>

Constants are never private. However, it's possible to create a module or class without assigning it to a constant.

So an alternative to <code>:private_class_method</code> is to create a private module or class and define public methods on it.

<pre><code>module PublicModule
 def self.do_stuff(input)
 @private_implementation.do_stuff(input)
 end

 @private_implementation = Module.new do
 def self.do_stuff(input)
 input.upcase # or call other methods on module
 end
 end
end
</code></pre>

Usage:

<pre><code>PublicModule.do_stuff("whatever") # =&gt; "WHATEVER"
</code></pre>

See the docs for <a href="https://ruby-doc.org/core-2.2.0/Module.html#method-c-new" rel="nofollow noreferrer">Module.new</a> and <a href="https://ruby-doc.org/core-2.2.0/Class.html#method-c-new" rel="nofollow noreferrer">Class.new</a>.

blocks|key|359441|text|此方法不允许与私有方法共享数据，除非您通过方法参数显式传递数据。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|359442|module+Thing
++extend+self

++def+pub
++++puts+priv(123)
++end

++private
++
++def+priv(value)
++++puts+"Private+method+with+value+#{value}"
++end
end

Thing.pub
#+"Private+method+with+value+123"

Thing.priv
#+NoMethodError+(private+method+`priv'+called+for+Thing:Module)|code-block|syntax|javascript|359443|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This method won't allow sharing data with the private methods unless you explicitly pass the data by method parameters.
<pre class="lang-rb prettyprint-override"><code>module Thing
 extend self

 def pub
 puts priv(123)
 end

 private
 
 def priv(value)
 puts &quot;Private method with value #{value}&quot;
 end
end

Thing.pub
# &quot;Private method with value 123&quot;

Thing.priv
# NoMethodError (private method `priv' called for Thing:Module)
</code></pre>

blocks|key|354738|text|这里有一个解决方案，说明如何在单个模块中嵌套多个类，并能够通过使用extend在模块上调用可从任何嵌套类访问的私有方法|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|354739|module+SomeModule

++class+ClassThatDoesNotExtendTheModule
++++class+<<+self
++++++def+random_class_method
++++++++private_class_on_module
++++++end
++++end
++end

++class+ClassThatDoesExtendTheModule
++++extend+SomeModule
++
++++class+<<+self
++++++def+random_class_method
++++++++private_class_on_module
++++++end
++++end
++end

++class+AnotherClassThatDoesExtendTheModule
++++extend+SomeModule
++
++++class+<<+self
++++++def+random_class_method
++++++++private_class_on_module
++++++end
++++end
++end

++private

++def+private_class_on_module
++++puts+'some+private+class+was+called'
++end
++
end|code-block|syntax|javascript|354740|显示实际解决方案的一些输出：|354741|>+SomeModule::ClassThatDoesNotExtendTheModule.random_class_method

NameError:+undefined+local+variable+or+method+`private_class_on_module'+for+SomeModule::ClassThatDoesNotExtendTheModule:Class


>+SomeModule::ClassThatDoesExtendTheModule.random_class_method

some+private+class+was+called


>+SomeModule::ClassThatDoesExtendTheModule.private_class_on_module

NoMethodError:+private+method+`private_class_on_module'+called+for+SomeModule::ClassThatDoesExtendTheModule:Class


>+SomeModule::AnotherClassThatDoesExtendTheModule.random_class_method

some+private+class+was+called


>+SomeModule::AnotherClassThatDoesExtendTheModule.random_class_method

NoMethodError:+private+method+`private_class_on_module'+called+for+SomeModule::AnotherClassThatDoesExtendTheModule:Class|354742|entityMap^0|X|6|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

Here's a solution for how you can have multiple classes nested within a single module, with the ability to call a private method on the module that's accessible from any of the nested classes, by making use of <code>extend</code>:
<pre class="lang-ruby prettyprint-override"><code>module SomeModule

 class ClassThatDoesNotExtendTheModule
 class &lt;&lt; self
 def random_class_method
 private_class_on_module
 end
 end
 end

 class ClassThatDoesExtendTheModule
 extend SomeModule
 
 class &lt;&lt; self
 def random_class_method
 private_class_on_module
 end
 end
 end

 class AnotherClassThatDoesExtendTheModule
 extend SomeModule
 
 class &lt;&lt; self
 def random_class_method
 private_class_on_module
 end
 end
 end

 private

 def private_class_on_module
 puts 'some private class was called'
 end
 
end

</code></pre>
Some output to show the solution in action:
<pre class="lang-none prettyprint-override"><code>&gt; SomeModule::ClassThatDoesNotExtendTheModule.random_class_method

NameError: undefined local variable or method `private_class_on_module' for SomeModule::ClassThatDoesNotExtendTheModule:Class


&gt; SomeModule::ClassThatDoesExtendTheModule.random_class_method

some private class was called


&gt; SomeModule::ClassThatDoesExtendTheModule.private_class_on_module

NoMethodError: private method `private_class_on_module' called for SomeModule::ClassThatDoesExtendTheModule:Class


&gt; SomeModule::AnotherClassThatDoesExtendTheModule.random_class_method

some private class was called


&gt; SomeModule::AnotherClassThatDoesExtendTheModule.random_class_method

NoMethodError: private method `private_class_on_module' called for SomeModule::AnotherClassThatDoesExtendTheModule:Class
</code></pre>

I have a two part question

Best-Practice

<ul>
<li>I have an algorithm that performs some operation on a data structure using the public interface</li>
<li>It is currently a module with numerous static methods, all private except for the one public interface method.</li>
<li>There is one instance variable that needs to be shared among all the methods.</li>
</ul>

These are the options I can see, which is the best?:

<ul>
<li>Module with static ('module' in ruby) methods </li>
<li>Class with static methods</li>
<li>Mixin module for inclusion into the data structure</li>
<li>Refactor out the part of the algorithm that modifies that data structure (very small) and make that a mixin that calls the static methods of the algorithm module</li>
</ul>

Technical part

Is there any way to make a private Module method?

<pre><code>module Thing
 def self.pub; puts "Public method"; end
 private
 def self.priv; puts "Private method"; end
end
</code></pre>

The <code>private</code> in there doesn't seem to have any effect, I can still call <code>Thing.priv</code> without issue.

Private module methods in Ruby

数据结构

我有一个两部分的问题最佳实践我有一个使用公共接口对数据结构执行某些操作的算法它当前是一个包含许多静态方法的模块，除了一个公共接口方法之外，所有方法都是私有的。需要在所有方法之间共享一个实例变量。这些是我能看到的选项，哪一个是最好的？：带有静态(ruby中的‘Module’)方法的模块带有静态模块模块，用于将修改该数据结...

问Ruby中的私有模块方法
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Ruby中的私有模块方法EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Ruby中的私有模块方法
EN