join

使用键变量按行合并两个表或时间表

语法

T = join(Tleft,Tright)

T = join(Tleft,Tright,Name=Value)

[T,iright] = join(___)

说明

T = join(Tleft,Tright) 通过合并来自两个输入的行来组合表或时间表 Tleft 和 Tright。join 函数执行简单形式的联接运算，其中 Tleft 的每行都必须与 Tright 中的一行完全匹配。当键变量中的对应值相同时，行匹配。输出将 Tleft 中的所有行与 Tright 中键变量具有匹配值的行组合在一起。

例如，如果 Tleft 具有名为 Key1 和 Var1 的变量，Tright 具有变量 Key1 和 Var2，则 T=join(Tleft,Tright) 使用 Key1 作为键变量。

The output T has variables Key1, Var1, and Var2, and combines all rows from Tleft with the rows from Tright where Key1 has matching values in Tleft.

默认情况下，键变量是：

在 Tleft 和 Tright 中具有相同名称的变量，如果两个输入均为表，或如果 Tleft 是时间表而 Tright 是表。
行时间的向量，如果 Tleft 和 Tright 均为时间表。

键变量的匹配值在左右输入中的顺序不必相同。此外，Tright 的键变量必须包含 Tleft 的键变量中的所有值。每个值在 Tright 的键变量中只能出现一次，但在 Tleft 的键变量中可以出现多次。因此，联接运算复制 Tright 中与 Tleft 中的多行匹配的任何行。

输入可以是表、时间表或其中之一。

如果 Tleft 是表，则 join 以表的形式返回 T。
如果 Tleft 是时间表，则 join 以时间表的形式返回 T。

示例

T = join(Tleft,Tright,Name=Value) 可在前面语法中的输入参量外使用一个或多个名称-值参量来指定选项。例如，您可以通过设置 Keys、LeftKeys 或 RightKeys 来指定将哪些变量用作键变量。

示例

[T,iright] = join(___) 还返回索引向量 iright，这样 iright 中的每个元素标识表 T 中与 Tright 中该行相对应的行。您可将此语法与上述语法中的任何输入参量一起使用。

示例

全部折叠

将一个表中的值追加到另一个表

打开实时脚本

创建表 Tleft。

Tleft = table(["Janice";"Jonas";"Javier";"Jerry";"Julie"],[1;2;1;2;1], ...
        VariableNames=["Employee" "Department"])

Tleft=5×2 table
    Employee    Department
    ________    __________

    "Janice"        1     
    "Jonas"         2     
    "Javier"        1     
    "Jerry"         2     
    "Julie"         1

创建与 Tleft 具有共有变量的表 Tright。

Tright = table([1;2],["Mary";"Mona"], ...
         VariableNames=["Department" "Manager"])

Tright=2×2 table
    Department    Manager
    __________    _______

        1         "Mary" 
        2         "Mona"

创建新表 T，其中包含表 Tleft 和 Tright 的数据。使用 join 函数，根据键变量 Department 重复表 Tright 中的 Manager 数据并将其追加到表 Tleft 的数据中。

T = join(Tleft,Tright)

T=5×3 table
    Employee    Department    Manager
    ________    __________    _______

    "Janice"        1         "Mary" 
    "Jonas"         2         "Mona" 
    "Javier"        1         "Mary" 
    "Jerry"         2         "Mona" 
    "Julie"         1         "Mary"

合并包含一个共有变量的表

打开实时脚本

创建表 Tleft。

Tleft = table([5;12;23;2;6], ...
        ["cereal";"pizza";"salmon";"cookies";"pizza"], ...
        VariableNames=["Age" "FavoriteFood"], ...
        RowNames=["Amy" "Bobby" "Holly" "Harry" "Sally"])

Tleft=5×2 table
             Age    FavoriteFood
             ___    ____________

    Amy       5      "cereal"   
    Bobby    12      "pizza"    
    Holly    23      "salmon"   
    Harry     2      "cookies"  
    Sally     6      "pizza"

创建与 Tleft 具有一个共有变量的表 Tright。

Tright = table(["cereal";"cookies";"pizza";"salmon";"cake"], ...
         [110;160;140;367;243], ...
         ["B";"D";"B-";"A";"C-"], ...
         VariableNames=["FavoriteFood" "Calories" "NutritionGrade"])

Tright=5×3 table
    FavoriteFood    Calories    NutritionGrade
    ____________    ________    ______________

     "cereal"         110            "B"      
     "cookies"        160            "D"      
     "pizza"          140            "B-"     
     "salmon"         367            "A"      
     "cake"           243            "C-"

创建新表 T，其中包含表 Tleft 和 Tright 的数据。共同的变量 FavoriteFood 用作 join 函数的键变量。

T = join(Tleft,Tright)

T=5×4 table
             Age    FavoriteFood    Calories    NutritionGrade
             ___    ____________    ________    ______________

    Amy       5      "cereal"         110            "B"      
    Bobby    12      "pizza"          140            "B-"     
    Holly    23      "salmon"         367            "A"      
    Harry     2      "cookies"        160            "D"      
    Sally     6      "pizza"          140            "B-"

表 T 不包含表 Tright 最后一行有关 "cake" 的信息，因为表 Tleft 中没有对应的项。

通过指定一个键变量来合并表

打开实时脚本

创建表 Tleft。

Tleft = table([10;4;2;3;7],[5;4;9;6;1],[10;3;8;8;4])

Tleft=5×3 table
    Var1    Var2    Var3
    ____    ____    ____

     10      5       10 
      4      4        3 
      2      9        8 
      3      6        8 
      7      1        4

创建表 Tright，使表 Tright 中 Var2 的内容与表 Tleft 中 Var2 的内容相同。

Tright = table([6;1;1;6;8],[5;4;9;6;1])

Tright=5×2 table
    Var1    Var2
    ____    ____

     6       5  
     1       4  
     1       9  
     6       6  
     8       1

创建新表 T，其中包含表 Tleft 和 Tright 的数据。使用表 Tleft 和 Tright 中的 Var2 作为 join 函数的键变量。

T = join(Tleft,Tright,Keys="Var2")

T=5×4 table
    Var1_Tleft    Var2    Var3    Var1_Tright
    __________    ____    ____    ___________

        10         5       10          6     
         4         4        3          1     
         2         9        8          1     
         3         6        8          6     
         7         1        4          8

join 为非键变量 Var1 添加一个唯一的后缀，以区分表 Tleft 和 Tright 中的数据。

仅保留非键变量的一份副本

打开实时脚本

创建一个新表，其中包含表 Tleft 和 Tright 的数据。如果两个表中有任何同名的非键变量，仅保留其在表 Tleft 中的副本。

创建表 Tleft。

Tleft = table([10;4;2;3;7],[5;4;9;6;1])

Tleft=5×2 table
    Var1    Var2
    ____    ____

     10      5  
      4      4  
      2      9  
      3      6  
      7      1

创建表 Tright，使表 Tright 中 Var2 的内容与表 Tleft 中 Var2 的内容相同。

Tright = table([6;1;1;6;8],[5;4;9;6;1],[10;3;8;8;4])

Tright=5×3 table
    Var1    Var2    Var3
    ____    ____    ____

     6       5       10 
     1       4        3 
     1       9        8 
     6       6        8 
     8       1        4

创建新表 T，其中包含表 Tleft 和 Tright 的数据。使用 Var2 作为 join 函数的键变量，并且仅保留表 Tleft 中 Var1 的副本。T 的输出表不包含表 Tright 中的 Var1 数据。

T = join(Tleft,Tright,Keys="Var2",KeepOneCopy="Var1")

T=5×3 table
    Var1    Var2    Var3
    ____    ____    ____

     10      5       10 
      4      4        3 
      2      9        8 
      3      6        8 
      7      1        4

使用行名称作为键变量来合并表

打开实时脚本

创建表 Tleft。

Tleft = table([true;true;false;false;false],[38;43;38;40;49], ...
        VariableNames=["Smoker" "Age"], ...
        RowNames=["Sanchez" "Johnson" "Wu" "Jones" "Brown"])

Tleft=5×2 table
               Smoker    Age
               ______    ___

    Sanchez    true      38 
    Johnson    true      43 
    Wu         false     38 
    Jones      false     40 
    Brown      false     49

创建表 Tright，使 Tleft 和 Tright 的行一一对应。

Tright = table([64;69;67;71;64], ...
         [119;163;133;176;131], ...
         [122 80; 149 87; 117 75; 154 93; 125 83], ...
         VariableNames=["Height" "Weight" "BloodPressure"], ...
         RowNames=["Brown" "Johnson" "Jones" "Sanchez" "Wu"])

Tright=5×3 table
               Height    Weight    BloodPressure
               ______    ______    _____________

    Brown        64       119       122     80  
    Johnson      69       163       149     87  
    Jones        67       133       117     75  
    Sanchez      71       176       154     93  
    Wu           64       131       125     83

创建新表 T，其中包含表 Tleft 和 Tright 的数据。使用行名称向量作为键变量。（表行名称向量的名称是 "Row"，如 Tleft.Properties.DimensionNames{1} 所示。）

T = join(Tleft,Tright,Keys="Row")

T=5×5 table
               Smoker    Age    Height    Weight    BloodPressure
               ______    ___    ______    ______    _____________

    Sanchez    true      38       71       176       154     93  
    Johnson    true      43       69       163       149     87  
    Wu         false     38       64       131       125     83  
    Jones      false     40       67       133       117     75  
    Brown      false     49       64       119       122     80

T 中行的顺序与 Tleft 相同。

使用左键变量和右键变量来合并表

打开实时脚本

创建表 Tleft。

Tleft = table([10;4;2;3;7],[5;4;9;6;1],[10;3;8;8;4])

Tleft=5×3 table
    Var1    Var2    Var3
    ____    ____    ____

     10      5       10 
      4      4        3 
      2      9        8 
      3      6        8 
      7      1        4

创建表 Tright，使表 Tright 中 Var2 的内容与表 Tleft 中 Var1 的内容相同，但顺序不同。

Tright = table([6;1;1;6;8],[2;3;4;7;10])

Tright=5×2 table
    Var1    Var2
    ____    ____

     6        2 
     1        3 
     1        4 
     6        7 
     8       10

创建新表 T，其中包含表 Tleft 和 Tright 的数据。使用表 Tleft 中的 Var1 和表 Tright 中的 Var2 作为 join 函数的键变量。

[T,iright] = join(Tleft,Tright,LeftKeys=1,RightKeys=2)

T=5×4 table
    Var1_Tleft    Var2    Var3    Var1_Tright
    __________    ____    ____    ___________

        10         5       10          8     
         4         4        3          1     
         2         9        8          6     
         3         6        8          1     
         7         1        4          6

iright = 5×1

     5
     3
     1
     2
     4

T 是 Tleft 和 Tright(iright,1) 的水平串联。

合并时间表

打开实时脚本

创建两个时间表，它们的行时间相同，但变量不同。

Traffic = [0.8;0.9;0.1;0.7;0.9];
Noise = [0;1;1.5;2;2.3];
Tleft = timetable(Traffic,Noise,RowTimes=hours(1:5))

Tleft=5×2 timetable
    Time    Traffic    Noise
    ____    _______    _____

    1 hr      0.8         0 
    2 hr      0.9         1 
    3 hr      0.1       1.5 
    4 hr      0.7         2 
    5 hr      0.9       2.3

Distance = [0.88;0.86;0.91;0.9;0.86];
Tright = timetable(Distance,RowTimes=hours(1:5))

Tright=5×1 timetable
    Time    Distance
    ____    ________

    1 hr      0.88  
    2 hr      0.86  
    3 hr      0.91  
    4 hr       0.9  
    5 hr      0.86

合并两个时间表。join 使用行时间作为键变量。

T = join(Tleft,Tright)

T=5×3 timetable
    Time    Traffic    Noise    Distance
    ____    _______    _____    ________

    1 hr      0.8         0       0.88  
    2 hr      0.9         1       0.86  
    3 hr      0.1       1.5       0.91  
    4 hr      0.7         2        0.9  
    5 hr      0.9       2.3       0.86

合并时间表和表

打开实时脚本

创建一个时间表和一个表。

Measurements = [0.13;0.22;0.31;0.42;0.53;0.57;0.67;0.81;0.90;1.00];
Device = ["A";"B";"A";"B";"A";"B";"A";"B";"A";"B"];
Tleft = timetable(Measurements,Device,RowTimes=seconds(1:10))

Tleft=10×2 timetable
     Time     Measurements    Device
    ______    ____________    ______

    1 sec         0.13         "A"  
    2 sec         0.22         "B"  
    3 sec         0.31         "A"  
    4 sec         0.42         "B"  
    5 sec         0.53         "A"  
    6 sec         0.57         "B"  
    7 sec         0.67         "A"  
    8 sec         0.81         "B"  
    9 sec          0.9         "A"  
    10 sec           1         "B"

Device = ["A";"B"];
Accuracy = [0.023;0.037];
Tright = table(Device,Accuracy)

Tright=2×2 table
    Device    Accuracy
    ______    ________

     "A"       0.023  
     "B"       0.037

合并时间表和表。Device 是键变量，因为 Tleft 和 Tright 中都存在具有该名称的变量。T 是一个时间表。

T = join(Tleft,Tright)

T=10×3 timetable
     Time     Measurements    Device    Accuracy
    ______    ____________    ______    ________

    1 sec         0.13         "A"       0.023  
    2 sec         0.22         "B"       0.037  
    3 sec         0.31         "A"       0.023  
    4 sec         0.42         "B"       0.037  
    5 sec         0.53         "A"       0.023  
    6 sec         0.57         "B"       0.037  
    7 sec         0.67         "A"       0.023  
    8 sec         0.81         "B"       0.037  
    9 sec          0.9         "A"       0.023  
    10 sec           1         "B"       0.037

输入参数

全部折叠

`Tleft` — 左表
表 | 时间表

左表，指定为表或时间表。对于所有键变量，Tleft 的每一行都必须与 Tright 中的一行完全匹配。

`Tright` — 右表
表 | 时间表

右表，指定为表或时间表。对于所有键变量，Tright 的每一行都必须与 Tleft 中的一行完全匹配。

名称-值参数

全部折叠

将可选参量对组指定为 Name1=Value1,...,NameN=ValueN，其中 Name 是参量名称，Value 是对应的值。名称-值参量必须出现在其他参量之后，但对各个参量对组的顺序没有要求。

示例: Keys=2 使用 Tleft 中的第二个变量和 Tright 中的第二个变量作为键变量。

`Keys` — 用作键值的变量
正整数 | 正整数向量 | 字符串数组 | 字符向量 | 字符向量元胞数组 | `pattern` 标量 | 逻辑向量

用作键值的变量，指定为正整数、正整数向量、字符串数组、字符向量、字符向量元胞数组、pattern 标量或逻辑向量。

您不能将 Keys 名称-值参量与 LeftKeys 和 RightKeys 名称-值参量配合使用。

来自输入表或时间表的行标签向量可以用作键，既可以单独使用，也可以与其他键变量组合使用。行标签是表的行名称或时间表的行时间。要将此向量用作键，请将其指定为 "Row"（如果是表的行名称）、行时间的时间表向量的名称，或者 T.Properties.DimensionNames{1} 的值，其中 T 是表或时间表。

为了实现向后兼容，当 Keys 和 "RowNames" 是具有行名称的表时，您也可以将 Tleft 的值指定为 Tright。但是，最佳做法是将 Keys 的值指定为行名称向量的名称。

示例: Keys=[1 3] 使用 Tleft 和 Tright 的第一个和第三个变量作为键变量。

示例: Keys=["X" "Y"] 使用 X 和 Y 中名为 Tleft 和 Tright 的变量作为键变量。

示例: 如果 Keys="Row" 和 Tleft 均为具有行名称的表，则 Tright 使用 Tleft 和 Tright 的行名称向量作为键变量。

`LeftKeys` — `Tleft` 中要用作键变量的变量
正整数 | 正整数向量 | 字符串数组 | 字符向量 | 字符向量元胞数组 | `pattern` 标量 | 逻辑向量

用作 Tleft 中的键值的变量，指定为正整数、正整数向量、字符串数组、字符向量、字符向量元胞数组、pattern 标量或逻辑向量。

必须将 LeftKeys 名称-值参量与 RightKeys 名称-值参量结合使用。LeftKeys 和 RightKeys 都必须指定相同数量的键变量。join 根据顺序对 Tleft 和 Tright 中的键值配对。

示例: LeftKeys=1 仅使用 Tleft 中的第一个变量作为键变量。

`RightKeys` — `Tright` 中要用作键变量的变量
正整数 | 正整数向量 | 字符串数组 | 字符向量 | 字符向量元胞数组 | `pattern` 标量 | 逻辑向量

用作 Tright 中的键值的变量，指定为正整数、正整数向量、字符串数组、字符向量、字符向量元胞数组、pattern 标量或逻辑向量。

必须将 RightKeys 名称-值参量与 LeftKeys 名称-值参量结合使用。LeftKeys 和 RightKeys 都必须指定相同数量的键变量。join 根据顺序对 Tleft 和 Tright 中的键值配对。

示例: RightKeys=3 仅使用 Tright 中的第三个变量作为键变量。

`LeftVariables` — 要包含在 `T` 中的来自 `Tleft` 的变量
正整数 | 正整数向量 | 字符串数组 | 字符向量 | 字符向量元胞数组 | `pattern` 标量 | 逻辑向量

要包含在 T 中的来自 Tleft 的变量，指定为正整数、正整数向量、字符串数组、字符向量、字符向量元胞数组、pattern 标量或逻辑向量。

可以使用 LeftVariables 在 T 中包含或排除键变量和非键变量。但是，您不能包含 Tleft 中的行名称或行时间，因为它们不是变量。

默认情况下，join 包含来自 Tleft 的所有变量。

`RightVariables` — 要包含在 `T` 中的来自 `Tright` 的变量
正整数 | 正整数向量 | 字符串数组 | 字符向量 | 字符向量元胞数组 | `pattern` 标量 | 逻辑向量

要包含在 T 中的来自 Tright 的变量，指定为正整数、正整数向量、字符串数组、字符向量、字符向量元胞数组、pattern 标量或逻辑向量。

可以使用 RightVariables 在 T 中包含或排除键变量和非键变量。但是，您不能包含 Tright 中的行名称或行时间，因为它们不是变量。

默认情况下，join 包含 Tright 中除键变量以外的所有变量。

`KeepOneCopy` — `join` 仅保留其在 `Tleft` 中的副本的变量
字符串数组 | 字符向量 | 字符向量元胞数组 | `pattern` 标量

join 仅保留其在 Tleft 中的副本的变量，指定为用于指定变量名称的字符串数组、字符向量、字符向量元胞数组或 pattern 标量。

键变量在 T 中只出现一次，但如果 Tleft 和 Tright 中包含同名的非键变量，则 join 默认情况下会在 T 中同时保留两者的副本。使用 KeepOneCopy 仅保留来自 Tleft 的副本。

示例: KeepOneCopy=Var2 仅保留 Tleft 中非键变量 Var2 的副本。

输出参量

全部折叠

`T` — `Tleft` 和 `Tright` 的合并数据
表 | 时间表

Tleft 和 Tright 的合并数据，以表或时间表形式返回。表 T 包含 Tleft 中的所有行，且显示顺序也相同。

join 通过水平串联 T 和 Tleft(:,leftVars) 来创建 Tright(iright,rightVars)。默认情况下，leftVars 为 Tleft 的所有变量，rightVars 为 Tright 的所有非键变量。否则，leftVars 包含由 LeftVariables 名称-值参量指定的变量，rightVars 包含由 RightVariables 名称-值参量指定的变量。

如果 Tleft 和 Tright 包含同名的非键变量，join 会在 T 中为对应的变量名称添加唯一性后缀，除非您指定了 KeepOneCopy 名称-值参量。

如果 Tleft 是表，则 T 也是表。如果 Tleft 是时间表，而 Tright 是时间表或表，则 T 是时间表。

您可以在 T 中存储描述、变量单位、变量名称和行名称等附加元数据。有关详细信息，请参阅 table 或 timetable 的“属性”部分。

`iright` — `Tright` 的索引
列向量

Tright 的索引，以列向量形式返回。iright 的每个元素标识 Tright 中与输出表或时间表 T 中的行对应的行。

详细信息

全部折叠

键变量

用于在输入表 Tleft 与 Tright 之间匹配和合并数据的变量。

键值

Tleft 或 Tright 的键变量中的值。

算法

join 函数首先查找一个或多个键变量。然后，join 使用键变量查找输入表 Tright 中与输入表 Tleft 中每一行匹配的行，并且合并这些行，以在输出表 T 中创建相应行。

如果 Tleft 和 Tright 中的键值之间存在一对一映射关系，join 会对 Tright 中的数据排序，并将其追加至表 Tleft。
如果 Tleft 和 Tright 中的键值之间存在多对一映射关系，join 会对 Tright 中的数据进行排序和复写操作，然后再将其追加至表 Tleft。
如果 Tright 的某个键变量中的数据与 Tleft 中的键值无映射关系，则 join 不会将该数据包含在输出表 T 中。

扩展功能

全部展开

tall 数组
对行数太多而无法放入内存的数组进行计算。

join 函数支持 tall 数组，但存在以下使用说明和限制：

要合并 tall 时间表和 tall 表，时间表必须是 join 的第一项输入。

有关详细信息，请参阅tall 数组。

C/C++ 代码生成
使用 MATLAB® Coder™ 生成 C 代码和 C++ 代码。

用法说明和限制：

通常，输入表不能有同名的非键变量。但是，如果指定名称-值参量，则可以联接输入表的子集：
- KeepOneCopy，仅列出要从左侧输入表中获取的变量。
- LeftVariables 和 RightVariables，列出要从左侧输入表或右侧输入表（但不能同时包含两者）中获取的变量。
这些名称-值参量的值必须为常量：
- Keys
- LeftKeys
- RightKeys
- LeftVariables
- RightVariables
- KeepOneCopy
以下名称-值参量的值不支持模式表达式：
- Keys
- LeftKeys
- RightKeys
- LeftVariables
- RightVariables
- KeepOneCopy
不支持嵌套的表和时间表。

GPU 代码生成
使用 GPU Coder™ 为 NVIDIA® GPU 生成 CUDA® 代码。

请参阅“C/C++ 代码生成”部分中的用法说明和限制。同样的用法说明和限制也适用于 GPU 代码生成。

基于线程的环境
使用 MATLAB® `backgroundPool` 在后台运行代码或使用 Parallel Computing Toolbox™ `ThreadPool` 加快代码运行速度。

join 函数完全支持基于线程的环境。有关详细信息，请参阅在基于线程的环境中运行 MATLAB 函数。

版本历史记录

在 R2013b 中推出

另请参阅

函数

innerjoin | outerjoin

实时编辑器任务

联接表

join

语法

说明

示例

将一个表中的值追加到另一个表

合并包含一个共有变量的表

通过指定一个键变量来合并表

仅保留非键变量的一份副本

使用行名称作为键变量来合并表

使用左键变量和右键变量来合并表

合并时间表

合并时间表和表

输入参数

Tleft — 左表 表 | 时间表

Tright — 右表 表 | 时间表

名称-值参数

Keys — 用作键值的变量 正整数 | 正整数向量 | 字符串数组 | 字符向量 | 字符向量元胞数组 | pattern 标量 | 逻辑向量

LeftKeys — Tleft 中要用作键变量的变量 正整数 | 正整数向量 | 字符串数组 | 字符向量 | 字符向量元胞数组 | pattern 标量 | 逻辑向量

RightKeys — Tright 中要用作键变量的变量 正整数 | 正整数向量 | 字符串数组 | 字符向量 | 字符向量元胞数组 | pattern 标量 | 逻辑向量

LeftVariables — 要包含在 T 中的来自 Tleft 的变量 正整数 | 正整数向量 | 字符串数组 | 字符向量 | 字符向量元胞数组 | pattern 标量 | 逻辑向量

RightVariables — 要包含在 T 中的来自 Tright 的变量 正整数 | 正整数向量 | 字符串数组 | 字符向量 | 字符向量元胞数组 | pattern 标量 | 逻辑向量

KeepOneCopy — join 仅保留其在 Tleft 中的副本的变量 字符串数组 | 字符向量 | 字符向量元胞数组 | pattern 标量

输出参量

T — Tleft 和 Tright 的合并数据 表 | 时间表

iright — Tright 的索引 列向量

详细信息

键变量

键值

算法

扩展功能

tall 数组 对行数太多而无法放入内存的数组进行计算。

C/C++ 代码生成 使用 MATLAB® Coder™ 生成 C 代码和 C++ 代码。

GPU 代码生成 使用 GPU Coder™ 为 NVIDIA® GPU 生成 CUDA® 代码。

基于线程的环境 使用 MATLAB® backgroundPool 在后台运行代码或使用 Parallel Computing Toolbox™ ThreadPool 加快代码运行速度。

版本历史记录

另请参阅

函数

实时编辑器任务

`Tleft` — 左表
表 | 时间表

`Tright` — 右表
表 | 时间表

`Keys` — 用作键值的变量
正整数 | 正整数向量 | 字符串数组 | 字符向量 | 字符向量元胞数组 | `pattern` 标量 | 逻辑向量

`LeftKeys` — `Tleft` 中要用作键变量的变量
正整数 | 正整数向量 | 字符串数组 | 字符向量 | 字符向量元胞数组 | `pattern` 标量 | 逻辑向量

`RightKeys` — `Tright` 中要用作键变量的变量
正整数 | 正整数向量 | 字符串数组 | 字符向量 | 字符向量元胞数组 | `pattern` 标量 | 逻辑向量

`LeftVariables` — 要包含在 `T` 中的来自 `Tleft` 的变量
正整数 | 正整数向量 | 字符串数组 | 字符向量 | 字符向量元胞数组 | `pattern` 标量 | 逻辑向量

`RightVariables` — 要包含在 `T` 中的来自 `Tright` 的变量
正整数 | 正整数向量 | 字符串数组 | 字符向量 | 字符向量元胞数组 | `pattern` 标量 | 逻辑向量

`KeepOneCopy` — `join` 仅保留其在 `Tleft` 中的副本的变量
字符串数组 | 字符向量 | 字符向量元胞数组 | `pattern` 标量

`T` — `Tleft` 和 `Tright` 的合并数据
表 | 时间表

`iright` — `Tright` 的索引
列向量

tall 数组
对行数太多而无法放入内存的数组进行计算。

C/C++ 代码生成
使用 MATLAB® Coder™ 生成 C 代码和 C++ 代码。

GPU 代码生成
使用 GPU Coder™ 为 NVIDIA® GPU 生成 CUDA® 代码。

基于线程的环境
使用 MATLAB® `backgroundPool` 在后台运行代码或使用 Parallel Computing Toolbox™ `ThreadPool` 加快代码运行速度。