J语言

J语言，是一种阵列编程语言，由肯尼斯·艾佛森和于1990年代初发明。J语言是APL语言的一种方言，延续了APL鲜明的简洁性，它在数学和统计学程式设计上十分高效，特别是在需要进行矩阵运算的场合。
J语言最初起步于肯尼斯·艾佛森在1987年发表的《APL字典》，它实现了其中至关重要的秩的概念
</ref>。J语言提供隐式定义机制包括秩、钩子、叉子和多种
</ref>，并介入了作为头等对象的动名词，用以建立控制结构
</ref>，它常被作为隐式编程的典范之一。
简介.
J语言的运算符，承袭APL传统，没有优先级并且最右先行，codice_1按照codice_2来运算。以历史上APL使用的典型符号为例，符号codice_3被用来指示折叠函数codice_4，所以codice_5等价于codice_6；在APL中，除法被表示为数学除号，它将减号和冒号一起在EBCDIC和ASCII二者的纸质文本终端上；J语言使用codice_7表示除法，是对除号的一种近似或提示。
为了避免APL使用特殊的字符而遇到的问题，J语言只需基本的ASCII字符集，但使用点号codice_8和冒号codice_9作为“屈折”。点号和冒号除了前导着空白字符的情况之外，都与紧前字符形成类似双字符组的短字。多数“基础”或“原始”的J单字，都充当数学符号，通过点号或冒号来扩展这些可用基本字符的含义。在其他语言中经常是成对的很多字符，比如codice_10，在J语言中被当作单独的字，或者在有屈折的时候，作为多字符字的单字符字根。
J语言不再支持从1968年的APL\360就有的codice_11形式的方括号索引，转而支持叫做“来自”（from）的索引机制
</ref>，它起源自Kenneth E. Iverson于1978年在《算子和函数》中提出的，依据基数解码定义
J语言的codice_12并未继承IBM对APL解码函数codice_13的扩展规定，它可以实现为：
<syntaxhighlight lang="J">
</syntaxhighlight>
</ref>，并用符号codice_14表示的索引
J语言在定义上述的codice_14（from）之时，解码前后不需要专门进行一元转置codice_16运算：
<syntaxhighlight lang="J" highlight="3-5,7,9-11,13">
0 1 2 3
4 5 6 7
8 9 10 11
10
0 1
2 0
1 2
1 8 6
</syntaxhighlight></ref>。
J语言承袭IBM APL\360采用了平坦阵列模型，不支持由NARS（嵌套阵列研究系统）于1981年介入，并被IBM APL2所采纳的嵌套阵列模型；J语言增加了Kenneth E. Iverson于1978年在《算子和函数》中提出的盒装数据类型，它由SHARP APL于1981年介入，并于1983年在研究报告《理性化APL》中，列入与APL2相比较的“限定子集”（RS）而著重强调。
J语言支持AVX2指令集进行SIMD运算。为了包装用面向对象编程语言开发的API和框架，J语言提供了层级命名空间机制，这里所有名字都存在于特定语境（locale）中，可以避免软件包之间的名字冲突，并能有效的用作基于类的面向对象编程的框架。
J语言解释器默认装载标准库标准库 </ref>。通过包管理器，还可以安装各种插件，如果是在管理员权限下安装的J语言解释器，则安装插件也需要同样的管理员权限。J语言拥有常规调试机制，还有叫做Dissect的可视调试器Dissect </ref>。除了科学计算和统计分析，它还被用于关系数据库管理系统如Jd、极限编程和网络性能分析。
2011年3月，J语言采用了GNU通用公共许可证版本3，从而成为自由和开源软件，人们还可以在Jsoftware的商业许可证下利用源代码。
文档与词类.
J语言的文档包括在官网的NuVoc中，在其中将主要的字罗列为“J”，并使用颜色标示出它们分别的词类。早期的文档还有入门和字典。在J语言中的字，被识别为名词、动词、定语（副词和连词）、系词、标点、控制字。一个程序或例程，如果接受数据作为输入并产生数据作为输出，则被称为“动词”，与之相对，数据参数被称为“名词”。
动词有两种形式：只有右侧一个参数的一元（monad）形式，和有左右两侧参数的二元（dyad）形式，例如在codice_17中减号是一元动词，而在codice_18中减号是二元动词。J语言预定义了很丰富的动词，它们都自动的作用于多种数据类型之上。用户定义的程序可以自行命名，并用在任何允许使用原始动词的地方。无论原始动词还是派生动词，它们的一元定义与二元定义，在很大程度上是独立的。
起步示例.
J语言可以写出非常精简的程序，特别是存在重度的对符号的函数重载，以至于一些编程者将它称为难以阅读的只写语言。在计算机的终端上执行codice_19，即可进入J语言的REPL解释器界面。
Hello, World!
J语言的“Hello, World!”程序：
<syntaxhighlight lang="j" highlight="2">
Hello, world!
</syntaxhighlight>
这个Hello World的实现反映了J语言的传统用法，就是把程序录入到J解释器会话中，显示出表达式结果。还可以准备J脚本来作为独立程序来执行，比如在Linux系统上，可以编辑如下内容的一个文本文件，并命名为比如codice_20：
<syntaxhighlight lang="j">
</syntaxhighlight>
注意第一行的codice_21必须顶头，这里的codice_22和codice_23，是与Unix shell中同名命令功能类似的动词。然后在终端界面中执行这个文件：
<syntaxhighlight lang="console" highlight="2,5">
$ ijconsole test01.ijs
Hello, world!
$ chmod +x test01.ijs # 另一种执行方式，授予这个文件可执行权限
$ ./test01.ijs
Hello, world!
</syntaxhighlight>
平均.
在J语言中函数一般称为动词，例如定义一个叫做codice_24的动词，计算一序列数的平均：
<syntaxhighlight lang="j" highlight="3">
2.5
</syntaxhighlight>
一元动词codice_25“计数”（tally），总计阵列中项目的总个数。动词codice_26“加”（plus）和副词codice_3“插入”（insert），派生出的动词codice_28，合计这个阵列的项目的总和。二元动词codice_7“除”（divide）将这个总和除以这个总个数。而用户定义的动词codice_24，用到了由连串（strand）的三个动词（codice_28、codice_7和 codice_25）构成的一个“叉子”（fork）。叉子codice_34↔codice_35，这里的codice_36、codice_37和codice_38指示动词，而codice_39指示一个名词。
使用codice_24的一些例子：
<syntaxhighlight lang="j" highlight="2,4,6,8-11,13,15">
94 56 8 6 85 48 66 96 76 59 33 72 63 1 89 52 17 20 9 65
50.75
41 38.75 36.75 51.25 73.75 71.5 74.25 66 60 56.75 42.25 56.25 51.25 39.75 44.5 24.5 27.75
44 6 8 6 35
48 16 46 26 9
33 22 13 1 39
31.75 15.25 21.75 10.5 24.5
19.8 29 21.6 12.6
</syntaxhighlight>
一元副词codice_3“插入”（insert），接受位于它左侧的一个运算元，并产生将这个动词应用于其参数的每个项目之间的一个动词。就是说，codice_28是一个动词，定义为应用codice_26于给它的参数的各个项目之间。计算移动平均用到的二元副词codice_44“中缀”（infix），将作为数据参数的列表划分成一系列的指定大小的连续项目的子列表，将所修饰动词应用于其上，并将这些结果形成一个列表。
一元动词codice_45“相同”（same），恒等于给它的单一右参数，常像这样用来在赋值之后显示变量的内容。一元动词codice_46“掷骰/固定种子”（roll/fixed seed），不同于一元动词codice_47“掷骰”（roll），在生成数据参数项目所指定大小范围内的随机数之时，采用固定的种子。这里确定对矩阵按行还是按列进行平均，用到了连词codice_48“秩”（rank），它在后面的定语章节和单独条目中论述。
查找与排序.
二元动词codice_49“出现索引”（index of），和二元动词codice_50“最后出现索引”（index of last），在任何大小的阵列内查找匹配者，并返回它的位置索引，如果未找到匹配者，则返回这个阵列的大小。例如：
<syntaxhighlight lang="j" highlight="3,5">
1 6
3 6
</syntaxhighlight>
在J语言中，排序可以按APL传统的两步骤方式，使用一元动词codice_51“升序索引”（grade up）或codice_52“降序索引”（grade down），和用二元副词codice_53“被动”修饰的二元动词codice_54“出自”（from），二者连串（strand）形成的一个“钩子”来完成。一元钩子codice_55↔codice_56；副词codice_53“反身·被动”，其一元定义为codice_58↔codice_59，二元定义为codice_60↔codice_61。J语言还提供专用的二元动词codice_51“上升排序”（sort up）或codice_52“下降排序”（sort down）。下面是用例：
<syntaxhighlight lang="j" highlight="3,5,7,9">
1 7 12 0 2 8 3 6 11 5 9 4 10 13
0 0 1 2 4 4 7 8 8 9 9 15 18 18
0 0 1 2 4 4 7 8 8 9 9 15 18 18
_10 _10 _9 _8 _6 _6 _3 _2 _2 _1 _1 5 8 8
</syntaxhighlight>
CSV插件.
安装用来支持CSV文件的插件Addons/tables/csv </ref>：
<syntaxhighlight lang="j">
</syntaxhighlight>
一个CSV文件简单用例：
<syntaxhighlight lang="j" highlight="4,6-10,12,13">
12
│0│1│2│
│3│4│5│
0 1 2
3 4 5
</syntaxhighlight>
下面演示使用J语言编写在管道中的过滤器，例如，在具有隐式编程机制Unix管道的Linux系统中，建立如下内容的文本文件，并命名为比如codice_64：
<syntaxhighlight lang="j">
load 'tables/csv'
stdout makecsv 10 + makenum fixcsv stdin "
exit "
</syntaxhighlight>
然后在终端界面中执行如下命令行：
<syntaxhighlight lang="console" highlight="2,3">
$ cat test01.csv | ijconsole filter01.ijs
10,11,12
13,14,15
</syntaxhighlight>
数据类型.
J语言支持三种简单类型：
其中数值有很多变种。J语言提供的唯一搜集（collection）类型，是任意维度的阵列。多数算法可以使用这些阵列来简洁的表达。
数值.
J语言的数值类型之一是“位”。位有两个值：codice_65和codice_66。位还可以形成列表，例如codice_67，是8个位的列表。在语法上，J分析器将位当作一个字。空格字符被识别为字形成字符，它处在属于其他数值字的字符之间。
J语言支持任意长度的列表。J语言进一步的在这些位列表之上，支持所有常见二元运算，比如动词codice_68“与”（and）、codice_69“或”（or）、codice_70“非”（not）、codice_71“反转·旋转”（reverse·rotate）、codice_72“移位”（shift）等。J语言还支持位的二维、三维等阵列。上面的运算同样运行在这些阵列之上。
其他数值类型包括整数（比如3、42）、浮点数（3.14、8.8e22）、复数（0j1、2.5j3e88）、扩展精度整数（12345678901234567890x）和（扩展精度）有理分数（1r2、3r4）。同位一样，它们可以形成列表或任意维度的阵列。同位的情况一样，运算可以在一个阵列的所有数值之上。下面例子展示π的前50位，超出了IEEE 754双精度浮点数的53位二进制尾数能精确表示的最大范围，这就要用到J语言的扩展精度整数：
<syntaxhighlight lang="j" highlight="2,4">
3.141592653589793
314159265358979323846264338327950288419716939937510
</syntaxhighlight>
这里采用一元动词codice_73“π乘以”（pi times），和一元动词codice_74“下取整”（floor）二者的复合，得到预期的结果。位的列表可以使用一元动词codice_12“基数2”（base 2）解码成整数。整数可以使用一元动词codice_76“反基数2”（antibase 2）编码为位的列表。
文字.
J语言还支持文字即字符类型。文字包围在撇号codice_77之间，比如codice_78或codice_79。文字的列表，通过将多个字符用撇号包围起来的常规字符串约定来表示，比如codice_80。在字符串内的codice_48表示codice_77字符本身。单个的文字，典型的是codice_83位宽即单字节的ASCII字符，此外J语言还支持Unicode文字。
不支持在文字上的数值和布尔运算，但支持面向搜集的运算，比如旋转等。使用动词codice_84“执行·数值”（do·numbers），将字节阵列转换成数值；使用动词codice_85“缺省格式·格式”（default format·format），将数值转换成字节阵列。
盒装.
盒装类型的值是0维标量，而不管所包含的是怎样的数据结构。使用一元动词codice_86“盒装”（box），将数据放置入盒子中；使用一元动词codice_87“打开”（open），打开盒子中取出其中数据。还可以通过二元动词codice_88“链接”（link）建立盒子的列表，通过一元动词codice_88“拆除”（raze）移除一层盒子的列表。盒子内可以装入其他盒子，还可以通过二元动词codice_90“重制形状”（reshape）和二元动词codice_25“计件复制”（copy）等操作盒子及其列表。
阵列.
J语言的阵列，具有同质（homogeneous）的项目类型，例如列表codice_92是整数的列表，尽管codice_66还可以是一个位。这种类型问题，在极大程度上对于编程者是透明的。只有特定的特殊运算，会显露出在类型上的不同。例如列表codice_94，对大多数运算，将被当作是完全同于列表codice_95。
J语言支持数值稀疏阵列，通过它们的下标存储非零数值。这在非零数值相对很少的情况下，是有效率的机制。
其他.
J语言还支持类和对象</ref>，但是它们并非数据类型，实际上使用盒装文字来提及类和对象，它们实为命名语境和编号语境。
此外还有一个伪类型即内存映射文件，它将变量映射到文件系统中的持久文件</code>内存映射文件 </ref>。
简要词汇表.
下面的表格简要列出了常用词汇。如果含义中用了间隔号（ · ）分隔，通常前者是只有一个右侧参数的一元含义，后者是左右两侧都有参数的二元含义。列出的对应APL符号，是Dyalog等现代APL所采用的符号。
定语.
J语言的能力，很大程度上来自它的“定语”（modifier：修饰词），这个范畴包括“副词”和“连词”：这些符号接受名词和动词作为运算元（operand），并以指定方式应用这些运算元。定语都可以应用于任何动词，包括用户写的动词，用户可以写自己的定语。
J语言的二元动词有右结合性，或称为尽量长右作用域，即它有尽可能多的右参数。定语即算子有左结合性，或称为尽量长左作用域，即它有尽可能多的左运算元。如果表达式中存在定语即算子，首先应用这些定语，然后应用其生成的动词。
副词.
一元副词codice_3“插入”（insert），副词codice_44“前缀·中缀”（prefix·infix），副词codice_98“后缀·外缀”（suffix·outfix），和连词codice_99“剪切”（cut），指定参数的诸个规则或不规则子集，并在其上执行运算。在J语言实现中，codice_100、极小值codice_101和极大值codice_102运算，是典型的会对其进行速度优化的特殊组合。
副词codice_53“反身·被动”（reflex·passive），其一元形式codice_58↔codice_59，将提供给动词的右参数重复放置在左参数位置上；二元形式codice_60↔codice_61，将提供给动词的左右两个参数对换位置。
秩.
名词的秩（rank）是排布其原子所依据的轴的数目，即它的形状中项目的数目。动词的秩是它能够在其上直接运算的右（和左）名词参数的最高秩，典型的表示为三个原子的一个列表：codice_108。对副词和连词标示的秩，是所形成的动词的秩。
秩在特定动词和特定名词的上下文下，将名词的诸维，划分成前缀诸维的序列，称为框架（frame）；和后缀诸维的序列，称为单元（cell）。秩采用连词codice_48“秩”来操纵，对应于APL符号codice_110，它有三种形式：codice_111“指定秩”（assign），codice_112“常量动词”（constant），codice_113和codice_114“复制秩”（copy），这里的codice_115、codice_116表示动词运算元，而codice_117、codice_118表示名词运算元。正数动词秩，指示单元诸维的数目，负数动词秩，指示框架诸维的数目，codice_119指示整体。
二元动词的左右参数的框架经常是匹配的，就是说二者有相同的形状，从而保证了它们有相同数目的单元。如果左右参数的框架不匹配，有三种可以运算的情况：
复合连词.
连词codice_121“在于”（at）、codice_122“顶上”（atop）、codice_123“并列”（appose）、codice_124“合成”（compose），是四种复合（composition）。J语言支持叫作“钩子”（hook）和“叉子”（fork）的隐形连词，二种隐形连词和四种复合连词，规定了如何将参数或将所饰动词应用于参数的结果，提供给所饰动词来进行应用的规则。下表列出它们的定义：
在上面表格中，codice_125，codice_126，codice_127，这里的副词codice_128给出动词codice_116的三个秩。在应用四种复合连词形成新动词的表达式中，codice_121和codice_123，要对第一步运算的中间结果，按所在子表达式的秩或整个表达式的秩codice_119进行汇集（assembly），并在有需要的情况下进行框架填充，然后在这个汇集成的框架内进行第二步运算；而codice_122和codice_124，直接在第一步运算的框架内，对中间结果进行第二步运算；在整个表达式求值结束时，最终结果在有需要的情况下要进行整体填充。
在中，一元codice_115直接在二元codice_116所划分的框架内进行自己的运算。在中，codice_121将二元codice_116的运算结果，汇集成codice_139所指定的框架。在，二元codice_115直接在一元codice_116所划分的两个框架内进行自己的运算。在中，codice_123将一元codice_116的两个运算结果，汇集成codice_144所指定的框架。
下面例子展示四种复合的中间结果的单元差异：
<syntaxhighlight lang="j" highlight="2,3,5,7-10,12-16,18-21,23-37">
1 2 3
4 5 6
0.1 0.2
│1.1 2.1 3.1│
│4.2 5.2 6.2│
│1.1│2.1│3.1│
│4.2│5.2│6.2│
│1 2 3│0.1 0.2│
│4 5 6│ │
│1│0.1│
│2│0.1│
│3│0.1│
│4│0.2│
│5│0.2│
│6│0.2│
</syntaxhighlight>
当连词codice_124的一个运算元是名词的时候，表示“粘上”（bond），它通过向二元动词固定提供其一个参数的值而产生一个动词：
codice_124派生的动词经常作为一元动词使用，即或；如果作为二元动词使用，即或，左参数表示应用这个派生动词于右参数的次数。需要确保通过codice_124定义的一元动词，不出现在能够取用左右两个的参数的上下文中；如此定义的二元动词，也不应该出现在只能取用一个右参数的上下文中。需要注意codice_148、codice_149和codice_150等的左参数的作用域，有时遇到其左侧的复合连词会产生并非预期的效果，经常需要将表达式整体加以圆括号包围。
J语言还提供连词codice_151“底下”（under）和codice_152“对偶”（dual）。下面定义中的动词幂codice_153表示逆运算：
codice_122、codice_124和codice_152合称为“紧密复合”（close composition）。现代APL中另有codice_157“每个”（each），codice_158相当于J语言中的codice_159。例如：
<syntaxhighlight lang="j" highlight="2-4,6-8,10-12,14-16">
│1.1 2.2│
│1.1│2.2│
</syntaxhighlight>
在J语言中，孤立的动词序列叫做“列车”（train）， codice_160意味着codice_161，codice_162意味着codice_163；以此类推，动词列车的一般模式codice_164，依赖于动词的数目，在偶数时形式为codice_165，最外层是个钩子；而在奇数时形式为codice_166，最外层是个叉子；二者的内部都是可能有多层的嵌套的叉子。
叉子、codice_121再加上codice_168和codice_45，可以将很多常用复合写为列车。在惯用法codice_170中，并不实际执行的隐式动词codice_171“遮帽”（cap），屏蔽了叉子的左分支，形成了等价于codice_172的特殊化叉子。
与现代APL如Dyalog等对照，复合连词codice_121对应于同秩连词共享APL符号codice_110的“顶上”（atop），而codice_123对应于codice_176“上方”（over），共享codice_124符号的“粘上”，对应于APL中的“绑上”（bind），APL的“绑上”和“边上”（beside）共享符号codice_178，“边上”的一元形式同于codice_110，而二元形式同于钩子。在《APL字典》中，codice_122对应其codice_176，而codice_124列入秩连词codice_110之内，钩子对应于符号codice_184“枝条”（withe），codice_152对应于符号codice_157。
用例.
下面的简单例子是计算欧几里得范数，和生成数位与维度坐标一致的整数：
<syntaxhighlight lang="j" highlight="2-4,7,10-16">
1 1 0
1 1 1
3 4 0
1.41421 1.73205 5
111 112 113 114
121 122 123 124
131 132 133 134
211 212 213 214
221 222 223 224
231 232 233 234
</syntaxhighlight>
在codice_187中采用的圆括号包围，使得codice_121处在整个表达式的最外层，从而形成了两步骤运算；右侧的第一步是圆括号包围的子表达式，它的完全加圆括号（fully-parenthesized）形式为：codice_189；左侧的第二步是codice_54与复合到其上诸运算构成的子表达式，它的完全加圆括号形式为：codice_191。一元动词codice_54“目录汇编”（catalogue），应用在盒装列表的列表之上，是接受可变数目的变长参数的典型的动词。
下面通过对圆括号包围的子表达式加以变化，辨析秩连词和复合连词的特性。这里的动词codice_45，划分开了给连词或副词的名词运算元，和给所生成的动词的名词参数：
<syntaxhighlight lang="j" highlight="2-4,6,8,10-16,18-22">
│1 2│1 2 3│1 2 3 4│
1
1
│1│2│ │ │
│1│2│3│ │
│1│2│3│4│
│1 2 0 0│
│1 2 3 0│
│1 2 3 4│
</syntaxhighlight>
下面的例子展示并联电阻电路计算：formula_1，它可以如下这样表达：
<syntaxhighlight lang="j" highlight="3">
2.72727
</syntaxhighlight>
动词幂.
连词codice_194动词幂”（power of verb），有两种形式：
对于固定幂codice_197，如果codice_198缺席，codice_199在以codice_39为运算对象的迭代中，将动词codice_115应用codice_118次；如果codice_198存在，codice_204在以codice_39为运算对象的迭代中，将动词codice_206应用codice_118次。如果codice_118是阵列，则按每个原子项目都执行一次动词幂，结果的框架为这个阵列的形状；如果codice_118是取值为codice_65或codice_66的变量，则形成布尔值条件执行；如果codice_118是codice_213，则进行codice_115的逆运算；如果codice_118是codice_119，则意味着“收敛”（converge），即反复应用codice_115直到结果不再变化。例如：
<syntaxhighlight lang="j" highlight="2,3,5,7,9">
1 2 3 4
4 7 10 13
1 2 3 4
0.5 1.73205 5
</syntaxhighlight>
对于动态幂codice_218，如果codice_198缺席，codice_220在以codice_39为运算对象的迭代中，将动词codice_115应用codice_223次；如果codice_198存在，codice_225在以codice_39为运算对象的迭代中，将动词codice_206应用codice_228次。动词幂可以形成动态条件执行，这里的动词codice_116必须总是产生布尔值结果，应用动词codice_115当且仅当codice_116返回codice_66。进而codice_233可以形成while循环构造，只要codice_116返回codice_66，就反复的执行codice_115，直到codice_116返回codice_65，或者codice_115将它的参数无变化的返回。例如：
<syntaxhighlight lang="j" highlight="2,4,6">
1 3 4 10
1 3 5.5 10
101 102 100
</syntaxhighlight>
用例.
下面的例子用来辨析秩指定与框架划分及汇集的性质，其中涉及的直接定义等内容可见于后面的定义章节：
<syntaxhighlight lang="j" highlight="3-5,7-9,11,13-19,21,23-29,31-37,39,41,43,45,47,49,51">
┌─────┬─────┬─────┐
│0 1 2│0 1 2│0 1 2│
│3│1 3│1 1 3│
3 1
│3 │
│1 3│
│1 3│
3 3
│ │ │ │
│3 │0│0│
│1 3│0│0│
│1│1│1│
│3│ │ │
│1│ │ │
0
0
3 1 1
3 1 3
3 1 1 3
3 1 1 3
</syntaxhighlight>
动名词.
在J语言中，动名词（gerund）是叫做“原子表示”的特殊盒子的一个列表，这种盒子可以像任何其他盒子一样使用，并可以最终转变回到要执行的动词。关于动名词的运算有：
下面是动名词简单示例和考拉兹猜想示例：
<syntaxhighlight lang="j" highlight="3-11,13-15,17,19,20,23,25">
┌─┬─────────────┐
│ ││&│┌─┬─────┐││
│ ││ ││ ││0│2││││
│ ││ │└─┴─────┘││
└─┴─────────────┘
│*│
0 3 8 15
0 1 1 1
2 3 4 5
4 1 10 2 16 3 22
1
</syntaxhighlight>
定义.
J语言支持用户进行显式定义
</ref>，和codice_248形式的
</ref>。下面以五种复合作为显式定义的例子：
<syntaxhighlight lang="j">
</syntaxhighlight>
下面以矩阵乘法作为直接定义的例子，并顺带演示秩连词的用法：
<syntaxhighlight lang="j" highlight="6,9,12,15">
1
1
1
1
</syntaxhighlight>
APL传统上的将内积解释为，J语言的矩阵乘法要求写为，不隐含的为左运算元codice_36附加一元codice_3。转置也是有较大的运算，不同的有不同的参照局部性。
在隐式定义中，递归定义可以不通过名字引用自身，转而使用动词codice_269“自引用”。例如递归的计算斐波那契数列：
<syntaxhighlight lang="j" highlight="3">
1 1 2 3 5 8 13 21 34
</syntaxhighlight>
codice_270到codice_271是常量动词。动词codice_171“遮帽”，用在连词codice_273“一元与二元定义”所应用的动词位置上，即充任了一元动词codice_115或二元动词codice_116，可分别在如下两种情况下报错：定义的是二元动词，却不适当的被用作一元动词；或定义的是一元动词，却不适当被用作二元动词。
在显式定义和直接定义中，提供了类似其他过程语言的控制结构。这里列出的是每个范畴内的代表性控制字：
索引.
J语言的索引机制采用二元codice_54“来自”（from）动词来完成，它的秩为codice_277，它有两种形式，分别为左参数为索引阵列的主轴索引，和左参数为二层或一层盒装结构的逐轴索引，二者分别对应APL中，方括号内为单个轴的主轴索引选取，和方括号内为codice_88分隔的多个轴的逐轴索引选取。
主轴索引.
索引阵列的每个项目指定对主轴的项目单元的一个选取，将它们的结果再汇合为一个阵列。负值索引表示从末尾往前记数。在APL中，这种形式的索引被称为“来自”（from），也叫做“选取”（select）或幽默地称为“明智”（sane）索引，最早出现在SAX（SHARP APL for UNIX）对其codice_122“来自”索引的扩展中，部份现代APL，将它表示为符号codice_280。例如：
<syntaxhighlight lang="j" highlight="2,3,5,6,8,9,11,12,14">
0 1 2
3 4 5
3 4 5
0 1 2
1 0
4 3
abc
def
g
</syntaxhighlight>
逐轴索引.
逐轴选取可以形成子阵列，在现代APL中，它被表示为codice_14，故而也被称为“扁方块”（squad：squish quad）索引（indexing）或就叫做“索引”（index）函数。装在二层盒装结构中的，是对应诸轴的一层盒装子结构的列表，其中每个一层盒装子结构内都是数值列表，它对应在此轴内一个或多个项目选择。默认全选使用名词codice_282“么点”（ace）指示，它是盒装空列表codice_283。在尾部的连续多个默认全选不需要写出。例如：
<syntaxhighlight lang="j" highlight="2-4,6,7,9,10,12-14,16-22">
0 1 2 3
4 5 6 7
8 9 10 11
4 5 6 7
8 9 10 11
4 6 7
8 10 11
它还支持一层盒装结构，装在其中的是数值列表，它的元素指示每轴选取一个项目，如果单选了所有轴，则指定一个原子项目。一层盒装结构中的这个数值列表，等价于二层盒装结构中一层盒装的单一数值的列表。两种索引形式可以结合使用，即可以将盒装结构的阵列作为给codice_54的左参数，它按这个阵列的形状汇合多个逐轴选取的结果。例如：
<syntaxhighlight lang="j" highlight="2,4,6-8">
6
0 10 5
│0 0│2 2│1 1│
例如codice_285 codice_286 codice_287
- style="text-align: center;"
! colspan="3" Table 3.9: TRANSPOSITION
}</ref>，它被称为“可能是APL编程者最后掌握的原始运算之一”。J语言的二元转置对轴次序的指定，不涉及将多个轴映射到结果中的一个轴的情况，使用了普通的索引形式的置换向量
上面的APL转置codice_16运算规定中，不将多个轴映射到结果中的一个轴的简单示例，所对应的J语言代码：
<syntaxhighlight lang="J" highlight="4,7">
2 3 5 7
7 2 3 5
</syntaxhighlight>
</ref>。在置换向量的元素个数小于阵列轴的数目之时，J语言在置换结果中将其指定的诸轴安排在尾部，而其他轴保持原来相对次序前移。
针对向量的索引运算，是不加盒装的主轴索引。要访问一般阵列的特定原子项目，其选取向量需要一层盒装，从而对其进行逐轴索引。置换向量codice_319所对应的逆向置换向量是，对于两个置换向量codice_319和codice_321，则有 ↔ 。
二元转置与索引机制有密切关联，它有两个重要性质
Kenneth E. Iverson的上述二元转置定义，用J语言写为 ↔ ，而恒等式 ↔ 的推导过程相应如下：
<syntaxhighlight lang="j">
</syntaxhighlight></ref>：
下面是演示例子代码：
<syntaxhighlight lang="j" highlight="6,8,10,12,15">
1
1
1
1
1
</syntaxhighlight>
示例.
帕斯卡三角.
下面例子形成帕斯卡三角的二项式系数的直接定义，并顺带展示基本的矩阵与盒装运算：
<syntaxhighlight lang="j" highlight="3-7,9,11-15,17-27,29-31,33-43">
1 0 0 0 0
1 1 0 0 0
1 2 1 0 0
1 3 3 1 0
1 4 6 4 1
1 1 2 3 5 8 13 21 34
1 1 1 1 1
1 2 3 4 5
1 3 6 10 15
1 4 10 20 35
1 5 15 35 70
│1│ │ │ │ │
│1│1│ │ │ │
│1│2│1│ │ │
│1│3│3│1│ │
│1│4│6│4│1│
│1│1 1│1 2 1│1 3 3 1│1 4 6 4 1│
│ │ │ │ │1│ │ │ │ │
│ │ │ │1│ │1│ │ │ │
│ │ │1│ │2│ │1│ │ │
│ │1│ │3│ │3│ │1│ │
│1│ │4│ │6│ │4│ │1│
</syntaxhighlight>
二项式系数也可以写成隐式定义形式：
<syntaxhighlight lang="j">
</syntaxhighlight>
简易图表.
下面是基于二元副词codice_3“形成表格”（table），制作条形图和散点图的简易图表例子:
<syntaxhighlight lang="j" highlight="3-11,14-22,25-33">
▄▄▄...
▄▄▄▄...
▄▄▄▄▄...
▄▄...
▄▄▄▄▄...
...▌...
...▌...
...▌▌.▌▌
▌.▌.▌▌.▌▌
▌▌▌▌▌▌▌▌▌
...█...
...█...█
█...
.█.█...
</syntaxhighlight>
这里用到的Unicode方块元素字符也出现在IBM PC代码页437之中。
这里的codice_328可以使用二元副词codice_329“修改”（amend）来实现：
<syntaxhighlight lang="j">
</syntaxhighlight>
对角线选取.
APL的二元转置，在多个轴映射到结果中的一个轴的情况下，将其依次安排到前导位置上并进行对角线选取。下面基于一元动词codice_330“真值位置索引”，定义进行对角线选取的动词codice_331，它的左参数是布尔值列表，其中的真值codice_66指示与其位置对应的轴，要依次安排在前导位置上并进行对角线选取，其他的假值codice_65所对应的轴相对位置不变。
<syntaxhighlight lang="j">
</syntaxhighlight>
这里局部定义了codice_334，它的左右参数同于给codice_331的参数，它生成二元转置需要的置换向量，这是由要安排到前导位置上的那些轴的位置索引，和余下其他轴的位置索引串接而成。这里的codice_336以右参数的诸轴数目选取左参数，用来在左参数的真值和假值的总数小于右参数的诸轴数目之时，对左参数填充上假值。
接着局部定义了codice_337，它的左参数是给codice_331的布尔值列表中真值codice_66的个数，右参数是要对其指定数目的前导轴进行对角线选取的阵列，它生成对角线选取所需要的一层盒装选取列表。这里的codice_340选取出要进行对角线选取的前导诸轴的最小长度，用codice_49形成这个长度的整数数列，再用codice_342形成其长度为左参数的全为codice_66的列表，通过codice_344在二者之上形成表格矩阵。
最后的表达式先进行指定的二元转置，再对其结果进行相应的对角线选取。下面是简单用例：
<syntaxhighlight lang="j" highlight="2-4,6,8-14,16,17,19-23,25,26">
11 12 13 14 15
1 7 13
10 11
0 1
8 9
0 2 4
1 3 5
6 8 10
7 9 11
0 2 4
7 9 11
</syntaxhighlight>
快速排序.
J语言提供的排序机制基于了稳定排序算法，下面的例子代码是快速排序的直接定义：
<syntaxhighlight lang="j">
</syntaxhighlight>
这里定义一个动词codice_345，它通过逐个做两个数的差并取其符号，得到取值为codice_213、codice_65或codice_66的平衡三进制值。codice_345将作为左运算元传递给副词codice_350。
在codice_350的定义中，向局部变量codice_334赋值的表达式，第一步随机选择支点（pivot）运算，首先计算codice_353，生成在数据总个数范围内的随机数，接着在其上计算codice_354，选择出在随机数指定的位置上的支点值；它的第二步运算，将运算元codice_115，应用到其左参数的数据列表，和右参数的支点值二者之上。
随后是串接分治运算结果，首先将平衡三进制值列表，分别与codice_65做逐项的三分法比较，得到三个布尔值列表；然后以这种列表中的codice_65和codice_66作为件数，复制出数据列表的符合这个条件一个新的子列表，其中两个作为参数传递给递归调用进行排序。
下面的快速排序实现，展示了隐式编程，即将函数复合在一起，而不显式的引用任何变量，不提及要应用于其上的形式参数。这里将前面代码中向局部变量codice_334赋值时所求值的表达式改为隐式定义，进而以作为钩子的第一步运算的方式，代入引用这个变量的表达式之中，并且采用钩子的参数复制机制消隐了形式参数codice_39：
<syntaxhighlight lang="j" highlight="4">
0 0 1 2 4 4 7 8 8 9 9 15 18 18
</syntaxhighlight>
提供给连词codice_194的左侧运算元，外层是个一元钩子，它将提供给它的单一右数据参数，重复放置在它的左数据参数位置上。这个外层一元钩子的第一步运算，是生成平衡三进制值列表的嵌套的二层一元钩子codice_362；而外层一元钩子的第二步运算，将生成的三个子列表串接起来。生成三个子列表的表达式，以数据列表是作为左参数，以平衡三进制值列表作为右参数；这里的三个二元钩子首先生成布尔值列表，接着进行对换了左右参数位置的二元复制运算，最后它们中有两个通过自引用codice_269进行了递归调用。
这个定义中的codice_269是在这个副词的私有语境内调用的动词，所以不像前面直接定义那样需要加上运算元codice_115以副词形式来调用。这里没有对字符串长度小于等于codice_66的情况进行处理，这是因为迭代运算在条件不满足时返回初始值，也就是返回这个字符串本身。将codice_345的表达式，代入定义中的左运算元codice_115，就能定义出动词，同时也不再需要外在的采用直接定义的形式。
将一元钩子替代为左分支为codice_45的叉子，形成的动词列车更具可读性：
<syntaxhighlight lang="j" highlight="4">
</syntaxhighlight>
下面的例子定义基于一元codice_51进行字符串比较的codice_345：
<syntaxhighlight lang="j" highlight="3,5,7,10-12,14-16">
_1
1
0
┌───┬─────┬───┬───┬───────┬────┬───┬──────┬────┬───┬────┐
│the│heart│has│its│reasons│that│the│reason│does│not│know│
│does│has│heart│its│know│not│reason│reasons│that│the│the│
</syntaxhighlight>
在这个codice_345定义中，codice_373先将两个字符串参数进行盒装串接，然后一元codice_51给出二者的升序索引，二者之间为升序或相同时为codice_375，而二者为降序时为codice_376；至此是升序还是相同仍需区分，codice_377判断两参数是否为“不相同”，不相同时为codice_66，而相同时为codice_65。这里的副词codice_380“自有区间”，使用字符串的第一个字符作为分隔符，对字符串进行划分并去除分隔符，然后应用所修饰的动词于这些子字符串之上。
全排列.
下面的例子给出codice_118个项目的所有置换的有次序的矩阵。首先定义名词codice_382，它是置换长度为codice_383的全排列矩阵：
<syntaxhighlight lang="j" highlight="2-7">
0 1 2
0 2 1
1 0 2
1 2 0
2 0 1
2 1 0
</syntaxhighlight>
这里用到了动词：codice_384“易位词”（anagram），codice_385的左参数codice_198，指定了长度为codice_387的所有置换中给特定一个置换的编号，其对应的置换向量在组合数学中被称为逆序向量，据此编号置换codice_39的项目。这里求全排列的数目，用到了一元动词codice_389“阶乘”。接着在codice_382的基础上，实现置换长度为codice_391的全排列矩阵：
<syntaxhighlight lang="j" highlight="2-5, 7-10, 12-17,20-27,29">
1 0 0 0
0 1 0 0
0 0 1 0
0 0 0 1
0 1 2 3
1 0 2 3
2 0 1 3
3 0 1 2
0 1 2 3
0 1 3 2
0 2 1 3
0 2 3 1
0 3 1 2
0 3 2 1
┌───────┬───────┬───────┬───────┐
│0 1 2 3│1 0 2 3│2 0 1 3│3 0 1 2│
│0 1 3 2│1 0 3 2│2 0 3 1│3 0 2 1│
│0 2 1 3│1 2 0 3│2 1 0 3│3 1 0 2│
│0 2 3 1│1 2 3 0│2 1 3 0│3 1 2 0│
│0 3 1 2│1 3 0 2│2 3 0 1│3 2 0 1│
│0 3 2 1│1 3 2 0│2 3 1 0│3 2 1 0│
4 6 4
</syntaxhighlight>
这里的codice_392，其左侧是从6×3全排列矩阵加工而成6×4选取矩阵，用它分别对其右侧的4×4“奇妙”矩阵的每一行进行主轴索引运算，即将选取矩阵每行第1个元素保持为“奇妙”矩阵此行的第1个元素，而每行后面3个元素是对“奇妙”矩阵此行后面3个元素的排列。这一步写出的排列动词的结果是4×6×4的三维阵列，将它重制形状为24×4全排列矩阵：
<syntaxhighlight lang="j" highlight="3">
24 4
</syntaxhighlight>
二元动词codice_90的左参数的值为codice_394，这里的codice_39是给排列动词的数据参数；而它的右参数是用一元动词codice_396将三维阵列散开后形成的一个向量。
然后将其中的codice_382，替代为递归的自引用codice_398；并通过名词秩，形成常量动词codice_399，设置长度为codice_65时的基础值为codice_401：
<syntaxhighlight lang="j" highlight="3,5,7,10-11,13">
1
1 0
1 1
0 1 3 2
3 2 1 0
23
</syntaxhighlight> 
最后将递归形式改为迭代形式，可采用连词codice_402“单结果正向折叠”（fold single forward），使用它需要事先安装插件codice_403。这个连词所形成的动词，从左至右遍历右参数列表，将其项目逐个作为动词运算元所见到的左参数；它的左参数是迭代对象的初始值，动词运算元所见到的右参数是迭代对象：
<syntaxhighlight lang="j">
</syntaxhighlight>
如果不采用连词codice_402，可以基于一元副词codice_3“插入”，自行实现正向折叠算子：
<syntaxhighlight lang="j">
</syntaxhighlight>
生命游戏.
在J语言中，提供了二元副词codice_406“子阵列”（subarrays），它是codice_99“剪切”（cut）的三种形式之一，也被称为密铺（tessellate）或镶嵌（tile）。codice_408应用动词codice_115于由codice_198指定的codice_39的有相同形状的每个正规镶嵌之上。codice_412与之类似，但不丢弃结果中不完整的镶嵌。
现代APL所使用的二元算子codice_413“”（stencil），在边缘的处理上不同于J语言的镶嵌，它要求镶嵌子阵列每个轴的中心，在长度为奇数时是codice_39的元素，在长度为偶数时在其元素之间，并且用填充（fill）元素填满超出的部份，它的缺省移动步长是codice_66。下面在codice_416的基础上，利于二元动词codice_417“采取”（take）的填充特性，定义一个codice_418实现：
<syntaxhighlight lang="j"">
</syntaxhighlight>
这个定义只提供一个右名词运算元codice_118，它是镶嵌子阵列的规定矩阵，不提供同每个子阵列对应的诸轴填充数目作为左名词运算，APLcodice_413算子提供它，意图在需要时籍此移除填充。这里的镶嵌规定矩阵定义，其第1行是子阵列的每轴长度，第2行是每轴的移动步长，这个行次序与codice_406的规定相反。这里的codice_319是给codice_416的镶嵌规定矩阵，codice_424是每轴在头部和尾部的填充数量，codice_334是正值控制尾部填充，codice_337是负值控制头部填充。在下面的简单用例中，数值阵列的填充元素是codice_65：
<syntaxhighlight lang="j" highlight="2-5,7-16">
1 2 3 4
5 6 7 8
9 1 2 3
4 5 6 7
│0 1 2│1 2 3│2 3 4│3 4 0│
│0 5 6│5 6 7│6 7 8│7 8 0│
│0 5 6│5 6 7│6 7 8│7 8 0│
│0 9 1│9 1 2│1 2 3│2 3 0│
│0 9 1│9 1 2│1 2 3│2 3 0│
│0 4 5│4 5 6│5 6 7│6 7 0│
</syntaxhighlight>
下面实现康威生命游戏，它是基于的一种细胞自动机:
<syntaxhighlight lang="j" highlight="10-14,16-22">
0 0 1 0 0
1 0 1 0 0
0 1 1 0 0
0 0 0 0 0
0 0 0 0 0
0 1 0 0 0
0 0 1 1 0
0 1 1 0 0
0 0 0 0 0
0 0 0 0 0
│..▖..│.▖...│..▖..│...│...│...│...│...│
│.▖▖..│.▖▖..│.▖▖▖.│..▖▖.│.▖.▖.│...▖▖│...▖│..▖.▖│
│...│...│...│...│...│...│...│...▖.│
</syntaxhighlight>
这里的实现算法，将生命游戏规则合并入一个单一表达式中，它由Arthur Whitney提出。算法的第一步骤用codice_428合计每个格点及其周围格点中codice_66数目，并将它局部保存在codice_334中。第二步骤将为前面的结果与codice_391做相等比较，再与当前状态codice_39做逻辑与运算，只有在当前格点为codice_66，而且周围格点合计为codice_383的情况下，当前格点得到真值codice_66。第三步骤用codice_334减去前面的结果真值，再与codice_383做相等比较。在这个最终结果中，当前格点得到真值codice_66有两类情况：⑴它在codice_334中的值为codice_391，并减去了真值codice_66，这就是第二步骤运算所选定的情况；⑵它在codice_334中的值为codice_383，并减去第二步骤运算在这种情况下必然得出的假值codice_65，这又可细分为两种情况：当前格点为codice_65，而且周围格点合计为codice_383；或者当前格点为codice_66，而且周围格点合计为codice_448。
这个算法可以写为隐式定义形式：
<syntaxhighlight lang="j"">
</syntaxhighlight>
在J语言中，实现以递推关系定义的序列，避免出现formula_3的时间复杂度，可以采用连词codice_449“多结果正向折叠”（fold multiple forward），使用它需要事先安装插件codice_403。这个连词所形成的动词，不输出左参数的初始值，如果提供的右参数为空值，它的输出为空值，否则它输出每次迭代的结果。上例中的迭代算式可以改写为：
<syntaxhighlight lang="j">
</syntaxhighlight>
如果不采用连词codice_449，可以自行实现输出中间结果的正向折叠算子： 
<syntaxhighlight lang="j">
</syntaxhighlight>
在这里的codice_452中，将codice_453改为codice_454，则codice_455可改为codice_456。
键分组.
在J语言中，提供了二元副词codice_457“键分组”（key），它按左参数中的唯一键，对右参数进行分组（group）或称为分区（partition），并将所修饰动词应用到这些分组之上。分组次序同于一元动词codice_458“唯一值”处理结果的次序，它除去匹配前面出现过的项目的任何项目。下面在它的基础之上，定义对应现代APL使用的二元算子codice_459“键分组”（key）的一个副词，它将所修饰动词应用在唯一键和相应的分组二者之上，它还具有一元和二元两种形式：
<syntaxhighlight lang="j">
</syntaxhighlight>
它的二元形式的左参数含有唯一键，而右参数是要分组的数据；它的一元形式的右参数含有唯一键，所分组的是右参数诸项目的索引值。下面是这个键分组副词所适用的动词的简单示例：
<syntaxhighlight lang="j" highlight="3-5,7-9,11-19,21-29">
┌─┬─┬─┬─┐
│M│i│s│p│
│0│1 4 7 10│2 3 5 6│8 9│
│M│0 │
│i│1 4 7 10│
│s│2 3 5 6 │
│p│8 9 │
│M│1│
│i│4│
│s│4│
│p│2│
</syntaxhighlight>
下面的例子通过键分组来找到一个单词列表中的易位词：
<syntaxhighlight lang="j" highlight="2-4,6-8,10-14">
│pats│spat│teas│sate│taps│etas│past│seat│eats│tase│star│east│seta│
│apst│apst│aest│aest│apst│aest│apst│aest│aest│aest│arst│aest│aest│
│┌────┬────┬────┬────┐│┌────┬────┬────┬────┬────┬────┬────┬────┐│┌────┐│
││pats│spat│taps│past│││teas│sate│etas│seat│eats│tase│east│seta│││star││
└─────────────────────┴─────────────────────────────────────────┴──────┘
</syntaxhighlight>
随机数.
在J语言中，提供了二元动词codice_330“区间索引”，它左参数codice_198必须是有次序的，从而定义了codice_462个区间，除了最后一个之外的每个区间，都含有并结束于codice_198的一个项目，而最后一个结束于正无穷，第一个开始于负无穷；它应用于右参数codice_39，给出codice_39所位于的区间的索引。
下面的例子产生符合指定离散概率分布的随机数列表，这里定义了动词codice_466，它依据左参数codice_198给出的正实数向量中的这些权重，从codice_468中选取出由右参数codice_39指定个数的随机数列表：
<syntaxhighlight lang="j" highlight="4,6,8,10,12">
1000000
0 1 1 5 0 1 3 4 4 0
0.222618 0.159083 0.19152 0.127394 0.222795 0.06378 0.01281
0.22293 0.159236 0.191083 0.127389 0.22293 0.0636943 0.0127389
_0.000312 _0.000153 0.000437 0.000005 _0.000135 0.000086 0.000071
</syntaxhighlight>
这里首先通过codice_470，生成指定数目的在区间codice_471中的随机浮点数，它也可以写为等价的codice_472。然后在叉子codice_473中，使用一元副词codice_44“前缀”修饰动词codice_28，从而计算权重向量的，再用前缀和除以总和得出累积分布函数。最后通过区间索引，在有随机浮点数落入特定区间的时候，生成这个区间对应的随机整数。
动词codice_466的表达式是个二层二元钩子，外层钩子的第一步运算应用到右参数上，它的第二步运算即内层钩子，整体修饰了二元副词codice_53“被动”而对换了两个参数的位置。内层钩子的第一步运算codice_473所应用的右参数实际上是外层钩子的左参数，它的第二步运算codice_330修饰了codice_53，从而将它所面对的内层钩子的左右两参数，再次对换回到外层钩子即整体表达式原先的位置上。
下面是将区间索引和键分组结合起来的例子，演示了－莱维中心极限定理:
<syntaxhighlight lang="j" highlight="7-30,36-59">
...▌▌▌▌▌▌...
...▌▌▌▌▌▌▌▌...
...▌▌▌▌▌▌▌▌▌▌▌▌...
...▌▌▌▌▌▌▌▌▌▌▌▌▌▌...
...▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌...
...▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌...
...▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌...
...▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌...
...▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌...
...▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌...
...▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌...
...▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌...
...████████████████████████████
...██...
...█...
...█...
...█...
...█...
...█...
...█...
...█...
...██...
...█...
...██...
</syntaxhighlight>
这里定义的codice_481局部赋值了两个局部变量codice_482和codice_424，可以将这两个局部赋值去掉，并将这两个局部变量的出现替代为运算元codice_117和codice_118，如此对它的调用将变成codice_486这样的形式。接下的代码结合前面两个例子，采用了不同于上例连续型均匀分布的其他分布作为独立同分布，和不同的：
<syntaxhighlight lang="j">
</syntaxhighlight>
SQLite插件.
操纵SQLite数据库的需要安装相应插件</ref>：
<syntaxhighlight lang="j">
</syntaxhighlight>
SQLite数据库的简单用例：
<syntaxhighlight lang="j" highlight="4-6,8-15,19-33,35,39,42,44-46,48,51-59,61,63,66-78,80,86,88-94,96">
│p│s│sp│
│cid│name │type│notnull│dflt_value│pk│
│0 │sid │text│0 │NULL │1 │
│1 │name │text│0 │NULL │0 │
│2 │status│int │0 │NULL │0 │
│3 │city │text│0 │NULL │0 │
┌──────┬──────────────────────────────────┐
│sid │┌──┬──┬──┬──┬──┐ │
│ ││s1│s2│s3│s4│s5│ │
├──────┼──────────────────────────────────┤
│name │┌─────┬─────┬─────┬─────┬─────┐ │
│ ││smith│jones│blake│clark│adams│ │
├──────┼──────────────────────────────────┤
│status│20 10 30 20 30 │
│city │┌──────┬─────┬─────┬──────┬──────┐│
│ ││london│paris│paris│london│athens││
└──────┴──────────────────────────────────┘
1
1
20 10 30 20 30
│s1│s2│s3│s4│s5│
1
┌───┬─────┬──────┬──────┐
│sid│name │status│city │
│s1 │smith│20 │london│
│s2 │jones│10 │paris │
│s3 │blake│30 │paris │
│s4 │clark│20 │london│
│s5 │adams│30 │athens│
5 1
1
┌──────────────────────┬────────────────────┐
││sid│name│status│city│││s1│smith│20│london││
│ ││s2│jones│10│paris ││
│ ││s3│blake│30│paris ││
│ ││s4│clark│20│london││
│ ││s5│adams│30│athens││
└──────────────────────┴────────────────────┘
1
0
│sid│name │status│city │
│s5 │adams│30 │athens│
│s6 │brown│40 │rome │
│s7 │eaton│10 │madrid│
1
</syntaxhighlight>
字典类.
J语言采用命名语境实现类，采用编号语境实现对象，下面示例建立字典类：
<syntaxhighlight lang="j">
cocurrent 'Dict'
cocurrent 'base'
</syntaxhighlight>
在家目录中建立一个codice_487文件并录入上述代码，接着以如下代码建立字典对象并对其进行检视和简单操作：
<syntaxhighlight lang="j" highlight="3-5,7-9,12-14,16-18,20-22,24-26,28,30,32,34,36-38,41,43,45,47,49,51-53">
┌────┬────┬─┬────────┬──────┬─────┬─┐
│Dict│base│j│jcompare│jregex│jtask│z│
│clear│copy│create│default│del│destroy│filt│get│in│len│list│pop│set│
│0│
│COCREATOR│DEFAULT│
│0│
│Dict│z│
2 3 
abc
3
│i1│i2│i3│
2 3
1
1
abc
1
│i1│i2│i3│
</syntaxhighlight>