js数组对象

最新推荐文章于 2023-04-22 15:20:47 发布
最新推荐文章于 2023-04-22 15:20:47 发布
阅读量901 收藏
点赞数 1
文章标签： javascript vue.js linq html5 ecmascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64337756/article/details/121940442
版权

一 字符串对象

规则：字符串所有的属性或方法都不会改变原来的字符串

var str =
    "dklasdklsahdkl&&jdhkas***dkjaskldjakl!!!djkash1233djkahdk9789789789idui12ABCOOPP3456789dasu***dkasldjal%%djlasdjals97897";
// 对str进行处理，数字在前，字母在后，去掉特殊字符，并且数字和字母不能重复

// 保存数字字符串
var numStr = '';
// 保存字母字符串
var charStr = '';

// a-z  97 -- 122
// A-Z  65 -- 90
// 0-9  48 -- 57

for(var i = 0;i<str.length;i++){
    // 获取当前这个字符串
    var curStr = str[i];
    // 获取当前字符串的ASCII值
    var curCode = str.charCodeAt(i);
    // 判断范围
    // 判断是字母       charStr  这个字符串是否包含  curStr 不包含 返回 -1
    if(((curCode >= 65 && curCode <=90) || (curCode >= 97 && curCode <= 122)) && charStr.indexOf(curStr) == -1){
        // 字符串拼接
        charStr += curStr;
    }

    // 判断数字         numStr 这个字符串是否包含  curStr     不包含 返回 -1
    if(curCode >= 48 && curCode <= 57 && numStr.lastIndexOf(curStr)==-1){
        // 字符串拼接
        numStr += curStr;
    }
}

var resStr = numStr+charStr;
console.log(resStr);

字符串的截取方法：截取到了返回对应字符串，截取不到返回空字符串 ""

  • substring(startIndex,endIndex);

    • 参数

      • startIndex:开始索引

      • endIndex:结束索引 不包含结束索引

        • 规律

      • 从当前索引开始，截取到结束索引，不包含结束索引

      • 不传递参数 startIndex默认值是0 截取到末尾

      • 只传递startIndex,从当前索引开始截取到末尾

      • startIndex为负数:不支持负数索引，会自动变为默认值0 endIndex不能不负

      • 开始索引大于结束索引 内置会自动交换位置

  • substr(startIndex,length);

    • 参数

      • startIndex:开始索引

      • length:截取的个数，截取的长度

    • 规律

      • 从当前索引开始截取length个

      • 不传递参数 startIndex默认值是0 截取到末尾

      • 只传递startIndex,从当前索引开始截取到末尾

      • startIndex支持负数索引最后一项是-1从后往前数，截取规律是不变的从前往后截取 ，length不能为负;

    • slice(startIndex,endIndex);

      • 参数

        • startIndex:开始索引

        • endIndex:结束索引 不包含结束索引

      • 规律

        • 从当前索引开始，截取到结束索引，不包含结束索引

        • 不传递参数 startIndex默认值是0 截取到末尾

        • 只传递startIndex,从当前索引开始截取到末尾

        • startIndex和endIndex都支持负数索引 (最后一项是-1，截取都是从前往后截取),一般我们 startIndex 要小于 endIndex

字符串的方法

  • toUpperCase() / toLowerCase(); 转为大写 / 小写

  • split("分隔符");

    • 作用：对字符串进行分割，将分隔符去掉，将其它项放到数组中

    • 返回值：数组

  • replace(searchStr,replaceStr);

    • 参数：searchStr:查找的字符串 replaceStr:用来替换的字符串

    • 作用：字符串替换 默认只能替换一处

    • trim(); 去除首尾空格 IE8及以下不兼容

.数组对象的创建

存储任意数据的集合

  • 字面量：[]

  • 构造函数：new Array();

    • 不传递参数 返回空数组

    • 传递1个参数 数值 规定数组的长度

    • 传递多个参数 传递具体数据

// push(数据1,...);
// 作用:在数组末尾进行增加
// 参数：可以传递一个也可以传递多个
// 是否改变原数组： 改变
// 返回值：返回增加后数组的长度
var arr1 = [10, 100, 200];
var resArr1 = arr1.push("哈哈", true, 1000);
console.log(resArr1);
console.log(arr1);


// pop();
// 作用:在数组末尾删除一项
// 参数：无
// 是否改变原数组： 改变
// 返回值：返回删除的那一项
var arr2 = [10, 100, 200];
var resArr2 = arr2.pop();
console.log(resArr2);
console.log(arr2);


// unshift(数据1,...);
// 作用:在数组开头进行增加
// 参数：可以传递一个也可以传递多个
// 是否改变原数组： 改变
// 返回值：返回增加后数组的长度
var arr3 = [10, 100, 200];
var resArr3 = arr3.unshift("哈哈", true);
console.log(resArr3);
console.log(arr3);


// shift();
// 作用:在数组开头删除一项
// 参数：无
// 是否改变原数组： 改变
// 返回值：返回删除的那一项
var arr4= [10, 100, 200];
var resArr4 = arr4.shift();
console.log(resArr4);
console.log(arr4);


// splice可以实现数组的增加 删除  修改

// 作用：从当前索引开始删除n项
// 参数：startIndex:开始索引  n:删除的个数   
// 是否改变原数组： 改变 
// 返回值：把删除的每一项以一个新的数组返回,没有删除返回空数组
// splice(startIndex,n);
var test1Arr = [10,20,30,40];
var resTest1Arr = test1Arr.splice(1,2);
console.log(resTest1Arr);
console.log(test1Arr); 


// splice(startIndex,n,content,...);
// content：替换的数据
// 从当前索引开始删除n项用content进行替换
var test2Arr = [10,20,30,40,1000,2000,"哈哈"];
var resTest2Arr = test2Arr.splice(1,3,"呵呵",true,{name:"哈哈"});
console.log(resTest2Arr);
console.log(test2Arr); 


// splice(startIndex,0,content,...);
// 从当前索引开始删除0项用content进行替换   放到开始索引之前
var test3Arr = [10,20,30,40,1000,2000,"哈哈"];
var resTest3Arr = test3Arr.splice(2,0,true,{name:"哈哈"});
console.log(resTest3Arr);
console.log(test3Arr);

数组对象的方法

  • indexOf(数据,[startIndex]) / lastIndexOf(数据,[startIndex]); 判断当前数组中是否包含这个数据 包含返回首次/最后一次出现的索引 不包含返回-1

    • IE8及以下没有这个方法（不兼容）

    • 原数组不改变

  • join("拼接符");

    • 作用：将数组中每一项数据用拼接符进行拼接返回字符串

    • 原数组不改变

  • slice(startIndex,endIndex);

    • 数组的截取

    • startIndex：开始索引 endIndex:结束索引

    • 原数组不改变

  • concat(数据,...);

    • 将当前数组与数据进行合并

    • 返回值：返回合并后的数组

    • 原数组不改变

  • reverse(); 倒序 翻转

    • 返回值：返回倒序后的数组

    • 改变原数组

数组去重

1.

var arr = [2,4,2,4,2,4];
// 获取当前项
for(var i = 0;i<arr.length;i++){
    // 获取后边的每一项
    for(var j = i+1;j<arr.length;j++){
        // 判断  相等就重复了
        if(arr[i] == arr[j]){
            arr.splice(j,1);
            j--;
        }
    }
}

 2.

/* 
	思想：用数组中当前项 和 后边的每一项进行比较  如果当前项和后边某一项相等 就删除这个一项  数组塌陷   数组中删除某一项   后边每一项往前移动一位索引的值也改变了
*/
var arr = [1, 2, 3, 4, 2, 2, 3, 4, 3, 2, 3, 4];
//获取当前项
for (var i = 0; i < arr.length; i++) {
    //获取后边的每一项
    for (var j = i + 1; j < arr.length; j++) {
        //判断   如果当前项和后边某一项相等 就删除这个一项
        if (arr[i] == arr[j]) {
            arr.splice(j, 1);
            j--;
        }
    }
}
console.log(arr);

数组排序

1.

/* 
    选择排序
    用数组中当前项 和 后边的每一项进行比较   如果说当前项大于后边这一项交换位置
*/
// 获取当前项
for (var i = 0; i < arr.length; i++) {
    // 获取后边的每一项
    for (var j = i + 1; j < arr.length; j++) {
        //如果说当前项大于后边这一项交换位置
        if (arr[i] > arr[j]) {
            // 定义中间变量 
            var temp;
            temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
}
console.log(arr);

2.

/* 
    冒泡排序
    思想：用数组中当前项和后一项进行比较 如果当前项大于后一项就交换位置
*/
var arr = [4, 3, 5, 2, 1];
//第一轮    首先不和自己比   将最大值放到了末尾   4, 3, 5, 2, 1
//第一次  4 > 3: 3, 4, 5, 2, 1
//第二次  4 > 5(不成立): 3, 4, 5, 2, 1
//第三次  5 > 2: 3, 4, 2, 5, 1
//第四次  5 > 1: 3, 4, 2, 1, 5

// 第二轮   首先不和自己比   将第二大的值放到了倒数第二项   3, 4, 2, 1, 5
// 第一次  3 > 4(不成立):  3, 4, 2, 1, 5
// 第二次  4 > 2: 3, 2, 4, 1, 5  
// 第三次  4 > 1: 3, 2, 1, 4, 5

// 第三轮   首先不和自己比     .....            3, 2, 1, 4, 5
// 第一次： 3 > 2: 2, 3, 1, 4, 5
// 第二次   3 > 1: 2, 1, 3, 4, 5


// 第四轮   首先不和自己比      2, 1, 3, 4, 5
// 第一次   2 > 1  1, 2, 3, 4, 5


// i(轮数)  arr.length - 1    j(次数) arr.length - 1 - i;
// 0                          4      arr.length - 1 - 0
// 1                          3      arr.length - 1 - 1
// 2                          2      arr.length - 1 - 2
// 3                          1      arr.length - 1 - 3


// 轮数
for (var i = 0; i < arr.length - 1; i++) {
    // 次数
    for (var j = 0; j < arr.length - 1 - i; j++) {
        // 如果说当前项大于后边这一项交换位置
        if (arr[j] > arr[j + 1]) {
            var temp;
            temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }
    }
}
console.log(arr);

数组的排序方法

/* 
    sort();  默认升序
    不传递参数：是按照字符串比较进行排序的 ，只能处理0-9 不能处理多位数
    返回值：排好序数组
    是否改变原数组：改变

*/

var arr1 = [1, 9, 8, 7, 2, 4, 3, 11, 22, 14, 23, 18];
var resArr1 = arr1.sort();
console.log(arr1);
console.log(resArr1);


/* 
    sort(callBack);
    传递参数
    callBack:函数   这个函数 需要定义两个形参   这个函数被sort方法调用的时候会传递实参 实参就是数组当中后一项及前一项  比较根据返回值的正负
     返回值：排好序数组
    是否改变原数组：改变

*/


// 数值排序 
var arr2 = [1, 9, 8, 7, 2, 4, 3, 11, 22, 14, 23, 18];
var resArr2 = arr2.sort(function (a, b) {
    console.log(a, b);
    // return a - b;//升序   根据返回值得正负  a-b 整数  负数  0
    return b - a;//降序
});
console.log(resArr2);
console.log(arr2);


var arr3 = [
    { name: "张三", age: 22, date: "1999/8/15" },
    { name: "李四", age: 21, date: "2000/8/15" },
    { name: "车金恩", age: 20, date: "2001/8/15" },
    { name: "钟桦", age: 23, date: "1998/8/15" },
    { name: "刘天信", age: 23, date: "2000/8/20" }
];

// 按照年龄排序
// var resArr3 = arr3.sort(function(a,b){
//     console.log(a,b);
//     console.log(a.age,b.age);
//     return a.age - b.age; //升序
// });



// 按照出生日期排序
var resArr3 = arr3.sort(function (a, b) {
    // console.log(a,b);
    // console.log(a.date,b.date);
    // return new Date(a.date) - new Date(b.date);
    return new Date(b.date) - new Date(a.date);
});

console.log(resArr3);
console.log(arr3);



console.log(new Date("1999/8/15"));
console.log(new Date("2000/8/15"));
// 日期对象相见  首先会先转为时间戳  然后进行相减  获取到的是毫秒值的差值
console.log(new Date("2000/8/15") - new Date("1999/8/15"));


// 根据名字
/* 
    sort(callBack);
    参数：函数
    callBack:这个函数 需要定义两个形参   这个函数被sort方法调用的时候会传递实参 实参就是数组当中后一项及前一项   根据返回值的比较直  return 字符串.localeCompare(字符串);
    中文：按照拼音  
    英文：按照英文字符表
*/

var resTest = arr3.sort(function (a, b) {
    console.log(a.name, b.name);
    // return a.name.localeCompare(b.name,"zh"); //升序
    // 中文
    return b.name.localeCompare(a.name, "zh"); //降序
    // 英文  不需要zh
});
console.log(resTest);
console.log(arr3);

前端小臂猿
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
javascript对象——数组对象
m0_72313625的博客
08-16 3673
添加数组元素：push() unshift() 删除数组元素：pop() shift() 删除或替换现有元素或者原地添加新的元素来修改数组 splice(star,num,insert) 截取指定开始位置到结束位置的字符串 slice 用于合并两个或多个数组 concat() 获取索引值的方法(去重时可以考虑使用） indexOf(数组元素,起始位置) lastIndexOf(数组元素，起始位置) ...
JS数组对象
m0_72738258的博客
08-04 448
JS冒泡排序
JS对象和数组
低调走过
08-15 7576
1、创建数组 创建数组的最简单的方法就是在JavaScript代码中加入一个对象直接量。对象直接量是用逗号分隔开的一对对的属性名和值的列表，包含在一个花括号之中，每个属性名可以是一个JavaScript标识符或一个字符串，而每个属性值可以是一个常量或任意的JavaScript表
js的数组对象
m0_74244177的博客
04-22 218
数组类型检测有两种常用的方式，分别是使用instanceof运算符和使用Array.isArray()方法。首先已经讲得很详细了，你要是在不懂，那只能看不别人的啦，我已经尽力教会你啦！！
js将类数组对象转换成数组对象
10-29
在JavaScript中，类数组对象并不是真正的数组，但是它们看起来和数组很相似，因为它们也有索引和length属性。类数组对象包括但不限于Arguments对象（函数调用时传入的参数集合）、HTMLCollection（如document....
JavaScript数组对象实现增加一个返回随机元素的方法
10-23
在给定的标题和描述中，我们看到的核心知识点是扩展JavaScript数组对象以包含一个返回随机元素的方法。这个方法涉及到对数组和随机数的操作。 首先，让我们详细了解一下如何实现这个方法。这里提供了三种随机元素...
JavaScript数组对象赋值用法实例
10-23
JavaScript数组对象是编程中一个非常重要的概念，它允许我们存储一系列的数据。数组中的每个元素都可以是不同类型的数据，包括数字、字符串、对象，甚至是其他数组。数组对象的使用可以让我们的JavaScript程序代码...
JavaScript类数组对象转换为数组对象的方法实例分析
12-04
本文实例分析了JavaScript类数组对象转换为数组对象的方法。分享给大家供大家参考，具体如下： 1、类数组对象： 拥有length属性，可以通过下标访问； 不具有数组所具有的方法。 2、为什么要将类数组对象转换为数组...
js 数组对象
2302_76143886的博客
01-20 299
(取值是以下标开始，0代表第一个值，从前往后算，-1代表最后一个值，从后往前算)2.数组元素（数组的内容）：是指存储在数组中并赋予唯一索引号（下标）的数据段。1.概念(什么叫数组)：数组是一个可以存储一组或一系列相关数据的容器。splice() 删除数组元素/替换数组元素。slice() 获取数组中的某段数组元素。格2：通过字面量创建数组（通过中括号创建数组）concat()多个数组连接成一个数组。shift()删除数组中的第一个元素。pop()删除数组中的最后一个元素。
js中的数组对象
通俗易懂
05-24 363
数组对象去重 根据数组对象的一个字端来判断去重 参数 arr：要去重的数组（数组对象） id：根据去重字端名称（string） 返回值：合并后的数组对象（数组对象） function arrObjUniq(arr, id){ let obj = {}; arr = arr.reduce((cur, next)=>{ obj[next[id]] ? '' : obj[next[id]] = true && cur.push(next); return cur;
js对象数组
ambition_star的博客
12-31 2222
一、 内置对象 1） 对象 2） Array 数组 创建 特点 属性和方法 二维数组 3）String 对象 创建 特点 属性 方法 Math 对象 定义 属性 方法 5）日期对象 创建日期对象 日期对象方法 一、 内置对象 1） 对象 对象是由属性和方法组成的,使用点语法访问 2） Array 数组 创建 特点 数组用于存储若干数据,自动为每位数据分配下标,从0开始 数组中的元素不...
JavaScript的数组对象
前端小白的博客
03-25 817
JavaScript 数组对象
JavaScript 数组 Array 对象
艾斯博弈
05-14 554
Array 对象方法 方法 描述 concat() 连接两个或更多的数组，并返回结果。 join() 把数组的所有元素放入一个字符串。元素通过指定的分隔符进行分隔。 pop() 删除并返回数组的最后一个元素 push() 向数组的末尾添加一个或更多元素，并返回新的长度。 rever
js基础 数组对象
赚钱养自个儿的博客
04-12 227
  目录创建数组的两种方式1、字面量方式2、new Array()检测是否为数组instanceof 运算符Array.isArray()添加删除数组元素的方法push(参数1，参数2，……)unshift(参数1，参数2，……)pop()shift()数组排序reverse()sort()数组索引方法indexOf()lastIndexOf()数组转换为字符串其他方法1.6 字符串对象基本包装类...
ECMAScript 6新特性（1）数组篇
weixin_30551963的博客
01-01 94
数组现有的方法： .concat():连接两个或更多的数组，并返回结果。 .join():把数组的所有元素放入一个字符串。元素通过指定的分隔符进行分隔。 .pop():删除并返回数组的最后一个元素 .push():向数组的末尾添加一个或更多元素，并返回新的长度。 .reverse():颠倒数组中元素的顺序。 .shift():删除并返回数组的第一个元素 .slice():从某个已有的...
JS 类数组对象——Array-like Objects
音韵者天
03-18 1458
什么是类数组对象？类数组对象是JS里面比较常用的一个对象，平时在操作DOM或写function的时候经常会用到，虽然对初学者来说概念比较陌生。类数组对象具有数组对象的一些属性，比如length,可以遍历(for-in不可以)但是却不能使用数组对象的方法。 最常见的类数组就是function里面的参数变量arguments，通常传递给function的参数都会被存储在一个名为arguments的类数
js 数组对象添加属性
最新发布
09-25
在JavaScript中，可以通过以下两种方法向数组对象添加属性： 方法一：使用forEach方法遍历数组对象，然后在遍历过程中为每个对象添加属性。...这样，通过以上两种方法，你可以向JavaScript数组对象中添加属性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值