779 Matching Annotations
  1. Apr 2024
  2. Feb 2024
    1. https://web.archive.org/web/20240216060220/https://observablehq.com/blog/observable-2-0

      Observable is a static site generator for data dashboards and analyses. It can handle markdown and is as such compatible with using Obsidian notes as source. See https://mastodon.social/@kepano/111937315007645449

      This is comparable with [[EUNotes via Github Respec naar Geonovum]] where I generate a respec site from my notes through github. Except that Respec is text documentation, and Observable contains javascript to present data.

    1. 3:00 "and its long..." -- yeah, i have a 3MB obfuscated webapp at boxy-svg.com/app<br /> 3:05 "what would you do?" -- semi-automatic dynamic analysis. rename symbols. eval function calls. interact with the webapp (hence "semi" automatic). trace data in the debugger.<br /> but im still looking for a tool to do that for me... : P<br /> most tools fail on large files, or ESM (import, export) ...<br /> my current favorite is https://github.com/j4k0xb/webcrack and https://github.com/pionxzh/wakaru -- at least it works with ESM

  3. 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.


      ```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.




    1. With the introduction of ES6 Modules, the module pattern (IIFEs) is not needed anymore, though you might still encounter them in the wild.
    1. Any constructor that can be called with new and has the prototype property can be the candidate for the parent class.

      Classes declared with class and functions with constructor and an assigned prototype.

  4. Dec 2023
    1. We can use the call() method to copy over properties from one constructor into another constructor. Let’s create a Warrior and a Healer constructor.
    2. It is important to note that .__proto__ is a legacy feature and should not be used in production code, and it is not present in every modern browser. However, we can use it throughout this article for demonstrative purposes.
  5. Oct 2023
    1. Por exemplo, ao usar métodos como Array.prototype.map()o que retorna o construtor padrão, você deseja que esses métodos retornem um Arrayobjeto pai, em vez do MyArrayobjeto. O Symbol.speciessímbolo permite
    2. Você pode querer retornar Arrayobjetos em sua classe de array derivada MyArray. O padrão
    3. Qualquer valor passado
    4. O Object()construtor faz casos especiais do cenário de subclasse. Se for chamado implicitamente via super(), ele sempre
    5. A única diferença de não escrever extendsnada é que o próprio construtor

      No entanto

    6. Subclasses abstratas ou mix-ins são modelos para classes. Uma classe só pode ter


      A funcionalidade

    7. Uma função com uma superclasse como entrada e uma subclasse estendendo essa superclasse como saída pode
    8. A herança é um relacionamento de acoplamento muito forte na programação orientada a objetos. Isso significa
    9. Podemos contornar isso usando um sinalizador privado para indicar se a instância está sendo construída. No entanto, um problema mais significativo com esse projeto é que ele quebra

      Que afirma

    10. A herança muitas vezes leva ao problema do círculo-elipse , porque nenhum tipo

      Em geral

    11. Composição significa que uma classe
    12. Nesse caso, a ReadOnlyMapclasse não é uma subclasse de Map, mas ainda implementa a maioria dos mesmos métodos. Isso significa mais duplicação de código, mas também significa que a ReadOnlyMapclasse não está fortemente acoplada à Mapclasse e não é facilmente interrompida
    13. Por exemplo, se a Mapclasse adicionar um emplace()método que não chama set(), isso fará com que a ReadOnlyMapclasse não seja mais somente leitura, a menos
    14. Todos os objetos JavaScript herdam
    15. As classes não podem estender objetos regulares (não construíveis). Se você deseja herdar de um objeto regular
    16. Em vez disso, você precisa retornar
    17. No entanto, devido a decisões incertas sobre se super()deve ser chamado dentro do construtor, não é possível
    18. extends nullfoi projetado para permitir
    19. Portanto, uma maneira melhor de estender os built-ins
    20. Qualquer adição de novos métodos na classe base também pode
    21. Se você deseja criar subclasses de built-ins enquanto alcança as expectativas acima, você precisa
    22. Novos métodos internos sempre constroem a classe base e chamam
    23. Esses problemas não são exclusivos de classes internas. Para suas próprias classes, você provavelmente terá que tomar as mesmas decisões. No entanto, para classes internas
    24. No entanto, as expectativas acima exigem esforços não triviais para serem implementadas adequadamente.
    25. Aqui estão algumas coisas que você pode esperar ao estender uma classe:
    26. Se o construtor da classe pai retornar um objeto, esse objeto será usado como

      Esse truque é chamado

    27. Enquanto a classe base pode retornar qualquer coisa de seu construtor, a classe derivada
    28. O thisvalor na extendsexpressão está
    29. O lado direito de extendsnão precisa ser um identificador. Você pode usar

      Isso geralmente é útil

    30. extendsdefine o protótipo para ambos ChildClasse ChildClass.prototype.
    31. A prototypepropriedade do ParentClassdeve
    32. As duas condições devem ser válidas — por exemplo, funções vinculadas e Proxypodem ser construídas, mas não têm uma prototypepropriedade, portanto
    33. A extendspalavra-chave pode ser usada para criar

      Bem como

    34. Qualquer construtor que possa ser chamado newe tenha a prototypepropriedade
    35. A extendspalavra-chave é usada em


  6. Aug 2023
  7. Jun 2023
  8. May 2023
    1. https://share-on-mastodon.social/

      A really neat customizable "Share on Mastodon" button for your pages or posts.

    1. Another downside to using Gutenberg’s sidebar panels is that, as long as I want to keep supporting the classic editor, I’ve basically got to maintain two copies of the same code, one in PHP and another in JavaScript.

      Note to self: getting into WP Gutenberg is a shift deeper into JS and less PHP. My usually entry into creating something for myself is to base it on *AMP (MAMP now) so I can re-use what I have in PHP and MySQL as a homecook.

  9. Mar 2023
  10. cocktailpeanut.github.io cocktailpeanut.github.io
    1. 컴퓨터에서 LLAMMA AI를 실행하는 매우 간단한 방법인 Dalai cpp 파일 빌드, github 복제, 파일 다운로드 등을 귀찮게 할 필요가 없음. 모든 것이 자동화 됨

  11. Feb 2023
    1. The simulator widget below contains the entire source code of the game. I’ll explain how it works in the following sections.
  12. Dec 2022
    1. Typescript added rich type annotations to Javascript, which opened the door to refactoring and static analysis tools that facilitate development and maintenance of large Javascript projects.