Section 1
Preview this deck
IIFE: Immediately Invoked Function Expression
Front
| 5 | 0 | ||
| 4 | 0 | ||
| 3 | 0 | ||
| 2 | 0 | ||
| 1 | 0 |
Active users
0
All-time users
0
Favorites
0
Last updated
6 years ago
Date created
Mar 1, 2020
Cards (62)
Section 1
(50 cards)
IIFE: Immediately Invoked Function Expression
Used in frameworks/ libraries like jQuery Wrap code for the framework inside of IIFE to protect scope of its variables and to make sure everything is executed without the user having to do anything
Asynchronus Operations
make the code execute in a way that doesn't read top to bottom Ex: adding a timeout to delay by 3000 seconds
Object Methods
Actions that can be performed on an object Are stored in objects as function definitions
splice();
Method for splitting arrays. destructive function bc it changes content of the input array Removes existing elements or adds new ones
JS Object Constructors
A blueprint for creating many objects of the same "type" Objects of the same type created by calling constructor function with "new" keyword. Doesn't have to have "constructor" in name when declared. Looks like a function but with Capital first letter name
.sort(); method
Sorts elements in an array
Lexical scoping
Uses the location where the variable is declared within the source code to determine where that variable is available. Nested function have access to variables declared in outer scope
3 states of promises
pending: initial state before operation begins fulfilled: specific operation was completed rejected: operation didn't complete =error thrown
Object.seal()
Seals an object Prevents new properties from being added and existing non-configurable Values of present properties can be changed
slice();
Method for splitting arrays. Non-destructive-returns a new copy Normally used in function programming to avoid side-effects
Promises
We can defer execution of a code block until an async request is completed: so that other operations can run without interruption
Hoisting
Variables and function declarations are moved to top of scope. Declaration is hoisted not initialization.
Arguments
Real values passed to the function. Take place of parameters
Function Return
when reaches return statement, will stop executing. Will compute a return value
For loop code
var hello = "hello" for (var i = 0; i < 50; i++) { console.log(hello); }
Arrow functions
Use less code than normal functions don't have their own "this": not good for defining object methods Are not Hoisted - must define before use
JS Objects
are variables too, but they can contain many values. Values are written as name:value pairs Or Property: Property Value Access object properties with property name
.map();
JS Method Takes 2 arguments (callback and optional context) Callback runs for each value in array and returns each new value in resulting array
Call() / apply ()
JS Method Invoke the function immediately
Callback Functions
Function simply accepts another function as an argument, the contained function is a callback .map() method iterates through array and accepts callback function Return that decides how elements are manipulated
Local variables
Variables declared inside the JS function- local to the function
Class Expressions
Another way to define a class Can be named or un-named Constructor method can only be used once inside a class Can use "super" keyword to call the constructor of the super class
.reduce();
JS Method passes the callback from one element of array to other ex: accumulator adding up years of experience from different element members of array
Parameters
Variables listed as part of the function definition inside ( ).
Anonymous Functions
Created using the function operator not declaration (no function name) could use var name = function(){
JS Built in constructor objects
new String(); new Array(); new Date();
Objects.freeze();
Freezes an object. Can no longer be changed Prevents new properties from being added, deleted, or changed Also prevents prototype from being changed
Invocation
When event occurs (button click) When called by JS code Automatically (self Invoked)
bind()
JS Method used when function needs to be called later in certain events returns a bound function that when executed later will have correct "this"
JS Function
Block of code designed to perform a task Executed when invoked/called Defined with function keyword, followed by name, followed by ()
Global Variables
Declared outside function: has global scope
Regular Expression
Sequence of characters that form a search pattern Used for text search and tech replace operations 2 string methods: search() and replace()
var
Always function scoped Can be reassigned & redeclared Global scope: declared outside a block Local scope: declared inside
Closures
Combination of a function and lexical environment within which that function was declared (Basically being able to use instances/ variables not completely intuitive to be available because of scope)
let
No hoisting block scoped cant be reassigned or redeclared the strictest one
Destructuring:
new feature in JS ES6 allowing destructure of properties of an object And values in array
Arrays
Technically special type of Objects. Arrays use numbers to access its "elements" [ ]. Can have objects, functions, and arrays inside an array
Why functions?
Use same code many times with different arguments to produce different results
sub classes with "extends"
The "extends" keyword is used in class declarations and expressions to create child class of another class Classes can't extend non-prototype objects
"this" inside an object
refers to the "owner" of the function
Bubbling
When an event happens in an element, it first runs the handlers in it, then in its parents, then all the way up. ex: nested alerts in html
JS classes
special functions with 2 syntax components (class expressions & declarations) To declare use the class keyword and name of class
block scoped
A local scope created from any kind of block including: function blocks, if statements, for/while loops. ex: const and let
3 methods to split an array
splice(); slice(); split()
.length property
returns number of elements. Used in for loop examples
.filter();
JS Method grab certain elements from the array ex: faction:rebels
Prototype Inheritance
All JavaScript objects inherit properties and methods from a prototype: Date objects, Array objects, and Person objects inherit from Object.prototype.
prototype property
The JavaScript prototype property allows you to add new properties to object constructors: Person.prototype.nationality = "English"; (functionName.prototype.newkeyword: value;
const
block-scoped values cant be modified or changed Arn't hoisted Must be declared and initialized at the same time Considered "mutable" (values can be changed) because can modify properties of an object declared with const
split();
Method for splitting arrays. Splits string by separator into new array -ex: separates words in "hello world"
Section 2
(12 cards)