JS运动缓冲效果的封装函数如何使用（js运动缓冲效果的封装函数如何使用视频）

25-02-07 17

本文将介绍JS运动缓冲效果的封装函数如何使用的详细情况，特别是关于js运动缓冲效果的封装函数如何使用视频的相关信息。我们将通过案例分析、数据研究等多种方式，帮助您更全面地了解这个主题，同时也将涉及一些

本文将介绍JS运动缓冲效果的封装函数如何使用的详细情况，特别是关于js运动缓冲效果的封装函数如何使用视频的相关信息。我们将通过案例分析、数据研究等多种方式，帮助您更全面地了解这个主题，同时也将涉及一些关于ajax 封装函数 jsonp使用方法、Axios的封装以及如何使用、CSS运动效果：为网页元素添加流动和运动效果、FreeRTOS 信号量的封装函数参数是二级指针的知识。

本文目录一览：

JS运动缓冲效果的封装函数如何使用（js运动缓冲效果的封装函数如何使用视频）
ajax 封装函数 jsonp使用方法
Axios的封装以及如何使用
CSS运动效果：为网页元素添加流动和运动效果
FreeRTOS 信号量的封装函数参数是二级指针

JS运动缓冲效果的封装函数如何使用（js运动缓冲效果的封装函数如何使用视频）

这次给大家带来JS运动缓冲效果的封装函数如何使用，使用JS运动缓冲效果的封装函数的注意事项有哪些，下面就是实战案例，一起来看一下。

之前经常写运动函数，要写好多好多，后来想办法封装起来。（运动缓冲）。

/*
  物体多属性同时运动的函数
  obj：运动的物体
  oTarget：对象，属性名为运动的样式名，属性值为样式运动的终点值
  ratio：速度的系数
*/
function bufferMove(obj, oTarget, fn,ratio = 8) {
  clearInterval(obj.iTimer);
  obj.iTimer = setInterval(function () {
    // 此处设定开关bBtn，假设所有的属性均已运动完毕true
    var bBtn = true;
    for(var sAttr in oTarget){
      // 获取当前值，此处兼容透明度的变化
      if(sAttr === 'opacity') {
        var iCur = parseFloat(getStyle(obj, sAttr) * 100);
      } else {
        var iCur = parseInt(getStyle(obj, sAttr));
      }
      // 计算速度，此处可判定方向，如向左或向右，先透明后出现或先出现后透明等
      var iSpeed = (oTarget[sAttr] - iCur) / ratio;
      iSpeed = iSpeed > 0 ? Math.ceil(iSpeed) : Math.floor(iSpeed);
      // 计算下一次的值
      var iNext = iCur + iSpeed;
      // 赋值给对应样式
      if(sAttr ==='opacity') {
        obj.style.opacity = iNext / 100;
        obj.style.filter = 'alpha(opacity=' + iNext +')';
      } else {
        obj.style[sAttr] = iNext + 'px';
      }
      // 清除定时器，当前的位置和终点值是否相等，相等则说明结束
      if(iNext !== oTarget[sAttr]) {
        bBtn = false;
      }
    }
    // 如果bBtn的值为true，则说明所有的属性均已运动完毕，回调函数fn()
    if(bBtn) {
      clearInterval(obj.iTimer);
      if(fn){
        fn();
      }
    }
  }, 50);
}

以上封装函数也可以用于单个属性，多样式运动，比如：

bufferMove(obj,{left:200,width:400,opacity:80},fn,8);

就这样。

相信看了本文案例你已经掌握了方法，更多精彩请关注小编网其它相关文章！

一、Axios是什么

Axios 就是对 ajax 的封装

之前如何发起数据请求
最原生的new XMLHttpRequest对象发起Ajax请求(open send onreadystatechange readyState responseText)
$.ajax{{配置对象}}
$.post(url地址，function(){})
$.get(url地址，处理函数)
当然还有后来出的 Fetch (这里就不多做解释,大家感兴趣可以专门去搜一下fetch的使用方法~)
现在用的 axios 来发起 ajax 请求
可以支持 get 和 post 等请求，但是无法发起 JSONP 请求
如果涉及到 JSONP 请求，可以让后端启用 cors 跨域资源共享即可
在 Vue 中，还可以使用 vue-resource 封装的 ajax 发起数据请求
在 vue-resource 支持 get，post，jsonp 请求

二、下载

参考网址：axios
cdn方式：<script src="https://unpkg.com/axios/dist/axios.min.js"></script>
npm方式：npm install axios

三、使用axios

3.1 发起get请求

语法：
请求地址：http://地址?xx=yy&xx=yy&xx=yy
返回结果result体现的是Promise对象，本身可以调用then或catch方法，或通过async或await进一步修饰

给服务器传递参数的时候需要借助params成员

const result = axios.get(地址,{params:{xx:yy,xx:yy,xx:yy....}})

async和await介入

async function getList(){
  var result = await axios.get(''http://127.0.0.1:3000/api/get'')
}

3.2 发起post请求

语法：
```
axios.post(地址,{xx:yy,xx:yy,xx:yy})
```

例子：

async function send_post() {
let result  = await axios.post(''http://127.0.0.1:3000/api/post'', {name: ''hello'', age: 18})
console.log(result)
}

3.3 例子

<div id="app">
 <button @click="send_post()">post请求</button>
 <button @click="send_get()">get请求</button>
</div>
<script>
 var vm = new Vue({
     el: ''#app'',
     data: {
         msg: ''aaa''
     },
     methods: {
         async send_get() {
             var {data: dt} = await axios.get(''http://127.0.0.1:3000/api/get'', {params:{name: ''hello'', age: 18}})
             console.log(dt)
         },
         async send_post() {
             var {data: dt} = await axios.post(''http://127.0.0.1:3000/api/post'', {name: ''hello'', age: 18})
             console.log(dt)
         }
     }
 })
</script>

四、Axios的配置

把axios配置给Vue并成为其一个子成员，每次需要通过Vue触发axios调用(axios自己不要贸然执行)

Vue.prototype.$http = axios// 在main.js中配置
this.$http.get()// 在组件中使用，$http是vue指向axios的成员名称，可以自定义为其他

给axios设置请求根地址，统一设置请求地址的前缀，做应用的时候就使用后缀，提升开发效率

axios.defaults.baseURL = ''根地址'' //语法

// 引入axios和配置
axios.defaults.baseURL = ''http://127.0.0.1:3000/api''
Vue.prototype.$http = axios

五、拦截器interceptors

5.1 为什么使用拦截器

axios在客户端与服务端之间传递数据时候是有时间消耗的
网络好、服务器比较空闲，axios的执行速度快
网络不好、服务器比较繁忙，axios的执行速度慢(这时用户需要多等待)
axios无论执行速度快还是慢，用户都需要等待，如果在axios执行过程中页面给予一定的提示，那么用户体验就比较好，这时候拦截器就可以应用上
5.2 axios本身有两种拦截器：请求拦截、响应拦截
请求拦截器
axios每次开始请求的时候先执行此处逻辑，在这个地方可以给axios做出发前的配置，也可以做出发前的检查工作，检查ok的情况下就开始向服务器端发请求

config代表axios请求的配置对象，后期可以借此给axios做相关配置

// axios的请求拦截器
axios.interceptors.request.use(function(config) {
// -------------------------------------------
// axios请求前的逻辑处理
nprogress.start()
var token = window.sessionStorage.getItem(''token'')
if (token !== null) {
  config.headers.Authorization = token
}
//---------------------------------------
return config
}, function(error) {
return Promise.reject(error)
})

响应拦截器
axios完成与服务端机交互回到客户端后就执行此处逻辑，在这个地方可以做一些后续收尾事宜

response代表服务器端给axios返回的信息，一般不做处理

// 添加响应拦截器
axios.interceptors.response.use(function(response) {
// 对响应数据做点什么
nprogress.done()

return response
}, function(error) {
// 对响应错误做点什么
return Promise.reject(error)
})

六、封装Axios

6.1 封装

在Vue项目中，可以在src根目录下新建一个axios.js(或axios.ts)
在React项目中，可以新建一个request文件夹，request文件夹中新建一个request.js(或request.ts)

import axios from ''axios''

// 如果是ts文件可以加上这个接口
// 配置项接口
/**interface AxiosOption {
  baseURL: string
  timeout: number
}*/


// 配置项
//const axiosOption: AxiosOption = { // ts的话使用这个限定类型
const axiosOption = {
  baseURL: ''http://127.0.0.1:9000/manage'',
  // baseURL: ''/api'',// 配置跨域后可以使用这个/api这个不固定，可以根据自己配置的跨域替换
  timeout: 5000,
}

// 创建一个单例
// 由于实际项目中可能会有多个接口地址
// create可以创建多个实例，在接口中要用几个地址就可以创建几个实例
const instance = axios.create(axiosOption)

// 添加请求拦截器
instance.interceptors.request.use(
  function (config) {
    // axios请求前的逻辑处理
    return config
  },
  function (error) {
    // 对请求错误做些什么
    return Promise.reject(error)
  }
)

// 添加响应拦截器
instance.interceptors.response.use(
  function (response) {
    // 对响应数据做点什么
    return response.data
  },
  function (error) {
    // 对响应错误做点什么
    return Promise.reject(error)
  }
)

export default instance

6.2 封装后使用

vue中，新建api.js接口模块

// 导入封装的axios
import axios from ''../axios''
export default {
  //---------------------------隐藏页面----------------------------------------------
  /**
* 添加
*/
  hideParameterAdd(data) {
 return axios.post(`/add`, data)
  },
}

//在要使用的.vue组件中import导入
<script>
import Api from ''../api/api''
export default {
  methods: {
 async getData () {
   let { data } = await Api.hideParameterAdd({id:1,name:''张三''})
   console.log(data)
 }
  }
}
</script>

在React中，新建api.js

// 导入封装的request.js
import request from ''./request''
// 注册接口
export const registerApi = (params) => request.post(''/register'', params)

// React组件中
import React, { useState } from ''react''
// 在要使用的页面导入api.js
import { loginApi } from ''./request/api''

export default function Login() {
  const onFinish = async (values) => {
 loginApi(values).then((res: IResRegister) => {
   console.log(res)
 })
  }

  return (
 <div className="login">
 111
 </div>
  )
}

总结

提示：这里对文章进行总结：

以上就是Axios的介绍以及封装，封装之后再Vue中和在React中如何使用，如果感觉写的实用可以辛苦大家点个赞啦，谢谢，文章会不定期更新哒。

CSS运动效果：为网页元素添加流动和运动效果

css运动效果：为网页元素添加流动和运动效果

CSS运动效果：为网页元素添加流动和运动效果，需要具体代码示例
CSS（Cascading Style Sheets）是一种用于描述网页元素样式的标记语言，通过使用CSS，我们可以美化网页、改变元素的外观和行为。其中，运动效果是一种非常有趣和常用的样式效果，可以为网页添加活力和吸引力。在本文中，我们将分享一些常见的CSS运动效果，并提供相应的代码示例。

平滑的滚动效果：
平滑的滚动效果可以为网页添加一种柔和和流畅的动画效果。可以通过以下代码来实现：

html {
  scroll-behavior: smooth;
}

登录后复制

在这个示例中，我们将 scroll-behavior 属性设置为 smooth，这样当用户点击一个带有锚链接的元素时，页面将平滑滚动到目标位置。

旋转动画：
旋转动画可以为元素添加一种动感和视觉吸引力。以下示例展示了如何实现一个旋转的方块：

@keyframes rotate {
  0% { transform: rotate(0deg); }
  100% { transform: rotate(360deg); }
}

.square {
  width: 100px;
  height: 100px;
  background-color: red;
  animation: rotate 2s linear infinite;
}

登录后复制

在这个示例中，我们创建了一个名为 rotate 的关键帧动画。通过 transform 属性，我们在 0% 和 100% 的关键帧中分别设置了元素的初始和最终旋转角度。然后，我们将这个动画应用于一个正方形元素，使用 animation 属性来指定动画名称、持续时间、动画速度和动画次数。

渐变背景色动画：
渐变背景色动画可以为元素的背景色添加流动和变化的效果。以下示例展示了如何实现一个渐变色背景的动画：

@keyframes gradient {
  0% { background-color: red; }
  50% { background-color: blue; }
  100% { background-color: red; }
}

.element {
  width: 200px;
  height: 200px;
  animation: gradient 3s linear infinite;
}

登录后复制

在这个示例中，我们创建了一个名为 gradient 的关键帧动画。通过在不同关键帧设置不同的背景色，我们实现了一个渐变色背景的动画效果。然后，我们将这个动画应用于一个元素，使用 animation 属性来指定动画名称、持续时间、动画速度和动画次数。

立即学习“前端免费学习笔记（深入）”；

缩放动画：
缩放动画可以为元素添加一种变大或变小的效果。以下示例展示了如何实现一个缩放的圆圈：

@keyframes scale {
  0% { transform: scale(1); }
  50% { transform: scale(1.5); }
  100% { transform: scale(1); }
}

.circle {
  width: 100px;
  height: 100px;
  border-radius: 50%;
  background-color: red;
  animation: scale 2s ease-in-out infinite;
}

登录后复制

在这个示例中，我们创建了一个名为 scale 的关键帧动画。通过在不同关键帧设置不同的缩放比例，我们实现了一个缩放的效果。然后，我们将这个动画应用于一个圆圈元素，使用 animation 属性来指定动画名称、持续时间、动画速度和动画次数。

总结：
运动效果可以为网页元素添加活力和吸引力，给用户带来更好的浏览体验。在本文中，我们分享了平滑的滚动效果、旋转动画、渐变背景色动画和缩放动画的示例代码。通过使用这些示例代码，你可以为网页添加流动和运动效果，制作出更加丰富和有趣的网页设计。不同的动画效果可以根据你的需求和创意来选择和实现。希望本文对你学习和实践CSS运动效果有所帮助！

以上就是CSS运动效果：为网页元素添加流动和运动效果的详细内容，更多请关注php中文网其它相关文章！

FreeRTOS 信号量的封装函数参数是二级指针

1. 先看正确的封装方式，问题所在，为什么要用 2 级指针

void  cissys_lockcreate(void** mutex)
{
    //创建信号量，应该是互斥锁
    *mutex =  ((SemaphoreHandle_t)xSemaphoreCreateMutex());
}

2. 错误的封装形式

void  cissys_lockcreate(void** mutex)
{
    //创建信号量，应该是互斥锁吧
    mutex =  &((SemaphoreHandle_t)xSemaphoreCreateMutex());
}

3. xSemaphoreCreateMutex 的函数原型

#define xSemaphoreCreateMutex() xQueueCreateMutex( queueQUEUE_TYPE_MUTEX )
QueueHandle_t xQueueCreateMutex( const uint8_t ucQueueType )
{
    Queue_t *pxNewQueue;
    const UBaseType_t uxMutexLength = ( UBaseType_t ) 1, uxMutexSize = ( UBaseType_t ) 0;
    pxNewQueue = ( Queue_t * ) xQueueGenericCreate( uxMutexLength, uxMutexSize, ucQueueType );
    prvInitialiseMutex( pxNewQueue );
    return pxNewQueue;
}

4. 句柄的定义

typedef void * QueueHandle_t;

5. （参考别人的写法）看一下其他的解释，错误的写法

程序1：
void  main()  
{  
     char  *p=NULL;  
     myMalloc(p);    //这里的p实际还是NULL,p的值没有改变，为什么？  
     if(p)  free(p);  
} 
void  myMalloc(char  *s)  //我想在函数中分配内存,再返回  
{  
     s=(char  *)  malloc(100);  
}

myMalloc (p) 的执行过程:
分配一个临时变量 char *s，s 的值等于 p，也就是 NULL，但是 s 占用的是与 p 不同的内存空间。此后函数的执行与 p 一点关系都没有了！只是用 p 的值来初始化 s。
然后 s=(char *) malloc (100)，把 s 的值赋成 malloc 的地址，对 p 的值没有任何影响。p 的值还是 NULL。
注意指针变量只是一个特殊的变量，实际上它存的是整数值，但是它是内存中的某个地址。通过它可以访问这个地址。

6. （参考别人的写法）对比正确的写法

程序2：
void  myMalloc(char  **s)  
{  
     *s=(char  *)  malloc(100);  
}  
void  main()  
{  
     char  *p=NULL;  
     myMalloc(&p);    //这里的p可以得到正确的值了  
     if(p)  free(p);  
}

程序 2 是正确的，为什么呢？看一个执行过程就知道了：
myMalloc (&p); 将 p 的地址传入函数，假设存储 p 变量的地址是 0x5555，则 0x5555 这个地址存的是指针变量 p 的值，也就是 Ox5555 指向 p。
调用的时候同样分配一个临时变量 char **s，此时 s 的值是 & p 的值也就是 0x5555，但是 s 所占的空间是另外的空间，只不过它所指向的值是一个地址：Ox5555。
*s=(char *) malloc (100); 这一句话的意思是将 s 所指向的值，也就是 0x5555 这个位置上的变量的值赋为 (char *) malloc (100)（并不是改变 p 的地址值 0x5555，而是指针变量 p 本身的值），而 0x5555 这个位置上存的是恰好是指针变量 p，这样 p 的值就变成了 (char *) malloc (100) 的值。即 p 的值是新分配的这块内存的起始地址。

7. 自己的总结

先假设一个二级指针，S--->P（0x3080）--->BUF1（0x1122），S 是二级指针，P 是一级指针，BUF1 是第一个空间，假设参数是一级指针，那么我们只能修改 BUF1 的内容，S--->P（0x3080）--->BUF1（0x3344），假设参数是二级指针，那么我们可以修改 P 的值，S--->P（0x4080）--->BUF2（0x7788），就是 P 指向的空间从 BUF1 改成指向了 BUF2。

今天关于JS运动缓冲效果的封装函数如何使用和js运动缓冲效果的封装函数如何使用视频的介绍到此结束，谢谢您的阅读，有关ajax 封装函数 jsonp使用方法、Axios的封装以及如何使用、CSS运动效果：为网页元素添加流动和运动效果、FreeRTOS 信号量的封装函数参数是二级指针等更多相关知识的信息可以在本站进行查询。

本文标签：