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

ऐरे फ़ंक्शन

नाम	ब्यौरा
`ARRAY`	यह एक `ARRAY` दिखाता है. इसमें हर इनपुट आर्ग्युमेंट के लिए एक एलिमेंट होता है
`ARRAY_CONCAT`	यह फ़ंक्शन, एक से ज़्यादा ऐरे को एक ही `ARRAY` में जोड़ता है
`ARRAY_CONTAINS`	अगर दिए गए `ARRAY` में कोई वैल्यू मौजूद है, तो `TRUE` दिखाता है
`ARRAY_CONTAINS_ALL`	अगर सभी वैल्यू `ARRAY` में मौजूद हैं, तो `TRUE` दिखाता है
`ARRAY_CONTAINS_ANY`	अगर कोई भी वैल्यू `ARRAY` में मौजूद है, तो `TRUE` दिखाता है
`ARRAY_FILTER`	यह फ़ंक्शन, `ARRAY` से उन एलिमेंट को हटा देता है जो किसी शर्त को पूरा नहीं करते
`ARRAY_FIRST`	किसी `ARRAY` में मौजूद पहला एलिमेंट दिखाता है
`ARRAY_FIRST_N`	किसी `ARRAY` में मौजूद पहले `n` एलिमेंट दिखाता है
`ARRAY_GET`	`ARRAY` में मौजूद किसी इंडेक्स पर मौजूद एलिमेंट दिखाता है
`ARRAY_INDEX_OF`	इस फ़ंक्शन से, `ARRAY` में किसी वैल्यू की पहली बार दिखने का इंडेक्स मिलता है
`ARRAY_INDEX_OF_ALL`	`ARRAY` में किसी वैल्यू के सभी इंडेक्स दिखाता है
`ARRAY_LENGTH`	यह फ़ंक्शन, `ARRAY` में मौजूद एलिमेंट की संख्या दिखाता है
`ARRAY_LAST`	यह फ़ंक्शन, `ARRAY` में मौजूद आखिरी एलिमेंट दिखाता है
`ARRAY_LAST_N`	यह फ़ंक्शन, `ARRAY` में मौजूद आखिरी `n` एलिमेंट दिखाता है
`ARRAY_REVERSE`	यह फ़ंक्शन, `ARRAY` में मौजूद एलिमेंट का क्रम उलट देता है
`ARRAY_SLICE`	`ARRAY` का स्लाइस दिखाता है
`ARRAY_TRANSFORM`	यह `ARRAY` में मौजूद एलिमेंट में बदलाव करता है. इसके लिए, हर एलिमेंट पर एक्सप्रेशन लागू किया जाता है
`MAXIMUM`	`ARRAY` एट्रिब्यूट की सबसे बड़ी वैल्यू दिखाता है
`MAXIMUM_N`	`ARRAY` में मौजूद `n` सबसे बड़ी वैल्यू दिखाता है
`MINIMUM`	`ARRAY` में मौजूद सबसे छोटी वैल्यू दिखाता है
`MINIMUM_N`	`n` में मौजूद सबसे छोटी वैल्यू दिखाता है `ARRAY`
`SUM`	यह `ARRAY` में मौजूद सभी `NUMERIC` वैल्यू का योग दिखाता है.
`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

ब्यौरा:

अगर array में value मौजूद है, तो TRUE दिखाता है. ऐसा न होने पर, FALSE दिखाता है.

उदाहरण:

कलेक्शन	value	`array_contains(array, value)`
[1, 2, 3]	2	सही
[[1, 2], [3]]	[1, 2]	सही
[1, null]	शून्य	सही
"abc"	कोई भी	गड़बड़ी

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

ब्यौरा:

अगर सभी search_values, array में मौजूद हैं, तो TRUE दिखाता है. ऐसा न होने पर, FALSE दिखाता है.

उदाहरण:

कलेक्शन	search_values	`array_contains_all(array, search_values)`
[1, 2, 3]	[1, 2]	सही
[1, 2, 3]	[1, 4]	गलत
[1, null]	[अमान्य]	सही
[NaN]	[NaN]	सही
[]	[]	सही
[1, 2, 3]	[]	सही

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

ब्यौरा:

अगर array में कोई भी search_values मिलता है, तो TRUE दिखाता है. ऐसा न होने पर, FALSE दिखाता है.

उदाहरण:

कलेक्शन	search_values	`array_contains_any(array, search_values)`
[1, 2, 3]	[4, 1]	सही
[1, 2, 3]	[4, 5]	गलत
[1, 2, null]	[अमान्य]	सही

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

ब्यौरा:

predicate एक्सप्रेशन का इस्तेमाल करके, array को फ़िल्टर करता है. साथ ही, सिर्फ़ उन एलिमेंट के साथ एक नई अरे दिखाता है जो प्रेडिकेट को पूरा करते हैं.

array में मौजूद हर एलिमेंट के लिए, predicate का आकलन किया जाता है. अगर यह true दिखाता है, तो एलिमेंट को नतीजे में शामिल किया जाता है. अगर यह false या null दिखाता है, तो इसे शामिल नहीं किया जाता.
अगर predicate का आकलन करने पर, बूलियन या शून्य नहीं है, तो फ़ंक्शन एक गड़बड़ी दिखाता है.

उदाहरण:

कलेक्शन	प्रीडिकेट	`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

ब्यौरा:

array में मौजूद 0 पर आधारित index पर मौजूद एलिमेंट दिखाता है.

अगर 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	गड़बड़ी
शून्य	0	शून्य
`Array`	"a"	गड़बड़ी
`Array`	2.0	गड़बड़ी

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

ब्यौरा:

array के पहले n एलिमेंट दिखाता है. यह 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

ब्यौरा:

array में value के पहले इंस्टेंस का इंडेक्स दिखाता है. यह इंडेक्स 0 से शुरू होता है. अगर value नहीं मिलता है, तो -1 दिखाता है.

उदाहरण:

कलेक्शन	value	`array_index_of(array, value)`
[1, 2, 3, 2]	2	1
[1, 2, 3]	4	-1
[1, null, 3]	शून्य	1

ARRAY_INDEX_OF_ALL

सिंटैक्स:

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

ब्यौरा:

यह फ़ंक्शन, array में value के सभी उदाहरणों के इंडेक्स वाली एक कैटगरी दिखाता है. इंडेक्स 0 से शुरू होते हैं. अगर value नहीं मिलता है, तो [] दिखाता है.

उदाहरण:

कलेक्शन	value	`array_index_of_all(array, value)`
[1, 2, 3, 2]	2	[1, 3]
[1, 2, 3]	4	[]
[1, null, 3, 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

ब्यौरा:

array के आखिरी n एलिमेंट दिखाता है.

अगर 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 का सबसेट दिखाता है. यह 0 पर आधारित इंडेक्स offset से शुरू होता है और इसमें 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]	शून्य
[]	शून्य

MAXIMUM_N

सिंटैक्स:

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

ब्यौरा:

यह फ़ंक्शन, array में मौजूद n सबसे बड़ी वैल्यू का अरे दिखाता है. यह अरे, घटते क्रम में होता है.

NULL वैल्यू को अनदेखा किया जाता है.
अगर n नेगेटिव है, तो गड़बड़ी का मैसेज दिखता है.

उदाहरण:

कलेक्शन	n	`maximum_n(array, n)`
[1, 5, 2, 4, 3]	3	[5, 4, 3]
[1, null, 5]	3	[5, 1]

कम से कम

सिंटैक्स:

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]	शून्य
[]	शून्य

MINIMUM_N

सिंटैक्स:

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

ब्यौरा:

यह फ़ंक्शन, array में मौजूद n सबसे छोटी वैल्यू का एक ऐसा कलेक्शन दिखाता है जिसमें वैल्यू बढ़ते क्रम में होती हैं.

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

ब्यौरा:

यह ARRAY में मौजूद सभी NUMERIC वैल्यू का योग दिखाता है.

ऐरे में मौजूद नॉन-न्यूमेरिक वैल्यू को अनदेखा किया जाता है.
अगर ऐरे में मौजूद कोई भी संख्यात्मक वैल्यू 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]	गड़बड़ी
[INT64.MAX_VALUE, 1, -1.0]	गड़बड़ी
[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 दिया गया है, तो array में मौजूद NULL वैल्यू को null_text से बदल दिया जाता है.
अगर null_text नहीं दिया गया है, तो array में मौजूद NULL वैल्यू को नतीजे से हटा दिया जाता है.

उदाहरण:

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']	","	गड़बड़ी
["a", "c"]	b','	गड़बड़ी
[b'a', b'c']	","	गड़बड़ी

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'	गड़बड़ी
[b'a', null]	b','	"N"	गड़बड़ी