Insegna a te stesso alcuni suggerimenti e trucchi potenti che non sono conosciuti dalla maggior parte degli sviluppatori

JavaScript è il linguaggio più comune e più utilizzato grazie alle sue funzioni e alla vasta comunità. Sto usando JS come mio stack principale negli ultimi 5 anni e ancora, ci sono così tanti concetti che sono ancora sconosciuti anche per me, ma in questi anni mi imbatto in molti suggerimenti e trucchi che mi aiutano. Quindi, come sviluppatore JS, dovresti conoscerne alcuni.

Tempistica delle prestazioni

Vuoi controllare quanto tempo impiega il tuo codice per essere eseguito? Abbastanza semplice, JS ha un performance.now()metodo che restituirà il tempo in ms(milisecond)Puoi avvolgere il tuo metodo per scoprire il tempo di esecuzione.

const firstTime = performance.now()
something()
const secondTime = performance.now()
console.log(`Average time function took ${secondTime - firstTime} milliseconds`)

È davvero semplice, facciamo lo scambio:

let p = 99, q = 100
[a, b] = [b, a]
console.log(a) // result -> 100
console.log(b) // result -> 99

Come tutti sapete il metodo tradizionale per convertire un numero in stringa e una stringa in numero:

let num = 100
let numTostring = num.toString()
let str = "100"
let strToNum = Number(str)

let num = 100
let str = "100"
let numTostring = num + "" // number to string
let strToNum = +s  // string to number

L'ereditarietà funzionale è il processo di eredità delle caratteristiche applicando una funzione aumentante a un'istanza di un oggetto. La funzione fornisce un ambito di chiusura che è possibile utilizzare per mantenere privati ​​alcuni dati. La funzione di aumento utilizza l'estensione dinamica dell'oggetto per estendere l'istanza dell'oggetto con nuove proprietà e metodi. Per saperne di più leggi qui

// Base function
let drinks = (data) => {
  let res = {} // Create an empty object
  that.name = data.name // Add it a "name" property
  return res // Return the object
};

// Fuction which inherits from the base function
let coffee = (data) => {
  // Create the Drinks object
  let res = Drinks(data)
  // Extend base object
  that.giveName = function() {
    return 'This is ' + that.name
  };
  return res
};

// Usage
let firstCoffee = Coffee({ name: 'Cappuccino' })
console.log(firstCoffee.giveName())
// Output: "This is Cappuccino"

COSA .map()ha anche sostituto? SÌ:

let person = [
    { name: ‘Shampp’, age: 2 },
    { name: ‘Piter’, age: 4},
    { name: ‘Gabba’, age: 5},
    { name: ‘Siku’, age: 4},
    { name: ‘Pinku’, age: 5},
    { name: ‘Furry’, age: 9},
]


let personNames = Array.from(person, ({name}) => name)
console.log(personNames) 
// returns [“Shampp”, “Piter”, “Gabba”, “Siku”, “Pinku”, “Furry"]

Sì, un vantaggio della lengthproprietà che non conosciamo dalla maggior parte di noi! Diamo un'occhiata all'esempio:

let array_values = [1, 2, 3, 4, 5, 6, 7, 8]  
console.log(array_values.length) 
// 8  
array_values.length = 5  
console.log(array_values.length) 
// 5  
console.log(array_values) 
// [1, 2, 3, 4, 5]
array_values.length = 0
console.log(array_values)
//[]

Se vuoi ignorare l'indice e hai ancora bisogno di scorrere i dati con forControlliamo un altro modo per usare il forciclo

const names = ["Shampp", "Gabba", "Pinku"];

// Long Version
for (let i = 0; i < names.length; i++) {
  const name = names[i]
  console.log(name)
}

// Short Version
for (let name of names) console.log(name)

Il polimorfismo è un concetto di linguaggio di programmazione orientato agli oggetti . Fornisce semplicemente la capacità di creare una proprietà, una funzione o un oggetto che ha una o più implementazioni. Lo stesso che puoi ottenere in JS. Comprendiamolo con un esempio:

function Employee(name) {
    this.name = name;
    this.getName = () => {
        return this.name
    }
}

const employee = new Employee("sandy")

console.log(employee.getName()) // sandy

Employee.prototype.getDetails = function () {
    return this.name.toUpperCase()
}

console.log(employee.getDetails()) // SANDY

class Shape {
    area() {
        return 0
    }
}

class Circle extends Shape {
    constructor (radius) {
        super(); // needed to use this
        this.radius = radius
    }

    area() {
        return Math.PI * this.radius * this.radius
    }
}

class Rectangle extends Shape {
    constructor (width, height) {
        super()
        this.width = width
        this.height = height
    }

    area() {
        return this.width * this.height
    }
}

const circle = new Circle(2)
const rectangle = new Rectangle(5, 6)

console.log(circle.area())
console.log(rectangle.area())

Quindi, questo è tutto ciò che voglio condividere con voi ragazzi, spero che finora abbiate imparato molto. Grazie per aver letto.

Più contenuti su plainenglish.io