一、获取对象属性和方法
 
Object.keys() 返回对象的可枚举属性和方法的名称数组。
 
Object.getOwnPropertyNames() 返回的数组的所有属性(可枚举或不可枚举)直接找到给定对象。
 
 1     // 创建一个对象的构造方法
 2     function myObj(name, attr) {
 3         this.name = name;
 4         this.attr = attr;
 5 
 6         this.sayHi = function () {
 7             return 'hi everyone!!!';
 8         }
 9     }
10 
11     // 创建一个对象
12     var myTester = new myObj("shinejaie", 1)
13     // 获取直接在对象上定义(可枚举)的属性和方法
14     var arr = Object.keys(myTester);
15     console.log('arr', arr); // 输出 arr ["name", "attr", "sayHi"]
16 
17     // 返回的数组的所有属性(可枚举或不可枚举)直接找到给定对象。
18     console.log("attr", Object.getOwnPropertyNames(myTester)); // 输出 attr ["name", "attr", "sayHi"]
19 
20     // 在 Object 原型上增加一个属性
21     Object.prototype.newShine = "it's me";
22 
23     // 返回可枚举属性一直找到该对象的原型链
24     for (var i in myTester) {
25         console.log(i);
26     }
27     // 输出 name,attr,sayHi,newShine
28 
29     // 返回直接定义在该对象上的可枚举属性
30     for (var i in myTester) {
31         if (myTester.hasOwnProperty(i)) {
32             console.log(i);
33         }
34     }
35     // 输出 name,attr,sayHi
 
二、Object.keys()、Object.getOwnPropertyNames()、for...in...对比
 
 
 
 1    // 不可枚举的对象属性
 2     var nonenum = Object.create({}, {
 3         getFoo: {
 4             value: function () {
 5                 return this.foo;
 6             },
 7             enumerable: false
 8         }
 9     });
10     nonenum.foo = 1;
11     nonenum.asj = 2;
12 
13     // 获取对象可枚举或不可枚举的属性
14     console.log(Object.getOwnPropertyNames(nonenum).sort()); // 输出 ["asj", "foo", "getFoo"]
15 
16     // 获取对象可枚举的属性
17     console.log(Object.keys(nonenum).sort()); // 输出 ["asj", "foo"]
18 
19     // 返回直接定义在该对象上的可枚举属性
20     for (var i in nonenum) {
21         if (nonenum.hasOwnProperty(i)) {
22             console.log(i); // 输出 foo asj
23         }
24     }
 
 
 
 三、分别获取JavaScript对象属性名和方法名
 
 
 
 1     // 创建一个对象的构造方法
 2     function myObj(name, attr) {
 3         this.name = name;
 4         this.attr = attr;
 5 
 6         this.sayHi = function () {
 7             return 'hi everyone!!!';
 8         }
 9     }
10 
11     // 创建一个对象
12     var myTester = new myObj("shinejaie", 1)
13 
14     // 获取对象方法
15     for (var i in myTester) {
16         if (myTester.hasOwnProperty(i) && typeof myTester[i] == "function") {
17             console.log("对象方法: ", i, "=", myTester[i])
18         }
19     }
20     // 输出 对象方法: sayHi = () { return 'hi everyone!!!'; }
21 
22     // 获取对象属性
23     for (var i in myTester) {
24         if (myTester.hasOwnProperty(i) && typeof myTester[i] != "function") {
25             console.log("对象属性: ", i);
26         }
27     }
28     // 输出 对象属性: name 对象属性: attr
 
 
 

JavaScript 使用 
for in 语句来遍历对象的属性和方法。for in 语句循环遍历 JavaScript 对象，每循环一次，都会取得对象的一个属性或方法。

 

 语法：

 
for(valueName  in  ObjectName){
     // 代码
 }

 其中，valueName 是变量名，保存着属性或方法的名称，每次循环，valueName 的值都会改变。

 

 
【例5-1】遍历zhangsan对象：
 
 
var zhangsan={}
zhangsan.name = "张三";
zhangsan.sex = "男";
zhangsan.say = function(){
        return "嗨！大家好，我来了。";
    }
zhangsan.contact = {
    tel : "029-81895644",
    qq : "1370753465",
    email : "itxueyuan@gmail.com"
}
var strTem="";  // 临时变量
for(value in zhangsan){
   strTem+=value+'：'+zhangsan[value]+"\n";
}
alert(strTem);

 【例5-2】给定任意一个字符串，使用 for  in 语句来统计字符出现的个数： 
 
 
function charNum(str){
    var charObj={}
    for(i=0,len=str.length;i<len;i++){
        if(charObj[str[i]]){
            charObj[str[i]]++;
        }else{
            charObj[str[i]]=1;
        }
    }
    var strTem="";  // 临时变量
    for(value in charObj){
        strTem+='"'+value+'"的个数：'+charObj[value]+'\n';
    }
    return strTem;
}
charNum("http://www.itxueyuan.org");
charNum("134775444637722991919");
另外，for in 循环也可用来遍历数组的每个元素，与遍历对象的用法一样，后续章节将会讲解。 
 
额外一个例子：
 

function test()
{
    var obj ={};
    obj.element1 = "element one";
    obj.element2 = [1,2,3,4];
    obj.element3 = {name:"my name",age:"123"}

    var strTem="";  // 临时变量
    for(elem in obj)
    {
       strTem+=elem'：'+zhangsan[elem]+"\n";
    }
    alert(strTem);
}


 
 
原文：http://www.itxueyuan.org/view/6335.html
 
 

C#基础知识汇总：
 
一、相关概念
 
1、对象:现实世界中的实体（世间万物皆对象）
 
　　对象，即系统中用于描述客观事物的一个实体，是构成系统的一个基本单位。
 
2、类:具有相似属性和方法的对象的集合
 
　　是具有相同数据成员和函数成员的一组对象的集合，它为属于该类的全部对象提供了抽象的描述。
 
3、面向对象程序设计的特点:封装 继承 多态
 
　　封装：面向对象技术中的封装，简单来说就是将代码及其处理的数据绑定在一起，形成一个独立单位，对外实现完整功能，并尽可能隐藏对象的内部细节 。
 　　继承：继承（Inheritance）也称作派生，指的是特殊类的对象自动拥有一般类的全部数据成员与函数成员（构造函数和析构函数除外）。
 　　多态：多态性（Polymorphism）是指一般类中定义的属性或行为，被特殊类继承之后，可以具有不同的数据类型或表现出不同的行为。
 
面向对象三要素是：封装 继承 多态
 
 
封装
 
 封装就是事物抽象为类，把对外接口暴露，将实现和内部数据隐藏。
 
继承
 
面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。
 
通过继承创建的新类称为“子类”或“派生类”。
 
被继承的类称为“基类”、“父类”或“超类”。
 
继承的过程，就是从一般到特殊的过程。
 
要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。
 
在某些 OOP 语言中，一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。
 
 
 
继承概念的实现方式有三类：实现继承、接口继承和可视继承。
 
Ø         实现继承是指使用基类的属性和方法而无需额外编码的能力；
 
Ø         接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；
 
Ø         可视继承是指子窗体（类）使用基窗体（类）的外观和实现代码的能力。
 
在考虑使用继承时，有一点需要注意，那就是两个类之间的关系应该是“属于”关系。例如，Employee 是一个人，Manager 也是一个人，因此这两个类都可以继承 Person 类。但是 Leg 类却不能继承 Person 类，因为腿并不是一个人。
 
抽象类仅定义将由子类创建的一般属性和方法，创建抽象类时，请使用关键字 Interface 而不是 Class。
 
OO开发范式大致为：划分对象→抽象类→将类组织成为层次化结构(继承和合成) →用类与实例进行设计和实现几个阶段。
 
 
 
多态
 
多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。
 
实现多态，有二种方式，覆盖，重载。
 
覆盖，是指子类重新定义父类的虚函数的做法。
 
重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。
 
其实，重载的概念并不属于“面向对象编程”，重载的实现是：编译器根据函数不同的参 数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。对于这两个函数的 调用，在编译器间就已经确定了，是静态的（记住：是静态）。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！真正和多态相关的是 “覆盖”。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态（记住：是动态！）的调用属于子类的该函数，这样的函数调用在编译 期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚邦定）。结论就是：重载只是一种语言特性，与多态无 关，与面向对象也无关！引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚邦定，它就不是多态。”
 
那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承 可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时 候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。
 
 
 
概念讲解
 
泛化（Generalization）
 
 
图表 1 泛化
 
在上图中，空心的三角表示继承关系（类继承），在UML的术语中，这种关系被称为泛化（Generalization）。Person(人)是基类，Teacher(教师)、Student(学生)、Guest(来宾)是子类。
 
若在逻辑上B是A的“一种”，并且A的所有功能和属性对B而言都有意义，则允许B继承A的功能和属性。
 
例如，教师是人，Teacher 是Person的“一种”（a kind of ）。那么类Teacher可以从类Person派生（继承）。
 
如果A是基类，B是A的派生类，那么B将继承A的数据和函数。
 
如果类A和类B毫不相关，不可以为了使B的功能更多些而让B继承A的功能和属性。
 
若在逻辑上B是A的“一种”（a kind of ），则允许B继承A的功能和属性。
 
 
 
聚合（组合）
 
 
图表 2 组合
 
若在逻辑上A是B的“一部分”（a part of），则不允许B从A派生，而是要用A和其它东西组合出B。
 
例如，眼（Eye）、鼻（Nose）、口（Mouth）、耳（Ear）是头（Head）的一部分，所以类Head应该由类Eye、Nose、Mouth、Ear组合而成，不是派生（继承）而成。
 
 
 
聚合的类型分为无、共享(聚合)、复合(组合)三类。
 
 
 
聚合（aggregation）
 
 
 
 
图表 3 共享
 
上面图中，有一个菱形（空心）表示聚合（aggregation）（聚合类型为共享），聚合的意义表示has-a关系。聚合是一种相对松散的关系，聚合类B不需要对被聚合的类A负责。
 
 
 
组合（composition）
 
 
图表 4 复合
 
这幅图与上面的唯一区别是菱形为实心的，它代表了一种更为坚固的关系——组合（composition）（聚合类型为复合）。组合表示的关系也是has-a，不过在这里，A的生命期受B控制。即A会随着B的创建而创建，随B的消亡而消亡。
 
 
 
依赖(Dependency)
 
 
图表 5 依赖
 
这里B与A的关系只是一种依赖(Dependency)关系，这种关系表明，如果类A被修改，那么类B会受到影响。
 
4、对象的三要素：属性（对象是什么）、方法（对象能做什么）、事件（对象如何响应）
 
☆相互关系：类是对象的抽象，对象是类的实例，类是一种抽象的分类，对象则是具体事物。
 
比如如果车是一个类，某个人的一辆奔驰车就是一个对象，车的颜色质量就是它的属性，启动、停止这些动作则可以定义为车的方法
 
二、类的定义与语法
 
1、定义类：
 
[修饰符] class 类名  
 
{
 
   类成员
 
}
 
 
 
2、类的访问修饰符:public internal
 
a) public:可访问域是所在的程序和任何引用的程序 访问不受限制
 
语法:
 
 public class 类名
 
 {
 
   类成员
 
 }
 
 
 
b) internal:可访问域定义范围内 (默认访问修饰符)
 
语法：
 
(internal) class 类名
 
 {
 
   类成员
 
 }
 
 
 
3、类成员：数据成员和字段
 
a)  数据成员:字段和常量
 
字段:变量
 
声明:类型 字段名
 
例：
 
public class Persion
 {
     public string name;
 }
 
 
 
b) 方法成员 （方法是类的行为，告诉我们类能够做什么，）
 
 实例方法：
 
修饰符 返回值类型 方法名(参数列表)
 
 {
 
      方法体
 
 }
 
 修饰符：如：public、private、protected、internal
 
 返回值类型：若方法无返回值，则使用 void
 
例：
 
public class Example01  //实例方法
 
{
 
    public void SayHello()  //定义一个无参无返回的方法
 
    { 
 
    Console.WriteLine("Hello There")
 
}
 
static void Main()
 
{
 
Example01 objA=new Example01()
 
objA.SayHello()    //创建对象并调用方法
 
}
 
}
 
 
 
静态方法：
 
修饰符 static返回值类型 方法名(参数列表)  //增加了static关键字
 
 {
 
      方法体
 
 }
 
例：
 
public class Example01  //实例方法
 
{
 
    public static void SayHello()  //定义一个静态方法
 
    { 
 
    Console.WriteLine("Hello There")
 
}
 
static void Main()
 
{
 
Example01.SayHello()    //不需要创建对象
 
}
 
}
 
 
 
☆静态方法与实例方法的区别：静态方法只与类有关，它不依赖于对象的存在而存在；实例方法则在对象存在后才能使用。
 
 
 
4、成员的访问修饰符：public、private、protected、internal
 
 a)  public:公有成员
 
 b) private:私有成员
 
 c) protected:保护成员
 
 d) internal:内部成员
 
 
例：
 
 
代码如下
 
 
复制代码
 
 
using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 
namespace ConsoleApplication2
 {
     public class Employee
     {
         private float sum;
         public int day;
         public float wage;
         //定义方法输出工资信息
         public void Show()
         {
             sum = day * wage;
             Console.WriteLine("工作时间：{0}，每天工资：{1}，总工资：{2}",day,wage,sum);
         }
     }
     class Program
     {
         static void Main(string[] args)
         {
             Employee employee = new Employee();
             employee.day = 20;
             employee.wage = 50;
             //employee.sum:无法访问  因为它为私有成员
             //调用方法现实工资
             employee.Show();
         }
     }
 }
 
 
 
 
 
 
 
 
 
三、实例化对象：关键字：new
 
语法：
 
类 对象名称=new 类();
 
 
 
 
例：
 
 
代码如下
 
 
复制代码
 
 
using System; 
 using System.Collections.Generic; 
 using System.Linq; 
 using System.Text; 
   
 namespace ConsoleApplication1 
 { 
     public class car 
     { 
         private string carName; 
         private string carType; 
         private int price; 
   
         public string CarName 
         { 
             get { return carName; } 
             set { carName = value; } 
         } 
         public string CarType 
         { 
             get { return carType; } 
             set { carType = value; } 
         } 
         
         public int Price 
         { 
             get { return price; } 
             set { price = value; } 
         } 
   
         public void  action() 
         { 
             Console.WriteLine("一辆名叫{0}车，型号是{1}，价钱是：{2}",carName,carType,price); 
         } 
           
     } 
   
     //创建实例并访问字段和方法 
     class Program 
     { 
         static void Main(string[] args) 
         { 
             //创建car类的实例 
             car vehicle = new car(); 
            //给实例赋值 
             vehicle.CarName = "奔驰"; 
             vehicle.CarType = "XZ001"; 
             vehicle.Price = 1000000; 
   
             //调用方法 
             vehicle.action(); 
   
   
   
         } 
     } 
 }
 
 
 
 
 
四、属性
 
1、
 
 a) 概念：用于访问类的字段的成员
 
 b) 属性用途：保证数据安全，作数据的验证
 
 
 
2、声明：
 
访问修饰符 数据类型 属性名
 
{
 
  get{return 字段;}  //读访问器，通过它外部用户可以读取属性的值
 
  set{字段=value;}  //写访问器，通过它外部用户可以为属性赋值，用户输入的值就存放在value关键字中，并可以进行输入值验证               
 
}
 
例：
 
public class Student
 
{
 
private int age;   //私有字段，防止用户直接访问
 
public int Age
 
{
 
get{return age;}  //用于读取age的值
 
set
 
{
 
if((value>=18)&&(value<=45))
 
age=value;  //为age赋值并验证
 
else
 
age=18;
 
}
 
}
 
}
 
 
 
3、特殊属性：
 
a) 只读属性：
 
public 数据类型 属性名称
 
{
 
get{return 字段;}
 
}
 
b) 自动属性：
 
public 数据类型 属性名称{get;set;}
 
 
 
五、方法的参数
 
1、值参数：按值传递
 
2、引用参数：向方法传递实参在内存中的地址，按地址传递
 
3、输出参数：从方法传递回一个结果
 
关键字：out
 
4、数组型参数：参数只允许是一组数组，当方法的参数前带有params关键字时，就是带数组型参数的方法（使用引用传递）

 一、属性 
 Object自带一个prototype的属性，即Object.prototype，Object.prototype本身也是一个对象，也会有一些属性和方法。如下： 
 1、属性 
 Object.prototype.writable：默认为false 
 Object.prototype.enumerable：默认为false 
 Object.prototype.configurable：默认为false 
 Object.prototype.constructor：用于创建一个对象的原型。 
 2、常用方法 
 Object.prototype.hasOwnProperty():返回一个布尔值，表示某个对象是否含有指定的属性，而且此属性非原型链继承。
 
 Object.prototype.isPrototypeOf():返回一个布尔值，表示指定的对象是否在本对象的原型链中。
 
 Object.prototype.propertyIsEnumerable():判断指定属性是否可枚举。
 
 Object.prototype.toString():返回对象的字符串表示。
 
 Object.prototype.watch():给对象的某个属性增加监听。
 
 Object.prototype.unwatch():移除对象某个属性的监听。
 
 Object.prototype.valueOf():返回指定对象的原始值。
 
 二、方法 
 Object.assign(target, …sources):把任意多个的源对象自身的可枚举属性拷贝给目标对象，然后返回目标对象。
 
 Object.create(proto,[propertiesobject]):创建一个拥有指定原型和若干个指定属性的对象。
 
 Object.defineProperties(obj, props)：在一个对象上添加或修改一个或者多个自有属性，并返回该对象。
 
 Object.defineProperty(obj, prop, descriptor)：直接在一个对象上定义一个新属性，或者修改一个已经存在的属性， 并返回这个对象。obj：需要定义属性的对象。prop：需定义或修改的属性的名字。descriptor：将被定义或修改的属性的描述符。
 
 Object.entries(obj)：返回一个包含由给定对象所有可枚举属性的属性名和属性值组成的 [属性名，属性值] 键值对的数组，数组中键值对的排列顺序和使用for…in循环遍历该对象时返回的顺序一致。 
 举例： 
 var obj = { foo: “bar”, baz: 42 }; 
 console.log(Object.entries(obj)); // [ [‘foo’, ‘bar’], [‘baz’, 42] ]
 
 Object.freeze(obj)：冻结一个对象，冻结指的是不能向这个对象添加新的属性，不能修改其已有属性的值，不能删除已有属性，以及不能修改该对象已有属性的可枚举性、可配置性、可写性。也就是说，这个对象永远是不可变的。该方法返回被冻结的对象。
 
 Object.getOwnPropertyDescriptor(obj, prop)：返回指定对象上一个自有属性对应的属性描述符。
 
 Object.getOwnPropertyNames(obj)：返回一个由指定对象的所有自身属性的属性名（包括不可枚举属性）组成的数组。 
 举例： 
 // 类数组对象 
 var obj = { 0: “a”, 1: “b”, 2: “c”}; 
 console.log(Object.getOwnPropertyNames(obj).sort()); // [“0”, “1”, “2”]
 
 Object.getPrototypeOf(object)：返回该对象的原型。
 
 Object.is(value1, value2)：判断两个值是否是同一个值。
 
 Object.isExtensible(obj)：判断一个对象是否是可扩展的（是否可以在它上面添加新的属性）。
 
 Object.isFrozen(obj)：判断一个对象是否被冻结（frozen）。
 
 Object.isSealed(obj)：判断一个对象是否是密封的（sealed）。密封对象是指那些不可 扩展 的，且所有自身属性都不可配置的（non-configurable）且属性不可删除的对象（其可以是可写的）。
 
 Object.keys(obj)：返回一个由给定对象的所有可枚举自身属性的属性名组成的数组，数组中属性名的排列顺序和使用for-in循环遍历该对象时返回的顺序一致 
 举例： 
 var arr = [“a”, “b”, “c”]; 
 alert(Object.keys(arr)); // 弹出”0,1,2”
 
 // 类数组对象 
 var obj = { 0 : “a”, 1 : “b”, 2 : “c”}; 
 alert(Object.keys(obj)); // 弹出”0,1,2”
 
 Object.preventExtensions(obj)：让一个对象变的不可扩展，也就是永远不能再添加新的属性。
 
 Object.setPrototypeOf(obj, prototype)：将一个指定的对象的原型设置为另一个对象或者null
 
 Object.values(obj)：返回一个包含指定对象所有的可枚举属性值的数组，数组中的值顺序和使用for…in循环遍历的顺序一样。 
 举例： 
 var obj = { foo: “bar”, baz: 42 }; 
 console.log(Object.values(obj)); // [‘bar’, 42]
 
 转自：http://blog.csdn.net/wlwanglu/article/details/52253002