原生模式下的 Cloud Firestore 企业版现已推出！了解详情。

Google आपकी पसंदीदा भाषा में कॉन्टेंट का अनुवाद करने के लिए, एआई टेक्नोलॉजी का इस्तेमाल करता है. एआई से मिले अनुवादों में गलतियां हो सकती हैं.

ऐरे फ़ंक्शन

अरे फ़ंक्शन

नाम	ब्यौरा
`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`	`ARRAY` में `n` सबसे छोटी वैल्यू दिखाता है
`SUM`	यह फ़ंक्शन, किसी `ARRAY` में मौजूद सभी `NUMERIC` वैल्यू का कुल योग दिखाता है.
`JOIN`	यह `ARRAY` में मौजूद एलिमेंट को जोड़कर, `STRING` वैल्यू के तौर पर दिखाता है.

ARRAY

सिंटैक्स:

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

जानकारी:

यह दिए गए एलिमेंट से एक अरे बनाता है.

अगर कोई आर्ग्युमेंट मौजूद नहीं है, तो उसे नतीजे के तौर पर मिलने वाले कलेक्शन में NULL से बदल दिया जाता है.

प्रॉम्प्ट के उदाहरण:

values	`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

जाएं

snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.ArrayConcat(firestore.FieldOf("genre"), firestore.FieldOf("subGenre")).As("allGenres"),
	)).
	Execute(ctx)pipeline_snippets_array.go

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

जाएं

snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.ArrayContains(firestore.FieldOf("genre"), "mystery").As("isMystery"),
	)).
	Execute(ctx)pipeline_snippets_array.go

ARRAY_CONTAINS_ALL

सिंटैक्स:

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

जानकारी:

अगर array में सभी search_values मिलते हैं, तो 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

जाएं

snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.ArrayContainsAll(firestore.FieldOf("genre"), []string{"fantasy", "adventure"}).As("isFantasyAdventure"),
	)).
	Execute(ctx)pipeline_snippets_array.go

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

जाएं

snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.ArrayContainsAny(firestore.FieldOf("genre"), []string{"fantasy", "nonfiction"}).As("isMysteryOrFantasy"),
	)).
	Execute(ctx)pipeline_snippets_array.go

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

जाएं

snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.ArrayLength(firestore.FieldOf("genre")).As("genreCount"),
	)).
	Execute(ctx)pipeline_snippets_array.go

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

जाएं

snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.ArrayReverse(firestore.FieldOf("genre")).As("reversedGenres"),
	)).
	Execute(ctx)pipeline_snippets_array.go

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

जानकारी:

हर एलिमेंट पर expression लागू करके, array को बदलता है. साथ ही, बदले गए एलिमेंट के साथ एक नई श्रेणी दिखाता है. आउटपुट कलेक्शन का साइज़ हमेशा इनपुट कलेक्शन के साइज़ के बराबर होगा.

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

सिंटैक्स:

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

सिंटैक्स:

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'	'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"	गड़बड़ी