Que fait l'axios de vue ?

Dans vue, axios est une bibliothèque HTTP basée sur des promesses, principalement utilisée pour implémenter des fonctions de communication asynchrone AJAX ; axios peut envoyer des requêtes XMLHttpRequests dans le navigateur, envoyer des requêtes http dans nodejs, et peut également intercepter des requêtes et des réponses, et convertir des requêtes et des requêtes. données de réponse.

L'environnement d'exploitation de ce tutoriel : système Windows 7, vue version 2.9.6, ordinateur DELL G3.

axios : Framework de communication front-end, car les limites de vue sont très claires, il s'agit de traiter le DOM, il n'a donc pas de fonctions de communication. Pour le moment, vous devez utiliser un framework de communication supplémentaire pour interagir avec le. serveur ; bien sûr, vous pouvez également utiliser la fonction de communication AJAX fournie par jQuery .

Axios est une bibliothèque HTTP basée sur des promesses, elle peut envoyer des requêtes get et post.

En parlant de get et de post, la première chose à laquelle tout le monde devrait penser est Jquery. Après tout, lorsque Jquery était très populaire il y a quelques années, tout le monde l'utilisait. Cependant, en raison de l’émergence de frameworks tels que Vue et React, Jquery n’est plus aussi populaire. C'est également l'émergence de frameworks tels que Vue et React qui ont conduit à l'émergence de la bibliothèque légère Axios. Parce que Vue et autres n'ont pas besoin de faire fonctionner le Dom, il n'est pas nécessaire d'introduire Jquery.js.

Fonctionnalités Axios

1. Vous pouvez envoyer des requêtes XMLHttp dans le navigateur

2 Vous pouvez envoyer des requêtes http dans node.js

3. Support Promise API

4. requêtes Données et données de réponse

6. Capable d'annuler les requêtes

7. Convertir automatiquement les données JSON

8 Le client prend en charge la protection contre les attaques XSRF

Dans quels scénarios Axios est-il utilisé ?

Comme mentionné dans les fonctionnalités, Axios peut être utilisé lorsque le navigateur envoie des requêtes ou que Node.js envoie des requêtes. Des projets tels que Vue, React, Node, etc. peuvent utiliser Axios. Si vous utilisez Jquery dans votre projet, il n'est pas nécessaire de faire quoi que ce soit de plus pour le moment, jquery lui-même peut envoyer des requêtes.

Comment utiliser Axios ? Installez le module

npm install axios

ou introduisez directement

<script src="https://unpkg.com/axios/dist/axios.min.js"></script>

Vous pouvez l'utiliser directement après avoir introduit le module

Exemple (1)

// GET
axios.get('/user', {
  params: {
    ID: 12345
  }
})
.then(function (response) {
  console.log(response);
})
.catch(function (error) {
  console.log(error);
});
// POST
axios.post('/user', {
  name: 'Javan',
  website: 'www.javanx.cn'
})
.then(function (response) {
  console.log(response);
})
.catch(function (error) {
  console.log(error);
});

Les paramètres ci-dessus sont facultatifs

Si vous souhaitez envoyer simultanément plusieurs requêtes, vous pouvez regarder le code ci-dessous

function getUserAccount() {
  return axios.get('/user/12345');
}
function getUserPermissions() {
  return axios.get('/user/12345/permissions');
}
axios.all([getUserAccount(), getUserPermissions()])
  .then(axios.spread(function (acct, perms) {
    // 两个请求都执行完成才会执行
  }));

Exemple (2)

En plus de la méthode ci-dessus, vous pouvez créer des requêtes en transmettant les configurations pertinentes à axios, telles que :

// POST
axios({
  method: 'post',
  url: '/user/12345',
  data: {
    firstName: 'Fred',
    lastName: 'Flintstone'
  }
});

Syntaxe

axios(url[, config])

config

{
  // `url` 是用于请求的服务器 URL
  url: '/user',
  // `method` 是创建请求时使用的方法
  method: 'get', // 默认是 get
  // `baseURL` 将自动加在 `url` 前面，除非 `url` 是一个绝对 URL。
  // 它可以通过设置一个 `baseURL` 便于为 axios 实例的方法传递相对 URL
  baseURL: 'https://some-domain.com/api/',
  // `transformRequest` 允许在向服务器发送前，修改请求数据
  // 只能用在 'PUT', 'POST' 和 'PATCH' 这几个请求方法
  // 后面数组中的函数必须返回一个字符串，或 ArrayBuffer，或 Stream
  transformRequest: [function (data) {
    // 对 data 进行任意转换处理
    return data;
  }],
  // `transformResponse` 在传递给 then/catch 前，允许修改响应数据
  transformResponse: [function (data) {
    // 对 data 进行任意转换处理
    return data;
  }],
  // `headers` 是即将被发送的自定义请求头
  headers: {'X-Requested-With': 'XMLHttpRequest'},
  // `params` 是即将与请求一起发送的 URL 参数
  // 必须是一个无格式对象(plain object)或 URLSearchParams 对象
  params: {
    ID: 12345
  },
  // `paramsSerializer` 是一个负责 `params` 序列化的函数
  // (e.g. https://www.npmjs.com/package/qs, http://api.jquery.com/jquery.param/)
  paramsSerializer: function(params) {
    return Qs.stringify(params, {arrayFormat: 'brackets'})
  },
  // `data` 是作为请求主体被发送的数据
  // 只适用于这些请求方法 'PUT', 'POST', 和 'PATCH'
  // 在没有设置 `transformRequest` 时，必须是以下类型之一：
  // - string, plain object, ArrayBuffer, ArrayBufferView, URLSearchParams
  // - 浏览器专属：FormData, File, Blob
  // - Node 专属： Stream
  data: {
    firstName: 'Fred'
  },
  // `timeout` 指定请求超时的毫秒数(0 表示无超时时间)
  // 如果请求话费了超过 `timeout` 的时间，请求将被中断
  timeout: 1000,
  // `withCredentials` 表示跨域请求时是否需要使用凭证
  withCredentials: false, // 默认的
  // `adapter` 允许自定义处理请求，以使测试更轻松
  // 返回一个 promise 并应用一个有效的响应 (查阅 [response docs](#response-api)).
  adapter: function (config) {
    /* ... */
  },
  // `auth` 表示应该使用 HTTP 基础验证，并提供凭据
  // 这将设置一个 `Authorization` 头，覆写掉现有的任意使用 `headers` 设置的自定义 `Authorization`头
  auth: {
    username: 'janedoe',
    password: 's00pers3cret'
  },
  // `responseType` 表示服务器响应的数据类型，可以是 'arraybuffer', 'blob', 'document', 'json', 'text', 'stream'
  responseType: 'json', // 默认的
  // `xsrfCookieName` 是用作 xsrf token 的值的cookie的名称
  xsrfCookieName: 'XSRF-TOKEN', // default
  // `xsrfHeaderName` 是承载 xsrf token 的值的 HTTP 头的名称
  xsrfHeaderName: 'X-XSRF-TOKEN', // 默认的
  // `onUploadProgress` 允许为上传处理进度事件
  onUploadProgress: function (progressEvent) {
    // 对原生进度事件的处理
  },
  // `onDownloadProgress` 允许为下载处理进度事件
  onDownloadProgress: function (progressEvent) {
    // 对原生进度事件的处理
  },
  // `maxContentLength` 定义允许的响应内容的最大尺寸
  maxContentLength: 2000,
  // `validateStatus` 定义对于给定的HTTP 响应状态码是 resolve 或 reject  promise 。如果 `validateStatus` 返回 `true` (或者设置为 `null` 或 `undefined`)，promise 将被 resolve; 否则，promise 将被 rejecte
  validateStatus: function (status) {
    return status >= 200 && status < 300; // 默认的
  },
  // `maxRedirects` 定义在 node.js 中 follow 的最大重定向数目
  // 如果设置为0，将不会 follow 任何重定向
  maxRedirects: 5, // 默认的
  // `httpAgent` 和 `httpsAgent` 分别在 node.js 中用于定义在执行 http 和 https 时使用的自定义代理。允许像这样配置选项：
  // `keepAlive` 默认没有启用
  httpAgent: new http.Agent({ keepAlive: true }),
  httpsAgent: new https.Agent({ keepAlive: true }),
  // &#39;proxy&#39; 定义代理服务器的主机名称和端口
  // `auth` 表示 HTTP 基础验证应当用于连接代理，并提供凭据
  // 这将会设置一个 `Proxy-Authorization` 头，覆写掉已有的通过使用 `header` 设置的自定义 `Proxy-Authorization` 头。
  proxy: {
    host: &#39;127.0.0.1&#39;,
    port: 9000,
    auth: : {
      username: &#39;mikeymike&#39;,
      password: &#39;rapunz3l&#39;
    }
  },
  // `cancelToken` 指定用于取消请求的 cancel token
  // （查看后面的 Cancellation 这节了解更多）
  cancelToken: new CancelToken(function (cancel) {
  })
}

Exemple (3)

Nous pouvons également créer une nouvelle instance axios en utilisant une configuration personnalisée et intercepter les demandes ou les réponses avant qu'elles ne soient traitées d'ici là ou interceptées.

// 如文件名叫http.js
import axios from 'axios'
// 创建实例时设置配置的默认值
var instance = axios.create({
  baseURL: 'https://some-domain.com/api/',
  timeout: 1000,
  headers: {'X-Custom-Header': 'foobar'}
});
// 添加请求拦截器
instance.interceptors.request.use(function (config) {
  // 在发送请求之前做些什么
  /**
    1、比如添加token之类的请求头信息
    2、添加每次请求loading等
  */
  return config;
}, function (error) {
  // 对请求错误做些什么
  return Promise.reject(error);
});
// 添加响应拦截器
instance.interceptors.response.use(function (response) {
  // 对响应数据做点什么
  /**
    1、集中处理响应数据（如错误码处理）
  */
  return response;
}, function (error) {
  // 对响应错误做点什么
  return Promise.reject(error);
});
export default instance

Comment utiliser le http.js ci-dessus???

import http from 'xxx/http'
http({
  method: 'POST',
  url: '/user',
  data: {
    name: 'Javan',
    website: 'www.javanx.cn'
  }
}).then((response) => {
  // 200响应
}, (err) => {
  // 500响应
})

Exemple (4)

Comment annuler l'interface ? ? ?

Scénario : Un champ de recherche, l'interface sera appelée à chaque fois qu'un caractère est saisi. Pour le moment, il n'y a aucun moyen de savoir quelles données d'interface ont été renvoyées pour la dernière fois. Le seul moyen est d'annuler la même interface initiée. avant, il y a donc une interface d'annulation.

var CancelToken = axios.CancelToken;
var source = CancelToken.source();
axios.get('/user/12345', {
  cancelToken: source.token
}).catch(function(thrown) {
  if (axios.isCancel(thrown)) {
    console.log('Request canceled', thrown.message);
  } else {
    // 处理错误
  }
});
// 取消请求（message 参数是可选的）
source.cancel('Operation canceled by the user.');

RésuméAxios peut être considéré comme ayant atteint le summum en matière de requête, et le packaging est très facile à utiliser. Le nombre actuel de téléchargements : 4 784 599 fois, étoile github : 60 584 fois. De quoi montrer que les développeurs l'aiment toujours beaucoup. Méthode de prise en charge du navigateur : à l'exception de la version inférieure d'IE, la dernière version du navigateur est prise en charge.

(Partage de vidéos d'apprentissage :

tutoriel vuejs

, web front-end)

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!