Please enable JavaScript.

Coggle requires JavaScript to display documents.

NodeJS & JQuery Tutorial (Functionalities of JQuery (The HTML setting…

- - - - Built-in modules/packages
        
        url
        
        url.parse: can be used to parse the url query by query names
        
        The second parameter must be true to have a parsed JSON object returned :star:
        
        http
        
        Use for server buliding
        
        .createServer
        
        IncomingMessage class
        
        ServerResponse class
        
        fs (file system)
        
        Read
        Create
        Update
        Rename
        Delete
        
        :red_flag: fs.rename can be used to move file: fs.rename(oldpath, newpath, (err) => { if (err) throw err; ...});
        
        This module can be used to show HTML page through server
        
        events
        
        var eventEmitter = new events.EventEmitter();
        
        eventEmitter.on('<id>', handler-function);
        eventEmitter.emit('<id>');
    - - formidable
        
        uploading files
  - - - Also block scope, and prevent re-assignment and re-declaration
      - But not protection object key-value change (adding, pushing)
    - - global scope, and very flexible (can be an issue)
    - - block scope, and using { } to separate scopes
- - - - This error happens when you get any error from a promise, and didn't catch this error from the Promise.
        
        Promise.catch(callbackfunction) OR Promise.then(null, callbackfunction, and these two are exactly then same. Except .catch is a shortcut.
        
        Callback function can just be console.log
        
        Even if you didn't use that promise, you will need to CATCH error! :red_flag:
    - - We can do things in natural order: first run function to get the promise, and .then we can do something.
      - We can have multiple new handler .then
      - Remember to catch for all promises
      - .finally won't stop output for other two handlers.
    - - In html, you can use on... events to pre set when will this function been called
        
        script.onload = function() { resolve(...)};
        script.onerror = () => reject(new Error(...));
    - - setTimeout(() => resolve(...), 1000)
    - - It always takes an executor function: (resolve, reject) => {...}, and the resolve is always in front of the reject function.
        
        When user get the returned value from promise, the first is result, and second is error.
    - - Except for scoping access issues (access all the returned results in previous promises) we don't use nested promises, and only use chained ones.
        
        promise.then(f1).catch(f2); is different from promise.then(f1, f2)
        
        Because the first one have a catch follow, but the second one doesn't. And since we can return promise in handler .then, new error can be generated in that promise (chain).
      - Don't forget the terminate promise chain with a .catch
      - For got to return a new promise after create it (only exception is when you are using arrow function with only one line of expression that creates the promise and no brackets around: it will auto return for you)
        
        :check:A good rule-of-thumb is to always either return or terminate promise chains, and as soon as you get a new promise, return it immediately, to flatten things:
        
        :star: Note that () => x is short for () => { return x; }
      - Using async/await addresses most, if not all of these problems—the tradeoff being that the most common mistake with that syntax is forgetting the await keyword.
      - In an ideal world, all asynchronous functions would already return promises. Unfortunately, some APIs still expect success and/or failure callbacks to be passed in the old way.
        
        Basically, the promise constructor takes an executor function that lets us resolve or reject a promise manually.
      - The constructor is primarily used to wrap functions that do not already support promises. (So constructor is not necessary for functions that already supports Promise)
      - When you console.log and see [object Promise], that just means your didn't using .then to handle/wait the promise.
        
        Syntaz: new Promise(executor);
      - Remember, the await keyword is only valid inside async functions. If you use it outside of an async function's body, you will get a SyntaxError.
        
        The purpose of async/await functions is to simplify the behavior of using promises synchronously and to perform some behavior on a group of Promises. Just as Promises are similar to structured callbacks, async/await is similar to combining generators and promises.
    - - When a handler like .then returns a value, that becomes the result for the next handler.
      - In JS no return is required, and it will simply return undefined if no return value is specified.
      - If .then (or catch/finally, doesn’t matter) handler returns a promise, the rest of the chain waits until it settles. When it does, its result (or error) is passed further.
      - Nested promise usage
        
        Only when you want to use the scope to catch inner errors, and let other outer scope catch to handle outer promise errors.
      - Multiple callbacks may be added by calling then() several times. Each callback is executed one after another, in the order in which they were inserted.
      - t's possible to chain after a failure, i.e. a catch, which is useful to accomplish new actions even after an action failed in the chain.
        
        However, anything in the catch block after the throw new Error won't be executed.
      - Basically, a promise chain stops if there's an exception, looking down the chain for catch handlers instead. This is very much modeled after how synchronous code works
        
        Only one catch in the end is enough for all chain
      - Using the chain promise to replace the old day async/await function syntax: even though each single .then is not guaranteed to run in order, but the chain will run each of them in order (one by one!) :star:
      - Composition
        
        Promise.all()
        
        If any of the passed-in promises reject, Promise.all asynchronously rejects with the value of the promise that rejected, whether or not the other promises have resolved.
        
        Using Promise.reject('reject reason') to test
        
        But, Promise.all resolves synchronously if and only if the iterable passed is empty:
        
        Promise.race()
        
        Promise.resolve() and Promise.reject() are shortcuts to manually create an already resolved or rejected promise respectively.
    - - const promise = createAudioFileAsync(audioSettings);
        promise.then(successCallback, failureCallback);
        
        Notice the const
      - createAudioFileAsync(audioSettings).then(successCallback, failureCallback);
        
        Though I still recommend a separated .catch( ) in the end to terminate promise
  - - - 0 arg: ()
        1 arg: arg
        2+ args: (arg1, arg2, ...)
    - - A function can be passed in up to 255 parameters
      - Notice that parameters are defined when we declare a function, whereas arguments are the actual values passed to functions when we invoke them.
    - - Because it is not one of the primitives (boolean, number, string, null, undefined)