JavaScript和TypeScript语法基础,数组,字符串的split，splice，slice，reduce，concat，charAt，indexOf，replace，se

最新推荐文章于 2025-02-11 12:28:19 发布

qq_42838904

最新推荐文章于 2025-02-11 12:28:19 发布

阅读量1.4k

点赞数

分类专栏：语言

本文链接：https://blog.csdn.net/qq_42838904/article/details/104973736

版权

语言专栏收录该内容

14 篇文章

订阅专栏

本文详细介绍了JavaScript和TypeScript中数组的操作方法，包括声明、初始化、元素赋值与添加、遍历、连接、排序、反序及常用数组方法的使用，如concat、every、filter等，帮助开发者掌握高效数组处理技巧。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

JavaScript

基本数据类型只有 Number string boolen object 等
使用时大多是直接声明并使用
var Ins；

数组 WXBanner._IDS = [];
WXBanner._IDS.push(ids[ran]);
遍历 i < WXBanner._IDS.length WXBanner._IDS[i]

TypeScript

一、数组的声明
let array1:Array;
let array2:number[];

二、数组初始化
let array1:Array = new Array();
let array2:number[] = [1，2，3];

三、数组元素赋值、添加、更改
先声明 public IsShowVideo = false

let array:Array = [1,2,3,4];
array[0] = 20;

array.splice(0, 1); // 删除元素（index, deleteCount）从index开始删除deleteCount个元素
array.shift(); // 删除第一个元素
array1 = array1.concat( array2) 合并数组1 和数组2 并赋值给数组1
let indexC = array.indexOf(“c”); 查找c元素在数组中的索引值

七、连接数组元素
let array: Array = [“a”,“b”,“c”,“d”,“c”,“a”];
let result = array.join(); //result 为数组 a,b,c,d,c,a
result = array.join("+"); //result 为数组 a+b+c+d+c+a

八、排序、反序数组
array.sort(); // 对数组从小到大排序
array.reverse(); //对数组反序排列
array.split(",") //【尸解】， //以，为分割，进行分裂，返回分裂后的数组
array.splice(start,length,xiaoming,xianghong) //删除或删除再增加数组中的元素从start位置开始删除，删除length个元素，
再在startwei位置增加xiaoming,xianghong。
详情见排序快速排序章节
array.slice(start,length) // 从数组中抽取一个数组从索引为start位置即第 start+1 个开始抽取，
//抽取长度为length，length省略是抽取到末尾
array.shift() //在字符串或数组头部删除一个元素百度翻译:转移,挪动,切换。
unshift() //在字符串或数组头部增加一个元素

pop() // 在数组末尾删除

//数组方法***********//

下表列出了一些常用的数组方法：

序号方法 & 描述实例

concat() ：连接两个或更多的数组，并返回结果。
var alpha = [“a”, “b”, “c”];
var numeric = [1, 2, 3];
var alphaNumeric = alpha.concat(numeric);
console.log("alphaNumeric : " + alphaNumeric ); // a,b,c,1,2,3
every() ：检测数值元素的每个元素是否都符合条件。
function isBigEnough(element, index, array) {
return (element >= 10);
}
```
							var passed = [12, 5, 8, 130, 44].every(isBigEnough); 
							console.log("Test Value : " + passed ); // false
```
filter() ：检测数值元素，并返回符合条件所有元素的数组。
function isBigEnough(element, index, array) {
return (element >= 10);
}
```
	var passed = [12, 5, 8, 130, 44].filter(isBigEnough); 
			console.log("Test Value : " + passed ); // 12,130,44
```
forEach() ：数组每个元素都执行一次回调函数。
let num = [7, 8, 9];
num.forEach(function (value) {
console.log(value);
});
编译成 JavaScript 代码：
```
							var num = [7, 8, 9];
							num.forEach(function (value) {
							    console.log(value);  // 7   8   9
							});
```
indexOf() ：搜索数组中的元素，并返回它所在的位置。
如果搜索不到，返回值 -1，代表没有此项。
var index = [12, 5, 8, 130, 44].indexOf(8);
console.log("index is : " + index ); // 2

join() ：把数组的所有元素放入一个字符串。
var arr = new Array(“First”,“Second”,“Third”);
var str = arr.join();
console.log("str : " + str ); // First,Second,Third

							var str = arr.join(", "); 
								console.log("str : " + str );  // First, Second, Third
							          
							var str = arr.join(" + "); 
							console.log("str : " + str );  // First + Second + Third

lastIndexOf() ：返回一个指定的字符串值最后出现的位置，在一个字符串中的指定位置从后向前搜索。
var index = [12, 5, 8, 130, 44].lastIndexOf(8);
console.log("index is : " + index ); // 2
map() ：通过指定函数处理数组的每个元素，并返回处理后的数组。
var numbers = [1, 4, 9];
var roots = numbers.map(Math.sqrt);
console.log("roots is : " + roots ); // 1,2,3
pop() ：删除数组的最后一个元素并返回删除的元素。
var numbers = [1, 4, 9];
var element = numbers.pop();
console.log("element is : " + element ); // 9
var element = numbers.pop();
console.log("element is : " + element ); // 4
push() ：向数组的末尾添加一个或更多元素，并返回新的长度。
var numbers = new Array(1, 4, 9);
var length = numbers.push(10);
console.log("new numbers is : " + numbers ); // 1,4,9,10
length = numbers.push(20);
console.log("new numbers is : " + numbers ); // 1,4,9,10,20
reduce() ：将数组元素计算为一个值（从左到右）。
var total = [0, 1, 2, 3].reduce(function(a, b){ return a + b; });
console.log("total is : " + total ); // 6
reduceRight() ：将数组元素计算为一个值（从右到左）。
var total = [0, 1, 2, 3].reduceRight(function(a, b){ return a + b; });
console.log("total is : " + total ); // 6
reverse() ：反转数组的元素顺序。
var arr = [0, 1, 2, 3].reverse();
console.log("Reversed array is : " + arr ); // 3,2,1,0
shift() ：删除并返回数组的第一个元素。
var arr = [10, 1, 2, 3].shift();
console.log("Shifted value is : " + arr ); // 10
slice() ：选取数组的的一部分，并返回一个新数组。
var arr = [“orange”, “mango”, “banana”, “sugar”, “tea”];
console.log("arr.slice( 1, 2) : " + arr.slice( 1, 2) ); // mango
console.log("arr.slice( 1, 3) : " + arr.slice( 1, 3) ); // mango,banana
some() ：检测数组元素中是否有元素符合指定条件。
function isBigEnough(element, index, array) {
return (element >= 10);
}
var retval = [2, 5, 8, 1, 4].some(isBigEnough);
console.log("Returned value is : " + retval ); // false
var retval = [12, 5, 8, 1, 4].some(isBigEnough);
console.log("Returned value is : " + retval ); // true
sort() ：对数组的元素进行排序。
var arr = new Array(“orange”, “mango”, “banana”, “sugar”);
var sorted = arr.sort();
console.log("Returned string is : " + sorted ); // banana,mango,orange,sugar
splice() ：从数组中添加或删除元素。
var arr = [“orange”, “mango”, “banana”, “sugar”, “tea”];
var removed = arr.splice(2, 0, “water”);
console.log("After adding 1: " + arr ); // orange,mango,water,banana,sugar,tea
console.log("removed is: " + removed);
```
								removed = arr.splice(3, 1);  
										console.log("After removing 1: " + arr );  // orange,mango,water,sugar,tea 
										console.log("removed is: " + removed);  // banana
```
toString() ：把数组转换为字符串，并返回结果。
var arr = new Array(“orange”, “mango”, “banana”, “sugar”);
var str = arr.toString();
console.log("Returned string is : " + str ); // orange,mango,banana,sugar
shift() ：方法用于把数组的第一个元素从其中删除，并返回第一个元素的值。
var fruits = [“Banana”, “Orange”, “Apple”, “Mango”];
fruits.unshift(“Lemon”,“Pineapple”);
fruits 将输出：
Lemon,Pineapple,Banana,Orange,Apple,Mango
unshift() ：向数组的开头添加一个或更多元素，并返回新的长度。
var arr = new Array(“orange”, “mango”, “banana”, “sugar”);
var length = arr.unshift(“water”);
console.log("Returned array is : " + arr ); // water,orange,mango,banana,sugar
console.log("Length of the array is : " + length ); // 5

//字符串方法***********//

更多方法实例可以参见：JavaScript String 对象。

方法描述
charAt() 返回指定索引位置的字符
charCodeAt() 返回指定索引位置字符的 Unicode 值
concat() 连接两个或多个字符串，返回连接后的字符串
fromCharCode() 将 Unicode 转换为字符串
indexOf() 返回字符串中检索指定字符第一次出现的位置
lastIndexOf() 返回字符串中检索指定字符最后一次出现的位置
localeCompare() 用本地特定的顺序来比较两个字符串

match() 找到一个或多个正则表达式的匹配

replace() 替换与正则表达式匹配的子串
search() 检索与正则表达式相匹配的值
slice() 提取字符串的片断，并在新的字符串中返回被提取的部分
split() 把字符串分割为子字符串数组
substr() 从起始索引号提取字符串中指定数目的字符
substring() 提取字符串中两个指定的索引号之间的字符
toLocaleLowerCase() 根据主机的语言环境把字符串转换为小写，只有几种语言（如土耳其语）具有地方特有的大小写映射
toLocaleUpperCase() 根据主机的语言环境把字符串转换为大写，只有几种语言（如土耳其语）具有地方特有的大小写映射
toLowerCase() 把字符串转换为小写
toString() 返回字符串对象值
toUpperCase() 把字符串转换为大写
trim() 移除字符串首尾空白
valueOf() 返回某个字符串对象的原始值

array.split() //在数组中删除或删除后再添加元素进行分割就好比在一根长绳子的每个打结处剪开，对数组也是如此。通过分离 字符串 成字串，将字符串对象分割成字符串数组。
reduce() // 计算数组或字符串元素相加后的总和，累加效果
function toCamel(str) {
if(typeof str === ‘string’){
str = str.split(’’)
}
return str.reduce(_doCamel); //相当于去除空格再组合在一个字符串，说白了就是去除字符串中的 ‘’ 空格也可以用正则表达式
//替换这个函数
}

var _item = _text.charAt(j); // charAt() 方法可返回指定 j 位置的字符。
this.items[_index].active = true;
if (info.answer.indexOf(_item) >= 0 ) { //indexOf()方法可返回某个指定的字符串值在字符串中首次出现的位置。

array.splice(start: number, deleteCount?: number) //删除或删除再增加数组中的元素
array.splice(start: number, deleteCount: number, …items: T[])

var fruits = [“Banana”, “Orange”, “Apple”, “Mango”];
fruits.splice(2,1,“Lemon”,“Kiwi”); 从下标为【 2 】的位置开始删除，删除【1】个，从下标为【 2】的位置的添加数组元素 “Lemon”,“Kiwi”
fruits 输出结果：Banana,Orange,Lemon,Kiwi,Mango

//*********************************** 去掉数组中为10的元素，并返回最终的数组 //
arr[10] = [1,5,10,3,4,10,8,2,10,9]
//**** 方法1 //
for(var i =0 ; i < arr.length ; i++){
if(arr[i] = 10){
arr.splice(i,1); 从下标为【 i】的位置开始删除，删除【1】个，从下标为【 2】的位置的添加数组元素
}
}
arr输出结果：1,5,3,4,8,2,9
//***** 方法2 *********************************//
声明一个新的数组 tempArr[];
for(var i =0 ; i < arr.length ; i++){
if(arr[i] != 10){
tempArr.push(arr[i]); 把数组中不是10的元素放到新的数组中
}
}

实例
从第三个位置开始删除数组后的两个元素：

var fruits = [“Banana”, “Orange”, “Apple”, “Mango”];
fruits.splice(2,2); 从下标为【 2】的位置开始删除，删除【2】个元素，返回最终的数组

百度翻译，胶接，粘接，就好比，将绳子从需要的位置剪开，去掉中间坏的部分，再将剩下的两端粘合，或把坏的部分换成新的之后再粘接成完成的绳子，对数组也是如此。通过分离 字符串 成字串从数组中删除元素，并在必要时在其位置插入新元素，返回已删除的元素。。

array.slice()
// 【薄片,部分;份额;锅铲;把…切成(薄)片;切;割;划;】定向抽取一段绳子中的一部分返回数组的一部分从指定头部到指定尾部

array.shift()
//【百度翻译：转移，挪动，切换，】。【类库：返回数组的一部分】。删除数组中的第一个元素，并返回这个数组，相当于删除第一位，把第二位到最后一位挪动，切换到前面的位置。

有关字符串的方法
比较常用的方法
String.prototype.split() 百度翻译，将绳子剪开，去掉中间坏的部分，再将剩下的两端粘合，对数组也是如此。通过分离 字符串 成字串，将字符串对象分割成字符串数组。
String.prototype.substring()返回在字符串中指定两个下标之间的字符。 console.log(anyString.substring(0,3)); 不算上第三个第0到2个
**String.prototype.slice()**摘取一个字符串区域，返回一个新的字符串。
String.prototype.trimStart() 从字符串的左侧去除空格。
String.prototype.trimLeft() 从字符串的左侧去除空格。

String.prototype.trimEnd() 从字符串的右侧去除空格。
String.prototype.trimRight() 从字符串的右侧去除空格。

//**************************** 保证数组地址不变，但是内容实时更新 *************//
// 说白了就是保证保证list地址不变 ,指向这个地址的参数不用手动更新也能自己改变 **************//
想要保持数组的长度不变，就要新声明一个数组_itemList 然后pop掉数组内所有的元素，再把想要的数组mailList内的元素 push进这个新声明的数组_itemList，就可以保持这个新的数组_itemList长度不变，如果只是不
private _itemList: CustomMail[] = []
for (index; index < this._itemList.length;) {
this._itemList.pop()
} //保证list地址不变
件奖励不会触发排序
for (let index = 0; index < mailList.length; index++) {
self._itemList.push(mailList[index])
}
tableView.setCellCreateHandler(function (cellNode: cc.Node, cellBase: MainMailCell) {
cellBase.setInfo(self._itemList) //刷新的时候，不会执行此句，但是_itemList的长度是指向
})
tableView.showWithLength(self._itemList.length)

public setInfo(itemList: CustomMail[]) {
let self = this
this._itemList = itemList
}
///

public setTime(createTime: number): { timeStr: string; language: string } {
    let subTime = ServerTime.instance.formatCreateTime(createTime)
    return subTime
}

public onRefresh(cellIndex) {
    let item = this._itemList[cellIndex]
    this._curCellIndex = cellIndex
    if (item === null || item === undefined) {
        return
    } else {
        this._curMailId = item.id
    }
    let subTime = this.setTime(item.create_time) // item.create_time.toNumber())
    }