All perguntas(coding)

Primeira vez que posto uma pergunta sobre programação aqui. Estou quase terminando um jogo em JS/HTML/CSS e vou publicá-lo no Steam em breve. Resumindo, me deparei com um problema: precisei mover todos os estilos inline do HTML para um arquivo CSS externo. Ao fazer isso, meu código de trabalho parece ter quebrado. Resumi tudo a esta pergunta: por que o botão no código abaixo não exibe a div? Com ​​todos os estilos movidos para um arquivo CSS externo, como posso fazer com que linhas em JavaScript como essa document.getElementById("id").style.display = ""funcionem com ajustes mínimos nas minhas milhares de linhas de código?

CSS :

#testID {
    display: none;
}

HTML :

<div id="testID">
    1234
</div>
<div>
    <button onclick="showFn()">Show</button>
</div>

Javascript :

function showFn() {
  document.getElementById("testID").style.display = ""
}

Plotei alguns gráficos QQ com o pacote car qqPlot {car}. Parece bom, mas não entendi o que são esses dois números dentro do gráfico. Por exemplo, plotei 72 valores e há dois números: 59 e 38. O que esses números estão tentando me dizer? O resumo dos dados do Fivenum é 21,20 26,55 30,50 35,35 47,60, então esses números não são nenhum destes. Veja a captura de tela em anexo. Agradeço antecipadamente!

Tenho um Polars DataFrame abaixo:

import polars as pl
df = pl.DataFrame({"a":[1, 2, 3], "b":[4, 3, 2]})

>>> df
  a    b
i64  i64
  1    4
  2    3
  3    2

Posso subdividir com base em um valor específico:

x = df[df["a"] == 3]

>>> x
  a    b
i64  i64
  3    2

Mas como posso subdividir com base em uma lista de valores? - algo assim:

list_of_values = [1, 3]
y = df[df["a"] in list_of_values]

Obter:

  a    b
i64  i64
  1    4
  3    2

Estou explorando o recurso "deduzindo isso" e estou com dificuldades para entender como usá-lo corretamente com conceitos. Aqui está o que eu tenho:

#include <concepts>

struct X {
  X() = default;
  X& operator+=(int x) { value += x; return *this; }
  int value = 0;
};

struct Y {
  Y() = default;
  template<typename Self> Self& operator+=(this Self& self, int x) {
    self.value += x; return self;
  }
  int value = 0;
};

template<typename T, typename U>
concept has_addition_assignment =
  std::is_lvalue_reference_v<T>
  && requires(T a, U b) { { a += b } -> std::same_as<T>; };

static_assert(has_addition_assignment<X&,int>); // OK
static_assert(!has_addition_assignment<const X&,int>); // OK

static_assert(has_addition_assignment<Y&,int>); // OK
// static_assert(!has_addition_assignment<const Y&,int>); // Fails

int
main()
{
  // Not allowed.
  //  const Y y;
  //  y += 1;
}

O conceito é tentar garantir que X x; x += 1;funcione, mas const X x; x += 1não funciona. Isso funciona para, Xmas não funciona Y, apesar de const Y y; y += 1;falhar.

Acredito que meu conceito está escrito incorretamente ou talvez +=não Yexpresse minha intenção corretamente. Qual é a melhor maneira de verificar se não é aceitável adicionar algo a um objeto constante ao usar deducing this?

Estou tentando criar um evento, mas gostaria de não ter os nomes padrão (arg1, arg2, etc.)

Como posso definir nomes padrão para que, em vez de algo

TypeName_MethodName(int arg1, string arg2) 

Posso obter algo assim:

TypeName_MethodName(int age, string name)?

Editar: código (não tenho certeza do porquê isso importa para algo assim), não ligue para meu código provavelmente ineficiente, não é por isso que estamos aqui:

namespace Test
{
    public static class People
    {
        public static event Action<int, string> OnPersonAdded = (age, name) => { };

        public static void AddPerson(int age, string name)
        {
            if (!PeopleByAge.TryAdd(age, [name]))
            {
                PeopleByAge[age].Add(name);
            }

            OnPersonAdded(age, name);
        }

        public static Dictionary<int, List<string>> PeopleByAge = [];
    }

    public static class Program
    {
        public static void Main(string[] args)
        {
            People.OnPersonAdded += People_OnPersonAdded;
            People.AddPerson(int.Parse(args[0]), args[1]);
        }

        private static void People_OnPersonAdded(int arg1, string arg2)
        {
            Console.WriteLine($"Add person {arg2}, aged {arg1}.");
        }
    }
}

Quero alterar os rótulos das colunas de um Polars DataFrame de

['#a', '#b', '#c', '#d']

para

['a', 'b', 'c', 'd']

Estou escrevendo um sintetizador de áudio e quero usar a cpalcaixa para gerar áudio. Isso acontece gerando uma thread de saída, cuja função de "geração de dados" precisa implementar FnMut(&mut [T], &OutputCallbackInfo) + Send + 'static. Isso OutputCallbackInfoé irrelevante para a questão em questão.

Para gerar o áudio, tenho uma AudioPipelineestrutura:

pub struct AudioPipeline {
    producer: Box<dyn AudioProducer + Sync>,
    modifiers: Vec<Box<dyn AudioModifier + Sync>>,
}

onde AudioProducere AudioModifiersão algumas outras características. Em main, eu crio um pipeline e o envio para a thread gerada usando um fechamento móvel:

let pipeline = AudioPipeline::new(Box::new(sine), vec![Box::new(asdr)]);
let stream = device
    .build_output_stream(
        ...
        move |data: &mut [u8], callback_info: &cpal::OutputCallbackInfo| {
            ...
            pipeline.recv();
            ...
        },
        ...
    );

Aqui pipeline.recv()está um método AudioPipelineque leva &mut self.

O código não compila, retornando este erro:

(dyn AudioProducer + Sync + 'static) cannot be sent between threads safely
the trait bound Unique<(dyn AudioProducer + Sync + 'static)>: Send is not satisfied
required for Unique<(dyn AudioProducer + Sync + 'static)> to implement Send

Imagino que o problema tenha algo a ver com o uso de Box? Mas acho esse erro um pouco difícil de entender: afinal, a documentação diz explicitamente "[ Unique<T>] implementa Send/ Syncse Tfor Send/ Sync." Certamente, ao exigir que o dyn AudioProduceris também seja Sync, ele definitivamente deveria ser Send, certo? Provavelmente estou perdendo alguma sutileza de segurança de thread aqui.

Por que podemos usar arrays de arrays em C? Essa foi a minha pergunta quando abri a linguagem C padrão (C17).

Encontrei algo interessante (6.2.5 "Tipos" /20):

Qualquer número de tipos derivados pode ser construído a partir dos tipos objeto e função, como segue: — Um tipo array descreve um conjunto não vazio de objetos alocados contiguamente com um tipo de objeto membro específico, chamado de tipo elemento. O tipo elemento deve ser completo sempre que o tipo array for especificado. Tipos array são caracterizados por seu tipo elemento e pelo número de elementos no array. Um tipo array é dito ser derivado de seu tipo elemento, e se seu tipo elemento for T, o tipo array é algumas vezes chamado de "array de T". A construção de um tipo array a partir de um tipo elemento é chamada de "derivação de tipo array".

Em C, temos tipos de objeto, tipos de função e tipos incompletos. Os elementos de um array têm um tipo de objeto, não um tipo derivado, e pensei: "E agora?". E então encontrei isto (6.7.6.2/1 e 6.7.6.2/3):

Além dos qualificadores de tipo opcionais e da palavra-chave static, [ e ] podem delimitar uma expressão ou*. Se delimitarem uma expressão (que especifica o tamanho de um array), a expressão deverá ser do tipo inteiro. Se a expressão for uma expressão constante, deverá ter um valor maior que zero. O tipo de elemento não deverá ser um tipo incompleto ou de função. Os qualificadores de tipo opcionais e a palavra-chave static deverão aparecer apenas na declaração de um parâmetro de função com um tipo array e, mesmo assim, apenas na derivação de tipo de array mais externa.

• Se, na declaração “T D1”, D1 tiver uma das formas: D [type-qualifier-listopt assignment-expressionopt] D [type-qualifier-listopt assignment-expression] D [type-qualifier-list static assignment-expression] D [type-qualifier-listopt] e o tipo especificado para ident na declaração “TD” for “derived-declarator-type-list T”, então o tipo especificado para ident será “derived-declarator-type-list array of T”.144) (Consulte 6.7.6.3 para o significado dos qualificadores de tipo opcionais e da palavra-chave static.)

Em 6.7.6.2/1, entendi que o tipo de elemento não pode ser um tipo de função nem um tipo incompleto, mas depois entendi que um tipo de elemento pode ser um tipo de objeto e um tipo derivado. Em 6.7.6.2/3, se o tipo for derivado, podemos criar um array de tipo derivado. E, na minha opinião, array é um tipo derivado que pode ser classificado como tipo de objeto. Mas esta é apenas a minha opinião, não digo que isso seja verdade. Se eu estiver errado, por favor, explique o porquê.

Estou lendo aqui e ali sobre vinculações de estrutura em C++20 especificamente. Esse recurso foi, no entanto, introduzido em C++17 e teve poucos problemas:

1. Não é possível usar especificadores de armazenamento ( staticou thread_local)
2. Quando usado dentro de uma classe, se os membros de dados forem, privateas ligações de estrutura usadas em métodos ou funções amigas não devem funcionar.

Para testar isso, escrevi este código:

#include <string>

struct Point {
  int x, y;
};

class AClass {
 private:
  std::string mString;
  int mId;

 public:
  void aMethod(const AClass& p) { 
    auto s = p.mString;
    auto [str, id] = p;  // this should not work, because we're
                         // accessing private memebers
  }
  friend void aFriendFunction(const AClass& p) {  
    auto s = p.mString;
    auto [str, id] = p; // Likewise as aMethod
  }
};

int main() {
  Point p{3, 5};

  // This shouldn't work in C++17
  static auto [u, v] = p;  // This gives a warning, compilation depends

  return 0;
}

O que, pelo que entendi, não deveria funcionar . E presumi que por "não funcionar" não deveria compilar. No entanto, esta linha:

g++ main.cpp -o out -std=c++17

Me dá uma saída que parece válida e sem problemas. Então por que isso está funcionando? Estou esquecendo de algo?

Também estou notando que no gcc 7.1. isso realmente dá o erro esperado (usando um compilador online). Mas ao mudar para minha versão do gcc (13.3.0) recebo o aviso mencionado anteriormente. Isso levanta para mim a questão de como a vinculação estruturada mudou dentro da mesma versão C++.

Estou tentando escrever uma extensão do Chrome para pegar alguns dados armazenados e POSTÁ-los em uma tabela de banco de dados remota. Estou tentando testar a funcionalidade de postagem usando https://www.postb.in/ . Estou usando um painel devtools que adicionei. Percorri o código e parece estar funcionando até a linha 37 em background.js. O que estou fazendo errado?

Panel.js contém:

const toDbBtn = document.getElementById("toDbBtn");

toDbBtn.addEventListener("click", async () => {
  const dbName = document.getElementById("textBox").value;

  try {
    const result = await chrome.storage.local.get(["yourKey"]);

    if (result.yourKey) {
      const savedArray = JSON.parse(result.yourKey);
      console.log(result.yourKey);
      console.log("Saved Array:", savedArray);
      console.log("DB Name:", dbName);
      console.log("Type of result.yourKey:", typeof result.yourKey);
      console.log("Type of savedArray:", typeof savedArray);
      console.log("Is savedArray an array?", Array.isArray(savedArray));

      // Send message to background script
      const response = await chrome.runtime.sendMessage({
        action: "sendToDB",
        data: { dbName: dbName, savedArray: result.yourKey },
      });

      if (response.error) {
        console.error("Error:", response.error);
      } else {
        console.log("Success:", response.result);
      }
    } else {
      console.log("No data found in storage to send.");
    }
  } catch (error) {
    console.error("Error during storage or message sending:", error);
  }
});

fundo.js:

chrome.runtime.onConnect.addListener(port => {});

chrome.runtime.onMessage.addListener(async (request, sender, sendResponse) => {
  if (request.action === "sendToDB") {
    const { dbName, savedArray } = request.data;

    if (typeof dbName !== 'string' || typeof savedArray !== 'string') {
      sendResponse({ error: 'Invalid data types' });
      return false;
    }

    let parsedArray;
    try {
      parsedArray = JSON.parse(savedArray);
    } catch (e) {
      sendResponse({ error: 'Invalid JSON string for savedArray' });
      return false;
    }

    const data = {
      dbName: dbName,
      savedArray: parsedArray,
    };

    const postable = JSON.stringify(data);
    console.log("postable", postable);

    try {
      const response = await fetch("https://www.postb.in/1743970496740-3388752799946", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
        },
        body: postable,
      });

      const result = await response.json();
      console.log("Response from server:", result);
      sendResponse({ result: result });
    } catch (error) {
      sendResponse({ error: error.message });
    }

    return true; // Required for asynchronous response
  }
  return false; // Required if the message is not for this listener
});

manifesto.json:

{
  "manifest_version": 3,
  "name": "myDevTools",
  "version": "1.0",
  "description": "Description of your extension",
  "devtools_page": "devtools.html",

  "host_permissions": [
    "*://*.cnn.com/",
    "https://www.postb.in/*"
  ],
  "permissions": [
    "storage",
    "activeTab",
    "scripting",
    "webNavigation",
    "tabs",
    "unlimitedStorage",
    "cookies",
    "alarms",
    "notifications",
    "contextMenus",
    "offscreen",
    "identity",
    "identity.email",
    "nativeMessaging",
    "browsingData"
  ],
  "background": {
    "service_worker": "background.js"
  }
}

EDIT: Alterei a solicitação POST para:

const response = await fetch("https://www.postb.in/1743979363812-2128863274119", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "Access-Control-Allow-Origin": "*",
      "Access-Control-Allow-Methods": "POST",
      "Access-Control-Allow-Headers": "Content-Type"
    },
    body: postable,
  });