精华内容
下载资源
问答
  • 下面以一道题为切入点: ...解析:Python中的数据类型包括: number(包括int,float,bool,complex)、string、tuple、list、dict、set。 不可变类型:number、string、tuple 可变类型:list、dict、set...

    下面以一道题为切入点:
    下面哪个是python中不变的数据结构?
    A.set B.list C.tuple D.dict
    答案:tuple
    解析:Python中的数据类型包括:
    number(包括int,float,bool,complex)、string、tuple、list、dict、set。
    不可变类型:number、string、tuple
    可变类型:list、dict、set。

    理解:

    1. 不可变类型:

      这些类型的数据一旦经过初始化创建成功,对应内存地址上的数据本身不能发生任何变化。
      例如,string、tuple、number创建之后,不支持修改。
      string:不能通过索引修改字符串中值。
      tuple:也是不可变的类型。
      如果a = “123”,如果再次对变量进行赋值,那么变量a的地址就会发生变化。即,不是原来的变量。

    2.可变类型
    这些类型的数据经过初始化创建成功后,对应内存地址上的数据可以发生多次局部变化。
    例如,字典,可以通过键对字典的对应的值进行修改。修改之后该字典的内存地址不变。

    展开全文
  • java中可变类型和不可变类型

    千次阅读 2011-07-07 00:20:54
    可变类和不可变类(Mutable and Immutable Objects)的初步定义: 可变类:当你获得这个类的一个实例引用时,你可以改变这个实例的内容。 不可变类:当你获得这个类的一个实例引用时,你不可以改变这个实例的内容。...
    1. 可变类和不可变类(Mutable and Immutable Objects)的初步定义:
      可变类:当你获得这个类的一个实例引用时,你可以改变这个实例的内容。
      不可变类:当你获得这个类的一个实例引用时,你不可以改变这个实例的内容。不可变类的实例一但创建,其内在成员变量的值就不能被修改。
    2. 如何创建一个自己的不可变类:
      .所有成员都是private
      .不提供对成员的改变方法,例如:setXXXX
      .确保所有的方法不会被重载。手段有两种:使用final Class(强不可变类),或者将所有类方法加上final(弱不可变类)。
      .如果某一个类成员不是原始变量(primitive)或者不可变类,必须通过在成员初始化(in)或者get方法(out)时通过深度clone方法,来确保类的不可变。
    3. 一个示例

    【这个例子中,为了实现不可变类,传入参数的时候,都使用“保护性拷贝”方法将传入参数拷贝一遍,防止恶意代码在传入参数之后,在外部修改不可变类的内容】 

    import java.util.Date;                                          
     public final class BrokenPerson                                
     {                                                              
      private String firstName;                                    
      private String lastName;                                     
      private Date dob;                                            
                                             
      public BrokenPerson( String firstName,                   public BetterPerson( String firstName,
        String lastName, Date dob)                                             String lastName, Date dob)          
      {                                                                                      {                                     
       this.firstName = firstName;                                             this.firstName = firstName;         
       this.lastName = lastName;                                             this.lastName = lastName;           
       this.dob = dob;     //error               this.dob = new Date( dob.getTime() ); //correct
      }                                                                                       }                                      
                                                                 
      public String getFirstName()
      {
       return this.firstName;
      }
      public String getLastName()
      {
       return this.lastName;
      }
      public Date getDOB()                                               public Date getDOB()                     
      {                                                                                    {                                      
       return this.dob;    //error                                         return new Date( this.dob.getTime() );//correct
      }                                                                                     }                                      
     }
      4. jdk的可变类和不可变类

    primitive变量: boolean,byte, char, double ,float, integer, long, short
    jdk的不可变类:jdk的java.lang包中 Boolean, Byte, Character, Double, Float, Integer, Long, Short, String.
     
      StringBuffer 可变类
      java.util.Date 可变类


           对于这个系列里的问题,每个学Java的人都应该搞懂。当然,如果只是学Java玩玩就无所谓了。如果你认为自己已经超越初学者了,却不很懂这些问题,请将你自己重归初学者行列。内容均来自于CSDN的经典老贴。

           问题一:我声明了什么!

           String s = "Hello world!";

           许多人都做过这样的事情,但是,我们到底声明了什么?回答通常是:一个String,内容是“Hello world!”。这样模糊的回答通常是概念不清的根源。如果要准确的回答,一半的人大概会回答错误。
           这个语句声明的是一个指向对象的引用,名为“s”,可以指向类型为String的任何对象,目前指向"Hello world!"这个String类型的对象。这就是真正发生的事情。我们并没有声明一个String对象,我们只是声明了一个只能指向String对象的引用变量。所以,如果在刚才那句语句后面,如果再运行一句:

           String string = s;

           我们是声明了另外一个只能指向String对象的引用,名为string,并没有第二个对象产生,string还是指向原来那个对象,也就是,和s指向同一个对象。

           问题二:"=="和equals方法究竟有什么区别?

           ==操作符专门用来比较变量的值是否相等。比较好理解的一点是:
           int a=10;
           int b=10;
           则a==b将是true。
           但不好理解的地方是:
           String a=new String("foo");
           String b=new String("foo");
           则a==b将返回false。

           根据前一帖说过,对象变量其实是一个引用,它们的值是指向对象所在的内存地址,而不是对象本身。a和b都使用了new操作符,意味着将在内存中产生两个内容为"foo"的字符串,既然是“两个”,它们自然位于不同的内存地址。a和b的值其实是两个不同的内存地址的值,所以使用"=="操作符,结果会是false。诚然,a和b所指的对象,它们的内容都是"foo",应该是“相等”,但是==操作符并不涉及到对象内容的比较。
           对象内容的比较,正是equals方法做的事。

           看一下Object对象的equals方法是如何实现的:
           boolean equals(Object o){
                  return this==o;
           }
           Object对象默认使用了==操作符。所以如果你自创的类没有覆盖equals方法,那你的类使用equals和使用==会得到同样的结果。同样也可以看出,Object的equals方法没有达到equals方法应该达到的目标:比较两个对象内容是否相等。因为答案应该由类的创建者决定,所以Object把这个任务留给了类的创建者。

           看一下一个极端的类:
    Class Monster{
    private String content;
    ...
    boolean equals(Object another){ return true;}
    ...
    }
           我覆盖了equals方法。这个实现会导致无论Monster实例内容如何,它们之间的比较永远返回true。
           所以当你是用equals方法判断对象的内容是否相等,请不要想当然。因为可能你认为相等,而这个类的作者不这样认为,而类的equals方法的实现是由他掌握的。如果你需要使用equals方法,或者使用任何基于散列码的集合(HashSet,HashMap,HashTable),请察看一下java doc以确认这个类的equals逻辑是如何实现的。

           问题三:String到底变了没有?

           没有。因为String被设计成不可变(immutable)类,所以它的所有对象都是不可变对象。请看下列代码:

           String s = "Hello";
           s = s + " world!";

           s所指向的对象是否改变了呢?从本系列第一篇的结论很容易导出这个结论。我们来看看发生了什么事情。在这段代码中,s原先指向一个String对象,内容是"Hello",然后我们对s进行了+操作,那么s所指向的那个对象是否发生了改变呢?答案是没有。这时,s不指向原来那个对象了,而指向了另一个String对象,内容为"Hello world!",原来那个对象还存在于内存之中,只是s这个引用变量不再指向它了。
           通过上面的说明,我们很容易导出另一个结论,如果经常对字符串进行各种各样的修改,或者说,不可预见的修改,那么使用String来代表字符串的话会引起很大的内存开销。因为String对象建立之后不能再改变,所以对于每一个不同的字符串,都需要一个String对象来表示。这时,应该考虑使用StringBuffer类,它允许修改,而不是每个不同的字符串都要生成一个新的对象。并且,这两种类的对象转换十分容易。
           同时,我们还可以知道,如果要使用内容相同的字符串,不必每次都new一个String。例如我们要在构造器中对一个名叫s的       String引用变量进行初始化,把它设置为初始值,应当这样做:
           public class Demo {
      private String s;
      ...
      public Demo {
        s = "Initial Value";
      }
      ...
    }
           而非
           s = new String("Initial Value");
           后者每次都会调用构造器,生成新对象,性能低下且内存开销大,并且没有意义,因为String对象不可改变,所以对于内容相同的字符串,只要一个String对象来表示就可以了。也就说,多次调用上面的构造器创建多个对象,他们的String类型属性s都指向同一个对象。
           上面的结论还基于这样一个事实:对于字符串常量,如果内容相同,Java认为它们代表同一个String对象。而用关键字new调用构造器,总是会创建一个新的对象,无论内容是否相同。
           至于为什么要把String类设计成不可变类,是它的用途决定的。其实不只String,很多Java标准类库中的类都是不可变的。在开发一个系统的时候,我们有时候也需要设计不可变类,来传递一组相关的值,这也是面向对象思想的体现。不可变类有一些优点,比如因为它的对象是只读的,所以多线程并发访问也不会有任何问题。当然也有一些缺点,比如每个不同的状态都要一个对象来代表,可能会造成性能上的问题。所以Java标准类库还提供了一个可变版本,即StringBuffer。

           问题四:final关键字到底修饰了什么?

           final使得被修饰的变量"不变",但是由于对象型变量的本质是“引用”,使得“不变”也有了两种含义:引用本身的不变,和引用指向的对象不变。

           引用本身的不变:
           final StringBuffer a=new StringBuffer("immutable");
           final StringBuffer b=new StringBuffer("not immutable");
           a=b;//编译期错误

           引用指向的对象不变:【就目前我所知道的java语言特性来看,java好像没有实现c++中const关键字的功能,虽然在java语言中const也是一个保留字。如果读者想实现const的功能,可以自己实现上面提到的“不可变类型”,来模拟const】
           final StringBuffer a=new StringBuffer("immutable");
           a.append(" broken!"); //编译通过

           可见,final只对引用的“值”(也即它所指向的那个对象的内存地址)有效,它迫使引用只能指向初始指向的那个对象,改变它的指向会导致编译期错误。至于它所指向的对象的变化,final是不负责的。

           理解final问题有很重要的含义。许多程序漏洞都基于此----final只能保证引用永远指向固定对象,不能保证那个对象的状态不变。在多线程的操作中,一个对象会被多个线程共享或修改,一个线程对对象无意识的修改可能会导致另一个使用此对象的线程崩溃。一个错误的解决方法就是在此对象新建的时候把它声明为final,意图使得它“永远不变”。其实那是徒劳的。

           问题五:到底要怎么样初始化!

    本问题讨论变量的初始化,所以先来看一下Java中有哪些种类的变量。
    1. 类的属性,或者叫值域
    2. 方法里的局部变量
    3. 方法的参数

           对于第一种变量,Java虚拟机会自动进行初始化。如果给出了初始值,则初始化为该初始值。如果没有给出,则把它初始化为该类型变量的默认初始值。

    int类型变量默认初始值为0
    float类型变量默认初始值为0.0f
    double类型变量默认初始值为0.0
    boolean类型变量默认初始值为false
    char类型变量默认初始值为0(ASCII码)
    long类型变量默认初始值为0
            所有对象引用类型变量默认初始值为null,即不指向任何对象。注意数组本身也是对象,所以没有初始化的数组引用在自动初始化后其值也是null。

           对于两种不同的类属性,static属性与instance属性,初始化的时机是不同的。instance属性在创建实例的时候初始化,static属性在类加载,也就是第一次用到这个类的时候初始化,对于后来的实例的创建,不再次进行初始化。这个问题会在以后的系列中进行详细讨论。

           对于第二种变量,必须明确地进行初始化。如果再没有初始化之前就试图使用它,编译器会抗议。如果初始化的语句在try块中或if块中,也必须要让它在第一次使用前一定能够得到赋值。也就是说,把初始化语句放在只有if块的条件判断语句中编译器也会抗议,因为执行的时候可能不符合if后面的判断条件,如此一来初始化语句就不会被执行了,这就违反了局部变量使用前必须初始化的规定。但如果在else块中也有初始化语句,就可以通过编译,因为无论如何,总有至少一条初始化语句会被执行,不会发生使用前未被初始化的事情。对于try-catch也是一样,如果只有在try块里才有初始化语句,编译部通过。如果在catch或finally里也有,则可以通过编译。总之,要保证局部变量在使用之前一定被初始化了。所以,一个好的做法是在声明他们的时候就初始化他们,如果不知道要出事化成什么值好,就用上面的默认值吧!

           其实第三种变量和第二种本质上是一样的,都是方法中的局部变量。只不过作为参数,肯定是被初始化过的,传入的值就是初始值,所以不需要初始化。

           问题六:instanceof是什么东东?

           instanceof是Java的一个二元操作符,和==,>,<是同一类东东。由于它是由字母组成的,所以也是Java的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例,返回boolean类型的数据。举个例子:

           String s = "I AM an Object!";
           boolean isObject = s instanceof Object;

           我们声明了一个String对象引用,指向一个String对象,然后用instancof来测试它所指向的对象是否是Object类的一个实例,显然,这是真的,所以返回true,也就是isObject的值为True。
           instanceof有一些用处。比如我们写了一个处理账单的系统,其中有这样三个类:

           public class Bill {//省略细节}
           public class PhoneBill extends Bill {//省略细节}
           public class GasBill extends Bill {//省略细节}

           在处理程序里有一个方法,接受一个Bill类型的对象,计算金额。假设两种账单计算方法不同,而传入的Bill对象可能是两种中的任何一种,所以要用instanceof来判断:

    public double calculate(Bill bill) {
      if (bill instanceof PhoneBill) {
        //计算电话账单
      }
      if (bill instanceof GasBill) {
        //计算燃气账单
      }
      ...
    }
    这样就可以用一个方法处理两种子类。

           然而,这种做法通常被认为是没有好好利用面向对象中的多态性。其实上面的功能要求用方法重载完全可以实现,这是面向对象变成应有的做法,避免回到结构化编程模式。只要提供两个名字和返回值都相同,接受参数类型不同的方法就可以了:

    public double calculate(PhoneBill bill) {
      //计算电话账单
    }
    public double calculate(GasBill bill) {
      //计算燃气账单
    }

           所以,使用instanceof在绝大多数情况下并不是推荐的做法,应当好好利用多态。

           from:http://www.blogjava.net/hilor/articles/150610.html

    展开全文
  • 什么是动态数据类型

    千次阅读 2016-07-02 13:02:45
    Python的变量,可变的是指向,不可通过变量名修改其指向数据单元的内容。 //函数id() 的作用是查看变量指向的内存地址。见help(id) //内存中分配两个单元,存放数字12和13。 //x,y分别指向内存地址,类似C语言...

    动态数据类型

    Python是动态数据类型,变量不需要指定类型。

    Python的变量,可变的是指向,不可通过变量名修改其指向数据单元的内容。

    //函数id() 的作用是查看变量指向的内存地址。见help(id)
    //内存中分配两个单元,存放数字12和13。
    //x,y分别指向内存地址,类似C语言的指针
    x=12
    y=13
    print 'x=',x,id(x)
    print 'y=',y,id(y)
    //让x指向y的地址
    x=y
    print 'x=',x,id(x)
    print 'y=',y,id(y)
    //内存中分配两个单元,存放数字15和16。
    x=15
    y=16
    print 'x=',x,id(x)
    print 'y=',y,id(y)
    运行结果:
    x= 12166579468
    y= 13 166579456
    x= 13 166579456
    y= 13 166579456
    x= 15 166579432
    y= 16 166579420

    可以看到变量x和y指向的内存单元在不断的变化。

    而某个内存单元中的数据内容是固定不变的,例如内存单元 166579468 始终保存数据12,直到程序结束,释放空间 。

    Python变量的类型是根据它所指向的内存单元中的数据类型决定的,因此不需要声明,指向什么类型,就是什么类型。

    C语言的静态数据类型

    #include <stdio.h>
    int main(int argc,char * argv[]){
    int x=12, y=13;
    //%d输出整数,%p输出指针
    printf("x=%d,x_addr = %p\n",x,&x);
    printf("y=%d,y_addr = %p\n",y,&y);
    x=y;
    printf("x=%d,x_addr = %p\n",x,&x);
    printf("y=%d,y_addr = %p\n",y,&y);
    //把变量x指向的内存单元中的数据缓存15
    x=15;
    y=16;
    printf("x=%d,x_addr = %p\n",x,&x);
    printf("y=%d,y_addr = %p\n",y,&y);
    return 0;
    }
    运行程序:
    //CentOS安装gcc
    $sudo yum install gcc
    //编译.c文件,生成myapp文件
    $gcc -o myapp dataType.c
    //运行myapp
    $./myapp

    运行结果:

    x=12,x_addr = 0xbfd9014c
    y=13,y_addr = 0xbfd90148
    x=13,x_addr = 0xbfd9014c
    y=13,y_addr = 0xbfd90148
    x=15,x_addr = 0xbfd9014c
    y=16,y_addr = 0xbfd90148

    和Python的情况相反,变量x,y的指向不变,例如变量x一直指向0xbfd9014c 内存单元。

    而变化的一直是变量指向的内存中的数据内容。

    C语言声明一个int类型的变量,即分配一块内存空间给这个变量。

    这个内存单元始终属于这个变量,且只能存放int类型的数据,直到释放内存。

    静态类型语言声明变量时必须指明数据类型,因为要为每个变量提前分配好固定大小的内存空间

    总结:

    动态语言(又称弱类型语言),变量不用声明类型,具体类型根据指向的内存单元中的数据类型决定。

    动态类型,指向可变,内存单元中的数据不可变。

    静态语言(又称强类型语言),变量需要声明类型,变量指向的内存单元可存放的数据类型固定。

    静态类型,内容可变,变量的指向不可变。


    展开全文
  • js数据类型(基本数据类型 | 引用数据类型

    千次阅读 多人点赞 2020-08-06 16:46:45
    一、数据类型 JS分两种数据类型: 基本数据类型:**Number、...基本数据类型是指存放在栈中的简单数据段,数据大小确定,内存空间大小可以分配,它们是直接按值存放的,所以可以直接按值访问 1、Number数值类型 Num

    一、数据类型

    JS分两种数据类型:

    基本数据类型:**Number、String、Boolean、Null、 Undefined、Symbol(ES6),**这些类型可以直接操作保存在变量中的实际值。

    引用数据类型Object(在JS中除了基数据类型以外的都是对象,数据是对象,函数是对象,正则表达式是对象)

    1、基本数据类型(六种)存放在栈中

    基本数据类型是指存放在中的简单数据段,数据大小确定,内存空间大小可以分配,它们是直接按值存放的,所以可以直接按值访问

    • 1、Number数值类型
      Number类型包含整数和浮点数(浮点数数值必须包含一个小数点,且小数点后面至少有一个数字)两种值

    注意:在js中浮点数的精度是17位,计算是二进制的计算数 据,所以得到的不是整数

    var num1 = 0.1;
    
    var num2 = 0.2;
    
    console.log(num1 + num2);   //0.30000000000000004
    

    NaN:非数字类型,属于数值型基本数据类型

    特点:
    1):设计任何的NaN操纵都会返回NaN
    console.log('ab'/10); // NaN
    2) NaN不等于自身。
    console.log(NaN == NaN);// false;

    判断是否是Number类型

    1、isNaN:判断是否是一个非数字类型,传入的非数字类型,返回true,否则返回false
    注意:传入的参数首先会被转化为数值,如果参数类型为对象类型,先调用valueOf()方法,再确定该方法返回的值是否可以转换为数值类型,如果不能,再调用toString()方法,再确定返回值
    2、typeof
    console.log(typeof 12) //Number

    数值类型的转换:
    Number():可以用于任何的数据类型
    parseInt:提取 整数数值
    paseFloat:提取浮点数值

    • 2、String 字符串类型

    特点:
    1、字符串的单引号和双引号作用效果一样
    2、字符串有length属性,可以取得字符串的长度
    3、字符串的值是不可变的,所以很多的字符串的api不会改变原字符串值

    字符串转换:
    String():适用于任何的数据类型(null -> null undefined -> undefined)
    toString()nullundefined没有这个功能
    console.log(null.toString()); //error 报错

    • 3、Boolean 布尔类型
      该类型只有两个值:truefalse
    转换为`boolean`:    `Boolean()`
    Boolean(undefined):false
    
    Boolean(null):false
    
    Boolean(非空对象包括空数组[]和空对象{}):true
    
    Boolean(0): true || Boolean(0NaN):false
    
    Boolean(非空包括空格字符串):true || Boolean(''):false
    
    [注意]true不一定等于1false也不一定等于0
    

    出现场景:
    (1)条件语句导致执行的隐士类转换
    (2)字面量或变量定义

    类型转换:
    Number(true): 1     ||   Number(false) : 0
    
    String(true):'true'      ||   String(false):'false'
    
    • 4、Null 空对象指针类型
      如果定了一个对象,初始化可以为null,因为null的基本类型是Null,在if语句中默认转化为false,在和数值计算默认为0
      出现场景:对象不存在
    类型转换:
    Booleam(null)  false
    
    Number(num)  0
    
    String(null)  'null'
    

    Number(null) // 0

    • 5、Undefined
      申明了变量但是没有初始化,默认为undefined,在if语句中默认转化为false,

    undefined:表示‘缺少值’,就是应该有一个值,但是没有定义,以下用法是典型的出现undefined情况
    (1)变量被申明,等于undefined
    (2)调用函数时,应该提供的参数没有提供,该参数等于undefined
    (3)对象没有赋值的属性,该属性值为undefined
    (4)函数没有返回值,默认返回undefined

    类型转换:
    Boolean(undefined):  false
     
    Number(undefined):  NaN
    
    String(undefined):  'undefined'
    
    • 6、Symbol
      ES6新增的一个基本数据类型,表示唯一性
     let id1 = Symbol('id');
     let id2 = Symbol('id');
     console.log(id1 == id2);  //false
    

    Symbol属性类型不支持for...inObject.keys()

     let id = Symbol("id");
     let obj = {
      [id]:'symbol'
     };
     for(let option in obj){
         console.log(obj[option]); //空
     }
    

    但是也能有方法去访问:Object.getOwnPropertySymbols
    方法会返回一个数组,成员是当前对象的所有用作属性名的 Symbol 值。

    console.log(Object.getOwnPropertySymbols(obj))
    // [ Symbol(c) ]
    
    • 介绍两个Symbol.forSymbol.keyFor
      (1)、Symbol.for :方法根据给到的键key来运行时的symbol注册表中找到对应的symbol,如果找到了,则返回它,否则新增一个与该键关联的symbol,并放入全局的symbol,这个Symbol值可以是被二次用到的
      返回值:
      返回由给定的 key 找到的 symbol,否则就是返回新创建的 symbol。
    Symbol.for("foo"); // 创建一个 symbol 并放入 symbol 注册表中,键为 "foo"
    Symbol.for("foo"); // 从 symbol 注册表中读取键为"foo"的 symbol
    
    Symbol.for("bar") === Symbol.for("bar"); // true,证明了上面说的
    Symbol("bar") === Symbol("bar"); // false,Symbol() 函数每次都会返回新的一个 symbol
    
    为了防止冲突,最好给你要放入 symbol 注册表中的 symbol 带上键前缀。
    Symbol.for("mdn.foo");
    Symbol.for("mdn.bar");
    
    

    (2)、Symbol.keyFor
    方法用来获取 symbol 注册表中与某个 symbol 关联的键。

    var globalSym = Symbol.for("foo"); 
    Symbol.keyFor(globalSym); // "foo"
    

    2、引用数据类型

    引用数据类型也叫对象数据类型,包括function,object,array,date,RegExp等可以可以使用new创建的数据,又叫对象类型,他们是存放在(heap)内存中的数据
    特点:

    • 引用类型的值可以改变
    • 引用数据类型可以添加属性和方法
    • 引用数据类型的赋值是对象引用
    • 引用类型的比较是引用的比较
    • 引用类型是同时保存在栈区中和堆区中的,引用类型的存储需要在内存的栈区和堆区中共同完成,栈区保存变量标识符和指向堆内存的地址

    注意:在引用类型赋值时对象的引用,所以从一个变量向另一个变量赋值引用类型的值时,同样会将存在在变量中的对象的值赋值一份到新的变量分配的空间,引用类型保存在变量中的时对象在堆存在的地址,所以与基本数据类型的简单赋值不同,这个值的副本实际上时一个指针,而这个指针指向储存在堆内存的一个对象,那么赋值操作后,两个变量都保存了同一个对象的地址,而这个地址都指向同一个对象,因此改变其中任何一个变量,都会影响
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jbmIM5T9-1596703084649)(images/screenshot_1595230430200.png)]

    在ECMAScript中,Object类型是所有它的实例的基础

    Object的每个实例都具有下列的属性和方法:

    • constructor:构造函数
    • hasOwnProperty(proertyName)
      用于检查给定的属性在当前对象实例(而不是实例的原型)中是否存在。
    • isPropertyOf(Object)
      用于检查其原型链的对象是否存在于指定对象的实例中,是则返回true,否则返回false。
    var a = {} function Person() {} 
    
    var p1 = new Person() // 继承自原来的原型,但现在已经无法访问  
    
    var Person.prototype = a var p2 = new Person() // 继承a  
    
    console.log(a.isPrototypeOf(p1)) // false a是不是p1的原型 
    
     console.log(a.isPrototypeOf(p2)) // true a是不是p2的原型  
    
    console.log(Object.prototype.isPrototypeOf(p1)) // true  
    
    console.log(Object.prototype.isPrototypeOf(p2)) // true
    
    
    • propertyIsEnumerable(propertyName)
      用于检查给定的属性是否可以用 for-in 语句进行枚举。
    • toLocaleString()
      返回对象的字符串表示,该字符串与执行环境的地区对应。
    • toString()
      返回对象的字符串表示。
    • valueOf()
      返回对象的字符串、数值、布尔值表示。通常与toString()方法的返回值相同。
      [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ncTTVVzi-1596703084652)(images/screenshot_1595228465109.png)]

    拓展:声明对象的几种方式

     <script>
    //内置函数
            var obj1=new Object();
            obj1.name="zhuyu";
            obj1.age=21;
            obj1.uni=function(){
                console.log(this.name+this.age);
            }
            console.log(obj1);
            obj1.uni();
     
    //字面量
            var obj2={
                name:"zhuyu2",
                age:21,
                uni2:function(){
                    console.log(this.name+this.age)
                }
            }
            console.log(obj2);
            obj2.uni2();
     
     
    // 自定义函数
            function Obj(name,age){
                this.name=name;
                this.age=age;
                this.uni3=function(){
                    console.log(this.name+this.age)
                }
            }
            var obj3=new Obj("zhuyu3",21);
            console.log(obj3);
            obj3.uni3();
     
    // Es6类
     
            class Obj2{
                constructor(name,age){
                    this.name=name;
                    this.age=age;
                }
                uni4(){
            console.log(this.name+this.age)
                }
            }
            var obj4=new Obj2("zhuyu4",21);
            console.log(obj4);
            obj4.uni4();
     
    //使用Object.create()
     
            var person={
                image:"true",
                uni5:function(){
                    console.log(`名字是${this.name},年龄是${this.age}`);
                }
            }
           var obj5=Object.create(person);
           obj5.name="zhuyu5";
           obj5.age=21;
           obj5.image=false;
           obj5.uni5();
           console.log(obj5)
        </script>
    

    3、基本数据类型和引用数据类型的区别

    总结基本数据类型和引用数据类型区别

    1、声明变量时内存分配不同

    *原始类型:在栈中,因为占据空间是固定的,可以将他们存在较小的内存中-栈中,这样便于迅速查询变量的值
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MXBAdxMe-1596703084654)(images/screenshot_1595226759783.png)]

    *引用类型:存在堆中,栈中存储的变量,只是用来查找堆中的引用地址。
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UsfodwlF-1596703084656)(images/screenshot_1595226765978.png)]

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1467GOxa-1596703084658)(images/screenshot_1595227087417.png)]

    这是因为:引用值的大小会改变,所以不能把它放在栈中,否则会降低变量查寻的速度。相反,放在变量的栈空间中的值是该对象存储在堆中的地址。地址的大小是固定的,所以把它存储在栈中对变量性能无任何负面影响

    2、不同的内存分配带来不同的访问机制

    在javascript中是不允许直接访问保存在堆内存中的对象的,所以在访问一个对象时,首先得到的是这个对象在堆内存中的地址,然后再按照这个地址去获得这个对象中的值,这就是传说中的按引用访问。而原始类型的值则是可以直接访问到的。

    3、复制变量时的不同

    1)原始值:在将一个保存着原始值的变量复制给另一个变量时,会将原始值的副本赋值给新变量,此后这两个变量是完全独立的,他们只是拥有相同的value而已。

    2)引用值:在将一个保存着对象内存地址的变量复制给另一个变量时,会把这个内存地址赋值给新变量,也就是说这两个变量都指向了堆内存中的同一个对象,他们中任何一个作出的改变都会反映在另一个身上。(这里要理解的一点就是,复制对象时并不会在堆内存中新生成一个一模一样的对象,只是多了一个保存指向这个对象指针的变量罢了)。多了一个指针
    浅拷贝:
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SoeUg10W-1596703084659)(images/screenshot_1595226833036.png)]

    深拷贝:
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JxsVP0Bi-1596703084660)(images/screenshot_1595226846817.png)]

    4、参数传递的不同(把实参复制给形参的过程

    首先我们应该明确一点:ECMAScript中所有函数的参数都是按值来传递的。

    但是为什么涉及到原始类型与引用类型的值时仍然有区别呢?还不就是因为内存分配时的差别。

    1)原始值:只是把变量里的值传递给参数,之后参数和这个变量互不影响。

    2)引用值:对象变量它里面的值是这个对象在堆内存中的内存地址,这一点你要时刻铭记在心!

    因此它传递的值也就是这个内存地址,这也就是为什么函数内部对这个参数的修改会体现在外部的原因了,因为它们都指向同一个对象。

    4、检测类型

    • 法一:typeof

    最基本的判断方式,该操作符返回一个表示数据类型的字符串,numberstringbooleanobjectfunctionundefinedsymbol

    1. ‘undefined’ --未定义的变量或值

    2. ‘boolean’ --布尔类型的变量或值

    3. ‘string’ --字符串类型的变量或值

    4. ‘number’ --数字类型的变量或值

    5. ‘object’ --对象类型的变量或值,或者null(这个是js历史遗留问题,将null作为object类型处理)

    6. ‘function’ --函数类型的变量或值

         console.log(typeof a);    //'undefined'
    
        console.log(typeof(true));  //'boolean'
    
        console.log(typeof '123');  //'string'
    
        console.log(typeof 123);   //'number'
    
        console.log(typeof NaN);   //'number'
    
        console.log(typeof null);  //'object'    
    
        var obj = new String();
    
        console.log(typeof(obj));    //'object'
    
        var  fn = function(){};
    
        console.log(typeof(fn));  //'function'
    
        console.log(typeof(class c{}));  //'function'
    
    • 法二:instanceof

    运算符用来测试一个对象在其原型链中是否存在一个构造函数的 prototype 属性
    语法:object instanceof constructor
    (1)基础类型

    let num = 1
    num instanceof Number // false
    
    num = new Number(1)
    num instanceof Number // true
    

    这两个都是一样的数值,为什么不一样?
    因为instanceof 检测的是:检测目标的__proto__与构造函数prototype,相同返回true,不同返回false,对于stringboolean是一样的
    注意:

    new String(1) // String {"1"}
    String(1) // "1"
    

    (2) 继承关系的用法

    // 判断 foo 是否是 Foo 类的实例 , 并且是否是其父类型的实例
     function Aoo(){}
     function Foo(){}
     Foo.prototype = new Aoo();//JavaScript 原型继承
    
     var foo = new Foo();
     console.log(foo instanceof Foo)//true
     console.log(foo instanceof Aoo)//true
    

    (3) 复杂类型

    let arr = []
    arr instanceof Array // true
    arr instanceof Object // true
    Array.isArray(arr) // true
    

    注意:
    (new Number(1)) instanceof Object // true
    (4) 其他类型

    let reg = new RegExp(//)
    reg instanceof RegExp // true
    reg instanceof Object // true
    
    let date = new Date()
    date instanceof Date // true
    date instanceof Object // true
    

    但是Fuction不一样

    function A() {}
    let a = new A()
    a instanceof Function // false
    a instanceof Object // true
    A instanceof Function // true
    

    –>分析a为什么不是?

    • a是new出来,所以是经过构造,因此已经是对象,不再是函数,所以false。
    • a是经过构造的对象,返回ture没问题。
    • 如上所述,A是个函数,因此没什么概念上的问题。但是要知道A.__proto__Function.prototypeƒ () { [native code] },这是与object以后处于原型链上层的存在,而且与object平级:
    let obj = {}
    obj.__proto__ // {constructor: ƒ, __defineGetter__: ƒ, __defineSetter__: ƒ, hasOwnProperty: ƒ, __lookupGetter__: ƒ, …}
    obj.__proto__.prototype // undefined
    
    let A = function() {}
    A.__proto__ // ƒ () { [native code] }
    A.__proto__.prototype // undefined
    

    本章内容图谱:
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qZLYd9tI-1596703084662)(images/screenshot_1595231058140.png)]

    展开全文
  • Python基本数据类型

    千次阅读 2015-09-12 08:12:40
    基本数据类型 数值型 整型Integral 浮点型Float 复数 布尔型Bool 变量的命名规则 组合数据类型 序列 字符串String 元组Tuple 列表List 最后前言Python作为一种弱类型编程语言,其数据类型较之于C/C++无论是在数据的...
  • PB中的any数据类型

    千次阅读 2016-12-26 15:33:16
    Any数据类型概述PowerBuilder还支持Any数据类型,它可以保存任何类型的值,包括标准数据类型、对象、结构和数组。一个类型为Any的变量,它的数据类型是可变的——这取决于赋给它的值。
  • Oracle 11g 数据类型

    千次阅读 2018-04-02 11:43:31
    建立表包括定义表的结构和添加数据记录。...(数据类型是数据的基本属性,反映了数据的类别) oracle 11g主要有3种数据类型:基本(oracle数据库内部)数据类型,集合类型,和引用类型。 基本数...
  • PostgreSQL 数据类型

    千次阅读 2017-11-06 20:13:06
    PostgreSQL 数据类型 6.1概述    PostgreSQL提供了丰富的数据类型。用户可以使用 CREATE TYPE ... 基本数据类型是数据库内置的数据类型,包括integer、char、varchar等数据类型。表6-1列出了Postg
  • PostgreSQL数据类型

    千次阅读 2017-03-12 12:28:04
    第六章 数据类型 6.1概述    PostgreSQL 提供了丰富的数据类型。用户可以使用 CREATE TYPE 命令在数据库... 基本数据类型是数据库内置的数据类型,包括integer、char、varchar等数据类型。表6-1列出了Postgre
  • PostpreSQL详细数据类型说明

    千次阅读 2013-09-23 09:34:05
    6.1概述     PostgreSQL 提供了丰富的数据类型。用户可以使用 CREATE TYPE ...基本数据类型是数据库内置的数据类型,包括integer、char、varchar等数据类型。表6-1列出了PostgreSQL提供的所有基
  • mongoDB支持的数据类型

    千次阅读 2019-03-26 20:55:35
    MongoDB文档存储是使用BSON类型,BSON(BSON short for Bin­ary JSON, is a bin­ary-en­coded seri­al­iz­a­...下表为MongoDB 常用的几种数据类型数据类型 描述 String 字符串。存...
  • 数据库数据类型学习总结

    千次阅读 2016-08-04 17:22:28
    SQLite 数据类型总结 http://www.cnblogs.com/bpasser/archive/2011/11/02/2233455.html 1。严格地说,SQLite 没有数据类型。SQLite 使用动态数据类型,即:数据的 类型取决于数据本身,而不是它的容器(字段) 2...
  • 自己整理的SQL数据类型

    千次阅读 2016-08-12 15:12:20
    SQL数据类型
  • MySQL数据类型--字符串类型

    万次阅读 2016-03-22 12:05:17
    字符串类型是在数据库中存储字符串的数据类型,字符串类型包括char,varchar,text,enum和set。 OK,我们来一个一个的看下上面提到的...其中,字符串类型参数指定了数据类型是char类型还是varchar类型,M参数指定
  • Kotlin 基本数据类型

    千次阅读 2020-08-10 16:46:09
    Kotlin 基本数据类型基本数据类型字面常量 基本数据类型 Kotlin 的基本数值类型包括 Byte、Short、Int、Long、Float、Double 等。不同于 Java 的是,字符不属于数值类型,是一个独立的数据类型。 类型 位宽度 ...
  • Flutter(Dart)基础——数据类型

    万次阅读 2020-09-14 17:34:22
    本文将介绍Dart的数据类型,以及它们的基本用法。
  • Mysql都支持哪些数据类型

    千次阅读 2019-07-03 23:00:38
    在设计数据库表时,其中一项重要步骤便是选择表中字段的数据类型。 如果你选择的是mysql作为数据库,必须要清楚mysql到底支持哪些数据类型呢? 总体来说包括数值型、字符串类型、日期和时间类型这么几大类。 1、数值...
  • JS基础篇1:数据类型(8种)

    万次阅读 多人点赞 2019-07-08 19:27:23
    最近有很多人说数据类型是 6种。我怎么记得JS的数据类型有8种。最近发现好多人对JS的基础不太了解。很多数据类型都没有搞清楚。不BB,我就按我的理解写一波笔记,每次看一波书我就感觉一次比一次多懂一点。来补下...
  • VC++常用数据类型

    万次阅读 2008-12-31 12:20:00
     常用数据类型转化2.1数学类型变量与字符串相互转换2.2 CString及string,char *与其他数据类型的转换和操作●CString,string,char*的综合比较●数学类型与CString相互转化●CString与char*相互转换举例●CStrin
  • postgresql数据类型

    千次阅读 2014-12-29 20:06:39
    第六章 数据类型 概述数值类型 整数类型任意精度数值浮点类型序列号类型Serial 字符类型二进制数据类型日期时间类型 日期时间输入 日期时间时间戳timestamp时间间隔特殊值 日期时间输出时区内部实现 ...
  • SQL数据类型和范围

    千次阅读 2015-08-12 16:07:52
    Microsoft Access、MySQL 以及 SQL Server 所使用的数据类型和范围。 SQL Server 数据类型 Character 字符串 数据类型 描述 存储 char(n) 固定长度的字符串。最多 8,000 个字符。 n varchar(n) 可变长度的...
  • Oracle常用数据类型说明

    千次阅读 2018-02-17 18:14:57
    可变长度的字符串, 最大长度4000bytes 可做索引的最大长度749 NCHAR 根据字符集而定的固定长度字符串 最大长度2000bytes NVARCHAR2 根据字符集而定的可变长度字符串 最大长度4000bytes
  • [MySQL] 数据类型与性能

    千次阅读 2013-11-15 13:23:23
    MySQL支持的数据类型非常多,选择正确的数据类型对性能至关重要,本文谈谈如何正确选择MySQL的数据类型。 整数 有以下几种整数:TINYINT, SMAILLINT, MEDIUMINT, INT, BIGINT,分别使用8, 16, 24, 32, 64位存储空间...
  • SQL Server2005 中的数据类型总结

    千次阅读 2009-08-15 11:15:00
    SQL Server2005 中的数据类型总结 SQL Server 2005 中的数据类型归纳为下列类别:精确数字 bigint decimal int numeric smallint money tinyint smallmon
  • SQL Server 2005 常用数据类型详解

    千次阅读 2013-10-28 14:16:36
    1. 字符串数据类型 char 此数据类型可存储1~8000个定长字符串,字符串长度在创建时指定;如未指定,默认为char(1)。每个字符占用1byte存储空间。 nchar ...此数据类型可存储最大值为8000个字符的可变
  • C语言数据类型

    万次阅读 2009-10-09 10:03:00
    在C语言中, 每个变量在使用之前必须定义其数据类型。C语言有以下几种类型: 整型(int)、浮点型(float)、字符型(char)、指针型(*)、无值型 (void)以及结构(struct)和联合(union)。其中前五种是Turbo C的基本数据类型、...
  • 数据库中各种数据类型

    千次阅读 2017-05-27 21:21:55
    SQL 数据类型 Microsoft Access、MySQL 以及 SQL Server 所使用的数据类型和范围。 Microsoft Access 数据类型 数据类型 描述 存储 Text 用于文本或文本与数字的组合。最多 255 个字符。  ...
  • JAVA与C语言之间数据类型上的比较

    千次阅读 2018-04-06 14:24:57
    JAVA和C语言在基本的数据类型上的比较1....常量是值不可变的变量,即不能重新赋值。 不同点:Java:Java的数据类型可分为两大类:-基本数据类型:byte、short、int、long、double、float、boole...
  • SQL Server 2005 数据类型比较

    千次阅读 2011-06-08 10:58:00
    1. 字符串数据类型char此数据类型可存储1~8000个定长字符串,字符串长度在创建时指定;如未指定,默认为char(1)。每个字符占用1byte存储空间...varchar此数据类型可存储最大值为8000个字符的可变长字符串。可变长字符串

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 89,633
精华内容 35,853
关键字:

下列是可变数据类型的是