json数据结构

来源:http://www.smjxgs.com 作者:4887王中王鉄算盘奖结果 人气:168 发布时间:2019-08-08
摘要:【JAVAWEB学习笔记】28_jqueryAjax:json数据结构、jquery的ajax操作和表单校验插件,javawebjson   Ajax-jqueryAjax     今天内容: 1、json数据结构(重点) 2、jquery的ajax操作(重点) 3、jquery的插件使

【JAVAWEB学习笔记】28_jqueryAjax:json数据结构、jquery的ajax操作和表单校验插件,javawebjson

 

Ajax-jqueryAjax

   

今天内容:

1、json数据结构(重点)

2、jquery的ajax操作(重点)

3、jquery的插件使用

 

一、json数据结构

1、什么是json

  JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。它基于ECMAScript的一个子集。

JSON采用完全独立于语言的文本格式,但是也使用了类似于C语言家族的习惯。这些特性使JSON成

为理想的数据交换语言。易于人阅读和编写,同时也易于机器解析和生成(一般用于提升网络传输速率)。

2、json的数据格式

json的结构有两种结构

第一种:对象结构:

  对象在js中表示为“{}”括起来的内容,数据结构为 {key:value,key:value,...}的键值对的结构,

在面向对象的语言中,key为对象的属性,value为对应的属性值,key的类型为字符串,value的

类型可以是 数字、字符串、数组、对象几种。

示例:描述一个用户

{"id":100,"username":"张三","age":28,"addr":"天津"}

第二种:数组结构:

  数组在js中是中括号“[]”括起来的内容,数据结构为 ["java","javascript","vb",...],取值方式和

所有语言中一样,使用索引获取,字段值的类型可以是 数字、字符串、数组、对象几种。

 

注意:在实际开发中,对象结构和数组结构会相互嵌套,相互包含

 

3、json的转换工具

  在实际的开发中,我j们经常会使用json串作为数据传输的载体,例如浏览器端页面中的js与服务

端的数据交互,android/ios移动端与服务端的数据交互都大量使用json,但发现使用java代码

手动拼接json串是一个很耗时很繁琐的事情,所以一批json的自动转换的工具出现了。即可以自

动的将对象、数组、集合等转换成json串,也可以将一个json串转成对象、数组和集合。

 

常用的转换工具:

jsonlib:是一个java类库,开发时需要导入6个jar包

    commons-beanutils-1.8.3.jar
        commons-collections-3.2.1.jar
        commons-lang-2.6.jar
        commons-logging-1.1.1.jar
        ezmorph-1.0.6.jar
        json-lib-2.4-jdk15.jar

Gson:google的产品 很多企业都在使用

FastJson:阿里巴巴技术团队的产品 号称是最快的json转换工具

 

二、jquery的ajax操作

查询jquery的官方文档发现与ajax相关的jquey方法如下:

$.ajax([options])
    load(url, [data], [callback])
    $.get(url, [data], [fn], [type])
    $.getJSON(url, [data], [fn])
    $.getScript(url, [callback])
    $.post(url, [data], [fn], [type])

 

1、jquery的ajax方法的分类

一般我们会将jquery的ajax方法习惯性的分为三种:

第一种:原始方法

$.ajax([options]) :jquery的ajax最底层的方法,可以认为其他的ajax的操作都是基于此方法的。

第二种:常用方法

load(url, [data], [callback]) :对象调用的方法,可以是get请求也可以是post请求

$.get(url, [data], [fn], [type]) :get提交方式

$.post(url, [data], [fn], [type]) :post提交方式

第三种:高级方法

$.getJSON(url, [data], [fn])

$.getScript(url, [callback])

 

2、jquery的ajax方法的参数

以上的方法的参数大都是重复的,分为如下几个:

url:请求提交的服务器路径  ----  xmlhttp.open("post","url")

data:向服务器端提交的数据  ----xmlhttp.send(data);

callback/fn:ajax请求返回后的回调函数 --- xmlhttp.onreadystatechenge = function(){}

回调函数的参数有三个:

data:返回值

info:执行信息(成功或失败的信息)

xmlhttprequest:ajax引擎对象 

type:返回的数据类型 xml, html, script, json, text, _default ----- xmlhttp.responsTest; 

xmlhttp.responseXML;

options:是一个json格式的参数集合

 

3、load方法

load(url, [data], [callback])

注意点:(1) 此方法是所有ajax操作方法中唯一对象调用的方法,其他都是全局方法

(2) 如果提交时携带了请求参数(json数据格式或key/value字符串),即data部分存在

即为post提交,data部分不存在即为get提交

(3) 在将json转换成json格式对象时的格式是 eval("(" json ")"); 原因是:eval本身

的问题。 由于json是以”{}”的方式来开始以及结束的,在JS中,它会被当成一个语

句块来处理,所以必须强制性的将它转换成一种表达式。

 

 

4、$.get方法

$.get(url, [data], [fn], [type]) :get提交方式

 

 

5、$.post方法

$.post(url, [data], [fn], [type])

与get提交方法相同 只不过的提交方式是post

 

6、$.ajax方法

$.ajax([options])

options是一个json格式的对象,参数是通过键值对的形式存在的

常用的参数如下:

async:(默认: true) 默认设置下,所有请求均为异步请求。如果需要发送同步请求,请将此

选项设置为 false。注意,同步请求将锁住浏览器,用户其它操作必须等待请求完成才可以执行。

data:发送到服务器的数据。将自动转换为请求字符串格式。GET 请求中将附加在 URL 后。

dataType:预期服务器返回的数据类型。如果不指定,jQuery 将自动根据 HTTP 包 MIME

信息来智能判断,比如application/json 会自动认为是json类型

type:提交方式,get提交或post提交

url:提交服务器路径

success:成功后的回调函数

error:失败后的回调函数

 

 

7、表单序列化

  如果想让表单通过ajax异步提交,那么首先我们要通过js获取到每个表单中输入的值,如果表单项

比较多的话,想必又是一件很麻烦,很痛苦的事情,那么我们可以通过jquery的表单序列化的操作

将表单的数据拼接成提交的参数格式 即:name=value&name=value&name=value 或者 json格式对象

例如:表单如下:

 

 

使用serialize方法

js代码:

 

 

打印结果↑↑↑↑↑

 

三、jquery的插件

  网络上有许多成熟的插件共使用者参考,插件就是将jquery实现的常用操作进行封装,封装后的

小框架就可以叫做插件,按照插件的语法去操作可以实现很多复杂的功能,而这些复杂功能的背

后实现我们可以不必懂。

 

表单校验插件

 

导入插件的步骤:

(1) 将jquery的原始文件和插件文件jquery.validate.js导入到工程中

(2) 编写js代码对表单进行验证

 

表单验证的格式:

$("form表单的选择器").validate(json数据格式);  //键值对  键:值({})

json数据格式:

 

{
    rules:{
            表单项name值:校验规则,
            表单项name值:校验规则... ...
      },
      messages:{
            表单项name值:错误提示信息,
            表单项name值:错误提示信息... ...
      }
}

其中:校验规则,可以是一个也可以是多个,如果是多个使用json格式

常用校验规则如下:

 

 

注意:当错误提示信息不按照我们预想的位置显示时,我们可以按照如下方式进行设置

自定义错误显示标签放在我们需要显示的位置,当此表单项验证不通过时会将此
信息自动显示出来,jquery验证插件会自动帮助我们控制它的显示与隐藏

<lable for="html元素name值" class="error"></lable>

如果设置了错误lable标签就不必在messages中设置此表单项错误提示信息了

 

如果预定义的校验规则尚不能满足需求的话可以进行自定义校验规则:

自定义校验规则步骤如下:

(1) 使用$.validator.addMethod("校验规则名称",function(value,element,params)){}

(2) 在rules中通过校验规则名称使用校验规则

(3) 在messages中定义该规则对应的错误提示信息

其中: value是校验组件的value值

element是校验组件的节点对象

params是校验规则的参数

Ajax-jqueryAjax 前几日内容: 1 、 json 数据结构 ( 重视...

json数据格式

参见json数据格式表达。

假使没操作过json数据,提议先看下上边的小说,有利于掌握本文前面包车型客车剧情。

在服务器和客户端的数量交互的时候,要找到一种多少格式,服务端好管理,客户端能够管理,这种数据格式应该是一种统一的正式,不管在何地端管理起来都以统一的,现在这种数据格式相当多,比如最早的xml,再后来比较流行的json。

Go json包

马尔斯hal():Go数据对象 -> json数据
Un马尔斯hal():Json数据 -> Go数据对象

func Marshal(v interface{}) ([]byte, error)func Unmarshal(data []byte, v interface{}) error

JSON是什么

JSON(JavaScript Object Notation, JS 对象标识) 是一种轻量级的数据沟通格式。它依据 ECMAScript (w3c制订的js标准)的一个子集,采取完全部独用立于编制程序语言的文本格式来积累和表示数据。简洁和明显的档案的次序结构使得 JSON 成为美好的数据交流语言。

JSON 比 XML 越来越小、更加快,更易深入分析。

json格式如下:

{
    "sites": [
        {
            "name": "阿猫学编程",
            "url": "www.bugingcode.com"
        },
        {
            "name": "博客园",
            "url": "www.cnblogs.com"
        },
        {
            "name": "cndn",
            "url": "www.csdn.com"
        }
    ]
}

图片 1

构建json数据

马尔斯hal()和马尔斯halIndent()函数能够将数据封装成json数据。

  • struct、slice、array、map都能够转换来json
  • struct调换到json的时候,独有字段首字母大写的才会被撤换
  • map转换的时候,key必须为string
  • 打包的时候,假设是指针,会追踪指针指向的对象进行打包

例如:

有一个struct结构:

type Post struct {    Id      int    Content string    Author  string}

本条组织意味着博客小说类型,有作品ID,作品内容,小说的付出小编。那没怎么可说的,独一需求指明的是:它是贰个struct,struct能够打包成JSON数据

要将这段struct数据转变来json,只需使用马尔斯hal()就可以。如下:

post := &Post{1, "Hello World", "userA"}b, err := json.Marshalif err != nil {    fmt.Println}

马尔斯hal()重返的是三个[]byte花色,未来变量b就早就积攒了一段[]byte品类的json数据,可以输出它:

fmt.Println)

结果:

{"Id":1,"Content":"Hello World","Author":"userA"}

能够在卷入成json的时候进行"美化",使用马尔斯halIndent()就可以自动抬高前缀(前缀字符串一般设置为空)和缩进:

c,err := json.MarshalIndent(post,"","t")if err != nil {    fmt.Println}fmt.Println)

结果:

{    "Id": 1,    "Content": "Hello World",    "Author": "userA"}

除去struct,array、slice、map结构都能剖判成json,不过map解析成json的时候,key必须只可以是string,那是json语法须求的。

例如:

// slice -> jsons := []string{"a", "b", "c"}d, _ := json.MarshalIndent(s, "", "t")fmt.Println)// map -> jsonm := map[string]string{    "a":"aa",    "b":"bb",    "c":"cc",}e,_ := json.MarshalIndent(m,"","t")fmt.Println)

归来结果:

[    "a",    "b",    "c"]{    "a": "aa",    "b": "bb",    "c": "cc"}

python中如何深入分析json

既然json是四个通用的数据沟通格局,那么python中怎样分析json呢?

在python中标准库就会对json字符串进行辨析,同有时候把python的数据结构调换为json格式字符串。

把字符串json剖判为python的数据结构:

#!/usr/bin/python
#coding=utf-8

"""
start python 项目
"""


import json

if __name__ == '__main__':
    jsonstr="""{
    "sites": [
        {
            "name": "阿猫学编程",
            "url": "www.bugingcode.com"
        },
        {
            "name": "博客园",
            "url": "www.cnblogs.com"
        },
        {
            "name": "cndn",
            "url": "www.csdn.com"
        }
    ]
    }"""

    print jsonstr

    sites = json.loads(jsonstr)
    print sites
    print sites['sites']
    for site in sites['sites']:
        print site['name'],site['url']

把python中的数据结构转变为json格式:

#!/usr/bin/python
#coding=utf-8

"""
start python 项目
"""


import json

if __name__ == '__main__':

    sites = {'sites':[{"name": "阿猫学编程","url": "www.bugingcode.com"},{"name": "博客园","url": "www.cnblogs.com"},{"name": "csdn","url": "www.csdn.com"}]}

    jsonstr = json.dumps(sites)

    print jsonstr

更加的多教程:阿猫学编制程序

选取struct tag协理构建json

struct能被撤换的字段都以首字母大写的字段,但一旦想要在json中选取小写字母开始的key,能够使用struct的tag来增派反射。

例如说,Post结构扩张叁个首字母小写的字段createAt。

type Post struct {    Id      int      `json:"ID"`    Content string   `json:"content"`    Author  string   `json:"author"`    Label   []string `json:"label"`}postp := &Post{    2,    "Hello World",    "userB",    []string{"linux", "shell"},    }p, _ := json.MarshalIndent(postp, "", "t")fmt.Println)

结果:

{    "ID": 2,    "content": "Hello World",    "author": "userB",    "label": [        "linux",        "shell"    ]}

动用struct tag的时候,多少个注意点:

  1. tag中标记的称谓将称为json数据中key的值
  2. tag可以设置为`json:"-"`来代表本字段不调换为json数据,尽管那几个字段名首字母大写
    • 假使想要json key的名号为字符"-",则能够特别管理`json:"-,"`,也等于充分一个逗号
  3. 如果tag中带有,omitempty选择,那么一旦那么些字段的值为0值,即false、0、""、nil等,这一个字段将不会调换来json中
  4. 只要字段的连串为bool、string、int类、float类,而tag中又满含,string慎选,那么那一个字段的值将改动到json字符串

例如:

type Post struct {    Id      int      `json:"ID,string"`    Content string   `json:"content"`    Author  string   `json:"author"`    Label   []string `json:"label,omitempty"`}

解析json数据到struct

json数据能够剖析到struct或空中接力口interface{}中(也能够是slice、map等)。精晓了下面营造json时的tag准则,明白深入分析json就不会细小略了。

举个例子,上边是一段json数据:

{    "id": 1,    "content": "hello world",    "author": {        "id": 2,        "name": "userA"    },    "published": true,    "label": [],    "nextPost": null,    "comments": [{            "id": 3,            "content": "good post1",            "author": "userB"        },        {            "id": 4,            "content": "good post2",            "author": "userC"        }    ]}

剖析下这段json数据:

  1. 顶层的大括号表示是三个无名氏对象,映射到Go中是三个struct,假如这么些struct名称叫Post
  2. 顶层大括号里的都以Post结构中的字段,这么些字段因为都以json数据,所以必须都首字母大写,相同的时候设置tag,tag中的名称小写
  3. 里头author是四个子对象,映射到Go中是另叁个struct,在Post中那么些字段的称号为Author,假使名称和struct名称一样,也为Author
  4. label是三个数组,映射到Go中能够是slice,也足以是array,且因为json array为空,所以Go中的slice/array类型不定,譬喻能够是int,能够是string,也足以是interface{},对于这里的示范来讲,大家知晓标签显明是string
  5. nextPost是三个子指标,映射到Go中是一个struct,但因为json中那个指标为null,表示这么些目的不设有,所以不恐怕看清映射到Go中struct的花色。但对这里的示范来讲,是未曾下一篇小说,所以它的档案的次序应该也是Post类型
  6. comment是子对象,且是数组包围的,映射到Go中,是八个slice/array,slice/array的项目是二个struct

浅析以往,对应地去创设struct和struct的tag就很轻松了。如下,是凭借上面深入分析创设出来的数据结构:

type Post struct {    ID        int64         `json:"id"`           Content   string        `json:"content"`      Author    Author        `json:"author"`       Published bool          `json:"published"`    Label     []string      `json:"label"`        NextPost  *Post         `json:"nextPost"`     Comments  []*Comment    `json:"comments"` }type Author struct {    ID   int64  `json:"id"`      Name string `json:"name"`}type Comment struct {    ID      int64  `json:"id"`         Content string `json:"content"`    Author  string `json:"author"` }

注意,前边在介绍创设json数据的时候证实过,指针会进展追踪,所以这里反推出来的struct中利用指针类型是没难题的。

于是,深入分析上面的json数据到Post类型的对象中,即使那个json数据存放在a.json文件中。代码如下:

func main() {    // 打开json文件    fh, err := os.Open("a.json")    if err != nil {        fmt.Println        return    }    defer fh.Close()    // 读取json文件,保存到jsonData中    jsonData, err := ioutil.ReadAll    if err != nil {        fmt.Println        return    }        var post Post    // 解析json数据到post中    err = json.Unmarshal(jsonData, &post)    if err != nil {        fmt.Println        return    }    fmt.Println}

输出结果:

{1 hello world {2 userA} true [] <nil> [0xc042072300 0xc0420723c0]}

恐怕你早就感受到了,从json数据反推算struct到底有多复杂,固然逻辑轻易,但即使数量复杂一点,那是件特别恶心的作业。所以,使用外人写好的工具来机关调换吧。本文前边有推荐json到数据结构的活动转换工具。

解析json到interface

上边是已知json数据结构的解析方法,假诺json结构是雾里看花的只怕协会恐怕会发生变动的动静,则深入分析到struct是不创建的。那时能够分析到空中接力口interface{}map[string]interface{}类型上,那二种等级次序的结果是完全一致的。

解析到interface{}上时,Go类型和JSON类型的呼应关系如下

  JSON类型             Go类型                ---------------------------------------------JSON objects    <-->  map[string]interface{} JSON arrays     <-->  []interface{}          JSON booleans   <-->  bool                   JSON numbers    <-->  float64                JSON strings    <-->  string                 JSON null       <-->  nil                    

例如:

func main() {    // 读取json文件    fh, err := os.Open("a.json")    if err != nil {        fmt.Println        return    }    defer fh.Close()    jsonData, err := ioutil.ReadAll    if err != nil {        fmt.Println        return    }        // 定义空接口接收解析后的json数据    var unknown interface{}    // 或:map[string]interface{} 结果是完全一样的    err = json.Unmarshal(jsonData, &unknown)    if err != nil {        fmt.Println        return    }    fmt.Println}

输出结果:

map[nextPost:<nil> comments:[map[id:3 content:good post1author:userB] map[id:4 content:good post2 author:userC]]id:1 content:hello world author:map[id:2 name:userA] published:true label:[]]

地点将出口map结构。那是分明的,因为品种对应关系中曾经证实了,json object深入分析到Go interface的时候,对应的是map结构。如若将方面输出的布局实行一下格式化,获得的将是近似上边包车型地铁结构:

map[    nextPost:<nil>    comments:[        map[            id:3            content:good post1            author:userB        ]        map[            id:4            content:good post2            author:userC        ]    ]    id:1    content:hello world    author:map[        id:2        name:userA    ]    published:true    label:[]]

今昔,能够从那个map中去看清项目、取得相应的值。可是怎么决断项目?可以利用项目断言:

func main() {    // 读取json数据    fh, err := os.Open("a.json")    if err != nil {        fmt.Println        return    }    defer fh.Close()    jsonData, err := ioutil.ReadAll    if err != nil {        fmt.Println        return    }        // 解析json数据到interface{}    var unknown interface{}    err = json.Unmarshal(jsonData, &unknown)    if err != nil {        fmt.Println        return    }    // 进行断言,并switch匹配    m := unknown.(map[string]interface{})    for k, v := range m {        switch vv := v. {        case string:            fmt.Println(k, "type: stringnvalue: ", vv)            fmt.Println("------------------")        case float64:            fmt.Println(k, "type: float64nvalue: ", vv)            fmt.Println("------------------")        case bool:            fmt.Println(k, "type: boolnvalue: ", vv)            fmt.Println("------------------")        case map[string]interface{}:            fmt.Println(k, "type: map[string]interface{}nvalue: ", vv)            for i, j := range vv {                fmt.Println(i,": ",j)            }            fmt.Println("------------------")        case []interface{}:            fmt.Println(k, "type: []interface{}nvalue: ", vv)            for key, value := range vv {                fmt.Println(key, ": ", value)            }            fmt.Println("------------------")        default:            fmt.Println(k, "type: nilnvalue: ", vv)            fmt.Println("------------------")        }    }}

结果如下:

comments type: []interface{}value:  [map[id:3 content:good post1 author:userB] map[author:userC id:4 content:good post2]]0 :  map[id:3 content:good post1 author:userB]1 :  map[id:4 content:good post2 author:userC]------------------id type: float64value:  1------------------content type: stringvalue:  hello world------------------author type: map[string]interface{}value:  map[id:2 name:userA]name :  userAid :  2------------------published type: boolvalue:  true------------------label type: []interface{}value:  []------------------nextPost type: nilvalue:  <nil>------------------

足见,从interface中剖判特别复杂,並且或者因为嵌套结构而导致爱莫能助正确迭代遍历。那时候,能够应用第三方包simplejson,见后文。

解析、创建json流

除此之外能够一向深入分析、创立json数据,还能拍卖流式数据。

  • type Decoder解码json到Go数据协会
  • type Encoder编码Go数据协会到json

例如:

const jsonStream = `    {"Name": "Ed", "Text": "Knock knock."}    {"Name": "Sam", "Text": "Who's there?"}    {"Name": "Ed", "Text": "Go fmt."}    {"Name": "Sam", "Text": "Go fmt who?"}    {"Name": "Ed", "Text": "Go fmt yourself!"}`type Message struct {    Name, Text string}dec := json.NewDecoder(strings.NewReader(jsonStream))for {    var m Message    if err := dec.Decode; err == io.EOF {        break    } else if err != nil {        log.Fatal    }    fmt.Printf("%s: %sn", m.Name, m.Text)}

输出:

Ed: Knock knock.Sam: Who's there?Ed: Go fmt.Sam: Go fmt who?Ed: Go fmt yourself!

再举例,从行业内部输入读json数据,解码后删除名称叫Name的因素,最终重复编码后输出到专门的职业输出。

func main() {    dec := json.NewDecoder    enc := json.NewEncoder(os.Stdout)    for {        var v map[string]interface{}        if err := dec.Decode; err != nil {            log.Println            return        }        for k := range v {            if k != "Name" {                delete            }        }        if err := enc.Encode; err != nil {            log.Println        }    }}

json转Go数据结构工具推荐

quicktype工具,能够轻便地将json文件转换来各个语言对应的数据结构。

地址:

在vscode中有连锁插件

  1. 先在命令面板中输入"set quicktype target language"选取要将json转换到什么语言的数据结构
  2. 再输入"open quicktype for json"就能够将前段时间json文件调换对应的数据结构

调换后只需按实际上的须求稍微修改一有个别品种就可以。譬如为json顶尖无名对象对应的struct设定名称,还也是有一部分不可能调换到struct时因为判别数据类型而利用的interface{}类型也要改一改。

举例说,上边是接纳quicktype工具对近来示例json数据开始展览转移后的数据结构:

type A struct {    ID        int64         `json:"id"`           Content   string        `json:"content"`      Author    Author        `json:"author"`       Published bool          `json:"published"`    Label     []interface{} `json:"label"`        NextPost  interface{}   `json:"nextPost"`     Comments  []Comment     `json:"comments"` }type Author struct {    ID   int64  `json:"id"`      Name string `json:"name"`}type Comment struct {    ID      int64  `json:"id"`         Content string `json:"content"`    Author  string `json:"author"` }

中间要求将type A struct的A改成你协和的称呼,将A中的interface{}也改成合理的类型。

本文由4887王中王鉄算盘奖结果发布于4887王中王鉄算盘奖结果,转载请注明出处:json数据结构

关键词:

上一篇:没有了

下一篇:没有了

最火资讯