luacheck - Online na nuvem

PROGRAMA:

NOME

luacheck - documentação luacheck

Conteúdo:

LISTA OF AVISOS

Os avisos produzidos pela Luacheck são categorizados usando códigos de aviso de três dígitos. Aviso
códigos podem ser exibidos na saída CLI usando --códigos Opção CLI ou códigos opção de configuração.
Os erros também têm códigos que começam com zero.

┌───────┬────────────────────────────────────
│ Código │ Descrição │
├───────┼────────────────────────────────────
│011 │ Um erro de sintaxe. │
├───────┼────────────────────────────────────
│021 │ Uma opção embutida inválida. │
├───────┼────────────────────────────────────
│022 │ Um push embutido com upair │
│ │ diretiva. │
├───────┼────────────────────────────────────
│023 │ Uma diretiva pop inline atualizada. │
├───────┼────────────────────────────────────
│111 │ Configurando um global indefinido │
│ │ variável. │
├───────┼────────────────────────────────────
│112 │ Mutando um global indefinido │
│ │ variável. │
├───────┼────────────────────────────────────
│113 │ Acessando um global indefinido │
│ │ variável. │
├───────┼────────────────────────────────────
│121 │ Configurando um global somente leitura │
│ │ variável. │
├───────┼────────────────────────────────────
│122 │ Transformando um global somente leitura │
│ │ variável. │
├───────┼────────────────────────────────────
│131 │ Global implicitamente definido não utilizado │
│ │ variável. │
├───────┼────────────────────────────────────
│211 │ Variável local não usada. │
├───────┼────────────────────────────────────
│212 │ Argumento não utilizado. │
├───────┼────────────────────────────────────
│213 │ Variável de loop não usada. │
├───────┼────────────────────────────────────
│221 │ A variável local é acessada, mas │
│ │ nunca definido. │
├───────┼────────────────────────────────────
│231 │ A variável local é definida, mas nunca │
│ │ acessado. │
├───────┼────────────────────────────────────
│232 │ Um argumento é definido, mas nunca │
│ │ acessado. │
├───────┼────────────────────────────────────
│233 │ A variável de loop é definida, mas nunca │
│ │ acessado. │
├───────┼────────────────────────────────────
│311 │ Valor atribuído a um local │
│ │ variável não utilizada. │
└───────┴────────────────────────────────────

│312 │ O valor de um argumento não é usado. │
├───────┼────────────────────────────────────
│313 │ O valor de uma variável de loop é │
│ │ não utilizado. │
├───────┼────────────────────────────────────
│321 │ Acessando local não inicializado │
│ │ variável. │
├───────┼────────────────────────────────────
│411 │ Redefinindo uma variável local. │
├───────┼────────────────────────────────────
│412 │ Redefinindo um argumento. │
├───────┼────────────────────────────────────
│413 │ Redefinindo uma variável de loop. │
├───────┼────────────────────────────────────
│421 │ Sombrear uma variável local. │
├───────┼────────────────────────────────────
│422 │ Sombreando um argumento. │
├───────┼────────────────────────────────────
│423 │ Sombrear uma variável de loop. │
├───────┼────────────────────────────────────
│431 │ Sombreando um upvalue. │
├───────┼────────────────────────────────────
│432 │ Sombreando um argumento de upvalue. │
├───────┼────────────────────────────────────
│433 │ Sombreando um loop de upvalue │
│ │ variável. │
├───────┼────────────────────────────────────
│511 │ Código inacessível. │
├───────┼────────────────────────────────────
│512 │ O loop pode ser executado no máximo │
│ │ uma vez. │
├───────┼────────────────────────────────────
│521 │ Etiqueta não usada. │
├───────┼────────────────────────────────────
│531 │ Lado esquerdo de uma tarefa │
│ │ é muito curto. │
├───────┼────────────────────────────────────
│532 │ Lado esquerdo de uma tarefa │
│ │ é muito longo. │
├───────┼────────────────────────────────────
│541 │ Um vazio do final bloquear. │
├───────┼────────────────────────────────────
│542 │ Um vazio if filial. │
├───────┼────────────────────────────────────
│551 │ Uma declaração vazia. │
└───────┴────────────────────────────────────

Global variáveis
Para cada arquivo, Luacheck constrói uma lista de globais definidos que podem ser usados ​​lá. Por padrão
apenas globais da biblioteca padrão de Lua são definidas; globais personalizados podem ser adicionados usando
--globais Opção CLI ou globals opção de configuração e versão da biblioteca padrão podem ser
selecionado usando --std Opção CLI ou std opção de configuração. Quando um global indefinido é definido,
mutado ou acessado, Luacheck produz um aviso.

Somente leitura globals
Por padrão, todos os globais padrão, exceto _G e pacote são marcados como somente leitura, para que
configurá-los ou alterá-los produz um aviso. Globais somente leitura personalizados podem ser adicionados usando
--read-globais Opção CLI ou read_globals opção de configuração.

Implicitamente definido globals
Luacheck pode ser configurado para considerar globais atribuídos sob algumas condições como sendo
definido implicitamente. Quando -d/--allow_definido Opção CLI ou permitir_definido opção de configuração é
usado, todas as atribuições aos globais os definem; quando -t/--allow_definido_top Opção CLI ou
permitir_definido_top opção de configuração é usada, atribuições a globais na função de nível superior
o escopo (também conhecido como bloco principal) os define. Um aviso é produzido quando um implicitamente
global definido não é acessado em qualquer lugar.

Módulos
Os arquivos podem ser marcados como módulos usando -m/--módulo Opção CLI ou módulo opção de configuração para
simular a semântica do obsoleto módulo função. Globais implicitamente definidos dentro de um
módulo são considerados parte de sua interface, não são visíveis do lado de fora e não são relatados
como não utilizado. Atribuições a outros globais não são permitidas, mesmo a definidas.

Não utilizado variáveis e valores
Luacheck gera avisos para todas as variáveis ​​locais não utilizadas, exceto uma chamada _. Também
detecta variáveis ​​que são definidas, mas nunca acessadas ou acessadas, mas nunca definidas.

Não utilizado valores e não inicializado variáveis
Para cada valor atribuído a uma variável local, Luacheck calcula um conjunto de expressões onde
poderia ser usado. Os avisos são produzidos para valores não usados ​​(quando um valor não pode ser usado
em qualquer lugar) e para acessar variáveis ​​não inicializadas (quando nenhum valor pode alcançar um
expressão). Por exemplo, no seguinte valor de snippet atribuído a Foo na linha 1 não é usado, e
variável Barra não foi inicializado na linha 9:

foo local = expr1 ()
bar local

se condição () então
foo = expr2 ()
bar = expr3 ()
outro
foo = expr4 ()
imprimir (barra)
final

voltar foo, bar

Secundário valores e variáveis
O valor não utilizado atribuído a uma variável local é secundário se sua origem for o último item em
o RHS de atribuição e outro valor desse item é usado. Valores secundários
normalmente aparecem quando o resultado de uma chamada de função é colocado em locais, e apenas alguns deles
são usados ​​posteriormente. Por exemplo, aqui o valor atribuído a b é secundário, valor atribuído a c is
usado e valor atribuído a a simplesmente não é usado:

local a, b, c = f (), g ()

retorno c

Uma variável é secundária se todos os valores atribuídos a ela forem secundários. No snippet acima,
b é uma variável secundária.

Avisos relacionados a valores secundários não utilizados e variáveis ​​podem ser removidos usando
-s/--não-não-secundários Opção CLI ou não usados_secundários opção de configuração.

Sombreamento declarações
Luacheck detecta declarações de variáveis ​​locais sombreando declarações anteriores, a menos que
a variável é nomeada _. Se a declaração anterior estiver no mesmo escopo da nova,
é chamado de redefinição.

Observe que é não necessário definir uma nova variável local ao substituir um argumento:

função local f (x)
local x = x ou "padrão" - ruim
final

função local f (x)
x = x ou "padrão" - bom
final

Controlar fluxo e dados, fluxo questões
Os seguintes problemas de fluxo de controle e fluxo de dados são detectados:

· Código inacessível e loops que podem ser executados no máximo uma vez (por exemplo, devido a um
quebra incondicional);

· Etiquetas não utilizadas;

· Atribuições desequilibradas;

· Blocos vazios.

· Declarações vazias (ponto e vírgula sem declarações precedentes).

COMANDO LINHA INTERFACE

luacheck programa aceita arquivos, diretórios e rochas como argumentos.

· Dado um arquivo, luacheck vai verificar.

· Dado -, luacheck irá verificar o stdin.

· Dado um diretório, luacheck irá verificar todos os arquivos dentro dele, selecionando apenas os arquivos com
.lua extensão a menos --include-arquivos opção é usada. Este recurso requer
LuaFileSystemName (instalado automaticamente se o LuaRocks foi usado para instalar o Luacheck).

· Dado um rockspec (um arquivo com .rockspec extensão), luacheck irá verificar todos os arquivos com
.lua extensão mencionada no rockspec em construir.instalar.lua, construir.instalar.bin e
construir.modules tabelas.

A saída de luacheck consiste em relatórios separados para cada arquivo verificado e termina com um
resumo:

$ luachecksrc
Verificando src / bad_code.lua 5 avisos

src / bad_code.lua: 3: 16: auxiliar de variável não utilizado
src / bad_code.lua: 3: 23: argumento de comprimento variável não utilizado
src / bad_code.lua: 7: 10: definindo abraço de variável global não padrão
src / bad_code.lua: 8: 10: a variável opt foi previamente definida como um argumento na linha 7
src / bad_code.lua: 9: 11: acessando hepler variável indefinida

Verificando src / good_code.lua OK
Verificando o erro src / python_code.lua 1

src / python_code.lua: 1: 6: esperado '=' próximo a '__future__'

Verificando avisos src / unused_code.lua 9

src / unused_code.lua: 3: 18: argumento não utilizado baz
src / unused_code.lua: 4: 8: variável de loop não utilizada i
src / unused_code.lua: 5: 13: variável não utilizada q
src / unused_code.lua: 7: 11: variável de loop não usada a
src / unused_code.lua: 7: 14: variável de loop não utilizada b
src / unused_code.lua: 7: 17: variável de loop não usada c
src / unused_code.lua: 13: 7: o valor atribuído à variável x não é usado
src / unused_code.lua: 14: 1: o valor atribuído à variável x não é usado
src / unused_code.lua: 22: 1: o valor atribuído à variável z não é usado

Total: 14 avisos / 1 erro em 4 arquivos

luacheck sai com 0 se nenhum aviso ou erro ocorreu e com um número positivo
de outra forma.

Command linha opções
Opções curtas que não levam um argumento podem ser combinadas em um, de modo que -qqu is
equivalente a -q -q -u. Para opções longas, ambos --opção valor or --option = value pode ser
usava.

As opções com vários argumentos podem ser usadas várias vezes; --ignorar Foo --ignorar Barra is
equivalente a --ignorar Foo Barra.

Observe que as opções que podem ter vários argumentos, como --globais, não deve ser usado
imediatamente antes dos argumentos posicionais; dado --globais Foo Barra arquivo.lua, luacheck precisarão
considere tudo Foo, Barra e arquivo.lua global e, em seguida, entre em pânico, pois não há nomes de arquivo restantes.

┌────────────────────────────────────┬────────────────────────────────────────────────────────────────────────── ──────────────────────┐
│ Opção │ Significado │
├────────────────────────────────────┼─────────────────────────────────────────────────────────┼──────────────────────────── ──────────────────────┤
│-g | --não global │ Filtre os avisos relacionados a │
│ │ variáveis ​​globais. │
├────────────────────────────────────┼─────────────────────────────────────────────────────────┼──────────────────────────── ──────────────────────┤
│-u | - não não utilizado │ Filtre os avisos relacionados a │
│ │ variáveis ​​e valores não utilizados. │
├────────────────────────────────────┼─────────────────────────────────────────────────────────┼──────────────────────────── ──────────────────────┤
│-r | --não-redefinido │ Filtre os avisos relacionados a │
│ │ variáveis ​​redefinidas. │
├────────────────────────────────────┼─────────────────────────────────────────────────────────┼──────────────────────────── ──────────────────────┤
│-a | --no-unused-args │ Filtre os avisos relacionados a │
│ │ argumentos não utilizados e loop │
│ │ variáveis. │
├────────────────────────────────────┼─────────────────────────────────────────────────────────┼──────────────────────────── ──────────────────────┤
│-s | --não-não-secundários │ Filtre os avisos relacionados a │
│ │ variáveis ​​não utilizadas definidas juntas │
│ │ com os usados. │
│ │ │
│ │ Ver valores e variáveis ​​secundários │
├────────────────────────────────────┼─────────────────────────────────────────────────────────┼──────────────────────────── ──────────────────────┤
│--não-eu │ Filtre os avisos relacionados a │
│ │ implícito eu argumento. │
└────────────────────────────────────┴─────────────────────────────────────────────────────────┴──────────────────────────── ──────────────────────┘

│--std │ Defina globais padrão. pode │
│ │ ser um dos: │
│ │ │
│ │ · _G - globais da Lua │
│ │ intérprete luacheck │
│ │ roda em (padrão); │
│ │ │
│ │ · lua51 - globais da Lua │
│ │ 5.1; │
│ │ │
│ │ · lua52 - globais da Lua │
│ │ 5.2; │
│ │ │
│ │ · lua52c - globais da Lua │
│ │ 5.2 compilado com │
│ │ LUA_COMPAT_ALL; │
│ │ │
│ │ · lua53 - globais da Lua │
│ │ 5.3; │
│ │ │
│ │ · lua53c - globais da Lua │
│ │ 5.3 compilado com │
│ │ LUA_COMPAT_5_2; │
│ │ │
│ │ · luajit - globais de │
│ │ LuaJIT 2.0; │
│ │ │
│ │ · ngx_lua - globais de │
│ │ Openresty │
│ │ módulo lua-nginx com │
│ │ LuaJIT 2.0; │
│ │ │
│ │ · minutos - intersecção de │
│ │ globais de Lua 5.1, Lua │
│ │ 5.2 e LuaJIT 2.0; │
│ │ │
│ │ · max - união dos globais │
│ │ de Lua 5.1, Lua 5.2 e │
│ │ LuaJIT 2.0; │
│ │ │
│ │ · flagra - globais adicionados │
│ │ por Busted 2.0; │
│ │ │
│ │ · Nenhum - sem padrão │
│ │ globais. │
│ │ │
│ │ Veja Conjuntos of padrão │
│ │ globals │
├────────────────────────────────────┼─────────────────────────────────────────────────────────┼──────────────────────────── ──────────────────────┤
│--globais [ ] ... │ Adicione globais personalizados em cima de │
│ │ padrão. │
├────────────────────────────────────┼─────────────────────────────────────────────────────────┼──────────────────────────── ──────────────────────┤
│--read-globais [ ] ... │ Adicione globais somente leitura. │
├────────────────────────────────────┼─────────────────────────────────────────────────────────┼──────────────────────────── ──────────────────────┤
│--novo-globais [ ] ... │ Defina globais personalizados. Remove │
│ │ globais personalizados adicionados anteriormente. │
├────────────────────────────────────┼─────────────────────────────────────────────────────────┼──────────────────────────── ──────────────────────┤
│--new-read-globals [ ] │ Defina globais somente leitura. Remove │
│... │ globais somente leitura adicionados │
│ │ anteriormente. │
├────────────────────────────────────┼─────────────────────────────────────────────────────────┼──────────────────────────── ──────────────────────┤
│-c | --compat │ Equivalente a --std max. │
└────────────────────────────────────┴─────────────────────────────────────────────────────────┴──────────────────────────── ──────────────────────┘

│-d | --permitido │ Permitir a definição de globais │
│ │ implicitamente definindo-os. │
│ │ │
│ │ Veja as globais implicitamente definidas │
├────────────────────────────────────┼─────────────────────────────────────────────────────────┼──────────────────────────── ──────────────────────┤
│-t | --allow-definido-top │ Permitir a definição de globais │
│ │ implicitamente configurando-os em │
│ │ o escopo de nível superior. │
│ │ │
│ │ Veja as globais implicitamente definidas │
├────────────────────────────────────┼─────────────────────────────────────────────────────────┼──────────────────────────── ──────────────────────┤
│-m | --módulo │ Limite a visibilidade de forma implícita │
│ │ definidos globais para seus arquivos. │
│ │ │
│ │ Ver módulos │
├────────────────────────────────────┼─────────────────────────────────────────────────────────┼──────────────────────────── ──────────────────────┤
│--ignorar | -i [ ] │ Filtre os avisos correspondentes │
│... │ padrões. │
├────────────────────────────────────┼─────────────────────────────────────────────────────────┼──────────────────────────── ──────────────────────┤
│--permitir | -e [ ] │ Não filtre os avisos │
│... │ padrões de correspondência. │
├────────────────────────────────────┼─────────────────────────────────────────────────────────┼──────────────────────────── ──────────────────────┤
│--só | -o [ ] ... │ Filtre os avisos que não correspondem │
│ │ padrões. │
├────────────────────────────────────┼─────────────────────────────────────────────────────────┼──────────────────────────── ──────────────────────┤
│--sem linha │ Desative as opções embutidas. │
├────────────────────────────────────┼─────────────────────────────────────────────────────────┼──────────────────────────── ──────────────────────┤
│--config │ Caminho para a configuração personalizada │
│ │ arquivo (padrão: .luacheckrc) │
├────────────────────────────────────┼─────────────────────────────────────────────────────────┼──────────────────────────── ──────────────────────┤
│--no-config │ Não procure personalizado │
│ │ arquivo de configuração. │
├────────────────────────────────────┼─────────────────────────────────────────────────────────┼──────────────────────────── ──────────────────────┤
│--nome do arquivo │ Use outro nome de arquivo na saída, │
│ │ para selecionar a configuração │
│ │ substitui e para arquivo │
│ │ filtragem. │
├────────────────────────────────────┼─────────────────────────────────────────────────────────┼──────────────────────────── ──────────────────────┤
│--excluir-arquivos [ ] │ Não verifique os arquivos correspondentes │
│... │ esses padrões de globbing. │
│ │ Globs recursivos, como ** / *. lua │
│ │ são suportados. │
├────────────────────────────────────┼─────────────────────────────────────────────────────────┼──────────────────────────── ──────────────────────┤
│--include-arquivos [ ] │ Não verifique os arquivos que não correspondem │
│... │ esses padrões de globbing. │
├────────────────────────────────────┼─────────────────────────────────────────────────────────┼──────────────────────────── ──────────────────────┤
│--cache [ ] │ Caminho para o arquivo de cache. (padrão: │
│ │ .luacheckcache). Vejo Cache │
├────────────────────────────────────┼─────────────────────────────────────────────────────────┼──────────────────────────── ──────────────────────┤
│--sem cache │ Não use cache. │
├────────────────────────────────────┼─────────────────────────────────────────────────────────┼──────────────────────────── ──────────────────────┤
│-j | --empregos │ Verifique arquivos em paralelo. │
│ │ Requer LuaLanes. │
└────────────────────────────────────┴─────────────────────────────────────────────────────────┴──────────────────────────── ──────────────────────┘

│--formatador │ Use um formatador personalizado. │
│ │ deve ser um módulo │
│ │ nome ou um dos seguintes: │
│ │ │
│ │ · TAP - Teste qualquer coisa │
│ │ Formatador de protocolo; │
│ │ │
│ │ · JUnit - XML ​​JUnit │
│ │ formatador; │
│ │ │
│ │ · planície - simples │
│ │ aviso por linha │
│ │ formatador; │
│ │ │
│ │ · omissão - padrão │
│ │ formatador. │
├────────────────────────────────────┼─────────────────────────────────────────────────────────┼──────────────────────────── ──────────────────────┤
│-q | --quieto │ Suprimir saída de relatório para arquivos │
│ │ sem avisos. │
│ │ │
│ │ · -qq - Suprimir saída │
│ │ de avisos. │
│ │ │
│ │ · -qqq - Somente saída │
│ │ resumo. │
├────────────────────────────────────┼─────────────────────────────────────────────────────────┼──────────────────────────── ──────────────────────┤
│--códigos │ Mostrar códigos de aviso. │
├────────────────────────────────────┼─────────────────────────────────────────────────────────┼──────────────────────────── ──────────────────────┤
│--gamas │ Mostrar intervalos de colunas relacionadas │
│ │ para avisos. │
├────────────────────────────────────┼─────────────────────────────────────────────────────────┼──────────────────────────── ──────────────────────┤
│- sem cor │ Não colorir a saída. │
├────────────────────────────────────┼─────────────────────────────────────────────────────────┼──────────────────────────── ──────────────────────┤
│-v | --versão │ Mostrar versão do Luacheck e seus │
│ │ dependências e saída. │
├────────────────────────────────────┼─────────────────────────────────────────────────────────┼──────────────────────────── ──────────────────────┤
│-h | --Socorro │ Mostrar ajuda e sair. │
└────────────────────────────────────┴─────────────────────────────────────────────────────────┴──────────────────────────── ──────────────────────┘

padrões
Opções CLI --ignorar, --permitir e --só e as opções de configuração correspondentes permitem a filtragem
avisos usando correspondência de padrões em códigos de aviso, nomes de variáveis ​​ou ambos. Se um padrão
contém uma barra, a parte antes da barra corresponde ao código de aviso e a parte após as correspondências
nome variável. Caso contrário, se um padrão contém uma letra ou sublinhado, ele corresponde
nome variável. Caso contrário, ele corresponde ao código de aviso. Por exemplo:

┌──────────┬──────────────────────────────────────────────────────────
│Padrão │ Avisos de correspondência │
├──────────┼──────────────────────────────────────────────────────────
│4.2 │ Declarações de sombra de │
│ │ argumentos ou redefinindo-os. │
├──────────┼──────────────────────────────────────────────────────────
│. * _ │ Avisos relacionados a variáveis ​​│
│ │ com _ sufixo. │
├──────────┼──────────────────────────────────────────────────────────
│4.2 /.*_ │ Declarações de sombra de │
│ │ argumentos com _ sufixo ou │
│ │ redefinindo-os. │
└──────────┴──────────────────────────────────────────────────────────┘

A menos que já ancorados, os padrões que correspondem aos nomes das variáveis ​​são ancorados em ambos os lados e
os padrões que correspondem aos códigos de aviso estão ancorados em seus primórdios. Isso permite que
filtrar avisos por categoria (por exemplo --só 1 concentra-se luacheck em avisos relacionados com o global).

Conjuntos of padrão globals
Opção CLI --stds permite combinar conjuntos integrados descritos acima usando +. Por exemplo, a
--std max é equivalente a --std = lua51 + lua52 + lua53. O sinal de mais à esquerda adiciona novos conjuntos a
padrão um em vez de substituí-lo. Por exemplo, --std + preso é adequado para verificação
arquivos de teste que usam Busted estrutura de teste. Conjuntos personalizados de globais podem ser definidos por
variável global mutante DST na configuração. Veja custom_stds

Formatadores
Opção CLI --formatador permite selecionar um formatador personalizado para luacheck saída. Um costume
formatador é um módulo Lua que retorna uma função com três argumentos: relatório conforme retornado por
luacheck módulo (ver relatório), array de nomes de arquivo e tabela de opções. As opções contêm
valores atribuídos a calma, cor, limitar, códigos, gamas e formatador opções em CLI ou
config. A função do formatador deve retornar uma string.

Cache
Se LuaFileSystem estiver disponível, Luacheck pode armazenar em cache os resultados da verificação de arquivos. No subseqüente
verificações, apenas os arquivos que foram alterados desde a última verificação serão verificados novamente, melhorando
tempo de execução significativamente. Alterar opções (por exemplo, definir globais adicionais) não
invalidar cache. O cache pode ser habilitado usando --cache opção ou esconderijo configuração
opção. Usando --cache sem um argumento ou configuração esconderijo opção de configuração para verdadeiro conjuntos
.luacheckcache como o arquivo de cache. Observe que --cache deve ser usado sempre luacheck is
correr, não apenas na primeira corrida.

Estável interface for editor plugins e ferramentas
A interface de linha de comando do Luacheck pode ser alterada entre versões secundárias. A partir de 0.11.0
versão, a seguinte interface é garantida pelo menos até a versão 1.0.0, e deve ser
usado por ferramentas que usam a saída do Luacheck, por exemplo, plug-ins do editor.

· O Luacheck deve ser iniciado a partir do diretório que contém o arquivo verificado.

· O arquivo pode ser passado por stdin usando - como argumento ou usando um arquivo temporário. Real
o nome do arquivo deve ser passado usando --nome do arquivo opção.

· O formatador simples deve ser usado. Ele produz um problema (aviso ou erro) por linha.

· Para obter a localização precisa do erro, --gamas opção pode ser usada. Cada linha começa com real
nome do arquivo (passado usando --nome do arquivo), Seguido por : : - :,
onde é o número da linha em que o problema ocorreu e - is
intervalo inclusivo de colunas de token relacionadas ao problema. A numeração começa em 1. Se
--gamas não é usado, a coluna final e o traço não são impressos.

· Para obter códigos de aviso e erro, --códigos opção pode ser usada. Para cada linha, substring
entre parênteses contém um código de problema de três dígitos, prefixado com E por erros e W
para avisos. A falta de tal substring indica um erro fatal (por exemplo, erro de E / S).

· O resto da linha é uma mensagem de aviso.

Se a compatibilidade com a versão mais antiga do Luacheck for desejada, a saída de luacheck --Socorro pode ser
usado para obter sua versão. Se contiver string 0 ., Onde está em
pelo menos 11 e remendo é qualquer número, a interface descrita acima deve ser usada.

CONFIGURAÇÃO ARQUIVO

luacheck tenta carregar a configuração de .luacheckrc arquivo no diretório atual. Se
não for encontrado, ele irá procurá-lo no diretório pai e assim por diante, subindo até ele
atinge a raiz do sistema de arquivos. O caminho para a configuração pode ser definido usando --config opção, caso em que
ele será usado durante o carregamento recursivo. O carregamento de configuração pode ser desabilitado usando --no-config
bandeira.

Config é simplesmente um script Lua executado por luacheck. Pode definir várias opções por
atribuindo a globais ou retornando uma tabela com nomes de opções como chaves.

Configuração opções
┌─────────────────────┬─────────────────────────────────────────────────────────────────────────────────────── ──────────────────────┐
│ Opção │ Tipo │ Valor padrão │
├─────────────────────┼─────────────────────────────────────────────────────────────────────────────────────── ─────────────────────┤
│cor │ Booleano │ verdadeiro │
├─────────────────────┼─────────────────────────────────────────────────────────────────────────────────────── ─────────────────────┤
│códigos │ Booleano │ falso │
└─────────────────────┴────────────────────────────────────────────────────────────────────────────────────────────── ──────────────────────┘

│formatador │ String ou função │ "padrão" │
├─────────────────────┼─────────────────────────────────────────────────────────────────────────────────────── ─────────────────────┤
│esconderijo │ Booleano ou string │ falso │
├─────────────────────┼─────────────────────────────────────────────────────────────────────────────────────── ─────────────────────┤
│empregos │ Número inteiro positivo │ 1 │
├─────────────────────┼─────────────────────────────────────────────────────────────────────────────────────── ─────────────────────┤
│arquivos_excluídos │ Matriz de strings │ {} │
├─────────────────────┼─────────────────────────────────────────────────────────────────────────────────────── ─────────────────────┤
│include_files │ Matriz de strings │ (Incluir todos os arquivos) │
├─────────────────────┼─────────────────────────────────────────────────────────────────────────────────────── ─────────────────────┤
│global │ Booleano │ verdadeiro │
├─────────────────────┼─────────────────────────────────────────────────────────────────────────────────────── ─────────────────────┤
│não usado │ Booleano │ verdadeiro │
├─────────────────────┼─────────────────────────────────────────────────────────────────────────────────────── ─────────────────────┤
│redefinido │ Booleano │ verdadeiro │
├─────────────────────┼─────────────────────────────────────────────────────────────────────────────────────── ─────────────────────┤
│argumentos_não utilizados │ Booleano │ verdadeiro │
├─────────────────────┼─────────────────────────────────────────────────────────────────────────────────────── ─────────────────────┤
│não usados_secundários │ Booleano │ verdadeiro │
├─────────────────────┼─────────────────────────────────────────────────────────────────────────────────────── ─────────────────────┤
│eu │ Booleano │ verdadeiro │
├─────────────────────┼─────────────────────────────────────────────────────────────────────────────────────── ─────────────────────┤
│std │ String ou conjunto de │ "_G" │
│ │ globais padrão │ │
├─────────────────────┼─────────────────────────────────────────────────────────────────────────────────────── ─────────────────────┤
│globals │ Matriz de strings │ {} │
├─────────────────────┼─────────────────────────────────────────────────────────────────────────────────────── ─────────────────────┤
│novos_globais │ Matriz de strings │ (não sobrescrever) │
├─────────────────────┼─────────────────────────────────────────────────────────────────────────────────────── ─────────────────────┤
│read_globals │ Matriz de strings │ {} │
├─────────────────────┼─────────────────────────────────────────────────────────────────────────────────────── ─────────────────────┤
│new_read_globals │ Matriz de strings │ (não sobrescrever) │
├─────────────────────┼─────────────────────────────────────────────────────────────────────────────────────── ─────────────────────┤
│compat │ Booleano │ falso │
├─────────────────────┼─────────────────────────────────────────────────────────────────────────────────────── ─────────────────────┤
│permitir_definido │ Booleano │ falso │
├─────────────────────┼─────────────────────────────────────────────────────────────────────────────────────── ─────────────────────┤
│permitir_definido_top │ Booleano │ falso │
├─────────────────────┼─────────────────────────────────────────────────────────────────────────────────────── ─────────────────────┤
│módulo │ Booleano │ falso │
├─────────────────────┼─────────────────────────────────────────────────────────────────────────────────────── ─────────────────────┤
│ignorar │ Matriz de padrões (ver │ {} │
│ │ padrões) │ │
├─────────────────────┼─────────────────────────────────────────────────────────────────────────────────────── ─────────────────────┤
│permitir │ Matriz de padrões │ {} │
├─────────────────────┼─────────────────────────────────────────────────────────────────────────────────────── ─────────────────────┤
│só │ Matriz de padrões │ (não filtrar) │
├─────────────────────┼─────────────────────────────────────────────────────────────────────────────────────── ─────────────────────┤
│em linha │ Booleano │ verdadeiro │
└─────────────────────┴────────────────────────────────────────────────────────────────────────────────────────────── ──────────────────────┘

Um exemplo de configuração que torna luacheck garantir que apenas os globais do portátil
intersecção de Lua 5.1, Lua 5.2, Lua 5.3 e LuaJIT 2.0 são usados, bem como desabilita
detecção de argumentos não utilizados:

std = "min"
ignore = {"212"}

Personalizado conjuntos of globals
std opção permite definir um conjunto padrão personalizado de globais usando uma tabela. Naquela mesa,
as chaves da string são globais e a string na parte do array são globais somente leitura.

Além disso, os conjuntos personalizados podem receber nomes por mutação global DST variável. Para
exemplo, ao usar GLP biblioteca, faz sentido acessar suas funções de forma concisa usando
globais. Nesse caso, a configuração a seguir permite a remoção de falsos positivos relacionados a
acesso global facilmente:

stds.lpeg = requer "lpeg"

lpeg local = requer "lpeg"

função local parse1 (...)
- Esta função usa funções lpeg apenas como globais.
_ENV local = lpeg
- luacheck: std lpeg
dígito local, espaço = R "09", S ""
- ...
final

função local parse2 (...)
- Esta função usa funções lpeg, bem como globais padrão.
local _ENV = setmetatable ({}, {__index = function (_, k) return _ENV [k] ou lpeg [k] end})
- luacheck: std + lpeg
dígito local, espaço = R "09", S ""
número local = C (dígito ^ 1) / número da tonelada
- ...
final

Por arquivo e por caminho Substitui
O ambiente em que luacheck carrega a configuração contém um global especial arquivos. Quando
verificando um arquivo , luacheck irá substituir as opções da configuração principal com itens
da arquivos[ ] e arquivos[ ], aplicando entradas para caminhos mais curtos primeiro. Para
exemplo, a configuração a seguir reativa a detecção de argumentos não utilizados apenas para arquivos em
src / dir, mas não para src / dir / myfile.lua, e permite usar Busted globais dentro spec /:

std = "min"
ignore = {"212"}
arquivos ["src / dir"] = {enable = {"212"}}
arquivos ["src / dir / meuarquivo.lua"] = {ignore = {"212"}}
arquivos ["spec"] = {std = "+ preso"}

Observe que arquivos tabela suporta autovivificação, de modo que

arquivos ["meuarquivo.lua"]. ignore = {"212"}

e

arquivos ["myfile.lua"] = {ignore = {"212"}}

são equivalentes.

NA LINHA OPÇÕES

Luacheck suporta a configuração de algumas opções diretamente nos arquivos marcados usando inline
comentários de configuração. Um comentário de configuração embutido começa com luacheck: rótulo,
possivelmente depois de algum espaço em branco. O corpo do comentário deve conter separado por vírgulas
options, onde a invocação da opção consiste em seu nome mais argumentos separados por espaço. o
as seguintes opções são suportadas:

┌─────────────────────┬─────────────────────────────────────────────────────────── ─────┐
│ Opção │ Número de argumentos │
├─────────────────────┼───────────────────────────────────────────────────────────────────────────────────── ─────┤
│global │ 0 │
├─────────────────────┼───────────────────────────────────────────────────────────────────────────────────── ─────┤
│ não utilizado │ 0 │
├─────────────────────┼───────────────────────────────────────────────────────────────────────────────────── ─────┤
│redefinido │ 0 │
├─────────────────────┼───────────────────────────────────────────────────────────────────────────────────── ─────┤
│ args não utilizados │ 0 │
├─────────────────────┼───────────────────────────────────────────────────────────────────────────────────── ─────┤
│ secundários não utilizados │ 0 │
├─────────────────────┼───────────────────────────────────────────────────────────────────────────────────── ─────┤
│ mesmo │ 0 │
└─────────────────────┴───────────────────────────────────────────────────────────────────────────────────── ─────┘

│compatível │ 0 │
├─────────────────────┼───────────────────────────────────────────────────────────────────────────────────── ─────┤
│ módulo │ 0 │
├─────────────────────┼───────────────────────────────────────────────────────────────────────────────────── ─────┤
│ permitir definido │ 0 │
├─────────────────────┼───────────────────────────────────────────────────────────────────────────────────── ─────┤
│permitir topo definido │ 0 │
├─────────────────────┼───────────────────────────────────────────────────────────────────────────────────── ─────┤
│std │ 1 │
├─────────────────────┼───────────────────────────────────────────────────────────────────────────────────── ─────┤
│globais │ 0+ │
├─────────────────────┼───────────────────────────────────────────────────────────────────────────────────── ─────┤
│novos globais │ 0+ │
├─────────────────────┼───────────────────────────────────────────────────────────────────────────────────── ─────┤
│ler globais │ 0+ │
├─────────────────────┼───────────────────────────────────────────────────────────────────────────────────── ─────┤
│nova leitura global │ 0+ │
├─────────────────────┼───────────────────────────────────────────────────────────────────────────────────── ─────┤
│ignore │ 0+ (sem argumentos tudo │
│ │ é ignorado) │
├─────────────────────┼───────────────────────────────────────────────────────────────────────────────────── ─────┤
│ativar │ 1+ │
├─────────────────────┼───────────────────────────────────────────────────────────────────────────────────── ─────┤
│apenas │ 1+ │
└─────────────────────┴───────────────────────────────────────────────────────────────────────────────────── ─────┘

As opções que não aceitam argumentos podem ser prefixadas com não para inverter seu significado. Por exemplo
--luacheck: não não usado args desativa avisos de argumentos não utilizados.

Parte do arquivo afetado pela opção embutida depende de onde ele está colocado. Se houver algum
código na linha com a opção, apenas essa linha é afetada; caso contrário, tudo até
o fim do fechamento atual é. Em particular, as opções embutidas na parte superior do arquivo
afeta tudo isso:

- luacheck: globais g1 g2, ignorar foo
local foo = g1 (g2) - Nenhum aviso emitido.

- A seguinte função não utilizada não é relatada.
função local f () - luacheck: ignorar
- luacheck: globais g3
g3 () - Sem aviso.
final

g3 () - Aviso é emitido como a opção inline definindo g3 apenas a função afetada f.

Para um controle refinado sobre a opção de visibilidade em linha, use luacheck: empurrar e luacheck:
estouro diretivas:

- luacheck: push ignorar foo
foo () - Sem aviso.
- luacheck: pop
foo () - Aviso é emitido.

As opções embutidas podem ser completamente desabilitadas usando --sem linha Opção CLI ou em linha configuração
opção.

LUACHECK MÓDULO

Use local luacheck = requerer "luacheck" importar luacheck módulo. Contém o
seguintes funções:

· luacheck.get_report (fonte): Dado string de origem, retorna dados de análise (uma tabela).

· luacheck.process_reports (relatórios, opções): Processos matriz de relatórios de análise e
aplica opções. relatórios [i] utiliza opções, opções [i], opções [i] [1], opções [i] [2], ...
como opções, substituindo-se mutuamente nessa ordem. A tabela de opções é uma tabela com campos
semelhante às opções de configuração; veja as opções. Relatórios de análise com campo fatal são ignorados.
relatórios_processos retorna o relatório final, veja Relatório formato.

· luacheck.check_strings (fontes, opções): Verifica a matriz de fontes usando opções, retorna
relatório final. Tabelas com campo fatal dentro fontes array são ignorados.

· luacheck.check_files (arquivos, opções): Verifica a matriz de arquivos usando opções, retorna final
relatório. Identificadores de arquivos abertos podem ser passados ​​em vez de nomes de arquivos, caso em que eles serão
leia até EOF e feche.

· luacheck.get_message (problema): Retorna uma mensagem de string para um problema, consulte Relatório formato.

luacheck._VERSION contém a versão Luacheck como uma string em MAIOR.MINOR.PATCH formato.

utilização luacheck como uma função é equivalente a chamar luacheck.check_files.

Relatório formato
Um relatório final é uma série de relatórios de arquivo mais campos avisos, erros e fatal
contendo o número total de avisos, erros e erros fatais, correspondentemente.

Um relatório de arquivo é uma série de problemas (avisos ou erros). Se um erro fatal ocorreu durante
verificando um arquivo, seu relatório terá fatal campo contendo o tipo de erro.

Um problema é uma tabela com campo código indicando o seu tipo (ver avisos), e campos linha,
coluna e coluna_final apontando para a fonte do aviso. nome campo pode conter nome
de relacionar variável. Problemas de alguns tipos também podem ter campos adicionais:

┌────────┬────────────────────────────────────────┬──────────
│ Códigos │ Campos adicionais │
├────────┼────────────────────────────────────────┼──────────
│011 │ msg campo contém erro de sintaxe │
│ │ mensagem. │
├────────┼────────────────────────────────────────┼──────────
│111 │ módulo campo indica que │
│ │ atribuição é para um não módulo │
│ │ variável global. │
├────────┼────────────────────────────────────────┼──────────
│211 │ função campo indica que não utilizado │
│ │ variável é uma função. │
├────────┼────────────────────────────────────────┼──────────
│4 .. │ linha_prev e coluna_prev campos │
│ │ contém a localização do │
│ │ definição substituída. │
└────────┴────────────────────────────────────────┴──────────

Outros campos podem estar presentes por motivos internos.

Esta é a documentação para a versão 0.13.0 do Luacheck, um linter para Lua.

Use luacheck online usando serviços onworks.net