我需要找到一个可以隐藏在深层嵌套列表中的特定值，而不是在同一个地方。甚至相同的深度;这是列表的一种形式：
(setq my-list '(((partnum . 1) (type (TEXT . plain)) (body (charset UTF-8))
(disposition nil) (transfer-encoding QUOTED-PRINTABLE))
((partnum . 2) (type (TEXT . html)) (body (charset UTF-8))
(disposition nil) (transfer-encoding QUOTED-PRINTABLE))))
现在我需要检索“charset”的值;第一个，如果有的话。在这种配置中，很容易：
(car (cdr (cadr (third (car my-list)))))
=> UTF-8
但是，当我确切地知道“身体”细胞的位置时。
我尝试像这样递归地使用mapcar：
(defun search-rec (list)
(mapcar
(lambda (x)
(if (listp x)
(search-rec x)
(message "OY %s" x)))
list))
但每次，当递归到达第一个cons单元的第一个原子时，我得到错误(wrong-type-argument listp 1)。我想我的问题确实是这样的：
如何在列表中搜索？
编辑现在列表看起来像这样，“charset”仍然在（正文）（告诉你这是唯一不变的事情）并且它不再被发现：（
(setq my-list '(((partnum . 1)
(1.1 (type (TEXT . plain)) (body (charset UTF-8))
(disposition nil) (transfer-encoding 7BIT))
(1.2 (type (TEXT . html)) (body (charset UTF-8))
(disposition nil) (transfer-encoding 7BIT))
(type . alternative) (body (boundary e89a8fb2067eba300404c63c5f7f))
(disposition nil) (transfer-encoding nil))
((partnum . 1.1) (type (TEXT . plain)) (body (charset UTF-8))
(disposition nil) (transfer-encoding 7BIT))
((partnum . 1.2) (type (TEXT . html)) (body (charset UTF-8))
(disposition nil) (transfer-encoding 7BIT))
((partnum . 2) (type (IMAGE . x-xpixmap)) (body (name ladybug.xpm))
(disposition nil) (transfer-encoding BASE64))))
编辑这里是更多的IRL示例：
(setq my-list haystack-list)
(setq my-needle (tree-assoc 'charset my-list))
(message "
-------------\n
- my-list: %s\n
- my-needle: %s\n
-------------\n" my-list my-needle)
产地：
my-list：（（TEXT plain（charset UTF-8）nil nil 7BIT 260 18 nil nil nil）（TEXT html（charset UTF-8）nil nil not nil nil not not nil nil nil nil nil）替代方案（边界e89a8fb1f8061a6be404c70a24a0）无零）
my-needle：nil
另一方面：
(tree-assoc 'charset '((TEXT plain (charset UTF-8) nil nil 7BIT 260 18 nil nil nil)
(TEXT html (charset UTF-8) nil nil QUOTED-PRINTABLE 738 17 nil nil nil)
alternative (boundary e89a8fb1f8061a6be404c70a24a0) nil nil))
=>(charset UTF-8)
所以，我真的不知道这里发生了什么：人们可能会争辩说“这个干草堆名单是什么，它来自哪里？”但这有关系吗？我正在研究这个干草堆列表的副本（我的列表），那么是什么给出了不同的结果呢？列表的引用？伙计们，我真的迷失了
NB（这种行为（在直接评估中工作，但在defun / let生产情况下没有发生）并且给出了所有解决方案）
编辑：我最终提取了找到的第一个列表，然后从该列表中提取（不搜索）元素。我证明更快;当然，这就是你可以说“我的元素总是在找到的第一个列表中”;感谢所有人，我通过这一切学到了很多东西。
答案 0 :(得分：5)
看起来你想要Association Lists的树模拟。通过遵循assoc函数的约定，该函数检索包含给定键作为其头部的列表元素，这里是一个在树上工作的assoc版本：
(defun tree-assoc (key tree)
(when (consp tree)
(destructuring-bind (x . y) tree
(if (eql x key) tree
(or (tree-assoc key x) (tree-assoc key y))))))
示例：
(let ((my-list '(((partnum . 1)
(1.1 (type (TEXT . plain)) (body (charset UTF-8))
(disposition nil) (transfer-encoding 7BIT))
(1.2 (type (TEXT . html)) (body (charset UTF-8))
(disposition nil) (transfer-encoding 7BIT))
(type . alternative) (body (boundary e89a8fb2067eba300404c63c5f7f))
(disposition nil) (transfer-encoding nil))
((partnum . 1.1) (type (TEXT . plain)) (body (charset UTF-8))
(disposition nil) (transfer-encoding 7BIT))
((partnum . 1.2) (type (TEXT . html)) (body (charset UTF-8))
(disposition nil) (transfer-encoding 7BIT))
((partnum . 2) (type (IMAGE . x-xpixmap)) (body (name ladybug.xpm))
(disposition nil) (transfer-encoding BASE64)))))
(tree-assoc 'charset my-list))
=> (charset UTF-8)
答案 1 :(得分：2)
这取决于你想做什么以及列表结构有多相似（也就是说，你总是有一个HTML部分的列表吗？是一个总是在body元素里面的charset？）
第一步可能是：
(defun list-query (list-of-keys data)
(let ((data data))
(while (and data list-of-keys)
(setq data (assoc (car list-of-keys) data))
(setq list-of-keys (cdr list-of-keys)))
data))
调用(list-query '(body charset) (car my-list))会导致(charset UTF-8)。在我的列表上循环以查找正文列表中的第一个（或所有）字符集应该相对容易。
答案 2 :(得分：2)
这是我对这个问题的看法，也许你会发现它很有用：
(defun depth-first-search (tree searched &optional comparator)
"TREE is the nested list of elements to search, SEARCHED
is the element to search for, COMPARATOR is the function used
to compare elements of the tree to the searched element, if
you don't provide any, then `equal' is used.
Returns a list of subscripts to be used with `nth' to find the
searched element. If the result is `nil', the list itself
is the searched element. If the result is not a list,
the `not-found' symbol, then the element was not found."
(unless comparator (setq comparator #'equal))
(let ((operations 'not-found))
(labels ((%df-search
(item ops)
(if (funcall comparator item searched)
(setq operations (reverse ops))
(let ((offset 0))
(when (consp item)
(dolist (i item)
(%df-search i (cons offset ops))
(unless (eq operations 'not-found)
(return))
(incf offset)))))))
(%df-search tree nil)
operations)))
(defun nth-repeat (subscripts tree)
"Given the list of SUBSCRIPTS, will subsequently evaluate
`nth' with every subscript on the result of the previous evaluation
such as to find the element in the TREE."
(let ((result tree))
(dolist (i subscripts result)
(setq result (nth i result)))))
(nth-repeat
(depth-first-search '(1 (1 1 2) (1 1 1 3)) 3)
'(1 (1 1 2) (1 1 1 3)))
这将要求你使用cl，但这很常见，你甚至可能都不会注意到，你很可能已经拥有它。
编辑：好的，这样你可以避免完全查看不正确列表的最后一个元素，但是，这意味着你无法在那里搜索：
(defun depth-first-search (tree searched &optional comparator)
"TREE is the nested list of elements to search, SEARCHED
is the element to search for, COMPARATOR is the function used
to compare elements of the tree to the searched element, if
you don't provide any, then `equal' is used.
Returns a list of subscripts to be used with `nth' to find the
searched element. If the result is `nil', the list itself
is the searched element. If the result is not a list,
the `not-found' symbol, then the element was not found."
(unless comparator (setq comparator #'equal))
(let ((operations 'not-found))
(labels ((%df-search
(item ops)
(if (funcall comparator item searched)
(setq operations (reverse ops))
(let ((offset 0))
(when (consp item)
(block outer
(maplist
(lambda (x)
(%df-search (car x) (cons offset ops))
(when (or (not (eq operations 'not-found))
(not (listp (cdr x))))
(return-from outer))
(incf offset))
item)))))))
(%df-search tree nil)
operations)))
(defun nth-repeat (subscripts tree)
"Given the list of SUBSCRIPTS, will subsequently evaluate
`nth' with every subscript on the result of the previous evaluation
such as to fint the element in the TREE."
(let ((result tree))
(dolist (i subscripts result)
(setq result (nth i result)))))
(defvar my-list '(((partnum . 1)
(1.1 (type (TEXT . plain)) (body (charset UTF-8))
(disposition nil) (transfer-encoding 7BIT))
(1.2 (type (TEXT . html)) (body (charset UTF-8))
(disposition nil) (transfer-encoding 7BIT))
(type . alternative) (body (boundary e89a8fb2067eba300404c63c5f7f))
(disposition nil) (transfer-encoding nil))
((partnum . 1.1) (type (TEXT . plain)) (body (charset UTF-8))
(disposition nil) (transfer-encoding 7BIT))
((partnum . 1.2) (type (TEXT . html)) (body (charset UTF-8))
(disposition nil) (transfer-encoding 7BIT))
((partnum . 2) (type (IMAGE . x-xpixmap)) (body (name ladybug.xpm))
(disposition nil) (transfer-encoding BASE64))))
(depth-first-search
my-list '(charset UTF-8)) ; (0 1 2 1)
(nth-repeat
(depth-first-search
my-list '(charset UTF-8)) my-list) ; (charset UTF-8)
可能不是解决问题的最佳方法，但更好的解决方案是需要更改算法以记录car和cdr的序列，这些序列会将您带到相关元素。在这种情况下，您还可以搜索列表中的“不正确”部分。但现在已经太晚了:)也许明天。
编辑2 ：
(defun tree-to-proper-tree (tree)
(cond
((null tree) nil)
((consp tree)
(let ((head
(if (consp (car tree))
(tree-to-proper-tree (car tree))
(car tree))))
(cons head
(tree-to-proper-tree (cdr tree)))))
(t (list tree))))
(defun find-path-to (tree node &optional comparator)
(unless comparator (setq comparator #'equal))
(let ((operations 'not-found))
(labels ((%df-search
(item ops)
(if (funcall comparator item node)
(setq operations (reverse ops))
(when (consp item)
(%df-search (car item) (cons 'car ops))
(%df-search (cdr item) (cons 'cdr ops))))))
(%df-search tree nil)
operations)))
(defun c*r-path (path tree)
(dolist (i path tree)
(setq tree (funcall i tree))))
(defvar my-list '(((partnum . 1)
(1.1 (type (TEXT . plain)) (body (charset UTF-8))
(disposition nil) (transfer-encoding 7BIT))
(1.2 (type (TEXT . html)) (body (charset UTF-8))
(disposition nil) (transfer-encoding 7BIT))
(type . alternative) (body (boundary e89a8fb2067eba300404c63c5f7f))
(disposition nil) (transfer-encoding nil))
((partnum . 1.1) (type (TEXT . plain)) (body (charset UTF-8))
(disposition nil) (transfer-encoding 7BIT))
((partnum . 1.2) (type (TEXT . html)) (body (charset UTF-8))
(disposition nil) (transfer-encoding 7BIT))
((partnum . 2) (type (IMAGE . x-xpixmap)) (body (name ladybug.xpm))
(disposition nil) (transfer-encoding BASE64))))
(tree-to-proper-tree my-list) ; the same lists as above but made into a proper lists
(c*r-path (find-path-to my-list 'UTF-8) my-list) ; UTF-8
(c*r-path (find-path-to my-list 'plain) my-list) ; plain
好的，所以，在这里，tree-to-proper-tree，如果你选择它，将以所有不正确的子树将成为正确的树的方式转换树。或者，您可以使用find-path-to查找car和cdr的序列将引导您搜索到的元素，c*r-path将评估该序列以返回元素以这种方式记录。
请注意，以这种方式搜索同一节点的重复出现将非常具有挑战性。您必须提供一些比较器函数来计算找到项目的次数。
答案 3 :(得分：2)
正如Rainer的回答暗示的那样，你遇到的问题是cons小区的cdr可能指向一个列表，或者它可能指向某种其他类型的对象;你的search-rec函数不能防范后一种可能性。
以下是您正在寻找的Elisp版本（未经过全面测试;适用于您的示例数据）：
(defun find-charset (l)
(catch 'my-result
(find-charset-do l)))
(defun find-charset-do (l)
(when (and (consp l)
(listp (cdr l)))
(if (and (eq (car l) 'charset)
(symbolp (cadr l)))
(throw 'my-result (cadr l))
(dolist (e l)
(find-charset-do e)))))