J (linguagem de programação) - J (programming language)

J
Projetado por	Kenneth E. Iverson , Roger Hui
Desenvolvedor	JSoftware
Apareceu pela primeira vez	1990 ; 31 anos atrás
Versão estável	J901 / 15 de dezembro de 2019 ; 22 meses atrás
Disciplina de digitação	dinâmico
SO	Plataforma cruzada : Windows , Linux , macOS , Android , iOS , Raspberry Pi
Licença	GPLv3
Local na rede Internet	www .jsoftware .com
Implementações principais
	J
Influenciado por
	APL
Influenciado
	NumPy , SuperCollider

A linguagem de programação J , desenvolvida no início dos anos 1990 por Kenneth E. Iverson e Roger Hui , é uma linguagem de programação de array baseada principalmente em APL (também por Iverson).

Para evitar a repetição do problema de caracteres especiais APL, J usa apenas o conjunto de caracteres ASCII básico , recorrendo ao uso do ponto e dois pontos como inflexões para formar palavras curtas semelhantes aos dígrafos . A maioria dessas palavras J primárias (ou primitivas ) servem como símbolos matemáticos, com o ponto ou dois pontos estendendo o significado dos caracteres básicos disponíveis. Além disso, muitos caracteres que em outros idiomas geralmente devem ser emparelhados (como [] {} "" ``ou <>) são tratados por J como palavras autônomas ou, quando flexionadas, como raízes de um único caractere de palavras com vários caracteres.

J é uma linguagem de programação de array muito concisa e mais adequada para programação matemática e estatística , especialmente ao realizar operações em matrizes . Também tem sido usado em programação extrema e análise de desempenho de rede .

Como as linguagens FP e FL de John Backus , J oferece suporte à programação em nível de função por meio de seus recursos de programação tácitos .

Ao contrário da maioria das linguagens que oferecem suporte à programação orientada a objetos , o esquema de namespace hierárquico flexível de J (onde cada nome existe em um local específico ) pode ser usado efetivamente como uma estrutura para programação orientada a objetos baseada em classes e em protótipos .

Desde março de 2011, J é um software livre e de código aberto sob a GNU General Public License versão 3 (GPLv3). Pode-se também comprar o código-fonte sob uma licença negociada.

Exemplos

J permite um estilo livre de pontos e composição de funções . Assim, seus programas podem ser muito concisos e são considerados difíceis de ler por alguns programadores.

O "Hello, World!" programa em J é

  'Hello, world!'

Esta implementação de hello world reflete o uso tradicional de J - programas são inseridos em uma sessão de intérprete J e os resultados das expressões são exibidos. Também é possível fazer com que os scripts J sejam executados como programas independentes. Veja como isso pode parecer em um sistema Unix :

   #!/bin/jc
   echo 'Hello, world!'
   exit ''

Historicamente, o APL costumava /indicar a dobra , então +/1 2 3era equivalente a 1+2+3. Enquanto isso, a divisão foi representada com o símbolo de divisão matemática ( ÷). Como o ASCII não inclui um símbolo de divisão per se , J usa% para representar a divisão, como uma aproximação visual ou lembrete. (Isso ilustra algo do caráter mnemônico dos tokens de J e alguns dos dilemas impostos pelo uso de ASCII.)

Definir uma função J nomeada avgpara calcular a média de uma lista de resultados de números:

  avg=: +/ % #

Esta é uma execução de teste da função:

  avg 1 2 3 4
2.5

# conta o número de itens na matriz. +/ soma os itens da matriz. % divide a soma pelo número de itens. Acima, avg é definido usando um trem de três verbos ( +/, %e #) denominado um garfo . Especificamente, (V0 V1 V2) Nyé o mesmo (V0(Ny)) V1 (V2(Ny))que mostra parte do poder de J. (aqui V0, V1 e V2 denotam verbos e Ny denota um substantivo.)

Alguns exemplos de uso avg:

  v=: ?. 20 $100     NB. a random vector
  v
46 55 79 52 54 39 60 57 60 94 46 78 13 18 51 92 78 60 90 62
  avg v
59.2

  4 avg\ v            NB. moving average on periods of size 4
58 60 56 51.25 52.5 54 67.75 64.25 69.5 57.75 38.75 40 43.5 59.75 70.25 80 72.5

  m=: ?. 4 5 $50     NB. a random matrix
  m
46  5 29  2  4
39 10  7 10 44
46 28 13 18  1
42 28 10 40 12

  avg"1 m             NB. apply avg to each rank 1 subarray (each row) of m
17.2 22 21.2 26.4

Ranking é um conceito crucial no J. Sua importância na J é semelhante ao significado de selectem SQL e whileem C .

A implementação do quicksort , a partir do J Dicionário, produz:

   sel=: adverb def 'u # ['
   
   quicksort=: verb define
    if. 1 >: #y do. y
    else.
     (quicksort y <sel e),(y =sel e),quicksort y >sel e=.y{~?#y
    end.
   )

A seguir está uma implementação do quicksort demonstrando a programação tácita . O último envolve a composição de funções em conjunto e não se refere explicitamente a nenhuma variável. O suporte de J para bifurcações e ganchos dita regras sobre como os argumentos aplicados a esta função serão aplicados às funções de seus componentes.

   quicksort=: (($:@(<#[), (=#[), $:@(>#[)) ({~ ?@#)) ^: (1<#)

A classificação em J é geralmente realizada usando os verbos internos /:( primitivos) (classificar para cima) e \:(classificar para baixo). As classificações definidas pelo usuário, como quicksort, acima, normalmente são apenas para ilustração.

O exemplo a seguir demonstra o uso do verbo de autorreferência $:para calcular recursivamente os números de Fibonacci:

1:`($:@-&2+$:@<:)@.(>&2)

Essa recursão também pode ser realizada referindo-se ao verbo pelo nome, embora isso, obviamente, só seja possível se o verbo for nomeado:

fibonacci=:1:`(fibonacci@-&2+fibonacci@<:)@.(>&2)

A expressão a seguir exibe pi com n dígitos e demonstra as habilidades de precisão estendida de J:

  n=: 50                      NB. set n as the number of digits required
  <.@o. 10x^n                 NB. extended precision 10 to the nth * pi
314159265358979323846264338327950288419716939937510

Verbos e modificadores

Um programa ou rotina - algo que recebe dados como entrada e produz dados como saída - é chamado de verbo . J tem um rico conjunto de verbos predefinidos, todos os quais funcionam em vários tipos de dados automaticamente: por exemplo, o verbo i. pesquisa em matrizes de qualquer tamanho para encontrar correspondências:

   3 1 4 1 5 9 i. 3 1  NB. find the index of the first occurrence of 3, and of 1
0 1
   3 1 4 1 5 9 i: 3 1  NB. find the index of the last occurrence of 3, and of 1
0 3

Os programas do usuário podem ser nomeados e usados sempre que as primitivas são permitidas.

O poder de J vem em grande parte de seus modificadores : símbolos que tomam substantivos e verbos como operandos e aplicam os operandos de uma maneira especificada. Por exemplo, o modificador / pega um operando, um verbo à sua esquerda, e produz um verbo que aplica esse verbo entre cada item de seu argumento. Ou seja, + / é um verbo, definido como 'aplicar + entre os itens do seu argumento'. Assim, a frase

   +/ 1 2 3 4 5

produz o efeito de

   1 + 2 + 3 + 4 + 5

   +/ 1 2 3 4 5
15

J tem cerca de duas dúzias desses modificadores. Todos eles podem ser aplicados a qualquer verbo, até mesmo um verbo escrito pelo usuário, e os usuários podem escrever seus próprios modificadores. Embora os modificadores sejam poderosos individualmente, permitindo

execução repetida, ou seja, do-while
execução condicional, ou seja, se
execução de subconjuntos regulares ou irregulares de argumentos

alguns dos modificadores controlam a ordem em que os componentes são executados, permitindo que os modificadores sejam combinados em qualquer ordem para produzir a variedade ilimitada de operações necessárias para a programação prática.

Tipos e estruturas de dados

J oferece suporte a três tipos simples:

Numérico
Literal (personagem)
Encaixotado

Destes, o numérico tem mais variantes.

Um dos tipos numéricos de J é o bit . Existem dois valores de bit: 0 e 1 . Além disso, os bits podem ser formados em listas. Por exemplo, 1 0 1 0 1 1 0 0 é uma lista de oito bits. Sintaticamente, o analisador J trata isso como uma palavra. (O caractere de espaço é reconhecido como um caractere formador de palavras entre o que, de outra forma, seriam palavras numéricas.) Listas de comprimento arbitrário são aceitas.

Além disso, J suporta todas as operações binárias usuais nessas listas, como e , ou , ou exclusivo , girar , mudar , não , etc. Por exemplo,

  1 0 0 1 0 0 1 0 +. 0 1 0 1 1 0 1 0     NB. or
1 1 0 1 1 0 1 0

  3 |. 1 0 1 1 0 0 1 1 1 1 1             NB. rotate
1 0 0 1 1 1 1 1 1 0 1

J também oferece suporte a matrizes de bits de ordem superior. Eles podem ser formados em matrizes bidimensionais, tridimensionais, etc. As operações acima funcionam igualmente bem nessas matrizes.

Outros tipos numéricos incluem inteiro (por exemplo, 3, 42), ponto flutuante (3,14, 8,8e22), complexo (0j1, 2,5j3e88), inteiro de precisão estendida (12345678901234567890x) e fração racional (precisão estendida) (1r2, 3r4). Tal como acontece com os bits, eles podem ser formados em listas ou matrizes dimensionadas arbitrariamente. Tal como acontece com os bits, as operações são realizadas em todos os números em uma matriz.

Listas de bits podem ser convertidas em inteiros usando o #.verbo. Os inteiros podem ser convertidos em listas de bits usando o #:verbo. (Ao analisar J, .(ponto) e :(dois pontos) são caracteres formadores de palavras. Eles nunca são tokens sozinhos, a menos que precedidos por caracteres de espaço em branco .)

J também suporta o tipo literal (caractere). Literais são colocados entre aspas, por exemplo, 'a'ou 'b'. Listas de literais também são suportadas usando a convenção usual de colocar vários caracteres entre aspas, como 'abcdefg'. Normalmente, os literais individuais têm 8 bits de largura (ASCII), mas J também oferece suporte a outros literais ( Unicode ). Operações numéricas e booleanas não são suportadas em literais, mas operações orientadas a coleção (como girar) são suportadas.

Finalmente, existe um tipo de dados em caixa. Normalmente, os dados são colocados em uma caixa usando a <operação (sem nenhum argumento à esquerda; se houver um argumento à esquerda, este seria a operação menor que ). Isto é análogo a C 's &funcionamento (sem argumento esquerda). No entanto, onde o resultado de C &tem semântica de referência, o resultado de J <tem semântica de valor. Em outras palavras, <é uma função e produz um resultado. O resultado tem 0 dimensões, independentemente da estrutura dos dados contidos. Do ponto de vista de um programador J, < coloca os dados em uma caixa e permite trabalhar com uma matriz de caixas (pode ser montada com outras caixas e / ou podem ser feitas mais cópias da caixa).

  <1 0 0 1 0
+---------+
|1 0 0 1 0|
+---------+

O único tipo de coleção oferecido por J é a matriz dimensionada arbitrariamente. A maioria dos algoritmos pode ser expressa de forma muito concisa usando operações nessas matrizes.

Os arrays de J são digitados de maneira homogênea, por exemplo, a lista 1 2 3 é uma lista de inteiros, apesar de 1 ser um bit. Na maior parte, esses tipos de problemas de tipo são transparentes para os programadores. Apenas certas operações especializadas revelam diferenças de tipo. Por exemplo, a lista 1.0 0.0 1.0 0.0 seria tratada exatamente da mesma forma, pela maioria das operações, que a lista 1 0 1 0 .

J também oferece suporte a matrizes numéricas esparsas, onde valores diferentes de zero são armazenados com seus índices. Este é um mecanismo eficiente onde relativamente poucos valores são diferentes de zero.

J também oferece suporte a objetos e classes, mas esses são um artefato da maneira como as coisas são nomeadas e não são tipos de dados. Em vez disso, os literais em caixa são usados para se referir a objetos (e classes). Os dados J têm semântica de valor, mas objetos e classes precisam de semântica de referência.

Outro pseudo-tipo - associado ao nome, em vez do valor - é o arquivo mapeado na memória.

Depurando

Dissecando a sequência de Collatz a partir de 6

J tem as facilidades usuais para parar em caso de erro ou em locais específicos dentro dos verbos. Ele também possui um depurador visual exclusivo, chamado Dissect , que fornece uma exibição interativa 2-D da execução de uma única frase J. Como uma única sentença de J executa tantos cálculos quanto uma sub-rotina inteira em linguagens de nível inferior, a exibição visual é bastante útil.

Documentação

A documentação de J inclui um dicionário , com palavras em J identificadas como substantivos , verbos , modificadores e assim por diante. As palavras primárias são listadas no vocabulário , no qual suas respectivas classes gramaticais são indicadas por meio de marcação. Observe que os verbos têm duas formas: monádico (argumentos apenas à direita) e diádico (argumentos à esquerda e à direita). Por exemplo, em ' -1' o hífen é um verbo monádico e em ' 3-2' o hífen é um verbo diádico. A definição monádica é principalmente independente da definição diádica, independentemente de o verbo ser um verbo primitivo ou um verbo derivado.

Estruturas de controle

J fornece estruturas de controle (detalhes aqui) semelhantes a outras linguagens procedurais. Palavras de controle proeminentes em cada categoria incluem:

assert.
break.
continue.
for.
goto_label.
if. else. elseif.
return.
select. case.
throw.
try. catch.
while. whilst.

Languages

In other projects

J (linguagem de programação) - J (programming language)

Conteúdo

Exemplos

Verbos e modificadores

Tipos e estruturas de dados

Depurando

Documentação

Estruturas de controle

Veja também

Referências

links externos