JavaScript窗口调整活动

Question

我怎么可以勾到浏览器窗口调整的事件吗？

还有 一个jQuery方式的听力调整活动 但是我宁愿不要把它带到我的项目的只是这一要求。

Answer 1

jQuery是刚好包住标准resize DOM事件，例如

window.onresize = function(event) {
    ...
};

的jQuery的可以的做一些工作，以确保resize事件被在所有浏览器中一致解雇，但我不知道是否有任何浏览器的不同，但我会鼓励你来测试火狐，Safari和IE。

Answer 2

从不重写window.onresize功能。

相反，创建一个函数来事件监听器添加到对象或元素。 这种检查和柜面听众不工作，那么它会覆盖作为最后的手段对象的功能。这是在库如jQuery中使用的优选的方法。

object：元素或窗口对象，点击 type：缩放，滚动（事件类型）点击 callback：函数参考

var addEvent = function(object, type, callback) {
    if (object == null || typeof(object) == 'undefined') return;
    if (object.addEventListener) {
        object.addEventListener(type, callback, false);
    } else if (object.attachEvent) {
        object.attachEvent("on" + type, callback);
    } else {
        object["on"+type] = callback;
    }
};

然后，使用是这样的：

addEvent(window, "resize", function_reference);

或与匿名功能：

addEvent(window, "resize", function(event) {
  console.log('resized');
});

Answer 3

首先，我知道addEventListener方法已在上述评论被提到，但我没有看到任何代码。因为它是优选的方法，在这里它是：

window.addEventListener('resize', function(event){
  // do stuff here
});

这里的一个工作示例。

Answer 4

在resize事件不应该被直接用作像我们调整它被连续地烧成。

使用去抖动功能来减轻过量的呼叫。

window.addEventListener('resize',debounce(handler, delay, immediate),false);

下面是一个常见的防抖左右浮动净，虽然看寻找更先进的在lodash featuerd。

const debounce = (func, wait, immediate) => {
    var timeout;
    return () => {
        const context = this, args = arguments;
        const later = function() {
            timeout = null;
            if (!immediate) func.apply(context, args);
        };
        const callNow = immediate && !timeout;
        clearTimeout(timeout);
        timeout = setTimeout(later, wait);
        if (callNow) func.apply(context, args);
    };
};

此可以使用像这样...

window.addEventListener('resize', debounce(() => console.log('hello'),
200, false), false);

这将永远不会触发超过每200ms一次。

有关移动方向的变化使用：

window.addEventListener('orientationchange', () => console.log('hello'), false);

下面是href="https://github.com/julienetie/resizilla" rel="noreferrer">小型图书馆我放在一起照顾这个

Answer 5

我确实相信 @Alex V 已经提供了正确的答案，但答案确实需要一些现代化，因为它已经有五年多了。

主要有两个问题：

1. 切勿使用 object 作为参数名称。这是一个保留词。话虽这么说，@Alex V 提供的功能将无法在 strict mode.

2. 这 addEvent @Alex V 提供的函数不返回 event object 如果 addEventListener 使用方法。应添加另一个参数 addEvent 函数来实现这一点。

笔记：新参数为 addEvent 已成为可选的，以便迁移到此新函数版本不会中断对此函数的任何先前调用。所有遗留用途都将受到支持。

这是更新的 addEvent 进行这些更改后的功能：

/*
    function: addEvent

    @param: obj         (Object)(Required)

        -   The object which you wish
            to attach your event to.

    @param: type        (String)(Required)

        -   The type of event you
            wish to establish.

    @param: callback    (Function)(Required)

        -   The method you wish
            to be called by your
            event listener.

    @param: eventReturn (Boolean)(Optional)

        -   Whether you want the
            event object returned
            to your callback method.
*/
var addEvent = function(obj, type, callback, eventReturn)
{
    if(obj == null || typeof obj === 'undefined')
        return;

    if(obj.addEventListener)
        obj.addEventListener(type, callback, eventReturn ? true : false);
    else if(obj.attachEvent)
        obj.attachEvent("on" + type, callback);
    else
        obj["on" + type] = callback;
};

调用 new 的示例 addEvent 功能：

var watch = function(evt)
{
    /*
        Older browser versions may return evt.srcElement
        Newer browser versions should return evt.currentTarget
    */
    var dimensions = {
        height: (evt.srcElement || evt.currentTarget).innerHeight,
        width: (evt.srcElement || evt.currentTarget).innerWidth
    };
};

addEvent(window, 'resize', watch, true);

Answer 6

在 HTTP引用我的博客文章谢谢：//mbccs.blogspot.com/2007/11/fixing-window-resize-event-in-ie.html

尽管你可以挂接到标准的窗口resize事件，你会发现，在IE浏览器，该事件对每个X，一次针对每一个Y轴移动触发一次，产生一吨的事件被解雇的可能在您的网站性能的影响，如果渲染是一个密集的任务。

我的方法涉及的是大干快上的后续事件，这样，直到用户完成调整窗口的事件没有得到冒泡到你的代码取消了短暂停。

Answer 7

<强>解2018 +：

您应该使用 ResizeObserver 。这将是具有比使用resize事件的表现要好得多浏览器本地解决方案。此外，它不仅支持在document而且对任意elements该事件。

var ro = new ResizeObserver( entries => {
  for (let entry of entries) {
    const cr = entry.contentRect;
    console.log('Element:', entry.target);
    console.log(`Element size: ${cr.width}px x ${cr.height}px`);
    console.log(`Element padding: ${cr.top}px ; ${cr.left}px`);
  }
});

// Observe one or multiple elements
ro.observe(someElement);

目前，只有 Chrome支持，但其他浏览器很可能会遵循（即将推出）。现在，你必须使用填充工具。

Answer 8

window.onresize = function() {
    // your code
};

Answer 9

以下博客可能是有用的： 固定的窗口调整的事件，在即

它提供这个代号：

Sys.Application.add_load(function(sender, args) {
    $addHandler(window, 'resize', window_resize);
});

var resizeTimeoutId;

function window_resize(e) {
     window.clearTimeout(resizeTimeoutId);
     resizeTimeoutId = window.setTimeout('doResizeCode();', 10);
}

Answer 10

上面已经提到的解决方案，将工作，如果你想要做的是调整只是窗口和窗口。但是，如果你想拥有传播到子元素的调整大小，你需要自己传播的事件。下面是一些示例代码来做到这一点：

window.addEventListener("resize", function () {
  var recResizeElement = function (root) {
    Array.prototype.forEach.call(root.childNodes, function (el) {

      var resizeEvent = document.createEvent("HTMLEvents");
      resizeEvent.initEvent("resize", false, true);
      var propagate = el.dispatchEvent(resizeEvent);

      if (propagate)
        recResizeElement(el);
    });
  };
  recResizeElement(document.body);
});

请注意子元素可以调用

 event.preventDefault();

传递在作为调整大小事件的第一精氨酸事件对象上。例如：

var child1 = document.getElementById("child1");
child1.addEventListener("resize", function (event) {
  ...
  event.preventDefault();
});

Answer 11

var EM = new events_managment();

EM.addEvent(window, 'resize', function(win,doc, event_){
    console.log('resized');
    //EM.removeEvent(win,doc, event_);
});

function events_managment(){
    this.events = {};
    this.addEvent = function(node, event_, func){
        if(node.addEventListener){
            if(event_ in this.events){
                node.addEventListener(event_, function(){
                    func(node, event_);
                    this.events[event_](win_doc, event_);
                }, true);
            }else{
                node.addEventListener(event_, function(){
                    func(node, event_);
                }, true);
            }
            this.events[event_] = func;
        }else if(node.attachEvent){

            var ie_event = 'on' + event_;
            if(ie_event in this.events){
                node.attachEvent(ie_event, function(){
                    func(node, ie_event);
                    this.events[ie_event]();
                });
            }else{
                node.attachEvent(ie_event, function(){
                    func(node, ie_event);
                });
            }
            this.events[ie_event] = func;
        }
    }
    this.removeEvent = function(node, event_){
        if(node.removeEventListener){
            node.removeEventListener(event_, this.events[event_], true);
            this.events[event_] = null;
            delete this.events[event_];
        }else if(node.detachEvent){
            node.detachEvent(event_, this.events[event_]);
            this.events[event_] = null;
            delete this.events[event_];
        }
    }
}

Answer 12

<script language="javascript">
    window.onresize = function() {
    document.getElementById('ctl00_ContentPlaceHolder1_Accordion1').style.height = '100%';
} 

</script>