ES语法以及ajax相关操作

这篇具有很好参考价值的文章主要介绍了ES语法以及ajax相关操作。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

ajax

ajax一个前后台配合的技术,它可以让javascript发送http请求,与后台通信,获取数据和信息。ajax技术的原理是实例化xmlhttp对象,使用此对象与后台通信。jquery将它封装成了一个函数$.ajax(),我们可以直接用这个函数来执行ajax请求。

ajax需要在服务器环境下运行。

$.ajax使用方法
常用参数:
1、url 请求地址
2、type 请求方式,默认是’get’,常用的还有’post’
3、dataType 设置返回的数据格式,常用的是’json’格式,也可以设置为’text’
4、data 设置发送给服务器的数据
5、success 设置请求成功后的回调函数
6、error 设置请求失败后的回调函数
7、async 设置是否异步,默认值是’true’,表示异步

以前的写法:

$.ajax({
    url: '/change_data',
    type: 'get',
    dataType: 'json',
    data:{'code':300268}
    success:function(dat){
        alert(dat.name);
    },
    error:function(){
        alert('服务器超时,请重试!');
    }
});

新的写法(推荐):

$.ajax({
    url: '/change_data',
    type: 'get',
    dataType: 'json',
    data:{'code':300268}
})
.done(function(dat) {
    alert(dat.name);
})
.fail(function() {
    alert('服务器超时,请重试!');
});
$(function(){
			
			/*$.ajax({
				url:'js/data.json',
				type:'get',
				dataType:'json'
				/*success:function(dat){
					// console.log(dat);
					$('.login_btn').hide();
					$('.login_info em').html( dat.name ).parent().show();
				},
				error:function(){
					alert('服务器超时,请重试!');
				}
			
			
			}).done(function(dat){
				$('.login_btn').hide();
				$('.login_info em').html( dat.name ).parent().show();
			}).fail(function(){
				alert('服务器超时,请重试!');
			})
			*/
			// 上面是完整写法,可以简写成下面$.get的写法:
			
			$.get('js/data.json',function(dat){
				$('.login_btn').hide();
				$('.login_info em').html( dat.name ).parent().show();
			});

		})

ES6语法

ES6是JavaScript语言的新版本,它也可以叫做ES2015,之前学习的JavaScript属于ES5,ES6在它的基础上增加了一些语法,ES6是未来JavaScript的趋势,而且React库中大量使用了ES6的语法,所以掌握这些常用的ES6语法是必须的。

变量声明let和const

let和const是新增的声明变量的开头的关键字,在这之前,变量声明是用var关键字,这两个关键字和var的区别是,它们声明的变量没有预解析,let和const的区别是,let声明的是一般变量,const申明的常量,不可修改。

alert(iNum01) // 弹出undefined
// alert(iNum02); 报错,let关键字定义变量没有变量预解析
// alert(iNum03); 报错,const关键字定义变量没有变量预解析

var iNum01 = 6;
// 使用let关键字定义变量
let iNum02 = 12;
// 使用const关键字定义变量
const iNum03 = 24;

alert(iNum01); // 弹出6
alert(iNum02); // 弹出12
alert(iNum03); // 弹出24

iNum01 = 7;
iNum02 = 13;
//iNum03 = 25; // 报错,const定义的变量不可修改,const定义的变量是常量

alert(iNum01)
alert(iNum02); 
alert(iNum03);

示例

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<script>
    // 用var定义变量,变量有预解析的特性
    // alert(iNum01);//undefined

    var iNum01 = 12;

    // alert(iNum01); //12

    //let定义的变量没有预解析,下面这一句就报错 在初始化之前无法访问'iNum02'
    // alert(iNum02); //Cannot access 'iNum02' before initialization 
    let iNum02 = 24; 
    // alert(iNum02); //24

    iNum02 =25;
    // alert(iNum02);//25

    //const定义的变量没有预解析,下面这一句出错 在初始化之前无法访问'iNum03'
    // alert(iNum03);//Cannot access 'iNum03' before initialization

    const iNum03 = 36;
    alert(iNum03); //36

    //对常量变量赋值。const定义的是常量,它的值不能修改,下面这一句出错
    // iNum03 = 37;
    
    // alert(iNum03);//Assignment to constant variable.
</script>
<body>
    
</body>
</html>

解构赋值

ES6 允许我们按照一定模式,从数组和对象中提取值,对变量进行赋值,这被称为解构(Destructuring)

1、数组的解构赋值

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

2、对象的解构赋值

const obj = { name: 'tom',address:'beijing', age: '100'} 
let {name, age} = obj  // 变量名称必须和对象的key同名
console.log(name, age); //tom 100

3、函数参数的解构赋值

const person = { name: '小明', age: 11}
function printPerson({name, age}) { // 函数参数可以解构一个对象
  console.log(`姓名:${name} 年龄:${age}`);
}
printPerson(person) // 姓名:小明 年龄:11

字符串模板

ES6中提供了模版字符串,用`(反引号)标识,用${}将变量括起来

let name = '小明';
let age = 11;
alert(`我的名字是${name},我的年龄是${age}岁。`)

示例

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        //数组的解构赋值
        let aList = [1,2,3];
        let [a,b,c] = aList;
        console.log(a,b,c);//1 2 3

        // 对象的解构赋值
        let person = {name:"tom",age:18};
        let {name,age} = person;
        console.log(`姓名:${name} 年龄:${age}`);//姓名:tom 年龄:18

        // 函数参数的解构赋值

        function fnAlertPerson({name,age}){
            console.log(`我的姓名:${name} 我的年龄:${age}`);
            alert(
            `我的名字是:${name},
            我的年龄是:${age}`
            );
        }
        fnAlertPerson(person); //我的姓名:[object Object] 我的年龄:undefined
    </script>
</head>
<body>
    
</body>
</html>

扩展运算符(…)

扩展运算符(…),它用于把一个数组转化为用逗号分隔的参数序列,它常用在不定参数个数时的函数调用,数组合并等情形。

let arr = [1,2,3];
let arr2 = [...arr,4];
console.log(arr2)  // [1,2,3,4]

function fnAdd(a,b,c){
    alert(a + b + c);
}
fnAdd(...arr); // 6

function fnMyalert(...a){
    console.log(a);
    alert(a[0]);
    alert(a[1]);
}
fnMyalert(10,5); // [10,5]  10  5

示例

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        let arr = [1,2,3];

        //下面这种方式不能复制数组
        let arr2 = arr; //只是指向同一个地址

        

        //用for循环赋值数组
        let arr3 = [];
        for (var index = 0; index < arr.length; index++) {
            arr3.push(arr[index]);
        }

       

        //通过扩展运算符复制数组
        let arr4 = [...arr,5];

        arr.push(4);
        // alert(arr); //1 2 3 4
        // alert(arr2); //1,2,3,4
        // alert(arr3); //1 2 3
        alert(arr4); // 1 2 3 5

        function fnAdd(a,b,c){
            alert(a+b+c);
        }

        // fnAdd(...arr);  //6 把数据arr传进去

        function fnConsole(...a){ //10,5,6
            console.log(a);
        }

        fnConsole(10,5,6);
    </script>
</head>
<body>
    
</body>
</html>

箭头函数

可以把箭头函数理解成匿名函数的第二种写法,箭头函数的作用是可以在对象中绑定this,解决了JavaScript中this指定混乱的问题。

// 定义函数的一般方式
/*
function fnRs(a,b){
    var rs = a + b;
    alert(rs);
}
fnRs(1,2);        
*/

// 通过匿名函数赋值来定义函数
/*
var fnRs = function(a,b){
    var rs = a + b;
    alert(rs);
}
fnRs(1,2);
*/

// 通过箭头函数的写法定义
var fnRs = (a,b)=>{
    var rs = a + b;
    alert(rs);
}        
// fnRs(1,2);

// 一个参数可以省略小括号
var fnRs2 = a =>{
    alert(a);
}
fnRs2('haha!');

// 函数中如果只有一个return语句,return和大括号都可以省略
/*
var fnAdd = function(a,b){
    return a + b;
}
*/
var fnAdd = (a,b) => a+b;


// 函数的返回值如果是javascript对象时,对象需要加括号
/*
let fn = function(){
    return {"a":5};
}
*/
// fn = ()=>{"a":5}
// 上面这么写是错的,需要写成下面的形式,返回的对象要加括号
fn = ()=>({"a":5})

示例

// 箭头函数的作用,可以绑定对象中的this
var person = {
    name:'tom',
    age:18,
    showName:function(){
        setTimeout(()=>{
            alert(this.name);
        },1000)            
    }
}
person.showName();

模块导入import和导出export

javascript之前是没有模块的功能的,之前做js模块化开发,是用的一些js库来模拟实现的,在ES6中加入了模块的功能,一个js文件就是一个模块,js文件中需要先导出(export)后,才能被其他js文件导入(import)

ES6的导出分为名字导出和默认导出
1、名称导出
导入的变量名必须和导出的变量名一致

// mod01.js文件中导出
export let iNum01 = 12;
export let fnMyalert = function(){
    alert('hello');
}

// index.html文件中导入
<script type="module">
    import {iNum01,fnMyalert} from "./js/mod01.js";
    alert(iNum01);
    fnMyalert();
</script>

// mod01.js中还可以写成如下:
let iNum01 = 12;
let fnMyalert = function(){
    alert('hello');
}
export {iNum01,fnMyalert}

2、默认导出(default export) 一个模块只能有一个默认导出,对于默认导出,导入的名称可以和导出的名称不一致,这对于导出匿名函数或类非常有用。

// mod02.js文件中导出
export default {"name":"tom","age":18}

// index.html文件中导入
<script type="module">
    import person from "./js/mod02.js";
    alert(person.name);
</script>

对象的简写
javascript对象在ES6中可以做一些简写形式,了解这些简写形式,才能方便我们读懂一些在javascript代码中简写的对象。

let name = '李思';
let age = 18;

/*
var person = {
    name:name,
    age:age,
    showname:function(){
        alert(this.name);
    },
    showage:function(){
        alert(this.age);
    }
}
*/

// 简写成下面的形式

var person = {
    name,
    age,
    showname(){
      alert(this.name);
    },
    showage(){
      alert(this.age);
    }
}

person.showname();
person.showage();

示例

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=\, initial-scale=1.0">
    <title>Document</title>
    <script>
        let name = "tom";
        let age = 18;

        // let person = {
        //     name:name,
        //     age:age,
        //     showname:function(){
        //         console.log(this.name);
        //     },

        //     showage:function(){
        //         console.log(this.age);
        //     }
        // }


        //上面对象可以简写成下面的形式
        let person = {
            name,
            age,
            showname(){
                console.log(this.name);
            },

            showage(){
                console.log(this.age);
            }
        }
        person.showname();

        person.showage();
    </script>
</head>
<body>
    
</body>
</html>

定义类及类的继承

ES6 封装了class语法来大大简化了类的创建和类的继承

// 定义类,类的首字母要大写
class Person {
    // 定义构造函数
    constructor(name,age){
        this.name = name;
        this.age = age;
    }
    // 定义方法
    showname(){
        alert('我的名字是:' + this.name);
    }
    showage(){
        alert('我的年龄是:' + this.age);
    }
}

// 通过类实例化对象
let Andy = new Person('刘德华',55);

// 调用对象的方法
Andy.showname();
Andy.showage();

// 定义类继承Person类
class Student extends Person{
    constructor(name,age,school){
        super(name,age);
        this.school = school;
    }
    showschool(){
        alert('我的学校是:' + this.school);
    }
}

// 通过类实例化对象
let Tom = new Student('小明','16','北京一中');

// 调用对象的方法
Tom.showname();
Tom.showschool();

示例

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        //定义一个类
        class Person{
            constructor(name,age){
                this.name = name;
                this.age = age;
            }

            showname(){
                console.log("我的名称:"+this.name);
            }

            showage(){
                console.log("我的年龄:"+this.age);
            }
        }

        //通过类来实例化一个对象
        let Andy = new Person('刘德华',55);

        //调用对象上面的方法
        // Andy.showname();
        // Andy.showage();

        //定义类继承Person

        class Student extends Person{
            constructor(name,age,school){
                super(name,age);
                this.school = school;
            }

            showschool(){
                console.log("我的学校是:"+this.school);
            }
        }

        var xiaoming = new Student("小明",15,"武汉一中");

        xiaoming.showage();
        xiaoming.showname();
        xiaoming.showschool();
    </script>
</head>
<body>
    
</body>
</html>

异步操作

es6新增了异步操作的写法,来解决异步操作函数回调的问题,这个新增的写法就是Promise对象,Promise实际上就是一个特殊的Javascript对象,反映了”异步操作的最终值”。”Promise”直译过来有预期的意思,因此,它也代表了某种承诺,即无论你异步操作成功与否,这个对象最终都会返回一个值给你。
在实际开发中,如果我们在写ajax程序时,我们如果希望两个ajax程序都执行完后,再去做一件事情,我们实现的方法可以是,在一个ajax中嵌套另外一个ajax程序:

$.ajax({
    url:'data01.json',
    type:'get',
    dataType:'json',
    success:function(dat1){
        $.ajax({
            url:'data01.json',
            type:'get',
            dataType:'json',
            success:function(dat2){
                console.log([dat1,dat2])
            }
        })
})

上面的写法不方便编写,也不方便阅读,Promise对象就可以解决这个问题

// 实例化一个Promise对象
var pro01 = new Promise(function(resolve,reject){
    $.ajax({
        url:'js/data01.json',
        type:'get',
        dataType:'json'
    }).done(function(dat){
        resolve(dat)
    }).fail(function(err){
        reject(err)
    })
});

var pro02 = new Promise(function(resolve,reject){
    $.ajax({
        url:'js/data02.json',
        type:'get',
        dataType:'json'
    }).done(function(dat){
        resolve(dat)
    }).fail(function(err){
        reject(err)
    })
});

// 通过Promise对象来处理回调
pro01.then(function(dat){
    console.log(dat);
}).catch(function(err){
    console.log(err)
})

上面将两个ajax请求分别放在两个promise对象中,其中resolve参数是处理请求成功的回调函数,reject是处理失败的回调函数,接着就可以通过这个对象,来处理ajax的回调,相当于把回调拆开了写。 如果希望两个ajax程序都执行完后,再去做一件事情,可以写成如下的形式:

Promise.all([pro01,pro02]).then(result=>console.log(result));

示例

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script src="js/jquery-1.12.4.min.js"></script>

    <script>

        //方式一
        // $.ajax({
        //     url:'js/data01.json',
        //     type:'get',
        //     dataType:'json',
        //     success: function(dat01){
        //         // console.log(dat); //{"name": "张三"}

        //         $.ajax({
        //             url:'js/data02.json',
        //             type:'get',
        //             dataType:'json',
        //             success: function(dat02){
        //                 // console.log(dat); //{"name": "张三"}
        //                 console.log([dat01,dat02]);
        //             },
        //             error: function(err){

        //             }
        //         })
        //     },
        //     error: function(err){

        //     }
        // })

        //方式二
        let pro01 = new Promise(function(resolve,reject){
            $.ajax({
                url:'js/data01.json',
                type:'get',
                dataType:'json',
                success:function(dat){
                    resolve(dat);
                },
                error:function(err){
                    reject(err);
                }
            })
        });

        let pro02 = new Promise(function(resolve,reject){
            $.ajax({
                url:'js/data02.json',
                type:'get',
                dataType:'json',
                success:function(dat){
                    resolve(dat);
                },
                error:function(err){
                    reject(err);
                }
            })
        });

        //then请求成功
        pro01.then(function(dat){
            console.log(dat);
        }).catch(function(err){

        })

        Promise.all([pro01,pro02]).then(re=>{
            console.log(re);
        })
    </script>
</head>
<body>
    
</body>
</html>

server.js

/*
NodeJS Static Http Server - http://github.com/thedigitalself/node-static-http-server/
By James Wanga - The Digital Self
Licensed under a Creative Commons Attribution 3.0 Unported License.

A simple, nodeJS, http development server that trivializes serving static files.

This server is HEAVILY based on work done by Ryan Florence(https://github.com/rpflorence) (https://gist.github.com/701407). I merged this code with suggestions on handling varied MIME types found at Stackoverflow (http://stackoverflow.com/questions/7268033/basic-static-file-server-in-nodejs).

To run the server simply place the server.js file in the root of your web application and issue the command 
$ node server.js 
or 
$ node server.js 1234 
with "1234" being a custom port number"

Your web application will be served at http://localhost:8888 by default or http://localhost:1234 with "1234" being the custom port you passed.

Mime Types:
You can add to the mimeTypes has to serve more file types.

Virtual Directories:
Add to the virtualDirectories hash if you have resources that are not children of the root directory

*/
var http = require("http"),
    url = require("url"),
    path = require("path"),
    fs = require("fs")
    port = process.argv[2] || 8888;

var mimeTypes = {
    "htm": "text/html",
    "html": "text/html",
    "jpeg": "image/jpeg",
    "jpg": "image/jpeg",
    "png": "image/png",
    "gif": "image/gif",
    "js": "text/javascript",
    "css": "text/css",
    "json":"text/json"
  };

var virtualDirectories = {
    //"images": "../images/"
  };

http.createServer(function(request, response) {

  var uri = url.parse(request.url).pathname
    , filename = path.join(process.cwd(), uri)
    , root = uri.split("/")[1]
    , virtualDirectory;
  
  virtualDirectory = virtualDirectories[root];
  if(virtualDirectory){
    uri = uri.slice(root.length + 1, uri.length);
    filename = path.join(virtualDirectory ,uri);
  }

  fs.exists(filename, function(exists) {
    if(!exists) {
      response.writeHead(404, {"Content-Type": "text/plain"});
      response.write("404 Not Found\n");
      response.end();
      console.error('404: ' + filename);
      return;
    }

	if (fs.statSync(filename).isDirectory()) filename += '/index.html';

    fs.readFile(filename, "binary", function(err, file) {
      if(err) {        
        response.writeHead(500, {"Content-Type": "text/plain"});
        response.write(err + "\n");
        response.end();
        console.error('500: ' + filename);
        return;
      }

      var mimeType = mimeTypes[path.extname(filename).split(".")[1]];
      response.writeHead(200, {"Content-Type": mimeType});
      response.write(file, "binary");
      response.end();
      console.log('200: ' + filename + ' as ' + mimeType);
    });
  });
}).listen(parseInt(port, 10));

console.log("Static file server running at\n  => http://localhost:" + port + "/\nCTRL + C to shutdown");

data01.json和data02.json示例

{"name":"张三"}  {"name":"李思"}

使用node server.js

新增数组操作方法

map() 方法
map方法可以分别处理数组中的成员,返回一个新数组,也可以用于遍历数组

let aList = [1,2,3];

aList.map(function(a){
    alert(a);
})

//  弹出 1  2   3

concat() 方法

concat() 方法用于连接新的数组成员或者其他数组,返回一个新的数组文章来源地址https://www.toymoban.com/news/detail-714617.html

let aList01 = [1,2,3];
let aList02 = ['a','b'];
let aList03 = arr.concat(4,5);
let aList04 = aList01.concat(aList02);

console.log(aList03) // [1,2,3,4,5]
console.log(aList04) // [1,2,3,'a','b']

示例

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

    <script>
        var aList = ['a','b','c'];
        //第一个参数数组成员值,第二个参数是成员的索引值
        aList.map((item,i)=>{
            console.log(item+" | "+i);
        })

        //concat会返回一个新的数组
        var aList2 = aList.concat('d','f');
        var aList3 = [1,2];

        var aList4 = aList.concat(aList3);

        console.log(aList2);
        console.log(aList4);
    </script>
</head>
<body>
    
</body>
</html>

到了这里,关于ES语法以及ajax相关操作的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • ElasticSearch进阶:多种查询操作,各种ES查询以及在Java中的实现

    目录 前言 1 词条查询 1.1 等值查询-term 1.2 多值查询-terms 1.3 范围查询-range 1.4 前缀查询-prefix 1.5 通配符查询-wildcard 2 复合查询 2.1 布尔查询 2.2 Filter查询 3 聚合查询 3.1 最值、平均值、求和 3.2 去重查询 3.3 分组聚合 3.3.1 单条件分组 3.3.2 多条件分组 3.4 过滤聚合 ElasticSearch 第一篇

    2024年02月02日
    浏览(50)
  • 原生语言操作和spring data中RestHighLevelClient操作Elasticsearch,索引,文档的基本操作,es的高级查询.查询结果处理. 数据聚合.相关性系数打分

    ​ Elasticsearch 是一个分布式、高扩展、高实时的搜索与数据分析引擎。它能很方便的使大量数据具有搜索、分析和探索的能力。充分利用Elasticsearch的水平伸缩性,能使数据在生产环境变得更有价值。Elasticsearch 的实现原理主要分为以下几个步骤,首先用户将数据提交到Elasti

    2024年02月05日
    浏览(80)
  • 前端同步异步讲解--Ajax(axios进阶)的相关操作

    之前我们讲到了数据在前后端传输是依赖xml文件,但是由于时代变迁,他也已经比逐步淘汰,json对象就逐步开始作为数据传输通道的桥梁,忘记的话可以去回顾文章对应的json对象 最全的前端知识之css与jsp介绍-CSDN博客 文章浏览阅读1k次,点赞31次,收藏21次。ok了,宝子们,

    2024年02月21日
    浏览(64)
  • 【ES专题】ElasticSearch 高级查询语法Query DSL实战

    个人在学习的过程中,感觉比较吃力的地方有如下: 语法结构比较陌生 没有中文文档, 只能看英文 其他博客也比较少介绍语法结构。比如说,为什么查询中会出现 query 有ES入门基础,且想进一步学习ES基本操作的朋友 系列上一篇文章:《【ES专题】ElasticSearch快速入

    2024年02月06日
    浏览(49)
  • es的语法操作命令

    ES提供了一个highlight属性,和query同级别的 fragment_size :指定高亮数据展示多少个字符回来; pre_tag:指定前缀标签,如 font color=“red” post_tags:指定后缀标签,如 /font field:指定那个字段为高亮字段 聚合:相当于mysql 中的sum(求和) text:会分词,不支持聚合 keyword:不会分

    2023年04月08日
    浏览(47)
  • 【python 基础语法二】流程语法及字符串相关操作

    以冒号作为开始,用缩进来划分相同的作用域,这个整体是一个代码块 作用域:作用的区域 流程: 代码执行的过程 控制: 对代码执行过程中的把控 三大结构: 顺序结构: 默认代码从上到下,依次执行 分支结构: 单项分支、 双向分支、 多项分支、 巢状分支 循环结构: while / for 内置

    2023年04月26日
    浏览(90)
  • Vue 3 的概述以及 ES 6 基本语法的介绍

    本章首先介绍前端架构模式,然后在此基础上介绍 Vue 及其安装方式,接着介绍 Vue 3的新特性,最后介绍 ECMAScript6 (简称ES 6)的语法。 在学习 Vue.js之前,我们先来了解一下 MVVM (Model-View-ViewModel, 模型-视图-视图模型)模式,它是一种基于前端开发的架构模式。MVVM 最早出现于

    2024年03月22日
    浏览(39)
  • ES鉴权设计以及相关探讨

    鉴权,分别由 鉴 和 权 组成 鉴 : 表示身份认证,认证相关用户是否存在以及相关的用户名和密码是否一致 权 : 完成身份的 鉴 后,还需要判断用户是否有相关操作的权限。 因此对于某一个用户来说,通常情况下,需要完成 鉴 和 权 才能够满足一个完整的业务场景,因此

    2024年02月20日
    浏览(30)
  • 写代码,编译代码,执行代码以及相关的java的基础语法

    在黑窗口 输入javac 文件名字 在黑窗口 输入java 文件.class名字 我们可以把常说的bug说成甲虫,因为bug就是从甲虫来的 黑窗口一般报了这个错误代表的是英文符号的写成中文的 说明你的程序包对象写的并不对,一般大小写出现错误导致,比如System写成system 用Notepad软件可以发现

    2024年02月11日
    浏览(38)
  • ES基本查询语法_Kibana操作(持续更新)

    1. ES查询索引下所有的数据 2. ES单字段精确查询 3. ES多字段精确查询(默认Kibana查询最多展示10条记录,可以通过设置size来展示更多匹配到的数据) 4. ES数组字段精确查询 5. ES日期范围查询(大写HH表示24小时制) 6. 查询ES索引下的数据量 7. 查询ES索引下的mapping关系 7. 查询E

    2024年02月11日
    浏览(64)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包