Basic Javascript

Question 1

arr.unshift(element1[, …[, elementN]])

Answer 1

The unshift() method adds one or more elements to the beginning of an array and returns the new length of the array.

Question 2

arr.shift()

Answer 2

The shift() method removes the first element from an array and returns that removed element. This method changes the length of the array.

Question 3

arr.push(element1[, …[, elementN]])

Answer 3

The push() method adds one or more elements to the end of an array and returns the new length of the array.

Question 4

arr.pop()

Answer 4

The pop() method removes the last element from an array and returns that element. This method changes the length of the array.

Question 5

undefined

Answer 5

undefined is a primitive value automatically assigned to variables that have just been declared, or to formal arguments for which there are no actual arguments.

Question 6

null

Answer 6

The value null represents the intentional absence of any object value. It is one of JavaScript’s primitive values and is treated as falsy for boolean operations.

Question 7

falsy

Answer 7

A falsy (sometimes written falsey) value is a value that is considered false when encountered in a Boolean context.

if (false)
if (null)
if (undefined)
if (0)
if (-0)
if (0n)
if (NaN)
if ("")

Question 8

NaN

Answer 8

The initial value of NaN is Not-A-Number — the same as the value of Number.NaN. In modern browsers, NaN is a non-configurable, non-writable property. Even when this is not the case, avoid overriding it.

Question 9

parameter

Answer 9

Parameters are variables that act as placeholders for the values that are to be input to a function when it is called. When a function is defined, it is typically defined along with one or more parameters. The actual values that are input (or “passed”) into a function when it is called are known as arguments.

Question 10

argument

Answer 10

An argument is a value (primitive or object) passed as input to a function.

Question 11

differences between parameter & argument

Answer 11

Function parameters are the names listed in the function’s definition.

Function arguments are the real values passed to the function.

Parameters are initialized to the values of the arguments supplied.

Question 12

let

Answer 12

The let statement declares a block scope local variable, optionally initializing it to a value.

Question 13

const

Answer 13

Constants are block-scoped, much like variables defined using the let keyword. The value of a constant can’t be changed through reassignment, and it can’t be redeclared.

Question 14

var

Answer 14

The var statement declares a function-scoped or globally-scoped variable, optionally initializing it to a value.

Question 15

Math.random()

Answer 15

The Math.random() function returns a floating-point, pseudo-random number in the range 0 to less than 1 (inclusive of 0, but not 1) with approximately uniform distribution over that range — which you can then scale to your desired range. The implementation selects the initial seed to the random number generation algorithm; it cannot be chosen or reset by the user.

Math.random() * (max - min) + min;

Question 16

global scope

Answer 16

In JavaScript, scope refers to the visibility of variables. Variables which are defined outside of a function block have Global scope. This means, they can be seen everywhere in your JavaScript code.

Variables which are used without the var keyword are automatically created in the global scope. This can create unintended consequences elsewhere in your code or when running a function again. You should always declare your variables with var.

Question 17

local scope

Answer 17

Variables which are declared within a function, as well as the function parameters have local scope. That means, they are only visible within that function.

Question 18

!==

Answer 18

The strict inequality operator (!==) is the logical opposite of the strict equality operator. It means “Strictly Not Equal” and returns false where strict equality would return true and vice versa.

Strict inequality will not convert data types like !=

Question 19

break;

Answer 19

The break statement terminates the current loop, switch, or label statement and transfers program control to the statement following the terminated statement.

break [label];
label Optional
Identifier associated with the label of the statement. If the statement is not a loop or switch, this is required.

Question 20

switch () {
case (value):
…

Answer 20

The switch statement evaluates an expression, matching the expression’s value to a case clause, and executes statements associated with that case, as well as statements in cases that follow the matching case.

switch (expression) {
  case value1:
    //Statements executed when the
    //result of expression matches value1
    [break;]
  case value2:
    //Statements executed when the
    //result of expression matches value2
    [break;]
  ...
  case valueN:
    //Statements executed when the
    //result of expression matches valueN
    [break;]
  [default:
    //Statements executed when none of
    //the values match the value of the expression
    [break;]]
}

Question 21

Object.keys(obj)

Answer 21

The Object.keys() method returns an array of a given object’s own enumerable property names, iterated in the same order that a normal loop would.

Question 22

how to access the properties of an object

Answer 22

There are two ways to access the properties of an object: dot notation (.) and bracket notation ([””]), similar to an array.

Dot notation is what you use when you know the name of the property you’re trying to access ahead of time.

Question 23

updating or adding new object properties is the same method

Answer 23

object.key = "value" 
object["key"] = "value"

Question 24

delete properties from an object

Answer 24

delete object.key

Question 25

accessing object properties with variables

Answer 25

var testObj = {
  12: "Namath",
  16: "Montana",
  19: "Unitas"
};

var playerNumber = 16;  
var player = testObj[playerNumber];

Question 26

problem: counting cards

Answer 26

Count Change Cards
+1 2, 3, 4, 5, 6
0 7, 8, 9
-1 10, ‘J’, ‘Q’, ‘K’, ‘A’

function cc(card) {
  var regex = /[JQKA]/;
  if (card > 1 &amp;&amp; card < 7) {
    count++;
  } else if (card === 10 || String(card).match(regex)) {
    count--;
  }

if (count > 0) return count + “ Bet”;
return count + “ Hold”;
}

Question 27

problem: using objects for lookups

Answer 27

function phoneticLookup(val) {
  var result = "";
  var lookup = {
    "alpha": "Adams",
    "bravo": "Boston",
    "charlie": "Chicago",
    "delta": "Denver",
    "echo": "Easy",
    "foxtrot": "Frank"
  };
// After converting our case statements into object properties you can make use of the variable `result` to let the function return the correct value.

  result = lookup[val];
  // Only change code above this line
  return result;
}

Question 28

testing objects for properties

Answer 28

Sometimes it is useful to check if the property of a given object exists or not. We can use the .hasOwnProperty(propname) method of objects to determine if that object has the given property name. .hasOwnProperty() returns true or false if the property is found or not.

function checkObj(obj, checkProp) {
  if(obj.hasOwnProperty(checkProp)) {
    return obj[checkProp];
  } else {
    return "Not Found";
  }
}

Question 29

string.match(regexp)

Answer 29

The match() method retrieves the result of matching a string against a regular expression.

Question 30

regex

regular expression

Answer 30

Regular expressions are patterns used to match character combinations in strings. In JavaScript, regular expressions are also objects. These patterns are used with the exec() and test() methods of RegExp, and with the match(), matchAll(), replace(), search(), and split() methods of String.

Question 31

how to iterate over an object

Answer 31

for (variable in object)

statement

Question 32

recursive version of multiply

Answer 32

multiply(arr, n - 1) * arr[n - 1]
replaces loop

The recursive version of multiply breaks down like this. In the base case, where n <= 0, it returns 1. For larger values of n, it calls itself, but with n - 1. That function call is evaluated in the same way, calling multiply again until n <= 0. At this point, all the functions can return and the original multiply returns the answer.

Note: Recursive functions must have a base case when they return without calling the function again (in this example, when n <= 0), otherwise they can never finish executing.

Question 33

Ternary

Answer 33

The conditional operator, also called the ternary operator, can be used as a one line if-else expression.

condition ? statement-if-true : statement-if-false;

Question 34

Using unshift to add element at given index

Answer 34

function applyUnshiftAgain(arrayOfArrays, index, element) {
  // add the element to the front of the inner array within the array of arrays located at the index
  arrayOfArrays[index].unshift(element);
  // return the array of arrays
  return arrayOfArrays;

}

Question 35

Array.isArray(value)

Answer 35

The Array.isArray() method determines whether the passed value is an Array.

Question 36

Number.parseFloat(value)

Answer 36

The Number.parseFloat() method parses an argument and returns a floating point number. If a number cannot be parsed from the argument, it returns NaN.

Question 37

substring

Answer 37

The substring() method returns the part of the string between the start and end indexes, or to the end of the string.

str.substring(indexStart[, indexEnd])

Question 38

find the the index of value within a string

Answer 38

str.indexOf(searchValue [, fromIndex])

The indexOf() method returns the index within the calling String object of the first occurrence of the specified value, starting the search at fromIndex. Returns -1 if the value is not found.