Promise模块化编程ES6新特性

news2024/11/30 14:50:12

文章目录

  • Promise&模块化编程
    • 1.Promise基本介绍
    • 2.快速入门
        • 1.需求分析
        • 2.原生ajax + jQuery
        • 3.Promise使用模板
    • 3.课后练习
        • 1.原生ajax + jQuery
        • 2.promise
    • 4.模块化编程基本介绍
    • 5.CommonJS基本介绍
    • 6.ES5模块化编程
        • 1.题目
        • 2.示意图
        • 3.代码实例—普通导入导出
          • function.js
          • use.js
        • 4.代码实例—对象解构导入导出
          • function.js
          • use.js
    • 7.ES6模块化编程
        • 1.基本介绍
        • 2.示意图
        • 3.批量导出
          • function.js
          • use.js
        • 4.定义时导出
          • function.js
          • use.js
        • 5.默认导出
          • function.js
          • use.js
        • 6.注意事项和细节
        • 7.课后练习
          • 1.练习一
          • 2.练习二
          • 3.练习三
            • 1.a.js
            • 2.b.js
            • 3.c.js
        • 8.ES6导入导出小结
          • 1.定义时和批量
          • 2.默认
  • ES6新特性
    • 1.基本介绍
    • 2.let生成变量
        • 1.新建项目
        • 2.基本介绍
        • 3.代码实例
    • 3.const常量（只读变量）
    • 4.解构赋值
        • 1.基本介绍
        • 2.数组解构赋值
        • 3.对象解构
    • 5.模板字符串+表达式
    • 6.对象新特性
        • 1.声明对象简写
        • 2.声明对象方法简写
        • 3.对象运算符扩展
    • 7.箭头函数
        • 1.基本介绍
        • 2.箭头函数实例1
        • 3.箭头函数与对象解构
    • 8.课后作业
        • 1.练习一
        • 2.练习二
        • 3.练习三
        • 4.练习四
        • 5.练习五
    • 9.ES6小结
        • 1.对象解构
        • 2.箭头函数简写

Promise&模块化编程

1.Promise基本介绍

image-20240213153714664

2.快速入门

1.需求分析

image-20240213154523642

2.原生ajax + jQuery

image-20240213160754050

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Title</title>
  <script type="text/javascript" src="script/jquery-3.6.0.min.js"></script>
  <script>
    $.ajax({
      url: "data/monster.json",
      success(resultData) {
        console.log("第一次请求得到的数据：", resultData);
        //如果成功获取数据则进行第二次请求
        $.ajax({
          url: `data/monster_detail_${resultData.id}.json`,
          success(resultData) {
            console.log("第二次请求得到的数据", resultData);
          },
          error(err) {
            console.log(err)
          }
        })
      },
      error(err) {
        console.log(err)
      }
    })
  </script>
</head>
<body>

</body>
</html>

image-20240213160811611

3.Promise使用模板
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Title</title>
  <script type="text/javascript" src="script/jquery-3.6.0.min.js"></script>
  <script>

    //url,data是要发送请求的参数，以后如果要添加可以修改
    function get(url, data) {
      return new Promise((resolve, reject) => {
        $.ajax({
          //url,data是要发送请求的参数，以后如果要添加可以修改
          url: url,
          data: data,
          success(resultData) {
            resolve(resultData);
          },
          error(err) {
            reject(err);
          }
        })
      })
    }

    //1.返回一个Promise对象然后调用then方法
    get("data/monster.json").then((resultData) => {
      //第一次ajax请求成功后的处理代码
      console.log("第一次请求返回的数据=", resultData);
      //2.再返回一个Promise对象
      return get(`data/monster_detail_${resultData.id}.json`);
      //3.get这个整体是返回了一个Promise对象，然后调用then方法
    }).then((resultData) => {
      //第二次ajax请求成功后的处理代码
      console.log("第二次请求返回的数据=", resultData);
      return get(`data/monster_sex_${resultData.sex}.json`);
    }).then((resultData) => {
      //第三次ajax请求成功后的处理代码
      console.log("第三次请求返回的数据=", resultData);
    }).catch(err => { //最后一次就直接处理异常
      console.log("promise请求异常=", err)
    })

  </script>
</head>
<body>

</body>
</html>

3.课后练习

image-20240214093016581

image-20240214093035476

image-20240214093046358

image-20240214093053222

1.原生ajax + jQuery
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Title</title>
  <script type="text/javascript" src="script/jquery-3.6.0.min.js"></script>
  <script>
    $.ajax({
      url: "data/student_100.json",
      success(resultData) {
        //第一次请求成功
        console.log(resultData)
        $.ajax({
          url: `data/class_${resultData.class_id}.json`,
          success(resultData) {
            //第二次请求成功
            console.log(resultData)
            $.ajax({
              url: `data/school_${resultData.school_id}.json`,
              success(resultData) {
                console.log(resultData)
              },
              error(err) {
                console.log(err)
              }

            })
          },
          error(err) {
            console.log(err)
          }
        })
      },
      error(err) {
        console.log(err);
      }
    })
  </script>
</head>
<body>

</body>
</html>

image-20240214094443994

2.promise
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Title</title>
  <script type="text/javascript" src="script/jquery-3.6.0.min.js"></script>
  <script>
    //url,data是要发送请求的参数，以后如果要添加可以修改
    function get(url, data) {
      return new Promise((resolve, reject) => {
        $.ajax({
          //url,data是要发送请求的参数，以后如果要添加可以修改
          url: url,
          data: data,
          success(resultData) {
            resolve(resultData);
          },
          error(err) {
            reject(err);
          }
        })
      })
    }

    get("data/student_100.json").then(resultData => {
      console.log(resultData);
      return get(`data/class_${resultData.class_id}.json`);
    }).then(resultData => {
      console.log(resultData);
      return get(`data/school_${resultData.school_id}.json`);
    }).then(resultData => {
      console.log(resultData);
    })
  </script>
</head>
<body>

</body>
</html>

image-20240214095248624

4.模块化编程基本介绍

image-20240214095947531

image-20240214100057660

5.CommonJS基本介绍

image-20240214100442200

6.ES5模块化编程

1.题目

image-20240214100625215

2.示意图

image-20240214101050513

3.代码实例—普通导入导出
function.js
//定义对象，变量，常量，函数
let age = 19;
const PI = 3.14;
const sum = function (a, b) {
  return parseInt(a) + parseInt(b);
}
let obj = {
  name: "孙显圣",
  age: 24
}
//导出对象
module.exports = {
  myage: age,
  PI: PI,
  sum: sum,
  obj: obj
}
use.js
//导入
const m = require("./function")
//使用
console.log(m.PI)
console.log(m.obj)
console.log(m.myage)
console.log(m.sum(1,2))
4.代码实例—对象解构导入导出
function.js
//定义对象，变量，常量，函数
let age = 19;
const PI = 3.14;
const sum = function (a, b) {
  return parseInt(a) + parseInt(b);
}
let obj = {
  name: "孙显圣",
  age: 24
}
//导出对象，简写形式
exports = {
  //这里简写的话，就是名字和变量名相同
  age,
  PI,
  sum,
  obj
}
use.js
//对象解构导入
const {PI, sum} = require("./function")
//使用
console.log(PI)
console.log(sum(1,2))

7.ES6模块化编程

1.基本介绍

image-20240214103650522

2.示意图

image-20240214103951263

3.批量导出
function.js
//定义对象，变量，常量，函数
let age = 19;
const PI = 3.14;
const sum = function (a, b) {
  return parseInt(a) + parseInt(b);
}
let obj = {
  name: "孙显圣",
  age: 24
}
//导出对象，简写形式
export {
  //这里简写的话，就是名字和变量名相同
  age,
  PI,
  sum
}
use.js
//ES6对象解构导入
//注意：这里的名字必须与导出的名字相同（因为是对象解构）
import {
  age,
  PI,
  sum
} from "./function"
//使用
console.log(age, PI, sum(1,2))
4.定义时导出
function.js
//定义对象，变量，常量，函数
//将两个变量在定义时导出
export let age = 19;
export const PI = 3.14;

const sum = function (a, b) {
  return parseInt(a) + parseInt(b);
}
let obj = {
  name: "孙显圣",
  age: 24
}
use.js
//ES6对象解构导入
//注意：这里的名字必须与导出的名字相同（因为是对象解构）
import {
  age,
  PI,
} from "./function"
//使用
console.log(age, PI)
5.默认导出
function.js
//定义对象，变量，常量，函数
//默认导出
export default {
  age: 19,
  PI: 3.14,
  sum(a, b) {
    return a + b;
  },
  obj: {
    name: "孙显圣"
  }
}
use.js
//默认导入
import m from "./function";
console.log(m.obj.name);
console.log(m.sum(1,2));
console.log(m.age);
6.注意事项和细节

image-20240214110816863

7.课后练习
1.练习一

image-20240214110907387

//定义对象，变量，常量，函数
let cat = {
  name: "小白",
  age: 12,
  cry() {
    console.log("猫在叫")
  }
}

//定义时导出
export let dog = {
  name: "小黑",
  age: 13,
  cry() {
    console.log("狗在叫")
  }
}

// //批量导出
// export {
//   cat,
//   dog
// }

//默认导出
export default {
  cat1 : {
    name: "小白",
    age: 12,
    cry() {
      console.log("猫在叫")
    }
  }
}
2.练习二

image-20240214140617711

// //批量导入
// import {
//   dog,
//   cat
// } from "./function";

console.log(dog.name)
console.log(cat.name)

//定义时导入
import {dog} from "./function";

console.log(dog.age)

//默认导入
import m from "./function"
console.log(m.cat1.age)
3.练习三

image-20240214140641414

1.a.js
export let dog = {
  hi() {
    console.log("hi")
  }
}
2.b.js
let dog = {
  say() {
    console.log("say")
  }
}
export {
  dog
}
3.c.js
//使用a的dog
import {dog} from "./a"
dog.hi()
//使用b的dog
import {dog} from "./b"
dog.say()
8.ES6导入导出小结
1.定义时和批量
  1. 都使用export导出
  2. 使用import 对象解构 from “文件位置”导入
2.默认
  1. 使用export default导出，导出的直接是一整个js对象
  2. 使用import 变量 from “文件位置”导入

ES6新特性

1.基本介绍

image-20240213105945370

2.let生成变量

1.新建项目

image-20240213110241112

2.基本介绍

image-20240213123736776

3.代码实例
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Title</title>
  <script>
    {
      //let细节一，let声明的变量，如果在代码块中，则作用域在代码块中
      var name = "121";
      let age = 12;
    }
    //console.log里面如果是逗号，如果是对象则会输出对象的值！
    console.log("name=", name);
    console.log("age=", age); //这里会报错！

    //let细节二：var可以声明多次，let只能声明一次
    var num = 2;
    var num = 4;
    let num1 = 3;
    let num1 = 4; //这里会报错，不允许重复定义

    //let细节三：let不存在变量提升，var存在变量提升，所谓变量提升，就是认不认可在变量使用之后定义
    console.log(a); //var在后面定义的这里就是undefined类型了，就是认可变量已经定义了，只是没有值
    var a = "3";

    console.log(b); //这里直接会爆语法错误
    let b = "4";

  </script>
</head>
<body>

</body>
</html>

3.const常量（只读变量）

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Title</title>
  <script>
    //1.常量必须赋值
    //2.常量的值不能修改
    const PI = 3.14
    console.log("PI=", PI)
  </script>
</head>
<body>

</body>
</html>

image-20240213124335902

4.解构赋值

1.基本介绍

image-20240213124459793

2.数组解构赋值
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Title</title>
  <script>
    let arr = [1, 2, 3];
    //传统
    let x = arr[0];
    let y = arr[1];
    let z = arr[2];
    console.log(x, y, z);
    //ES6方式1
    let [a, b, c] = arr;
    console.log(a, b, c)
    //ES6方式2
    let [a1, b1, c1] = [100, 200, 300];
    console.log(a1, b1, c1)
  </script>
</head>
<body>

</body>
</html>

image-20240213130306590

3.对象解构
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Title</title>
  <script>
    let obj = {name: "牛魔王", age: 12};
    //普通解构
    console.log("name", obj.name, "age", obj.age);
    //ES6对象解构
    //1.只要保证名字跟对象里面的相同即可，顺序无所谓
    //2.需要使用{}
    let {age, name} = obj;
    console.log("name", name, "age", age);
    //这样也可以let {age, name} = {name: "牛魔王", age: 12}

    //方法的参数使用对象解构
    function f({age, name}) {
      console.log("fage=", age, "fname=", name);
    }
    f(obj)
  </script>
</head>
<body>

</body>
</html>

image-20240213131539109

5.模板字符串+表达式

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Title</title>
  <script>
    //1.模板字符串就是使用反引号引起来，这样字符串，换行就会原生输出
    let str = `hello
    world`
    console.log(str)
    //2.在模板字符串中是可以使用$()表达式的，类似于EL表达式，可以读取变量，调用函数
    //读取变量
    let name = "孙显圣";
    console.log(`你好 ${name}`)
    //变量计算
    let num1 = 2;
    let num2 = 3;
    console.log(`num1 + num2 = ${num1 + num2}`)
    //函数调用
    function f(name) {
      return name;
    }
    console.log(`name= ${f(name)}` )
  </script>
</head>
<body>

</body>
</html>

image-20240213133329621

6.对象新特性

1.声明对象简写
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Title</title>
  <script>
    const name = "孙显圣";
    const age = 24;
    //传统声明对象方式
    let obj = {name: name, age: age};
    console.log("obj:" , obj);
    //ES6声明对象方式
    let obj1 = {name, age}; //这样声明就相当于name属性的值是name变量，age属性的值是age变量
    console.log("obj1=", obj1)

  </script>
</head>
<body>

</body>
</html>

image-20240213134143016

2.声明对象方法简写
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Title</title>
  <script>
    //普通对象方法声明
    let obj = {
      name: "孙显圣",
      sayHi: function () {
        console.log("hi1")
      }
    }
    obj.sayHi();

    //ES6方法声明简写
    let obj1 = {
      sayHi() {
        console.log("hi2")
      }
    }
    obj1.sayHi()
  </script>
</head>
<body>

</body>
</html>

image-20240213135032679

3.对象运算符扩展
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Title</title>
  <script>
    let name = "大花猫";
    let age = 23
    //声明两个对象，name的值都是大花猫
    let obj1 = {name};
    let obj2 = {name, age};

    //传统的赋值
    let obj3 = obj1;
    obj3.name = "小花猫"; //obj3跟obj1共享一个对象空间，所以会影响到obj1
    console.log(obj1.name); //小花猫

    //拷贝对象，深拷贝，两个引用指向的是不同的对象空间，不会互相影响
    let obj4 = {...obj2};
    obj4.name = "中花猫";
    console.log("obj4", obj4)
    console.log("obj2", obj2)

    //合并对象，也是深拷贝，如果是重复的，则后面的覆盖前面的值
    let obj5 = {...obj1, ...obj2}
    console.log(obj5)
  </script>
</head>
<body>

</body>
</html>

image-20240213140836306

7.箭头函数

1.基本介绍

image-20240213141117466

2.箭头函数实例1
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Title</title>
  <script>
    //传统函数
    let fun1 = function (num) {
      return num;
    }
    console.log(fun1(100));


    //箭头函数
    let fun2 = (x, y) => {
      return x + y;
    }
    console.log(fun2(1, 3));

    //一个参数并且一条语句，需要返回的时候，可以简写
    let fun3 = x => x + 4; //这个箭头函数会返回x + 4

    //箭头函数也可以传递给函数
    //定义一个接受参数为函数的一个函数
    let fun = (fun1) => {
      console.log(fun1(100))
    }
    //调用上面的函数，传进去一个函数，一个参数x，返回x * 5
    fun(x => x * 5);


    //传统函数，求n到m的和
    var f1 = function (n, m) {
      var res = 0;
      for (var i = n; i <= m; i++) {
        res += i;
      }
      return res;
    }
    console.log(f1(1, 3))

    //箭头函数
    let f2 = (n, m) => {
      let res = 0;
      for (let i = n; i <= m; i++) {
        res += i;
      }
      return res;
    }
    console.log(f2(1,3))
  </script>
</head>
<body>

</body>
</html>

image-20240213143743852

3.箭头函数与对象解构
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Title</title>
  <script>
    let obj = {
      name: "孙显圣",
      age: 19
    }
    //箭头函数加对象解构
    let fun = ({name, age}) => {
      console.log(`name:${name} age:${age}`)
    }
    fun(obj)
  </script>
</head>
<body>

</body>
</html>

image-20240213150211040

8.课后作业

1.练习一

image-20240213150339999

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Title</title>
  <script>
    let cat = {
      name: "jack",
      age: 10
    }
    console.log(`name: ${cat.name} age: ${cat.age}`);
  </script>
</head>
<body>

</body>
</html>

image-20240213150615157

2.练习二

image-20240213150640938

namex是undefined，原因是没有与对象中的属性名字相对应

3.练习三

image-20240213150759161

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Title</title>
  <script>
    let name = "周星驰";
    let job = "演员";

    let obj = {
      name,
      job,
      fun() {
        console.log(`name: ${this.name} job: ${this.job}`)
      }
    };
    obj.fun()
  </script>
</head>
<body>

</body>
</html>
4.练习四

image-20240213151514098

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Title</title>
  <script>
    let cal = {
      oper: "/",
      arr: [1, 2, 3, 5]
    }
    let fun = ({oper, arr}) => {
      let res = 0;
      //遍历数组
      for (let i = 0; i < arr.length; i++) {
        switch (oper) {
          case "+":
            res += arr[i];
          case "-":
            res -= arr[i];
          case "*":
            res *= arr[i];
          case "/":
            res /= arr[i];
        }
      }
      console.log(res)
    }
    fun(cal)
  </script>
</head>
<body>

</body>
</html>

image-20240213152444103

5.练习五

image-20240213152548917

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Title</title>
  <script>
    let f8 = (arr, fun) => {
      console.log("结果：", fun(arr))
    }
    let f = arr => {
      let res = 0;
      for (let i = 0; i < arr.length; i++) {
        res += arr[i];
      }
      return res;
    }
    f8([1,2,3,4,5], f)

  </script>
</head>
<body>

</body>
</html>

image-20240213153138461

9.ES6小结

1.对象解构
2.箭头函数简写
  1. 参数：只有一个时可以去掉（）
  2. 函数体：只有一行并且要返回的时候可以去掉{}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1602807.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

一文搞懂Kotlin符号处理接口KSP

一文搞懂Kotlin符号处理接口KSP

公众号「稀有猿诉」 原文链接 一文搞懂Kotlin符号处理接口KSP Kotlin符号处理&#xff08;Kotlin Symbol Processing&#xff09;即KSP是可以用于开发轻量级编译器插件的一套API。是Kotlin原生的&#xff0c;Kotlin语法友好的编译器插件。使用简单且易于上手&#xff0c…
阅读更多...
同城货运系统的开发与货运搬家软件的技术性探讨和市场分析

同城货运系统的开发与货运搬家软件的技术性探讨和市场分析

一、市场前景展望 随着城市化进程的加快和电商物流的蓬勃发展&#xff0c;同城货运市场展现出了巨大的潜力。尤其是在快节奏的生活环境中&#xff0c;个人和企业对于快速、便捷、可靠的货运搬家服务需求日益增长。同城货运系统与货运搬家软件作为连接货主与货运司机的桥梁&…
阅读更多...
2024还想走c++后端的同学，该如何准备才有机会成功上岸拿到offer

2024还想走c++后端的同学，该如何准备才有机会成功上岸拿到offer

c后端&#xff0c;一个被网上说没有市场的c方向。但是对于想从事c后端的同学该如何准备呢&#xff1f; 就目前的市场需求来说&#xff0c;c后端的需求市真不大&#xff0c;中小厂基本没有&#xff0c;大部分集中在大厂。 那么&#xff0c;如果大家想求职c后端&#xff0c;第一…
阅读更多...
野生动物保护视频AI智能监管方案，撑起智能保护伞，守护野生动物

野生动物保护视频AI智能监管方案，撑起智能保护伞，守护野生动物

一、背景 在当今世界&#xff0c;野生动物保护已经成为全球性的重要议题。然而&#xff0c;由于野生动物生存环境的不断恶化以及非法狩猎等活动的盛行&#xff0c;保护野生动物变得尤为迫切。为了更有效地保护野生动物&#xff0c;利用视频智能监管技术成为一种可行的方案。 …
阅读更多...
docker方式 部署jenkins服务，实现持续集成（CI/CD）功能

docker方式 部署jenkins服务，实现持续集成（CI/CD）功能

一、背景&#xff1a; 因公司需求&#xff0c;需要部署一套jenkins自动化部署服务&#xff0c;并且是通过docker容器的方式部署的。 二、jenkins简介&#xff1a; 什么是Jenkins &#xff1f; Jenkins是一个开源软件&#xff0c;是基于Java开发的一种持续集成工具&#xff0c;用…
阅读更多...
VS集成vcpkg

VS集成vcpkg

VS集成vcpkg 下载vcpkg 下载vcpkg git clone https://github.com/Microsoft/vcpkg.git安装vcpgk&#xff0c;文件目录 .\bootstrap-vcpkg.bat集成到vs2022中 # 集成到项目 vcpkg integrate project vcpkg integrate installPS C:\Users\Administrator> vcpkg integrate…
阅读更多...
Python入门教程完整版（懂中文就能学会）

Python入门教程完整版（懂中文就能学会）

网友虐我千百遍&#xff0c;我待网友如初恋&#xff0c;因为今天又给大家带来了干货&#xff0c;Python入门教程完整版&#xff0c;完整版啊&#xff01;完整版&#xff01; 为了吸取教训&#xff0c;小编一定要分享一下攻略&#xff0c;“怎样获得小编分享的教程呢&#xff1…
阅读更多...
多线程同步：使用 std::mutex 和 std::unique_lock 保护共享资源

多线程同步：使用 std::mutex 和 std::unique_lock 保护共享资源

在当今的软件开发中&#xff0c;多线程编程是一项至关重要的技术&#xff0c;它允许程序同时执行多个任务&#xff0c;从而提高应用程序的效率和响应速度。然而&#xff0c;多线程环境也带来了数据安全和一致性的挑战。在多个线程需要访问和修改同一数据资源的情况下&#xff0…
阅读更多...
【SAP NWDI】创建DC（Development component）（三）

【SAP NWDI】创建DC（Development component）（三）

一、准备DC组件包 首先需要下载下面这7个sca 的组件包，找到对应的ME版本的组件包，可以找对应的Basis帮忙下载。然后把这7个组件包放入到服务器中根目录的这个目录中，如果目录没有的需要自己创建出来。 二、导入DC组件包 注意：下面的的图中 有需要填写 in 和 out 的连个目…
阅读更多...
RabbitMQ-核心特性

RabbitMQ-核心特性

已经不需要为RabbitMQ交换机的离去而感到伤心了&#xff0c;接下来登场的是RabbitMQ-核心特性!!! 文章目录 核心特性消息过期机制消息确认机制死信队列 核心特性 消息过期机制 官方文档&#xff1a;https://www.rabbitmq.com/ttl.html 可以给每条消息指定一个有效期&#xf…
阅读更多...
富文本在线编辑器 - tinymce

富文本在线编辑器 - tinymce

tinymce 项目是一个比较好的富文本编辑器. 这里有个小demo, 下载下来尝试一下, 需要配置个本地服务器才能够访问, 我这里使用的nginx, 下面是我的整个操作过程: git clone gitgitee.com:chick1993/layui-tinymce.git cd layui-tinymcewget http://nginx.org/download/nginx-1.…
阅读更多...
监控系统泛滥：CTO 面临的隐形成本危机

监控系统泛滥：CTO 面临的隐形成本危机

在信息技术飞速发展的今天&#xff0c;构建和维护现代化的数字系统变得日益复杂和关键&#xff1b;在这样的背景下&#xff0c;监控系统的作用变得尤为突出。正如业界广泛流传的一句经验之谈“无监控&#xff0c;不运维”所揭示的道理一样&#xff0c;对于任何具有一定复杂性的…
阅读更多...
Redis（Windows版本下载安装和使用）

Redis（Windows版本下载安装和使用）

天行健&#xff0c;君子以自强不息&#xff1b;地势坤&#xff0c;君子以厚德载物。 每个人都有惰性&#xff0c;但不断学习是好好生活的根本&#xff0c;共勉&#xff01; 文章均为学习整理笔记&#xff0c;分享记录为主&#xff0c;如有错误请指正&#xff0c;共同学习进步。…
阅读更多...
lua 光速入门

lua 光速入门

文章目录 安装注释字符串变量逻辑运算条件判断循环函数Table (表)常用全局函数模块化 首先明确 lua 和 js Python一样是动态解释性语言&#xff0c;需要解释器执行。并且不同于 Python 的强类型与 js 的弱类型&#xff0c;它有点居中&#xff0c;倾向于强类型。 安装 下载解释…
阅读更多...
AI预测福彩3D第38弹【2024年4月17日预测--第8套算法开始计算第6次测试】

AI预测福彩3D第38弹【2024年4月17日预测--第8套算法开始计算第6次测试】

今天咱们继续测试第8套算法和模型&#xff0c;今天是第5次测试&#xff0c;目前的测试只是为了记录和验证&#xff0c;为后续的模型修改和参数调整做铺垫&#xff0c;所以暂时不建议大家盲目跟买~废话不多说了&#xff0c;直接上结果&#xff01; 2024年4月17日3D的七码预测结果…
阅读更多...
vivado 与 VIO 核输出探针进行交互

vivado 与 VIO 核输出探针进行交互

与 VIO 核输出探针进行交互 VIO 核输出探针用于将值写入实际硬件中的 FPGA 或 ACAP 中运行的设计。 VIO 输出探针通常用作为待测设计的低带 宽控制信号。 VIO 调试探针需手动添加到 VIO 仪表板的“ VIO 探针 (VIO Probes) ”窗口中。请参阅“在‘调试探针 (Debug Pr…
阅读更多...
中国12.5米DEM地形瓦片数据免费领取！

中国12.5米DEM地形瓦片数据免费领取！

之前向大家公开了中国34个省12.5米DEM地形瓦片数据的免费领取链接&#xff0c;大家对12.5米DEM数据的使用需求很强烈&#xff0c;领取也很积极&#xff0c;也有不少读者反馈能否提供全国范围的12.5米DEM地形瓦片数据&#xff0c;因为分省级地形瓦片数据想要合并成全国数据&…
阅读更多...
CUDA 以及MPI并行矩阵乘连接服务器运算vscode配置

CUDA 以及MPI并行矩阵乘连接服务器运算vscode配置

一、CUDA Vscode配置 &#xff08;一&#xff09;扩展安装 本地安装 服务器端安装 &#xff08;二&#xff09; CUDA 配置 .vscode c_cpp_properties.json {"configurations": [{"name": "Linux","includePath": ["${workspa…
阅读更多...
【AI】DeepStream(01)介绍

【AI】DeepStream(01)介绍

1、简介 DeepStream 本质是 GStreamer 的插件，基于GStreamer的管道，实现高效的视频流分析。 DeepStream 将来自 USB/CSI 摄像头的流数据、来自文件的视频或通过 RTSP 的流作为输入，并使用人工智能和计算机视觉从像素中生成AI结果。 DeepStream SDK 可以成为许多视频分析解…
阅读更多...
C++ queue priority_queuestack 详解及模拟实现

C++ queue priority_queuestack 详解及模拟实现

1. stack的介绍和使用 1.1 stack的介绍 1. stack是一种容器适配器&#xff0c;专门用在具有后进先出操作的上下文环境中&#xff0c;其删除只能从容器的一端进行元素的插入与提取操作。 2. stack是作为容器适配器被实现的&#xff0c;容器适配器即是对特定类封装作为其底层的容…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023