Mais

Usando apenas o nome da variável (não o caminho completo do arquivo) para substituição de variável embutida no Model Builder

Usando apenas o nome da variável (não o caminho completo do arquivo) para substituição de variável embutida no Model Builder


Estou tentando usar a substituição de variável embutida no ModelBuilder para retornar o nome de um raster usado nas Estatísticas Zonais como um campo na minha tabela de saída (consulte o modelo abaixo).

Atualmente, o modelo funciona bem usando o"% Conjunto de dados raster%"para obter o campo que desejo, mas ele retorna o caminho COMPLETO do arquivo - por exemplo,C / Usuários / Newton / GIS / Projeto / RASTER123em vez de apenas"RASTER123". Alguém sabe como selecionar apenas o nome do raster de entrada, não o caminho completo?


Com a ajuda de colegas e muito pesquisando no Google, encontrei a resposta.

Se você escolher "Inserir" -> Ferramentas somente modelo -> Caminho de análisee conecte o conjunto de dados raster a ele, escolha Parse type = Name e renomeie a saída "Value" da ferramenta ParsePath para "RasterName". Você receberá APENAS o nome do raster se alterar a expressão (azul, em jpeg acima) para "% RasterName%".


Salve o resultado de encontrar como uma variável em um script de shell [duplicado]

Primeiro, seu comando find está incorreto. Se você quiser procurar todos os arquivos que terminam em -gcc no diretório atual, deve ser:

Para salvar a saída de encontrar em GCC_VERSION, use a substituição do processo:

Observe que você pode ter mais de um arquivo que termina em -gcc, portanto, coloque o nome de uma variável entre aspas duplas:

Você precisa usar carrapatos

ou melhor, a sintaxe de substituição de comando de novo estilo recomendada

Embora ambos os formulários sejam suportados, existem limitações para a incorporação de scripts no primeiro.

A forma "$ ()" de substituição de comando resolve um problema de comportamento inconsistente ao usar crases. Por exemplo:

Além disso, a sintaxe das aspas tem restrições históricas sobre o conteúdo do comando incorporado. Embora o formulário "$ ()" mais recente possa processar qualquer tipo de script incorporado válido, o formulário com aspas não pode lidar com alguns scripts válidos que incluem aspas. Por exemplo, esses scripts incorporados válidos não funcionam na coluna da esquerda, mas funcionam na direita:


Conjuntos de dados

  • Conjuntos de dados transportáveis são recursos, rasters, tabelas e arquivos. Os parâmetros que contêm conjuntos de dados transportáveis ​​oferecem suporte ao modo de entrada de valor definido pelo usuário.
  • Conjuntos de dados não transportáveis são qualquer coisa diferente de recursos, rasters, tabelas e arquivos. Existem duas categorias de conjuntos de dados não transportáveis.
    • Conjuntos de dados complexos são conjuntos de dados como redes geométricas, conjuntos de dados de rede, topologias, TINs e assim por diante. Esses tipos de dados são conhecidos como conjuntos de dados complexos porque modelam relacionamentos complexos entre recursos simples.
    • Conjuntos de dados de contêiner são itens como pastas, arquivos e bancos de dados geográficos pessoais e documentos de mapas (.mxd). Esses tipos de dados contêm uma coleção mista de outros conjuntos de dados - daí seu nome, contêineres.

    Determinar o tipo de dados de um parâmetro de ferramenta

    • Na página de referência de uma ferramenta, a seção de sintaxe tem uma tabela que descreve cada parâmetro. A última coluna desta tabela contém o tipo de dados do parâmetro.
    • No ModelBuilder, clique com o botão direito do mouse em uma variável, clique em Propriedades e clique na guia Tipo de dados. O tipo de dados é listado na parte superior da caixa de diálogo.
    • Para uma ferramenta de script, na janela Catálogo, clique com o botão direito na ferramenta de script e escolha Propriedades. Na caixa de diálogo de propriedades, clique na guia Parâmetros. O tipo de dados de cada parâmetro é listado na tabela de parâmetros.

    Listas de escolha e conjuntos de dados não transportáveis

    Se um valor de parâmetro de entrada for uma camada que faz referência a um conjunto de dados não transportável, você pode escolher Lista de opções como uma opção de modo de entrada. Por exemplo, o parâmetro de rede Modo de transporte pode ser usado em uma tarefa que encontre a melhor rota para o modo de transporte do usuário - carro, bicicleta ou caminhada.

    O tipo de dados deste parâmetro é Network Dataset Layer. Conjuntos de dados de rede são conjuntos de dados complexos que não podem ser transportados pela web, portanto, o valor definido pelo usuário não está disponível para este parâmetro. No entanto, você pode usar uma lista de opções para especificar uma lista de opções de nomes de camadas a serem usados. O cliente selecionará um dos nomes de camada da lista de opções e sua tarefa usará a camada que o cliente escolher, acessando o conjunto de dados de rede referenciado pela camada e armazenado no servidor.

    A maioria dos conjuntos de dados complexos tem uma representação de camada correspondente. O exemplo acima mostrou Network Dataset Layers. Outros conjuntos de dados complexos incluem camadas TIN, camadas geoestatísticas, camadas de tecido de pacote e camadas de conjunto de dados LAS. Sempre que tiver um conjunto de dados não transportável, você pode usar sua representação de camada como o valor de entrada. A tarefa de exemplo acima foi criada executando um modelo e fornecendo a camada de rede Street como entrada. Se o modelo foi executado fornecendo o caminho para um conjunto de dados de rede no disco em vez de um nome de camada, o modo de entrada será definido como valor constante. Você deve executar a ferramenta usando uma camada como entrada para que a opção Lista de escolha apareça.

    • Os clientes podem enviar e receber (transportar) recursos simples, rasters, tabelas e arquivos pela Internet.
    • Conjuntos de dados complexos, como conjuntos de dados de rede, TINs e malhas de pacotes não são transportáveis. Conjuntos de dados de contêiner, como pastas, bancos de dados geográficos e documentos de mapa também não são transportáveis. Ou seja, não há como um cliente criar esses conjuntos de dados ou contêineres complexos e transportá-los pela Internet. Isso é verdadeiro mesmo para clientes com recursos completos, como o ArcMap.
    • A maioria dos conjuntos de dados complexos tem uma representação de camada, ou seja, você pode adicionar o conjunto de dados ao ArcMap e uma camada é criada no índice.
      • Você pode criar uma lista de opções de nomes de camadas e o cliente escolherá um ou mais desses nomes de camadas como entrada para sua tarefa. Sua tarefa usará o conjunto de dados referenciado pela camada.
      • Para criar uma lista de opções de nomes de camadas, você deve executar sua ferramenta usando uma camada como entrada. No Editor de serviço, a lista de opções será preenchida a partir das camadas aplicáveis ​​no índice analítico.
      • Se você executar sua ferramenta usando o caminho para um conjunto de dados no disco, a opção Lista de opções não estará disponível, mesmo se você tiver camadas do tipo correto no índice analítico.

      Quando você publica uma lista de opções de nomes de camadas, os dados referenciados pelas camadas tornam-se dados do projeto e serão copiados para o servidor GIS, a menos que possam ser encontrados no armazenamento de dados do servidor.

      Valor constante e conjuntos de dados complexos

      Se uma entrada para sua tarefa for um caminho para um conjunto de dados complexo (por exemplo, D: mydata chicago.gdb Transportation streetnetwork, um conjunto de dados de rede), o modo de entrada será fixado para o valor Constante. Se você publicar com o modo de entrada definido para o valor Constante, o conjunto de dados será copiado para o servidor (a menos que seja encontrado no armazenamento de dados do servidor) e sua tarefa usará o conjunto de dados copiado.

      Se você pode adicionar o conjunto de dados ao ArcMap para criar uma camada, você pode executar novamente sua ferramenta usando a camada como entrada. Isso criará um novo resultado que você pode compartilhar, e o Service Editor oferecerá suporte à lista de opções como um modo de entrada.

      Camadas não podem ser feitas para redes geométricas. Os parâmetros que contêm redes geométricas sempre terão seu modo de entrada definido como valor constante.

      Valor constante e conjuntos de dados de contêiner

      Os contêineres são itens como pastas, arquivos e bancos de dados geográficos pessoais e documentos de mapas (.mxd). Esses tipos de dados contêm uma coleção mista de outros conjuntos de dados - daí seu nome, contêineres. Os contêineres não são transportáveis ​​e a regra geral é que o contêiner e todo o seu conteúdo serão copiados para o servidor (a menos que o contêiner esteja no armazenamento de dados do servidor). e sua tarefa publicada usará o contêiner copiado. Alguns recipientes comuns são discutidos abaixo.

      Pastas

      Se a entrada para sua tarefa for uma pasta, o modo de entrada será fixado em um valor constante. Se você publicar com o modo de entrada definido para o valor Constante, a pasta e seu conteúdo (veja a nota abaixo) serão copiados para o servidor (a menos que seja encontrado no armazenamento de dados do servidor) e sua tarefa usará a pasta copiada.

      Quando as pastas são copiadas para o servidor como parte do processo de publicação, apenas os arquivos e conjuntos de dados geográficos são copiados e nenhuma subpasta dentro da pasta é copiada. Alguns conjuntos de geodatas, como bancos de dados de arquivos, rasters e TINS ​​são tecnicamente pastas, mas serão copiados para o servidor se encontrados dentro da pasta a ser copiada.

      Documentos do mapa (.mxd)

      Se a entrada para sua tarefa for um documento de mapa, o modo de entrada será fixado para o valor constante. Se você publicar com o modo de entrada definido como valor constante, o documento do mapa, todas as suas camadas e todos os conjuntos de dados referenciados pelas camadas serão copiados para o servidor, a menos que o documento do mapa possa ser encontrado no armazenamento de dados do servidor. Se algum dos conjuntos de dados referenciados não puder ser encontrado no armazenamento de dados do servidor, eles também serão copiados para o servidor. Essencialmente, o documento do mapa é empacotado, enviado ao servidor e, em seguida, descompactado no servidor.

      Bases de dados geográficas

      Se a entrada para sua tarefa for um geodatabase, o modo de entrada será fixado para o valor Constante. Se você publicar com o modo de entrada definido para o valor Constante, o geodatabase e seu conteúdo serão copiados para o servidor (a menos que seja encontrado no armazenamento de dados do servidor) e sua tarefa usará o geodatabase copiado.

      As bases de dados geográficas pessoais (.mdb) não são suportadas em plataformas de servidor (sistemas operacionais de 64 bits) e serão convertidas em bases de dados geográficas de arquivo quando copiadas para o servidor. Os bancos de dados geográficos corporativos também serão convertidos em bancos de dados geográficos de arquivos quando copiados para o servidor.

      Saída não transportável

      Se a saída de sua ferramenta for um conjunto de dados complexo ou um conjunto de dados de contêiner, ele não poderá ser transportado de volta para o cliente. No Editor de serviço, o parâmetro de saída mostrará um tipo de dados String. Na ilustração abaixo, o valor retornado pela tarefa será o nome do conjunto de dados TIN criado, não o próprio conjunto de dados.

      • Use um serviço de mapa de resultado para enviar ao cliente o resultado como um mapa. Nenhum conjunto de dados é transportado para o cliente, apenas um mapa dos dados.
      • Converta o conjunto de dados em um conjunto de dados transportável. Por exemplo, você pode usar a ferramenta TIN To Raster para converter um TIN (não transportável) em um conjunto de dados raster (transportável).
      • Crie um pacote de camadas (.lpk) do conjunto de dados usando uma das ferramentas no conjunto de ferramentas Camadas e visualizações de tabela e, em seguida, use a ferramenta Camada de pacotes para criar o pacote de camadas. Um pacote de camada é um arquivo e os arquivos podem ser transportados pela Internet. O cliente terá que desempacotar o pacote.
      • Use o utilitário ZIP para criar um arquivo do conjunto de dados ou pasta de resultados e transporte o arquivo .zip para o cliente. O cliente é responsável por descompactar o arquivo. O exemplo de serviço de recorte e envio recorta camadas de uma área de estudo em um arquivo geodatabase (e outros formatos) e, a seguir, cria um arquivo .zip a ser transportado para o cliente. Se você deseja usar essa técnica, consulte os links abaixo:
          pega uma pasta de entrada e um nome de arquivo de saída e cria um arquivo .zip compactado. pega um arquivo .zip de entrada e uma pasta de saída e grava o conteúdo na pasta.

      • 3 respostas 3

        O método subprocess.call obtém uma lista de parâmetros, não uma string com separadores de espaço, a menos que você diga a ele para usar o shell, o que não é recomendado se a string puder conter qualquer coisa da entrada do usuário.

        A melhor maneira é construir o comando como uma lista

        isso também torna mais fácil passar parâmetros (por exemplo, caminhos ou arquivos) com espaços para o programa chamado.

        Ambas as formas são fornecidas na documentação do subprocesso.

        Você pode passar uma string delimitada, mas então você tem que deixar o shell processar os argumentos


        8 Respostas 8

        Você pode usar envsubst (parte de gnu gettext):

        Para substituir apenas algumas variáveis ​​de ambiente, consulte esta pergunta.

        Isso não é muito bom, mas funciona

        Se estivesse em um script de shell, teria a seguinte aparência:

        Editar, não estritamente relacionado à questão, mas no caso de variáveis ​​lidas do arquivo:

        Se acontecer de você ter Perl (mas não gettext e envsubst), você pode fazer a substituição simples com um script curto:

        Presumi que os nomes das variáveis ​​terão apenas letras maiúsculas e sublinhados, mas o primeiro padrão deve ser fácil de alterar conforme necessário. $ ENV <. > faz referência ao ambiente que Perl vê.

        Se você deseja apoiar o $ <. > sintaxe ou lance um erro em variáveis ​​não definidas, você precisará de mais trabalho. Um equivalente próximo de envsubst de gettext seria:

        Embora eu sinta que alimentar variáveis ​​como essa por meio do ambiente de processo parece um pouco duvidoso em geral: você não pode usar variáveis ​​arbitrárias nos arquivos (uma vez que podem ter significados especiais), e alguns dos valores podem possivelmente ter pelo menos semi- dados sensíveis neles.


        4 respostas 4

        Você pode usar o nome de arquivo "falso" / dev / stdin que representa a entrada padrão.

        O comando echo e o pipe enviam o conteúdo da variável especificada para a entrada padrão do próximo comando cook, e isso abre a entrada padrão (como um descritor de arquivo separado) e a lê.

        Uma outra maneira de usar o recurso de substituição de processo do shell bash faz com que um FIFO seja criado em / tmp ou / var / tmp, ou usa um descritor de arquivo nomeado (/ dev / fd / *), dependendo do sistema operacional. A sintaxe de substituição (& lt (cmd)) é substituída pelo nome do FIFO ou FD, e o comando dentro dele é executado em segundo plano.

        O comando cook agora lê o conteúdo da variável como se estivesse disponível em um arquivo.

        Isso também pode ser usado para mais de um arquivo de entrada:

        Depende dos recursos do aplicativo. Ele pode ou não insistir em um arquivo nomeado e pode ou não insistir em um arquivo pesquisável.

        Cachimbo anônimo

        Alguns aplicativos apenas leem a entrada de qualquer lugar. Normalmente, eles usam como padrão a leitura da entrada padrão. Se você tiver os dados em uma string e quiser passá-los para a entrada padrão do aplicativo, existem algumas maneiras. Você pode passar as informações por meio de um tubo:

        Não use echo aqui porque dependendo do shell, ele pode desfigurar barras invertidas.

        Se o aplicativo insistir em um argumento de arquivo, ele pode aceitar - para significar entrada padrão. Esta é uma convenção comum, mas não sistemática.

        Se o aplicativo precisa de um nome de arquivo real, passe / dev / stdin para significar entrada padrão.

        Para alguns aplicativos, mesmo isso não é suficiente: eles precisam de um nome de arquivo com certas propriedades, por exemplo, com uma determinada extensão, ou precisam de um nome de arquivo em um diretório gravável onde criam arquivos temporários. Nesses casos, geralmente você precisa de um arquivo temporário, embora às vezes um pipe nomeado seja suficiente.

        Pipe nomeado

        É possível dar um nome a um tubo. Menciono isso para ser completo, mas raramente é a maneira mais conveniente. Isso evita obter os dados no disco. É adequado se o aplicativo precisa de um arquivo com restrições de nome, mas não precisa que o arquivo seja pesquisável.

        Arquivo temporário

        Se o aplicativo precisa de um procurável arquivo, você precisa criar um arquivo temporário. Um arquivo pesquisável é aquele em que o aplicativo pode ir e voltar, lendo partes arbitrárias de cada vez. Um cachimbo não permite isso: precisa ser lido do início ao fim, em sequência, sem nunca retroceder.

        Bash, ksh e zsh têm uma sintaxe conveniente para passar uma string como entrada por meio de um arquivo temporário. Observe que eles sempre acrescentam uma nova linha à string (mesmo se já houver uma).

        Com outros shells, ou se quiser controlar qual diretório contém o arquivo temporário, você precisa criar o arquivo temporário manualmente. A maioria dos unices fornece um utilitário mktemp para criar o arquivo temporário com segurança. (Nunca use algo como … & Gt / tmp / temp. $ ! Ele permite que outros programas, mesmo executados como outros usuários, sequestrem o arquivo.) Este é um script que cria um arquivo temporário e se encarrega de removê-lo se for interrompido.

        Para escolher onde criar o arquivo temporário, defina a variável de ambiente TMPDIR para a chamada mktemp. Por exemplo, para criar o arquivo temporário no diretório atual em vez do local padrão para arquivos temporários:

        (Usar $ PWD em vez de. Fornece um nome de arquivo absoluto, o que significa que você pode chamar cd com segurança em seu script sem se preocupar que $ tmp não designará mais o mesmo arquivo.)

        Se o aplicativo precisa de um nome de arquivo com uma determinada extensão, você precisa criar um diretório temporário e criar um arquivo nele. Para criar o diretório temporário, use mktemp -d. Novamente, defina a variável de ambiente TMPDIR se quiser controlar onde o diretório temporário é criado.


        Isso ocorre porque o shell expande a variável na linha de comando antes na verdade, ele executa o comando e, nesse momento, a variável não existe. Se você usar

        export fará com que a variável apareça no ambiente de comandos executados subseqüentemente (para saber como isso funciona no bash, consulte a ajuda de exportação). Se você só precisa que a variável apareça no ambiente de um comando, use o que você tentou, ou seja:

        A sintaxe do shell descreve isso como sendo funcionalmente equivalente a:

        A parte interessante é que o comando de exportação muda o sinalizador de exportação para a variável nome. Portanto, se você:

        O TESTE será exportado, embora não tenha sido definido no momento em que foi exportado. No entanto, ainda mais não definido deve remover o atributo de exportação dele.

        Eu suspeito que você quer ter Concha variáveis ​​para ter um escopo limitado, em vez de variáveis ​​de ambiente. Variáveis ​​de ambiente são uma lista de strings passadas para comandos quando eles são executado.

        Você está passando a string var = value para o ambiente que echo recebe. No entanto, echo não faz nada com sua lista de ambiente¹ e, de qualquer forma, na maioria dos shells, echo está embutido e, portanto, não executado.

        Isso teria sido outro assunto. Aqui, estamos passando var = value para o comando sh, e sh por acaso usa seu ambiente. Os shells convertem cada uma das variáveis ​​que recebem de seu ambiente em uma variável de shell, de modo que a variável de ambiente var que sh recebe será convertida em uma variável $ var e, quando a expandir nessa linha de comando de eco, isso se tornará o valor de eco. Como o ambiente é herdado por padrão, o echo também receberá var = value em seu ambiente (ou receberia se fosse executado), mas, novamente, o echo não se preocupa com o ambiente.

        Agora, se como eu suspeito, o que você deseja é limitar o escopo das variáveis ​​do shell, existem várias abordagens possíveis.

        Portável (Bourne e POSIX):

        O (.) Acima inicia um sub-shell (um novo processo de shell na maioria dos shells), então qualquer variável declarada lá afetará apenas esse sub-shell, então eu esperaria que o código acima gerasse "1: valor" e " 2: "ou" 2: qualquer-var-que-foi-definido-para-antes ".

        Com a maioria dos shells tipo Bourne, você pode usar funções e o "local" embutido:

        Com zsh, você pode usar funções embutidas:

        Com bash e zsh (mas não ash, pdksh ou AT & ampT ksh), este truque também funciona:

        Uma variante que funciona em mais alguns shells (traço, mksh, yash), mas não zsh (a menos que em emulação sh / ksh):

        (usar o comando na frente de um builtin especial (aqui eval) em shells POSIX remove sua especialidade (aqui que as atribuições de variáveis ​​a partir deles permanecem em vigor após terem retornado))

        ¹ Estritamente falando, isso não é totalmente verdade. Diversas implementações se preocupam com as variáveis ​​de ambiente de localização (LANG, LOCPATH, LC_ *.), A implementação GNU se preocupa com a variável de ambiente POSIXLY_CORRECT (compare env echo --version com POSIXLY_CORRECT = 1 env echo --version em um sistema GNU).


        1 resposta 1

        substituindo um valor de uma determinada variável em outra.

        Essa descrição está errada por vários motivos. A substituição de variável substitui o nome de uma variável (mais alguma fluff sintática) por seu valor. Além disso, não opera “em” uma variável, mas em um comando. O comando pode ser aquele que define o valor de uma variável, mas é apenas um caso entre muitos.

        Por exemplo, o comando echo $ foo exibe o valor da variável. O código-fonte contém $ foo, e a saída correspondente contém o valor da variável foo.

        A razão pela qual isso é chamado de “substituição de variável” é que o shell opera por uma série de transformações de strings (e listas de strings). Por exemplo (simplificado), considere o comando ls -l $ dir /*.$ ext. Para avaliá-lo, várias coisas acontecem em sequência:

        1. O shell começa a analisar o comando e o divide em três palavras: ls, -l e $ dir /*.$ ext.
        2. Na terceira palavra, o shell vê duas substituições de variáveis ​​a serem executadas (é isso que os cifrões significam neste contexto). Digamos que o valor de dir seja / algum / caminho e o valor de ext seja txt, então o shell reescreve $ dir /*.$ ext em /some/path/*.txt. Esta é uma substituição porque o valor de cada variável é substituído pela sintaxe do nome do dólar.
        3. O shell expande o padrão curinga /some/path/*.txt para a lista de nomes de arquivo correspondentes.
        4. O shell executa ls com os argumentos que é calculado.

        Na maioria das linguagens de programação, para obter o valor de uma variável, basta escrever o nome da variável. O shell é projetado para uso interativo se você escrever um nome que seja interpretado como uma string literal. É por isso que a sintaxe para obter o valor de uma variável tem um marcador extra para dizer “Eu quero pegar o valor de uma variável”.

        por que essa ação requer um termo especial em vez de apenas dizer "alterar o valor de uma variável editando-a manualmente em um editor de texto?

        A substituição de variável não tem nada a ver com a mudança do valor de uma variável. Alterar o valor de uma variável é uma atribuição.

        Claro, uma atribuição pode conter substituições de variáveis, como qualquer outro comando. Mas as substituições de variáveis ​​não são projetadas especificamente para atribuições.

        Além disso, você não pode alterar o valor de uma variável com um editor. Uma variável já declarada tem um valor em cada processo, não é uma configuração do sistema. Você pode ter arquivos de configuração que definem o inicial valor de uma variável, e você pode usar um editor para alterar esse valor inicial nesses arquivos, mas depois disso o valor pode ser alterado.


        Variáveis ​​de ambiente que armazenam preferências

        Os recursos do PowerShell podem usar variáveis ​​de ambiente para armazenar as preferências do usuário. Essas variáveis ​​funcionam como variáveis ​​de preferência, mas são herdadas por sessões filhas das sessões nas quais foram criadas. Para obter mais informações sobre variáveis ​​de preferência, consulte about_preference_variables.

        As variáveis ​​de ambiente que armazenam preferências incluem:

        Armazena a política de execução definida para a sessão atual. Essa variável de ambiente existe apenas quando você define uma política de execução para uma única sessão. Você pode fazer isso de duas maneiras diferentes.

        Inicie uma sessão a partir da linha de comando usando o ExecutionPolicy parâmetro para definir a política de execução para a sessão.

        Use o cmdlet Set-ExecutionPolicy. Use o parâmetro Scope com um valor de & quotProcess & quot.

        O PowerShell fornece controle sobre o arquivo usado para armazenar dados em cache sobre módulos e seus cmdlets. O cache é lido na inicialização durante a busca por um comando e é escrito em um thread de segundo plano algum tempo depois que um módulo é importado.

        A localização padrão do cache é:

        • Windows PowerShell 5.1: $ env: LOCALAPPDATA Microsoft Windows PowerShell
        • PowerShell 6.0 e superior: $ env: LOCALAPPDATA Microsoft PowerShell
        • Padrão fora do Windows:

        O nome de arquivo padrão para o cache é ModuleAnalysisCache. Quando você tem várias instâncias do PowerShell instaladas, o nome do arquivo inclui um sufixo hexadecimal para que haja um nome de arquivo exclusivo por instalação.

        Se a descoberta do comando não estiver funcionando corretamente, por exemplo, o Intellisense mostra comandos que não existem, você pode excluir o arquivo de cache. O cache é recriado na próxima vez que você iniciar o PowerShell.

        Para alterar o local padrão do cache, defina a variável de ambiente antes de iniciar o PowerShell. As alterações nesta variável de ambiente afetam apenas os processos filhos. O valor deve nomear um caminho completo (incluindo o nome do arquivo) que o PowerShell tem permissão para criar e gravar arquivos.

        Para desativar o cache do arquivo, defina este valor para um local inválido, por exemplo:

        Isso define o caminho para o NUL dispositivo. O PowerShell não pode gravar no caminho, mas nenhum erro é retornado. Você pode ver os erros relatados usando um rastreador:

        Ao gravar o cache de análise de módulo, o PowerShell verifica os módulos que não existem mais para evitar um cache desnecessariamente grande. Às vezes, essas verificações não são desejáveis; nesse caso, você pode desativá-las definindo o valor da variável de ambiente como 1.

        A definição dessa variável de ambiente entra em vigor imediatamente no processo atual.

        A variável de ambiente $ env: PSModulePath contém uma lista de localizações de pastas que são pesquisadas para encontrar módulos e recursos.

        Por padrão, os locais efetivos atribuídos a $ env: PSModulePath são:

        Locais de todo o sistema: essas pastas contêm módulos que acompanham o PowerShell. Os módulos são armazenados no local $ PSHOME Modules. Além disso, este é o local onde os módulos de gerenciamento do Windows estão instalados.

        Módulos instalados pelo usuário: são os módulos instalados pelo usuário. Módulo de instalação tem um Alcance parâmetro que permite especificar se o módulo é instalado para o usuário atual ou para todos os usuários. Para obter mais informações, consulte Módulo de instalação.

        • No Windows, a localização do específico do usuário Usuário atual o escopo é a pasta $ HOME Documents PowerShell Modules. A localização do Todos os usuários o escopo é $ env: ProgramFiles PowerShell Modules.
        • Em sistemas não Windows, a localização do usuário específico Usuário atual escopo é a pasta $ HOME / .local / share / powershell / Modules. A localização do Todos os usuários o escopo é / usr / local / share / powershell / Modules.

        Além disso, os programas de configuração que instalam módulos em outros diretórios, como o diretório Arquivos de programas, podem acrescentar suas localizações ao valor de $ env: PSModulePath.


        Variáveis ​​Registradas¶

        Outro uso importante das variáveis ​​é executar um comando e usar o resultado desse comando para salvar o resultado em uma variável. Os resultados variam de módulo para módulo. O uso de -v ao executar playbooks mostrará os valores possíveis para os resultados.

        O valor de uma tarefa sendo executada em ansible pode ser salvo em uma variável e usado posteriormente. Veja alguns exemplos disso no capítulo Condicionais.

        Embora seja mencionado em outro lugar nesse documento também, aqui está um exemplo rápido de sintaxe:

        As variáveis ​​registradas são válidas no host durante o restante da execução do manual, que é o mesmo que o tempo de vida dos “fatos” no Ansible. Variáveis ​​efetivamente registradas são como fatos.

        Ao usar o registro com um loop, a estrutura de dados colocada na variável durante um loop, conterá um atributo de resultados, que é uma lista de todas as respostas do módulo. Para um exemplo mais detalhado de como isso funciona, consulte a seção Loops sobre o uso de registradores com um loop.

        Se uma tarefa falhar ou for ignorada, a variável ainda é registrada com um status de falha ou ignorada, a única maneira de evitar o registro de uma variável é usando tags.