Javascript-Codeausschnitte

Datentypen

Primitive Datentypen

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

Wie überprüfe ich den Datentyp?

console.log(typeof a);

Klasse

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);

Nachlass

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;
    }
}

Holen und einstellen

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);

Sofort aufgerufener Funktionsausdruck (IIFE)

Ein IIFE ist eine Funktion, die ausgeführt wird, sobald sie definiert ist

(function() {
    console.log("IIFE executed!");
})();

Funktionen höherer Ordnung

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!"

Variables Shadowning

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();

Zugriff auf HTML-Elemente in JavaScript

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");

Wert übergeben

function changeValue(x) {
  x = 10;
  console.log("Inside function:", x)
}

let num = 5;
changeValue(num);

Als Referenz übergeben

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

verwenden Sie streng

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

Spread-Operator

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

InstanzVon

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

Filter

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]

Reduzieren

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

Ausruhen

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

Arten von Erklärungen

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 im Strikten 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

Synthetisches Ereignis

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 <button onClick={this.handleClick}>Click Me</button>;
  }
}

Heben in JavaScript

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");
};

Geben Sie Zwang ein

Es handelt sich um die automatische Konvertierung von Werten von einem Datentyp in einen anderen. Es gibt zwei Arten von Zwang: implizit und explizit.

Impliziter Zwang

Bsp.

let result = 5 + "10"; // "510"
let result = "5" * 2; // 10
let result = "5" - 2; // 3
let result = "5" / 2; // 2.5

Explizite Nötigung

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"

Truthy Values

Non-zero numbers (positive and negative)
Non-empty strings
Objects (including arrays and functions)
Symbol
BigInt values (other than 0n)

Falsy Values

0 (zero)
-0 (negative zero)
0n (BigInt zero)
"" (empty string)
null
undefined
NaN (Not-a-Number)

Props (Properties)

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 message={data} />;
}

// Child Component
function Child(props) {
  return <div>{props.message}</div>;
}

State

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 (
    <div>
      <p>Count: {count}</p>
      <button onClick={() => setCount(count + 1)}>Increment</button>
    </div>
  );
}

Closure

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

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

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!