matze511: Hilfe für Rechnen mit JavaScript

Hallo liebe Gemeinde,

könnte mir bitte mal jemand Hilfestellung geben wie ich am besten anfange meine alte Rechnung die ich mal in Swift geschriben habe für JavaScript zu bewerkstelligen? Das war mal für eine App aber da man ja um sie auch auf dem eigenen Telefon zu haben reichlich Geld bezahlen soll möchte ich sie gern als private Webseite umbauen. Daher suche ich jegliche Hilfe. Das ist der alte Code in Swift:

class Dachgeometrie {

    var computationMode: ComputationMode = .traufhöVordachNeigung
    
    // Eingabe der Profilmaße
    
    var grundmaß = 0.0
    var firsthöhe = 0.0
    var traufhöhe = 0.0
    var dachüberstand = 0.0
    var dachneigung = 0.0
    var okFußpfette= 0.0
    var okFirstpfette = 0.0
    
    // Holzabmessungen zur Berechnung
    
    var sparrenhöhe = 0.18
    var fußpfettenhöhe = 0.12
    var fußpfettenbreite = 0.12
    var firstpfettenbreite = 0.12
    
    // Maße für die Herstellung des Dachstuhls / der Dachsparren
    
    var klauentiefe = 0.03
    var fußpfettenrücksprung = 0.0
    var lotrechtesObholz = 0.0
    var waagerechtesObholz = 0.0
    var okKniestock = 0.0
    var verkämmungZangen = 0.02
    var zangenRücksprung = 0.0
    var firstlaschenRücksprung = 0.0
    var returnBaptismOfSolderToRectangular = 0.0
    
    // Eigenschaften zur Berechnung der Werte
    
    var raumhöheRohbau = 2.75
    var sparrenbreite = 0.08
    var zangenhöhe = 0.16
    var zangenbreite = 0.08
    var mittelpfettenhöhe = 0.22
    var mittelpfettenbreite = 0.16
    var firstpfettenhöhe = 0.12
    var firstpfettenbreite = 0.12
    var firstlaschenbreite = 0.04
    
    // Eigenschaft für den Markierungswerte-Controller
    // Dachtraufe senkrecht
    
    var traufabschnittLotrecht = 0.0
    var traufabschnittlotrechteinzelmaß = 0.0
    var klauefußpfettemaßkette = 0.0
    var klauefußpfetteeinzelmaß = 0.0
    var klauefirstmaßkette = 0.0
    var klauefirstpfetteeinzelmaß = 0.0
    var klauemittelpfettemaßkette = 0.0
    var klauemittelpfetteeinzelmaß = 0.0
    var pliersOuterEdgeMiddlePurlin = 0.0
    var pliersMiddlepurlinToOuterEdge = 0.0
    var lengthRidgeFlap = 0.0
    var bottomMiddlePurlin = 0.0
    
    // Traufe senkrecht
    
    var rechtwinkligklauefußpfettemaßkette = 0.0
    var perpendicularklauemittelpfettemaßkette = 0.0
    var perpendicularklauefirstmaßkette = 0.0
    var perpendiculartraufabschnittLotrecht = 0.0
    var perpendicularklauefußpfetteeinzelmaß = 0.0
    var perpendicularklauemittelpfetteeinzelmaß = 0.0
    var perpendicularklauefirstpfetteeinzelmaß = 0.0
    var perpendiculartraufabschnittlotrechteinzelmaß = 0.0
    
    // Berechnungen/ Formeln
    // Keine Funktion, sondern eine berechnete Eigenschaft
    // Ätsch! Doch eine Funktion! :-D
    
    func updateProfilmaße() {
        
        switch computationMode {
            
        case .traufhöVordachNeigung:
            
            firsthöhe = round((((grundmaß + dachüberstand) * tan(dachneigung * M_PI / 180)) + traufhöhe) / 0.001) * 0.001
            okKniestock = round((dachüberstand * tan(dachneigung * M_PI / 180)) / 0.001) * 0.001
            lotrechtesObholz = (sparrenhöhe - klauentiefe) / cos(dachneigung * M_PI / 180)
            
            // okFußpfette
            let a = round(((dachüberstand + fußpfettenrücksprung) * tan(dachneigung * M_PI / 180)) / 0.001) * 0.001
            okFußpfette = round(((a - lotrechtesObholz) + traufhöhe) / 0.001) * 0.001
            
            // okFirstpfette
            let b = grundmaß - 0.5 * firstpfettenbreite + dachüberstand
            let c = b * tan(dachneigung * M_PI / 180) - lotrechtesObholz + traufhöhe
            okFirstpfette = round(c / 0.001) * 0.001
            
        case .firsthöTraufhöVordach:
            
            dachneigung = round(((atan((firsthöhe - traufhöhe) / (grundmaß + dachüberstand))) / M_PI * 180)  / 0.1) * 0.1
            okKniestock = round((dachüberstand * tan(dachneigung * M_PI / 180)) / 0.001) * 0.001
            lotrechtesObholz = (sparrenhöhe - klauentiefe) / cos(dachneigung * M_PI / 180)
            
            // okFußpfette
            let a = round(((dachüberstand + fußpfettenrücksprung) * tan(dachneigung * M_PI / 180)) / 0.001) * 0.001
            okFußpfette = round(((a - lotrechtesObholz) + traufhöhe) / 0.001) * 0.001
            
            // okFirstpfette
            let b = grundmaß - 0.5 * firstpfettenbreite + dachüberstand
            let c = b * tan(dachneigung * M_PI / 180) - lotrechtesObholz + traufhöhe
            okFirstpfette = round(c / 0.001) * 0.001
            
        case .vordachNeigungOKFußpf:
            
            lotrechtesObholz = (sparrenhöhe - klauentiefe) / cos(dachneigung * M_PI / 180)
            firsthöhe = round((((grundmaß - fußpfettenrücksprung) * tan(dachneigung * M_PI / 180)) + okFußpfette + lotrechtesObholz) / 0.001) * 0.001
            traufhöhe = round(((okFußpfette + lotrechtesObholz) - (dachüberstand + fußpfettenrücksprung) * tan(dachneigung * M_PI / 180)) / 0.001) * 0.001
            
            // okFirstpfette
            let a = grundmaß - 0.5 * firstpfettenbreite + dachüberstand
            let b = a * tan(dachneigung * M_PI / 180) - lotrechtesObholz + traufhöhe
            okFirstpfette = round(b / 0.001) * 0.001
        }
        
        // Berechnungen für MarkingValuesController
        // Traufe lotrecht Maßkette
        traufabschnittLotrecht = sqrt(pow((grundmaß + dachüberstand), 2.0) + pow((firsthöhe - traufhöhe), 2.0))
        klauefußpfettemaßkette = sqrt(pow((dachüberstand + fußpfettenrücksprung), 2.0) + pow((okFußpfette + lotrechtesObholz - traufhöhe), 2.0))
        klauefirstmaßkette = sqrt(pow((grundmaß + dachüberstand - (0.5 * firstpfettenbreite)), 2.0) + pow((okFirstpfette + lotrechtesObholz - traufhöhe), 2.0))
        let c = raumhöheRohbau + (zangenhöhe - verkämmungZangen) + mittelpfettenhöhe + lotrechtesObholz - traufhöhe
        klauemittelpfettemaßkette = c / sin(dachneigung * M_PI / 180)
        
        // Traufe lotrecht Einzelmaße
        klauefußpfetteeinzelmaß = klauefußpfettemaßkette
        traufabschnittlotrechteinzelmaß = traufabschnittLotrecht - klauefirstmaßkette
        klauefirstpfetteeinzelmaß = traufabschnittLotrecht - traufabschnittlotrechteinzelmaß - klauemittelpfettemaßkette
        klauemittelpfetteeinzelmaß = traufabschnittLotrecht - traufabschnittlotrechteinzelmaß - klauefirstpfetteeinzelmaß - klauefußpfetteeinzelmaß
        
        // Traufe rechtwinklig Maßkette
        rechtwinkligklauefußpfettemaßkette = klauefußpfettemaßkette - returnBaptismOfSolderToRectangular
        rechtwinkligklauemittelpfettemaßkette = klauemittelpfettemaßkette - returnBaptismOfSolderToRectangular
        rechtwinkligklauefirstmaßkette = klauefirstmaßkette - returnBaptismOfSolderToRectangular
        rechtwinkligtraufabschnittLotrecht = traufabschnittLotrecht - returnBaptismOfSolderToRectangular
        
        // Traufe rechtwinklig Einzelmaße
        rechtwinkligklauefußpfetteeinzelmaß = rechtwinkligklauefußpfettemaßkette
        rechtwinkligklauemittelpfetteeinzelmaß = klauemittelpfetteeinzelmaß
        rechtwinkligklauefirstpfetteeinzelmaß = klauefirstpfetteeinzelmaß
        rechtwinkligtraufabschnittlotrechteinzelmaß = traufabschnittlotrechteinzelmaß
        
        // Zangen/ Firstlaschen/ Pfosten etc
        zangeaußenkantemittelpfette = grundmaß + dachüberstand - (raumhöheRohbau + (zangenhöhe - verkämmungZangen) + mittelpfettenhöhe + lotrechtesObholz - traufhöhe)
        zangemittelpfettezuraußenkante = ((mittelpfettenhöhe - verkämmungZangen) / tan(dachneigung * M_PI / 180)) + waagerechtesObholz - zangenRücksprung
        ukmittelpfette = raumhöheRohbau + (zangenhöhe - verkämmungZangen)
        längefirstlasche = (((firsthöhe - okFirstpfette + firstpfettenhöhe) / tan(dachneigung * M_PI / 180)) - firstlaschenRücksprung) * 2.0
        
        // Berechnungen/ Zwischenrechnunge/ Maße die nicht auftauchen in den Views
        
        waagerechtesObholz = lotrechtesObholz / tan(dachneigung * M_PI / 180)
        zangenRücksprung = 0.02 / sin(dachneigung * M_PI / 180)
        firstlaschenRücksprung = 0.01 / sin(dachneigung * M_PI / 180)
        returnBaptismOfSolderToRectangular = sparrenhöhe / tan(dachneigung * M_PI / 180)
        
    }
    
    // Berechnungen für die Warnungen!!!
    var überhangfußpfettenachinnen: Double {
        return fußpfettenrücksprung + fußpfettenbreite
    }
    var drempel-sparren: Double {
        return (fußpfettenhöhe - (klauentiefe / cos(dachneigung * M_PI / 180))) / tan(dachneigung * M_PI / 180)
    }
    var ukFirstlasche: Double {
        return okFirstpfette - firstpfettenhöhe - firstlaschenhöhe
    }
    var okmittelpfette: Double {
        return raumhöheRohbau + zangenhöhe - verkämmungZangen + mittelpfettenhöhe
    }
    var beta: Double {
        return 90 - dachneigung
    }
    
}

Danke schonmal für jegliche Hilfestellung!

LG Matze

  1. Hallo matze511,

    Wenn das Script korrekt ist, kannst du es ja von ChatGPT übersetzen lassen:

    To translate your Swift code to JavaScript, I'll start by creating a class structure in JavaScript that resembles the Swift class. JavaScript does not have native support for specific features like Swift's computed properties and enums, but we can simulate them with functions and conditionals. Here's a translated version of your Swift class:

    class Dachgeometrie {
        constructor() {
            // Default computation mode
            this.computationMode = 'traufhoVordachNeigung'; // Simulated enum value
    
            // Input profile dimensions
            this.grundmaß = 0.0;
            this.firsthöhe = 0.0;
            this.traufhöhe = 0.0;
            this.dachüberstand = 0.0;
            this.dachneigung = 0.0;
            this.okFußpfette = 0.0;
            this.okFirstpfette = 0.0;
    
            // Timber dimensions for calculation
            this.sparrenhöhe = 0.18;
            this.fußpfettenhöhe = 0.12;
            this.fußpfettenbreite = 0.12;
            this.firstpfettenbreite = 0.12;
    
            // Roof production dimensions
            this.klauentiefe = 0.03;
            this.fußpfettenrücksprung = 0.0;
            this.lotrechtesObholz = 0.0;
            this.waagerechtesObholz = 0.0;
            this.okKniestock = 0.0;
            this.verkämmungZangen = 0.02;
            this.zangenRücksprung = 0.0;
            this.firstlaschenRücksprung = 0.0;
            this.returnBaptismOfSolderToRectangular = 0.0;
    
            // Properties for calculations
            this.raumhöheRohbau = 2.75;
            this.sparrenbreite = 0.08;
            this.zangenhöhe = 0.16;
            this.zangenbreite = 0.08;
            this.mittelpfettenhöhe = 0.22;
            this.mittelpfettenbreite = 0.16;
            this.firstpfettenhöhe = 0.12;
            this.firstlaschenbreite = 0.04;
    
            // Traufe vertical
            this.traufabschnittLotrecht = 0.0;
            this.klauefußpfettemaßkette = 0.0;
            this.klauefirstmaßkette = 0.0;
            this.klauemittelpfettemaßkette = 0.0;
            this.perpendicularklauefirstmaßkette = 0.0;
            this.traufabschnittlotrechteinzelmaß = 0.0;
    
            // Formulas and calculations
            this.beta = 0.0;  // Additional property for the angle
    
            // Further dimensions and calculations can be added here similarly
        }
    
        // Function to update profile dimensions based on the computation mode
        updateProfilmaße() {
            const PI = Math.PI;
    
            switch (this.computationMode) {
                case 'traufhoVordachNeigung':
                    this.firsthöhe = Math.round((((this.grundmaß + this.dachüberstand) * Math.tan(this.dachneigung * PI / 180)) + this.traufhöhe) / 0.001) * 0.001;
                    this.okKniestock = Math.round((this.dachüberstand * Math.tan(this.dachneigung * PI / 180)) / 0.001) * 0.001;
                    this.lotrechtesObholz = (this.sparrenhöhe - this.klauentiefe) / Math.cos(this.dachneigung * PI / 180);
                    
                    let a = Math.round(((this.dachüberstand + this.fußpfettenrücksprung) * Math.tan(this.dachneigung * PI / 180)) / 0.001) * 0.001;
                    this.okFußpfette = Math.round(((a - this.lotrechtesObholz) + this.traufhöhe) / 0.001) * 0.001;
                    
                    let b = this.grundmaß - 0.5 * this.firstpfettenbreite + this.dachüberstand;
                    let c = b * Math.tan(this.dachneigung * PI / 180) - this.lotrechtesObholz + this.traufhöhe;
                    this.okFirstpfette = Math.round(c / 0.001) * 0.001;
                    break;
    
                case 'firsthoTraufhoVordach':
                    this.dachneigung = Math.round(((Math.atan((this.firsthöhe - this.traufhöhe) / (this.grundmaß + this.dachüberstand))) / PI * 180) / 0.1) * 0.1;
                    this.okKniestock = Math.round((this.dachüberstand * Math.tan(this.dachneigung * PI / 180)) / 0.001) * 0.001;
                    this.lotrechtesObholz = (this.sparrenhöhe - this.klauentiefe) / Math.cos(this.dachneigung * PI / 180);
                    
                    let a2 = Math.round(((this.dachüberstand + this.fußpfettenrücksprung) * Math.tan(this.dachneigung * PI / 180)) / 0.001) * 0.001;
                    this.okFußpfette = Math.round(((a2 - this.lotrechtesObholz) + this.traufhöhe) / 0.001) * 0.001;
    
                    let b2 = this.grundmaß - 0.5 * this.firstpfettenbreite + this.dachüberstand;
                    let c2 = b2 * Math.tan(this.dachneigung * PI / 180) - this.lotrechtesObholz + this.traufhöhe;
                    this.okFirstpfette = Math.round(c2 / 0.001) * 0.001;
                    break;
    
                case 'vordachNeigungOKFußpf':
                    this.lotrechtesObholz = (this.sparrenhöhe - this.klauentiefe) / Math.cos(this.dachneigung * PI / 180);
                    this.firsthöhe = Math.round((((this.grundmaß - this.fußpfettenrücksprung) * Math.tan(this.dachneigung * PI / 180)) + this.okFußpfette + this.lotrechtesObholz) / 0.001) * 0.001;
                    this.traufhöhe = Math.round(((this.okFußpfette + this.lotrechtesObholz) - (this.dachüberstand + this.fußpfettenrücksprung) * Math.tan(this.dachneigung * PI / 180)) / 0.001) * 0.001;
                    
                    let a3 = this.grundmaß - 0.5 * this.firstpfettenbreite + this.dachüberstand;
                    let b3 = a3 * Math.tan(this.dachneigung * PI / 180) - this.lotrechtesObholz + this.traufhöhe;
                    this.okFirstpfette = Math.round(b3 / 0.001) * 0.001;
                    break;
            }
    
            // Additional calculations for "MarkingValuesController"
            this.traufabschnittLotrecht = Math.sqrt(Math.pow((this.grundmaß + this.dachüberstand), 2) + Math.pow((this.firsthöhe - this.traufhöhe), 2));
            this.klauefußpfettemaßkette = Math.sqrt(Math.pow((this.dachüberstand + this.fußpfettenrücksprung), 2) + Math.pow((this.okFußpfette + this.lotrechtesObholz - this.traufhöhe), 2));
            this.klauefirstmaßkette = Math.sqrt(Math.pow((this.grundmaß + this.dachüberstand - (0.5 * this.firstpfettenbreite)), 2) + Math.pow((this.okFirstpfette + this.lotrechtesObholz - this.traufhöhe), 2));
            let c3 = this.raumhöheRohbau + (this.zangenhöhe - this.verkämmungZangen) + this.mittelpfettenhöhe + this.lotrechtesObholz - this.traufhöhe;
            this.klauemittelpfettemaßkette = c3 / Math.sin(this.dachneigung * PI / 180);
    
            // More calculations can be added here as per the original logic
        }
    
        // Computed properties in Swift can be replaced with functions in JS
        get überhangfußpfettenachinnen() {
            return this.fußpfettenrücksprung + this.fußpfettenbreite;
        }
    
        get drempelSparren() {
            return (this.fußpfettenhöhe - (this.klauentiefe / Math.cos(this.dachneigung * Math.PI / 180))) / Math.tan(this.dachneigung * Math.PI / 180);
        }
    
        get ukFirstlasche() {
            return this.okFirstpfette - this.firstpfettenhöhe - this.firstlaschenbreite;
        }
    
        get okmittelpfette() {
            return this.raumhöheRohbau + this
    
    

    Jetzt musst du es in deine App einbinden und testen!

    Bis bald! Jonathan

    --
    "Ich habe heute ein Elan-Problem und mein Tatenvolumen ist fast aufgebraucht!"
  2. Hallo Matze,

    du wirst nicht umhin kommen, HTML und Javascript zu lernen. Aber dafür haben wir einiges in unserem Wiki:

    • Wie fange ich an, und da speziell der Einstieg in HTML und der Einstieg in Javascript.
    • Für deine Rechnungen brauchst du das Math-Objekt .
    • Ein Beispiel für Eingabe, Berechnung und Ausgabe von Zahlen: BMI-Rechner

    Fang mal an und wenn du nicht weiter weißt, frag hier nach.

    Gruß
    Jürgen