ऐरे फ़ंक्शन

ऐरे फ़ंक्शन

नाम ब्यौरा
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 डाल दिया जाता है.

उदाहरण:

वैल्यू 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();
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("genre").arrayConcat([Field("subGenre")]).as("allGenres")])
  .execute()

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("genre").arrayConcat(field("subGenre")).alias("allGenres"))
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(arrayConcat(field("genre"), field("subGenre")).as("allGenres"))
        .execute()
        .get();
जाएं
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.ArrayConcat(firestore.FieldOf("genre"), firestore.FieldOf("subGenre")).As("allGenres"),
	)).
	Execute(ctx)

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();

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("genre").arrayContains(constant("mystery")).as("isMystery"))
);
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("genre").arrayContains(Constant("mystery")).as("isMystery")])
  .execute()

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("genre").arrayContains("mystery").alias("isMystery"))
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(arrayContains(field("genre"), "mystery").as("isMystery"))
        .execute()
        .get();
जाएं
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.ArrayContains(firestore.FieldOf("genre"), "mystery").As("isMystery"),
	)).
	Execute(ctx)

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();

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("genre")
      .arrayContainsAll([constant("fantasy"), constant("adventure")])
      .as("isFantasyAdventure")
  )
);
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("genre")
      .arrayContainsAll([Constant("fantasy"), Constant("adventure")])
      .as("isFantasyAdventure")
  ])
  .execute()

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("genre")
            .arrayContainsAll(Arrays.asList("fantasy", "adventure"))
            .alias("isFantasyAdventure")
    )
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            arrayContainsAll(field("genre"), Arrays.asList("fantasy", "adventure"))
                .as("isFantasyAdventure"))
        .execute()
        .get();
जाएं
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.ArrayContainsAll(firestore.FieldOf("genre"), []string{"fantasy", "adventure"}).As("isFantasyAdventure"),
	)).
	Execute(ctx)

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();

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(
    field("genre")
      .arrayContainsAny([constant("fantasy"), constant("nonfiction")])
      .as("isMysteryOrFantasy")
  )
);
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([
    Field("genre")
      .arrayContainsAny([Constant("fantasy"), Constant("nonfiction")])
      .as("isMysteryOrFantasy")
  ])
  .execute()

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(
        field("genre")
            .arrayContainsAny(Arrays.asList("fantasy", "nonfiction"))
            .alias("isMysteryOrFantasy")
    )
    .execute();
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()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(
            arrayContainsAny(field("genre"), Arrays.asList("fantasy", "nonfiction"))
                .as("isMysteryOrFantasy"))
        .execute()
        .get();
जाएं
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.ArrayContainsAny(firestore.FieldOf("genre"), []string{"fantasy", "nonfiction"}).As("isMysteryOrFantasy"),
	)).
	Execute(ctx)

ARRAY_FILTER

सिंटैक्स:

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

ब्यौरा:

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

  • 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();

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("genre").arrayLength().as("genreCount"))
);
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("genre").arrayLength().as("genreCount")])
  .execute()

Kotlin

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

Java

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("genre").arrayLength().alias("genreCount"))
    .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("genre").array_length().as_("genreCount"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(arrayLength(field("genre")).as("genreCount"))
        .execute()
        .get();
जाएं
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.ArrayLength(firestore.FieldOf("genre")).As("genreCount"),
	)).
	Execute(ctx)

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();

Web

const result = await execute(db.pipeline()
  .collection("books")
  .select(field("genre").arrayReverse().as("reversedGenres"))
);
Swift
let result = try await db.pipeline()
  .collection("books")
  .select([Field("genre").arrayReverse().as("reversedGenres")])
  .execute()

Kotlin

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

Task<Pipeline.Snapshot> result = db.pipeline()
    .collection("books")
    .select(field("genre").arrayReverse().alias("reversedGenres"))
    .execute();
Python
from google.cloud.firestore_v1.pipeline_expressions import Field

result = (
    client.pipeline()
    .collection("books")
    .select(Field.of("genre").array_reverse().as_("reversedGenres"))
    .execute()
)
Java
Pipeline.Snapshot result =
    firestore
        .pipeline()
        .collection("books")
        .select(arrayReverse(field("genre")).as("reversedGenres"))
        .execute()
        .get();
जाएं
snapshot := client.Pipeline().
	Collection("books").
	Select(firestore.Fields(
		firestore.ArrayReverse(firestore.FieldOf("genre")).As("reversedGenres"),
	)).
	Execute(ctx)

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

ब्यौरा:

यह फ़ंक्शन, 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

ब्यौरा:

यह फ़ंक्शन, 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] 3000
[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" गड़बड़ी