Gå til hovedinnhold

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:

KategoriNavn
InngangsfunksjoneronRequest, onResponse, onSessionCompleted, onSchedule, abort()
Native $-moduler$codec, $hash, $hmac, $crypto, $jwt, $format, $fs, $env, $uuid, $log
Web-standard-API-erfetch, HTTPClient, setTimeout / setInterval, btoa / atob / sleep / require / TextEncoder / crypto, console
HTTP-klasserRequest, Response, Body, Headers, URLSearchParams
LagringSharedPreferences, sdk-variabler
KonteksterRewriteContext, CompletedContext, ScheduleContext
tips

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).

ParameterTypeBeskrivelse
contextRewriteContextKontekstobjektet.
urlstringURL-en til HTTP-forespørselen.
requestRequestHTTP-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).

ParameterTypeBeskrivelse
contextRewriteContextKontekstobjektet.
urlstringURL-en til HTTP-svaret.
responseResponseHTTP-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.

ParameterTypeBeskrivelse
contextCompletedContextKontekstobjektet.
urlstringURL-en til HTTP-forespørselen.
requestRequestHTTP-forespørselsobjektet.
responseResponseHTTP-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.

ParameterTypeBeskrivelse
contextScheduleContextKontekstobjektet.
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;
}
warning

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.

MetodeReturnerer
$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.

MetodeUtdata-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.

MetodeAlgoritme
$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).

MetodeReturnerer
$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.

MetodeReturnerer
$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.

MetodeReturnerer
$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.

MetodeReturnerer
$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
merknad

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.

MetodeReturnerer
$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).

MetodeReturnerer
$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
merknad

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).

MetodeReturnerer
$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:

FeltTypeStandardBeskrivelse
methodstring"GET"Ikke sensitiv for store/små bokstaver; ukjente verdier faller tilbake til GET.
timeoutIntervalnumber30I sekunder.
headers[[k, v]] eller [{k: v}][]Begge formene godtas.
textBodystring—Forespørselens body-tekst.
encodingstring—"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().

MetodeBeskrivelse
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 URLSearchParams
  • timeoutInterval: 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.

FunksjonReturnerer
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​

NavnSignaturBeskrivelse
btoa(str)(string) → stringBase64-koding — UTF-8-symmetrisk semantikk (strenger utenfor Latin1 tillates, i motsetning til nettlesere).
atob(str)(string) → stringBase64-dekoding; ugyldig inndata returnerer "".
performance.now()() → numberMillisekunder siden epoken (ikke sidenes lasting).
sleep(ms)(number) → PromiseFullføres etter ms; bruk await sleep(1000).
require(id)(string) → anyLaster 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.
TextEncodernew 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()() → stringTilfeldig 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.

MedlemTypeBeskrivelse
schemestring (get / set)Forespørselens skjema, f.eks. https.
hoststring (get / set)Forespørselens vert.
portnumber (get / set)Forespørselens port.
pathstring (get / set)Forespørselens sti.
methodstring (get / set)HTTP-metoden, f.eks. GET.
queriesURLSearchParams (get)Forespørselens query-parametere.
headersHeaders (get)Forespørselens headere.
bodyBody (get) / string | Map | Array | URLSearchParams (set)Forespørselens body.
merknad

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&param2=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.

MedlemTypeBeskrivelse
statusCodenumber (get / set)Svarstatuskoden.
statusPhrasestring (get / set)Svarstatusfrasen, f.eks. OK.
headersHeaders (get)Svarets headere.
bodyBody (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.

MetodeReturnererBeskrivelse
parseText()string | nullParser bodyen som tekst.
parseJSON()object | nullParser bodyen som JSON.
parseURLSearchParams()URLSearchParams | nullParser 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.

MetodeReturnererBeskrivelse
append(name, value)voidLegger til en verdi på den angitte headeren.
set(name, value)voidAngir (erstatter) verdien til den angitte headeren.
get(name)string | nullHenter verdien til den angitte headeren.
has(name)booleanSjekker om den angitte headeren finnes.
delete(name)voidSletter den angitte headeren.
forEach(callback, thisArg?)voidKaller en funksjon for hver header.
entries() / keys() / values()IteratorItererer over oppføringer / nøkler / verdier.
encode()ArrayKoder 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).

MetodeReturnererBeskrivelse
append(name, value)voidLegger til en verdi på den angitte parameteren.
set(name, value)voidAngir (erstatter) verdien til den angitte parameteren.
get(name)string | nullHenter verdien til den angitte parameteren.
has(name)booleanSjekker om den angitte parameteren finnes.
delete(name)voidSletter den angitte parameteren.
forEach(callback, thisArg?)voidKaller en funksjon for hver parameter.
entries() / keys() / values()IteratorItererer over oppføringer / nøkler / verdier.
sort()voidSorterer parameterne.
toString()stringSerialiserer 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).

MetodeReturnererBeskrivelse
SharedPreferences.write(key, value)voidSkriver en verdi (string / number / boolean / object / array). Å skrive null sletter nøkkelen.
SharedPreferences.read(key)anyLeser 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.

MedlemBeskrivelse
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;
}
merknad

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).

MedlemTypeBeskrivelse
isEnableOnRequestboolean (get)Om onRequest-inngangen er aktivert.
isEnableOnResponseboolean (get)Om onResponse-inngangen er aktivert.
parametersobject (get / set)En parameterordbok delt mellom onRequest og onResponse.
scriptNamestring (get)Navnet på skriptet.

CompletedContext​

Kontekstobjektet som sendes til HTTP completed-skript.

MedlemTypeBeskrivelse
sessionobject (get)Øktobjektet knyttet til completed-skriptet.
scriptNamestring (get)Navnet på completed-skriptet.

ScheduleContext​

Kontekstobjektet som sendes til schedule-skript.

MedlemTypeBeskrivelse
parametersobject (get / set)Parametere som sendes videre til neste runloop når de angis.
cronstring (get)Planens cron-uttrykk.
repeatedCountnumber (get)Hvor mange ganger skriptet har blitt gjentatt.
scriptNamestring (get)Navnet på det planlagte skriptet.

Atferdsnotater​

  • Ufangede unntak feiler skriptet. Feil (inkludert AbortError fra abort()) propagerer til Hodor, og kjøringen rapporteres som mislykket — delvise omskrivninger gjort før feilen forkastes, så beskytt risikable blokker med try / 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.base64Decode returnerer "", $crypto returnerer "Error: ..."-strenger, $fs.read returnerer "Error: ..."-strenger og $fs.info returnerer undefined. Sjekk disse returverdiene i stedet for å stole på try / catch.
  • console.log vs $log. Begge er synlige i skriptloggvisningen; $log legger til tidsstempler og nivåer.
  • Vedvarende skriptkjøretid. Variabler skrevet med sdk.setVar og filer skrevet med $fs forblir tilgjengelige for påfølgende kjøringer av samme skript; SharedPreferences overlever app-omstarter.