精华内容
下载资源
问答
  • js基本数据类型和复杂数据类型的区别为: let b = { age: 10 } let a = b; a.age = 20; console.log(a); //{ age: 20 } //基本数据类型 let b = 10 function change(info) { info=20; } //info=b;基本数据类型...

    js基本数据类型和复杂数据类型的区别为:
    在这里插入图片描述

    let b = {
        age: 10
    }
    
    let a = b;
    a.age = 20;
    console.log(a); //{ age: 20 }
    

    在这里插入图片描述

    //基本数据类型
    let b = 10
    
    function change(info) {
        info=20;
    }
    //info=b;基本数据类型,拷贝的是值得副本,二者互不干扰
    change(b);
    console.log(b);//10
    

    复杂类型:

    //复杂数据类型
    let b = {
        age: 10
    }
    
    function change(info) {
        info.age = 20;
    }
    //info=b;根据第三条差异,可以看出,拷贝的是地址的引用,修改互相影响。
    change(b);
    console.log(b);//{ age: 20 }
    
    展开全文
  • Hive复杂数据类型使用

    千次阅读 2019-02-12 15:54:01
    Hive复杂数据类型有Array、Map、Struct三种。下面介绍这三种复杂数据类型的使用方法。 1 Array类型 创建数据库 创建数据库 表,以 Array做为数据类型    查询数据库表  查询person表 array数据类型字段...

    Hive复杂数据类型有Array、Map、Struct三种。下面介绍这三种复杂数据类型的使用方法。

    1 Array类型

    创建数据库 创建数据库 表,以 Array做为数据类型

     

     查询数据库表

     查询person表 array数据类型字段指定列。

    查询array数据类型字段的长度。

    查询array数据类型字段指定列的一行数据。

    查看表结构


    Map类型

    创建数据库表

     查看表结构

    在本地创建score.txt文件,并将内容导入到 score表中 。

     查询score 表的所有数据。

    查询所有的语文,英语成绩。


    3 Struct类型

    创建数据库表

    本地新建文件sc.txt,并将文件导入到 sc 表中

    查询 sc 表的所有数据

    查询 SC 表的学生名称和选课。 

    查询 SC 表所有学生英语课成绩。

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • ElasticSearch学习笔记之九 复杂数据类型和嵌套对象复杂数据类型空域数组域多层级对象内部对象的映射内部对象的索引内部对象数组嵌套对象嵌套对象映射 复杂数据类型 除了前面说到的简单数据类型,Elasticsearch还...

    复杂数据类型

    除了前面说到的简单数据类型,Elasticsearch还支持JSON 的null ,数组,和对象.

    空域

    字段取值可以为空,当然,数组也可以为空。 然而,在 Lucene 中是不能存储 null 值的,所以我们认为存在 null 值的域为空域。

    下面三种域被认为是空的,它们将不会被索引:

    "null_value":               null,
    "empty_array":              [],
    "array_with_null_value":    [ null ]
    

    数组域

    很多时候,我们希望 tag 域 包含多个标签。我们可以以数组的形式索引标签:

    { "tag": [ "search", "nosql" ]}
    

    对于数组,没有特殊的映射需求。任何域都可以包含0、1或者多个值,就像全文域分析得到多个词条。

    这暗示 数组中所有的值必须是相同数据类型的 。你不能将日期和字符串混在一起。如果你通过索引数组来创建新的域,Elasticsearch 会用数组中第一个值的数据类型作为这个域的 类型 。

    注意:
    当你从 Elasticsearch 得到一个文档,每个数组的顺序和你当初索引文档时一样。你得到的 _source 域,包含与你索引的一模一样的 JSON 文档。

    但是,数组是以多值域 索引的—可以搜索,但是无序的。 在搜索的时候,你不能指定 “第一个” 或者 “最后一个”。 更确切的说,把数组想象成 装在袋子里的值 。

    多层级对象

    内部对象 经常用于嵌入一个实体或对象到其它对象中。例如,与其在 tweet 文档中包含 user_name 和 user_id 域,我们也可以这样写:

    {
        "tweet":            "Elasticsearch is very flexible",
        "user": {
            "id":           "@johnsmith",
            "gender":       "male",
            "age":          26,
            "name": {
                "full":     "John Smith",
                "first":    "John",
                "last":     "Smith"
            }
        }
    }
    

    内部对象的映射

    Elasticsearch 会动态监测新的对象域并映射它们为 对象 ,在 Elasticsearch 6之前properties 属性下列出内部域:

    {
      "gb": {
        "tweet": 
          "properties": {
            "tweet":            { "type": "string" },
            "user": {
              "type":             "object",
              "properties": {
                "id":           { "type": "string" },
                "gender":       { "type": "string" },
                "age":          { "type": "long"   },
                "name":   { 
                  "type":         "object",
                  "properties": {
                    "full":     { "type": "string" },
                    "first":    { "type": "string" },
                    "last":     { "type": "string" }
                  }
                }
              }
            }
          }
        }
      }
    }
    

    user 和 name 域的映射结构与 tweet 类型的相同。事实上, type 映射只是一种特殊的 对象 映射,我们称之为 根对象 。除了它有一些文档元数据的特殊顶级域,例如 _source 和 _all 域,它和其他对象一样。

    注:
    elasticsearch6以后没有object类型了,默认嵌套处理了。elasticsearch6以后映射查询结果如下:

    {
      "test": {
        "mappings": {
          "test": {
            "properties": {
              "tweet": {
                "type": "text",
                "fields": {
                  "keyword": {
                    "type": "keyword",
                    "ignore_above": 256
                  }
                }
              },
              "user": {
                "properties": {
                  "age": {
                    "type": "long"
                  },
                  "gender": {
                    "type": "text",
                    "fields": {
                      "keyword": {
                        "type": "keyword",
                        "ignore_above": 256
                      }
                    }
                  },
                  "id": {
                    "type": "text",
                    "fields": {
                      "keyword": {
                        "type": "keyword",
                        "ignore_above": 256
                      }
                    }
                  },
                  "name": {
                    "properties": {
                      "first": {
                        "type": "text",
                        "fields": {
                          "keyword": {
                            "type": "keyword",
                            "ignore_above": 256
                          }
                        }
                      },
                      "full": {
                        "type": "text",
                        "fields": {
                          "keyword": {
                            "type": "keyword",
                            "ignore_above": 256
                          }
                        }
                      },
                      "last": {
                        "type": "text",
                        "fields": {
                          "keyword": {
                            "type": "keyword",
                            "ignore_above": 256
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
    

    内部对象的索引

    Lucene 不支持内部对象。 Lucene 文档是由一组键值对列表组成的。为了能让 Elasticsearch 有效地索引内部类,它把我们的文档转化成这样:

    {
        "tweet":            [elasticsearch, flexible, very],
        "user.id":          [@johnsmith],
        "user.gender":      [male],
        "user.age":         [26],
        "user.name.full":   [john, smith],
        "user.name.first":  [john],
        "user.name.last":   [smith]
    }
    

    内部域 可以通过名称引用(例如, first )。为了区分同名的两个域,我们可以使用全 路径 (例如, user.name.first ) 或 type 名加路径( tweet.user.name.first )。

    在前面简单扁平的文档中,没有 user 和 user.name 域。Lucene 索引只有标量和简单值,没有复杂数据结构。

    内部对象数组

    假设我们有个 followers 内部对象数组:

    {
        "followers": [
            { "age": 35, "name": "Mary White"},
            { "age": 26, "name": "Alex Jones"},
            { "age": 19, "name": "Lisa Smith"}
        ]
    }
    

    这个文档会像我们之前描述的那样被扁平化处理,结果如下所示:

    {
        "followers.age":    [19, 26, 35],
        "followers.name":   [alex, jones, lisa, smith, mary, white]
    }
    

    但是这里有一个问题,{age: 35}{name: Mary White}之间的相关性已经丢失了,因为每个多值域只是一包无序的值,而不是有序数组。这足以让我们问,“有一个26岁的追随者?”

    但是我们不能得到一个准确的答案:“是否有一个26岁 名字叫 Alex Jones 的追随者?”

    嵌套对象

    考虑到上面内部对象数组的问题,我们看下面的例子:

    由于在 Elasticsearch 中单个文档的增删改都是原子性操作,那么将相关实体数据都存储在同一文档中也就理所当然。 比如说,我们可以将订单及其明细数据存储在一个文档中。又比如,我们可以将一篇博客文章的评论以一个 comments 数组的形式和博客文章放在一起:

    PUT /my_index/blogpost/1
    {
      "title": "Nest eggs",
      "body":  "Making your money work...",
      "tags":  [ "cash", "shares" ],
      "comments": [ 
        {
          "name":    "John Smith",
          "comment": "Great article",
          "age":     28,
          "stars":   4,
          "date":    "2014-09-01"
        },
        {
          "name":    "Alice White",
          "comment": "More like this please",
          "age":     31,
          "stars":   5,
          "date":    "2014-10-22"
        }
      ]
    }
    

    如果我们依赖字段自动映射,那么 comments 字段会自动映射为 object 类型。

    由于所有的信息都在一个文档中,当我们查询时就没有必要去联合文章和评论文档,查询效率就很高。

    但是当我们使用如下查询时,上面的文档也会被当做是符合条件的结果:

    GET /my_index/blogpost/_search
    {
      "query": {
        "bool": {
          "must": [
            { "match": { "name": "Alice" }},
            { "match": { "age":  28      }} 
          ]
        }
      }
    }
    

    Alice实际是31岁,不是28!
    注:
    elasticsearch6之后的版本没有整个问题,被解决了,6之后的查询结果没有命中,结果如下:

    {
      "took": 0,
      "timed_out": false,
      "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
      },
      "hits": {
        "total": 0,
        "max_score": null,
        "hits": []
      }
    }
    

    正如我们在 对象数组 中讨论的一样,出现上面这种问题的原因是 JSON 格式的文档被处理成如下的扁平式键值对的结构。

    {
      "title":            [ eggs, nest ],
      "body":             [ making, money, work, your ],
      "tags":             [ cash, shares ],
      "comments.name":    [ alice, john, smith, white ],
      "comments.comment": [ article, great, like, more, please, this ],
      "comments.age":     [ 28, 31 ],
      "comments.stars":   [ 4, 5 ],
      "comments.date":    [ 2014-09-01, 2014-10-22 ]
    }
    

    Alice 和 31 、 John 和 2014-09-01 之间的相关性信息不再存在。虽然 object 类型 (参见 内部对象) 在存储 单一对象 时非常有用,但对于对象数组的搜索而言,毫无用处。

    嵌套对象 就是来解决这个问题的。将 comments 字段类型设置为 nested 而不是 object 后,每一个嵌套对象都会被索引为一个 隐藏的独立文档 ,举例如下:

    { #第一个 嵌套文档
      "comments.name":    [ john, smith ],
      "comments.comment": [ article, great ],
      "comments.age":     [ 28 ],
      "comments.stars":   [ 4 ],
      "comments.date":    [ 2014-09-01 ]
    }
    { #第二个 嵌套文档
      "comments.name":    [ alice, white ],
      "comments.comment": [ like, more, please, this ],
      "comments.age":     [ 31 ],
      "comments.stars":   [ 5 ],
      "comments.date":    [ 2014-10-22 ]
    }
    { #根文档 或者也可称为父文档
      "title":            [ eggs, nest ],
      "body":             [ making, money, work, your ],
      "tags":             [ cash, shares ]
    }
    

    在独立索引每一个嵌套对象后,对象中每个字段的相关性得以保留。我们查询时,也仅仅返回那些真正符合条件的文档。

    不仅如此,由于嵌套文档直接存储在文档内部,查询时嵌套文档和根文档联合成本很低,速度和单独存储几乎一样。

    嵌套文档是隐藏存储的,我们不能直接获取。如果要增删改一个嵌套对象,我们必须把整个文档重新索引才可以。值得注意的是,查询的时候返回的是整个文档,而不是嵌套文档本身。

    嵌套对象映射

    设置一个字段为 nested 很简单 —  你只需要将字段类型 object 替换为 nested 即可:

    
    PUT /my_index
    {
      "mappings": {
        "blogpost": {
          "properties": {
            "comments": {
              "type": "nested", 
              "properties": {
                "name":    { "type": "string"  },
                "comment": { "type": "string"  },
                "age":     { "type": "short"   },
                "stars":   { "type": "short"   },
                "date":    { "type": "date"    }
              }
            }
          }
        }
      }
    }
    
    展开全文
  • js复杂数据类型的判断

    千次阅读 2018-10-22 06:43:14
    1.typeof 操作符只能判断简单的数据类型,对应复杂数据类型它就无能为力,如下面判断的数组和对象返回的都是object //undefined number string boolean function symbol console.log(typeof undefined,typeof 1,...

    1.typeof 操作符只能判断简单的数据类型,对应复杂的数据类型它就无能为力,如下面判断的数组和对象返回的都是object

    //undefined number string boolean function symbol
     console.log(typeof undefined,typeof 1,typeof '1',typeof true,typeof function(){}, typeof Symbol());
    
    //object object object object
     console.log(typeof null,typeof [],typeof {},typeof new Date());
    复制代码

    2.instanceof操作符判断复杂的数据类型

     console.log([].constructor == Array); //true
     console.log(function(){}.constructor == Function); //true
     console.log(new Date().constructor == Date); //true
    复制代码

    3.constructor属性判断复杂的数据类型

    console.log([] instanceof Array);//true
    console.log(function(){} instanceof Function); //true
    console.log(new Date() instanceof Date); //true
    复制代码

    4.toString判断复杂的数据类型

     var arr = [];var arr2 = {};var arr3 = new Date();var arr4 = new RegExp();var arr5 = null;
      console.log( Object.prototype.toString.call(arr) == '[object Array]' ); //true
      console.log( Object.prototype.toString.call(arr2) == '[object Object]' ); //true
      console.log( Object.prototype.toString.call(arr3) == '[object Date]' ); //true
      console.log( Object.prototype.toString.call(arr4) == '[object RegExp]' ); //true
      console.log( Object.prototype.toString.call(arr5) == '[object Null]' ); //true
    复制代码

    注:instanceof和constructor在iFrame中穿插使用的时候会出错,toString不会,最好的方法是用toString来判断,如果不在iFrame使用是可以用的。

    这种情况下使用会报错
    var oF = document.createElement('iframe');
     document.body.appendChild( oF );
     var ifArray = window.frames[0].Array;//这个Array是iframe下面的
     var arr = new ifArray();
     console.log( arr.constructor == Array );  //false
     console.log( arr instanceof Array );  //false
     console.log( Object.prototype.toString.call(arr) == '[object Array]' );  //true
    复制代码

    转载于:https://juejin.im/post/5bcd678ae51d457a551a72d6

    展开全文
  • //基本类型 //指的是两个内存 所以n2还是10 var n1 = 10; var n2 = n1; n1 = 20; console.log(n2); //复杂(引用)类型 function Student(name,age,salary) { this.name = name;
  • 本文主要介绍hive中一些较为复杂数据类型,例如array,map,struct等类型
  • 简单数据类型、复杂数据类型

    万次阅读 2020-09-20 17:50:01
    <!... <... <head> ...meta charset="UTF-8">...meta name="viewport" content="width=device-width, initial-scale=1.0">...简单类型/复杂类型</title> <script> //堆和栈 //
  • 基础34 ElasticSearch mapping复杂数据类型以及object类型数据分布式实战(干货)spring cloud 实战(干货)mybatis 实战(干货)spring boot 实战(干货)React 入门实战(干货)构建中小型互联网企业架构(干货)...
  • 简单和复杂数据类型存储和传递: var num1 = 0; var num2 = num1; num1 = 1; //请问num2的值会改变吗? console.log(num2); var stu1 = new Object(); stu1.name = "张三";
  • Hive的复杂数据类型之Array

    千次阅读 2017-05-24 09:21:50
    此链接对Hive的复杂数据类型Array,Map,Struct讲的很详细 Array数组类型:由一系列相同数据类型的元素组成。 举例: 首先创建一个student表,该表中grade的类型是数组类型 注意: fields ...
  • 本来是想在基于豆瓣电影数据进行相关的数据分析项目 中进行相关解释说明的,仔细想了下,刚好拿出来,对hive的三个复杂数据类型做一个总结性的学习 关于Hive的一些其他数据类型使用参考:...
  • vue axios post请求发送复杂数据类型详解 前面会有一些基础的介绍,懂的人可跳过前面的基础介绍直接copy文档末尾的代码 基础介绍开始 一般post不允许发送复杂数据类型,比如object和array,而jquery的ajax封装了...
  • 一、hive 复杂数据类型建表举例1、使用数组的情况hive&gt;create table student(sid int,sname string,grade array&lt;float&gt;);记录内容 {1,'alice',[80,90,90]}2、使用map的情况hive&gt;...
  • JS基本数据类型复杂类型的区别

    千次阅读 2017-04-22 17:48:03
    复杂数据类型在栈中存储数据名和一个堆的地址,在堆中存储属性及值。访问时先从栈获取地址,再到堆中拿出相应的值。 2.不同数据类型作为参数时 函数内部对参数的修改是否改变外部变量的值 (1)基本数据类型作为参数...
  • Hive中复杂数据类型Map常用方法介绍

    万次阅读 2019-01-12 20:58:34
    工作中在清洗数据的时候经常遇到一些map类型数据的清洗、提取等。这边介绍一下我在工作中遇到的问题及相关的解决方法,其实如果知道的话都是挺简单的用法的,但是对于很多不太熟悉Hive Map函数的人来说不知道用法...
  • Hive支持关系型数据库中的大多数基本数据类型,同时支持关系型数据库中很少出现的3种集合数据类型,下面我们将简短地介绍一下这样做的原因。    其中一个需要考虑的因素就是这些数据类型是如何在文本文件中进行...
  • Redis存储结构、数据类型

    千次阅读 2019-09-06 09:55:39
    存储结构: Redis的全称是remote dictionary server(远程字典服务器),它以字典结构存储数据(key-value),并允许... 字符串类型是redis中最基本的数据类型,它能存储任何形式的字符串,包括二进制数据。你可以用它...
  • 简单类型复杂类型的区别

    千次阅读 2019-03-18 14:14:32
    引用类型:复杂数据类型,在存储是,变量中存储的仅仅是地址(引用),因此叫做引用数据类型。 堆和栈: 堆栈空间分配区别:  1、栈(操作系统):由操作系统自动分配释放 ,存放函数的参数值,局部变量的值等。其...
  • Java各种数据类型详细介绍及其区别 基本类型,或者叫做内置类型,是JAVA中不同于类的特殊类型。 Java中的简单类型从概念上分为四种:实数、整数、字符、布尔值。但是有一点需要说明的是,Java里面只有八种原始类型...
  • [yh@centos bin]$ ./elasticsearch
  • Hive支持原始数据类型复杂类型

    千次阅读 2018-06-19 21:19:10
    Hive支持原始数据类型复杂类型,原始类型包括数值型,Boolean,字符串,时间戳。复杂类型包括array,map,struct,union。一,原始数据类型类型名称大小示例TINYINT1字节整数45YSMALLINT2字节整数12SINT4字节整数...
  • 数据结构、数据类型、抽象数据类型之间的区别

    千次阅读 多人点赞 2019-11-03 20:15:37
    数据元素是最基本的数据单位,最基本的数据元素是一个二进制位。) 逻辑结构指反映数据元素之间的逻辑关系的数据结构,其中的逻辑关系是指数据元素之间的前后件关系,而与他们在计算机中的存储位置无关。包括: ...
  • Matlab的数据类型

    万次阅读 多人点赞 2016-01-25 16:31:27
    Matlab在工程中有着非常重要的作用...Matlab的数据类型与我们平常用的编程语言稍有不同,但是语言都是想通的,有了其他语言的编程基础,Matlab上手会很快。 一、数值类型 Matlab的数值类型分为三种,整形,单精度浮点
  • ROS实操入门系列(八)ROS service通讯之自定义复杂srv消息类型解决实际需求(详解)rossrv 命令需求自定义消息编写代码 srv消息 是ROS service通讯节点间传递的内容。srv消息描述的是业务间传递数据,也可以理解为...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,250,243
精华内容 500,097
关键字:

复杂数据类型