如何检测DIV的尺寸变化?

2020/10/01 00:01 · javascript ·  · 0评论

我有以下示例html,有一个DIV,其宽度为100%。它包含一些元素。在执行窗口调整大小时,内部元素可能会重新放置,并且div的尺寸可能会更改。我问是否有可能挂钩div的尺寸更改事件?以及如何做到这一点?我目前将回调函数绑定到目标DIV上的jQuery resize事件,但是,没有控制台日志输出,请参见以下内容:

调整大小之前
在此处输入图片说明

<html>
<head>
    <script type="text/javascript" language="javascript" src="http://code.jquery.com/jquery-1.6.1.min.js"></script>
    <script type="text/javascript" language="javascript">
            $('#test_div').bind('resize', function(){
                console.log('resized');
            });
    </script>
</head>
<body>
    <div id="test_div" style="width: 100%; min-height: 30px; border: 1px dashed pink;">
        <input type="button" value="button 1" />
        <input type="button" value="button 2" />
        <input type="button" value="button 3" />
    </div>
</body>
</html>

有一种非常有效的方法来确定元素的大小是否已更改。

http://marcj.github.io/css-element-queries/

该库具有ResizeSensor可用于调整大小检测的类。
它使用基于事件的方法,因此该死的速度很快,并且不会浪费CPU时间。

例:

new ResizeSensor(jQuery('#divId'), function(){ 
    console.log('content dimension changed');
});

请不要使用jQuery onresize插件,因为它setTimeout()与读取循环中的DOM clientHeight/clientWidth属性结合使用以检查更改。
这是令人难以置信的缓慢且不准确,因为它会引起布局抖动

披露:我与此图书馆直接相关。

Chrome 64中提供了一个新的标准,即Resize Observer api。

function outputsize() {
 width.value = textbox.offsetWidth
 height.value = textbox.offsetHeight
}
outputsize()

new ResizeObserver(outputsize).observe(textbox)
Width: <output id="width">0</output><br>
Height: <output id="height">0</output><br>
<textarea id="textbox">Resize me</textarea><br>

调整观察者大小

规格:https//wicg.github.io/ResizeObserver

Polyfills:https//github.com/WICG/ResizeObserver/issues/3

Firefox问题:https//bugzil.la/1272409

Safari问题:http//wkb.ug/157743

当前支持:http : //caniuse.com/#feat=resizeobserver

从长远来看,您将可以使用ResizeObserver

new ResizeObserver(callback).observe(element);

不幸的是,当前许多浏览器默认都不支持它。

同时,您可以使用以下功能。既然如此,大多数元素大小的更改将来自于调整窗口大小或更改DOM中的某些内容。您可以使用窗口的resize事件监听窗口的大小调整,也可以使用MutationObserver监听DOM的更改

这是一个函数示例,当提供的元素的大小由于这些事件中的任何一个而改变时,该函数将回调您:

var onResize = function(element, callback) {
  if (!onResize.watchedElementData) {
    // First time we are called, create a list of watched elements
    // and hook up the event listeners.
    onResize.watchedElementData = [];

    var checkForChanges = function() {
      onResize.watchedElementData.forEach(function(data) {
        if (data.element.offsetWidth !== data.offsetWidth ||
            data.element.offsetHeight !== data.offsetHeight) {
          data.offsetWidth = data.element.offsetWidth;
          data.offsetHeight = data.element.offsetHeight;
          data.callback();
        }
      });
    };

    // Listen to the window's size changes
    window.addEventListener('resize', checkForChanges);

    // Listen to changes on the elements in the page that affect layout 
    var observer = new MutationObserver(checkForChanges);
    observer.observe(document.body, { 
      attributes: true,
      childList: true,
      characterData: true,
      subtree: true 
    });
  }

  // Save the element we are watching
  onResize.watchedElementData.push({
    element: element,
    offsetWidth: element.offsetWidth,
    offsetHeight: element.offsetHeight,
    callback: callback
  });
};

您必须将resize事件绑定到window对象上,而不是通用html元素上。

然后,您可以使用以下代码:

$(window).resize(function() {
    ...
});

在回调函数中,您可以检查div呼叫的新宽度

$('.a-selector').width();

因此,您的问题的答案为,您无法将resize事件绑定到div。

ResizeSensor.js是一个庞大的库的一部分,但我将其功能简化为THIS

function ResizeSensor(element, callback)
{
    let zIndex = parseInt(getComputedStyle(element));
    if(isNaN(zIndex)) { zIndex = 0; };
    zIndex--;

    let expand = document.createElement('div');
    expand.style.position = "absolute";
    expand.style.left = "0px";
    expand.style.top = "0px";
    expand.style.right = "0px";
    expand.style.bottom = "0px";
    expand.style.overflow = "hidden";
    expand.style.zIndex = zIndex;
    expand.style.visibility = "hidden";

    let expandChild = document.createElement('div');
    expandChild.style.position = "absolute";
    expandChild.style.left = "0px";
    expandChild.style.top = "0px";
    expandChild.style.width = "10000000px";
    expandChild.style.height = "10000000px";
    expand.appendChild(expandChild);

    let shrink = document.createElement('div');
    shrink.style.position = "absolute";
    shrink.style.left = "0px";
    shrink.style.top = "0px";
    shrink.style.right = "0px";
    shrink.style.bottom = "0px";
    shrink.style.overflow = "hidden";
    shrink.style.zIndex = zIndex;
    shrink.style.visibility = "hidden";

    let shrinkChild = document.createElement('div');
    shrinkChild.style.position = "absolute";
    shrinkChild.style.left = "0px";
    shrinkChild.style.top = "0px";
    shrinkChild.style.width = "200%";
    shrinkChild.style.height = "200%";
    shrink.appendChild(shrinkChild);

    element.appendChild(expand);
    element.appendChild(shrink);

    function setScroll()
    {
        expand.scrollLeft = 10000000;
        expand.scrollTop = 10000000;

        shrink.scrollLeft = 10000000;
        shrink.scrollTop = 10000000;
    };
    setScroll();

    let size = element.getBoundingClientRect();

    let currentWidth = size.width;
    let currentHeight = size.height;

    let onScroll = function()
    {
        let size = element.getBoundingClientRect();

        let newWidth = size.width;
        let newHeight = size.height;

        if(newWidth != currentWidth || newHeight != currentHeight)
        {
            currentWidth = newWidth;
            currentHeight = newHeight;

            callback();
        }

        setScroll();
    };

    expand.addEventListener('scroll', onScroll);
    shrink.addEventListener('scroll', onScroll);
};

如何使用它:

let container = document.querySelector(".container");
new ResizeSensor(container, function()
{
    console.log("dimension changed:", container.clientWidth, container.clientHeight);
});

我不推荐setTimeout()hack,因为它会降低性能!相反,您可以使用 DOM突变观察器来监听Div大小的变化。

JS:

var observer = new MutationObserver(function(mutations) {
    console.log('size changed!');
  });
  var target = document.querySelector('.mydiv');
  observer.observe(target, {
    attributes: true
  });

HTML:

<div class='mydiv'>
</div>

这是小提琴

尝试更改div的大小。


您可以将方法进一步包装在方法中debounce以提高效率。debounce将每隔x毫秒触发一次您的方法,而不是每隔一毫秒触发一次DIV调整大小。

最好的解决方案是使用所谓的元素查询但是,它们不是标准的,没有规范-如果您想这样做,唯一的选择是使用一种可用的polyfills /库。

元素查询背后的想法是允许页面上的某个容器响应提供给它的空间。这将允许编写一次组件,然后将其放在页面上的任何位置,同时它将其内容调整为当前大小。无论窗口大小是多少。这是我们在元素查询和媒体查询之间看到的第一个区别。每个人都希望在某个时候可以创建一个规范,以规范元素查询(或达到相同目标的东西)并使它们本机,干净,简单且健壮。大多数人都认为媒体查询非常有限,对模块化设计和真正的响应能力没有帮助。

有一些polyfills /库以不同的方式解决问题(尽管可以称为解决方法而不是解决方案):

我已经看到了针对类似问题的其他解决方案。通常他们使用计时器或引擎盖下的窗口/视口大小,这不是真正的解决方案。此外,我认为理想情况下,这应该主要在CSS中解决,而不是在javascript或html中解决。

当MarcJ的解决方案不起作用时,我发现此库可以工作:

https://github.com/sdecima/javascript-detect-element-resize

它非常轻巧,甚至可以通过CSS或HTML加载/渲染来检测自然大小。

代码示例(从链接中获取):

<script type="text/javascript" src="detect-element-resize.js"></script>
<script type="text/javascript">
  var resizeElement = document.getElementById('resizeElement'),
      resizeCallback = function() {
          /* do something */
      };
  addResizeListener(resizeElement, resizeCallback);
  removeResizeListener(resizeElement, resizeCallback);
</script>

看看这个http://benalman.com/code/projects/jquery-resize/examples/resize/

它有各种各样的例子。尝试调整窗口大小,并查看容器元素中的元素如何调整。

js小提琴的示例解释了如何使其工作。

看看这个小提琴
http://jsfiddle.net/sgsqJ/4/

在该事件中,将resize()事件绑定到具有“ test”类的元素以及窗口对象,并在窗口对象的resize回调中调用$('。test')。resize()。

例如

$('#test_div').bind('resize', function(){
            console.log('resized');
});

$(window).resize(function(){
   $('#test_div').resize();
});

您可以使用iframeobject使用contentWindowcontentDocument调整大小。没有setIntervalsetTimeout

步骤:

  1. 将元素位置设置为 relative
  2. 在透明的绝对隐藏的IFRAME中添加
  3. IFRAME.contentWindow- onresize事件

HTML的示例:

<div style="height:50px;background-color:red;position:relative;border:1px solid red">
<iframe style=width:100%;height:100%;position:absolute;border:none;background-color:transparent allowtransparency=true>
</iframe>
This is my div
</div>

Javascript:

$('div').width(100).height(100);
$('div').animate({width:200},2000);

$('object').attr({
    type : 'text/html'
})
$('object').on('resize,onresize,load,onload',function(){
    console.log('ooooooooonload')
})

$($('iframe')[0].contentWindow).on('resize',function(){
    console.log('div changed')
})

运行示例

JsFiddle:https://jsfiddle.net/qq8p470d/


看更多:

仅窗口对象会生成“调整大小”事件。我唯一知道要执行的操作的方法是运行一个间隔计时器,该计时器会定期检查大小。

var div = document.getElementById('div');
div.addEventListener('resize', (event) => console.log(event.detail));

function checkResize (mutations) {
    var el = mutations[0].target;
    var w = el.clientWidth;
    var h = el.clientHeight;
    
    var isChange = mutations
      .map((m) => m.oldValue + '')
      .some((prev) => prev.indexOf('width: ' + w + 'px') == -1 || prev.indexOf('height: ' + h + 'px') == -1);

    if (!isChange)
      return;

    var event = new CustomEvent('resize', {detail: {width: w, height: h}});
    el.dispatchEvent(event);
}

var observer = new MutationObserver(checkResize); 
observer.observe(div, {attributes: true, attributeOldValue: true, attributeFilter: ['style']});
#div {width: 100px; border: 1px solid #bbb; resize: both; overflow: hidden;}
<div id = "div">DIV</div>

与这个问题一样古老,在大多数浏览器中这仍然是一个问题。

就像其他人所说的那样,Chrome 64+现在原生随附了Resize Observes,但是该规范仍在微调中,并且Chrome当前(截至2019-01-29)目前落后于该规范的最新版本

我已经看到了很多不错的ResizeObserver填充,但是,其中一些并没有严格遵循规范,而另一些则存在一些计算问题。

我非常需要这种行为来创建一些可在任何应用程序中使用的响应式Web组件。为了使它们正常工作,他们需要始终了解它们的尺寸,因此ResizeObservers听起来很理想,我决定创建一个尽可能符合规格的polyfill。

回购:
https //github.com/juggle/resize-observer

演示:https :
//codesandbox.io/s/myqzvpmmy9

使用Clay.js(https://github.com/zzarcon/clay),检测元素大小的变化非常简单:

var el = new Clay('.element');

el.on('resize', function(size) {
    console.log(size.height, size.width);
});

这篇博客文章帮助我有效地检测DOM元素的大小变化。

http://www.backalleycoder.com/2013/03/18/cross-browser-event-based-element-resize-detection/

如何使用此代码...

AppConfig.addResizeListener(document.getElementById('id'), function () {
  //Your code to execute on resize.
});

该示例使用的打包代码...

var AppConfig = AppConfig || {};
AppConfig.ResizeListener = (function () {
    var attachEvent = document.attachEvent;
    var isIE = navigator.userAgent.match(/Trident/);
    var requestFrame = (function () {
        var raf = window.requestAnimationFrame || window.mozRequestAnimationFrame || window.webkitRequestAnimationFrame ||
            function (fn) { return window.setTimeout(fn, 20); };
        return function (fn) { return raf(fn); };
    })();

    var cancelFrame = (function () {
        var cancel = window.cancelAnimationFrame || window.mozCancelAnimationFrame || window.webkitCancelAnimationFrame ||
               window.clearTimeout;
        return function (id) { return cancel(id); };
    })();

    function resizeListener(e) {
        var win = e.target || e.srcElement;
        if (win.__resizeRAF__) cancelFrame(win.__resizeRAF__);
        win.__resizeRAF__ = requestFrame(function () {
            var trigger = win.__resizeTrigger__;
            trigger.__resizeListeners__.forEach(function (fn) {
                fn.call(trigger, e);
            });
        });
    }

    function objectLoad(e) {
        this.contentDocument.defaultView.__resizeTrigger__ = this.__resizeElement__;
        this.contentDocument.defaultView.addEventListener('resize', resizeListener);
    }

    AppConfig.addResizeListener = function (element, fn) {
        if (!element.__resizeListeners__) {
            element.__resizeListeners__ = [];
            if (attachEvent) {
                element.__resizeTrigger__ = element;
                element.attachEvent('onresize', resizeListener);
            } else {
                if (getComputedStyle(element).position === 'static') element.style.position = 'relative';
                var obj = element.__resizeTrigger__ = document.createElement('object');
                obj.setAttribute('style', 'display: block; position: absolute; top: 0; left: 0; height: 100%; width: 100%; overflow: hidden; pointer-events: none; z-index: -1;');
                obj.__resizeElement__ = element;
                obj.onload = objectLoad;
                obj.type = 'text/html';
                if (isIE) element.appendChild(obj);
                obj.data = 'about:blank';
                if (!isIE) element.appendChild(obj);
            }
        }
        element.__resizeListeners__.push(fn);
    };

    AppConfig.removeResizeListener = function (element, fn) {
        element.__resizeListeners__.splice(element.__resizeListeners__.indexOf(fn), 1);
        if (!element.__resizeListeners__.length) {
            if (attachEvent) element.detachEvent('onresize', resizeListener);
            else {
                element.__resizeTrigger__.contentDocument.defaultView.removeEventListener('resize', resizeListener);
                element.__resizeTrigger__ = !element.removeChild(element.__resizeTrigger__);
            }
        }
    }
})();

注意:AppConfig是我用于组织可重用功能的名称空间/对象。随时搜索和替换您想要的名称。

我的jQuery插件不仅对启用所有元素的“调整大小”事件window

https://github.com/dustinpoissant/ResizeTriggering

$("#myElement") .resizeTriggering().on("resize", function(e){
  // Code to handle resize
}); 

您可以尝试以下代码段中的代码,它使用纯JavaScript满足了您的需求。运行代码段,然后单击“整页”链接以触发有关div调整大小的警报,如果您要对其进行测试。)。

基于这是setInterval100毫秒的事实,我敢说我的PC并没有发现它占用过多的CPU。(在测试时,Chrome中所有打开的标签页使用的CPU总数为0.1%。)。但是同样,这仅适用于一个div,如果您想对大量元素执行此操作,则可以,这可能会非常占用CPU。

无论如何,您始终可以使用click事件来停止div-resize嗅探

var width = 0; 
var interval = setInterval(function(){
if(width <= 0){
width = document.getElementById("test_div").clientWidth;
} 
if(document.getElementById("test_div").clientWidth!==width) {   
  alert('resized div');
  width = document.getElementById("test_div").clientWidth;
}    

}, 100);
<div id="test_div" style="width: 100%; min-height: 30px; border: 1px dashed pink;">
        <input type="button" value="button 1" />
        <input type="button" value="button 2" />
        <input type="button" value="button 3" />
</div>

您可以检查小提琴

更新

var width = 0; 
function myInterval() {
var interval = setInterval(function(){
if(width <= 0){
width = document.getElementById("test_div").clientWidth;
} 
if(document.getElementById("test_div").clientWidth!==width) {   
  alert('resized');
  width = document.getElementById("test_div").clientWidth;
}    

}, 100);
return interval;
}
var interval = myInterval();
document.getElementById("clickMe").addEventListener( "click" , function() {
if(typeof interval!=="undefined") {
clearInterval(interval);
alert("stopped div-resize sniffing");
}
});
document.getElementById("clickMeToo").addEventListener( "click" , function() {
myInterval();
alert("started div-resize sniffing");
});
<div id="test_div" style="width: 100%; min-height: 30px; border: 1px dashed pink;">
        <input type="button" value="button 1" id="clickMe" />
        <input type="button" value="button 2" id="clickMeToo" />
        <input type="button" value="button 3" />
</div>

更新小提琴

这几乎是最佳答案的精确副本,但它不是链接,而只是重要的代码部分,翻译为IMO更易读和理解。其他一些小的变化包括使用cloneNode(),而不是将html放入js字符串中。小东西,但是您可以按原样复制并粘贴它,它将起作用。

它的工作方式是通过使两个不可见的div填充您正在观看的元素,然后在每个div中放置一个触发器,并设置一个滚动位置,该滚动位置将在大小改变时触发滚动更改。

真正的功劳归功于Marc J,但是,如果您只是在寻找相关的代码,这里是:

    window.El = {}

    El.resizeSensorNode = undefined;
    El.initResizeNode = function() {
        var fillParent = "display: block; position: absolute; left: 0; top: 0; right: 0; bottom: 0; overflow: hidden; z-index: -1; visibility: hidden;";
        var triggerStyle = "position: absolute; left: 0; top: 0; transition: 0s;";

        var resizeSensor = El.resizeSensorNode = document.createElement("resizeSensor");
        resizeSensor.style = fillParent;

        var expandSensor = document.createElement("div");
        expandSensor.style = fillParent;
        resizeSensor.appendChild(expandSensor);

        var trigger = document.createElement("div");
        trigger.style = triggerStyle;
        expandSensor.appendChild(trigger);

        var shrinkSensor = expandSensor.cloneNode(true);
        shrinkSensor.firstChild.style = triggerStyle + " width: 200%; height: 200%";
        resizeSensor.appendChild(shrinkSensor);
    }


    El.onSizeChange = function(domNode, fn) {
        if (!domNode) return;
        if (domNode.resizeListeners) {
            domNode.resizeListeners.push(fn);
            return;
        }

        domNode.resizeListeners = [];
        domNode.resizeListeners.push(fn);

        if(El.resizeSensorNode == undefined)
            El.initResizeNode();

        domNode.resizeSensor = El.resizeSensorNode.cloneNode(true);
        domNode.appendChild(domNode.resizeSensor);

        var expand = domNode.resizeSensor.firstChild;
        var expandTrigger = expand.firstChild;
        var shrink = domNode.resizeSensor.childNodes[1];

        var reset = function() {
            expandTrigger.style.width = '100000px';
            expandTrigger.style.height = '100000px';

            expand.scrollLeft = 100000;
            expand.scrollTop = 100000;

            shrink.scrollLeft = 100000;
            shrink.scrollTop = 100000;
        };

        reset();

        var hasChanged, frameRequest, newWidth, newHeight;
        var lastWidth = domNode.offsetWidth;
        var lastHeight = domNode.offsetHeight;


        var onResized = function() {
            frameRequest = undefined;

            if (!hasChanged) return;

            lastWidth = newWidth;
            lastHeight = newHeight;

            var listeners = domNode.resizeListeners;
            for(var i = 0; listeners && i < listeners.length; i++) 
                listeners[i]();
        };

        var onScroll = function() {
            newWidth = domNode.offsetWidth;
            newHeight = domNode.offsetHeight;
            hasChanged = newWidth != lastWidth || newHeight != lastHeight;

            if (hasChanged && !frameRequest) {
                frameRequest = requestAnimationFrame(onResized);
            }

            reset();
        };


        expand.addEventListener("scroll", onScroll);
        shrink.addEventListener("scroll", onScroll);
    }

这是@nkron解决方案的简化版本,适用于单个元素(而不是@nkron答案中的元素数组,我不需要复杂性)。

function onResizeElem(element, callback) {    
  // Save the element we are watching
  onResizeElem.watchedElementData = {
    element: element,
    offsetWidth: element.offsetWidth,
    offsetHeight: element.offsetHeight,
    callback: callback
  };

  onResizeElem.checkForChanges = function() {
    const data = onResizeElem.watchedElementData;
    if (data.element.offsetWidth !== data.offsetWidth || data.element.offsetHeight !== data.offsetHeight) {
      data.offsetWidth = data.element.offsetWidth;
      data.offsetHeight = data.element.offsetHeight;
      data.callback();
    }
  };

  // Listen to the window resize event
  window.addEventListener('resize', onResizeElem.checkForChanges);

  // Listen to the element being checked for width and height changes
  onResizeElem.observer = new MutationObserver(onResizeElem.checkForChanges);
  onResizeElem.observer.observe(document.body, {
    attributes: true,
    childList: true,
    characterData: true,
    subtree: true
  });
}

事件侦听器和观察者可以通过以下方式删除:

window.removeEventListener('resize', onResizeElem.checkForChanges);
onResizeElem.observer.disconnect();

纯Javascript解决方案,但仅在使用css resize按钮调整元素大小时才有效

  1. 使用offsetWidthoffsetHeight存储元素大小
  2. 在此元素上添加onclick事件侦听器;
  3. 触发后,比较当前offsetWidthoffsetHeight存储的值,如果不同,则执行所需操作并更新这些值。
jQuery(document).ready( function($) {

function resizeMapDIVs() {

// check the parent value...

var size = $('#map').parent().width();



if( $size < 640 ) {

//  ...and decrease...

} else {

//  ..or increase  as necessary

}

}

resizeMapDIVs();

$(window).resize(resizeMapDIVs);

});

使用Bharat Patil答案,只需在绑定回调中返回false即可防止最大堆栈错误,请参见以下示例:

$('#test_div').bind('resize', function(){
   console.log('resized');
   return false;
});

这是一个非常老的问题,但我认为我会发布解决方案。

我尝试使用它,ResizeSensor因为每个人似乎对此都有很大的迷恋。不过,实施之后,我意识到在元素查询的幕后,要求有问题的元素具有位置relativeabsolute应用到,这对我的情况不起作用。

我最终使用Rxjsinterval代替了以前的实现setTimeoutrequestAnimationFrame类似的实现来处理这个问题

间隔的可观察风格的好处是您可以修改流,但是可以处理其他任何可观察的事物。对我来说,一个基本的实现就足够了,但是您可能会发疯并进行各种合并等。

在下面的示例中,我正在跟踪内部(绿色)div的宽度变化。它的宽度设置为50%,但最大宽度为200px。拖动滑块会影响包装器(灰色)div的宽度。您可以看到,只有当内部div的宽度发生变化时,可观察对象才会触发,只有当外部div的宽度小于400px时才会发生。

const { interval } = rxjs;
const { distinctUntilChanged, map, filter } = rxjs.operators;


const wrapper = document.getElementById('my-wrapper');
const input = document.getElementById('width-input');




function subscribeToResize() {
  const timer = interval(100);
  const myDiv = document.getElementById('my-div');
  const widthElement = document.getElementById('width');
  const isMax = document.getElementById('is-max');
  
  /*
    NOTE: This is the important bit here 
  */
  timer
    .pipe(
      map(() => myDiv ? Math.round(myDiv.getBoundingClientRect().width) : 0),
      distinctUntilChanged(),
      // adding a takeUntil(), here as well would allow cleanup when the component is destroyed
    )
      .subscribe((width) => {        
        widthElement.innerHTML = width;
        isMax.innerHTML = width === 200 ? 'Max width' : '50% width';

      });
}

function defineRange() {
  input.min = 200;
  input.max = window.innerWidth;
  input.step = 10;
  input.value = input.max - 50;
}

function bindInputToWrapper() {
  input.addEventListener('input', (event) => {
    wrapper.style.width = `${event.target.value}px`;
  });
}

defineRange();
subscribeToResize();
bindInputToWrapper();
.inner {
  width: 50%;
  max-width: 200px;
}




/* Aesthetic styles only */

.inner {
  background: #16a085;
}

.wrapper {
  background: #ecf0f1;
  color: white;
  margin-top: 24px;
}

.content {
  padding: 12px;
}

body {
  
  font-family: sans-serif;
  font-weight: bold;
}
<script src="https://unpkg.com/rxjs/bundles/rxjs.umd.min.js"></script>

<h1>Resize Browser width</h1>

<label for="width-input">Adjust the width of the wrapper element</label>
<div>
  <input type="range" id="width-input">
</div>

<div id="my-wrapper" class="wrapper">
  <div id="my-div" class="inner">
    <div class="content">
      Width: <span id="width"></span>px
      <div id="is-max"></div>  
    </div>
  </div>
</div>

Window.onResize存在于规范,但你总是可以利用IFrame来产生新Window的DIV中的对象。

请检查此答案有一个新的小jquery插件,可移植且易于使用。您始终可以检查源代码以了解其完成方式。

<!-- (1) include plugin script in a page -->
<script src="/src/jquery-element-onresize.js"></script>

// (2) use the detectResizing plugin to monitor changes to the element's size:
$monitoredElement.detectResizing({ onResize: monitoredElement_onResize });

// (3) write a function to react on changes:
function monitoredElement_onResize() {    
    // logic here...
}

我以为无法完成,但后来我想到了,您可以通过style =“ resize:both;”手动调整div的大小。为了做到这一点,您必须单击它,因此添加了一个onclick函数来检查元素的高度和宽度,并且它起作用了。仅使用5行纯JavaScript(确保它可能更短)
http://codepen.io/anon/pen/eNyyVN

<div id="box" style="
                height:200px; 
                width:640px;
                background-color:#FF0066;
                resize: both;
                overflow: auto;" 
                onclick="myFunction()">
    <p id="sizeTXT" style="
                font-size: 50px;">
       WxH
    </p>
    </div>

<p>This my example demonstrates how to run a resize check on click for resizable div.</p>

<p>Try to resize the box.</p>


<script>
function myFunction() {
var boxheight = document.getElementById('box').offsetHeight;
var boxhwidth = document.getElementById('box').offsetWidth;
var txt = boxhwidth +"x"+boxheight;
document.getElementById("sizeTXT").innerHTML = txt;
}
</script>
本文地址:http://javascript.askforanswer.com/ruhejiancedivdechicunbianhua.html
文章标签: ,   ,  
版权声明:本文为原创文章,版权归 javascript 所有,欢迎分享本文,转载请保留出处!

文件下载

老薛主机终身7折优惠码boke112

上一篇:
下一篇:

评论已关闭!