小編給大家分享一下js對象有什么用，相信大部分人都還不怎么了解，因此分享這篇文章給大家參考一下，希望大家閱讀完這篇文章后大有收獲，下面讓我們一起去了解一下吧！

創(chuàng)新互聯(lián)長期為近1000家客戶提供的網(wǎng)站建設(shè)服務(wù)，團(tuán)隊從業(yè)經(jīng)驗10年，關(guān)注不同地域、不同群體，并針對不同對象提供差異化的產(chǎn)品和服務(wù)；打造開放共贏平臺，與合作伙伴共同營造健康的互聯(lián)網(wǎng)生態(tài)環(huán)境。為武威企業(yè)提供專業(yè)的網(wǎng)站設(shè)計、成都網(wǎng)站制作，武威網(wǎng)站改版等技術(shù)服務(wù)。擁有10多年豐富建站經(jīng)驗和眾多成功案例,為您定制開發(fā)。

JavaScript作為一個基于對象(沒有類的概念)的語言，從入門到精通到放棄一直會被對象這個問題圍繞。

平時發(fā)的文章基本都是開發(fā)中遇到的問題和對最佳解決方案的探討，終于忍不住要寫一篇基礎(chǔ)概念類的文章了。

本文探討以下問題，在座的朋友各取所需，歡迎批評指正:

1、創(chuàng)建對象
2、__proto__與prototype
3、繼承與原型鏈
4、對象的深度克隆
5、一些Object的方法與需要注意的點
6、ES6新增特性

下面反復(fù)提到實例對象和原型對象，通過構(gòu)造函數(shù) new 出來的本文稱作 實例對象，構(gòu)造函數(shù)的原型屬性本文稱作 原型對象。

創(chuàng)建對象

字面量的方式:

var myHonda = {color: "red", wheels: 4, engine: {cylinders: 4, size: 2.2}}

就是new Object()的語法糖，一樣一樣的。

工廠模式:

function createCar(){ 
 var oTemp = new Object(); 
 oTemp.name = arguments[0];
 //直接給對象添加屬性，每個對象都有直接的屬性 
 oTemp.age = arguments[1]; 
 oTemp.showName = function () {  
 alert(this.name); 
 };//每個對象都有一個 showName 方法版本 
 return oTemp;
};
var myHonda = createCar('honda', 5)

只是給new Object()包了層皮，方便量產(chǎn)，并沒有本質(zhì)區(qū)別，姑且算作創(chuàng)建對象的一種方式。

構(gòu)造函數(shù):

function Person(name, age, sex) {
 this.name = name;
 this.age = age;
 this.sex = sex;
 this.getName = function() {
return this.name;
 };
}
var rand = new Person("Rand McKinnon", 33, "M");

上面構(gòu)造函數(shù)的 getName 方法，每次實例化都會新建該函數(shù)對象，還形成了在當(dāng)前情況下并沒有卵用的閉包，所以構(gòu)造函數(shù)添加方法用下面方式處理，工廠模式給對象添加方法的時候也應(yīng)該用下面的方式避免重復(fù)構(gòu)造函數(shù)對象

function Person(name, age, sex) {
 this.name = name;
 this.age = age;
 this.sex = sex;
 this.getName = getName
}
function getName() {
 return this.name;
};

構(gòu)造函數(shù)創(chuàng)建對象的過程和工廠模式又是半斤八兩，相當(dāng)于隱藏了創(chuàng)建新對象和返回該對象這兩步，構(gòu)造函數(shù)內(nèi) this 指向新建對象，沒什么不同。

最大不同點: 構(gòu)造函數(shù)創(chuàng)造出來的對象 constructor 屬性指向該構(gòu)造函數(shù)，工廠模式指向 function Object(){...}。

構(gòu)造函數(shù)相當(dāng)于給原型鏈上加了一環(huán)，構(gòu)造函數(shù)有自己的 prototype，工廠模式就是個普通函數(shù)。說到這兒我上一句話出現(xiàn)了漏洞，工廠模式的 constructor 指向哪得看第一句話 new 的是什么。

構(gòu)造函數(shù)直接調(diào)用而不 new 的話，就看調(diào)用時候 this 指向誰了，直接調(diào)用就把屬性綁到 window 上了，通過 call 或者 apply 綁定到其他對象作用域就把屬性添加到該對象了。

原型模式:

構(gòu)造函數(shù)雖然在原型鏈上加了一環(huán)，但顯然這一環(huán)啥都沒有啊，這樣一來和工廠模式又有什么區(qū)別？加了一環(huán)又有什么意義？原型模式浮出水面。

function Car(){} 
//用空構(gòu)造函數(shù)設(shè)置類名
Car.prototype.color = "blue";//每個對象都共享相同屬性
Car.prototype.doors = 3;
Car.prototype.drivers = new Array("Mike","John");
Car.prototype.showColor = function(){  
 alert(this.color);
};//每個對象共享一個方法版本，省內(nèi)存。
//構(gòu)造函數(shù)的原型屬性可以通過字面量來設(shè)置，別忘了通過 Object.defineProperty()設(shè)置 constructor 為該構(gòu)造函數(shù)
function Car(){} 
Car.prototype = {
 color:"blue",
 doors:3,
 showColor:function(){  
alert(this.color);
 }
}
Object.defineProperty(Car.prototype, "constructor", { enumerable:false, value:Car })
//(不設(shè)置 constructor 會導(dǎo)致 constructor 不指向構(gòu)造函數(shù)，直接設(shè)置 constructor 會導(dǎo)致 constructor 可枚舉)

使用原型模式注意動態(tài)性，通過構(gòu)造函數(shù)實例化出的對象，他的原型對象是構(gòu)造函數(shù)的 prototype ，如果在他的原型對象上增加或刪除一些方法，該對象會繼承這些修改。例如，先通過構(gòu)造函數(shù) A 實例化出對象 a ，然后再給 A.prototype 添加一個方法，a 是可以繼承這個方法的。但是給 A.prototype 設(shè)置一個新的對象，a 是不會繼承這個新對象的屬性和方法的。聽起來有點繞，修改 A.prototype 相當(dāng)于直接修改 a 的原型對象，a 很自然的會繼承這些修改，但是重新給 A.prototype 賦值的話，修改的是構(gòu)造函數(shù)的原型，并沒有影響 a 的原型對象！a 被創(chuàng)建出來以后原型對象就已經(jīng)確定了，除非直接修改這個原型對象(或者這個原型對象的原型對象)，否則 a 是不會繼承這些修改的！

Object.create()

傳入要創(chuàng)建對象實例的原型對象，和原型模式幾乎是一個意思也是相當(dāng)于在原型鏈上加了一環(huán)，區(qū)別在于這種方式創(chuàng)建的對象沒有構(gòu)造函數(shù)。這種方式相當(dāng)于:

function object(o){
function F(){}
F.prototype = o;
return new F()
}

相當(dāng)于構(gòu)造函數(shù)只短暫的存在了一會，創(chuàng)建出來的對象的 constructor 指向 原型對象 o 的 constructor ！

混合模式:

使用原型模式時，當(dāng)給實例對象設(shè)置自己專屬的屬性的時候，該實例對象會忽略原型鏈中的該屬性。但當(dāng)原型鏈中的屬性是引用類型值的時候，操作不當(dāng)有可能會直接修改原型對象的屬性！這會影響到所有使用該原型對象的實例對象！

大部分情況下，實例對象的多數(shù)方法是共有的，多數(shù)屬性是私有的，所以屬性在構(gòu)造函數(shù)中設(shè)置，方法在原型中設(shè)置是合適的，構(gòu)造函數(shù)與原型結(jié)合使用是通常的做法。

還有一些方法，無非是工廠模式與構(gòu)造函數(shù)與原型模式的互相結(jié)合，在生成過程和 this 指向上做一些小變化。

class 方式:

見下面 ES6 class 部分，只是一個語法糖，本質(zhì)上和構(gòu)造函數(shù)并沒有什么區(qū)別，但是繼承的方式有一些區(qū)別。

proto與prototype

這兩個到底是什么關(guān)系？搞清楚 實例對象 構(gòu)造函數(shù) 原型對象 的三角關(guān)系，這兩個屬性的用法就自然清晰了，順便說下 constructor。

構(gòu)造函數(shù)創(chuàng)建的實例對象的 constructor 指向該構(gòu)造函數(shù)(但實際上 constructor 是對應(yīng)的原型對象上的一個屬性！所以實例對象的 constructor 是繼承來的，這一點要注意，如果利用原型鏈繼承，constructor 將有可能指向原型對象的構(gòu)造函數(shù)甚至更上層的構(gòu)造函數(shù)，其他重寫構(gòu)造函數(shù) prototype 的行為也會造成 constructor 指向問題，都需要重設(shè) constructor)，構(gòu)造函數(shù)的 prototype 指向?qū)?yīng)的原型對象，實例對象的 __proto__ 指對應(yīng)的原型對象，__proto__是瀏覽器的實現(xiàn)，并沒有出現(xiàn)在標(biāo)準(zhǔn)中，可以用 constructor.prototype 代替?？紤]到 Object.create() 創(chuàng)建的對象，更安全的方法是 Object.getPrototpyeOf() 傳入需要獲取原型對象的實例對象。

我自己都感覺說的有點亂，但是他們就是這樣的，上一張圖，看看能不能幫你更深刻理解這三者關(guān)系。

繼承與原型鏈

當(dāng)訪問一個對象的屬性時，如果在對象本身找不到，就會去搜索對象的原型，原型的原型，知道原型鏈的盡頭 null，那原型鏈?zhǔn)窃趺存溒饋淼模?/p>

把 實例對象 構(gòu)造函數(shù) 原型對象 視為一個小組，上面說了三者互相之間的關(guān)系，構(gòu)造函數(shù)是函數(shù)，可實例對象和原型對象可都是普通對象啊，這就出現(xiàn)了這樣的情況:

這個小組的原型對象，等于另一個小組實例對象，而此小組的原型對象又可能是其他小組的實例對象，這樣一個個的小組不就連接起來了么。舉個例子:

function Super(){
 this.val = 1;
 this.arr = [1];
}
function Sub(){
 // ...
}
Sub.prototype = new Super();

Sub 是一個小組 Super 是一個小組，Sub 的原型對象鏈接到了 Super 的實例對象。

基本上所有對象順著原型鏈爬到頭都是 Object.prototype , 而 Object.prototype 就沒有原型對象，原型鏈就走到頭了。

判斷構(gòu)造函數(shù)和原型對象是否存在于實例對象的原型鏈中:

實例對象 instanceof 構(gòu)造函數(shù)，返回一個布爾值，原型對象.isPrototypeOf(實例對象)，返回一個布爾值。

上面是最簡單的繼承方式了，但是有兩個致命缺點:

所有 Sub 的實例對象都繼承自同一個 Super 的實例對象，我想傳參數(shù)到 Super 怎么辦？

如果 Super 里有引用類型的值，比如上面例子中我給 Sub 的實例對象中的 arr 屬性 push 一個值，豈不是牽一發(fā)動全身？

下面說一種最常用的組合繼承模式，先舉個例子:

function Super(value){
 // 只在此處聲明基本屬性和引用屬性
 this.val = value;
 this.arr = [1];
}
// 在此處聲明函數(shù)
Super.prototype.fun1 = function(){};
Super.prototype.fun2 = function(){};
//Super.prototype.fun3...
function Sub(value){
 Super.call(this,value); // 核心
 // ...
}
Sub.prototype = new Super(); // 核心

過程是這樣的，在簡單的原型鏈繼承的基礎(chǔ)上， Sub 的構(gòu)造函數(shù)里運行 Super ，從而給 Sub 的每一個實例對象一份單獨的屬性，解決了上面兩個問題，可以給 Super 傳參數(shù)了，而且因為是獨立的屬性，不會因為誤操作引用類型值而影響其他實例了。不過還有個小缺點: Sub 中調(diào)用的 Super 給每個 Sub 的實例對象一套新的屬性，覆蓋了繼承的 Super 實例對象的屬性，那被覆蓋的的那套屬性不就浪費了？豈不是白繼承了？最嚴(yán)重的問題是 Super 被執(zhí)行了兩次，這不能忍(其實也沒多大問題)。下面進(jìn)行一下優(yōu)化，把上面例子最后一行替換為:

Sub.prototype = Object.create(Super.prototype);
// Object.create() 給原型鏈上添加一環(huán)，否則 Sub 和 Super 的原型就重疊了。
Sub.prototype.constructor = Sub;

到此為止，繼承非常完美。

其他還有各路繼承方式無非是在 簡單原型鏈繼承 --> 優(yōu)化的組合繼承 路程之間的一些思路或者封裝。

通過 class 繼承的方式:

通過 class 實現(xiàn)繼承的過程與 ES5 完全相反，詳細(xì)見下面 ES6 class的繼承 部分。

對象的深度克隆

JavaScript的基礎(chǔ)類型是值傳遞，而對象是引用傳遞，這導(dǎo)致一個問題:

克隆一個基礎(chǔ)類型的變量的時候，克隆出來的的變量是和舊的變量完全獨立的，只是值相同而已。

而克隆對象的時候就要分兩種情況了，簡單的賦值會讓兩個變量指向同一塊內(nèi)存，兩者代表同一個對象，甚至算不上克隆克隆。但我們常常需要的是兩個屬性和方法完全相同但卻完全獨立的對象，稱為深度克隆。我們接下來討論幾種深度克隆的方法。

說幾句題外的話，業(yè)界有一個非常知名的庫 immutable ，個人認(rèn)為很大程度上解決了深度克隆的痛點，我們修改一個對象的時候，很多時候希望得到一個全新的對象(比如Redux每次都要用一個全新的對象修改狀態(tài))，由此我們就需要進(jìn)行深度克隆。而 immutable 相當(dāng)于產(chǎn)生了一種新的對象類型，每一次修改屬性都會返回一個全新的 immutable 對象，免去了我們深度克隆的工作是小事，關(guān)鍵性能特別好。

歷遍屬性

function clone(obj){
 var newobj = obj.constructor === Array ? [] : {}; // 用 instanceof 判斷也可
 if(typeof obj !== 'object' || obj === null ){
return obj
 } else {
for(var i in obj){
 newobj[i] = typeof obj[i] === 'object' ? cloneObj(obj[i]) : obj[i]; 
 // 只考慮 對象和數(shù)組， 函數(shù)雖然也是引用類型，但直接賦值并不會產(chǎn)生什么副作用，所以函數(shù)類型無需深度克隆。
}
 }
 return newobj;
};

原型式克隆

function clone(obj){
 function F() {};
 F.prototype = obj;
 var f = new F();
 for(var key in obj)
 {
 if(typeof obj[key] =="object")
 {
  f[key] = clone(obj[key])
 }
 }
 return f ;
}

這種方式不能算嚴(yán)格意義上的深度克隆，并沒有切斷新對象與被克隆對象的聯(lián)系，被克隆對象作為新對象的原型存在，雖然新對象的改變不會影響舊對象，但反之則不然！而且給新對象屬性重新賦值的時候只是覆蓋了原型中的屬性，在歷遍新對象的時候也會出現(xiàn)問題。這種方式問題重重，除了實現(xiàn)特殊目的可以酌情使用，通常情況應(yīng)避免使用。
json序列化

var newObj = JSON.parse(JSON.stringify(obj));

這是我最喜歡的方式了！簡短粗暴直接！但是最大的問題是，畢竟JSON只是一種數(shù)據(jù)格式所以這種方式只能克隆屬性，不能克隆方法，方法在序列化以后就消失了。。。

一些Object的方法與需要注意的點

Object 自身的方法:

設(shè)置屬性，Object.defineProperty(obj, prop, descriptor) 根據(jù) descriptor 定義 obj 的 prop 屬性(值，是否可寫可枚舉可刪除等)。

Object.getOwnPropertyDescriptor(obj, prop) 返回 obj 的 prop 屬性的描述。

使對象不可拓展，Object.preventExtensions(obj)，obj 將不能添加新的屬性。

判斷對像是否可拓展，Object.isExtensible(obj)。

密封一個對象，Object.seal(obj)，obj 將不可拓展且不能刪除已有屬性。

判斷對象是否密封，Object.isSealed(obj)。

凍結(jié)對象，Object.freeze(obj) obj 將被密封且不可修改。

判斷對象是否凍結(jié)，Object.isFrozen(obj)。

獲取對象自身屬性(包括不可枚舉的)，Object.getOwnPropertyNames(obj)，返回 obj 所有自身屬性組成的數(shù)組。

獲取對象自身屬性(不包括不可枚舉的)，Object.keys(obj)，返回 obj 所有自身可枚舉屬性組成的數(shù)組。

當(dāng)使用for in循環(huán)遍歷對象的屬性時，原型鏈上的所有可枚舉屬性都將被訪問。

只關(guān)心對象本身時用Object.keys(obj)代替 for in，避免歷遍原型鏈上的屬性。

獲取某對象的原型對象，Object.getPrototypeOf(object)，返回 object 的原型對象。

設(shè)置某對象的原型對象，Object.setPrototypeOf(obj, prototype)，ES6 新方法，設(shè)置 obj 的原型對象為 prototype ，該語句比較耗時。

Object.prototype 上的方法:

檢查對象上某個屬性是否存在時(存在于本身而不是原型鏈中)，obj.hasOwnProperty() 是唯一可用的方法，他不會向上查找原型鏈，只在 obj 自身查找，返回布爾值。

檢測某對象是否存在于參數(shù)對象的原型鏈中，obj.isPrototypeOf(obj2)，obj 是否在 obj2 的原型鏈中，返回布爾值。

檢測某屬性是否是對象自身的可枚舉屬性，obj.propertyIsEnumerable(prop)，返回布爾值。

對象類型，obj.toString()，返回 "[object type]" type 可以是 Date，Array，Math 等對象類型。

obj.valueOf(),修改對象返回值時的行為，使用如下:

function myNumberType(n) {
this.number = n;
}
myNumberType.prototype.valueOf = function() {
return this.number;
};
myObj = new myNumberType(4);
myObj + 3; // 7

ES6新增特性

判斷兩個值是否完全相等，Object.is(value1, value2)，類似于 === 但是可以用來判斷 NaN。

屬性和方法簡寫:

// 屬性簡寫
var foo = 'bar';
var baz = {foo};
baz // {foo: "bar"}
// 等同于
var baz = {foo: foo};
// 方法簡寫
function f(x, y) {
 return {x, y};
}
// 等同于
function f(x, y) {
 return {x: x, y: y};
}
f(1, 2) // Object {x: 1, y: 2}

合并對象:

Object.assign(target, [...source]);

將 source 中所有和枚舉的屬性復(fù)制到 target。

多個 source 對象有同名屬性，后面的覆蓋前面的。

var target = { a: 1 };
var source1 = { b: 2 };
var source2 = { c: 3 };
Object.assign(target, source1, source2);
target // {a:1, b:2, c:3}

注意一點，該命令執(zhí)行的是淺克隆，如果 source 中有屬性是對象，target 中會復(fù)制該對象的引用。

常用于給對象添加屬性和方法(如給構(gòu)造函數(shù)的原型添加方法)，克隆、合并對象等。

獲取對象自身的值或鍵值對(做為Object.keys(obj)的補(bǔ)充不包括不可枚舉的):

Object.keys(obj)返回 obj 自身所有可枚舉屬性的值組成的數(shù)組。

Object.entries(obj)返回 obj 自身所有可枚舉鍵值對數(shù)組組成的數(shù)組，例如:

var obj = { foo: 'bar', baz: 42 };
Object.entries(obj)
// [ ["foo", "bar"], ["baz", 42] ]
// 可用于將對象轉(zhuǎn)為 Map 結(jié)構(gòu)
var obj = { foo: 'bar', baz: 42 };
var map = new Map(Object.entries(obj));
map // Map { foo: "bar", baz: 42 }

拓展運算符:

取出對象所有可歷遍屬性，舉例:

let z = { a: 3, b: 4 };
let n = { ...z };
n // { a: 3, b: 4 }
// 可代替 Object.assign()
let ab = { ...a, ...b };
// 等同于
let ab = Object.assign({}, a, b);

可用于解構(gòu)賦值中最后一個參數(shù):

let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };
x // 1
y // 2
z // { a: 3, b: 4 }
// 可以這樣理解，把 z 拆開以后就等于后面對象未被分配出去的鍵值對。

Null 傳導(dǎo)運算符:

const firstName = message?.body?.user?.firstName || 'default';
// 代替
const firstName = (message
 && message.body
 && message.body.user
 && message.body.user.firstName) || 'default';

class:

ES6 引入了 class 關(guān)鍵字，但并沒有改變對象基于原型繼承的原理，只是一個語法糖，讓他長得像傳統(tǒng)面向?qū)ο笳Z言而已。

以下兩個寫法完全等價:

function Point(x, y) {
 this.x = x;
 this.y = y;
}
Point.prototype.toString = function () {
 return '(' + this.x + ', ' + this.y + ')';
};
//定義類
class Point {
 constructor(x, y) {
this.x = x;
this.y = y;
 }
 toString() {
return '(' + this.x + ', ' + this.y + ')';
 }
}
// 類中定義的方法就是在原型上

有兩點區(qū)別， class 中定義的方法是不可枚舉的，class 必須通過 new 調(diào)用不能直接運行。

class 不存在變量提升，使用要在定義之后。

class 中的方法前加 static 關(guān)鍵字定義靜態(tài)方法，只能通過 class 直接調(diào)用不能被實例繼承。

如果靜態(tài)方法包含 this 關(guān)鍵字，這個 this 指的是 class，而不是實例。注意下面代碼:

class Foo {
 static bar () {
 this.baz();
 }
 static baz () {
 console.log('hello');
 }
 baz () {
 console.log('world');
 }
}
Foo.bar() // hello

父類的靜態(tài)方法，可以被子類繼承，目前 class 內(nèi)部無法定義靜態(tài)屬性。

設(shè)置靜態(tài)屬性與實例屬性新提案:

class 的實例屬性可以用等式，寫入類的定義之中。

靜態(tài)屬性直接前面加 static 即可。

class MyClass {
 myProp = 42;
 static myStaticProp = 42;
}

class 的繼承:

class 通過 extends 實現(xiàn)繼承,注意 super 關(guān)鍵字

class ColorPoint extends Point {
 constructor(x, y, color) {
super(x, y); // 調(diào)用父類的constructor(x, y)
this.color = color;
 }
 toString() {
return this.color + ' ' + super.toString(); // 調(diào)用父類的toString()
 }
}

extends 可以繼承其他類或任何有 prototype 屬性的函數(shù)。

super 會從父類獲取各路信息綁定到子類的 this。

子類自己沒有 this 對象，要先繼承父類的實例對象然后再進(jìn)行加工，所以要在 constructor 里調(diào)用 super 繼承 this 對象后才能使用 this。

ES5 的繼承，實質(zhì)是先創(chuàng)造子類的實例對象 this，然后再將父類的方法添加到 this 上面（Parent.apply(this)）。ES6 的繼承機(jī)制完全不同，實質(zhì)是先創(chuàng)造父類的實例對象 this（所以必須先調(diào)用 super 方法創(chuàng)建和繼承這個 this，并綁定到子類的 this），然后再用子類的構(gòu)造函數(shù)修改this。

這條理由也是造成了 ES6 之前無法繼承原生的構(gòu)造函數(shù)(Array Function Date 等)的原型對象，而使用 class 可以。因為 ES5 中的方法是先實例化子類，再把父類的屬性添加上去，但是父類有很多不能直接訪問的屬性或方法，這就糟了，而通過 class 繼承反其道而行之先實例化父類，這就自然把所有屬性和方法都繼承了。

super 作為對象時，在普通方法中，指向父類的原型對象；在靜態(tài)方法中，指向父類。

通過 super 調(diào)用父類的方法時，super 會綁定子類的 this。

constructor 方法會被默認(rèn)添加:

class ColorPoint extends Point {
}
// 等同于
class ColorPoint extends Point {
 constructor(...args) {
super(...args);
 }
}

Object.getPrototypeOf(object)，獲取某對象的原型對象，也可以獲取某類的原型類。

class 的 __proto__與prototype

子類的__proto__屬性，表示構(gòu)造函數(shù)的繼承，總是指向父類。

子類prototype屬性的__proto__屬性，表示方法的繼承，總是指向父類的 prototype 屬性。

相當(dāng)于子類本身繼承父類，子類的原型對象繼承自父類的原型對象。

new.target:

用在構(gòu)造函數(shù)或者 class 內(nèi)部，指向調(diào)用時 new 的構(gòu)造函數(shù)或者 class。

以上是“js對象有什么用”這篇文章的所有內(nèi)容，感謝各位的閱讀！相信大家都有了一定的了解，希望分享的內(nèi)容對大家有所幫助，如果還想學(xué)習(xí)更多知識，歡迎關(guān)注創(chuàng)新互聯(lián)行業(yè)資訊頻道！