blocks|key|2039274|text|您必须自己定义它，如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2039275|index_of(Item,+List)+->+index_of(Item,+List,+1).

index_of(_,+[],+_)++->+not_found;
index_of(Item,+[Item%7C_],+Index)+->+Index;
index_of(Item,+[_%7CTl],+Index)+->+index_of(Item,+Tl,+Index%2B1).|code-block|syntax|javascript|2039276|但是请注意，访问列表的第N个元素是O(N)，因此经常通过索引访问列表的算法的效率将低于按顺序迭代列表的算法。|2039277|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|$]]

You'll have to define it yourself, like this:

<pre><code>index_of(Item, List) -&gt; index_of(Item, List, 1).

index_of(_, [], _) -&gt; not_found;
index_of(Item, [Item|_], Index) -&gt; Index;
index_of(Item, [_|Tl], Index) -&gt; index_of(Item, Tl, Index+1).
</code></pre>

Note however that accesing the Nth element of a list is O(N), so an algorithm that often accesses a list by index will be less efficient than one that iterates through it sequentially.

blocks|key|1825493|text|这个函数在Erlang中非常少见，这可能是它不在标准库中的原因。有经验的Erlang程序员都不需要它，也不鼓励使用这个函数的算法。当有人需要它时，可以为自己的目的而写，但这种非常罕见的情况并不是将其包含在stdlib中的理由。以适当的方式设计你的数据结构，而不是要求这个函数。在大多数情况下，需要此函数表示设计中存在错误。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1825494|entityMap^0|2U|6|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

This function is very uncommon for Erlang and this is may be reason why it is not in standard library. No one of experienced Erlang programmers need it and is discourage to use algorithms using this function. When someone needs it, can write for own purpose but this very rare occasions are not reason to include it to <code>stdlib</code>. Design your data structures in proper way instead of ask for this function. In most cases need of this function indicates error in design.

blocks|key|1825527|text|其他解决方案(请注意，这些是base-index=1)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1825528|index_of(Value,+List)+->
+++Map+=+lists:zip(List,+lists:seq(1,+length(List))),
+++case+lists:keyfind(Value,+1,+Map)+of
++++++{Value,+Index}+->+Index;
++++++false+->+notfound
+++end.

index_of(Value,+List)+->
+++Map+=+lists:zip(List,+lists:seq(1,+length(List))),
+++case+dict:find(Value,+dict:from_list(Map))+of
++++++{ok,+Index}+->+Index;
++++++error+->+notfound
+++end.|code-block|syntax|javascript|1825529|在某些情况下，当传递给这些函数的列表变得足够长时，构造额外列表或字典的开销就会变得过于昂贵。如果您可以通过在这些函数之外保留该格式的列表来避免每次要搜索列表时都进行构造，那么您就消除了大部分开销。|1825530|使用字典将对列表中的值进行散列处理，并有助于将索引查找时间减少到O(log+N)，因此最好将其用于大型单键列表。|1825531|一般而言，将数据组织成适合您如何使用它们的结构取决于您作为程序员。我的猜测是，没有内置的index_of是为了鼓励这样的考虑。如果要进行单键查找--+index_of()就是这样--请使用字典。如果您正在进行多键查找，请使用带有列表的元组列表:keyfind()等。如果你的列表非常大，一个不那么简单的解决方案可能是最好的。|1825532|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|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Other solutions (remark that these are base-index=1):



<pre><code>index_of(Value, List) -&gt;
 Map = lists:zip(List, lists:seq(1, length(List))),
 case lists:keyfind(Value, 1, Map) of
 {Value, Index} -&gt; Index;
 false -&gt; notfound
 end.

index_of(Value, List) -&gt;
 Map = lists:zip(List, lists:seq(1, length(List))),
 case dict:find(Value, dict:from_list(Map)) of
 {ok, Index} -&gt; Index;
 error -&gt; notfound
 end.
</code></pre>

At some point, when the lists you pass to these functions get long enough, the overhead of constructing the additional list or dict becomes too expensive. If you can avoid doing the construction every time you want to search the list by keeping the list in that format outside of these functions, you eliminate most of the overhead.

Using a dictionary will hash the values in the list and help reduce the index lookup time to O(log N), so it's better to use that for large, singly-keyed lists.

In general, it's up to you, the programmer, to organize your data into structures that suit how you're going to use them. My guess is that the absence of a built-in index_of is to encourage such consideration. If you're doing single-key lookups -- that's really what index_of() is -- use a dictionary. If you're doing multi-key lookups, use a list of tuples with lists:keyfind() et al. If your lists are inordinately large, a less simplistic solution is probably best.

blocks|key|1825552|text|正如其他人所指出的，有更有效的方法来解决这个问题。但是如果你正在寻找一些快速的东西，这对我来说很有效：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1825553|string:str(List,+[Element]).|code-block|syntax|javascript|1825554|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|$]]

As others noted, there are more efficient ways to solve for this. But if you're looking for something quick, this worked for me:

<pre><code>string:str(List, [Element]).
</code></pre>

blocks|key|2039379|text|我认为作者的观点很有说服力。以下是我在日志记录应用程序中的用例。目标是根据要针对不同级别的错误响应执行的操作来检查错误的严重性。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2039380|get_index(A,L)+->
++++get_index(A,L,1).
get_index(A,[A%7C_],N)+->
++++N;
get_index(A,[_%7CT],N)+->
++++get_index(A,T,N%2B1).

get_severity(A)+->
++++Severity=[debug,info,warn,error],
++++get_index(A,Severity).|code-block|syntax|javascript|2039381|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 writer makes a valid case. Here is my use case from a logging application. The objective is to check the severity of an error against the actions to be performed against various levels of error response.

<pre><code>get_index(A,L) -&gt;
 get_index(A,L,1).
get_index(A,[A|_],N) -&gt;
 N;
get_index(A,[_|T],N) -&gt;
 get_index(A,T,N+1).

get_severity(A) -&gt;
 Severity=[debug,info,warn,error],
 get_index(A,Severity).
</code></pre>

blocks|key|1825586|text|下面的函数返回列表中给定元素的索引列表。结果可用于获取列表中重复元素的第一个或最后一个匹配项的索引。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1825587|indices_of(Element,+L)+->++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++Indices+=+lists:zip(lists:seq(1,length(L)),+L),++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++[+I+%7C%7C+{I,+E}+<-+Indices,+E+==+Element+].+++|code-block|syntax|javascript|1825588|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|$]]

The following function returns a list of indices of a given element in a list. Result can be used to get the index of the first or last occurrence of a duplicate element in a list.

<pre><code>indices_of(Element, L) -&gt; 
 Indices = lists:zip(lists:seq(1,length(L)), L), 
 [ I || {I, E} &lt;- Indices, E == Element ]. 
</code></pre>

I'm looking for an Erlang library function that will return the index of a particular element in a list.
So, if
<pre class="lang-erlang prettyprint-override"><code>X = [10,30,50,70]
</code></pre>
<pre><code>lists:index_of(30, X)
</code></pre>
would return 1, etc., just like <code>java.util.List</code>'s <code>indexOf()</code> method.
Does such a method exist in the Erlang standard lib? I tried looking in the lists module but no luck. Or should I write it myself?

Erlang lists:index_of function?

数据结构

Erlang

我正在寻找一个Erlang库函数，它将返回列表中特定元素的索引。所以，如果X = [10,30,50,70]lists:index_of(30, X)将返回1，等等，就像java.util.List的indexOf()方法一样。Erlang标准库中是否存在这样的方法？我试着在列表模块中查找，但没有成功。或者我应该自己写...

问Erlang lists:index_of函数？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Erlang lists:index_of函数？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Erlang lists:index_of函数？
EN