Ooker's questions

Este comando extrai o arquivo ao executá-lo diretamente no PowerShell 7.5.0-rc.1:

Expand-Archive -path .\test.zip -DestinationPath .

Mas executando-o por meio de um script Deno:

new Deno.Command("PowerShell", {
  args: ["Expand-Archive -path ./test.zip -DestinationPath ."],
}).spawn();

produz este erro:

Expand-Archive : The 'Expand-Archive' 
command was found in the module 
'Microsoft.PowerShell.Archive', but the 
module could not be loaded. For more 
information, run 'Import-Module 
Microsoft.PowerShell.Archive'.
At line:1 char:1
+ Expand-Archive -path ./test.zip 
-DestinationPath .
+ ~~~~~~~~~~~~~~
    + CategoryInfo          : ObjectNotFound 
   : (Expand-Archive:String) [], CommandNot  
  FoundException
    + FullyQualifiedErrorId : CouldNotAutolo 
   adMatchingModule

Em seguida, executo este script:

new Deno.Command("PowerShell", {
  args: ["Import-Module Microsoft.PowerShell.Archive"],
}).spawn();

new Deno.Command("PowerShell", {
  args: ["Expand-Archive -path ./test.zip -DestinationPath ."],
}).spawn();

e gera este erro:

Import-Module : File C:\program files\powersh
ell\7-preview\Modules\Microsoft.PowerShell.Ar
chive\Microsoft.PowerShell.Archive.psm1 
cannot be loaded because running scripts is 
disabled on this system. For more 
information, see about_Execution_Policies at 
https:/go.microsoft.com/fwlink/?LinkID=135170
.
At line:1 char:1
+ Import-Module Microsoft.PowerShell.Archive
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : SecurityError: 
    (:) [Import-Module], PSSecurityExceptio  
  n
    + FullyQualifiedErrorId : UnauthorizedAc 
   cess,Microsoft.PowerShell.Commands.Impor  
  tModuleCommand
Expand-Archive : The 'Expand-Archive' 
command was found in the module 
'Microsoft.PowerShell.Archive', but the 
module could not be loaded. For more 
information, run 'Import-Module 
Microsoft.PowerShell.Archive'.
At line:1 char:1
+ Expand-Archive -path ./test.zip 
-DestinationPath .
+ ~~~~~~~~~~~~~~
    + CategoryInfo          : ObjectNotFound 
   : (Expand-Archive:String) [], CommandNot  
  FoundException
    + FullyQualifiedErrorId : CouldNotAutolo 
   adMatchingModule

Aqui está a configuração atual das políticas de execução :

Get-ExecutionPolicy -List

        Scope ExecutionPolicy
        ----- ---------------
MachinePolicy       Undefined
   UserPolicy       Undefined
      Process    Unrestricted
  CurrentUser       Undefined
 LocalMachine    Unrestricted

Você tem alguma ideia?

Como o OpenPGP.js ainda não foi publicado em JSR, preciso importá-lo via HTTP se não quiser cloná-lo para meu local. Usando:

import 'https://unpkg.com/browse/[email protected]/dist/openpgp.js';

Rendimentos:

error: Expected a JavaScript or TypeScript module, but identified a Unknown module. Importing these types of modules is currently not supported.

Ele publica em deno.land/x , mas usando:

import 'https://deno.land/x/[email protected]/mod.js';

produz "Módulo não encontrado".

Meu objetivo final é carregar as credenciais da API do Google no GitHub , criptografando e descriptografando as credenciais.

Das interações da página | Puppeteer :

Locators é a maneira recomendada de selecionar um elemento e interagir com ele. Locators encapsulam as informações sobre como selecionar um elemento e permitem que o Puppeteer espere automaticamente que o elemento esteja presente no DOM e esteja no estado certo para a ação. Você sempre instancia um locator usando a função page.locator() ou frame.locator(). Se a API do locator não oferecer uma funcionalidade que você precisa, você ainda pode usar APIs de nível inferior, como page.waitForSelector() ou ElementHandle.

Esta tabela resume meu entendimento sobre a diferença entre locator()e $():

Tenho algumas perguntas:

• Se locator()espera que o elemento esteja presente no DOM, então não é que ele tem que ter await? Similarmente, se $()não espera, então não é que ele não precisa de await?
• Por que $()um método que não espera que elementos sejam apresentados no DOM tem mais métodos de entrada de dispositivo do que aquele que espera por eles?
• Será que por baixo do capô locator()está a combinação de waitForSelector()e $()?

Pergunta relacionada: O que torna um elemento não clicável ao usar locator(), mas clicável ao usar $()?

Esta é uma maneira de reorganizar as propriedades do objeto no topo da lista de propriedades :

const raw = {
  a: 1,
  b: 2,
  // ...the rest
  y: 3,
  z: 4,
};

const templateTop = {
  y: null,
  z: null,
}

const rearrangedTop = Object.assign(templateTop, raw);
// {
//   y: 3,
//   z: 4,
//   a: 1,
//   b: 2,
//   ...the rest
// };

No entanto, existe uma maneira de reorganizar algumas propriedades para o fundo? Ou seja,

const rearrangedBottom =  {
  // ...the rest
  y: 3,
  z: 4,
  a: 1,
  b: 2,
};

Espero que os tipos de ambos ae bsejam inferidos como número. Por que não é o caso?

const map1 = new Map([
  ["a", 1]
])
const a = map1.get("a") // number | undefined

const map2 = new Map()
map2.set("b", 2)
const b = map2.get("b") // any

Parque infantil

Usando git for-each-ref --format="%(objectname:short) %(refname)"eu obtenho:

207e698 refs/heads/main
f78d212 refs/original/refs/heads/main
24f61e4 refs/original/refs/tags/Cấutrúc1
4248ddd refs/original/refs/tags/Cấutrúc1.1
207e698 refs/remotes/origin/main
bc5335c refs/tags/Cấutrúc2.0
a03c71f refs/tags/Cấutrúc2.0.1
c72d77c refs/tags/Cấutrúc2.1.0
03f6aa0 refs/tags/Cấutrúc2.2.0
391fcd5 refs/tags/cấutrúc2.3.0

O que refs/original/faz? Uma resposta em Remove refs/original/heads/master from git repo after filter-branch --tree-filter? diz que:

refs/original/*está lá como um backup, caso você estrague seu filter-branch. Acredite, é uma ideia muito boa.

Pelo comentário, entendi que não é apenas um backup para filter-branch, mas uma maneira de desencorajá-lo a usá-lo. Suponho que por "ideia realmente boa" a citação anterior significa que é uma ideia realmente boa não usar filter-branch. Mas é a única operação que aciona sua criação? E vejo que tem vários subcaminhos: refs/heads, refs/tags, heads. O que eles estão tentando dizer?

No meu entendimento, unifiedé uma interface para processamento de conteúdo com árvores sintáticas , e remarké um conjunto de plugins . Isso significa que é necessário usar unifiede anexar plug-ins a ele. Por exemplo:

import rehypeSanitize from 'rehype-sanitize'
import rehypeStringify from 'rehype-stringify'
import remarkParse from 'remark-parse'
import remarkRehype from 'remark-rehype'
import {unified} from 'unified'

const file = await unified()
  .use(remarkParse)
  .use(remarkRehype)
  .use(rehypeSanitize)
  .use(rehypeStringify)
  .process('# Hello, Neptune!')

console.log(String(file))

Mas esta página lista exemplos que podem ser usados remark​​diretamente. Por exemplo:

import {remark} from 'remark'
import remarkPresetLintConsistent from 'remark-preset-lint-consistent'
import remarkPresetLintRecommended from 'remark-preset-lint-recommended'
import {reporter} from 'vfile-reporter'

const file = await remark()
  .use(remarkPresetLintConsistent)
  .use(remarkPresetLintRecommended)
  .process('1) Hello, _Jupiter_ and *Neptune*!')

console.error(reporter(file))

Não entendo por que pode funcionar assim. Será que remarké uma versão (ou fork) unifiedmais focada em alguma coisa?

No Preact, quero exibir um objeto:

export default function Component() {
  const obj = { a: 'a', b: 'b'} 
  const elements = [];
  for (const [key, value] of Object.entries(obj)) {
    elements.push(<>{key}: {value}<br></br></>)
  }
  return (
    <article>
      {elements}
    </article>
  );
}

Isso retorna bem:

a: a
b: b

No entanto, se eu extrair o elemento em um elemento JSX separado como este:

function Element({ key, value }) {
  return (<>{key}: {value}<br></br></>);
}
export default function Component() {
  const obj = { a: 'a', b: 'b'} 
  const elements = [];
  for (const [key, value] of Object.entries(obj)) {
    // elements.push(<>{key}: {value}<br></br></>)
    elements.push(<Element key={key} value={value} />)
  }
  return (
    <article>
      {elements}
    </article>
  );
}

Então todas as chaves ficam indefinidas:

: a
: b

Por que isso acontece?

Parque infantil

Estou usando o useState()gancho do Deno Fresh, que é baseado no Preact. Em uma ilha eu tenho:

import { useState } from "preact/hooks";

export default function(){
  const [state, setState] = useState('hi')
  const str = 'a'
  setState(str)
  console.log(state)
} 

Isso funciona bem. Mas se eu usar um objeto:

- const str = 'a'
- setState(str)
+ const obj = {a: 'a'} 
+ setState(obj)

Então fica preso em um loop infinito. Por que é que?

Quero experimentar o toSpliced()método:

const a = [1, 2] as const 
const b = a.toSpliced(0, 1, 'hi') 

Isso dá erro:Argument of type '"hi"' is not assignable to parameter of type '1 | 2'

Eu tento copiar o array:

const copiedA = [...a] //or
const copiedA = a.map(x => x)

ou digite afirmar:

const b = a.toSpliced(0, 1, 'hi') as any

mas nada disso funciona. Há alguma maneira de evitar isto?

Em routes/index.tsxeu tenho:

import Main from "../islands/Counter.tsx";

export default function Home() {
  return (<Main />);
}

Em islands/Counter.tsxeu tenho:

import { useState } from "preact/hooks";

export default function Main() {
  const [count, setCount] = useState<number>(0);
  return (
    <main>
      <button onClick={setCount(count + 1)}>click</button>
      {count}
    </main>
  );
}

A primeira renderização mostra o número 24 e o Firefox diz "Esta página está deixando o Firefox lento". Qual parte estou fazendo errado?

import { A } from "https://example.com/type.d.ts";
type B = A | A

Parque infantil

Se você passar o mouse Bno TS Playground e no VS Code, ele será exibido como Ano caso type B = Ae anyno caso type B = A | A. Independentemente de A ser conhecido ou não, espero que sejam consistentes. Por que não é esse o caso?

Estou usando os componentes Fresh, TailwindCSS e daisyUI para construir um footer de pequena altura , com algumas modificações minhas:

import IconSphere from "https://deno.land/x/[email protected]/tsx/sphere.tsx"
import IconBrandFacebook from "https://deno.land/x/[email protected]/tsx/brand-facebook.tsx"
import IconBrandDiscord from "https://deno.land/x/[email protected]/tsx/brand-discord.tsx"

export default function Footer() {
    return (
        <footer class="footer items-center p-4 bg-neutral text-neutral-content">
            <aside class="items-center grid-flow-col gap-8">
                <span class='text-2xl italic font-mono font-bold tracking-wide'>Trấn Kỳ</span>
                        <a class="link link-hover">Trấn Kỳ là gì?</a>
                        <a class="link link-hover">Lý do viết Trấn Kỳ</a>
                        <a class="link link-hover">Kế hoạch phát triển Trấn Kỳ</a>
                        <a class="link link-hover">Tích hợp Trấn Kỳ vào hệ thống của bạn</a>
                        <a class="link link-hover">Các buổi đáp ứng nhu cầu tự học lập trình</a>
            </aside> 
            <nav class="grid-flow-col gap-4 md:place-self-center md:justify-self-end">
                <IconSphere class="w-6 h-6" />
                <IconBrandDiscord class="w-6 h-6" />
                <IconBrandFacebook class="w-6 h-6" />           
            </nav>
        </footer>
    )
}

( Parque do vento traseiro )

Na tela grande é perfeito:

Na tela média, quando o texto tem no máximo 2 linhas, também é bom:

No entanto, em tela pequena, não quero que o texto fique comprimido assim:

No <aside>elemento se eu remover as grid-flow-col gap-8classes e só usar items-centerentão funciona como esperado no mobile:

Eu tento este código:

<aside class="items-center md:grid-flow-col md:gap-8">

Mas preserva o layout de telas pequenas a médias e grandes.

Resumindo, quero construir um rodapé que:

• Listar todos os links lado a lado, com no máximo duas linhas de texto para cada link
• Se isso não for possível, liste-os linha por linha

Existe uma maneira de conseguir isso?

Eu gostaria de poder fazer isso:

>>> obj = Example('hi', 'hello')
>>> obj.a 
'hi'
>>> obj.sub_obj.b
'hello'

Eu tento isso, mas recebo AttributeError: 'dict' object has no attribute 'b':

class Example:
    def __init__(self, a, b):
        self.a = a
        self.sub_obj = {} 
        self.sub_obj.b = b

Vejo uma pergunta semelhante, mas não entendo muito: os objetos python podem ter propriedades aninhadas? . Eu só quero que a saída JSON tenha objetos aninhados. A API exige que eu faça isso.

Eu executo este comando:

Get-ChildItem -recurse -file | ForEach-Object { (Get-Content $_).Replace('hi there','hello') | Set-Content $_ } 

e recebo este erro:

InvalidOperation: You cannot call a method on a null-valued expression.
InvalidOperation: You cannot call a method on a null-valued expression.

Você sabe por que isso acontece?

Eu tenho esse script:

type Input = string
function util(input: Input) {
    return input
}

function main(input: Input | null) {
    const isNull = input === null
    if (isNull) {
        return 'empty string'
    }    
    input = util(input) //error
}

O erro é:Argument of type 'string | null' is not assignable to parameter of type 'string'. Type 'null' is not assignable to type 'string'.

No entanto, isso não acontece se:

• A última linha é return util(input), ou
• A linha de condição é encurtada paraif (input === null)

Por que é que?

Parque Infantil

Eu tenho este projeto:

script.sh:

#!/bin/sh
echo "test"

Dockerfile:

FROM ubuntu
RUN ["sh", "script.sh"]

Com build command docker build -t test ., recebo este erro:

 => [internal] load .dockerignore                                                                                  0.1s
 => => transferring context: 2B                                                                                    0.0s
 => [internal] load build definition from Dockerfile                                                               0.1s
 => => transferring dockerfile: 118B                                                                               0.0s
 => [internal] load metadata for docker.io/library/ubuntu:latest                                                   2.3s
 => [auth] library/ubuntu:pull token for registry-1.docker.io                                                      0.0s
 => CACHED [1/2] FROM docker.io/library/ubuntu@sha256:ec050c32e4a6085b423d36ecd025c0d3ff00c38ab93a3d71a460ff1c44f  0.0s
 => ERROR [2/2] RUN ["sh", "script.sh"]                                                                            0.9s
------
 > [2/2] RUN ["sh", "script.sh"]:
#0 0.791 sh: 0: cannot open script.sh: No such file
------
Dockerfile:2
--------------------
   1 |     FROM ubuntu
   2 | >>> RUN ["sh", "script.sh"]
--------------------
ERROR: failed to solve: process "sh script.sh" did not complete successfully: exit code: 2

No entanto, se eu alterar o Dockerfile para:

FROM ubuntu
CMD ["sh", "script.sh"]

Então funciona:

[+] Building 1.2s (5/5) FINISHED
 => [internal] load build definition from Dockerfile                                                               0.1s
 => => transferring dockerfile: 73B                                                                                0.0s
 => [internal] load .dockerignore                                                                                  0.0s
 => => transferring context: 2B                                                                                    0.0s
 => [internal] load metadata for docker.io/library/ubuntu:latest                                                   1.0s
 => CACHED [1/1] FROM docker.io/library/ubuntu@sha256:ec050c32e4a6085b423d36ecd025c0d3ff00c38ab93a3d71a460ff1c44f  0.0s
 => exporting to image                                                                                             0.0s
 => => exporting layers                                                                                            0.0s
 => => writing image sha256:d9bf124a17e507c73f6defde7b046fff153fb464c2cad8a57333a0966ddf07c1                       0.0s
 => => naming to docker.io/library/test                                                                            0.0s

Da diferença entre RUN e CMD em um Dockerfile :

RUN - o comando é acionado enquanto construímos a imagem do docker.

CMD - o comando é acionado enquanto iniciamos a imagem docker criada.

Ainda assim, não consigo explicar por que o RUN não funciona, mas o CMD funciona.