JavaScript was created by Netscape’s Brendan Eich in 1995. It was originally intended as a simpler scripting language for websites, complementing the use of Java for more complex web applications, but its tight integration with Web pages and built-in support in browsers has caused it to become far more common than Java in web frontends.

JavaScript isn’t just limited to web browsers, though: Node.js, a project that provides a standalone runtime for Google Chrome’s V8 JavaScript engine, is becoming more and more popular.

JavaScript often abbreviated as JS, is a high-level, interpreted programming language that conforms to the ECMAScript specification. It is a programming language that is characterized as dynamic, weakly typed, prototype-based and multi-paradigm.

dynamic (vs static): a variable initially bound to a number may be reassigned to a string

weakly typed (vs strongly): type are distinguish in a weakly manner (looser typing rules and may produce unpredictable results or may perform implicit type conversion at runtime)

prototype-based (vs classic oop): In JavaScript, an object is an associative array, augmented with a prototype. JavaScript uses prototypes where many other object-oriented languages use classes for inheritance.

multi-paradigm: event-driven, functional, and imperative (including object-oriented and prototype-based) programming styles.

Vanilla JS is plain JavaScript code

Object-oriented programming (OOP) is a programming paradigm based on the concept of "objects", which can contain data, in the form of fields (often known as attributes or properties), and code, in the form of procedures (often known as methods or functions).

• Classes (blueprint)
• Object (instance of a blueprint)
• Property
• Method
• Function
• Procedure
• void aka nothing
• Variable
• Class variables (static)
• Instance variables
• Member variables (global var)
• Class methods (static)
• Instance methods
• Class members

Class-based vs prototype-based

• In class-based languages the classes are defined beforehand and the objects are instantiated based on the classes.
• In prototype-based languages the objects are the primary entities. No classes even exist. The prototype of an object is just another object to which the object is linked. Every object has one prototype link (and only one).

										
																							/* 
													this is a 
													multiline comment
												*/
												//this is a single line comment
												"use strict";
												x = 3.14; // This will cause an error because x is not declared
												var a = 10;
												var sum = 5 + 5;
												var diff = 5 - 2;
												var div = 10/2;
												var mul = 10*2;
												var modulo = 11%2;
												var length = 16; // Number
												var lastName = "Johnson"; // String
												var x = {firstName:"John", lastName:"Doe"}; // Object
												var cars = ["Saab", "Volvo", "BMW"]; //Array
												var car; // Value is undefined, type is undefined
												var person = null; // Now value is null, but type is still an object
												var nan = "NaN" - 5;//nan is NaN (not a number)
												var bitshifting = 1 << 2; //=4
												var parenthesis = (1 + 3) * 2; // = 8

												var boolWithOr = true || false;
												var boolWithEnd = true && false;
											
										
									

										
																							var boolWithNot = !true; // not true
												var boolEq = "5" == 5; // true
												var boolTypeCheckEq = "5" === 5; // false
												var notEqOrDifferent = "5" != 5; //false
												var notEqOrDifferentTypeCheck = "5" !== 5; //true
												var greaterThen = 5 > 4; //true
												var lessThen = 5 < 4; //false
												var greaterThenOrEq = 5 >= 5; //true
												var lessThenOrEq = 4 <= 4: //true
												var concatStr = "Hello" + "World";
												var v = 0;
												var res = v++; //or just v++
												var r = ++v; //or just ++v
												v += 1;

												var minus = 0;
												--minus;
												minus--;
												minus -=1;
											
										
									

										
																							var count = 1;
												if (count == 3){
													// evaluated if count is 3
												} else if (count == 4){
													// evaluated if count is 4
												} else {
													// evaluated if it's not either 3 or 4
												}

												// As does `while`.
												while (true){
													// An infinite loop!
												}

												// Do-while loops are like while loops, except they always run at least once.
												var input = 0;
												do {
													input++;
												} while (input <= 5);//input will reach 6
											
										
									

										
																							// The `for` loop is the same as C and Java:
												// initialization; continue condition; iteration.
												for (var i = 0; i < 5; i++){
														// will run 5 times
												}

												//statement_1_0, statement_1_1; statement_2; statement_3_0, statement_3_1
												for(var i = 0, u = 0; i < 5; i++, u+=2) { 
													console.log("u is: ", u); // 0, 2, 4, 6, 8
												}

												// The for/in statement allows iteration over properties of an object.
												var description = "";
												var person = {fname:"Paul", lname:"Ken", age:18};
												for (var x in person){
														description += person[x] + " ";
												} // description = 'Paul Ken 18 '
											
										
									

										
																							var grade = 'B';
												switch (grade) {
													case 'A':
														console.log("Great job");
													break;// or return

													case 'B':
														console.log("OK job");
													break;

													default:
														console.log("Oy vey");
													break;
												}
												
												function test (parameter_1, parameter_2) {
												console.log("I have received: ", parameter_1, parameter_2);
												}
												
												test("argument 1", "argument 2");
												
												var testFunctionExpression = function (param_1) {
													console.log("param_1 is: ", param_1);
												}
												testFunctionExpression();
											
										
									

										
																							// This has led to a common pattern of "JavaScript Immediately-invoked Function Expressions (IIFE),
												// which prevent temporary variables from leaking into the global
												// scope.
												(function (){
													var temporary = 5;
													// We can access the global scope by assigning to the "global object", which
													// in a web browser is always `window`. The global object may have a
													// different name in non-browser environments such as Node.js.
													window.permanent = 10;
													console.log("temporary inside IIFE: ", temporary);
													console.log("window.permanent inside IIFE: ", window.permanent);
												})();
												console.log("temporary outside IIFE: ", temporary);
												console.log("window.permanent outside IIFE: ", window.permanent);