Jahresrückblick 2025 – unser neuer Blogbeitrag ist online! ✨

[Gaspode]

Hallo,

Visual Studio Code meckert mir in folgendem Stück code (stark vereinfachtes Beispiel) die Zeile 22 an:

class Test extends utils.Adapter {

    /* ........ */

    async test() {
        let stateInfo = {
            stateName: 'pbat'
            , name: 'Battery power'
            , type: 'number'
            , read: true
            , role: 'value.power'
            , id: 'Battery_power'
            , unit: 'W'
        };

        await this.setObjectNotExistsAsync(stateInfo.id, {
            type: 'state',
            common: {
                name: stateInfo.name
                , type: stateInfo.type
                , role: stateInfo.role
                , read: true
                , write: false
                , unit: stateInfo.unit
            },
            native: {},
        });
    }
}

Meldung für Zeile 22:

                , read: true

Type '{ name: string; type: string; role: string; read: true; write: false; unit: string; desc: any; }' is not assignable to type 'ChannelCommon | StateCommon | DeviceCommon | OtherCommon | EnumCommon | MetaCommon | HostCommon | ... 4 more ... | ScriptCommon'.
  Object literal may only specify known properties, and 'read' does not exist in type 'AdapterCommon'.ts(2322)
objects.d.ts(546, 13): The expected type comes from property 'common' which is declared here on type '(Omit<StateObject, "_id" | "acl"> & { _id?: string | undefined; acl?: StateACL | undefined;

Ändere ich Zeile 20 von

                , type: stateInfo.type

zu

                , type: 'number'

verschwindet die Problemmeldung. Ist das wirklich ein Problem oder eine Falschmeldung. Sollte ich etwas ändern oder kann ich das Problem mittels "// @ts-ignore" ignorieren?

[dirkhe]

@gaspode das ganze ist async, da kennt er stateinfo nicht mehr

am besten definierst du das objekt kpl. Vorher und übergibst es als 2. Parameter

[Gaspode]

@dirkhe said in Visual Studio Code meldet Problem - und ich kapier's nicht.:

am besten definierst du das objekt kpl. Vorher und übergibst es als 2. Parameter

Vielen Dank für deine Hilfe. Ich glaube, ich verstehe das Problem, finde aber irgendwie nicht die richtige Syntax. Ich hab in Javascript wohl noch viel zu lernen. Ich hätte jetzt nach deinem Hinweis erwartet, dass folgendes funktioniert:

class Test extends utils.Adapter {

    /* ........ */

    async test() {
        let stateInfo = {
            stateName: 'pbat'
            , name: 'Battery power'
            , type: 'number'
            , read: true
            , role: 'value.power'
            , id: 'Battery_power'
            , unit: 'W'
        };

        const obj = {
            type: 'state',
            common: {
                name: stateInfo.name
                , type: stateInfo.type
                , role: stateInfo.role
                , read: true
                , write: false
                , unit: stateInfo.unit
            },
            native: {},
        };
        await this.setObjectNotExistsAsync(stateInfo.id, obj);
    }
}

Leider mag er das auch nicht:

Argument of type '{ type: string; common: { name: string; type: string; role: string; read: boolean; write: boolean; unit: string; desc: any; }; native: {}; }' is not assignable to parameter of type '(Omit<StateObject, "_id" | "acl"> & { _id?: string | undefined; acl?: StateACL | undefined; }) | (Omit<ChannelObject, "_id" | "acl"> & { ...; }) | ... 10 more ... | (Omit<...> & { ...; })'.
  Type '{ type: string; common: { name: string; type: string; role: string; read: boolean; write: boolean; unit: string; desc: any; }; native: {}; }' is not assignable to type 'Omit<OtherObject, "_id" | "acl"> & { _id?: string | undefined; acl?: ObjectACL | undefined; }'.
    Type '{ type: string; common: { name: string; type: string; role: string; read: boolean; write: boolean; unit: string; desc: any; }; native: {}; }' is not assignable to type 'Omit<OtherObject, "_id" | "acl">'.
      Types of property 'type' are incompatible.
        Type 'string' is not assignable to type '"config" | "chart"'.ts(2345)

Ich stehe gerade auf dem Schlauch. :flushed:
Für weitere Hilfe wäre ich sehr dankbar.

[dirkhe]

@gaspode ich glaube, ich war auf dem holzweg, die variable müsste er doch kennen...
Ich denke, der tyPe des objectes passt nicht. Ich glaube, du wirfst da was bei common durcheinander, was eins höher muss.
Schau dir die typen novhmal genazer an. Vs code hilt dir da bei der autovervollständigung. Ich denjem dass es bei dir auch direkt unterschlängelt ist?
Sitzte nicht am rechner, aber sollte eigentlich so sein.

[OliverIO]

@gaspode vs code prüft genau, was für typen von variablen du in eine funktion reinstecken darfst.

das problem hier ist, das es verschiedene datenobjekttypen gibt (state, channel, directory und nochmal 10 mehr). jede dieser typen hat aber wieder unterschiedliche anforderungen an den inhalt insbesondere auch an die untertypen common und native

Das Objekt für einen normalen Datenpunkt (also Typ state) anzulegen benötigt im Minimum die folgenden Attribute. Dann meckert vs code nicht mehr.

        this.setObjectNotExistsAsync("xyz",{
            type: "state",
            common:{
                name:"",
                read:true,
                write:true,
                role:""
            },
            native:{}
        });

Wenn du so etwas erstellst, dann musst du genau die Vorschläge und den Text den dir vs code da gibt lesen. Da es dafür soviele variationen gibt, ist das nicht immer einfach zu lesen.

dieses dokument solltest du dir auch einmal durchlesen
https://github.com/ioBroker/ioBroker.docs/blob/master/docs/en/dev/objectsschema.md
ich weiß, auch das ist nicht einfach zu lesen.
Auch hilft es dann direkt im iobroker mal direkt bei einem bereits vorhandenen objekt in die Bearbeitung zu gehen. im Reiter objektdaten findet man dann genau diese informationen.

und noch eine bitte: Das Komma gehört bei einem Property immer ans Ende und nicht an den Anfang. https://www.w3schools.com/js/js_conventions.asp

[Gaspode]

@oliverio

Danke für deine Hilfe. Allerdings ist das ja gerade das, was ich nicht verstehe. Die Varianten ...

        let stateInfo = {
            stateName: 'pbat'
            , name: 'Battery power'
            , type: 'number'
            , role: 'value.power'
            , id: 'Battery_power'
            , unit: 'W'
        };

        await this.setObjectNotExistsAsync(stateInfo.id, {
            type: 'state',
                common: {
                    name: stateInfo.name
                    , type: stateInfo.type
                    , role: stateInfo.role
                    , read: true
                    , write: false
                    , unit: stateInfo.unit
                    , desc: stateInfo.description
                },
                native: {},
            });

... und ...

        let stateInfo = {
            stateName: 'pbat'
           , name: 'Battery power'
           , type: 'number'
           , role: 'value.power'
          , id: 'Battery_power'
          , unit: 'W'
        };
                            
        await this.setObjectNotExistsAsync(stateInfo.id, {
                                type: 'state',
                                common: {
                                    name: stateInfo.name
                                    , type: 'number'
                                    , role: stateInfo.role
                                    , read: true
                                    , write: false
                                    , unit: stateInfo.unit
                                    , desc: stateInfo.description
                                },
                                native: {},
                            });

unterscheiden sich nur in einer Zeile ...

                , type: stateInfo.type

zu

                , type: 'number'

... und sollten nach meinem Verständnis absolut identisch sein. Sie tun auch beide, was sie sollen, nur bei Variante 1 meckert der VSC Type Checker. Ich tu mich nur immer schwer, eine Meldung per "// @ts-ignore" weg zu bügeln, denn manchmal deuten solche Meldungen ja doch auf Probleme hin, die man einfach (noch) nicht verstanden hat. Und da ich in Javascript noch blutiger Anfänger bin (komme von C++), frag ich lieber mal nach. :)

[OliverIO]

@gaspode

ich kann mir nur vorstellen, das vs code da ein problem hat den wert aus dem Objekt zu entnehmen.
Mach mal aus

let stateInfo

ein

const stateInfo

wenn vs code weiß, das sich das Objekt nicht ändern kann, evtl ist er dann eher bereit das zu aktzeptieren. Ansonsten könnte die Prüfung ja nur im runtime erfolgen.
Das sind halt die Dinge die Typsicherheit mit sich bringen, den Programmierer zu zwingen auch typsicherheit im code zu gewährleisten.

[Gaspode]

@oliverio
const ändert auch nix.
Normalerweise ist die Typprüfung echt super, im Original ist das ein const Array aus stateInfo, aus dem dann das passende Element herausgesucht wird. Wenn dann auch nur in einem Element was nicht passt, merkt er das sofort. Nur mit diesem speziellen Fall gibt's ein Problem. OK, dann kommt jetzt ein Ignore Comment drüber. Vielen Dank!

[OliverIO]

@gaspode

vs code hat nur im editor gemeckert? sonst läuft der code aber?

die typdeklaration ist auch etwas komplex. ein objekt, das sich aus einem generischen objekt, welches aber wieder viele verschiedene varianten hat und da dann das richtige raussuchen?
wenn du das aus einem array rausholst, dann evtl diese information einer variable zuweisen, die mit dem richtigen typ deklariert ist (StateCommon oder StateObject, je nach Ebene was im Array gespeichert ist). Dann könnte man da noch weiterhelfen.

[Gaspode]

@oliverio said in [Gelöst] VS Code meldet Problem - und ich kapier's nicht.:

vs code hat nur im editor gemeckert? sonst läuft der code aber?

Ja, läuft einwandfrei.

@oliverio said in [Gelöst] VS Code meldet Problem - und ich kapier's nicht.:

die typdeklaration ist auch etwas komplex. ein objekt, das sich aus einem generischen objekt, welches aber wieder viele verschiedene varianten hat und da dann das richtige raussuchen?

Naja, es wird ja Attribut für Attribut zugewiesen. Und wie gesagt, grundsätzlich klappt es perfekt mit der Typprüfung. Nur in diesem einen speziellen Fall meldet er was.