J (linguaxe de programación)

**J** é unha linguaxe de programación deseñada por Kenneth Iverson e Roger Hui nos anos 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 da 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 se executen 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.{?#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

## 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. Sintacticamente, 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 '*** ó ****. 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 . 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 homoxeneamente 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 obxectos (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*
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

## Véxase tamén 
### Outros artigos 
* Programación a nivel de funcións
* APL
* FP
* FL
* K

### Ligazóns externas 
* JSoftware- Creadores de *J*