js数组头部添加元素_js中如何给数组添加数据

关于JS的问题（设计二维数组）

var arr = [1,2,3];

直接给你代码，对你的代码微略的做了修改。你对照看，就知道你的错误了！

js数组头部添加元素_js中如何给数组添加数据

js数组头部添加元素_js中如何给数组添加数据

第二个参数(可选): 类似数组的map方法，对每个元素进行处理，将处理后的值放入返回的数组。

var myarr = [['小A','女',21,'大一'],['小B','男',23,'大三'],['小C','男',24,'大四'],['小D','女',21,'大一'],['小E','女',22,'大四'],['小F','男',21,'大一'],['小G','女',22,'大二'],['小H','女',20,'大三'],['小I','女',20,'大一'],['小J','男',20,'大三']];

//次遍历

var dayi=[];//声明一个数组，用于存放大一学生

for(var i=0;i

if(myarr[i][3]=="大一"){

//将大一学生加入到一个新的数组中

dayi.push(myarr[i]);

console.log(myarr[i]);

}}

end(可选):索引数值(不包括),接受负值，在该索引处前结束提取原数组元素，默认值为数组末尾(包括一个元素)。//找出都是女生的信息，遍历新的数组

for(var j=0;j

if(dayi[j][1]=='女')

document.write("姓名："+dayi[j][0]+" 年龄："+dayi[j][2]+"

");

}

firarray.push(myarr[i]); // 这样才是正确的数组添加元素的方法

JS怎么把for循环出来的东西放到一个数组里

console.log(arr.indexOf("xxx")); // -1; 查不到就返回-1；数组迭代(遍历)

var arr = [];

var arr2 = ["a","b","c"];

for(var i =0;i

arr.push(obj[i]);

arr.unshift(obj[i]);

};

console.log(arr);

1：obj是一个对象。或者是你要需要的目标的

2：push()方法是数组的栈底添11、 toLowerCase方法用于将一个字符串全部转为小写加 意思是往数组的底部添加

3：unshift()方法是数组的栈顶添加 意思是往数组的头部添加

4：如果对以上步骤还有哪里不理解的请追问

5：望采纳

js中怎么把值放入数组中

"王五";

不知道你什么意思？这是基本的：

(1)

使用方括号，创建数组的同时赋初值

myA=["张三",

"李四","王五"];

b=[10,20,30,40];

(2)

使用new

作符，创建数组的同时赋初值

myA=ne//判断：数组中有3的倍数w

Array("张三",

"李四","王五");

注意圆括号和方括号的区别，不能任意使用。

(3)

先创建长度为10的数组，内容后面再赋值

}console.log(str); // 刘备|张飞|关羽anArray

=new

Array(9);

anArray[0]=

"张三";

anArray[1]=

"李四";

anArray[2]=

a=

[];

a[1]

="kotomi";

两种都可以，第二种要提供一个下标，重是放到数组末尾

js 将数组导入某元素innerHTML中

querySelectorAll方法返回的是NodeList对象，需要转换为数组。

responseText=responseText.match(regExp);

return b-a;//实参：array[j+1]-array[j]；

responseText = responseText.substring(0, responseText.length - 1);

document.getElementById('result').innerHTML=responseText;

补充回答:

要得到0 1 2 3 4 5 6 7 8 9是吧?把","替换成空格就可以了

document.getElementById('result').innerHTML=responseText.replace(/,/g," ");

可以调用数组的join方法

document.getElementById('result').innerHTML=responseText.join('');

在JS中有关数组函数如何使用

str += separator+arr[i];

本篇文章小编给大家整理了非常全的JS数组函数以及相关的写法规则，希望能够对读者们起到帮助和参考。

12.清空子元素

脚本之家以前就给大家整理过关于JS数组相关的内容，这次我们给大家整理的是非常实用的JS数组作技巧和写法，学习下吧。

instanceof

检测一个对象是否是数组;(用来对付复杂数据类型;)

// 简单数据类型 typeof ;

A instanceof B // A是不是B造出来的;

例：

console.log(arr instanceof Array); //arr属不属于Array类型;Array.isArray( )

Array.isArray(参数); // 判断参数是不是数组,返回布尔值;

例：

var num = 123;

console.log(Array.isArray(arr)howmany：必需。要删除的项目数量。如果设置为 0，则不会删除项目。); //true

console.log(Array.isArray(num)); //falsetoString( )

数组.toString(); // 把数组变成字符串,去除了[],内容用逗号链接;

例：

var arr = ["","bbb","ccc"];

数组.valueOf(); //返回数组本身;

例：

var arr = ["","bbb","ccc"];

console.log(arr.valueOf()); //返回数组本身 ["","bbb","ccc"]数组.join(参数)

console.log(arr.join()); //和toString()一样用逗号链接

console.log(arr.join("|")); //用参数链接

console.log(arr.join("&")); //用参数链接

console.log(arr.join(" ")); //如果是空格，真的用空格链接

console.log(arr.join("")); //空字符是无缝连接数组元素的添加和删除

push( )和pop( )

1. 数组.push() //在数组的末尾添加元素;

2. 数组.pop() //不需要参数;在数组的末尾删除一项;

例：

var = arr.push("abc");//在数组的末尾添加一个元素;

console.log();//返回值是数组的长度;

= arr.pop();//不需要参数;在数组的末尾删除一项;

console.log();//被删除的那一项unshift( )和shift( )

1. 数组.unshift() //在数组的前面添加一个元素;

2. 数组.shift() //不需要参数;在数组的前面删除一项;

例：

= arr.unshift("abc");//在数组的前面添加一个元素;

console.log();//返回值是数组的长度;

= arr.shift();//不需要参数;在数组的前面删除一项;

console.log();//被删除的那一项数组元素排序

rrse( )

rrse() //翻转数组

例:

var arr1 = [1,2,3,4,5];

var = arr1.rrse(); // [5,4,3,2,1]sort( )

sort() // 数组中元素排序;(默认：从小到大)

// 默认：按照字符的Unicode编码排序;如果个相同那么就比较第二个...

例：

var arr = [4,5,1,3,2,7,6];

var =arr.sort();

console.log(); // [1, 2, 3, 4, 5, 6, 7]

console.log( === arr);// true 原数组被排序了(冒泡排序)

//默认还可以排列字母;

var arr2 = ["c","e","d","a","b"];

var bbb = arr2.sort();

console.log(bbb); // ["a", "b", "c", "d", "e"]

console.log(bbb===arr2); // true 原数组被排序了(冒泡排序)

sort() //数值大小排序方法,需要借助回调函数;

例：

var arr = [4,5,1,13,2,7,6];

//回调函数里面返回值如果是：参数1-参数2;升幂； 参数2-参数1;降幂；

arr.sort(function (a,b) {

return a-b; //升序

//return b-a; //降序

//return b.value-a.value; //按照元素value属性的大小排序;

console.log(arr); // [1, 2, 4, 5, 6, 7, 13]sort( )底层原理

var = bubbleSort([1,12,3], function (a,b) {

// return a-b;//实参：array[j]-array[j+1]；

console.log();

function bubbleSort(array,fn){

//外循环控制轮数，内循环控制次数，都是元素个数-1;

for(var i=0;i

for(var j=0;j

//满足条件交换位置;

// if(array[j]>array[j+1]){//大于升幂排序；否则降幂;

//a-b>0 和 a>b是一个意思;

//b-a>0 和 a

// if(array[j]-array[j+1]>0){//升幂排序

// if(array[j+1]-array[j]>0){//降幂排序

//把两个变量送到一个函数中;

if(fn(array[j],array[j+1])>0){

var temp = array[j];

array[j] = array[j+1];

array[j+1] = temp;

}}

}//返回数组

return array;

}数组元素的作

concat( )

数组1.concat(数组2); // 链接两个数组;

var arr1 = [1,2,3];

var arr3 = arr1.concat(arr2);

console.log(arr3) // [1, 2, 3, "a", "b", "c"]sl( )

数组.sl(开始索引值，结束索引值); //数组截取;

例 ：

var arr = [1, 2, 3, "a", "b", "c"];

console.log(arr.sl(3)); //从索引值为3截取到;["a", "b", "c"]

console.log(arr.sl(0,3)); //包左不包右;[1, 2, 3]

console.log(arr.sl(3,0)); //如果前面的比后面的大，那么就是[];[]

console.log(arr); //原数组不被修改;[1, 2, 3, "a", "b", "c"]spl( )

数组.spl(开始索引值，删除几个，替换内容1，替换内容2，...); // 替换和删除;

例:

arr.spl(5); //从索引值为3截取到;(删除)

console.log(arr); // [1, 2, 3, 4, 5]

arr.spl(1,2); //(删除指定个数)从索引为1的开始删除2个

console.log(arr); //[1, 4, 5]

//替换

var arr = [1,2,3,4,5,6,"a", "b", "c"];

console.log(arr.spl(3,3,"","bbb","ccc")); //(删除指定数并替换)

console.log(arr); // [1, 2, 3, "", "bbb", "ccc", "a", "b", "c"]

// 添加

arr.spl(3,0,"","bbb","ccc");//(删除指定个数)

//

console.log(arr);//截取或者替换之后的; [1, 2, 3, "", "bbb", "ccc", "", "bbb", "ccc", "a", "b", "c"]indexOf / lastIndexOf

数组.indexOf(元素); // 给元素，查索引(从前往后)

数组.lastIndexOf(元素); // 给元素，查索引(从后往前)

例：

var arr = ["a","b","c","d","c","b","b"];

console.log(arr.indexOf("b")); // 1 查到以后立刻返回

console.log(arr.lastIndexOf("b")); // 6 找到以后立刻返回

ry()

对数组中每一项运行回调函数，如果都返回true，ry返回true，

如果有一项返回false，则停止遍历 ry返回false；不写默认返回false

像保镖失误一次，游戏结束！！！

例：

1. var arr = [111,222,333,444,555];

arr.ry(function (a,b,c) {

console.log(a); //元素

console.log(b); //索引值

console.log(c); //数组本身;

console.log("-----"); //数组本身;

//数组中元素赋值：c[b] = 值; a=有时候无法赋值;

return true;

2. //ry返回一个bool值，全部是true才是true；有一个是false，结果就是false

var bool = arr.ry(function (element, index, array) {

//判断：我们定义所有元素都大于200;

//if(element > 100){

if(element > 200){

return true;

}else{

return false;

}})

alert(bool); //falsefilter()

// 对数组中每一项运行回调函数，该函数返回结果是true的项组成的新数组

// 新数组是有老数组中的元素组成的，return为ture的项;

例：

var arr = [111,222,333,444,555];

var newArr = arr.filter(function (element, index, array) {

//只要是奇数，就组成数组;(数组中辨别元素)

if(element%2 === 0){

return true;

}else{

return false;

}})

console.log(newArr); // [222, 444]forEach()

例：

var arr = [111,222,333,444,555];

var sum = 0;

var = arr.forEach(function (element,index,array) {

console.log(element); // 输出数组中的每一个元素

console.log(index); // 数组元素对应的索引值

console.log(array); // 数组本身 [111, 222, 333, 444, 555]

sum += element; //数组中元素求和;

console.log(sum); // 数组元素加起来的和

console.log();//undefined；没有返回值 所以返回undefinedmap()

// 对数组中每一项运行回调函数，返回该函数的结果组成的新数组

// return什么新数组中就有什么; 不return返回undefined; 对数组二次加工

例：

var arr = [111,222,333,444,555];

var newArr = arr.map(function (element, index, array) {

if(index == 2){

return element; // 这里return了 所以下面返回的值是333

}return element100; // 返回的元素值都乘上100后的值

})

console.log(newArr); // [11100, 22200, 333, 44400, 55500]some()

//对数组中每一项运行回调函数，如果该函数对某一项返回true，则some返回true; 像杀手，有一个成功，就胜利了！！！

例：

var arr = [111,222,333,444,555];

var bool = arr.some(function (ele,i,array) {

if(ele%3 == 0){

return true;

}return false;

})

alert(bool); //true ; 有一个成功就是true数组清空

1. arr.length = 0; // (不好，伪数组无法清空)

2. arr.spl(0); // 伪数组没有这个方法;

例： // arguments

fn(111,222,333);

function fn(){

arguments.length = 0; // 无法清空 返回 [1, 2, 3]

arguments.spl(0); // 会报错 arguments.spl is not a function

arguments = []; // 可以清空,返回空数组[]

console.log(arguments);

}数组案例

1.将一个字符串数组输出为|分割的形式，比如“刘备|张飞|关羽”。使用两种方式实现

var arr = ["刘备","张飞","关羽"];

var separator = "|";

//通过for循环累加

var str = arr[0];

for(var i=1;i

//join()可以把数组中的元素链接成字符串;

console.log(arr.join("|")); // 刘备|张飞|关羽2.将一个字符串数组的元素的顺序进行反转。["a", "b", "c", "d"] -> [ "d","c","b","a"]。使用两种种方式实现。提示：第i个和第length-i-1个进行交换

// 数组.rrse() 方法

var arr = ["a", "b", "c", "d"];

console.log(arr.rrse()); // ["d", "c", "b", "a"]

// 三种：1.正向遍历，反向添加; 2.反向遍历，正向添加; 3.元数组元素交换位置;

for(var i=0;i

var temp = arr[i];

arr[i] = arr[arr.length-1-i];

arr[arr.length-1-i] = temp;

}console.log(arr);3.工资的数组[1500, 1200, 2000, 2100, 1800],把工资超过2000的删除

var arr = [1500, 1200, 2000, 2100, 1800];

//利用filter()形成一个数组;return true;组成的数组;

var newArr = arr.filter(function (ele, i, array) {

//2000以上返回false;

if(ele<2000){

return true;

}else{

return false;

}});

console.log(newArr); // [1500, 1200, 1800]4.["c", "a", "z", "a", "x", "a"]找到数组中每一个a出现的位置

var arr = ["c", "a", "z", "a", "x", "a"];

//遍历数组(for/while/do...while) forEach();

//如果元素等于“a”，那么就输出索引值；

if("a" === e

JS Array(数组)所有作方法，改变数组方法、不改变数组方法

var arr = [1,2,3,4,5,6,"a", "b", "c"]

定义：返回由所有参数值组成的数组，如果没有参数，就返回一个空数组。

//改变原数组;返回值是被删除/替换的内容

目的：Array.of() 出现的目的是为了解决上述构造器因参数个数不同，导致的行为有异的问题。

rrse() 数组元素反向排序

参数：

个参数(必需):要转化为真正数组的对象。

第三个参数(可选): 用来绑定this。

ps：spl方法从数组中添加/删除项目，然后返回被删除的项目

参数:

index：必需。整数，规定添加/删除项目的位置，使用负数可从数组结尾处规置。

1, …, X： 可选。向数组添加的新项目。

返回值: 如果有元素被删除,返回包含被删除项目的新数组。

删除元素

删除并添加

不删除只添加

ps：方法接受两个参数，一个从哪里开始，一个是到哪里结束（但是不包括这个结束的元素本身）。如果是负数，就从倒数第几个。

参数可选: 规定排序顺序的比较 函数 。

默认情况下sort()方法没有传比较函数的话，默认按字母升序，如果不是元素不是字符串的话，会调用toString()方法将元素转化为字符串的Unicode(万国码)位点，然后再比较字符。

比较函数的两个参数

sort的比较函数有两个默认参数，要在函数中接收这两个参数，这两个参数是数组中两个要比较的元素，通常我们用 a 和 b 接收两个将要比较的元素：

sort排序常见用法

数组元素为数字的升序、降序:

数组多条件排序

自定义比较函数

定义: 在当前数组内部，将指置的成员到其他位置,并返回这个数组。

语法: array.copyWithin(target, start = 0, end = this.length)

参数:

三个参数都是数值，如果不是，会自动转为数值.

target（必需）：从该位置开始替换数据。如果为负值，表示倒数。

start（可选）：从该位置开始读取数据，默认为 0。如果为负值，表示倒数。

end（可选）：到该位置前停止读取数据，默认等于数组长度。使用负数可从数组结尾处规置。

浏览器兼容(MDN): chrome 45,Edge 12,Firefox32,Opera 32,Safari 9, IE 不支持

从上述例子:

个参数是开始被替换的元素位置

要替换数据的位置范围:从第二个参数是开始读取的元素，在第三个参数前面一个元素停止读取

数组的长度不会改变

读了几个元素就从开始被替换的地方替换几个元素

参数:

个元素(必须): 要填充数组的值

第二个元素(可选): 填充的开始位置,默认值为0

第三个元素(可选)：填充的结束位置，默认是为this.length

使用join方法或者下文说到的toString方法时，当数组中的元素也是数组或者是对象时会出现什么情况？

join()/toString()方法在数组元素是数组的时候，会将里面的数组也调用join()/toString(),如果是对象的话，对象会被转为[object Object]字符串。

如上述栗子：调用数组的toLocaleString方法，数组中的每个元素都会调用自身的toLocaleString方法，对象调用对象的toLocaleString,Date调用Date的toLocaleString。

该方法的效果和join方法一样，都是用于数组转字符串的，但是与join方法相比没有优势，也不能自定义字符串的分隔符，因此不使用。

ps：当数组和字符串作的时候，js 会调用这个方法将数组自动转换成字符串

ps：字符串也有一个sl() 方法是用来提取字符串的，不要弄混了。

参数:

begin(可选): 索引数值,接受负值，从该索引处开始提取原数组中的元素,默认值为0。

如上：新数组是浅拷贝的，元素是简单数据类型，改变之后不会互相干扰。

如果是复杂数据类型(对象,数组)的话，改变其中一个，另外一个也会改变

原因在定义上面说过了的：sl()是浅拷贝，对于复杂的数据类型浅拷贝，拷贝的只是指向原数组的指针，所以无论改变原数组，还是浅拷贝的数组，都是改变原数组的数据。

ES6扩展运算符...合并数组：

因为ES6的语法更简洁易懂，所以现在合并数组我大部分采用...来处理，...运算符可以实现cancat的每个栗子，且更简洁和具有高度自定义数组元素位置的效果。

参数:

searchElement(必须):被查找的元素

fromIndex(可选):开始查找的位置(不能大于等于数组的长度，返回-1)，接受负值，默认值为0。

严格相等的搜索:

数组的indexOf搜索跟字符串的indexOf不一样,数组的indexOf使用严格相等===搜索元素，即数组元素要完全匹配才能搜索成功。

注意：indexOf()不能识别NaN

参数:

fromIndex(可选): 逆向查找开始位置，默认值数组的长度-1，即查找整个数组。

关于fromIndex有三个规则:

正值。如果该值大于或等于数组的长度，则整个数组会被查找。

负值。将其视为从数组末尾向前的偏移。(比如-2，从数组第二个元素开始往前查找)

负值。其大于数组长度，则方法返回 -1，即数组不会被查找。

参数：

searchElement(必须):被查找的元素

fromIndex(可选):默认值为0，参数表示搜索的起始位置，接受负值。正值超过数组长度，数组不会被搜索，返回false。负值超过长数组度，重置从0开始搜索。

includes方法是为了弥补indexOf方法的缺陷而出现的:

indexOf方法不能识别NaN

indexOf方法检查是否包含某个值不够语义化，需要判断是否不等于-1，表达不够直观

数组、字符串常用方法

a.push("nagisa");

将任意类型的值转换成字符串：

6、substr方法返回一个从指置开始的指定长度的子字符串。

7、indexOf方法返回String对象内次出现子字符串位置。如果没有找到子字符串，则返回-1。

lastindexOf()方法从尾部开始寻找对象中次出现子字符串的位置

8、search方法返回与正则表达式查找内容匹配的个字符串的位置。

9、concat方法返回字符串值，该值包含了两个或多个提供的字符串的连接。

10、Split将一个字符串分割为子字符串，然后将结果作为字符串数组返回。

toUpperCase则是全部转为大写。

它们都返回一个新字符串，不改变原字符串。

12、trim(): 用于去除字符串两端的空白，返1、push（） 可以接收任意数量的参数，把他们逐个添加到数组末尾，并返回修改后数组的长度回一个新字符串 不改变原数据

13、replace 返回被替换的字符串

1、构造数组 var arr = new Array（）；

向数组中添加元素：数组[索引] = 值；

读取数组 数组[索引] 当索引值比数组长度大时，会返回undefined；

数组长度：数组.length;

2、字面量创建数组 var arr = []；

中括号里边可以直接添加元素（可以是任意类型的数据类型）；

2、Pop（） 数组末尾移除一项，减少数组的LENGTH值，并返回被删除的元素

3、Unshift（） 在数组的头部添加一个或者多个元素，返回增加后数组的长度

4、Shift（） 从数组的头部删除一个元素并返回这个删除的元素，如果数组为空则返回undefined；

5、Sl（）返回从原数组中指定开始下标到结束下标用Json来存数据，如果遇到需要循环需要用 for(元素变量 in 变量名){}；因为Json没有length所以要用for in循环，for in循环可以用于Json和数组之间的项组成的新数组。

6、spl:

7、join()

8、rrse():

用来反转数组，前面的去后面，后面的去前面；

9、Sort（） 对数组成员进行排序，默认按照字典顺序排序，原数组会改变

sort的参数函数本身接受两个参数，表示进行比较的两个数组成员。如果该函数的返回值大于0，表示个成员排在第二个成员后面；其他情况下，都是个元素排在第二个元素前面

10、concat() ：将参数添加到原数组中。

11、indexOf()：接收两个参数：要查找的项和（可选的）表示查找起点位置的索引。其中， 从数组的开头（位置 0）开始向后查找。

12、lastIndexOf：接收两个参数：要查找的项和（可选的）表示查找起点位置的索引。其中， 从数组的末尾开始向前查找。

这两个方法都返回要查找的项在数组中的位置，或者在没找到的情况下返回-1。在比较个参数与数组中的每一项时，会使用全等作符。

13、forEach()：对数组进行遍历循环，对数组中的每一项运行给定函数。这个方法没有返回值。参数都是function类型，默认有传参，参数分别为：遍历的数组内容；对应的数组索引，数组本身。

14、map()：指“映射”，对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组。

15、filter(): 用于过滤数组成员，满足条件的成员组成一个 新数组返回 原数组不变

它的参数是一个函数，所有数组成员一次执行，返回结果为 true 的元素组成一个新数组返回

个参数：当前成员

第二个参数：当前成员的索引

第三个参数：整个数组

15、ry()：判断数组中每一项都是否满足条件，只有所有项都满足条件，才会返回true。

16、some():判断数组中是否存在满足条件的项，只要有一项满足条件，就会返回true。

17、reduce(): 将内部的返回值作为实参传递个形参，进行下一次运算

jascript数组定义的几种方法（图文教程）

{}表示语法模拟，表示模拟Object类的实例（=new Object()）

这篇文章主要介绍了jascript数组定义的几种方法，一般来说分为隐式创建、直接实例化、创建数组并指定长度、后来为了方便直接使用json格式定义数组，需要的朋友可以参考一下

上面是我整理给大家的，希望今后会对大家有帮助。

1、什么是数组

数组就是一组数据的

其表现形式就是内存中的一段连续的内存地址

数组名称其实就是连续内存地址的首地址

2、关于js中的数组特点

数组定义时无需指定数据类型

数组定义时可以无需指定数组长度

数组可以存储任何数据类型的数据（比如说一个元素保存整型，一个元素保存字符串型，这个在JS中是可以的）

创建数组的语法：

var arr=new Array(值1,值2,值3); //直接实例化

var array=new Array(size); //创建数组并指定长度

JS中符号含义：

()表示函数执行

[]表示语法模拟，表示模拟Array类的实例（=new Array()）

//表示语法模拟（正则对结论：从后台传入到前台的是json字符串，不是真正的json对象，因此需要使用eval函数转换。象），表示模拟RegExp类的实例（=new RegExp()）

3、关于数组长度

数组对象.length

在js中，每一个数组对象都可以调用length属性，它表示数组对象下共有几个数组元素

示例：

4、for...in语句

在js中，数组不是数据类型，数组的数据类型其实就是对象

Js中的For.....in语句可以实现对一个对象的所有属性的遍历

也可以使用for...in语句实现对一个数组的所有元素的遍历

语法：

for( var i in array ){

}原理：数组中有几个元素，for..in语句就循环执行多少次

每次执行时，将当前数组元素的下标存放到变量i中

结果：

0:zhangsan

1:lisi

2:wangwu

3:xiaoqiang

格式:

arr['key'] = value;

在js中，文本下标的数组元素，不计入数组长度

以文本下标形式添加到数组，实际是以属性形式添加到数组对象中的

结果：

3zhangsan

lisi

遍历带有文本下标的数组：

结果：

0:1

1:2

2:3

first:zhangsan

second:lisi

6、数组

7.先定义再赋值

8.定义数组时同时赋值

varmyArray3 = new Array("P","H","P");

//你需要在数组内指定数值或者逻辑值，那么变量类型应该是数值变量或者布尔变量，而不是字符变量

9、json格式的定义

不懂的同学可以查看这篇文章：

Json定义用法和数组的区别

Json：是在jascript用来存数据的一种方法。

Json形式： var Json={a:1 , b:2 , c:3};

数组形式：var arr=[1,2,3];

Json个数组的区别：

1、Json的下标是字符串，如调用个数据时用：Json.a 。 数组的下标是数字如 arr[0]

2、Json没有length，数组有lengt

for(i in Json){

语句

};

什么时候用for循环，什么时候用for in循环？

数组：用for循环 for(i=0,i

Json：用for in循环 for(i in Json){};

10. 注意

· 数组只有数组长度一个属性

· 如果没有给数组赋值得到的是undefined，打印是”“

· 数组长度不够可以自动扩充，不存在越界的问题

相关文章：

js中存储键值对使用详解

NodeJS父进程与子进程资源共享步骤详解

JS匿名自执行函数概念与使用说明

编写JS代码:创建一个二维数组(1010),在数组中添加杨辉三角形的元素. 杨辉三角形的规则如下？

concat( ) ——————–多个数组合并，原数组不变

先上效果图：

代码如下：

function pTriangle(){

let output = [];

for(let i=0;i<10;i++){

learr.forEach(function (ele, index, array) {t a = [];

for(let j=0;j<10;j++){

if(j===0||j===i){

a[j] = 1;

}else if(j>i){

//上三角元素为0

a[j]=0;

}else{

a[j] = output[i-1][j-1]+output[i-1][j]

}}

output[i]=a;

}console.(output)

}pTriangle();

var arr = [1,2,3];如果帮助到你的话，请点个采纳+赞哦，感谢。