使用Ajax上传多个文件和参数通常涉及到使用FormData对象。以下是一个简单的实例，展示了如何使用JavaScript和Ajax发送多个文件和参数到服务器端。

前端JavaScript代码：

// 假设有一个<form>元素，包含多个<input type="file">和其他输入字段
document.getElementById('my-form').addEventListener('submit', function(e) {
    e.preventDefault();
 
    var formData = new FormData();
 
    // 遍历所有文件输入，添加到FormData
    var fileInputs = document.querySelectorAll('input[type="file"]');
    for (var i = 0; i < fileInputs.length; i++) {
        if (fileInputs[i].files.length > 0) {
            formData.append('file' + i, fileInputs[i].files[0]);
        }
    }
 
    // 添加其他参数
    formData.append('param1', document.getElementById('param1').value);
    formData.append('param2', document.getElementById('param2').value);
 
    // 创建Ajax请求
    var xhr = new XMLHttpRequest();
    xhr.open('POST', '/upload', true);
 
    // 上传进度
    xhr.upload.onprogress = function(event) {
        if (event.lengthComputable) {
            var percentComplete = (event.loaded / event.total) * 100;
            console.log(percentComplete.toFixed(2) + '%');
        }
    };
 
    // 请求完成
    xhr.onload = function() {
        if (this.status == 200) {
            console.log('Upload succeeded');
        } else {
            console.log('Upload failed');
        }
    };
 
    // 发送请求
    xhr.send(formData);
});

后端Node.js/Express代码：

const express = require('express');
const multer = require('multer');
const app = express();
 
// 设置 multer 配置
const storage = multer.diskStorage({
    destination: function (req, file, cb) {
        cb(null, 'uploads/')
    },
    filename: function (req, file, cb) {
        cb(null, file.fieldname + '-' + Date.now())
    }
})
const upload = multer({ storage: storage });
 
// 处理上传的路由
app.post('/upload', upload.array('file', 10), function (req, res, next) {
    // req.files 是 'file' 字段的文件数组
    // req.body 包含文本字段，可以通过 req.body.param1 访问
    console.log(req.files);
    console.log(req.body);
    res.send('Success');
});
 
app.listen(3000, function () {
  console.log('App listening on port 3000!');
});

在这个例子中，前端JavaScript使用FormData收集文件和参数，然后通过Ajax发送到服务器。服务器端使用Express框架和multer中间件来处理上传的文件和参数。

uni-ajax 是一个基于 Promise 的轻量级 HTTP 请求库，主要用于微信小程序和 Uni-app 开发。以下是一个使用 uni-ajax 发送 GET 和 POST 请求的示例代码：

// 引入 uni-ajax 模块
import uniAjax from 'uni-ajax';
 
// 发送 GET 请求
uniAjax({
  url: 'https://your-api-endpoint.com/get', // 你的 API 接口
  method: 'GET',
  data: {
    param1: 'value1',
    param2: 'value2'
  }
}).then(response => {
  console.log('GET Response:', response.data);
}).catch(error => {
  console.error('GET Error:', error);
});
 
// 发送 POST 请求
uniAjax({
  url: 'https://your-api-endpoint.com/post', // 你的 API 接口
  method: 'POST',
  data: {
    field1: 'value1',
    field2: 'value2'
  }
}).then(response => {
  console.log('POST Response:', response.data);
}).catch(error => {
  console.error('POST Error:', error);
});

在这个示例中，我们首先导入了 uni-ajax 模块，然后使用它来发送 GET 和 POST 请求。我们通过 url 指定请求的目标地址，通过 method 指定请求的类型，并且可以通过 data 属性传递请求参数。请求结果会以 Promise 的形式返回，使用 .then() 处理成功的响应，使用 .catch() 处理可能发生的错误。

Ajax（Asynchronous JavaScript and XML）技术能够实现在Web页面和服务器之间进行异步数据交换，从而不会阻塞用户的其他操作。以下是一个简单的Ajax请求示例：

// 创建一个新的XMLHttpRequest对象
var xhr = new XMLHttpRequest();
 
// 配置请求类型、URL 以及是否异步处理
xhr.open('GET', 'your-api-endpoint', true);
 
// 设置请求完成的回调函数
xhr.onreadystatechange = function () {
  // 请求完成并且响应状态码为 200
  if (xhr.readyState === XMLHttpRequest.DONE) {
    if (xhr.status === 200) {
      // 处理请求成功的响应数据
      console.log(xhr.responseText);
    } else {
      // 处理请求失败
      console.error('AJAX Request was unsuccessful');
    }
  }
};
 
// 发送请求
xhr.send();

这段代码演示了如何使用原生JavaScript创建一个简单的GET请求。your-api-endpoint是你想要请求的服务器端API地址。当请求完成时，它会通过onreadystatechange回调函数处理响应。如果请求成功，它会在控制台打印响应文本；如果失败，则会输出错误信息。这是一个基本的Ajax使用示例，适用于理解和入门级别的Web开发任务。

// 使用jQuery发送Ajax GET请求
$.ajax({
    url: 'https://api.example.com/data', // 请求的URL
    method: 'GET', // 请求方法
    dataType: 'json', // 预期服务器返回的数据类型
    success: function(response) {
        // 请求成功时的回调函数
        console.log('Response:', response);
    },
    error: function(xhr, status, error) {
        // 请求失败时的回调函数
        console.error('An error occurred:', error);
    }
});
 
// 使用jQuery发送Ajax POST请求
$.ajax({
    url: 'https://api.example.com/data',
    method: 'POST',
    data: { key: 'value' }, // 发送到服务器的数据
    dataType: 'json',
    success: function(response) {
        console.log('Response:', response);
    },
    error: function(xhr, status, error) {
        console.error('An error occurred:', error);
    }
});

这段代码展示了如何使用jQuery的$.ajax方法发送GET和POST请求。在成功获取数据或发送数据后，它会在控制台中打印出响应。如果请求失败，它会打印出错误信息。这是一个基本的Ajax请求的例子，适用于学习和复习jQuery Ajax的基础。

Vue3 脚手架创建的项目通常不包含Ajax请求的实现，因为Vue3推荐使用更现代的HTTP客户端如Axios。以下是如何在Vue3项目中安装和使用Axios的步骤：

1. 安装Axios：

npm install axios

2. 在项目中设置Axios：

   创建一个src/utils/http.js文件，并添加以下内容：

import axios from 'axios';
 
const http = axios.create({
  baseURL: 'http://your-api-url/', // 替换为你的API基地址
  timeout: 10000, // 请求超时时间
});
 
export default http;

3. 使用Axios进行请求：

   在组件中引入Axios并使用：

<template>
  <div>
    <!-- 组件模板内容 -->
  </div>
</template>
 
<script>
import http from '@/utils/http';
 
export default {
  name: 'YourComponentName',
  data() {
    return {
      data: null,
      error: null,
    };
  },
  mounted() {
    this.fetchData();
  },
  methods: {
    async fetchData() {
      try {
        const response = await http.get('your-endpoint'); // 替换为你的API端点
        this.data = response.data;
      } catch (error) {
        this.error = error;
      }
    },
  },
};
</script>

以上代码展示了如何在Vue3项目中安装Axios，并在组件中使用它来发送GET请求。你可以根据需要修改http.js中的配置，以及在组件中使用Axios发送其他类型的HTTP请求。

在这个问题中，我们将使用Ajax技术创建一个简单的天气应用程序。我们将使用OpenWeatherMap API来获取天气数据。

首先，我们需要创建一个HTML文件，并在其中放置一个用于输入城市名称的输入框和一个用于显示天气信息的段落。

<!DOCTYPE html>
<html>
<body>
 
<h2>Enter the city name</h2>
 
<input id="city" type="text" value="London">
<button type="button" onclick="getWeather()">Get Weather</button>
 
<p id="weather-info"></p>
 
<script src="script.js"></script>
 
</body>
</html>

然后，我们需要创建一个JavaScript文件，并在其中编写用于发送Ajax请求并处理响应的函数。

function getWeather() {
    var city = document.getElementById('city').value;
    var apiKey = 'YOUR_API_KEY'; // 替换为你的OpenWeatherMap API密钥
    var url = 'http://api.openweathermap.org/data/2.5/weather?q=' + city + '&appid=' + apiKey;
 
    var xhr = new XMLHttpRequest();
    xhr.open('GET', url, true);
    xhr.onreadystatechange = function () {
        if (xhr.readyState == 4 && xhr.status == 200) {
            var data = JSON.parse(xhr.responseText);
            var weatherInfo = 'City: ' + data.name + '<br>' +
                              'Temperature: ' + data.main.temp + '°C<br>' +
                              'Pressure: ' + data.main.pressure + ' hPa<br>' +
                              'Humidity: ' + data.main.humidity + ' %<br>' +
                              'Wind speed: ' + data.wind.speed + ' m/s';
            document.getElementById('weather-info').innerHTML = weatherInfo;
        }
    };
    xhr.send();
}

在这段代码中，我们首先获取用户输入的城市名称，然后构造一个URL，用于从OpenWeatherMap API获取天气数据。我们创建了一个XMLHttpRequest对象，并设置了请求方法、URL以及处理响应函数。在处理函数中，我们解析了响应的JSON数据，并构造了一个包含天气信息的字符串，然后将这个字符串设置为段落元素的innerHTML，从而在网页上显示天气信息。

注意：你需要替换'YOUR\_API\_KEY'为你从OpenWeatherMap获取的实际API密钥。

这个简单的应用程序演示了如何使用Ajax从外部API获取数据，并在用户的网页上显示这些数据。这是学习Ajax的基本知识，并将其应用于实际场景的一个很好的例子。

在$.ajax中，success函数内的data参数是异步从服务器接收的响应数据。如果你想在$.ajax外部处理这些数据，你可以将数据存储在全局变量或者某个特定作用域内的变量中，或者使用Promise或者async/await来处理异步流程。

以下是使用全局变量的例子：

var globalData; // 全局变量
 
$.ajax({
    url: 'your-endpoint',
    type: 'GET',
    success: function(data) {
        globalData = data; // 将数据存储在全局变量中
        // 其他处理逻辑
    }
});
 
// 在其他地方使用全局变量
console.log(globalData);

使用Promise的例子：

function fetchData() {
    return new Promise((resolve, reject) => {
        $.ajax({
            url: 'your-endpoint',
            type: 'GET',
            success: function(data) {
                resolve(data); // 当数据成功获取时，调用resolve并传递数据
            },
            error: function(error) {
                reject(error); // 当获取数据出现错误时，调用reject并传递错误信息
            }
        });
    });
}
 
fetchData().then(data => {
    // 在这里处理你的数据
    console.log(data);
}).catch(error => {
    // 处理可能发生的错误
    console.error(error);
});

使用async/await的例子：

async function fetchAndProcessData() {
    try {
        const data = await $.ajax({
            url: 'your-endpoint',
            type: 'GET'
        });
        // 在这里处理你的数据
        console.log(data);
    } catch (error) {
        // 处理可能发生的错误
        console.error(error);
    }
}
 
fetchAndProcessData();

在实际应用中，推荐使用Promise或async/await，因为它们提供了更好的异步流程控制，而且能够更好地处理错误。

在JavaScript中，可以使用原生的XMLHttpRequest对象或者更现代的fetchAPI来发送AJAX请求。以下是使用fetchAPI的例子：

// 封装的AJAX请求函数
function fetchJSON(url, options) {
  return fetch(url, {
    ...options,
    headers: {
      'Content-Type': 'application/json',
      ...(options && options.headers)
    }
  })
  .then(response => {
    if (response.ok) {
      // 如果HTTP状态码在200-299范围内，直接返回response.json()的结果
      return response.json();
    }
    // 否则抛出错误
    return response.json().then(json => {
      throw new Error(json);
    });
  })
  .catch(error => {
    console.error('请求出错:', error);
    throw error;
  });
}
 
// 使用封装的AJAX请求函数
fetchJSON('/api/data', {
  method: 'POST',
  body: JSON.stringify({ key: 'value' })
})
.then(data => console.log('请求成功:', data))
.catch(error => console.error('请求出错:', error));

在实际应用中，可以根据需要对fetchJSON函数进行更多的封装和错误处理。例如，可以添加对请求超时的处理，或者对不同的HTTP状态码进行不同的处理等。

对于axios二次封装，可以参考下面的代码：

import axios from 'axios';
 
// 创建axios实例
const instance = axios.create({
  baseURL: 'http://your-api-url/',
  timeout: 1000, // 请求超时时间
  // 可以添加更多配置...
});
 
// 请求拦截器
instance.interceptors.request.use(config => {
  // 可以在这里添加例如token等请求头
  return config;
}, error => {
  // 请求错误处理
  return Promise.reject(error);
});
 
// 响应拦截器
instance.interceptors.response.use(response => {
  // 对响应数据做处理，例如只返回data部分
  return response.data;
}, error => {
  // 响应错误处理
  return Promise.reject(error);
});
 
// 封装的二次封装的AJAX请求函数
export function request(config) {
  // 使用axios实例发送请求
  return instance({
    ...config,
    method: config.method || 'get'
  });
}
 
// 使用二次封装的AJAX请求函数
request({
  url: '/endpoint',
  method: 'post',
  data: { key: 'value' }
})
.then(data => console.log('请求成功:', data))
.catch(error => console.error('请求出错:', error));

在这个例子中，我们使用axios创建了一个实例，并对请求和响应进行了拦截处理。然后我们创建了一个request函数，使用axios实例发送请求，并简化了响应数据。这样，我们可以在不同的地方复用这个封装过的request函数，提高代码的可维护性和复用性。

报错问题描述不够详细，但是基于您提供的信息，可以猜测可能的原因和解决方法如下：

可能原因：

1. 跨域问题：如果你的Ajax请求是从一个本地服务器发起到另一个不同域的服务器，可能会遇到浏览器的同源策略限制。
2. 服务器配置问题：如果BrowserSync的server配置不正确，可能导致资源无法正确加载。
3. Ajax请求的路径问题：如果请求的路径不正确，也会导致错误。

解决方法：

1. 跨域问题：

   • 确保你了解CORS（跨源资源共享），并确保目标服务器允许你的本地服务器进行跨域请求。
   • 如果你控制目标服务器，可以在服务器上设置相应的CORS头部允许你的本地域名访问。
   • 或者使用代理服务器，如BrowserSync的代理功能，将请求代理到目标服务器，从而绕过同源策略。

2. 服务器配置问题：

   • 检查BrowserSync的配置，确保没有配置错误，如路径错误、端口冲突等。
   • 确保服务器正确运行，并且所需的资源都可以通过配置的路径访问。

3. Ajax请求的路径问题：

   • 检查Ajax请求的URL，确保路径正确，包括协议、域名、端口和路径。
   • 如果使用了相对路径，请确保它是相对于当前页面的正确路径。

如果报错信息更详细，可以提供具体的错误代码或者描述，以便进一步精确解决问题。

以下是使用原生JavaScript实现Ajax的三种方法的简化示例代码：

1. 使用XMLHttpRequest：

// 创建 XMLHttpRequest 对象
const xhr = new XMLHttpRequest();
 
// 配置请求类型、URL 以及是否异步处理
xhr.open('GET', 'your-api-endpoint', true);
 
// 设置请求完成的回调函数
xhr.onreadystatechange = function () {
  // 请求完成并且响应状态码为 200
  if (xhr.readyState === XMLHttpRequest.DONE) {
    if (xhr.status === 200) {
      console.log(xhr.responseText); // 处理请求结果
    } else {
      console.error('There was a problem with the request.');
    }
  }
};
 
// 发送请求
xhr.send();

2. 使用fetch API：

// 发送 GET 请求
fetch('your-api-endpoint')
  .then(response => {
    if (response.ok) {
      return response.text();
    }
    throw new Error('Network response was not ok.');
  })
  .then(text => {
    console.log(text); // 处理请求结果
  })
  .catch(error => {
    console.error('There has been a problem with your fetch operation:', error);
  });

3. 使用axios库：

首先，需要在项目中安装axios：

npm install axios

然后，在代码中使用axios发送请求：

const axios = require('axios'); // 引入 axios
 
axios.get('your-api-endpoint')
  .then(response => {
    console.log(response.data); // 处理请求结果
  })
  .catch(error => {
    console.error('There was an error with your axios request:', error);
  });

这些示例展示了如何使用原生JavaScript或者通过引入库来实现Ajax请求。在实际应用中，你需要根据具体需求和项目配置选择合适的方法，并处理可能出现的错误和异常情况。