JS基本语法5：JS访问器属性/字符串和数组方法/循环队列

JS访问器属性/字符串和数组方法/循环队列

JS访问器属性

1.这个属性不包含数据值，包含的是一对get和set方法，在读写访问器属性时，就是通过这两个方法来进行操作处理的。

传统访问属性
  let staff = {
        data: {
          age: 30,
        },
       //获取age访问接口
        getAge: function () {
          return this.data.age;
        },
        //设置age接口
        setAge: function (age) {
        if(age<18||age>=60){    // 错误优先策略
        console.log("年龄不符要求！");
        return false;
        }else{
        this.data.age = age;
        }
        },
      };
      console.log(staff.data.age);  // 30
      //更新age
      staff.setAge(20);
      console.log(staff.data.age);//20
------------
访问器属性
let staff = {
  data: { age: 40 },
  get age() {
    return this.data.age;
  },
  set age(age) {
  // 错误优先策略
    if (age <= 18 || age >= 60) {
      console.log("年龄必须在18-60之间");
      return false;
    }
    this.data.age = age;
  },
};
console.log(staff.age);
staff.age = 76;
console.log(staff.age);

访问器属性

1. getter: getAge() => get age()
2. setter: setAge(value) => set age(value)

披着”属性”外衣的”方法”，
按”属性”来访问, 按”方法”来声明
说一套,做一套,表里不一

如果对象中存在与”访问器属性”同名的”属性”,访问器属性 > 原有同名属性

字符串和数组常用方法

字符串

字符串常用方法介绍地址

let str = "我在php中文网学编程";
console.log(str.length);  //11
//字符串是由一个个字符组成的字符数组
 console.log(str[0], str[1], str[2], str[3], str[4]);//我 在 p h p
//1.length,查询字符串的长度
console.log(str.length);  //11
//2.查找字符串中的单个字符索引,str.search('string')
// string:单个字符(单个字符) => 索引;
 console.log(str.search("中文"));
//3.replace
//str.replace('被替换的字符','替换字符')
 console.log(str.replace("中文网", ".cn"));
//4.slice: 子串,起始索引,结束索引(忽略结束索引的值)
//只有一个参数
 console.log(str.slice(4)); //p中文网学编程,
 console.log(str.slice(0, 4)); //我在ph
//5.substr: 子串,起始索引和获取的数量,不用知道到哪结束
//2个参数时，第1个：开始截取的索引,第2个：截取字符串的长度
//当1个参数时，表示从这个索引一直截取到最后一个字符
console.log(str.substr(3, 3));// hp中
console.log(str.substr(7));//网学编程
//6.split:将一个字符串转成一个数组  string --> array
 str = "php编程";
 console.log(str.split(""));
//[ 'p', 'h', 'p', '编', '程' ]
str = "p-h-p-编-程";
 console.log(str.split(""));
/* [
    'p',  '-', 'h',
    '-',  'p', '-',
    '编', '-', '程'
  ] */
console.log(str.split("-"));
//[ 'p', 'h', 'p', '编', '程' ]
//7.toLowerCase():将字符串转成小写字母
//toUpperCase()：将字符串转成大写字母
str = "Php.cN";
console.log(str.toLowerCase()); //php.cn
console.log(str.toUpperCase()); //PHP.CN
// 将字符串转为统一格式
let url = "php.cn";
switch (url.toUpperCase) {
  case "php.cn":
    console.log("php中文网");
    break;
  default:
    console.log("输入错误");
}

3. 数组的常用方法

数组常用方法介绍链接地址

1. arr.push()/arr.pop()：尾部添加与删除元素
2. arr.unshift()/arr.shift()：头部添加与删除元素
3. arr.keys()/arr.values()/arr.entries()：获取数组键(索引)/值/键值对
4. arr.slice()：截取数组元素
5. arr.splice()：对数组元素增删改操作
6. arr.sort()：数组元素排序
7. arr.forEach()/arr.map()：遍历数组元素
8. arr.some()/arr.every()：断言数组元素
9. arr.filter()/find()/findLast()/findIndex()：过滤元素
10. arr.reduce()：累加数组元素

数组回调方法

   * 1. 遍历: forEach / map
   * 2. 断言: every / some
   * 3. 过滤: filter / find /findLast
   * 4. 累加: reduce

1. arr.push()/arr.pop()：尾部增加与删除元素
arr.push() 方法：将一个或多个元素添加到数组的末尾，并返回该数组的新长度
参数:被添加到数组末尾的元素。
arr.pop()方法：从数组中删除最后一个元素，并返回该元素的值。此方法会更改数组的长度。
参数：没有参数

const arr = ["a", "b", "c"];
console.log(arr.push("a1")); //4   a1添加到数组尾部
const arr1 = ["a1", "a2", "a3"];
console.log(arr.push(...arr1)); // ...arr1解构添加到arr尾部,返回值 7
console.log(arr); //['a',  'b',  'c','a1', 'a1', 'a2', 'a3' ]
console.log(arr.pop()); // a3
console.log(arr.pop()); //a2
console.log(arr.pop()); //a1
console.log(arr.pop()); //a1
console.log(arr.pop()); //c
console.log(arr); //  [ 'a', 'b' ]

2. arr.unshift()/arr.shift()：头部添加与删除元素
unshift() 方法将一个或多个元素添加到数组的开头，并返回该数组的新长度
shift() 方法从数组中删除第一个元素，并返回该元素的值。此方法更改数组的长度

const arr = ["a", "b", "c"];
console.log(arr.unshift("c1")); //4
const arr1 = ["a1", "a2"];
console.log(arr.unshift(...arr1)); //6,将arr1 解构添加到arr头部
console.log(arr.shift()); //a1 ,删除a1,并返回删除的值
console.log(arr.shift()); //a2 ,删除a2,并返回删除的值
console.log(arr.shift()); //c1 ,删除c1,并返回删除的值
console.log(arr.shift()); //a ,删除a,并返回删除的值
console.log(arr); //[ 'b', 'c' ]

循环队列

出队的元素,再重新回到队的尾部重新进队,首尾相连
队列: 尾进头出, push + shift

/**
 * 10,20,30,40,50
 * 20,30,40,50,10
 * 30,40,50,10,20
 * 40,50,10,20,30
 * 50,10,20,30,40
 * 10.20.30.40.50
 */
let num = ["10", "20", "30", "40", "50"];
for (let i = 0; i <= 3; i++) {
  for (let j = 0; j <= num.length; j++) {
    let k = num.shift();//获取shift删除返回的元素
    num.push(k);//将获取的元素添加到数组尾部
    console.log(num);
  }
}

3. arr.keys()/arr.values()/arr.entries()：获取数组键(索引)/值/键值对
keys() 方法返回一个包含数组中每个索引键的 Array Iterator 对象
values() 方法返回一个新的 Array Iterator 对象，该对象包含数组每个索引的值
entries() 方法返回一个新的数组迭代器对象，该对象包含数组中每个索引的键/值对
使用 for…of 循环迭代器查徇返回结果

const arr = ["a", "b", "c", "d", "e"];
let keys=arr.keys()
for(let item of keys){
    console.log(item);
}
/*
0
1
2
3
4
*/
let values = arr.values();
for (let item of values) {
  console.log(item);
}/*
a
b
c
d
e
*/
let ent = arr.entries();
for (let item of ent) {
  console.log(item);
}
/*
[ 0, 'a' ]
[ 1, 'b' ]
[ 2, 'c' ]
[ 3, 'd' ]
[ 4, 'e' ]
*/

4. arr.slice()：方法返回一个新的数组对象，这一对象是一个由 begin 和 end 决定的原数组的浅拷贝（包括 begin，不包括end）。原始数组不会被改变。
参数：2个
参数1：begin,起始索引
参数2：end,结束索引，可选，不选即从起始索引到末尾全部元素
返回值
包含begin，不包括end索引的新数组

const arr = [2, 6, 4, 7, 13, 5];
console.log(arr.slice(1, 4));
console.log(arr.slice(3));
/*
[ 6, 4, 7 ]
[ 7, 13, 5 ]
*/

5. arr.splice()：对数组增删改操作
splice() 方法通过删除或替换现有元素或者原地添加新的元素来修改数组，并以数组形式返回被修改的内容。此方法会改变原数组。
3个参数
start
指定修改的开始位置（从 0 计数）。

deleteCount 可选
整数，表示要移除的数组元素的个数。如果 deleteCount 大于 start 之后的元素的总数，则从 start 后面的元素都将被删除（含第 start 位）。

item1, item2, … 可选
要添加进数组的元素，从start 位置开始。如果不指定，则 splice() 将只删除数组元素。

返回值
由被删除的元素组成的一个数组。如果只删除了一个元素，则返回只包含一个元素的数组。如果没有删除元素，则返回空数组。

const arr = [1, 2, 3, 4, 5];
//增加元素
let i = arr.splice(3, 0, "a", "b");
console.log(i); //[] 返回空数组
console.log(arr); //[ 1, 2, 3,'a','b',4,5]
//删除元素
i = arr.splice(2, 3);
console.log(i); //[ 3, 'a', 'b' ] 返回被删除的元素
console.log(arr); //[ 1, 2, 4, 5 ]
//更新数组
//分2步: 1.先删除元素 2.在删除的位置上增加新元素
//把元素2,4更新为7,8
console.log(arr.splice(1, 2)); //[ 2, 4 ]删除元素2,4
console.log(arr.splice(1, 0, 7, 8));//[]返回空数组
console.log(arr);//[ 1, 7, 8, 5 ]

6. arr.sort()：数组排序
对数组的元素进行排序，并返回数组。默认排序顺序是在将元素转换为字符串，然后比较它们的 UTF-16 代码单元值序列时构建的
3个参数
compareFn 可选
用来指定按某种顺序进行排列的函数。如果省略，元素按照转换为的字符串的各个字符的 Unicode 位点进行排序。
a
第一个用于比较的元素。
b
第二个用于比较的元素。

返回值
排序后的数组。请注意，数组已原地排序，并且不进行复制。

let arr = [1, 7, 2, 12, 8, 5];
let arr1 = arr.sort();
console.log(arr1);//[ 1, 12, 2, 5, 7, 8 ],默认按字符串排序
console.log(arr.sort((a, b) => a - b)); //从小到大 [ 1, 2, 5, 7, 8, 12 ]
console.log(arr.sort((a, b) => b - a));//从大到小[ 12, 8, 7, 5, 2, 1 ]

7. arr.forEach()/arr.map()：遍历数组
forEach() 方法对数组的每个元素执行一次给定的函数,无返回值
map() 方法创建一个新数组，这个新数组由原数组中的每个元素都调用一次提供的函数后的返回值组成。

参数
callbackFn
生成新数组元素的函数，使用三个参数：

currentValue
callbackFn 数组中正在处理的当前元素。

index
callbackFn 数组中正在处理的当前元素的索引。

array
map 方法调用的数组。

thisArg 可选
执行 callbackFn 函数时被用作 this 的值。

返回值
一个新数组，每个元素都是回调函数的返回值

 // 箭头函数
forEach((element) => { /* … */ })
forEach((element, index) => { /* … */ })
forEach((element, index, array) => { /* … */ })
// 回调函数
forEach(callbackFn)
forEach(callbackFn, thisArg)
// 内联回调函数
forEach(function(element) { /* … */ })
forEach(function(element, index) { /* … */ })
forEach(function(element, index, array){ /* … */ })
forEach(function(element, index, array) { /* … */ }, thisArg)
 // 箭头函数
map((element) => { /* … */ })
map((element, index) => { /* … */ })
map((element, index, array) => { /* … */ })
// 回调函数
map(callbackFn)
map(callbackFn, thisArg)
// 内联回调函数
map(function(element) { /* … */ })
map(function(element, index) { /* … */ })
map(function(element, index, array){ /* … */ })
map(function(element, index, array) { /* … */ }, thisArg)

const arr = [1, 7, 2, 12, 8, 5];
arr.forEach(function (values, index) {
  console.log(values * 2, index);
});
/*
2 0
14 1
4 2
24 3
16 4
10 5
*/
console.log(arr.map((values) => values * 2));//[ 2, 14, 4, 24, 16, 10 ]

8. arr.some()/arr.every()：断言数组元素
some() 方法测试数组中是不是至少有 1 个元素通过了被提供的函数测试，它返回的是一个 Boolean 类型的值。
every() 方法测试一个数组内的所有元素是否都能通过某个指定函数的测试。它返回一个布尔值。

const arr = [2, 6, 4, 7, 13, 5];
//测试数组中的值是否有 > 15,有 返回 true,没有则 false
console.log(arr.some((value) => value > 15)); //false
//测试数组中的值是否都是 < 15,是 返回 true,否则 false
console.log(arr.every((value) => value < 15)); //true
console.log(arr.every((value) => value < 10)); //false

9. arr.filter()/find()/findLast()/findIndex()：过滤元素
filter() 方法返回满足条件的元素，并组成新数组
find()返回满足条件的第1个元素
findLast()返回满足条件的最后1个元素
findIndex()方法返回数组中满足条件的第1个元素的索引
lastIndexof()方法返回数组中满足条件的最后1个元素的索引(分2步获取)

const arr = [2, 6, 4, 7, 13, 5];
//返回数组中<5的元素
let items = arr.filter((values) => values > 5);
console.log(items);//[ 6, 7, 13 ]
//找出数组中<5条件的第1个元素
let items = arr.filter((values) => values > 5)[0];
console.log(items); // 6
//返回数组中<5条件的第1个元素
 let items = arr.find((values) => values > 5);
console.log(items); // 6
//返回数组中<=5条件的最后1个元素
 let items = arr.findLast((values) => values >= 5);
console.log(items);//5
//返回数组中满足条件的第1个元素的索引
let items = arr.findIndex((values) => values >= 5);
console.log(items);//1
//获取最后一个满足条件的元素对应的索引,需要分2步
//第1步,拿到最后满足条件的元素
//第2步,通过元素获取索引
 let items = arr.findLast((values) => values >= 5);
console.log(items); //5
//返回满足条件最后一个元素在数组中的索引
console.log(arr.lastIndexOf(5)); //5

10. arr.reduce()：累加数组元素
reduce() 方法对数组中的每个元素按序执行一个由您提供的 reducer 函数，
每一次运行 reducer 会将先前元素的计算结果作为参数传入，最后将其结果汇总为单个返回值。
2个参数
1.回调函数
2.初始值,可选,默认初始值为0

const arr = [2, 6, 4, 7, 13, 5];
let res = arr.reduce((a, b) => a + b, 100);//设定起始值100
console.log(res); //137
let res = arr.reduce((a, b) => a + b);//没有设定默认
console.log(res);  //37

累加数组元素使用案例

    <script>
      let links = ["首页", "公司简介", "视频课程", "开发社区", "文档中心"];
      let res = links.reduce(function (prev, curr) {
        return prev.link("#") + curr.link("#");
      });
      console.log(res);
      res = "<ul>" + res + "</ul>";
      console.log(res);
      document.body.insertAdjacentHTML("afterbegin", res);
    </script>

字符串/数组方法的扩展

数组方法

1.toString():方法返回一个字符串，表示指定的数组及其元素。
返回值
一个表示数组所有元素的字符串。

const array1 = [1, 2, "a", "1a"];
console.log(array1.toString()); //1,2,a,1a

2.copyWithin（）: 方法浅复制数组的一部分到同一数组中的另一个位置，并返回它，不会改变原数组的长度。
3个参数
target
0 为基底的索引，复制序列到该位置。
start
0 为基底的索引，开始复制元素的起始位置。
end
0 为基底的索引，开始复制元素的结束位置。

const arr = [1, 2, 3, 4, 5, 6];
console.log(arr);
console.log(arr.copyWithin(0, 2));//[ 3, 4, 5, 6, 5, 6 ]
console.log(arr.copyWithin(1, 2, 6));//[ 3, 5, 6, 5, 6, 6 ]

3.reverse（）:方法将数组中元素的位置颠倒，并返回该数组。数组的第一个元素会变成最后一个，数组的最后一个元素变成第一个。该方法会改变原数组。

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