数组知识整合

最新推荐文章于 2024-07-20 23:54:17 发布
最新推荐文章于 2024-07-20 23:54:17 发布
阅读量85 收藏
点赞数
分类专栏： js 文章标签： js javascript 数组 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhizhan888/article/details/122009966
版权

数组

  • 数据结构（数据的结构形态，数据表现时的形态方式）

    var a = 1;
var b = 2;
var c = 3;
var d = 4;

var obj = { a: 1, b: 2, c: 3, d: 4 };

  • 不关心 key，只关心值，并且希望值可以排序，希望可以统计到数据的数量

  • ⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇⬇

  • 数组，数据组合，一组数据

    var arr = [1, 2, 3, 4];

数组如何创建

  1. 字面量创建
    var arr = [1, 2, 3, 4];
var arr = [1, , 2, undefined, 3, 4];
  2. 实例化(函 shu)创建（按照实际案例的格式化创建出来）
    var arr = new Array();
var arr = new Array(10); //建立了一个长度为10空数组，里面有10个空元素
    • 使用 new Array 或者 Array 时，如果，参数只有一个并且是数值类型，这个数值就是数组创建的长度，并且放入对应个数的空元素，所以这个数值必须是正整数，如果是小数或者负数时，就会抛出错误
      （Invalid array length 长度错误）
      function fn() {
  // 抛出错误
  // throw new Error("错误");
  // throw new TypeError("数据类型错误")
  // throw new RangeError("Invalid array length");
  // console.error("错误")
}
fn();
console.log("aa");
var arr = new Array(-2);
  3. 构造函数创建
    var arr = Array();
  • 对象创建法（用的不多）
    var arr = new Object([1, 2, 3]);

数组的下标和长度

  • var arr=[1,2,3,4];

  • 数组里面的所有内容称为元素，简称元

  • 每个元素，对应的一个索引数，这个索引数叫做下标

  • 根据变量[下标]就可以获取到这个变量数组的下标所对应索引的元素

    console.log(arr[0]);

arr[0] = 1;
//1 元素
//arr 数组变量
//0 下标 索引值
//arr[0]  下标变量

  • 下标是从 0 开始，第一个元素对应的下标是 0

  • 因为这个 100 表示第 101 个元素，因此，数组先有 101 个元素，可是原数组只有 4 个元素，就会自动生,成 96 个元素，在里面，这些都是空元素

    var arr = [1, 2, 3, 4];
arr[100] = 20;
//输出结果是 ➡(101) [1, 2, 3, 4, 空属性 × 96, 20]

length (长度 数组的元素数量)

  • length 是最大下标+1 最大下标=length-1

    console.log(arr.length);

//在末尾添加一个元素1
arr[arr.length] = 1;

  • 如果设置的 length 的长度比原有的长度大，这就会将数组的元素数量增多，并且补充空元素在数组末尾

    var arr = [1, 2, 3, 4];
arr.length = 10;

  • 如果设置的 length 的长度比原有的长度小，这就将数组的元素进行删除，只保留给定的长度

    var arr = [1, 2, 3, 4];
arr.length = 2;

  • 如果设置 length 为 0 时，表示清空数组

        var arr=[1,2,3,4];
    arr.length=;

  • 如果设置 length–时，表示删除数组的最后一个元素

    var arr = [1, 2, 3, 4];
arr.length--;

push

  • 给数组的尾部添加多个元素，并且返回数组的新长度，改变原数组

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

//arr.push(6);
arr.push(6, 7, 8);
var len = arr.push(6, 7, 8);
console.log(arr, len);

var arr = Array(10);
arr.push(1);
console.log(arr);

var arr = [];
var i = 1;
while (arr.length <= 10) {
  arr.push(i);
  i++;
}
console.log(arr);

var arr = [];
var i = 1;
while (arr.push(i++) <= 10);
console.log(arr);

  • unshift 在数组的最前面添加一个或多个元素，并且返回数组的新长度，改变原数组，每往前面添加一个元素，会往数组最后添加一个空间，把原元素整体往后挪一位，当第一个空间没有值，再给这个空间添加新元素，效率太低，尽量少用

  • pop 删除数组尾部的一个元素，并且返回这个删除的元素，改变原数组

    var arr = [1, 2, 3, 4, 5, 6, 7];
for (var i = 0; i < arr.length; i++) {
  arr.pop();
}
console.log(arr);

//当长度是3时，i的值已经是4不再满足条件，停止循环
//所以有两种方法解决：

var len = arr.length;
for (var i = 0; i < len; i++) {
  arr.pop();
}
console.log(arr);

while (arr.length > 0) arr.pop();
console.log(arr);

shift

  • 删除数组头部的一个元素，并且返回这个删除的元素，改变原数组 arr.shift()

concat

  • 将多个数组及元素，合并为一个新数组，原数组不发生改变

    //连接一个数组
var arr2 = arr.concat(arr1);
//连接多个数组
var arr2 = arr.concat(arr1, [9, 10, 11]);
//连接多个数组及元素
var arr2 = arr.concat(arr1, 9, 10, [11, 12], 13);
//复制一个新数组，浅复制
var arr2 = arr.concat();

toString

  • 将数组转换为字符串，使用,连接每个元素

  • 数组隐式转换为字符串时，会自动调用 toString

    // var obj={};
// obj[arr]=1;
// console.log(obj)

// var obj={};
// var arr=["a"];
// 因为转换为字符串变成"a"
// obj[arr]=3;
// console.log(obj.a);

var arr = [];
// 因为是空数组，转换为字符串时会变成""
console.log(arr.toString());
console.log([] == ""); //true
console.log([] == false); //true
console.log([] == 0); //true
console.log([] == [].length); //true
console.log([] == []); //false

//""==false
console.log([] == ![]); //![]  []是一个引用类型，直接转换为布尔值时就是true  ！true-->false

join

  • 将数组以给入的参数作为间隔符连接为一个字符串，如果间隔符是空字符串，则将每个元素紧密连接在一起，返回这个字符串，原数组不发生改变

    var arr = [1, 2, 3, 4];
//var str=arr.join("|");
var str = arr.join("");
console.log(str);

console.log(arr.join("+"));

var arr = ["FF", "00", "00"];
console.log("#" + arr.join(""));

slice

  • 将数组中第几位开始到第几位之前的所有元素截取返回一个新数组，原数组不变

  • slice（开始位置，结束位置）

    • arr.slice(); 开始位置没有赋值，结束位置也没有赋值，开始位置默认从 0 开始，结束位置默认到数组尾部，这样做可以复制数组
    • var arr1=arr.slice(2);结束位置也没有赋值,结束位置默认到数组尾部
    • 开始和结束位置都可以给负数，负数就是倒数第几位，也可以使用 arr.length+(负数)
var arr=["a","b","c","d","e"];
var arr1=arr.slice(1,4);
console.log(arr1)

var arr=["a","b","c","d","e"];
   var arr1=arr.slice();
   arr[0]="z";
   console.log(arr1,arr);

var arr=["a","b","c","d","e"];
var arr1=arr.slice(2);
console.log(arr1);

var arr=["a","b","c","d","e"];
   var arr1=arr.slice(-3);
console.log(arr1);
var arr1=arr.slice(-1);
console.log(arr1);

var item=arr.slice(-1)[0];
console.log(item)
//连缀 用前面方法返回得到结果用于后面的方法
var str=arr.slice(-3).join("");
console.log(str);

var arr1=arr.slice(2).concat("f")
console.log(arr1);

splice

  • 在数组中删除，替换，插入，新的多个元素，改变原数组，并且返回一个由删除元素组成的新数组

    • arr.splice(开始位置,删除几个,插入的元素…);

    • var arr1=arr.splice();如果没有开始位置，不会删除元素，返回一个空数组

    • var arr1=arr.splice(2); 如果只有开始位置，没有删除几个，就会删除到数组的尾部

    • var arr1=arr.splice(1,2);从下标为 1 的位置开始删除 2 个元素，返回被删除的这两个元素

    • var arr1=arr.splice(1,2,“z”); 从下标为 1 的位置开始删除 2 个元素,并且在这个位置插入一个字符 z，返回被删除的两个元素组成的新数组

    • var arr1=arr.splice(1,2,“y”,“z”);

    • var arr1=arr.splice(1,0,“y”,“z”); 如果删除的数量为 0 时，表示不删除，在这个位置插入 y，z 两个字符，并且返回一个空数组

遍历

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

console.log("for遍历");
for (var i = 0; i < arr.length; i++) {
  console.log(arr[i], i);
}
console.log("for in遍历");
for (var index in arr) {
  console.log(arr[index], index);
}
    1. for 会遍历到空元素，但是 for in 不会遍历到
    • for in 遍历时 主要是针对对象的，目的是遍历 key value 这种键值对，因此 for in 使用变量会自动转换为字符串，数组是由对象创建来的，所以可以理解为数组中的下标就相当于对象中 key，元素相当于对象中 value，for in 的前提必须是键值对，也就是说必须有键有值，数组中空元素，仅有下标没有值，不能称为键值对，因此，在 for in 中不做遍历
    1. for 循环时仅遍历数组的元素，但是 for in 循环时会遍历到数组元素之外的数组属性
    var arr = ["a", , "b", "c", undefined, "d", "e", "f"];
arr.a = 10;
for (var i = 0; i < arr.length; i++) {
  if (i in arr) console.log(arr[i]);
}
//在这里的话,if(i in arr)是判断元素在数组中成没成键值对,也就是过滤空元素(空元素只有键没有值)

forEach

  • 遍历数组的每个元素，并且执行 forEach 函数中回调函数 arr.forEach(回调函数) 回调函数中里面有 3 个参数，分别对应的是数组的元素，下标，数组本身

    arr.forEach(function (item) {});

map

  • 遍历数组的每个元素，并且执行 map 函数中回调函数，将这个回调函数中 return 的结果分别存储在一个新数组的当前下标对应位置，并且返回这个新数组,原数组不改变
    var arr1 = arr.map(function (item) {
  return value;
});

forEach 和 map 的区别

  • forEach 仅遍历数组的每个元素，map 不但遍历数组的每个元素，还会将回调函数 return 返回的结果放在一个新数组对应下标的位置，返回这个新数组，map 使用后，返回的新数组与数组的长度相等如果没有使用 return，则该项就是 undefined

indexOf

  • arr.indexOf(元素，从下标第几位开始向后查找)
  • 查找元素所对应的下标，如果找到了就返回找到第一个下标，如果没有找到返回-1

lastIndexOf

  • arr.lastIndexOf(元素，从下标第几位开始向后查找)
  • 从后向前查找元素所对应的下标，如果找到了就返回找到第一个下标，如果没有找到返回-1

includes

  • arr.includes(元素);
  • 判断当前数组中是否有这个元素，如果有返回 true，否则返回 false

some

  • 数组中是否有满足条件的,返回布尔值,如果遇到一个满足条件的就会直接跳出
var arr = [1, 2, 3, 4, 5, 6, 7];
var bool = arr.some(function (item, index, arr) {
  return item > 4; //判断每个元素是不是都大于4
});

every

  • 数组中是否所有元素都满足条件,返回布尔值,如果遇到一个不满足条件的就会直接跳出
var arr = [1, 2, 3, 4, 5, 6, 7];
var bool = arr.every(function (item, index, arr) {
  return item > 2; //判断所有元素是不是都大于2
});

filter

  • 筛选数组中满足条件的元素,返回满足条件元素组成的数组
var arr = [1, 2, 3, 4, 5, 6, 7];
var arr1 = arr.filter(function (item, index, arr) {
  return item > 3; //把所有大于3的元素都放在arr1中
});

var arr = [
  { id: 1001, name: "计算机1", price: 1200, num: 1 },
  { id: 1002, name: "计算机2", price: 3200, num: 1 },
  { id: 1003, name: "计算机3", price: 6800, num: 1 },
  { id: 1004, name: "计算机4", price: 7200, num: 1 },
  { id: 1005, name: "计算机5", price: 13000, num: 1 },
];

var arr1 = arr.filter(function (item) {
  return item.price > 5000;
});
console.log(arr1);

var arr1 = arr.filter(function (item) {
  return item.id === 1003;
});
var o = arr1[0];
console.log(o);

find

  • 在数组中找到满足条件的第一个元素，返回，并且不在继续向后循环
var o = arr.find(function (item) {
  return item.id === 1003;
});

reduce

  • 归并,返回一个元素
var arr = [12, 13, 14, 15, 16, 17];

//reduce return结果会传递给下一次遍历时的value，遍历完成后返回最终value值

var sum = arr.reduce(function (value, item, index, arr) {
  console.log(value, item, index, arr);
  return value + item;
});
console.log(sum);
  • 用 reduce 求和
var arr = [12, 13, 14, 15, 16, 17];
//求和
var sum = arr.reduce(function (v, t) {
  return v + t;
});
console.log(sum);
  • 用 reduce 从初始值是一百开始求和
  • 如果有 reduce 的初始值，value 开始就是这个初始值，并且 item 会从第 0 项开始遍历
// 如果有reduce的初始值，value开始就是这个初始值，并且item会从第0项开始遍历
var arr = [12, 13, 14, 15, 16, 17];
var sum = arr.reduce(function (value, item, index) {
  console.log(value, item, index);
  return value + item;
}, 100);
console.log(sum);
  • 数据驱动显示
// 数据驱动显示
var arr = [
  { site: "网易", url: "http://www.163.com" },
  { site: "腾讯", url: "http://www.qq.com" },
  { site: "淘宝", url: "http://www.taobao.com" },
  { site: "京东", url: "http://www.jd.com" },
  { site: "百度", url: "http://www.baidu.com" },
  { site: "小米", url: "http://www.mi.com" },
  { site: "华为", url: "http://www.huawei.com" },
];
var ul = document.getElementById("ul");
ul.innerHTML = arr.reduce(function (value, item) {
  return value + "<li><a href='" + item.url + "'>" + item.site + "</a></li>";
}, "");
//初始值是空字符串
  • 用 reduce 替代 map
// map输出新数组
var arr = [1, 2, 3, 4, 5];
var arr1 = arr.map(function (item) {
  return item + 10;
});
// 用reduce替代map
var arr1 = arr.reduce(function (value, item) {
  value.push(item + 10);
  return value;
}, []);
console.log(arr1);
  • 用 reduce 替代 some
var arr = [1, 2, 3, 4, 5];

var bool = arr.some(function (item) {
  return item > 3;
});

//  用reduce替代some

var bool = arr.reduce(function (v, t) {
  if (t > 3) v = true;
  return v;
}, false);
console.log(bool);
  • 用 reduce 替代 every
var bool = arr.every(function (item) {
  return item > 3;
});

//用reduce替代every

var bool = arr.reduce(function (v, t) {
  if (t <= 3) v = false;
  return v;
}, true);
  • 用 reduce 去重
//去重
var arr = [1, 2, 2, 3, 4, 4, 5, 6, 5, 6, 7, 8, 9];
var arr1 = arr.reduce(function (v, t) {
  if (v.indexOf(t) < 0) v.push(t);
  return v;
}, []);
console.log(arr1);

var arr = [
  { id: 1001, name: "计算机1", price: 1200, num: 1 },
  { id: 1002, name: "计算机2", price: 3200, num: 1 },
  { id: 1003, name: "计算机3", price: 6800, num: 1 },
  { id: 1004, name: "计算机4", price: 7200, num: 1 },
  { id: 1005, name: "计算机5", price: 13000, num: 1 },
];

//筛选price大于5000的数组,替代filter,返回的是数组
var arr1 = arr.reduce(function (v, t) {
  if (t.price > 5000) v.push(t);
  return v;
}, []);
console.log(arr1);

//筛选id 是 1003的对象,替代find,返回的是对象
var o = arr.reduce(function (v, t) {
  if (t.id === 1003) v = t;
  return v;
}, null);
console.log(o);

// var arr=[[1,2,3],[5,6,7],8,9];
// // 扁平化数组
// var arr1=arr.flatMap(function(item){
//     return item;
// });
// console.log(arr1);

var arr = [[1, 2, 3], [4, 5, 6], 7, 8, 9, [[11, 12], [13, 14], 15]];

// 扁平化数组
function flat(arr, target) {
  if (!target) {
    target = [];
  }
  for (var i = 0; i < arr.length; i++) {
    if (Array.isArray(arr[i])) {
      flat(arr[i], target);
    } else {
      target.push(arr[i]);
    }
  }
  return target;
}

var arr1 = flat(arr);
console.log(arr1);

fill

  • 填充数组
  • arr.fill(值,从什么位置开始填充,到什么下标之前结束)
// fill
var arr = Array(6);

var arr = [];
arr[3] = 2;
arr.length = 20;

arr.fill(10);
console.log(arr);

var arr = Array(10);
arr.fill(1, 5);
arr.fill(1, 2, 6);
console.log(arr);

Math.random()

  • 随机数 Math.random()
  • 随机颜色
// console.log(Math.random())//0-1

var div = document.getElementById("div1");
div.onclick = function () {
  div.style.backgroundColor = Array(6)
    .fill(1)
    .reduce(function (value, item) {
      return value + parseInt(Math.random() * 16).toString(16);
    }, "#");
};

reverse

  • 反转数组,改变原数组,并且返回这个原数组
// 数组反转
var len = parseInt(arr.length / 2);
for (var i = 0; i < len; i++) {
  var temp = arr[i];
  arr[i] = arr[arr.length - 1 - i];
  arr[arr.length - 1 - i] = temp;
}
console.log(arr);

Aarry 的静态方法(Array.isArray())

  • arr.puth() 实例化方法
  • **Array.isArray();静态方法;**判断给入的内容是不是数组
  • arr.constructor===Array;判断这个变量的构造函数是不是 Array
  • Array.from()将迭代器对象转换成数组(ES6)
    • iterable 迭代器
    • 常用的迭代器有:HTMLCollection arguments NodeList Set Map
var divs = document.getElementsByClassName("div1");
var arr = Array.from(divs);
console.log(arr.pop());
console.log(divs);

function fn() {
  console.log(Array.from(arguments));
  console.log(arguments);
}
fn(1, 2, 3, 4, 5, 6);
//可以将迭代器对象转换为数组(ES5)
var arr = Array.prototype.slice.call(divs);
var arr = Array.prototype.concat.apply([], divs);
console.log(arr);
  • 可以将迭代器对象转换为数组(ES5)
    • var arr=Array.prototype.slice.call(divs);
    • var arr=Array.prototype.concat.apply([],divs);
      console.log(arr)

sort 排序

  • arr.sort()
var arr = [1, 4, 5, 3, 2, 11, 15, 6, 7, 9, 1, 12, 3, 1, 22, 8, 9];
// arr.sort();
// console.log(arr);
arr.sort(function (a, b) {
  return a - b; //从小到大排序
  return b - a; //从大到小排序
});
console.log(arr);

var arr = [
  { id: 1001, name: "计算机1", price: 1200, num: 1 },
  { id: 1002, name: "计算机2", price: 3200, num: 1 },
  { id: 1003, name: "计算机3", price: 6800, num: 1 },
  { id: 1004, name: "计算机4", price: 7200, num: 1 },
  { id: 1005, name: "计算机5", price: 13000, num: 1 },
];
arr.sort(function (a, b) {
  return b.price - a.price;
});
console.log(arr);

var arr = [
  1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
];
arr.sort(function () {
  return Math.random() - 0.5;
});
算法
  • 冒泡算法
for (var j = 0; j < arr.length - 1; j++) {
  for (var i = 0; i < arr.length - j - 1; i++) {
    if (arr[i] > arr[i + 1]) {
      var temp = arr[i];
      arr[i] = arr[i + 1];
      arr[i + 1] = temp;
    }
  }
}
console.log(arr);
//找最大的往后放
  • 选择排序
// 选择排序

for (var i = 0; i < arr.length; i++) {
  var min = i;
  for (var j = i + 1; j < arr.length; j++) {
    if (arr[min] > arr[j]) {
      min = j;
    }
  }
  if (i !== min) {
    var temp = arr[i];
    arr[i] = arr[min];
    arr[min] = temp;
  }
}
console.log(arr);
//直到比较完才交换,找最小的往前放
  • 快速排序
function qSort (arr) {
	if (arr.length == 0) {
		return []
	}
	var left = []
	var right = []
	var pivot = arr[0]
	for (var i = 1; i < arr.length; i++) {
		if (arr[i] < pivot) {
			left.push(arr[i])
		} else {
			right.push(arr[i])
		}
	}
	return qSort(left).concat(pivot, qSort(right))
}

二维数组

// 二维数组

var arr = [
  [1, 2],
  [3, 4],
];

var arr = [];
for (var i = 0; i < 10; i++) {
  arr[i] = [];
  for (var j = 0; j < 10; j++) {
    arr[i][j] = i * 10 + j;
  }
}

console.log(arr[4][5]);

//arr[3][4]-->arr[3][5];

对象型数组

  • 不能用 typeof 查询
// 对象型数组
var arr = [
  { id: 1001, name: "计算机1", price: 1200, num: 1 },
  { id: 1002, name: "计算机2", price: 3200, num: 1 },
  { id: 1003, name: "计算机3", price: 6800, num: 1 },
  { id: 1004, name: "计算机4", price: 7200, num: 1 },
  { id: 1005, name: "计算机5", price: 13000, num: 1 },
];
前端小码~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JAVA数组扁平化整合_一文搞定数组扁平化（超全面的数组拉平方案及实现）
weixin_34086545的博客
02-26 794
前言面试手写代码在大厂面试中非常常见，秋招中面试小米就手写了一道flat实现的代码题，当时通过递归方式实现了数组扁平化逻辑，但没有考虑多种实现方案及其边界条件(主要是对所涉及到高阶函数的知识点不够熟练，也没有考虑空位处理)，现在从头梳理一下，并尽可能全面地总结数组扁平化的实现方案。数组扁平化数组扁平化即将一个嵌套多层的数组array(嵌套可以是任意层数)转换为只有一层的数组，如将数组[1,[2,[...
C++知识点——整合
01-27
引用是别名，声明时必须初始化。实际代码中多用作函数的形参，通过将引用变量用作参数，函数将使用...数组-------->只能使用指针结构-------->可以使用指针、引用类对象------>使用引用 指针是变量，可以重新
树状数组知识点整合
m0_63799444的博客
04-19 85
1，作用：对数组某一区间的和的快速修改和维护 实现 树状数组把前缀和需要维护从1到i的点进行优化 通过lowbit函数进行快速的前缀和遍历 int lowbit(int x){ return x&(-x);//i取反+1与i } 具体树状数组的实现： 给i加上一个数 for(int j=a1;j<=n;j+=lowbit(j)){ b[j]+=b1; } 求前缀和： for(int i=a1-1;i>0;i-=lowbit(i)){ sum1
超详解“数组”基础知识点很全面（Java）
weixin_52533616的博客
02-18 2865
数组（是一种数据类型） 一，数组定义？：它是基础的线性储存结构，也可以有效的实现一组变量的关联 1.“数组名称.length”属性，可以直接得到数组的长度 2.数组属于引用数据类型，在代码中需要进行内存的分配 3.动态初始化后会发现数组中的每一个元素的内容都是其对应数据类型的默认值 4.静态初始化：在数组定义时就为其设置了具体的数据内容 二、数组引用传递分析？： ...
JAVA数组扁平化整合_数组扁平化的几种处理放法
weixin_29473667的博客
02-26 360
清明节，这几天放假闲来无事，好好研究一下基础知识，今天看看数组扁平化该怎么处理：先来看数组扁平化是什么：var arr = [1,2,3,4,[5,6,[7,8]],true] =>[1,2,3,4,5,6,7,8,true]就是把二维或者多维数组，转成一维数组。1、我想大部分同学会和一样，首先想到的肯定是遍历数组，如果某一项是基本数据类型，直接push到新数组，如果某一项是数组，则直接将这...
Java基础知识点（数组）
StruggleBamboo的博客
12-18 238
Java基础知识点一、数组1.数组的赋值方式：2.数组的定义：3.数组中的排序方法有：4.Arrays类的常用方法：5.数组的查找方法（前提：数组已经处于升序）：二、二维数组：1.二维数组的定义：2.二维数组存数据的方法：3.取出数值： 一、数组 1.数组的赋值方式： 1.String[] arr=new String[]; //[]中括号中写数组的长度 2.String[] arr2=new String[]{“a1”,”a2”,”a3”}; 3.String[] arr3={“a1”,”a2”,”a3
知识联合——函数指针数组
2303_78442132的博客
09-18 257
函数、指针、数组
「枯燥的数组知识一网打尽！轻松学会JavaScript的数组操作」
weixin_55355282的博客
05-22 804
Array（数组）是编程中常见的数据结构之一。本文基于JavaScript介绍了一维数组、二维数组和多维数组的概念和用法，以及对象数组的应用和使用方法。此外，还介绍了JavaScript中常用的处理对象数组的方法。
spark知识点整合
bai10161206的博客
05-15 635
数组是Scala中常用的一种数据结构，数组是一种存储了相同类型元素的固定大小的顺序集合，# 第1种方式# 第2种方式var arr:Array[String] = Array(元素1,元素2,…)2.2数组的常用方法方法描述length返回数组的长度head查看数组的第一个元素tail查看数组中除了第一个元素外的其他元素isEmpty判断数组是否为空判断数组是否包含元素x函数是Scala的重要组成部分，Scala作为支持函数式编程的语言，可以将函数作为对象.
Android 网络知识点整合
qq_27494201的博客
03-30 124
1、HTTP和HTTPS协议是什么，有什么区别？ 2、HTTP组成部分 2、HTTP中的请求头和响应头 3、利用okHttp实现网络请求 4、什么是Https加密？ 6、Http接口调试工具 7、HTTP请求常见字段cookie、session、token鉴权 8、okHttp的详细使用 get、post请求 10、JSONObject put,accumulate,element的区别 11、怎么提交JSON数组数据给服务器 12、SSL是什么？ 13、DNS是什么？
内存数组做统计专题图
12-15
通过以上步骤，我们能够从内存数组中提取出有价值的见解，并通过统计专题图清晰地呈现出来，这对于数据分析、业务决策以及知识传播都具有极大的价值。实践中，应根据具体需求选择合适的数据结构、统计方法和可视化...
php及MySQL常用知识整合
06-19
"php核心知识纲要.html"可能包含了PHP的基础概念，如变量、数据类型、控制结构（如if-else、switch-case）、循环（for、while、do-while）、数组、函数等。此外，PHP还支持面向对象编程，包括类、对象、继承、封装和...
leetcode背诵+算法知识整合1
08-08
本篇文章将针对标题"leetcode背诵+算法知识整合1"和描述中的内容，深入探讨一系列与动态规划和树形结构相关的LeetCode题目，以及它们所涵盖的关键知识点。 首先，动态规划是一种解决复杂问题的有效方法，它通过将大...
Next.js静态导出与动态路由优化
最新发布
天涯学馆
07-20 806
Next.js 是一个流行的 React 框架，它简化了构建服务端渲染（SSR）和静态站点生成（SSG）的应用。静态导出是Next.js的一项强大特性，它允许你将整个应用程序导出为静态文件，从而在无服务器环境下运行，提高加载速度和降低服务器成本。动态路由则允许你根据数据生成页面，即使在静态导出的情况下也能保持灵活性。
TinyVue v3.17.0 正式发布，推出了一款基于 Quill 2.0 的富文本编辑器，功能强大、开箱即用！
OpenTiny的博客
07-17 1138
本文由体验技术团队Kagol老师原创~我们非常高兴地宣布，2024年6月26日，TinyVue 发布了 v3.17.0 🎉。TinyVue 每次大版本发布，都会给大家带来一些实用的新特性，上一个版本我们重构了 chart-core，新增 CircleProcessChart 圆环进度图等6个新的图表组件，并增加了 Statistic 数据统计组件。表格图片超链接复制粘贴插入表情文件上传@提醒斜杆菜单v-auto-tip。
谷粒商城实战笔记-39-前端基础-Vue-指令-v-on、v-for、v-if
epitomizelu的专栏
07-20 646
v-on 是 Vue.js 中的一个指令，用于在 DOM 元素上监听用户事件，并在事件触发时执行相应的 JavaScript 函数。它提供了一种将 Vue 实例中的方法与 DOM 事件关联起来的方式，使得你可以轻松地对用户交互做出响应。v-on 指令的基本语法是在元素上添加 v-on:event-name=“method”，其中 event-name 是你要监听的 DOM 事件类型（如 click、mouseover、keydown 等），method 则是 Vue 实例中定义的方法名。
vue执行npm install问题idealTree:yudao-ui-admin-vben: sill idealTree buildDeps
yuan5025的博客
07-17 1100
目前这个问题只在芋道源码yudao-ui-admin-vben碰到了，其他vue项目没用遇到过。
博客前端项目学习day03——框架页
qq_53237241的博客
07-19 435
【代码】博客前端项目学习day03——框架页。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

前端小码~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值