PROFILPELAJAR.COM

A linguaxe de programación J, deseñada por Kenneth Iverson e Roger Hui nos '90, é unha síntese das linguaxes de programación APL (deseñado tamén por Iverson) e as linguaxes funcionais FP e FL creados por John Backus (famoso por FORTRAN, ALGOL e BNF).

Historia e características

Para eliminar o problema xerado polo uso dun xogo de caracteres especiais en APL, J só require o xogo de caracteres básicos ASCII. Úsanse tanto o punto como os dous puntos para estender o significado do xogo de caracteres dispoñible.

Dado que se trata dunha linguaxe de programación de array, J é moi conciso e potente, e é útil para crear programas nos campos das matemáticas e da estatística, especialmente cando involucran operacións con matrices.

Da mesma xeito que as linguaxes FP/FL, J soporta Programación a nivel de funcións (tamén coñecida como programación funcional de alta orde), grazas ás súas características de programación tácita (nótese que a programación a nivel de funcións non é o mesmo que programación funcional).

A diferenza de moitas linguaxes que soportan a programación orientada a obxectos, o flexible esquema de espazo de nomes xerárquico da linguaxe J (onde cada nome existe nun ámbito particular) pode ser usado con efectividade como un marco de traballo para realizar programación orientada a obxectos baseada tanto en clases, como en instancias.

J é unha linguaxe de programación non von Neumanniano, que con todo permite que o programador use o estilo de programación von Neumann a conveniencia.

Nótese que a linguaxe de programación J non está relacionado con J++, nin a súa nova versión J# (unha versión propietaria do Linguaxe de programación Java desenvolvida por Microsoft).

Exemplos

J é unha linguaxe de programación extremadamente potente, e os seus programas poden ser moi tersos, pero ata máis crípticos.

O programa 'Ola Mundo' en J é:

   'Ola Mundo'

Esta implementación de 'Ola Mundo' reflicte o uso tradicional de J -- os programas son introducidos durante unha sesión do intérprete J, e os resultados das expresións móstranse de modo interactivo. Tamén é posible facer que scripts en J póidanse executar como programas independentes, pero os mecanismos usados para asociar o script co intérprete son dependentes do sistema. Nun sistema Unix, poderíase facer como segue:

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

Con todo, estes mecanismos non son usados por moitos programadores expertos de J.

A continuación móstrase un programa J que calcula a media dunha lista de números:

      avg =. +/ % #
      avg 1 2 3 4
  2.5

'#' - conta o número de elementos na cadea. '+/' - suma todos os elementos da cadea. '%' - divide a suma dos elementos polo número de elementos.

Agora xeraremos algúns números aleatorios e calcularemos a súa media:

     a =. ?2000
     a
  31 16 60 64 64 71 13 3 76 26 25 77 68 48 42 91 99 97 99 9
     avg a
  53.95

Segue unha implementación do algoritmo quicksort, sacada do dicionario de funcións de J:

sel=: adverb def 'x. # ['

quicksort=: verb define
 if. 1 >: #e. do. e.
 else.
  (quicksort e. <sel e),(e. =sel e),quicksort e. >sel e=.e.{?#e.
 end.
)

A seguinte expresión (Roger Hui) calcula os primeiros n díxitos de pi, e demostra a capacidade de J de usar precisión estendida:

 n=.50                                           NB. asigna a n o número de díxitos requirido.
 <.@\ou. 10x^*                                     NB. precisión estendida 10^* * pi
314159265358979323846264338327950288419716939937510

Pode atopar tamén unha implementación en J do Xogo da vida de Conway en http://ww2.lafayette.edu/reiterc/j/vector/vlife_index.html^{[Ligazón morta]}

Estruturas e Tipos de Datos

J soporta tres tipos de datos simples:

Numérico
Literal (Carácter)
Encaixado

O tipo numérico é o que máis variantes ten de todos éllos.

Un dos tipos numéricos de J é o bit. Existen dous valores neste tipo: 0 e 1. Ademais, varios bits poden formar unha lista. Por exemplo, 1 0 1 0 1 1 0 0 é unha lista de oito bits. Sintácticamente, o parser de J trátaos como unha única palabra (os caracteres espazo recoñécense como formadores de palabras cando están situados entre o que serían palabras numéricas de forma individual). J soporta listas de lonxitude arbitraria.

Ademais, J soporta todas as operacións habituais sobre estas listas, talles como e, ou, ou exclusivo, rotación, translación, non etc. Por exemplo,

   1 0 0 1 0 0 1 0 +. 0 1 0 1 1 0 1 0     NB. ó
1 1 0 1 1 0 1 0
   3 |. 1 0 1 1 0 0 1 1 1 1 1             NB. rotación
1 0 0 1 1 1 1 1 1 0 1

Nótese que J tamén soporta arrays de bits de orde maior—é dicir, pódense formar arrays bidimensionales, tridimensionales etc. As operacións descritas arriba execútanse de igual xeito sobre estes arrays.

Outros tipos numéricos inclúen enteiro (3, 42), punto flotante (3.14, 8.8e22), complexo (0j1, 2.5j3e88), enteiro de precisión estendida (12345678901234567890x), e fracción racional (de precisión estendida) (1r2, 3r4). De igual forma que pasaba cos bits, poden formarse tanto listas como arrays dun número arbitrario de dimensións. Tamén de forma similar, as operacións sobre o array execútanse sobre todos os números contidos no array.

As listas de bits poden ser convertidas en enteiros usando o verbo #. Os enteiros poden ser convertidos en listas de bits usando o verbo #:. (Durante a análise sintáctico, J interpreta . e : como caracteres que forman palabras. Nunca os considera elementos por si mesmos salvo que estean precedidos por un espazo branco).

J tamén soporta o tipo literal (caracter). Os literais encérranse entre comiñas simples, por exemplo 'a' ó 'b'. J soporta tamén listas de literais usando a convención habitual de pór unha secuencia de caracteres entre comiñas simples, por exemplo 'abcdefg'. Tipicamente, os literais individuais teñen 8 bits (ASCII), pero J tamén soporta outros tipos de literais (Unicode). Os operadores numéricos e booleanos non están soportados sobre os literais, pero as operacións sobre coleccións (talles como a rotación) si que o están.

Para rematar, existe o tipo encaixado. Tipicamente, os datos encáixanse usando a operación < (sen ningún argumento á esquerda—se hai un argumento á esquerda, este carácter interprétase como a operación 'menor que'). É análogo á operación & do C (sen argumento á esquerda). Con todo, os resultados do operador de C & teñen semántica de referencia, minetras que o resultado da operación < de J teñen semántica de copia. Dito doutro xeito, < é unha función e produce un resultado. O resultado ten 0 dimensións, a pesar da estrutura dos datos que contén. Desde o punto de vista dun programador en J, < 'pon os datos nunha caixa' e permite ao programador traballar con arrays de caixas (que poden ensamblarse con outras caixas, e/ou se poden facer copias adicionais da caixa). O intérprete de J mostra os datos encaixados de forma similar á que un intérprete de SQL podería decorar os resultados dun comando select.

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

O único tipo colección ofrecido por J é o array arbitrariamente dimensionado. A maior parte dos algoritmos poden expresarse de forma moi concisa usando operacións sobre estes arrays.

Os arrays en J están homogéneamente tipados, por exemplo a lista 1 2 3 considérase unha lista de enteiros, a pesar de que 1 é un bit. Normalmente estes asuntos son transparentes para o programados. Só certas operacións especializadas revelan as diferenzas no tipo. Por exemplo, a maior parte das operacións tratarían de igual forma as listas 1.0 0.0 1.0 0.0 e 1 0 1 0.

J tamén soporta arrays numéricos dispersos, onde os valores non nulos son almacenados cos seus índices. Este mecanismo é eficiente cando relativamente poucos valores son non nulos.

J tamén soporta obxectos e clases, pero son artefactos na forma en que se nomean as cousas, e non son tipos de datos por si mesmos. Adóitanse usar literais encaixados para referirse a objectos (e a clases). Os datos en J teñen semántica de copia, pero os obxectos e clases necesitan que a linguaxe soporte semántica de referencia.

Outro pseudo-tipo—asociado con nome, en lugar de con valor—é o ficheiro mapeado a memoria.

Dicionario

A documentación de J está organizada como un dicionario, con palabras en J identificadas como substantivos, verbos, adverbios, conxuncións etc. As diversas partes dun programa indícanse usando markup: nomes^{[Ligazón morta]} verbos, e varios adverbios, e conxuncións. Nótese que os verbos teñen dúas formas—unarios (con argumentos só á dereita), e binarios (con argumentos á esquerda e á dereita). Por exemplo, en '-1' o operador - é unario, e en '3-2' o operador - é binario. A definición dun operador unario é case independente da definición do operador binario, sen importar se o verbo é primitivo ó derivado.

Vocabulario

Constantes
Controis
Foreigns
Partes dun programa

`=` Self-Classify • Equal	`=.` Is (Local)	`=:` Is (Global)
`<` Box • Less Than	`<.` Floor • Lesser Of (Min)	`<:` Decrement • Less Or Equal
`>` Open • Larger Than	`>.` Ceiling • Larger of (Max)	`>:` Increment • Larger Or Equal
`_` Negative Sign / Infinity	`_.` Indeterminate	`_:` Infinity

`+` Conjugate • Plus	`+.` Real / Imaginary • GCD (Or)	`+:` Double • Not-Or
`*` Signum • Times	`*.` Length/Angle • LCM (And)	`*:` Square • Not-And
`-` Negate • Minus	`-.` Not • Less	`-:` Halve • Match
`%` Reciprocal • Divide	`%.` Matrix Inverse • Matrix Divide	`%:` Square Root • Root

<tt Exponential • Power	<tt. Natural Log • Logarithm	<tt: Power
`$` Shape Of • Shape	`$.` Sparse	`$:` Self-Reference
Reflex • Passive / EVOKE	`.` Nub •	`:` Nub Sieve • Not-Equal
`\|` Magnitude • Residue	`\|.` Reverse • Rotate (Shift)	`\|:` Transpose

`.` Determinant • Dot Product	`..` Even	`.:` Odd
`:` Explicit / Monad-Dyad	`:.` Obverse	`::` Adverse
`,` Ravel • Append	`,.` Ravel Items • Stitch	`,:` Itemize • Laminate
`;` Raze • Link	`;.` Cut	`;:` Word Formation •

`#` Tally • Copy	`#.` Base 2 • Base	`#:` Antibase 2 • Antibase
`!` Factorial • Out Of	`!.` Fit (Customize)	`!:` Foreign
`/` Insert • Table	`/.` Oblique • Key	`/:` Grade Up • Sort
`\` Prefix • Infix	`\.` Suffix • Outfix	`\:` Grade Down • Sort

`[` Same • Left		`[:` Cap
`]` Same • Right
`{` Catalogue • From	`{.` Head • Take	`{:` Tail • `{::` Map • Fetch
`}` Item Amend • Amend	`}.` Behead • Drop	`}:` Curtail •

`"` Rank	`".` Do • Numbers	`":` Default Format • Format
`:` Evoke Gerund
`@\` Atop	`@\.` Axenda	`@\:` At
`&` Bond / Compose	`&.` Under (Dual)	`&:` Appose
	`&.:` Under
`?` Roll • Deal	`?.` Roll • Deal (fixed seed)

`a.` Alphabet	`a:` Ace (Boxed Empty)	`A.` Anagram Index • Anagram
`b.` Boolean / Basic	`c.` Characteristic Values	`C.` Cycle-Direct • Permute
`d.` Derivative	`D.` Derivative	`D:` Secant Slope
`e.` Raze In • Member (In)	`E.` • Member of Interval	`f.` Fix

`H.` Hypergeometric	`i.` Integers • Index Of	`i:` Integers • Index Of Last
`j.` Imaginary • Complex	`L.` Level Of	`L:` Level At
`m. n.` Explicit Noun Args	`NB.` Comment	`ou.` Pi Times • Circle Function
`p.` Polynomial	`p..` Poly. Deriv. • Poly. Integral	`p:` Primes •

`q:` Prime Factors • Prime Exponents	`r.` Angle • Polar	`s:` Symbol
`S:` Spread	`t.` Taylor Coefficient	`t:` Weighted Taylor
`T.` Taylor Approximation	`ou. v.` Explicit Verb Args	`ou:` Unicode
`x. e.` Explicit Arguments	`x:` Estendede Precision	`_9:` to `9:` Constant Functions