Анонимный тип по сравнению с динамическим типом
Если вы хотите вернуть измененный документ, вам нужно установить ссылку API {new:true} API, вы можете использовать Cat.findOneAndUpdate(conditions, update, options, callback) // executes
, принятый официальным API Mongoose http: // mongoosejs. com / docs / api.html # findoneandupdate_findOneAndUpdate вы можете использовать следующие параметры
A.findOneAndUpdate(conditions, update, options, callback) // executes
A.findOneAndUpdate(conditions, update, options) // returns Query
A.findOneAndUpdate(conditions, update, callback) // executes
A.findOneAndUpdate(conditions, update) // returns Query
A.findOneAndUpdate() // returns Query
Другая реализация, которая не выражена на официальной странице API, и это то, что я предпочитаю использовать, это Promise, которые позволяют вам иметь .catch, где вы можете иметь дело со всей вашей различной ошибкой.
let cat: catInterface = {
name: "Naomi"
};
Cat.findOneAndUpdate({age:17}, cat,{new: true}).then((data) =>{
if(data === null){
throw new Error('Cat Not Found');
}
res.json({ message: 'Cat updated!' })
console.log("New cat data", data);
}).catch( (error) => {
/*
Deal with all your errors here with your preferred error handle middleware / method
*/
res.status(500).json({ message: 'Some Error!' })
console.log(error);
});
5 ответов
Анонимный тип является реальным, сгенерированным компилятором типом, который создается для Вас. Хорошая вещь об этом состоит в том, что компилятор может снова использовать этот тип позже для других операций, которые требуют его, как это ПОСТЕПЕННО.
Мое понимание динамических типов - то, что они являются последними ограниченными, означая, что CLR (или ДОЛЛАР) будет оценивать объект во время выполнения и затем использовать утиный ввод, чтобы позволить или запретить членский доступ к объекту.
, Таким образом, я предполагаю, что различие - то, что анонимные типы являются истинным POCOs, который видит компилятор, но можно только использовать, и динамические типы являются последними ограниченными динамическими объектами.
Эти dynamic тип по существу object, но разрешит весь метод / свойство / оператор и т.д. звонит во времени выполнения через ДОЛЛАР или другого поставщика (такого как отражение).
Это делает его во многом как VB с Option Strict Off и делает его очень универсальным для вызова в COM, или в типы ДОЛЛАРА.
существует никакой тип, проверяющий во время компиляции с динамическим; с другой стороны анонимные типы являются надлежащими статически введенными, проверенными в типе зверями (Вы видите их в отражателе, хотя они не симпатичны).
Кроме того, анонимные типы могут быть обработаны исключительно компилятором; dynamic требует обширной поддержки во время выполнения - таким образом, анонимные типы являются функцией C#, но dynamic будет в основном реализован.NET 4.0 (с некоторой поддержкой C# 4.0).
Существует три раза, с тремя агентами - один в каждый раз.
- Время проектирования - программист
- Время компиляции - c# компилятор
- Время выполнения - .net время выполнения
Анонимные типы объявляет и называет компилятор. Это объявление основано на спецификации программиста (как он использовал тип). Так как эти типы называют после того, как программист оставил процесс, они, кажется, являются неназванными программисту, следовательно "анонимными".
- программист говорит: Некоторый тип имеет Имя и адрес
- , в компиляторе говорится: существует тип, названный xyz со свойствами Name and Address и полями, обеими строками.
- время выполнения говорит: Я не могу сказать никакому различию между xyz и любым типом, что программист сделал.
динамический контроль типов в c# позволяет Вам называть методы, которые могут или не могут существовать во время компиляции. Это полезно для вызова в Python или JavaScript, которые не компилируются.
- программист говорит: рассматривайте этот экземпляр автомобиля как динамический тип. Теперь, шарлатан.
- в компиляторе говорится: динамический контроль типов а? должен быть в порядке. Я не буду жаловаться, потому что я не могу проверить его.
- время выполнения пытается сделать экземпляр автомобиля, шарлатана.
Вы, кажется, смешиваете три совершенно других, ортогональных вещи:
- статичный по сравнению с динамическим ввод
- декларация по сравнению с неявным ввод
- названный по сравнению с анонимным типы
Те три аспекта абсолютно независимы, у них нет ничего вообще, чтобы сделать друг с другом.
Статичный по сравнению с динамическим ввод относится к [1 115], когда проверка типа происходит: динамический контроль типов происходит в [1 116] время выполнения , статический контроль типов происходит перед временем выполнения .
Декларация по сравнению с неявным ввод относится к тому, являются ли типы декларация в исходном коде или нет: явный ввод означает, что программист должен записать типы в исходный код, неявная типизация означает, что система типов понимает их самостоятельно.
Названный по сравнению с анонимным типы относятся к, ну, в общем, имеют ли типы имена или нет.
dynamic ключевое слово в C# 4.0 означает, что эта переменная, параметр, метод, поле, свойство... независимо от того, что с динамическим контролем типов , т.е. что его тип будет проверен во времени выполнения. Все, что не вводится как динамичное, со статическим контролем типов. Является ли тип статичным или динамичным не, только определяет, когда проверка типа происходит, но и в C# 4.0 это также определяет, когда отправка метода происходит. В C# отправка метода сделана перед временем выполнения, на основе статического типа (за исключением полиморфизма подтипа во время выполнения, конечно), тогда как на объектах с динамическим контролем типов в C# 4.0, отправка метода сделана во времени выполнения, на основе типа выполнения.
var ключевое слово в C# 3.0 означает, что эта локальная переменная будет , неявно ввел , т.е. что вместо программиста, записывающего тип явно, система типов поймет его самостоятельно. Это не имеет никакого отношения к динамическому контролю типов, по крайней мере, в C# 3.0. Переменная будет решительно со статическим контролем типов так же, как если бы Вы записали тип сами. Это - просто удобство: например, почему необходимо было бы записать все имена типов дважды в HashMap<int, string> foo = new HashMap<int, string>();, когда система типов может ясно фигура, которая foo является HashMap<int, string>, так вместо этого Вы пишете var foo = new HashMap<int, string();. Обратите внимание на то, что нет ничего динамического или анонимного об этом. Тип статичен, и он имеет имя: HashMap<int, string>. Конечно, в C# 4.0, если система типов выясняет, что правая сторона присвоения является динамичной, тогда тип переменной на левой стороне будет динамичным.
анонимный тип в C# 3.0 означает, что этот тип не имеет никакого имени. Ну, на самом деле реальный анонимные типы потребовали бы назад несовместимого изменения в Общей системе типов, поэтому что на самом деле происходит позади занавеса, то, что компилятор генерирует очень длинное, очень случайное, уникальное и недопустимое название типа и поставит то имя в том, везде, где анонимный тип появляется. Но с точки зрения программиста, тип не имеет никакого имени. Почему это полезно? Ну, иногда у Вас есть промежуточные результаты, в которых Вы только нуждаетесь кратко и затем выбрасываете снова. Давание таких переходных типов, собственное имя подняло бы их до важного уровня, которого они просто не заслуживают. Но снова, нет ничего динамического об этом.
Так, если тип не имеет никакого имени, как программист может обратиться к нему? Ну, она не может! По крайней мере, не непосредственно. Что программист может делать, быть, описывают тип: это имеет два свойства, один названный "название" типа string, другой названный "идентификатор" типа int. Это - тип, который я хочу, но я не забочусь о том, чем это называют.
Вот то, где части начинают объединяться. В C# необходимо объявить типы локальных переменных путем явной записи названий типов. Но, как можно записать название типа, который не имеет никакого имени? Это - то, где var входит: потому что начиная с C# 3.0, это больше не на самом деле верно: Вы больше не должны записывать имена, можно также сказать компилятору понимать его. Так, в то время как то, что я записал в первом абзаце выше, верно, та неявная типизация и анонимные типы не имеют никакого отношения к другому, это также верно, что анонимные типы были бы довольно бесполезны без неявной типизации.
Примечание, однако, что противоположное не верно: неявная типизация совершенно полезна без анонимных типов. var foo = HashMap<int, string> имеет идеальный смысл и в поле зрения нет никакого анонимного типа.