我有一个包含方法的对象。这些方法被放入匿名函数内部的对象中。看起来像这样：

var t = {};
window.document.addEventListener("keydown", function(e) {
    t.scroll = function(x, y) {
        window.scrollBy(x, y);
    };
    t.scrollTo = function(x, y) {
        window.scrollTo(x, y);
    };
});  

（还有很多代码，但这足以显示问题）

现在，在某些情况下，我想停止事件监听器。因此，我试图做一个removeEventListener，但我不知道如何去做。我已经读过其他问题，无法在匿名函数上调用removeEventListener，但是在这种情况下也是如此吗？

我在匿名函数内部创建了一个t方法，因此我认为这是可能的。看起来像这样：

t.disable = function() {
    window.document.removeEventListener("keydown", this, false);
}

我为什么不能这样做？

还有其他（好的）方法吗？

奖金信息；这仅在Safari中有效，因此缺少IE支持。

我认为这是匿名函数的重点，它缺少名称或引用它的方式。

如果您是我，则可以创建一个命名函数，或将其放在变量中，以便对其进行引用。

var t = {};
var handler = function(e) {
    t.scroll = function(x, y) {
        window.scrollBy(x, y);
    };
    t.scrollTo = function(x, y) {
        window.scrollTo(x, y);
    };
};
window.document.addEventListener("keydown", handler);

您可以通过以下方式将其删除

window.document.removeEventListener("keydown", handler);   

如果您在实际函数内部，则可以使用arguments.callee作为对该函数的引用。如：

button.addEventListener('click', function() {
      ///this will execute only once
      alert('only once!');
      this.removeEventListener('click', arguments.callee);
});

编辑： 如果您在严格模式下（"use strict";），这将无法工作

可在严格模式下使用的Otto Nascarella解决方案的版本是：

button.addEventListener('click', function handler() {
      ///this will execute only once
      alert('only once!');
      this.removeEventListener('click', handler);
});

window.document.removeEventListener("keydown", getEventListeners(window.document.keydown[0].listener));  

可能是几个匿名函数，keydown 1

警告：仅适用于Chrome Dev Tools＆不能在代码中使用：链接

在现代浏览器中，您可以执行以下操作...

button.addEventListener( 'click', () => {
    alert( 'only once!' );
}, { once: true } );

https://developer.mozilla.org/zh-CN/docs/Web/API/EventTarget/addEventListener#Parameters

一个不太匿名的选择

element.funky = function() {
    console.log("Click!");
};
element.funky.type = "click";
element.funky.capt = false;
element.addEventListener(element.funky.type, element.funky, element.funky.capt);
// blah blah blah
element.removeEventListener(element.funky.type, element.funky, element.funky.capt);

由于收到了Andy的反馈（很正确，但与许多示例一样，我希望显示该想法的上下文扩展），因此这里的说明较为简单：

<script id="konami" type="text/javascript" async>
    var konami = {
        ptrn: "38,38,40,40,37,39,37,39,66,65",
        kl: [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]
    };
    document.body.addEventListener( "keyup", function knm ( evt ) {
        konami.kl = konami.kl.slice( -9 );
        konami.kl.push( evt.keyCode );
        if ( konami.ptrn === konami.kl.join() ) {
            evt.target.removeEventListener( "keyup", knm, false );

            /* Although at this point we wish to remove a listener
               we could easily have had multiple "keyup" listeners
               each triggering different functions, so we MUST
               say which function we no longer wish to trigger
               rather than which listener we wish to remove.

               Normal scoping will apply to where we can mention this function
               and thus, where we can remove the listener set to trigger it. */

            document.body.classList.add( "konami" );
        }
    }, false );
    document.body.removeChild( document.getElementById( "konami" ) );
</script>

这允许有效的匿名函数结构，避免使用实际上不推荐使用的被调用方，并允许轻松删除。

顺便说一句：设置侦听器后立即删除script元素是一种隐藏代码的可爱技巧，人们宁愿撬起眼睛也不是很明显（会破坏惊喜；-)

因此，方法（更简单地说）是：

element.addEventListener( action, function name () {
    doSomething();
    element.removeEventListener( action, name, capture );
}, capture );

这是不理想的，因为它会删除所有内容，但可能会满足您的需求：

z = document.querySelector('video');
z.parentNode.replaceChild(z.cloneNode(1), z);

克隆节点会复制其所有属性及其值，包括固有（串联）侦听器。它不会复制使用addEventListener（）添加的事件侦听器

Node.cloneNode（）

JavaScript：addEventListener 方法将指定的侦听器注册在调用它的EventTarget（Element | document | Window）上。

EventTarget。addEventListener（event_type，handler_function，Bubbling | Capturing）;

鼠标，键盘事件 WebConsole中的示例测试：

var keyboard = function(e) {
    console.log('Key_Down Code : ' + e.keyCode);
};
var mouseSimple = function(e) {
    var element = e.srcElement || e.target;
    var tagName = element.tagName || element.relatedTarget;
    console.log('Mouse Over TagName : ' + tagName);    
};
var  mouseComplex = function(e) {
    console.log('Mouse Click Code : ' + e.button);
} 

window.document.addEventListener('keydown',   keyboard,      false);
window.document.addEventListener('mouseover', mouseSimple,   false);
window.document.addEventListener('click',     mouseComplex,  false);

removeEventListener 方法将删除先前向EventTarget.addEventListener（）注册的事件侦听器。

window.document.removeEventListener('keydown',   keyboard,     false);
window.document.removeEventListener('mouseover', mouseSimple,  false);
window.document.removeEventListener('click',     mouseComplex, false);

我可以用吗

要对此提供最新的方法：

//one-time fire
element.addEventListener('mousedown', {
  handleEvent: function (evt) {
    element.removeEventListener(evt.type, this, false);
  }
}, false);

我偶然发现了相同的问题，这是我可以获得的最佳解决方案：

/*Adding the event listener (the 'mousemove' event, in this specific case)*/
element.onmousemove = function(event) {
    /*do your stuff*/
};
/*Removing the event listener*/
element.onmousemove = null;

请记住，我仅针对window元素和'mousemove'事件对此进行了测试，因此这种方法可能会出现一些问题。

就您的要求而言，可能不是最佳的解决方案。我还没有确定一种有效的方法来删除与事件侦听器调用内联声明的匿名函数。

我个人使用变量来存储<target>和在事件侦听器调用之外声明函数，例如：

const target = document.querySelector('<identifier>');

function myFunc(event) { function code; }

target.addEventListener('click', myFunc);

然后删除监听器：

target.removeEventListener('click', myFunc);

不是您会收到的最高建议，而是删除匿名函数，我发现唯一有用的解决方案是删除然后替换HTML元素。我敢肯定必须有一个更好的香草JS方法，但我还没有看到它。

我知道这是一个相当老的话题，但我想我可能会为那些觉得有用的人投入两美分。

脚本（关于非创意方法名称的道歉）：

window.Listener = {
    _Active: [],
    remove: function(attached, on, callback, capture){
        for(var i = 0; i < this._Active.length; i++){
            var current = this._Active[i];
            if(current[0] === attached && current[1] === on && current[2] === callback){
                attached.removeEventListener(on, callback, (capture || false));
                return this._Active.splice(i, 1);
            }
        }
    }, removeAtIndex(i){
        if(this._Active[i]){
            var remove = this._Active[i];
            var attached = remove[0], on = remove[1], callback = remove[2];
            attached.removeEventListener(on, callback, false);
            return this._Active.splice(i, 1);
        }
    }, purge: function(){
        for(var i = 0; i < this._Active.length; i++){
            var current = this._Active[i];
            current[0].removeEventListener(current[1], current[2]);
            this._Active.splice(i, 1);
        }
    }, declare: function(attached, on, callback, capture){
        attached.addEventListener(on, callback, (capture || false));
        if(this._Active.push([attached, on, callback])){
            return this._Active.length - 1;
        }
    }
};

您可以像这样使用它：

// declare a new onclick listener attached to the document
var clickListener = Listener.declare(document, "click" function(e){
    // on click, remove the listener and log the clicked element
    console.log(e.target);
    Listener.removeAtIndex(clickListener);
});

// completely remove all active listeners 
// (at least, ones declared via the Listener object)
Listener.purge();

// works exactly like removeEventListener
Listener.remove(element, on, callback);

window.document.onkeydown = function(){};