精华内容
下载资源
问答
  • 在块定义时允许将对象删除
    千次阅读
    2021-02-03 11:01:24

    python中对象的定义和使用

    发布时间:2020-06-22 11:57:16

    来源:亿速云

    阅读:98

    作者:Leah

    今天就跟大家聊聊有关python中对象的定义和使用,可能很多人都不太了解,为了让大家更加了解,小编给大家总结了以下内容,希望大家根据这篇文章可以有所收获。

    类(class)抽象的概念,比如说人类、鸟类、水果、是一个总的称呼,没有具体到某个物体;

    对象(object,指具体实例,instance);

    给对象增加一个实例变量

    # 增加一个skills实例变量

    p.skills = ['programming','writing']

    print(p.skills)

    #删除p对象的name实例变量,而不是删除类中变量,新建一个对象,name实例变量还是构造函数默认的。

    del p.name

    # print(p.name) 会报错

    Python 允许通过对象访问类变量 ,但如果程序通过对象尝试对类变量赋值,此时性质就变了一Python 是动态语言,赋值语句往往意味着定义新变量。因此,如果程序通过对象对类变量赋值,其实不是对“类变量赋值”,而是定义新的实例变量 。例如如下程序 。

    class Inventory:

    #定义两个变量

    quantity = 2000

    item = '鼠标'

    #定义实例方法

    def change(self,item,quantity):

    self.item = item

    self.quantity = quantity

    #创建Inventory对象

    iv = Inventory()

    iv.change('显示器',500)

    #访问iv的item和quantity实例变量

    print(iv.item) #显示器

    print(iv.quantity) #500

    #访问Inventotry的item和quantity类变量

    print(Inventory.item) #鼠标

    print(Inventory.quantity) #2000

    观点扩展:

    Python的面向对象,可以简单理解为你处理的东西都是“对象”。变量是指向一个对象的,变量名称是一个对象,相关的是namespace这个概念。类代表一类东西,是个对象。class下面的instance就是类的具体表现,相当于具备某一特征的个体,这些都是对象。

    看完上述内容,你们对python中对象的定义和使用有进一步的了解吗?如果还想了解更多相关内容,欢迎关注亿速云行业资讯频道,感谢各位的阅读。

    更多相关内容
  • 目录 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方法前加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

    展开全文
  • 存储,文件系统存储,对象存储区别 概念层级的区别 1.块级概念: 块级是指以扇区为基础,一个或我连续的扇区组成一个,也叫物理。它是文件系统与设备(例如:磁盘驱动器)之间。 2.文件级概念: 文件级是...

    块存储,文件系统存储,对象存储区别

    概念层级的区别

    1.块级概念:

    块级是指以扇区为基础,一个或我连续的扇区组成一个块,也叫物理块。它是在文件系统与块设备(例如:磁盘驱动器)之间。

    2.文件级概念:

    文件级是指文件系统,单个文件可能由于一个或多个逻辑块组成,且逻辑块之间是不连续分布。逻辑块大于或等于物理块整数倍,

    3.物理块与文件系统之间的关系图:

    映射关系:扇区→物理块→逻辑块→文件系统

    【块存储】

    典型设备:磁盘阵列,硬盘,虚拟硬盘

    传统的文件系统,是直接访问存储数据的硬件介质的。介质不关心也无法去关心这些数据的组织方式以及结构,因此用的是最简单粗暴的组织方式:所有数据按照固定的大小分块,每一块赋予一个用于寻址的编号。以大家比较熟悉的机械硬盘为例,一块就是一个扇区,老式硬盘是512字节大小,新硬盘是4K字节大小。老式硬盘用柱面-磁头-扇区号(CHS,Cylinder-Head-Sector)组成的编号进行寻址,现代硬盘用一个逻辑块编号寻址(LBA,Logical Block Addressing)。所以,硬盘往往又叫块设备(Block Device),当然,除了硬盘还有其它块设备,例如不同规格的软盘,各种规格的光盘,磁带等。

    【文件存储】
    典型设备:FTP、NFS服务器,SamBa

    把存储介质上的数据组织成目录-子目录-文件这种形式的数据结构,用于从这个结构中寻找、添加、修改、删除文件的程序,以及用于维护这个结构的程序,组成的系统有一个专用的名字:文件系统(File System)。

    【对象存储】
    典型设备:内置大容量硬盘的分布式服务器

    分布式存储的应用场景相对于其存储接口,现在流行分为三种:
    对象存储: 也就是通常意义的键值存储,其接口就是简单的GET、PUT、DEL和其他扩展,如七牛、又拍、Swift、S3

    管理这些文件和底层介质的组织结构,然后给每个文件一个唯一的标识,其它系统需要访问某个文件,直接提供文件的标识就可以了。存储系统可以用更高效的数据组织方式来管理这些标识以及其对应的存储介质上的块。

    之所以出现了对象存储这种东西,是为了克服块存储与文件存储各自的缺点,发扬它俩各自的优点。简单来说块存储读写快,不利于共享,文件存储读写慢,利于共享。能否弄一个读写快,利 于共享的出来呢。于是就有了对象存储。

    使用上的区别

    这三种存储,分别对应了不同的访问协议,这也就决定了他们的本质差别。

    先说一下文件存储,主要操作对象是文件和文件夹。以 NFS 为例,文件相关的接口包括:LOOKUP/ACCESS/READ/WRITE/CREATE/REMOVE/RENAME 等等,文件夹相关的接口包括:MKDIR/RMDIR/READDIR 等等。同时也会有 FSSTAT/FSINFO 等接口用于提供文件系统级别的信息。POSIX,SAMBA 等也是文件存储协议。协议更注重接口的灵活,以及访问权限控制。

    块存储,主要操作对象是磁盘。以 SCSI 为例,主要接口有 Read/Write/Read Capacity/Inquiry 等等。FC,iSCSI,也是块存储协议。和文件存储相比,没有文件和目录树的概念,一般协议也不会定义磁盘的创建和删除操作。协议更注重传输控制。

    对象存储,主要操作对象是对象(Object)。以 S3 为例,主要接口有 PUT/GET/DELETE 等。和文件和对象存储相比,没有随机读写的接口。和文件存储相比,没有目录树的概念。协议更注重简洁。

    分布式文件存储,块存储,对象存储

    文件、块和对象是三种以不同的方式来保存、整理和呈现数据的存储格式。这些格式各有各的功能和限制。文件存储会以文件和文件夹的层次结构来整理和呈现数据;块存储会将数据拆分到任意划分且大小相同的卷中; 对象存储会管理数据并将其链接至关联的元数据。


    什么是文件存储?

    img

    文件存储也称为文件级存储或基于文件的存储,且正如您所想:数据会以单条信息的形式存储在文件夹中,正如您将几张纸放入一个马尼拉文件夹中一样。当您需要访问该数据时,您的计算机需要知道相应的查找路径。(注意,这可能会是一条蜿蜒冗长的路径。)存储在文件中的数据会根据数量有限的元数据来进行整理和检索,这些元数据会告诉计算机文件所在的确切位置。它就像是数据文件的库卡目录。

    请试想一下塞满文件柜的储藏室。每个文档都会按照某种类型的逻辑层次结构来排放 ——按文件柜、抽屉、文件夹,然后再是纸张。“分层存储”这个术语就是这么来的,而这就是文件存储。它是适用于直接和网络附加存储系统的最古老且运用最为广泛的一种数据存储系统;而且,这种系统您可能已经用了数十年。只要您访问保存在个人计算机上的文件中的文档,您就是在使用文件存储。文件存储具有丰富多样的功能,几乎可以存储任何内容。它非常适合用来存储一系列复杂文件,并且有助于用户快速导航。

    问题是,就像文件柜一样,虚拟抽屉只能打开到一定的程度。基于文件的存储系统必须通过添置更多系统来进行横向扩展,而不是通过增添更多容量来进行纵向扩展。


    什么是块存储?

    img

    块存储会将数据拆分成块,并单独存储各个块。每个数据块都有一个唯一标识符,所以存储系统能将较小的数据存放在最方便的位置。这意味着有些数据可以存储在 Linux 环境中,有些则可以存储在 Windows 单元中。

    块存储通常会被配置为将数据与用户环境分离,并会将数据分布到可以更好地为其提供服务的多个环境中。然后,当用户请求数据时,底层存储软件会重新组装来自这些环境的数据块,并将它们呈现给用户。它通常会部署在存储区域网络 (SAN) 环境中,而且必须绑定到正常运行的服务器。

    由于块存储不依赖于单条数据路径(和文件存储一样),因此可以实现快速检索。每个块都独立存在,且可进行分区,因此可以通过不同的操作系统进行访问,这使得用户可以完全自由地配置数据。它是一种高效可靠的数据存储方式,且易于使用和管理。它适用于要执行大型事务的企业和部署了大型数据库的企业。这意味着,需要存储的数据越多,就越适合使用块存储。

    但是,块存储有一些缺点。块存储的成本高昂。它处理元数据的能力有限;这意味着,它需要在应用或数据库级别进行处理 — 开发人员或系统管理员又多了一件事要担忧。


    什么是对象存储?

    img

    对象存储,也称为基于对象的存储,是一种扁平结构,其中的文件被拆分成多个部分并散布在多个硬件间。在对象存储中,数据会被分解为称为“对象”的离散单元,并保存在单个存储库中,而不是作为文件夹中的文件或服务器上的块来保存。

    对象存储卷会作为模块化单元来工作:每个卷都是一个自包含式存储库,均含有数据、允许在分布式系统上找到对象的唯一标识符以及描述数据的元数据。元数据很重要,其包括年龄、隐私/安全信息和访问突发事件等详细信息。对象存储元数据也可以非常详细,并且能够存储与视频拍摄地点、所用相机和各个帧中特写的演员有关的信息。为了检索数据,存储操作系统会使用元数据和标识符,这样可以更好地分配负载,并允许管理员应用策略来执行更强大的搜索。

    对象存储需要一个简单的 HTTP 应用编程接口 (API),以供大多数客户端(各种语言)使用。对象存储经济高效:您只需为已用的内容付费。它可以轻松扩展,因而是公共云存储的理想之选。它是一个非常适用于静态数据的存储系统,其灵活性和扁平性意味着它可以通过扩展来存储极大量的数据。对象具有足够的信息供应用快速查找数据,并且擅长存储非结构化数据。

    当然,它也存在缺点。无法修改对象 — 您必须一次性完整地写入对象。对象存储也不能很好地与传统数据库搭配使用,因为编写对象是一个缓慢的过程,编写应用以使用对象存储 API 并不像使用文件存储那么简单。

    展开全文
  • blockly -- 定义块

    千次阅读 2020-01-10 15:00:48
    定义块 块定义描述了的外观和行为,包括文本,颜色,形状以及它可以连接的其他。...Blockly有两种定义块的方式:JSON对象和JavaScript函数。JSON格式是跨平台的,因此可以使用相同的代码Web,Android和iO...

    定义块

    块定义描述了块的外观和行为,包括文本,颜色,形状以及它可以连接的其他块。

    定义自定义块后,每个平台都会以不同的方式加载这些定义,详细信息请参见 网络和 Android特定配置指南。

     

    JSON格式与JavaScript API

    Blockly有两种定义块的方式:JSON对象和JavaScript函数。JSON格式是跨平台的,因此可以使用相同的代码在Web,Android和iOS上定义块。此外,JSON格式旨在在开发具有不同单词顺序的语言时简化本地化过程。JSON格式是定义块的首选方法。

    但是,JSON格式无法直接定义高级功能,例如变异器或验证器。这些必须以平台的本机代码,JavaScript,Java或Swift编写,通常作为 扩展

    使用Blockly的原始JavaScript实现的应用程序也可以直接将块定义写入较低级别的Blockly API函数调用,如下面的各种JavaScript示例所示。

    //javascript
    
    Blockly.Blocks['string_length'] = {
      init: function() {
        this.appendValueInput('VALUE')
            .setCheck('String')
            .appendField('length of');
        this.setOutput(true, 'Number');
        this.setColour(160);
        this.setTooltip('Returns number of letters in the provided text.');
        this.setHelpUrl('http://www.w3schools.com/jsref/jsref_length_string.asp');
      }
    };
    
    //json
    {
      "type": "string_length",
      "message0": 'length of %1',
      "args0": [
        {
          "type": "input_value",
          "name": "VALUE",
          "check": "String"
        }
      ],
      "output": "Number",
      "colour": 160,
      "tooltip": "Returns number of letters in the provided text.",
      "helpUrl": "http://www.w3schools.com/jsref/jsref_length_string.asp"
    }

    两个示例均加载相同的“ string_length”块。

    在Web上,使用initJson函数加载JSON格式。这也允许将两种格式混合在Blockly网页中。最好在可能的情况下使用JSON定义您的块,并且仅将JavaScript用于JSON不支持的部分块定义。

    以下是一个块的示例,该块主要使用JSON定义,但使用JavaScript API进行了扩展,以提供动态工具提示。

    var mathChangeJson = {
      "message0": "change %1 by %2",
      "args0": [
        {"type": "field_variable", "name": "VAR", "variable": "item", "variableTypes": [""]},
        {"type": "input_value", "name": "DELTA", "check": "Number"}
      ],
      "previousStatement": null,
      "nextStatement": null,
      "colour": 230
    };
    
    Blockly.Blocks['math_change'] = {
      init: function() {
        this.jsonInit(mathChangeJson);
        // Assign 'this' to a variable for use in the tooltip closure below.
        var thisBlock = this;
        this.setTooltip(function() {
          return 'Add a number to variable "%1".'.replace('%1',
              thisBlock.getFieldValue('VAR'));
        });
      }
    };

    Block colour

    块的主颜色由JSON colour属性block.setColour(..)函数定义,或者通过使用主题和定义块样式来定义。

    //JSON
    
    {
      // ...,
      "colour": 160,
    }
    
    //javascript
    
    init: function() {
      // ...
      this.setColour(160);
    }

    有关详细信息,请参阅块颜色指南。

    Statement Connections (块连接)

    用户可以使用nextStatement和previousStatement连接器创建块序列。在Blockly的标准布局中,这些连接位于顶部和底部,块垂直堆叠。

    带有前一个连接器的块不能有输出连接器,反之亦然。语句块是指没有值输出的块。语句块通常同时具有前一个连接和下一个连接。

    可以键入nextStatement和previousStatement连接,但标准块不使用此功能。

    Next Connection (向下连接)

    在块的底部创建一个点,以便其他语句可以堆叠在它的下面。具有下一个连接但没有上一个连接的块通常表示一个事件,并且可以配置为使用hat呈现。

    // JSON
    
    Untyped:
    
    {
      ...,
      "nextStatement": null,
    }
    
    Typed (rare):
    
    {
      "nextStatement": "Action",
      ...
    }
    
    //javascript
    
    Untyped:
    
    this.setNextStatement(true);  // false implies no next connector, the default
    
    Typed (rare):
    
    this.setNextStatement(true, 'Action');

    Previous Connection  (向上连接)

    在块的顶部创建槽口,以便它可以作为语句堆栈连接。

    具有先前连接的块不能有输出连接。

    //JSON
    
    Untyped:
    
    {
      ...,
      "previousStatement": null,
    }
    
    Typed (rare):
    
    {
      "previousStatement": "Action",
      ...
    }
    
    
    
    //javascript
    
    Untyped:
    
    this.setPreviousStatement(true);  // false implies no previous connector, the default
    
    Typed (rare):
    
    this.setPreviousStatement(true, 'Action');

    Block Output (块输出)

    块可以具有单个输出,表示为前缘上的公拼图连接器。输出连接到值输入。具有输出的块通常称为值块。

    //JSON
    
    
    Untyped:
    
    {
      // ...,
      "output": null,
    }
    
    Typed:
    
    {
      // ...,
      "output": "Number",
    }
    
    
    //javascript
    
    Untyped:
    
    init: function() {
      // ...
      this.setOutput(true);
    }
    
    Typed:
    
    init: function() {
      // ...
      this.setOutput(true, 'Number');
    }

    带有输出连接器的块也不能有前一个语句槽。

    Block Inputs

    一个块有一个或多个输入,其中每个输入是可能以连接结束的标签和字段序列。有三种输入类型,与连接类型匹配:

    Value input:连接到值块的输出连接。math_算术块(加法、减法)是具有两个值输入的块的示例。

    Statement input:连接到语句块的前一个连接。while循环的嵌套部分是语句输入的一个示例。

    Dummy input:没有块连接。当块被配置为使用外部值输入时,其行为类似于换行符。

    JSON格式和JavaScript API使用稍微不同的模型来描述它们的输入。

    Inputs and Fields in JSON

    JSON定义的块被构造为一个插值消息字符串序列(message0、message1,…),其中每个插值标记(%1、%2,…)是匹配的JSON argsN数组中的字段或输入端(因此,在消息中输入连接器呈现)。这种格式旨在使国际化变得容易。

    {
      "message0": "set %1 to %2",
      "args0": [
        {
          "type": "field_variable",
          "name": "VAR",
          "variable": "item",
          "variableTypes": [""]
        },
        {
          "type": "input_value",
          "name": "VALUE"
        }
      ]
    }

    插值标记必须与args0数组完全匹配:无重复,无遗漏。标记可以以任何顺序出现,这允许不同的语言更改块的布局。

    插值标记两边的文本将被空格修剪。使用字符的文本(例如,当引用百分比时)应使用%%,这样它就不会被解释为插值标记。

    参数的顺序和参数类型定义块的形状。更改其中一个字符串可以完全更改块的布局。这在语序与英语不同的语言中尤为重要。假设有一种语言,其中“set%1 to%2”(如上面的例子中所使用的)需要颠倒过来,表示“put%2 in%1”。更改这一个字符串(并保持JSON的其余部分不变)将导致以下块:

    块自动改变字段的顺序,创建一个虚拟输入,并从外部输入切换到内部输入。

    Args

    每个消息字符串都与一个相同编号的args数组配对。例如,message0 与args0一起使用。插值标记(%1、%2,…)引用args数组的项。每个对象都有一个类型字符串。其余参数因类型而异:

    每个对象也可能有alt字段。如果Blockly无法识别对象的类型,则使用alt对象代替它。例如,如果将名为field_time的新字段添加到Blockly,则使用此字段的块可以使用alt为Blockly的旧版本定义field_input fallback:

    {
      "message0": "sound alarm at %1",
      "args0": [
        {
          "type": "field_time",
          "name": "TEMPO",
          "hour": 9,
          "minutes": 0,
          "alt":
            {
              "type": "field_input",
              "name": "TEMPOTEXT",
              "text": "9:00"
            }
        }
      ]
    }

    alt对象可能有自己的alt对象,因此允许链接。最后,如果Blockly无法在args0数组中创建对象(在尝试任何alt对象之后),则只跳过该对象。

    如果消息字符串以不包含在输入中的文本或字段结尾,则将自动在块的末尾添加一个伪输入。因此,如果块上的最后一个输入是伪输入,则可以从args数组中省略它,并且不需要在消息中插入。自动添加拖尾伪输入允许转换器更改消息,而无需修改JSON的其余部分。请参阅本页前面的“将%1设置为%2”(无伪输入)和“将%2放入%1”(添加了伪输入)示例。

    lastDummyAlign0

    在极少数情况下,自动创建的尾部伪输入需要与“右”或“中心”对齐。如果未指定,则默认值为“左”。

    在下面的示例中,message0 is "send email to %1 subject %2 secure %3" ,并为第三行自动添加一个虚拟输入。将lastDummyAlign0设置为“RIGHT”将强制此行右对齐。

    在为RTL(阿拉伯语和希伯来语)设计块时,左右颠倒。因此,“RIGHT”将字段与左边对齐。

    message1args1lastDummyAlign1

    有些区块自然分成两个或多个独立的部分。考虑这个重复块,它有两行:

    如果用单个消息描述此块,则message0属性将为“repeat %1次%2执行%3”。这个字符串对于翻译来说很难理解,很难解释%2替换意味着什么。在某些语言中甚至可能不需要%2伪输入。可能有多个块希望共享第二行的文本。一种更好的方法是JSON使用多个消息和args属性:

    {
      "type": "controls_repeat_ext",
      "message0": "repeat %1 times",
      "args0": [
        {"type": "input_value", "name": "TIMES", "check": "Number"}
      ],
      "message1": "do %1",
      "args1": [
        {"type": "input_statement", "name": "DO"}
      ],
      "previousStatement": null,
      "nextStatement": null,
      "colour": 120
    }

    任何数量的消息、参数和lastDummyAlign属性都可以用JSON格式定义,从0开始并按顺序递增。请注意,块工厂不能将消息拆分为多个部分,但手动执行此操作非常简单。

    Inputs and Fields in JavaScript

    JavaScript API为每个输入类型都包含一个append方法:

    this.appendDummyInput()
        .appendField('for each')
        .appendField('item')
        .appendField(new Blockly.FieldVariable());
    this.appendValueInput('LIST')
        .setCheck('Array')
        .setAlign(Blockly.ALIGN_RIGHT)
        .appendField('in list');
    this.appendStatementInput('DO')
        .appendField('do');

    每个方法都可以采用由代码生成器使用的标识符字符串。虚拟输入很少需要引用,标识符通常不设置。

    如上所示,每个方法都通过方法链返回要配置的输入对象。有三个功能用于配置输入。

    setCheck

    input.setCheck('Number');

    此可选功能用于连接输入的类型检查。如果给定的参数为null(默认值),则此输入可以连接到任何块。有关详细信息,请参见类型检查。

    setAlign

    input.setAlign(Blockly.ALIGN_RIGHT);

    此可选功能用于对齐字段(请参见下文)。有三个自描述性值可以作为参数传递给此函数:Blockly.ALIGN_LEFT、Blockly.ALIGN_RIGHT和Blockly.ALIGN_CENTRE。注意“center”的英国拼写。默认为左对齐。

    在为RTL(阿拉伯语和希伯来语)设计块时,左右颠倒。因此Blockly.ALIGN_RIGHT会将字段左对齐。

    appendField

    一旦创建了输入并将其附加到带有append input的块中,就可以选择将任意数量的字段附加到输入中。这些字段通常用作描述每个输入的用途的标签。

    input.appendField('hello');

    最简单的字段元素是文本。Blockly的惯例是使用所有小写文本,但专有名称除外(例如Google、SQL)。

    输入行可以包含任意数量的字段元素。可以将多个appendField调用链接在一起,以便有效地将多个字段添加到同一输入行。

    input.appendField('hello')
         .appendField(new Blockly.FieldLabel('Neil', 'person'));

    appendField('hello')调用实际上是使用显式FieldLabel构造函数的快捷方式:appendField(new Blockly.FieldLabel('hello'))。只有在指定类名时才希望使用构造函数,以便可以使用CSS规则对文本进行样式设置。

    Inline vs. External

    块输入可以呈现为外部或内部。

    块定义可以指定可选的布尔值,以控制输入是否内联。如果为false,则任何值输入都将是外部的(例如左块)。如果为true,则任何值输入都将内联(如上面的右块)。

    //json
    {
      // ...,
      "inputsInline": true
    }
    
    //javascript
    init: function() {
      // ...
      this.setInputsInline(true);
    }

    如果没有定义,那么Blockly将使用一些启发式方法来猜测哪种模式是最好的。假设Blockly做出了正确的选择,最好不定义这个字段,因为不同的语言翻译可以自动具有不同的模式。请参阅本页前面的JSON示例“将%1设置为%2”(外部输入)和“将%2放入%1”(内联输入)。

    当块可能有小的输入(如数字)时,使用内联输入。如果启用折叠配置(如果工具箱具有类别,则默认为true),则用户可以通过上下文菜单切换此选项。

    Fields

    字段定义块中的UI元素。其中包括字符串标签、图像和文本数据(如字符串和数字)的输入。最简单的例子是math_number块,可以是field_input(web)或field_number(Android)来输入数字。

    Blockly提供了许多内置字段,包括文本输入、颜色选择器和图像。也可以创建自己的字段。

    有关 built-in fields.的更多信息。

    有关creating custom fields.的详细信息。

    Tooltips

    当用户将鼠标悬停在块上时,工具提示提供即时帮助。如果文本很长,它将自动换行。

    //json
    {
      // ...,
      "tooltip": "Tooltip text."
    }
    
    
    //javascript
    init: function() {
      this.setTooltip("Tooltip text.");
    }

    在JavaScript API中,工具提示也可以定义为函数而不是静态字符串。这允许动态帮助。有关工具提示的示例,请参见math_算术,该工具提示会根据选择的下拉选项而更改。

    Blockly.Blocks['math_arithmetic'] = {
      init: function() {
        // ...
    
        // Assign 'this' to a variable for use in the tooltip closure below.
        var thisBlock = this;
        this.setTooltip(function() {
          var mode = thisBlock.getFieldValue('OP');
          var TOOLTIPS = {
            'ADD': Blockly.Msg.MATH_ARITHMETIC_TOOLTIP_ADD,
            'MINUS': Blockly.Msg.MATH_ARITHMETIC_TOOLTIP_MINUS,
            'MULTIPLY': Blockly.Msg.MATH_ARITHMETIC_TOOLTIP_MULTIPLY,
            'DIVIDE': Blockly.Msg.MATH_ARITHMETIC_TOOLTIP_DIVIDE,
            'POWER': Blockly.Msg.MATH_ARITHMETIC_TOOLTIP_POWER
          };
          return TOOLTIPS[mode];
        });
      }
    };

    使用JavaScript API,块可以指定一个函数,而不是返回工具提示字符串的静态字符串。这允许动态工具提示。例如,参见数学。

    Help URL

    块可以具有与其关联的帮助页。Blockly for Web的用户可以通过右键单击该块并从上下文菜单中选择“帮助”来使用它。如果此值为空,则菜单将灰显。

    //JSON
    {
      // ...,
      "helpUrl": "https://en.wikipedia.org/wiki/For_loop"
    }
    
    //javascript
    
    init: function() {
      // ...
      this.setHelpUrl('https://en.wikipedia.org/wiki/For_loop');
    }

    使用JavaScript API,块可以指定一个函数,而不是返回URL字符串的静态字符串,从而允许动态帮助。

    Change Listeners and Validators

    块可以具有对工作区的任何更改(包括与块无关的更改)调用的更改侦听器函数。它们主要用于设置块的警告文本或工作区外的类似用户通知。

    通过使用函数调用setOnChange来添加该函数,如果计划在所有平台上使用它,则可以在init期间或通过JSON扩展来完成。

    //JSON 
    {
      // ...,
      "extensions":["warning_on_change"],
    }
    
    Blockly.Extensions.register('warning_on_change', function() {
      // Example validation upon block change:
      this.setOnChange(function(changeEvent) {
        if (this.getInput('NUM').connection.targetBlock()) {
          this.setWarningText(null);
        } else {
          this.setWarningText('Must have an input block.');
        }
      });
    });
    
    
    //javascript
    Blockly.Blocks['block_type'] = {
      init: function() {
        // Example validation upon block change:
        this.setOnChange(function(changeEvent) {
          if (this.getInput('NUM').connection.targetBlock()) {
            this.setWarningText(null);
          } else {
            this.setWarningText('Must have an input block.');
          }
        });
      }
    }

    系统调用函数,传递change事件。在函数内部,这指的是块实例。

    因为函数是在任何更改时调用的,如果使用,开发人员应该确保监听器快速运行。还应该注意对工作区的更改,这些更改可能会层叠或循环回侦听器。

    有关示例,请参阅controls_flow_statements、logic_compare和procedures_ifreturn块。

    请注意,可编辑字段有自己的事件侦听器,用于输入验证并产生副作用。

    Mutator

    变异器允许高级块更改形状,特别是当用户打开一个对话框来添加、删除或重新排列组件时。可以使用mutator键通过JSON添加mutator。

    {
      // ...,
      "mutator":"if_else_mutator"
    }

    Per-block configuration

    块实例具有许多属性,可配置它们对用户的行为方式。它们可以用来约束工作区以反映域的某些属性(例如,只有一个“开始”事件),或者集中用户的精力(例如,教程)。

    Deletable State

    默认情况下,用户可以删除可编辑工作区(而不是只读)上的任何块。有时,使某些块成为永久性固定装置是有用的。例如,教程框架代码。

    block.setDeletable(false);

    任何块,包括那些标记为不可删除的块,都可以通过编程方式删除:

    block.dispose();

    Editable State

    block.setEditable(false); 

    当设置为false时,用户将无法更改块的字段(例如下拉列表和文本输入)。块在可编辑工作空间上默认为可编辑。

    Movable State

    block.setMovable(false); 

    当设置为false时,用户将无法直接移动块。作为另一个块的子块的不可移动块不能从该块断开,尽管如果父块被移动,它将与其父块一起移动。

    块默认为在可编辑工作空间上可移动。

    任何块(甚至是不可移动的块)一旦在工作区上,就可以通过编程方式移动。在JavaScript中,调用block.moveBy(dx,dy)。除非另有指定,否则工作区上块的起始位置默认为(0,0)。

    Block data (web only)

    this.data = '16dcb3a4-bd39-11e4-8dfc-aa07a5b093db';  // Web only

    数据是附加到块的可选任意字符串。当保存为XML时,数据字符串存储在一个<data></data>标记中,以便它可以往返返回到一个块。使用数据字符串将块与外部资源关联或用于任何其他自定义目的。

    请注意,如果块被复制或复制/粘贴,则数据字符串也会被复制。无法复制或复制/粘贴不可删除的块。

     

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

    千次阅读 2019-12-28 16:57:15
    ES6 中三种方式定义对象属性 ...本文我们主要介绍利用三种方式初始化对象时定义属性。 1. 属性简写 属性简写即删除重复表达。这里定义两个变量: const name = "Luke"; const age = 24; 现在把这两个变量赋值给...
  • java中,使用sonarqube的时候,string类型的代码不允许直接使用未经定义的常量,什么是未经定义的产量呢?下面举个例子: //这个会报未经定义的常量 String value = "常量"; 一开始想到的解决方案...
  • 其他浏览器正常。ie中报错的代码: &lt;el-select filterable clearable v-model="Form.PlaceProvId" placeholder="选项" filterable clearable style="width:100px" @...
  • VUe实例会初始化实例,对属性执行getter/setter的转化过程,所以属性必须得是data对象上存在的,才可以让Vue转化它,这样才能让它是响应式的。 let vm = new Vue({ data:{ a:1 } }) //vm.a是响应式的 vm.b=2 ...
  • 计算机存储的发展(存储,文件存储,对象存储)

    万次阅读 多人点赞 2018-09-15 15:04:08
    存储 DAS SAN 文件存储 存储和文件存储异同: 对象存储 1、对象 2、对象存储设备 3、元数据服务器(Metadata Server,MDS) 4、对象存储系统的客户端Client 三者之间异同比较 参考文献 如果要实现一个...
  • c语言中引用数组元素,其数组下标的数据类型允许是:整型常量或整型表达式。C语言规定只能逐个引用数组元素而不能一次引用整个数组,数据元素的表示形式为“数组名[下标]”,下标可以是整型常量...
  • 如何list中删除我指定的对象

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

    千次阅读 2011-06-23 09:22:00
    一,概述Java语言中,我们可以定义自己的类,并根据这些类创建对象来使用,Javascript中,我们也可以定义自己的类,例如定义User类、Hashtable类等等。目前Javascript中,已经存在一些标准的类,例如Date、...
  • https://blog.csdn.net/enweitech/article/details/51445087 存储和文件存储是我们比较熟悉的两种主流的存储类型,而对象存储(Object-based Storage)是一种新的网络存储架构,基于对象存储技术的设备就是对象...
  • TypeScript系列:(三) 对象类型

    千次阅读 2022-03-23 17:18:04
    前面的章节中,我们已经了解到了对象的基本使用。可以用字面量、interface、type alias来规定一个普通的对象类型。现在是时候了解一下常用的对象属性修饰符、类型拓展、索引签名和内置的特殊对象类型了。 还没有...
  • 【C++】C++类和对象、构造函数和析构函数

    千次阅读 多人点赞 2018-06-03 20:32:37
    它即可包含描述事物的数据,又可包含处理这些数据的函数,类程序运行是被用作样板来建立对象的。所以要建立对象,首先必须定义类。 定义定义一个类的一般格式为: class 类名{ private: 成员表1; public:...
  • 文章目录准备知识定义唯一约束使用SSMS工具定义唯一约束使用SQL方式定义唯一约束方式一:创建数据表的时候定义唯一约束方式二:修改数据表定义唯一约束删除唯一约束使用SSMS工具删除唯一约束方式一:在对象资源...
  • 深入剖析kubernetes的API对象类型定义

    万次阅读 多人点赞 2019-10-14 22:46:07
    目录 1.背景 2.分析 2.1api 2.2metav1 2.2.1MetaType ...初学kuberentes的时候,笔者作为码农就非常好奇它的代码实现。于是开始git clone代码,首先就被kuberentes的代码仓库搞蒙了,kuberent...
  • 三种存储类型比较-文件、对象存储

    万次阅读 多人点赞 2016-07-26 09:09:28
    存储和文件存储是我们比较熟悉的两种主流的存储类型,而对象存储(Object-based Storage)是一种新的网络存储架构,基于对象存储技术的设备就是对象存储设备(Object-based Storage Device)简称OSD。  首先...
  • 文章目录《C++面向对象程序设计》✍千处细节、万字总结一、面向对象程序设计二、C++基础2.1 C++的产生和特点2.2 一个简单的C++示例程序2.3 C++非面向对象方面对C语言的扩充输入和输出cinconst修饰符void型指针内联...
  • vue中,改变某个对象的值(如数组中的某一项或者对象的某个属性),vue并不会触发dom更新,这时就需要我们自己手动来操作。 方法一:强制刷新 // 此行为会重新渲染整个dom,除数据层次太多外,不建议使用 ...
  • java面向对象

    万次阅读 多人点赞 2018-08-21 16:51:59
    本文内容是根据毕晓东老师的视频教程总结而得。包括面向对象概念、类与对象的关系、封装、构造函数、this关键字、... 面向对象功能封装进对象,强调具备了功能的对象 面向对象是基于面向过程的 面向过程例子: ...
  • 类体内定义的成员函数称为内联函数。 5.1.1 类的定义格式 class &lt;类名&gt; //声明部分、 { public: &lt;公有数据成员和成员函数的声明或实现&gt; protected: &lt;保护数据成员和成员函数的...
  • 函数中的声明和变量的定义

    千次阅读 2019-04-14 19:44:13
    某些编程语言里,函数声明和函数定义区分开的,一个函数声明包括提供对函数名,参数的名字(传统上还有参数的类型),但不必给出函数的任何代码,具体的代码通常属于函数定义的范畴。 ​ 声明和定义有区别的...
  • 版权归作者所有,任何形式转载请联系作者。 作者:U_U(来自豆瓣) ... JavaScript 中, 如何让一个对象是不可变的? 即 immutable, 让这个...假象一下这样的场景, 我们写了一个 JS, 其中定义了一个对象, 会开放出来...
  • 上一篇我们提到了typescript中对于对象定义和使用,俗话说"万物皆对象",这里我们就来说一下另一个特别的对象---数组。 网上有很多对于数组的定义,例如:数组对象是使用单独的变量名来存储一系列的值,简单...
  • JSP九大内置对象

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

    万次阅读 多人点赞 2018-05-20 12:40:59
    面向对象基础面向对象三大特性封装性:数据和代码捆绑一起,避免外界...继承可以扩展已存在的代码多态性:同一事物表现出不同事物的能力,即向不同对象发送同一消息,不同的对象在接收会产生不同的行为(重载...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 514,992
精华内容 205,996
关键字:

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