Typstの配列とそのメソッド

Typstの配列（Array）は、PythonやRのリストに相当し、文字列や数値など異なる型の要素を一括して扱うための構造です。Typstの配列には多様なメソッドが用意されており、外部データの処理や表の作成などを効率化できます。

Typst の公式サイトには各メソッドの説明がありますが、簡素であったり例が載っていなかったりするものもあるため、ひととおり使い方と動作を確認しました。備忘録がてら、そのまとめをここに記載しておきます。

配列の作成

任意要素の配列の作成

配列は次のように定義します。配列要素は()に入れ、要素間は「,」で区切ります。配列の要素に配列や辞書を含むことも可能です。

#let my_array = (1, 2, 3, "あ", (1,2,3), (x: 1, y: 2))

中身を表示させると次のようになります。

#my_array

(1, 2, 3, "あ", (1,2,3), (x: 1, y: 2))

なお、配列要素が1つしかない場合、(1)のように書くと配列として認識されません

#let my_array1 = (1)

#my_array1

1

その場合、「(1,)」のように要素の最後に「,」を入れることで配列として定義できます。

#let my_array2 = (1,)

#my_array2

(1,)

数列の作成

特定の数列からなる配列を作成したい場合、次のようにrange()メソッドを用いることもできます。range()メソッドについては、この後のメソッドのところで詳しく説明します。

  #let my_array = range(5)

  #my_array

(0, 1, 2, 3, 4)

メソッド（メンバ関数）

Typstの配列には、配列要素を操作するためのメソッド（メンバ関数）が多数用意されています。外部データを取り込んで使用する場合など、これらのメソッドを柔軟に組み合わせることで、さまざまな処理が可能になります。

配列要素を参照するためのメソッド

配列の要素数(配列の長さ)を参照する： len

定義

self.len() -> int    // 戻り値は整数値

使用例

  #let my_array = (1, 5, 4, 3, 2)

  #my_array.len()

5

配列の最初の要素を参照する： first

定義

self.first() -> any    // 戻り値は配列の要素

配列の先頭にある要素を参照します。先頭の要素を参照するだけで、配列そのものに変更は加えられません。

使用例

  #let my_array = ("あ", "い", "う", "え", "お")

  #my_array.first()

あ

配列の最後の要素を参照する： last

定義

self.last() -> any    // 戻り値は配列の要素

配列の一番最後にある要素を参照します。最後の要素を参照するだけで、配列そのものに変更は加えられません。

使用例

  #let my_array = ("あ", "い", "う", "え", "お")

  #my_array.last()

お

指定位置の要素を参照する： at

定義

self.at(
  index,         // 配列の位置（int）　※必須
  default: any,  // 指定されたインデックスが範囲外の場合の戻り値
) -> any         // 戻り値は配列の要素

インデックスで指定された位置にある配列要素を取得します。指定位置の要素を参照するだけで、配列そのものに変更は加えられません。

Typstでは、配列要素の先頭は0から始まる点には注意が必要です。先頭から$n$番目の要素を参照したい場合は、インデックスに $n-1$ の値を指定する必要があります。

また−1は配列の末尾を指します。したがって、self.at(0)はself.first()と、self.at(-1)はself.last()と同じ意味になります。

使用例

  #let my_array = ("t", "y", "p", "s", "t")

  3番目：#my_array.at(2), 先頭：#my_array.at(0), 最後尾：#my_array.at(-1)

3 番目：う, 先頭：あ, 最後尾：お

通常、範囲外のインデックスを指定した場合はエラーになりますが、デフォルト値を設定しておくことにより、インデックスが配列の範囲を超えた場合に特別な値を返せるようになります。

使用例

  #let my_array = ("t", "y", "p", "s", "t")

  #my_array.at(9, default: "<<範囲外>>")

<<範囲外>>

配列要素を変更するためのメソッド

配列末尾に要素を追加する：push

定義

self.push(
  value         // 追加したい要素（any）　※必須
)               // 戻り値なし

配列の末尾に新たな要素を追加します。このメソッドには戻り値がないので、中身を確認するには別途#my_arrayなどと書く必要があります。

なお、一度に追加できるのは1要素のみです。my_array.push((1,3,4))のように書くと、(1,3,4)という配列が新たな要素として追加されます。

使用例

#let my_array = ("あ", "い", "う", "え", "お")

#my_array.push("か")        // 末尾に要素を追加
#my_array

("あ","い","う","え","お", "か")

配列末尾の要素を取り出す：pop

定義

self.pop() -> any        // 引数なし、戻り値は配列の要素

配列末尾の要素を取り出します。このメソッドには引数がありません。

使用例

#let my_array = ("あ", "い", "う", "え", "お", "f")

#my_array.pop()

か

popでは必ず戻り値が返されますが、配列を短くすることが目的で戻り値が不要な場合には、捨て変数( _ )を使用します。

使用例

#let my_array = ("あ", "い", "う", "え", "お", "f")

#let _ = my_array.pop() // 最後の要素を取り出して _ に捨てる

#my_array               // 配列の内容を表示

("あ","い","う","え","お")

指定した位置に配列要素を挿入する：insert

定義

self.insert(
  index,          // 挿入位置のインデックス（int）　※必須
  value,          // 追加したい要素（any）　※必須
)                 // 戻り値なし

インデックスで指定した箇所に配列要素を挿入します。指定位置以降の要素は、1つずつ後ろにずれます。

使用例

#let my_array = ("あ", "い", "う", "お")

// インデックス3の位置（先頭から4番目）に要素として"え"を追加
#my_array.insert(3, "え") 

#my_array

("あ" , "い" , "う" , "え" , "お")

インデックスに -1 を指定すると配列末尾に要素が追加されます。つまり、#my_array.insert(-1, "ん")と#my_array.push("ん") は同じ結果になります。

なお、要素の挿入ではなく、入れ替え（更新）をしたい場合には、次のように at を用います。

使用例

#let my_array = ("あ", "い", "う", "え", "を")

#(my_array.at(4) = "お")

#my_array

("あ" , "い" , "う" , "え" , "お")

指定した位置から配列要素を取り出す：remove

定義

self.remove(
    index,            // インデックス（int)　※必須
    default: any,     // インデックスが範囲外の場合の戻り値
  ) -> any            // 戻り値は配列要素

インデックスで指定した位置から配列要素を取り出します。指定位置以降の要素は、1つずつ前にずれます。

使用例

#let my_array = ("あ", "い", "う", "わ", "え", "お")

#my_array.remove(3) // インデックス3（先頭から4番目）の値を取り出し

#my_array

("あ" , "い" , "う" , "え" , "お")

popの場合と同様に、配列を短くすることが目的で戻り値が不要な場合には捨て変数( _ )を使用します。

指定した範囲の配列要素を取り出す：slice

定義

self.slice(
    start,         // 範囲の開始インデックス（int)　※必須
    end,           // 範囲の終了インデックス（none or int）
    count: int,    // 範囲の幅
  ) -> array       // 戻り値は配列

slice は、特定の要素ではなく、配列の一部を切り出します。

取り出す範囲は、開始インデックスと終了インデックス、または、開始インデックスとそこからの幅（要素数）のいずれかで指定します。終了インデックスと幅の両方が指定され、かつ位置が矛盾している場合には、終了インデックスの値が優先されます。

終了インデックスを用いて指定した場合、取り出されるのは終了インデックスの直前までの要素です。

使用例

#let my_array = ("あ", "い", "う", "え", "お")

#my_array.slice(1, 3) // 開始インデックス:1 終了インデックス:3

("い" , "う")

終了インデックスと範囲幅のいずれの値も指定されていない場合、slice は開始インデックスから配列末尾までの要素を返します。

使用例

#let my_array = ("あ", "い", "う", "え", "お")

#my_array.slice(2) // 開始インデックスのみを指定

("う" , "え" , "お")

また、開始インデックスや終了インデックスに負の値を指定した場合、その値は配列末尾からの位置を示すインデックスとみなされます。

使用例

#let my_array = ("あ", "い", "う", "え", "お")

#my_array.slice(2, -2) // 終了インデックスに負の値を指定

("い" , "う")

なお、配列を slice しても、元の配列は変更されません。

使用例

#let my_array = ("あ", "い", "う", "え", "お")

let _ = my_array.slice(1, 3) // sliceした内容を捨てる

#my_array                    // slice 後の配列の内容を表示

("あ", "い", "う", "え", "お")

配列要素を検索するためのメソッド

指定した値が配列に含まれているか確認する：contains

定義

self.contains(
  value         // 確認対象の要素　※必須
) -> bool       // 値が配列に含まれていれば true、そうでなければ false

配列要素に特定の値が含まれているかどうかを検索するメソッドです。含まれていれば true、含まれていなければfalse が返されます。実際の場面では、文章中ではなく、コードの中で使用することがほとんどでしょう。

使用例

#let my_array = ("あ", "い", "う", "え", "お")

r: #my_array.contains("え"), z: #my_array.contains("か")

え: true, か: false

コード中においては、次のような書き方もできるようになっています。

使用例

#let my_array = ("あ", "い", "う", "え", "お")

#( "え" in my_array)

true

なお、contains で確認できるのは、第一階層の要素で完全一致するものがあるかどうかのみです。要素に配列を含む場合、その中までは確認できません。このような場合には、flatten() で配列を1次元に展開するなどしてから検索するといった工夫が必要になります。

使用例

#let my_array = ("あ", "い", ("う", "え"), "お")

#my_array.contains("う") // "r" は ("う", "え") という配列の要素なので存在を確認できない

false

条件を満たす配列要素を探す：find

定義

self.find(
  searcher         // 検索条件を記述した関数　※必須
) -> any           // 条件にあてはまる要素があればその要素、そうでなければ none

複雑な条件で配列の要素を検索したい場合には、find を用います。find では、検索条件を関数で記述します。検索条件に使用する関数は、戻り値が bool 型でなければなりません。

find は、配列要素の先頭から順に関数を適用し、条件に合致したものが見つかった場合にその最初の要素を返します。条件に合致する要素が複数ある場合、最初に合致した要素だけが返される点には注意が必要です。条件に合致する要素すべてを取り出したい場合には、filter メソッドを用いてください。なお、合致する要素がなかった場合には、none が返されます。

使用例

#let my_array = (2, 8, 15, 42, 50, 24)

#my_array.find(
  x => {x > 20}   // 配列要素を変数xに代入し、その値が20より大きいかどうかをテスト
)

42

条件を満たす配列要素の位置を探す：position

定義

self.position(
  searcher         // 検索条件を記述した関数　※必須
) -> int           // 戻り値は、条件に合致する要素があればその要素のインデックス、なければ none

値そのものではなく、配列中における位置を検索したい場合には、position を用います。find と同様に、検索条件は関数で記述します。配列要素の先頭から順に関数が適用され、条件に合致したものが見つかった場合にその最初の要素のインデックスが返されます。合致する要素がなかった場合には、none が返されます。

使用例

#let my_array = (2, 8, 15, 42, 50, 24)

#my_array.position(
  x => {x > 20}   // 配列要素を変数xに代入し、その値が20より大きいかどうかをテスト
)

3

条件を満たす配列を作成するためのメソッド

指定した条件で数列を作成する：range

定義

array.range(
    start,           // 数列の開始値（int）
    end,             // 数列の終了値（int）　※必須
    step: int        // 数値の間隔
) -> array           // 戻り値は、作成された数列からなる配列

1から10までの数字を含む配列を作りたい、偶数番号のみを含む配列を作りたいなど、何らかの数列を含む配列が必要な場合には、range が便利です。なお、range は個別の配列に含まれるメソッドではなく、arrayそのもののメソッドなので、array.range() または range() の形で使用します。

使用例

#array.range(1, 5)

#range(2, 7)

#range(1, 11, step: 2)

(1, 2, 3, 4)
(2, 3, 4, 5, 6)
(1, 3, 5, 7, 9)

数列の最後の値は、指定した終了値の手前までになるので、その点は注意が必要です。また、引数に値が1つしか指定されていな場合、それは終了値とみなされ、0から終了値の直前までの値を含む数列が作成されます。

使用例

#range(5)

(0, 1, 2, 3, 4)

ステップの値には、負の値も指定できます。 その場合、開始値から順にステップを減じた値が含まれる配列が作成されます。またこの場合、開始値、終了値の値は両方とも必要です。

使用例

#range(50, 0, step: -7) // 50から7ずつ減じた数で、0より大きい値からなる数列

(50, 43, 36, 29, 22, 15, 8, 1)

配列から条件を満たす要素を抜き出して新たな配列を作成する：filter

定義

self.filter(
    test         // 抽出条件を記述した関数　※必須
  ) -> array     // 戻り値は、条件を満たす要素を含む配列

既存の配列から、条件を満たした要素をすべて抽出し、それらを要素として含む配列を新たに作成するには filter を使用します。抽出条件として使用する関数は、戻り値が bool 型でなくてはなりません。

使用例

#let my_array = (2, 8, 15, 42, 50, 24)

#my_array.filter(x => {x > 20}) // my_arrayから20を超える値のみを抽出し、新たな配列を作成

(42, 50, 24)

配列要素に変換操作を施して新たな配列を作成する：map

定義

self.map(
    mapper         // 変換操作を記述した関数　※必須
  ) -> array       // 戻り値は、変換操作後の要素を含む配列

map メソッドは、配列の各要素に対して何らかの変換を施し、その結果を新たな配列として作成します。map で使用する変換関数は、戻り値が bool 型である必要はありません。

使用例

#let my_array = (12, 18, 15, 16, 20, 24)

#my_array.map(x => { x - 15 }) // my_arrayの各要素から 15 を引いた値からなる配列を作成

(-3, 3, 0, 1, 5, 9)

配列要素に連番をつけた配列を作成する：enumerate

定義

self.enumerate(
    start: int        // 連番の開始番号
  ) -> array          // 戻り値は、元の配列要素と連番のペアを要素として含む配列

enumerate メソッドは、既存の配列の各要素に連番をつけ、その番号と値のペアを要素として含む配列を使用します。開始番号を省略した場合には、0番から連番が作成されます。

使用例

#let my_array = ("あ", "い", "う")

#my_array.enumerate(start: 101)  // 101で始まる番号と my_array 要素のペアを作成

#my_array.enumerate()          // 数値を省略した場合、番号は0から開始

((101, "あ"), (102, "い"), (103, "う"))
((0, "あ"), (1, "い"), (2, "う"))

列の各要素に他の配列の要素を結びつけて新たな配列を作成する：zip

定義

self.zip(
    exact: bool,    // 要素数が一致する場合のみに限定するかどうか（初期期：false）
    array,          // 各要素に結びつける値を含む配列
  ) -> array        // 戻り値は、元の配列要素と別配列の要素がペアになった新たな配列

zip は、複数の配列を一括りにして1つの配列にまとめるメソッドです。既存の配列の各要素に別の配列の要素を結びつけ、その結果を要素として持つ新たな配列を作成します。exact を true にした場合、連結する配列の要素数が一致していないとエラーになります。exact が false の場合、作成される配列の長さは要素が少ない方の配列と同じになります。

使用例

#let my_array1 = ("あ", "い", "う", "え")
#let my_array2 = ("a", "b", "c")

#my_array1.zip(my_array2)    // my_array1 に my_array2 を結合

#my_array2.zip(my_array1)    // my_array2 に my_array1 を結合

(("あ", "a"), ("い", "b") , ("う", "c"))
(("a", "あ"), ("b", "い") , ("c", "う"))

配列要素を値に集約するためのメソッド

配列の各要素に指定の操作を加え、1つの値に集約する：fold

定義

self.fold(
  init: any,         // 開始値　※必須    
  function(acc, x),  // 要素の操作関数　※必須（関数には累積値 acc と要素 x の2つの引数が必要）
) -> any           // 戻り値*は、配列要素を集約した値

fold は、指定した操作を行なって配列要素を集約し、1つの値にまとめるメソッドです。要素を操作するための関数には、各時点までの値を含む変数と、各要素の値を含む変数の2つの変数が必要です。関数の引数の名前は何でもかまいません。また、配列要素が数値の場合、文字列の場合のいずれも、それぞれの型に合った方法で集約可能です。

使用例

#let my_array1 = (2, 4, 6, 8, 10)

各要素の2倍の合計: #my_array1.fold( 0, (goukei, x) => goukei + x * 2 )


#let my_array2 = ("あ", "い", "う", "え", "お")

各要素の合計: #my_array2.fold("", (kana, x) => kana + x )

各要素の2倍の合計: 60

各要素の合計: あいうえお

配列の各要素に指定の操作を加え、1つの値に集約する：reduce

定義

self.reduce(
  function(acc, x),  // 要素の操作関数　※必須（関数には累積値 acc と要素 x の2つの引数が必要）
) -> any             // 戻り値は、配列要素を集約した値

reduce は、配列の最初の要素を初期値として用い、残りの配列要素に対して操作を施して結果を集約します。fold とよく似ていますが、fold とは違い、配列の最初の要素に対しては関数による変換は適用されませんので注意が必要です。

使用例

#let my_array1 = (2, 4, 6, 8, 10)

// 最初の要素は2倍されない
#各要素の2倍の合計？ #my_array1.reduce((goukei, x) => goukei + ( x * 2 ))

各要素の2倍の合計？ #goukei

各要素の2倍の合計？ 58

配列の各要素を合計、あるいは連結して1つの値に集約する：sum

定義

self.sum(
  default: any  // 配列が空の場合に返される値
) -> any        // 戻り値は、配列要素を合計（文字列の場合は連結）した値

sum は、その名の通り、配列の各要素の合計を求め、その値を返すメソッドです。配列の要素が数値ではなく文字の場合、その内容がすべて連結された文字列が返されます。配列の要素に文字と数値が混在している場合にはエラーになるので注意が必要です。

使用例

#let my_array1 = (2, 4, 6, 8, 10)

合計：#my_array1.sum()

#let my_array2 = ("a", "b", "c", "d")

合計：#my_array2.sum()

合計：30

合計：abcd

配列の各要素を積算し、1つの値に集約する：product

定義

self.product(
  default: any  // 配列が空の場合に返される値
) -> any        // 戻り値は、配列要素の積算結果

product は、配列要素の総積を求め、その値を返します。配列要素が互いに掛け算できる値でない場合にはエラーになります。

使用例

#let my_array = (2, 4, 6, 8, 10)

総積：#my_array.product()

総積：3840

なお、配列要素に文字列が含まれていても、次のケースは掛け算（というのが適切かどうかは別として）が可能なのでエラーにはなりません。

使用例

#let my_array = ("こんにちは！", 3)

#my_array.product() // この場合、"こんにちは！"が 3 回繰り返される

こんにちは！こんにちは！こんにちは！

配列の各要素を検査し、条件を満たすものが含まれているかどうか調べる：any

定義

self.any(
  test         // 各要素を検査するための関数　※必須　
) -> bool      // 条件にあてはまる要素が1つでもあれば true、そうでなければ false

any は、配列の各要素を関数で検査し、条件を満たすものが含まれているかどうかを調べます。contain に似ていますが、値ではなく関数で定義した条件を適用できる点が異なります。なお、検査に使用する関数は、戻り値が bool 型でなくてはなりません。

使用例

#let my_array = (2, 4, 6, 8, 10)

#my_array.any( x => x > 8) // 8 より大きい値が含まれているかどうかを検査

true

配列の各要素を検査し、すべての要素が条件を満たしているかどうか調べる：all

定義

self.all(
  test         // 各要素を検査するための関数　※必須　
) -> bool      //すべての要素が条件にあてはまれば true、そうでなければ false

any は条件にあてはまる要素が1つでもあれば true を返しますが、all はすべての要素が条件を満たしていない限り false になります。検査に使用する関数は、any と同様に戻り値が bool 型でなくてはなりません。

使用例

#let my_array = (2, 4, 6, 8, 10)

#my_array.all( x => x > 8) // 8 全要素が8より大きいかどうかを検査

false

その他のメソッド

入れ子になっている配列要素を1次元に展開する: flatten()

定義

self.flatten() -> array  // 戻り値は、入れ子になっている配列要素をすべて展開した1次元配列

配列要素にさらに配列が含まれる入れ子構造になった配列では、配列の各要素に対する処理が複雑になりすぎたり、要素の検索がうまくいかなかったりする場合があります。そのような場合、配列要素の入れ子構造を解消し、単純な1次元配列にすることで扱いやすくなります。flatten は、そのように配列の構造を単純化するためのメソッドです。

使用例

#let my_array = (2, 4, (6, 8), 10)  // 要素に配列 (6, 8) が含まれている

// #my_array.sum() <- 数値と配列は足せないので、これはエラーになる

#let my_array2 = my_array.flatten()

#my_array2        // flatten で入れ子が解消される

#my_array2.sum()  // 要素はすべて数値なので合計できる

(2, 4, 6, 8, 10)

30

配列要素を逆順に並び替える：rev

定義

self.rev() -> array        //*戻り値*は、要素の順序を逆転させた配列

rev は、配列要素の並び順を逆転させるメソッドです。要素に配列が含まれる場合、その配列の中身までは逆転されません。

使用例

#let my_array = (2, 4, (6, 8), 10) 

#my_array.rev()

(10, (6, 8), 4, 2)

配列要素を指定値で分割する：split

定義

self.split(
  value      // 要素を分割する値(any)　※必須
) -> array   // 戻り値*は、分割された要素を含む新たな配列

split は、指定した値で配列要素を区切って返すメソッドです。区切り値に挟まれる要素がひとまとまりになり、配列として要素に格納されます。なお、区切りに使用した値は、新たな配列の要素には含まれません。

使用例

#let my_array = (2, 3, 4, 5, 6, 4, 10, 12) 

#my_array.split(4) // 4 を区切り値として配列要素を区切る

((2, 3), (5, 6), (10, 12))

配列要素を区切り値で繋いで1つにする：join

定義

self.join(
  separator,     // 区切り値
  last: any      // 最後の要素を連結する際の区切り値
) -> array       // 戻り値は、要素が連結された文字列、配列等

join は、指定した値で配列要素を連結して返すメソッドです。戻される結果は、元の配列要素の型に依存します。たとえば、元の配列要素がすべて文字列であれば、区切り値で連結された1つの文字列が返されます。元の配列要素が数値であれば、区切り値を挟んで数値が並んだ配列が返されます。なお、last 引数を指定した場合、最後の要素を連結する際にその値が使用されます。

使用例

#let my_array = ("Smith", "Brown", "Davis", "Carter") 

#my_array.join(", ", last: ", and ") // 人名をコンマでつなぐ（最後だけ ", and "）


#let my_array2 = ((2, 3), (4, 5), (6, 4), (10, 12))

#my_array2.join((0,))  // 配列の間に 0 を入れて1つにつなぐ

Smith, Brown, Davis, and Carter

(2, 3, 0, 4, 5, 0, 6, 4, 0, 10, 12)

配列の各要素の間に区切り値を挿入する：intersperse

定義

self.intersperse(
    separator,     // 区切り値　※ 
  ) -> array      // 戻り値*は、要素が連結された文字列、配列等

intersperse は、指定した値を配列の各要素の間に挿入した配列を作成して返すメソッドです。

使用例

#let my_array = ("a", "b", "c", "d") 

#my_array.intersperse(" ") // 元の配列の要素間に " " を挿入した配列を作成

("a", " ", "b", " ", "c", " ", "d")

配列の要素を指定したサイズのかたまり（チャンク）に区切る：chunks

定義

self.chunks(
  size,          // チャンクのサイズ（int）　※必須 
  exact: bool    // 余った要素の扱い（true: 破棄、false: 残す）
) -> array       // 戻り値は、要素をチャンクにまとめた配列

chunks は、配列要素を指定サイズのかたまり（チャンク）に区切るメソッドです。exact の値が true のとき、指定サイズで割り切れなかった残りの要素は破棄されます。exact が false のとき、残りの要素は配列の末尾に残されます（初期値： false ）。

使用例

#let my_array = (2, 3, 6, 4, 5, 6, 7, 8) 

#my_array.chunks(3)               // 配列要素を 3 個ずつまとめる

#my_array.chunks(3, exact: true)  // exact が true のときは、余った要素は破棄される

((2, 3, 6), (4, 5, 6), (7, 8))

((2, 3, 6), (4, 5, 6))

配列要素上で指定サイズの枠(ウィンドウ)をスライドさせ、新たな配列を作成する：windows

定義

self.windows(
    size,          // ウィンドウのサイズ（int）　※必須 
  ) -> array       // 戻り値は、各ウィンドウの要素を含む新たな配列

windows は、指定した枠（ウィンドウ）を1つずつスライドさせながら、そのつどそのウィンドウに収まる配列要素をチャンクとして配列を作成するメソッドです。

使用例

#let my_array = (2, 4, 6, 8, 10) 

#my_array.windows(3)               // 長さ 3 のウィンドウをスライドさせた配列を作成する

((2, 4, 6), (4, 6, 8), (6, 8, 10))

要素を並び替えた配列を作成する：sorted

定義

self.sorted(
  key,          // 並び替えのための関数
) -> array      // 戻り値は、要素が並び替えられた配列

sorted は、指定した条件で配列要素を並び替え（ソート）するメソッドです。sorted は要素を並び替えた配列を新たに作成するメソッドであり、元の変数要素の順序が変更されることはありません。key 関数が指定されていない場合、配列要素は単純に昇順ソートされます。

使用例

#let my_array = (2, 10, 5, 8, 7) 

#my_array.sorted()

(2, 5, 7, 8, 10)

key 関数を指定した場合、その関数の定義に沿って配列要素が並び替えられます。たとえば、2つの数値ペアを要素とする配列で、1つ目の値ではなく、2つ目の値を基準に並び替える場合には、key 関数でそのように定義する必要があります。

使用例

#let my_array = ( (8, 2) , (5, 8) , (1, 3) ) 

#my_array.sorted()                  // key なしのソート

#my_array.sorted(key: x => x.at(1)) // 数値ペアの2つ目の値で並び替え

((1, 3), (5, 8), (8, 2))

((8, 2), (1, 3), (5, 8))

値が重複する要素を除いた、新たな配列を作成する：dedup

定義

self.dedup(
  key,          // 重複条件を指定するための関数
) -> array      // 戻り値は、重複要素が整理された配列

dedup は、配列要素を整理して、要素の重複を解消するメソッドです。このメソッドは要素の重複を解消した新たな配列を作成するものであり、元の配列の要素は変更されません。

使用例

#let my_array = (2, 10, 5, 8, 7, 8) 

#my_array.dedup()  // 重複要素は、最初のものだけが残される

(2, 10, 5, 8, 7)

値のペアを要素とする配列を、辞書（名前つきリスト）に変換する：to-dict

定義

self.to-dict()(
) -> dict        // 戻り値は、辞書型データ

to-dict は、ペア要素で構成される配列を辞書（名前つきリスト）に変換するメソッドです。

使用例

#let my_array = (("a", 10), ("b", 6), ("c", 8), ("a", 9)) 

#my_array.to-dict()  // 重複するキーがある場合、最後の値で上書きされる

(a: 9, b: 6, c: 8)