mdn_geminicli.com

API de Intersection Observer

Línea base Ampliamente disponible *

Esta función está bien establecida y funciona en muchos dispositivos y versiones de navegador. Está disponible en todos los navegadores desde marzo de 2019.

* Algunas partes de esta función pueden tener distintos niveles de soporte.

La API Intersection Observer proporciona una forma de observar de manera asíncrona los cambios en la intersección de un elemento objetivo con un elemento antecesor o con la ventana gráfica de un documento de nivel superior .

Descripción general

Históricamente, detectar la visibilidad de un elemento, o la visibilidad relativa de dos elementos entre sí, ha sido una tarea difícil cuyas soluciones han sido poco fiables y propensas a ralentizar el navegador y los sitios web que el usuario visita. Con la evolución de la web, la necesidad de este tipo de información ha aumentado. La información de intersección es necesaria por muchas razones, tales como:

  • Carga diferida de imágenes u otro contenido a medida que se desplaza la página.
  • Implementar sitios web con "desplazamiento infinito", donde se carga y se muestra cada vez más contenido a medida que el usuario se desplaza, para que no tenga que pasar de una página a otra.
  • Informes sobre la visibilidad de los anuncios para calcular los ingresos publicitarios.
  • Decidir si se realizan o no tareas o procesos de animación en función de si el usuario verá o no el resultado.

En el pasado, la implementación de la detección de intersecciones implicaba el uso de manejadores de eventos y bucles que llamaban a métodos Element.getBoundingClientRect()para recopilar la información necesaria para cada elemento afectado. Dado que todo este código se ejecuta en el hilo principal, incluso uno solo puede causar problemas de rendimiento. Cuando un sitio web se carga con estas pruebas, la situación puede volverse realmente problemática.

Consideremos una página web con desplazamiento infinito. Utiliza una biblioteca de un proveedor para gestionar los anuncios que aparecen periódicamente, incluye gráficos animados y emplea una biblioteca personalizada para dibujar cuadros de notificación y otros elementos similares. Cada una de estas bibliotecas tiene sus propias rutinas de detección de intersecciones, que se ejecutan en el hilo principal. Es posible que el autor del sitio web ni siquiera se dé cuenta de esto, ya que probablemente desconozca el funcionamiento interno de las dos bibliotecas que utiliza. A medida que el usuario se desplaza por la página, estas rutinas de detección de intersecciones se ejecutan constantemente durante el código de gestión del desplazamiento, lo que genera una experiencia frustrante para el usuario, tanto con el navegador como con el sitio web y su ordenador.

The Intersection Observer API lets code register a callback function that is executed whenever a particular element enters or exits an intersection with another element (or the viewport), or when the intersection between two elements changes by a specified amount. This way, sites no longer need to do anything on the main thread to watch for this kind of element intersection, and the browser is free to optimize the management of intersections as it sees fit.

One thing the Intersection Observer API can't do: trigger logic based on the exact number of pixels that overlap, or specifically on which ones they are. It only solves the common use case of "If they intersect by somewhere around N%, I need to do something."

Concepts and usage

The Intersection Observer API allows you to configure a callback that is called when either of these circumstances occur:

  • A target element intersects either the device's viewport or a specified element. That specified element is called the root element or root for the purposes of the Intersection Observer API.
  • The first time the observer is initially asked to watch a target element.

Typically, you'll want to watch for intersection changes with regard to the target element's closest scrollable ancestor, or, if the target element isn't a descendant of a scrollable element, the device's viewport. To watch for intersection relative to the device's viewport, specify null for the root option. Keep reading for a more detailed explanation about intersection observer options.

Whether you're using the viewport or some other element as the root, the API works the same way, executing a callback function you provide whenever the visibility of the target element changes so that it crosses desired amounts of intersection with the root.

The degree of intersection between the target element and its root is the intersection ratio. This is a representation of the percentage of the target element which is visible as a value between 0.0 and 1.0.

Creating an intersection observer

Create the intersection observer by calling its constructor and passing it a callback function to be run whenever a threshold is crossed in one direction or the other:

js
const options = {
  root: document.querySelector("#scrollArea"),
  rootMargin: "0px",
  scrollMargin: "0px",
  threshold: 1.0,
};

const observer = new IntersectionObserver(callback, options);

A threshold of 1.0 means that when 100% of the target is visible within the element specified by the root option, the callback is invoked.

Intersection observer options

The options object passed into the IntersectionObserver() constructor let you control the circumstances under which the observer's callback is invoked. It has the following fields:

root

The element that is used as the viewport for checking visibility of the target. Must be the ancestor of the target. Defaults to the browser viewport if not specified or if null.

rootMargin

Margen alrededor de la raíz. Una cadena de uno a cuatro valores similar a la marginpropiedad CSS, por ejemplo, "10px 20px 30px 40px"(superior, derecha, inferior, izquierda). Los valores solo pueden estar en píxeles ( px) o porcentajes ( %). Este conjunto de valores sirve para aumentar o disminuir cada lado del cuadro delimitador del elemento raíz antes de calcular las intersecciones. Los valores negativos disminuirán el cuadro delimitador del elemento raíz y los valores positivos lo expandirán. El valor predeterminado, si no se especifica, es "0px 0px 0px 0px".

scrollMargin

Margen alrededor de contenedores de desplazamiento anidados que toma los mismos valores/tiene el mismo valor predeterminado que rootMargin. Los márgenes se aplican a los contenedores desplazables anidados antes de calcular las intersecciones. Los valores positivos aumentan el rectángulo de recorte del contenedor, lo que permite que los objetivos se intersequen antes de que se vuelvan visibles, mientras que los valores negativos reducen el rectángulo de recorte.

threshold

Un número único o una matriz de números que indiquen en qué porcentaje de la visibilidad del objetivo se debe ejecutar la función de devolución de llamada del observador. Si solo desea detectar cuando la visibilidad supera el 50 %, puede usar un valor de 0,5. Si desea que la función de devolución de llamada se ejecute cada vez que la visibilidad supere otro 25 %, debe especificar la matriz [0, 0,25, 0,5, 0,75, 1]. El valor predeterminado es 0 (lo que significa que la función de devolución de llamada se ejecutará tan pronto como el elemento objetivo interseque o toque el límite de la raíz, incluso si aún no se ven píxeles). Un valor de 1,0 significa que el umbral no se considera superado hasta que todos los píxeles sean visibles.

delay 

Al monitorizar la visibilidad del objetivo ( trackVisibility es true), se puede usar para establecer el retardo mínimo en milisegundos entre las notificaciones de este observador. Limitar la frecuencia de las notificaciones es recomendable, ya que el cálculo de la visibilidad requiere mucha capacidad de procesamiento. Si se monitoriza la visibilidad, el valor se establecerá en 100 para cualquier valor inferior a 100, y se debe usar el valor máximo tolerable. El valor predeterminado es 0.

trackVisibility 

Un valor booleano que indica si se IntersectionObserverestá realizando un seguimiento de los cambios en la visibilidad de un objetivo.

Cuando falseel navegador informará intersecciones cuando el elemento objetivo se desplace dentro del área visible del elemento raíz. Cuando true, el navegador comprobará adicionalmente que el objetivo sea realmente visible y que no haya sido cubierto por otros elementos o potencialmente distorsionado u oculto por un filtro, opacidad reducida o alguna transformación. El valor es falsepor defecto ya que el seguimiento de la visibilidad es computacionalmente intensivo. Si se establece esto, delaytambién se debe establecer un .

Devoluciones de llamada de cambio de intersección

La función de devolución de llamada que se pasa al IntersectionObserver()constructor recibe una lista de IntersectionObserverEntryobjetos y el observador:

js
const callback = (entries, observer) => {
  entries.forEach((entry) => {
    // Each entry describes an intersection change for one observed
    // target element:
    //   entry.boundingClientRect
    //   entry.intersectionRatio
    //   entry.intersectionRect
    //   entry.isIntersecting
    //   entry.rootBounds
    //   entry.target
    //   entry.time
  });
};

La lista de entradas recibidas por la función de devolución de llamada incluye un IntersectionObserverEntryobjeto por cada evento de cruce de umbral; se pueden recibir varias entradas a la vez, ya sea de varios objetivos o de un único objetivo que cruza varios umbrales en un corto período de tiempo. Las entradas se envían mediante una cola, por lo que deben ordenarse según el tiempo en que se generaron, pero es preferible usar IntersectionObserverEntry.timepara ordenarlas correctamente. Cada entrada describe qué parte de un elemento dado se interseca con el elemento raíz, si el elemento se considera que se interseca o no, etc. La entrada solo contiene información sobre ese instante en particular; si necesita información que requiera seguimiento a lo largo del tiempo, como la dirección y la velocidad de desplazamiento, es posible que deba calcularla usted mismo memorizando las entradas recibidas previamente.

Tenga en cuenta que su función de devolución de llamada se ejecuta en el hilo principal. Debe operar lo más rápido posible; si necesita realizar alguna tarea que consuma mucho tiempo, utilice Window.requestIdleCallback().

El fragmento de código que se muestra a continuación ilustra una función de devolución de llamada que mantiene un contador de cuántas veces los elementos pasan de no intersecar la raíz a intersecarla en al menos un 75%. Para un valor umbral de 0,0 (por defecto), la función de devolución de llamada se ejecuta aproximadamente cuando cambia el valor booleano de isIntersecting. Por lo tanto, el fragmento primero verifica que la transición sea positiva y luego determina si intersectionRatioes superior al 75%, en cuyo caso incrementa el contador.

js
const intersectionCallback = (entries) => {
  entries.forEach((entry) => {
    if (entry.isIntersecting) {
      let elem = entry.target;

      if (entry.intersectionRatio >= 0.75) {
        intersectionCounter++;
      }
    }
  });
};

Seleccionar un elemento para ser observado

Una vez que hayas creado el observador, debes asignarle un elemento objetivo para observar:

js
const target = document.querySelector("#listItem");
observer.observe(target);

// the callback we set up for the observer will be executed now for the first time
// it waits until we assign a target to our observer (even if the target is currently not visible)

Siempre que el objetivo alcance un umbral especificado para IntersectionObserver, se invoca la función de devolución de llamada.

Además, tenga en cuenta que si especificó la rootopción, el destino debe ser un descendiente del elemento raíz.

Cómo se calcula la intersección

Todas las áreas consideradas por la API Intersection Observer son rectángulos; los elementos de forma irregular se consideran dentro del rectángulo más pequeño que engloba todas sus partes. Del mismo modo, si la porción visible de un elemento no es rectangular, su rectángulo de intersección se considera el rectángulo más pequeño que contiene todas sus porciones visibles.

Es útil comprender un poco cómo las diversas propiedades proporcionadas IntersectionObserverEntrydescriben una intersección.

La raíz de intersección y el margen de la raíz

Antes de poder rastrear la intersección de un elemento con un contenedor, necesitamos saber cuál es ese contenedor. Ese contenedor es la raíz de la intersección , o elemento raíz . Puede ser un elemento específico del documento que sea antecesor del elemento que se va a observar, o bien, nullutilizar la ventana gráfica del documento como contenedor.

El rectángulo de intersección de la raíz es el rectángulo que se utiliza para comprobar si coincide con el objetivo o los objetivos. Este rectángulo se determina de la siguiente manera:

  • Si la raíz de intersección es la raíz implícita (es decir, la de nivel superior Document), el rectángulo de intersección de la raíz es el rectángulo de la ventana gráfica.
  • Si la raíz de la intersección tiene un recorte de desbordamiento, el rectángulo de intersección de la raíz es el área de contenido del elemento raíz.
  • De lo contrario, el rectángulo de intersección raíz es el rectángulo cliente delimitador de la raíz de intersección (tal como se devuelve al llamarlo getBoundingClientRect()).

El rectángulo de intersección de la raíz se puede ajustar aún más configurando el margen de la raíz al rootMargincrearlo IntersectionObserver. Los valores rootMargindefinen los desplazamientos que se agregan a cada lado del cuadro delimitador de la raíz de intersección para crear los límites finales de la raíz de intersección (que se muestran IntersectionObserverEntry.rootBoundscuando se ejecuta la función de devolución de llamada). Los valores positivos agrandan el cuadro, mientras que los negativos lo reducen. Cada valor de desplazamiento solo se puede expresar en píxeles (px) o en porcentaje (%).

El efecto de ampliar el cuadro utilizando el margen raíz es permitir que los elementos que se desbordan se intersequen con la raíz antes de que se hagan visibles. Esto se puede usar, por ejemplo, para comenzar a cargar imágenes justo antes de que aparezcan en pantalla, en lugar de en el momento en que se hacen visibles.

En el ejemplo siguiente, tenemos un cuadro desplazable y un elemento que inicialmente está fuera de la vista. Puedes ajustar el margen derecho de la raíz y ver que:

  • Si el margen es positivo, se considera que el elemento rojo interseca con la raíz aunque no sea visible, porque interseca con el área del margen de la raíz.
  • Si el margen es negativo, incluso cuando el elemento rojo comienza a ser visible, todavía no se considera que se interseca con la raíz porque el cuadro delimitador de la raíz se reduce.

La raíz de intersección y el margen de desplazamiento

Consideremos el caso en el que tenemos un elemento raíz que contiene contenedores de desplazamiento anidados , y queremos observar las intersecciones con un elemento objetivo dentro de uno de esos contenedores desplazables. Las intersecciones con el elemento objetivo comienzan a ser observables, por defecto, cuando el objetivo es visible dentro del área definida por la raíz; en otras palabras, cuando el contenedor se desplaza hasta ser visible en la raíz y el objetivo se desplaza hasta ser visible dentro del rectángulo de recorte de su contenedor.

Puedes usar un margen de desplazamiento para comenzar a observar las intersecciones antes o después de que el objetivo se desplace a la vista dentro de su contenedor de desplazamiento. El margen se agrega a todos los contenedores de desplazamiento anidados en la raíz, incluido el elemento raíz si también es un contenedor de desplazamiento, y tiene el efecto de aumentar (márgenes positivos) o disminuir (márgenes negativos) la región de recorte utilizada para calcular las intersecciones.

Nota: Podrías crear un observador de intersección en cada contenedor de desplazamiento para el que desees un margen de desplazamiento y usar la propiedad de margen raíz para lograr un efecto similar. Usar un margen de desplazamiento es más práctico, ya que en la mayoría de los casos basta con un único observador de intersección para todos los elementos anidados.

En el ejemplo siguiente, tenemos un cuadro desplazable y un carrusel de imágenes que inicialmente está fuera de la vista. Un observador en el elemento raíz observa los elementos de imagen dentro del carrusel. Cuando un elemento de imagen comienza a intersecarse con el elemento raíz, la imagen se carga, se registra la intersección y se elimina el observador.

Desplázate hacia abajo para ver el carrusel. Las imágenes visibles se cargarán inmediatamente. Si te desplazas por el carrusel, observarás que las imágenes se cargan en cuanto el elemento se hace visible.

Tras reiniciar el ejemplo, puede usar el control proporcionado para cambiar el porcentaje del margen de desplazamiento. Si establece un valor positivo, como el 20 %, el rectángulo de recorte del contenedor de desplazamiento aumentará un 20 %, y observará que las imágenes se detectan y cargan antes de que aparezcan en pantalla. Del mismo modo, un valor negativo indicará que la intersección se detecta una vez que las imágenes ya están visibles.

Umbrales

En lugar de informar sobre cada cambio mínimo en la visibilidad de un elemento objetivo, la API Intersection Observer utiliza umbrales . Al crear un observador, puede proporcionar uno o más valores numéricos que representen el porcentaje de visibilidad del elemento objetivo. La API solo informa sobre los cambios de visibilidad que superen estos umbrales.

Por ejemplo, si desea recibir una notificación cada vez que la visibilidad de un objetivo retroceda o avance por cada marca del 25 %, deberá especificar la matriz [0, 0.25, 0.5, 0.75, 1] ​​como la lista de umbrales al crear el observador.

Cuando se invoca la función de devolución de llamada, esta recibe una lista de IntersectionObserverEntryobjetos, uno por cada objetivo observado cuyo grado de intersección con la raíz ha cambiado de tal manera que la cantidad expuesta supera uno de los umbrales, en cualquier dirección.

Puedes comprobar si el elemento de destino interseca actualmente la raíz observando la isIntersectingpropiedad de la entrada; si su valor es true, el elemento de destino interseca al menos parcialmente el elemento raíz o el documento. Esto te permite determinar si la entrada representa una transición de elementos que intersecan a que ya no intersecan, o una transición de no intersecar a intersecar.

Cabe señalar que es posible obtener un rectángulo de intersección cero, lo cual puede ocurrir si la intersección se produce exactamente a lo largo del límite entre ambos o si el área boundingClientRectes cero. Este estado, en el que el objetivo y la raíz comparten una línea límite, no se considera suficiente para que se produzca una transición a un estado de intersección.

Para comprender mejor cómo funcionan los umbrales, intente desplazar el cuadro a continuación. Cada cuadro de color dentro del mismo muestra el porcentaje de sí mismo que es visible en sus cuatro esquinas, de modo que puede observar cómo cambian estas proporciones con el tiempo a medida que desplaza el contenedor. Cada cuadro tiene un conjunto diferente de umbrales:

  • La primera casilla tiene un umbral para cada punto porcentual de visibilidad; es decir, la IntersectionObserver.thresholdsmatriz es [0.00, 0.01, 0.02, /*…,*/ 0.99, 1.00].
  • La segunda casilla tiene un único umbral, en el 50%.
  • La tercera casilla tiene umbrales cada 10% de visibilidad (0%, 10%, 20%, etc.).
  • La última casilla tiene umbrales cada 25%.

Seguimiento de la visibilidad y el retraso

Por defecto, el observador proporciona notificaciones cuando el elemento objetivo se desplaza dentro del área visible del elemento raíz. Si bien esto suele ser suficiente en muchas situaciones, a veces es importante que no se informen las intersecciones cuando el elemento objetivo se ha visto afectado visualmente. Por ejemplo, al medir análisis o impresiones de anuncios, es fundamental que los elementos objetivo no se oculten ni se distorsionen, ni total ni parcialmente.

Esta trackVisibilityconfiguración indica al observador que solo informe sobre intersecciones de elementos que el navegador no considere visualmente comprometidos, por ejemplo, al modificar la opacidad o aplicar un filtro o transformación. El algoritmo es conservador y puede omitir elementos que son técnicamente visibles, como aquellos con una ligera reducción de opacidad.

El cálculo de visibilidad es computacionalmente costoso y solo debe usarse cuando sea necesario. Al realizar el seguimiento de la visibilidad, delaytambién se debe establecer un límite para el período mínimo de informe. Se recomienda configurar el retraso al valor máximo tolerable (el retraso mínimo al realizar el seguimiento de la visibilidad es de 100 milisegundos).

Recorte y rectángulo de intersección

El navegador calcula el rectángulo de intersección final de la siguiente manera; todo esto se hace automáticamente, pero puede ser útil comprender estos pasos para entender mejor cuándo se producirán las intersecciones.

  1. El rectángulo delimitador del elemento objetivo (es decir, el rectángulo más pequeño que encierra completamente los cuadros delimitadores de cada componente que lo conforma) se obtiene llamando getBoundingClientRect()a la función correspondiente. Este es el tamaño máximo que puede tener el rectángulo de intersección. Los pasos restantes eliminarán las partes que no se intersequen.
  2. Partiendo del bloque padre inmediato del objetivo y extendiéndose hacia afuera, el recorte de cada bloque contenedor (si lo hay) se aplica al rectángulo de intersección. El recorte de un bloque se determina en función de la intersección de los dos bloques y el modo de recorte (si lo hay) especificado por la overflowpropiedad. Si se establece overflowen cualquier valor distinto de cero, visiblese produce el recorte.
  3. Si uno de los elementos contenedores es la raíz de un contexto de navegación anidado (como el documento contenido en un <iframe>), el rectángulo de intersección se recorta al área visible del contexto contenedor, y la recursión ascendente a través de los contenedores continúa con el bloque contenedor del contenedor. Por lo tanto, si <iframe>se alcanza el nivel superior de un , el rectángulo de intersección se recorta al área visible del marco, y luego el elemento padre del marco es el siguiente bloque que se recorre recursivamente hacia la raíz de la intersección.
  4. Cuando la recursión ascendente alcanza la raíz de la intersección, el rectángulo resultante se mapea al espacio de coordenadas de la raíz de la intersección.
  5. El rectángulo resultante se actualiza luego intersecándolo con el rectángulo de intersección raíz .
  6. Este rectángulo se mapea, finalmente, al espacio de coordenadas del objetivo document.

Interfaces

IntersectionObserver

La interfaz principal para la API Intersection Observer. Proporciona métodos para crear y administrar un observador que puede monitorear cualquier número de elementos objetivo para la misma configuración de intersección. Cada observador puede observar de forma asíncrona los cambios en la intersección entre uno o más elementos objetivo y un elemento ancestro compartido o con su ventana gráficaDocument de nivel superior . El ancestro o ventana gráfica se denomina raíz .

IntersectionObserverEntry

Describe la intersección entre el elemento objetivo y su contenedor raíz en un momento específico de transición. Los objetos de este tipo solo se pueden obtener de dos maneras: como entrada a su IntersectionObserverfunción de devolución de llamada o llamando a IntersectionObserver.takeRecords().

Un ejemplo sencillo

Este sencillo ejemplo provoca que un elemento objetivo cambie de color y transparencia a medida que se vuelve más o menos visible. En la API Intersection Observer , encontrará un ejemplo más extenso que muestra cómo medir el tiempo que un conjunto de elementos (como anuncios) permanecen visibles para el usuario y cómo reaccionar a esa información registrando estadísticas o actualizando los elementos.

HTML

El código HTML de este ejemplo es muy corto, con un elemento principal que es el cuadro al que nos dirigiremos (con el ID creativo "box") y algo de contenido dentro del cuadro.

htmlPlay
<div id="box">
  <div class="vertical">Welcome to <strong>The Box!</strong></div>
</div>

CSS

El CSS no es terriblemente importante para los propósitos de este ejemplo; establece el elemento y establece que los background-coloratributos bordery pueden participar en las transiciones CSS , que utilizaremos para afectar los cambios en el elemento a medida que se vuelve más o menos oculto.

cssPlay
#box {
  background-color: rgb(40 40 190 / 100%);
  border: 4px solid rgb(20 20 120);
  transition:
    background-color 1s,
    border 1s;
  width: 350px;
  height: 350px;
  display: flex;
  align-items: center;
  justify-content: center;
  padding: 20px;
}

.vertical {
  color: white;
  font: 32px "Arial";
}

.extra {
  width: 350px;
  height: 350px;
  margin-top: 10px;
  border: 4px solid rgb(20 20 120);
  text-align: center;
  padding: 20px;
}

JavaScript

Por último, echemos un vistazo al código JavaScript que utiliza la API Intersection Observer para que esto suceda.

Configurando

Primero, necesitamos preparar algunas variables e instalar el observador.

jsPlay
const numSteps = 20.0;

const boxElement = document.querySelector("#box");
let prevRatio = 0.0;
let increasingColor = "rgb(40 40 190 / ratio)";
let decreasingColor = "rgb(190 40 40 / ratio)";

createObserver();

Las constantes y variables que definimos aquí son:

numSteps

Una constante que indica cuántos umbrales queremos tener entre una relación de visibilidad de 0,0 y 1,0.

prevRatio

Esta variable se utilizará para registrar cuál era el índice de visibilidad la última vez que se superó un umbral; esto nos permitirá determinar si el elemento objetivo se está volviendo más o menos visible.

increasingColor

Una cadena que define el color que se aplicará al elemento objetivo cuando aumente su índice de visibilidad. La palabra "ratio" en esta cadena se sustituirá por el índice de visibilidad actual del elemento, de modo que este no solo cambie de color, sino que también se vuelva cada vez más opaco a medida que se oculta menos.

decreasingColor

De manera similar, esta es una cadena que define un color que aplicaremos cuando la relación de visibilidad esté disminuyendo.

Obtenemos una referencia al elemento con el ID "box"usando querySelector(), luego llamamos al createObserver()método que crearemos en un momento para manejar la construcción e instalación del observador de intersección.

Creación del observador de intersección

Este createObserver()método se llama una vez que la página se ha cargado por completo para encargarse de crear el nuevo elemento IntersectionObservery comenzar el proceso de observación del elemento de destino.

jsPlay
function createObserver() {
  const options = {
    root: null,
    rootMargin: "0px",
    threshold: buildThresholdList(),
  };

  const observer = new IntersectionObserver(handleIntersect, options);
  observer.observe(boxElement);
}

Esto comienza configurando un optionsobjeto que contiene los ajustes para el observador. Queremos observar los cambios en la visibilidad del elemento objetivo en relación con la ventana gráfica del documento, por lo que rootes null. No necesitamos margen, así que el desplazamiento del margen, rootMargin, se especifica como "0px". Esto hace que el observador observe los cambios en la intersección entre los límites del elemento objetivo y los de la ventana gráfica, sin ningún espacio añadido (o sustraído).

La lista de umbrales de relación de visibilidad, threshold, se construye mediante la función buildThresholdList(). En este ejemplo, la lista de umbrales se construye mediante programación, ya que hay varios y se pretende que dicho número sea ajustable.

Una vez optionslisto, creamos el nuevo observador, llamando al IntersectionObserver()constructor, especificando una función que se llamará cuando la intersección cruce uno de nuestros umbrales, handleIntersect()y nuestro conjunto de opciones. Luego llamamos observe()al observador devuelto, pasándole el elemento objetivo deseado.

Podríamos optar por monitorizar varios elementos para detectar cambios en la intersección de la visibilidad con respecto a la ventana gráfica, llamando observer.observe()a cada uno de esos elementos, si quisiéramos hacerlo.

Construyendo la matriz de relaciones umbral

La buildThresholdList()función, que construye la lista de umbrales, tiene este aspecto:

jsPlay
function buildThresholdList() {
  const thresholds = [];
  const numSteps = 20;

  for (let i = 1.0; i <= numSteps; i++) {
    const ratio = i / numSteps;
    thresholds.push(ratio);
  }

  thresholds.push(0);
  return thresholds;
}

Esto crea la matriz de umbrales, cada uno de los cuales es una proporción entre 0,0 y 1,0, agregando el valor i/numStepsa la thresholdsmatriz para cada entero ientre 1 y numSteps. También agrega 0 para incluir ese valor. El resultado, dado el valor predeterminado de numSteps(20), es la siguiente lista de umbrales:

#Relación#Relación
00,05110,6
10.1120,65
20,15130,7
30,2140,75
40,25150,8
50,3160,85
60,35170,9
70,4180,95
80,45191
90,5200
100,55

Por supuesto, podríamos incluir directamente el conjunto de umbrales en nuestro código, y a menudo eso es lo que se termina haciendo. Pero este ejemplo deja margen para añadir controles de configuración que permitan ajustar la granularidad, por ejemplo.

Manejo de cambios en las intersecciones

Cuando el navegador detecta que el elemento de destino (en nuestro caso, el que tiene el ID "box") se ha revelado u ocultado de tal manera que su índice de visibilidad supera uno de los umbrales de nuestra lista, llama a nuestra función controladora handleIntersect():

jsPlay
function handleIntersect(entries, observer) {
  entries.forEach((entry) => {
    if (entry.intersectionRatio > prevRatio) {
      entry.target.style.backgroundColor = increasingColor.replace(
        "ratio",
        entry.intersectionRatio,
      );
    } else {
      entry.target.style.backgroundColor = decreasingColor.replace(
        "ratio",
        entry.intersectionRatio,
      );
    }

    prevRatio = entry.intersectionRatio;
  });
}

Para cada elemento IntersectionObserverEntryde la lista entries, verificamos si el valor de la entrada intersectionRatioestá aumentando; si es así, establecemos el valor del objetivo background-colora la cadena en increasingColor(recuerda, es "rgb(40 40 190 / ratio)"), reemplazando la palabra "ratio" con el valor de la entrada intersectionRatio. El resultado: no solo cambia el color, sino que también cambia la transparencia del elemento objetivo; a medida que la relación de intersección disminuye, el valor alfa del color de fondo disminuye con ella, lo que resulta en un elemento más transparente.

De manera similar, si intersectionRatioestá bajando, usamos la cadena decreasingColory reemplazamos la palabra "ratio" en ella con intersectionRatioantes de establecer el elemento de destino background-color.

Finalmente, para poder rastrear si la relación de intersección está aumentando o disminuyendo, recordamos la relación actual en la variable prevRatio.

Resultado

A continuación se muestra el contenido resultante. Desplácese hacia arriba y hacia abajo en esta página y observe cómo cambia la apariencia del cuadro al hacerlo.

Existe un ejemplo aún más extenso en Visibilidad de elementos de temporización con la API Intersection Observer .

Presupuesto

Especificación
Observador de intersecciones #interfaz-observador-de-intersecciones

Compatibilidad con navegadores

IntersectionObserver
IntersectionObserver()constructor
options.rootEl parámetro puede ser unDocument
delay
Experimental
disconnect
observe
root
rootMargin
scrollMargin
takeRecords
thresholds
trackVisibility
Experimental
unobserve

Leyenda

Consejo: puedes hacer clic o pulsar sobre una celda para obtener más información.

Soporte completo
Soporte completo
Sin soporte
Sin soporte
Experimental. Es posible que el comportamiento cambie en el futuro.
Consulte las notas de implementación.

Véase también

Comentarios

Entradas más populares de este blog

aistudio.Google.com

Cloud.a1

https://git.io.com