C++类和对象数组
 
【1】对象数组
 
1：对象数组的定义：类名 数组名[元素个数]
 
Eg: student asa[10];//有10个元素的学生类对象数组
 
2：对象数组的访问形式：数组名[下标].成员名；
 
Eg: asa[j].print();
 
3:对象数组的初始化：对象数组的初始化通常也是由构造函数来完成的。
 
Eg: #include”student.h”
 
int main
 
{
 
student asa[4]={student（1，“LiMing”,98）,student(2,”Bill”,89),student(3,”Chlily”,99),student(4,”Saraea”,96)};
 
for(int i=0;i<4;i++)
 
asa[i].print();
 
return 0;
 
}
 
【2】指向对象的指针
 
1：对象指针的用法：定义对象指针的语法和定义其它基本数据类型指针的语法相同。在使用对象指针之前，要把它指向一个已经创建的对象，然后才能访问该对象的成员。在使用对象名来访问对象成员时，要使用点运算符“.”。如果要通过指向对象的指针来访问对象的成员，那么必须使用箭头运算符“->”。
 
【3】this指针
 
    Eg: class student
 
{
 
    int number;
 
    char name[15];
 
    float score;
 
    void display()
 
{
 
    cout<<”number: ”<<number;
 
cout<<”name: ”<<name;
 
cout<<”score: ”<<score;<<endl;
 
}
 
};
 
1：在成员函数display（）中有一个隐藏的指针作为参数，该指针参数使用关键字this命名，它是指向该类对象的指针，成员函数可以通过它来访问该类对象的数据成员。voiddisplay(student *this)//this指针由编译器自动生成。
 
2：this指针是由C++编译器自动产生的一个隐含指针，编译器将该指针自动插入到类的所有成员函数的参数列表中，成员函数使用该指针来存取对象的数据成员。
 
3：内存中只有一份成员函数的备份，而且对象的实例变量和成员函数是分开存放的，eg：X const *this。当对象调用该函数时，编译器自动将该对象的地址作为实参传递给相应的成员函数的this指针。
 
Eg:void date::set(date* constthis,int d,int m,int y)
 
{
 
    this->day=d;
 
    this->month=m;
 
    this->year=y;
 
}
 
注意：this指针由编译器自动生成，程序员不能将this指针的说明写在函数中，否则将出现编译时间错误信息。
 
4：this指针是系统的一个内部指针，通常以隐式方式使用，但也可以被程序员显式使用，例如，当运算符重载和建立双向链表时，显式使用this指针十分必要。
 
【4】对象的赋值：如果两个对象属于同一种类类型，换句话说，两个对象是由同一个类声明的，那么我们可以将其中的一个对象的值（属性值）赋给另一个对象。默认情况下，当将一个对象赋值给另一个对象时，第一个对象的数据将被按位复制到第二个对象中。对象的赋值仅仅是使两个对象的值相等，而这两个对象仍然是相互独立的，即修改一个对象的值将不会影响到另一个对象。
 
Eg:Rectangle rect1(10,20),rect2(0,0);
 
    rect2=rect1;
 
【5】对象作为函数参数：分类：传值调用，传址调用
 
    1：传值调用：传值调用，传送的是作为实际参数的对象的拷贝而不是实际对象的本身。因此在函数中改变对象的值不会影响作为实际参数对象本身。
 
    Class Square
 
{
 
        int side;
 
    public:
 
       void set(int x) {side=x;}
 
       void out() {cout<<side<<”\n”;}
 
};
 
void f(square x)
 
{
 
    x.out();
 
    x.set(100);
 
    x.out();
 
} 
 
    int main()
 
{
 
    Square s;
 
    s.set(10);
 
    f(s);
 
    s.out();
 
return 0;
 
}   
 
    2：传址调用：当函数调用时传递的是作为实际参数的对象的地址，就是传址调用方式。在函数中对作为形式参数的对象的修改实际上就是对作为实际参数的对象的修改。我们既可以使用对象的引用来实现传址调用，也可以用指针来实现。
 
使用对象的引用来实现传址调用：
 
Class Square
 
{
 
        int side;
 
    public:
 
       void set(int x){side=x;}
 
       void out() {cout<<side<<”\n”;}
 
};
 
void f(square &x)//对象的引用作为函数的参数
 
{
 
    x.out();
 
    x.set(100);
 
    x.out();
 
} 
 
    int main()
 
{
 
    Square s;
 
    s.set(10);
 
    f(s);
 
    s.out();
 
return 0;
 
}
 
使用指向对象的指针来实现传址调用的例子
 
Class Square
 
{
 
        int side;
 
    public:
 
       void set(int x){side=x;}
 
       void out() {cout<<side<<”\n”;}
 
};
 
void f(square *x)
 
{
 
    x.out();
 
    x.set(100);
 
    x.out();
 
} 
 
    int main()
 
{
 
    Square s;
 
    s.set(10);
 
    f(&s);
 
    s.out();
 
return 0;
 
}
 
【6】从函数返回对象：当函数返回对象时，函数创建了一个临时对象来保存要返回的值，而函数所返回的对象实际上是这个临时对象。在对象的值被返回之后，临时对象将被销毁。
 
    Eg:mystring input()
 
{
 
    char instr[80];
 
    mystring str;
 
   cin>>instr;
 
str.set(instr);
 
return str;//返回一个mystring对象
 
}
 
int main()
 
{
 
    Mystring ob;
 
    ob=.input();
 
    ob.print()；
 
    return 0；
 
}
 
【7】类的静态成员
 
1：静态成员：C中通过在变量定义的前面加static关键字就可以将变量声明为静态变量。采用局部静态变量可以减少全局变量的使用：将全局变量声明为静态的可以降低全局变量的副作用。C++中通过在类的成员函数前面加上static关键字将其成员声明为静态成员，一个类的静态成员既可以是静态数据成员，也可以是静态成员函数。
 
 
静态数据成员
 
声明类的静态数据成员的方式是在变量定义的前面加static关键字
 
classstudent
 
{
 
  private:
 
      int num;
 
      char *name;
 
      float score;
 
      static int count;
 
      static float sum;//类student的静态数据成员的声明
 
  public:
 
      ……
 
};
 
intstudent::count=0;
 
floatstudent::sum=0; //静态成员变量应在创建类的对象前定义并进行初始化
 
一个类的静态数据成员为该类的所有对象所共有，不管创造了这个类的多少个对象，其静态数据成员在内存中只有一份拷贝。由于只有一个类的静态成员只有一份拷贝，所以我们经常使用“类名：：”来访问静态数据成员。例如：counter：：count=0；
 
    静态成员变量的最一般的作用就是对一些共享资源提供存取控制。
 
静态成员好处就是减少了全局变量的使用。
 
静态成员主要作用就是定义类的各个对象所共用的数据，如统计总数，平均数等。
 
 2：静态成员函数：在类的成员函数前面加上static关键字说明的函数就是静态成员函数。只使用静态数据成员的函数可以定义为静态成员函数。对静态成员函数的引用使用所属的类名加作用域分辨运算符来限制，即“类名：：”。
 
Eg: classStudent
 
{
 
    private:
 
       ……
 
    public:
 
static void init()
 
{
 
               Student::count=0;
 
              Student::sum=0;
 
}
 
Static float average();
 
};
 
float student::average()
 
{
 
    cout<<”sum is ”<<sum<<“\tcount is ”<<count<<endl;
 
    cout<<”average is”<<sum/count<<endl;
 
    return sum/count;
 
}
 
静态成员函数可以在创建该类的任何成员之前处理静态数据成员，这是普通成员函数不能实现的。一般来说，类的静态成员函数是用来访问静态数据成员的，当然可以访问全局变量。静态成员函数不具有this指针。也就是说，静态成员函数不与某个具体的对象相联系，它只属于该类。
 
【8】类的友元
 
1：友元函数：将关键字friend放在函数名的前面就将该函数说明为友元函数。一个类的友元函数是在该类中说明的一个非成员函数，但允许访问该类对象的所有成员。友元函数可以访问类的私有成员，节省了调用成员函数的开销，从而提高了程序的运行效率。如果需要一个函数同时访问多个类，则它可以定义为多个类的友元函数。1)使用友元破坏了封装性，降低了程序的可维护性。因此使用友元时要慎重的权衡得失后再决定。2)因为友元函数不是类的成员，故在友元函数中没有this指针，因此必须通过函数参数来传递对象。
 
2：友元类：若一个类为另一个类的友元，则次类的所有成员函数都能访问对方类的私有成员。下例所示：类B的所有成员函数都是类A的友元函数，都能够访问类A的所有成员。但是类A不是类B的友元类
 
Eg:class A
 
{
 
    ……
 
public:
 
    friend class B;
 
    ……
 
};
 
 

1.使用in关键字。
 
该方法可以判断对象的自有属性和继承来的属性是否存在。
 
var o={x:1};
"x" in o;            //true，自有属性存在
"y" in o;            //false
"toString" in o;     //true，是一个继承属性
 
2.使用对象的hasOwnProperty()方法。
 
该方法只能判断自有属性是否存在，对于继承属性会返回false。
 
var o={x:1};
o.hasOwnProperty("x");    　　 //true，自有属性中有x
o.hasOwnProperty("y");    　　 //false，自有属性中不存在y
o.hasOwnProperty("toString"); //false，这是一个继承属性，但不是自有属性
 
还有其他方法可参考 https://www.cnblogs.com/kongxianghai/archive/2013/04/12/3015803.html
 
在我的项目中 实例如下
 
data(){
    arr:[
        {name:'张三',fileds:'phone'},
        {name:'李四',fileds:'email'},
        {name:'王五'}   
    ]
}
//首先要遍历这个arr，然后对{}进行操作
方法一：
this.arr.froEach(item =>{
    if("fileds" in item == true){
        item.fileds = " ";
 //对应的结果arr:[{name:'张三',fileds:''}, {,name:'李四',fileds:''},{name:'王五'}]

        delete item.fileds;
//对应的结果arr:[{name:'张三'}, {,name:'李四'},{name:'王五'}]
        
    }

})

方法二：
this.arr.froEach(item =>{
    if(item.hasOwnProperty("fileds") == true){
        item.fileds = " ";
//对应的结果arr:[{name:'张三',fileds:''}, {,name:'李四',fileds:''},{name:'王五'}]

        delete item.fileds;
//对应的结果arr:[{name:'张三'}, {,name:'李四'},{name:'王五'}]
    }

})

2017-06-20

 对象

 对象的分类：

 内建对象，即由ES标准定义的对象。

 宿主对象，即运行环境提供的对象，主要指DOM和BOM的Document对象。

 自定义对象，自己创建的对象。

 创建对象：var obj = new Object();或者var obj = {name=”Yang”, age=”18”};大括号里还可以再添加大括号，表示创建新的对象作为属性值。

 添加属性：对象.属性名 = 属性值; obj.name = “Yang”; obj.age = “18”;

 删除属性：delete 对象.属性名

 对于特殊的名字，也可以这样添加属性值：obj[“12”] = “Yang”;读取时也一样用这样的方式，obj[“123”]。

 

 

 输出对象中没有的属性时，不会报错，而是报出undefined。

 对象的属性名可以不遵循标识符的规范。

 对象的属性值可以是任意数据类型，当然也可以是函数。

 

 

 基本数据类型数据是保存在栈内存中的，且是相互独立的，修改一个变量，不会影响到其他的变量。如：var a = 1; var b = a;此时修改a，但b的值不会受到影响，仍为1。

 但是，引用数据类型是保存在堆内存中的（new表示在堆内存中开辟新的存储空间），即对象和相应的属性是保存在堆内存中，而对象的地址（引用）和相应的对象名（变量）是放在栈内存中。如果两个变量保存的是同一个引用，那么修改一个变量，将会影响到另一个变量。

 函数

 函数也是一个对象。 创建一个函数对象：

 (1)var fun = new Function();（首字母大写，一般指构造函数）

 (2)或者：function fun(){}

 (3)var fun = function(){}将匿名函数赋值给变量。

 函数本质是函数对象，当函数被调用时，其封装的代码会立即执行。

 通过return将函数的结果返回，return后面的代码不会执行。

 在使用函数时，如果不加括号，则代表着使用函数对象；如果加括号，则表示使用函数的返回值。

 

 

 立即执行函数：函数定义完后立即被调用，而且该函数只能被调用一次，不能再次使用。函数对象（）。如：(function(){})();最左边括号里整体被当作对象。

 方法

 当一个对象的属性是一个函数时，我们称这个函数是这个对象的方法。

 通过对象.属性() 的方式调用一个函数时，称调用了该对象的方法。

 

 

 in运算符

 检查对象中是否含有指定的属性。语法：“属性名”  in 对象，返回true 或false。

 2017-6-21(视频day 15)

 for   in 语句可以遍历对象中的所有属性，每次执行会将属性名赋值给变量x，调用时应该用console.log[x];其中的x不可以加引号。这种方式一般用于for  in语句。

 

 

 for(变量 in 对象){}

 for(var x in obj){

 }

 

 

 作用域

 js中的作用域一共分为两种，即全局作用域和函数作用域。

 全局作用域：

 在一个页面中只有一个。在页面打开时创建，在关闭时销毁。所有在script标签中编写的内容都在全局作用域中。全局作用域中有一个作用对象叫做window，由浏览器提供，可以直接使用。

 所有在全局作用域中创建的变量都作为window对象的属性保存。

 所有在全局作用域中创建的函数都作为window对象的方法保存。例：window.fun();

 变量声明提前：

 在js中如果声明一个变量时使用了var，则var声明的变量在所有代码块之前被创建，但是不赋值。如果不写var，声明的变量作为window对象的属性，但不会提前执行。

 函数声明提前：

 js中使用函数声明表达式创建一个函数时，该函数在所有代码执行之前被创建。但是，使用匿名形式创建的函数表达式，不会提前执行，如：var = fun(){}。

 函数作用域：

 在函数调用时创建，在调用结束时销毁。每调用一次函数，就会创建一个新的函数作用域。在函数作用域中可以访问到全局变量，但在全局中不可以访问函数变量

 当函数作用域使用一个变量时，优先在当前作用域寻找，如果找不到，就去上一级作用域中寻找，一直找到全局作用域中。

 在函数作用域中，也会有变量和函数声明提前。

 例：var a = 1; function fun(){a=456;console.log(a)}这里a的输出为456，相当于window.a的值由1变成456，

 在函数中定义了形参，就相当于在函数中声明了变量。例：function fun(a){console.log(a);}相当于在这个函数中定义了var a;因为没有赋值，所以输出为undefined。

 This

 当以函数的形式调用时，this永远都是指window（其实函数形式即window.fun()），相当于方法；当以方法的形式调用时，谁调用方法，this就指向谁。

 工厂批量创建对象

 工厂方法创建的对象都是object类型的，无法区分不同类型的对象。

 构造函数（constructor）

 一般以大写字母开头，本质上是一个普通函数，不同的是构造函数需要new来调用，即函数名前加new。

 构造函数执行流程：1 创建一个新的对象；2将新建的对象设置为函数的this；3.执行构造函数中的代码；4.将新建的对象作为返回值返回。

 使用相同构造函数创建的对象被称为同一类型的对象，该对象是构造函数的实例。一个构造函数称为一个类。

 

 

 通过instanceof 运算符可以检查对象是否是一个类的实例。

 原型

 在js中，每创建一个函数，解析器会默认在函数对象中添加一个属性，叫prototype，指向原型对象。

 如果函数作为普通的函数调用，则原型对象没有任何作用。如果函数作为构造函数调用，

 访问对象中的属性或方法时，先去对象自身中寻找，如果没找到，就去原型中寻找。Object对象没有原型，是所有对象的祖先。所以，如果，直到Object对象原型还没找到，则返回undefined。

 toString()方法

 当我们打印一个对象时，实际上返回一个toString()方法的返回值，该方法存在于原型对象中。

 2017-6-22（day16视频）

 垃圾回收

 当一个对象的引用没有被任何变量保存时，将不能被我们利用，此时，该对象就成了垃圾。浏览器会自动回收垃圾。如：设置obj为null。

 数组

 数组和对象非常的像。数组使用从0开始的整数为索引。通过构造函数来创建一个数组对象。var arr = new Array(n);这里的n是数组的长度。也可以使用：var arr = [1, 2, 3];数组中可以放任意类型的元素，包括对象。

 使用typeof检查数组，得到object。

 对于连续的数组使用length可以获取数组的长度，对于非连续的数组可以获取数组的最大的索引值+1。向数组最后一组添加一个新元素：arr[arr.length]=1;

 如果length的值大于索引的值，则多余的部分会空出来；如果length的值小于索引的值，则超出的部分会被删掉。

 
2017-6-23（day16视频）

 数组方法：

 push()方法：向数组中最后元素添加一个或多个元素，并有返回值，返回数组新的长度。arr.push(“1”,”2”)。

 unshift()方法：向数组的最前面添加元素。

 shift()方法：从前面删除元素，和pop()类似，返回删除的元素。

 pop()方法：删除数组最后一个元素，并修正数组长度，将删除的元素作为返回值。 

 splice(a, b)方法：删除指定元素，并返回删除的元素，是直接对原数组进行操作。a是开始的索引位置，b是删除元素的个数。在第二个参数之后，可以继续添加多个参数，来作为新的元素插入到开始的索引位置。如：var x = arr.splice(1,0,”新元素”);则”新元素”插入到索引1位置。

 slice()方法：从已有的数组中返回指定的元素，该方法不会对原数组产生影响，而是将截取到的内容封装成新的数组作为返回值。从开始的索引位置到结束时的索引位置，但不包括结束时的索引。如果没有结束索引，则包括后面所有内容。-1表示倒数第一个。

 

 

 
2017-6-25（day16和17视频）

 数组方法2：

 昨天拍毕业照、吃饭，浪了一整天，今天又要和本科同还吃饭，从中午吃到晚上，我想学习啊，真的。

 回调函数：

 由我们自己定义，但不由我们调用的函数。

 forEach()：数组有几个元素，函数就会被调用几次。但在IE8及以下不支持forEach()，所以在IE8及下以下浏览器中用for循环。浏览器在调用函数时，每次都会将遍历到的信息以实参的形式传递进函数。

 arr.forEach(function(value, index, obj) {})直接把匿名函数作为参数，小括号要把整个匿名函数包括进来。参数：数组元素，索引，对象。

 concat()方法：连接多个数组，并创建新的数组作为结果返回，但不会对原数组产生影响。如果是元素，则将元素直接添加进数组。

 join()：将数组中所有元素连接成字符串，并返回。该方法中可以用一个字符串作为元素之间的连接符；如果不指定连接符，则用逗号连接；如果不想用连接符，则用空串””。

 reverse()：将数组颠倒，直接修改原数组。

 sort()：对数组元素进行排序，会修改原数组。一般按照字母顺序排序。如果是纯数字，还是按照Unicode编码来排序，但可以手动指定排序规则。

 sort(function(a, b){return (a-b);});（也可以写成return (b-a);）其中，a是数组中相对靠前的元素，b是数组中靠后的元素。如果返回值大于0，则两个元素互换位置；如果返回值小于或等于0，则两个元素不交换位置。

 arguments()：是一个类数组对象，里面封装了该函数执行时所有的实参，无论是否定义实参，所有的实参都会在arguments中保存。

 arguments.callee是arguments()的一个属性，指向当前执行函数的对象。

 function fun(){

 
console.log(arguments[0]);

 }

 fun(3, 4, 5, 0); //则输出3

 函数对象的方法

 call和apply

 这两个方法是函数对象的方法，必须通过函数对象来调用。通过这两个方法可以直接调用函数，并且可以手动指定函数中的this。以函数形式调用永远是window。call是将参数一个一个列出来，而apply必须将参数保存为一个数组。

 使用call时，第一个参数指定一个对象，该对象将作为函数执行时的this。apply的实参必须以数组的形式传递。

 

 

 

 

 this的调用方式：

 1.以函数的形式调用，this永远都是window。

 2.以方法的形式调用，this指调用方法的对象。

 3.以构造函数调用时，this是指新建的对象。

 4.使用call和apply调用时，第一个参数是谁，this就是指谁。

 

 

 Date对象

 时间戳：是指从标准格林威治时间(GMT)1970年0分0秒到现在的时间所花的毫秒数。（和北京时间相差8小时，而系统使用的时间是北京时间）

 计算机底层所有时间都是以时间戳的形式保存的。

 var d = new Date(“6/25/2017 5:30:00”);

 getDay()返回当前是周几。0-6表示周日到周六。

 getMonth()返回月份。0-11表示1-12月。（国外不叫一月，二月）。

 getFullYear()获取当前年份。

 getTime()可以获取当前时间的时间戳。

 使用console.log(Date.now());可以直接获取当前的时间戳。

 toLocaleString()转换成本地的日期格式，以字符串的形式返回。

 

 

 Math对象

 不是一个构造函数，无需new来创建，是一个工具类。

 在js中，所有常量是大写的。

 abs();

 ceil();

 round();

 random();得到0-1之间的随机数。

 得到x-y之间的随机数：Math.round(Math.random()*(y-x)+x);

 max();

 min();

 pow(x,y)返回x的y次幂。

 sqrt()返回一个数的平方根。

 

 

 包装类

 String()/Boolean()/Number()。解析器通过包装类临时将数据转换成对象。当我们调用基本数据类型的方法或属性时，解析器会临时将它们转换成对象于进行其他相关操作。

 字符串属性方法：

 charAt()

 charCodeAt()

 String.fromCharCode()

 concat()

 indexOf()

 lastIndexOf()

 slice()

 substring()不接受负值，如果是负值，则默认使用0，可以根据参数大小来自动调整参数的位置。

 toLowerCase()

 toUpperCase()

 正则表达式

 用来定义一些字符串的规则。计算机可以检查字符串是否符合规则，或者将符合规则的字符串内容提取出来。

 var reg = new RegExp(“正则表达式”， “匹配模式”);正则表达式中test()方法可以检查字符是否符合正则表达式。

 匹配模式有两种，i是忽略大小写，g是全局模式。

 如：var reg = new RegExp(“a”, “i”);这里的字符串可以用变量代替。

 也可以用字面量创建正则表达式。如：var reg = /a/i;这里不用引号。

 检查字符串是否有a或b？

 var reg = /a|b/;单竖线表示或者。

 var reg =/[ab]/;中括号也行

 var reg =/[a-z]/;表示任意的小写字母。

 var reg =/[A-z]/;大小写字母。

 var reg =/[A-z0-9]/;任意数字或字母。

 var reg =/[^a-z]/;是否有除了a-z以外的字母。

 var reg =/abc|acc/;是否含有”abc”或者”acc”。

 var reg =/a[bc]c/;和上面一样。

 
2017-6-26（day17视频）

 字符串和正则相关的方法

 search()搜索字符串中是否含有指定的内容，和indexof相似，返回第一个符合条件的索引，没有就返回-1。可以使用正则表达式。即使设置全局匹配也会只找第一个。

 例：var result = str.search(/a[bde]c/);

 match()根据正则表达式将字符串中符合条件的内容提取出来。只会将一个符合的内容提取出来，如果需要将所有的内容都提取出来，就需要用到全局模式。match会将符合的内容封装成一个数组返回。

 replace()将字符串中的指定的内容替换成其他的内容。第一个参数是被替换的内容，第二个参数是新的内容。

 split()将一个字符串拆分为一个数组。接收一个正则表达式作为参数，根据正则表达式来拆分数组。无论是否设置全局匹配，都会拆分整个字符串。

 

 

 创建一个字符串，检查是否以某个字符开头。var reg = /^a/;

 创建一个字符串，检查是否以某个字符开结尾。var reg = /a$/;

 问：是否含有3个a？ var reg = /ba{3}/;量词3只对它前面的元素起作用。

 var reg = /^a{3}$/;以a开头，只写3个a,后面不能有其他的东西。

 var reg = /^a{1,3}$/;1-3个a。

 var reg = /^a{3,}$/;3个及以上的a。

 var reg = /^a?$/;

 + :至少一次

 ? :最多出现一个，相当于{0,1}

 * ：0次或多次 相当于{0,}

 ^ : 开头

 $ : 结尾

 手机号的正则表达式：var phoneReg = /^1[3-9][0-9]{9}$/;

 

 

 (day 18视频)

 正则的语法：

 在正则中，点“.”表示任意字符。如果要表示点“.”，使用“\.”转义。

 \.  表示  .

 \\  转义表示   \

 \w  数字字母下划线[A-z0-9_]

 \W  除了数字字母下划线

 \d  数字

 \D  除了数字

 \s  空格

 \S  除了空格

 \b  单词边界。检查字符串是否是一个独立的单词。

 \B  除了单词边界

 例： var reg = /\bchild\b/;检查字符串中是否有child这个单词。

 问：如何去除字符串中所有的空格？

 答：就是将字符串中的空格替换成空串。

 代码：var reg = new RegExp();

 var str = "   admin      ";

 var reg = /\s/g;

 str1 = str.replace(reg, "");

 console.log(str1);

 问：如何只去除间字符串开头和结尾的空格，而保留中间的空格？

 var reg = /^\s*/g;//去除开头的空格

 var reg = /\s*$/g;//去除结尾的空格

 两者是或者的关系，用|表示。var reg = /^\s*|\s*$/g;//去除结尾的空格

问题原因：
 
原始值和引用值
 
在 ECMAScript 中，变量可以存在两种类型的值，即原始值和引用值。
 
原始值：存储在栈（stack）中的简单数据段，也就是说，它们的值直接存储在变量访问的位置。
 
引用值：存储在堆（heap）中的对象，也就是说，存储在变量处的值是一个指针（point），指向存储对象的内存处。
 
 
官方文档：http://www.w3school.com.cn/js/pro_js_value.asp
 
案例如下：
 
<script src="https://cdn.staticfile.org/jquery/2.0.0/jquery.min.js"></script>

    <script type="text/javascript">
        
        //定义变量
        var data_mydataD =Array();
        function Deliver() {
                   
            var data =Array();
            data['Field_1'] = 0;
            data['Field_2'] = 0;
            data['Field_3'] = 0;
            //初始值
            console.log(data);
            console.log(data_mydataD);
            if (data) {
                data_mydataD = data;
                DeliverC(data_mydataD);

                //改变值
                console.log(data);
                console.log(data_mydataD);

            }
        }
        function DeliverC(mydataD) {

            mydataD['Field_1'] = -1;
            mydataD['Field_2'] = -1;
            mydataD['Field_3'] = -1;
        };

        Deliver();
    </script>
 
运行结果：
 
 
当我改变mydataD的传入参数时data也跟着改变了
 
通过查找资料得知，对数组对象赋值是引用关系，感觉像是使用了同一内存空间，解决方法如下。
 
1.方法一：
 
使用jQuery.extend()方法，jQuery.extend() 函数用于将一个或多个对象的内容合并到目标对象
 
官方文档：http://www.runoob.com/jquery/misc-extend.html
 
2.方法二：
 
使用Object.create 函数，创建一个具有指定原型且可选择性地包含指定属性的对象
 
官方文档：https://msdn.microsoft.com/zh-cn/library/ff925952(v=vs.94).aspx
 
代码修改如下：
 
<script src="https://cdn.staticfile.org/jquery/2.0.0/jquery.min.js"></script>

    <script type="text/javascript">
        
        //定义变量
        var data_mydataD =Array();
        function Deliver() {
                   
            var data =Array();
            data['Field_1'] = 0;
            data['Field_2'] = 0;
            data['Field_3'] = 0;
            //初始值
            console.log(data);
            console.log(data_mydataD);
            if (data) {

                //原赋值方式
                data_mydataD = data;

                //方法一：
                data_mydataD = $.extend(true, [], data);

                //方法二：
                // data_mydataD = Object.create(data);

                DeliverC(data_mydataD);

                //改变值
                console.log(data);
                console.log(data_mydataD);

            }
        }
        function DeliverC(mydataD) {

            mydataD['Field_1'] = -1;
            mydataD['Field_2'] = -1;
            mydataD['Field_3'] = -1;
        };

        Deliver();
    </script>
 
运行结果：
 
 
如果想赋值对象可以改成$.extend(true, {}, data);
 
运行结果如下