Section 1
Preview this deck
return
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 (185)
Section 1
(50 cards)
return
exists a function
null === undefined // false null == undefined // true
null === undefined // false null == undefined // true
10!
10 factorial
EVENT EQUENE
The browser has an event loop which checks the event queue and processes pending events. For example, if an event happens in the background (e.g., a script onload event) while the browser is busy (e.g., processing an onclick), the event gets appended to the queue. When the onclick handler is complete, the queue is checked and the event is then handled (e.g., the onload script is executed). Similarly, setTimeout() also puts execution of its referenced function into the event queue if the browser is busy.
( ) operator
Using the example above, toCelsius refers to the function object, and toCelsius() refers to the function result. Accessing a function without () will return the function definition instead of the function result:
JavaScript Types are Dynamic
JavaScript has dynamic types. This means that the same variable can be used to hold different data types:
closure
\
backslash
setTimeout()
Calls a function or evaluates an expression after a specified number of milliseconds setTimeout(function(){ alert("Hello"); }, 3000);
use strict
a way to voluntarily enforce stricter parsing and error handling on your JavaScript code at runtime. Code errors that would otherwise have been ignored or would have failed silently will now generate errors or throw exceptions. In general, it is a good practice.
= is the assign operator
comments
code after // or between / and / will be treated as comment
for (let i = 0; i < 5; i++) { setTimeout(function() { console.log(i); }, i * 1000 ); }
It will print 0 1 2 3 4, because we use let instead of var here. The variable i is only seen in the for loop's block scope.
Accessing Object Methods
objectName.methodName() If you access a method without the () parentheses, it will return the function definition:
"5" + 5 = 55
When adding a number and a string, JavaScript will treat the number as a string.
object key
When setting an object property, JavaScript will implicitly stringify the parameter value. In this case, since b and c are both objects, they will both be converted to "[object Object]"
CSS
Cascading Style Sheets (CSS) are used to describe the appearance or presentation of content on a webpage.
NaN
The NaN property represents a value that is "not a number". This special value results from an operation that could not be performed either because one of the operands was non-numeric (e.g., "abc" / 4), or because the result of the operation is non-numeric. A better solution would either be to use value !== value, which would only produce true if the value is equal to NaN. Also, ES6 offers a new Number.isNaN() function, which is a different and more reliable than the old global isNaN() function.
this keyword
In a function definition, this refers to the "owner" of the function. In the example above, this is the person object that "owns" the fullName function. In other words, this.firstName means the firstName property of this object.
common html events
<element event='some JavaScript'> onchange An HTML element has been changed onclick The user clicks an HTML element onmouseover The user moves the mouse over an HTML element onmouseout The user moves the mouse away from an HTML element onkeydown The user pushes a keyboard key onload The browser has finished loading the page
parameters vs arguments
Function parameters are listed inside the parentheses () in the function definition. Function arguments are the values received by the function when it is invoked.
HTTP
HyperText Transfer Protocol (HTTP) is used to deliver HTML and other hypermedia documents on the web.
JS quotes
JavaScript has dynamic types. This means that the same variable can be used to hold different data types:
hoisting (function () { try { throw new Error(); } catch (x) { var x = 1, y = 2; console.log(x); } console.log(x); console.log(y); })();
var statements are hoisted (without their value initialization) to the top of the global or function scope it belongs to, even when it's inside a with or catch block. However, the error's identifier is only visible inside the catch block. It is equivalent to: (function () { var x, y; // outer and hoisted try { throw new Error(); } catch (x / inner /) { x = 1; // inner x, not the outer one y = 2; // there is only one y, which is in the outer scope console.log(x / inner /); } console.log(x); console.log(y); })();
HTML
HyperText Markup Language (HTML) is used to describe and define the content of a webpage.
Object Methods
A method is a function stored as a property. Objects can also have methods. Methods are actions that can be performed on objects. Methods are stored in properties as function definitions. var person = { firstName: "John", lastName : "Doe", id : 5566, fullName : function() { return this.firstName + " " + this.lastName; } }
javascript objects
containers for variables called properties and methods
return statement
When JavaScript reaches a return statement, the function will stop executing.
Accessing Object Properties
You can access object properties in two ways: objectName.propertyName or objectName["propertyName"]
{ }
curly bracket
JS
JavaScript is the programming language that runs in your browser. You can use it to add interactivity and other dynamic features to your website or application. With the advent of Node.js, you can also run JavaScript on the server.
javascript identifiers
the first letter must be a letter, an underscore _, or a dollar sign. Subsequent characters may be letters digits, underscores, or dollar signs
Local Variables
Variables declared within a JavaScript function, become LOCAL to the function. Local variables can only be accessed from within the function.
console.log(sum(2,3)); // Outputs 5 console.log(sum(2)(3)); // Outputs 5
function sum(x) { if (arguments.length == 2) { return arguments[0] + arguments[1]; } else { return function(y) { return x + y; }; } }
How do you add an element at the begining of an array? How do you add one at the end?
var myArray = ['a', 'b', 'c', 'd']; myArray.push('end'); myArray.unshift('start'); console.log(myArray); // ["start", "a", "b", "c", "d", "end"] With ES6, one can use the spread operator: myArray = ['start', ...myArray]; myArray = [...myArray, 'end']; Or, in short: myArray = ['start', ...myArray, 'end'];
var hero = { _name: 'John Doe', getSecretIdentity: function (){ return this._name; } }; var stoleSecretIdentity = hero.getSecretIdentity;
The first console.log prints undefined because we are extracting the method from the hero object, so stoleSecretIdentity() is being invoked in the global context (i.e., the window object) where the _name property does not exist.
Object Properties
The name:values pairs in JavaScript objects are called properties:
breaking longlines
If a JavaScript statement does not fit on one line, the best place to break it is after an operator:
typeOf(undefined)
is undefined
a unary operation is an operation with only one operand, i.e. a single input
goes
var x = 21; var girl = function () { console.log(x); var x = 20; }; girl ();
Neither 21, nor 20, the result is undefined It's because JavaScript initialization is not hoisted. (Why doesn't it show the global value of 21? The reason is that when the function is executed, it checks that there's a local x variable present but doesn't yet declare it, so it won't look for global one.)
promise
semi column
The reason for this has to do with the fact that semicolons are technically optional in JavaScript (although omitting them is generally really bad form). As a result, when the line containing the return statement (with nothing else on the line) is encountered in foo2(), a semicolon is automatically inserted immediately after the return statement.
console.log(0.1 + 0.2); console.log(0.1 + 0.2 == 0.3);
An educated answer to this question would simply be: "You can't be sure. it might print out 0.3 and true, or it might not. Numbers in JavaScript are all treated with floating point precision, and as such, may not always yield the expected results."
JavaScript Expressions
An expression is a combination of values, variables, and operators, which computes to a value. The computation is called an evaluation.
typeOf(null)
is an Object
javascript is a loosely typed language
string + number => string
hoisting
[ ]
square bracket
closure
an inner function that has access to the variables in the outer (enclosing) function's scope chain. The closure has access to variables in three scopes; specifically: (1) variable in its own scope, (2) variables in the enclosing function's scope, and (3) global variables.
Section 2
(50 cards)
Re-Declaring JavaScript Variables
when a js variable is redeclared, it will not lose its value. var carName = "Volvo"; var carName; //still have the value Volvo
NaN is a number: typeof NaN returns number:
slice(start, end)
end is not included
Assignment Operator
=, +=, -=, =, /=, %/, *=
Number Methods
- num.toString() - num.toExponential(num(optional, defines the number of characters behind the decimal point)) ->returns a string, with a number rounded and written using exponential notation. - num.toFixed(num(optional, # of specific decimals)) returns a string, with the number written with a specified number of decimals: - num.toPrecision(num(optional)) returns a string, with a number written with a specified length: -num.valueOf() returns a number as a number. -> The valueOf() method is used internally in JavaScript to convert Number objects to primitive values. There is no reason to use it in your code. All JavaScript data types have a valueOf() and a toString() method. Global JavaScript Methods Converting Variables to Numbers The Number() method The parseInt() method -> parseInt() parses a string and returns a whole number. Spaces are allowed. Only the first number is returned: The parseFloat() method -> parseFloat() parses a string and returns a number. Spaces are allowed. Only the first number is returned: If the number cannot be converted, NaN (Not a Number) is returned Number Properties Property Description MAX_VALUE Returns the largest number possible in JavaScript MIN_VALUE Returns the smallest number possible in JavaScript POSITIVE_INFINITY Represents infinity (returned on overflow) NEGATIVE_INFINITY Represents negative infinity (returned on overflow) NaN Represents a "Not-a-Number" value Number Properties Cannot be Used on Variables Number properties belongs to the JavaScript's number object wrapper called Number. These properties can only be accessed as Number.MAX_VALUE. Using myNumber.MAX_VALUE, where myNumber is a variable, expression, or value, will return undefined:
The toPrecision() Method
returns string var x = 9.656; x.toPrecision(); // returns 9.656 x.toPrecision(2); // returns 9.7 x.toPrecision(4); // returns 9.656 x.toPrecision(6); // returns 9.65600
comparison operators
Operator Description == equal to === equal value and equal type != not equal !== not equal value or not equal type > greater than < less than >= greater than or equal to <= less than or equal to ? ternary operator
replace()
The replace() method does not change the string it is called on. It returns a new string. the replace() method replaces only the first match:
undefined null
undefined has both undefined value and type null has null value, but object type
JS String Operators
when used on strings, the + operator is called the concatenation operator.
backslash escape character
The backslash (\) escape character turns special characters into string characters: Code Result Description \' ' Single quote \" " Double quote \\ \ Backslash
Operator Precedence Values
in general (highest first): ( ) -> expression grouping accessing the attribute ++ ! typeOf normal arithmetic operations non equal comparison operations in instanceof equal/unequal comparison operations tertiary operation assignment
complex data
typeof can return one of two complex types: function object -> both objects, arrays and null, in javascript arrays are objects
Arrays are Objects
Arrays are a special type of objects. The typeof operator in JavaScript returns "object" for arrays. Because of this, you can have variables of different types in the same Array. But, JavaScript arrays are best described as arrays. Arrays use numbers to access its "elements". In this example, person[0] returns John: Objects use names to access its "members". In this example, person.firstName returns John:
To replace case insensitive, use a regular expression with an /i flag (insensitive):
str = "Please visit Microsoft!"; var n = str.replace(/MICROSOFT/i, "W3Schools");
You can declare many variables in one statement
var person = "John Doe", carName = "Volvo", price = 200; A declaration can span multiple lines var person = "John Doe", carName = "Volvo", price = 200;
typeof Infinity; // returns "number"
x.toString();
Arrays properties and methos
.length .sort() accessing the last element of array, array doesn't take in negative index fruits = ["Banana", "Orange", "Apple", "Mango"]; var last = fruits[fruits.length - 1]; .forEach(function) .push(element) -> add add the end; use [] may create holes, empty Array.isArray(array) fruits instanceof Array; // returns true
Type Operators
Operator Description typeof Returns the type of a variable instanceof Returns true if an object is an instance of an object type
str.length
returns the number of characters in the given string (int)
There are 3 methods for extracting string characters: charAt(position) charCodeAt(position) Property access [ ]
A string can be converted to an array with the split() method:
var txt = "a,b,c,d,e"; // String txt.split(","); // Split on commas txt.split(" "); // Split on spaces txt.split("|"); // Split on pipe If the separator is omitted, the returned array will contain the whole string in index [0]. If the separator is "", the returned array will be an array of single characters:
JavaScript Numbers are Always 64-bit Floating Point
The maximum number of decimals is 17, but floating point arithmetic is not always 100% accurate: var x = 0.2 + 0.1; // x will be 0.30000000000000004 var x = (0.2 10 + 0.1 10) / 10; // x will be 0.3
lastIndexOf()
returns the index of the last occurrence of a specified text in a string Both methods accept a second parameter as the starting position for the search:
Comparing two JavaScript objects will always return false.
Comparing two JavaScript objects will always return false.
JavaScript Types are Dynamic
same variable can be used to hold different data types: var x; // Now x is undefined x = 5; // Now x is a Number x = "John"; // Now x is a String
All string methods return a new string. They don't modify the original string. Formally said: Strings are immutable: Strings cannot be changed, only replaced
var text2 = text1.toUpperCase(); var text2 = text1.toLowerCase(); var text3 = text1.concat(" ", text2); The trim() method removes whitespace from both sides of a string:
Infinity (or -Infinity) is the value JavaScript will return if you calculate a number outside the largest possible number.
var x = 2 / 0; // x will be Infinity var y = -2 / 0; // y will be -Infinity
var x = "100"; var y = "10"; var z = x / y; // z will be 10 var x = "100"; var y = "10"; var z = x - y; // z will be 90 but not with +
JavaScript will try to convert strings to numbers in all numeric operations:
A safer way to break up a string, is to use string addition:
document.getElementById("demo").innerHTML = "Hello " + "Dolly!";
Integers (numbers without a period or exponent notation) are accurate up to 15 digits.
var x = (0.2 10 + 0.1 10) / 10; // x will be 0.3
var str = "Please locate where 'locate' occurs!"; var pos = str.search("locate");
the search() method searches a string for a specified value and returns the position of the match:
The Number() Method
Number(true); // returns 1 Number(false); // returns 0 Number("10"); // returns 10 Number(" 10"); // returns 10 Number("10 "); // returns 10 Number(" 10 "); // returns 10 Number("10.33"); // returns 10.33 Number("10,33"); // returns NaN Number("10 33"); // returns NaN Number("John"); // returns NaN
substring(start, end) substr(start, length)
The difference is that substring() cannot accept negative indexes. substr - The difference is that the second parameter specifies the length of the extracted part.
logical operators
Operator Description && logical and || logical or ! logical not
indexOf(
returns the index of (the position of) the first occurrence of a specified text in a string: Both methods accept a second parameter as the starting position for the search:
var x = 100 / "Apple"; isNaN(x); // returns true because x is Not a Number
global JavaScript function isNaN()
Arithmetic Operators
+, -, *, /, %, ++, --
x.toExponential(2);
parseFloat()
parseFloat() parses a string and returns a number. Spaces are allowed. Only the first number is returned: parseFloat("10"); // returns 10 parseFloat("10.33"); // returns 10.33 parseFloat("10 20 30"); // returns 10 parseFloat("10 years"); // returns 10 parseFloat("years 10"); // returns NaN
declaring a variable
after the declaration, the variable has no value, or has the value of undefined
Primitive Data
typeof can return one of these primitive types string number boolean undefined
list String methos
All string methods return a new string. They don't modify the original string. Formally said: Strings are immutable: Strings cannot be changed, only replaced. - length find a string in a string: - indexOf(str, start(optional)) - lastIndexOf(str, start(optional)) - search(str/regex) extracting string parts - slice (start, end(optional, end not included)) -> returns the sliced string, (takes negative index, Negative positions do not work in Internet Explorer 8 and earlier. ) - substring (start, end (optional)) -> similar to slice but can't accept negative indexes - substr (start, length(optional)) -> takes negative parameter for the start replace a string content - replace(toBeReplaced, new str) -> only replace the first match, and the updated string is returned, the string it called on is not changed - can use regex to replace insensitive and global matches - .toUpperCase() - .toLowerCase() - the original string is not changed var text3 = text1.concat(" ",text2,"check","another one"); -> join two or more strings String.trim() -> removes white spaces on both sides of the string You can also use the replace solution above to add a trim function to the JavaScript String.prototype: Extracting String Characters - charAt(position) - charCodeAt(position) - Property access [ ] //not recommend Converting a String to an Array txt.split("char") If the separator is omitted, the returned array will contain the whole string in index [0]. If the separator is "", the returned array will be an array of single characters:
The valueOf() Method
valueOf() returns a number as a number. var x = 123; x.valueOf(); // returns 123 from variable x (123).valueOf(); // returns 123 from literal 123 (100 + 23).valueOf(); // returns 123 from expression 100 + 23
To replace all matches, use a regular expression with a /g flag (global match):
str = "Please visit Microsoft and Microsoft!"; var n = str.replace(/Microsoft/g, "W3Schools");
You can also break up a code line within a text string with a single backslash:
document.getElementById("demo").innerHTML = "Hello \ Dolly!"; The \ method is not the preferred method. It might not have universal support. Some browsers do not allow spaces behind the \ character.
The parseInt() Method
parseInt() parses a string and returns a whole number. Spaces are allowed. Only the first number is returned: parseInt("10"); // returns 10 parseInt("10.33"); // returns 10 parseInt("10 20 30"); // returns 10 parseInt("10 years"); // returns 10 parseInt("years 10"); // returns NaN
toFixed()
toFixed() returns a string, with the number written with a specified number of decimals: var x = 9.656; x.toFixed(0); // returns 10 x.toFixed(2); // returns 9.66 x.toFixed(4); // returns 9.6560 x.toFixed(6); // returns 9.656000
String methods
Primitive values, like "John Doe", cannot have properties or methods (because they are not objects). But with JavaScript, methods and properties are also available to primitive values, because JavaScript treats primitive values as objects when executing methods and properties.
Section 3
(50 cards)
Array.reduce()
The reduce() method does not reduce the original array. var numbers1 = [45, 4, 9, 16, 25]; var sum = numbers1.reduce(myFunction); function myFunction(total, value, index, array) { return total + value; } The reduce() method can accept an initial value: var sum = numbers1.reduce(myFunction, 100);
The Compare Function
The purpose of the compare function is to define an alternative sort order. The compare function should return a negative, zero, or positive value, depending on the arguments: function(a, b){return a - b} When the sort() function compares two values, it sends the values to the compare function, and sorts the values according to the returned (negative, zero, positive) value. If the result is negative a is sorted before b. If the result is positive b is sorted before a. If the result is 0 no changes is done with the sort order of the two values.
var fruits = ["Banana", "Orange", "Apple", "Mango"]; fruits.splice(2, 0, "Lemon", "Kiwi");
The first parameter (2) defines the position where new elements should be added (spliced in). The second parameter (0) defines how many elements should be removed. The rest of the parameters ("Lemon" , "Kiwi") define the new elements to be added. The splice() method returns an array with the deleted items:
In JavaScript, arrays always use numbered indexes.
Array.some(function)
The some() method check if some array values pass a test.
var fruits = ["Banana", "Orange", "Apple", "Mango"]; fruits.sort(); // First sort the elements of fruits fruits.reverse(); // Then reverse the order of the elements
Everything With a "Value" is True
Everything Without a "Value" is False
Numeric Sort By default, the sort() function sorts values as strings. This works well for strings ("Apple" comes before "Banana"). However, if numbers are sorted as strings, "25" is bigger than "100", because "2" is bigger than "1". Because of this, the sort() method will produce incorrect result when sorting numbers. You can fix this by providing a compare function:
var points = [40, 100, 1, 5, 25, 10]; points.sort(function(a, b){return a - b});
for loop
for (i = 0; i < 5; i++) { text += "The number is " + i + "<br>"; } statement 1 is optional, can initialize multiple values or initialize it outside of the loop statement 2 is also optional, always returns true statement 3 can be optional and the couter value can be edited inside the loop
Find the Highest (or Lowest) Array Value
There are no built-in functions for finding the max or min value in an array. However, after you have sorted an array, you can use the index to obtain the highest and lowest values. Sorting a whole array is a very inefficient method if you only want to find the highest (or lowest) value. Math.max.apply(null, [1, 2, 3]) is equivalent to Math.max(1, 2, 3). Math.min.apply(null, [1, 2, 3]) is equivalent to Math.min(1, 2, 3). The fastest solution is to use a "home made" method. function myArrayMax(arr) { var len = arr.length var max = -Infinity; while (len--) { if (arr[len] > max) { max = arr[len]; } } return max; }
Array.findIndex()
The findIndex() method returns the index of the first array element that passes a test function.
pop()
The pop() method removes the last element from an array: The pop() method returns the value that was "popped out":
Comparing Different Types
When comparing a string with a number, JavaScript will convert the string to a number when doing the comparison. An empty string converts to 0. A non-numeric string converts to NaN which is always false. When comparing two strings, "2" will be greater than "12", because (alphabetically) 1 is less than 2.
JavaScript Break and Continue
The break statement "jumps out" of a loop. The continue statement "jumps over" one iteration in the loop.
In JavaScript, arrays use numbered indexes. In JavaScript, objects use named indexes.
Merging (Concatenating) Arrays
var myGirls = ["Cecilie", "Lone"]; var myBoys = ["Emil", "Tobias", "Linus"]; var myChildren = myGirls.concat(myBoys); // Concatenates (joins) myGirls and myBoys
Array.forEach(function)
var txt = ""; var numbers = [45, 4, 9, 16, 25]; numbers.forEach(myFunction); function myFunction(value, index, array) { txt = txt + value + "<br>"; } Note that the function can take 3 arguments: The item value The item index The array itself
Array.map(function)
The map() method creates a new array by performing a function on each array element. The map() method does not execute the function for array elements without values. The map() method does not change the original array.
JS Math Object
Math.PI Math.round() -> returns the value of x rounded to its nearest integer Math.pow(base, power) Math.sqrt() Math.abs() Math.ceil() Math.floor() Math.min() and Math.max() Math.random() returns a random number between 0 (inclusive), and 1 (exclusive):
Sorting Object Arrays
cars.sort(function(a, b){return a.year - b.year}); Comparing string properties is a little more complex: cars.sort(function(a, b){ var x = a.type.toLowerCase(); var y = b.type.toLowerCase(); if (x < y) {return -1;} if (x > y) {return 1;} return 0; });
comparison operators
if (age < 18) text = "Too young";
Array.reduceRight()
The reduceRight() works from right-to-left in the array. See also reduce().
The unshift() method adds a new element to an array (at the beginning), and "unshifts" older elements:
The unshift() method returns the new array length.
fruits.join(" * ");
The join() method also joins all array elements into a string. It behaves just like toString(), but in addition you can specify the separator:
Array methods
array.toString() -> Banana,Orange,Apple,Mango array.join(separator) -> without separator works like toString array.pop() -> pops out the last element array.push() -> adds a new element, and returns the array length array.shift() -> removes the first element array.unshift -> adds a new element to array, and returns the array length fruits[0] = "Kiwi"; -> change element delete fruits[0]; -> change the first element to undefined, empty array.splice(start, # removed, ...newelements to be added (optional)) -> returns an array with the deleted items slice(start, end(optional)) The slice() method creates a new array. It does not remove any elements from the source array. array1.concat(array2, arr3...(any number))-> does not change the existing arrays, it always returns a new array There are no built-in functions for finding the highest or lowest value in a JavaScript array.
shift() method removes the first array element and "shifts" all other elements to a lower index.
The shift() method returns the string that was "shifted out":
Array.reduce(function)
The reduce() method runs a function on each array element to produce (reduce it to) a single value. The reduce() method works from left-to-right in the array. See also reduceRight(). The reduce() method does not reduce the original array. var numbers1 = [45, 4, 9, 16, 25]; var sum = numbers1.reduce(myFunction); function myFunction(total, value, index, array) { return total + value; } gives the sum 99
Math.max.apply(null, [1, 2, 3]) is equivalent to Math.max(1, 2, 3).
You can use Math.min.apply to find the lowest number in an array:
Array.reduceRight(function)
The reduceRight() works from right-to-left in the array.
Arrays
Access the Elements of an Array var item = array[index] changing an element array[index] = item
Array.find(function)
The find() method returns the value of the first array element that passes a test function. This example finds (returns the value of) the first element that is larger than 18: var numbers = [4, 9, 16, 25, 29]; var first = numbers.find(myFunction); function myFunction(value, index, array) { return value > 18; } returns 25
The Do/While Loop
do { // code block to be executed } while (condition);
switch statement
switch(expression) { case x: // code block break; case y: // code block break; default: // code block } The default keyword specifies the code to run if there is no case match: The default case does not have to be the last case in a switch block: If it is not to the end, end it with a break. Note: If you omit the break statement, the next case will be executed even if the evaluation does not match the case.
The For/In Loop
The JavaScript for/in statement loops through the properties of an object: var person = {fname:"John", lname:"Doe", age:25};
JS Array Iteration Methods
function myFunction(value, index, array) { txt = txt + value + "<br>"; } Array.forEach(function) -> method calls a function (a callback function) once for each array element. newArray = Array.map(function) -> creates a new array -> return value * 2; Array.filter(function) -> return value > 18, creates a new array with array elements that passes a test Array.reduce() Array.reduceRight() result = Array.every(function) -> checks if all array values pass as test; result is true or false result = Array.some(function) -> checks if some array values pass a test; result returns true or false array.indexOf(element, start(optional, can be -)) -> return element's position; returns -1 if the item is not found array.lastIndexOf(item, start(optional, can be negative)) array.find(function) -> returns the value of the first array element that passes a test function Array.findIndex(function) -> returns the index of the first array element that passes a test function
Array.every(function)
var numbers = [45, 4, 9, 16, 25]; var allOver18 = numbers.every(myFunction); //return true or false, depend on if all numbers pass the test function myFunction(value, index, array) { return value > 18; }
Sometimes you will want different switch cases to use the same code.
switch (new Date().getDay()) { case 4: case 5: text = "Soon it is Weekend"; break; case 0: case 6: text = "It is Weekend"; break; default: text = "Looking forward to the Weekend"; } Switch cases use strict comparison (===).
Array.isArray(fruits); // returns true
slice() method slices out a piece of an array into a new array.
The slice() method can take two arguments like slice(1, 3). The method then selects elements from the start argument, and up to (but not including) the end argument. If the end argument is omitted, like in the first examples, the slice() method slices out the rest of the array.
Converting Arrays to Strings
The JavaScript method toString() converts an array to a string of (comma separated) array values. Banana,Orange,Apple,Mango
JS Array Sort
array.sort() array.reverse() reverse the order of the lements By default, the sort() function sorts values as strings. This works well for strings ("Apple" comes before "Banana"). However, if numbers are sorted as strings, "25" is bigger than "100", because "2" is bigger than "1". it's best to sort numbers using a compare function var points = [40, 100, 1, 5, 25, 10]; points.sort(function(a, b){return a - b}); If the result is negative a is sorted before b. If the result is positive b is sorted before a. If the result is 0 no changes is done with the sort order of the two values.
Sorting Object Arrays
Even if objects have properties of different data types, the sort() method can be used to sort the array. The solution is to write a compare function to compare the property values: cars.sort(function(a, b){return a.year - b.year}); comparing string properties is a little more complex: cars.sort(function(a, b){ var x = a.type.toLowerCase(); var y = b.type.toLowerCase(); if (x < y) {return -1;} if (x > y) {return 1;} return 0; });
array.sort()
whileloop
while (i < 10) { text += "The number is " + i; i++; }
if statement
if (condition1) { // block of code to be executed if condition1 is true } else if (condition2) { // block of code to be executed if the condition1 is false and condition2 is true } else { // block of code to be executed if the condition1 is false and condition2 is false }
Array.filter(function)
The filter() method creates a new array with array elements that passes a test.
push() method adds a new element to an array (at the end):
The push() method returns the new array length:
Conditional (Ternary) Operator
variablename = (condition) ? value1:value2 var voteable = (age < 18) ? "Too young":"Old enough";
Finding Max and Min Values in an Array
There are no built-in functions for finding the highest or lowest value in a JavaScript array.
array.indexOf(item, start) array.lastIndexOf(item, start)
Array.lastIndexOf() is the same as Array.indexOf(), but searches from the end of the array.
Section 4
(35 cards)