Sådan filtreres værdipapirer fra bestemte børser for at oprette en brugerdefineret aktiescreener i Pine Script

Overvinde udfordringer med at bygge en brugerdefineret Pine Script Stock Screener

Har du nogensinde spekuleret på, om det er muligt at hente værdipapirer fra en bestemt børs i Pine Script, filtrere dem gennem brugerdefinerede betingelser og derefter vise dem på et diagram? Du er ikke alene! Mange udviklere og handlende har forsøgt at knække denne idé, kun for at møde begrænsninger i Pine Scripts indbyggede funktionalitet. 🤔

Mens Pine Script udmærker sig ved at anvende tekniske indikatorer og visualiseringer, er det ikke en indbygget funktion at skabe en aktiescreener til at arbejde dynamisk på specifikke børser. Men med den rigtige kodningslogik og kreativitet kan du omgå disse begrænsninger. Udfordringen ligger i at forstå, hvordan man kan hente og behandle sikkerhedsdata effektivt.

På min personlige rejse stod jeg over for lignende vejspærringer. For eksempel, da jeg forsøgte at oprette en screener for teknologiaktier fra en specifik børs, indså jeg hurtigt, at Pine Script mangler muligheden for direkte at forespørge alle værdipapirer fra en børs. Dette krævede out-of-the-box-tænkning og kombination af ekstern databehandling med Pine Script-funktioner. 💻

Denne artikel dykker ned i kerneudfordringerne ved at implementere denne brugerdefinerede funktionalitet, især omhandler det indledende trin med at hente værdipapirer. Sammen vil vi undersøge, om denne ambitiøse plan er gennemførlig, og afdække praktiske løsninger for at bringe din screener til live. 🚀

Opbygning af en brugerdefineret aktiescreener med Pine Script og eksterne værktøjer

De tidligere præsenterede scripts har til formål at løse problemet med at skabe en brugerdefineret aktiescreener i Fyrreskrift, der overvinder platformens iboende begrænsninger. Det første script fungerer udelukkende inden for Pine Script og udnytter arrays til manuelt at administrere en liste over ticker-symboler. Den bruger kommandoerne `array.new_string()` og `array.push()` til dynamisk at udfylde denne liste. Når tickerne er defineret, anvender scriptet `request.security()` til at hente data for hvert symbol, hvilket muliggør filtrering i realtid baseret på foruddefinerede forhold såsom volumentærskler. Ved at iterere over arrayet identificerer og fremhæver scriptet de tickere, der opfylder kriterierne direkte på diagrammet ved hjælp af `label.new()`. Denne fremgangsmåde er enkel, men manuel, og kræver ticker-input i selve scriptet. 🚀

Det andet script tager en mere avanceret rute ved at kombinere JavaScript til dataaggregering og Pine Script til visualisering. JavaScript bruges til at interagere med en ekstern API, der henter værdipapirdata dynamisk baseret på den specificerede udveksling. Kommandoen `axios.get()` henter data, og funktionen `response.data.filter()` anvender filtre såsom volumen. Dette giver mulighed for programmatisk kontrol i realtid over værdipapirudvælgelsesprocessen. De filtrerede tickers gemmes ved hjælp af `fs.writeFileSync()` til en fil, som Pine Script senere kan læse og bruge til visualisering. Denne metode strømliner processen, men kræver en to-trins arbejdsgang, der involverer eksterne værktøjer. 🤔

Den Python-baserede løsning tager en lignende hybrid tilgang, der udnytter Pythons robuste biblioteker til at hente og behandle data fra API'er. Scriptet definerer en funktion `fetch_securities()`, der bruger Pythons `requests`-bibliotek til at foretage API-kald og filtrerer værdipapirerne baseret på volumentærskler. Tickerne skrives derefter til en fil, ligesom i JavaScript-løsningen, men med Pythons ligetil syntaks. Disse data kan importeres til Pine Script til endelig visualisering. Pythons fleksibilitet og brugervenlighed gør det til et glimrende valg til backend-behandling i denne opsætning, især når man har at gøre med store datasæt eller komplekse filtre. 💡

I det væsentlige demonstrerer disse løsninger, hvordan man bygger bro mellem Pine Scripts kortlægningsstyrker og dets begrænsninger i datahentning. Uanset om du bruger rent Pine Script eller integrerer eksterne værktøjer som JavaScript eller Python, ligger nøglen i at udnytte optimerede metoder til datafiltrering og visualisering. Ved at bruge kommandoer såsom `request.security()` i Pine Script eller `axios.get()` i JavaScript, kan udviklere bygge kraftfulde og tilpassede screenere, der er skræddersyet til deres unikke behov. Kombinationen af ​​værktøjer udvider ikke kun Pine Scripts muligheder, men sikrer også en mere effektiv og skalerbar tilgang til værdipapiranalyse. 🚀

// Step 1: Define security list (manual input as Pine Script lacks database access)
var securities = array.new_string(0)
array.push(securities, "AAPL") // Example: Apple Inc.
array.push(securities, "GOOGL") // Example: Alphabet Inc.
array.push(securities, "MSFT") // Example: Microsoft Corp.

// Step 2: Input filter criteria
filter_criteria = input.float(100, title="Minimum Volume (in millions)")

// Step 3: Loop through securities and fetch data
f_get_filtered_securities() =>
    var filtered_securities = array.new_string(0)
    for i = 0 to array.size(securities) - 1
        ticker = array.get(securities, i)
        [close, volume] = request.security(ticker, "D", [close, volume])
        if volume > filter_criteria
            array.push(filtered_securities, ticker)
    filtered_securities

// Step 4: Plot filtered securities on the chart
var filtered_securities = f_get_filtered_securities()
for i = 0 to array.size(filtered_securities) - 1
    ticker = array.get(filtered_securities, i)
    label.new(bar_index, high, ticker, style=label.style_circle, color=color.green)

// JavaScript Code: Fetch and filter securities from an API
const axios = require('axios');
async function fetchSecurities(exchange) {
    const response = await axios.get(`https://api.example.com/securities?exchange=${exchange}`);
    const filtered = response.data.filter(security => security.volume > 1000000);
    return filtered.map(security => security.ticker);
}
// Save tickers to a file for Pine Script
const fs = require('fs');
fetchSecurities('NASDAQ').then(tickers => {
    fs.writeFileSync('filtered_tickers.txt', tickers.join(','));
});

// Pine Script Code: Import and visualize filtered securities
// Load tickers from an external source
filtered_tickers = str.split(input.string("AAPL,GOOGL,MSFT", "Filtered Tickers"), ",")

// Plot the tickers on the chart
for i = 0 to array.size(filtered_tickers) - 1
    ticker = array.get(filtered_tickers, i)
    label.new(bar_index, high, ticker, style=label.style_circle, color=color.green)

# Python Code: Fetch securities and write filtered data to a file
import requests
def fetch_securities(exchange):
    response = requests.get(f'https://api.example.com/securities?exchange={exchange}')
    data = response.json()
    return [sec['ticker'] for sec in data if sec['volume'] > 1000000]

tickers = fetch_securities('NASDAQ')
with open('filtered_tickers.txt', 'w') as file:
    file.write(','.join(tickers))

// Pine Script Code: Visualize pre-filtered data
filtered_tickers = str.split(input.string("AAPL,GOOGL,MSFT", "Filtered Tickers"), ",")
for i = 0 to array.size(filtered_tickers) - 1
    ticker = array.get(filtered_tickers, i)
    label.new(bar_index, high, ticker, style=label.style_circle, color=color.green)

Tilpasning af Pine Script screeners for forbedret funktionalitet

Et afgørende aspekt ved at bygge en aktiescreener ind Fyrreskrift forstår sine begrænsninger i at få adgang til data direkte fra udvekslinger. Mens Pine Script kan håndtere avancerede beregninger og diagramoverlejringer, understøtter det ikke indbygget at hente en komplet liste over værdipapirer fra en børs. For at løse dette kombinerer udviklere ofte Pine Script med eksterne datakilder. For eksempel kan brug af API'er som Alpha Vantage eller Quandl hjælpe med at hente data, som derefter kan behandles for forhold som volumentærskler, RSI-værdier eller glidende gennemsnits-crossovers. Denne tilgang giver handlende mulighed for at inkorporere datadrevet indsigt i deres strategier. 📊

En anden teknik er at bruge Pine Script's sikkerhed fungere kreativt. Mens det traditionelt bruges til at trække data på tværs af tidsrammer for et specifikt symbol, bruger nogle udviklere det til at trække metrics fra flere foruddefinerede tickers. Denne metode involverer opsætning af en række tickers, iteration gennem dem og dynamisk opdatering af diagrammet baseret på de opfyldte betingelser. Selvom den ikke er dynamisk for nye tickere, fungerer denne metode godt til foruddefinerede overvågningslister eller populære indekser. 💡

For at sikre, at din screener er effektiv, er det vigtigt at optimere betingelserne for filtrering. For eksempel kan tilføjelse af regler som "Vis kun tickers med en volumen større end 1M og en lukkekurs over 50-dages SMA" gøre en screener handlekraftig. Med sådanne regler hjælper visuelle hjælpemidler som farvede etiketter eller plotmarkører med at identificere potentielle kandidater hurtigt. Ved at kombinere Pine Scripts funktioner med ekstern datahåndtering, kan handlende lave meget tilpassede screenere, der er skræddersyet til deres unikke handelsstrategier. 🚀