data tructures and algorithms for JavaScript

arithmetic operation

精度问题：

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

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

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

OOP (object-oriented programming)

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

function Checking(amount) {
  this.balance = balance;	//属性
  this.deposit = deposite; //方法
  this.withdraw = withdraw; //方法
  this.toString = toString; //方法
}

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

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
}

方法的互相引用

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

Array

调用方法：

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

字符串生成数组：

split()

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

浅复制和深复制：

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

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

function cp(arr1,arr2){
  arr1.foreach((item,index)=>{
    arr2[index] = item;
  })
}

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

Access function

查找元素：

indexOf()

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

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

lastIndexOf()

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

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

数组的字符串表示：

join(),toString()

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():

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():

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

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

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

增加元素：

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

删除元素：

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()

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

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

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

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

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():

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