Uebungen

src/destructering.js

@@ -1,9 +1,11 @@
 'use strict'
 
 // swap
-// let a = 1 ,b = 2, arr = [a, b];
+ //let a = 1 ,b = 2, arr = [a, b];
+
+
+ //[b, a] = [a, b]
 
-// [b, a] = [a, b]
 
 // // default values
 // let [eins, zwei, drei = 3] = arr

src/exercises/MeineLoesung/Object-js-vs-json-uebungen.js

@@ -0,0 +1,71 @@
+"use strict"
+//1
+
+const users = [
+    {
+        name: "Martin",
+        score: 100
+    },
+    {
+        name: "Sven",
+        score: 20
+    },
+    {
+        name: "Eva",
+        score: 33
+    },
+    {
+        name: "Heike",
+        score: 40
+    }
+]
+
+// sortiert aufsteigend a.score - b.score **** b.score -a.score sortiert absteigend
+users.sort((a, b) => {
+    return a.score - b.score
+}).forEach((e) => {
+    console.log(e)
+})
+
+//2
+let topScorer = users.sort((a, b) => {
+    return b.score -a.score
+})
+
+let topThree1 = [topScorer[0], topScorer[1], topScorer[2]]
+console.log(topThree1)
+
+let topThree2 = topScorer.slice(0, 3)
+console.log(topThree2)
+
+//
+let topThree3 = topScorer.filter((value,index) => {
+    return index <= 2
+})
+console.log(topThree3)
+
+
+ const jsonUsers = JSON.stringify(topThree3)
+console.log(jsonUsers)
+
+//3
+
+let userChange = users.map( user => ({
+    content: user.name,
+    length: user.name.length
+
+})).sort((a, b) => {
+    return a.length - b.length
+})
+
+console.log(userChange)
+
+//4
+
+
+
+
+
+//5
+
+

src/exercises/MeineLoesung/admin.mjs

@@ -0,0 +1,37 @@
+export class Person {
+    nachname
+    vorname
+
+    constructor(nachname, vorname) {
+        this.nachname = nachname
+        this.vorname = vorname
+    }
+}
+
+export class Store {
+    items = []
+
+    constructor(items) {
+        this.items = items
+    }
+
+    add(item) {
+        this.items.push(item)
+    }
+
+    remove(item) {
+        let indexToRemove = this.items.indexOf(item)
+        this.items.splice(indexToRemove, 1)
+    }
+
+    findAll(matcher) {
+        const foundItems = []
+        for (const item of this.items) {
+            //matcherfunktion = true, dann push item in foundItems Array
+            if (matcher(item)){
+              foundItems.push(item)
+            }
+        }
+     return foundItems
+    }
+}

src/exercises/MeineLoesung/basicAufgabe.js

@@ -0,0 +1,58 @@
+"use strict"
+
+// Aufgabe 1.1
+
+function returnName (name){
+    return "Hallo \<" + name + "\>"
+}
+
+console.log(returnName("Claudia"))
+
+//Aufgabe 1.2
+function returnNameDefault (name , to = "Welt"){
+    if (name === undefined){
+        return "Hallo \<" + to +  "\>"
+    }else {
+        return "Hallo \<" + name+  "\>"
+    }
+
+}
+
+console.log(returnNameDefault())
+console.log(returnNameDefault("Claudia"))
+
+//Aufgabe 1.3
+
+function  returnMoreNameDefault (...name){
+    if (name.length === 0){
+        name.push("Welt")
+    }else{
+        name.push(name)
+    }
+    let nameOutput = name.join(", ")
+
+    return "Hallo " + nameOutput
+}
+
+console.log(returnMoreNameDefault("Claudia", "Simon", "Marco"))
+console.log(returnMoreNameDefault())
+
+//"use strict"
+function test1 (){
+    console.log(this)
+}
+test1()
+let objekt={
+    name: "Claudia",
+    say: function (){
+        console.log(this.name)
+    }
+
+};
+console.log(objekt.name)
+let objektName = objekt.say()
+console.log(objektName)
+console.log(objekt.__proto__)
+
+
+

src/exercises/MeineLoesung/classes/Car.mjs

@@ -0,0 +1,31 @@
+"use strict"
+
+export class Car {
+    // private #brand
+    #brand;
+    color;
+    fuel;
+
+    constructor(brand, color, fuel) {
+        this.#brand = brand;
+        this.color = color;
+        this.fuel = fuel;
+        this._brand = brand;
+    }
+
+    drive(){
+        console.log(`Car: ${this.brand} with the color: ${this.color} drives with ${this.fuel} `)
+    }
+
+
+    get brand() {
+        return this._brand;
+    }
+
+    set brand(value) {
+        this._brand = value;
+    }
+
+
+}
+

src/exercises/MeineLoesung/classes/RacingCar.mjs

@@ -0,0 +1,21 @@
+"use strict"
+import {Car} from "./Car.mjs";
+//
+
+export class RacingCar extends Car {
+    team;
+    horsePower;
+
+    constructor(brand, color, fuel, team, horsePower) {
+        super(brand,color,fuel);
+        this.team = team;
+        this.horsePower = horsePower;
+    }
+
+    drive(){
+        console.log(`Racingcar: Team: ${this.team} with the brand: ${this.brand} drives with ${this.horsePower} `)
+    }
+
+
+
+}

src/exercises/MeineLoesung/classes/app.mjs

@@ -0,0 +1,16 @@
+import {Car} from "./Car.mjs";
+import {RacingCar} from "./RacingCar.mjs";
+
+let car1 = new Car("VW", "White", "Gas");
+let raceCar = new RacingCar("BMW", "Black", "Diesel", "Sauber", 450)
+
+car1.drive()
+raceCar.drive()
+
+// Use getter
+console.log(car1.brand)
+console.log(raceCar.brand)
+//use setter
+car1.brand = "Smart"
+console.log(car1.brand)
+

src/exercises/MeineLoesung/client.mjs

@@ -0,0 +1,22 @@
+
+import {Person, Store} from './admin.mjs'
+
+const person1 = new Person("Martinez", "Claudia")
+const person2 = new Person("Martinez", "Marco")
+const person3 = new Person("Martinez", "Antonio")
+const person4 = new Person("Rumhold", "Eva")
+const person5 = new Person("Germann", "Simon")
+let persons = [person1, person2, person3]
+
+const store = new Store(persons)
+
+store.add(person4)
+console.log(persons)
+
+store.remove(person1)
+console.log(persons)
+console.log("*********************************")
+
+let found = store.findAll((person) => person.nachname === "Martinez")
+console.log(found)
+

src/exercises/MeineLoesung/eigeneUebungen/function-methods.js

@@ -0,0 +1,28 @@
+// übung für call(), apply() bind()
+
+
+let bob = function (num, str,x){
+    console.log('bob', num, str, this, x)
+
+    return true
+}
+
+let bill = {
+    name:'Bill Murray',
+    movie: 'Lost in translation',
+    myMethod: function (fn){
+
+
+    }
+}
+
+//bob(1, 'hi') // bob, 1, hi, this => global Object ( use strict: this => undefined)
+
+//bill.myMethod(bob) // auch wenn myMethod instanz methode ist => ruft inner funktion auf, bei der this => global
+//bill.myMethod(bob.call(bill, 10, 'Welt'))// call(thisArgument, parameter1, parameter2 ) output => bob, 10, Welt, {bill}
+//bill.myMethod(bob.apply(bill,[20, 'Planet']))// apply(thisArgument, [parameter1, parameter2] output => bob, 20, Planet, {bill}
+
+
+//bill.myMethod(bob(2, 'blödian')) // nicht gebunden müssen parameter zur laufzeit übergeben werden
+let gebundeneFunktion = bob.bind(bill, 30, 'Universum'); // thisContext + Parameter können vor der Ausführung gespeichert werden ( Bind() macht nur KOPIE von Funktion)
+gebundeneFunktion("3. parameter x: nachträglich eingefügt => nach bind()")// Muss separat ausgeführt werden