Como detectar o nível de zoom da página em todos os navegadores modernos?

  1. Como posso detectar o nível de zoom da página em todos os navegadores modernos? Enquanto esta discussão informa como fazer isso no IE7 e no IE8, não consigo encontrar uma boa solução entre navegadores.

  2. O Firefox armazena o nível de zoom da página para access futuro. No primeiro carregamento da página, eu conseguiria obter o nível de zoom? Em algum lugar que eu li, funciona quando ocorre uma mudança de zoom após a página ser carregada.

  3. Existe uma maneira de interceptar o evento 'zoom' ?

Eu preciso disso porque alguns dos meus cálculos são baseados em pixels e eles podem flutuar quando ampliados.


Amostra modificada dada por @tfl

Esta página alerta diferentes valores de altura quando ampliada. [jsfiddle]

      
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque sollicitudin tortor in lacus tincidunt volutpat. Integer dignissim imperdiet mollis. Suspendisse quis tortor velit, placerat tempor neque. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Praesent bibendum auctor lorem vitae tempor. Nullam condimentum aliquam elementum. Nullam egestas gravida elementum. Maecenas mattis molestie nisl sit amet vehicula. Donec semper tristique blandit. Vestibulum adipiscing placerat mollis.

    Agora é uma bagunça ainda maior do que quando esta pergunta foi feita pela primeira vez. A partir da leitura de todas as respostas e posts que pude encontrar, aqui está um resumo. Eu também configuro esta página para testar todos esses methods de medição do nível de zoom .

    Editar (2011-12-12): Eu adicionei um projeto que pode ser clonado: https://github.com/tombigel/detect-zoom

    • IE8 : screen.deviceXDPI / screen.logicalXDPI (ou, para o nível de zoom relativo ao zoom padrão, screen.systemXDPI / screen.logicalXDPI )
    • IE7 : var body = document.body,r = body.getBoundingClientRect(); return (r.left-r.right)/body.offsetWidth; var body = document.body,r = body.getBoundingClientRect(); return (r.left-r.right)/body.offsetWidth; (graças a este exemplo ou a esta resposta )
    • FF3.5 SOMENTE : largura de canvas da largura de canvas / largura de canvas da mídia (veja abaixo) (aproveita o fato de que screen.width usa pixels de dispositivo, mas a largura do MQ usa pixels CSS – graças às larguras de Quirksmode )
    • FF3.6 : nenhum método conhecido
    • FF4 + : pesquisa binária de consultas de mídia (veja abaixo)
    • WebKit : https://www.chromestatus.com/feature/5737866978131968 (agradecimentos a Teo nos comentários)
    • WebKit : meça o tamanho preferido de uma div com -webkit-text-size-adjust:none .
    • WebKit : (quebrado desde r72591 ) document.width / jQuery(document).width() (graças a Dirk van Oosterbosch acima ). Para obter a proporção em termos de pixels do dispositivo (em vez de em relação ao zoom padrão), multiplique por window.devicePixelRatio .
    • WebKit antigo? (não verificado): parseInt(getComputedStyle(document.documentElement,null).width) / document.documentElement.clientWidth ( desta resposta )
    • Opera : document.documentElement.offsetWidth / width de uma position:fixed; width:100% position:fixed; width:100% div. daqui ( a tabela de larguras do Quirksmode diz que é um erro; innerWidth deve ser CSS px). Usamos a posição: fixed element para obter a largura da viewport, incluindo o espaço onde as barras de rolagem estão ; document.documentElement.clientWidth exclui essa largura. Isso está quebrado desde algum dia em 2011; Eu não sei mais como obter o nível de zoom no Opera.
    • Outro : solução Flash de Sebastian
    • Não confiável: ouça os events do mouse e meça a mudança na screenX / change no clientX

    Aqui está uma pesquisa binária para o Firefox 4, já que não conheço nenhuma variável onde ela é exposta:

      
    Dummy element to test media queries.

    Para mim, para o Chrome / Webkit, document.width / jQuery(document).width() não funcionou. Quando tornei minha janela pequena e document.width / jQuery(document).width() meu site de forma que as barras de rolagem horizontais aparecessem, document.width / jQuery(document).width() não era igual a 1 no zoom padrão. Isso ocorre porque document.width inclui parte do documento fora da viewport.

    Usando window.innerWidth e window.outerWidth funcionou. Por algum motivo, no Chrome, outerWidth é medido em pixels de canvas e innerWidth é medido em pixels css.

     var screenCssPixelRatio = (window.outerWidth - 8) / window.innerWidth; if (screenCssPixelRatio >= .46 && screenCssPixelRatio <= .54) { zoomLevel = "-4"; } else if (screenCssPixelRatio <= .64) { zoomLevel = "-3"; } else if (screenCssPixelRatio <= .76) { zoomLevel = "-2"; } else if (screenCssPixelRatio <= .92) { zoomLevel = "-1"; } else if (screenCssPixelRatio <= 1.10) { zoomLevel = "0"; } else if (screenCssPixelRatio <= 1.32) { zoomLevel = "1"; } else if (screenCssPixelRatio <= 1.58) { zoomLevel = "2"; } else if (screenCssPixelRatio <= 1.90) { zoomLevel = "3"; } else if (screenCssPixelRatio <= 2.28) { zoomLevel = "4"; } else if (screenCssPixelRatio <= 2.70) { zoomLevel = "5"; } else { zoomLevel = "unknown"; } 

    Podes tentar

     var browserZoomLevel = Math.round(window.devicePixelRatio * 100); 

    Isso fornecerá o nível percentual de zoom do navegador.

    Para pegar o evento de zoom, você pode usar

     $(window).resize(function() { // your code }); 

    Meu colega de trabalho e eu usamos o script em https://github.com/tombigel/detect-zoom . Além disso, também criamos dinamicamente um elemento svg e verificamos sua propriedade currentScale. Funciona muito bem no Chrome e provavelmente na maioria dos navegadores também. No FF, o recurso “somente texto com zoom” deve ser desativado. O SVG é suportado na maioria dos navegadores. No momento da redação deste artigo, testado no IE10, FF19 e ​​Chrome28.

     var svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg'); svg.setAttribute('xmlns', 'http://www.w3.org/2000/svg'); svg.setAttribute('version', '1.1'); document.body.appendChild(svg); var z = svg.currentScale; ... more code ... document.body.removeChild(svg); 

    Eu achei este artigo muito útil. Muito obrigado a yonran. Eu queria passar algum aprendizado adicional que encontrei durante a implementação de algumas das técnicas que ele forneceu. No FF6 e no Chrome 9, foi adicionado suporte para consultas de mídia do JS, o que pode simplificar bastante a abordagem de consulta de mídia necessária para determinar o zoom no FF. Veja os documentos no MDN aqui . Para os meus propósitos, eu só precisava detectar se o navegador estava ampliado ou não, não tinha necessidade do fator de zoom real. Consegui obter minha resposta com uma linha de JavaScript:

     var isZoomed = window.matchMedia('(max--moz-device-pixel-ratio:0.99), (min--moz-device-pixel-ratio:1.01)').matches; 

    Combinando isso com as soluções IE8 + e Webkit, que também eram linhas únicas, consegui detectar o zoom na grande maioria dos navegadores que acessam nosso aplicativo com apenas algumas linhas de código.

     zoom = ( window.outerWidth - 10 ) / window.innerWidth 

    Isso é tudo que você precisa.

    No Internet Explorer 7, 8 e 9, isso funciona:

     function getZoom() { var screen; screen = document.frames.screen; return ((screen.deviceXDPI / screen.systemXDPI) * 100 + 0.9).toFixed(); } 

    O “+0.9” é adicionado para evitar erros de arredondamento (caso contrário, você obteria 104% e 109% quando o zoom do navegador estiver definido como 105% e 110%, respectivamente).

    No IE6, o zoom não existe, portanto, não é necessário verificar o zoom.

    Isso funcionou muito bem para mim em navegadores baseados em webkit (Chrome, Safari):

     function isZoomed() { var width, mediaQuery; width = document.body.clientWidth; mediaQuery = '(max-width: ' + width + 'px) and (min-width: ' + width + 'px)'; return !window.matchMedia(mediaQuery).matches; } 

    Parece não funcionar no Firefox embora.

    Isso também funciona no WebKit:

     var zoomLevel = document.width / document.body.clientWidth; 

    Eu tenho uma solução para isso a partir de janeiro de 2016. Testado trabalhando nos navegadores Chrome, Firefox e MS Edge.

    O princípio é o seguinte. Colete 2 pontos MouseEvent que estão distantes. Cada evento de mouse é fornecido com coordenadas de canvas e documento. Meça a distância entre os 2 pontos em ambos os sistemas de coordenadas. Embora haja deslocamentos fixos variables ​​entre os sistemas de coordenadas devido à mobília do navegador, a distância entre os pontos deve ser idêntica se a página não for ampliada. A razão para especificar “far apart” (coloquei isso como 12 pixels) é para que pequenas mudanças de zoom (por exemplo, 90% ou 110%) sejam detectáveis.

    Referência: https://developer.mozilla.org/en/docs/Web/Events/mousemove

    Passos:

    1. Adicionar um ouvinte de movimento do mouse

       window.addEventListener("mousemove", function(event) { // handle event }); 
    2. Capture 4 medições de events de mouse:

       event.clientX, event.clientY, event.screenX, event.screenY 
    3. Meça a distância d_c entre os 2 pontos no sistema do cliente

    4. Meça a distância d_s entre os 2 pontos no sistema de canvas

    5. Se d_c! = D_s, o zoom é aplicado. A diferença entre os dois indica a quantidade de zoom.

    Nota: Faça os cálculos de distâncias raramente, por exemplo, quando você pode experimentar um novo evento de mouse que esteja longe do anterior.

    Limitações: Assume que o usuário moverá o mouse pelo menos um pouco e o zoom ficará incognoscível até esse momento.

    O que eu descobri é:

    1) Faça uma position:fixed

    com width:100% ( id = zoomdiv )

    2) quando a página é carregada:

     zoomlevel=$("#zoomdiv").width()*1.0 / screen.availWidth 

    E funcionou para mim para ctrl+ e ctrl+ zooms.

    ou posso adicionar a linha a um evento $(window).onresize() para obter o nível de zoom ativo


    Código:

       

    PS: este é o meu primeiro post, perdoem quaisquer erros

    Seus cálculos ainda são baseados em vários pixels CSS. Eles são apenas um tamanho diferente na canvas agora. Esse é o ponto de zoom de página inteira.

    O que você gostaria que acontecesse em um navegador em um dispositivo de 192dpi que, portanto, normalmente exibia quatro pixels de dispositivo para cada pixel em uma imagem? Com zoom de 50%, este dispositivo agora exibe um pixel de imagem em um pixel de dispositivo.

    Não testei isso para o IE, mas se você fizer um elemento elem com

     min-width: 100% 

    então

     window.document.width / elem.clientWidth 

    lhe dará o nível de zoom do seu navegador (incluindo o fator document.body.style.zoom ).

    Isto é para o Chrome , na sequência da resposta user800583

    Passei algumas horas sobre este problema e não encontrei uma abordagem melhor, mas:

    • Existem 16 ‘zoomLevel’ e não 10
    • Quando o Chrome está em canvas window.outerWidth/window.innerWidth / maximizado, a proporção é window.outerWidth/window.innerWidth , e quando não é, a proporção parece ser (window.outerWidth-16)/window.innerWidth , no entanto, o primeiro caso pode ser abordado até o segundo. 1.

    Então eu vim para o seguinte …

    Mas essa abordagem tem limitações: por exemplo, se você tocar o acordeão com a janela do aplicativo (aumentar rapidamente e reduzir a largura da janela), obterá intervalos entre os níveis de zoom, embora o zoom não tenha mudado (pode ser outerWidth e innerWidth não exatamente atualizado no mesmo tempo).

     var snap = function (r, snaps) { var i; for (i=0; i < 16; i++) { if ( r < snaps[i] ) return i; } }; var w, l, r; w = window.outerWidth, l = window.innerWidth; return snap((w - 16) / l, [ 0.29, 0.42, 0.58, 0.71, 0.83, 0.95, 1.05, 1.18, 1.38, 1.63, 1.88, 2.25, 2.75, 3.5, 4.5, 100 ], ); 

    E se você quiser o fator:

     var snap = function (r, snaps, ratios) { var i; for (i=0; i < 16; i++) { if ( r < snaps[i] ) return eval(ratios[i]); } }; var w, l, r; w = window.outerWidth, l = window.innerWidth; return snap((w - 16) / l, [ 0.29, 0.42, 0.58, 0.71, 0.83, 0.95, 1.05, 1.18, 1.38, 1.63, 1.88, 2.25, 2.75, 3.5, 4.5, 100 ], [ 0.25, '1/3', 0.5, '2/3', 0.75, 0.9, 1, 1.1, 1.25, 1.5, 1.75, 2, 2.5, 3, 4, 5 ] ); 

    Eu tenho esta solução apenas para celular (testado com Android):

     jQuery(function($){ zoom_level = function(){ $("body").prepend('
    '); var ratio = $("body .overlay:eq(0)").outerWidth() / $(window).width(); $("body .overlay:eq(0)").remove(); return ratio; } alert(zoom_level()); });

    Se você quiser o nível de zoom logo após o movimento de pinça, provavelmente terá que definir um pouco de tempo limite devido ao atraso de renderização (mas não tenho certeza porque não testei).

     function supportFullCss3() { var div = document.createElement("div"); div.style.display = 'flex'; var s1 = div.style.display == 'flex'; var s2 = 'perspective' in div.style; return (s1 && s2); }; function getZoomLevel() { var screenPixelRatio = 0, zoomLevel = 0; if(window.devicePixelRatio && supportFullCss3()) screenPixelRatio = window.devicePixelRatio; else if(window.screenX == '0') screenPixelRatio = (window.outerWidth - 8) / window.innerWidth; else { var scr = window.frames.screen; screenPixelRatio = scr.deviceXDPI / scr.systemXDPI; } //--------------------------------------- if (screenPixelRatio <= .11){ //screenPixelRatio >= .01 && zoomLevel = "-7"; } else if (screenPixelRatio <= .25) { zoomLevel = "-6"; }else if (screenPixelRatio <= .33) { zoomLevel = "-5.5"; } else if (screenPixelRatio <= .40) { zoomLevel = "-5"; } else if (screenPixelRatio <= .50) { zoomLevel = "-4"; } else if (screenPixelRatio <= .67) { zoomLevel = "-3"; } else if (screenPixelRatio <= .75) { zoomLevel = "-2"; } else if (screenPixelRatio <= .85) { zoomLevel = "-1.5"; } else if (screenPixelRatio <= .98) { zoomLevel = "-1"; } else if (screenPixelRatio <= 1.03) { zoomLevel = "0"; } else if (screenPixelRatio <= 1.12) { zoomLevel = "1"; } else if (screenPixelRatio <= 1.2) { zoomLevel = "1.5"; } else if (screenPixelRatio <= 1.3) { zoomLevel = "2"; } else if (screenPixelRatio <= 1.4) { zoomLevel = "2.5"; } else if (screenPixelRatio <= 1.5) { zoomLevel = "3"; } else if (screenPixelRatio <= 1.6) { zoomLevel = "3.3"; } else if (screenPixelRatio <= 1.7) { zoomLevel = "3.7"; } else if (screenPixelRatio <= 1.8) { zoomLevel = "4"; } else if (screenPixelRatio <= 1.9) { zoomLevel = "4.5"; } else if (screenPixelRatio <= 2) { zoomLevel = "5"; } else if (screenPixelRatio <= 2.1) { zoomLevel = "5.2"; } else if (screenPixelRatio <= 2.2) { zoomLevel = "5.4"; } else if (screenPixelRatio <= 2.3) { zoomLevel = "5.6"; } else if (screenPixelRatio <= 2.4) { zoomLevel = "5.8"; } else if (screenPixelRatio <= 2.5) { zoomLevel = "6"; } else if (screenPixelRatio <= 2.6) { zoomLevel = "6.2"; } else if (screenPixelRatio <= 2.7) { zoomLevel = "6.4"; } else if (screenPixelRatio <= 2.8) { zoomLevel = "6.6"; } else if (screenPixelRatio <= 2.9) { zoomLevel = "6.8"; } else if (screenPixelRatio <= 3) { zoomLevel = "7"; } else if (screenPixelRatio <= 3.1) { zoomLevel = "7.1"; } else if (screenPixelRatio <= 3.2) { zoomLevel = "7.2"; } else if (screenPixelRatio <= 3.3) { zoomLevel = "7.3"; } else if (screenPixelRatio <= 3.4) { zoomLevel = "7.4"; } else if (screenPixelRatio <= 3.5) { zoomLevel = "7.5"; } else if (screenPixelRatio <= 3.6) { zoomLevel = "7.6"; } else if (screenPixelRatio <= 3.7) { zoomLevel = "7.7"; } else if (screenPixelRatio <= 3.8) { zoomLevel = "7.8"; } else if (screenPixelRatio <= 3.9) { zoomLevel = "7.9"; } else if (screenPixelRatio <= 4) { zoomLevel = "8"; } else if (screenPixelRatio <= 4.1) { zoomLevel = "8.1"; } else if (screenPixelRatio <= 4.2) { zoomLevel = "8.2"; } else if (screenPixelRatio <= 4.3) { zoomLevel = "8.3"; } else if (screenPixelRatio <= 4.4) { zoomLevel = "8.4"; } else if (screenPixelRatio <= 4.5) { zoomLevel = "8.5"; } else if (screenPixelRatio <= 4.6) { zoomLevel = "8.6"; } else if (screenPixelRatio <= 4.7) { zoomLevel = "8.7"; } else if (screenPixelRatio <= 4.8) { zoomLevel = "8.8"; } else if (screenPixelRatio <= 4.9) { zoomLevel = "8.9"; } else if (screenPixelRatio <= 5) { zoomLevel = "9"; }else { zoomLevel = "unknown"; } return zoomLevel; }; 

    Basicamente, nós temos:

    • window.devicePixelRatio que leva em conta tanto o zoom no nível do navegador * quanto o zoom do sistema / densidade de pixels.
      * – no nível de zoom Mac / Safari não é levado em conta
    • consultas de mídia
    • unidades de CSS vw / vh
    • resize evento de resize , que é acionado na alteração do nível de zoom, causa o tamanho efetivo das alterações na janela

    isso deve ser suficiente para o UX normal . Se você precisar detectar o nível de zoom que pode ser um sinal de mau design da interface do usuário.

    Pitch-zoom é mais difícil de rastrear e não é considerado atualmente.

    Esta resposta é baseada em comentários sobre devicePixelRatio voltando incorretamente na resposta de user1080381.

    Descobri que esse comando estava voltando incorretamente em alguns casos também ao trabalhar com um desktop, Surface Pro 3 e Surface Pro 4.

    O que eu descobri é que funcionou na minha área de trabalho, mas o SP3 e o SP4 estavam dando números diferentes uns dos outros e da área de trabalho.

    Eu notei que o SP3 estava voltando com uma vez e meia o nível de zoom que eu esperava. Quando dei uma olhada nas configurações de exibição, o SP3 foi realmente definido como 150%, em vez dos 100% que eu tinha em minha área de trabalho.

    Assim, a solução para os comentários deve ser dividir o nível de zoom retornado pela escala da máquina em que você está atualmente.

    Consegui obter a escala nas configurações do Windows fazendo o seguinte:

     ManagementObjectSearcher searcher = new ManagementObjectSearcher("SELECT * FROM Win32_DesktopMonitor"); double deviceScale = Convert.ToDouble(searcher.Get().OfType().FirstOrDefault()["PixelsPerXLogicalInch"]); int standardPixelPerInch = 96; return deviceScale / standardPixelPerInch; 

    Então, no caso do meu SP3, é assim que esse código parece com zoom de 100%:

     devicePixelRatio = 1.5 deviceScale = 144 deviceScale / standardPixelPerInch = 1.5 devicePixelRatio / (deviceScale / standardPixelPerInch) = 1 

    Multiplicando pelo 100 na resposta original do user1080381, você terá um zoom de 100 (%).

    O problema está nos tipos de monitor utilizados, um monitor de 4k vs monitor padrão. O Chrome é de longe o mais inteligente em ser capaz de nos dizer qual é o nível de zoom apenas usando window.devicePixelRatio , aparentemente ele pode dizer qual é a densidade de pixels e reportar o mesmo número para importar o quê.

    Outros navegadores, não tanto. IE e Edge são provavelmente os piores, já que lidam com os níveis de zoom de forma muito diferente. Para obter o mesmo tamanho de texto em um monitor de 4k, você precisa selecionar 200%, em vez de 100% em um monitor padrão.

    A partir de maio de 2018, aqui está o que tenho para detectar os níveis de zoom para alguns dos navegadores mais populares, Chrome, Firefox e IE11. Eu tenho que me dizer qual é a porcentagem de zoom. Para o IE, ele informa 100%, mesmo para monitores de 4k, que na verdade são de 200%, mas o tamanho do texto é realmente o mesmo.

    Aqui está um violino: https://jsfiddle.net/ae1hdogr/

    Se alguém quiser dar uma olhada em outros navegadores e atualizar o violino, faça isso. Meu objective principal era cobrir esses três navegadores para detectar se as pessoas estavam usando um fator de zoom maior que 100% para usar meu aplicativo da web e exibir um aviso sugerindo um fator de zoom do lessor.

    Em dispositivos móveis (com o Chrome para Android ou Opera Mobile), você pode detectar o zoom por window.visualViewport.scale . https://developer.mozilla.org/pt-BR/docs/Web/API/Visual_Viewport_API

    Detectar no Safari: document.documentElement.clientWidth / window.innerWidth (retorne 1 se não houver zoom no dispositivo).

    aqui não muda !:

          
    foobar

    criar um arquivo html simples, clique no botão. independentemente do nível de zoom: ele mostrará a largura de 400px (pelo menos com o firefox e ie8)

    Isso pode ou não ajudar alguém, mas eu tinha uma página que eu não conseguia centralizar corretamente, não importa quais truques CSS eu tentei, então eu escrevi uma página de centro de chamada de arquivo JQuery:

    O problema ocorreu com o nível de zoom do navegador, a página mudaria com base em se você fosse 100%, 125%, 150%, etc.

    O código abaixo está em um arquivo JQuery chamado centerpage.js.

    Da minha página eu tive que ligar ao JQuery e este arquivo para fazê-lo funcionar, mesmo que a minha página mestra já tivesse um link para o JQuery.

     Home Page.   

    centerpage.js :

     // centering page element function centerPage() { // get body element var body = document.body; // if the body element exists if (body != null) { // get the clientWidth var clientWidth = body.clientWidth; // request data for centering var windowWidth = document.documentElement.clientWidth; var left = (windowWidth - bodyWidth) / 2; // this is a hack, but it works for me a better method is to determine the // scale but for now it works for my needs if (left > 84) { // the zoom level is most likely around 150 or higher $('#MainBody').removeClass('body').addClass('body150'); } else if (left < 100) { // the zoom level is most likely around 110 - 140 $('#MainBody').removeClass('body').addClass('body125'); } } } // CONTROLLING EVENTS IN jQuery $(document).ready(function() { // center the page centerPage(); }); 

    Além disso, se você quiser centralizar um painel:

     // centering panel function centerPanel($panelControl) { // if the panel control exists if ($panelControl && $panelControl.length) { // request data for centering var windowWidth = document.documentElement.clientWidth; var windowHeight = document.documentElement.clientHeight; var panelHeight = $panelControl.height(); var panelWidth = $panelControl.width(); // centering $panelControl.css({ 'position': 'absolute', 'top': (windowHeight - panelHeight) / 2, 'left': (windowWidth - panelWidth) / 2 }); // only need force for IE6 $('#backgroundPanel').css('height', windowHeight); } } 

    Esta é uma pergunta que foi postada como as idades de volta, mas hoje, quando eu estava procurando a mesma resposta “Como detectar o zoom in e out evento”, eu não consegui encontrar uma resposta que caberia todos os navegadores.

    Como agora: para o Firefox / Chrome / IE8 e IE9, o zoom in e out aciona um evento window.resize. Isso pode ser capturado usando:

     $(window).resize(function() { //YOUR CODE. }); 

    Uma solução alternativa para o FireFox 16+ para encontrar o DPPX (nível de zoom) puramente com JavaScript:

     var dppx = (function (precision) { var searchDPPX = function(level, min, divisor) { var wmq = window.matchMedia; while (level >= min && !wmq("(min-resolution: " + (level/divisor) + "dppx)").matches) { level--; } return level; }; var maxDPPX = 5.0; // Firefox 22 has 3.0 as maximum, but testing a bit greater values does not cost much var minDPPX = 0.1; // Firefox 22 has 0.3 as minimum, but testing a bit smaller values does not cost anything var divisor = 1; var result; for (var i = 0; i < precision; i++) { result = 10 * searchDPPX (maxDPPX, minDPPX, divisor); maxDPPX = result + 9; minDPPX = result; divisor *= 10; } return result / divisor; }) (5);