blocks|key|66525|text|使用tap，就像博主所做的那样，只是一种方便的方法。在您的示例中，这可能有些过头了，但如果您想与用户一起做一大堆事情，tap可以提供一个看起来更整洁的界面。因此，在下面的示例中可能更好：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|66526|user+=+User.new.tap+do+%7Cu%7C
++u.build_profile
++u.process_credit_card
++u.ship_out_item
++u.send_email_confirmation
++u.blahblahyougetmypoint
end|code-block|syntax|javascript|66527|使用上面的方法可以很容易地看到，所有这些方法都分组在一起，因为它们都引用相同的对象(本例中的用户)。另一种方法是：|66528|user+=+User.new
user.build_profile
user.process_credit_card
user.ship_out_item
user.send_email_confirmation
user.blahblahyougetmypoint|66529|再一次，这是有争议的--但是第二个版本看起来有点混乱，并且需要更多的人工解析才能看到所有的方法都是在同一个对象上调用的。|66530|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Using tap, as the blogger did, is simply a convenience method. It may have been overkill in your example, but in cases where you'd want to do a bunch of things with the user, tap can arguably provide a cleaner looking interface. So, perhaps it may be better in an example as follows:

<pre><code>user = User.new.tap do |u|
 u.build_profile
 u.process_credit_card
 u.ship_out_item
 u.send_email_confirmation
 u.blahblahyougetmypoint
end
</code></pre>

Using the above makes it easy to quickly see that all those methods are grouped together in that they all refer to the same object (the user in this example). The alternative would be:

<pre><code>user = User.new
user.build_profile
user.process_credit_card
user.ship_out_item
user.send_email_confirmation
user.blahblahyougetmypoint
</code></pre>

Again, this is debatable - but the case can be made that the second version looks a little messier, and takes a little more human parsing to see that all the methods are being called on the same object.

blocks|key|282948|text|当读者遇到以下情况：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|282949|user+=+User.new
user.username+=+"foobar"
user.save!|code-block|syntax|javascript|282950|他们必须遵循所有这三行，然后识别出它只是创建了一个名为user的实例。|offset|length|style|CODE|282951|如果是的话：|282952|user+=+User.new.tap+do+%7Cu%7C
++u.username+=+"foobar"
++u.save!
end|282953|那么这一点就会立刻变得清晰起来。读取器不必读取块中的内容即可知道实例user已创建。|282954|entityMap^0|0|0|R|4|0|0|0|Y|4|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@$I|X|J|Y|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|10|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|11|8|@$I|12|J|13|K|L]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|T|$]]

When readers encounter:

<pre><code>user = User.new
user.username = "foobar"
user.save!
</code></pre>

they would have to follow all the three lines and then recognize that it is just creating an instance named <code>user</code>.

If it were:

<pre><code>user = User.new.tap do |u|
 u.username = "foobar"
 u.save!
end
</code></pre>

then that would be immediately clear. A reader would not have to read what is inside the block to know that an instance <code>user</code> is created.

blocks|key|66632|text|您是对的:在您的示例中使用tap是毫无意义的，而且可能没有您的替代方案那么干净。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|66633|正如Rebitzele所指出的，tap只是一种方便的方法，通常用于创建对当前对象的较短引用。|66634|tap的一个很好的用例是用于调试:您可以修改对象，打印当前状态，然后继续修改同一块中的对象。请看这里的示例：http://moonbase.rydia.net/mental/blog/programming/eavesdropping-on-expressions。|66635|我有时喜欢在方法中使用tap来有条件地提前返回，而在其他情况下返回当前对象。|66636|entityMap|0|LINK|mutability|MUTABLE|url|http://moonbase.rydia.net/mental/blog/programming/eavesdropping-on-expressions^0|D|3|0|G|3|0|0|3|1I|26|0|0|B|3|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@$9|12|A|13|1|14]]|E|$]]|$1|J|3|K|5|6|7|15|8|@$9|16|A|17|B|C]]|D|@]|E|$]]|$1|L|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|M|$N|$5|O|P|Q|E|$R|S]]]]

You're right: the use of <code>tap</code> in your example is kind of pointless and probably less clean than your alternatives.

As Rebitzele notes, <code>tap</code> is just a convenience method, often used to create a shorter reference to the current object.

One good use case for <code>tap</code> is for debugging: you can modify the object, print the current state, then continue modifying the object in the same block. See here for example: <a href="http://moonbase.rydia.net/mental/blog/programming/eavesdropping-on-expressions" rel="nofollow">http://moonbase.rydia.net/mental/blog/programming/eavesdropping-on-expressions</a>.

I occasionally like to use <code>tap</code> inside methods to conditionally return early while returning the current object otherwise.

blocks|key|283049|text|使用tap的另一种情况是在返回对象之前对其进行操作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|283050|因此，不是这样：|283051|def+some_method
++...
++some_object.serialize
++some_object
end|code-block|syntax|javascript|283052|我们可以省去额外的一行：|283053|def+some_method
++...
++some_object.tap{+%7Co%7C+o.serialize+}
end|283054|在某些情况下，该技术可以节省多行代码，并使代码更加紧凑。|283055|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Another case to use tap is to make manipulation on object before returning it.

So instead of this:

<pre><code>def some_method
 ...
 some_object.serialize
 some_object
end
</code></pre>

we can save extra line:

<pre><code>def some_method
 ...
 some_object.tap{ |o| o.serialize }
end
</code></pre>

In some situation this technique can save more then one line and make code more compact.

blocks|key|283144|text|我要说的是，使用tap没有任何优势。正如@sawa+points+out所说，唯一的潜在好处是：“读者不必阅读代码块中的内容即可知道实例用户已创建。”然而，在这一点上，可以认为如果您正在进行非简单化的记录创建逻辑，那么通过将该逻辑提取到它自己的方法中将更好地传达您的意图。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|283145|我坚持认为，tap对代码的可读性来说是一个不必要的负担，可以不使用，也可以用更好的技术替代，比如Extract+Method。|283146|虽然tap是一种方便的方法，但它也是个人喜好。试一试tap。然后在不使用tap的情况下编写一些代码，看看您是否喜欢其中一种方式。|283147|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/17493604/373522|1|http://refactoring.com/catalog/extractMethod.html^0|8|3|K|G|0|0|6|3|1C|E|1|0|2|3|Q|3|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@$9|W|A|X|1|Y]]|E|$]]|$1|F|3|G|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@$9|12|A|13|1|14]]|E|$]]|$1|H|3|I|5|6|7|15|8|@$9|16|A|17|B|C]|$9|18|A|19|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]]|K|$L|$5|M|N|O|E|$P|Q]]|R|$5|M|N|O|E|$P|S]]]]

I would say that there is no advantage to using <code>tap</code>. The only potential benefit, as <a href="https://stackoverflow.com/a/17493604/373522">@sawa points out</a> is, and I quote: "A reader would not have to read what is inside the block to know that an instance user is created." However, at that point the argument can be made that if you're doing non-simplistic record creation logic, your intent would be better communicated by extracting that logic into its own method.

I hold to the opinion that <code>tap</code> is an unnecessary burden on the readability of the code, and could be done without, or substituted with a better technique, like <a href="http://refactoring.com/catalog/extractMethod.html" rel="nofollow noreferrer">Extract Method</a>.

While <code>tap</code> is a convenience method, it's also personal preference. Give <code>tap</code> a try. Then write some code without using tap, see if you like one way over another.

blocks|key|283180|text|@sawa答案的一个变体：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|283181|如前所述，使用tap有助于了解代码的意图(但不一定使代码更紧凑)。|offset|length|style|CODE|283182|下面两个函数的长度相等，但在第一个函数中，您必须通读末尾才能弄清楚为什么我在开始时初始化了一个空的Hash。|283183|def+tapping1
++#+setting+up+a+hash
++h+=+{}
++#+working+on+it
++h[:one]+=+1
++h[:two]+=+2
++#+returning+the+hash
++h
end|code-block|syntax|javascript|283184|另一方面，在这里，您从一开始就知道被初始化的散列将是块的输出(在本例中是函数的返回值)。|283185|def+tapping2
++#+a+hash+will+be+returned+at+the+end+of+this+block;
++#+all+work+will+occur+inside
++Hash.new.tap+do+%7Ch%7C
++++h[:one]+=+1
++++h[:two]+=+2
++end
end|283186|entityMap^0|0|7|3|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@$D|W|E|X|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|Y|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|Z|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|L|7|11|8|@]|9|@]|A|$M|N]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

A variation on @sawa's answer:

As already noted, using <code>tap</code> helps figuring out the intent of your code (while not necessarily making it more compact).

The following two functions are equally long, but in the first one you have to read through the end to figure out why I initialized an empty Hash at the beginning.

<pre><code>def tapping1
 # setting up a hash
 h = {}
 # working on it
 h[:one] = 1
 h[:two] = 2
 # returning the hash
 h
end
</code></pre>

Here, on the other hand, you know right from the start that the hash being initialized will be the block's output (and, in this case, the function's return value).

<pre><code>def tapping2
 # a hash will be returned at the end of this block;
 # all work will occur inside
 Hash.new.tap do |h|
 h[:one] = 1
 h[:two] = 2
 end
end
</code></pre>

blocks|key|283226|text|它是调用链的帮助器。它将其对象传递到给定块中，并在块完成后返回该对象：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|283227|an_object.tap+do+%7Co%7C
++#+do+stuff+with+an_object,+which+is+in+o+#
end++===>+an_object|code-block|syntax|javascript|283228|这样做的好处是，tap总是返回被调用的对象，即使块返回了其他结果。因此，您可以在不中断流程的情况下将tap块插入到现有方法管道的中间。|283229|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

It’s a helper for call chaining. It passes its object into the given block and, after the block finishes, returns the object:

<pre><code>an_object.tap do |o|
 # do stuff with an_object, which is in o #
end ===&gt; an_object
</code></pre>

The benefit is that tap always returns the object it’s called on, even if the block returns some other result. Thus you can insert a tap block into the middle of an existing method pipeline without breaking the flow.

blocks|key|283246|text|在rails中，我们可以使用tap显式地将参数列入白名单：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|283247|def+client_params
++++params.require(:client).permit(:name).tap+do+%7Cwhitelist%7C
++++++++whitelist[:name]+=+params[:client][:name]
++++end
end|code-block|syntax|javascript|283248|entityMap^0|E|3|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

In rails we can use <code>tap</code> to whitelist parameters explicitly:

<pre><code>def client_params
 params.require(:client).permit(:name).tap do |whitelist|
 whitelist[:name] = params[:client][:name]
 end
end
</code></pre>

blocks|key|283266|text|如果您希望在设置用户名后返回用户，则需要执行以下操作|type|unstyled|depth|inlineStyleRanges|entityRanges|data|283267|user+=+User.new
user.username+=+'foobar'
user|code-block|syntax|javascript|283268|使用tap，您可以省去这种尴尬的返回|offset|length|style|CODE|283269|User.new.tap+do+%7Cuser%7C
++user.username+=+'foobar'
end|283270|entityMap^0|0|0|2|3|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

If you wanted to return the user after setting the username you'd need to do

<pre><code>user = User.new
user.username = 'foobar'
user
</code></pre>

With <code>tap</code> you could save that awkward return

<pre><code>User.new.tap do |user|
 user.username = 'foobar'
end
</code></pre>

blocks|key|283306|text|我将举另一个我用过的例子。我有一个方法user_params，它为用户返回保存所需的参数(这是一个Rails项目)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|283307|def+user_params
++params.require(:user).permit(
++++:first_name,
++++:last_name,
++++:email,
++++:address_attributes
++)
end|code-block|syntax|javascript|283308|你可以看到我没有返回任何东西，除了ruby返回最后一行的输出。|283309|然后，过了一段时间，我需要有条件地添加一个新属性。因此，我将其更改为如下所示：|283310|def+user_params+
++u_params+=+params.require(:user).permit(
++++:first_name,+
++++:last_name,+
++++:email,
++++:address_attributes
++)
++u_params[:time_zone]+=+address_timezone+if+u_params[:address_attributes]
++u_params
end|283311|在这里，我们可以使用tap删除局部变量并删除返回值：|283312|def+user_params+
++params.require(:user).permit(
++++:first_name,+
++++:last_name,+
++++:email,
++++:address_attributes
++).tap+do+%7Cu_params%7C
++++u_params[:time_zone]+=+address_timezone+if+u_params[:address_attributes]
++end
end|283313|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|W|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

I will give another example which I have used. I have a method user_params which returns the params needed to save for the user (this is a Rails project)

<pre><code>def user_params
 params.require(:user).permit(
 :first_name,
 :last_name,
 :email,
 :address_attributes
 )
end
</code></pre>

You can see I dont return anything but ruby return the output of the last line. 

Then, after sometime, I needed to add a new attribute conditionally. So, I changed it to something like this:

<pre><code>def user_params 
 u_params = params.require(:user).permit(
 :first_name, 
 :last_name, 
 :email,
 :address_attributes
 )
 u_params[:time_zone] = address_timezone if u_params[:address_attributes]
 u_params
end
</code></pre>

Here we can use tap to remove the local variable and remove the return:

<pre><code>def user_params 
 params.require(:user).permit(
 :first_name, 
 :last_name, 
 :email,
 :address_attributes
 ).tap do |u_params|
 u_params[:time_zone] = address_timezone if u_params[:address_attributes]
 end
end
</code></pre>

blocks|key|66985|text|有一个名为flog的工具可以测量读取方法的难度。得分越高，代码所处的痛苦就越大。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|66986|def+with_tap
++user+=+User.new.tap+do+%7Cu%7C
++++u.username+=+"foobar"
++++u.save!
++end
end

def+without_tap
++user+=+User.new
++user.username+=+"foobar"
++user.save!
end

def+using_create
++user+=+User.create!+username:+"foobar"
end|code-block|syntax|javascript|66987|根据flog的结果，使用tap的方法是最难理解的(我同意这一点)。|style|CODE|66988|+4.5:+main#with_tap++++++++++++++++++++temp.rb:1-4
+2.4:+++assignment
+1.3:+++save!
+1.3:+++new
+1.1:+++branch
+1.1:+++tap

+3.1:+main#without_tap+++++++++++++++++temp.rb:8-11
+2.2:+++assignment
+1.1:+++new
+1.1:+++save!

+1.6:+main#using_create++++++++++++++++temp.rb:14-16
+1.1:+++assignment
+1.1:+++create!|66989|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/seattlerb/flog^0|5|4|0|0|0|C|3|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|11|8|@$A|12|B|13|K|L]]|9|@]|C|$]]|$1|M|3|N|5|F|7|14|8|@]|9|@]|C|$G|H]]|$1|O|3|-4|5|6|7|15|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]]]

There is a tool called <a href="https://github.com/seattlerb/flog" rel="nofollow noreferrer">flog</a> that measures how difficult it is to read a method. "The higher the score, the more pain the code is in."

<pre><code>def with_tap
 user = User.new.tap do |u|
 u.username = "foobar"
 u.save!
 end
end

def without_tap
 user = User.new
 user.username = "foobar"
 user.save!
end

def using_create
 user = User.create! username: "foobar"
end
</code></pre>

and according on flog's result the method with <code>tap</code> is the most difficult to read (and I agree with it)

<pre><code> 4.5: main#with_tap temp.rb:1-4
 2.4: assignment
 1.3: save!
 1.3: new
 1.1: branch
 1.1: tap

 3.1: main#without_tap temp.rb:8-11
 2.2: assignment
 1.1: new
 1.1: save!

 1.6: main#using_create temp.rb:14-16
 1.1: assignment
 1.1: create!
</code></pre>

blocks|key|283378|text|在函数式编程模式正在成为最佳实践(https://maryrosecook.com/blog/post/a-practical-introduction-to-functional-programming)的世界中，您可以将tap看作是单个值上的map，实际上，它可以修改转换链上的数据。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|283379|transformed_array+=+array.map(&:first_transformation).map(&:second_transformation)

transformed_value+=+item.tap(&:first_transformation).tap(&:second_transformation)|code-block|syntax|javascript|283380|这里不需要多次声明item。|283381|entityMap|0|LINK|mutability|MUTABLE|url|https://maryrosecook.com/blog/post/a-practical-introduction-to-functional-programming^0|34|3|3F|3|H|2D|0|0|0|9|4|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@$9|Z|A|10|1|11]]|E|$]]|$1|F|3|G|5|H|7|12|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|13|8|@$9|14|A|15|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

In the world where functional programming pattern is becoming a best practice (<a href="https://maryrosecook.com/blog/post/a-practical-introduction-to-functional-programming" rel="nofollow noreferrer">https://maryrosecook.com/blog/post/a-practical-introduction-to-functional-programming</a>), you can see <code>tap</code>, as a <code>map</code> on a single value, indeed, to modify your data on a transformation chain.

<pre><code>transformed_array = array.map(&amp;:first_transformation).map(&amp;:second_transformation)

transformed_value = item.tap(&amp;:first_transformation).tap(&amp;:second_transformation)
</code></pre>

No need to declare <code>item</code> multiple times here.

blocks|key|283392|text|除了上面的答案之外，我还在编写RSpecs时在存根和模仿中使用了tap。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|283393|场景:当我有一个复杂的查询要使用多个参数来存根和模拟时，这是不应该错过的。这里的替代方案是使用receive_message_chain+(但它缺乏细节)。|offset|length|style|CODE|283394|#+Query
Product
++.joins(:bill)
++.where("products.availability+=+?",+1)
++.where("bills.status+=+?",+"paid")
++.select("products.id",+"bills.amount")
++.first|code-block|syntax|javascript|283395|#+RSpecs

product_double+=+double('product')

expect(Product).to+receive(:joins).with(:bill).and_return(product_double.tap+do+%7Cproduct_scope%7C
++expect(product_scope).to+receive(:where).with("products.availability+=+?",+1).and_return(product_scope)
++expect(product_scope).to+receive(:where).with("bills.status+=+?",+"paid").and_return(product_scope)
++expect(product_scope).to+receive(:select).with("products.id",+"bills.amount").and_return(product_scope)
++expect(product_scope).to+receive(:first).and_return({+id:+1,+amount:+100+})
end)

#+Alternative+way+by+using+`receive_message_chain`
expect(Product).to+receive_message_chain(:joins,+:where,+:where,+:select).and_return({+id:+1,+amount:+100+})|283396|entityMap^0|0|1B|L|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@$D|S|E|T|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|U|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|J|7|V|8|@]|9|@]|A|$K|L]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Apart from the above answers, I have used tap in stubbing and mocking while writing RSpecs.
Scenario: When I have a complex query to stub and mock with multiple arguments which shouldn't go missed. The alternative here is to use <code>receive_message_chain</code> (but it lacks the details).
<pre><code># Query
Product
 .joins(:bill)
 .where(&quot;products.availability = ?&quot;, 1)
 .where(&quot;bills.status = ?&quot;, &quot;paid&quot;)
 .select(&quot;products.id&quot;, &quot;bills.amount&quot;)
 .first
</code></pre>
<pre><code># RSpecs

product_double = double('product')

expect(Product).to receive(:joins).with(:bill).and_return(product_double.tap do |product_scope|
 expect(product_scope).to receive(:where).with(&quot;products.availability = ?&quot;, 1).and_return(product_scope)
 expect(product_scope).to receive(:where).with(&quot;bills.status = ?&quot;, &quot;paid&quot;).and_return(product_scope)
 expect(product_scope).to receive(:select).with(&quot;products.id&quot;, &quot;bills.amount&quot;).and_return(product_scope)
 expect(product_scope).to receive(:first).and_return({ id: 1, amount: 100 })
end)

# Alternative way by using `receive_message_chain`
expect(Product).to receive_message_chain(:joins, :where, :where, :select).and_return({ id: 1, amount: 100 })
</code></pre>

I was just reading a blog article and noticed that the author used <code>tap</code> in a snippet something like: 

<pre><code>user = User.new.tap do |u|
 u.username = "foobar"
 u.save!
end
</code></pre>

My question is what exactly is the benefit or advantage of using <code>tap</code>? Couldn't I just do: 

<pre><code>user = User.new
user.username = "foobar"
user.save!
</code></pre>

or better yet:

<pre><code>user = User.create! username: "foobar"
</code></pre>

advantage of tap method in ruby

我刚刚读了一篇博客文章，注意到作者在一段代码片段中使用了tap，如下所示：user = User.new.tap do |u|  u.username = "foobar"  u.save!end我的问题是，使用tap到底有什么好处？我就不能这样做：user = User.newuser.username = "foo...

问tap法在红宝石中的优势
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问tap法在红宝石中的优势EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问tap法在红宝石中的优势
EN