JavaScript Basics: Variables, Loops, Functions
Uploaded by
diptowin101JavaScript Basics: Variables, Loops, Functions
Uploaded by
diptowin101Common questions
Powered by AIUsing 'const' for variable declaration indicates that the variable's identifier cannot be reassigned, providing a predictable fixed value within its context, which is essential when defining constants like `const pi = 3.14` . This differs from 'let,' which allows reassignment within the same block, and 'var,' which is function-scoped and can be hoisted, potentially leading to unexpected overwrites or values . Choosing 'const' aids in reducing mutation and side-effects, promoting functional programming principles .
Function declaration defines a named function using the "function" keyword followed by a name and parentheses, allowing the function to be used before it's declared due to hoisting. Function expression involves defining a function inside a variable without a name, making it an anonymous function that is not hoisted, meaning it must be defined before use . Choosing function expressions offers flexibility since they allow changing the function name and are not hoisted, which can help in avoiding errors due to hoisting behaviors .
The 'break' statement terminates the current loop immediately, resuming control after the loop. 'Continue' skips the current iteration and proceeds to the next one. For example, consider a loop over an array where we want to break upon finding a specific value: ``` for (let i = 0; i < array.length; i++) { if (array[i] === 'stop') { break; } if (array[i] % 2 !== 0) { continue; } console.log(array[i]); } ``` This loop breaks out completely if 'stop' is encountered, but skips odd numbers, continuing with the next iteration . Proper use of break and continue can optimize loop flow efficiency .
For loops are ideal for iterating a known number of times, such as iterating through arrays, since they combine initialization, condition, and increment in one line. While loops are suitable for scenarios where the number of iterations is not known and the loop needs to continue until a condition becomes false. Do-while loops guarantee at least one execution regardless of the condition, making them useful when the loop must run at least once before checking the condition . For example, use a for loop for fixed iterations, while use a while loop for undefined iterations based on dynamic conditions .
Type coercion in JavaScript happens implicitly, converting values between types during operations or comparisons, sometimes leading to unexpected results. For example, using '==' instead of '===' allows coercion, such as when comparing `5 == '5'`, which returns true due to coercion. Conversion, however, is explicit, like using `Number('5')` to convert a string to a number explicitly, ensuring type safety . Coercion can lead to unexpected errors, whereas conversion ensures clarity and type predictability .
Logical operators (&&, ||, !) combine or invert conditions in conditional statements. They help evaluate multiple conditions together. For example, a nested if-else condition using logical operators can look like this: ``` if (age > 18 && !married) { if (hasID) { console.log('Eligible for entry'); } else { console.log('ID required'); } } else { console.log('Not eligible'); } ``` This evaluates whether 'age' is greater than 18 and not married, proceeding to check 'hasID' for eligibility .
Arrow functions provide a shorter syntax for writing functions and do not have their own 'this' context, making them ideal for non-method functions. They preserve the 'this' value of the enclosing context, reducing the risks of bugs in callbacks where 'this' might refer to unexpected objects . This behavior can benefit cleaner code and avoid common mistakes in object-oriented programming .
Hoisting moves declarations to the top of its scope before code execution. For variables declared with 'var,' this means they are initialized as 'undefined' at the top of their function scope, leading potentially to logic errors if relied on before explicit initialization. For functions, hoisting allows functions to be invoked before they appear in code. For example, invoking a function before its line of definition due to its declaration being hoisted . Understanding hoisting necessitates careful planning of declaration order, especially with 'var', to prevent unexpected behavior .
Using backticks allows for template literals which enable multi-line strings and the embedding of expressions directly within a string. For instance, `console.log(`${name} is ${age} years old.`);` evaluates the expressions within `${}` and incorporates them seamlessly. This is preferred over regular quotes because it simplifies string interpolation and enhances readability, eliminating the need for concatenation . Backticks enhance code clarity and efficiency when handling dynamic strings .
The ternary operator simplifies conditional statements by allowing inline condition checks within an expression, `condition ? expression_if_true : expression_if_false;`. For example, simplifying a check for minimum value: `const min = (a < b) ? a : b;`. It provides a concise alternative to multi-line if-else statements, improving readability when dealing with simple conditions . It is particularly helpful for quick assignments based on conditions .