Tema para preguntas random a Chatgpt 🤖

  • Autor Autor Carlos Arreola
  • Fecha de inicio Fecha de inicio
blankito1998 dijo:
podrias agregarle un setinterval a st 2do observer asi como el primero porfa?
Hacer clic para expandir...
¡Claro! A continuación, te muestro cómo podrías agregar un setInterval a este segundo observador:

JavaScript: 
let intervalIds2 = {};

let observer2 = new IntersectionObserver((entries) => {
  entries.forEach(entry => {
    let dataId = entry.target.getAttribute('data-id');
    if (entry.isIntersecting) {
      if (intervalIds2[dataId]) { // Si ya existe un intervalo, lo borramos
        clearInterval(intervalIds2[dataId]);
      }
      intervalIds2[dataId] = setInterval(() => {
        // Acá iría la funcionalidad que quieres que se repita cada cierto intervalo.
      }, 1000); // Este intervalo se ejecuta cada 1000 ms (1 segundo).
    } else {
      if (intervalIds2[dataId]) { // Si el elemento ya no está en vista, borramos el intervalo.
        clearInterval(intervalIds2[dataId]);
        delete intervalIds2[dataId]; // También borramos la entrada correspondiente del objeto intervalIds2.
      }
    }
  });
}, { threshold: [0.1] });

document.querySelectorAll('.tuSegundoSelectorCss').forEach(elem => observer2.observe(elem));
Este código creará un intervalo para cada elemento que observe el observador cuando dichos elementos crucen el umbral de intersección. Una vez que estos elementos salgan de la intersección, los intervalos correspondientes serán borrados.
 
BotBeta dijo:
¡Claro! A continuación, te muestro cómo podrías agregar un setInterval a este segundo observador:

JavaScript: 
let intervalIds2 = {};

let observer2 = new IntersectionObserver((entries) => {
  entries.forEach(entry => {
    let dataId = entry.target.getAttribute('data-id');
    if (entry.isIntersecting) {
      if (intervalIds2[dataId]) { // Si ya existe un intervalo, lo borramos
        clearInterval(intervalIds2[dataId]);
      }
      intervalIds2[dataId] = setInterval(() => {
        // Acá iría la funcionalidad que quieres que se repita cada cierto intervalo.
      }, 1000); // Este intervalo se ejecuta cada 1000 ms (1 segundo).
    } else {
      if (intervalIds2[dataId]) { // Si el elemento ya no está en vista, borramos el intervalo.
        clearInterval(intervalIds2[dataId]);
        delete intervalIds2[dataId]; // También borramos la entrada correspondiente del objeto intervalIds2.
      }
    }
  });
}, { threshold: [0.1] });

document.querySelectorAll('.tuSegundoSelectorCss').forEach(elem => observer2.observe(elem));
Este código creará un intervalo para cada elemento que observe el observador cuando dichos elementos crucen el umbral de intersección. Una vez que estos elementos salgan de la intersección, los intervalos correspondientes serán borrados.
Hacer clic para expandir...
let intervalIds2 = {};
let observer2 = new IntersectionObserver((entries) => {
entries.forEach(entry => {
let dataId = entry.target.getAttribute('data-id');
if (entry.isIntersecting) {
intervalIds2[dataId] = setInterval(() => {
entry.target.style.background="red";
}, 1000);
} else {
entry.target.style.background="gold";
clearInterval(intervalIds2[dataId]);
}
});
}, { threshold: [0.1] });
document.querySelectorAll('.strupture').forEach(elem => observer2.observe(elem));
let mutationObserver2 = new MutationObserver((mutations) => {
mutations.forEach(mutation => {
if (mutation.type === 'childList') {
mutation.addedNodes.forEach(node => {
if (node.nodeType === 1 && node.matches('.strupture')) {
observer2.observe(node);
}
});
}
});
});
mutationObserver2.observe(document, {
childList: true,
subtree: true
});

tienes alguna idea de porque no me funciona con los nuevos objetos encontrados??
 
blankito1998 dijo:
let intervalIds2 = {};
let observer2 = new IntersectionObserver((entries) => {
entries.forEach(entry => {
let dataId = entry.target.getAttribute('data-id');
if (entry.isIntersecting) {
intervalIds2[dataId] = setInterval(() => {
entry.target.style.background="red";
}, 1000);
} else {
entry.target.style.background="gold";
clearInterval(intervalIds2[dataId]);
}
});
}, { threshold: [0.1] });
document.querySelectorAll('.strupture').forEach(elem => observer2.observe(elem));
let mutationObserver2 = new MutationObserver((mutations) => {
mutations.forEach(mutation => {
if (mutation.type === 'childList') {
mutation.addedNodes.forEach(node => {
if (node.nodeType === 1 && node.matches('.strupture')) {
observer2.observe(node);
}
});
}
});
});
mutationObserver2.observe(document, {
childList: true,
subtree: true
});

tienes alguna idea de porque no me funciona con los nuevos objetos encontrados??
Hacer clic para expandir...
En tu código, pareces estar haciendo todo correcto: estás observando los elementos '.strupture' existentes, y cualquier nodo nuevo que se añade al DOM y que coincide con ese selector es observado también.

Una posible razón por la que no esté funcionando podría ser que los nuevos elementos '.strupture' se estén añadiendo dentro de elementos que ya son observados para las intersecciones. En ese caso, el elemento nuevo se podría estar considerando como en intersección desde el momento en que se añade.

Otro motivo podría ser que los nuevos nodos que se están añadiendo al DOM ya hayan terminado su transición al momento de ser añadidos y por lo tanto no disparen el IntersectionObserver.

Si el problema persiste, podrías intentar agregar algunas declaraciones de consola para depurar y ver si los nuevos elementos que coinciden con '.strupture' están siendo realmente capturados y observados como se espera.
 
BotBeta dijo:
En tu código, pareces estar haciendo todo correcto: estás observando los elementos '.strupture' existentes, y cualquier nodo nuevo que se añade al DOM y que coincide con ese selector es observado también.

Una posible razón por la que no esté funcionando podría ser que los nuevos elementos '.strupture' se estén añadiendo dentro de elementos que ya son observados para las intersecciones. En ese caso, el elemento nuevo se podría estar considerando como en intersección desde el momento en que se añade.

Otro motivo podría ser que los nuevos nodos que se están añadiendo al DOM ya hayan terminado su transición al momento de ser añadidos y por lo tanto no disparen el IntersectionObserver.

Si el problema persiste, podrías intentar agregar algunas declaraciones de consola para depurar y ver si los nuevos elementos que coinciden con '.strupture' están siendo realmente capturados y observados como se espera.
Hacer clic para expandir...
Una posible razón por la que no esté funcionando podría ser que los nuevos elementos '.strupture' se estén añadiendo dentro de elementos que ya son observados para las intersecciones. En ese caso, el elemento nuevo se podría estar considerando como en intersección desde el momento en que se añade.


como puedo hacer en ese caso??
 
blankito1998 dijo:
Una posible razón por la que no esté funcionando podría ser que los nuevos elementos '.strupture' se estén añadiendo dentro de elementos que ya son observados para las intersecciones. En ese caso, el elemento nuevo se podría estar considerando como en intersección desde el momento en que se añade.


como puedo hacer en ese caso??
Hacer clic para expandir...
Podrías tratar de quitar el observador del elemento padre antes de agregar el nuevo nodo '.strupture', y luego volver a agregar el observador al elemento padre.

Aquí hay una idea de cómo podrías hacerlo:

JavaScript: 
let mutationObserver2 = new MutationObserver((mutations) => {
  mutations.forEach(mutation => {
    if (mutation.type === 'childList') {
      mutation.addedNodes.forEach(node => {
        if (node.nodeType === 1 && node.matches('.strupture')) {
          // Quita el observador del elemento padre
          observer2.unobserve(mutation.target);
          // Observa al nuevo nodo
          observer2.observe(node);
          // Vuelve a agregar el elemento padre al observador
          observer2.observe(mutation.target);
        }
      });
    }
  });
});

Esto debe hacer que el nuevo nodo '.strupture' no se considere en intersección en el momento en que se añade. Sin embargo, este código puede crear un parpadeo breve debido a que el elemento padre está siendo quitado y luego reañadido al observador.

Por favor, ten en cuenta que esto es solo una idea y que podrías necesitar hacer ajustes adicionales para lograr el comportamiento deseado.
 
BotBeta dijo:
Podrías tratar de quitar el observador del elemento padre antes de agregar el nuevo nodo '.strupture', y luego volver a agregar el observador al elemento padre.

Aquí hay una idea de cómo podrías hacerlo:

JavaScript: 
let mutationObserver2 = new MutationObserver((mutations) => {
  mutations.forEach(mutation => {
    if (mutation.type === 'childList') {
      mutation.addedNodes.forEach(node => {
        if (node.nodeType === 1 && node.matches('.strupture')) {
          // Quita el observador del elemento padre
          observer2.unobserve(mutation.target);
          // Observa al nuevo nodo
          observer2.observe(node);
          // Vuelve a agregar el elemento padre al observador
          observer2.observe(mutation.target);
        }
      });
    }
  });
});

Esto debe hacer que el nuevo nodo '.strupture' no se considere en intersección en el momento en que se añade. Sin embargo, este código puede crear un parpadeo breve debido a que el elemento padre está siendo quitado y luego reañadido al observador.

Por favor, ten en cuenta que esto es solo una idea y que podrías necesitar hacer ajustes adicionales para lograr el comportamiento deseado.
Hacer clic para expandir...
podrias agregar el setinterval?
 
blankito1998 dijo:
podrias agregar el setinterval?
Hacer clic para expandir...
Por supuesto, aquí está el código con la adición del setInterval:

JavaScript: 
let intervalIds2 = {};

let observer2 = new IntersectionObserver((entries) => {
  entries.forEach(entry => {
    let dataId = entry.target.getAttribute('data-id');
    if (entry.isIntersecting) {
      intervalIds2[dataId] = setInterval(() => {
        // Aquí va el código que quieres que se ejecute cada intervalo
        entry.target.style.background = "red";
      }, 1000);
    } else {
      clearInterval(intervalIds2[dataId]);
    }
  });
}, { threshold: [0.1] });
document.querySelectorAll('.strupture').forEach(elem => observer2.observe(elem));

let mutationObserver2 = new MutationObserver((mutations) => {
  mutations.forEach(mutation => {
    if (mutation.type === 'childList') {
      mutation.addedNodes.forEach(node => {
        if (node.nodeType === 1 && node.matches('.strupture')) {
          observer2.unobserve(mutation.target);
          observer2.observe(node);
          observer2.observe(mutation.target);
        }
      });
    }
  });
});

mutationObserver2.observe(document, {
  childList: true,
  subtree: true
});

Este código ahora debería agregar a los nuevos elementos al observador y iniciar el setInterval cuando dichos elementos estén en el viewport.
 
BotBeta dijo:
Por supuesto, aquí está el código con la adición del setInterval:

JavaScript: 
let intervalIds2 = {};

let observer2 = new IntersectionObserver((entries) => {
  entries.forEach(entry => {
    let dataId = entry.target.getAttribute('data-id');
    if (entry.isIntersecting) {
      intervalIds2[dataId] = setInterval(() => {
        // Aquí va el código que quieres que se ejecute cada intervalo
        entry.target.style.background = "red";
      }, 1000);
    } else {
      clearInterval(intervalIds2[dataId]);
    }
  });
}, { threshold: [0.1] });
document.querySelectorAll('.strupture').forEach(elem => observer2.observe(elem));

let mutationObserver2 = new MutationObserver((mutations) => {
  mutations.forEach(mutation => {
    if (mutation.type === 'childList') {
      mutation.addedNodes.forEach(node => {
        if (node.nodeType === 1 && node.matches('.strupture')) {
          observer2.unobserve(mutation.target);
          observer2.observe(node);
          observer2.observe(mutation.target);
        }
      });
    }
  });
});

mutationObserver2.observe(document, {
  childList: true,
  subtree: true
});

Este código ahora debería agregar a los nuevos elementos al observador y iniciar el setInterval cuando dichos elementos estén en el viewport.
Hacer clic para expandir...
creo qu mi problma esta en cuanto añado un nuevo div y refresco los viejos
 
blankito1998 dijo:
creo qu mi problma esta en cuanto añado un nuevo div y refresco los viejos
Hacer clic para expandir...
Entiendo, parece que el problema puede estar relacionado con cómo se manejan los nodos viejos cuando se añade un nuevo div. Podría ser que los observadores y los intervalos asociados a los viejos nodos no se están gestionando correctamente cuando se refrescan.

Una forma de solucionar esto podría ser asegurarse de que estás limpiando los intervalos y dejando de observar los viejos nodos antes de refrescarlos. Aquí te dejo un boceto de cómo podrías hacerlo:

JavaScript: 
mutation.addedNodes.forEach(node => {
  if (node.nodeType === 1 && node.matches('.strupture')) {
    // Detén la observación de los viejos nodos antes de refrescarlos
    document.querySelectorAll('.strupture').forEach(oldNode => {
      observer2.unobserve(oldNode);
      let oldNodeId = oldNode.getAttribute('data-id');
      // Asegúrate de limpiar los intervalos de los viejos nodos
      if(intervalIds2[oldNodeId]){
        clearInterval(intervalIds2[oldNodeId]);
      }
    });
    // Ahora puedes refrescar tus viejos nodos y añadir el nuevo

    // Observa al nuevo nodo
    observer2.observe(node);
  }
});
Por supuesto, necesitarías adaptar este boceto a tu código específico. Pero la idea sería detener la observación y limpiar los intervalos de los viejos nodos antes de refrescarlos o añadir nuevos nodos.
 
BotBeta dijo:
Entiendo, parece que el problema puede estar relacionado con cómo se manejan los nodos viejos cuando se añade un nuevo div. Podría ser que los observadores y los intervalos asociados a los viejos nodos no se están gestionando correctamente cuando se refrescan.

Una forma de solucionar esto podría ser asegurarse de que estás limpiando los intervalos y dejando de observar los viejos nodos antes de refrescarlos. Aquí te dejo un boceto de cómo podrías hacerlo:

JavaScript: 
mutation.addedNodes.forEach(node => {
  if (node.nodeType === 1 && node.matches('.strupture')) {
    // Detén la observación de los viejos nodos antes de refrescarlos
    document.querySelectorAll('.strupture').forEach(oldNode => {
      observer2.unobserve(oldNode);
      let oldNodeId = oldNode.getAttribute('data-id');
      // Asegúrate de limpiar los intervalos de los viejos nodos
      if(intervalIds2[oldNodeId]){
        clearInterval(intervalIds2[oldNodeId]);
      }
    });
    // Ahora puedes refrescar tus viejos nodos y añadir el nuevo

    // Observa al nuevo nodo
    observer2.observe(node);
  }
});
Por supuesto, necesitarías adaptar este boceto a tu código específico. Pero la idea sería detener la observación y limpiar los intervalos de los viejos nodos antes de refrescarlos o añadir nuevos nodos.
Hacer clic para expandir...
añade el setinterval
 
blankito1998 dijo:
añade el setinterval
Hacer clic para expandir...
¡Claro! Aquí integré la parte de setInterval con el código:

JavaScript: 
let intervalIds2 = {};

let observer2 = new IntersectionObserver((entries) => {
  entries.forEach(entry => {
    let dataId = entry.target.getAttribute('data-id');
    if (entry.isIntersecting) {
      intervalIds2[dataId] = setInterval(() => {
        entry.target.style.background = "red";
      }, 1000);
    } else {
      clearInterval(intervalIds2[dataId]);
    }
  });
}, { threshold: [0.1] });
document.querySelectorAll('.strupture').forEach(elem => observer2.observe(elem));

let mutationObserver2 = new MutationObserver((mutations) => {
  mutations.forEach(mutation => {
    if (mutation.type === 'childList') {
      mutation.addedNodes.forEach(node => {
        if (node.nodeType === 1 && node.matches('.strupture')) {
          document.querySelectorAll('.strupture').forEach(oldNode => {
            let oldNodeId = oldNode.getAttribute('data-id');
            observer2.unobserve(oldNode);
            if(intervalIds2[oldNodeId]){
              clearInterval(intervalIds2[oldNodeId]);
            }
          });

          observer2.observe(node);
        }
      });
    }
  });
});

mutationObserver2.observe(document, {
  childList: true,
  subtree: true
});

Este bloque de código hará las cosas siguientes:
1. Observa inicialmente todos los elementos con la clase 'strupture'.
2. Cuando un nuevo nodo con la clase 'strupture' se agrega al DOM, el código deja de observar todos los nodos antiguos, borra los intervalos existentes, y comienza a observar el nuevo nodo.
3. Si un nodo observado ingresa al viewport, se inicia un intervalo que cambia el color de fondo de dicho nodo a rojo cada segundo.
4. Cuando el nodo sale del viewport, se detiene el intervalo.
 
BotBeta dijo:
¡Claro! Aquí integré la parte de setInterval con el código:

JavaScript: 
let intervalIds2 = {};

let observer2 = new IntersectionObserver((entries) => {
  entries.forEach(entry => {
    let dataId = entry.target.getAttribute('data-id');
    if (entry.isIntersecting) {
      intervalIds2[dataId] = setInterval(() => {
        entry.target.style.background = "red";
      }, 1000);
    } else {
      clearInterval(intervalIds2[dataId]);
    }
  });
}, { threshold: [0.1] });
document.querySelectorAll('.strupture').forEach(elem => observer2.observe(elem));

let mutationObserver2 = new MutationObserver((mutations) => {
  mutations.forEach(mutation => {
    if (mutation.type === 'childList') {
      mutation.addedNodes.forEach(node => {
        if (node.nodeType === 1 && node.matches('.strupture')) {
          document.querySelectorAll('.strupture').forEach(oldNode => {
            let oldNodeId = oldNode.getAttribute('data-id');
            observer2.unobserve(oldNode);
            if(intervalIds2[oldNodeId]){
              clearInterval(intervalIds2[oldNodeId]);
            }
          });

          observer2.observe(node);
        }
      });
    }
  });
});

mutationObserver2.observe(document, {
  childList: true,
  subtree: true
});

Este bloque de código hará las cosas siguientes:
1. Observa inicialmente todos los elementos con la clase 'strupture'.
2. Cuando un nuevo nodo con la clase 'strupture' se agrega al DOM, el código deja de observar todos los nodos antiguos, borra los intervalos existentes, y comienza a observar el nuevo nodo.
3. Si un nodo observado ingresa al viewport, se inicia un intervalo que cambia el color de fondo de dicho nodo a rojo cada segundo.
4. Cuando el nodo sale del viewport, se detiene el intervalo.
Hacer clic para expandir...
tengo una duda, este segundo observer no detecta los divs que estan dentro del 1er observer cuando los refresco?
 
blankito1998 dijo:
tengo una duda, este segundo observer no detecta los divs que estan dentro del 1er observer cuando los refresco?
Hacer clic para expandir...
Si estás refrescando los divs que están siendo observados por el primer observador, deberías notificar explícitamente al segundo observador sobre estos divs refrescados. Intersection Observer no detectará cambios internos en los divs, solo notifica cuando un cambio en la posición o tamaño del div provoca que cruce el umbral de observación.

Así que, si refrescas o actualizas divs (por ejemplo, cambias su contenido o estilo), tendrías que quitarlos del Observer y volver a agregarlos para que se registren los cambios. Esto se aplica tanto para el primer como para el segundo Observer.

Espero que esto ayude a resolver tu duda. Si no, no dudes en aclarar o aportar más detalles acerca de tu pregunta.
 
BotBeta dijo:
Si estás refrescando los divs que están siendo observados por el primer observador, deberías notificar explícitamente al segundo observador sobre estos divs refrescados. Intersection Observer no detectará cambios internos en los divs, solo notifica cuando un cambio en la posición o tamaño del div provoca que cruce el umbral de observación.

Así que, si refrescas o actualizas divs (por ejemplo, cambias su contenido o estilo), tendrías que quitarlos del Observer y volver a agregarlos para que se registren los cambios. Esto se aplica tanto para el primer como para el segundo Observer.

Espero que esto ayude a resolver tu duda. Si no, no dudes en aclarar o aportar más detalles acerca de tu pregunta.
Hacer clic para expandir...
podrias hacerlo porfa?
 
blankito1998 dijo:
podrias hacerlo porfa?
Hacer clic para expandir...
Claro, puedes hacerlo de la siguiente manera. Esta versión del código desvinculará y vinculará nuevamente los divs al segundo observador cuando los divs sean refrescados:

JavaScript: 
let intervalIds2 = {};

let observer2 = new IntersectionObserver((entries) => {
  entries.forEach(entry => {
    let dataId = entry.target.getAttribute('data-id');
    if (entry.isIntersecting) {
      intervalIds2[dataId] = setInterval(() => {
        entry.target.style.background = "red";
      }, 1000);
    } else {
      clearInterval(intervalIds2[dataId]);
    }
  });
}, { threshold: [0.1] });

document.querySelectorAll('.strupture').forEach(elem => observer2.observe(elem));

let mutationObserver2 = new MutationObserver((mutations) => {
  mutations.forEach(mutation => {
    mutation.addedNodes.forEach(node => {
      if (node.nodeType === 1 && node.matches('.strupture')) {
        document.querySelectorAll('.strupture').forEach(oldNode => {
          let oldNodeId = oldNode.getAttribute('data-id');
          observer2.unobserve(oldNode);
          if(intervalIds2[oldNodeId]){
            clearInterval(intervalIds2[oldNodeId]);
          }
          observer2.observe(oldNode);
        });
        observer2.observe(node);
      }
    });
  });
});

mutationObserver2.observe(document, {
  childList: true,
  subtree: true
});
Este código hace lo siguiente: Si un div existente es refrescado, el código primero desvincula el div del observador, luego cancela el intervalo asociado a ese div (si existe), y luego vuelve a vincular el div al observador. Esto debería hacer que el observador tome en cuenta los cambios realizados en el div.
 
BotBeta dijo:
Claro, puedes hacerlo de la siguiente manera. Esta versión del código desvinculará y vinculará nuevamente los divs al segundo observador cuando los divs sean refrescados:

JavaScript: 
let intervalIds2 = {};

let observer2 = new IntersectionObserver((entries) => {
  entries.forEach(entry => {
    let dataId = entry.target.getAttribute('data-id');
    if (entry.isIntersecting) {
      intervalIds2[dataId] = setInterval(() => {
        entry.target.style.background = "red";
      }, 1000);
    } else {
      clearInterval(intervalIds2[dataId]);
    }
  });
}, { threshold: [0.1] });

document.querySelectorAll('.strupture').forEach(elem => observer2.observe(elem));

let mutationObserver2 = new MutationObserver((mutations) => {
  mutations.forEach(mutation => {
    mutation.addedNodes.forEach(node => {
      if (node.nodeType === 1 && node.matches('.strupture')) {
        document.querySelectorAll('.strupture').forEach(oldNode => {
          let oldNodeId = oldNode.getAttribute('data-id');
          observer2.unobserve(oldNode);
          if(intervalIds2[oldNodeId]){
            clearInterval(intervalIds2[oldNodeId]);
          }
          observer2.observe(oldNode);
        });
        observer2.observe(node);
      }
    });
  });
});

mutationObserver2.observe(document, {
  childList: true,
  subtree: true
});
Este código hace lo siguiente: Si un div existente es refrescado, el código primero desvincula el div del observador, luego cancela el intervalo asociado a ese div (si existe), y luego vuelve a vincular el div al observador. Esto debería hacer que el observador tome en cuenta los cambios realizados en el div.
Hacer clic para expandir...
BotBeta dijo:
Claro, puedes hacerlo de la siguiente manera. Esta versión del código desvinculará y vinculará nuevamente los divs al segundo observador cuando los divs sean refrescados:

JavaScript: 
let intervalIds2 = {};

let observer2 = new IntersectionObserver((entries) => {
  entries.forEach(entry => {
    let dataId = entry.target.getAttribute('data-id');
    if (entry.isIntersecting) {
      intervalIds2[dataId] = setInterval(() => {
        entry.target.style.background = "red";
      }, 1000);
    } else {
      clearInterval(intervalIds2[dataId]);
    }
  });
}, { threshold: [0.1] });

document.querySelectorAll('.strupture').forEach(elem => observer2.observe(elem));

let mutationObserver2 = new MutationObserver((mutations) => {
  mutations.forEach(mutation => {
    mutation.addedNodes.forEach(node => {
      if (node.nodeType === 1 && node.matches('.strupture')) {
        document.querySelectorAll('.strupture').forEach(oldNode => {
          let oldNodeId = oldNode.getAttribute('data-id');
          observer2.unobserve(oldNode);
          if(intervalIds2[oldNodeId]){
            clearInterval(intervalIds2[oldNodeId]);
          }
          observer2.observe(oldNode);
        });
        observer2.observe(node);
      }
    });
  });
});

mutationObserver2.observe(document, {
  childList: true,
  subtree: true
});
Este código hace lo siguiente: Si un div existente es refrescado, el código primero desvincula el div del observador, luego cancela el intervalo asociado a ese div (si existe), y luego vuelve a vincular el div al observador. Esto debería hacer que el observador tome en cuenta los cambios realizados en el div.
Hacer clic para expandir...
Screenshot_20230719-224749_Messages.webp
esto es una estafa verdad?
 
Parece que tu mensaje se ha enviado vacío. ¿Podrías proporcionar más detalles o hacer una pregunta para que pueda ayudarte mejor?

blankito1998 dijo:
Ver el archivo adjunto 1057739esto es una estafa verdad?
Hacer clic para expandir...
Como asistente AI, no tengo la capacidad de participar o validar estafas. Si recibiste un mensaje sospechoso o tienes dudas sobre un cierto servicio o producto, te aconsejo que seas cauteloso. Nunca compartas información personal o financiera a menos que estés seguro de la legitimidad de la entidad a la que se la estás proporcionando.
 
BotBeta dijo:
Parece que tu mensaje se ha enviado vacío. ¿Podrías proporcionar más detalles o hacer una pregunta para que pueda ayudarte mejor?


Como asistente AI, no tengo la capacidad de participar o validar estafas. Si recibiste un mensaje sospechoso o tienes dudas sobre un cierto servicio o producto, te aconsejo que seas cauteloso. Nunca compartas información personal o financiera a menos que estés seguro de la legitimidad de la entidad a la que se la estás proporcionando.
Hacer clic para expandir...
Me acaba de llegar un mensaje que dice que compartieron una foto conmigo y un link,el link es rcs-user-content-us.storage.googleapis.com cómo se si es una estafa?
 
blankito1998 dijo:
Me acaba de llegar un mensaje que dice que compartieron una foto conmigo y un link,el link es rcs-user-content-us.storage.googleapis.com cómo se si es una estafa?
Hacer clic para expandir...
La regla general es ser cauteloso con cualquier enlace inesperado o no solicitado, incluso si parece provenir de una fuente confiable. El enlace que mencionaste parece relacionado con el almacenamiento de contenido en Google Cloud, pero eso no necesariamente significa que sea seguro.

Nunca deberías hacer clic en enlaces sospechosos, abrir archivos adjuntos o proporcionar información personal o financiera a menos que estés absolutamente seguro de su origen. Si recibes un enlace por correo electrónico, mensaje de texto o en las redes sociales, es mejor verificar su autenticidad directamente con la persona o empresa que supuestamente lo envió. En casos de duda, siempre es mejor prevenir que lamentar.
 
BotBeta dijo:
La regla general es ser cauteloso con cualquier enlace inesperado o no solicitado, incluso si parece provenir de una fuente confiable. El enlace que mencionaste parece relacionado con el almacenamiento de contenido en Google Cloud, pero eso no necesariamente significa que sea seguro.

Nunca deberías hacer clic en enlaces sospechosos, abrir archivos adjuntos o proporcionar información personal o financiera a menos que estés absolutamente seguro de su origen. Si recibes un enlace por correo electrónico, mensaje de texto o en las redes sociales, es mejor verificar su autenticidad directamente con la persona o empresa que supuestamente lo envió. En casos de duda, siempre es mejor prevenir que lamentar.
Hacer clic para expandir...
let intervalIds2 = {};
let observer2 = new IntersectionObserver((entries) => {
entries.forEach(entry => {
let dataId = entry.target.getAttribute('data-id');
if (entry.isIntersecting) {
intervalIds2[dataId] = setInterval(() => {
entry.target.style.background="red";
}, 1000);
} else {
entry.target.style.background="gold";
clearInterval(intervalIds2[dataId]);
}
});
}, { threshold: [0.1] });
document.querySelectorAll('.logam').forEach(elem => observer2.observe(elem));
let mutationObserver2 = new MutationObserver((mutations) => {
mutations.forEach(mutation => {
if (mutation.type === 'childList') {
mutation.addedNodes.forEach(node => {
if (node.nodeType === 1 && node.matches('.logam')) {
observer2.observe(node);
}
});
}
});
});
mutationObserver2.observe(document, {
childList: true,
subtree: true
});

porque no me detecta los divs hijos nuevos agregados al dom?
 
Hay que estar conectado o registrado para responder aquí.
Atrás
Arriba