javascript中的非和不等于為什么不一樣

從邏輯上分析一下就知道，如果要判斷某個字符“既不等于X，也不等于x”，這兩個條件之間的關(guān)系是“與”而不是“或”，所以你的第一個表達(dá)式正確的應(yīng)該是：

創(chuàng)新互聯(lián)專注于四平網(wǎng)站建設(shè)服務(wù)及定制，我們擁有豐富的企業(yè)做網(wǎng)站經(jīng)驗。 熱誠為您提供四平營銷型網(wǎng)站建設(shè)，四平網(wǎng)站制作、四平網(wǎng)頁設(shè)計、四平網(wǎng)站官網(wǎng)定制、重慶小程序開發(fā)服務(wù)，打造四平網(wǎng)絡(luò)公司原創(chuàng)品牌,更為您提供四平網(wǎng)站排名全網(wǎng)營銷落地服務(wù)。

if(str.charAt(str.length-1)!="X"str.charAt(str.length-1)!="x")

而如果換一種說法，即“把所有等于X或等于x的字符排除掉”，這時候兩者的關(guān)系就是“或”了，所以你的第二個表達(dá)式是正確的：

if(!(str.charAt(str.length-1)=="X"||str.charAt(str.length-1)=="x"))

Javascript中邏輯非!運算符放置問題？

第二個！并不是邏輯非運算符，它和=合在一起表示不等于。

即 == 是邏輯等于運算符，!= 是邏輯不等于運算符。

這樣一來，邏輯非運算符應(yīng)該放在哪的問題就不是問題了。

js與或非

（1）對于布爾值，只有都為true才返回true；

（2）對于不是布爾值的情況則：

如果第一個操作數(shù)是對象，則返回第二個數(shù)

? ? ? ? ? ? ????????eg：var str = new Array();?

console.log(str8)；//返回值為8

如果第二個操作數(shù)是對象，則只有在第一個操作數(shù)的求值結(jié)果為true的情況下才會返回該對象。

如果第兩個操作數(shù)都是對象，則返回第二個數(shù)操作數(shù)。

如果有一個操作數(shù)是null，則返回null。

? ? ? ? ? ? ????????eg： console.log(8null);//返回結(jié)果為null

如果有一個操作數(shù)是NaN，則返回第NaN。

如果第一個操作數(shù)是undefined，則返回undefined。

（1）對于布爾值，邏輯或是非常簡單的，只要有一個true，就返回true；

（2）對于不是布爾值的情況則：

如果第一個操作數(shù)是對象，則返第一個操作數(shù)

如果第一個操作數(shù)的求值結(jié)果為false，則返回第二個操作數(shù)

如果兩個操作數(shù)都是對象，則返回第一個操作數(shù)

如果兩個操作數(shù)是null，則返回null

如果兩個操作數(shù)是NaN，則返回NaN

如果兩個操作數(shù)是undefined，則返回undefined

如果一個操作數(shù)是一個對象，返回false;

如果一個操作數(shù)是一個空字符串，返回false;

如果一個操作數(shù)是一個非空字符串，返回false

如果一個操作數(shù)是一個數(shù)值0，返回true;

如果一個操作數(shù)是任意的非零字符，返回false;

如果一個操作數(shù)是null，返回true;

如果一個操作數(shù)是NaN，返回true;

如果一個操作數(shù)是undefined，返回true;

注：邏輯與，邏輯非都是從左向右判斷，誰的第一個邏輯判斷為true就顯示誰，只不過邏輯非必須兩個都為true，而且誰是第一個false就顯示誰。

JavaScript中的 “與”或“非” 用什么表示

你是要位運算還是邏輯運算。

按位與?

|???按位或?

^???異或???

邏輯與?

||??邏輯或

JavaScript 非構(gòu)造函數(shù)的繼承（深拷貝）

對象之間的"繼承"的五種方法。

比如，現(xiàn)在有一個"動物"對象的構(gòu)造函數(shù)。

function Animal(){

this.species = "動物";

}

還有一個"貓"對象的構(gòu)造函數(shù)。

function Cat(name,color){

this.name = name;

this.color = color;

}

怎樣才能使"貓"繼承"動物"呢？

一、 構(gòu)造函數(shù)綁定

第一種方法也是最簡單的方法，使用call或apply方法，將父對象的構(gòu)造函數(shù)綁定在子對象上，即在子對象構(gòu)造函數(shù)中加一行：

function Cat(name,color){

Animal.apply(this, arguments);

this.name = name;

this.color = color;

}

var cat1 = new Cat("大毛","黃色");

alert(cat1.species); // 動物

二、 prototype模式

第二種方法更常見，使用prototype屬性。

如果"貓"的prototype對象，指向一個Animal的實例，那么所有"貓"的實例，就能繼承Animal了。

Cat.prototype = new Animal();

Cat.prototype.constructor = Cat;

var cat1 = new Cat("大毛","黃色");

alert(cat1.species); // 動物

代碼的第一行，我們將Cat的prototype對象指向一個Animal的實例。

Cat.prototype = new Animal();

它相當(dāng)于完全刪除了prototype 對象原先的值，然后賦予一個新值。但是，第二行又是什么意思呢？

Cat.prototype.constructor = Cat;

原來，任何一個prototype對象都有一個constructor屬性，指向它的構(gòu)造函數(shù)。如果沒有"Cat.prototype = new Animal();"這一行，Cat.prototype.constructor是指向Cat的；加了這一行以后，Cat.prototype.constructor指向Animal。

alert(Cat.prototype.constructor == Animal); //true

更重要的是，每一個實例也有一個constructor屬性，默認(rèn)調(diào)用prototype對象的constructor屬性。

alert(cat1.constructor == Cat.prototype.constructor); // true

因此，在運行"Cat.prototype = new Animal();"這一行之后，cat1.constructor也指向Animal！

alert(cat1.constructor == Animal); // true

這顯然會導(dǎo)致繼承鏈的紊亂（cat1明明是用構(gòu)造函數(shù)Cat生成的），因此我們必須手動糾正，將Cat.prototype對象的constructor值改為Cat。這就是第二行的意思。

這是很重要的一點，編程時務(wù)必要遵守。下文都遵循這一點，即如果替換了prototype對象，

o.prototype = {};

那么，下一步必然是為新的prototype對象加上constructor屬性，并將這個屬性指回原來的構(gòu)造函數(shù)。

o.prototype.constructor = o;

三、 直接繼承prototype

第三種方法是對第二種方法的改進(jìn)。由于Animal對象中，不變的屬性都可以直接寫入Animal.prototype。所以，我們也可以讓Cat()跳過 Animal()，直接繼承Animal.prototype。

現(xiàn)在，我們先將Animal對象改寫：

function Animal(){ }

Animal.prototype.species = "動物";

然后，將Cat的prototype對象，然后指向Animal的prototype對象，這樣就完成了繼承。

Cat.prototype = Animal.prototype;

Cat.prototype.constructor = Cat;

var cat1 = new Cat("大毛","黃色");

alert(cat1.species); // 動物

與前一種方法相比，這樣做的優(yōu)點是效率比較高（不用執(zhí)行和建立Animal的實例了），比較省內(nèi)存。缺點是 Cat.prototype和Animal.prototype現(xiàn)在指向了同一個對象，那么任何對Cat.prototype的修改，都會反映到Animal.prototype。

所以，上面這一段代碼其實是有問題的。請看第二行

Cat.prototype.constructor = Cat;

這一句實際上把Animal.prototype對象的constructor屬性也改掉了！

alert(Animal.prototype.constructor); // Cat

四、 利用空對象作為中介

由于"直接繼承prototype"存在上述的缺點，所以就有第四種方法，利用一個空對象作為中介。

var F = function(){};

F.prototype = Animal.prototype;

Cat.prototype = new F();

Cat.prototype.constructor = Cat;

F是空對象，所以幾乎不占內(nèi)存。這時，修改Cat的prototype對象，就不會影響到Animal的prototype對象。

alert(Animal.prototype.constructor); // Animal

我們將上面的方法，封裝成一個函數(shù)，便于使用。

function extend(Child, Parent) {

var F = function(){};

F.prototype = Parent.prototype;

Child.prototype = new F();

Child.prototype.constructor = Child;

Child.uber = Parent.prototype;

}

使用的時候，方法如下

extend(Cat,Animal);

var cat1 = new Cat("大毛","黃色");

alert(cat1.species); // 動物

這個extend函數(shù)，就是YUI庫如何實現(xiàn)繼承的方法。

另外，說明一點，函數(shù)體最后一行

Child.uber = Parent.prototype;

意思是為子對象設(shè)一個uber屬性，這個屬性直接指向父對象的prototype屬性。（uber是一個德語詞，意思是"向上"、"上一層"。）這等于在子對象上打開一條通道，可以直接調(diào)用父對象的方法。這一行放在這里，只是為了實現(xiàn)繼承的完備性，純屬備用性質(zhì)。

五、 拷貝繼承

上面是采用prototype對象，實現(xiàn)繼承。我們也可以換一種思路，純粹采用"拷貝"方法實現(xiàn)繼承。簡單說，如果把父對象的所有屬性和方法，拷貝進(jìn)子對象，不也能夠?qū)崿F(xiàn)繼承嗎？這樣我們就有了第五種方法。

首先，還是把Animal的所有不變屬性，都放到它的prototype對象上。

function Animal(){}

Animal.prototype.species = "動物";

然后，再寫一個函數(shù)，實現(xiàn)屬性拷貝的目的。

function extend2(Child, Parent) {

var p = Parent.prototype;

var c = Child.prototype;

for (var i in p) {

c[i] = p[i];

}

c.uber = p;

}

這個函數(shù)的作用，就是將父對象的prototype對象中的屬性，一一拷貝給Child對象的prototype對象。

使用的時候，這樣寫：

extend2(Cat, Animal);

var cat1 = new Cat("大毛","黃色");

alert(cat1.species); // 動物

非構(gòu)造函數(shù)的繼承

一、什么是"非構(gòu)造函數(shù)"的繼承？

比如，現(xiàn)在有一個對象，叫做"中國人"。

var Chinese = {

nation:'中國'

};

還有一個對象，叫做"醫(yī)生"。

var Doctor ={

career:'醫(yī)生'

}

請問怎樣才能讓"醫(yī)生"去繼承"中國人"，也就是說，我怎樣才能生成一個"中國醫(yī)生"的對象？

這里要注意，這兩個對象都是普通對象，不是構(gòu)造函數(shù)，無法使用構(gòu)造函數(shù)方法實現(xiàn)"繼承"。

二、object()方法

json格式的發(fā)明人Douglas Crockford，提出了一個object()函數(shù)，可以做到這一點。

function object(o) {

function F() {}

F.prototype = o;

return new F();

}

這個object()函數(shù)，其實只做一件事，就是把子對象的prototype屬性，指向父對象，從而使得子對象與父對象連在一起。

使用的時候，第一步先在父對象的基礎(chǔ)上，生成子對象：

var Doctor = object(Chinese);

然后，再加上子對象本身的屬性：

Doctor.career = '醫(yī)生';

這時，子對象已經(jīng)繼承了父對象的屬性了。

alert(Doctor.nation); //中國

三、淺拷貝

除了使用"prototype鏈"以外，還有另一種思路：把父對象的屬性，全部拷貝給子對象，也能實現(xiàn)繼承。

下面這個函數(shù)，就是在做拷貝：

function extendCopy(p) {

var c = {};

for (var i in p) {

c[i] = p[i];

}

c.uber = p;

return c;

}

使用的時候，這樣寫：

var Doctor = extendCopy(Chinese);

Doctor.career = '醫(yī)生';

alert(Doctor.nation); // 中國

但是，這樣的拷貝有一個問題。那就是，如果父對象的屬性等于數(shù)組或另一個對象，那么實際上，子對象獲得的只是一個內(nèi)存地址，而不是真正拷貝，因此存在父對象被篡改的可能。

請看，現(xiàn)在給Chinese添加一個"出生地"屬性，它的值是一個數(shù)組。

Chinese.birthPlaces = ['北京','上海','香港'];

通過extendCopy()函數(shù)，Doctor繼承了Chinese。

var Doctor = extendCopy(Chinese);

然后，我們?yōu)镈octor的"出生地"添加一個城市：

Doctor.birthPlaces.push('廈門');

發(fā)生了什么事？Chinese的"出生地"也被改掉了！

alert(Doctor.birthPlaces); //北京, 上海, 香港, 廈門

alert(Chinese.birthPlaces); //北京, 上海, 香港, 廈門

所以，extendCopy()只是拷貝基本類型的數(shù)據(jù)，我們把這種拷貝叫做"淺拷貝"。這是早期jQuery實現(xiàn)繼承的方式。

四、深拷貝

所謂"深拷貝"，就是能夠?qū)崿F(xiàn)真正意義上的數(shù)組和對象的拷貝。它的實現(xiàn)并不難，只要遞歸調(diào)用"淺拷貝"就行了。

function deepCopy(p, c) {

var c = c || {};

for (var i in p) {

if (typeof p[i] === 'object') {

c[i] = (p[i].constructor === Array) ? [] : {};

deepCopy(p[i], c[i]);

} else {

c[i] = p[i];

}

}

return c;

}

使用的時候這樣寫：

var Doctor = deepCopy(Chinese);

現(xiàn)在，給父對象加一個屬性，值為數(shù)組。然后，在子對象上修改這個屬性：

Chinese.birthPlaces = ['北京','上海','香港'];

Doctor.birthPlaces.push('廈門');

這時，父對象就不會受到影響了。

alert(Doctor.birthPlaces); //北京, 上海, 香港, 廈門

alert(Chinese.birthPlaces); //北京, 上海, 香港

目前，jQuery庫使用的就是這種繼承方法。

網(wǎng)站標(biāo)題：javascript非,javascript非現(xiàn)場模型編寫用那本書
網(wǎng)站地址：http://chinadenli.net/article48/dsihoep.html

成都網(wǎng)站建設(shè)公司_創(chuàng)新互聯(lián)，為您提供App開發(fā)、虛擬主機(jī)、外貿(mào)建站、App設(shè)計、網(wǎng)站制作、網(wǎng)站內(nèi)鏈

廣告

聲明：本網(wǎng)站發(fā)布的內(nèi)容（圖片、視頻和文字）以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主，如果涉及侵權(quán)請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網(wǎng)站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載，或轉(zhuǎn)載時需注明來源： 創(chuàng)新互聯(lián)