Number
let age = 25;
String
let name = "John";
Boolean
let isStudent = true;
Undefined:
let address;
Null
let salary = null;
Symbol
let sym = Symbol("id");
BigInt
let bigIntNumber = 1234567890123456789012345678901234567890n;
Not-a-Number (NaN)
NaN stands for "Not-a-Number" and represents a value that is not a legal number
console.log(0 / 0); // NaN console.log(parseInt("abc")); // NaN
console.log(typeof a);
1) Class can only have one constructor
class gfg { constructor(name, estd, rank) { this.n = name; this.e = estd; this.r = rank; } decreaserank() { this.r -= 1; } } const test = new gfg("tom", 2009, 43); test.decreaserank(); console.log(test.r); console.log(test);
class car { constructor(brand) { this.carname = brand; } present() { return 'I have a ' + this.carname; } } class Model extends car { constructor(brand, model) { super(brand); super.present(); this.model = model; } show() { return this.present() + ', it is a ' + this.model; } }
class car { constructor(brand) { this.carname = brand; } // Getter method get cnam() { return "It is " + this.carname; // Return a value } // Setter method set cnam(x) { this.carname = x; } } const mycar = new car("Ford"); console.log(mycar.cnam);
An IIFE is a function that runs as soon as it is defined
(function() { console.log("IIFE executed!"); })();
Higher-order functions are functions that take other functions as arguments or return functions as their result
function higherOrderFunction(callback) { return callback(); } function sayHello() { return "Hello!"; } console.log(higherOrderFunction(sayHello)); // "Hello!"
Variable Shadowing occurs when a local variable has the same name as a variable in an outer scope.
The local variable overrides or hides the outer variable within its own scope.
The outer variable remains intact and can be accessed outside of the local scope.
var name = "John"; function sayName() { console.log(name); var name = "Jane"; } sayName();
There are several ways to access HTML elements in JavaScript:
Select element by ID:
document.getElementById("elementId");
Select element by Classname:
document.getElementsByClassName("className");
Select element by Tagname:
document.getElementsByTagName("tagName");
Css selector:
document.querySelector(".className"); document.querySelectorAll(".className");
function changeValue(x) { x = 10; console.log("Inside function:", x) } let num = 5; changeValue(num);
function changeProperty(obj) { obj.name = "Alice"; console.log("Inside function:", obj.name); // Output: Inside function: Alice } let person = { name: "Bob" }; changeProperty(person); console.log("Outside function:", person.name); // Output: Outside function: Alice
It switches the JavaScript engine to strict mode, which catches common coding mistakes and throws more exceptions.
"use strict"; x = 10; // Throws an error because x is not declared
It allows an iterable such as an array or string to be expanded in places where zero or more arguments or elements are expected
function sum(a, b, c) { return a + b + c; } const numbers = [1, 2, 3]; console.log(sum(...numbers)); // Output: 6
The operator checks whether an object is an instance of a specific class or constructor function.
class Animal { constructor(name) { this.name = name; } } class Dog extends Animal { constructor(name, breed) { super(name); this.breed = breed; } } const myDog = new Dog('Buddy', 'Golden Retriever'); console.log(myDog instanceof Dog); // true console.log(myDog instanceof Animal); // true console.log(myDog instanceof Object); // true console.log(myDog instanceof Array); // false
This method creates a new array with all elements that pass the test implemented by the provided function.
const numbers = [1, 2, 3, 4, 5, 6]; const evenNumbers = numbers.filter(num => num % 2 === 0); console.log(evenNumbers); // [2, 4, 6]
This method executes a reducer function on each element of the array, resulting in a single output value.
const numbers = [1, 2, 3, 4, 5]; const sum = numbers.reduce((sum, value) => sum + value, 0); // sum = 0 initially console.log(sum); // 15
This parameter syntax allows a function to accept an indefinite number of arguments as an array.
function sum(...numbers) { return numbers.reduce((sum, value) => sum + value, 0); } console.log(sum(1, 2, 3)); // 6 console.log(sum(5, 10, 15, 20)); // 50
Implicit Global variable
An implicit global variable is a variable that is created automatically in the global scope when it is assigned a value without being explicitly declared with a keyword like var, let, or const. But this throws error if it is inStrict mode
function myFunction() { x = 10; // no error }
const
It declares a constant variable that cannot be reassigned.
const PI = 3.14;
let
It declares a block-scoped variable.
It cannot be re-intialized with same name
let c=1; let c=3;// throws error let count = 0; if (true) { let count = 1; console.log(count); // Output: 1 } console.log(count); // Output: 0
var
It declares a function-scoped or globally-scoped variable. It encourages hoisting and reassignment.
var name = 'John'; if (true) { var name = 'Doe'; console.log(name); // Output: Doe } console.log(name); // Output: Doe console.log(a) var a=2 // prints undefined
Synthetic Events: React provides a SyntheticEvent wrapper around the native browser events. This wrapper normalizes the event properties and behavior across different browsers, ensuring that your event handling code works the same way regardless of the browser.
import React from 'react'; class MyComponent extends React.Component { handleClick = (event) => { // `event` is a SyntheticEvent console.log(event.type); // Always 'click' regardless of browser console.log(event.target); // Consistent target property } render() { return ; } }
Hoisting is a JavaScript mechanism where variables and function declarations are moved to the top of their containing scope during the compile phase, allowing them to be used before they are declared in the code. However, only the declarations are hoisted, not the initializations.
console.log(x); // Output: undefined var x = 5; console.log(x); // Output: 5 // Function hoisting hoistedFunction(); // Output: "Hoisted!" function hoistedFunction() { console.log("Hoisted!"); } // Function expressions are not hoisted notHoisted(); // Error: notHoisted is not a function var notHoisted = function() { console.log("Not hoisted"); };
It is the automatic conversion of values from one data type to another. There are two types of coercion: implicit and explicit.
Ex.
let result = 5 + "10"; // "510" let result = "5" * 2; // 10 let result = "5" - 2; // 3 let result = "5" / 2; // 2.5
It happens when we manually convert a value from one type to another using built-in functions.
let num = 5; let str = String(num); // "5" let str2 = num.toString(); // "5" let str3 = `${num}`; // "5"
Non-zero numbers (positive and negative)
Non-empty strings
Objects (including arrays and functions)
Symbol
BigInt values (other than 0n)
0 (zero)
-0 (negative zero)
0n (BigInt zero)
"" (empty string)
null
undefined
NaN (Not-a-Number)
To pass data from a parent component to a child component. It is immutable (read-only) within the child component.
// Parent Component function Parent() { const data = "Hello from Parent!"; return; } // Child Component function Child(props) { return {props.message}; }
To manage data that can change over time within a component. It is mutable within the component.
// Function Component using useState import { useState } from 'react'; function Counter() { const [count, setCount] = useState(0); return (); }Count: {count}
A closure in JavaScript is a feature where an inner function has access to the outer (enclosing) function's variables and scope chain even after the outer function has finished executing.
function outerFunction(outerVariable) { return function innerFunction(innerVariable) { console.log('Outer Variable:', outerVariable); console.log('Inner Variable:', innerVariable); }; } const newFunction = outerFunction('outside'); newFunction('inside');
Currying is a technique of transforming a function that takes multiple arguments into a sequence of functions that each take a single argument.
function add(a) { return function(b) { return a + b; }; } const add5 = add(5); console.log(add5(3)); // Output: 8 console.log(add(2)(3)); // Output: 5
Generators are special functions that can be paused and resumed, allowing you to generate a sequence of values over time.
function* generateSequence() { yield 1; yield 2; yield 3; } const generator = generateSequence(); console.log(generator.next()); // { value: 1, done: false } console.log(generator.next()); // { value: 2, done: false } console.log(generator.next()); // { value: 3, done: false } console.log(generator.next()); // { value: undefined, done: true }
Stay Connected!
If you enjoyed this post, don’t forget to follow me on social media for more updates and insights:
Twitter:madhavganesan
Instagram:madhavganesan
LinkedIn:madhavganesan
以上がJavascript Code Snippetsの詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。