0%

javascript-data_tructures_and_algorithms

data tructures and algorithms for JavaScript

arithmetic operation

精度问题:

1
2
console.log(3+1.1)	//输出4.1
console.log(3*1.1) //输出3.3000000000000003

如果计算精度不必像上面那样精确,可以格式化为固定精度:

1
print((3*1.1).toFixed(2))	//显示3.30

OOP (object-oriented programming)

构建一个检查银行账户对象的构造函数

1
2
3
4
5
6
function Checking(amount) {
this.balance = balance; //属性
this.deposit = deposite; //方法
this.withdraw = withdraw; //方法
this.toString = toString; //方法
}

this关键字用来将方法和属性绑定到一个对象的实例上

1
2
3
4
5
6
7
8
9
10
11
12
13
14
function deposit(amount) {
this.balance += amount;
}
function withdraw(amount) {
if(this.balance<amount){
print("Insufficient funds")
}else{
this.balance -= amount;
}

}
function toString() {
return "Balance:"+ this.balance
}

方法的互相引用

1
2
3
const bank = new Checking(500);
bank.deposit(100);
bank.withdraw(400);

Array

调用方法:

1
2
3
let arr = [];
let arr1 = new Array();
let arr2 = new Array(10); //定义长度

字符串生成数组

split()

1
2
let str = "A is a cat";
let arr = str.split(""); //根据空格分隔产生数组

浅复制深复制

1
2
3
4
let arr1 = [1,2,3,4,5];
var arr2 = arr1;
arr[0] = 100;
console.log(arr2[0]); //输出100

这种行为就叫做浅复制,新数组依然指向原来的数组,如果需要改变新数组的值,则需要使用深复制的方案

1
2
3
4
5
function cp(arr1,arr2){
arr1.foreach((item,index)=>{
arr2[index] = item;
})
}

这种叫做深复制,将旧数组每一项的元素赋值到新数组上

Access function

查找元素:

indexOf()

1
2
3
let arr = ["a","b","c","d"];
let position = arr.indexOf("b"); //position为1
let position1 = arr.indexOf("v"); //position1位NAN

如果数组中包含多个相同的元素,用indexOf()返回数组第一个值的索引

lastIndexOf()

1
2
let arr = ["a","b","b","c"];
let position = arr.lastIndexOf("b"); //position为2

如果数组中包含多个相同的元素,用indexOf()返回数组最后一个值的索引

数组的字符串表示:

join(),toString()

1
2
3
4
5
let name = ["jack","pack","john"];
let namestr = name.join();
let namestr1 = name.toString();
console.log(namestr) //输出jack,pack,john
console.log(namestr1) //输出jack,pack,john

这两个方法都返回一个包含数组所有元素的字符串,各元素之间用逗号分隔开。

实际上,当直接对一个数组使用print()函数时,系统会自动调用哪个数组的toString()方法。

由已知数组创建新数组:

concat():

1
2
3
4
let arr = [1,2,3,4];
let arr2 = [5,6,7,8];
let newarr = arr.concat(arr2);
print(newarr); //输出1,2,3,4,5,6,7,8

Array.concat(Array),作为参数的数组拼接在发起者的数组上

splice():

1
2
3
4
let arr = ["a","b","c","d"];
let resultarr = arr.splice(1,2);
console.log(resultarr) //打印出[b,c]
console.log(arr) //打印出[a,d]

该方法第一个参数是截取的起始索引,第二个参数是截取的长度。

splice方法还可以用于增加或移除元素

增加元素:

1
2
let nums = [1,2,3,7,8,9];
nums.splice(3,0,4,5,6); //第三个参数开始为增添的元素

删除元素:

1
2
3
let nums = [1,2,3,100,200,300,400,4,5];
nums.splice(3,4);
console.log(numes); //打印出1,2,3,4,5

The variable element:

添加元素:

push() 从数组后面添加

unshift() 从数组头添加

删除元素:

pop() 从数组后面删除

shift() 从数组头删除

本质上就是栈的操作

数组排序:

reverse() 翻转数组元素顺序

sort()

1
2
3
let names = ["David","Mike","Cynthia","Clayton","Bryan","Raymond"];
names.sort();
print(names); //Bryan,Clayton,Cynthia,David,Mike,Raymond

sort()方法是按照字典顺序对元素进行排序的,因此它假定元素都是字符串类型。即使是Number类型也会转换成字符串类型在进行排序。对于数字的排序,会发生非常不友好的结果。

1
2
3
let arr = [1,3,2,11,6,100,21];
arr.sort();
print(arr); //1,100,11,2,21,3,6

就像上面一样,是按照字符串的字典顺序进行排序的,解决方法是通过sort传入一个大小比较函数解决排序问题

1
2
3
4
5
6
function compare(num1,num2)	{
return num1-num2
}
let nums = [3,1,2,100,4,200];
nums.sort(compare); //传入compare函数
print(nums); //1,2,3,4,100,200

Lterator method

这些方法对数组中的每个元素应用一个函数,可以返回一个值、一组值或者一个新数组。

不生成新数组的迭代器方法:

forEach():

该方法接受一个函数作为参数,对数组中的每个元素使用该函数。

欢迎关注我的其它发布渠道