js direkt aufrufen

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • js direkt aufrufen

    Hallo miteinander,

    ich habe: eine javascript datei die eine websocketverbindung aufbaut, eine Anforderung sendet und eine Antwort bekommt.
    ich habe: einen node server am laufen der webrequests aufnimmt und verarbeitet.

    Wie mache ich es dass ich per webrequest die javascript Datei aufrufe und node sie verarbeitet. Wenn ich den request in eine Browserzeile eingebe funktioniert es nicht. Da liefert er mir eben den Quelltext zurück. Also eigentlich soll der server den request entgegennehmen, die js datei aufrufen und verarbeiten.

    Ich stelle mir das ein bisschen wie bei php vor. Wie bringe ich dem nodeserver bei einen 127.0.0.1:8081/main.js einfach auszuführen?

    Vielen Dank
  • Wirf mal einen Blick auf node-direct, das macht genau das was du beschreibst.

    Alternativ dazu kannst du dir auch selbst einen solchen Node.js-Webserver bauen, der die im Ordner files liegenden JavaScript-Dateien dynamisch bei Bedarf lädt und ausführt:

    npm install require.async

    JavaScript-Quellcode: main.js

    1. const http = require('http')
    2. const path = require('path')
    3. require('require.async')(require)
    4. var cacheFiles = false
    5. const server = http.createServer((req, res) => {
    6. var filepath = './files' + path.normalize(req.url)
    7. // Cache bei Bedarf leeren
    8. if (!cacheFiles) try { delete require.cache[require.resolve(filepath)] } catch(err) {}
    9. // Datei laden und ausführen
    10. require.async(filepath, (route) => route(req, res), (err) => {
    11. res.writeHead(404)
    12. res.end()
    13. })
    14. })
    15. server.listen(8081)
    Alles anzeigen

    JavaScript-Quellcode: files/test.js

    1. module.exports = function(req, res) {
    2. res.writeHead(200, {'Content-Type': 'text/plain'})
    3. res.end('Hallo Welt!')
    4. }
    Beachte aber dass es aus Sicht der Performance generell besser ist alle benötigten Dateien im Voraus zu laden, da du so die Lade- und Initialisierungszeit der Dateien bei den Anfragen, oder mit Caching zumindest bei der jeweils ersten Anfrage, sparst.
    Grüße,
    NodeCode

    NodeCode.de
  • Der große Vorteil von Node besteht ja gerade darin nicht wie bei php immer wieder eine vollständige Datei verarbeiten zu müssen.

    Ich weiß ja nicht, was du genau vor hast, aber bei Node würde man normaler weise keine Datei ansprechen, sondern einen API-Endpunkt.

    Mal als kleines Beispiel mit Spirit:

    JavaScript-Quellcode: api.js

    1. const zitatListe = [
    2. 'Sokrates - Ich weiß, dass ich nichts weiß.',
    3. 'Conrad Adenauer - Ich bin diktatorisch, nur mit stark demokratischem Einschlag.',
    4. 'Helmut Schmidt - Wer Kritik übel nimmt, hat etwas zu verbergen.',
    5. 'Friedrich Hebbel - Das Publikum beklatscht ein Feuerwerk, aber keinen Sonnenaufgang!',
    6. 'Friedrich Hebbel - Es gehört oft mehr Mut dazu, seine Meinung zu ändern, als ihr treu zu bleiben.'
    7. ]
    8. function zitate() {
    9. return zitatListe[Math.round(Math.random() * 4)]
    10. }
    11. module.exports = {
    12. zitate
    13. }
    Alles anzeigen

    JavaScript-Quellcode: server.js

    1. const http = require('http')
    2. const { adapter } = require('spirit').node
    3. const route = require('spirit-router')
    4. const { zitate } = require('./api')
    5. const app = route.define([
    6. route.get('/zitate', zitate)
    7. ])
    8. http.createServer(adapter(app)).listen(8080)

    Wenn du jetzt "server.js" startest, bekommst du unter der Adresse "http://localhost:8080/zitate" immer ein zufälliges der 5 angezeigt.
  • So jetzt erstmal wieder herzlichen Dank für die Tipps und guten Ratschläge.
    Ich erläutere kurz mal mein Projekt- Ich möchte aus dem MetaTrader (gängiges Tradingprogramm) direkt mit dem Broker kommunizieren. Der Broker bietet da eine nützliche SChnittstelle für alle möglichen Sprachen.
    Anfangs hatte ich eine html Datei mit Javascript und wenn ich die im Browser aufgerufen habe konnte ich einen Trade beim Broker platzieren.
    Danach, der MetaTrader kann ein Webseite öffnen, konnte ich damit diese html Datei aufrufen was zu Folge hatte dass er bei jedem Trade ein Browserwindow geöffnet hat. Nicht sehr elegant, aber hat schon mal funktioniert.
    Deswegen kam mir die Idee mit der serverseitig ausführbaren javascript Datei und habe mich ein paar Tage mit dem node.js beschäftigt. Daraus kam die obige Frage zustande wie ich denn die jetzt auf dem server aufrufe.

    Mittlerweile bin ich ein ganzes Stück weiter und die Lösung ist wahrscheinlich immer noch nicht State of the Art aber für meine Zwecke schon recht gut.Ich begreife langsam auch was man mit diesem node eigentlich auch anfangen kann.Ich habe nun eine js Datei die einen Nodeserver erstellt. Den Metatrader habe ich auch soweit dass er mit diesem server requests austauschen kann.
    Dann habe ich in dem server script auch gleichzeitig eine ws Verbindung zum Broker aufbauen können. Und somit klicke ich auf "BUY" im Metatrader -> der sendet ein JSON Request an den server der es dann weiterreicht an die ws Verbindung zum Broker.
    Noch eleganter wäre es wahrscheinlich wenn man die ws Verbindung in eine separate Datei auslagert, das wäre wahrscheinlich sauberer von der Funktionstrennung.

    Im Moment läuft die node Geschicht noch lokal. Ich hätte aber schon gedacht dass das ganze am Ende im Netz läuft, so dass andere die Anbindung zum Broker auch nutzen können. Aber das ist noch Zukunftsmusik.

    Könnte mir vielleicht noch einer erklären was passiert bei ws.pause() ? Ist das so ähnlich wie standby. Und wozu benutzt man das? Und ist es üblich ws Verbindungen offen zu lassen oder nach jeden request wieder zu schliessen. Ich glaube dass der Broker nach einer Weile inaktivität sowieso die Verbindung wieder löst.

    Gibt es dann die Möglichkeit die Socketverbindung wieder herzustellen oder macht man da am besten wieder eine neue auf?

    Grüße

    Dieser Beitrag wurde bereits 4 mal editiert, zuletzt von Frika ()

  • ws.pause() pausiert soweit ich weiß die Verarbeitung von eingehenden Nachrichten.

    WebSockets wurde entwickelt um eine interaktive Kommunikation zwischen Server und Client mit möglichst geringer Latenzzeit zu ermöglichen, daher ist es üblich die Verbindung dauerhaft oder zumindest für eine gewisse Zeit offen zu lassen. Für alles andere kann auch normales HTTP verwendet werden.

    Wenn die WebSocket-Verbindung geschlossen wurde musst du wieder eine neue aufmachen.
    Grüße,
    NodeCode

    NodeCode.de
  • Hallo,
    die ws Verbindung halte ich nun aufrecht indem ich jede Minute ein ping schicke.

    Jetzt stehe ich wieder an einer Hürde die vielleciht einen neuen thread rechtfertigen würde aber da es um das gleiche Projekt geht mach ich hier mal weiter.

    Ich hab den Nodeserver am laufen. Dort mach ich eine ws-verbindung auf. Jetzt wäre es schön wenn noch jemand anderes auf den nodeserver zugreift und auch eine ws-verbindung zu seinem account aufmacht. Da jeder seinen speziellen token mitbringt der ihm Zugang zu seinem Account herstellen lässt wäre es ja super wenn die ws-verbindung den Namen des Token annehmen könnte. Also in etwas so:

    JavaScript-Quellcode

    1. var ws_("TOKEN von Hans") = new WebSocket('ws.llala...');
    Für mich wäre das die naheliegendste Lösung. So könnte man auch sicherstellen das jede Anfrage an die richtige websocket Verbindung weitergereicht wird.
    Oder denke ich da in die falsche Richtung. Weil rausgefunden habe ich noch nicht wie man so einen string (Token) als Variablennamen verwenden kann. Und nachträglich einen Namen einer Variablen zu ändern geht auch nicht, oder?
  • Ja, herzlichen Dank das mit dem Objekt ist die beste Lösung.
    Bei mir sieht das jetzt so aus:

    Quellcode

    1. const WS = {};
    2. WS[tokID] = {ws:new WebSocket('wss://ws.bin...'),chartCount : 1};
    Ich übergebe also noch ein Objekt in die Liste oder Array. Funktioniert auch sehr gut.
    Für mein Verständis nochmal, ich lege ja mit WS={} ein leeres Objekt an, richtig? Und dann füge ich mit WS[tokID] = {...} ein neues Objekt als Property zum Objekt WS hinzu, richtig. Ich mache also kein Array sondern ein Objekt mit vielen Properties die widerum Objekte sind.