suyog's questions

Estou tendo um comportamento inesperado. Ou seja, coloquei uma condição de salto na consulta e, mesmo quando a condição de salto deveria ser verdadeira, a consulta continua sendo executada. Fiz uma reprodução mínima do bug.

Aplicativo.jsx:

import { useState } from "react";
import "./App.css";
import { Test } from "../test";
import { useApolloClient } from "@apollo/client";

export default function App() {
  const [bool, setBool] = useState(false);
  const client = useApolloClient();
  return (
    <main>
      <button
        onClick={() => {
            if (bool) {
              client.resetStore();
            }
          setBool((bool) => {
            return !bool;
          });
        }}
      >
        Click me
      </button>
      {bool && <Test bool={bool} />}
    </main>
  );
}

teste.jsx:

import { gql, useQuery } from "@apollo/client";

const testQuery = gql`
  query {
    countries {
      name
    }
  }
`;
export const Test = ({ bool }) => {
  const { data, loading, error } = useQuery(testQuery, {
    skip: !bool,
    variables:{holy:"shit"}
  });
  if (loading) return <p>Loading...</p>;
  if (error) return <p>Error :(</p>;
  return (
    <div>
      {data.countries.map((country) => (
        <div key={country.name}>{country.name}</div>
      ))}
    </div>
  );
};

Estou usando a API de países fornecida pela Apollo GraphQL.

Aqui, quando o botão é clicado pela primeira vez, a consulta é enviada ao servidor que faz sentido. Então, quando ele é clicado novamente (ou seja, tornando bool=false), o cache deve ser limpo e a consulta não deve ser executada, pois está sendo ignorada, mas ela é executada (posso ver que está em execução olhando para a guia de rede). Ao fazer a renderização condicional do teste, pensei que a consulta não seria executada com certeza, pois o componente nem renderizava, mas estava sendo executado novamente, então acho que o problema é que a consulta está em execução entre o momento em que o cache é limpo e o ReactJS atualiza completamente o estado. Acho que não entendo alguns conceitos sobre estados. Como posso evitar que a consulta seja executada quando eu não quero? Agradeço sua ajuda.

Você pode ver aqui por si mesmo relitLink

Este é o meu código

import { useEffect, useRef, useState } from "react";
import PostContainer from "./postContainer.jsx"

export function App(props) {
  const postContainerRef=useRef()
  useEffect(()=>{
    console.log(postContainerRef.current)
  },[postContainerRef])
  return (
    <div className='App'>
      <h1>Hello React.</h1>
      <PostContainer 
      ref={postContainerRef}
      some_prop={"meow"} />
    </div>
  );
}

aqui eu quero usar postContainerRefuma vez definido, mas é apenas um registro indefinido. Tentei usar [postContainerRef.current]como matriz de dependência, mas também não fez nada.

import { useState, useEffect, useRef, forwardRef } from "react";

const PostContainer = forwardRef((props, ref) => {
    useEffect(()=>{
      console.log(ref.current)
    },[ref])
    return <>
    <div>This is Container</div>
    </>
})

export default PostContainer

Também quero acessar o elemento Container depois de renderizado, mas ele também está registrando indefinido.

Playcode playground

quero desenhar um semicírculo dentro de uma superfície. Então pensei em usar, pygame.draw.arc() mas não consigo descobrir como desenhar o arco dentro de uma superfície. Vi os documentos oficiais e estou usando math.radians()para converter graus em radianos, mas não consigo ver o arco. Um círculo está sendo desenhado...

import pygame
import math

pygame.init()
width, height = 800, 600
screen = pygame.display.set_mode((width, height))

surf = pygame.Surface((100, 100))
surf.fill("green")
rect = surf.get_rect(center=(100, 100))

run = 1
while run:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            run = 0

    screen.fill((255, 202, 135))
    pygame.draw.circle(surf, (255, 255, 255), (30,30),25)
    pygame.draw.arc(surf, (255, 255, 255), rect, math.radians(270), math.radians(90))
    screen.blit(surf, rect)

    pygame.display.flip()
pygame.quit()

desde já, obrigado

sempre que executo este código, a animação é executada de maneira suave, mas, pelo que parece, quando a temperatura chega ao comprimento da lista e volta a zero, a imagem pisca

não é que as imagens que estão sendo animadas não estão sincronizadas corretamente fiz um gif para ver se as imagens tinham algum problema de enquadramento mas não tem nenhum no gif a animação é suave

exemplo de replicação com imagens

import pygame,os

pygame.init()
window=pygame.display.set_mode((600,600))
clock=pygame.time.Clock()
run=[]
for image in os.listdir("run"):
    run.append(
        pygame.transform.scale(
            pygame.image.load("run/" + image),
            (40, 40),
        ).convert_alpha()
    )

temp=0
diff=0.2
index=0
while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            

    temp+=diff
    if temp>=len(run):
        temp=0
    index=int(temp)
    print(index)
    window.fill("white")

    window.blit(run[index],(300,300))
    pygame.display.flip()
    clock.tick(60)