blocks|key|1393144|text|对你的第二个和第三个问题是肯定的--这是你需要做的，因为你不能在一个赋值的左边有多个‘lvalue’。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1393145|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Yes to your second and third questions -- that's what you need to do as you cannot have multiple 'lvalues' on the left of an assignment.

blocks|key|1177684|text|通常我将输出包装成一个列表，这非常灵活(你可以在输出中使用数字，字符串，向量，矩阵，数组，列表，对象的任意组合)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1177685|就像这样：|1177686|func2<-function(input)+{
+++a<-input%2B1
+++b<-input%2B2
+++output<-list(a,b)
+++return(output)
}

output<-func2(5)

for+(i+in+output)+{
+++print(i)
}

[1]+6
[1]+7|code-block|syntax|javascript|1177687|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Usually I wrap the output into a list, which is very flexible (you can have any combination of numbers, strings, vectors, matrices, arrays, lists, objects int he output)

so like:

<pre><code>func2&lt;-function(input) {
 a&lt;-input+1
 b&lt;-input+2
 output&lt;-list(a,b)
 return(output)
}

output&lt;-func2(5)

for (i in output) {
 print(i)
}

[1] 6
[1] 7
</code></pre>

blocks|key|1177740|text|我在互联网上偶然发现了这个聪明的黑客。我不确定它是讨厌的还是漂亮的，但它允许你创建一个“神奇的”运算符，允许你将多个返回值解压到它们自己的变量中。:=函数is+defined+here，并包含在下面，供后代使用：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1177741|':='+<-+function(lhs,+rhs)+{
++frame+<-+parent.frame()
++lhs+<-+as.list(substitute(lhs))
++if+(length(lhs)+>+1)
++++lhs+<-+lhs[-1]
++if+(length(lhs)+==+1)+{
++++do.call(`=`,+list(lhs[[1]],+rhs),+envir=frame)
++++return(invisible(NULL))+
++}
++if+(is.function(rhs)+%7C%7C+is(rhs,+'formula'))
++++rhs+<-+list(rhs)
++if+(length(lhs)+>+length(rhs))
++++rhs+<-+c(rhs,+rep(list(NULL),+length(lhs)+-+length(rhs)))
++for+(i+in+1:length(lhs))
++++do.call(`=`,+list(lhs[[i]],+rhs[[i]]),+envir=frame)
++return(invisible(NULL))+
}|code-block|syntax|javascript|1177742|有了它，你就可以做你想做的事情了：|1177743|functionReturningTwoValues+<-+function()+{
++return(list(1,+matrix(0,+2,+2)))
}
c(a,+b)+:=+functionReturningTwoValues()
a
#[1]+1
b
#+++++[,1]+[,2]
#+[1,]++++0++++0
#+[2,]++++0++++0|1177744|我不知道我对此有什么感觉。也许您会发现它在您的交互式工作空间中很有帮助。使用它来构建(重用)可用库(用于大众消费)可能不是最好的主意，但我猜这取决于您。|1177745|..。你知道他们怎么说责任和权力的..。|1177746|entityMap|0|LINK|mutability|MUTABLE|url|http://code.google.com/p/miscell/source/browse/rvalues/rvalues.r^0|21|2|25|F|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@$9|13|A|14|1|15]]|E|$]]|$1|F|3|G|5|H|7|16|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|17|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|18|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|19|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1A|8|@]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1B|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z]]]]

I somehow stumbled on this clever hack on the internet ... I'm not sure if it's nasty or beautiful, but it lets you create a "magical" operator that allows you to unpack multiple return values into their own variable. The <code>:=</code> function <a href="http://code.google.com/p/miscell/source/browse/rvalues/rvalues.r" rel="noreferrer">is defined here</a>, and included below for posterity:

<pre><code>':=' &lt;- function(lhs, rhs) {
 frame &lt;- parent.frame()
 lhs &lt;- as.list(substitute(lhs))
 if (length(lhs) &gt; 1)
 lhs &lt;- lhs[-1]
 if (length(lhs) == 1) {
 do.call(`=`, list(lhs[[1]], rhs), envir=frame)
 return(invisible(NULL)) 
 }
 if (is.function(rhs) || is(rhs, 'formula'))
 rhs &lt;- list(rhs)
 if (length(lhs) &gt; length(rhs))
 rhs &lt;- c(rhs, rep(list(NULL), length(lhs) - length(rhs)))
 for (i in 1:length(lhs))
 do.call(`=`, list(lhs[[i]], rhs[[i]]), envir=frame)
 return(invisible(NULL)) 
}
</code></pre>

With that in hand, you can do what you're after:

<pre><code>functionReturningTwoValues &lt;- function() {
 return(list(1, matrix(0, 2, 2)))
}
c(a, b) := functionReturningTwoValues()
a
#[1] 1
b
# [,1] [,2]
# [1,] 0 0
# [2,] 0 0
</code></pre>

I don't know how I feel about that. Perhaps you might find it helpful in your interactive workspace. Using it to build (re-)usable libraries (for mass consumption) might not be the best idea, but I guess that's up to you.

... you know what they say about responsibility and power ...

blocks|key|1393266|text|列表对于这个目的来说似乎是完美的。例如，在函数中，您将拥有|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1393267|x+=+desired_return_value_1+#+(vector,+matrix,+etc)

y+=+desired_return_value_2+#+(vector,+matrix,+etc)

returnlist+=+list(x,y...)

}++#+end+of+function|code-block|syntax|javascript|1393268|主程序|1393269|x+=+returnlist[[1]]

y+=+returnlist[[2]]|1393270|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Lists seem perfect for this purpose. For example within the function you would have

<pre><code>x = desired_return_value_1 # (vector, matrix, etc)

y = desired_return_value_2 # (vector, matrix, etc)

returnlist = list(x,y...)

} # end of function
</code></pre>

<h1>main program</h1>

<pre><code>x = returnlist[[1]]

y = returnlist[[2]]
</code></pre>

blocks|key|1393319|text|使用assign怎么样？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1393320|functionReturningTwoValues+<-+function(a,+b)+{
++assign(a,+1,+pos=1)
++assign(b,+2,+pos=1)
}|code-block|syntax|javascript|1393321|您可以通过引用传递要传递的变量的名称。|1393322|>+functionReturningTwoValues('a',+'b')
>+a
[1]+1
>+b
[1]+2|1393323|如果您需要访问现有值，则与assign相反的是get。|offset|length|style|CODE|1393324|entityMap^0|0|0|0|0|D|6|N|3|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|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@$M|X|N|Y|O|P]|$M|Z|N|10|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

How about using assign?

<pre><code>functionReturningTwoValues &lt;- function(a, b) {
 assign(a, 1, pos=1)
 assign(b, 2, pos=1)
}
</code></pre>

You can pass the names of the variable you want to be passed by reference.

<pre><code>&gt; functionReturningTwoValues('a', 'b')
&gt; a
[1] 1
&gt; b
[1] 2
</code></pre>

If you need to access the existing values, the converse of <code>assign</code> is <code>get</code>.

blocks|key|1393336|text|functionReturningTwoValues+<-+function()+{+
++results+<-+list()
++results$first+<-+1
++results$second+<-2
++return(results)+
}
a+<-+functionReturningTwoValues()|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1393337|我想这行得通。|unstyled|1393338|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>functionReturningTwoValues &lt;- function() { 
 results &lt;- list()
 results$first &lt;- 1
 results$second &lt;-2
 return(results) 
}
a &lt;- functionReturningTwoValues()
</code></pre>

I think this works.

blocks|key|1393461|text|如果foo和bar都是一个数字，那么c(foo，bar)没有问题；您也可以将组件命名为:+c(Foo=foo，Bar=bar)。因此，您可以访问结果'res‘的组件，作为res1，res2；或者，在命名的情况下，作为res"Foo"，res"BAR“。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1393462|B如果foo和bar是相同类型和长度的向量，那么返回cbind(foo，bar)或rbind(foo，bar)也没什么问题；同样也是可命名的。在'cbind‘的情况下，你可以通过res,1，res,2或者res，"+foo+"，res，"+bar“来访问Foo和Bar。您可能还更喜欢返回数据帧而不是矩阵：|1393463|data.frame(Foo=foo,Bar=bar)|code-block|syntax|javascript|1393464|并通过res$Foo，res$Bar访问它们。如果foo和bar的长度相同，但类型不同(例如，foo是数字的向量，而不是字符串的向量)，这也可以很好地工作。|1393465|C如果foo和bar完全不同，不能像上面那样方便地组合，那么你肯定应该返回一个列表。|1393466|例如，您的函数可能拟合一个线性模型并计算预测值，因此您可以|1393467|LM<-lm(....)+;+foo<-summary(LM);+bar<-LM$fit|1393468|然后，您将以res$Foo形式访问摘要，以res$+return+list(Foo=foo,Bar=bar)形式访问预测值|offset|length|style|CODE|1393469|来源：http://r.789695.n4.nabble.com/How-to-return-multiple-values-in-a-function-td858528.html|1393470|entityMap|0|LINK|mutability|MUTABLE|url|http://r.789695.n4.nabble.com/How-to-return-multiple-values-in-a-function-td858528.html^0|0|0|0|0|0|0|0|Q|S|0|3|2F|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|17|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|18|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|19|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|1A|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1B|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|1C|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|1D|8|@$S|1E|T|1F|U|V]]|9|@]|A|$]]|$1|W|3|X|5|6|7|1G|8|@]|9|@$S|1H|T|1I|1|1J]]|A|$]]|$1|Y|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]]|Z|$10|$5|11|12|13|A|$14|15]]]]

[A] 
If each of foo and bar is a single number, then there's nothing wrong with c(foo,bar); and you can also name the components: c(Foo=foo,Bar=bar). So you could access the components of the result 'res' as res[1], res[2]; or, in the named case, as res["Foo"], res["BAR"]. 

[B] 
If foo and bar are vectors of the same type and length, then again there's nothing wrong with returning cbind(foo,bar) or rbind(foo,bar); likewise nameable. In the 'cbind' case, you would access foo and bar as res[,1], res[,2] or as res[,"Foo"], res[,"Bar"]. You might also prefer to return a dataframe rather than a matrix: 

<pre><code>data.frame(Foo=foo,Bar=bar)
</code></pre>

and access them as res$Foo, res$Bar. This would also work well if foo and bar were of the same length but not of the same type (e.g. foo is a vector of numbers, bar a vector of character strings). 

[C] 
If foo and bar are sufficiently different not to combine conveniently as above, then you shuld definitely return a list. 

For example, your function might fit a linear model and 
also calculate predicted values, so you could have 

<pre><code>LM&lt;-lm(....) ; foo&lt;-summary(LM); bar&lt;-LM$fit
</code></pre>

and then you would <code>return list(Foo=foo,Bar=bar)</code> and then access the summary as res$Foo, the predicted values as res$Bar

source: <a href="http://r.789695.n4.nabble.com/How-to-return-multiple-values-in-a-function-td858528.html" rel="nofollow">http://r.789695.n4.nabble.com/How-to-return-multiple-values-in-a-function-td858528.html</a>

blocks|key|1177979|text|如果要将函数的输出返回到全局环境，可以使用list2env，如下例所示：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1177980|myfun+<-+function(x)+{+a+<-+1:x
+++++++++++++++++++++++b+<-+5:x
+++++++++++++++++++++++df+<-+data.frame(a=a,+b=b)

+++++++++++++++++++++++newList+<-+list("my_obj1"+=+a,+"my_obj2"+=+b,+"myDF"=df)
+++++++++++++++++++++++list2env(newList+,.GlobalEnv)
+++++++++++++++++++++++}
++++myfun(3)|code-block|syntax|javascript|1177981|此函数将在您的全局环境中创建三个对象：|1177982|>+my_obj1
++[1]+1+2+3

>+my_obj2
++[1]+5+4+3

>+myDF
++++a+b
++1+1+5
++2+2+4
++3+3+3|1177983|entityMap^0|L|8|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|$]]

If you want to return the output of your function to the Global Environment, you can use <code>list2env</code>, like in this example:

<pre><code>myfun &lt;- function(x) { a &lt;- 1:x
 b &lt;- 5:x
 df &lt;- data.frame(a=a, b=b)

 newList &lt;- list("my_obj1" = a, "my_obj2" = b, "myDF"=df)
 list2env(newList ,.GlobalEnv)
 }
 myfun(3)
</code></pre>

This function will create three objects in your Global Environment:

<pre><code>&gt; my_obj1
 [1] 1 2 3

&gt; my_obj2
 [1] 5 4 3

&gt; myDF
 a b
 1 1 5
 2 2 4
 3 3 3
</code></pre>

blocks|key|1178041|text|要从函数中获得多个输出并将其保留为所需的格式，可以将输出从函数内部保存到硬盘(在工作目录中)，然后从函数外部加载它们：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1178042|myfun+<-+function(x)+{
++++++++++++++++++++++df1+<-+...
++++++++++++++++++++++df2+<-+...
++++++++++++++++++++++save(df1,+file+=+"myfile1")
++++++++++++++++++++++save(df2,+file+=+"myfile2")
}
load("myfile1")
load("myfile2")|code-block|syntax|javascript|1178043|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|$]]

To obtain multiple outputs from a function and keep them in the desired format you can save the outputs to your hard disk (in the working directory) from within the function and then load them from outside the function:

<pre><code>myfun &lt;- function(x) {
 df1 &lt;- ...
 df2 &lt;- ...
 save(df1, file = "myfile1")
 save(df2, file = "myfile2")
}
load("myfile1")
load("myfile2")
</code></pre>

blocks|key|1393646|text|我组装了一个R包zeallot来解决这个问题。zeallot包括一个多重赋值或解包赋值运算符%25<-%25。运算符的LHS是要赋值的任意数量的变量，使用对c()的调用构建。运算符的RHS是一个矢量、列表、数据框、日期对象或任何具有实现的destructure方法的自定义对象(请参阅?zeallot::destructure)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1393647|这里有几个基于原始帖子的例子。|1393648|library(zeallot)

functionReturningTwoValues+<-+function()+{+
++return(c(1,+2))+
}

c(a,+b)+%25<-%25+functionReturningTwoValues()
a++#+1
b++#+2

functionReturningListOfValues+<-+function()+{
++return(list(1,+2,+3))
}

c(d,+e,+f)+%25<-%25+functionReturningListOfValues()
d++#+1
e++#+2
f++#+3

functionReturningNestedList+<-+function()+{
++return(list(1,+list(2,+3)))
}

c(f,+c(g,+h))+%25<-%25+functionReturningNestedList()
f++#+1
g++#+2
h++#+3

functionReturningTooManyValues+<-+function()+{
++return(as.list(1:20))
}

c(i,+j,+...rest)+%25<-%25+functionReturningTooManyValues()
i+++++#+1
j+++++#+2
rest++#+list(3,+4,+5,+..)|code-block|syntax|javascript|1393649|有关更多信息和示例，请查看vignette包。|1393650|entityMap|0|LINK|mutability|MUTABLE|url|https://cran.r-project.org/package=zeallot|1|https://cran.r-project.org/web/packages/zeallot/vignettes/unpacking-assignment.html^0|1A|4|22|3|37|B|3U|L|8|7|0|0|0|0|D|8|1|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@$9|17|A|18|1|19]]|E|$]]|$1|F|3|G|5|6|7|1A|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1B|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1C|8|@]|D|@$9|1D|A|1E|1|1F]]|E|$]]|$1|O|3|-4|5|6|7|1G|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]|W|$5|R|S|T|E|$U|X]]]]

I put together an R package <a href="https://CRAN.R-project.org/package=zeallot" rel="noreferrer">zeallot</a> to tackle this problem. zeallot includes a multiple assignment or unpacking assignment operator, <code>%&lt;-%</code>. The LHS of the operator is any number of variables to assign, built using calls to <code>c()</code>. The RHS of the operator is a vector, list, data frame, date object, or any custom object with an implemented <code>destructure</code> method (see <code>?zeallot::destructure</code>).

Here are a handful of examples based on the original post,

<pre><code>library(zeallot)

functionReturningTwoValues &lt;- function() { 
 return(c(1, 2)) 
}

c(a, b) %&lt;-% functionReturningTwoValues()
a # 1
b # 2

functionReturningListOfValues &lt;- function() {
 return(list(1, 2, 3))
}

c(d, e, f) %&lt;-% functionReturningListOfValues()
d # 1
e # 2
f # 3

functionReturningNestedList &lt;- function() {
 return(list(1, list(2, 3)))
}

c(f, c(g, h)) %&lt;-% functionReturningNestedList()
f # 1
g # 2
h # 3

functionReturningTooManyValues &lt;- function() {
 return(as.list(1:20))
}

c(i, j, ...rest) %&lt;-% functionReturningTooManyValues()
i # 1
j # 2
rest # list(3, 4, 5, ..)
</code></pre>

Check out the package <a href="https://cran.r-project.org/web/packages/zeallot/vignettes/unpacking-assignment.html" rel="noreferrer">vignette</a> for more information and examples.

blocks|key|1393695|text|使用R+3.6.1，我可以执行以下操作|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1393696|fr2v+<-+function()+{+c(5,3)+}
a_b+<-+fr2v()
(a_b[[1]])+#+prints+"5"
(a_b[[2]])+#+prints+"3"|code-block|syntax|javascript|1393697|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|$]]

With R 3.6.1, I can do the following

<pre><code>fr2v &lt;- function() { c(5,3) }
a_b &lt;- fr2v()
(a_b[[1]]) # prints "5"
(a_b[[2]]) # prints "3"
</code></pre>

blocks|key|1393782|text|2021年，这是我经常使用的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1393783|tidyverse包有一个名为lst的函数，该函数在创建列表时为列表元素分配名称。Post，我使用list2env()来赋值变量或直接使用列表|offset|length|style|CODE|1393784|library(tidyverse)
fun+<-+function(){
++a<-1
++b<-2
++lst(a,b)
}
list2env(fun(),+envir=.GlobalEnv)#unpacks+list+key-values+to+variable-values+into+the+current+environment|code-block|syntax|javascript|1393785|entityMap^0|0|0|9|F|3|1D|A|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]|$D|S|E|T|F|G]|$D|U|E|V|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|W|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|N|$]]

Year 2021 and this is something I frequently use.
<code>tidyverse</code> package has a function called <code>lst</code> that assigns name to the list elements when creating the list.
Post which I use <code>list2env()</code> to assign variable or use the list directly
<pre><code>library(tidyverse)
fun &lt;- function(){
 a&lt;-1
 b&lt;-2
 lst(a,b)
}
list2env(fun(), envir=.GlobalEnv)#unpacks list key-values to variable-values into the current environment
</code></pre>

Still trying to get into the R logic... what is the "best" way to unpack (on LHS) the results from a function returning multiple values?

I can't do this apparently:

<pre><code>R&gt; functionReturningTwoValues &lt;- function() { return(c(1, 2)) }
R&gt; functionReturningTwoValues()
[1] 1 2
R&gt; a, b &lt;- functionReturningTwoValues()
Error: unexpected ',' in "a,"
R&gt; c(a, b) &lt;- functionReturningTwoValues()
Error in c(a, b) &lt;- functionReturningTwoValues() : object 'a' not found
</code></pre>

must I really do the following?

<pre><code>R&gt; r &lt;- functionReturningTwoValues()
R&gt; a &lt;- r[1]; b &lt;- r[2]
</code></pre>

or would the R programmer write something more like this:

<pre><code>R&gt; functionReturningTwoValues &lt;- function() {return(list(first=1, second=2))}
R&gt; r &lt;- functionReturningTwoValues()
R&gt; r$first
[1] 1
R&gt; r$second
[1] 2
</code></pre>

--- edited to answer Shane's questions ---

I don't really need giving names to the result value parts. I am applying one aggregate function to the first component and an other to the second component (<code>min</code> and <code>max</code>. if it was the same function for both components I would not need splitting them).

How to assign from a function which returns more than one value?

仍在尝试进入R逻辑...解包(在LHS上)返回多个值的函数的结果的“最佳”方法是什么？显然我不能这么做：R> functionReturningTwoValues <- function() { return(c(1, 2)) }R> functionReturningTwoValues()[1] 1 2R> a, b...

问如何从一个返回多个值的函数赋值？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何从一个返回多个值的函数赋值？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何从一个返回多个值的函数赋值？
EN