㈠ 【js】Array.of() 創建數組
Array.of() 的作用是 創建數組 。
創建數組本來已經有 字面量 和 Array構造函數 等方法，但由於 Array構造函數 創建數組時有一些怪異的行為，所以 ES6 添加了 Array.of() 來彌補 Array構造函數 的不足。
以上是 Array構造函數 的用法，也是 Array構造函數 的怪異行為。
new Array() 當只傳入一個參數時，不能傳入負數，也不能傳入浮點數。
在使用 new Array 時，一不小心就會創建出稀疏數組。這個動作會產生一些詭異的「空槽」行為，這也是JS數組廣為人所詬病的一點。
Array.of() 取代了 Array() 成為數組的推薦函數形式構造器，因為 Array.of() 並沒有這個特殊的單一數值型參數值的問題。
Array.of() 總是返回參數值組成的數組。如果沒有參數就返回一個空數組。
所以說，Array.of() 的行為比 Array() 更統一。
如果有一個回調函數需要傳入的參數封裝為數組，而且不能保證傳入的值一定不是0或正整數，Array.of()可以完美解決這個問題。
如果需要構建 Array 的子類，並且想要在子類實例中創建和初始化元素。
這里用了rece方法，這個方法是Array的，這里用 this.rece 是因為 Calculator 繼承了 Array。
Array.rece的使用方法可以看下面的鏈接
【JS】遍歷數組的常用方法（舉例版）
㈡ JS創建數組及數組元素
1、字面量的方式創建數組 ：
let arr = ['張三','李四','王五'];
let num = [11,22,33,44]；
console.log(arr);
數組的下標從0開始
2、構造函數的方式創建數組
new Array(size);
表示數組中可存放的元素總數
規定了總數 但是添加一個數 總數也會增
new Array()實例化一個數組對象
let arr = new Array(3)
arr = [1,2,3,4]
聲明時賦值 ：
let arr = new Array(1,2,3,4,5,6)
分別賦值 ：
let arr = new Array(3);
arr[0] = 'zhangsan';
arr[1] = 'lisi';
arr[2] = 'wangwu' ；
3、通過數組的名稱和下標直接訪問數組的元素
console.log(arr[1]);
for(var i in arr){
console.log(arr[i]); }
4、屬性 length 設置或返回數組中元素的數目
let arr = [1,2,3,4,5]
console.log(arr.length);
5、 join( ) 把數組的所有元素放入一個字元串，通過一個分隔符進行分隔
把數組轉成字元串
let newstr = arr.join();
join()裡面沒有傳任何參數 默認以逗號連接
join('') 數字中間沒有任何字元拼接
let newstr = arr.join('+');
console.log( typeof(newstr) );
console.log(newstr);
6、 sort() 對數組排序
隱式數據類型轉換 會字元串類型的轉成數字類型進行排序
let arr = ['2', '3', '1', '5', '0'];
let newarr = arr.sort();
sort方法 會把老數組和新產生的數組都進行排序
console.log(arr, newarr);
sort()對應多位數排序會出現問題
let arr = [2,22,3,32,1,12,100];
sort 給我們提供的解決方法
arr.sort(function(a,b){
從小到大的順序
return a-b;
從大到小的順序
return b-a; })
console.log(arr);
7、 push() 向數組末尾添加一個或更多元素，並返回新的長度
在外面定義的叫全局變數
let stu = ['小張','小王','小李'];
console.log(stu);
方法裡面的叫局部區域
function fn(){
因為stu 是全局的 所以在方法裡面 可以獲取到
數組可以添加重復的數據
push也可以添加多個數據
let a = stu.push('麗麗','倩倩','雯雯')
console.log(a);
console.log(stu);}
定義一個空數組 點擊添加按鈕 可以在空數組裡面添加
姓名 點擊一個添加 可以把數組使用 dw 顯示在頁面上
let arr = []
function fn(){
arr.push('xiaoa')
document.write有個缺陷，用按鈕點擊的時候
會把整個頁面進行重新繪制，導致頁面原來的內容丟失
document.write(arr)} }
8、 concat() 合並兩個數組
對原來的兩個數組 沒有任何改變，會生成一個拼接好的新數組
let arr1 = [1,2,3];
let arr2 = [4,5,6];
let arr3 = [7,8,9]
拼接多個數組
let newarr = arr1.concat(arr2).concat(arr3);
console.log('arr1',arr1);
console.log('arr2',arr2);
console.log('newarr',newarr);
es6合並數組 要是用擴展運算符 ...
等同於 [1,2,3] 把arr1的括弧去掉，
把裡面的內容拿出來了
let newarr = [...arr1];
let newarr = [...arr1,...arr2,...arr3];
console.log(newarr);
eg1：定義 三個數組 分別是 三組學生的信息 第一組 姓名 年紀 性別
把三個數組 拼接起來 使用兩種方式
數組中的splice方法 可以對數組進行增刪改
splice()裡面有三個參數，
第一個參數表示 你要操作的數組元素的索引
第二個參數表示 你要從你選擇的索引開始要刪除的個數
第三個參數表示 你要添加的數組元素
let arr = ['張三','李四','王五'];
刪除李四
arr.splice(1,1)
把王五修改成麗麗
arr.splice(2,1,'麗麗')
添加 你想在哪裡添加就在哪裡添加
把倩倩放在數組索引為2的位置 因為第二個參數是0 所以王五不會被刪除
arr.splice(2,0,'倩倩')
使用splice在數組的末尾添加
arr.splice(3,0,'倩倩')
在任意數組末尾的位置進行添加
arr.splice(arr.length,0,'倩倩')
console.log(arr);
eg2：寫一個數組 裡面有姓名 年紀 性別 展示在頁面上
再寫三個按鈕 點擊 可以實現
數組的末尾添加一個信息 刪除年紀 修改性別 點擊完成之後
數組的最終結果使用alert列印出來
let arr = ['張三',20,'男'];
document.write(arr);
function fn(str){
if(str=='add'){
arr.splice(arr.length,0,'賓士')
alert(arr) }
if(str=='del'){
arr.splice(1,1)
alert(arr) }
if(str=='update'){
arr.splice(1,1,'女')
alert(arr） } }
let arr = ['張三','李四','王五']
push在數組的末尾添加一個元素
pop 刪除數組的最後一個元素
arr.pop();
console.log(arr);
shift 刪除數組的最前面的一個元素
arr.shift();
console.log(arr);
unshift 在數組的最前面添加一個數組
arr.unshift('麗麗')
console.log(arr);
㈢ js如何創建一個數組並給數組設置指定寬度
使用Array方式創建數組.
如：var arr = new Array(5);//創建了一個寬度是5的數組。
㈣ js怎麼快速創建這樣一個數組
創建數組的語法：
var
arr=[值1,值2,值3];
//隱式創建
var
arr=new
Array(值1,值2,值3);
//直接實例化
var
array=new
Array(size);
//創建數組並指定長度
JS中符號含義：
()表示函數執行
[]表示語法模擬，表示模擬Array類的實例（=new
Array()）
{}表示語法模擬，表示模擬Object類的實例（=new
Object()）
㈤ javaScript不使用for循環，還有其他方法快速新建一個指定長度的數組，並且每個元素的值就是
1、定義數組
var arr1 = [];//通過[]方式定義一個數組
var arr2 = new Array(2);//通過Array對象定義一個數組
2、for循環賦值
for(var i=0;i<arr2.length;i++){//循環數組
arr2[i] = i;//為arr2賦每個數組元素賦值
arr1[i]=i;//往arr1中賦數組初始值
}
㈥ 哪一個是javascript中創建數組的正確寫法（）
選項呢？ 創建數組的方法： 一、 new Array（1, 2） 二、 var array = [1, 2]
㈦ javascript怎麼創建對象數組
var objmoList1=new Array();//數組var objmo=new Object();//對象objmo.s="11";//對象裡面的回屬性答objmo.t="22";objmoList1.push(objmo);alert(objmoList1[0].s);
㈧ js 如何動態添加數組
1、數組的創建
var arrayObj = new Array();//創建一個數組
var arrayObj = new Array([size]);//創建一個數組並指定長度，注意不是上限，是長度
var arrayObj = new Array([element0[, element1[, ...[, elementN]]]]);創建一個數組並賦值
要說明的是，雖然第二種方法創建數組指定了長度，但實際上所有情況下數組都是變長的，也就是說即使指定了長度為5，仍然可以將元素存儲在規定長度以外的，注意：這時長度會隨之改變。
2、數組的元素的訪問
var testGetArrValue=arrayObj[1]; //獲取數組的元素值
arrayObj[1]= "這是新值"; //給數組元素賦予新的值
3、數組元素的添加
arrayObj. push([item1 [item2 [. . . [itemN ]]]]);// 將一個或多個新元素添加到數組結尾，並返回數組新長度
arrayObj.unshift([item1 [item2 [. . . [itemN ]]]]);// 將一個或多個新元素添加到數組開始，數組中的元素自動後移，返回數組新長度
arrayObj.splice(insertPos,0,[item1[, item2[, . . . [,itemN]]]]);//將一個或多個新元素插入到數組的指定位置，插入位置的元素自動後移，返回""。
4、數組元素的刪除
arrayObj.pop(); //移除最後一個元素並返回該元素值
arrayObj.shift(); //移除最前一個元素並返回該元素值，數組中元素自動前移
arrayObj.splice(deletePos,deleteCount); //刪除從指定位置deletePos開始的指定數量deleteCount的元素，數組形式返回所移除的元素
5、數組的截取和合並
arrayObj.slice(start, [end]); //以數組的形式返回數組的一部分，注意不包括 end 對應的元素，如果省略 end 將復制 start 之後的所有元素
arrayObj.concat([item1[, item2[, . . . [,itemN]]]]); //將多個數組（也可以是字元串，或者是數組和字元串的混合）連接為一個數組，返回連接好的新的數組
整理：www.mls169.com
6、數組的拷貝
arrayObj.slice(0); //返回數組的拷貝數組，注意是一個新的數組，不是指向
arrayObj.concat(); //返回數組的拷貝數組，注意是一個新的數組，不是指向
7、數組元素的排序
arrayObj.reverse(); //反轉元素（最前的排到最後、最後的排到最前），返回數組地址
arrayObj.sort(); //對數組元素排序，返回數組地址
8、數組元素的字元串化
arrayObj.join(separator); //返回字元串，這個字元串將數組的每一個元素值連接在一起，中間用 separator 隔開。
toLocaleString 、toString 、valueOf：可以看作是join的特殊用法，不常用
㈨ js創建數組對象的過程有幾種特點是什麼
js編程中創建對象的幾種方式，如原始方法、工廠方法等創建對象。
1、原始方法
復制代碼代碼示例:
<script type="text/javascript">
var obj = new Object();
obj.name = "Koji"; //為對象添加屬性
obj.age = 21;
obj.showName = function(){ //為對象添加方法
alert(this.name);
}
obj.showAge = function(){
alert(this.age);
}
obj.showName(); //Koji
obj.showAge(); //21
</script>
上面的方式通過new關鍵字生成一個對象，然後根據JS是動態語言的特性添加屬性和方法，構造一個對象。其中的this是表示調用該方法的對象。
這種方式的問題是如果需要多次創建對象，則需要重復代碼多次，不利於代碼的復用。
2、工廠方法 ：
復制代碼代碼示例:
<script type="text/javascript">
function createObj(){
var obj = new Object(); //創建對象
obj.name = "Koji";
obj.age = 21;
obj.showName = function(){
alert(this.name);
}
obj.showAge = function(){
alert(this.age);
}
return obj; //返回對象
}
var obj1 = createObj();
var obj2 = createObj();
obj1.showName(); //Koji
obj2.showAge(); //21
</script>
這種方式提高了代碼重用率，還可以改變工廠方法，傳入參數賦值。
復制代碼代碼示例:
<script type="text/javascript">
function createObj(name, age){ //構造對象時可以傳入初始化參數
var obj = new Object(); //創建對象
obj.name = name;
obj.age = age;
obj.showName = function(){
alert(this.name);
}
obj.showAge = function(){
alert(this.age);
}
return obj; //返回對象
}
var obj1 = createObj("Koji", 22);
var obj2 = createObj("Luo", 21);
obj1.showName(); //Koji
obj1.showAge(); //22
obj2.showName(); //Luo
obj2.showAge(); //21
</script>
上面的方式雖然可以提高代碼的復用率，但和面向對象中類的概念相比有一個很大的缺陷。面向對象強調對象的屬性私有，而對象的方法是共享的。而上面的工廠方法創建對象的時候要為每個對象創建各自私有的方法。同時由於為每個對象都創建邏輯相同的方法，浪費內存。
改進如下：
復制代碼代碼示例:
<script type="text/javascript">
function createObj(name, age){
var obj = new Object(); //創建對象
obj.name = name;
obj.age = age;
obj.showName = showName;
obj.showAge = showAge;
return obj; //返回對象
}
function showName(){ //函數也是一個對象
alert(this.name);
}
function showAge(){
alert(this.age);
}
var obj1 = createObj("Koji", 22);
var obj2 = createObj("Luo", 21);
obj1.showName(); //Koji
obj1.showAge(); //22
obj2.showName(); //Luo
obj2.showAge(); //21
</script>
上面通過定義連個函數對象，解決了不同對象持有函數對象的私有問題。現在所有對象的方法都持有上面兩個函數的引用。但這么一來的話，對象的函數又和對象成了相互獨立，不相乾的了。這和面向對象中特定方法屬於特定類的思想不符合。
3、構造函數方式
復制代碼代碼示例:
<script type="text/javascript">
//定義一個構造函數，用來生成對應的對象，可以類比Java中的構造函數
function Person(name, age){
//當調用new Person的時候，在執行第一行代碼前，先生成一個Person對象，並將對象在內存中的
//索引賦值給this關鍵字，此時可以通過this關鍵字操作新生成的對象，如下面的添加屬性或方法
this.name = name; //this關鍵字不能少。為當前對象，即this關鍵字引用的對象的name屬性賦值
//，實際相當於為當前對象添加name屬性後,再為其name屬性賦值。
this.age = age;
this.showName = function(){ //為當前對象添加方法
alert(this.name);
}
this.showAge = function(){
alert(this.age);
}
//將當前對象返回給賦值符號左邊的變數（不必明確使用return）
}
var obj1 = new Person("Koji", 22); //生成一個Person對象
var obj2 = new Person("Luo", 21);
obj1.showName(); //Koji
obj1.showAge(); //22
obj2.showName(); //Luo
obj2.showAge(); //21
</script>
構造函數的方式和工廠方式一樣，會為每個對象創建獨享的函數對象。當然也可以將這些函數
對象定義在構造函數外面，這樣又有了對象和方法相互獨立的問題。
原型方法：
該方法利用的對象的prototype屬性
復制代碼代碼示例:
<script type="text/javascript">
function Person(){} //定義一個空構造函數，且不能傳遞參數
//將所有的屬性的方法都賦予prototype屬性
Person.prototype.name = "Koji"; //添加屬性
Person.prototype.age = 22;
Person.prototype.showName = function(){ //添加方法
alert(this.name);
}
Person.prototype.showAge = function(){
alert(this.age);
}
var obj1 = new Person(); //生成一個Person對象
var obj2 = new Person();
obj1.showName(); //Koji
obj1.showAge(); //22
obj2.showName(); //Koji
obj2.showAge(); //22
</script>
當生成Person對象的時候prototype的屬性都賦值給了新的對象。那麼屬性和方法是共享的。
該方法的問題首先是構造函數不能傳參，每個新生成的對象都有默認值。其次，方法共享沒有任何問題，但是屬性共享就有問題，當屬性是可改變狀態的對象的時候。
例子：
復制代碼代碼示例:
<script type="text/javascript">
function Person(){} //定義一個空構造函數，且不能傳遞參數
Person.prototype.age = 22;
Person.prototype.array = new Array("Koji", "Luo");
Person.prototype.showAge = function(){
alert(this.age);
}
Person.prototype.showArray = function(){
alert(this.array);
}
var obj1 = new Person(); //生成一個Person對象
var obj2 = new Person();
obj1.array.push("Kyo"); //向obj1的array屬性添加一個元素
obj1.showArray(); //Koji,Luo,Kyo
obj2.showArray(); //Koji,Luo,Kyo
</script>
以上代碼通過obj1向obj1的屬性array添加元素的時候，obj2的arra屬性的元素也跟著受到影響，原因就在於obj1和obj2對象的array屬性引用的是同一個Array對象，那麼改變這個Array 對象，另一引用該Array對象的屬性自然也會受到影響混合的構造函數/原型方式。
使用構造函數定義對象的屬性，使用原型（prototype）定義對象的方法，這樣就可以做到屬性私有，而方法共享。
例子：
復制代碼代碼示例:
<script type="text/javascript">
function Person(name, age) {
this.name = name;
this.age = age;
this.array = new Array("Koji", "Luo");
}
Person.prototype.showName = function() {
alert(this.name);
}
Person.prototype.showArray = function() {
alert(this.array);
}
var obj1 = new Person("Koji", 22); //生成一個Person對象
var obj2 = new Person("Luo", 21);
obj1.array.push("Kyo"); //向obj1的array屬性添加一個元素
obj1.showArray(); //Koji,Luo,Kyo
obj1.showName(); //Koji
obj2.showArray(); //Koji,Luo
obj2.showName(); //Luo
</script>
屬性私有後，改變各自的屬性不會影響別的對象。同時，方法也是由各個對象共享。在語義上，
這符合了面相對象編程的要求。
4、動態原型方法
復制代碼代碼示例:
<script type="text/javascript">
function Person(name, age) {
this.name = name;
this.age = age;
this.array = new Array("Koji", "Luo");
//如果Person對象中的_initialized為undefined，表明還沒有為Person的原型添加方法
if (typeof Person._initialized == "undefined")
{
Person.prototype.showName = function() {
alert(this.name);
}
Person.prototype.showArray = function() {
alert(this.array);
}
Person._initialized = true; //設置為true，不必再為prototype添加方法
}
}
var obj1 = new Person("Koji", 22); //生成一個Person對象
var obj2 = new Person("Luo", 21);
obj1.array.push("Kyo"); //向obj1的array屬性添加一個元素
obj1.showArray(); //Koji,Luo,Kyo
obj1.showName(); //Koji
obj2.showArray(); //Koji,Luo
obj2.showName(); //Luo
</script>
這種方法和構造函數/原型方式大同小異。只是將方法的添加放到了構造函數之中，同時在構造函數Person上添加了一個屬性用來保證if語句只能成功執行一次。
在實際應用中採用最廣泛的是構造函數/原型方法。動態原型方法也很流行，它在功能上和構造函數/原型方法是等價的，不要單獨使用構造函數或原型方法。
㈩ JS代碼，創建一個長度為20的數組，並輸出1到100任意的20個數（最好寫一下注釋）
var arr=Array(20)://創建20個空數組
arr=arr.fill(0).map(function(item){ return item+=Math.ceil(Math.random()*100);});//先用0填充，再專每項加一個屬1-100隨機數