常用的js方法_js常用的方法有幾種

『壹』 javascript中常用的方法

JavaScript中常用的運算符及其使用方法
JavaScript中常用的運算符及其使用方法如下：
類型
-（負值），例如：-5。
*（乘法），例如：2*4，得8。
/（除法），例如：10/2，得5。
%（取余），例如：9%2，余數為1。
+（加法），例如：1+2，得3。
-（減法），例如：9-8，得1。
算術運算符
|（按位或運算），例如：5|3，得7。
<<（左移），例如：5<<3，得40。
>>（右移），例如：5>>1，得2。
~（取補），例如：~5
，得6。
++（遞加），例如：
a=5，a++，得a=6。
--（遞減），例如：
a=5，a--，得a=4。
字元運算符
＋（字元串連接），例如：「a」＋「b」，得ab。
==（等於），例如：1==2，為Flase。
!=（不等於），例如：3!=4，為True。
比較運算符
<（小於），例如：7<6，為Flase。
>（大於），例如：10>9，為True。
<=（小於等於），例如：6<=9，為True。
>=（大於等於），例如：3>=6，為Flase。
邏輯算符
!（邏輯非），例如：!Flase，為True。
&（邏輯與），例如：Flase&True，為Flase。
||（邏輯或），例如：Flase||True，為True。
^（邏輯異或），例如：Flase^True，為True。

『貳』 js函數的幾種寫法閉包概要

最常見的：Js代碼1functionfoo() {2alert('hi, js');3}4foo();用匿名函數：Js代碼1varfoo =function() {2alert('hi, js');3}4foo();改裝一下，給調用的foo()加個括弧：Js代碼1varfoo =function() {2alert('hi, js');3}4(foo)();乾脆，連foo的定義也省掉------把foo賦值語句的等號右邊的東東、直接替換掉剛才括起來的foo：Js代碼1(function() {2alert('hi, js');3})();先看常用的函數：1functionsayHello(name) {2vartext = 'Hello ' +name;3varsayAlert =function() { alert(text); }4sayAlert();5}6sayHello('Bob');閉包的例子一句話描述：閉包是函數的局部變數，在函數return之後，仍然有值，或者閉包是stack-frame，在函數return的時候，它不會被釋放。（就好像'stack-frame'是內存分配、而非處於堆棧！）下面的代碼返回一個function的引用：1functionsayHello2(name) {2vartext = 'Hello ' + name;//local variable3varsayAlert =function() { alert(text); }4returnsayAlert;5}6varsay2 = sayHello2('Jane');7say2();//hello Jane C函數指針和JavaScript的函數引用有著本質的不同。在JavaScript，函數引用變數既是一個函數指針，又是一個隱藏的閉包指針。在C和其他多數語言，當函數return之後，stack-frame就被銷毀了，所有的局部變數也就不能訪問了。在JavaScript中，如果你在函數里聲明了函數，在你調用的函數renturn之後，局部變數仍然可以訪問。請注意上面的例子，我們調用了變數text，它是函數sayHello2的局部變數。Example 3 這個例子表明局部變數不是拷貝傳遞，而是引用傳遞。在外層函數退出時，它把stack-frame保存在內存。1functionsay667() {2//Local variable that ends up within closure3varnum = 666;4varsayAlert =function() { alert(num); }5num++;6returnsayAlert;7}8varsayNumba =say667();9sayNumba();//667，而不是66610alert(sayNumba.toString());Example 4 三個函數對某個閉包使用同一個引用，因為它們均在setupSomeGlobals()里聲明的。1vargAlertNumber = gIncreaseNumber = gSetNumber =null;2functionsetupSomeGlobals() {3//Local variable that ends up within closure4varnum = 666;5//Store some references to functions as global variables6gAlertNumber =function() { alert(num); }7gIncreaseNumber =function() { num++; }8gSetNumber =function(x) { num =x; }9}10setupSomeGlobals();11//任意、多次運行下面的函數12gAlertNumber();13gIncreaseNumber();14gSetNumber(5);//把num重新設為 515gSetNumber(-8888);//把num重新設為 -8888 重新運行setupSomeGlobals(); 就會重新產生一個新的閉包。在JavaScript中，當你在函數里又聲明一個函數，外部函數每調用一次，內部函數將再被重新產生一次。Example 5 當心下面例子的循環：閉包中的局部變數可能和你最初想的不一樣。1functionbuildList(list) {2varresult =[];3for(vari = 0; i < list.length; i++) {4varitem = 'item' +list[i];5result.push(function() {alert(item + ' ' + list[i])} );6}7returnresult;8}910functiontestList() {11varfnlist = buildList([1,2,3 ]);12//using j only to help prevent confusion - could use i13for(varj = 0; j < fnlist.length; j++) {14fnlist[j]();15}16}1718testList();//輸出3次：'item3 undefined'Example 6 下面的例子表明，閉包包含了在外部函數退出之前、定義的任何局部變數。注意，變數alice實際上在匿名函數之後聲明的。匿名函數先被聲明：當函數被調用時，它可以訪問alice，因為alice在閉包里。1functionsayAlice() {2varsayAlert =function() { alert(alice); }3//Local variable that ends up within closure4varalice = 'Hello Alice';5returnsayAlert;6}7sayAlice()();//Hello Alice8alert(alice);//錯誤：alice不是全局變數，它在函數體內var了Example 7下面的例子表明，每次調用會產生各自的閉包。1functionnewClosure(someNum, someRef) {2//Local variables that end up within closure3varnum =someNum;4varanArray = [1,2,3];5varref =someRef;6returnfunction(x) {7num +=x;8anArray.push(num);9alert('num: ' + num +10'\nanArray ' + anArray.toString() +11'\nref.someVar ' + ref.someVar);12}13}14closure1 = newClosure(40, {someVar : 'closure 1'});15closure1(5);1617closure2 = newClosure(1000, {someVar : 'closure 2'});18closure2(-10);小結讀一些說明要比理解上面的例子難得多。我對於閉包的說明以及stack-frame等等在技術上可能不正確 --- 但是它們的確有助於理解

『叄』 javascript常用的技巧

1) 使用!!將變數轉換成布爾類型
有時，我們需要檢查一些變數是否存在，或者它是否具有有效值，從而將它們的值視為true。對於做這樣的檢查，你可以使用||（雙重否定運算符），它能自動將任何類型的數據轉換為布爾值，只有這些變數才會返回false：0，null，""，undefined或NaN，其他的都返回true。我們來看看這個簡單的例子：
function Account(cash) {
this.cash = cash;
this.hasMoney = !!cash;
}
var account = new Account(100.50);
console.log(account.cash); // 100.50
console.log(account.hasMoney); // true

var emptyAccount = new Account(0);
console.log(emptyAccount.cash); // 0
console.log(emptyAccount.hasMoney); // false

在這個例子中，如果account.cash的值大於零，則account.hasMoney的值就是true。
2) 使用+將變數轉換成數字
這個轉換超級簡單，但它只適用於數字字元串，不然就會返回NaN（不是數字）。看看這個例子：
function toNumber(strNumber) {
return +strNumber;
}
console.log(toNumber("1234")); // 1234
console.log(toNumber("ACB")); // NaN

這個轉換操作也可以作用於Date，在這種情況下，它將返回時間戳：
console.log(+new Date()) // 1461288164385

3) 短路條件
如果你看到過這種類似的代碼:
if (conected) {
login();
}

那麼你可以在這兩個變數之間使用&&（AND運算符）來縮短代碼。例如，前面的代碼可以縮減到一行：
conected && login();

你也可以用這種方法來檢查對象中是否存在某些屬性或函數。類似於以下代碼：
user && user.login();

4) 使用||設置默認值
在ES6中有默認參數這個功能。為了在舊版瀏覽器中模擬此功能，你可以使用||（OR運算符），並把默認值作為它的第二個參數。如果第一個參數返回false，那麼第二個參數將會被作為默認值返回。看下這個例子：
function User(name, age) {
this.name = name || "Oliver Queen";
this.age = age || 27;
}
var user1 = new User();
console.log(user1.name); // Oliver Queen
console.log(user1.age); // 27

var user2 = new User("Barry Allen", 25);
console.log(user2.name); // Barry Allen
console.log(user2.age); // 25

5) 在循環中緩存array.length
這個技巧非常簡單，並且在循環處理大數組時能夠避免對性能造成巨大的影響。基本上幾乎每個人都是這樣使用for來循環遍歷一個數組的：
for (var i = 0; i < array.length; i++) {
console.log(array[i]);
}

如果你使用較小的數組，那還好，但是如果處理大數組，則此代碼將在每個循環里重復計算數組的大小，這會產生一定的延遲。為了避免這種情況，你可以在變數中緩存array.length，以便在循環中每次都使用緩存來代替array.length：
var length = array.length;
for (var i = 0; i < length; i++) {
console.log(array[i]);
}

為了更簡潔，可以這么寫：
for (var i = 0, length = array.length; i < length; i++) {
console.log(array[i]);
}

6) 檢測對象中的屬性
當你需要檢查某些屬性是否存在，避免運行未定義的函數或屬性時，這個技巧非常有用。如果你打算編寫跨瀏覽器代碼，你也可能會用到這個技術。例如，我們假設你需要編寫與舊版Internet Explorer 6兼容的代碼，並且想要使用document.querySelector()來通過ID獲取某些元素。但是，在現代瀏覽器中，這個函數不存在。所以，要檢查這個函數是否存在，你可以使用in運算符。看下這個例子：
if ('querySelector' in document) {
document.querySelector("#id");
} else {
document.getElementById("id");
}

在這種情況下，如果在document中沒有querySelector函數，它就會使用document.getElementById()作為代替。

『肆』 js常用的方法有幾種

concat()連接兩個或更多的數組，並返回結果。
join()把數組的所有元素放入一個字元串。元素通過指定的分隔符進行分隔。
pop()刪除並返回數組的最後一個元素
push()向數組的末尾添加一個或更多元素，並返回新的長度。
reverse()顛倒數組中元素的順序。

『伍』介紹幾個js對數據常用的處理方式

獲取數據方式數據獲取是指從各種設備獲得有關各業務所需的流量、IP、次數、協議等網路傳送的原始數據，從而對用戶進行管理和計費。一般通過以下三種方式獲取數據。如果目前的IP寬頻網路的對用戶的接入採用的是以太區域網(LAN)的接入方式，則可

『陸』 js中操作數組的幾個常用方法

1. Array.shift()------刪除並返回第一個元素
作用：從數組中刪除第一個元素（即下標為0的元素），並返回該元素。
注意：1）刪除元素之後，數組的長度-1。2）如果數組是空的，那麼 shift() 方法將不進行任何操作，返回 undefined 值。

『柒』 js數組常用方法

1.push方法將單個元素或者另外的數組添加到條用該方法的數組末尾去
2.concat方法就是將兩個數組或者元素之間連接起來調用該方法的數組放在前面，方法實參放在後面
3.pop方法刪除數組中的最後一個元素且會將這個被刪除的元素返回
4.splice 方法刪除或插入指定位置的元素函數的原型為splice(index,howmany,element1,.....,elementX...
5.reverse 方法即將數組的順序反轉

『捌』 js數組遍歷的常用的幾種方法以及差異和性能優化

『玖』 js數組幾種常見的操作方法

關於js數組的用法有很多，下面主要針對一些簡單的操作，比如合並，反轉，添加刪除等簡單的操作總結一下。

第一：讀取數組 for循環

方法如下：

var ay=[1,"sdsd","sdsd"]
for (var i=0;i<ay.length;i++) {

console.log("index:"+i+" "+ay[i]) //index：0 1 index：1 sdsd index：2 sdsd

}

第二：合並數組 concat

方法如下：

var arr1=['w','e','s'];

var arr2=['e','y','u'];
var arr3=arr1.concat(arr2);
console.log(arr3) //['w','e','s''e','y','u'];
第三：數組變為字元串格式 join

方法如下：

var arr1=['w','e','s'];

var arr4=arr1.join()
console.log(arr4) //w,e,s

第四：刪除最後一個元素,針對老數組是刪除最後一個,針對新數組是返回最後一個 pop

var arr6=["d","s","t"];
var arr7=arr6.pop();
console.log(arr6) //["d","s"];
console.log(arr7);// t

第五：添加最後一個元素，針對老數組最後一個元素後面添加一個元素，新數組返回元素個數 push

var arr8=["i","u","t"];

var arr9=arr8.push("k");

console.log(arr8); //["i","u","t","k"];

console.log(arr9); // 4

第六：shift() 和pop()一樣，不同的是操作的是開頭刪除的元素shift（）；具體操作不在展示
第七：unshiift()和push一樣，不同的是操作的是開頭添加的元素unshift（）；具體操作不再展示

第八：反轉數組 reverse

方法如下：

var arr1=['w','e','s'];

var arr10=arr1.reverse()

console.log(arr10) //['s','e','w'];

第九：數組排序 sort a-b正向 b-a 反向

正向

var arr11=[3,1,5,8,28]
var arr12=arr11.sort(function (a,b) {
return a-b;
})
console.log(arr12) //[1,3,5,8,28];

反向

var arr13=arr11.sort(function (a,b) {
return b-a;
})
console.log(arr13) //[28,8,5,3,1]

第十：數組截取數組截取的方法主要有slice 和splice，另外說到截取我這里隨便也把字元串截取帶上，字元串截取的方法主要有substr 和substring

（1）slice 使用方法arr.slice(m,n);其中arr為數組，m，n為兩個參數，意思是從已有數組中返回選定的元素，截取位置均為下標，其中m必須，為起始位置，可以為負值，n為結束位置（截取位置並不包含）。

示例如下：

①只有起起始值，並且為正，默認的從起始位置一直到整個數組結束，起始下標從0開始

var arr=[2,3,5,6,8,9]
var arr1=arr.slice(1)
console.log(arr) //[2,3,5,6,8,9] 老數組是沒有變化的，下面不在列舉，都是一樣的
console.log(arr1) //[3,5,6,8,9] 只有起始參數，並且為正值，返回新數組從下標1開始截取

②只有起始值，並且為負，默認的是從起始位置一直到整個數組結束，此處沒有起始值，數組的最後一個下標是-1，比如此例，如果從-6開始取，必定是整個數組

var arr=[2,3,5,6,8,9]
var arr1=arr.slice(-1)
console.log(arr1) //[9] 只有起始參數，並且為負值，從數組尾部截取元素

③有起始值和結束值，並且為正，此處需注意下標是從小到大，比如你（3，1）肯定是取不到值的，另外截取的下標個數並不包含最後一個下標

var arr=[2,3,5,6,8,9]
var arr1=arr.slice(1,4)
console.log(arr1) //[3,5,6] 此時是從下標1開始到下標4，但是需要注意的是並不包含下標4，准確的說是1-3的下標

④有起始值和結束值，並且為負，此處需注意下秒也是從小到大，同理，比如（-1，-6）也是肯定取不到值的，另外截取的下標個數也並不包含最後一個下標

var arr=[2,3,5,6,8,9]
var arr1=arr.slice(-6,-1)
console.log(arr1) //[2,3,5,6,8]

⑤有起始值和結束值，並且正負都有

負值到0

var arr=[2,3,5,6,8,9]
var arr1=arr.slice(-1,0)

//剛剛都看到了，數組下標都是從小到大的，所以說如果正負都有的情況下，理論上應該可以取值的，比如這個例子，-1為9的小標，0為2的下標，所以取值應該為 [9]，但是結果並不是這樣的
console.log(arr1) //[ ] 從這里可以看出他的結果是為空的，所以從負值到0結果是取不到的

負值到正直

var arr=[2,3,5,6,8,9]

var arr1=arr.slice(-1,2)

//那從負值到正值呢，同樣也是取不到值的

console.log(arr1) //[ ]

正直到負值

var arr=[2,3,5,6,8,9]

var arr1=arr.slice(2,-1)

//那從正直到負值，這個理論上是取不到的，但是看下結果

console.log(arr1) //[ 5，6，8] 從結果可以看出是可以取的原理是2的下標為5，-1的下標為9，不包含結束位置下標

總結：這個方法看著可能會麻煩些（也可能被我寫的麻煩啦），比如正到負等，不知道大家都是怎麼操作，我一般用這個取值都是只截取正的，所以這個實際操作還是非常簡單的。

（2）splice 像數組中添加或者刪除元素
arr.splice(m,n,index,index1,...,indexx)
m是起始位置，n是刪除元素的個數，index是要添加的元素，在不添加元素的前提下，只有第一個參數是必須的，後面兩個都不是必須的，在需要添加元素的情況下，三個元素都是必須的，此方法和slice是不一樣的，這個返回的是被刪除的元素

示例如下：

只刪除不添加

注意看此例，是（1，2）刪除兩個，如果是（1，0），則表示刪除零個，也就是不刪除的意思，如果只有一個參數則表示從這里開始刪除，比如是（1）則為[2]，當然這個也是可以取負值，但是這個和slice是不一樣的，只能起始位置取負值，因為刪除的個數不可能為負值，slice可以取（2，-1），這個就截然不同啦，但是剛剛也說啦，slice是不可以起始位置取負值，結束位置取正的，但是這個是可以的，比如（-1，0）則表示從-1開始刪除零個，結果為[2,3,5,6,8,9]，（-6，2),結果為[5,6,8,9]，另外這個刪除的第二個值如果寫的過大，也只是刪除從本下標到最後一個，比如（2，78）為[2,3]

var arr=[2,3,5,6,8,9]
var arr1=arr.splice(1,2)
console.log(arr) // [2,6,8,9] 注意看此處才是我們要的數組，從下標1開始刪除刪除兩個
console.log(arr1) //[3,5] 此處是我們刪除掉的數組

刪除加添加具體的和上面的差不多，主要添加了添加元素的效果，這個也可以添加多個元素

var arr=[2,3,5,6,8,9]
var arr1=arr.splice(1,2,"il")
console.log(arr) //[2,"li",6,8,9]
console.log(arr1) //[3,5]

總結：此方法用的時候，一般也都是只取正值

（3）substr 這個是字元串的用法用法arr.substr(m,n) m必選也可以負值 n選填，注意看這個並不是結束為止而是截取的個數

示例如下：

只有一個參數默認從此下標開始，取後面所有的

正值

var arr="sdhgfhf"
var arr1=arr.substr(1)
console.log(arr)// "sdhgfhf"這個是不變的，下面不再列舉
console.log(arr1)//"dhgfhf" 從下標1開始取後面所有的

負值

var arr="sdhgfhf"
var arr1=arr.substr(-2)
console.log(arr1)//"hf" 從下標-2開始取後面所有的

兩個參數，從第一個下標開始，截取到下標2的長度

var arr="sdhgfhf"
var arr1=arr.substr(1，3)
console.log(arr1)//"dhg" 從下標1開始取後面所有的同理如果為負值，比如（-6，3）則為"hjf";後面的始終為長度

總結：此方法需注意不要和數組的混淆，這個是截取長度的

（4）substring 用法arr.substring(m,n) 兩個參數，m必須，起始位置，n選填，截取下標的結束位置，此用法和上面slice有點類似，但是需要注意的是此方法是不支持負值的

示例如下：

只有一個參數

var arr="sdhgfhf"
var arr1=arr.substring(1)
console.log(arr1)//"dhgfhf"從下標1開始取後面所有的

兩個參數

var arr="sdhgfhf"
var arr1=arr.substring(1,3)
console.log(arr1)// "dh"從下標1開始截取到下標3，但是不包含3

總結：此方法不支持負值，只針對下標來截取的

最後，以上主要是總結的數組的一些簡單的操作方法，學無止境，繼續努力。

導航:首頁 > 使用方法 > 常用的js方法

常用的js方法

與常用的js方法相關的資料