谷粒商城_03_前端基础

最新推荐文章于 2024-05-13 11:00:55 发布

早上真起不来！

最新推荐文章于 2024-05-13 11:00:55 发布

阅读量743

点赞数 29

分类专栏：后端文章标签：前端 java vue.js es6

本文链接：https://blog.csdn.net/qq_51998352/article/details/121942276

版权

谷粒商城_01_环境搭建
 谷粒商城_02_Nacos、网关

前端

前后端对比

在这里插入图片描述

ES6

ECMAScript6.0（以下简称ES6，ECMAScript是一种由Ecma国际通过ECMA-262标准化的脚本），是JavaScript语言的下一代标准，2015年6月正式发布，从ES6开始的版本号采用年号，如ES2015，就是ES6。ES2016就是ES7。ECMAScript是规范，JS的规范的具体实现。

vscode打开文件夹，创建es6文件夹打开
在es6文件中，创建文件，shift+! 回车快速生成html
右键—Open with Live Server打开浏览器查看
shift+alt+f 整理代码

let&&const

var在{}之外也起作用，类似全局变量，let在{}之外不起作用
var多次声明同一变量不会报错，let多次声明会报错，只能声明一次。
var 会变量提升（打印和定义可以顺序反）。let 不存在变量提升（顺序不能反）
const声明之后不允许改变

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>
<body>
    

    <script>
       // var 声明的变量往往会越域
       // let 声明的变量有严格局部作用域
//         {
     
//             var a = 1;
//             let b = 2;
//         }
//         console.log(a);  // 1
//         console.log(b);  // ReferenceError: b is not defined

    // var 可以声明多次
            // let 只能声明一次
//         var m = 1
//         var m = 2
//         let n = 3
//       let n = 4
//         console.log(m)  // 2
//         console.log(n)  // Identifier 'n' has already been declared

        // var 会变量提升
        // let 不存在变量提升
//         console.log(x);  // undefined
//         var x = 10;
//         console.log(y);   //ReferenceError: y is not defined
//         let y = 20;

        // const
        // 1. const声明之后不允许改变
        // 2. 一但声明必须初始化，否则会报错
        const a = 1;
        a = 3; //Uncaught TypeError: Assignment to constant variable.
    
    </script>
</body>
</html>

解构表达式

数组解构：支持let arr = [1,2,3]; let [a,b,c] = arr;
对象解构：const { name: abc, age, language } = person; 冒号代表改名
字符串函数：支持一个字符串为多行占位符功能 ${}

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>
<body>

    <script>
        // 数组解构
        // let arr = [1,2,3];
        // // let a = arr[0];
        // // let b = arr[1];
        // // let c = arr[2];

        // let [a,b,c] = arr;
        // console.log(a,b,c) // 1,2,3

        const person = {
     
            name: "jack",
            age: 21,
            language: ['java', 'js', 'css']
        }
        //         const name = person.name;
        //         const age = person.age;
        //         const language = person.language;

        // 对象解构
        const {
      name: abc, age, language } = person;
        console.log(abc, age, language) // jack，21，['java', 'js', 'css']

        // 字符串扩展
        let str = "hello.vue";
        console.log(str.startsWith("hello"));// 是否以hello开始：true
        console.log(str.endsWith(".vue"));// 是否以.vue结尾：true
        console.log(str.includes("e"));// 是否包含e：true
        console.log(str.includes("hello"));// 是否包含hello：true

        // 字符串模板，多行字符串 ``
        let ss = `<div>
                    <span>hello world<span>
                </div>`
        console.log(ss); // 这里的字符串是什么样就打印什么样的，空格也算
        

        // 字符串插入变量和表达式。变量名写在 ${} 中，${} 中可以放入 JavaScript 表达式。
        function fun() {
     
            return "这是一个函数"
        }
        let info = `我是${
       abc}，今年${
       age + 10}了, 我想说： ${
       fun()};`
        console.log(info); // 我是jack，今年31了, 我想说： 这是一个函数

    </script>
</body>
</html>

函数优化

原来想要函数默认值得这么写 b = b || 1 ;
现在可以直接写了：function add(a, b = 1) { }
函数不定参数：function fun(…values) { }
支持箭头函数（lambda表达式）
还支持使用{}结构传入对象的成员

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>
<body>

    <script>
        //在ES6以前，我们无法给一个函数参数设置默认值，只能采用变通写法：
        function add(a, b) {
     
            // 判断b是否为空，为空就给默认值1
            b = b || 1;
            return a + b;
        }
        // 传一个参数
        console.log(add(10)); // 11


        //现在可以这么写：直接给参数写上默认值，没传就会自动使用默认值
        function add2(a, b = 1) {
     
            return a + b;
        }
        console.log(add2(20)); // 21


        //不定参数
        function fun(...values) {
     
            console.log(values.length)
        }
        fun(1, 2)      //2
        fun(1, 2, 3, 4)  //4

        // 箭头函数
        // 以前声明一个方法
        // var print = function (obj) {
     
        //     console.log(obj);
        // }
        var print = obj => console.log(obj);
        print("hello"); // hello

        // var sum = function (a, b) {
     
        //     c = a + b;
        //     return a + c;
        // }
        var sum2 = (a, b) => a + b;
        console.log(sum2(11, 12)); // 23

        var sum3 = (a, b) => {
     
            c = a + b;
            return a + c;
        }
        console.log(sum3(10, 20)) // 40


        const person = {
     
            name: "jack",
            age: 21,
            language: ['java', 'js', 'css']
        }

        function hello(person) {
     
            console.log("hello," + person.name) // hello,jack
        }

        //箭头函数+解构
        var hello2 = (obj) => console.log("hello," +obj.name);      
        hello2(person); // hello,jack
        var hello3 = ({
      name}) => console.log("hello," +name);
        hello3(person); // hello,jack

    </script>
</body>
</html>

对象优化

可以获取map的键值对的信息，Object.keys()、values、entries
Object.assgn(target,source1,source2) 合并为 target
const person2 = { age, name } ：属性名和值相同可以声明对象简写
对象的函数属性简写
…代表取出该对象所有属性拷贝到当前对象。let someone = { …p1 }

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>
<body>
    <script>
        const person = {
     
            name: "jack",
            age: 21,
            language: ['java', 'js', 'css']
        }

        console.log(Object.keys(person));		
        // ["name", "age", "language"]
        console.log(Object.values(person));		
        // ["jack", 21, Array(3)] // ['java', 'js', 'css']
        console.log(Object.entries(person));	
        // [Array(2), Array(2), Array(2)]
        // 0: (2) ['name', 'jack']、1: (2) ['age', 21]、2: (2) ['language', Array(3)]

        const target = {
      a: 1 };
        const source1 = {
      b: 2 };
        const source2 = {
      c: 3 };
        
        // target为目标对象，将其中的合并
        Object.assign(target, source1, source2);
        console.log(target);	// {a:1,b:2,c:3}

        // 声明对象简写
        const age = 23
        const name = "张三"
        const person1 = {
      age: age, name: name } // {age: 23, name: '张三'}

        const person2 = {
      age, name }// 如果属性名和值相同的就可以，声明对象简写
        console.log(person2);

        // 对象的函数属性简写
        let person3 = {
     
            name: "jack",
            // 以前：
            eat: function (food) {
     
                console.log(this.name + "在吃" + food);
            },
            // 箭头函数this不能使用，对象.属性
            eat2: food => console.log(person3.name + "在吃" + food),
            eat3(food) {
     
                console.log(this.name + "在吃" + food);
            }
        }

        person3.eat("香蕉"