MongoDB $isArray

I MongoDB kan du använda $isArray aggregeringspipeline-operatör för att kontrollera om ett värde är en array eller inte.

Den accepterar alla giltiga uttryck och returnerar true om uttrycket är en array, false om det inte är det.

Exempel

Anta att vi har en samling som heter test med följande dokument:

{ "_id" : 1, "data" : [ ] }
{ "_id" : 2, "data" : [ 1, 2, 3 ] }
{ "_id" : 3, "data" : [ "XS", "M", "L" ] }
{ "_id" : 4, "data" : 123 }
{ "_id" : 5, "data" : "Homer Jay" }

Vi kan använda följande kod för att kontrollera data fält för arrayer:

db.test.aggregate(
  [
     { $match: { _id: { $in: [ 1, 2, 3, 4, 5 ] } } },
    {
      $project:
        { 
          _id: 1,
          data: 1,
          result: { $isArray: "$data" }
        }
    }
  ]
)

Resultat:

{ "_id" : 1, "data" : [ ], "result" : true }
{ "_id" : 2, "data" : [ 1, 2, 3 ], "result" : true }
{ "_id" : 3, "data" : [ "XS", "M", "L" ], "result" : true }
{ "_id" : 4, "data" : 123, "result" : false }
{ "_id" : 5, "data" : "Homer Jay", "result" : false }

Vi kan se att de tre första dokumenten innehåller arrayer och att de andra två inte gör det.

Vi kan också se att det första dokumentet innehåller en tom array. Det är fortfarande en array, och så $isArray returnerar true .

Exempel 2

Här är ett annat exempel som innehåller olika fält med olika BSON-typer.

Anta att vi har en samling som heter types med följande dokument:

{
	"_id" : ObjectId("601738d7c8eb4369cf6ad9de"),
	"double" : 123.75,
	"string" : "123",
	"boolean" : true,
	"date" : ISODate("2020-12-31T23:30:15.123Z"),
	"integer" : 123,
	"long" : NumberLong(123),
	"decimal" : NumberDecimal("123.75"),
	"object" : {
		"a" : 1
	},
	"array" : [
		1,
		2,
		3
	]
}

För syftet med den här artikeln har jag döpt varje fält för att återspegla dess BSON-typ.

Vi kan nu använda följande kod för att returnera antingen true eller false för varje fält, beroende på om fältet är en array eller inte:

db.types.aggregate(
  [
    {
      $project:
        { 
          _id: { $isArray: "$_id" },
          double: { $isArray: "$double" },
          string: { $isArray: "$string" },
          boolean: { $isArray: "$boolean" },
          date: { $isArray: "$date" },
          integer: { $isArray: "$integer" },
          long: { $isArray: "$long" },
          decimal: { $isArray: "$decimal" },
          object: { $isArray: "$object" },
          array: { $isArray: "$array" }
        }
    }
  ]
).pretty()

Resultat:

{
	"_id" : false,
	"double" : false,
	"string" : false,
	"boolean" : false,
	"date" : false,
	"integer" : false,
	"long" : false,
	"decimal" : false,
	"object" : false,
	"array" : true
}

Fält saknas

Använder $isArray till ett fält som inte finns resulterar i false .

Anta att vårt test samlingen innehåller följande dokument:

{ "_id" : 6 }

Och vi tillämpar $isArray till det dokumentet:

db.test.aggregate(
  [
     { $match: { _id: { $in: [ 6 ] } } },
    {
      $project:
        { 
          _id: 1,
          data: 1,
          result: { $isArray: "$data" }
        }
    }
  ]
)

Resultat:

{ "_id" : 6, "result" : false }

Nullvärden

Använder $isArray till null returnerar false .

Anta att vårt test samlingen innehåller följande dokument:

{ "_id" : 7, "data" : null }

Och vi tillämpar $isArray till det dokumentet:

db.test.aggregate(
  [
     { $match: { _id: { $in: [ 7 ] } } },
    {
      $project:
        { 
          _id: 1,
          data: 1,
          result: { $isArray: "$data" }
        }
    }
  ]
)

Resultat:

{ "_id" : 7, "data" : null, "result" : false }

Odefinierade värden

På samma sätt returnerar odefinierade värden false .

Anta att vårt test samlingen innehåller följande dokument:

{ "_id" : 8, "data" : undefined }

Använd $isArray :

db.test.aggregate(
  [
     { $match: { _id: { $in: [ 8 ] } } },
    {
      $project:
        { 
          _id: 1,
          data: 1,
          result: { $isArray: "$data" }
        }
    }
  ]
)

Resultat:

{ "_id" : 8, "data" : undefined, "result" : false }