blocks|key|4962569|text|不太确定你在问什么，但是...|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4962570|您可以为数组提供索引。|4962571|for+(int+i+=+0;+i+<+z.Length;+i%2B%2B)
{
++Math.Log(z[i]);
}|code-block|syntax|javascript|4962572|虽然我认为不保留计算的价值是没有意义的？|4962573|编辑|offset|length|style|BOLD|4962574|您可能必须使用double数据类型，因为这是math.log返回的数据类型|4962575|++++++++static+void+Process()
++++++++{
++++++++++++double[]+test+=+{+1,+2,+3,+4+};
++++++++++++double[]+answer+=+new+double[test.Length];
++++++++++++for+(int+i+=+0;+i+<+test.Length;+i%2B%2B)
++++++++++++{
++++++++++++++++answer[i]+=+Math.Log(test[i]);
++++++++++++}

++++++++}|4962576|entityMap^0|0|0|0|0|0|2|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|10|8|@$M|11|N|12|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

Not quite sure what you're asking, but...

You could provide an index into the array.

<pre><code>
for (int i = 0; i &lt; z.Length; i++)
{
 Math.Log(z[i]);
}
</code></pre>

Though I see no point in not retaining the value of the calculation?

Edit

You might have to use the double data type as that is what math.log returns

<pre><code>
 static void Process()
 {
 double[] test = { 1, 2, 3, 4 };
 double[] answer = new double[test.Length];
 for (int i = 0; i &lt; test.Length; i++)
 {
 answer[i] = Math.Log(test[i]);
 }

 }
</code></pre>

blocks|key|4962592|text|您可以将丑陋封装到一个函数中：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4962593|private+static+double[]+getLogForIntArray(int[]+z)
{
++++double[]+q+=+(double[])z.Select(p+=>+Math.Log(p)).ToArray();
++++return+q;
}|code-block|syntax|javascript|4962594|并将其调用为语法3(并将其返回为某个值)：|4962595|double[]+q+=+getLogForIntArray(z);+//+Syntax+3|4962596|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|$]]

You could encase the ugliness into a function:

<pre><code>private static double[] getLogForIntArray(int[] z)
{
 double[] q = (double[])z.Select(p =&gt; Math.Log(p)).ToArray();
 return q;
}
</code></pre>

and call it for syntax 3 (and return it into something):

<pre><code>double[] q = getLogForIntArray(z); // Syntax 3
</code></pre>

blocks|key|1177539|text|不，没有更干净的方法。语法2使用Select()和一个λ表达式将Math.Log()应用到每个元素，这是在C#中实现这一点的惯用方法。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|CODE|entityRanges|data|1177540|entityMap^0|B|3|G|8|W|A|0^^$0|@$1|2|3|4|5|6|7|I|8|@$9|J|A|K|B|C]|$9|L|A|M|B|D]|$9|N|A|O|B|D]]|E|@]|F|$]]|$1|G|3|-4|5|6|7|P|8|@]|E|@]|F|$]]]|H|$]]

No, there is not a cleaner way. The Syntax 2 use of <code>Select()</code> and a lambda expression to apply <code>Math.Log()</code> to each element is the idiomatic way of of doing this in C#.

blocks|key|3493462|text|int[]+z+=+new+[]+{1,2,3,4};
double[]+result+=+Array.ConvertAll(z,+p+=>+Log(p));|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3493463|或|unstyled|3493464|double+Log(int+i)+{+return+Math.Log(i);+}

int[]+z+=+new[]+{+1,+2,+3,+4+};
double[]+result+=+Array.ConvertAll(z,+Log);|3493465|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>int[] z = new [] {1,2,3,4};
double[] result = Array.ConvertAll(z, p =&gt; Log(p));
</code></pre>

or

<pre><code>double Log(int i) { return Math.Log(i); }

int[] z = new[] { 1, 2, 3, 4 };
double[] result = Array.ConvertAll(z, Log);
</code></pre>

blocks|key|1177557|text|在我看来，这是最干净的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1177558|double[]+x+=+Array.ConvertAll(z,+p+=>+Math.Log(p));|code-block|syntax|javascript|1177559|它应该是一个比select更好的解决方案，因为ConvertAll预先知道返回的数组中有多少元素。我不确定select是不是真的这样，如果有其他更复杂的魔法发生的话。然而，上面的代码更清晰，因为转换的意图更清晰。|1177560|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|$]]

This looks the cleanest solution to me:-

<pre><code>double[] x = Array.ConvertAll(z, p =&gt; Math.Log(p));
</code></pre>

It ought to be a better solution than select since ConvertAll knows up front how many elements there will be in the returned array. I'm not sure thats true of select, it could be if there some other compilier magic going on. However the above is cleaner because the convert intent is more clear.

blocks|key|1177571|text|为了完整性，还应该注意到Linq最大的优点之一是扩展它的能力。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1177572|如果这个操作是您经常做的事情，那么很可能会使用日志函数来扩展您的IEnumerable，这将是非常简单的|1177573|++static+class+LogExtension
++{
++++public+static+IEnumerable<Double>+Log(this+IEnumerable<int>+list)
++++{
++++++foreach+(int+i+in+list)
++++++{
++++++++yield+return+Math.Log(i);
++++++}
++++}
++}|code-block|syntax|javascript|1177574|然后简单地叫它像这样..。|1177575|IEnumerable<Double>+logValues+=+myInts.AsEnumerable().Log();|1177576|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

For completeness, It should also be noted that one of the biggest stregths of Linq is the ability to extend it.

If this operation is something that you do a lot, it may well be a candidate to extend your IEnumerable with a Log function, this would be very simple

<pre><code> static class LogExtension
 {
 public static IEnumerable&lt;Double&gt; Log(this IEnumerable&lt;int&gt; list)
 {
 foreach (int i in list)
 {
 yield return Math.Log(i);
 }
 }
 }
</code></pre>

Then simply call it like...

<pre><code>IEnumerable&lt;Double&gt; logValues = myInts.AsEnumerable().Log();
</code></pre>

blocks|key|4962690|text|在此代码中：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4962691|int[]+z+=+new+[]+{1,2,3,4};
double[]+result+=+z.Select(p+=>+Log(p)).ToArray();|code-block|syntax|javascript|4962692|当问题标题为“是否有更清晰的语法用于将操作应用于sequence的每个元素？”时，您看到的大多数(如果不是全部)+"cruft“是由于使用了数组。|offset|length|style|BOLD|4962693|在.NET+3.0中，“序列”是用IEnumerable<>接口封装的。|CODE|4962694|使用它，你会得到更整洁的代码：|4962695|IEnumerable<int>+z+=+new[]+{1,+2,+3,+4};
IEnumerable<double>+result+=+z.Select(i+=>+Math.Log(i));|4962696|再加上通过变量关键字使用隐式类型，事情就变得非常清楚了：|4962697|var+z+=+new[]+{1,+2,+3,+4};
var+result+=+z.Select(i+=>+Math.Log(i));|4962698|通常，当您使用List<>而不是数组时，您会发现Linq3.0的新特性(尤其是C#+)发挥得最好。|4962699|如果您的代码已经是基于数组的，我建议向接受IEnumerable而不是int[]的应用程序接口添加重载，从而允许使用代码使用现代语言功能。|4962700|entityMap^0|0|0|O|8|0|H|D|0|0|0|5|2|0|0|0|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|@$I|16|J|17|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|18|8|@$I|19|J|1A|K|O]]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1B|8|@]|9|@]|A|$]]|$1|R|3|S|5|D|7|1C|8|@]|9|@]|A|$E|F]]|$1|T|3|U|5|6|7|1D|8|@$I|1E|J|1F|K|L]]|9|@]|A|$]]|$1|V|3|W|5|D|7|1G|8|@]|9|@]|A|$E|F]]|$1|X|3|Y|5|6|7|1H|8|@]|9|@]|A|$]]|$1|Z|3|10|5|6|7|1I|8|@]|9|@]|A|$]]|$1|11|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]]|12|$]]

In this code:

<pre><code>int[] z = new [] {1,2,3,4};
double[] result = z.Select(p =&gt; Log(p)).ToArray();
</code></pre>

Most, if not all, of the "cruft" you see is due to the use of arrays, when the question title reads "Is there a cleaner syntax for applying an operation to each element of a sequence?"

In .NET 3.0, a "sequence" is encapsulated with the <code>IEnumerable&lt;&gt;</code> interface.

Using this, you end up with much cleaner code:

<pre><code>IEnumerable&lt;int&gt; z = new[] {1, 2, 3, 4};
IEnumerable&lt;double&gt; result = z.Select(i =&gt; Math.Log(i));
</code></pre>

Throw in the use of implicit typing through the var keywork and things are very clear indeed:

<pre><code>var z = new[] {1, 2, 3, 4};
var result = z.Select(i =&gt; Math.Log(i));
</code></pre>

Generally, you'll find the new features of C# 3.0 (especially LINQ) play most nicely when you use List&lt;> instead of Arrays.

If you have code that is already array based, I'd suggest adding overloads to your API that accept IEnumerable instead of int[], allowing the consuming code to use modern language features.

<pre><code>int z = 1;
double result = Math.Log(z); //works
</code></pre>

However trying to do the same thing with an array of numbers doesn't work:

<pre><code>int[] z = new [] {1,2,3,4};
double[] result = Math.Log(z); //Syntax 1 - error CS1503: Argument '1': cannot convert from 'int[]' to 'double'
double[] result = z.Select(p =&gt; Log(p)).ToArray(); //Syntax 2 - OK
</code></pre>

How can I make Syntax #1 work? Syntax #2 seems dirty to me.

Is there a cleaner syntax for applying an operation to each element of a sequence?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

int z = 1;double result = Math.Log(z);            //works然而，尝试用数字数组做同样的事情是行不通的：int[] z = new [] {1,2,3,4};double[] result = Math.Log(z);            //Syntax 1 -...

问是否有更清晰的语法来将操作应用于序列的每个元素？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问是否有更清晰的语法来将操作应用于序列的每个元素？EN