Início / coding / 问题

All perguntas(coding)

Martin Hope
Mark Theis
Asked: 2025-04-05 07:37:13 +0800 CST
  • 11

Se eu tiver um array, ou um ponteiro para um array, do tipo uint32_t, meus arrays são quase sempre menores em comprimento do que o máximo que eu precisaria indexar com um uint32_t. No entanto, descobri que ao usar uint64_tem vez de uint32_tcomo um índice, o compilador evita algumas movinstruções.

Aqui está um exemplo muito simples para ilustrar isso:

Código fonte:

#include <cstdint>

void set_value(uint32_t* __restrict array, const uint32_t idx, const uint32_t value)
{
    array[idx] = value;
}

void set_value(uint32_t* __restrict array, const uint64_t idx, const uint32_t value)
{
    array[idx] = value;
}

Montagem gerada usando Clang 14.0.0 com -O3 -march=skylake -std=c++17 -mno-vzeroupper:

set_value(unsigned int*, unsigned int, unsigned int):
  mov eax, esi
  mov dword ptr [rdi + 4*rax], edx
  ret

set_value(unsigned int*, unsigned long, unsigned int):
  mov dword ptr [rdi + 4*rsi], edx
  ret

Alguém pode explicar as diferentes saídas do compilador? Por que a uint64_tversão pula a movinstrução?

c++
Martin Hope
Chu Man Ki Morris
Asked: 2025-04-05 07:27:06 +0800 CST
  • 5

Tenho o seguinte código em que o hyperlink será gerado dinamicamente. Os hyperlinks podem ser gerados com sucesso.

índice.html

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <link rel="stylesheet" href="styles.css" />
    <title>Timely</title>
  </head>
  <body id=settingbg>
  <a href=index.html>Home</a>
    <div id="stopping"><div id=stopitem></div>
  </body>
  <script src="setting.js"></script>
</html>

script.js

let stopping = document.getElementById("stopping");

showstop();

function showstop(){
    chrome.storage.local.get(['stops'], function(result) {
        let stopsp = (result.stops).split(",");
        for(i=0;i<stopsp.length;i++){
            stopping.innerHTML += "<div id=stopitem><a href='#' id='linkPassValue' data-value='"+stopsp[i]+"'>"+stopsp[i]+"</a></div>";
        }
    });
}

document.addEventListener('DOMContentLoaded', function() {
  document.querySelector('#linkPassValue')?.addEventListener('click', function(e) {
    e.preventDefault();
    const value = this.getAttribute('data-value');
    alert(value);
  });
});

No entanto, a ação onclick não funciona uma vez que os hiperlinks são gerados. Alguém pode me ajudar a conseguir isso? Obrigado.

google-chrome-extension
Martin Hope
zagpoint
Asked: 2025-04-05 07:25:48 +0800 CST
  • 7

Tenho um objeto do tipo dict/json que capturei da saída de uma chamada de API REST, digamos que esteja em uma variável/registrador chamado output . Os dados são os seguintes. Para completar, compartilhei o objeto inteiro e fiz uma limpeza básica. Sinta-se à vontade para focar apenas na linha que discutirei a seguir ;-)

            {
            "_create_time": 1724823837185,
            "_create_user": "system",
            "_last_modified_time": 1736218001919,
            "_last_modified_user": "nsx_policy",
            "_protection": "NOT_PROTECTED",
            "_revision": 1,
            "_system_owned": false,
            "display_name": "w1-vc1-c4n17.example.com",
            "host_switch_spec": {
                "host_switches": [
                    {
                        "cpu_config": [],
                        "ecmp_mode": "L3",
                        "host_switch_id": "50 01 cb 21 be 19 cb 38-78 bd 67 bc b3 0e 91 f1",
                        "host_switch_mode": "STANDARD",
                        "host_switch_name": "w1-vc1-c4-dvs",
                        "host_switch_profile_ids": [
                            {
                                "key": "UplinkHostSwitchProfile",
                                "value": "/infra/host-switch-profiles/6d7a0ed8-c86a-4190-9121-ce6f863226ae"
                            },
                            {
                                "key": "VtepHAHostSwitchProfile",
                                "value": "/infra/host-switch-profiles/0de8282e-7385-4e8e-a905-0c11960db728"
                            }
                        ],
                        "host_switch_type": "VDS",
                        "ip_assignment_spec": {
                            "ip_pool_id": "/infra/ip-pools/w1-nsx1-esxi-teps",
                            "resource_type": "StaticIpPoolSpec"
                        },
                        "is_migrate_pnics": false,
                        "not_ready": false,
                        "portgroup_transport_zone_id": "/infra/sites/default/enforcement-points/default/transport-zones/77166711-1f83-407f-8c27-a4e1b8b4e1e5",
                        "transport_zone_endpoints": [
                            {
                                "transport_zone_id": "/infra/sites/default/enforcement-points/default/transport-zones/4b367ddf-d4ac-460b-a884-24846ff4edf6",
                                "transport_zone_profile_ids": [
                                    {
                                        "profile_id": "/infra/transport-zone-profiles/52035bb3-ab02-4a08-9884-18631312e50a",
                                        "resource_type": "BfdHealthMonitoringProfile"
                                    }
                                ]
                            },
                            {
                                "transport_zone_id": "/infra/sites/default/enforcement-points/default/transport-zones/bc19b340-f0b5-46d8-9454-6d94d3288821",
                                "transport_zone_profile_ids": [
                                    {
                                        "profile_id": "/infra/transport-zone-profiles/52035bb3-ab02-4a08-9884-18631312e50a",
                                        "resource_type": "BfdHealthMonitoringProfile"
                                    }
                                ]
                            }
                        ],
                        "uplinks": [
                            {
                                "uplink_name": "uplink-2",
                                "vds_uplink_name": "uplink2"
                            },
                            {
                                "uplink_name": "uplink-1",
                                "vds_uplink_name": "uplink1"
                            }
                        ]
                    }
                ],
                "resource_type": "StandardHostSwitchSpec"
            },
            "id": "w1-vc1-c4n17-6adb838f-669c-48ca-b76f-e1238984ef93host-2171",
            "is_overridden": false,
            "maintenance_mode": "DISABLED",
            "marked_for_delete": false,
            "node_deployment_info": {
                "compute_collection_id": "6adb838f-669c-48ca-b76f-e1238984ef93:domain-c2147",
                "discovered_ip_addresses": [
                    "x.x.x.x",
                    "x.x.x.x"
                ],
                "discovered_node_id": "6adb838f-669c-48ca-b76f-e1238984ef93:host-2171",
                "fqdn": "w1-vc1-c4n17.example.com",
                "ip_addresses": [
                    "10.x.x.x"
                ],
                "managed_by_server": "10.x.x.x",
                "os_type": "ESXI",
                "os_version": "x.x.x"
            },
            "overridden": false,
            "owner_id": "1ae23909-d587-4683-a515-4c2001940803",
            "parent_path": "/infra/sites/default/enforcement-points/default",
            "path": "/infra/sites/default/enforcement-points/default/host-transport-nodes/w1-vc1-c4n17-6adb838f-669c-48ca-b76f-e1238984ef93host-2171",
            "realization_id": "c2c69a21-698a-4586-869a-7c0b0a651601",
            "relative_path": "w1-vc1-c4n17-6adb838f-669c-48ca-b76f-e1238984ef93host-2171",
            "remote_path": "",
            "resource_type": "HostTransportNode",
            "unique_id": "c2c69a21-698a-4586-869a-7c0b0a651601"
        }

Gostaria de atualizar este objeto alterando a seguinte linha:

"host_switch_mode": "STANDARD",

para:

"host_switch_mode": "LEGACY",

E alimentarei o resultado JSON como um corpo de mensagem para uma chamada de API POST. Tentei o filtro combine do anislbe, mas não obtive o resultado esperado. Algo como:

- Name: example post/put API call
  uri:
    url: "https://{{ nsx }}/policy/api/v1/infra/host-transport-node-profiles/{{ id }}"
        force_basic_auth: yes
        validate_certs: no
        headers:
          Accept: "application/json"
          Content-Type: "application/json"
        user: "{{ username }}"
        password: "{{ password }}"
        method: PUT
        body: "{{ ouput | combine( {'host_switch_spec': {'host_switches': [ {'host_switch_mode': "LEGACY"},],}, }, recursive=true) }}"
        status_code: "200"
        body_format: json

Com o filtro de combinação, o que vejo é que, em vez de apenas mesclar a linha relevante, toda a seção host_switch_spec é substituída (perdendo, portanto, outros atributos, como host_switch_name, host_switch_id, etc.), o que não é o que eu quero:

            "host_switch_spec": {
            "host_switches": [
                {
                    "host_switch_mode": "STANDARD"
                }
            ],
            "resource_type": "StandardHostSwitchSpec"
        },

O que eu fiz de errado? Consultei a página de manual do filtro Combine e tentei todas as opções do list_merge , mas nenhuma delas ajudou.

atualizar:

Para simplificar, uma das complicações que não mencionei na minha postagem inicial é que tenho uma lista desses objetos de dados de "saída" e preciso processá-los em um loop como o mostrado abaixo. Digamos que a lista esteja na variável "tn":

  # Modify the transport node json data on the fly and feed it to the API as message body
  - debug: 
      msg: 
        - "{{ item }}"
        - "{{ item | combine( {'host_switch_spec': {'host_switches': [ {'host_switch_mode': mode}, ], }, },) }}"
    with_items: "{{ tn }}"
    loop_control:
      label: "{{ item.display_name }}"

Resumo:

Obrigado a todos pela ajuda e orientação. Ainda não concluí os testes de ponta a ponta, mas aqui está o que criei com base nos exemplos fantásticos de Vladimir Botka:

      # how to modify the transport node json data on the fly and feed it to the API as message body
  - name: Testing switch mode update on the fly
    debug: 
      msg:
        #- "hs: {{ (item.host_switch_spec.host_switches + [ hs_update ]) | combine }}"
        #- "update: {{ {'host_switch_spec': {'host_switches': [ (item.host_switch_spec.host_switches + [ hs_update ]) | combine ]}} }}"
        #- "result: {{ item | combine({'host_switch_spec': {'host_switches': [ (item.host_switch_spec.host_switches + [ hs_update ]) | combine ]}}) }}"
        - "{{ item | combine({'host_switch_spec': {'host_switches': [ (item.host_switch_spec.host_switches + [ hs_update ]) | combine ]}}) }}"
    loop: "{{ tn }}"
    loop_control:
      label: "{{ item.display_name }}"
      index_var: counter
    vars:
      hs_update:
        host_switch_mode: "LEGACY"

E o resultado parece promissor (mostrando o último - #24, e apenas parcial para evitar confusão):

ok: [localhost] => (item=w11-vc1-c1n24.example.com) => {
"msg": [
    "24':' STANDARD",
    {
        "_create_time": 1743198123451,
        "_create_user": "system",
        "_last_modified_time": 1743445520238,
        "_last_modified_user": "system",
        "_protection": "NOT_PROTECTED",
        "_revision": 2,
        "_system_owned": false,
        "display_name": "w11-vc1-c1n24.example.com",
        "host_switch_spec": {
            "host_switches": [
                {
                    "cpu_config": [],
                    "ecmp_mode": "L3",
                    "host_switch_id": "50 1e 66 c9 c5 fb da b3-5e 1f 45 fc 2a 42 99 50",
                    "host_switch_mode": "LEGACY",
                    "host_switch_name": "w11-vc1-dvs",
                    "host_switch_profile_ids": [
                        {
                            "key": "UplinkHostSwitchProfile",
                            "value": "/infra/host-switch-profiles/ace9be64-9728-4340-968e-a62dae6a3d00"
                        },
                        {
                            "key": "VtepHAHostSwitchProfile",
                            "value": "/infra/host-switch-profiles/0de8282e-7385-4e8e-a905-0c11960db728"
                        }
                    ],
                    "host_switch_type": "VDS",
json
Martin Hope
beginnercoder
Asked: 2025-04-05 07:25:02 +0800 CST
  • 4

Estou tentando inserir um áudio em um código enquanto ele é executado, mas como o navegador que uso não permite reprodução automática (Safari e Chrome), tentei usar um "botão" no início para reproduzir o áudio, mas ele continua travando. Não sei como criar botões, então estou usando um retângulo e, quando o mouse é pressionado dentro da barreira do retângulo, a variável para iniciar o áudio se torna verdadeira. Este é o meu código:

if(starty = 380){ /*if it’s pressed at a specific time*/
  if(startx + startw > mouseX && mouseX > startx){
    if(starty + starth > mouseY && mouseY > starty) {
        if(mouseIsPressed){
          start = true;
        } 
  }
  }
}

if (start == true){
  startr = 0;
  song.play();
}

Mas imaginei que, como o áudio é reproduzido continuamente enquanto start = true, isso acontece muitas vezes e trava.

Tentei adicionar um loop for ao song.play(), mas não funcionou :(

if (start == true){
  startr = 0;
  for (let i = 0; i < 2; i += 1) { /*hopefully this makes it run only once*/
    song.play();
  }
}

Mas ainda trava e não sei o que fazer. Além disso, é a primeira vez que faço uma pergunta, então pode ficar um pouco confuso, desculpe. Obrigado!

javascript
Martin Hope
Bill
Asked: 2025-04-05 07:16:13 +0800 CST
  • 6

Estou muito confuso e um pouco preocupado ao descobrir o seguinte comportamento, onde tenho dois testes e dois acessórios.

import pytest


@pytest.fixture
def new_object():
    return list()


@pytest.fixture
def a_string(new_object):
    # Change this instance of the object
    new_object.append(1)
    return "a string"


def test_1(new_object):
    assert len(new_object) == 0


def test_2(a_string, new_object):
    assert len(new_object) == 0

O primeiro teste passa, mas o segundo falha.

    def test_2(a_string, new_object):
>       assert len(new_object) == 0
E       assert 1 == 0
E        +  where 1 = len([1])

tests/test_pytest_list.py:21: AssertionError
================================================ short test summary info =================================================
FAILED tests/test_pytest_list.py::test_2 - assert 1 == 0
============================================== 1 failed, 1 passed in 0.36s ===============================================

Eu esperava que os equipamentos passassem novas instâncias de um objeto (a menos que especificado de outra forma), não o mesmo objeto que algum outro equipamento modificou.

De acordo com a documentação sobre o escopo dos acessórios, está escrito:

o padrão é invocar uma vez por função de teste

Outro equipamento não se qualifica como uma função?

ATUALIZAR

Com base nos comentários, agora entendo o problema, embora eu ainda ache que é um comportamento perigoso para uma ferramenta de teste de unidade.

Aqui está outro uso inválido de fixtures que uma pessoa ingênua como eu pode não perceber que é errado:

@pytest.fixture
def new_object():
    """I want to test instances of this class"""
    return list()


@pytest.fixture
def case_1(new_object):
    new_object.append(1)
    return new_object


@pytest.fixture
def case_2(new_object):
    new_object.append(2)
    return new_object


def test_cases(case_1, case_2):
    assert sum(case_1) + sum(case_2) == 3  # fails: assert (3 + 3) == 3
python
Martin Hope
Matteo
Asked: 2025-04-05 07:14:11 +0800 CST
  • 5

Estou trabalhando em um gráfico mostrando a distribuição de comprimento de alguns eventos no genoma humano. Estou bem com o resultado final, mas gostaria de adicionar um geom_labelpara a contagem mais alta relatando o comprimento correspondente no eixo x , bem como uma geom_densitydistribuição — se possível.

Sobre o rótulo, a cor pode refletir a mesma correspondente à barra associada, a menos que não seja o caso por padrão? Obrigado antecipadamente!

Abaixo o código que estou usando e uma dput()parte da entrada junto com a saída final que estou obtendo do gráfico.

library(scico)
library(readr)
library(stringr)
library(ggplot2)

retros <- read_delim("/path/to/homo_sapiens_Retrogenes.fasta.txt", delim = "\n", col_names = FALSE) #import the data

#wrangle
single_retro <- str_split(retros, ">retro_hsap_[0-9]+")

a=list()
for (i in seq_along(single_retro)){
  for (j in seq_along(single_retro[[i]])) {
    a <- c(a, single_retro[[i]][[j]])
  }
}; a[[1]] <- NULL

len=vector()
for (s in 1:length(a)) {
  len <- c(len, str_count(a[[s]], "[A-Z]"))
}

#plot
ggplot(as.data.frame(len), aes(len)) +
  geom_bar(color=scico(1229, palette='acton')) + 
  scale_x_continuous(breaks=seq(0,6500,250), expand=c(0, 0)) + 
  scale_y_continuous(limits=c(0,30), expand=c(0, 0)) + theme_bw()

dput(len)– somente os primeiros 1000

c(408L, 321L, 522L, 942L, 462L, 564L, 765L, 747L, 465L, 957L, 
993L, 1056L, 690L, 1554L, 1209L, 246L, 462L, 3705L, 1554L, 507L, 
681L, 1173L, 408L, 330L, 1317L, 240L, 576L, 2301L, 1911L, 1677L, 
1014L, 756L, 918L, 864L, 528L, 882L, 1131L, 1440L, 1167L, 1146L, 
1002L, 906L, 1056L, 1881L, 396L, 1278L, 501L, 1110L, 303L, 1176L, 
699L, 747L, 1971L, 3318L, 1875L, 450L, 354L, 1218L, 378L, 303L, 
777L, 915L, 5481L, 576L, 1920L, 2022L, 1662L, 519L, 936L, 423L, 
1149L, 600L, 1896L, 648L, 2238L, 1419L, 423L, 552L, 1299L, 1071L, 
963L, 471L, 408L, 729L, 1896L, 1068L, 1254L, 1179L, 1188L, 645L, 
978L, 903L, 1191L, 1119L, 747L, 1005L, 273L, 1191L, 519L, 930L, 
1053L, 2157L, 933L, 888L, 591L, 1287L, 457L, 294L, 291L, 669L, 
270L, 556L, 444L, 483L, 438L, 452L, 659L, 372L, 480L, 464L, 477L, 
256L, 350L, 357L, 524L, 477L, 218L, 192L, 216L, 587L, 473L, 525L, 
657L, 241L, 719L, 383L, 459L, 855L, 417L, 283L, 408L, 678L, 681L, 
1254L, 879L, 250L, 857L, 706L, 456L, 567L, 190L, 887L, 287L, 
240L, 960L, 587L, 361L, 816L, 297L, 290L, 253L, 335L, 609L, 507L, 
294L, 1475L, 464L, 780L, 552L, 555L, 1605L, 1127L, 382L, 579L, 
645L, 273L, 241L, 552L, 344L, 890L, 1346L, 1067L, 764L, 431L, 
796L, 569L, 1386L, 413L, 401L, 407L, 252L, 375L, 378L, 339L, 
457L, 1779L, 243L, 701L, 552L, 708L, 174L, 300L, 257L, 378L, 
777L, 729L, 969L, 603L, 378L, 436L, 348L, 399L, 1662L, 1511L, 
799L, 715L, 1400L, 399L, 516L, 399L, 355L, 1291L, 1286L, 657L, 
374L, 492L, 334L, 295L, 210L, 270L, 858L, 1487L, 1020L, 1641L, 
417L, 396L, 303L, 553L, 492L, 1097L, 612L, 441L, 654L, 611L, 
532L, 474L, 864L, 377L, 465L, 435L, 1003L, 608L, 486L, 748L, 
351L, 245L, 545L, 627L, 303L, 457L, 419L, 449L, 843L, 312L, 398L, 
704L, 315L, 330L, 1054L, 259L, 507L, 372L, 468L, 345L, 1303L, 
408L, 1031L, 471L, 653L, 925L, 397L, 231L, 684L, 449L, 336L, 
344L, 619L, 917L, 417L, 516L, 359L, 550L, 222L, 789L, 608L, 659L, 
853L, 360L, 657L, 372L, 305L, 353L, 650L, 564L, 547L, 969L, 505L, 
230L, 953L, 769L, 307L, 516L, 408L, 342L, 267L, 570L, 572L, 348L, 
1005L, 981L, 1586L, 1302L, 369L, 1290L, 1458L, 572L, 1122L, 363L, 
879L, 651L, 466L, 1203L, 485L, 440L, 473L, 810L, 1320L, 461L, 
455L, 258L, 660L, 297L, 285L, 424L, 273L, 378L, 432L, 293L, 410L, 
327L, 483L, 477L, 551L, 894L, 638L, 538L, 678L, 303L, 478L, 1046L, 
995L, 360L, 252L, 480L, 490L, 475L, 394L, 1185L, 357L, 361L, 
387L, 489L, 450L, 788L, 366L, 340L, 829L, 469L, 404L, 593L, 498L, 
840L, 601L, 235L, 452L, 395L, 504L, 299L, 662L, 357L, 686L, 683L, 
248L, 574L, 1108L, 587L, 483L, 1481L, 1297L, 1334L, 579L, 182L, 
456L, 1335L, 513L, 967L, 918L, 607L, 564L, 727L, 913L, 743L, 
312L, 480L, 659L, 939L, 705L, 1001L, 553L, 339L, 286L, 452L, 
744L, 519L, 521L, 491L, 565L, 522L, 377L, 861L, 812L, 523L, 332L, 
800L, 1015L, 1000L, 513L, 990L, 1003L, 733L, 542L, 940L, 399L, 
399L, 612L, 1361L, 399L, 399L, 318L, 319L, 510L, 504L, 841L, 
1529L, 506L, 1881L, 500L, 358L, 240L, 1261L, 354L, 519L, 779L, 
656L, 311L, 635L, 527L, 759L, 333L, 648L, 770L, 330L, 584L, 453L, 
632L, 513L, 998L, 343L, 696L, 1286L, 391L, 374L, 893L, 375L, 
426L, 658L, 455L, 518L, 466L, 417L, 614L, 285L, 480L, 845L, 344L, 
534L, 572L, 1727L, 1085L, 480L, 468L, 192L, 348L, 578L, 2433L, 
390L, 1031L, 1129L, 626L, 735L, 963L, 439L, 272L, 806L, 743L, 
560L, 250L, 679L, 459L, 207L, 905L, 616L, 404L, 489L, 582L, 340L, 
435L, 1632L, 417L, 221L, 279L, 462L, 357L, 288L, 248L, 981L, 
1015L, 935L, 678L, 279L, 348L, 470L, 958L, 867L, 352L, 735L, 
293L, 911L, 460L, 767L, 386L, 531L, 411L, 192L, 742L, 373L, 1454L, 
970L, 285L, 468L, 273L, 1527L, 612L, 983L, 552L, 998L, 553L, 
812L, 983L, 403L, 1706L, 781L, 183L, 405L, 891L, 647L, 1022L, 
946L, 476L, 270L, 471L, 888L, 435L, 354L, 563L, 526L, 877L, 1170L, 
351L, 863L, 1503L, 562L, 1174L, 345L, 385L, 275L, 374L, 171L, 
474L, 408L, 1640L, 345L, 462L, 722L, 1645L, 504L, 840L, 459L, 
783L, 501L, 473L, 609L, 684L, 543L, 353L, 788L, 684L, 734L, 242L, 
751L, 478L, 471L, 365L, 293L, 380L, 486L, 617L, 786L, 436L, 632L, 
624L, 386L, 925L, 469L, 405L, 2406L, 462L, 435L, 251L, 1118L, 
349L, 779L, 343L, 458L, 264L, 243L, 935L, 535L, 576L, 480L, 406L, 
606L, 495L, 396L, 456L, 798L, 404L, 285L, 375L, 922L, 1136L, 
330L, 339L, 559L, 998L, 239L, 587L, 468L, 1237L, 1722L, 699L, 
436L, 377L, 306L, 326L, 1076L, 385L, 537L, 315L, 342L, 386L, 
400L, 340L, 202L, 266L, 455L, 435L, 259L, 317L, 456L, 249L, 452L, 
1345L, 699L, 456L, 456L, 453L, 275L, 315L, 693L, 354L, 475L, 
780L, 415L, 956L, 554L, 258L, 418L, 996L, 552L, 511L, 1404L, 
469L, 262L, 398L, 242L, 350L, 538L, 379L, 300L, 460L, 373L, 276L, 
258L, 740L, 609L, 753L, 357L, 495L, 532L, 551L, 234L, 633L, 480L, 
312L, 898L, 350L, 705L, 265L, 345L, 334L, 334L, 582L, 583L, 582L, 
478L, 465L, 480L, 408L, 870L, 624L, 1107L, 303L, 384L, 1165L, 
1456L, 878L, 297L, 301L, 276L, 372L, 551L, 799L, 496L, 204L, 
552L, 791L, 330L, 359L, 480L, 468L, 414L, 1102L, 876L, 1112L, 
850L, 536L, 500L, 374L, 825L, 476L, 499L, 275L, 345L, 616L, 360L, 
609L, 310L, 260L, 376L, 283L, 390L, 1529L, 1310L, 207L, 1039L, 
661L, 570L, 1292L, 914L, 843L, 658L, 302L, 1119L, 609L, 225L, 
317L, 1091L, 225L, 403L, 544L, 495L, 912L, 744L, 473L, 985L, 
342L, 630L, 298L, 392L, 297L, 933L, 888L, 666L, 1023L, 346L, 
310L, 1134L, 840L, 1277L, 387L, 463L, 435L, 610L, 492L, 1107L, 
582L, 582L, 582L, 1307L, 647L, 1280L, 555L, 645L, 267L, 952L, 
588L, 348L, 287L, 507L, 410L, 737L, 731L, 354L, 2192L, 309L, 
388L, 692L, 389L, 742L, 766L, 1228L, 1640L, 237L, 495L, 351L, 
285L, 2443L, 963L, 296L, 420L, 482L, 246L, 553L, 621L, 405L, 
597L, 459L, 310L, 300L, 450L, 471L, 291L, 610L, 723L, 380L, 1439L, 
312L, 900L, 275L, 396L, 342L, 309L, 549L, 355L, 474L, 417L, 372L, 
384L, 291L, 987L, 629L, 407L, 655L, 357L, 473L, 348L, 459L, 599L, 
474L, 430L, 620L, 584L, 546L, 435L, 242L, 1167L, 627L, 378L, 
945L, 349L, 255L, 216L, 530L, 516L, 606L, 449L, 1490L, 401L, 
1070L, 899L, 452L, 1304L, 451L, 723L, 354L, 229L, 629L, 639L, 
501L, 465L, 344L, 1895L, 288L, 341L, 2377L, 542L, 453L, 291L, 
645L, 494L, 471L, 612L, 1294L, 713L, 1291L, 467L, 734L, 300L, 
1432L, 320L, 753L, 609L, 1051L, 231L, 875L, 704L, 438L, 742L, 
504L, 1334L, 738L, 342L, 435L, 1133L, 1229L, 436L, 310L, 494L, 
273L, 1228L, 626L, 470L, 235L, 1264L, 465L, 450L, 350L, 647L, 
541L, 256L, 231L, 435L, 485L, 224L, 555L, 395L, 300L, 969L, 237L
)

teste_len

Martin Hope
Schmaehgrunza
Asked: 2025-04-05 07:12:21 +0800 CST
  • 6

Tenho problemas com vazamentos de memória, então fiz o seguinte código de teste.

#!/usr/bin/cjs
"use strict";
import Gtk from 'gi://Gtk?version=3.0';
 
Gtk.init (null);

const window=  new Gtk.Window ();
let buttons=[], button, box=new Gtk.Box ({ orientation:1}), remove=true;

function construct_buttons ()
   {
   for (let i=0;i<500;i++)
      {
      button=new Gtk.Button ({label:"hello"});
      box.add (button);
      buttons.push (button);
      }
   }
   
setInterval (function ()   
   {
   if (remove)
      {
      for (let i=0;i<500;i++) buttons[i].destroy ();
      buttons=[], button=null;
      }
   else
      {
      construct_buttons ();
      window.show_all ();
      }
   remove=!remove;
   }, 2000);

construct_buttons ();
      
window.add(box);
window.set_title ("Test");
window.connect ('destroy', () => { Gtk.main_quit (); });
window.set_size_request (740, 600);
window.show_all ();

Gtk.main ();

Eu construo 500 botões e os adiciono a uma caixa. Após 2 segundos, eu os destruo com Gtk.widget.destroy() e libero o array de referência buttons=[], button=null, e após 2 segundos eu os construo novamente e assim por diante.

Fazendo isso por um tempo, minha memória cresceu de 17 MiB para mais de 50 MiB. Então parei. Não consigo descobrir o que estou fazendo errado. Tenho o mesmo problema com um aplicativo maior. Este é apenas um pequeno exemplo para teste.

Eu também tentei em vez de destruir. Gtk.widget.remove (widget), e deixei o cjs destruí-lo, mas aqui também a memória cresce.

Eu tenho o cjs versão 6.0.0

insira a descrição da imagem aqui

insira a descrição da imagem aqui

gjs
Martin Hope
yaakov
Asked: 2025-04-05 06:00:27 +0800 CST
  • 6

Tenho uma classe genérica que define um makemétodo, principalmente como uma conveniência para evitar ter que escrever new Foo(). Funciona assim:

class Parent<T> {
    public declare props: T;

    constructor(props: T){
        this.props = props;
    }

    static make<T extends typeof Parent<P>, P = InstanceType<T>['props']>(this: T, props: P): InstanceType<T> {
        return new this(props) as InstanceType<T>;
    }
}

type Props = {
    name: string;
}

class Child extends Parent<Props> {
    public sayName(){
        console.log(this.props.name);
    }
}

const instance = Child.make({
    name: "Bob"
});

instance.sayName(); // "Bob"

Isso está quase certo. O tipo de instanceé a classe resolvida corretamente ( Child), e a sugestão de tipo do IDE para os props também funciona. No entanto, a única coisa que não é feita é validar os props passados ​​para o makemétodo. Como o propsparâmetro é definido como padrão para InstanceType<T>['props'], o compilador não marcará os props ausentes como um erro. Ou seja, se eu deixasse de fora o nameprop, ele não me diria que " nameestá faltando no tipo Props". Tenho brincado com esse conceito genérico por algum tempo e não consegui descobrir como obter essa última peça do quebra-cabeça - ou mesmo se isso é possível.

Alguém tem alguma ideia de como os adereços podem ser validados corretamente?

typescript
Martin Hope
user2366975
Asked: 2025-04-05 05:10:03 +0800 CST
  • 7

Finalmente eu fiz o boost e o beast compilarem, essa é minha primeira tentativa e eu não tenho a mínima ideia sobre asio. Não funciona, e eu não sei por onde começar a procurar. A depuração mostra que o código nem chega às coroutines task_main_GETor .do_session

Como base, peguei o exemplo aqui: beast pode ser usado com a palavra-chave co_await do C++20?

Como @sehe sugeriu desta vez ( da última vez ), não tentei usar nenhuma corrotina personalizada, mas acho que não sei como usar o asio.

Também estou pensando em como fazer co_spawncom o executor. Olhando a assinatura da função, pensei que ele compilaria, mas só consegui fazê-lo executar passando o io_contextque acredito não ser recomendado.

Para ser honesto, e isso é offtopic, ainda não entendi o ponto da run()função de bloqueio. O que eu quero é um cliente http assíncrono com corrotinas, para que eu possa co_awaitresponder no meu aplicativo. Mas como, se ele está bloqueando? Eu basicamente não me importo como o cliente http é implementado internamente, quase parece que o "asio é assíncrono" é enganoso porque isso parece se referir aos internos, mas eu só me importo de fora para que eu possa encadeá-lo bem na lógica do meu aplicativo sem retornos de chamada. No cliente, eu poderia até usar uma biblioteca de bloqueio e jogá-la em alguns threads, não importa para o desempenho, ao contrário de um servidor. Mas sim, eu sei que ele é capaz, e eu tenho que aprender mais sobre isso.

#include "openssl/conf.h"

#include <boost/beast/core.hpp>
#include <boost/beast/http.hpp>
#include <boost/beast/ssl.hpp>
#include <boost/beast/version.hpp>
#include <boost/asio/co_spawn.hpp>  // added
#include <boost/asio/awaitable.hpp>  // added
#include <boost/asio/experimental/promise.hpp> // added
#include <boost/asio/experimental/use_promise.hpp> // added
#include <boost/asio/as_tuple.hpp> // added
#include <boost/asio/detached.hpp> // added
#include <cstdlib>
#include <functional>
#include <iostream>
#include <string>

namespace this_coro = boost::asio::this_coro; // added

#include <boost/certify/extensions.hpp>   // added
#include <boost/certify/https_verification.hpp>   // added

#include <syncstream>  // added

namespace beast = boost::beast;         // from <boost/beast.hpp>
namespace http = beast::http;           // from <boost/beast/http.hpp>
namespace net = boost::asio;            // from <boost/asio.hpp>
namespace ssl = boost::asio::ssl;       // from <boost/asio/ssl.hpp>
using tcp = boost::asio::ip::tcp;       // from <boost/asio/ip/tcp.hpp>
using boost::asio::use_awaitable; // added

//------------------------------------------------------------------------------

#define use_void
#ifdef use_void
using T = void;
#else
using T = std::string;
#endif

// Performs an HTTP GET and prints the response
boost::asio::awaitable<T>
do_session(
    std::string host,
    std::string port,
    std::string target,
    ssl::context& ctx)
{

    beast::error_code ec;

    auto ex = co_await net::this_coro::executor;

    // These objects perform our I/O
    tcp::resolver resolver(ex);
    beast::ssl_stream<beast::tcp_stream> stream(ex, ctx);

    // Set SNI Hostname (many hosts need this to handshake successfully)
    if(! SSL_set_tlsext_host_name(stream.native_handle(), host.c_str()))
    {
        ec.assign(static_cast<int>(::ERR_get_error()), net::error::get_ssl_category());
        std::cerr << ec.message() << "\n";
        co_return;
    }

    try{    
        // Look up the domain name
        auto const results = co_await resolver.async_resolve(host, port, use_awaitable);

        // Set the timeout.
        beast::get_lowest_layer(stream).expires_after(std::chrono::seconds(30));

        // Make the connection on the IP address we get from a lookup
        co_await beast::get_lowest_layer(stream).async_connect(results, use_awaitable);

        // Set the timeout.
        beast::get_lowest_layer(stream).expires_after(std::chrono::seconds(30));

        // Perform the SSL handshake
        co_await stream.async_handshake(ssl::stream_base::client, use_awaitable);

        // Set up an HTTP GET request message
        http::request<http::string_body> req{http::verb::get, target, 11};
        req.set(http::field::host, host);
        req.set(http::field::user_agent, BOOST_BEAST_VERSION_STRING);

        // Set the timeout.
        beast::get_lowest_layer(stream).expires_after(std::chrono::seconds(30));

        // Send the HTTP request to the remote host
        co_await http::async_write(stream, req, use_awaitable);

        // This buffer is used for reading and must be persisted
        beast::flat_buffer b;

        // Declare a container to hold the response
        http::response<http::dynamic_body> res;

        // Receive the HTTP response
        auto [ec, bytes] =
            co_await http::async_read(stream, b, res, boost::asio::as_tuple(use_awaitable));

        // Write the message to standard out
        std::cout << res << std::endl;

        // Set the timeout.
        beast::get_lowest_layer(stream).expires_after(std::chrono::seconds(30));

        if(ec == net::error::eof)
        {
            // eof is to be expected for some services
            if(ec != net::error::eof)
                throw beast::system_error(ec);
        }
        else
        {
            std::cout << res << std::endl;

            // Gracefully close the stream
            co_await stream.async_shutdown(use_awaitable);
        }

    }
    catch(beast::system_error const& se)
    {
        //std::cerr << "Handled: " << se.code().message() << "\n";
        throw; // handled at the spawn site instead
    }

    // If we get here then the connection is closed gracefully
}

//------------------------------------------------------------------------------


boost::asio::awaitable<T> task_main_GET(net::io_context &ioc)
{
    auto const host = "https://microsoftedge.github.io/Demos/json-dummy-data/64KB.json";
    auto const port = "443";
    auto const target = "/";

    std::osyncstream(std::cout) << "GET " << host << ":" << port << target << std::endl;
    // The SSL context is required, and holds certificates
    ssl::context ctx{ssl::context::tlsv12_client};

    // https://stackoverflow.com/a/61429566/2366975
    ctx.set_verify_mode(ssl::context::verify_peer );
    boost::certify::enable_native_https_server_verification(ctx);


    auto ex = this_coro::executor;
    auto task = boost::asio::co_spawn(
        //ex,
        ioc,
        [&]() mutable -> boost::asio::awaitable<std::string>
        {
            co_await do_session(host, port, target, ctx);
        },
        use_awaitable
    );


#ifdef use_void
    co_return;
#else
    std::string responseText = co_await task;
    std::osyncstream(std::cout) << "response:\n" << responseText << std::endl;
    co_return responseText ;
#endif
}

int main()
{
    // The io_context is required for all I/O
    net::io_context ioc;

    // https://stackoverflow.com/questions/79177275/how-can-co-spawn-be-used-with-co-await
    auto task = boost::asio::co_spawn(ioc, task_main_GET(ioc), use_awaitable);

    // Run the I/O service. The call will return when the get operation is complete.
    ioc.run();

    return EXIT_SUCCESS;
}

CMakeLists.txt

cmake_minimum_required(VERSION 3.5)

project(boost_beast_example LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# Fix compiler error C1128
# https://learn.microsoft.com/en-us/cpp/error-messages/compiler-errors-1/fatal-error-c1128?view=msvc-170
if (MSVC)
    add_compile_options(/bigobj)
else ()
    add_compile_options(-Wa,-mbig-obj)   # not tested
endif ()

# OPENSSL =======================================================
# https://cmake.org/cmake/help/v3.31/module/FindOpenSSL.html
set(OPENSSL_ROOT_DIR "C:/OpenSSL-Win64")
set(OPENSSL_INCLUDE_DIR "C:/OpenSSL-Win64/include")
#find_package(OpenSSL REQUIRED PATHS "C:/OpenSSL-Win64/")
find_package(OpenSSL REQUIRED)
link_directories("C:/OpenSSL-Win64/")
include_directories(${OPENSSL_INCLUDE_DIR})
message("OPENSSL_FOUND: " ${OPENSSL_FOUND})
message("OPENSSL_INCLUDE_DIR: " ${OPENSSL_INCLUDE_DIR})
message("OPENSSL_CRYPTO_LIBRARY: " ${OPENSSL_CRYPTO_LIBRARY})
message("OPENSSL_SSL_LIBRARY: " ${OPENSSL_SSL_LIBRARY})

# BOOST =========================================================
# https://cmake.org/cmake/help/v3.31/module/FindBoost.html
set(Boost_DEBUG 1)
SET(CMAKE_INCLUDE_PATH ${CMAKE_INCLUDE_PATH} "G:/SoftwareDev/libs/boost")
SET(CMAKE_LIBRARY_PATH ${CMAKE_LIBRARY_PATH} "G:/SoftwareDev/libs/boost/bin/x64/lib/cmake")
find_package(Boost REQUIRED context system coroutine regex PATHS "G:/SoftwareDev/libs/boost/bin/x64/lib/cmake")
include_directories("G:/SoftwareDev/libs/boost/libs/beast")
include_directories(${Boost_INCLUDE_DIRS})
message("Boost_FOUND: " ${Boost_FOUND})
message("Boost_INCLUDE_DIRS: " ${Boost_INCLUDE_DIRS})
message("Boost_LIBRARY_DIRS: " ${Boost_LIBRARY_DIRS})
message("Boost_LIBRARIES: " ${Boost_LIBRARIES})
message("Boost_CONTEXT_LIBRARY: " ${Boost_CONTEXT_LIBRARY})
message("Boost_SYSTEM_LIBRARY: " ${Boost_SYSTEM_LIBRARY})

find_package(Threads REQUIRED)

add_executable(${PROJECT_NAME} main.cpp)

# CERTIFY FOR BEAST==============================================
include_directories(libs/certify/include)
if(MSVC)
    target_link_libraries(${PROJECT_NAME} Crypt32.lib)
endif()
if(APPLE)
    target_link_libraries(${PROJECT_NAME} INTERFACE "-framework CoreFoundation" "-framework Security")
    set_target_properties(${PROJECT_NAME} PROPERTIES LINK_FLAGS "-Wl,-F/Library/Frameworks")
endif()


target_link_libraries(${PROJECT_NAME}  OpenSSL::Crypto OpenSSL::SSL)
# How to link boost libraries
# https://stackoverflow.com/a/43885372/2366975
target_link_libraries(${PROJECT_NAME} ${Boost_LIBRARIES} Threads::Threads)
c++
Martin Hope
jeromecc
Asked: 2025-04-05 05:07:45 +0800 CST
  • 6

A partir do ES2015, lidar com isso ficou um pouco mais fácil. String.prototype[@@iterator] produz strings correspondentes a pontos de código**. Então, por exemplo, podemos fazer isso:

function capitalizeFirstLetter([ first='', ...rest ]) {
  return [ first.toUpperCase(), ...rest ].join('');
}

Como os parâmetros devem ser digitados no TypeScript para evitar o aviso "O elemento de vinculação 'rest' tem implicitamente um tipo 'any'"?

typescript
Prev
Próximo