Cloud Firestore Enterprise edition in Native mode is now available! Learn more.

פונקציות של מערכים

שם	תיאור
`ARRAY`	מחזירה רכיב `ARRAY` שמכיל רכיב אחד לכל ארגומנט קלט
`ARRAY_CONCAT`	הפונקציה משרשרת כמה מערכים למערך אחד `ARRAY`
`ARRAY_CONTAINS`	הפונקציה מחזירה את הערך `TRUE` אם הערך `ARRAY` מכיל ערך מסוים
`ARRAY_CONTAINS_ALL`	הפונקציה מחזירה את הערך `TRUE` אם כל הערכים מופיעים ב-`ARRAY`
`ARRAY_CONTAINS_ANY`	הפונקציה מחזירה את הערך `TRUE` אם אחד מהערכים מופיע ב-`ARRAY`
`ARRAY_FILTER`	סינון אלמנטים מ-`ARRAY` שלא עומדים בתנאי
`ARRAY_FIRST`	הפונקציה מחזירה את הרכיב הראשון ב-`ARRAY`
`ARRAY_FIRST_N`	הפונקציה מחזירה את `n` הרכיבים הראשונים ב-`ARRAY`
`ARRAY_GET`	מחזירה את הרכיב באינדקס נתון ב-`ARRAY`
`ARRAY_INDEX_OF`	הפונקציה מחזירה את האינדקס של המופע הראשון של ערך ב-`ARRAY`
`ARRAY_INDEX_OF_ALL`	הפונקציה מחזירה את כל האינדקסים של ערך במערך `ARRAY`
`ARRAY_LENGTH`	הפונקציה מחזירה את מספר הרכיבים ב-`ARRAY`
`ARRAY_LAST`	הפונקציה מחזירה את הרכיב האחרון ב-`ARRAY`
`ARRAY_LAST_N`	הפונקציה מחזירה את `n` הרכיבים האחרונים ב-`ARRAY`
`ARRAY_REVERSE`	הופך את סדר הרכיבים ב-`ARRAY`
`ARRAY_SLICE`	הפונקציה מחזירה פרוסה של `ARRAY`
`ARRAY_TRANSFORM`	טרנספורמציה של רכיבים ב-`ARRAY` על ידי החלת ביטוי על כל רכיב
`MAXIMUM`	הפונקציה מחזירה את הערך המקסימלי ב-`ARRAY`
`MAXIMUM_N`	הפונקציה מחזירה את `n` הערכים הגדולים ביותר ב-`ARRAY`
`MINIMUM`	הפונקציה מחזירה את הערך המינימלי ב-`ARRAY`
`MINIMUM_N`	הפונקציה מחזירה את `n` הערכים הקטנים ביותר ב-`ARRAY`
`SUM`	הפונקציה מחזירה את סכום כל הערכים של `NUMERIC` ב-`ARRAY`.
`JOIN`	יוצרת שרשור של הרכיבים ב-`ARRAY` כערך `STRING`.

ARRAY

תחביר:

array(values: ANY...) -> ARRAY

תיאור:

הפונקציה יוצרת מערך מהרכיבים שצוינו.

אם ארגומנט לא קיים, הוא מוחלף ב-NULL במערך שמתקבל.

לדוגמה:

ערכים	`array(values)`
()	[]
(1, 2, 3)	[1, 2, 3]
("a", 1, true)	‪["a", 1, true]
‪(1, null)	‫[1, null]
(1, [2, 3])	[1, [2, 3]]

ARRAY_CONCAT

תחביר:

array_concat(arrays: ARRAY...) -> ARRAY

תיאור:

הפונקציה משרשרת שני מערכים או יותר למערך אחד ARRAY.

לדוגמה:

מערכים	`array_concat(arrays)`
([1, 2], [3, 4])	‫[1, 2, 3, 4]
‪(["a", "b"], ["c"])	‪["a", "b", "c"]
([1], [2], [3])	[1, 2, 3]
([], [1, 2])	[1, 2]

Node.js

const result = await db.pipeline()
  .collection("books")
  .select(field("genre").arrayConcat([field("subGenre")]).as("allGenres"))
  .execute();test.firestore.js

Swift

let result = try await db.pipeline()
  .collection("books")
  .select([Field("genre").arrayConcat([Field("subGenre")]).as("allGenres")])
  .execute()PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(field("genre").arrayConcat(field("subGenre")).alias("allGenres"))
    .execute()DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("genre").arrayConcat(field("subGenre")).alias("allGenres"))
    .execute();DocSnippets.java

Python

from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("genre").array_concat(Field.of("subGenre")).as_("allGenres"))
    .execute()
)firestore_pipelines.py

Java

Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(arrayConcat(field("genre"), field("subGenre")).as("allGenres"))
        .execute()
        .get();PipelineSnippets.java

ARRAY_CONTAINS

תחביר:

array_contains(array: ARRAY, value: ANY) -> BOOLEAN

תיאור:

הפונקציה מחזירה TRUE אם המחרוזת value נמצאת במחרוזת array, אחרת היא מחזירה FALSE.

לדוגמה:

מערך	ערך	`array_contains(array, value)`
[1, 2, 3]	2	true
‪[[1, 2], [3]]	[1, 2]	true
‫[1, null]	null	true
‪"abc"	הכול	error

Node.js

const result = await db.pipeline()
  .collection("books")
  .select(field("genre").arrayContains(constant("mystery")).as("isMystery"))
  .execute();test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("genre").arrayContains(constant("mystery")).as("isMystery"))
);test.firestore.js

Swift

let result = try await db.pipeline()
  .collection("books")
  .select([Field("genre").arrayContains(Constant("mystery")).as("isMystery")])
  .execute()PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(field("genre").arrayContains("mystery").alias("isMystery"))
    .execute()DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("genre").arrayContains("mystery").alias("isMystery"))
    .execute();DocSnippets.java

Python

from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("genre").array_contains("mystery").as_("isMystery"))
    .execute()
)firestore_pipelines.py

Java

Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(arrayContains(field("genre"), "mystery").as("isMystery"))
        .execute()
        .get();PipelineSnippets.java

ARRAY_CONTAINS_ALL

תחביר:

array_contains_all(array: ARRAY, search_values: ARRAY) -> BOOLEAN

תיאור:

הפונקציה מחזירה TRUE אם כל הערכים של search_values נמצאים ב-array, אחרת היא מחזירה FALSE.

לדוגמה:

מערך	search_values	`array_contains_all(array, search_values)`
[1, 2, 3]	[1, 2]	true
[1, 2, 3]	[1, 4]	false
‫[1, null]	[אפס]	true
[NaN]	[NaN]	true
[]	[]	true
[1, 2, 3]	[]	true

Node.js

const result = await db.pipeline()
  .collection("books")
  .select(
    field("genre")
      .arrayContainsAll([constant("fantasy"), constant("adventure")])
      .as("isFantasyAdventure")
  )
  .execute();test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("genre")
      .arrayContainsAll([constant("fantasy"), constant("adventure")])
      .as("isFantasyAdventure")
  )
);test.firestore.js

Swift

let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("genre")
      .arrayContainsAll([Constant("fantasy"), Constant("adventure")])
      .as("isFantasyAdventure")
  ])
  .execute()PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        field("genre")
            .arrayContainsAll(listOf("fantasy", "adventure"))
            .alias("isFantasyAdventure")
    )
    .execute()DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("genre")
            .arrayContainsAll(Arrays.asList("fantasy", "adventure"))
            .alias("isFantasyAdventure")
    )
    .execute();DocSnippets.java

Python

from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("genre")
        .array_contains_all(["fantasy", "adventure"])
        .as_("isFantasyAdventure")
    )
    .execute()
)firestore_pipelines.py

Java

Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            arrayContainsAll(field("genre"), Arrays.asList("fantasy", "adventure"))
                .as("isFantasyAdventure"))
        .execute()
        .get();PipelineSnippets.java

ARRAY_CONTAINS_ANY

תחביר:

array_contains_any(array: ARRAY, search_values: ARRAY) -> BOOLEAN

תיאור:

הפונקציה מחזירה TRUE אם אחד מהערכים search_values נמצא בערך array, ו-FALSE אחרת.

לדוגמה:

מערך	search_values	`array_contains_any(array, search_values)`
[1, 2, 3]	[4, 1]	true
[1, 2, 3]	[4, 5]	false
[1, 2, null]	[אפס]	true

Node.js

const result = await db.pipeline()
  .collection("books")
  .select(
    field("genre")
      .arrayContainsAny([constant("fantasy"), constant("nonfiction")])
      .as("isMysteryOrFantasy")
  )
  .execute();test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("genre")
      .arrayContainsAny([constant("fantasy"), constant("nonfiction")])
      .as("isMysteryOrFantasy")
  )
);test.firestore.js

Swift

let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("genre")
      .arrayContainsAny([Constant("fantasy"), Constant("nonfiction")])
      .as("isMysteryOrFantasy")
  ])
  .execute()PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(
        field("genre")
            .arrayContainsAny(listOf("fantasy", "nonfiction"))
            .alias("isMysteryOrFantasy")
    )
    .execute()DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("genre")
            .arrayContainsAny(Arrays.asList("fantasy", "nonfiction"))
            .alias("isMysteryOrFantasy")
    )
    .execute();DocSnippets.java

Python

from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(
        Field.of("genre")
        .array_contains_any(["fantasy", "nonfiction"])
        .as_("isMysteryOrFantasy")
    )
    .execute()
)firestore_pipelines.py

Java

Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            arrayContainsAny(field("genre"), Arrays.asList("fantasy", "nonfiction"))
                .as("isMysteryOrFantasy"))
        .execute()
        .get();PipelineSnippets.java

ARRAY_FILTER

תחביר:

array_filter(array: ARRAY, predicate: (ANY) -> BOOLEAN) -> ARRAY

תיאור:

מסננת את array באמצעות ביטוי predicate ומחזירה מערך חדש עם רכיבים שמקיימים את התנאי.

לכל רכיב ב-array, מתבצעת הערכה של predicate. אם הפונקציה מחזירה true, הרכיב נכלל בתוצאה. אחרת (אם היא מחזירה false או null), הוא מושמט.
אם predicate מוערך כערך שאינו בוליאני או שאינו null, הפונקציה מחזירה שגיאה.

לדוגמה:

מערך	תנאי	`array_filter(array, predicate)`
[1, 2, 3]	x -> x > 1	[2, 3]
‫[1, null, 3]	x -> x > 1	[3]
‪["a", "b", "c"]	x -> x != "b"‎	‪["a", "c"]
[]	x -> true	[]

ARRAY_GET

תחביר:

array_get(array: ARRAY, index: INT64) -> ANY

תיאור:

הפונקציה מחזירה את הרכיב במיקום index (החל מ-0) ב-array.

אם index הוא מספר שלילי, הגישה לרכיבים היא מסוף המערך, כאשר -1 הוא הרכיב האחרון.
אם array הוא לא מסוג ARRAY ולא null, הפונקציה מחזירה שגיאה.
אם index הוא מחוץ לגבולות, הפונקציה מחזירה ערך חסר.
אם index הוא לא מסוג INT64, הפונקציה מחזירה שגיאה.

לדוגמה:

מערך	אינדקס	`array_get(array, index)`
[1, 2, 3]	0	1
[1, 2, 3]	-1	3
[1, 2, 3]	3	נעדר/ת
[1, 2, 3]	-4	נעדר/ת
‪"abc"	0	error
null	0	null
`Array`	"a"	error
`Array`	2.0	error

ARRAY_LENGTH

תחביר:

array_length(array: ARRAY) -> INT64

תיאור:

הפונקציה מחזירה את מספר הרכיבים ב-array.

לדוגמה:

מערך	`array_length(array)`
[1, 2, 3]	3
[]	0
‫[1, 1, 1]	3
‫[1, null]	2

Node.js

const result = await db.pipeline()
  .collection("books")
  .select(field("genre").arrayLength().as("genreCount"))
  .execute();test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("genre").arrayLength().as("genreCount"))
);test.firestore.js

Swift

let result = try await db.pipeline()
  .collection("books")
  .select([Field("genre").arrayLength().as("genreCount")])
  .execute()PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(field("genre").arrayLength().alias("genreCount"))
    .execute()DocSnippets.kt

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("genre").arrayLength().alias("genreCount"))
    .execute();DocSnippets.java

Python

from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("genre").array_length().as_("genreCount"))
    .execute()
)firestore_pipelines.py

Java

Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(arrayLength(field("genre")).as("genreCount"))
        .execute()
        .get();PipelineSnippets.java

ARRAY_REVERSE

תחביר:

array_reverse(array: ARRAY) -> ARRAY

תיאור:

היפוך של array הנתון.

לדוגמה:

מערך	`array_reverse(array)`
[1, 2, 3]	‫[3, 2, 1]
‪["a", "b"]	‪["b", "a"]
‫[1, 2, 2, 3]	‫[3, 2, 2, 1]

Node.js

const result = await db.pipeline()
  .collection("books")
  .select(arrayReverse(field("genre")).as("reversedGenres"))
  .execute();test.firestore.js

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("genre").arrayReverse().as("reversedGenres"))
);test.firestore.js

Swift

let result = try await db.pipeline()
  .collection("books")
  .select([Field("genre").arrayReverse().as("reversedGenres")])
  .execute()PipelineSnippets.swift

Kotlin

val result = db.pipeline()
    .collection("books")
    .select(field("genre").arrayReverse().alias("reversedGenres"))
    .execute()DocSnippets.kt

    Java
Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("genre").arrayReverse().alias("reversedGenres"))
    .execute();DocSnippets.java

Python

from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("genre").array_reverse().as_("reversedGenres"))
    .execute()
)firestore_pipelines.py

Java

Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(arrayReverse(field("genre")).as("reversedGenres"))
        .execute()
        .get();PipelineSnippets.java

ARRAY_FIRST

תחביר:

array_first(array: ARRAY) -> ANY

תיאור:

הפונקציה מחזירה את הרכיב הראשון ב-array. הפונקציה הזו שוות ערך לפונקציה array_get(array, 0).

אם array ריק, הפונקציה מחזירה ערך חסר.

לדוגמה:

מערך	`array_first(array)`
[1, 2, 3]	1
[]	נעדר/ת

ARRAY_FIRST_N

תחביר:

array_first_n(array: ARRAY, n: INT64) -> ARRAY

תיאור:

הפונקציה מחזירה את n הרכיבים הראשונים של array. הפונקציה הזו שוות ערך לפונקציה array_slice(array, 0, n).

אם הערך של n הוא שלילי, הפונקציה מחזירה שגיאה.

לדוגמה:

מערך	n	`array_first_n(array, n)`
‫[1, 2, 3, 4, 5]	3	[1, 2, 3]
[1, 2]	3	[1, 2]
[1, 2, 3]	0	[]

ARRAY_INDEX_OF

תחביר:

array_index_of(array: ARRAY, value: ANY) -> INT64

תיאור:

הפונקציה מחזירה את האינדקס (המתחיל מ-0) של המופע הראשון של value ב-array. הפונקציה מחזירה ‎-1 אם המחרוזת value לא נמצאה.

לדוגמה:

מערך	ערך	`array_index_of(array, value)`
‫[1, 2, 3, 2]	2	1
[1, 2, 3]	4	-1
‫[1, null, 3]	null	1

ARRAY_INDEX_OF_ALL

תחביר:

array_index_of_all(array: ARRAY, value: ANY) -> ARRAY<INT64>

תיאור:

הפונקציה מחזירה מערך שמכיל את האינדקסים מבוססי-0 של כל המופעים של value ב-array. הפונקציה מחזירה [] אם value לא נמצא.

לדוגמה:

מערך	ערך	`array_index_of_all(array, value)`
‫[1, 2, 3, 2]	2	[1, 3]
[1, 2, 3]	4	[]
‪[1, null, 3, null]	null	[1, 3]

ARRAY_LAST

תחביר:

array_last(array: ARRAY) -> ANY

תיאור:

הפונקציה מחזירה את הרכיב האחרון ב-array. הפונקציה הזו שוות ערך לפונקציה array_get(array, -1).

אם array ריק, הפונקציה מחזירה ערך חסר.

לדוגמה:

מערך	`array_last(array)`
[1, 2, 3]	3
[]	נעדר/ת

ARRAY_LAST_N

תחביר:

array_last_n(array: ARRAY, n: INT64) -> ARRAY

תיאור:

הפונקציה מחזירה את n הרכיבים האחרונים של array.

אם הערך של n הוא שלילי, הפונקציה מחזירה שגיאה.

לדוגמה:

מערך	n	`array_last_n(array, n)`
‫[1, 2, 3, 4, 5]	3	[3, 4, 5]
[1, 2]	3	[1, 2]
[1, 2, 3]	0	[]

ARRAY_SLICE

תחביר:

array_slice(array: ARRAY, offset: INT64, length: INT64) -> ARRAY

תיאור:

הפונקציה מחזירה קבוצת משנה של array החל מהאינדקס offset (מבוסס-0), וכולל length רכיבים.

אם offset הוא מספר שלילי, הוא מציין את מיקום ההתחלה מסוף המערך, כאשר -1 הוא הרכיב האחרון.
אם length גדול ממספר האלמנטים שנותרו במערך אחרי offset, התוצאה תורחב עד לסוף המערך.
הערך length לא יכול להיות שלילי, אחרת הפונקציה מחזירה שגיאה.

לדוגמה:

מערך	לקזז	אורך	`array_slice(array, offset, length)`
‫[1, 2, 3, 4, 5]	1	3	‫[2, 3, 4]
‫[1, 2, 3, 4, 5]	-2	2	[4, 5]
[1, 2, 3]	1	5	[2, 3]
[1, 2, 3]	3	2	[]

ARRAY_TRANSFORM

תחביר:

array_transform(array: ARRAY, expression: (ANY) -> ANY) -> ARRAY
array_transform(array: ARRAY, expression: (ANY, INT64) -> ANY) -> ARRAY

תיאור:

הפונקציה מבצעת טרנספורמציה של array על ידי החלת expression על כל רכיב, ומחזירה מערך חדש עם רכיבים שעברו טרנספורמציה. גודל מערך הפלט תמיד יהיה זהה לגודל מערך הקלט.

‫expression יכול להיות פונקציה אוניטרית element -> result או פונקציה בינארית (element, index) -> result.
אם expression הוא אונארי, הוא נקרא עם כל רכיב של array.
אם expression הוא בינארי, הוא נקרא עם כל רכיב של array והאינדקס המתאים שלו מבוסס-0.

לדוגמה:

מערך	ביטוי	`array_transform(array, expression)`
[1, 2, 3]	x -> x * 2	[2, 4, 6]
[1, 2, 3]	x -> x + 1	‫[2, 3, 4]
‫[10, 20]	‫(x, i) -> x + i	[10, 21]
[]	x -> 1	[]

מקסימום

תחביר:

maximum(array: ARRAY) -> ANY

תיאור:

הפונקציה מחזירה את הערך המקסימלי ב-array.

המערכת מתעלמת מהערכים של NULL במהלך ההשוואה.
אם array ריק או מכיל רק ערכים של NULL, הפונקציה מחזירה NULL.

לדוגמה:

מערך	`maximum(array)`
[1, 5, 2]	5
[1, null, 5]	5
‪["a", "c", "b"]	"c"
[null, null]	null
[]	null

MAXIMUM_N

תחביר:

maximum_n(array: ARRAY, n: INT64) -> ARRAY

תיאור:

הפונקציה מחזירה מערך של n הערכים הגדולים ביותר ב-array בסדר יורד.

המערכת מתעלמת מהערכים של NULL.
אם הערך של n הוא שלילי, הפונקציה מחזירה שגיאה.

לדוגמה:

מערך	n	`maximum_n(array, n)`
‫[1, 5, 2, 4, 3]	3	‫[5, 4, 3]
[1, null, 5]	3	[5, 1]

MINIMUM

תחביר:

minimum(array: ARRAY) -> ANY

תיאור:

הפונקציה מחזירה את הערך המינימלי ב-array.

המערכת מתעלמת מהערכים של NULL במהלך ההשוואה.
אם array ריק או מכיל רק ערכים של NULL, הפונקציה מחזירה NULL.

לדוגמה:

מערך	`minimum(array)`
[1, 5, 2]	1
‫[5, null, 1]	1
‪["a", "c", "b"]	"a"
[null, null]	null
[]	null

MINIMUM_N

תחביר:

minimum_n(array: ARRAY, n: INT64) -> ARRAY

תיאור:

הפונקציה מחזירה מערך של n הערכים הקטנים ביותר ב-array בסדר עולה.

המערכת מתעלמת מהערכים של NULL.
אם הערך של n הוא שלילי, הפונקציה מחזירה שגיאה.

לדוגמה:

מערך	n	`minimum_n(array, n)`
‫[1, 5, 2, 4, 3]	3	[1, 2, 3]
‫[5, null, 1]	3	[1, 5]

SUM

תחביר:

sum(array: ARRAY) -> INT64 | FLOAT64

תיאור:

הפונקציה מחזירה את סכום כל הערכים של NUMERIC ב-ARRAY.

המערכת מתעלמת מערכים לא מספריים במערך.
אם ערך מספרי כלשהו במערך הוא NaN, הפונקציה מחזירה NaN.
סוג ההחזרה נקבע לפי הסוג המספרי הרחב ביותר במערך: INT64 < FLOAT64.
אם מתרחשת גלישה של מספר שלם בן 64 ביט לפני סיכום של ערך נקודה צפה, הפונקציה מחזירה שגיאה. אם מסכמים ערכים של נקודה צפה, גלישה מעבר לקיבולת תגרום לתוצאה של אינסוף חיובי או שלילי.
אם המערך לא מכיל ערכים מספריים בכלל, הפונקציה מחזירה NULL.

לדוגמה:

מערך	`sum(array)`
[1, 2, 3]	6L
‫[1L, ‏ 2L, ‏ 3L]	6L
‫[2000000000, 2000000000]	4000000000L
‫[10, 20.5]	30.5
‪[1, "a", 2]	‫3L
‫[INT64.MAX_VALUE, 1]	error
[INT64.MAX_VALUE, 1, -1.0]	error
‫[INT64.MAX_VALUE, 1.0]	9.223372036854776e+18

JOIN

תחביר:

join[T <: STRING | BYTES](array: ARRAY<T>, delimiter: T) -> STRING
join[T <: STRING | BYTES](array: ARRAY<T>, delimiter: T, null_text: T) -> STRING

תיאור:

הפונקציה מחזירה שרשור של האלמנטים ב-array בתור STRING. הפרמטר array יכול להיות מסוג הנתונים STRING או BYTES.

כל הרכיבים ב-array,‏ delimiter וגם null_text צריכים להיות מאותו סוג. הם צריכים להיות כולם STRING או כולם BYTES.
אם מציינים את null_text, כל הערכים של NULL ב-array מוחלפים ב-null_text.
אם לא מציינים את null_text, ערכי NULL ב-array לא נכללים בתוצאה.

לדוגמה:

אם לא מציינים את הערך null_text:

מערך	תו מפריד	`join(array, delimiter)`
‪["a", "b", "c"]	","	‫"a,b,c"
‪["a", null, "c"]	","	‪"a,c"
[b'a', b'b', b'c']	b','	b'a,b,c'
‪["a", b'c']	","	error
‪["a", "c"]	b','	error
[b'a', b'c']	","	error

כשהערך בשדה null_text הוא:

מערך	תו מפריד	null_text	`join(array, delimiter, null_text)`
‪["a", null, "c"]	","	‫"MISSING"	‪"a,MISSING,c"
[b'a', null, b'c']	b','	b'NULL'	b'a,NULL,c'
[null, "b", null]	","	‫"MISSING"	‪"MISSING,b,MISSING"
‪[b'a', null, null]	b','	b'NULL'	b'a,NULL,NULL'
‪["a", null]	","	b'N'	error
[b'a', null]	b','	‫"N"	error

פונקציות של מערכים קל לארגן דפים בעזרת אוספים אפשר לשמור ולסווג תוכן על סמך ההעדפות שלך.