爽啊，请大虾解释一下namespace这个东西。顺便现一下丑。

Question

顺便，javascript可以操纵CSS中的class不？

Answer 1

namespace:名称空间
目的是为了避免使用相同的名字带来的意义上的混淆。
比如：
Title:可以作为书的标题，也可以做为头衔，加上名称空间可以避免。
<d:Title xmlns:d="http://lucky.myrice.com">书名字</d:Title>
可以操纵

Answer 2

namespace:名称空间
目的是为了避免使用相同的名字带来的意义上的混淆,IE5+支持。
比如：
Title:可以作为书的标题，也可以做为头衔，加上名称空间可以避免。
<d:Title xmlns:d="http://lucky.myrice.com">书名字</d:Title>
可以操纵Css的Class

Answer 3

能不能写一个javascript操纵CSS的class的例子？

Answer 4

斑竹讲的是XML，我看javascript里也有namespace {}这样的写法，不知道这个跟C#里的意义是否相同，要是相同的话，去看看C#就可以了，不同，就说说吧，

Answer 5

Jscript.NET才引进namesapce的吧。和C#,xml 的意义和作用相同<style>
.a{color:red}
.b{color:blue}
</style>
<div id=mxh class="a" onclick="test()">Click Here</div>
<script>
function test(){
alert(document.all.mxh.className)
document.all.mxh.className="b"
alert(document.all.mxh.className)
document.all.mxh.style.color="green"
document.all.mxh.style.fontSize="72pt"
}
</script>

Answer 6

我的理解NAMASPACE就是一个大箱子，里面放了好多类，类里面又有各种各样的方法属性什么的：P也不找到理解的对不对~~~

Answer 7

XML的NAMESPACE是区分不同的XML文档出现在同一个文档时名字冲突的。
和
C#,VB.Net,JScript.Net的Namespace是不同。。所以，，，
在XML中，ns不能说是个箱子，名字空间不能包含名字空间  。

Answer 8

<style>
.b{color:blue}
.a{color:red}
</style>
<span class=a>test</span>
<input class=a>
<input type=button class=a value=test>
<a href=. class=a>test</a>
<div class=a>test</div><span class=b>test</span>
<input class=b>
<input type=button class=b value=test>
<a href=. class=b>test</a>
<div class=b>test</div><input type=button onclick=chgClass("a","fontSize","20pt") value="class a"><input type=button onclick=chgClass("b","color","lime") value="class b"><script>
function chgClass(sel,prop,val){
/******(qiushuiwuhen 2002-5-24)*****/
with(document.styleSheets[0]){
for(i=0;i<rules.length;i++)
if(rules[i].selectorText=="."+sel)eval("rules[i].style."+prop+"=val")
}
}
</script>

Answer 9

js里的namespace? 你指的是function嵌套吧，应该把他当class看，和真正的namespace还是有差距的example 1:
  function Tree(){
    this.root = null
    this.createNode=function(sKey,sText){
      ......
    }
    
    this.removeNode=function(sKey){
     .......
    }
  }
this关键字：this表示当前对象，也可以看做调用者，如果在一般的元素上的事件处理里用，则和event.srcElement相等,那么我们的Tree对象现在有了两个简单的方法，可以如下调用
  tree = new Tree()  //创建一个实例
    tree.createNode(v1,v2)
    tree.removeNode(v1)
    tree.root
用this修饰的变量和function可以看成class的public方法和public属性example 2: 
  function Tree(){
    var root
    this.getRoot=function(){
      return root
    }
    this.setRoot=function(oNode){
       if (oNode instanceof Node){
          root = oNode
       }
    }
    ......
  }
  现在我们的root在这里成为Tree的私有成员
  var tree = new Tree()
  tree.root                //error: undefined
  不能直接访问，我们只能通过访问器getRoot和setRoot方法来访问,已达到 一些必要的控制
  这个例子表明在js里实现private属性的方法example 3:
   function Tree(){
     var root = null 
     .....
     this.NodeCount=function(){
        return countNode()
     }
     
     function countNode(){
       ...
     }   }
在public方法NodeCount调用private方法countNodeexample 3:private方法能能访问public方法和public属性吗？
   理论上当然是可以的，但实际上在js这里已经发生了一些微妙的变化：
   function Cls(){
     var a  = "a"
     this.b = "b"
     this.geta=function(){
       return a
     }
      
     this.getb=function(){
       return getb()
     }     function getb(){
      return this.b              //undefined
     }
   }  cls = new Cls
  alert(cls.geta())     //正常
  alert(cls.getb())     //返回值undefined，不能访问this.b
当初刚碰到这几乎使我疑心不用this用var直接在类里申明的是static静态变量和静态方法（类变量、类方法），但实际上并不是如此,见下例example 4：
  function Cls(){
    var a = ""
    this.setToA=function(){
      a = "a"
    }
    
    this.setToB=function(){
      a = "b"
    }
    this.show=function(){
     alert(a)
    }
  }cls1 = new Cls()
cls2 = new Cls()cls1.setToA()
cls1.show()
cls2.setToB()
cls1.show()         //如果是static,那么将返回"b",实际上还是"a"
cls2.show()         //返回"a"
这个例子表明var声明的更像private而不是static的//example 5：
function Cls(){
  Cls.a = "a"
  
  this.show=function(){
    alert(getA())
  }
  function getA(){
    return Cls.a
  }
}       cls = new Cls()  
alert(Cls.a)    //注意是Cls不是实例cls
cls.show()      //正常
这个例子里的a更像static变量;)//example 题外话，重载object的toString方法
function Cls(){
  this.toString=function(){
    return "i am Cls"
  }
}cls = new Cls()
alert(cls)     //will be "i am Cls"//粗劣写了一下，大家一起研究研究^_^

Answer 10

这个是ECMAScript的变量空间的引用规则
不断的网函数的上一层（不是堆栈）寻找相应的名字符合的变量。
--------------------------------
我做的
Delegate就是用这个方法实现的。
http://lostinet.d2g.com/temp/public/delegate/JScriptSoapClient
http://lostinet.d2g.com/Lostinet-Publish/JScriptSoapClient
这个是我自己做的Collection:
(其他的函数定义是这里：http://www.csdn.net/Develop/read_article.asp?id=13635) function CreateDefaultCollection()
 {
  return FunctionSpace();
  function FunctionSpace()
  {
   var _Length=0;
   var _Coll=new Object();
   function Collection(index)
   {
    return Collection.Item(index);
   }
   function Collection.valueOf(){
    if(_Length==0)return GetUndefined();
    return VarValueOf(Collection.Item(0));
   }
   function Collection.toString(){
    return VarToString(Collection.valueOf());
   }
   function Collection.Length(){return _Length;}
   function Collection.Length.valueOf(){
    return Collection.Length();
   }
   function Collection.Length.toString(){
    return Collection.Length();
   }
   function Collection.Item(index){
    ASSERT(index<_Length||IsNull(_Coll[index])==false,"找不到Item:"+index);
    if(!IsNumber(index))return _Coll[index];
    var pos=0;
    for(var ppt in _Coll){
     if(pos==index)return _Coll[ppt];
     pos++;
    }
    ASSERT(0,"CreateDefaultCollection::Collection.Item : 不能到达");
   }
   function Collection._add(obj){
    ASSERT(IsJScriptObject(obj)&&IsString(obj.Name),"CreateDefaultCollection::Collection._add : 参数错误");
    ASSERT(obj.Name!=parseInt(obj.Name),"CreateDefaultCollection::Collection._add : obj.Name 不能为数字");
    if(IsJScriptObject(_Coll[obj.Name]))return true;
    _Coll[obj.Name]=obj;
    _Length++;
    return true;
   }
   return Collection;
  }
 }

Answer 11

@cc_on
@set @debug=truefunction GetUndefined(){}
function IsUndefined(unknown){
return typeof(unknown)=="undefined";
}
function typeOf(unknown){
return typeof(unknown);
}
function valueOf(unknown){
if(IsUndefined(unknown))return GetUndefined();
try{
return unknown.valueOf();
}catch(x){}
return unknown;
}
function toString(unknown){
if(IsUndefined(unknown))return "";
if(unknown===null)return "";
try{
return unknown.toString();
}catch(x){}
return unknown+"";
}
function IsNull(unknown){
switch(typeOf(unknown))
{
case "undefined":return true;
case "string":return unknown=="";
case "number":return unknown==0;
case "object":return unknown==null;
case "function":return false;
default:return unknown?false:true;
}
}
function IsBoolean(unknown){
return typeOf(unknown)=="boolean";
}
function IsNumber(unknown){
return typeOf(unknown)=="number";
}
function IsString(unknown){
return typeOf(unknown)=="string";
}
function IsFunction(unknown){
return typeOf(unknown)=="function";
}
function IsObject(unknown){
return typeOf(unknown)=="object";
}
function IsJScriptObject(unknown)
{
if(false==IsObject(unknown)&&false==IsFunction(unknown))return false;
try{
return IsFunction(unknown.constructor);
}catch(x){
}
return false;
}function VarValueOf(unknown){
var arr=new Array();
var unknown2=unknown;
while(unknown=valueOf(unknown))
{
if(unknown2===unknown)return unknown;
arr[arr.length]=unknown2;
for(var i=0;i<arr.length;i++)
{
if(arr[i]===unknown)ThrowError("VarValueOf()检测到的valueOf环");
}
unknown2=unknown;
}
}
function VarTypeOf(unknown){
return typeOf(VarValueOf(unknown));
}
function VarToString(unknown){
return toString(VarValueOf(unknown));
}
//下面的判断根据VarValueOf来进行。
//对变量进行属性操作前不要使用这些判断
function VarIsBoolean(unknown){
return VarTypeOf(unknown)=="boolean";
}
function VarIsNumber(unknown){
return VarTypeOf(unknown)=="number";
}
function VarIsString(unknown){
return VarTypeOf(unknown)=="string";
}
function VarIsFunction(unknown){
return VarTypeOf(unknown)=="function";
}
function VarIsObject(unknown){
return VarTypeOf(unknown)=="object";
}function ThrowError(msg){
throw(new Error(-1,msg));
}
@if(@debug)
function ASSERT(mustbetrue,msg){
if(mustbetrue)return;
msg?null:(msg="下面函数发生未指定错误:\m"+fs().caller);
ThrowError("ASSERT - 发生错误:\n"+msg);
}
function BREAKPOINT(msg){
msg?null:(msg=fs().caller);
msg="BREAKPOINT,是否抛出异常?:\n"+msg;
if(confirm(msg)){
ThrowError("BREAKPOINT抛出异常");
}
}
function ALERT(msg){
alert("调试信息,请注意:\n"+msg);
}
@else
function ASSERT(mustbetrue,msg){}
function BREAKPOINT(msg){}
function ALERT(msg){}
@end
function fs(){return fs.caller}
function IsCalledByNew(_this){
try{
if(_this&&_this.constructor&&fs().caller==_this.constructor)
return true;
}catch(x){}
return false;
}//var1,var2,明确参数
function Delegate(var1,var2)
{
if(IsCalledByNew(this))ThrowError("new Delegate()是不合法的调用方式");
if(IsUndefined(var1))ThrowError("Delegate()参数无效");
if(IsUndefined(var2))
{
ASSERT(IsFunction(var1),"Delegate的参数非function");
return Delegate_Function(var1);
}
ASSERT(IsFunction(var1)||IsObject(var1),"Delegate的参数非object");
if(IsString(var2))
{
ASSERT(IsObject(var1[var2])||IsFunction(var1[var2]),"Delegate的参数不是方法");
return Delegate_Method(var1,var2);
}
else
{
ASSERT(IsJScriptObject(var1),"Delegate的参数非JScriptObject");
ASSERT(IsFunction(var2),"Delegate的参数非function");
return Delegate_VirtualMethod(var1,var2);
}

function Delegate_Function(func)
{
function Function()
{
if(IsNull(Function._Function))return;
var arr=new Array();
for(i=0;i<Function.arguments.length;i++)
arr[arr.length]="Function.arguments["+i+"]";
for(;i<Function._Arguments.length;i++)
arr[arr.length]="Function._Arguments["+i+"]";
var strArguments=arr.join(",");
var strEval="Function._Function("+strArguments+")"
strEval="var f=(function(){return "+strEval+"});f.Delegate=Function;f()";
return eval(strEval);
}
function Function.valueOf(){return Function();}
function Function.toString(){return Function();}
function Function.PreInvoke()
{
Function._Arguments=new Array();
Function.SetArguments(Function.PreInvoke.arguments);
return Function;
}
function Function.SetArguments(args)
{
for(var i=0;i<args.length;i++)
Function._Arguments[i]=args[i];
return Function;
}
function Function.Detach()
{
Function._Function=null;
Function._Arguments=null;
}
Function._Function=func;
Function._Arguments=new Array();
return Function;
}
function Delegate_Method(obj,name)
{
function Function()
{
if(IsNull(Function._Object))return;
var arr=new Array();
for(i=0;i<Function.arguments.length;i++)
arr[arr.length]="Function.arguments["+i+"]";
for(;i<Function._Arguments.length;i++)
arr[arr.length]="Function._Arguments["+i+"]";
var strArguments=arr.join(",");
var strEval="Function._Object."+Function._Name+"("+strArguments+")";
strEval="var f=(function(){return "+strEval+"});f.Delegate=Function;f()";
return eval(strEval);
}
function Function.valueOf(){return Function();}
function Function.toString(){return Function();}
function Function.PreInvoke()
{
Function._Arguments=new Array();
Function.SetArguments(Function.PreInvoke.arguments);
return Function;
}
function Function.SetArguments(args)
{
for(var i=0;i<args.length;i++)
Function._Arguments[i]=args[i];
return Function;
}
function Function.Detach()
{
Function._Object=null;
Function._Name="";
Function._Arguments=null;
}
Function._Object=obj;
Function._Name=name;
Function._Arguments=new Array();
return Function;
}
function Delegate_VirtualMethod(obj,func)
{
function Function()
{
if(IsNull(Function._Object))return;
var arr=new Array();
for(i=0;i<Function.arguments.length;i++)
arr[arr.length]="Function.arguments["+i+"]";
for(;i<Function._Arguments.length;i++)
arr[arr.length]="Function._Arguments["+i+"]";
var strArguments=arr.join(",");
var ppt="DelegateVirtualMethod"+new Date().getTime()+"_"+Math.floor(Math.random()*1000000);
Function._Object[ppt]=func;
var res,error;
var strEval="Function._Object."+ppt+"("+strArguments+")";
strEval="var f=(function(){return "+strEval+"});f.Delegate=Function;f()";
try{
res=eval(strEval);
}catch(x){
error=x;
}
if(!IsNull(Function._Object))delete Function._Object[ppt];
if(error)throw(error);
return res;
}
function Function.valueOf(){return Function();}
function Function.toString(){return Function();}
function Function.PreInvoke()
{
Function._Arguments=new Array();
Function.SetArguments(Function.PreInvoke.arguments);
return Function;
}
function Function.SetArguments(args)
{
for(var i=0;i<args.length;i++)
Function._Arguments[i]=args[i];
return Function;
}
function Function.Detach()
{
Function._Object=null;
Function._Function=null;
Function._Arguments=null;
}
Function._Object=obj;
Function._Function=func;
Function._Arguments=new Array();
return Function;
}
}
function Delegate.QueryDelegate()
{//小心递归
return fs().caller.caller.Delegate;
}

Answer 12

但是这些模拟的面向对象有很多无法弥补的先天不足
1.不能实现多修饰符,没有办法使一个static成员同时又是private的,所以简单的singleton模式就无法实现
2.没有构造器，方法不能覆盖(overloading)
3.不能直接继承
-----------------------------------------------------------------
但没有类型的js使得后期绑定变得水到渠成，很容易实现多态

Answer 13

：）
这个是教学用的例子：str="ok";
function GetFunc()
{
var str="GF"+Math.random();
return Func;
function Func()
{
return str;
}
}
var f1=GetFunc();
var f2=GetFunc();
alert(f1==f2);
alert(f1()+"\n"+f2()+"\n"+f1());

Answer 14

从一个空间的函数调用另外一个空间的函数的变量引用规则：str="ok";
function GetFuncA()
{
var str="GF"+Math.random();
return Func;
function Func()
{
return str;
}
}
function GetCaller(func)
{
var str="caller";
return Caller;
function Caller()
{
return str+":"+func();
}
}
var f=GetFuncA();
var c=GetCaller(f);
alert(c());