diff --git a/src/destructering.js b/src/destructering.js index 59b77da..a142148 100644 --- a/src/destructering.js +++ b/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 diff --git a/src/exercises/MeineLoesung/Object-js-vs-json-uebungen.js b/src/exercises/MeineLoesung/Object-js-vs-json-uebungen.js new file mode 100644 index 0000000..00e7fa3 --- /dev/null +++ b/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 + + diff --git a/src/exercises/MeineLoesung/admin.mjs b/src/exercises/MeineLoesung/admin.mjs new file mode 100644 index 0000000..0e5ea65 --- /dev/null +++ b/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 + } +} diff --git a/src/exercises/MeineLoesung/basicAufgabe.js b/src/exercises/MeineLoesung/basicAufgabe.js new file mode 100644 index 0000000..2cea5e5 --- /dev/null +++ b/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__) + + + diff --git a/src/exercises/MeineLoesung/classes/Car.mjs b/src/exercises/MeineLoesung/classes/Car.mjs new file mode 100644 index 0000000..fe10d41 --- /dev/null +++ b/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; + } + + +} + diff --git a/src/exercises/MeineLoesung/classes/RacingCar.mjs b/src/exercises/MeineLoesung/classes/RacingCar.mjs new file mode 100644 index 0000000..6c3cc84 --- /dev/null +++ b/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} `) + } + + + +} \ No newline at end of file diff --git a/src/exercises/MeineLoesung/classes/app.mjs b/src/exercises/MeineLoesung/classes/app.mjs new file mode 100644 index 0000000..eac411d --- /dev/null +++ b/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) + diff --git a/src/exercises/MeineLoesung/client.mjs b/src/exercises/MeineLoesung/client.mjs new file mode 100644 index 0000000..dc7bb85 --- /dev/null +++ b/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) + diff --git a/src/exercises/MeineLoesung/eigeneUebungen/function-methods.js b/src/exercises/MeineLoesung/eigeneUebungen/function-methods.js new file mode 100644 index 0000000..3e3e608 --- /dev/null +++ b/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 diff --git a/src/exercises/MeineLoesung/flowControll.js b/src/exercises/MeineLoesung/flowControll.js new file mode 100644 index 0000000..7699733 --- /dev/null +++ b/src/exercises/MeineLoesung/flowControll.js @@ -0,0 +1,108 @@ +//If und switch case +"use strict" +//Aufgabe 1 +//Variante 1 +let name = " Claudia" +let alter = 100; +let hiChild = "Hoi " + name; +let hiTeen = "Hallo" + name; +let grüezi = "Gruezi"+ name; +let alte = "Grüss Gott" + name; + +if(alter <= 10 ){ + console.log(hiChild); +} +else if(alter <= 18 ){ + console.log(hiTeen); +} +else if( alter <= 100){ + console.log(grüezi); +}else { + console.log(alte); +} + +//Variante 2 +if(alter <= 10){ + console.log(hiChild); +} +if (alter > 10 && alter <= 18){ + console.log(hiTeen); +} +if (alter > 18 && alter <=100){ + console.log(grüezi); +} +if (alter > 100){ + console.log(alte); +} + +//Aufgabe 2 +//Varainte 1 +let age = 61 +let betrag = 0; + +if(age < 5){ + betrag; +} +else if(age <= 15){ + betrag = 5; +} +else if(age <= 60){ + betrag = 15; +} +else { + betrag = 10; +} + +console.log(betrag + "fr.-") + +//Variante 2 + +if(age < 5){ + betrag; +} +if(age >= 5 && age <= 15){ + betrag= 5; +} +if(age > 15 && age <= 60){ + betrag = 15; +} +if(age > 60){ + betrag = 10; +} +console.log(betrag + "fr.-") + +//Aufgabe 3 +//Variante 1 +let geschlecht = "w"; +let age1 = 18 +let enter = false; + +switch (geschlecht){ + case "w": + enter = age1 >= 18; + break; + case "m": + enter = age1 >= 20; + break; + default: + enter = false; +} + +console.log(`Darf die Person des Geschlechts ${geschlecht} hinein? --> ${enter}`); +//Variante 2 + 3 Ternäre schreibweise + +let enter1 = (age1 >= 18 && geschlecht === "w") || (age1 >= 20 && geschlecht === "m") +let enter2 = (age1 >= 18 && geschlecht === "w") || (age1 >= 20 && geschlecht === "m")? "Darf hinein":"Darf nicht hinein" +console.log(enter1) +console.log(enter2) + + + + + + + + + + + diff --git a/src/exercises/MeineLoesung/functional-imperativ-uebungen.js b/src/exercises/MeineLoesung/functional-imperativ-uebungen.js new file mode 100644 index 0000000..95a32ef --- /dev/null +++ b/src/exercises/MeineLoesung/functional-imperativ-uebungen.js @@ -0,0 +1,54 @@ +"use strict" + +/* 1. Schreibe eine Funktion sum(in: Array): Number, welche alle Zahlen von in summiert und das Ergebnis retourniert. +Schreibe eine funktionale und eine imperative Variante. + */ + +let arrNumbers = [20, 30, 40, 50] + +//Funktional +console.log(arrNumbers.reduce((sum, numb) => { + sum += numb + return sum +})) + +// Imperativ +function summiere (arr){ + let sum = 0; + + for (const number of arr) { + sum += number + } + return sum +} +let sum = summiere(arrNumbers) +console.log(sum) + + + +/* 2. Schreibe eine Funktion even(in: Array[Number]): Array, welche nur die geraden Zahlen aus in retourniert. +Schreibe eine funktionale und eine imperative Variante. + + */ +//Funktional +let numbers = [3, 10, 45, 90, 32] + +let even = numbers.filter((number) => { + return number % 2 === 0 +}) +console.log(even) + + +//Imperativ +function filterEvenNumbers (arr){ + let evenNumbers = [] + + for (const number of arr) { + number % 2 === 0? evenNumbers.push(number): evenNumbers + } + return evenNumbers +} + +let evenNumbers = filterEvenNumbers(numbers) +console.log(evenNumbers) + diff --git a/src/exercises/MeineLoesung/functionalUebung.js b/src/exercises/MeineLoesung/functionalUebung.js new file mode 100644 index 0000000..e0a2d58 --- /dev/null +++ b/src/exercises/MeineLoesung/functionalUebung.js @@ -0,0 +1,91 @@ +/*1 +Schreibe eine Funktion die alle Zahlen eines Arrays summiert. +z.B. sum([1,2,3]) => 6 +Schreibe eine funktionale und eine imperative Variante. +Schreibe die Signatur als Deklaration. + +2 +Schreibe eine Funktion die einen Array von Zahlen entgegennimmt und einen Array mit Booleans zurückgibt. +Die Funktion ermittelt für jede Zahl ob diese gerade ist oder nicht. +z.B. even([1,2,3]) => [false, true, false] \ + +Schreibe eine funktionale und imperative Variante. +Schreibe die Signatur als Deklaration. + +3.1 +Implementiere eine Funktion filter(in: Array, predicate: (value: A) => Boolean): Array. +Teste ob diese funktioniert :). + +3.2 +Implementiere eine Funktion map(in: Array, mapper: (value: A) => B): Array. +Teste ob diese funktioniert :). + + */ + +//1 + +let arr = [0,1, 2, 3, 4, 5] +let stringArr = ["Wasser", "Brot", "wein"] +// Imperative Variante +let sum = 0; +for (const number of arr) { + sum += number +} +console.log(sum) + +//Funtionale Variante +console.log(arr.reduce((sum, val ) => { + return sum + val +}),0) +//Signatur: reduce(in: Array, predicate: sum:Number, val:Number : Array) + +//2 +// Imperative Variante +let boolArr =[]; +for (const number of arr) { + console.log(number) + if (number % 2 === 0){ + console.log(number) + boolArr.push(true) + }else { + console.log(number) + boolArr.push(false) + } +} +console.log(boolArr) + +// Funktionale Variante +console.log(arr.map((val => val % 2 === 0))) +// Signatur map(Array predicate: val:Number => Boolean): Array + +//3.1 +// eigene Filter Funktion + function filter (arr, number) { + let foundNumbers = [] + for (const ele of arr) { + ele === number ? foundNumbers.push(ele): foundNumbers + } + return foundNumbers + } + +let result = filter(arr, 5) +console.log(result) + + + +//3.2 +//eigene Map funktion +function mapper (arr){ + let resultMapper = [] + for (const number of arr) { + number % 2 === 0? resultMapper.push(true): resultMapper.push(false) + } + return resultMapper +} + +console.log(mapper(arr)) + + + + + diff --git a/src/exercises/MeineLoesung/objectAufgaben.js b/src/exercises/MeineLoesung/objectAufgaben.js new file mode 100644 index 0000000..917540b --- /dev/null +++ b/src/exercises/MeineLoesung/objectAufgaben.js @@ -0,0 +1,123 @@ +//Aufgabe 1 +//Definiere eine Liste von mehreren User Objekten. Jeder User hat einen Namen und eine Punktezahl. + +const user1 = { + name: "Ueli", + score: 25453534535345, +}; +const user2 = { + name: "Claudia", + score: 300, +}; + +let userList = [user1, user2]; + +//Aufgabe2 +//Finde den User mit der höchsten Punktezahl +//Variante 1 +let winner = null; + +for (const user of userList) { + if (winner === null || winner.score < user.score) { + winner = user; + } +} +console.log(winner); + +//Variante 2 +for (const user of userList) { + if (winner === null) { + winner = user; + } else if (winner.score < user.score) { + winner = user; + console.log(winner); + } +} +console.log(winner); + +//Aufgabe 3 + +let row1 = "|Name|Punkte|" +let row2 = "|----|-----|" +let row3 = "|" + user1.name + "| " + user1.score + "|" +let row4 = "|" + user2.name + "| " + user2.score + "|" + +let rowArr = [row1, row2, row3, row4] + +list = rowArr.join("\n") +console.log(list) +//Aufgabe 4 +//längster name +//Länge der höchsten Punktezahl.??? was ist damit gemeint? +function longestName (){ + let winner2 = null; + + for (const user of userList) { + if (winner2 === null || winner2.name.length < user.name.length) { + winner2 = user; + } + } + return winner2.name.length +} + +console.log(longestName()) + +function longestScore(){ + let winnerScoreLength = null; + + for (const user of userList) { + if (winnerScoreLength === null || winnerScoreLength.score.toString().length < user.score.toString().length) { + winnerScoreLength = user; + } + } + return winnerScoreLength.score.toString().length +} + +console.log(longestScore()); + + + +// Augabe 5 +let rows = [] +let longestUsername = longestName() +let longestUserScore = longestScore() + +// Check if HeaderName/Punkte length is longer than de longest Username or longest Score length +function lengthCheck(value1, value2){ + if (value1 > value2){ + return value1 + }else{ + return value2 + } +} + +let longestInNameRow = lengthCheck(longestUsername, "name".length) +let longestInPunkteRow = lengthCheck(longestUserScore, "Punkte".length) + +let headerRowName = "Name".padEnd(longestInNameRow) +let headerRowPunkte = "Punkte".padEnd(longestInPunkteRow) + +let nameBorder = "-".repeat(longestInNameRow) +let punkteBorder = "-".repeat(longestInPunkteRow) + +let headerCells = ['', headerRowName, headerRowPunkte, '']; +let borderCells = ['', nameBorder, punkteBorder, '']; + +let headerRow = headerCells.join('|'); +let borderRow = borderCells.join('|'); + +rows.push(headerRow) +rows.push(borderRow) + +for(const user of userList){ + const paddedName = user.name.padEnd(longestInNameRow) + const paddedScore = user.score.toString().padEnd(longestInPunkteRow) + const userCells = ['', paddedName, paddedScore, ''] + const userRow = userCells.join('|') + + rows.push(userRow) +} +list = rows.join('\n') +console.log(list) + + diff --git a/src/exercises/MeineLoesung/schleifen-funtional-uebungen.js b/src/exercises/MeineLoesung/schleifen-funtional-uebungen.js new file mode 100644 index 0000000..8773e19 --- /dev/null +++ b/src/exercises/MeineLoesung/schleifen-funtional-uebungen.js @@ -0,0 +1,136 @@ +"use strict" + +// Aufgabe 0 functional + +let word = "Pinguin" + + +let wordWithKomma = Array.from(word).join(","); +console.log(wordWithKomma) + +// Aufgabe 1 functional + +let prices = [1.50, 9.90, 10.00] +let total = prices.reduce((sum, price) =>{ + return sum += price +}, 0) +console.log(total) + +// Aufgabe 2 functional + +let numbers = [20, 10, 33, 53, 22] + +let boolNumberEven = numbers.map((number) => { + return number % 2 === 0 +}) +console.log(boolNumberEven) + +// Aufgabe 3 functional + +let sentence = "Ich weiss, dass ich nichts weiss ... !" +let words = sentence.split(" ") +console.log(words) +let capitalSentence = words.map((word) => { + return word[0].toUpperCase().concat(word.slice(1)) +}) +let convertedSentence = capitalSentence.join(" ") +console.log(convertedSentence) + +// Aufgabe 4 functional + + +// Aufgabe 5 functional + +let normalText = "Claudia Martinez" +let char = Array.from(normalText) +let shift = 1 + +let caesarText = char.map((char, index) => { + return normalText.charCodeAt(index) + shift}) + .map((charCode) => { + return String.fromCharCode(charCode).toUpperCase()}) + .toString() + +console.log(caesarText) + +// Aufgabe 6.1 functional + +let mixedNumbers = [1, 5, -10, 6.7, 45, 30] +let integers = [] + + integers = mixedNumbers.filter((number) => number % 1 === 0) + +console.log(integers) + +//Aufgabe 6.2 functional + +let positivNumbers = [] + +positivNumbers = mixedNumbers.filter((number) => number > 0) +console.log(positivNumbers) + +// Aufgabe 6.3 Quersumme functional +// zuerst alle einstelligen filtern +// dann alle mehrstelligen auseinander nehmen (string) +// mehrstellige wieder in Number umwandeln +// beide Arrays vereinen +// dann Quersumme berechnet werden +let numbersArr = [1, 34, 5, ] +let stringNumbers = [] +let oneDigit +let quersum = 0; + +stringNumbers = numbersArr.map(String) +oneDigit = stringNumbers.map((string) => { + return string.split("") +}) +console.log(oneDigit) +quersum = oneDigit.reduce((sum, val) => sum += val) +console.log(quersum) + +// Aufgabe 6.4 Durchschnitt functional + +let average = 0; + +average = mixedNumbers.reduce((sum, number) => sum += number) / mixedNumbers.length +console.log(average) + + + +// 7.1 functional + +let zeichenKette = "Ich habe keine Ahnung" +let zeichenArr = Array.from(zeichenKette) +console.log(zeichenArr) + +let neueZeichenKette = zeichenArr.map((zeichen) => { + return zeichen.split(" ") +}) + .map((zeichen, index) => { + return index % 2 === 0? zeichen.toString().toUpperCase():zeichen.toString().toLowerCase() +}) + .join(" ") + +console.log(neueZeichenKette) + + + +//7.2 functional + + + +//7.3 functional +let reversedWord = zeichenKette.split('').reverse().join('') +console.log(reversedWord) + + + +//7.4 functional +let reversedZeichenKette = zeichenKette.split(" ").reverse().join(" ") +console.log(reversedZeichenKette) + + + + + + diff --git a/src/exercises/MeineLoesung/schleifenAufgaben.js b/src/exercises/MeineLoesung/schleifenAufgaben.js new file mode 100644 index 0000000..454acd5 --- /dev/null +++ b/src/exercises/MeineLoesung/schleifenAufgaben.js @@ -0,0 +1,259 @@ +//Schleifen / Loops +//Aufgabe 0 +string = "Pinguin" +console.log(string[0] + ", ", string[1] + ", ", string[2] + ", ", string[3] + ", ", string[4] + ", ", string[5] + ", ", string[6]) + +let stringKomma = "" + +for (let i = 0; i < string.length; i++) { + if (i === string.length - 1) { + stringKomma += string[i] + "" + } else { + stringKomma += string[i] + ", " + } +} +console.log(stringKomma) + +// Aufgabe 1 +//Variante 1 +let sum = 0 +let prices = [1, 2, 3] + +for (const price of prices) { + sum += price + console.log(sum) +} +console.log(" Total sum of = " + sum) + +//Variante 2 +let sum1 = 0 +for (let i = 0; i < prices.length; i++) { + sum1 += prices[i] + console.log(sum1) +} +console.log(" Total sum of = " + sum1) + +//Variante 3 +let sum2 = 0; +let i = 0; + +while (i < prices.length){ + sum2 += prices[i] + i++ + console.log(sum2) +} +console.log(" Total sum of = " + sum2) + +//Aufgabe 2 +//Variante 1 +let numbers = [1,2,3] +let result = []; + +for (let number of numbers){ + if(number %2 === 0){ + result.push(true) + + }else{ + result.push(false); + } +} + +// Variante 2 als Funktion +function numberToBoolean(...numbers){ + let result =[] + for (let number of numbers){ + result.push(number % 2 === 0) + } + return result; +} +console.log(result) + +//Array Spreaden wieder auspacken +const numberArray = [1,2,3,4] +console.log(numberToBoolean(...numberArray)); + +//rest parameter einzelne zahlen werden zu einem array zusammengefasst +numberToBoolean(1,2,3,4,5,6); +console.log(numberToBoolean(1,2,3,4,5,6)) + +//Aufgabe 3 +let sentence = "Ich weiss, dass ich nichts weiss ... !" +let capitalSentence = "" + +for (let i = 0; i < sentence.length; i++) { + let char = sentence[i] + if (i === 0){ + char = char.toUpperCase() + console.log(char) + } + if (char === " "){ + capitalSentence += " " + sentence[++i].toUpperCase() + console.log(capitalSentence) + }else { + capitalSentence += char + } +} +console.log(capitalSentence) + +//Aufgabe 4 +// +/*Eine Primzahl ist eine Zahl, die nur durch sich selbst und durch 1 ohne Rest teilbar ist. + Eine Primzahl ist immer eine natürliche Zahl. + Die 0 und die 1 sind jedoch keine Primzahlen.*/ + +let number = 2; +let isPrime = true + + for (let i = 2; i < number; i++) { + if (number === 0 || number === 1 ){ + isPrime = false + } + if (number % i === 0){ + isPrime = false + } + if (number <= 100){ + number++ + }else { + break + } + +} +if (isPrime)console.log(number) + + + + +let n = 0 +while (n++ < 100) { + let isPrime = true + for (let i = 2; i < n; i++) { + if (n % i === 0) { + isPrime = false + break + } + } + if (isPrime) console.log(n) +} + +//Aufgabe 5 +let normalText = "Claudia Martinez" +let caesarText = "" +let shift = 1 + +for (let j = 0; j < normalText.length; j++) { + if (normalText[j] === " "){ + caesarText += " " + } + let charCode = normalText.charCodeAt(j) + shift + + caesarText += String.fromCharCode(charCode).toUpperCase() + console.log(caesarText) +} +console.log(caesarText) + +//Aufgabe 6.1 +let mixedNumbers = [1, 5, -10, 6.7, 45, 30] +let integers = [] + +for (const integer of mixedNumbers) { + if (integer % 1 === 0){ + integers.push(integer) + } +} +console.log(integers) + +//6.2 +let positivNumbers = [] + +for (const positivNumber of mixedNumbers) { + if (positivNumber > 0){ + positivNumbers.push(positivNumber) + } +} +console.log(positivNumbers) + +//6.3 + +/****************************************/ +// +console.log(positivNumbers) +// Quersumme berechnung von allen positiven zahlen +let querSumme = 0; +for (let i = 0; i < positivNumbers.length; i++){ + let stringNumber = "" + if (positivNumbers[i] <= 9){ + querSumme += positivNumbers[i] + console.log(querSumme) + }else{ + // zweistellige oder grössere Zahlen werden in string gewandelt und zerlegt + stringNumber = String(positivNumbers[i]) + console.log(stringNumber) + for (const stringNumberElement of stringNumber) { + console.log(stringNumberElement) + let digit = Number(stringNumberElement) + querSumme += digit + console.log(querSumme) + } + } + +} +console.log(querSumme) + +//6.4 +let zwischenSum = 0; +let durchschnitt = 0; +for (let j = 0; j < mixedNumbers.length; j++) { + zwischenSum += mixedNumbers[j] + +} +durchschnitt = zwischenSum / mixedNumbers.length +console.log(durchschnitt) + +//7.1 +let zeichenKette = "Ich habe keine Ahnung" +let neueZeichenKette = "" + +for (let i = 0; i < zeichenKette.length; i++) { + if (i % 2 === 0){ + neueZeichenKette += zeichenKette[i].toLowerCase() + }else { + neueZeichenKette += zeichenKette[i].toUpperCase() + } +} +console.log(neueZeichenKette) + + +// 7.2 +let konstanten = ["b","c","d","g","h","k","m","n","p","r","s","t","w"] +let selbstlaute = ["be", "ce", "de", "ge", "ha", "ka", "äm", "än", "pe", "är", "äs", "te", "we"] +let tauschString = "" +for (let i = 0; i < zeichenKette.length; i++) { + if (konstanten.includes(zeichenKette[i].toLowerCase())){ + let tausch = konstanten.indexOf(zeichenKette[i].toLowerCase()) + tauschString += selbstlaute[tausch] + }else{ + tauschString += zeichenKette[i] + } +} +console.log(tauschString) + +// 7.3 +//Variante 1 +let reverseZeichenKette = "" + +for (let i = zeichenKette.length -1; i >= 0 ; i--) { + reverseZeichenKette += zeichenKette[i] +} +console.log(reverseZeichenKette) + +//Variante 2 +let stringArr1 = zeichenKette.split('') +let reversed1 = stringArr1.reverse().join('') +console.log(reversed1) + + +// 7.4 + +let stringArr2 = zeichenKette.split(' ') +let reversed2 = stringArr2.reverse().join(' ') +console.log(reversed2) \ No newline at end of file diff --git a/src/exercises/MeineLoesung/zahlenraten.html b/src/exercises/MeineLoesung/zahlenraten.html new file mode 100644 index 0000000..d5cff98 --- /dev/null +++ b/src/exercises/MeineLoesung/zahlenraten.html @@ -0,0 +1,43 @@ + + + + + Zahlen raten + + + + + +

+ Finde die Geheimzahl! +

+ + + + \ No newline at end of file diff --git a/src/exercises/Webseiteuebung/index.html b/src/exercises/Webseiteuebung/index.html new file mode 100644 index 0000000..e0d77ef --- /dev/null +++ b/src/exercises/Webseiteuebung/index.html @@ -0,0 +1,38 @@ + + + + + + + Zahlenraten + + +

Finde die Geheimzahl!

+
0
+
1
+
2
+
3
+
4
+
5
+
6
+
7
+
8
+
9
+ + + + diff --git a/src/exercises/fibonacci.js b/src/exercises/fibonacci.js index dc3319f..b79692e 100644 --- a/src/exercises/fibonacci.js +++ b/src/exercises/fibonacci.js @@ -2,3 +2,18 @@ // Berechne die Fibonacci Folge für n Elemente, beginnend bei 0. // Gib alle berechneten Elemente aus. +function fibonacci (anzahlElemente){ + let fibonacciArr = [0, 1] + + for (let i = 2; fibonacciArr.length < anzahlElemente; i++) { + console.log(i) + // Addiere die zahlen von fiboarray[index (letzte zahl)] + fiboarray[index (zweitletzte zahl)] + fibonacciArr.push(fibonacciArr[i-2] + fibonacciArr[i-1]) + } + return fibonacciArr +} + +let result = fibonacci(10) +console.log(result) + + diff --git a/src/exercises/flow-control.md b/src/exercises/flow-control.md index 10846b2..63d4ab3 100644 --- a/src/exercises/flow-control.md +++ b/src/exercises/flow-control.md @@ -42,7 +42,7 @@ Gib die Entscheidung auf der Console aus. Schreibe zwei Varianten, - eine Variante mit switch case -- eine Variante mit && und || (ohne ganz ausgeschriebene if) +- eine Variante mit && und || (ohne ganz ausgeschriebene if) Ternäre if ## Schleifen / Loops diff --git a/src/exercises/functions/closures.js b/src/exercises/functions/closures.js new file mode 100644 index 0000000..e0d02ad --- /dev/null +++ b/src/exercises/functions/closures.js @@ -0,0 +1,15 @@ +// 1 +// a. Was gibt folgender Code aus? +//var wird in den global Scope gehoistet und die letzte zugewiesene variable wird 4x ausgegeben +for (var i = 0; i < 4; i++) { + setTimeout(() => { + console.log(i) + }, 2000) +} + +// b. Wie kann ich das Programm ändern, damit es tut was es tun sollte. +for (let i = 0; i < 4; i++) { + setTimeout(() => { + console.log(i) + }, 2000) +} \ No newline at end of file diff --git a/src/exercises/functions/fn-objects-callbacks.js b/src/exercises/functions/fn-objects-callbacks.js new file mode 100644 index 0000000..11d5c8f --- /dev/null +++ b/src/exercises/functions/fn-objects-callbacks.js @@ -0,0 +1,53 @@ +// 1 +// gegeben +function add(a, b){ + return a + b +} + +function aPlusb (p){ + return add(20, p) +} + +console.log(aPlusb(40)) + + let abx = add.bind(null,40 ) // erstes argmument von add(40, p) +console.log(abx(20))// aufruf abx(20) => add(40, p=20) + + +// +// Erstelle eine Funktion namens aPlusb welche einen Parameter p entgegen nimmt, +// und intern immer add mit a=20 aufruft, b soll mit p belegt werden. +// Gib das Ergebnis der Berechnung zurück. +// Versuche zwei Lösungs-Varianten zu finden (Hint: bind). + + + + + + +// 2 +// Die gegebene Funktion add aus Aufgabe 1 soll geändert werden. +// Neu möchten wir, dass immer alle Argumente geloggt werden (bevor die Berechnung gemacht wird). +// Der Aufrufer kann selbst entscheiden was für einen Logger er verwenden möchte. +// z.B. console.log oder console.warn wären mögliche Logger. + +/* +function add2(a, b, logger){ + logger(`add(${a}, ${b})`) + return a + b +} +*/ +// via ...arguments array holen +function add2(a, b, logger){ + logger(`add(${[...arguments].slice(0, -1).join(', ')})`) + return a + b +} + +console.log(add2(20, 40, console.log)) + + +function bPlusa (p){ + return add2(20, p, console.log) +} + +console.log(bPlusa(20)) \ No newline at end of file diff --git a/src/functions.js b/src/functions.js index 120fd9c..246e73e 100644 --- a/src/functions.js +++ b/src/functions.js @@ -54,7 +54,7 @@ function meineFn(){ let y = 20 // shadow global y // this.x => sucht die variable x nur im this objekt // x sucht die variable x im lokalen scope und im äusseren globalen scope - console.log(this, this.x, x) + // console.log(this, this.x, x) } meineFn() // undefined undefined 1 new meineFn() // {} undefined 1 @@ -79,6 +79,7 @@ scopeWith1('hi') + // arrow functions let summ = (a, b) => a + b let decoratedSumm = (a, b) => { diff --git a/src/modules/app.js b/src/modules/app.mjs similarity index 62% rename from src/modules/app.js rename to src/modules/app.mjs index 80c56ee..24b692b 100644 --- a/src/modules/app.js +++ b/src/modules/app.mjs @@ -1,10 +1,10 @@ // 'use strict' // optional, weil im Browser via + + diff --git a/src/modules/logger.module.js b/src/modules/logger.module.mjs similarity index 100% rename from src/modules/logger.module.js rename to src/modules/logger.module.mjs diff --git a/src/objects.js b/src/objects.js index 9a75e37..83ec20d 100644 --- a/src/objects.js +++ b/src/objects.js @@ -63,5 +63,4 @@ const child1 = { weight: "86kg", father: person } - person.children.push(child1) \ No newline at end of file diff --git a/src/types.js b/src/types.js index 9e87fd6..944e715 100644 --- a/src/types.js +++ b/src/types.js @@ -18,6 +18,7 @@ x++ // evaluate than increment + //String let sa = 'hallo wasdfölkajsfdgelt'