浅析php面向对象public private protected 访问修饰符
字体：[ ] 类型：转载 时间：
本篇文章是对php面向对象public private protected 访问修饰符进行了详细的分析介绍，需要的朋友参考下
PHP中有三种访问修饰符，分别是：&&&& public（公共的、默认）&&&& protected（受保护的）&&&& private（私有的）public（公共的、默认）在PHP5中如果类没有指定成员的访问修饰符，默认就是public的访问权限。protected（受保护的）被声明为protected的成员，只允许该类的子类进行访问。private（私有的 ） 被定义为private的成员，对于类内部所有成员都可见，没有访问限制。对类外部不允许访问。&图解demo 代码如下:class Woman{&&& public $name = "gaojin";&&& protected $age = "22";&&& private $height = "170";&&& function info(){&&&&&&& echo $this-&&&& }&&& private function say(){&&&&&&& echo "这是私有的方法";&&& }}//$w = new Woman();//echo $w-&info();//echo $w-&//公共属性可以访问//echo $w-&// 受保护属性,报致命错误//echo $w-&// 受保护属性,报致命错误//私有方法，访问出错//$w-&say(); // 私有方法，访问出错class Girl extends Woman{&&& // 可以重新定义父类的public和protected方法，但不能定义private的& //protected $name = "jingao"; // 可以从新定义&&& function info(){&&&&&&& echo $this-&&&&&&&& echo $this-&&&&&&&& echo $this-&&&& }&&& function say(){&&&&&&& //parent::say();//私有方法 不能被继承& 如果父类的的say方法是protected 这里就不会报错&&&&&&& echo "我是女孩";&&& }}$g = new Girl();$g-&say();//正常输出//echo $g-&//私有属性访问不到 没输出结果//$g-&info();//这是输出 gaojin22 $height是私有的属性没有被继承//$g-&height ="12";//这里是重新定义 height属性 也赋值了 //$g-&info();//所以这里会输出来gaojin2212
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具PHP 面向对象 - 简书
下载简书移动应用
写了38303字，被13人关注，获得了10个喜欢
PHP 面向对象
PHP 对待对象的方式与引用和句柄相同，即每个变量都持有对象的引用，而不是整个对象的拷贝。
类的定义：
class SimpleClass
// property declaration
public $var = 'a default value';
// method declaration
public function displayVar() {
echo $this-&
类的实例化：
$instance = new SimpleClass();
// 也可以这样做：
$className = 'Foo';
$instance = new $className(); // Foo()
$instance = new SimpleClass();
$reference
$instance-&var = '$assigned will have this value';
$instance = // $instance and $reference become null
var_dump($instance);
var_dump($reference);
var_dump($assigned);
object(SimpleClass)#1 (1) {
string(30) "$assigned will have this value"
PHP不支持多重继承，一个类只能继承一个基类。被继承的方法和属性可以通过用同样的名字重新声明被覆盖。但是如果父类定义方法时使用了 final，则该方法不可被覆盖。可以通过 parent:: 来访问被覆盖的方法或属性。当覆盖方法时，参数必须保持一致否则 PHP 将发出 E_STRICT 级别的错误信息。但构造函数例外，构造函数可在被覆盖时使用不同的参数。
自 PHP 5.5 起，关键词 class 也可用于类名的解析。使用 ClassName::class 你可以获取一个字符串，包含了类 ClassName 的完全限定名称。这对使用了 命名空间 的类尤其有用。
namespace NS {
class ClassName {
echo ClassName::
NS\ClassName
属性中的变量可以初始化，但是初始化的值必须是常数，这里的常数是指 PHP 脚本在编译阶段时就可以得到其值，而不依赖于运行时的信息才能求值。
如果直接使用 var 声明属性，而没有用 public，protected 或 private 之一，PHP 5 会将其视为 public。
在类的成员方法里面，可以用 -&（对象运算符）：$this-&property（其中 property 是该属性名）这种方式来访问非静态属性。静态属性则是用 ::（双冒号）：self::$property 来访问。
class SimpleClass
// 错误的属性声明
public $var1 = 'hello ' . 'world';
public $var2 = &&&EOD
hello world
public $var3 = 1+2;
public $var4 = self::myStaticMethod();
public $var5 = $myV
// 正确的属性声明
public $var6 = myC
public $var7 = array(true, false);
//在 PHP 5.3.0 及之后，下面的声明也正确
public $var8 = &&&'EOD'
hello world
可以把在类中始终保持不变的值定义为常量。在定义和使用常量的时候不需要使用 $ 符号。常量的值必须是一个定值，不能是变量，类属性，数学运算的结果或函数调用。接口（interface）中也可以定义常量。
自 PHP 5.3.0 起，可以用一个变量来动态调用类。但该变量的值不能为关键字（如 self，parent 或 static）。
class MyClass
const constant = 'constant value';
function showConstant() {
self::constant . "\n";
echo MyClass::constant . "\n";
$classname = "MyClass";
echo $classname::constant . "\n"; // 自 5.3.0 起
$class = new MyClass();
$class-&showConstant();
echo $class::constant."\n"; // 自 PHP 5.3.0 起
构造函数和析构函数
void __construct ([ mixed $args [, $... ]] )
如果子类中定义了构造函数则不会隐式调用其父类的构造函数。要执行父类的构造函数，需要在子类的构造函数中调用 parent::__construct()。如果子类没有定义构造函数则会如同一个普通的类方法一样从父类继承（假如没有被定义为 private 的话）。
class BaseClass {
function __construct() {
print "In BaseClass constructor\n";
class SubClass extends BaseClass {
function __construct() {
parent::__construct();
print "In SubClass constructor\n";
class OtherSubClass extends BaseClass {
// inherits BaseClass's constructor
// In BaseClass constructor
$obj = new BaseClass();
// In BaseClass constructor
// In SubClass constructor
$obj = new SubClass();
// In BaseClass constructor
$obj = new OtherSubClass();
为了实现向后兼容性，如果 PHP 5 在类中找不到 construct() 函数并且也没有从父类继承一个的话，它就会尝试寻找旧式的构造函数，也就是和类同名的函数。因此唯一会产生兼容性问题的情况是：类中已有一个名为 construct() 的方法却被用于其它用途时。与其它方法不同，当 construct() 被与父类 construct() 具有不同参数的方法覆盖时，PHP 不会产生一个 E_STRICT 错误信息。自 PHP 5.3.3 起，在命名空间中，与类名同名的方法不再作为构造函数。这一改变不影响不在命名空间中的类。
void __destruct ( void )
PHP 5 引入了析构函数的概念，这类似于其它面向对象的语言，如 C++。析构函数会在到某个对象的所有引用都被删除或者当对象被显式销毁时执行。
class MyDestructableClass {
function __construct() {
print "In constructor\n";
$this-&name = "MyDestructableClass";
function __destruct() {
print "Destroying " . $this-&name . "\n";
$obj = new MyDestructableClass();
和构造函数一样，父类的析构函数不会被引擎暗中调用。要执行父类的析构函数，必须在子类的析构函数体中显式调用 parent::__destruct()。此外也和构造函数一样，子类如果自己没有定义析构函数则会继承父类的。析构函数即使在使用 exit() 终止脚本运行时也会被调用。在析构函数中调用 exit() 将会中止其余关闭操作的运行。
试图在析构函数（在脚本终止时被调用）中抛出一个异常会导致致命错误。
对属性或方法的访问控制，是通过在前面添加关键字 public（公有），protected（受保护）或 private（私有）来实现的。被定义为公有的类成员可以在任何地方被访问。被定义为受保护的类成员则可以被其自身以及其子类和父类访问。被定义为私有的类成员则只能被其定义所在的类访问。类属性必须定义为公有，受保护，私有之一。如果用 var 定义，则被视为公有。类中的方法可以被定义为公有，私有或受保护。如果没有设置这些关键字，则该方法默认为公有。
其它对象的访问控制
同一个类的对象即使不是同一个实例也可以互相访问对方的私有与受保护成员。这是由于在这些对象的内部具体实现的细节都是已知的。
class Test
public function __construct($foo)
$this-&foo = $
private function bar()
echo 'Accessed the private method.';
public function baz(Test $other)
// We can change the private property:
$other-&foo = 'hello';
var_dump($other-&foo);
// We can also call the private method:
$other-&bar();
$test = new Test('test');
$test-&baz(new Test('other'));
string(5) "hello"
Accessed the private method.
除非使用了自动加载，否则一个类必须在使用之前被定义。如果一个类扩展了另一个，则父类必须在子类之前被声明。此规则适用于类继承其它类与接口。
public function printItem($string)
echo 'Foo: ' . $string . PHP_EOL;
public function printPHP()
echo 'PHP is great.' . PHP_EOL;
class bar extends foo
public function printItem($string)
echo 'Bar: ' . $string . PHP_EOL;
$foo = new foo();
$bar = new bar();
$foo-&printItem('baz'); // Output: 'Foo: baz'
$foo-&printPHP();
// Output: 'PHP is great'
$bar-&printItem('baz'); // Output: 'Bar: baz'
$bar-&printPHP();
// Output: 'PHP is great'
范围解析操作符（::）
范围解析操作符（也可称作 Paamayim Nekudotayim）或者更简单地说是一对冒号，可以用于访问静态成员，类常量，还可以用于覆盖类中的属性和方法。
在类的外部使用 :: 操作符
class MyClass {
const CONST_VALUE = 'A constant value';
$classname = 'MyClass';
echo $classname::CONST_VALUE; // 自 PHP 5.3.0 起
echo MyClass::CONST_VALUE;
在类定义内部使用 ::
self，parent 和 static 这三个特殊的关键字是用于在类定义的内部对其属性或方法进行访问的。
class OtherClass extends MyClass
public static $my_static = 'static var';
public static function doubleColon() {
echo parent::CONST_VALUE . "\n";
echo self::$my_static . "\n";
$classname = 'OtherClass';
echo $classname::doubleColon(); // 自 PHP 5.3.0 起
OtherClass::doubleColon();
当一个子类覆盖其父类中的方法时，PHP 不会调用父类中已被覆盖的方法。是否调用父类的方法取决于子类。这种机制也作用于构造函数和析构函数，重载以及魔术方法。
class MyClass
protected function myFunc() {
echo "MyClass::myFunc()\n";
class OtherClass extends MyClass
// 覆盖了父类的定义
public function myFunc()
// 但还是可以调用父类中被覆盖的方法
parent::myFunc();
echo "OtherClass::myFunc()\n";
$class = new OtherClass();
$class-&myFunc();
Static（静态）关键字
声明类属性或方法为静态，就可以不实例化类而直接访问。静态属性不能通过一个类已实例化的对象来访问（但静态方法可以）。
由于静态方法不需要通过对象即可调用，所以伪变量 $this 在静态方法中不可用。静态属性不可以由对象通过 -& 操作符来访问。用静态方式调用一个非静态方法会导致一个 E_STRICT 级别的错误。
PHP 5 支持抽象类和抽象方法。定义为抽象的类不能被实例化。任何一个类，如果它里面至少有一个方法是被声明为抽象的，那么这个类就必须被声明为抽象的。被定义为抽象的方法只是声明了其调用方式（参数），不能定义其具体的功能实现。继承一个抽象类的时候，子类必须定义父类中的所有抽象方法；另外，这些方法的访问控制必须和父类中一样（或者更为宽松）。此外方法的调用方式必须匹配，即类型和所需参数数量必须一致。例如，子类定义了一个可选参数，而父类抽象方法的声明里没有，则两者的声明并无冲突。 这也适用于 PHP 5.4 起的构造函数。在 PHP 5.4 之前的构造函数声明可以不一样的。
abstract class AbstractClass
// 强制要求子类定义这些方法
abstract protected function getValue();
abstract protected function prefixValue($prefix);
// 普通方法（非抽象方法）
public function printOut() {
print $this-&getValue() . "\n";
class ConcreteClass1 extends AbstractClass
protected function getValue() {
return "ConcreteClass1";
public function prefixValue($prefix) {
return "{$prefix}ConcreteClass1";
class ConcreteClass2 extends AbstractClass
public function getValue() {
return "ConcreteClass2";
public function prefixValue($prefix) {
return "{$prefix}ConcreteClass2";
$class1 = new ConcreteClass1;
$class1-&printOut();
echo $class1-&prefixValue('FOO_') ."\n";
$class2 = new ConcreteClass2;
$class2-&printOut();
echo $class2-&prefixValue('FOO_') ."\n";
ConcreteClass1
FOO_ConcreteClass1
ConcreteClass2
FOO_ConcreteClass2
abstract class AbstractClass
// 我们的抽象方法仅需要定义需要的参数
abstract protected function prefixName($name);
class ConcreteClass extends AbstractClass
// 我们的子类可以定义父类签名中不存在的可选参数
public function prefixName($name, $separator = ".") {
if ($name == "Pacman") {
$prefix = "Mr";
} elseif ($name == "Pacwoman") {
$prefix = "Mrs";
$prefix = "";
return "{$prefix}{$separator} {$name}";
$class = new ConcreteC
echo $class-&prefixName("Pacman"), "\n";
echo $class-&prefixName("Pacwoman"), "\n";
Mr. Pacman
Mrs. Pacwoman
使用接口（interface），可以指定某个类必须实现哪些方法，但不需要定义这些方法的具体内容。接口是通过 interface 关键字来定义的，就像定义一个标准的类一样，但其中定义所有的方法都是空的。接口中定义的所有方法都必须是公有，这是接口的特性。
实现（implements）
要实现一个接口，使用 implements 操作符。类中必须实现接口中定义的所有方法，否则会报一个致命错误。类可以实现多个接口，用逗号来分隔多个接口的名称。
实现多个接口时，接口中的方法不能有重名。接口也可以继承，通过使用 extends 操作符。类要实现接口，必须使用和接口中所定义的方法完全一致的方式。否则会导致致命错误。
接口中也可以定义常量。接口常量和类常量的使用完全相同，但是不能被子类或子接口所覆盖。
// 声明一个'iTemplate'接口
interface iTemplate
public function setVariable($name, $var);
public function getHtml($template);
// 实现接口
// 下面的写法是正确的
class Template implements iTemplate
private $vars = array();
public function setVariable($name, $var)
$this-&vars[$name] = $
public function getHtml($template)
foreach($this-&vars as $name =& $value) {
$template = str_replace('{' . $name . '}', $value, $template);
// 下面的写法是错误的，会报错，因为没有实现 getHtml()：
// Fatal error: Class BadTemplate contains 1 abstract methods
// and must therefore be declared abstract (iTemplate::getHtml)
class BadTemplate implements iTemplate
private $vars = array();
public function setVariable($name, $var)
$this-&vars[$name] = $
interface a
public function foo();
interface b extends a
public function baz(Baz $baz);
// 正确写法
class c implements b
public function foo()
public function baz(Baz $baz)
// 错误写法会导致一个致命错误
class d implements b
public function foo()
public function baz(Foo $foo)
interface a
public function foo();
interface b
public function bar();
interface c extends a, b
public function baz();
class d implements c
public function foo()
public function bar()
public function baz()
interface a
const b = 'Interface constant';
// 输出接口常量
echo a::b;
// 错误写法，因为常量不能被覆盖。接口常量的概念和类常量是一样的。
class b implements a
const b = 'Class constant';
PHP所提供的"重载"（overloading）是指动态地"创建"类属性和方法。我们是通过魔术方法（magic methods）来实现的。所有的重载方法都必须被声明为 public。
这些魔术方法的参数都不能通过引用传递。
PHP中的"重载"与其它绝大多数面向对象语言不同。传统的"重载"是用于提供多个同名的类方法，但各方法的参数类型和个数不同。
PHP 5 提供了一种定义对象的方法使其可以通过单元列表来遍历，例如用 foreach 语句。默认情况下，所有可见属性都将被用于遍历。
如果觉得我的文章对您有用，请随意打赏。您的支持将鼓励我继续创作！
打开微信“扫一扫”，打开网页后点击屏幕右上角分享按钮
被以下专题收入，发现更多相似内容：
· 17人关注
如果觉得我的文章对您有用，请随意打赏。您的支持将鼓励我继续创作！
选择支付方式：面向对象 | PHP源码阅读，PHP设计模式-胖胖的空间PHP面向对象基础知识总结
&&& 近来参加了几场PHP工程师的面试，但是笔试题答得都不理想，回来总结了一下失败的原因，是没看PHP手册。几家公司的PHP基础面试题都可以在PHP手册上找到。哎，现在才知道最好的面试宝典是PHP手册。
&&&&&&&& 下面是一些PHP面向对象基础知识的摘录，摘录内容来自PHP5.1手册。
1.类的变量成员叫做&属性&，或者叫&字段&、&特征&，在本文档统一称为&属性&。
2.属性中的变量可以初始化，但是初始化的值必须是常数，这里的常数是指php脚本在编译阶段时就为常数，而不是
在编译阶段之后在运行阶段运算出的常数。
3.在类的成员方法里面，可以通过$this-&property(property是属性名字)这种方式来访问类的属性、 方法，但是
要访问类的静态属性或者在静态方法里面却不能使用，而是使用self::$property。
4.在类的非静态方法里面可以使用伪变量$this，这个伪变量是调用该方法的实例化对象引用
5.常量的值必须是一个定值，不允许修改，且不能是变量，类属性或其它操作（如函数调用）的结果。
class MyClass
&&& const constant = 'constant value';
&&& function showConstant() {
&&&&&&& echo& self::constant . &\n&;
echo MyClass::constant . &\n&;
$n=new MyClass();
$n-&showConstant();
6.构造函数的类会在每次创建对象时先调用此方法，所以非常适合在使用对象之前做一些初始化工作。
如果子类中定义了构造函数则不会暗中调用其父类的构造函数。要执行父类的构造函数，需要在子类的构造函数中
调用 parent::__construct()。
7.析构函数会在到某个对象的所有引用都被删除或者当对象被显式销毁时执行。
父类的析构函数不会被引擎暗中调用。要执行父类的析构函数，必须在子类的析构函数体中显式调用
parent::__destruct()。
析构函数在脚本关闭时调用，此时所有的头信息已经发出。
试图在析构函数中抛出一个异常会导致致命错误。
8.当扩展一个类，子类就会继承父类的所有公有和保护方法。但是子类的方法会覆盖父类的方法。
9.范围解析操作符（::），可以用于访问静态成员、方法和常量
当在类的外部访问这些静态成员、方法和常量时，必须使用类的名字。
self 和 parent这两个特殊的关键字是用于在类的内部对成员或方法进行访问的。
10.当一个子类覆盖其父类中的方法时，PHP 不会再执行父类中已被覆盖的方法，直到子类中调用这些方法为止。这
种机制也作用于 构造函数和析构函数、重载 及 魔术 函数。
11.静态变量和方法
声明类成员或方法为static，就可以不实例化类而直接访问。不能通过一个对象来访问其中的静态成员（静态方法
由于静态方法不需要通过对象即可调用，所以伪变量$this在静态方法中不可用。
静态属性不可以由对象通过-&操作符来访问。
用::方式调用一个非静态方法会导致一个E_STRICT级别的错误。
就像其它所有的PHP静态变量一样，静态属性只能被初始化为一个字符值或一个常量，不能使用表达式。 所以你可
以把静态属性初始化为整型或数组，但不能指向另一个变量或函数返回值，也不能指向一个对象。
12.如果没有指定&可见性&，属性和方法默认为public。
抽象类不能直接被实例化，你必须先继承该抽象类，然后再实例化子类。抽象类中 至少要包含一个抽象方法。如果
类方法被声明为抽象的，那么其中就不能包括具体的功能实现。
继承一个抽象类的时候，子类必须实现抽象类中的所有抽象方法；另外，这些方法的可见性 必须和抽象类中一样（
或者更为宽松）。如果抽象类中某个抽象方法被声明为protected，那么子类中实现的方法就应该声明为protected
或者public，而不 能定义为private。
应用示例：
abstract class AbstractClass
&// 强制要求子类定义这些方法
&&& abstract protected function getValue();
&&& abstract protected function prefixValue($prefix);
&&& // 普通方法（非抽象方法）
&&& public function printOut() {
&&&&&&& print $this-&getValue() . &\n&;
class ConcreteClass1 extends AbstractClass
&&& protected function getValue() {
&&&&&&& return &ConcreteClass1&;
&&& public function prefixValue($prefix) {
&&&&&&& return &{$prefix}ConcreteClass1&;
14.使用接口（interface），你可以指定某个类必须实现哪些方法，但不需要定义这些方法的具体内容。
我们可以通过interface来定义一个接口，就像定义一个标准的类一样，但其中定义所有的方法都是空的。
接口中定义的所有方法都必须是public，这是接口的特性。
要实现一个接口，可以使用implements操作符。类中必须实现接口中定义的所有方法，否则 会报一个fatal错误。
如果要实现多个接口，可以用逗号来分隔多个接口的名称。
实现多个接口时，接口中的方法不能有重名。
接口也可以继承，通过使用extends操作符。
接口中也可以定义常量。接口常量和类常量的使用完全相同。 它们都是定值，不能被子类或子接口修改。
应用示例：
//接口定义
interface iTemplate
&&& public function setVariable($name, $var);
&&& public function getHtml($template);
//使用接口
class Template implements iTemplate
&&& private $vars = array();
&&& public function setVariable($name, $var)
&&&&&&& $this-&vars[$name] = $
&&& public function getHtml($template)
&&&&&&& foreach($this-&vars as $name =& $value) {
&&&&&&&&&&& $template = str_replace('{' . $name . '}', $value, $template);
&&&&&&& return $
15.PHP5提供了一种迭代（iteration）对象的功能，就像使用数组那样，可以通过foreach来遍历对象中的属性。
默认情况下，在外部迭代只能得到外部可见的属性的值。
应用示例：
class MyClass
&&& public $var1 = 'value 1';
&&& public $var2 = 'value 2';
&&& public $var3 = 'value 3';
&&& protected $protected = 'protected var';
&&& private&& $private&& = 'private var';
&&& function iterateVisible() {
&&&&&& echo &MyClass::iterateVisible:\n&;
&&&&&& foreach($this as $key =& $value) {
&&&&&&&&&& print &$key =& $value\n&;
$class = new MyClass();
foreach($class as $key =& $value) {
&&& print &$key =& $value\n&;
echo &\n&;
$class-&iterateVisible();
16.设计模式
工厂模式（Factory）允许你在代码执行时实例化对象。它之所以被称为工厂模式是因为它负责&生产&对象。工厂
方法的参数是 你要生成的对象对应的类名称。
单例模式（Singleton）用于为一个类生成一个唯一的对象。最常用的地方是数据库连接。 使用单例模式生成一个
对象后，该对象可以被其它众多对象所使用。
应用示例：
class Example
&&& // 保存类实例在此属性中
&&& private static $
&&&&&& // 构造方法声明为private，防止直接创建对象
&&& private function __construct()
&&&&&&& echo 'I am constructed';
&&& // singleton 方法
&&& public static function singleton()
&&&&&&& if (!isset(self::$instance)) {
&&&&&&&&&&& $c = __CLASS__;
&&&&&&&&&&& self::$instance = new $c;
&&&&&&& return self::$
&&& // Example类中的普通方法
&&& public function bark()
&&&&&&& echo 'Woof!';
&&& // 阻止用户复制对象实例
&&& public function __clone()
&&&&&&& trigger_error('Clone is not allowed.', E_USER_ERROR);
这样我们可以得到一个独一无二的Example类的对象。
// 这个写法会出错，因为构造方法被声明为private
$test = new E
// 下面将得到Example类的单例对象
$test = Example::singleton();
$test-&bark();
// 复制对象将导致一个E_USER_ERROR.
$test_clone = clone $
17.PHP 5 新增了一个 final 关键字。如果父类中的方法被声明为final，则子类无法覆盖该方法； 如果一个类被
声明为final，则不能被继承。
18.对象复制可以通过clone关键字来完成（如果对象中存在__clone()方法，会先被调用）。对象中的 __clone()
方法不能直接调用。
$copy_of_object = clone $
当对象被复制后，PHP5会对对象的所有属性执行一个&浅复制&（shallow copy）。所有的属性中的引用 仍然不
变，指向原来的变量。如果定义了__clone()方法，则新创建的对象（复制生成的对象）中的__clone()方法会被调
用， 可用于修改属性的值（如果有必要的话）。
19.对象比较
当使用对比操作符(==)比较两个对象变量时，比较的原则是：如果两个对象的属性和属性值 都相等，而且两个对象
是同一个类的实例，那么这两个对象变量相等。
而如果使用全等操作符(===)，这两个对象变量一定要指向某个类的同一个实例（即同一个对象）。
20.对象和引用
php的引用是别名，就是两个不同的变量名字指向相同的内容。在php5，一个对象变量已经不再保存整个对象的值。
只是保存一个标识符来访问真正的对象内容。 当对象作为参数传递，作为结果返回，或者赋值给另外一个变量，另
外一个变量跟原来的不是引用的关系，只是他们都保存着同一个标识符的拷贝，这个标识符指向同一个对象的真正
作者：JL_liuning
(window.slotbydup=window.slotbydup || []).push({
id: '2467140',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467141',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467143',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467148',
container: s,
size: '1000,90',
display: 'inlay-fix'