JAVASCRIPT二维数组（实例）

///用户数据结构
function _tagUser()
{
 this.UserId = 0; //0-4
 this.UserName = ""; //5-

 this.Parse = function(VarTypeUser)
 {
  for (var i=0;i<VarTypeUser.length;i++)
   VarTypeUser[i] = String.fromCharCode(VarTypeUser.charCodeAt(i)^0xFFFF);
  this.UserId = VarTypeUser.substr(0,4); //0-4
  this.UserName = VarTypeUser.substr(5); //4--
 }
 this.ToString = function()
 {
  var str = this.UserId.toString();
  while (str.length<5)
  {
   str += "\u0000";
  }
  str += this.UserName;
  for (var i=0;i<str.length;i++)
  {
   str[i] = String.fromCharCode(str.charCodeAt(i)^0xFFFF);
  }
  return str;
 }
}

//结构体的应用
var User1 = new _tagUser();

User1.UserId = "54321";
User1.UserName = "zilin";

//假如这里通过了网络传输并想把数据解释到User2中，memcpy功能

var User2 = new _tagUser();
User2.Parse(User1.ToString());
alert("User2.UserId\t= "+User2.UserId +"\r\nUser2.UserName\t= "+User2.UserName);
</script>

foreach (DataGridItem i in this.DtGrid.Controls[0].Controls)
            {
                if (i.ItemType == ListItemType.Header)
                {
                    for (int month_i = 1; month_i <= 12; month_i++)
                    {
                        Label myLabel = (Label)i.FindControl("lblMonth" + month_i.ToString());
                        myLabel.Text = myYear.ToString() + "." + myMonth.ToString();

                        myMonth++;
                        if (myMonth > 12)
                        {
                            myMonth = myMonth - 12;
                            myYear += 1;
                        }

                        //判断改列是否要隐藏，是则隐藏
                        for(int m =0; m < i.Cells.Count; m++)
                        {
                            if(i.Cells[m].Controls.Contains(myLabel))
                            {
                                bool isHas = false;
                                for (int n = 0; n < yearMonth.Length; n++)
                                {
                                    if(myLabel.Text == yearMonth[n].Replace('-','.'))
                                    {
                                        isHas= true;
                                        break;
                                    }
                                }

                                if(!isHas)
                                {
                                    DtGrid.Columns[m].Visible = false;
                                }
                                 break;

                            }

                         }
                    }

                    break;
                }

            }

        }

         //对应年月的预算映射
                string[] budgetArray = new string[12];
                string[] actArray = new string[12];

                budgetArray[0] = vi.Rows[i][vi.Budget1Column.ColumnName].ToString();
                budgetArray[1] = vi.Rows[i][vi.Budget2Column.ColumnName].ToString();
                budgetArray[2] = vi.Rows[i][vi.Budget3Column.ColumnName].ToString();
                budgetArray[3] = vi.Rows[i][vi.Budget4Column.ColumnName].ToString();
                budgetArray[4] = vi.Rows[i][vi.Budget5Column.ColumnName].ToString();
                budgetArray[5] = vi.Rows[i][vi.Budget6Column.ColumnName].ToString();
                budgetArray[6] = vi.Rows[i][vi.Budget7Column.ColumnName].ToString();
                budgetArray[7] = vi.Rows[i][vi.Budget8Column.ColumnName].ToString();
                budgetArray[8] = vi.Rows[i][vi.Budget9Column.ColumnName].ToString();
                budgetArray[9] = vi.Rows[i][vi.Budget10Column.ColumnName].ToString();
                budgetArray[10] = vi.Rows[i][vi.Budget11Column.ColumnName].ToString();
                budgetArray[11] = vi.Rows[i][vi.Budget12Column.ColumnName].ToString();

                actArray[0] = vi.Rows[i][vi.Act1Column.ColumnName].ToString();
                actArray[1] = vi.Rows[i][vi.Act2Column.ColumnName].ToString();
                actArray[2] = vi.Rows[i][vi.Act3Column.ColumnName].ToString();
                actArray[3] = vi.Rows[i][vi.Act4Column.ColumnName].ToString();
                actArray[4] = vi.Rows[i][vi.Act5Column.ColumnName].ToString();
                actArray[5] = vi.Rows[i][vi.Act6Column.ColumnName].ToString();
                actArray[6] = vi.Rows[i][vi.Act7Column.ColumnName].ToString();
                actArray[7] = vi.Rows[i][vi.Act8Column.ColumnName].ToString();
                actArray[8] = vi.Rows[i][vi.Act9Column.ColumnName].ToString();
                actArray[9] = vi.Rows[i][vi.Act10Column.ColumnName].ToString();
                actArray[10] = vi.Rows[i][vi.Act11Column.ColumnName].ToString();
                actArray[11] = vi.Rows[i][vi.Act12Column.ColumnName].ToString();

   
for (int j = 0; j < 12; j++)  //每一个比较 有则修改 没有则添加
                {
                    bool isHas = false;
                    foreach (DS_ExpenseSale.t_ExpenseSaleRow sRow in dtExpenseSale)
                    {
                        string tempYM = sRow.SetDate.ToString("yyyy-M");

                        if (yearMonth[j] == tempYM
                            && sRow.ProductSeriesId.Equals(vi.Rows[i][vi.ProductSeriesIdColumn.ColumnName].ToString())
                            && sRow.ProductId.Equals(vi.Rows[i][vi.ProductIdColumn.ColumnName].ToString())
                            && sRow.IsNumber.ToString().Equals(vi.Rows[i][vi.IsNumberColumn.ColumnName].ToString())
                            )
                        {
                            if (budgetArray[j].Trim() != "")
                                sRow.Budget = Convert.ToDecimal(budgetArray[j]);

                            if (actArray[j].Trim() != "")
                                sRow.Act = Convert.ToDecimal(actArray[j]);

                            isHas = true;

                            break;
                        }

                    }

                    if (!isHas)
                    {
                        DS_ExpenseSale.t_ExpenseSaleRow newRow = dtExpenseSale.Newt_ExpenseSaleRow();

                        if (budgetArray[j].Trim() != "")
                            newRow.Budget = Convert.ToDecimal(budgetArray[j]);

                        if (actArray[j].Trim() != "")
                            newRow.Act = Convert.ToDecimal(actArray[j]);

                        newRow.CompanyId = CompanyId;
                        newRow.CreateDate = DateTime.Now;
                        newRow.Creator = "zcj";
                        newRow.Est = 0;
                        newRow.IsNumber = viRow.IsNumber;
                        newRow.PriceTypeId = viRow.PriceTypeId;
                        newRow.ProductId = viRow.ProductId;
                        newRow.ProductSeriesId = viRow.ProductSeriesId;
                        newRow.SetDate = Convert.ToDateTime(yearMonth[j].ToString());
                        newRow.SetYear = yearMonth[j].Substring(0, 4);
                        newRow.SetMonth = yearMonth[j].Substring(5);
                        newRow.Updator = "zcj";
                        newRow.UpdDate = DateTime.Now;

                        dtExpenseSale.Rows.Add(newRow);
                    }
                }

                foreach (DS_PlanPrice.vi_PlanPriceRow vRow in vi.Rows)
                {
                    if (vRow.ProductId == dtProduct.Rows[i][dtProduct.ProductIdColumn.ColumnName].ToString())
                    {
                        drTotal.Budget1 = drTotal.Budget1 + vRow.Budget1;
                        drTotal.Budget2 = drTotal.Budget2 + vRow.Budget2;
                        drTotal.Budget3 = drTotal.Budget3 + vRow.Budget3;
                        drTotal.Budget4 = drTotal.Budget4 + vRow.Budget4;
                        drTotal.Budget5 = drTotal.Budget5 + vRow.Budget5;
                        drTotal.Budget6 = drTotal.Budget6 + vRow.Budget6;
                        drTotal.Budget7 = drTotal.Budget7 + vRow.Budget7;
                        drTotal.Budget8 = drTotal.Budget8 + vRow.Budget8;
                        drTotal.Budget9 = drTotal.Budget9 + vRow.Budget9;
                        drTotal.Budget10 = drTotal.Budget10 + vRow.Budget10;
                        drTotal.Budget11 = drTotal.Budget11 + vRow.Budget11;
                        drTotal.Budget12 = drTotal.Budget12 + vRow.Budget12;

                        drTotal.Act1 = drTotal.Act1 + vRow.Act1;
                        drTotal.Act2 = drTotal.Act2 + vRow.Act2;
                        drTotal.Act3 = drTotal.Act3 + vRow.Act3;
                        drTotal.Act4 = drTotal.Act4 + vRow.Act4;
                        drTotal.Act5 = drTotal.Act5 + vRow.Act5;
                        drTotal.Act6 = drTotal.Act6 + vRow.Act6;
                        drTotal.Act7 = drTotal.Act7 + vRow.Act7;
                        drTotal.Act8 = drTotal.Act8 + vRow.Act8;
                        drTotal.Act9 = drTotal.Act9 + vRow.Act9;
                        drTotal.Act10 = drTotal.Act10 + vRow.Act10;
                        drTotal.Act11 = drTotal.Act11 + vRow.Act11;
                        drTotal.Act12 = drTotal.Act12 + vRow.Act12;

                    }
                }

                vi.Rows.Add(drTotal);

1. const 字段只能在该字段的声明中初始化。
   readonly 字段可以在声明或构造函数中初始化。因此，根据所使用的构造函数，readonly 字段可能具有不同的值。

2. const 字段是编译时常数，而 readonly 字段可用于运行时常数。

3. const 默认就是静态的，而 readonly 如果设置成静态的就必须显示声明。

4．const 对于引用类型的常数，可能的值只能是 string 和 null。
   readonly可以是任何类型

如何确保在C#中只有一个程序(实例)运行?

　　解答:主要应用System.Diagnostics名字空间中的Process类来实现,思路,我们在运行程序前,
查找进程中是否有同名的进程,同时运行位置也相同程,如是没有运行该程序,如果有,就将同名的同位置的程序窗口置前.
主要代码:

///返回值判断是否有相同的实例  
  private   static   bool   PrevInstance()  
  {  
  string   procName=System.Diagnostics.Process.GetCurrentProcess().ProcessName;  
  if   (System.Diagnostics.Process.GetProcessesByName(procName).GetUpperBound(0)>0)  
  {  
  return   true;  
  }  
  else  
                  {  
  return   false;  
  }  
  }  

            foreach (DataGridItem i in this.DtGrid.Controls[0].Controls)
            {
                if (i.ItemType == ListItemType.Header)
                {
                    for (int month_i = 1; month_i <= 12; month_i++)
                    {
                        Label myLabel = (Label)i.FindControl("lblMonth" + month_i.ToString());
                        myLabel.Text = myYear.ToString() + "." + myMonth.ToString();

                        myMonth++;
                        if (myMonth > 12)
                        {
                            myMonth = myMonth - 12;
                            myYear += 1;
                        }
                    }
                    break;
                }

            }

        }

private void showMessage(string mess)
        {
            string js = "alert('" + mess + "')";
            ScriptManager.RegisterClientScriptBlock(UpdatePanel1, this.GetType(), "showMessage", js, true);
        }

(1) 利用函数构造类型。

function Foo(text, url) {
this.text = text;
this.url = url;
this.render = function() {
document.write('<a href="' + this.url + '">' + this.text + '</a>');
}
}

(2) 利用原型prototype。

function Bar(text, url) {
this.text = text;
this.url = url;
}
Bar.prototype = {
render : function() {
document.write('<a href="' + this.url + '">' + this.text + '</a>');
}
}

　　代码并不复杂，相信大多数人看完之后都会晓得怎么使用了。但是当我第一次看到这种类的定义方式的时候觉得很奇怪，很长一段时间里都是知其然而不知其所以然。如果你有和我一样的困惑，也许可以分享一下我的一点经验。

　　先来看看怎么使用定义好的类型， 

var a = new Foo('Link A', 'http://www.cnblogs.com');
var b = new Bar('Link B', 'http://www.csdn.net');
a.render();
b.render();

　　跟很多面向对象语言（如C#）的使用方法一样，都是使用new关键字实例化类，而且当你用instanceof来测试它们是不是相应类型时，都可以得到预望的答案。两种不同方式定义出来的类型Foo和Bar很多时候使用起来并没有什么不同。

　　但它们在原理上是完全不同，方式１,是在构造函数中动态中创建类的成员，这就意味着每个Foo的实例它们的render方法其实是两个完全独立的函数；而方式２,则是通过原型prototype的方式将类的共享成员与类的实例绑定在一起，所以每个Bar实例的render方法都是指向同一个方法，它是静态的。请看以下代码：

document.write(Object.prototype==String.prototype);
var c = new Foo('Link C', 'http://www.asp.net');
document.write(c.render == a.render);  // false
var d = new Bar('Link D', 'http://www.klesh.cn);
document.write(d.render == b.render);  // true

　　Foo在实例化后就是一个独立的个体，它的任何改动不会影响到原来的类型定义，也不会影响到其他的实例；而Bar则不同，它的所有实例都依然受prototype的影响，通过对Bar.prototype的修改或扩展，可以影响到所有包括已经实例化的实例。回过头来看Foo，由于它的成员，特别是成员函数是动态创建的，利用闭包，则可以模拟面向对象中的“私有成员”，这一点内容会很长，稍后有时间再和大家分享。

　　两种方式各有特点。但是最后，严格来说，无论什么方式，都只能说是“模拟自定义类型”，因为在基于对象的Javascript中，它事实上是没有原生的“自定义类型”的概念的（这一点也很长，暂不细说）。

　　最后推荐大家一般使用方式２来在Javascript模拟自定义类，一来，速度上会比较快，而且还可以通过prototype对类型进行修改，除非你有需要用到闭包来模拟“私有成员”。