Promise模块化编程ES6新特性

文章目录

  • 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. 函数体：只有一行并且要返回的时候可以去掉{}

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

JVM垃圾回收与算法

JVM垃圾回收与算法

1. 如何确定垃圾 1.1 引用计数法 在 Java 中&#xff0c;引用和对象是有关联的。如果要操作对象则必须用引用进行。因此&#xff0c;很显然一个简单 的办法是通过引用计数来判断一个对象是否可以回收。简单说&#xff0c;即一个对象如果没有任何与之关 联的引用&#xff0c;即…
阅读更多...
推荐系统综述

推荐系统综述

推荐系统研究综述 - 中国知网 传统推荐方法主要分类&#xff1a; 1)基于内容推荐方法 主要依据用户与项目之间的特征信息,用户之间的联系不会影响推荐结果,所以不存在冷启动和稀疏问题,但是基于内容推荐的结果新颖程度低并且面临特征提取的问题。 基于内容的推荐方法的思想非…
阅读更多...
能源成果3D网络三维展厅越发主流化

能源成果3D网络三维展厅越发主流化

在这个数字化飞速发展的时代&#xff0c;我们为您带来了全新的展览形式——线上3D虚拟展厅。借助VR虚拟现实制作和web3d开发技术&#xff0c;我们能够将物品、图片、视频和图文信息等完美融合&#xff0c;通过计算机技术和3D建模&#xff0c;为您呈现一个逼真、生动的数字化展览…
阅读更多...
动态规划|1049.最后一块石头的重量II

动态规划|1049.最后一块石头的重量II

力扣题目链接 class Solution { public:int lastStoneWeightII(vector<int>& stones) {vector<int> dp(15001, 0);int sum 0;for (int i 0; i < stones.size(); i) sum stones[i];int target sum / 2;for (int i 0; i < stones.size(); i) { // 遍…
阅读更多...
开源项目one-api的k8s容器化部署（下）-- 部署至k8s

开源项目one-api的k8s容器化部署（下）-- 部署至k8s

一、接着上文 本文讲述如何把上文制作好的docker镜像部署到K8S&#xff0c;会涉及以下部分&#xff1a; 健康检测应用程序的配置应用程序的端口日志路径 二、健康检测 1、健康状态 从官方的docker-compose.yml可以得知其健康检测方法 curl http://localhost:5175/api/statu…
阅读更多...
03-JAVA设计模式-迭代器模式

03-JAVA设计模式-迭代器模式

迭代器模式 什么是迭代器模式 迭代器模式&#xff08;demo1.Iterator Pattern&#xff09;是Java中一种常用的设计模式&#xff0c;它提供了一种顺序访问一个聚合对象中各个元素&#xff0c;而又不需要暴露该对象的内部表示的方法。迭代器模式将遍历逻辑从聚合对象中分离出来…
阅读更多...
Latex学习（从入门到入土）2

Latex学习（从入门到入土）2

第一章 &#xff1a;插图 在LaTeX中插入插图可以通过graphicx宏包来实现&#xff0c;这个宏包提供了强大的图像处理功能。以下是如何使用graphicx宏包插入图像的基本步骤&#xff1a; ### 1. 加载宏包 在文档的序言部分&#xff08;\begin{document}之前&#xff09;&#x…
阅读更多...
《C语言深度解剖》:（5）C语言操作符一网打尽

《C语言深度解剖》:（5）C语言操作符一网打尽

&#x1f921;博客主页&#xff1a;醉竺 &#x1f970;本文专栏&#xff1a;《C语言深度解剖》 &#x1f63b;欢迎关注&#xff1a;感谢大家的点赞评论关注&#xff0c;祝您学有所成&#xff01; ✨✨&#x1f49c;&#x1f49b;想要学习更多数据结构与算法点击专栏链接查看&am…
阅读更多...
一些docker安装配置以及常见命令

一些docker安装配置以及常见命令

​常用命令 docker 命令 //进去容器内部&#xff0c;找到需要拷贝的文件及目录 docker exec -it 2c2600fb60f8 /bin/bash ​ //将container id为4db8edd86202的容器内elasticsearch.yml文件拷贝到宿主机指定目录下&#xff1a; docker cp 4db8edd86202:/usr/share/elasticsea…
阅读更多...
pytest系列——allure之在测试用例添加标题（@allure.title()）

pytest系列——allure之在测试用例添加标题（@allure.title()）

前言 通过使用装饰器allure.title可以为测试用例自定义一个更具有阅读性的易读的标题。 allure.title的三种使用方式&#xff1a; 直接使用allure.title为测试用例自定义标题&#xff1b;allure.title支持通过占位符的方式传递参数&#xff0c;可以实现测试用例标题参数化&a…
阅读更多...
温度对射频电路性能的影响

温度对射频电路性能的影响

对于射频电路，通常会有使用温度范围的要求，即在特定的温度范围内其性能变化不超出指标要求的值。对于工业级产品，一般要求使用温度范围为-40℃～+70℃，而军品要求使用温度范围为-55℃～+85℃。有一些其他特殊使用场景的产品会有不同的要求。 不同的温度对电路性能的影响，…
阅读更多...
nginx安装在linux上

nginx安装在linux上

nginx主要用于反向代理和负载均衡&#xff0c;现在简单的说说如何在linux操作系统上安装nginx 第一步&#xff1a;安装依赖 yum install -y gcc-c pcre pcre-devel zlib zlib-devel openssl openssl-devel 第二步&#xff1a; 下载nginx&#xff0c;访问官网&#xff0c;ngin…
阅读更多...
char和varchar的区别？

char和varchar的区别？

一、问题解析 char和varchar都是用于在数据库中存储字符串的数据类型。它们之间的主要区别在于存储空间的使用方式&#xff1a; char是一种定长的数据类型&#xff0c;它的长度固定且在存储时会自动在结尾添加空格来将字符串填满指定的长度。char的长度范围是0-255&#xff0c…
阅读更多...
机器学习理论入门---线性回归从理论到实践

机器学习理论入门---线性回归从理论到实践

线性回归是机器学习里面最简单也是最常用的算法&#xff0c;理解了线性回归的推导之后对于后续的学习有很大帮助&#xff0c;所以我决定从这里开始深入学习相关的机器学习模型。 本篇首先从矩阵求导开始切入&#xff0c;然后介绍一次线性回归的推导&#xff0c;再到代码实现。本…
阅读更多...
【八股】Redisson分布式锁

【八股】Redisson分布式锁

Redisson分布式锁 主要了解了Redisson分布式锁实现的三个功能&#xff1a; 1.可重入 -> 防止死锁 2.可重试&#xff08;i.e. 非阻塞获取锁&#xff09; 3.自动续约 1. 可重入 原理&#xff1a; 利用Redis的Hash结构&#xff0c;记录了使用当前锁的线程id和重用次数&#…
阅读更多...
零基础小白，如何入门计算机视觉？

零基础小白，如何入门计算机视觉？

目录 前言 计算机视觉技术学习路线 基础知识 1. 数学基础 2. 编程基础 3. 图像处理基础 基础算法与技术 1. 特征提取与描述符 2. 图像分割与对象检测 3. 三维重建与立体视觉 机器学习与深度学习 1. 机器学习基础 2. 深度学习 高级主题与应用 1. 高级机器学习与深度学习 2. 计算…
阅读更多...
Linux之 USB驱动框架-USB总线核心和主控驱动(4)

Linux之 USB驱动框架-USB总线核心和主控驱动(4)

一、USB设备描述符 一个USB设备描述符中可以有多个配置描述符&#xff0c;即USB设备可以有多种配置&#xff1b;一个配置描述符中可以有多个接口描述符&#xff0c;即USB设备可以支持多种功能&#xff08;接口&#xff09;&#xff1b;一个接口描述符中可以有多个端点描述符。 …
阅读更多...
【YOLOv8改进[Neck]】使用BiFPN助力V8更优秀

【YOLOv8改进[Neck]】使用BiFPN助力V8更优秀

目录 一 BiFPN(双向特征金字塔网络) 1 BiFPN 2 EfficientDet 二 使用BiFPN助力模型更优秀 1 整体修改 2 配置文件 3 训练 其他 一 BiFPN(双向特征金字塔网络) BiFPN(双向特征金字塔网络&#xff0c; 2020)用于特征融合层。 官方论文地址&#xff1a;https://arxiv.org…
阅读更多...
445. 两数相加 II

445. 两数相加 II

给你两个 非空 链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。 你可以假设除了数字 0 之外&#xff0c;这两个数字都不会以零开头。 示例1&#xff1a; 输入&#xff1a;l1 [7,2,4,3], l2 [5,6,4]…
阅读更多...
什么地推网推拉新副业平台最值得推荐？ 赚取互联网第一桶金

什么地推网推拉新副业平台最值得推荐？ 赚取互联网第一桶金

随着互联网的发展&#xff0c;新型行业层出不穷。其中地推网推拉新作为互联网行业具有收入高、门槛低、时间自由等优势&#xff0c;一部分人从中嗅到了商机&#xff0c;开始纷纷接触并加入了进来。但还是有一部分人对于地推网推拉新的了解很少&#xff0c;不知道如何才能加入其…
阅读更多...
最新文章

Copyright @ 2022~2023