778 Matching Annotations
  1. 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

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

    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.

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

      Portanto

      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

      Para

  5. Aug 2023
  6. Jun 2023
  7. 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.

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

  10. 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.
  11. 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.
  12. Nov 2022
    1. The btoa() function takes a JavaScript string as a parameter. In JavaScript strings are represented using the UTF-16 character encoding: in this encoding, strings are represented as a sequence of 16-bit (2 byte) units. Every ASCII character fits into the first byte of one of these units, but many other characters don't. Base64, by design, expects binary data as its input. In terms of JavaScript strings, this means strings in which each character occupies only one byte. So if you pass a string into btoa() containing characters that occupy more than one byte, you will get an error, because this is not considered binary data:
    2. If you need to encode Unicode text as ASCII using btoa(), one option is to convert the string such that each 16-bit unit occupies only one byte.
  13. Oct 2022
    1. We use Javascript everywhere, since we solve the “issues” caused by Javascript rendering we want to build as much expertise as possible in this field. But for the other parts, we are taking advantage of CloudFlare’s distributed system for fast response and global scalability. While our uptime guarantees are supported by Digital Ocean’s cloud platform. We also use a myriad of other SaaS providers to maximize our effectiveness.

      Stack of Prerender: - Javascript - CloudFlare - Digital Ocean - SaaS providers

  14. Sep 2022
  15. Aug 2022
  16. Jul 2022
  17. May 2022
    1. let timer; // Timer identifier const waitTime = 500; // Wait time in milliseconds // Search function const search = (text) => { // TODO: Make HTTP Request HERE }; // Listen for `keyup` event const input = document.querySelector('#input-text'); input.addEventListener('keyup', (e) => { const text = e.currentTarget.value; // Clear timer clearTimeout(timer); // Wait for X ms and then process the request timer = setTimeout(() => { search(text); }, waitTime); });

      let timer; // timer identifier const waitTime = 500; // Wait time in milliseconds

      // search function const search = (text) => { // to do: make http request here }

      // Listen for keyup event const input = document.querySelector('#input-text'); input.addEventListener('keyup', (e) => { const text = e.currentTarget.value; // clear timer clearTimeout(timer);

      // Wait for X ms and then process the request timer = setTimeout(() => { search(text); }, waitTime); });

    1. // Get the input box let input = document.getElementById('my-input'); // Init a timeout variable to be used below let timeout = null; // Listen for keystroke events input.addEventListener('keyup', function (e) { // Clear the timeout if it has already been set. // This will prevent the previous task from executing // if it has been less than <MILLISECONDS> clearTimeout(timeout); // Make a new timeout set to go off in 1000ms (1 second) timeout = setTimeout(function () { console.log('Input Value:', textInput.value); }, 1000); });

      let timeout = setTimeout(callback, milliseconds); clearTimeout(timeout);

      document.getElementById("id-name"); object.addEventListener('event-name',callback);

    2. In order to execute an event listener (or any function for that matter) after the user stops typing, we need to know about the two built-in JavaScript methods setTimeout(callback, milliseconds) and clearTimeout(timeout): setTimeout is a JavaScript method that executes a provided function after a specified amount of time (in milliseconds). clearTimeout is a related method that can be used to cancel a timeout that has been queued.

      Step 1. Listen for User Input

      <input type="text" id="my-input" />

      let input = document.querySelector('#my-input'); input.addEventListener('keyup', function (e) { console.log('Value:', input.value); })

      Step2: Debounce Event Handler Function

      let input = document.getElementById('my-input'); let timeout = null;

      input.addEventListener('keyup', function(e) { clearTimeout(timeout);

      timeout = setTimeout(function() { console.llog('Input Value:', textInput.value); }, 1000); })

    1. 227 This answer is not useful Show activity on this post. Your real question seem to be: Why: null >= 0; // true But: null == 0; // false
      • ME TOO
    1. encodeURIComponent() escapes all characters except: Not Escaped: A-Z a-z 0-9 - _ . ! ~ * ' ( )
      • EXCEPTIONs
      • ( =%28
      • ) = %F29
  18. Apr 2022
    1. Stimulus is a JavaScript framework with modest ambitions. It doesn’t seek to take over your entire front-end—in fact, it’s not concerned with rendering HTML at all.
    1. 1) Use Set Using Set(), an instance of unique values will be created, implicitly using this instance will delete the duplicates. So we can make use of this instance and from there we will have to convert that instance into a new array, and that would be it: let chars = ['A', 'B', 'A', 'C', 'B']; let uniqueChars = [...new Set(chars)]; console.log(uniqueChars);
      • SET = unique values
  19. developer.mozilla.org developer.mozilla.org
    1. Basic Examplelet myFirstPromise = new Promise((resolve, reject) => { // We call resolve(...) when what we were doing asynchronously was successful, and reject(...) when it failed. // In this example, we use setTimeout(...) to simulate async code. // In reality, you will probably be using something like XHR or an HTML5 API. setTimeout( function() { resolve("Success!") // Yay! Everything went well! }, 250) }) myFirstPromise.then((successMessage) => { // successMessage is whatever we passed in the resolve(...) function above. // It doesn't have to be a string, but if it is only a succeed message, it probably will be. console.log("Yay! " + successMessage) });
      • BASIC
  20. Mar 2022
    1. let msg = res.code != 0 ? res.msg || '操作失败' : res.msg || "操作成功";

      代码优化,可读性的衡量:

      let options = res.code != 0 ? { msg: '操作失败', icon: 2} : {msg: "操作成功", icon: 1};

      msg = res.msg || options.msg;

    1. JavaScript 的数学运算

      基于 Math 类 Math.ceil() Math.floor()

      3.1415926.toFixed(2) // 保留小数位 99.89233.toPrecision(5) // 整体长度,含整数部分

      全局对象 window 的方法

      parseInt('100') parseInt(100.12) parseInt('string') // => NaN

      Number("string") // => 0

      位运算:

      | 0 , 和 0 按位或 ~~ ,两次按位非

      0,右移 0 位 << 0,左移 0 位

      0,无符号右移 0 位

  21. Feb 2022
    1. Here's a very simple solution without too much code using a very simple map of diacritics that includes some or all that map to ascii equivalents containing more than one character, i.e. Æ => AE, ffi => ffi, etc... Also included some very basic functional tests var diacriticsMap = { '\u00C0': 'A', // À => A
      • MAP of chars to change
    2. One solution that seems to be way faster by the given test : http://jsperf.com/diacritics/9 function removeDiacritics(str) { return str.replace(/[^A-Za-z0-9\s]+/g, function(a){ return diacriticsMap[a] || a; }); } removeDiacritics(teste); Working example: http://jsbin.com/sovorute/1/edit Reasoning: One reason this is much faster is because we only iterate through the special characters, picked by the negated regex pattern. The fastest of the tests (String Iteration without in) iterates 1001 on the given text, which means every character. This one iterates only 35 times and outputs the same result. Keep in mind that this will only replace what is indicated in the map. Classic article on the subject: http://alistapart.com/article/accent-folding-for-auto-complete Credit: http://semplicewebsites.com/removing-accents-javascript , also provides a nice character map.
      • GOOD SOLUTION
    3. With ES2015/ES6 String.prototype.normalize(), const str = "Crème Brulée" str.normalize("NFD").replace(/[\u0300-\u036f]/g, "") > "Creme Brulee" Two things are happening here: normalize()ing to NFD Unicode normal form decomposes combined graphemes into the combination of simple ones. The è of Crème ends up expressed as e + ̀. Using a regex character class to match the U+0300 → U+036F range, it is now trivial to globally get rid of the diacritics, which the Unicode standard conveniently groups as the Combining Diacritical Marks Unicode block. As of 2021, one can also use Unicode property escapes: str.normalize("NFD").replace(/\p{Diacritic}/gu, "")

      This solution is the only correct solution here. This works on NodeJS 4.6, Firefox 50 and Chrome 54. – david_p Dec 9, 2016 at 13:12

    4. 6 This solution is the only correct solution here. This works on NodeJS 4.6, Firefox 50 and Chrome 54. – david_p Dec 9, 2016 at 13:12

      With ES2015/ES6 String.prototype.normalize(),

      const str = "Crème Brulée" str.normalize("NFD").replace(/[\u0300-\u036f]/g, "")

      "Creme Brulee" Two things are happening here:

      normalize()ing to NFD Unicode normal form decomposes combined graphemes into the combination of simple ones. The è of Crème ends up expressed as e + ̀. Using a regex character class to match the U+0300 → U+036F range, it is now trivial to globally get rid of the diacritics, which the Unicode standard conveniently groups as the Combining Diacritical Marks Unicode block. As of 2021, one can also use Unicode property escapes:

      str.normalize("NFD").replace(/\p{Diacritic}/gu, "")

    5. 23 There's always one char that fails.. 'ąśćńżółźćę'.normalize('NFD').replace(/[\u0300-\u036f]/g, "") -> ascnzołzce (missing match for ł -> l). – Paweł Fus Jul 24, 2017 at 13:23 15 Correct me if I'm wrong but ł is a letter in itself, not an accented L. Therefore it should not be changed to l. – Lewis Diamond Jul 25, 2017 at 15:28 4 @PawełFus - the ł does not fall within the character class range. You can target it specifically as \u0142 ---SO---> 'ł'.replace(/\u0142/g, "l") – Chris Geirman Nov 26, 2017 at 19:18
      • DIACRITICS
    1. All the popular web browsers have built-in JavaScript engines. Hence, you can run JavaScript on a browser. To run JavaScript on a browser,
  22. Jan 2022
    1. nstead of using the /regex\d/g syntax, you can construct a new RegExp object: var replace = "regex\\d"; var re = new RegExp(replace,"g");
      • REGEX
      • crear regex a partir de pattern
      • CIUDADO: \b -> \b; \s -> \s en la cadena pattern
    1. My gut told me calling an async function from the setTimeout callback was a bad thing. Since the setTimeout machinery ignores the return value of the function, there is no way it was awaiting on it. This means that there will be an unhandled promise. An unhandled promise could mean problems if the function called in the callback takes a long time to complete or throws an error.
    2. The callback executed by setTimeout is not expected to return anything, it just ignores the returned value. Since once you enter the promise/async world in JavaScript you cannot escape, I was left to wonder what happens when the setTimeout callback returns a promise?
    1. test2 being marked async does wrap your return value in a new promise:
    2. const rejectedP = Promise.reject('-'); const finallyP = rejectedP.finally(); const result1 = rejectedP; const result2 = new Promise(resolve => { const rejectedP = Promise.reject('-'); const finallyP = rejectedP.finally(); resolve(rejectedP); }); we can see that the first snippet creates two promises (result1 and rejectedP being the same) while the second snippet creates three promises. All of these promises are rejected, but the rejectedP rejection is handled by the callbacks attached to it, both through ….finally() and resolve(…) (which internally does ….then(resolve, reject)). finallyP is the promise whose rejection is not handled in the both examples. In the second example, result2 is a promise distinct from rejectedP that is also not handled, causing the second event.
    1. You basically did var a = promise.then(…); var b = promise.catch(…); creating a branch in the chain. If promise is getting rejected now, the catch callback will be called and b will be a fulfilled promise just fine, but the a promise is getting rejected too and nobody handles that. Instead, you should use both arguments of then and write Requirement.create({id: id, data: req.body.data, deleted: false}) .then(requirement => { res.json(requirement); }, reason => { let err = {'error': reason}; res.json(err); });