JavaScript.txt

															DATA TYPES:

Numbers:

0-9

Infinity, -Infinity

NaN

	NaN will propagate through an expression, and will return itself 
		as opposed to an error.










															STRINGS:

Must be inside of quotes.

""  &  ''   both serve identically.

		STRING LITERALS	

``          (backticks) can be used to embed something else, such that
		`Two plus two equals ${2 + 2}`;

A string may be a single character eg. (c)


If an error such as 

	unterminated string literal

Go back through and make sure all strings are contained within quotation marks.


The Same type of quotation marks that were used to open the string cannot be contained 
	within the string itself.

	eg
	var bigmouth = 'I've got no right to take my place...';

	This will retrun an error.

This can be overcome by "escaping" the 	character with a backslash \

	var bigmouth = 'I\'ve got no right to take my place...';

	bigmouth; "I've got no right to take my place..."



The Number object can be used to convert a string to a number.

	var myString = '123';
	var myNum = Number(myString);
	typeof myNum;


toString() will convert a number to a string:

	var myNum = 123;
	var myString = myNum.toString();
	typeof myString;









															STRINGS:
															METHODS AND PROPERTIES



															LENGTH

String Length:

The Length Property returns the length of a string:

	var txt = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
	var sln = txt.length; 





															INDEXOF

Finding a String in a String:

The indexOf() returns the index of (the position of) the first occurance of a specified text
in a string.

	var str = "Please locate where 'locate' occurs!";
	var pos = str.indexOf("locate"); \\ 7

The lastIndexOf() method returns the index of the last occurrence of a specified text in a string:





This is similar to search()

	
    The search() method cannot take a second start position argument.
    The indexOf() method cannot take powerful search values (regular expressions).








															EXTRACTING

3 Ways

    slice(start, end)
    substring(start, end)
    substr(start, length)

This example slices out a portion of a string from position 7 to position 13: 

	var str = "Apple, Banana, Kiwi";
	ar res = str.slice(7, 13); \\ Banana

If the numbers in slice() are negative, it will count from the end of the string.

substring() is the same, but it can't accept negative numbers.

substr() is similar to slice(), but the second numbe specifies the length 
what will be cut out after the starting point of the first number

	var str = "Apple, Banana, Kiwi";
	var res = str.substr(7, 6); \\ Banana





															REPLACE

replace() replaces a value in a string with something else.
This does not change the orignal string, but returns a new one.

	str = "Please visit Microsoft!";
	var n = str.replace("Microsoft", "W3Schools");

To replace case insensitive, use a regular expression with an /i flag (insensitive):

	str = "Please visit Microsoft!";
	var n = str.replace(/MICROSOFT/i, "W3Schools");

To replace all instances globally within a string, use a /g flag

	str = "Please visit Microsoft and Microsoft!";
	var n = str.replace(/Microsoft/g, "W3Schools");

To Replace All instances within a string - supported by all modern browsers 2022
	String.prototype.replaceAll()


															      REPEAT
'lol'.repeat(5);
'lollollollollol'



															CONVERT TO UPPERCASE
																or lowercase

toUpperCase()
toLowerCase()

	var text1 = "Hello World!";       // String
	var text2 = text1.toUpperCase();  // text2 is text1 converted to upper 




															CONCATENATION METHOD

concat()    this joins two or more strings

	var text1 = "Hello";
	var text2 = "World";
	var text3 = text1.concat(" ", text2); // Hello World

This can be used instead of the + operator

This would return the same thing as the above

	var text = "Hello" + " " + "World!";
	var text = "Hello".concat(" ", "World!");  	






															REMOVING WHITE SPACE

String.trim()  trims off excess white space at the start and end of a string	








															EXTRACTING STRING CHARACTERS

charAt(position)

	var str = "HELLO WORLD";
	str.charAt(0);            // returns H 


charCodeAt(position)

Returns the unicode of the character at a specified index in a string:

The method returns a UTF-16 code (an integer between 0 and 65535).

	var str = "HELLO WORLD";

	str.charCodeAt(0);         // returns 72 


Property access []


	var str = "HELLO WORLD";
	str[0];                   // returns H 





															CONVERTING A STRING
															TO AN ARRAY

split()

	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 ommitted, it will return the whole string as an array in index[0].

If the separator is "" the returned array will be an array of single characters.



























															BOOLEAN:

True or False

	let nameFieldChecked = true; // yes, name field is checked
	let ageFieldChecked = false; // no, age field is not checked


Booleans also come as the result of comparisons, eg:
	
	let isGreater = 4 > 1;

	alert( isGreater ); // true (the comparison result is "yes")









															NULL:

Empty. Nothing. Refers to Nothing Else. It's just an empty nothing.
It has to be assigned

Explicitly defines something as having no value. Useful for when you want to make it clear in the code that there is no data here.

	let age = null;

		The value of age is unknown











															UNDEFINED:

A value is not assigned

Variables that do not have an assigned value are undefined.
If a variable is declared but not assigned a value,
	the value is undefined

	let x;

	alert(x); // shows "undefined"

Technically, you can do

	let x = 123;

	x = undefined;

	alert(x); // "undefined"

It is advisable to not do this, and to instead assign a value of "null"
to variables that don't have a value.

Undefined can be used as a check to see if a variable has a value.











															OBJECTS & SYMBOLS

object is a non-primitave data type used to store lareger collections of data.

The symbol type is used to create unique lables for objects.














															TYPEOF

The typeof operator returns the type of the argument.

It's useful for processing values of different types differently,
	or for a quick check of what datatype a variable is.

Two forms of Syntax:
	
    As an operator: typeof x

    Function style: typeof(x)

	These both work exactly the same


Examples:

	typeof undefined // "undefined"

	typeof 0 // "number"

	typeof true // "boolean"

	typeof "foo" // "string"

	typeof Symbol("id") // "symbol"

	typeof Math // "object"  (1)

	typeof null // "object"  (2)

	typeof alert // "function"  (3)





















															CONDITIONALS:




															COMPARISONS



A comparison:    <    >    >=    <=    ==      returns a boolean (true, false)

This can be assigned to a variable:

	let result = 5>4; // true




Strings can be compared just as well as numbers

	alert( 'Z' > 'A' ); // true

	alert( 'Glow' > 'Glee' ); // true

	alert( 'Bee' > 'Be' ); // true


	
    1. Compare first characters of both strings.
    2. If the first one is greater(or less), then the first string is greater(or less) than the second. We’re done.
    3. Otherwise if first characters are equal, compare the second characters the same way.
    4. Repeat until the end of any string.
    5. If both strings ended simultaneously, then they are equal. Otherwise the longer string is greater.

Lowercase letters have a higher value than uppercase. Think of the order
Words would be in in a dictionary.



When variables of different types are compared, they are converted to numbers.

	alert( '2' > 1 ); // true, string '2' becomes a number 2
	alert( '01' == 1 ); // true, string '01' becomes a number 1


For Booleans:

	true == 1

	false == 0

It is possible that at the same time:

    Two values are equal.
    One of them is true as a boolean and the other one is false as a boolean.


	let a = 0;
	alert( Boolean(a) ); // false

	let b = "0";
	alert( Boolean(b) ); // true

	alert(a == b); // true!



															STRICT EQUALITY

===

Strict Equality: There is no type conversion with this.


0 == false

"" == false

This is because operands of different types are converted to numbers 
through the equality operator ==


	alert(0 === false); // false, because 0 and false are of different types.

!== Strict non equality operator






															COMPARISON WITH NULL 
															    & UNDEFINED

	alert( null === undefined ); // false

Null == undefined   (This is the only case in which they are equilivent)

These two equal each other in terms of ==
	But not in any other case.



	< > <= >= 
In this case, null (0) and undefined (NaN) are converted to numbers.



	alert( null > 0 );  // (1) false
	alert( null == 0 ); // (2) false
	alert( null >= 0 ); // (3) true

Since comparisons convert null to 0, null > 0 is false

In an equality check, == , null is a special value different from 0
	So null == 0 is false.

In comparison >= , null is converted to 0, so null >= 0 is true.







	alert( undefined > 0 ); // false (1)
	alert( undefined < 0 ); // false (2)
	alert( undefined == 0 ); // false (3)

Undefined can only pass an equality test, == , with Null, nothing else.



To avoid problems, try no never include null/undefined in comparisons. 
Making a separate check for null/undefined is a good idea. 
















															LOGICAL OPERATORS:

|| (or)           && (and)           ! (not)







															|| (OR)

|| can be applied to any value, not just booleans.

	result = a||b;

With booleans, there are four possible outcomes

alert( true || true );  // true
alert( true || false ); // true
alert( false || true ): // true
alert(false || false);  // false



If an operand is not boolean, then it’s converted to boolean for the evaluation.

For instance, a number 1 is treated as true, a number 0 – as false:

Often, || is used as part of an if statement to see if any of the given conditions are correct. 

	let hour = 9;

	if (hour < 10 || hour > 18) {
	  alert( 'The office is closed.' );
	}


This can be applied with more than two values:

	let hour = 12;
	let isWeekend = true;

	if (hour < 10 || hour > 18 || isWeekend) {
 	 alert( 'The office is closed.' ); // it is the weekend
	}



The || operator does the following:

	1. Evaluates operands from left to right
	2. For each operant, convert it to a boolean. If the result is true then stop and return the original
		value of that operand
	3. If all other operands were false, returns the last operand.


	alert( 1 || 0 ); // 1 (1 is truthy)

	alert( true || "no matter what" ); // true is truthy

	alert ( null || 1 ); // 1 (1 is the first truthy value)

	alert ( null || 0 || 1 ) // 1 (the first truthy value)

	alert ( null || undefined || 0 ); // 0 (all falsy, last value returned)





eg: 
	let currentUser = null;
	let defaultUser = "John";
	
	let name = currentUser || defaultUser || "unnamed"


	alert( name ); // selects "John" (The first truthy value).






Operands can be both values and random expressions:

	let x;

	true || (x = 1);

	alert( x ); // undefined ((x = 1) was was not evaluated)

	
	...therefore


	let x;

	false || (x = 1);

	alert(x); // 1











															&& (AND)

	result = a && b;



	alert( true && true); // true
	alert( true && false); // false
	alert( false && true); // false
	alert( false && false); // false




	let hour = 12;
	let minute = 30;

	if (hour == 12 && minute == 30) {
  	alert( 'Time is 12:30' );
	}
	
	


	if (1 && 0) { //evaluate as true and false
	  alert( 'Won't work because the result is falsy)
	}





AND seeks the first falsy value.

	result = value1 && value2 && value3;

&& evaluates as such:
	1. Evaluates from Left to Right
	2. Finds the first falsy value, and returns it.
	3. If all are truthy, returns the last value if no falsy were found.


	// if the first operand is truthy,
	// AND returns the second operand:
	alert( 1 && 0 ); // 0
	alert( 1 && 5 ); // 5
	
	// if the first operand is falsy,
	// AND returns it. The second operand is ignored
	alert( null && 5 ); // null
	alert( 0 && "no matter what" ); // 0




&& Has a higher precedence than ||













															! (NOT)

	result = !value;

	1. Converts the operator to a boolean type (true/false)
	2. Returns an inverse value.




	alert( !true ); // false

	alert (!0 ); // True



A double NOT !! is sometimes used to convert a value to a boolean type:

	alert( !!"non-empty string" ); // true
	alert( !!null ); // false



This would be the same as doing:

	alert( Boolean("non-empty string") ); //true
	alert( Boolean(null) ); // false





! (NOT) has a higher precedence than || , &&
















															Math.object

															
An object built into the JS language that provides a useful set of generalized mathematical stuff. Like rounding, and tangents, and Random, and PI, etc, etc, etc, etc

Math.PI


															IF:

	if (condition) {
 	   block of code to be executed if the condition is true
	} 





															ELSE

	 if (condition) {
	    block of code to be executed if the condition is true
	} else {
	    block of code to be executed if the condition is false
	}





															ELSE IF

	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
	}





															NESTING

	if (condition) {
 	 if (condition2) {
    	  code to be run
  	}
   	 else if (condition3) {
 	     code to be run
	  }
	}



	if (choice === 'sunny') {
	  if (temperature < 86) {
	    para.textContent = 'It is ' + temperature + ' degrees outside — nice and sunny. Let\'s go out to the beach, or the park, and get an ice cream.';
	  } else if (temperature >= 86) {
	    para.textContent = 'It is ' + temperature + ' degrees outside — REALLY HOT! If you want to go outside, make sure to put some suncream on.';
	  }
	}





Logical Operators && and || can be used to condense this:

&&: All conditions must return true.

||: At least one condition must return true.


&& Example:

	if (choice === 'sunny' && temperature < 86) {
	  para.textContent = 'It is ' + temperature + ' degrees outside — nice and sunny. Let\'s go out to the beach, or the park, and get an ice cream.';
	} else if (choice === 'sunny' && temperature >= 86) {
	  para.textContent = 'It is ' + temperature + ' degrees outside — REALLY HOT! If you want to go outside, make sure to put some suncream on.';
	}



|| Example:

	if (iceCreamVanOutside || houseStatus === 'on fire') {
	  console.log('You should leave the house quickly.');
	} else {
	  console.log('Probably should just stay in then.');
	}
  






! Can be used to negate an expression.










															SWITCH:

These are similar to the if..else statements. 

They search throught a number of specific cases given, and only
run the code that is presented under the case that returns true.



	switch (expression) {
	  case choice1:
	    run this code;
	    break;
	
	  case choice2:
	    run this code instead;
	    break;
	    
	  // include as many cases as you like
	
	  default:
	    actually, just run this code;
	}



	1. The Keyword switch
	2. (expression or value) inside parenthesis {
	3. Keyword case followed by a choice that the expression/value could be.
	4. Some code to run if the choice matches the expression.
	5. break statement followed by semicolon; 
		If the case matches the expression/value, the code is run and the browser stops
		executing the code here.

	...as many of these as you need until...

	6. Keyword default:
			run this code;

		This is the default option that runs if none of the cases match the value/expression. 
	}



The Default value can be omitted if it is impossible that none of the cases are met.











															TERNARY OPERATOR:

	( condition ) ? run this code : run this code instead


First code is run if the condition is true
Second Code is run if the condition is false

This is useful if you only have two conditions, true/false, to be met

eg.

	var greeting = ( isBirthday ) ? 'Happy birthday Mrs. Smith — we hope you have a great day!' : 'Good morning Mrs. Smith.';



With this you can run lines of code, execute functions... anything really.

eg: