Nummer
let age = 25;
Zeichenfolge
let name = "John";
Boolean
let isStudent = true;
Undefiniert:
let address;
Null
let salary = null;
Symbol
let sym = Symbol("id");
BigInt
let bigIntNumber = 1234567890123456789012345678901234567890n;
Not-a-Number (NaN)
NaN steht für „Not-a-Number“ und stellt einen Wert dar, der keine legale Zahl ist
console.log(0 / 0); // NaN console.log(parseInt("abc")); // NaN
console.log(typeof a);
1) Die Klasse kann nur einen Konstruktor haben
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);
Ein IIFE ist eine Funktion, die ausgeführt wird, sobald sie definiert ist
(function() { console.log("IIFE executed!"); })();
Funktionen höherer Ordnung sind Funktionen, die andere Funktionen als Argumente annehmen oder Funktionen als Ergebnis zurückgeben
function higherOrderFunction(callback) { return callback(); } function sayHello() { return "Hello!"; } console.log(higherOrderFunction(sayHello)); // "Hello!"
Variable Shadowing tritt auf, wenn eine lokale Variable denselben Namen hat wie eine Variable in einem äußeren Bereich.
Die lokale Variable überschreibt oder verbirgt die äußere Variable in ihrem eigenen Bereich.
Die äußere Variable bleibt intakt und kann außerhalb des lokalen Bereichs aufgerufen werden.
var name = "John"; function sayName() { console.log(name); var name = "Jane"; } sayName();
Es gibt mehrere Möglichkeiten, auf HTML-Elemente in JavaScript zuzugreifen:
Element nach ID auswählen:
document.getElementById("elementId");
Element nach Klassenname auswählen:
document.getElementsByClassName("className");
Element nach Tagname auswählen:
document.getElementsByTagName("tagName");
CSS-Auswahl:
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
Es schaltet die JavaScript-Engine in den strikten Modus, der häufige Codierungsfehler abfängt und mehr Ausnahmen auslöst.
"use strict"; x = 10; // Throws an error because x is not declared
Es ermöglicht die Erweiterung eines Iterables wie eines Arrays oder einer Zeichenfolge an Stellen, an denen keine oder mehr Argumente oder Elemente erwartet werden
function sum(a, b, c) { return a + b + c; } const numbers = [1, 2, 3]; console.log(sum(...numbers)); // Output: 6
Der Operator prüft, ob ein Objekt eine Instanz einer bestimmten Klasse oder Konstruktorfunktion ist.
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
Diese Methode erstellt ein neues Array mit allen Elementen, die den von der bereitgestellten Funktion implementierten Test bestehen.
const numbers = [1, 2, 3, 4, 5, 6]; const evenNumbers = numbers.filter(num => num % 2 === 0); console.log(evenNumbers); // [2, 4, 6]
Diese Methode führt eine Reduzierfunktion für jedes Element des Arrays aus, was zu einem einzelnen Ausgabewert führt.
const numbers = [1, 2, 3, 4, 5]; const sum = numbers.reduce((sum, value) => sum + value, 0); // sum = 0 initially console.log(sum); // 15
Diese Parametersyntax ermöglicht einer Funktion, eine unbegrenzte Anzahl von Argumenten als Array zu akzeptieren.
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
Implizite globale Variable
Eine implizite globale Variable ist eine Variable, die automatisch im globalen Bereich erstellt wird, wenn ihr ein Wert zugewiesen wird, ohne explizit mit einem Schlüsselwort wie var, let oder const deklariert zu werden. Dies löst jedoch einen Fehler aus, wenn es sich imStrikten Modus
befindet
function myFunction() { x = 10; // no error }
const
Es deklariert eine konstante Variable, die nicht neu zugewiesen werden kann.
const PI = 3.14;
lassen
Es deklariert eine Variable mit Blockbereich.
Es kann nicht mit demselben Namen neu initialisiert werden
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
Es deklariert eine Variable mit Funktions- oder Globalbereich. Es fördert das Heben und Neuzuordnen.
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
Synthetische Ereignisse: React stellt einen SyntheticEvent-Wrapper für die nativen Browserereignisse bereit. Dieser Wrapper normalisiert die Ereigniseigenschaften und das Verhalten in verschiedenen Browsern und stellt so sicher, dass Ihr Ereignisbehandlungscode unabhängig vom Browser auf die gleiche Weise funktioniert.
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 ist ein JavaScript-Mechanismus, bei dem Variablen und Funktionsdeklarationen während der Kompilierungsphase an den Anfang ihres enthaltenden Bereichs verschoben werden, sodass sie verwendet werden können, bevor sie im Code deklariert werden. Allerdings werden nur die Deklarationen gehisst, nicht die Initialisierungen.
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"); };
Es handelt sich um die automatische Konvertierung von Werten von einem Datentyp in einen anderen. Es gibt zwei Arten von Zwang: implizit und explizit.
Bsp.
let result = 5 + "10"; // "510" let result = "5" * 2; // 10 let result = "5" - 2; // 3 let result = "5" / 2; // 2.5
Das passiert, wenn wir einen Wert mithilfe integrierter Funktionen manuell von einem Typ in einen anderen konvertieren.
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
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
Das obige ist der detaillierte Inhalt vonJavascript-Codeausschnitte. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
