Script API-referanse
Hodor kjører skriptene dine i en innebygd JavaScript-motor. Avhengig av skripttypen kaller Hodor én av inngangsfunksjonene nedenfor på riktig tidspunkt — du implementerer bare logikken du trenger. Hvis du ikke endrer noe, sletter du inngangsfunksjonen som ikke er i bruk, for å unngå unødvendige kall.
Tilgjengelige globale objekter og klasser:
| Kategori | Navn |
|---|---|
| Inngangsfunksjoner | onRequest, onResponse, onSessionCompleted, onSchedule, abort() |
Native $-moduler | $codec, $hash, $hmac, $crypto, $jwt, $format, $fs, $env, $uuid, $log |
| Web-standard-API-er | fetch, HTTPClient, setTimeout / setInterval, btoa / atob / sleep / require / TextEncoder / crypto, console |
| HTTP-klasser | Request, Response, Body, Headers, URLSearchParams |
| Lagring | SharedPreferences, sdk-variabler |
| Kontekster | RewriteContext, CompletedContext, ScheduleContext |
Bruk console.log(...) hvor som helst i et skript for å inspisere verdier — utdataene vises i skriptets loggvisning.
Inngangsfunksjoner
Skript oppdages ved å skanne etter async function-deklarasjoner — antall parametere i hver inngangsfunksjon er fast (onRequest/onResponse tar 3, onSessionCompleted tar 4, onSchedule tar 1). Pilfunksjons-tilordninger (let onRequest = async (...) => {}) oppdages ikke. Parameternavn er fritt valgbare.
onRequest(context, url, request)
Designet for Rewrite-skript og Quick Requests skript før sending. Denne funksjonen kalles før HTTP-forespørselen sendes til serveren. Returner request (eventuelt endret).
| Parameter | Type | Beskrivelse |
|---|---|---|
context | RewriteContext | Kontekstobjektet. |
url | string | URL-en til HTTP-forespørselen. |
request | Request | HTTP-forespørselsobjektet. |
// modify request body
async function onRequest(context, url, request) {
// parse to Text
var text = request.body.parseText()
console.log(text)
request.body = "this is a replaced request text"
// parse to JSON
var json = request.body.parseJSON()
json["script_json"] = "JSONValue"
request.body = json
// parse to URLSearchParams
var urlencoded = request.body.parseURLSearchParams()
urlencoded.append("script", "parseURLSearchParams")
request.body = urlencoded
// Done
return request;
}
// redirect, modify path / queries / headers
async function onRequest(context, url, request) {
console.log(url);
// set a parameter, you can get it in onResponse
context.parameters["custom"] = "custom parameter on request"
// redirect
request.scheme = "http"
request.path = "/upload/json"
request.host = "192.168.3.30"
request.port = 6000
// change method
request.method = "POST"
// queries operation
request.queries.append("name", "value1") // add query
request.queries.set("name", "value2") // replace or add query
request.queries.get("name") // get query by name
request.queries.delete("name") // delete query by name
// headers operation
request.headers.delete("accept") // delete header by name
request.headers.append("hodor", "custom value") // add name-value pair
request.headers.forEach((value, name) => {
console.log(name + ":" + value)
});
// Done
return request;
}
onResponse(context, url, response)
Designet for Rewrite-skript og Quick Requests skript etter svar. Denne funksjonen kalles før HTTP-svaret sendes til klienten. Returner response (eventuelt endret).
| Parameter | Type | Beskrivelse |
|---|---|---|
context | RewriteContext | Kontekstobjektet. |
url | string | URL-en til HTTP-svaret. |
response | Response | HTTP-svarobjektet. |
// response body
async function onResponse(context, url, response) {
// parse to Text
var text = response.body.parseText()
console.log(text)
response.body = "this is a replaced response text"
// parse to JSON
var json = response.body.parseJSON()
json["script_json"] = "JSONValue"
response.body = json
// parse to URLSearchParams
var urlencoded = response.body.parseURLSearchParams()
urlencoded.append("script", "parseURLSearchParams")
response.body = urlencoded
// Done
return response;
}
// change status code and headers
async function onResponse(context, url, response) {
// get parameters set in onRequest
console.log(context.parameters["custom"]) // Output "custom parameter on request"
response.statusCode = 200 // change status code
response.statusPhrase = "OK" // change status phrase
response.headers.delete("accept")
response.headers.append("hodor", "custom value")
response.headers.forEach((value, name) => {
console.log(name + ":" + value)
});
// Done
return response
}
onSessionCompleted(context, url, request, response)
Designet for HTTP completed-skript. Kalles asynkront etter at HTTP-svaret er returnert, uten å påvirke dataoverføringen mellom appen og serveren. Nyttig for datainnsamling og videresending.
| Parameter | Type | Beskrivelse |
|---|---|---|
context | CompletedContext | Kontekstobjektet. |
url | string | URL-en til HTTP-forespørselen. |
request | Request | HTTP-forespørselsobjektet. |
response | Response | HTTP-svarobjektet. |
// sample: pass session data to your own server
async function onSessionCompleted(context, url, request, response) {
try {
var reqText = request.body.parseText();
var rspText = response.body.parseText()
var params = {
"body": { // HTTPClient post body data
"url": url, // request url
"reqHeader": request.headers.encode(), // request headers
"reqText": reqText, // request body
"rspHeader": response.headers.encode(), // response headers
"rspText": rspText, // response body
},
"headers": { // HTTPClient headers
"from": "onSessionCompleted"
},
}
const rsp = await HTTPClient.post("http://192.168.3.30:8000/upload", params)
let text = rsp.body.parseText()
console.log(text)
} catch(error) {
console.log(error)
}
}
onSchedule(context)
Designet for Schedule-skript. Kalles på det planlagte utløsningstidspunktet (cron-uttrykk med 5 eller 6 felt støttes). Bruk abort() for å stoppe planløkken.
| Parameter | Type | Beskrivelse |
|---|---|---|
context | ScheduleContext | Kontekstobjektet. |
async function onSchedule(context) {
// set custom parameters for next runloop
context.parameters["custom"] = "custom parameters for next runloop";
// repeated count
console.log(`repeatedCount ${context.repeatedCount}`);
// if repeatedCount is 2, abort schedule
if (context.repeatedCount == 2) {
abort()
}
// you can also use HTTPClient to send requests
const rsp = await HTTPClient.get("https://www.apple.com")
let text = rsp.body.parseText()
console.log(text)
}
abort()
Inne i kanalskript (onRequest / onResponse / onSchedule), kall abort() for å stoppe skriptet og avbryte gjeldende kjøring umiddelbart — det kaster en AbortError som Hodor rapporterer tilbake til deg.
// ✅ correct — abort() is injected into the script scope
async function onRequest(context, url, request) {
if (url.includes("/tracking")) abort();
return request;
}
Deklarer ikke onRequest(context, url, request, aborter) med en 4. parameter. Antall parametere i inngangsfunksjoner er fast — en 4. parameter gjør inngangen uoppdagbar.
Native moduler
Alle moduler med $-prefiks injiseres når kjøretiden aktiveres. De er implementert nativt, returnerer synkront (med mindre annet er oppgitt) og behandler strenginndata som UTF-8.
$codec — Koding og dekoding
Base64 / hex / URL-prosentkoding for protokollkonvertering og dataoverføring.
| Metode | Returnerer |
|---|---|
$codec.base64Encode(str) | Base64-streng. |
$codec.base64Decode(str) | Dekodet streng; ugyldig inndata returnerer "" (kastet ikke). |
$codec.hexEncode(str) | Hex-streng med små bokstaver. |
$codec.hexDecode(str) | Dekodet streng; ugyldige tegn hoppes over. |
$codec.urlEncode(str) | Prosentkodet streng. |
$codec.urlDecode(str) | Dekodet streng; ugyldige sekvenser returneres som de er. |
$codec.base64Encode("Hello, World!"); // "SGVsbG8sIFdvcmxkIQ=="
$codec.base64Decode("SGVsbG8sIFdvcmxkIQ=="); // "Hello, World!"
$codec.hexEncode("ABC"); // "414243"
$codec.hexDecode("414243"); // "ABC"
$codec.urlEncode("hello world&foo=bar"); // "hello%20world%26foo%3Dbar"
$hash — Hashing
Digest-beregning for integritetskontroller, innholdsadressering og anonymisering. Returnerer hex med små bokstaver.
| Metode | Utdata-lengde |
|---|---|
$hash.md5(str) | 32 hex-tegn |
$hash.sha1(str) | 40 hex-tegn |
$hash.sha256(str) | 64 hex-tegn |
$hash.sha384(str) | 96 hex-tegn |
$hash.sha512(str) | 128 hex-tegn |
$hash.md5("hello"); // "5d41402abc4b2a76b9719d911017c592"
$hash.sha256("hello"); // "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"
// integrity check
const checksum = $hash.sha256(JSON.stringify({user: "admin"}));
$hmac — Meldingsautentiseringskode
Nøklet hashing for API-signering og manipulasjonsdeteksjon. Både (data, key) er UTF-8-kodet; returnerer hex med små bokstaver.
| Metode | Algoritme |
|---|---|
$hmac.md5(data, key) | HMAC-MD5 |
$hmac.sha1(data, key) | HMAC-SHA1 |
$hmac.sha256(data, key) | HMAC-SHA256 |
$hmac.sha384(data, key) | HMAC-SHA384 |
$hmac.sha512(data, key) | HMAC-SHA512 |
const signature = $hmac.sha256("important data", "my-secret-key");
const isValid = (signature === $hmac.sha256("important data", "my-secret-key")); // true
$crypto — Symmetrisk kryptering
AES-GCM autentisert kryptering (anbefalt) og DES (bakoverkompatibilitet).
| Metode | Returnerer |
|---|---|
$crypto.encryptAES(plaintext, password, options?) | Base64-ciphertext; feil returnerer en "Error: <reason>"-streng. |
$crypto.decryptAES(ciphertext, password, options?) | Klartekst; ugyldig ciphertext returnerer "Error: Invalid ciphertext". |
$crypto.encryptDES(plaintext, key) | DES-ECB + PKCS7, nøkkelen kuttes til 8 byte → Base64. |
$crypto.decryptDES(ciphertext, key) | Klartekst; ikke-Base64-inndata returnerer "". |
options: { keySize: 128 \| 192 \| 256 } (standard 256). AES-ciphertext-formatet er base64(nonce[12] + ciphertext + tag[16]) — bruk det sammen med decryptAES; når du samarbeider med andre språk må du pakke ut dette formatet selv.
const encrypted = $crypto.encryptAES("sensitive data", "my-password");
$crypto.decryptAES(encrypted, "my-password"); // "sensitive data"
// 128-bit key
const e128 = $crypto.encryptAES("data", "pass", { keySize: 128 });
// errors are returned as strings, not thrown — check the prefix
const out = $crypto.decryptAES("not-base64!!", "p");
if (out.startsWith("Error:")) { /* handle error */ }
$jwt — JSON Web Token
JWT-oppretting, -parsing og signaturverifisering (HMAC-familien) for autentiseringsflyt-skript.
| Metode | Returnerer |
|---|---|
$jwt.sign(payload, secret, algorithm?) | JWT-streng; standard HS256. |
$jwt.decode(token) | {header, payload}-objekt (signaturen er ikke verifisert); returnerer null for feilformede token. |
$jwt.verify(token, secret, algorithm?) | boolean — resultatet av signaturverifiseringen. |
algorithm: "HS256" | "HS384" | "HS512".
// sign
const payload = JSON.stringify({ sub: "user123", exp: Math.floor(Date.now() / 1000) + 3600 });
const token = $jwt.sign(payload, "my-secret", "HS256");
// decode — returns an object directly, no JSON.parse needed
const decoded = $jwt.decode(token);
decoded.header.alg; // "HS256"
decoded.payload.sub; // "user123"
// verify
$jwt.verify(token, "my-secret", "HS256"); // true
$jwt.verify(token, "wrong-secret", "HS256"); // false
// expiry check
const exp = $jwt.decode(token).payload.exp;
const expired = exp * 1000 < Date.now();
$format — Dataformatering
JSON/XML pretty-printing og minifisering for logging og feilsøking. JSON-nøkler sorteres alfabetisk i utdataene.
| Metode | Returnerer |
|---|---|
$format.json(str, indent?) | Pretty-printet JSON; innrykk begrenses til 1–8 (standard 2); ugyldig inndata returnerer "Error: Invalid JSON". |
$format.minify(str) | Minifisert JSON (sorterte nøkler, ingen mellomrom); ugyldig inndata returnerer "Error: Invalid JSON". |
$format.xml(str) | Enkelt innrykket XML. |
$format.json('{"b":1,"a":2}');
// {
// "a": 2,
// "b": 1
// }
$format.json('{"a":2}', 4); // 4-space indent
$format.minify('{ "a": 2 }'); // '{"a":2}'
$format.xml('<root><child>t</child></root>');
// <root>
// <child>t</child>
// </root>
$fs — Filsystem
Lettvekts fillesing/-skriving i skript (konfigurasjon, cache, eksport). Stier støtter ~-utvidelse; write oppretter manglende overordnede mapper automatisk.
| Metode | Returnerer |
|---|---|
$fs.read(path) | UTF-8-innhold; feil returnerer "Error: Cannot read file at <path>". |
$fs.readBinary(path) | Bytes som Base64; feil returnerer "". |
$fs.write(path, content) | boolean — vellykket. |
$fs.exists(path) | boolean. |
$fs.delete(path) | boolean; manglende filer returnerer false. |
$fs.list(path) | string[] med mappeoppføringer; feil returnerer []. |
$fs.info(path) | JSON-streng {size, modified, isDirectory, path}; manglende stier returnerer undefined. |
const file = $env.tmpDir() + "/hodor-test.txt";
$fs.write(file, "Hello from Hodor!");
$fs.read(file); // "Hello from Hodor!"
$fs.exists(file); // true
$fs.list($env.tmpDir()); // ["hodor-test.txt", ...]
const info = JSON.parse($fs.info(file));
info.size; // byte count
info.isDirectory; // false
$fs.delete(file); // true
Feilformene varierer per metode: read returnerer en "Error: ..."-streng, readBinary returnerer "", list returnerer [] og info returnerer undefined — håndter hver av dem deretter.
$env — Miljøvariabler
Prosessens miljøvariabler og systemstier. Merk: $env er prosessmiljøet (delt mellom kjøringer, lever med prosessen). For å gjøre brukervendte variabler vedvarende, bruk heller sdk.setEnvVar eller SharedPreferences.
| Metode | Returnerer |
|---|---|
$env.get(key) | Verdien; manglende nøkler returnerer "". |
$env.set(key, value) | boolean — setenv-resultatet. |
$env.all() | JSON-streng med alle miljøvariabler. |
$env.cwd() | Gjeldende arbeidsmappe. |
$env.tmpDir() | Midlertidig mappe. |
$env.homeDir() | Brukerens hjemmemappe. |
$env.set("APP_VERSION", "1.0.0");
$env.get("APP_VERSION"); // "1.0.0"
const all = JSON.parse($env.all());
$uuid — UUID
Generering og validering av UUID-er (forespørsels-ID-er, idempotensnøkler).
| Metode | Returnerer |
|---|---|
$uuid.v4() | Standard v4-UUID (store bokstaver, med bindestrek), f.eks. "550e8400-E29B-41D4-A716-446655440000". |
$uuid.compact() | Form uten bindestrek, med små bokstaver. |
$uuid.validate(str) | Om strengen er en gyldig UUID. |
const id = $uuid.v4();
$uuid.compact(); // "550e8400e29b41d4a716446655440000"
$uuid.validate($uuid.v4()); // true
$uuid.validate("not-uuid"); // false
validate godtar bare formatet med bindestrek — validate($uuid.compact()) returnerer false. Sett inn bindestreker på nytt før du validerer en kompakt streng.
$log — Strukturert logging
Logglinjer med tidsstempel og nivå, rutet gjennom motorens konsollsystem (samlet i skriptets loggvisning).
| Metode | Returnerer |
|---|---|
$log.log(level, message, tag?) | Formatert logglinje (skrives også ut). |
$log.debug / info / warn / error(message) | Praktiske nivåmetoder, kun utdata. |
Logglinjeformat: [yyyy-MM-dd'T'HH:mm:ss.SSSZ] [LEVEL] [tag] message (delen [tag] utelates når ingen tag er oppgitt).
$log.info("Server started on port 8080");
// [2025-07-24T01:11:45.548+0800] [INFO] Server started on port 8080
$log.log("info", "Request processed", "API");
// [2025-07-24T01:11:45.548+0800] [INFO] [API] Request processed
Web-API-er
fetch
Send ekte HTTP-forespørsler fra skript — hovedkanalen for Postman-stil arbeidsflyter.
fetch(url: string, options?: object) → Promise<response>
options:
| Felt | Type | Standard | Beskrivelse |
|---|---|---|---|
method | string | "GET" | Ikke sensitiv for store/små bokstaver; ukjente verdier faller tilbake til GET. |
timeoutInterval | number | 30 | I sekunder. |
headers | [[k, v]] eller [{k: v}] | [] | Begge formene godtas. |
textBody | string | — | Forespørselens body-tekst. |
encoding | string | — | "hex" betyr at textBody er en hex-streng. |
Den utløste verdien er et vanlig objekt: statusCode (tall), headers (array av enkeltnøkkel-objekter, dupliserte nøkler bevares) og textBody() — en funksjon som returnerer {text, encoding} med automatisk tegnsett-deteksjon (body som ikke kan dekodes faller tilbake til {text: <hex>, encoding: "hex"}). Den avviste verdien er en feilmeldingsstreng.
// GET
const rsp = await fetch("https://httpbin.org/get");
if (rsp.statusCode === 200) {
const body = rsp.textBody(); // {text: "...", encoding: "utf-8"}
const json = JSON.parse(body.text);
}
// POST JSON
const rsp2 = await fetch("https://httpbin.org/post", {
method: "POST",
headers: [["Content-Type", "application/json"]],
textBody: JSON.stringify({a: 1}),
timeoutInterval: 10,
});
HTTPClient
Klassen HTTPClient sender HTTP-forespørsler fra hvilket som helst skript (implementert på toppen av fetch). Alle metoder er async og returnerer et svarobjekt med statusCode, headers og textBody().
| Metode | Beskrivelse |
|---|---|
HTTPClient.get(url, params?) | Send en GET-forespørsel. |
HTTPClient.post(url, params?) | Send en POST-forespørsel. |
HTTPClient.put(url, params?) | Send en PUT-forespørsel. |
HTTPClient.update(url, params?) | Send en UPDATE-forespørsel. |
HTTPClient.delete(url, params?) | Send en DELETE-forespørsel. |
HTTPClient.request(url, method, params?) | Send en forespørsel med egendefinert metode. |
params er et valgfritt objekt med:
headers: objekt med forespørselshoder, f.eks.{"key1": "value1"}body: forespørselsbody — en streng, et JSON-objekt (serialiseres automatisk) eller URLSearchParamstimeoutInterval: tidsavbrudd i sekunder (standard 60)
try {
var params = {
"headers": {"key1": "value1"},
"body": {"a": "a1", "b": "b1"},
};
const response = await HTTPClient.post("https://dummyjson.com/products/1", params);
console.log(response.textBody().text);
} catch(error) {
console.log(error);
}
Timere
setTimeout / setInterval / clearTimeout / clearInterval fungerer som i nettlesere. Callbacks dispatches på en seriell motorkø, så timere utløses pålitelig uavhengig av vertstråden.
| Funksjon | Returnerer |
|---|---|
setTimeout(callback, ms) | Timer-id (streng), utløses én gang. |
setInterval(callback, ms) | Timer-id, utløses gjentatte ganger. |
clearTimeout(id) / clearInterval(id) | Avbryt (idempotent, ukjente id-er ignoreres). |
await new Promise(resolve => setTimeout(resolve, 500)); // wait 0.5s
const timer = setInterval(() => console.log("tick"), 1000);
setTimeout(() => clearInterval(timer), 3500);
Globale funksjoner
| Navn | Signatur | Beskrivelse |
|---|---|---|
btoa(str) | (string) → string | Base64-koding — UTF-8-symmetrisk semantikk (strenger utenfor Latin1 tillates, i motsetning til nettlesere). |
atob(str) | (string) → string | Base64-dekoding; ugyldig inndata returnerer "". |
performance.now() | () → number | Millisekunder siden epoken (ikke sidenes lasting). |
sleep(ms) | (number) → Promise | Fullføres etter ms; bruk await sleep(1000). |
require(id) | (string) → any | Laster et skriptbibliotek med CommonJS-semantikk (module.exports); nøkkelen er @libs/<key>, løst som skriptbibliotek-identifikator → skriptbibliotek-navn (unikt) → innebygde biblioteker; kaster feil når det ikke finnes. |
TextEncoder | new TextEncoder().encode(str) | UTF-8-koding inn i en Uint8Array (encoding er alltid "utf-8"). |
crypto.getRandomValues(n) | (Array) → number[] | Fyller med n tilfeldige UInt32-verdier. |
crypto.randomUUID() | () → string | Tilfeldig UUID (store bokstaver, med bindestrek). |
btoa("Hello"); // "SGVsbG8="
atob("SGVsbG8="); // "Hello"
btoa("中文"); // works — UTF-8 bytes are encoded
performance.now(); // 1760000000000.123
await sleep(100);
const { encode } = require("@libs/base64"); // built-in lib
const { sign } = require("@libs/sign-lib"); // your script library
new TextEncoder().encode("hi"); // Uint8Array [104, 105]
Biblioteker administreres i skriptmodulbehandleren. Require-nøkkelen er alltid @libs/<key>: skriptbibliotekene dine løses etter identifikator først (stabil tross navneendringer), deretter etter navn (unikt treff), deretter de innebygde bibliotekene @libs/base64 / @libs/hex. Biblioteker eksporterer via module.exports, kan require andre biblioteker, og en manglende nøkkel kaster feil (feil før sending avbryter forespørselen, feil etter svar beholder det opprinnelige svaret). Se Quick Request scripting, Laste skriptbiblioteker med require() for den fullstendige veiledningen.
console
console.log / info / warn / error skriver ut verdier til skriptets loggvisning. Flere argumenter serialiseres, så du kan logge objekter og arrays direkte:
console.log("headers", {Accept: "application/json"}, [1, 2, 3]);
$log tilbyr strukturert, nivådelt utdata (se $log) — begge kanalene er synlige i Hodors skriptloggvisning.
HTTP-klasser
Request
Klassen Request er den pakkede HTTP-forespørselen som sendes til onRequest / onSessionCompleted.
| Medlem | Type | Beskrivelse |
|---|---|---|
scheme | string (get / set) | Forespørselens skjema, f.eks. https. |
host | string (get / set) | Forespørselens vert. |
port | number (get / set) | Forespørselens port. |
path | string (get / set) | Forespørselens sti. |
method | string (get / set) | HTTP-metoden, f.eks. GET. |
queries | URLSearchParams (get) | Forespørselens query-parametere. |
headers | Headers (get) | Forespørselens headere. |
body | Body (get) / string | Map | Array | URLSearchParams (set) | Forespørselens body. |
Headere må endres med .set() / .append() — indeks-tilordning (f.eks. headers["X-Key"] = v) ignoreres.
Du kan også konstruere en forespørsel selv:
const request = new Request({
scheme: 'https',
host: 'example.com',
port: 8080,
path: '/api',
method: 'GET',
queries: 'param1=value1¶m2=value2',
headers: [
['Content-Type', 'application/json'],
['Authorization', 'Bearer token']
],
textBody: '{"key": "value"}'
});
console.log(request.encode());
Response
Klassen Response representerer HTTP-svaret som sendes til onResponse / onSessionCompleted.
| Medlem | Type | Beskrivelse |
|---|---|---|
statusCode | number (get / set) | Svarstatuskoden. |
statusPhrase | string (get / set) | Svarstatusfrasen, f.eks. OK. |
headers | Headers (get) | Svarets headere. |
body | Body (get) / string | Map | Array | URLSearchParams (set) | Svarets body. |
const response = new Response({
statusCode: 404,
statusPhrase: 'Not Found',
headers: {
'Content-Type': 'application/json',
'Cache-Control': 'no-cache'
},
textBody: '{"error": "Resource not found"}'
});
console.log(response.encode());
Body
Klassen Body representerer bodyen til en HTTP-forespørsel eller et HTTP-svar. Å tildele en ny verdi til request.body / response.body erstatter hele bodyen.
| Metode | Returnerer | Beskrivelse |
|---|---|---|
parseText() | string | null | Parser bodyen som tekst. |
parseJSON() | object | null | Parser bodyen som JSON. |
parseURLSearchParams() | URLSearchParams | null | Parser bodyen som URL-kodede parametere. |
const bodyInstance = new Body('{"user": "alice"}');
const json = bodyInstance.parseJSON();
if (json) {
console.log('User:' + json.user);
} else {
console.error('Failed to parse JSON');
}
Headers
Klassen Headers representerer HTTP-headere.
| Metode | Returnerer | Beskrivelse |
|---|---|---|
append(name, value) | void | Legger til en verdi på den angitte headeren. |
set(name, value) | void | Angir (erstatter) verdien til den angitte headeren. |
get(name) | string | null | Henter verdien til den angitte headeren. |
has(name) | boolean | Sjekker om den angitte headeren finnes. |
delete(name) | void | Sletter den angitte headeren. |
forEach(callback, thisArg?) | void | Kaller en funksjon for hver header. |
entries() / keys() / values() | Iterator | Itererer over oppføringer / nøkler / verdier. |
encode() | Array | Koder headerne til et serialiserbart format. |
const headers = new Headers();
headers.append('Content-Type', 'application/json');
headers.set('Content-Length', '1024');
console.log(headers.get('Content-Type')); // 'application/json'
console.log(headers.has('Authorization')); // false
headers.forEach((value, name) => {
console.log(name + ' ' + value);
});
URLSearchParams
Klassen URLSearchParams representerer URL-query-parametere (eller urlencoded body).
| Metode | Returnerer | Beskrivelse |
|---|---|---|
append(name, value) | void | Legger til en verdi på den angitte parameteren. |
set(name, value) | void | Angir (erstatter) verdien til den angitte parameteren. |
get(name) | string | null | Henter verdien til den angitte parameteren. |
has(name) | boolean | Sjekker om den angitte parameteren finnes. |
delete(name) | void | Sletter den angitte parameteren. |
forEach(callback, thisArg?) | void | Kaller en funksjon for hver parameter. |
entries() / keys() / values() | Iterator | Itererer over oppføringer / nøkler / verdier. |
sort() | void | Sorterer parameterne. |
toString() | string | Serialiserer til en urlencoded-streng. |
const params = new URLSearchParams({ key1: 'value1', key2: 'value2' });
console.log(params.get('key1')); // 'value1'
console.log(params.get('key3')); // null
params.forEach((value, key) => console.log(key + ' ' + value));
SharedPreferences
Klassen SharedPreferences gir lokal vedvarende nøkkel-verdi-lagring som overlever skriptkjøringer og app-omstarter (støttet av systemets user defaults).
| Metode | Returnerer | Beskrivelse |
|---|---|---|
SharedPreferences.write(key, value) | void | Skriver en verdi (string / number / boolean / object / array). Å skrive null sletter nøkkelen. |
SharedPreferences.read(key) | any | Leser verdien knyttet til nøkkelen, eller null hvis den ikke finnes. |
SharedPreferences.write("test_key", "test_value");
const value = SharedPreferences.read("test_key");
console.log(value);
SharedPreferences.write("cfg", {a: 1}); // objects are stored directly
SharedPreferences.write("cfg", null); // deletes "cfg"
sdk — Quick Request-skript
sdk (alias pm) injiseres bare i Quick Requests pre/post-skript. Det bygger bro mellom appens variabellagring (miljøer, globale og kjøretidsvariabler) og samler assertions, med et Postman-lignende API-form.
| Medlem | Beskrivelse |
|---|---|
sdk.env.get(key) | Leser en miljøvariabel definert i appen. |
sdk.env.set(key, value) | Angir en miljøvariabel (samme som sdk.setEnvVar). |
sdk.setEnvVar(key, value) | Skriver en miljøvariabel — samles inn og gjøres vedvarende tilbake til appen. |
sdk.setVar(key, value) | Skriver en kjøretidsvariabel (lokal). |
sdk.setGlobalVar(key, value) | Skriver en global variabel. |
sdk.getVar(key) | Leser en kjøretidsvariabel. |
sdk.test(name, fn) | Kjører et navngitt assertion-blokk; feil samles inn og rapporteres i appen. |
sdk.expect(value) | Assertion-primitiver: toBe, toEqual, toBeTruthy. |
sdk.jsonPath(object, path) | Dot-path-oppslag, f.eks. "$.data.list[0].id". |
sdk.utils.uuid() | Samme som crypto.randomUUID(). |
sdk.utils.base64Encode(s) / base64Decode(s) | Samme som btoa / atob. |
sdk.utils.md5(s) | Samme som $hash.md5. |
// Quick Request pre-request script: sign the request
async function onRequest(context, url, request) {
// read variables defined in the app's environment
const secret = sdk.env.get("secret") || "test-key";
sdk.expect(secret).toBeTruthy();
const ts = String(Date.now());
const bodyText = request.body && request.body.text ? request.body.text : '';
const sig = $hmac.sha256(ts + bodyText, secret);
// headers must be set via .set / .append
request.headers.set("X-Signature", sig);
request.headers.set("X-Timestamp", ts);
// persist variables back to the app
sdk.setEnvVar("lastTs", ts);
sdk.test("signature is 64 hex", () => {
sdk.expect(sig.length).toBe(64);
});
console.log("signed request for", url);
return request;
}
Assertion-resultater rapporteres for skript før sending. I skript etter svar kjører assertionene, men resultatene samles ikke inn.
Kontekster
RewriteContext
Kontekstobjektet som sendes til rewrite-skript (onRequest / onResponse).
| Medlem | Type | Beskrivelse |
|---|---|---|
isEnableOnRequest | boolean (get) | Om onRequest-inngangen er aktivert. |
isEnableOnResponse | boolean (get) | Om onResponse-inngangen er aktivert. |
parameters | object (get / set) | En parameterordbok delt mellom onRequest og onResponse. |
scriptName | string (get) | Navnet på skriptet. |
CompletedContext
Kontekstobjektet som sendes til HTTP completed-skript.
| Medlem | Type | Beskrivelse |
|---|---|---|
session | object (get) | Øktobjektet knyttet til completed-skriptet. |
scriptName | string (get) | Navnet på completed-skriptet. |
ScheduleContext
Kontekstobjektet som sendes til schedule-skript.
| Medlem | Type | Beskrivelse |
|---|---|---|
parameters | object (get / set) | Parametere som sendes videre til neste runloop når de angis. |
cron | string (get) | Planens cron-uttrykk. |
repeatedCount | number (get) | Hvor mange ganger skriptet har blitt gjentatt. |
scriptName | string (get) | Navnet på det planlagte skriptet. |
Atferdsnotater
- Ufangede unntak feiler skriptet. Feil (inkludert
AbortErrorfraabort()) propagerer til Hodor, og kjøringen rapporteres som mislykket — delvise omskrivninger gjort før feilen forkastes, så beskytt risikable blokker medtry / catch. - Timeout-vokter. Hver skriptkjøring har et tidsbudsjett; et skript som aldri blir ferdig (f.eks. en endeløs løkke eller et hengende
await) avbrytes med tvang og rapporteres som timeout. - Feil som returverdier. Noen API-er kaster aldri:
$codec.base64Decodereturnerer"",$cryptoreturnerer"Error: ..."-strenger,$fs.readreturnerer"Error: ..."-strenger og$fs.inforeturnererundefined. Sjekk disse returverdiene i stedet for å stole påtry / catch. console.logvs$log. Begge er synlige i skriptloggvisningen;$loglegger til tidsstempler og nivåer.- Vedvarende skriptkjøretid. Variabler skrevet med
sdk.setVarog filer skrevet med$fsforblir tilgjengelige for påfølgende kjøringer av samme skript;SharedPreferencesoverlever app-omstarter.