evento JavaScript janela de redimensionamento

Question

Como posso ligar para um evento navegador janela de redimensionamento?

Há uma maneira jQuery de ouvir para redimensionar eventos mas eu prefere não colocá-lo em meu projeto para apenas esta exigência um.

Answer 1

jQuery é apenas envolvendo o evento resize DOM padrão, por exemplo.

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

jQuery pode fazer algum trabalho para garantir que o evento de redimensionamento é demitido de forma consistente em todos os navegadores, mas eu não tenho certeza se qualquer um dos navegadores diferentes, mas eu encorajá-lo a teste em Firefox, Safari e IE.

Answer 2

Nunca substituir a função window.onresize.

Em vez disso, crie uma função para adicionar um ouvinte de eventos para o objeto ou elemento. Isto verifica e meter os ouvintes não funcionam, então ela substitui a função do objeto como um último recurso. Este é o método preferido utilizado em bibliotecas, tais como jQuery.

object: o elemento ou janela objeto
type: redimensionamento, rolagem (tipo de evento)
callback: a referência de função

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;
    }
};

uso Então é assim:

addEvent(window, "resize", function_reference);

ou com uma função anônima:

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

Answer 3

Em primeiro lugar, eu sei que o método addEventListener foi mencionado nos comentários acima, mas eu não vi qualquer código. Uma vez que é a abordagem preferida, aqui está:

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

Aqui está uma amostra de trabalho.

Answer 4

O evento de redimensionamento nunca deve ser usado diretamente como ela é disparado continuamente à medida que redimensionar.

Use uma função debounce para mitigar as chamadas em excesso.

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

Aqui está um debounce comum flutuando em torno da rede, apesar de fazer olhar para os mais avançados como featuerd em lodash.

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);
    };
};

Isso pode ser usado assim ...

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

Isso nunca vai disparar mais de uma vez a cada 200ms.

Para mudanças de orientação móveis usam:

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

Aqui está um pequena biblioteca eu juntos para cuidar do presente ordenadamente.

Answer 5

Eu acredito que a resposta correta já foi fornecido pelo @Alex V, mas a resposta requer alguma modernização, pois é mais de cinco anos de idade agora.

Existem duas questões principais:

1. Nunca uso object como um nome de parâmetro. É uma palavra reservered. Com isto dito, a função fornecida @Alex V não funcionará no strict mode.

2. A função addEvent fornecida por @Alex V não voltar a event object se o método addEventListener é usado. Outro parâmetro deve ser adicionado à função addEvent para permitir isso.

NOTA: O novo parâmetro para addEvent foi tornado facultativo para que a migração para esta nova versão da função não vai quebrar todas as chamadas anteriores para esta função. será apoiado todos os usos antigos.

Aqui é a função addEvent atualizada com essas alterações:

/*
    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;
};

Um exemplo chamada para a nova função 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

Obrigado por fazer referência a meu blog em http :. //mbccs.blogspot.com/2007/11/fixing-window-resize-event-in-ie.html

Enquanto você pode simplesmente ligar para o evento janela de redimensionamento padrão, você verá que no IE, o evento é acionado uma vez para cada X e uma vez para cada eixo Y movimento, resultando em uma tonelada de eventos de ser demitido o que pode ter um impacto no desempenho em seu site se render é uma tarefa intensiva.

O meu método envolve um curto tempo limite que é cancelado em eventos subsequentes para que o evento não se borbulhava ao seu código até que o usuário tenha terminado o redimensionamento da janela.

Answer 7

Solução para 2018 +:

Você deve usar ResizeObserver . Será uma solução navegador nativo que tem um desempenho muito melhor do que usar o evento resize. Além disso, ele não só apoia o evento no document mas também sobre elements arbitrária.

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);

Atualmente, apenas Chrome suporta-lo, mas outros navegadores provavelmente vai seguir (em breve). Por agora você tem que usar um polyfill .

Answer 8

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

Answer 9

O seguinte post pode ser útil para você: fixação do evento janela de redimensionamento no IE

Ele fornece este código:

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

As soluções já mencionadas acima vai funcionar se tudo que você quer fazer é redimensionar a janela ea janela única. No entanto, se você quiser ter o redimensionamento propagadas para os elementos filho, você vai precisar para propagar o evento sozinho. Aqui está um código de exemplo para fazê-lo:

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);
});

Note-se que um elemento filho pode chamar

 event.preventDefault();

no objeto de evento que é passado como o primeiro argumento do evento de redimensionamento. Por exemplo:

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>