Syntax verstehen mal wieder (sql, javascript)

[Aua (Gast)]

Ich arbeite mich gerade an diesem Tutorial ab:

https://bezkoder.com/node-js-rest-api-express-mysql/

Dabei fällt es mir schwer, zu verstehen, wie das Fragezeichen hier in 
dem sql-statement funktioniert - also woher weiß man / wie kann man 
nachlesen, was genau für das Fragezeichen eingesetzt wird; also wie dann 
das "fertige" Insert-into-Statement aussieht?

Customer.create = (newCustomer, result) => {
  sql.query("INSERT INTO customers SET ?", newCustomer, (err, res) => {
    if (err) {
      console.log("error: ", err);
      result(err, null);
      return;
    }
...

[Εrnst B. (ernst)]

Aua schrieb:
> wie kann man
> nachlesen

https://dev.mysql.com/doc/refman/8.0/en/insert.html

-> das insert ... set nimmt eine "assignment list", also eine Liste von 
zuweisungen wie "Vorname=Franz, Nachname=Aua, ..."

Wie das "newCustomer" - Objekt da hineingepresst wird, steht z.B. hier:
https://www.npmjs.com/package/mysql#escaping-query-values

- Objects that have a toSqlString method will have .toSqlString() called and the returned value is used as the raw SQL.
- Objects are turned into key = 'val' pairs for each enumerable property on the object. If the property's value is a function, it is skipped; if the property's value is an object, toString() is called on it and the returned value is used.

--> entweder hat dein Customer eine "toSqlString"-Methode, oder es wird 
drüberiteriert und key=value Paare gebildet.

[Irgend W. (Firma: egal) (irgendwer)]

Aua schrieb:
> wie kann man nachlesen

Wie wäre es damit einfach mal in der Beschreibung der von dir 
verwendeten Datenbank nachzuschauen?

z.B. https://dev.mysql.com/doc/refman/8.0/en/insert.html

[Aua (Gast)]

Εrnst B. schrieb:
> Wie das "newCustomer" - Objekt da hineingepresst wird, steht z.B. hier:
> https://www.npmjs.com/package/mysql#escaping-query-values

Danke! (da wird das mit dem Fragezeichen erklärt)

[Aua (Gast)]

ok, jetzt fehlt mir noch etwas zum Verständnis, gleiches Tutorial: In 
customer.model.js lautet die letzte Zeile:

module.exports = Customer;

Was macht die Zeile, und was ist dieses "exports", das im weiteren 
Verlauf verwendet wird?

[Aua (Gast)]

ah ok ich habs selbst gefunden

[Aua (Gast)]

Jetzt hatte ich mal wieder etwas Zeit für mein Hobby - aber leider auch 
noch ein Syntax-Verständnisproblem (gleiches Tutorial siehe oben):

Zum einen verstehe ich diese Schreibweise der Funktionen mit dem => 
Pfeil nicht:

Customer.create = (newCustomer, result) => {
  sql.query("INSERT INTO customers SET ?", newCustomer, (err, res) => {
    if (err) {
      console.log("error: ", err);
      result(err, null);
      return;
    }

    console.log("created customer: ", { id: res.insertId, ...newCustomer });
    result(null, { id: res.insertId, ...newCustomer });
  });
};

wie würde man das ohne den => Pfeil schreiben? Ich hab gelesen, dass das 
in den geschweiften Klammern nach dem Pfeil das ist, was die Funktion 
zurückgibt - aber wo wird da was ausgegeben, und was (zum anderen) 
bedeutet dieses "result(err, null);"?

[Εrnst B. (ernst)]

Aua schrieb:
> wie würde man das ohne den => Pfeil schreiben?

Ein aktuelles Javascript-Buch möchtest du nicht lesen? Oder wenigstens 
ein Grundlagen-Tutorial?

Bis auf einige Eigenheiten z.B. bzgl. "this" ist

(a,b,c)=>{...}
dasselbe wie
function(a,b,c) {...}

Aua schrieb:
> bedeutet dieses "result(err, null);"

"result" ist eine Funktion. Diese nimmt zwei Parameter. Bei Fehler wird 
die Funktion mit parametern "(err, null)" aufgerufen. Im Erfolgsfall mit 
"(null, ergebnis)"

Besonderheit: Welche tatsächliche Funktion sich hinter "result" 
verbirgt, wird erst beim Aufruf von Customer.create mitgeteilt, und kann 
bei jedem create-Aufruf eine andere sein.
Macht man, damit das Programm nicht blockiert ist, während die 
SQL-Anweisung läuft, aber man trotzdem auf deren Beendigung reagieren 
kann.

z.B.

console.log("A");
Customer.create({customerdata},(a,b) => { console.log("customer.create 
fertig",a,b); });
console.log("B");

Gibt aus:

A
B
... auf Datenbank warten ...
customer.create fertig null { id:12345, ...}


d.H. das Programm läuft weiter ("B"), während im Hintergrund die 
Datenbank werkelt

[Aua (Gast)]

danke, dieses "funktion als Parameter" bzw. als Argument war mir bisher 
fremd. Auch asynchrone callback-Funktionen. Ich lese ja nebenbei / aber 
manchmal ist es schön, wenn man es parallel mit anderen Worten (wie 
hier) erklärt sieht.

[Aua (Gast)]

.. und was noch schwer für mich ist: zu sehen, welcherart die Daten 
sind, die da hin und her wandern. Wieso z.B. kann man schreiben wie Du 
oben

Customer.create({customerdata},(a,b) => { console.log("customer.create
fertig",a,b); });

was ist dieses {customerdata} ? Ein Objekt? Array? Lose Blattsammlung? 
Wieso die geschweiften Klammern um ein Argument? :-)

Ich habe früher viel VB.net gemacht, da musste das vorher deklariert 
sein (man konnte es so einstellen)

[Εrnst B. (ernst)]

Aua schrieb:
> was ist dieses {customerdata}

in dem Fall: Ein Gedanklicher Platzhalter, hier sollten deine 
Kundendaten rein. Sinnvoll in dem Kontext ist das so nicht.

Besser:

const customerdata={
  vorname: "Hans",
  nachname: "Huber"
};

Customer.create(customerdata, ...

Oder (sog "spread-Operator")

Customer.create({ ...customerdata }, ...


Nur {customerdata} wäre kurz für
{ customerdata: customerdata }, und in dem Fall nicht das gewünschte.

War also in meinem Beispiel ungünstig und verwirrend gewählt, sorry.

[Aua (Gast)]

ah gut, danke für die Klarstellung ;-)

[Experte (Gast)]

Naja, eigentlich ist es ganz einfach, von den geschweiften Klammern wird 
in Javascript heftig Gebrauch gemacht für:

a.) Anonyme Funktionen bzw. Lambda-Funktionen:

  const f = (...) => {...}

b.) Objekte, Konstruktion sowie Dekonstruktion:

  const obj = {...};  // Objekt-Konstruktion
  const {...} = obj;  // Objekt-Dekonstruktion

Dabei gibt es für die Konstruktion sehr praktische Abkürzungen:

  const name = "Hans";
  const age = 21;
  const obj1 = { name: name, age: age };  // Ausführlich, redudant
  const obj2 = { name, age };             // Abkürzung

Und Objekt-Dekonstruktion:

  const obj = { name: "Hans", age: 21 };
  const { name, age } = obj;

Ist das gleiche wie:

  const obj = { name: "Hans", age: 21 };
  const name = obj.name;
  const age = obj.age;

Dabei kann und wird die Objekt-Konstruktion oft als Argument bei einem 
Funktionsaufruf geschrieben, und die Objekt-Dekonstruktion wird als 
Parameter verwendet:

  const beispiel = (data, fn) => {
    const msg = "Hallo, Welt!"; 
    fn({...data, msg});
  };

  const name = "Hans";
  const age = 21;
  const obj = {name, age};

  beispiel(obj, ({msg, name, age}) => { 
    console.log(msg);
    console.log(name, age); 
  });