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

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 |

Véxase tamén
------------

### Outros artigos

* Programación a nivel de funcións
* APL
* FP
* FL
* K

### Ligazóns externas

* JSoftwareArquivado 20 de novembro de 2004 en Wayback Machine.- Creadores de *J* *(en inglés)*

|  |  |
| --- | --- |
| Control de autoridades | 
* Wd: Q383994
* LCCN: sh2001001715

 |

| * v
* c
* e
Linguaxes de programación |
| --- |
| Baixo nivel | 

|  |  |
| --- | --- |
| Primeira xeración | Código máquina |
| Segunda xeración | Assembly |

 |
| Alto nivel | 

|  |  |
| --- | --- |
| Terceira xeración | 
* A+
* ABC
* Algol
* B
* BASIC
* C
* C++
* C#
* COBOL
* CPL
* D
* E
* Fortran
* Go
* Java
* JavaScript
* Lisp
* Objective-C
* PL/1
* Pascal
* Smalltalk
* Visual Basic .NET

 |
| Cuarta xeración | 
* Clarion
* Clipper
* Clojure
* Common Lisp
* Erlang
* GNU Octave
* Haskell
* Lisp
* Lua
* Julia
* Perl
* PHP
* Prolog
* Python
* R
* Ruby
* Rust
* S
* Scilab
* Stata
* SQL

 |
| Quinta xeración | 
* Mercury
* OPS5
* Prolog

 |

 |
| 
* Ambiente de desenvolvemento
* Metaprogramación
* Programación a nivel funcional
* Programación estruturada
* Programación non estruturada
* Programación imperativa
* Programación modular
* Programación multidimensional
* Orientación a obxectos

 |