精华内容
下载资源
问答
  • java中,使用sonarqube的时候,string类型的代码不允许直接使用未经定义的常量,什么是未经定义的产量呢?下面举个例子: //这个会报未经定义的常量 String value = "常量"; 一开始想到的解决方案...

    不是报错,只是soanrqube检测觉得这样子不规范,这个也是阿里巴巴java编程手册中的一个规定,里面说法是不允许使用魔法值
    java中,在使用sonarqube的时候,string类型的代码不允许直接使用未经定义的常量,什么是未经定义的产量呢?下面举个例子:

        //这个会报未经定义的常量
        String value = "常量";
    

    一开始想到的解决方案是改成下面这个:

        //这样子就是定义了这个变量了,sonarqube也没有报错了
        String value = new String("常量");
    

    但是里面有一个问题,那就是浪费内存。
    浪费内存是,里面有两个对象,String value只是一个字符串变量,没有产生对象,new String(“常量”)不是原子操作,把它拆分为"常量"和new String(),首先会在字符串的常量池中查找有没有这个字符串"常量",没有找到就会创建一个字符串对象"常量"在元空间(JDK1.8 , 谢谢评论区指正~),然后new String 会把这个字符串对象拷贝一份到堆中,返回这个对象的引用。

    除此之外,我知道String是不可变的,但是那是创建了之后不可变,也就是线程安全,那么我的疑问是在创建的时候是线程安全的么?以下是关于这个方面的个人理解:
    之所以说线程不安全,这里引入两个概念:原子操作指令重排

    1.原子操作

    • 原子操作,可以理解为不可分割的操作,就是它已经小到不可以再切分为多个操作进行,那么在计算机中要么它完全执行了,要么它完全没有执行,它不会存在执行到中间状态,可以理解为没有中间状态。比如:赋值语句就是一个原子操作:
     n = 1; //这是一个原子操作 
    

    假设n的值以前是0,那么这个操作的背后就是要么执行成功n等于1,要么没有执行成功n等于0,不会存在中间状态,就算是并发的过程中也是一样的。
    下面看一句不是原子操作的代码:

    int n =1;//不是原子操作
    

    **原因:**这个语句中可以拆分为两个操作,1.声明变量n,2.给变量赋值为1,从中我们可以看出有一种状态是n被声明后但是没有来得及赋值的状态,这样的情况,在并发中,如果多个线程同时使用n,那么就会可能导致不稳定的结果。

    2.指令重排

    所谓指令重排,就是计算机会对我们代码进行优化,优化的过程中会在不影响最后结果的前提下,调整原子操作的顺序。比如下面的代码:

    int a ;   // 语句1 
    a = 1 ;   // 语句2
    int b = 2 ;     // 语句3
    int c = a + b ; // 语句4
    

    正常的情况,执行顺序应该是1234,但是实际有可能是3124,或者1324,这是因为语句3和4都没有原子性问题,那么就有可能被拆分成原子操作,然后重排.

    那么回到我们上面那个代码

        String value = new String("常量");
        //这不是原子操作,就是可以拆分,事实上先定义了一个String变量,然后创建了对象"常量",然后拷贝对象到堆中,将对象引用指向value。
    

    上面代码如果在多线程中,有可能触发指令重排,如果有线程创建了对象,还没有将引用指过去,其他线程也就有可能创建多个这样的常量,有可能会导致其他问题出现。【如有错误,还请指教】

    正确的改动方法:

    1.使用常量,将项目的常量都抽取到一个class文件中:
    2.使用format方法:

    public class ConstantFile{
        public static final String name = "常量";//方法1
        public void myMethod(){
            String.format("常量,%s,%s",args1,args2);//方法2
        }
    }
    
    

    3.使用枚举类型:

    public enum  ConstantFile {
      USA("美国",1),CHINA("中国",2);
      private String name;
      private int index;
      private ConstantFile(String name,int index){
        this.name=name;
        this.index=index;
      }
    
      public String getName() {
        return name;
      }
    
      public void setName(String name) {
        this.name = name;
      }
    
      public int getIndex() {
        return index;
      }
    
      public void setIndex(int index) {
        this.index = index;
      }
    }
    
    

    如有错误,还请指教,感激!!!
    此文章仅代表自己(本菜鸟)学习积累记录,或者学习笔记,如有侵权,请联系作者删除。人无完人,文章也一样,文笔稚嫩,在下不才,勿喷,如果有错误之处,还望指出,感激不尽~

    技术之路不在一时,山高水长,纵使缓慢,驰而不息。

    公众号:秦怀杂货店

    展开全文
  • 目录 1.对象概述 2.对象和属性 ...4.5.1为对象类型定义属性 JavaScript的设计是一个简单的基于对象的范式。一个对象就是一系列属性的集合,一个属性包含一个名和一个值。一个属性的值可以是...

    目录

    1.对象概述

    2.对象和属性

    3.枚举一个对象的所有属性

    4.创建新对象

    4.1使用对象初始化器

    4.2使用构造函数

    4.3使用 Object.create 方法

    4.4继承

    4.5对象属性引用

    4.5.1为对象类型定义属性


           JavaScript 的设计是一个简单的基于对象的范式。一个对象就是一系列属性的集合,一个属性包含一个名和一个值。一个属性的值可以是函数,这种情况下属性也被称为方法。除了浏览器里面预定义的那些对象之外,你也可以定义你自己的对象。本章节讲述了怎么使用对象、属性、函数和方法,怎样实现自定义对象。

    1.对象概述

    Javascript 中的对象(物体),和其它编程语言中的对象一样,可以比照现实生活中的对象(物体)来理解它。 javascript 中对象(物体)的概念可以比照着现实生活中实实在在的物体来理解。

    在javascript中,一个对象可以是一个单独的拥有属性和类型的实体。我们拿它和一个杯子做下类比。一个杯子是一个对象(物体),拥有属性。杯子有颜色,图案,重量,由什么材质构成等等。同样,javascript对象也有属性来定义它的特征。

    2.对象和属性

    一个 javascript 对象有很多属性。一个对象的属性可以被解释成一个附加到对象上的变量。对象的属性和普通的 javascript 变量基本没什么区别,仅仅是属性属于某个对象。属性定义了对象的特征(译注:动态语言面向对象的鸭子类型)。你可以通过点符号来访问一个对象的属性。

    objectName.propertyName

    和其他 javascript 变量一样,对象的名字(可以是普通的变量)和属性的名字都是大小写敏感的。你可以在定义一个属性的时候就给它赋值。例如,我们创建一个myCar的对象然后给他三个属性,make,model,year。具体如下所示:

    var myCar = new Object();
    myCar.make = "Ford";
    myCar.model = "Mustang";
    myCar.year = 1969;

    对象中未赋值的属性的值为undefined(而不是null)。

    myCar.noProperty; // undefined

    JavaScript 对象的属性也可以通过方括号访问或者设置(更多信息查看 property accessors). 对象有时也被叫作关联数组, 因为每个属性都有一个用于访问它的字符串值。例如,你可以按如下方式访问 myCar 对象的属性:

    myCar["make"] = "Ford";
    myCar["model"] = "Mustang";
    myCar["year"] = 1969;

    一个对象的属性名可以是任何有效的 JavaScript 字符串,或者可以被转换为字符串的任何类型,包括空字符串。然而,一个属性的名称如果不是一个有效的 JavaScript 标识符(例如,一个由空格或连字符,或者以数字开头的属性名),就只能通过方括号标记访问。这个标记法在属性名称是动态判定(属性名只有到运行时才能判定)时非常有用。例如:

    // 同时创建四个变量,用逗号分隔
    var myObj = new Object(),
        str = "myString",
        rand = Math.random(),
        obj = new Object();
    
    myObj.type              = "Dot syntax";
    myObj["date created"]   = "String with space";
    myObj[str]              = "String value";
    myObj[rand]             = "Random Number";
    myObj[obj]              = "Object";
    myObj[""]               = "Even an empty string";
    
    console.log(myObj);

    请注意,方括号中的所有键都将转换为字符串类型,因为JavaScript中的对象只能使用String类型作为键类型。 例如,在上面的代码中,当将键obj添加到myObj时,JavaScript将调用obj.toString()方法,并将此结果字符串用作新键。

    你也可以通过存储在变量中的字符串来访问属性:

    var propertyName = "make";
    myCar[propertyName] = "Ford";
    
    propertyName = "model";
    myCar[propertyName] = "Mustang";

    你可以在  for...in 语句中使用方括号标记以枚举一个对象的所有属性。为了展示它如何工作,下面的函数当你将对象及其名称作为参数传入时,显示对象的属性:

    function showProps(obj, objName) {
      var result = "";
      for (var i in obj) {
        if (obj.hasOwnProperty(i)) {
            result += objName + "." + i + " = " + obj[i] + "\n";
        }
      }
      return result;
    }

    因而,对于函数调用 showProps(myCar, "myCar") 将返回以下值:

    myCar.make = Ford
    myCar.model = Mustang
    myCar.year = 1969

    3.枚举一个对象的所有属性

    从 ECMAScript 5 开始,有三种原生的方法用于列出或枚举对象的属性:

    • for...in 循环
      该方法依次访问一个对象及其原型链中所有可枚举的属性。
    • Object.keys(o)
      该方法返回一个对象 o 自身包含(不包括原型中)的所有属性的名称的数组。
    • Object.getOwnPropertyNames(o)
      该方法返回一个数组,它包含了对象 o 所有拥有的属性(无论是否可枚举)的名称。

    在 ECMAScript 5 之前,没有原生的方法枚举一个对象的所有属性。然而,可以通过以下函数完成:

    function listAllProperties(o){     
    	var objectToInspect;     
    	var result = [];
    	
    	for(objectToInspect = o; objectToInspect !== null; objectToInspect = Object.getPrototypeOf(objectToInspect)){  
    		result = result.concat(Object.getOwnPropertyNames(objectToInspect));  
    	}
    	
    	return result; 
    }

    这在展示 “隐藏”(在原型中的不能通过对象访问的属性,因为另一个同名的属性存在于原型链的早期)的属性时很有用。可以通过在数组中去除同名元素即可轻松地列出访问的属性。

    4.创建新对象

    除了通过构造函数创建对象之外,你也可以通过对象初始化器创建对象。使用对象初始化器也被称作通过字面值创建对象。对象初始化器与 C++ 术语相一致。

    4.1使用对象初始化器

    通过对象初始化器创建对象的语法如下:

    var obj = { property_1:   value_1,   // property_# 可以是一个标识符...
                2:            value_2,   // 或一个数字...
               ["property" +3]: value_3,  //  或一个可计算的key名... 
                // ...,
                "property n": value_n }; // 或一个字符串

    这里 obj 是新对象的名称,每一个 property_i是一个标识符(可以是一个名称、数字或字符串字面量),并且每个 value_i 是一个其值将被赋予 property_i 的表达式。obj 与赋值是可选的;如果你不需要在其他地方引用对象,你就不需要将它赋给一个变量。(注意在接受一条语句的地方,你可能需要将对象字面量括在括号里,从而避免将字面量与块语句相混淆)

    如果一个对象是通过在顶级脚本的对象初始化器创建的,则 JavaScript 在每次遇到包含该对象字面量的表达式时都会创建对象。同样的,在函数中的初始化器在每次函数调用时也会被创建。

    下面的语句只有当 cond 表达式的值为 true 时创建对象并将其赋给变量 x

    if (cond) var x = {hi: "there"};

    下例创建了有三个属性的 myHonda 对象。注意它的 engine 属性也是一个拥有自己属性的对象。

    var myHonda = {color: "red", wheels: 4, engine: {cylinders: 4, size: 2.2}};

    你也可以用对象初始化器来创建数组。参见 array literals.

    在 JavaScript 1.1 及更早版本中,你不能使用对象初始化器。你只能通过使用构造函数或其他对象的函数来创建对象。参见 使用构造函数.

    4.2使用构造函数

    作为另一种方式,你可以通过两步来创建对象:

    1. 通过创建一个构造函数来定义对象的类型。首字母大写是非常普遍而且很恰当的惯用法。
    2. 通过 new 创建对象实例。

    为了定义对象类型,为对象类型创建一个函数以声明类型的名称、属性和方法。例如,你想为汽车创建一个类型,并且将这类对象称为 car ,并且拥有属性 make, model, 和 year,你可以创建如下的函数:

    function Car(make, model, year) {
      this.make = make;
      this.model = model;
      this.year = year;
    }

    注意通过使用 this 将传入函数的值赋给对象的属性。

    现在你可以象这样创建一个 mycar 对象:

    var mycar = new Car("Eagle", "Talon TSi", 1993);

    该创建了 mycar 并且将指定的值赋给它的属性。因而 mycar.make 的值是字符串 "Eagle", mycar.year 的值是整数 1993,依此类推。

    你可以通过调用 new 创建任意数量的 car 对象。例如:

    var kenscar = new Car("Nissan", "300ZX", 1992);
    var vpgscar = new Car("Mazda", "Miata", 1990);

    一个对象的属性值可以是另一个对象。例如,假设你按如下方式定义了 person 对象:

    function Person(name, age, sex) {
      this.name = name;
      this.age = age;
      this.sex = sex;
    }

    然后按如下方式创建了两个 person 实例:

    var rand = new Person("Rand McKinnon", 33, "M");
    var ken = new Person("Ken Jones", 39, "M");

    那么,你可以重写 car 的定义以包含一个拥有它的 owner 属性,如:

    function Car(make, model, year, owner) {
      this.make = make;
      this.model = model;
      this.year = year;
      this.owner = owner;
    }

    你可以按如下方式创建新对象:

    var car1 = new Car("Eagle", "Talon TSi", 1993, rand);
    var car2 = new Car("Nissan", "300ZX", 1992, ken);

    注意在创建新对象时,上面的语句将 rand 和 ken 作为 owner 的参数值,而不是传入字符串字面量或整数值。接下来你如果想找出 car2 的拥有者的姓名,你可以访问如下属性:

    car2.owner.name

    注意你总是可以为之前定义的对象增加新的属性。例如,语句

    car1.color = "black";

    为 car1 增加了 color 属性,并将其值设为 "black." 然而,这并不影响其他的对象。想要为某个类型的所有对象增加新属性,你必须将属性加入到 car 对象类型的定义中。

    4.3使用 Object.create 方法

    对象也可以用 Object.create() 方法创建。该方法非常有用,因为它允许你为创建的对象选择其原型对象,而不用定义一个构造函数。

    // Animal properties and method encapsulation
    var Animal = {
      type: "Invertebrates", // Default value of properties
      displayType : function() {  // Method which will display type of Animal
        console.log(this.type);
      }
    }
    
    // Create new animal type called animal1 
    var animal1 = Object.create(Animal);
    animal1.displayType(); // Output:Invertebrates
    
    // Create new animal type called Fishes
    var fish = Object.create(Animal);
    fish.type = "Fishes";
    fish.displayType(); // Output:Fishes

    该函数更多的信息及详细用法,参见 Object.create method

    4.4继承

    所有的 JavaScript 对象继承于至少一个对象。被继承的对象被称作原型,并且继承的属性可通过构造函数的 prototype 对象找到。查看更多详细 Inheritance and the prototype chain

    4.5对象属性引用

    在 JavaScript 1.0 中,你可以通过名称或序号访问一个属性。但是在 JavaScript 1.1 及之后版本中,如果你最初使用名称定义了一个属性,则你必须通过名称来访问它;而如果你最初使用序号来定义一个属性,则你必须通过索引来访问它。

    这个限制发生在你通过构造函数创建一个对象和它的属性(就象我们之前通过 Car 对象类型所做的那样)并且显式地定义了单独的属性(如 myCar.color = "red")之时。如果你最初使用索引定义了一个对象属性,例如 myCar[5] = "25",则你只可能通过 myCar[5] 引用它。

    这条规则的例外是从与HTML对应的对象,例如 forms 数组。对于这些数组的元素,你总是既可以通过其序号(依据其在文档中出现的顺序),也可以按照其名称(如果有的话)访问它。举例而言,如果文档中的第二个 <form> 标签有一个 NAME 属性且值为 "myForm",访问该 form 的方式可以是 document.forms[1],document.forms["myForm"]或 document.myForm。

    4.5.1为对象类型定义属性

    你可以通过 prototype 属性为之前定义的对象类型增加属性。这为该类型的所有对象,而不是仅仅一个对象增加了一个属性。下面的代码为所有类型为 car 的对象增加了 color 属性,然后为对象 car1 的 color 属性赋值:

    Car.prototype.color = null;
    car1.color = "black";

    参见 JavaScript Reference 中 Function 对象的 prototype 属性 。

    4.5.1.1定义方法

    一个方法 是关联到某个对象的函数,或者简单地说,一个方法是一个值为某个函数的对象属性。定义方法就像定义普通的函数,除了它们必须被赋给对象的某个属性。查看 method definitions了解更多详情例如:

    objectName.methodname = function_name;
    
    var myObj = {
      myMethod: function(params) {
        // ...do something
      }
      
      // 或者 这样写也可以
      
      myOtherMethod(params) {
        // ...do something else
      }
    };

    这里 objectName 是一个已经存在的对象,methodname 是方法的名称,而 function_name 是函数的名称。

    你可以在对象的上下文中象这样调用方法:

    object.methodname(params);

    你可以在对象的构造函数中包含方法定义来为某个对象类型定义方法。例如,你可以为之前定义的 car 对象定义一个函数格式化并显示其属性:

    function displayCar() {
      var result = "A Beautiful " + this.year + " " + this.make
        + " " + this.model;
      pretty_print(result);
    }

    这里 pretty_print 是一个显示横线和一个字符串的函数。注意使用 this 指代方法所属的对象。

    你可以在对象定义中通过增加下述语句将这个函数变成 Car 的方法:

    this.displayCar = displayCar;

    因此,Car 的完整定义看上去将是:

    function Car(make, model, year, owner) {
      this.make = make;
      this.model = model;
      this.year = year;
      this.owner = owner;
      this.displayCar = displayCar;
    }

    然后你可以按如下方式为每个对象调用 displayCar 方法:

    car1.displayCar();
    car2.displayCar();

    4.5.1.2通过this引用对象

    JavaScript 有一个特殊的关键字 this,它可以在方法中使用以指代当前对象。例如,假设你有一个名为 validate 的函数,它根据给出的最大与最小值检查某个对象的 value 属性:

    function validate(obj, lowval, hival) {
      if ((obj.value < lowval) || (obj.value > hival)) {
        alert("Invalid Value!");
      }
    }

    然后,你可以在每个元素的 onchange 事件处理器中调用 validate,并通过 this 传入相应元素,代码如下:

    <input type="text" name="age" size="3"
      onChange="validate(this, 18, 99)">

    总的说来, this 在一个方法中指调用的对象。

    当与 form 属性一起使用时,this 可以指代当前对象的父窗体。在下面的例子中,窗体 myForm 包含一个 Text 对象和一个按钮,当用户点击按键,Text 对象的值被设为窗体的名称。按钮的 onclick 事件处理器使用 this.form 以指代其父窗体,即 myForm

    <form name="myForm">
    <p><label>Form name:<input type="text" name="text1" value="Beluga"></label>
    <p><input name="button1" type="button" value="Show Form Name"
         onclick="this.form.text1.value = this.form.name">
    </p>
    </form>

    4.5.1.3定义 getters 与 setters

    一个 getter 是一个获取某个特定属性的值的方法。一个  setter 是一个设定某个属性的值的方法。你可以为预定义的或用户定义的对象定义 getter 和 setter 以支持新增的属性。定义 getter 和 setter 的语法采用对象字面量语法。

    下面例子描述了getters 和 setters 是如何为用户定义的对象 o 工作的。

    var o = {
      a: 7,
      get b() { 
        return this.a + 1;
      },
      set c(x) {
        this.a = x / 2
      }
    };
    
    console.log(o.a); // 7
    console.log(o.b); // 8
    o.c = 50;
    console.log(o.a); // 25

    o 对象的属性如下:

    • o.a — 数字
    • o.b — 返回 o.a + 1 的 getter
    • o.c — 由  o.c 的值所设置 o.a 值的 setter

    请注意在一个对象字面量语法中定义getter和setter使用"[gs]et property()"的方式(相比较于__define[GS]etter__)时,并不是获取和设置某个属性自身,容易让人误以为是"[gs]et propertyName(){ }"这样错误的使用方法。定义一个getter或setter函数使用语法"[gs]et property()",定义一个已经声明的函数作为的getter和setter方法,使用Object.defineProperty(或者 Object.prototype.__defineGetter__ 旧语法回退)

    下面这个例子展示使用getter和setter方法扩展 Date原型,为预定义好的Date类添加一个year的属性。定义属性year的getter和setter方法用到了Date类中已存在的getFullYear和setFullYear方法。

    定义属性year的getter和setter:

    var d = Date.prototype;
    Object.defineProperty(d, "year", {
      get: function() { return this.getFullYear() },
      set: function(y) { this.setFullYear(y) }
    });

    通过一个Date对象使用getter和setter:

    var now = new Date();
    console.log(now.year); // 2000
    now.year = 2001; // 987617605170
    console.log(now);
    // Wed Apr 18 11:13:25 GMT-0700 (Pacific Daylight Time) 2001

    原则上,getter 和 setter 既可以:

    • 使用 使用对象初始化器 定义
    • 也可以之后随时使用 getter 和 setter 添加方法添加到任何对象

    当使用 使用对象初始化器 的方式定义getter和setter时,只需要在getter方法前加get,在setter方法前加set,当然,getter方法必须是无参数的,setter方法只接受一个参数(设置为新值),例如:

    var o = {
      a: 7,
      get b() { return this.a + 1; },
      set c(x) { this.a = x / 2; }
    };

    使用Object.defineProperties的方法,同样也可以对一个已创建的对象在任何时候为其添加getter或setter方法。这个方法的第一个参数是你想定义getter或setter方法的对象,第二个参数是一个对象,这个对象的属性名用作getter或setter的名字,属性名对应的属性值用作定义getter或setter方法的函数,下面是一个例子定义了和前面例子一样的getter和setter方法:

    var o = { a:0 }
    
    Object.defineProperties(o, {
        "b": { get: function () { return this.a + 1; } },
        "c": { set: function (x) { this.a = x / 2; } }
    });
    
    o.c = 10 // Runs the setter, which assigns 10 / 2 (5) to the 'a' property
    console.log(o.b) // Runs the getter, which yields a + 1 or 6

    这两种定义方式的选择取决于你的编程风格和手头的工作量。当你定义一个原型准备进行初始化时,可以选择第一种方式,这种方式更简洁和自然。但是,当你需要添加getter和setter方法 —— 因为并没有编写原型或者特定的对象 ——使用第二种方式更好。第二种方式可能更能表现JavaScript语法的动态特性——但也会使代码变得难以阅读和理解。

    4.5.1.3删除属性

    你可以用 delete 操作符删除一个不是继承而来的属性。下面的例子说明如何删除一个属性:

    //Creates a new object, myobj, with two properties, a and b.
    var myobj = new Object;
    myobj.a = 5;
    myobj.b = 12;
    
    //Removes the a property, leaving myobj with only the b property.
    delete myobj.a;

    如果一个全局变量不是用 var 关键字声明的话,你也可以用 delete 删除它:

    g = 17;
    delete g;

    参见delete 以获取更多信息。

    4.5.1.4比较对象

    在 JavaScript 中 objects 是一种引用类型。两个独立声明的对象永远也不会相等,即使他们有相同的属性,只有在比较一个对象和这个对象的引用时,才会返回true.

    // 两个变量, 两个具有同样的属性、但不相同的对象
    var fruit = {name: "apple"};
    var fruitbear = {name: "apple"};
    
    fruit == fruitbear // return false
    fruit === fruitbear // return false

    注意: "===" 运算符用来检查数值是否相等: 1 === "1" // return false and 1 == "1" // return true

    // 两个变量, 同一个对象
    var fruit = {name: "apple"};
    var fruitbear = fruit;  // 将fruit的对象引用(reference)赋值给 fruitbear
                            // 也称为将fruitbear“指向”fruit对象
    // fruit与fruitbear都指向同样的对象
    fruit == fruitbear // return true
    fruit === fruitbear // return true

    了解更多关于比较操作符的用法,查看 Comparison operators.

    参考:

    https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Guide/Working_with_Objects

    展开全文
  • ES6 中三种方式定义对象属性

    千次阅读 2019-12-28 16:57:15
    ES6 中三种方式定义对象属性 ...本文我们主要介绍利用三种方式初始化对象时定义属性。 1. 属性简写 属性简写即删除重复表达。这里定义两个变量: const name = "Luke"; const age = 24; 现在把这两个变量赋值给...

    ES6 中三种方式定义对象属性

    重复样本代码让开发者很不爽,代码混乱掩盖了重要业务代码。ES6关注并解决一些重复的代码方式,使代码简洁、逻辑清晰,如数组解构、对象解构、箭头函数等。本文我们主要介绍利用三种方式在初始化对象时定义属性。

    1. 属性简写

    属性简写即删除重复表达。这里定义两个变量:

    const name = "Luke";  
    const age = 24;  
    

    现在把这两个变量赋值给对象相同名称的属性,这时正常的表达为:

    {
      name: name,
      age: age
    }
    

    这里重复的名称显得多余,对的,ES6允许我们采用简洁的方式表达:

    {
      name,
      age
    }
    

    这里简单通过name代替name:name,JavaScript理解你想把name的值赋值给相同名称的属性。

    2. 方法属性

    另一个受欢迎的用法是定义方法,即通过给对象属性赋值函数来实现。为了简单,我们创建连个getter函数获取name和age属性:

    {
      getName: function() { return "Luke" },
      getAge: function() {return 24 }
    }
    

    同样这种方案也很冗长,同样ES6提供了语法糖让代码简洁:

    {
      getName() { return "Luke" },
      getAge() {return 24 }
    }
    

    3. 计算属性的名称

    最后我们看通过评估表达式确定计算属性名称的情况。

    这里定义函数getLo,简单返回字符串‘lo’。

    var getLo = () => "lo"  
    

    现在通过合并字符串定义对象属性,字符串为“hel”连接调用getLo()的返回值,其结果为"hello".

    在ES6之前,需要两步才能实现,首先初始化对象,然后使用方括号在对象中创建属性。

    var obj = {};  
    obj[ "hel" + getLo() ] = "world";  
    

    这不算太坏,但使用ES6可以直接一步完成。

    let obj2 = {  
      [ "hel" + getLo() ]: "world"
    }
    

    4. 总结

    本文介绍ES6提供三种方式定义属性让代码更简洁。

    展开全文
  • 如何list中删除我指定的对象

    万次阅读 2016-10-24 21:28:31
    Iterator是工作一个独立的线程中,并且拥有一个 mutex锁,就是说Iterator工作的时候,是不允许被迭代的对象被改变的。Iterator被创建的时候,建立了一个内存索引表(单链表),这 个索引表指向原来的对象,当...

    遍历list,删除指定对象的三种方式:
    1、再定义一个List,用来保存需要删除的对象:

    修改部分代码:

     List<User> userRemove = new ArrayList<User>();
            //找出要删除的用户
            System.err.println("要删除的用户:");
            for (User result : list)
            {
                if (result.getId() == 1 || result.getId() == 3)
                {
                    userRemove.add(result);
    
                    System.err.println("id:" + result.getId() + "\tname:" + result.getName());
                }
            }
            list.removeAll(userRemove);
    
            //剩下的用户
            System.err.println("剩下的用户:");
            for (User result : list)
            {
                System.err.println("id:" + result.getId() + "\tname:" + result.getName());
            }
    

    2、不用for-each循环,使用倒序循环删除

    for(int i=list.size()-1;i>=0;i--)
                    {
                        User result = list.get(i);
                        if (result.getId() == 3)
                        {
                            list.remove(result);
                            System.err.println("id: " + result.getId() + "\tname: " + result.getName());
                        }
                    }
    

    3、用迭代器删除

    Iterator<User> it = list.iterator();
            while (it.hasNext())
            {
                User userObj = it.next();
                if (userObj.getId() == 3)
                {
                    it.remove();
                }
            }
            //剩下的用户
            System.err.println("剩下的用户:");
            for (User result : list)
            {
                System.err.println("id:" + result.getId() + "\tname:" + result.getName());
            }
    

    PS: 用for-each遍历 实际上使用的是Iterator迭代器
    Iterator的工作机制:
    Iterator是工作在一个独立的线程中,并且拥有一个 mutex锁,就是说Iterator在工作的时候,是不允许被迭代的对象被改变的。Iterator被创建的时候,建立了一个内存索引表(单链表),这 个索引表指向原来的对象,当原来的对象数量改变的时候,这个索引表的内容没有同步改变,所以当索引指针往下移动的时候,便找不到要迭代的对象,于是产生错 误。List、Set等是动态的,可变对象数量的数据结构,但是Iterator则是单向不可变,只能顺序读取,不能逆序操作的数据结构,当 Iterator指向的原始数据发生变化时,Iterator自己就迷失了方向。
    三种方式 方便以后学习 !

    展开全文
  • 存储和文件存储是我们比较熟悉的两种主流的存储类型,而对象存储(Object-based Storage)是一种新的网络存储架构,基于对象存储技术的设备就是对象存储设备(Object-based Storage Device)简称OSD。  首先...
  • 深入剖析kubernetes的API对象类型定义

    万次阅读 2019-10-14 22:46:07
    目录 1.背景 2.分析 2.1api 2.2metav1 2.2.1MetaType ...初学kuberentes的时候,笔者作为码农就非常好奇它的代码实现。于是开始git clone代码,首先就被kuberentes的代码仓库搞蒙了,kuberent...
  • DICOM标准之三_信息对象定义1

    千次阅读 2012-07-17 14:52:38
    第3部分 信息对象定义(1) 1.应用范围和层次 Dicom标准的本部分明确了一套信息对象定义(IOD),提供了可应用于数字医疗信息的真实世界对象的抽象定义。 对于每个IOD,本部分明确了: 1)IOD语义描述的任何所需信息; 2...
  • 计算机存储的发展(存储,文件存储,对象存储)

    万次阅读 多人点赞 2018-09-15 15:04:08
    存储 DAS SAN 文件存储 存储和文件存储异同: 对象存储 1、对象 2、对象存储设备 3、元数据服务器(Metadata Server,MDS) 4、对象存储系统的客户端Client 三者之间异同比较 参考文献 如果要实现一个...
  • 文章目录准备知识定义唯一约束使用SSMS工具定义唯一约束使用SQL方式定义唯一约束方式一:创建数据表的时候定义唯一约束方式二:修改数据表定义唯一约束删除唯一约束使用SSMS工具删除唯一约束方式一:在对象资源...
  • 出现这种报错,往往是代码标签里面有重复的属性,之前Chrome下打开一直是正常的,但是换成IE11版本会报错,那是因为IE容错率比较低,要求代码严格性,所以需要找出代码的标签里重复的选项,删除掉重复的就可以了。...
  • 一、Pod Kubernetes为每个Pod都分配了唯一的IP地址,称之为Pod IP,一个Pod里的多个容器共享Pod IP地址。...因此,Kubernetes里,一个Pod里的容器与另外主机上的Pod容器能够直接通信。Pod有两种类...
  • JS的对象与内置对象详细介绍

    万次阅读 多人点赞 2019-07-06 23:53:50
    JS的对象就是Object,还有独立于宿主环境的ECMAScript实现提供的内置对象:Array,String,Date,Math。。。 首先我们来学习一下JS的对象: Object: JS里有一句话叫万物皆对象(除了基本数据类型)。但是new String(’...
  • https://blog.csdn.net/enweitech/article/details/51445087 存储和文件存储是我们比较熟悉的两种主流的存储类型,而对象存储(Object-based Storage)是一种新的网络存储架构,基于对象存储技术的设备就是对象...
  • delphi中TObjectList删除对象

    千次阅读 2015-04-16 17:34:01
    TObjectList删除对象,内存泄露
  • 很多情况下要求当前的程序中只有一个object。... 当我们程序中声明一个对象时,编译器为调用构造函数(如果有的话),而这个调用通常是外部的,也就是说它不属于class对象本身的调用,假如构造函数是私
  • //必须先删除左右子女树再删除自己,若先删除自己,则leftChlid,rightChild不存在,无法访问子女树 } } template BinTreeNode<T> * BinaryTree<T>::GetParent(BinTreeNode<T> * subTree, BinTreeNode<T> ...
  • 创建用户定义函数。这是一个已保存 Transact-SQL 或公共语言运行 (CLR) 例程,该例程可返回一个值。用户定义函数不能用于...用户定义函数可使用 ALTER FUNCTION 修改,使用 DROP FUNCTION 删除。 Transact-SQL 语法
  • js对象操作,删除某个属性

    千次阅读 2018-11-13 19:48:36
    js对象操作,删除某个属性
  • 尽量做到原创。如果转载,请注明出处!  ...这种错误很明显,如果for循环的时候是不允许删除这个list对象的。 这个相必大家都知道为什么会这样,因为ArrayList的父类AbstractList里有个modCount
  • java面向对象

    万次阅读 多人点赞 2018-08-21 16:51:59
    本文内容是根据毕晓东老师的视频教程总结而得。包括面向对象概念、类与对象的关系、封装、构造函数、this关键字、... 面向对象功能封装进对象,强调具备了功能的对象 面向对象是基于面向过程的 面向过程例子: ...
  • JSP九大内置对象

    万次阅读 多人点赞 2019-02-28 15:52:26
    JSP提供了由容器实现和管理的内置对象,也可以称之为隐含对象,由于JSP使用Java作为脚本语言,所以JSP具有强大的对象处理...使用JSP内置对象时,不需要先定义这些对象,直接使用即可。 JSP中一共预先定义了...
  • 【C++】C++类和对象、构造函数和析构函数

    千次阅读 多人点赞 2018-06-03 20:32:37
    它即可包含描述事物的数据,又可包含处理这些数据的函数,类程序运行是被用作样板来建立对象的。所以要建立对象,首先必须定义类。 定义定义一个类的一般格式为: class 类名{ private: 成员表1; public:...
  • 面向对象总结

    千次阅读 多人点赞 2019-09-03 23:17:49
    面向对象 什么是面向对象 面向对象和面向过程对比 面向对象: 面向对象是宏观的上为用户解决功能需求,用户只需要知道怎么用对象实现功能就好了,具体底层...类是对象的抽象,是将对象的相同部分提取出来 对象: ...
  • 前言ECMAScript中我觉得非常重要的一就是对于对象的理解了,就我个人而言,我的理解还是不够透彻的; 所以这篇文章不扯多深,只扯扯比较表层的知识;何为面向对象面向对象定义是比较好比喻的,比如一个人,有什么特征...
  • java Map接口定义和常用方法

    千次阅读 2018-11-07 22:36:37
    java Map接口定义和常用方法1.Map接口的定义2.Map常用方法 1.Map接口的定义 ...Map 中的 key 用Set来存放,不允许重复,即同一个 Map 对象所对应的类,须重写hashCode()和equals()方法。 常用Stri...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 435,715
精华内容 174,286
关键字:

在块定义时允许将对象删除