added content

Author: nilaydatta

arithmetic-operators.js

@@ -0,0 +1,17 @@
+a * (b + c)         // grouping
+person.age          // member
+person[age]         // member
+!(a == b)           // logical not
+a != b              // not equal
+typeof a            // type (number, object, function...)
+x << 2  x >> 3      // minary shifting
+a = b               // assignment
+a == b              // equals
+a != b              // unequal
+a === b             // strict equal
+a !== b             // strict unequal
+a < b   a > b       // less and greater than
+a <= b  a >= b      // less or equal, greater or eq
+a += b              // a = a + b (works with - * %...)
+a && b              // logical and
+a || b              // logical or

array-methods.js

@@ -0,0 +1,67 @@
+var dogs = ["Bulldog", "Beagle", "Labrador"]; 
+var dogs = new Array("Bulldog", "Beagle", "Labrador");  // declaration
+
+alert(dogs[1]);             // access value at index, first item being [0]
+dogs[0] = "Bull Terier";    // change the first item
+
+for (var i = 0; i < dogs.length; i++) {     // parsing with array.length
+    console.log(dogs[i]);
+}
+
+dogs.toString();                        // convert to string: results "Bulldog,Beagle,Labrador"
+dogs.join(" * ");                       // join: "Bulldog * Beagle * Labrador"
+dogs.pop();                             // remove last element
+dogs.push("Chihuahua");                 // add new element to the end
+dogs[dogs.length] = "Chihuahua";        // the same as push
+dogs.shift();                           // remove first element
+dogs.unshift("Chihuahua");              // add new element to the beginning
+delete dogs[0];                         // change element to undefined (not recommended)
+dogs.splice(2, 0, "Pug", "Boxer");      // add elements (where, how many to remove, element list)
+var animals = dogs.concat(cats,birds);  // join two arrays (dogs followed by cats and birds)
+dogs.slice(1,4);                        // elements from [1] to [4-1]
+dogs.sort();                            // sort string alphabetically
+dogs.reverse();                         // sort string in descending order
+x.sort(function(a, b){return a - b});   // numeric sort
+x.sort(function(a, b){return b - a});   // numeric descending sort
+highest = x[0];                         // first item in sorted array is the lowest (or highest) value
+x.sort(function(a, b){return 0.5 - Math.random()});     // random order sort
+
+/* More Array Methods */
+
+// Accessing Elements I
+
+a1.concat(a2) // Return new array by joining arrays a1 and a2 together
+a1.join(separator) // Join all elements of array a1 into a string separated by separator arg
+a1.slice(start, end) // Extract a section from start to end of array a1 and return a new array
+a1.indexOf(obj) // Return first index of obj within array a1
+a1.lastIndexOf(obj) // Return last index of obj within array a1
+
+// Iterating I
+
+a1.forEach(fn) // Calls function fn for each element in the array a1
+a1.every(fn) // Return true if every element in array a1 satisfies provided testing function fn
+a1.some(fn) // Return true if at least one element in array a1 satisfies provided testing function fn
+a1.filter(fn) // Create a new array with all elements of array a1 which pass the filtering function fn
+
+// Iterating II
+
+a1.map(fn) // Create a new array with results of calling function fn on every element in array a1
+a1.reduce(fn) // Apply a function fn against an accumulator and each value (from left to right) of the array as to reduce it to a single value
+a1.reduceRight(fn) // Apply a function fn against an accumulator and each value (from right to left) of the array as to reduce it to a single value
+
+// Mutating I
+
+a1.pop() // Remove and return last element from array a1
+a1.push(obj) // Add obj to end of array a1 and return new length
+a1.reverse() // Reverse order of elements of array a1 in place
+a1.sort() // Sort the elements of array a1 in place
+a1.splice(start, deleteCount, items) // Change content of array a1 by removing existing elements and/or adding new elements
+a1.unshift(obj) // Add obj to start of array a1 and return new length
+
+// General I
+
+a1.toString() // Return a string representing array a1 and its elements (same as a1. join(','))
+a1.toLocaleString() // Return a localized string representing array a1 and its elements (similar to a1.join(','))
+Array.isArray(var) // Return true if var is an array
+a1.length // Return length of array a1
+a1[0] // Access first element of array a1

data-types.js

@@ -0,0 +1,13 @@
+var age = 18; // number
+var name = "Jane"; // string
+var name = { first: "Jane", last: "Doe" }; // object
+var truth = false; // boolean
+var sheets = ["HTML", "CSS", "JS"]; // array
+var a;
+typeof a; // undefined
+var a = null; // value null
+
+false, true; // boolean
+18, 3.14, 0b10011, 0xf6, NaN; // number
+"flower", "John"; // string
+undefined, null, Infinity; // special

if-else.js

@@ -0,0 +1,21 @@
+var age = 23;
+var status = "N/A";
+
+if (age < 0) {
+  // logical condition
+  status = "Please enter a valid age"; // executed if condition is true
+} else if (age >= 0 && age <= 3) {
+  // else if block comes next
+  status = "Toddler";
+} else if (age >= 4 && age <= 12) {
+  status = "Kid"; 
+} else if (age >= 13 && age <= 17) {
+  status = "Teenager";
+} else if (age >= 18 && age <= 39) {
+  status = "Young Adult"
+} else if (age >= 40 && age <= 59) {
+  status = "Middle Aged Adult";
+} else (age >= 60) {
+  // Executed if all other conditions fail
+  status = "Old and Senior Citizen"
+}

js-global-functions.js

@@ -0,0 +1,71 @@
+var abc = "abcdefghijklmnopqrstuvwxyz";
+var esc = 'I don\'t \n know';   // \n new line
+var len = abc.length;           // string length
+abc.indexOf("lmno");            // find substring, -1 if doesn't contain 
+abc.lastIndexOf("lmno");        // last occurance
+abc.slice(3, 6);                // cuts out "def", negative values count from behind
+abc.replace("abc","123");       // find and replace, takes regular expressions
+abc.toUpperCase();              // convert to upper case
+abc.toLowerCase();              // convert to lower case
+abc.concat(" ", str2);          // abc + " " + str2
+abc.charAt(2);                  // character at index: "c"
+abc[2];                         // unsafe, abc[2] = "C" doesn't work
+abc.charCodeAt(2);              // character code at index: "c" -> 99
+abc.split(",");                 // splitting a string on commas gives an array
+abc.split("");                  // splitting on characters
+128.toString(16);               // number to hex(16), octal (8) or binary (2)
+
+/* More Strings Methods */
+
+var str = "Hello World";
+var str1 = "United States of America";
+var str2 = "states";
+
+// Basics I
+
+str.length // Return length of string str
+str[n] // Return nth character of string str
+str.charAt(index) // Return character in string str at specified index
+str.toLowerCase() // Convert string str to lower case
+str.toUpperCase() // Convert string str to upper case
+
+// General I
+
+str.indexOf(substr) // Return first index within string str of substring substr
+str.split(separator) // Split string str into an array of substrings separated by param separator
+str.trim() // Trim whitespace from beginning and end of string str
+str1 < str2 // Return true if str1 is less than str2
+str1 > str2 // return true if str1 is greater than str2
+
+// Experimental I
+
+str.codePointAt(index) // Return non-negative int from string str that is the UTF-16 encoded code point at given index
+str1.includes(str2) // Return true if str2 is found in string str1
+str1.endsWith(str2) // Return true if string str1 ends with string str2
+str.normalize() // Return Unicode Normalization Form of string str
+str.repeat(int) // Return string repeated int times of string str
+str1.startsWith(str2) // Return true if string str1 starts with str2
+str[@@iterator]() // Return a new Iterator that iterates over the code points of string str, returning each code point as String value
+
+// General II
+
+str.charCodeAt(index) // Return number indicating Unicode value of char at given index of string str
+str1.concat(str2) // Combine text of strings str1 and str2 and return a new string
+str.lastIndexOf(substr) // Return last index within string str of substring substr
+str.slice(start, end) // Extract a section of string str from start to end
+str.substr(start, length) // Return characters in string str from start having length length
+
+// General III
+
+str.substring(index1, index2) // Return subset of string str between index1 and index2
+str.toLocaleLowerCase() //Convert chars in string str to lower case while respecting current locale
+str.toLocaleUpperCase() // Convert chars in string str to upper case while respecting current locale
+str.trimLeft() // Trim whitespace from left side of string st
+str.trimRight() // Trim whitespace form right side of string str
+
+// General IV
+
+str1.localeCompare(str2) // Return -1, 0, or 1 indicating if string str1 is less than, equal to, or greater than str2
+str.match(regexp) // Match a regular expression regexp against string str
+str1.replace(regexp, str2) // Replace matched regexp elements in string str1 with string str2
+str.search(regexp) // Return position of search for a match between regexp and string str

string-methods.js

@@ -0,0 +1,13 @@
+switch (
+  new Date().getDay() // input is current day
+) {
+  case 6: // if (day == 6)
+    text = "Saturday";
+    break;
+  case 0: // if (day == 0)
+    text = "Sunday";
+    break;
+  default:
+    // else...
+    text = "Weekday";
+}

switch-case.js

@@ -0,0 +1,14 @@
+var a; // variable
+var b = "init"; // string
+var c = "Hi" + " " + "Joe"; // = "Hi Joe"
+var d = 1 + 2 + "3"; // = "33"
+var e = [2, 3, 5, 8]; // array
+var f = false; // boolean
+var g = /()/; // RegEx
+var h = function() {}; // function object
+
+const PI = 3.14; // constant
+var a = 1,
+  b = 2,
+  c = a + b; // one line
+let z = "zzz"; // block scope local variable