26 Matching Annotations
  1. Jan 2024
    1. Instance methods Instances of Models are documents. Documents have many of their own built-in instance methods. We may also define our own custom document instance methods. // define a schema const animalSchema = new Schema({ name: String, type: String }, { // Assign a function to the "methods" object of our animalSchema through schema options. // By following this approach, there is no need to create a separate TS type to define the type of the instance functions. methods: { findSimilarTypes(cb) { return mongoose.model('Animal').find({ type: this.type }, cb); } } }); // Or, assign a function to the "methods" object of our animalSchema animalSchema.methods.findSimilarTypes = function(cb) { return mongoose.model('Animal').find({ type: this.type }, cb); }; Now all of our animal instances have a findSimilarTypes method available to them. const Animal = mongoose.model('Animal', animalSchema); const dog = new Animal({ type: 'dog' }); dog.findSimilarTypes((err, dogs) => { console.log(dogs); // woof }); Overwriting a default mongoose document method may lead to unpredictable results. See this for more details. The example above uses the Schema.methods object directly to save an instance method. You can also use the Schema.method() helper as described here. Do not declare methods using ES6 arrow functions (=>). Arrow functions explicitly prevent binding this, so your method will not have access to the document and the above examples will not work.

      Certainly! Let's break down the provided code snippets:

      1. What is it and why is it used?

      In Mongoose, a schema is a blueprint for defining the structure of documents within a collection. When you define a schema, you can also attach methods to it. These methods become instance methods, meaning they are available on the individual documents (instances) created from that schema.

      Instance methods are useful for encapsulating functionality related to a specific document or model instance. They allow you to define custom behavior that can be executed on a specific document. In the given example, the findSimilarTypes method is added to instances of the Animal model, making it easy to find other animals of the same type.

      2. Syntax:

      Using methods object directly in the schema options:

      javascript const animalSchema = new Schema( { name: String, type: String }, { methods: { findSimilarTypes(cb) { return mongoose.model('Animal').find({ type: this.type }, cb); } } } );

      Using methods object directly in the schema:

      javascript animalSchema.methods.findSimilarTypes = function(cb) { return mongoose.model('Animal').find({ type: this.type }, cb); };

      Using Schema.method() helper:

      javascript animalSchema.method('findSimilarTypes', function(cb) { return mongoose.model('Animal').find({ type: this.type }, cb); });

      3. Explanation in Simple Words with Examples:

      Why it's Used:

      Imagine you have a collection of animals in your database, and you want to find other animals of the same type. Instead of writing the same logic repeatedly, you can define a method that can be called on each animal instance to find similar types. This helps in keeping your code DRY (Don't Repeat Yourself) and makes it easier to maintain.

      Example:

      ```javascript const mongoose = require('mongoose'); const { Schema } = mongoose;

      // Define a schema with a custom instance method const animalSchema = new Schema({ name: String, type: String });

      // Add a custom instance method to find similar types animalSchema.methods.findSimilarTypes = function(cb) { return mongoose.model('Animal').find({ type: this.type }, cb); };

      // Create the Animal model using the schema const Animal = mongoose.model('Animal', animalSchema);

      // Create an instance of Animal const dog = new Animal({ type: 'dog', name: 'Buddy' });

      // Use the custom method to find similar types dog.findSimilarTypes((err, similarAnimals) => { console.log(similarAnimals); }); ```

      In this example, findSimilarTypes is a custom instance method added to the Animal schema. When you create an instance of the Animal model (e.g., a dog), you can then call findSimilarTypes on that instance to find other animals with the same type. The method uses the this.type property, which refers to the type of the current animal instance. This allows you to easily reuse the logic for finding similar types across different instances of the Animal model.

      Certainly! Let's go through each part and explain it in simple terms: ### 1. `this` in Mongoose: - **What is `this`?** In JavaScript, `this` refers to the current context or object. In Mongoose, particularly within methods and middleware functions, `this` represents the instance (document) the function is currently operating on. - **Why is it used?** `this` is used to access and modify the properties of the current document. For example, in a Mongoose method, `this` allows you to refer to the fields of the specific document the method is called on. ### 2. Example: Let's use the `userSchema.pre("save", ...)`, which is a Mongoose middleware, as an example: ```javascript userSchema.pre("save", async function (next) { if (!this.isModified("password")) { next(); } else { this.password = await bcrypt.hash(this.password, 10); next(); } }); ``` - **Explanation in Simple Words:** - Imagine you have a system where users can sign up and set their password. - Before saving a new user to the database, you want to ensure that the password is securely encrypted (hashed) using a library like `bcrypt`. - The `userSchema.pre("save", ...)` is a special function that runs automatically before saving a user to the database. - In this function: - `this.isModified("password")`: Checks if the password field of the current user has been changed. - If the password is not modified, it means the user is not updating their password, so it just moves on to the next operation (saving the user). - If the password is modified, it means a new password is set or the existing one is changed. In this case, it uses `bcrypt.hash` to encrypt (hash) the password before saving it to the database. - The use of `this` here is crucial because it allows you to refer to the specific user document that's being saved. It ensures that the correct password is hashed for the current user being processed. In summary, `this` in Mongoose is a way to refer to the current document or instance, and it's commonly used to access and modify the properties of that document, especially in middleware functions like the one demonstrated here for password encryption before saving to the database.

    Tags

    Annotators

    URL

  2. Dec 2023
  3. Jul 2023
  4. Mar 2023
    1. 硬件会帮助操作系统完成最初的初始化和加载,之后,操作系统加载完第一个程序后,从此作为 “中断处理程序” 在后台管理整个计算机系统

      关于硬件如何帮助操作系统完成最初的初始化和加载也是我最近的兴趣。至于 jyy 在课上讲授的内容稍显简略,一些内容我也没有吸收。

  5. Jan 2023
    1. run on a wide variety of hardware - desktops, laptops, tablets, phones, watches

      Curious if he means can run on different devices or an installation spans multiple devices. I'm interested in considering the operating system as a control plane for many devices. Additionally multi-user support for sharing hardware.

  6. Sep 2022
    1. PreferredMD

      PreferredMD Solutions - connecting patients, physicians, and facilities in one HIPAA-compliant platform. Simplify surgery center management workflows for more efficient, transparent health care.

  7. Dec 2021
    1. Operating System MCQ

      Find the list of 50+ Operating System MCQs with Answers to brush up your skills.

  8. Oct 2021
  9. May 2020
  10. Jan 2020
  11. Feb 2019
    1. }-lume who seeks to understand the operations of mind.

      In this sense, the mind is a machine, which operates in order to produce a certain product. What is this product? Knowledge? Can the product differ between people and instances?

  12. Sep 2018
  13. Mar 2018
    1. Operating System Concepts

    2. Scheduling of this kind is a fundamental operating-system function.Almost all computer resources are scheduled before use

      调度是操作系统的基本功能, 几乎所有的计算机资源在使用前均先调度

    Tags

    Annotators

  14. Aug 2017
  15. Jul 2016
  16. Apr 2016
  17. Jan 2016
    1. Today, we’re announcing the end of Chrome’s support for Windows XP, as well as Windows Vista, and Mac OS X 10.6, 10.7, and 10.8, since these platforms are no longer actively supported by Microsoft and Apple. Starting April 2016, Chrome will continue to function on these platforms but will no longer receive updates and security fixes.

      Google announcement from 10 Nov 2015.

      Estimate of operating system usage.

      Microsoft security updates for Windows Vista are scheduled to continue until 11 April, 2017.

  18. Dec 2015
    1. Mozilla's Firefox OS is just the latest in a long list of mobile operating systems that have struggled to get the attention of consumers, who have typically shied away from upstarts often characterized by a weak selection of apps available. That hard-luck list includes Microsoft's Windows Phone, Samsung's Tizen, Jolla's Sailfish OS, Canonical's Ubuntu, Hewlett-Packard's WebOS and BlackBerry's BlackBerry OS.
    2. "We are definitely working with a good number of partners who desire a non-Android OS to power their mobile devices," Acadine founder and Chief Executive Li Gong told CNET. He declined to detail discussions but said, "We are now the frontrunner in terms of choice in this space."

      Hong Kong-based startup Acadine Technologies may take over development of Firefox OS, as H5OS.

  19. Nov 2015
    1. The Wall Street Journal reports that Google will be merging Chrome OS into Android, to be released sometime in 2017. Chrome OS runs on netbooks and provides most of its applications through the Web browser. As a result, it is a very secure system -- unlike Android, which has been quite vulnerable. Chrome OS will continue to exist as open source software, but Google will focus on extending Android to run on laptops.

  20. Jan 2014
    1. In all cases, one standard is clear: Each of these vendors is betting very heavily on HTML5-based applications as well as methods to make HTML5 compatibility the basis for their future. Whether made from Java or other language frameworks, HTML5 is the common thread that runs through each of these alternative mobile operating systems. Start with HTML5, and your applications’ portability is almost assured.

      Is there any other reasonable bet than HTML5?! Especially in the smartdevice realm where there is a rich set of HTML5-family features already enabled it makes less and less sense to make native applications except for special edge-cases. And any smartdevice competitors cannot possibly compete against iOS and Android on their own unique native app development format-- so HTML5 would seem the only reasonable place to focus development of new apps. Where Ubuntu succeeds is compatibility with an already well established Linux ecosystem.