1
// JSONP 的基本工作原理
2
function jsonpRequest(url, callbackName) {
3
  // 1. 定义全局回调函数
4
  window[callbackName] = function(data) {
5
    console.log('收到数据:', data)
6
    // 处理数据后清理
7
    delete window[callbackName]
8
    document.body.removeChild(script)
9
  }
10

11
  // 2. 创建 script 标签
12
  const script = document.createElement('script')
13
  script.src = `${url}?callback=${callbackName}`
14
  document.body.appendChild(script)
15
}
16

17
// 使用示例
18
jsonpRequest('https://api.example.com/data', 'handleData')

1
fetch = async ({codes}) => {
2
      var rows = []
3
      for(var i=0;i<codes.length;i++){
4
        console.log(codes[i])
5
        // 等待请求的响应完成，再进行下一个请求。
6
        await fund.fetchData(codes[i]).then((res)=>{
7
          rows.push(res)
8
        }).catch((err)=>{
9
          console.log(err)
10
        })
11
      }

1
class BatchJsonp {
2
  constructor(options = {}) {
3
    this.prefix = options.prefix || '__jp'
4
    this.timeout = options.timeout || 60000
5
    this.param = options.param || 'callback'
6
    this.counter = 0
7
  }
8

9
  /**
10
   * 发起单个 JSONP 请求
11
   */
12
  request(url, options = {}) {
13
    return new Promise((resolve, reject) => {
14
      const id = options.name || `${this.prefix}_${this.counter++}_${Date.now()}`
15
      const timeout = options.timeout || this.timeout
16
      const param = options.param || this.param
17

18
      let timer = null
19
      let script = null
20

21
      const cleanup = () => {
22
        if (script && script.parentNode) {
23
          script.parentNode.removeChild(script)
24
        }
25
        window[id] = undefined
26
        try { delete window[id] } catch(e) {}
27
        if (timer) clearTimeout(timer)
28
      }
29

30
      // 超时处理
31
      timer = setTimeout(() => {
32
        cleanup()
33
        reject(new Error(`JSONP request timeout: ${url}`))
34
      }, timeout)
35

36
      // 注册全局回调
37
      window[id] = (data) => {
38
        cleanup()
39
        resolve(data)
40
      }
41

42
      // 构造 URL
43
      const separator = url.indexOf('?') === -1 ? '?' : '&'
44
      const fullUrl = `${url}${separator}${param}=${encodeURIComponent(id)}`
45

46
      // 创建 script 标签
47
      script = document.createElement('script')
48
      script.src = fullUrl
49
      script.onerror = () => {
50
        cleanup()
51
        reject(new Error(`JSONP request failed: ${url}`))
52
      }
53

54
      const target = document.getElementsByTagName('script')[0] || document.head
55
      target.parentNode.insertBefore(script, target)
56
    })
57
  }
58
}

1
class BatchJsonp {
2
  // ... 上面的代码
3

4
  /**
5
   * 批量并发请求，带速率控制
6
   * @param {Array<string>} urls - 请求 URL 列表
7
   * @param {Object} options - 配置选项
8
   * @param {number} options.concurrency - 最大并发数，默认 5
9
   * @param {number} options.delay - 每批请求之间的延迟（ms），默认 200
10
   * @returns {Promise<Array>} - 所有请求的结果
11
   */
12
  async batch(urls, options = {}) {
13
    const concurrency = options.concurrency || 5
14
    const delay = options.delay || 200
15
    const results = []
16
    const errors = []
17

18
    // 分批处理
19
    for (let i = 0; i < urls.length; i += concurrency) {
20
      const batch = urls.slice(i, i + concurrency)
21
      const promises = batch.map((url, index) =>
22
        this.request(url, options)
23
          .then(data => ({ index: i + index, data, success: true }))
24
          .catch(err => ({ index: i + index, error: err, success: false }))
25
      )
26

27
      const batchResults = await Promise.all(promises)
28
      results.push(...batchResults)
29

30
      // 批次间延迟，避免触发服务端限流
31
      if (i + concurrency < urls.length && delay > 0) {
32
        await this.sleep(delay)
33
      }
34
    }
35

36
    return results
37
  }
38

39
  sleep(ms) {
40
    return new Promise(resolve => setTimeout(resolve, ms))
41
  }
42
}

1
async function fetchWithFixedDelay(urls, delayMs = 200) {
2
  const results = []
3
  for (const url of urls) {
4
    try {
5
      const data = await jsonp(url)
6
      results.push({ url, data, success: true })
7
    } catch (err) {
8
      results.push({ url, error: err, success: false })
9
    }
10
    await sleep(delayMs)
11
  }
12
  return results
13
}

1
class TokenBucket {
2
  constructor(options = {}) {
3
    this.capacity = options.capacity || 10      // 桶容量
4
    this.refillRate = options.refillRate || 5    // 每秒补充的令牌数
5
    this.tokens = this.capacity
6
    this.lastRefill = Date.now()
7
  }
8

9
  async acquire() {
10
    this.refill()
11
    if (this.tokens > 0) {
12
      this.tokens--
13
      return
14
    }
15
    // 等待令牌补充
16
    const waitTime = 1000 / this.refillRate
17
    await new Promise(resolve => setTimeout(resolve, waitTime))
18
    return this.acquire()
19
  }
20

21
  refill() {
22
    const now = Date.now()
23
    const elapsed = (now - this.lastRefill) / 1000
24
    this.tokens = Math.min(
25
      this.capacity,
26
      this.tokens + elapsed * this.refillRate
27
    )
28
    this.lastRefill = now
29
  }
30
}

1
class AdaptiveRateLimiter {
2
  constructor(options = {}) {
3
    this.currentDelay = options.initialDelay || 100
4
    this.minDelay = options.minDelay || 50
5
    this.maxDelay = options.maxDelay || 5000
6
    this.successCount = 0
7
    this.failureCount = 0
8
  }
9

10
  async wait() {
11
    await new Promise(resolve => setTimeout(resolve, this.currentDelay))
12
  }
13

14
  onSuccess() {
15
    this.successCount++
16
    this.failureCount = 0
17
    // 连续成功 5 次后，逐步降低延迟
18
    if (this.successCount >= 5) {
19
      this.currentDelay = Math.max(
20
        this.minDelay,
21
        this.currentDelay * 0.8
22
      )
23
      this.successCount = 0
24
    }
25
  }
26

27
  onFailure() {
28
    this.failureCount++
29
    this.successCount = 0
30
    // 出现失败时，指数退避
31
    this.currentDelay = Math.min(
32
      this.maxDelay,
33
      this.currentDelay * 2
34
    )
35
  }
36
}

1
class RetryableJsonp {
2
  constructor(options = {}) {
3
    this.maxRetries = options.maxRetries || 3
4
    this.baseDelay = options.baseDelay || 1000
5
    this.batchJsonp = new BatchJsonp(options)
6
  }
7

8
  async requestWithRetry(url, options = {}) {
9
    let lastError = null
10
    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
11
      try {
12
        const data = await this.batchJsonp.request(url, options)
13
        return data
14
      } catch (err) {
15
        lastError = err
16
        if (attempt < this.maxRetries) {
17
          // 指数退避 + 随机抖动
18
          const delay = this.baseDelay * Math.pow(2, attempt)
19
            + Math.random() * 500
20
          console.warn(`请求失败，${delay.toFixed(0)}ms 后重试 (${attempt + 1}/${this.maxRetries}): ${url}`)
21
          await new Promise(r => setTimeout(r, delay))
22
        }
23
      }
24
    }
25
    throw lastError
26
  }
27
}

1
async function robustBatch(urls, options = {}) {
2
  const retryable = new RetryableJsonp(options)
3
  const results = []
4

5
  for (const url of urls) {
6
    try {
7
      const data = await retryable.requestWithRetry(url, options)
8
      results.push({ url, data, success: true })
9
    } catch (err) {
10
      results.push({
11
        url,
12
        error: err.message,
13
        success: false
14
      })
15
      // 记录失败但继续处理后续请求
16
      console.error(`请求最终失败: ${url}`, err.message)
17
    }
18
  }
19

20
  const successCount = results.filter(r => r.success).length
21
  console.log(`完成: ${successCount}/${results.length} 成功`)
22

23
  return results
24
}

1
async function fetchWithToken(baseUrl, dataUrl) {
2
  // 1. 先获取页面，提取 Token
3
  const pageResponse = await fetch(baseUrl)
4
  const pageHtml = await pageResponse.text()
5
  const tokenMatch = pageHtml.match(/token\s*=\s*['"]([^'"]+)['"]/)
6
  const token = tokenMatch ? tokenMatch[1] : ''
7

8
  // 2. 带 Token 发起 JSONP 请求
9
  const url = `${dataUrl}&token=${encodeURIComponent(token)}`
10
  return jsonp(url)
11
}

1
const http = require('http')
2
const https = require('https')
3

4
function jsonpNode(url, options = {}) {
5
  return new Promise((resolve, reject) => {
6
    const callbackName = options.callback || `cb_${Date.now()}`
7
    const separator = url.indexOf('?') === -1 ? '?' : '&'
8
    const fullUrl = `${url}${separator}callback=${callbackName}`
9
    const client = fullUrl.startsWith('https') ? https : http
10

11
    client.get(fullUrl, (res) => {
12
      let data = ''
13
      res.on('data', chunk => data += chunk)
14
      res.on('end', () => {
15
        try {
16
          // 解析 JSONP 响应：callbackName({...})
17
          const jsonMatch = data.match(/\((.+)\)$/)
18
          if (jsonMatch) {
19
            resolve(JSON.parse(jsonMatch[1]))
20
          } else {
21
            resolve(JSON.parse(data))
22
          }
23
        } catch (err) {
24
          reject(new Error(`Parse error: ${err.message}`))
25
        }
26
      })
27
    }).on('error', reject)
28
  })
29
}

1
const { JSDOM } = require('jsdom')
2
const dom = new JSDOM('<!DOCTYPE html><html><body></body></html>')
3
global.window = dom.window
4
global.document = dom.window.document
5

6
// 然后就可以使用浏览器端的 JSONP 库了