Catch up on everything announced at Firebase Summit, and learn how Firebase can help you accelerate app development and run your app with confidence. Learn More

הוסף נתונים ל-Cloud Firestore

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

ישנן מספר דרכים לכתוב נתונים ל-Cloud Firestore:

  • הגדר את הנתונים של מסמך בתוך אוסף, תוך ציון מפורש מזהה מסמך.
  • הוסף מסמך חדש לאוסף. במקרה זה, Cloud Firestore מייצר אוטומטית את מזהה המסמך.
  • צור מסמך ריק עם מזהה שנוצר אוטומטית, והקצה לו נתונים מאוחר יותר.

מדריך זה מסביר כיצד להשתמש בסט, להוסיף או לעדכן מסמכים בודדים ב-Cloud Firestore. אם ברצונך לכתוב נתונים בכמות גדולה, ראה עסקאות וכתיבת אצווה .

הגדר מסמך

כדי ליצור או להחליף מסמך בודד, השתמש בשיטות set() הספציפיות לשפה הבאות:

Web version 9

השתמש בשיטת setDoc() :

import { doc, setDoc } from "firebase/firestore"; 

// Add a new document in collection "cities"
await setDoc(doc(db, "cities", "LA"), {
  name: "Los Angeles",
  state: "CA",
  country: "USA"
});

Web version 8

השתמש בשיטת set() :

// Add a new document in collection "cities"
db.collection("cities").doc("LA").set({
    name: "Los Angeles",
    state: "CA",
    country: "USA"
})
.then(() => {
    console.log("Document successfully written!");
})
.catch((error) => {
    console.error("Error writing document: ", error);
});
מָהִיר

השתמש בשיטת setData() :

הערה: מוצר זה אינו זמין ביעדי watchOS ו-App Clip.
// Add a new document in collection "cities"
db.collection("cities").document("LA").setData([
    "name": "Los Angeles",
    "state": "CA",
    "country": "USA"
]) { err in
    if let err = err {
        print("Error writing document: \(err)")
    } else {
        print("Document successfully written!")
    }
}
Objective-C

השתמש בשיטת setData: ::

הערה: מוצר זה אינו זמין ביעדי watchOS ו-App Clip.
// Add a new document in collection "cities"
[[[self.db collectionWithPath:@"cities"] documentWithPath:@"LA"] setData:@{
  @"name": @"Los Angeles",
  @"state": @"CA",
  @"country": @"USA"
} completion:^(NSError * _Nullable error) {
  if (error != nil) {
    NSLog(@"Error writing document: %@", error);
  } else {
    NSLog(@"Document successfully written!");
  }
}];

Java

השתמש בשיטת set() :

Map<String, Object> city = new HashMap<>();
city.put("name", "Los Angeles");
city.put("state", "CA");
city.put("country", "USA");

db.collection("cities").document("LA")
        .set(city)
        .addOnSuccessListener(new OnSuccessListener<Void>() {
            @Override
            public void onSuccess(Void aVoid) {
                Log.d(TAG, "DocumentSnapshot successfully written!");
            }
        })
        .addOnFailureListener(new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                Log.w(TAG, "Error writing document", e);
            }
        });

Kotlin+KTX

השתמש בשיטת set() :

val city = hashMapOf(
        "name" to "Los Angeles",
        "state" to "CA",
        "country" to "USA"
)

db.collection("cities").document("LA")
        .set(city)
        .addOnSuccessListener { Log.d(TAG, "DocumentSnapshot successfully written!") }
        .addOnFailureListener { e -> Log.w(TAG, "Error writing document", e) }

Dart

השתמש בשיטת set() :

final city = <String, String>{
  "name": "Los Angeles",
  "state": "CA",
  "country": "USA"
};

db
    .collection("cities")
    .doc("LA")
    .set(city)
    .onError((e, _) => print("Error writing document: $e"));
Java

השתמש בשיטת set() :

// Create a Map to store the data we want to set
Map<String, Object> docData = new HashMap<>();
docData.put("name", "Los Angeles");
docData.put("state", "CA");
docData.put("country", "USA");
docData.put("regions", Arrays.asList("west_coast", "socal"));
// Add a new document (asynchronously) in collection "cities" with id "LA"
ApiFuture<WriteResult> future = db.collection("cities").document("LA").set(docData);
// ...
// future.get() blocks on response
System.out.println("Update time : " + future.get().getUpdateTime());
פִּיתוֹן

השתמש בשיטת set() :

data = {
    u'name': u'Los Angeles',
    u'state': u'CA',
    u'country': u'USA'
}

# Add a new doc in collection 'cities' with ID 'LA'
db.collection(u'cities').document(u'LA').set(data)

Python

השתמש בשיטת set() :

data = {"name": "Los Angeles", "state": "CA", "country": "USA"}

# Add a new doc in collection 'cities' with ID 'LA'
await db.collection("cities").document("LA").set(data)
C++

השתמש בשיטת Set() :

// Add a new document in collection 'cities'
db->Collection("cities")
    .Document("LA")
    .Set({{"name", FieldValue::String("Los Angeles")},
          {"state", FieldValue::String("CA")},
          {"country", FieldValue::String("USA")}})
    .OnCompletion([](const Future<void>& future) {
      if (future.error() == Error::kErrorOk) {
        std::cout << "DocumentSnapshot successfully written!" << std::endl;
      } else {
        std::cout << "Error writing document: " << future.error_message()
                  << std::endl;
      }
    });
Node.js

השתמש בשיטת set() :

const data = {
  name: 'Los Angeles',
  state: 'CA',
  country: 'USA'
};

// Add a new document in collection "cities" with ID 'LA'
const res = await db.collection('cities').doc('LA').set(data);
ללכת

השתמש בשיטת Set() :

_, err := client.Collection("cities").Doc("LA").Set(ctx, map[string]interface{}{
	"name":    "Los Angeles",
	"state":   "CA",
	"country": "USA",
})
if err != nil {
	// Handle any errors in an appropriate way, such as returning them.
	log.Printf("An error has occurred: %s", err)
}
PHP

השתמש בשיטת set() :

PHP

למידע נוסף על התקנה ויצירה של לקוח Cloud Firestore, עיין בספריות לקוח Cloud Firestore .

$data = [
    'name' => 'Los Angeles',
    'state' => 'CA',
    'country' => 'USA'
];
$db->collection('samples/php/cities')->document('LA')->set($data);
אַחְדוּת

השתמש בשיטת SetAsync() :

DocumentReference docRef = db.Collection("cities").Document("LA");
Dictionary<string, object> city = new Dictionary<string, object>
{
	{ "Name", "Los Angeles" },
	{ "State", "CA" },
	{ "Country", "USA" }
};
docRef.SetAsync(city).ContinueWithOnMainThread(task => {
	Debug.Log("Added data to the LA document in the cities collection.");
});
C#

השתמש בשיטת SetAsync() :

C#

למידע נוסף על התקנה ויצירה של לקוח Cloud Firestore, עיין בספריות לקוח Cloud Firestore .

DocumentReference docRef = db.Collection("cities").Document("LA");
Dictionary<string, object> city = new Dictionary<string, object>
{
    { "name", "Los Angeles" },
    { "state", "CA" },
    { "country", "USA" }
};
await docRef.SetAsync(city);
אוֹדֶם

השתמש בשיטת set() :

city_ref = firestore.doc "#{collection_path}/LA"

data = {
  name:    "Los Angeles",
  state:   "CA",
  country: "USA"
}

city_ref.set data

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

Web version 9

import { doc, setDoc } from "firebase/firestore"; 

const cityRef = doc(db, 'cities', 'BJ');
setDoc(cityRef, { capital: true }, { merge: true });

Web version 8

var cityRef = db.collection('cities').doc('BJ');

var setWithMerge = cityRef.set({
    capital: true
}, { merge: true });
מָהִיר
הערה: מוצר זה אינו זמין ביעדי watchOS ו-App Clip.
// Update one field, creating the document if it does not exist.
db.collection("cities").document("BJ").setData([ "capital": true ], merge: true)
Objective-C
הערה: מוצר זה אינו זמין ביעדי watchOS ו-App Clip.
// Write to the document reference, merging data with existing
// if the document already exists
[[[self.db collectionWithPath:@"cities"] documentWithPath:@"BJ"]
     setData:@{ @"capital": @YES }
     merge:YES
     completion:^(NSError * _Nullable error) {
       // ...
     }];

Java

// Update one field, creating the document if it does not already exist.
Map<String, Object> data = new HashMap<>();
data.put("capital", true);

db.collection("cities").document("BJ")
        .set(data, SetOptions.merge());

Kotlin+KTX

// Update one field, creating the document if it does not already exist.
val data = hashMapOf("capital" to true)

db.collection("cities").document("BJ")
        .set(data, SetOptions.merge())

Dart

// Update one field, creating the document if it does not already exist.
final data = {"capital": true};

db.collection("cities").doc("BJ").set(data, SetOptions(merge: true));
Java
// asynchronously update doc, create the document if missing
Map<String, Object> update = new HashMap<>();
update.put("capital", true);

ApiFuture<WriteResult> writeResult =
    db.collection("cities").document("BJ").set(update, SetOptions.merge());
// ...
System.out.println("Update time : " + writeResult.get().getUpdateTime());
פִּיתוֹן
city_ref = db.collection(u'cities').document(u'BJ')

city_ref.set({
    u'capital': True
}, merge=True)

Python

city_ref = db.collection("cities").document("BJ")

await city_ref.set({"capital": True}, merge=True)
C++
db->Collection("cities").Document("BJ").Set(
    {{"capital", FieldValue::Boolean(true)}}, SetOptions::Merge());
Node.js
const cityRef = db.collection('cities').doc('BJ');

const res = await cityRef.set({
  capital: true
}, { merge: true });
ללכת
_, err := client.Collection("cities").Doc("BJ").Set(ctx, map[string]interface{}{
	"capital": true,
}, firestore.MergeAll)

if err != nil {
	// Handle any errors in an appropriate way, such as returning them.
	log.Printf("An error has occurred: %s", err)
}
PHP

PHP

למידע נוסף על התקנה ויצירה של לקוח Cloud Firestore, עיין בספריות לקוח Cloud Firestore .

$cityRef = $db->collection('samples/php/cities')->document('BJ');
$cityRef->set([
    'capital' => true
], ['merge' => true]);
אַחְדוּת
DocumentReference docRef = db.Collection("cities").Document("LA");
Dictionary<string, object> update = new Dictionary<string, object>
{
	{ "capital", false }
};
docRef.SetAsync(update, SetOptions.MergeAll);
C#

C#

למידע נוסף על התקנה ויצירה של לקוח Cloud Firestore, עיין בספריות לקוח Cloud Firestore .

DocumentReference docRef = db.Collection("cities").Document("LA");
Dictionary<string, object> update = new Dictionary<string, object>
{
    { "capital", false }
};
await docRef.SetAsync(update, SetOptions.MergeAll);
אוֹדֶם
city_ref = firestore.doc "#{collection_path}/LA"
city_ref.set({ capital: false }, merge: true)

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

סוגי מידע

Cloud Firestore מאפשר לך לכתוב מגוון סוגי נתונים בתוך מסמך, כולל מחרוזות, בוליאנים, מספרים, תאריכים, null ומערכים ואובייקטים מקוננים. Cloud Firestore תמיד מאחסנת מספרים כפולים, ללא קשר לסוג המספר שבו אתה משתמש בקוד שלך.

Web version 9

import { doc, setDoc, Timestamp } from "firebase/firestore"; 

const docData = {
    stringExample: "Hello world!",
    booleanExample: true,
    numberExample: 3.14159265,
    dateExample: Timestamp.fromDate(new Date("December 10, 1815")),
    arrayExample: [5, true, "hello"],
    nullExample: null,
    objectExample: {
        a: 5,
        b: {
            nested: "foo"
        }
    }
};
await setDoc(doc(db, "data", "one"), docData);

Web version 8

var docData = {
    stringExample: "Hello world!",
    booleanExample: true,
    numberExample: 3.14159265,
    dateExample: firebase.firestore.Timestamp.fromDate(new Date("December 10, 1815")),
    arrayExample: [5, true, "hello"],
    nullExample: null,
    objectExample: {
        a: 5,
        b: {
            nested: "foo"
        }
    }
};
db.collection("data").doc("one").set(docData).then(() => {
    console.log("Document successfully written!");
});
מָהִיר
הערה: מוצר זה אינו זמין ביעדי watchOS ו-App Clip.
let docData: [String: Any] = [
    "stringExample": "Hello world!",
    "booleanExample": true,
    "numberExample": 3.14159265,
    "dateExample": Timestamp(date: Date()),
    "arrayExample": [5, true, "hello"],
    "nullExample": NSNull(),
    "objectExample": [
        "a": 5,
        "b": [
            "nested": "foo"
        ]
    ]
]
db.collection("data").document("one").setData(docData) { err in
    if let err = err {
        print("Error writing document: \(err)")
    } else {
        print("Document successfully written!")
    }
}
Objective-C
הערה: מוצר זה אינו זמין ביעדי watchOS ו-App Clip.
NSDictionary *docData = @{
  @"stringExample": @"Hello world!",
  @"booleanExample": @YES,
  @"numberExample": @3.14,
  @"dateExample": [FIRTimestamp timestampWithDate:[NSDate date]],
  @"arrayExample": @[@5, @YES, @"hello"],
  @"nullExample": [NSNull null],
  @"objectExample": @{
    @"a": @5,
    @"b": @{
      @"nested": @"foo"
    }
  }
};

[[[self.db collectionWithPath:@"data"] documentWithPath:@"one"] setData:docData
    completion:^(NSError * _Nullable error) {
      if (error != nil) {
        NSLog(@"Error writing document: %@", error);
      } else {
        NSLog(@"Document successfully written!");
      }
    }];

Java

Map<String, Object> docData = new HashMap<>();
docData.put("stringExample", "Hello world!");
docData.put("booleanExample", true);
docData.put("numberExample", 3.14159265);
docData.put("dateExample", new Timestamp(new Date()));
docData.put("listExample", Arrays.asList(1, 2, 3));
docData.put("nullExample", null);

Map<String, Object> nestedData = new HashMap<>();
nestedData.put("a", 5);
nestedData.put("b", true);

docData.put("objectExample", nestedData);

db.collection("data").document("one")
        .set(docData)
        .addOnSuccessListener(new OnSuccessListener<Void>() {
            @Override
            public void onSuccess(Void aVoid) {
                Log.d(TAG, "DocumentSnapshot successfully written!");
            }
        })
        .addOnFailureListener(new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                Log.w(TAG, "Error writing document", e);
            }
        });

Kotlin+KTX

val docData = hashMapOf(
        "stringExample" to "Hello world!",
        "booleanExample" to true,
        "numberExample" to 3.14159265,
        "dateExample" to Timestamp(Date()),
        "listExample" to arrayListOf(1, 2, 3),
        "nullExample" to null
)

val nestedData = hashMapOf(
        "a" to 5,
        "b" to true
)

docData["objectExample"] = nestedData

db.collection("data").document("one")
        .set(docData)
        .addOnSuccessListener { Log.d(TAG, "DocumentSnapshot successfully written!") }
        .addOnFailureListener { e -> Log.w(TAG, "Error writing document", e) }

Dart

final docData = {
  "stringExample": "Hello world!",
  "booleanExample": true,
  "numberExample": 3.14159265,
  "dateExample": Timestamp.now(),
  "listExample": [1, 2, 3],
  "nullExample": null
};

final nestedData = {
  "a": 5,
  "b": true,
};

docData["objectExample"] = nestedData;

db
    .collection("data")
    .doc("one")
    .set(docData)
    .onError((e, _) => print("Error writing document: $e"));
Java
Map<String, Object> docData = new HashMap<>();
docData.put("stringExample", "Hello, World");
docData.put("booleanExample", false);
docData.put("numberExample", 3.14159265);
docData.put("nullExample", null);

ArrayList<Object> arrayExample = new ArrayList<>();
Collections.addAll(arrayExample, 5L, true, "hello");
docData.put("arrayExample", arrayExample);

Map<String, Object> objectExample = new HashMap<>();
objectExample.put("a", 5L);
objectExample.put("b", true);

docData.put("objectExample", objectExample);

ApiFuture<WriteResult> future = db.collection("data").document("one").set(docData);
System.out.println("Update time : " + future.get().getUpdateTime());
פִּיתוֹן
data = {
    u'stringExample': u'Hello, World!',
    u'booleanExample': True,
    u'numberExample': 3.14159265,
    u'dateExample': datetime.datetime.now(tz=datetime.timezone.utc),
    u'arrayExample': [5, True, u'hello'],
    u'nullExample': None,
    u'objectExample': {
        u'a': 5,
        u'b': True
    }
}

db.collection(u'data').document(u'one').set(data)

Python

data = {
    "stringExample": "Hello, World!",
    "booleanExample": True,
    "numberExample": 3.14159265,
    "dateExample": datetime.datetime.now(tz=datetime.timezone.utc),
    "arrayExample": [5, True, "hello"],
    "nullExample": None,
    "objectExample": {"a": 5, "b": True},
}

await db.collection("data").document("one").set(data)
C++
MapFieldValue doc_data{
    {"stringExample", FieldValue::String("Hello world!")},
    {"booleanExample", FieldValue::Boolean(true)},
    {"numberExample", FieldValue::Double(3.14159265)},
    {"dateExample", FieldValue::Timestamp(Timestamp::Now())},
    {"arrayExample", FieldValue::Array({FieldValue::Integer(1),
                                        FieldValue::Integer(2),
                                        FieldValue::Integer(3)})},
    {"nullExample", FieldValue::Null()},
    {"objectExample",
     FieldValue::Map(
         {{"a", FieldValue::Integer(5)},
          {"b", FieldValue::Map(
                    {{"nested", FieldValue::String("foo")}})}})},
};

db->Collection("data").Document("one").Set(doc_data).OnCompletion(
    [](const Future<void>& future) {
      if (future.error() == Error::kErrorOk) {
        std::cout << "DocumentSnapshot successfully written!" << std::endl;
      } else {
        std::cout << "Error writing document: " << future.error_message()
                  << std::endl;
      }
    });
Node.js
const data = {
  stringExample: 'Hello, World!',
  booleanExample: true,
  numberExample: 3.14159265,
  dateExample: Timestamp.fromDate(new Date('December 10, 1815')),
  arrayExample: [5, true, 'hello'],
  nullExample: null,
  objectExample: {
    a: 5,
    b: true
  }
};

const res = await db.collection('data').doc('one').set(data);
ללכת
doc := make(map[string]interface{})
doc["stringExample"] = "Hello world!"
doc["booleanExample"] = true
doc["numberExample"] = 3.14159265
doc["dateExample"] = time.Now()
doc["arrayExample"] = []interface{}{5, true, "hello"}
doc["nullExample"] = nil
doc["objectExample"] = map[string]interface{}{
	"a": 5,
	"b": true,
}

_, err := client.Collection("data").Doc("one").Set(ctx, doc)
if err != nil {
	// Handle any errors in an appropriate way, such as returning them.
	log.Printf("An error has occurred: %s", err)
}
PHP

PHP

למידע נוסף על התקנה ויצירה של לקוח Cloud Firestore, עיין בספריות לקוח Cloud Firestore .

$data = [
    'stringExample' => 'Hello World',
    'booleanExample' => true,
    'numberExample' => 3.14159265,
    'dateExample' => new Timestamp(new DateTime()),
    'arrayExample' => array(5, true, 'hello'),
    'nullExample' => null,
    'objectExample' => ['a' => 5, 'b' => true],
    'documentReferenceExample' => $db->collection('samples/php/data')->document('two'),
];
$db->collection('samples/php/data')->document('one')->set($data);
printf('Set multiple data-type data for the one document in the data collection.' . PHP_EOL);
אַחְדוּת
DocumentReference docRef = db.Collection("data").Document("one");
Dictionary<string, object> docData = new Dictionary<string, object>
{
	{ "stringExample", "Hello World" },
	{ "booleanExample", false },
	{ "numberExample", 3.14159265 },
	{ "nullExample", null },
	{ "arrayExample", new List<object>() { 5, true, "Hello" } },
	{ "objectExample", new Dictionary<string, object>
		{
			{ "a", 5 },
			{ "b", true },
		}
	},
};

docRef.SetAsync(docData);
C#

C#

למידע נוסף על התקנה ויצירה של לקוח Cloud Firestore, עיין בספריות לקוח Cloud Firestore .

DocumentReference docRef = db.Collection("data").Document("one");
Dictionary<string, object> docData = new Dictionary<string, object>
{
    { "stringExample", "Hello World" },
    { "booleanExample", false },
    { "numberExample", 3.14159265 },
    { "nullExample", null },
};

ArrayList arrayExample = new ArrayList();
arrayExample.Add(5);
arrayExample.Add(true);
arrayExample.Add("Hello");
docData.Add("arrayExample", arrayExample);

Dictionary<string, object> objectExample = new Dictionary<string, object>
{
    { "a", 5 },
    { "b", true },
};
docData.Add("objectExample", objectExample);

await docRef.SetAsync(docData);
אוֹדֶם
doc_ref = firestore.doc "#{collection_path}/one"

data = {
  stringExample:  "Hello, World!",
  booleanExample: true,
  numberExample:  3.14159265,
  dateExample:    DateTime.now,
  arrayExample:   [5, true, "hello"],
  nullExample:    nil,
  objectExample:  {
    a: 5,
    b: true
  }
}

doc_ref.set data

אובייקטים מותאמים אישית

השימוש באובייקטי Map או Dictionary לייצוג המסמכים שלך לרוב אינו נוח במיוחד, לכן Cloud Firestore תומכת בכתיבת מסמכים עם מחלקות מותאמות אישית. Cloud Firestore ממירה את האובייקטים לסוגי נתונים נתמכים.

באמצעות שיעורים מותאמים אישית, תוכל לשכתב את הדוגמה הראשונית כפי שמוצג:

Web version 9

class City {
    constructor (name, state, country ) {
        this.name = name;
        this.state = state;
        this.country = country;
    }
    toString() {
        return this.name + ', ' + this.state + ', ' + this.country;
    }
}

// Firestore data converter
const cityConverter = {
    toFirestore: (city) => {
        return {
            name: city.name,
            state: city.state,
            country: city.country
            };
    },
    fromFirestore: (snapshot, options) => {
        const data = snapshot.data(options);
        return new City(data.name, data.state, data.country);
    }
};

Web version 8

class City {
    constructor (name, state, country ) {
        this.name = name;
        this.state = state;
        this.country = country;
    }
    toString() {
        return this.name + ', ' + this.state + ', ' + this.country;
    }
}

// Firestore data converter
var cityConverter = {
    toFirestore: function(city) {
        return {
            name: city.name,
            state: city.state,
            country: city.country
            };
    },
    fromFirestore: function(snapshot, options){
        const data = snapshot.data(options);
        return new City(data.name, data.state, data.country);
    }
};
מָהִיר
הערה: מוצר זה אינו זמין ביעדי watchOS ו-App Clip.
public struct City: Codable {

    let name: String
    let state: String?
    let country: String?
    let isCapital: Bool?
    let population: Int64?

    enum CodingKeys: String, CodingKey {
        case name
        case state
        case country
        case isCapital = "capital"
        case population
    }

}
Objective-C
הערה: מוצר זה אינו זמין ביעדי watchOS ו-App Clip.
// This isn't supported in Objective-C.
  

Java

לכל מחלקה מותאמת אישית חייב להיות בנאי ציבורי שאינו לוקח ארגומנטים. בנוסף, הכיתה חייבת לכלול מגבר ציבורי לכל נכס.

public class City {


    private String name;
    private String state;
    private String country;
    private boolean capital;
    private long population;
    private List<String> regions;

    public City() {}

    public City(String name, String state, String country, boolean capital, long population, List<String> regions) {
        // ...
    }

    public String getName() {
        return name;
    }

    public String getState() {
        return state;
    }

    public String getCountry() {
        return country;
    }

    public boolean isCapital() {
        return capital;
    }

    public long getPopulation() {
        return population;
    }

    public List<String> getRegions() {
        return regions;
    }

}

Kotlin+KTX

data class City(
    val name: String? = null,
    val state: String? = null,
    val country: String? = null,
    @field:JvmField // use this annotation if your Boolean field is prefixed with 'is'
    val isCapital: Boolean? = null,
    val population: Long? = null,
    val regions: List<String>? = null
)

Dart

class City {
  final String? name;
  final String? state;
  final String? country;
  final bool? capital;
  final int? population;
  final List<String>? regions;

  City({
    this.name,
    this.state,
    this.country,
    this.capital,
    this.population,
    this.regions,
  });

  factory City.fromFirestore(
    DocumentSnapshot<Map<String, dynamic>> snapshot,
    SnapshotOptions? options,
  ) {
    final data = snapshot.data();
    return City(
      name: data?['name'],
      state: data?['state'],
      country: data?['country'],
      capital: data?['capital'],
      population: data?['population'],
      regions:
          data?['regions'] is Iterable ? List.from(data?['regions']) : null,
    );
  }

  Map<String, dynamic> toFirestore() {
    return {
      if (name != null) "name": name,
      if (state != null) "state": state,
      if (country != null) "country": country,
      if (capital != null) "capital": capital,
      if (population != null) "population": population,
      if (regions != null) "regions": regions,
    };
  }
}
Java
public City() {
  // Must have a public no-argument constructor
}

// Initialize all fields of a city
public City(
    String name,
    String state,
    String country,
    Boolean capital,
    Long population,
    List<String> regions) {
  this.name = name;
  this.state = state;
  this.country = country;
  this.capital = capital;
  this.population = population;
  this.regions = regions;
}
פִּיתוֹן
class City(object):
    def __init__(self, name, state, country, capital=False, population=0,
                 regions=[]):
        self.name = name
        self.state = state
        self.country = country
        self.capital = capital
        self.population = population
        self.regions = regions

    @staticmethod
    def from_dict(source):
        # ...

    def to_dict(self):
        # ...

    def __repr__(self):
        return (
            f'City(\
                name={self.name}, \
                country={self.country}, \
                population={self.population}, \
                capital={self.capital}, \
                regions={self.regions}\
            )'
        )

Python

class City(object):
    def __init__(self, name, state, country, capital=False, population=0, regions=[]):
        self.name = name
        self.state = state
        self.country = country
        self.capital = capital
        self.population = population
        self.regions = regions

    @staticmethod
    def from_dict(source):
        # ...

    def to_dict(self):
        # ...

    def __repr__(self):
        return f"City(\
                name={self.name}, \
                country={self.country}, \
                population={self.population}, \
                capital={self.capital}, \
                regions={self.regions}\
            )"
C++
// This is not yet supported.
Node.js
// Node.js uses JavaScript objects
ללכת

// City represents a city.
type City struct {
	Name       string   `firestore:"name,omitempty"`
	State      string   `firestore:"state,omitempty"`
	Country    string   `firestore:"country,omitempty"`
	Capital    bool     `firestore:"capital,omitempty"`
	Population int64    `firestore:"population,omitempty"`
	Regions    []string `firestore:"regions,omitempty"`
}
PHP

PHP

למידע נוסף על התקנה ויצירה של לקוח Cloud Firestore, עיין בספריות לקוח Cloud Firestore .

class City
{
    /* var string */
    public $name;
    /* var string */
    public $state;
    /* var string */
    public $country;
    /* var bool */
    public $capital;
    /* var int */
    public $population;
    /* var array */
    public $regions;

    public function __construct(
        string $name,
        string $state,
        string $country,
        bool $capital = false,
        int $population = 0,
        array $regions = []
    ) {
        $this->name = $name;
        $this->state = $state;
        $this->country = $country;
        $this->capital = $capital;
        $this->population = $population;
        $this->regions = $regions;
    }

    public static function fromArray(array $source): City
    {
        // implementation of fromArray is excluded for brevity
        # ...
    }

    public function toArray(): array
    {
        // implementation of toArray is excluded for brevity
        # ...
    }

    public function __toString()
    {
        // implementation of __toString is excluded for brevity
        # ...
    }
}
אַחְדוּת
[FirestoreData]
public class City
{
	[FirestoreProperty]
	public string Name { get; set; }

	[FirestoreProperty]
	public string State { get; set; }

	[FirestoreProperty]
	public string Country { get; set; }

	[FirestoreProperty]
	public bool Capital { get; set; }

	[FirestoreProperty]
	public long Population { get; set; }
}
C#

C#

למידע נוסף על התקנה ויצירה של לקוח Cloud Firestore, עיין בספריות לקוח Cloud Firestore .

[FirestoreData]
public class City
{
    [FirestoreProperty]
    public string Name { get; set; }

    [FirestoreProperty]
    public string State { get; set; }

    [FirestoreProperty]
    public string Country { get; set; }

    [FirestoreProperty]
    public bool Capital { get; set; }

    [FirestoreProperty]
    public long Population { get; set; }
}
אוֹדֶם
// This isn't supported in Ruby

Web version 9

import { doc, setDoc } from "firebase/firestore"; 

// Set with cityConverter
const ref = doc(db, "cities", "LA").withConverter(cityConverter);
await setDoc(ref, new City("Los Angeles", "CA", "USA"));

Web version 8

// Set with cityConverter
db.collection("cities").doc("LA")
  .withConverter(cityConverter)
  .set(new City("Los Angeles", "CA", "USA"));
מָהִיר
הערה: מוצר זה אינו זמין ביעדי watchOS ו-App Clip.
let city = City(name: "Los Angeles",
                state: "CA",
                country: "USA",
                isCapital: false,
                population: 5000000)

do {
    try db.collection("cities").document("LA").setData(from: city)
} catch let error {
    print("Error writing city to Firestore: \(error)")
}
Objective-C
הערה: מוצר זה אינו זמין ביעדי watchOS ו-App Clip.
// This isn't supported in Objective-C.
  

Java

City city = new City("Los Angeles", "CA", "USA",
        false, 5000000L, Arrays.asList("west_coast", "sorcal"));
db.collection("cities").document("LA").set(city);

Kotlin+KTX

val city = City("Los Angeles", "CA", "USA",
        false, 5000000L, listOf("west_coast", "socal"))
db.collection("cities").document("LA").set(city)

Dart

final city = City(
  name: "Los Angeles",
  state: "CA",
  country: "USA",
  capital: false,
  population: 5000000,
  regions: ["west_coast", "socal"],
);
final docRef = db
    .collection("cities")
    .withConverter(
      fromFirestore: City.fromFirestore,
      toFirestore: (City city, options) => city.toFirestore(),
    )
    .doc("LA");
await docRef.set(city);
Java
City city =
    new City("Los Angeles", "CA", "USA", false, 3900000L, Arrays.asList("west_coast", "socal"));
ApiFuture<WriteResult> future = db.collection("cities").document("LA").set(city);
// block on response if required
System.out.println("Update time : " + future.get().getUpdateTime());
פִּיתוֹן
city = City(name=u'Los Angeles', state=u'CA', country=u'USA')
db.collection(u'cities').document(u'LA').set(city.to_dict())

Python

city = City(name="Los Angeles", state="CA", country="USA")
await db.collection("cities").document("LA").set(city.to_dict())
C++
// This is not yet supported.
Node.js
// Node.js uses JavaScript objects
ללכת
city := City{
	Name:    "Los Angeles",
	Country: "USA",
}
_, err := client.Collection("cities").Doc("LA").Set(ctx, city)
if err != nil {
	// Handle any errors in an appropriate way, such as returning them.
	log.Printf("An error has occurred: %s", err)
}
PHP
// This isn't supported in PHP.
אַחְדוּת
DocumentReference docRef = db.Collection("cities").Document("LA");
City city = new City
{
	Name = "Los Angeles",
	State = "CA",
	Country = "USA",
	Capital = false,
	Population = 3900000L
};
docRef.SetAsync(city);
C#

C#

למידע נוסף על התקנה ויצירה של לקוח Cloud Firestore, עיין בספריות לקוח Cloud Firestore .

DocumentReference docRef = db.Collection("cities").Document("LA");
City city = new City
{
    Name = "Los Angeles",
    State = "CA",
    Country = "USA",
    Capital = false,
    Population = 3900000L
};
await docRef.SetAsync(city);
אוֹדֶם
// This isn't supported in Ruby.

הוסף מסמך

כאשר אתה משתמש ב- set() כדי ליצור מסמך, עליך לציין מזהה עבור המסמך ליצירת. לדוגמה:

Web version 9

import { doc, setDoc } from "firebase/firestore"; 

await setDoc(doc(db, "cities", "new-city-id"), data);

Web version 8

db.collection("cities").doc("new-city-id").set(data);
מָהִיר
הערה: מוצר זה אינו זמין ביעדי watchOS ו-App Clip.
db.collection("cities").document("new-city-id").setData(data)
Objective-C
הערה: מוצר זה אינו זמין ביעדי watchOS ו-App Clip.
[[[self.db collectionWithPath:@"cities"] documentWithPath:@"new-city-id"]
    setData:data];

Java

db.collection("cities").document("new-city-id").set(data);

Kotlin+KTX

db.collection("cities").document("new-city-id").set(data)

Dart

db.collection("cities").doc("new-city-id").set({"name": "Chicago"});
Java
db.collection("cities").document("new-city-id").set(data);
פִּיתוֹן
db.collection(u'cities').document(u'new-city-id').set(data)

Python

await db.collection("cities").document("new-city-id").set(data)
C++
db->Collection("cities").Document("SF").Set({/*some data*/});
Node.js
await db.collection('cities').doc('new-city-id').set(data);
ללכת
_, err := client.Collection("cities").Doc("new-city-id").Set(ctx, data)
if err != nil {
	// Handle any errors in an appropriate way, such as returning them.
	log.Printf("An error has occurred: %s", err)
}
PHP

PHP

למידע נוסף על התקנה ויצירה של לקוח Cloud Firestore, עיין בספריות לקוח Cloud Firestore .

$db->collection('samples/php/cities')->document('new-city-id')->set($data);
אַחְדוּת
db.Collection("cities").Document("new-city-id").SetAsync(city);
C#

C#

למידע נוסף על התקנה ויצירה של לקוח Cloud Firestore, עיין בספריות לקוח Cloud Firestore .

await db.Collection("cities").Document("new-city-id").SetAsync(city);
אוֹדֶם
city_ref = firestore.doc "#{collection_path}/new-city-id"
city_ref.set data

אבל לפעמים אין מזהה משמעותי למסמך, ונוח יותר לתת ל-Cloud Firestore ליצור עבורך מזהה אוטומטית. אתה יכול לעשות זאת על ידי קריאה לשיטות add() הספציפיות לשפה הבאות:

Web version 9

השתמש בשיטת addDoc() :

import { collection, addDoc } from "firebase/firestore"; 

// Add a new document with a generated id.
const docRef = await addDoc(collection(db, "cities"), {
  name: "Tokyo",
  country: "Japan"
});
console.log("Document written with ID: ", docRef.id);

Web version 8

השתמש בשיטת add() :

// Add a new document with a generated id.
db.collection("cities").add({
    name: "Tokyo",
    country: "Japan"
})
.then((docRef) => {
    console.log("Document written with ID: ", docRef.id);
})
.catch((error) => {
    console.error("Error adding document: ", error);
});
מָהִיר

השתמש בשיטת addDocument() :

הערה: מוצר זה אינו זמין ביעדי watchOS ו-App Clip.
// Add a new document with a generated id.
var ref: DocumentReference? = nil
ref = db.collection("cities").addDocument(data: [
    "name": "Tokyo",
    "country": "Japan"
]) { err in
    if let err = err {
        print("Error adding document: \(err)")
    } else {
        print("Document added with ID: \(ref!.documentID)")
    }
}
Objective-C

השתמש בשיטת addDocumentWithData: ::

הערה: מוצר זה אינו זמין ביעדי watchOS ו-App Clip.
// Add a new document with a generated id.
__block FIRDocumentReference *ref =
    [[self.db collectionWithPath:@"cities"] addDocumentWithData:@{
      @"name": @"Tokyo",
      @"country": @"Japan"
    } completion:^(NSError * _Nullable error) {
      if (error != nil) {
        NSLog(@"Error adding document: %@", error);
      } else {
        NSLog(@"Document added with ID: %@", ref.documentID);
      }
    }];

Java

השתמש בשיטת add() :

// Add a new document with a generated id.
Map<String, Object> data = new HashMap<>();
data.put("name", "Tokyo");
data.put("country", "Japan");

db.collection("cities")
        .add(data)
        .addOnSuccessListener(new OnSuccessListener<DocumentReference>() {
            @Override
            public void onSuccess(DocumentReference documentReference) {
                Log.d(TAG, "DocumentSnapshot written with ID: " + documentReference.getId());
            }
        })
        .addOnFailureListener(new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                Log.w(TAG, "Error adding document", e);
            }
        });

Kotlin+KTX

השתמש בשיטת add() :

// Add a new document with a generated id.
val data = hashMapOf(
        "name" to "Tokyo",
        "country" to "Japan"
)

db.collection("cities")
    .add(data)
    .addOnSuccessListener { documentReference ->
        Log.d(TAG, "DocumentSnapshot written with ID: ${documentReference.id}")
    }
    .addOnFailureListener { e ->
        Log.w(TAG, "Error adding document", e)
    }

Dart

השתמש בשיטת add() :

// Add a new document with a generated id.
final data = {"name": "Tokyo", "country": "Japan"};

db.collection("cities").add(data).then((documentSnapshot) =>
    print("Added Data with ID: ${documentSnapshot.id}"));
Java

השתמש בשיטת add() :

// Add document data with auto-generated id.
Map<String, Object> data = new HashMap<>();
data.put("name", "Tokyo");
data.put("country", "Japan");
ApiFuture<DocumentReference> addedDocRef = db.collection("cities").add(data);
System.out.println("Added document with ID: " + addedDocRef.get().getId());
פִּיתוֹן

השתמש בשיטת add() :

city = {
    u'name': u'Tokyo',
    u'country': u'Japan'
}
update_time, city_ref = db.collection(u'cities').add(city)
print(f'Added document with id {city_ref.id}')

Python

השתמש בשיטת add() :

city = City(name="Tokyo", state=None, country="Japan")
await db.collection("cities").add(city.to_dict())
C++

השתמש בשיטת Add() :

db->Collection("cities").Add({/*some data*/});
Node.js

השתמש בשיטת add() :

// Add a new document with a generated id.
const res = await db.collection('cities').add({
  name: 'Tokyo',
  country: 'Japan'
});

console.log('Added document with ID: ', res.id);
ללכת

השתמש בשיטת Add() :

_, _, err := client.Collection("cities").Add(ctx, map[string]interface{}{
	"name":    "Tokyo",
	"country": "Japan",
})
if err != nil {
	// Handle any errors in an appropriate way, such as returning them.
	log.Printf("An error has occurred: %s", err)
}
PHP

השתמש בשיטת add() :

PHP

למידע נוסף על התקנה ויצירה של לקוח Cloud Firestore, עיין בספריות לקוח Cloud Firestore .

$data = [
    'name' => 'Tokyo',
    'country' => 'Japan'
];
$addedDocRef = $db->collection('samples/php/cities')->add($data);
printf('Added document with ID: %s' . PHP_EOL, $addedDocRef->id());
אַחְדוּת

השתמש בשיטת AddAsync() :

Dictionary<string, object> city = new Dictionary<string, object>
{
	{ "Name", "Tokyo" },
	{ "Country", "Japan" }
};
db.Collection("cities").AddAsync(city).ContinueWithOnMainThread(task => {
	DocumentReference addedDocRef = task.Result;
	Debug.Log(String.Format("Added document with ID: {0}.", addedDocRef.Id));
});
C#

השתמש בשיטת AddAsync() :

C#

למידע נוסף על התקנה ויצירה של לקוח Cloud Firestore, עיין בספריות לקוח Cloud Firestore .

Dictionary<string, object> city = new Dictionary<string, object>
{
    { "Name", "Tokyo" },
    { "Country", "Japan" }
};
DocumentReference addedDocRef = await db.Collection("cities").AddAsync(city);
Console.WriteLine("Added document with ID: {0}.", addedDocRef.Id);
אוֹדֶם

השתמש בשיטת add() :

data = {
  name:    "Tokyo",
  country: "Japan"
}

cities_ref = firestore.col collection_path

added_doc_ref = cities_ref.add data
puts "Added document with ID: #{added_doc_ref.document_id}."

במקרים מסוימים, זה יכול להיות שימושי ליצור הפניה למסמך עם מזהה שנוצר אוטומטית, ולאחר מכן להשתמש בהפניה מאוחר יותר. למקרה שימוש זה, אתה יכול לקרוא doc() :

Web version 9

import { collection, doc, setDoc } from "firebase/firestore"; 

// Add a new document with a generated id
const newCityRef = doc(collection(db, "cities"));

// later...
await setDoc(newCityRef, data);

Web version 8

// Add a new document with a generated id.
var newCityRef = db.collection("cities").doc();

// later...
newCityRef.set(data);
מָהִיר
הערה: מוצר זה אינו זמין ביעדי watchOS ו-App Clip.
let newCityRef = db.collection("cities").document()

// later...
newCityRef.setData([
    // ...
])
Objective-C
הערה: מוצר זה אינו זמין ביעדי watchOS ו-App Clip.
FIRDocumentReference *newCityRef = [[self.db collectionWithPath:@"cities"] documentWithAutoID];
// later...
[newCityRef setData:@{ /* ... */ }];

Java

Map<String, Object> data = new HashMap<>();

DocumentReference newCityRef = db.collection("cities").document();

// Later...
newCityRef.set(data);

Kotlin+KTX

val data = HashMap<String, Any>()

val newCityRef = db.collection("cities").document()

// Later...
newCityRef.set(data)

Dart

// Add a new document with a generated id.
final data = <String, dynamic>{};

final newCityRef = db.collection("cities").doc();

// Later...
newCityRef.set(data);
Java
// Add document data after generating an id.
DocumentReference addedDocRef = db.collection("cities").document();
System.out.println("Added document with ID: " + addedDocRef.getId());

// later...
ApiFuture<WriteResult> writeResult = addedDocRef.set(data);
פִּיתוֹן
new_city_ref = db.collection(u'cities').document()

# later...
new_city_ref.set({
    # ...
})

Python

new_city_ref = db.collection("cities").document()

# later...
await new_city_ref.set(
    {
        # ...
    }
)
C++
DocumentReference new_city_ref = db->Collection("cities").Document();
Node.js
const newCityRef = db.collection('cities').doc();

// Later...
const res = await newCityRef.set({
  // ...
});
ללכת
ref := client.Collection("cities").NewDoc()

// later...
_, err := ref.Set(ctx, data)
if err != nil {
	// Handle any errors in an appropriate way, such as returning them.
	log.Printf("An error has occurred: %s", err)
}
PHP

PHP

למידע נוסף על התקנה ויצירה של לקוח Cloud Firestore, עיין בספריות לקוח Cloud Firestore .

$addedDocRef = $db->collection('samples/php/cities')->newDocument();
printf('Added document with ID: %s' . PHP_EOL, $addedDocRef->id());
$addedDocRef->set($data);
אַחְדוּת
DocumentReference addedDocRef = db.Collection("cities").Document();
Debug.Log(String.Format("Added document with ID: {0}.", addedDocRef.Id));
addedDocRef.SetAsync(city).ContinueWithOnMainThread(task => {
	Debug.Log(String.Format(
		"Added data to the {0} document in the cities collection.", addedDocRef.Id));
});
C#

C#

למידע נוסף על התקנה ויצירה של לקוח Cloud Firestore, עיין בספריות לקוח Cloud Firestore .

DocumentReference addedDocRef = db.Collection("cities").Document();
Console.WriteLine("Added document with ID: {0}.", addedDocRef.Id);
await addedDocRef.SetAsync(city);
אוֹדֶם
cities_ref = firestore.col collection_path

added_doc_ref = cities_ref.doc
puts "Added document with ID: #{added_doc_ref.document_id}."

added_doc_ref.set data

מאחורי הקלעים, .add(...) ו- .doc().set(...) שקולות לחלוטין, כך שתוכלו להשתמש במה שנוח יותר.

עדכן מסמך

כדי לעדכן שדות מסוימים במסמך מבלי להחליף את המסמך כולו, השתמש בשיטות update() הספציפיות לשפה הבאות:

Web version 9

השתמש בשיטת updateDoc() :

import { doc, updateDoc } from "firebase/firestore";

const washingtonRef = doc(db, "cities", "DC");

// Set the "capital" field of the city 'DC'
await updateDoc(washingtonRef, {
  capital: true
});

Web version 8

השתמש בשיטת update() :

var washingtonRef = db.collection("cities").doc("DC");

// Set the "capital" field of the city 'DC'
return washingtonRef.update({
    capital: true
})
.then(() => {
    console.log("Document successfully updated!");
})
.catch((error) => {
    // The document probably doesn't exist.
    console.error("Error updating document: ", error);
});
מָהִיר

השתמש בשיטת updateData() :

הערה: מוצר זה אינו זמין ביעדי watchOS ו-App Clip.
let washingtonRef = db.collection("cities").document("DC")

// Set the "capital" field of the city 'DC'
washingtonRef.updateData([
    "capital": true
]) { err in
    if let err = err {
        print("Error updating document: \(err)")
    } else {
        print("Document successfully updated")
    }
}
Objective-C

השתמש בשיטת updateData: ::

הערה: מוצר זה אינו זמין ביעדי watchOS ו-App Clip.
FIRDocumentReference *washingtonRef =
    [[self.db collectionWithPath:@"cities"] documentWithPath:@"DC"];
// Set the "capital" field of the city
[washingtonRef updateData:@{
  @"capital": @YES
} completion:^(NSError * _Nullable error) {
  if (error != nil) {
    NSLog(@"Error updating document: %@", error);
  } else {
    NSLog(@"Document successfully updated");
  }
}];

Java

השתמש בשיטת update() :

DocumentReference washingtonRef = db.collection("cities").document("DC");

// Set the "isCapital" field of the city 'DC'
washingtonRef
        .update("capital", true)
        .addOnSuccessListener(new OnSuccessListener<Void>() {
            @Override
            public void onSuccess(Void aVoid) {
                Log.d(TAG, "DocumentSnapshot successfully updated!");
            }
        })
        .addOnFailureListener(new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                Log.w(TAG, "Error updating document", e);
            }
        });

Kotlin+KTX

השתמש בשיטת update() :

val washingtonRef = db.collection("cities").document("DC")

// Set the "isCapital" field of the city 'DC'
washingtonRef
        .update("capital", true)
        .addOnSuccessListener { Log.d(TAG, "DocumentSnapshot successfully updated!") }
        .addOnFailureListener { e -> Log.w(TAG, "Error updating document", e) }

Dart

השתמש בשיטת update() :

final washingtonRef = db.collection("cites").doc("DC");
washingtonRef.update({"capital": true}).then(
    (value) => print("DocumentSnapshot successfully updated!"),
    onError: (e) => print("Error updating document $e"));
Java

השתמש בשיטת update() :

// Update an existing document
DocumentReference docRef = db.collection("cities").document("DC");

// (async) Update one field
ApiFuture<WriteResult> future = docRef.update("capital", true);

// ...
WriteResult result = future.get();
System.out.println("Write result: " + result);
פִּיתוֹן

השתמש בשיטת update() :

city_ref = db.collection(u'cities').document(u'DC')

# Set the capital field
city_ref.update({u'capital': True})

Python

השתמש בשיטת update() :

city_ref = db.collection("cities").document("DC")

# Set the capital field
await city_ref.update({"capital": True})
C++

השתמש בשיטת Update() :

DocumentReference washington_ref = db->Collection("cities").Document("DC");
// Set the "capital" field of the city "DC".
washington_ref.Update({{"capital", FieldValue::Boolean(true)}});
Node.js

השתמש בשיטת update() :

const cityRef = db.collection('cities').doc('DC');

// Set the 'capital' field of the city
const res = await cityRef.update({capital: true});
ללכת

השתמש בשיטת Update() :

_, err = client.Collection("cities").Doc("DC").Update(ctx, []firestore.Update{
	{
		Path:  "capital",
		Value: true,
	},
})
if err != nil {
	// Handle any errors in an appropriate way, such as returning them.
	log.Printf("An error has occurred: %s", err)
}
PHP

השתמש בשיטת update() :

PHP

למידע נוסף על התקנה ויצירה של לקוח Cloud Firestore, עיין בספריות לקוח Cloud Firestore .

$cityRef = $db->collection('samples/php/cities')->document('DC');
$cityRef->update([
    ['path' => 'capital', 'value' => true]
]);
אַחְדוּת

השתמש בשיטת UpdateAsync() :

DocumentReference cityRef = db.Collection("cities").Document("new-city-id");
Dictionary<string, object> updates = new Dictionary<string, object>
{
	{ "Capital", false }
};

cityRef.UpdateAsync(updates).ContinueWithOnMainThread(task => {
	Debug.Log(
		"Updated the Capital field of the new-city-id document in the cities collection.");
});
// You can also update a single field with: cityRef.UpdateAsync("Capital", false);
C#

השתמש בשיטת UpdateAsync() :

C#

למידע נוסף על התקנה ויצירה של לקוח Cloud Firestore, עיין בספריות לקוח Cloud Firestore .

DocumentReference cityRef = db.Collection("cities").Document("new-city-id");
Dictionary<string, object> updates = new Dictionary<string, object>
{
    { "Capital", false }
};
await cityRef.UpdateAsync(updates);

// You can also update a single field with: await cityRef.UpdateAsync("Capital", false);
אוֹדֶם

השתמש בשיטת update() :

city_ref = firestore.doc "#{collection_path}/DC"
city_ref.update({ capital: true })

חותמת זמן של שרת

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

Web version 9

import { updateDoc, serverTimestamp } from "firebase/firestore";

const docRef = doc(db, 'objects', 'some-id');

// Update the timestamp field with the value from the server
const updateTimestamp = await updateDoc(docRef, {
    timestamp: serverTimestamp()
});

Web version 8

var docRef = db.collection('objects').doc('some-id');

// Update the timestamp field with the value from the server
var updateTimestamp = docRef.update({
    timestamp: firebase.firestore.FieldValue.serverTimestamp()
});
מָהִיר
הערה: מוצר זה אינו זמין ביעדי watchOS ו-App Clip.
db.collection("objects").document("some-id").updateData([
    "lastUpdated": FieldValue.serverTimestamp(),
]) { err in
    if let err = err {
        print("Error updating document: \(err)")
    } else {
        print("Document successfully updated")
    }
}
Objective-C
הערה: מוצר זה אינו זמין ביעדי watchOS ו-App Clip.
[[[self.db collectionWithPath:@"objects"] documentWithPath:@"some-id"] updateData:@{
  @"lastUpdated": [FIRFieldValue fieldValueForServerTimestamp]
} completion:^(NSError * _Nullable error) {
  if (error != nil) {
    NSLog(@"Error updating document: %@", error);
  } else {
    NSLog(@"Document successfully updated");
  }
}];

Java

// If you're using custom Java objects in Android, add an @ServerTimestamp
// annotation to a Date field for your custom object classes. This indicates
// that the Date field should be treated as a server timestamp by the object mapper.
DocumentReference docRef = db.collection("objects").document("some-id");

// Update the timestamp field with the value from the server
Map<String,Object> updates = new HashMap<>();
updates.put("timestamp", FieldValue.serverTimestamp());

docRef.update(updates).addOnCompleteListener(new OnCompleteListener<Void>() {
    // ...
    // ...

Kotlin+KTX

// If you're using custom Kotlin objects in Android, add an @ServerTimestamp
// annotation to a Date field for your custom object classes. This indicates
// that the Date field should be treated as a server timestamp by the object mapper.
val docRef = db.collection("objects").document("some-id")

// Update the timestamp field with the value from the server
val updates = hashMapOf<String, Any>(
        "timestamp" to FieldValue.serverTimestamp()
)

docRef.update(updates).addOnCompleteListener { }

Dart

final docRef = db.collection("objects").doc("some-id");
final updates = <String, dynamic>{
  "timestamp": FieldValue.serverTimestamp(),
};

docRef.update(updates).then(
    (value) => print("DocumentSnapshot successfully updated!"),
    onError: (e) => print("Error updating document $e"));
Java
DocumentReference docRef = db.collection("objects").document("some-id");
// Update the timestamp field with the value from the server
ApiFuture<WriteResult> writeResult = docRef.update("timestamp", FieldValue.serverTimestamp());
System.out.println("Update time : " + writeResult.get());
פִּיתוֹן
city_ref = db.collection(u'objects').document(u'some-id')
city_ref.update({
    u'timestamp': firestore.SERVER_TIMESTAMP
})

Python

city_ref = db.collection("objects").document("some-id")
await city_ref.update({"timestamp": firestore.SERVER_TIMESTAMP})
C++
DocumentReference doc_ref = db->Collection("objects").Document("some-id");
doc_ref.Update({{"timestamp", FieldValue::ServerTimestamp()}})
    .OnCompletion([](const Future<void>& future) {
      // ...
    });
Node.js
// Create a document reference
const docRef = db.collection('objects').doc('some-id');

// Update the timestamp field with the value from the server
const res = await docRef.update({
  timestamp: FieldValue.serverTimestamp()
});
ללכת
_, err := client.Collection("objects").Doc("some-id").Set(ctx, map[string]interface{}{
	"timestamp": firestore.ServerTimestamp,
}, firestore.MergeAll)
if err != nil {
	// Handle any errors in an appropriate way, such as returning them.
	log.Printf("An error has occurred: %s", err)
}
PHP

PHP

למידע נוסף על התקנה ויצירה של לקוח Cloud Firestore, עיין בספריות לקוח Cloud Firestore .

$docRef = $db->collection('samples/php/objects')->document('some-id');
$docRef->update([
    ['path' => 'timestamp', 'value' => FieldValue::serverTimestamp()]
]);
אַחְדוּת
DocumentReference cityRef = db.Collection("cities").Document("new-city-id");
cityRef.UpdateAsync("Timestamp", FieldValue.ServerTimestamp)
	.ContinueWithOnMainThread(task => {
		Debug.Log(
			"Updated the Timestamp field of the new-city-id document in the cities "
			+ "collection.");
	});
C#

C#

למידע נוסף על התקנה ויצירה של לקוח Cloud Firestore, עיין בספריות לקוח Cloud Firestore .

DocumentReference cityRef = db.Collection("cities").Document("new-city-id");
await cityRef.UpdateAsync("Timestamp", Timestamp.GetCurrentTimestamp());
אוֹדֶם
city_ref = firestore.doc "#{collection_path}/new-city-id"
city_ref.update({ timestamp: firestore.field_server_time })

בעת עדכון שדות חותמת זמן מרובים בתוך עסקה , כל שדה מקבל את אותו ערך חותמת זמן של השרת.

עדכן שדות באובייקטים מקוננים

אם המסמך שלך מכיל אובייקטים מקוננים, אתה יכול להשתמש ב"סימן נקודה" כדי להפנות לשדות מקוננים בתוך המסמך כשאתה קורא update() :

Web version 9

import { doc, setDoc, updateDoc } from "firebase/firestore"; 

// Create an initial document to update.
const frankDocRef = doc(db, "users", "frank");
await setDoc(frankDocRef, {
    name: "Frank",
    favorites: { food: "Pizza", color: "Blue", subject: "recess" },
    age: 12
});

// To update age and favorite color:
await updateDoc(frankDocRef, {
    "age": 13,
    "favorites.color": "Red"
});

Web version 8

// Create an initial document to update.
var frankDocRef = db.collection("users").doc("frank");
frankDocRef.set({
    name: "Frank",
    favorites: { food: "Pizza", color: "Blue", subject: "recess" },
    age: 12
});

// To update age and favorite color:
db.collection("users").doc("frank").update({
    "age": 13,
    "favorites.color": "Red"
})
.then(() => {
    console.log("Document successfully updated!");
});
מָהִיר
הערה: מוצר זה אינו זמין ביעדי watchOS ו-App Clip.
// Create an initial document to update.
let frankDocRef = db.collection("users").document("frank")
frankDocRef.setData([
    "name": "Frank",
    "favorites": [ "food": "Pizza", "color": "Blue", "subject": "recess" ],
    "age": 12
    ])

// To update age and favorite color:
db.collection("users").document("frank").updateData([
    "age": 13,
    "favorites.color": "Red"
]) { err in
    if let err = err {
        print("Error updating document: \(err)")
    } else {
        print("Document successfully updated")
    }
}
Objective-C
הערה: מוצר זה אינו זמין ביעדי watchOS ו-App Clip.
// Create an initial document to update.
FIRDocumentReference *frankDocRef =
    [[self.db collectionWithPath:@"users"] documentWithPath:@"frank"];
[frankDocRef setData:@{
  @"name": @"Frank",
  @"favorites": @{
    @"food": @"Pizza",
    @"color": @"Blue",
    @"subject": @"recess"
  },
  @"age": @12
}];
// To update age and favorite color:
[frankDocRef updateData:@{
  @"age": @13,
  @"favorites.color": @"Red",
} completion:^(NSError * _Nullable error) {
  if (error != nil) {
    NSLog(@"Error updating document: %@", error);
  } else {
    NSLog(@"Document successfully updated");
  }
}];

Java

// Assume the document contains:
// {
//   name: "Frank",
//   favorites: { food: "Pizza", color: "Blue", subject: "recess" }
//   age: 12
// }
//
// To update age and favorite color:
db.collection("users").document("frank")
        .update(
                "age", 13,
                "favorites.color", "Red"
        );

Kotlin+KTX

// Assume the document contains:
// {
//   name: "Frank",
//   favorites: { food: "Pizza", color: "Blue", subject: "recess" }
//   age: 12
// }
//
// To update age and favorite color:
db.collection("users").document("frank")
        .update(mapOf(
                "age" to 13,
                "favorites.color" to "Red"
        ))

Dart

// Assume the document contains:
// {
//   name: "Frank",
//   favorites: { food: "Pizza", color: "Blue", subject: "recess" }
//   age: 12
// }
db
    .collection("users")
    .doc("frank")
    .update({"age": 13, "favorites.color": "Red"});
Java
// Create an initial document to update
DocumentReference frankDocRef = db.collection("users").document("frank");
Map<String, Object> initialData = new HashMap<>();
initialData.put("name", "Frank");
initialData.put("age", 12);

Map<String, Object> favorites = new HashMap<>();
favorites.put("food", "Pizza");
favorites.put("color", "Blue");
favorites.put("subject", "Recess");
initialData.put("favorites", favorites);

ApiFuture<WriteResult> initialResult = frankDocRef.set(initialData);
// Confirm that data has been successfully saved by blocking on the operation
initialResult.get();

// Update age and favorite color
Map<String, Object> updates = new HashMap<>();
updates.put("age", 13);
updates.put("favorites.color", "Red");

// Async update document
ApiFuture<WriteResult> writeResult = frankDocRef.update(updates);
// ...
System.out.println("Update time : " + writeResult.get().getUpdateTime());
פִּיתוֹן
# Create an initial document to update
frank_ref = db.collection(u'users').document(u'frank')
frank_ref.set({
    u'name': u'Frank',
    u'favorites': {
        u'food': u'Pizza',
        u'color': u'Blue',
        u'subject': u'Recess'
    },
    u'age': 12
})

# Update age and favorite color
frank_ref.update({
    u'age': 13,
    u'favorites.color': u'Red'
})

Python

# Create an initial document to update
frank_ref = db.collection("users").document("frank")
await frank_ref.set(
    {
        "name": "Frank",
        "favorites": {"food": "Pizza", "color": "Blue", "subject": "Recess"},
        "age": 12,
    }
)

# Update age and favorite color
await frank_ref.update({"age": 13, "favorites.color": "Red"})
C++
// Assume the document contains:
// {
//   name: "Frank",
//   favorites: { food: "Pizza", color: "Blue", subject: "recess" }
//   age: 12
// }
//
// To update age and favorite color:
db->Collection("users").Document("frank").Update({
    {"age", FieldValue::Integer(13)},
    {"favorites.color", FieldValue::String("red")},
});
Node.js
const initialData = {
  name: 'Frank',
  age: 12,
  favorites: {
    food: 'Pizza',
    color: 'Blue',
    subject: 'recess'
  }
};

// ...
const res = await db.collection('users').doc('Frank').update({
  age: 13,
  'favorites.color': 'Red'
});
ללכת
initialData := map[string]interface{}{
	"name": "Frank",
	"age":  12,
	"favorites": map[string]interface{}{
		"food":    "Pizza",
		"color":   "Blue",
		"subject": "recess",
	},
}

// ...

_, err := client.Collection("users").Doc("frank").Set(ctx, map[string]interface{}{
	"age": 13,
	"favorites": map[string]interface{}{
		"color": "Red",
	},
}, firestore.MergeAll)
if err != nil {
	// Handle any errors in an appropriate way, such as returning them.
	log.Printf("An error has occurred: %s", err)
}
PHP

PHP

למידע נוסף על התקנה ויצירה של לקוח Cloud Firestore, עיין בספריות לקוח Cloud Firestore .

// Create an initial document to update
$frankRef = $db->collection('samples/php/users')->document('frank');
$frankRef->set([
    'first' => 'Frank',
    'last' => 'Franklin',
    'favorites' => ['food' => 'Pizza', 'color' => 'Blue', 'subject' => 'Recess'],
    'age' => 12
]);

// Update age and favorite color
$frankRef->update([
    ['path' => 'age', 'value' => 13],
    ['path' => 'favorites.color', 'value' => 'Red']
]);
אַחְדוּת
DocumentReference frankDocRef = db.Collection("users").Document("frank");
Dictionary<string, object> initialData = new Dictionary<string, object>
{
	{ "Name", "Frank" },
	{ "Age", 12 }
};

Dictionary<string, object> favorites = new Dictionary<string, object>
{
	{ "Food", "Pizza" },
	{ "Color", "Blue" },
	{ "Subject", "Recess" },
};
initialData.Add("Favorites", favorites);
frankDocRef.SetAsync(initialData).ContinueWithOnMainThread(task => {

	// Update age and favorite color
	Dictionary<string, object> updates = new Dictionary<string, object>
	{
		{ "Age", 13 },
		{ "Favorites.Color", "Red" },
	};

	// Asynchronously update the document
	return frankDocRef.UpdateAsync(updates);
}).ContinueWithOnMainThread(task => {
	Debug.Log(
		"Updated the age and favorite color fields of the Frank document in "
		+ "the users collection.");
});
C#

C#

למידע נוסף על התקנה ויצירה של לקוח Cloud Firestore, עיין בספריות לקוח Cloud Firestore .

DocumentReference frankDocRef = db.Collection("users").Document("frank");
Dictionary<string, object> initialData = new Dictionary<string, object>
{
    { "Name", "Frank" },
    { "Age", 12 }
};

Dictionary<string, object> favorites = new Dictionary<string, object>
{
    { "Food", "Pizza" },
    { "Color", "Blue" },
    { "Subject", "Recess" },
};
initialData.Add("Favorites", favorites);
await frankDocRef.SetAsync(initialData);

// Update age and favorite color
Dictionary<string, object> updates = new Dictionary<string, object>
{
    { "Age", 13 },
    { "Favorites.Color", "Red" },
};

// Asynchronously update the document
await frankDocRef.UpdateAsync(updates);
אוֹדֶם
# Create an initial document to update
frank_ref = firestore.doc "#{collection_path}/frank"
frank_ref.set(
  {
    name:      "Frank",
    favorites: {
      food:    "Pizza",
      color:   "Blue",
      subject: "Recess"
    },
    age:       12
  }
)

# Update age and favorite color
frank_ref.update({ age: 13, "favorites.color": "Red" })

סימון נקודות מאפשר לך לעדכן שדה מקונן בודד מבלי להחליף שדה מקונן אחר. אם תעדכן שדה מקונן ללא סימון נקודות, תדרוס את כל שדה המפה, לדוגמה:

אינטרנט

// Create our initial doc
db.collection("users").doc("frank").set({
  name: "Frank",
  favorites: {
    food: "Pizza",
    color: "Blue",
    subject: "Recess"
  },
  age: 12
}).then(function() {
  console.log("Frank created");
});

// Update the doc without using dot notation.
// Notice the map value for favorites.
db.collection("users").doc("frank").update({
  favorites: {
    food: "Ice Cream"
  }
}).then(function() {
  console.log("Frank food updated");
});

/*
Ending State, favorite.color and favorite.subject are no longer present:
/users
    /frank
        {
            name: "Frank",
            favorites: {
                food: "Ice Cream",
            },
            age: 12
        }
 */

עדכן אלמנטים במערך

אם המסמך שלך מכיל שדה מערך, אתה יכול להשתמש ב- arrayUnion() וב-arrayRemove( arrayRemove() כדי להוסיף ולהסיר אלמנטים. arrayUnion() מוסיף אלמנטים למערך אך רק אלמנטים שעדיין לא קיימים. arrayRemove() מסיר את כל המופעים של כל אלמנט נתון.

Web version 9

import { doc, updateDoc, arrayUnion, arrayRemove } from "firebase/firestore";

const washingtonRef = doc(db, "cities", "DC");

// Atomically add a new region to the "regions" array field.
await updateDoc(washingtonRef, {
    regions: arrayUnion("greater_virginia")
});

// Atomically remove a region from the "regions" array field.
await updateDoc(washingtonRef, {
    regions: arrayRemove("east_coast")
});

Web version 8

var washingtonRef = db.collection("cities").doc("DC");

// Atomically add a new region to the "regions" array field.
washingtonRef.update({
    regions: firebase.firestore.FieldValue.arrayUnion("greater_virginia")
});

// Atomically remove a region from the "regions" array field.
washingtonRef.update({
    regions: firebase.firestore.FieldValue.arrayRemove("east_coast")
});
מָהִיר
הערה: מוצר זה אינו זמין ביעדי watchOS ו-App Clip.
let washingtonRef = db.collection("cities").document("DC")

// Atomically add a new region to the "regions" array field.
washingtonRef.updateData([
    "regions": FieldValue.arrayUnion(["greater_virginia"])
])

// Atomically remove a region from the "regions" array field.
washingtonRef.updateData([
    "regions": FieldValue.arrayRemove(["east_coast"])
])
Objective-C
הערה: מוצר זה אינו זמין ביעדי watchOS ו-App Clip.
FIRDocumentReference *washingtonRef =
    [[self.db collectionWithPath:@"cities"] documentWithPath:@"DC"];

// Atomically add a new region to the "regions" array field.
[washingtonRef updateData:@{
  @"regions": [FIRFieldValue fieldValueForArrayUnion:@[@"greater_virginia"]]
}];

// Atomically remove a new region to the "regions" array field.
[washingtonRef updateData:@{
  @"regions": [FIRFieldValue fieldValueForArrayRemove:@[@"east_coast"]]
}];

Java

DocumentReference washingtonRef = db.collection("cities").document("DC");

// Atomically add a new region to the "regions" array field.
washingtonRef.update("regions", FieldValue.arrayUnion("greater_virginia"));

// Atomically remove a region from the "regions" array field.
washingtonRef.update("regions", FieldValue.arrayRemove("east_coast"));

Kotlin+KTX

val washingtonRef = db.collection("cities").document("DC")

// Atomically add a new region to the "regions" array field.
washingtonRef.update("regions", FieldValue.arrayUnion("greater_virginia"))

// Atomically remove a region from the "regions" array field.
washingtonRef.update("regions", FieldValue.arrayRemove("east_coast"))

Dart

final washingtonRef = db.collection("cities").doc("DC");

// Atomically add a new region to the "regions" array field.
washingtonRef.update({
  "regions": FieldValue.arrayUnion(["greater_virginia"]),
});

// Atomically remove a region from the "regions" array field.
washingtonRef.update({
  "regions": FieldValue.arrayRemove(["east_coast"]),
});
Java
DocumentReference washingtonRef = db.collection("cities").document("DC");

// Atomically add a new region to the "regions" array field.
ApiFuture<WriteResult> arrayUnion =
    washingtonRef.update("regions", FieldValue.arrayUnion("greater_virginia"));
System.out.println("Update time : " + arrayUnion.get());

// Atomically remove a region from the "regions" array field.
ApiFuture<WriteResult> arrayRm =
    washingtonRef.update("regions", FieldValue.arrayRemove("east_coast"));
System.out.println("Update time : " + arrayRm.get());
פִּיתוֹן
city_ref = db.collection(u'cities').document(u'DC')

# Atomically add a new region to the 'regions' array field.
city_ref.update({u'regions': firestore.ArrayUnion([u'greater_virginia'])})

# // Atomically remove a region from the 'regions' array field.
city_ref.update({u'regions': firestore.ArrayRemove([u'east_coast'])})

Python

city_ref = db.collection("cities").document("DC")

# Atomically add a new region to the 'regions' array field.
await city_ref.update({"regions": firestore.ArrayUnion(["greater_virginia"])})

# // Atomically remove a region from the 'regions' array field.
await city_ref.update({"regions": firestore.ArrayRemove(["east_coast"])})
C++
// This is not yet supported.
Node.js
// ...
const washingtonRef = db.collection('cities').doc('DC');

// Atomically add a new region to the "regions" array field.
const unionRes = await washingtonRef.update({
  regions: FieldValue.arrayUnion('greater_virginia')
});
// Atomically remove a region from the "regions" array field.
const removeRes = await washingtonRef.update({
  regions: FieldValue.arrayRemove('east_coast')
});

// To add or remove multiple items, pass multiple arguments to arrayUnion/arrayRemove
const multipleUnionRes = await washingtonRef.update({
  regions: FieldValue.arrayUnion('south_carolina', 'texas')
  // Alternatively, you can use spread operator in ES6 syntax
  // const newRegions = ['south_carolina', 'texas']
  // regions: FieldValue.arrayUnion(...newRegions)
});
ללכת
// Not supported yet
PHP

PHP

למידע נוסף על התקנה ויצירה של לקוח Cloud Firestore, עיין בספריות לקוח Cloud Firestore .

$cityRef = $db->collection('samples/php/cities')->document('DC');

// Atomically add a new region to the "regions" array field.
$cityRef->update([
    ['path' => 'regions', 'value' => FieldValue::arrayUnion(['greater_virginia'])]
]);

// Atomically remove a region from the "regions" array field.
$cityRef->update([
    ['path' => 'regions', 'value' => FieldValue::arrayRemove(['east_coast'])]
]);
אַחְדוּת
// This is not yet supported in the Unity SDK
  
C#

C#

למידע נוסף על התקנה ויצירה של לקוח Cloud Firestore, עיין בספריות לקוח Cloud Firestore .

DocumentReference washingtonRef = db.Collection("cities").Document("DC");

// Atomically add a new region to the "regions" array field.
await washingtonRef.UpdateAsync("Regions", FieldValue.ArrayUnion("greater_virginia"));

// Atomically remove a region from the "regions" array field.
await washingtonRef.UpdateAsync("Regions", FieldValue.ArrayRemove("east_coast"));
אוֹדֶם
// Not supported yet

הגדל ערך מספרי

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

Web version 9

import { doc, updateDoc, increment } from "firebase/firestore";

const washingtonRef = doc(db, "cities", "DC");

// Atomically increment the population of the city by 50.
await updateDoc(washingtonRef, {
    population: increment(50)
});

Web version 8

var washingtonRef = db.collection('cities').doc('DC');

// Atomically increment the population of the city by 50.
washingtonRef.update({
    population: firebase.firestore.FieldValue.increment(50)
});
מָהִיר
הערה: מוצר זה אינו זמין ביעדי watchOS ו-App Clip.
let washingtonRef = db.collection("cities").document("DC")

// Atomically increment the population of the city by 50.
// Note that increment() with no arguments increments by 1.
washingtonRef.updateData([
    "population": FieldValue.increment(Int64(50))
])
Objective-C
הערה: מוצר זה אינו זמין ביעדי watchOS ו-App Clip.
FIRDocumentReference *washingtonRef =
    [[self.db collectionWithPath:@"cities"] documentWithPath:@"DC"];

// Atomically increment the population of the city by 50.
// Note that increment() with no arguments increments by 1.
[washingtonRef updateData:@{
  @"population": [FIRFieldValue fieldValueForIntegerIncrement:50]
}];

Java

DocumentReference washingtonRef = db.collection("cities").document("DC");

// Atomically increment the population of the city by 50.
washingtonRef.update("population", FieldValue.increment(50));

Kotlin+KTX

val washingtonRef = db.collection("cities").document("DC")

// Atomically increment the population of the city by 50.
washingtonRef.update("population", FieldValue.increment(50))

Dart

var washingtonRef = db.collection('cities').doc('DC');

// Atomically increment the population of the city by 50.
washingtonRef.update(
  {"population": FieldValue.increment(50)},
);
Java
DocumentReference washingtonRef = db.collection("cities").document("DC");

// Atomically increment the population of the city by 50.
final ApiFuture<WriteResult> updateFuture =
    washingtonRef.update("population", FieldValue.increment(50));
פִּיתוֹן
washington_ref = db.collection(u'cities').document(u'DC')

washington_ref.update({"population": firestore.Increment(50)})

Python

washington_ref = db.collection("cities").document("DC")

washington_ref.update({"population": firestore.Increment(50)})
C++
// This is not yet supported.
Node.js
// ...
const washingtonRef = db.collection('cities').doc('DC');

// Atomically increment the population of the city by 50.
const res = await washingtonRef.update({
  population: FieldValue.increment(50)
});
ללכת
import (
	"context"
	"fmt"

	"cloud.google.com/go/firestore"
)

// updateDocumentIncrement increments the population of the city document in the
// cities collection by 50.
func updateDocumentIncrement(projectID, city string) error {
	// projectID := "my-project"

	ctx := context.Background()

	client, err := firestore.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("firestore.NewClient: %v", err)
	}
	defer client.Close()

	dc := client.Collection("cities").Doc(city)
	_, err = dc.Update(ctx, []firestore.Update{
		{Path: "population", Value: firestore.Increment(50)},
	})
	if err != nil {
		return fmt.Errorf("Update: %v", err)
	}

	return nil
}
PHP

PHP

למידע נוסף על התקנה ויצירה של לקוח Cloud Firestore, עיין בספריות לקוח Cloud Firestore .

$cityRef = $db->collection('samples/php/cities')->document('DC');

// Atomically increment the population of the city by 50.
$cityRef->update([
    ['path' => 'regions', 'value' => FieldValue::increment(50)]
]);
אַחְדוּת
// This is not yet supported in the Unity SDK.
  
C#

C#

למידע נוסף על התקנה ויצירה של לקוח Cloud Firestore, עיין בספריות לקוח Cloud Firestore .

DocumentReference washingtonRef = db.Collection("cities").Document("DC");

// Atomically increment the population of the city by 50.
await washingtonRef.UpdateAsync("Regions", FieldValue.Increment(50));
אוֹדֶם
city_ref = firestore.doc "#{collection_path}/DC"
city_ref.update({ population: firestore.field_increment(50) })

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