09-初始setup-axios-promise

监听属性

需要使用ref和ractive包一下才可以正常监听。

// 使用相关属性需要导入
import { reactive, ref, watch } from "vue";

// 监听单个
let name = ref("阿珂")
watch(name, (newValue, oldValue) =>{
    console.log("老名字", oldValue);
    console.log("新名字", newValue);
})

// 监听对象
const data = reactive({ name: "小满", age: 3 });
watch(() => data.name, (newValue, oldValue) => {
    console.log("老名字", oldValue);
    console.log("新名字", newValue);
})

// 监听多个，列表里面放多个对象即可
watch([data, score], (newValue, oldValue) => {
    console.log(data);
    console.log(score.value);
});

watchEffect 监听单个 vue3新增

在Vue 3中，watchEffect 函数允许您观察响应式数据的变化，并在数据发生变化时执行副作用。但是，与 watch 函数不同，watchEffect 不直接提供所观察的响应式数据的新旧值。

watchEffect(()=>{
    // 不用指定监听谁，只要watchEffect内部用了某个变量，某个变量发送变化，就会触发。
    console.log("姓名变化了", data.name);
})

生命周期

配置项API生命周期

vue2中生命周期	vue3的配置项API生命周期
beforeDestroy	beforeUmount
destroy	unmounted

// vue2
export default {
  beforeCreate() {},
  created() {},
  beforeMounte() {},
  mounted() {},
  beforeUpdate() {},
  updated() {},
  beforeDestroy(){},
  destroy() {}
}

// Vue3
export default defineComponent({
  beforeCreate() {},
  created() {},
  beforeMount() {},
  mounted() {},
  beforeUpdate() {},
  updated() {},
  beforeUmount(){}, // 变了
  unmounted() {} // 变了
})

组件式API生命周期

值得注意的是，setup 里没有 beforeCreate 和 created 这两个生命周期，因为 setup 本身就是在这两个生命周期之间执行的，所以不需要显式的定义他们。

vue2生命周期	vue3组件式API生命周期
beforeCreate
created
beforeMount	onBeforeMount
mounted	onMounted
beforeUpdate	onBeforeUpdate
updated	onUpdated
beforeDestroy	onBeforeUnmount
destroy	onUnmounted

<script setup>
    import axios from "axios" 
    async function getData(){
        const res = await axios.get("https://jsonplaceholder.typicode.com/comments")
        console.log(res.data);
    }
    getData()
</script>

ref toRef和toRefs

ref

通过ref把属性值设置成响应式，通过reactive把对象设置成响应式。

如果要修改ref的属性值，需要通过.value去操作。

<template>
    <p>number: {{number}} --- num: {{data.num}}</p>
</template>

<script>
import { reactive, ref } from "vue";

export default {
  setup() {
    let number = ref(3) // 情况1 使用ref设置成响应式
    const data = reactive({num: 5}) // 情况2 使用reactive设置成响应式
    
    setInterval(() => {
        number.value++
        data.num++
    }, 1000);

    return {
        number,
        data
    }
  },
};
</script>

可以用来获取DOM，需要注意的是template中ref对应的名称需要一致。

<template>
  <div ref="elDom">div-box</div>
</template>

<script>
import { ref } from "vue";
    
export default {
  setup() {
    const elDom = ref(null);

    onMounted(() => {
      console.log(elDom.value.innerHTML); // div-box
    });

    return {
        elDom
    }
  },
};
</script>

toRef

• 针对一个响应式对象的prop，需要使用reactive包裹一个对象
• 创建一个ref，具有响应式
• 两者保持引用关系

<template>
  {{data.name}} --- {{nameRef}}
</template>

<script>
import { reactive, toRef } from "vue";

export default {
  setup() {
    const data = reactive({name: "小满"})
    const nameRef = toRef(data, "name") // 这样使用

    setTimeout(() => {
        data.name = '大乔'
    }, 1000);

    setTimeout(() => {
        nameRef.value = "阿珂"
    }, 2000);

    return {
        nameRef,
        data
    }
  },
};
</script>

上面的代码中，使用toRef将data的name属性变成一个响应式变量，然后在1秒后将data的name值变为大乔，此时nameRef也会变成大乔；在2秒后将nameRef的值变为阿珂，此时data的name值也会变成阿珂，说明了两者保持相互引用关系。

toRef针对的是响应式，针对的不是普通对象，如果用于非响应式，产出的结果不具有响应式。

toRefs

• 将一个响应式对象转为普通对象，即只能接收reactive的对象。
• 对象的每一个属性都是对应的ref
• 两者保持引用关系

<template>
  <p>姓名：{{ name }}</p>
  <p>年龄：{{ age }}</p>
</template>

<script>
import { reactive, toRefs } from "vue";

export default {
  setup() {
    const data = reactive({ name: "小满", age: 3});
    const DataRefs = toRefs(data);

    setTimeout(()=>{
        data.name = '阿珂'
    }, 1000)

    setTimeout(() => {
        DataRefs.age.value = 4
    }, 2000);

    return {
        ...DataRefs
    }
  },
};
</script>

上面的代码中，使用toRefs将data转变成一个普通对象，这时候就可以直接返回stateRefs，这时候在template就可以直接调用name和age。然后在1秒后将data的name值变为阿珂，此时页面中的name也会变成阿珂；在2秒后将DataRefs中的age的值变为4，此时页面中的age值也会变成4，说明了两者保持相互引用关系。

如何选择

reactive做对象的响应式，ref做值类型响应式

setup中返回toRefs(data), 或者toRef(state, 'xxx')---(这样就能够在template中不使用data.xxx)

ref的变量命名都用xxxRef

合成函数返回响应式对象时，使用toRefs

参考地址：https://juejin.cn/post/7046200573212753951

script setup

在Vue 3中，使用 <script setup> 时，不需要使用 export default 来导出组件。实际上，<script setup> 会自动将组件导出为默认导出。

# 1 组件，只需要导入，就会自动注册
# 2 setup写法
<script setup> 写原来setup函数中的代码即可</script>
# 3 生命周期钩子--created
# 4 监听属性，计算属性
# 5 组件间通信 父传子
# 6 组件通信，子传父
# 7 插槽
# 8 mixin 没了-->直接导入导出用
# 9 插件一样
# 10 toRefs-->把对象中所有变量都做成响应式
# 11 toRef -->只把对象中某一个做成响应式
# 12 ref属性

https://zhuanlan.zhihu.com/p/471806345

// 1 组件，只需要导入，就会自动注册
// 在vue3中 .vue 后缀必须写
import HelloWorld from './components/HelloWorld.vue'

计算属性

<template>总价格：{{totalPrice}}</template>
<script setup>
    import { computed, reactive } from "vue";
    const dataList = reactive([
        {id: 1, name: "海边的卡夫卡", price: 78},
        {id: 2, name: "图解HTTP", price: 68},
        {id: 3, name: "活着", price: 49},
    ])
    const totalPrice = computed(()=>{
        return dataList.reduce((sum, item) => sum + item.price, 0)
    })
    setTimeout(() => {
        dataList[0].price = 70
    }, 2000);
</script>

组件通信 父传子

子组件使用defineProps

<!-- 父组件 -->
<D1Child :message="message"></D1Child>

// 子组件
import { defineProps } from "vue";

// 方式1
defineProps(['message'])
// 方式2
defineProps({
  message: String,
});

父子通信子传父

子组件使用defineEmits

// 子组件
import { defineEmits, ref } from "vue"

const data = ref('小满')
let emit = defineEmits(['msg'])
emit("msg", data.value)

// 父组件核心代码
<D1Child @msg="handleEvent"></D1Child>

function handleEvent(value){
	message.value = value
}

插槽

默认插槽

子组件用<slot>标签来确定渲染的位置，标签里面可以放DOM结构，当父组件使用的时候没有往插槽传入内容，标签内DOM结构就会显示在页面

父组件在使用的时候，直接在子组件的标签内写入内容即可。

---

子组件

<template>
    <slot>
        <p>我是默认的内容</p>
    </slot>
</template>

父组件

<template>
    <D1Child></D1Child>  <!-- 我是默认的内容 -->
</template>

<template>
    <D1Child>
        <p>我被替换了</p>  <!-- 我被替换了 -->
    </D1Child>  
</template>

具名插槽

1. slot标签中，如果没有设置 name 属性则默认 name 是 default
2. # 是 v-slot 指令的简写

子组件

<template>
    <slot name="title">
        <p>我是被替换的内容</p>
    </slot>
    <slot>
        看到我了吗
    </slot>
</template>

父组件

<template>
    <D1Child>
        <template #title>
            <p>成功修改为标题</p>
        </template> 
        <template v-slot:default>
            没看见
        </template>
    </D1Child>
</template>

<!-- 
	页面最终显示

	成功修改为标题
	没看见
-->

作用域插槽

有些时候，我们希望父组件填充插槽内容的时候，可以使用子组件的一些数据，为了实现这个需求，Vue 提供了作用域插槽我们可以像对组件传递 props 那样，向一个插槽的出口（slot 标签 <slot>）上传递属性（attributes），而这个属性中的数据可以在父组件中被访问到！

子组件

<template>
    <slot name="hi" msg="你好, 父组件！">
        <p>你好啊</p>
    </slot>
</template>

父组件

<template>
    <D1Child>
       <template #hi="slotProps">
         <p>来自子组件的消息：{{slotProps.msg}}</p>
       </template>
    </D1Child>
</template>

小结

• v-slot属性只能在<template>上使用，但在只有默认插槽时可以在组件标签上使用
• 默认插槽名为default，可以省略default直接写v-slot
• 缩写为#时不能不写参数，写成#default
• 可以通过解构获取v-slot={user}，还可以重命名v-slot="{user: newName}"和定义默认值v-slot="{user = '默认值'}"

参考文章：

https://juejin.cn/post/7340478055914209330?searchId=202405071947239138F4C38FC8EB9854FF

https://vue3js.cn/interview/vue/slot.html#一、slot是什么

axios

数据源结构

基本使用

写法很low

import { reactive } from "vue";

const dataList = reactive({})

axios.get("https://api.vvhan.com/api/hotlist/wbHot").then(
    response => {
        let data = response.data.data
        dataList.content = data
    }
).catch(err => console.log(err))

高级使用

Object.assign的使用：https://juejin.cn/post/6844903984675684366?searchId=202405072030535B33204404F5119D8572

尝试优化1

const dataList = reactive({data: {}})

axios.get("https://api.vvhan.com/api/hotlist/wbHot").then(
    response => {
        let data = response.data.data
        // 直接把结果复制到目标对象中
        Object.assign(dataList.data, data)
    }
).catch(err => console.log(err))

尝试优化2

axios.get("https://api.vvhan.com/api/hotlist/wbHot").then(
    response => {
        // 结构赋值
        let {data} = response.data 
        Object.assign(dataList.data, data)
    }
).catch(err => console.log(err))

尝试优化3

const dataList = reactive({data: {}})

axios.get("https://api.vvhan.com/api/hotlist/wbHot").then(
    response => {
        // 结构赋值 
        let {data:{data}}  = response
        Object.assign(dataList.data, data)
    }
).catch(err => console.log(err))

尝试优化4

const dataList = reactive({data: {}})

axios.get("https://api.vvhan.com/api/hotlist/wbHot").then(
    response => {
        let {data}  = response
        Object.assign(dataList, data)
    }
).catch(err => console.log(err))

async 和 await

let isShow = ref(false)
const dataList = reactive({data: {}})

async function load(){
    // 这里的response就是之前的.then中的response
    // const response = axios.get("https://api.vvhan.com/api/hotlist/wbHot")
    // data 就是 --> response.data
    const {data} = await axios.get("https://api.vvhan.com/api/hotlist/wbHot")
    Object.assign(dataList, data)
}

异常捕获

async function load(){
    try {
        const {data} = await axios.get("httpsssss://api.vvhan.com/api/hotlist/wbHot") // 不存在的地址
        Object.assign(dataList, data)
    } catch (error) {
        alert('出错了')
    }
}

request请求

// axios的所有请求本质上都是在调用axios的request方法
async function getBooks(){
    try {
        const res = await axios.request({
            method: "get",
            url: "http://127.0.0.1:8000/api/v1/books/"
        })
        console.log(res.data);
    } catch (error) {
        alert(error)
    }
}

all

axios.all 是一个用于同时处理多个并发请求的方法。它接收一个由多个 Promise 组成的数组，并在所有 Promise 都成功时才返回结果。这使得可以同时发起多个请求，并在它们都完成后再执行其他操作。

axios.all本质上就是Promise.all

// 1
function getBooks() {
        return axios.get("http://127.0.0.1:8000/api/v1/books/")
    }

function addBook(){
    return axios.post("http://127.0.0.1:8000/api/v1/books/" , {
        name: name.value,
        publish: publish.value
    })
}

// 两个任务
function twoTask(){
    axios.all([getBooks(), addBook()]).then(
        axios.spread(function(getBooksResponse, addBookResponse){
            console.log(getBooksResponse.data);  // 输出获取书籍信息的结果
            console.log(addBookResponse.data);  // 输出添加书籍的结果
        })
    )
}

// 2
async function twoTask(){
    const [getBookResponse, addBookResponse] = await axios.all([
        axios.get("http://127.0.0.1:8000/api/v1/books/"),
        axios.post("http://127.0.0.1:8000/api/v1/books/", {
            name: name.value,
            publish: publish.value
        })
    ])
    console.log(getBookResponse.data);
    console.log(addBookResponse.data);
}

拦截器

// 拦截器必须要在请求和响应之前被注册

// 请求拦截器 --- use方法的两个参数 --分别对应resolve和reject
// resolve方法的参数为请求的配置选项
// reject方法的参数为错误对象
axios.interceptors.request.use(
    config => {
        console.log(config);
        return config;  // 确保将请求配置返回，以便请求能够继续进行
    },
    err => console.error(err)
);

// 下面的函数需要写在拦截器之后
async function getBooks() {
    const res = await axios.get("http://127.0.0.1:8000/api/v1/books/");
    console.log(res.data);
}

async function addBook(){
    const res = await axios.post("http://127.0.0.1:8000/api/v1/books/" , {
        name: name.value,
        publish: publish.value
    })
    }

// 响应拦截器 --- use方法的两个参数 --- 分别对应resolve和reject
// resolve方法的参数为响应体
// reject方法的参数为错误对象
axios.interceptors.response.use(
    res => {
        return res.data
    },
    err => {
        return Promise.reject(err)
    }
)

async function getBooks() {
    try {
        const res = await axios.get("http://127.0.0.1:8000/api/v1/books/")
        console.log(res) // 这样能直接获取到结果，因为在拦截器中返回的是res.data
    } catch (error) {
        console.log(error)
    }
}

配置

// 以下都是全局配置
// axios的所有全局配置都可以设置在属性defaults下

// 基本请求公共路径
axios.defaults.baseURL = "http://127.0.0.1:8000/api/v1/books/"

// 超时时间 这里是10秒
axios.defaults.timeout = 10000

// 局部配置
async function getBooks(){
    // 因为我的baseURL是完整的地址，所以这里直接写一个 / 即可，如果还需要别的参数拼到 / 后面就好
    const res = await axios.get("/", {
        timeout:2000
    })
    console.log(res) // 使用了响应拦截器，所以能直接拿到结果
}

 async function updateBook(){
     // 修改1本
     const res = await axios.put("/3/", {
         name: '挪威的森林',
         publish: '延安出版社'
     })
     console.log(res)
 }

axios的其他配置项

axios({
    url:'地址'，
    method:'post',
    headers: {'token': 'adsfa.adsfa.adsf',contentType:'application/json'},
    params: {name: '小满',age: 3}, // get请求携带参数
    data: {firstName: 'Fred'},  // post请求携带参数
    timeout: 1000,  // 超时时间 1S
})

更多参数

// 更多参数
{
  //1 `url` 是用于请求的服务器 URL
  url: '/user',
  //2 `method` 是创建请求时使用的方法
  method: 'get', // 默认值
  //3 `baseURL` 将自动加在 `url` 前面，除非 `url` 是一个绝对 URL。
  // 它可以通过设置一个 `baseURL` 便于为 axios 实例的方法传递相对 URL
  baseURL: 'https://some-domain.com/api/',
  //4 `transformRequest` 允许在向服务器发送前，修改请求数据
  // 它只能用于 'PUT', 'POST' 和 'PATCH' 这几个请求方法
  // 数组中最后一个函数必须返回一个字符串， 一个Buffer实例，ArrayBuffer，FormData，或 Stream
  // 你可以修改请求头。
  transformRequest: [function (data, headers) {
    // 对发送的 data 进行任意转换处理
    return data;
  }],
  // `transformResponse` 在传递给 then/catch 前，允许修改响应数据
  transformResponse: [function (data) {
    // 对接收的 data 进行任意转换处理
    return data;
  }],
  //5  自定义请求头
  headers: {'X-Requested-With': 'XMLHttpRequest'},
  //6 params` 是与请求一起发送的 URL 参数
  // 必须是一个简单对象或 URLSearchParams 对象
  params: {
    ID: 12345
  },
  // 7 aramsSerializer`是可选方法，主要用于序列化`params`
  // (e.g. https://www.npmjs.com/package/qs, http://api.jquery.com/jquery.param/)
  paramsSerializer: function (params) {
    return Qs.stringify(params, {arrayFormat: 'brackets'})
  },
  //8 data` 是作为请求体被发送的数据
  // 仅适用 'PUT', 'POST', 'DELETE 和 'PATCH' 请求方法
  // 在没有设置 `transformRequest` 时，则必须是以下类型之一:
  // - string, plain object, ArrayBuffer, ArrayBufferView, URLSearchParams
  // - 浏览器专属: FormData, File, Blob
  // - Node 专属: Stream, Buffer
  data: {
    firstName: 'Fred'
  },
  // 发送请求体数据的可选语法
  // 请求方式 post
  // 只有 value 会被发送，key 则不会
  data: 'Country=Brasil&City=Belo Horizonte',
  // 0imeout` 指定请求超时的毫秒数。
  // 如果请求时间超过 `timeout` 的值，则请求会被中断
  timeout: 1000, // 默认值是 `0` (永不超时)
  // 11 thCredentials` 表示跨域请求时是否需要使用凭证
  withCredentials: false, // default
  //12 dapter` 允许自定义处理请求，这使测试更加容易。
  // 返回一个 promise 并提供一个有效的响应 （参见 lib/adapters/README.md）。
  adapter: function (config) {
    /* ... */
  },
  //13 auth` HTTP Basic Auth
  auth: {
    username: '小满'
    password: '123'
  },
  //14 `responseType` 表示浏览器将要响应的数据类型
  // 选项包括: 'arraybuffer', 'document', 'json', 'text', 'stream'
  // 浏览器专属：'blob'
  responseType: 'json', // 默认值
  //15 `responseEncoding` 表示用于解码响应的编码 (Node.js 专属)
  // 注意：忽略 `responseType` 的值为 'stream'，或者是客户端请求
  // Note: Ignored for `responseType` of 'stream' or client-side requests
  responseEncoding: 'utf8', // 默认值
  //16  `xsrfCookieName` 是 xsrf token 的值，被用作 cookie 的名称
  xsrfCookieName: 'XSRF-TOKEN', // 默认值
  //17  `xsrfHeaderName` 是带有 xsrf token 值的http 请求头名称
  xsrfHeaderName: 'X-XSRF-TOKEN', // 默认值
  //18  `onUploadProgress` 允许为上传处理进度事件
  // 浏览器专属
  onUploadProgress: function (progressEvent) {
    // 处理原生进度事件
  },
  //19  `onDownloadProgress` 允许为下载处理进度事件
  // 浏览器专属
  onDownloadProgress: function (progressEvent) {
    // 处理原生进度事件
  },
  // 20 `maxContentLength` 定义了node.js中允许的HTTP响应内容的最大字节数
  maxContentLength: 2000,
  //21  `maxBodyLength`（仅Node）定义允许的http请求内容的最大字节数
  maxBodyLength: 2000,
  // 22 `validateStatus` 定义了对于给定的 HTTP状态码是 resolve 还是 reject promise。
  // 如果 `validateStatus` 返回 `true` (或者设置为 `null` 或 `undefined`)，
  // 则promise 将会 resolved，否则是 rejected。
  validateStatus: function (status) {
    return status >= 200 && status < 300; // 默认值
  },
  // 23 `maxRedirects` 定义了在node.js中要遵循的最大重定向数。
  // 如果设置为0，则不会进行重定向
  maxRedirects: 5, // 默认值
  //24  `socketPath` 定义了在node.js中使用的UNIX套接字。
  // e.g. '/var/run/docker.sock' 发送请求到 docker 守护进程。
  // 只能指定 `socketPath` 或 `proxy` 。
  // 若都指定，这使用 `socketPath` 。
  socketPath: null, // default
  //25  `httpAgent` and `httpsAgent` define a custom agent to be used when performing http
  // and https requests, respectively, in node.js. This allows options to be added like
  // `keepAlive` that are not enabled by default.
  httpAgent: new http.Agent({ keepAlive: true }),
  httpsAgent: new https.Agent({ keepAlive: true }),
  //26  `proxy` 定义了代理服务器的主机名，端口和协议。
  // 您可以使用常规的`http_proxy` 和 `https_proxy` 环境变量。
  // 使用 `false` 可以禁用代理功能，同时环境变量也会被忽略。
  // `auth`表示应使用HTTP Basic auth连接到代理，并且提供凭据。
  // 这将设置一个 `Proxy-Authorization` 请求头，它会覆盖 `headers` 中已存在的自定义 `Proxy-Authorization` 请求头。
  // 如果代理服务器使用 HTTPS，则必须设置 protocol 为`https`
  proxy: {
    protocol: 'https',
    host: '127.0.0.1',
    port: 9000,
    auth: {
      username: '小满',
      password: '123'
    }
  },
  // 27 see https://axios-http.com/zh/docs/cancellation
  cancelToken: new CancelToken(function (cancel) {
  }),
  // 28 `decompress` indicates whether or not the response body should be decompressed 
  // automatically. If set to `true` will also remove the 'content-encoding' header 
  // from the responses objects of all decompressed responses
  // - Node only (XHR cannot turn off decompression)
  decompress: true // 默认值
}

axios封装

对 axios 进行封装有几个重要的原因：

1. 简化重复代码：通过封装 axios，您可以将常见的请求逻辑（例如设置基本 URL、拦截器等）封装到一个地方，避免在每个请求中重复编写相同的代码。

2. 统一处理请求和响应：封装可以让您在一个地方统一处理请求和响应，例如添加认证信息、处理错误等。这样可以提高代码的一致性和可维护性。

3. 隐藏细节：封装可以隐藏底层的请求细节，使调用代码更加简洁和易于理解。这对于团队合作和代码维护非常有帮助。

4. 定制化需求：通过封装，您可以根据项目的特定需求定制化请求和响应的处理逻辑，使其更符合项目的实际情况。

因此，对 axios 进行封装可以提高代码的可维护性、可读性和灵活性，是一个在实际项目中常见的做法。

一般会放置在src下的service或者api文件夹下。

// scr/service/axiosRequest.js
import { ElMessage } from 'element-plus'
import axios from 'axios'


// 创建一个axios实例
const service = axios.create({
    baseURL: "http://127.0.0.1:8000/api/v1/books/", // 默认地址
    timeout: 2000, // 超时时间
})

// 请求拦截器
service.interceptors.request.use(
    config => {
        // 在发送请求之前做些什么
        // ....可以写逻辑
        return config
    },
    err => {
        return Promise.reject(err) // 错误对象返回出去，后续能直接捕获到
    }
)

// 响应拦截器
service.interceptors.response.use(
    response => {
        const res = response.data  // 获取结果
        // 这个状态码不是后端定义的，是根据浏览器获取的，如果获取后端定义的，请从res里面获取
        if (response.status !== 200) {
            ElMessage.error(res.message || 'Oops, this is a error message.')
            // 还可以定义一些其他的逻辑
            return Promise.reject(res.message || "Error")
        } else {
            return res // 没有错误把正常的数据返回出去
        }
    },
    err => {
        ElMessage()
        return Promise.reject(err.message)
    }
)

// 别忘记导出
export default service

<!-- 视图使用 -->
<template>
    <h3>home</h3>
    <button @click="getBooks">获取1本书</button>
    <button @click="addBook">新增1本书</button>
    <button @click="updateBook">修改1本书</button>
    <br>
    <input type="text" v-model="name" placeholder="书名">
    <input type="text" v-model="publish" placeholder="出版社">
</template>

<script setup>
    import { ref } from "vue"
    // 导入
    import axiosRequest from "../api/axiosRequest.js"


    const name = ref("")
    const publish = ref("")


    // 查看图书
    async function getBooks() {
        try {
            const res = await axiosRequest.get("/")
            console.log(res)
        } catch (error) {
            console.log(error)
        }
    }

    // 新增图书
    async function addBook() {
        try {
            // 使用
            const res = await axiosRequest.post("/", {
                name: "摸鱼技巧大全",
                publish: "摸鱼出版社"
            })
            console.log(res)

        } catch (error) {
            console.log(error)
        }
    }
    // 修改图书
    async function updateBook(){
        try {
            const res = await axiosRequest.put("/18/", {
            name: "追梦人",
            publish: "追梦出版社"
        })
            console.log(res)
        } catch (error) {
            console.log(error)
        }
    }
</script>

参考资料：

https://juejin.cn/post/6942745384829583397?searchId=20240509170214C1BC4A51BA2511AB5675

promise语法

普通函数和回调函数

//普通函数: 正常调用的函数,一般函数执行完毕后才会继续执行下一行代码

<script>
    let fun1 = () =>{
        console.log("fun1 执行了")
    }
    // 调用函数
    fun1()
    // 函数执行完毕,继续执行后续代码
    console.log("其他代码继续执行")
</script>

//回调函数: 一些特殊的函数,表示未来才会执行的一些功能,后续代码不会等待该函数执行完毕就开始执行了

<script>
    // 设置一个2000毫秒后会执行一次的定时任务，基于事件自动调用，console.log先执行
    setTimeout(function (){
        console.log("延迟演示执行了")
    },2000)
    console.log("其他代码执行")
</script>

promise基本使用(用来处理回调函数)

# Promise对象代表一个异步操作，有三种状态：`Pending`（进行中）、`Resolved`（已完成，又称 Fulfilled）和`Rejected`（已失败）

# 现实生活中对应
你跟你女朋友说，5年后等我赚够500w就结婚--》定义函数
 -1 进行中（努力赚钱，其他代码继续执行）
 -2 成功（赚够500w---》结婚）
 -3 失败（没赚够---》分手）

# 代码模拟

<script>
    let promise =new Promise(function(resolve,reject){
        // resolve,reject 是两个函数
        console.log("promise 开始执行")
        // resolve("promise 执行成功")
        // reject("promise 执行失败")
        // 主动抛异常，也是执行失败
        throw new Error("error message")
    })
    console.log('11111')
    // promise.then(
    //     function(value){console.log(`promise中执行了resolve:${value}`)},
    //     function(error){console.log(`promise中执行了reject:${error}`)}
    // )
    promise.then(res=>{
        console.log(res)
    }).catch(err=>{
        console.log(err)
    })
    console.log('222222')

</script>

# axios.get()--->得到一个promise对象

async和await的使用

# promise对象 支持async和await 写法

// async 和await 写法
    // 1  async标识函数后,async函数的返回值会变成一个promise对象
    async function demo01() {
        let promise = new Promise(function (resolve, reject) {
            // resolve,reject 是两个函数
            console.log("promise 开始执行")
            // resolve("promise 执行成功")
            // reject("promise 执行失败")
            // 主动抛异常，也是执行失败
            throw new Error("error message")
        })
        return promise
    }

    console.log('11111')

    // await 关键字，必须写在async修饰的函数中
    async function demo02() {
        try {
            let res = await demo01()  // 正常调用，返回promise 对象，加await 调用--》返回正常then的数据
            console.log(res)
        } catch (err) {
            console.log('出错了')
        }

    }

    demo02()  // 它会等正常执行完成才会调用
    console.log('222222')

function sendRequest(){
    return new Promise(function(resolve, reject){
        // 执行结果只能二选一 要么resolve 成功 要么reject 失败，不支持同时满足
        setTimeout(() => {
            resolve('小满')
        }, 2000);
    });
}
// 这里得到的是一个promise对象
// 如果要获取里面的数据，需要使用.then回调函数，拿到结果。
const r = sendRequest()
r.then(username => console.log(username))

使用await

let username = await sendRequest()
console.log(username); // Uncaught SyntaxError: await is only valid in async functions and the top level bodies of modules

async必须结合await一起使用，继续优化

async function getUserName(){
    // await的任务是等待promise完成任务，所以await后面一般会尾随返回promise的函数
    let username = await sendRequest()
    console.log(username);
}

getUserName() // 小满

捕获报错信息，即获取reject的异常，通过trycatch捕获

function sendRequest() {
    return new Promise(function (resolve, reject) {
        setTimeout(() => {
            reject('服务器连接失败')
        }, 2000);
    });
}
async function getUserName(){
    try {
        let username = await sendRequest()
        } catch (error) { // 这个error 就是reject的错误信息
            console.log(error);
        }
}
getUserName() // 服务器连接失败

简单总结：

1. await关键字必须未遂promise objest
2. 使用Try Catch语句捕获async await出现的错误