牛客网在线编程——javascript_v8语言输入输出总结及常用知识点总结

输入输出

1，输入

• 获取输入的参数，可以用readline()函数，多个输入参数可以通过多次readline()函数进行读取，比如输入：

12
abc

以上两个参数可以通过以下代码读取：

let param1 = readline() // 读取 12
let param2 = readline() // 读取 abc

• 当获取多个可变入参数的时候，比如要输入一个输入的时候，一般第一个入参是告诉你要输入数组元素的个数，比如输入：

3
aa
bb
cc

可以通过以下代码读取：

while(count = readline()) {
	for (var i=0; i<count; i++) {
		// 这样就可以分别读取 aa bb cc，如有需要可以通过这个循环把它们放到数组中
		var word = readline()
	}
}

• 获取的多行参数，但是并没有说明有多少行，可以判断读取的是否为undefined，如果读取的为undefined，说明已经读取了所有入参

while (1) {
    var arr = readline()
    if (arr == undefined) break // 通过break跳出循环
  
    var nums = arr.split(' ')
    var sum = 0
    for (var i=1; i<nums.length; i++) {
        sum += parseInt(nums[i])
    }
    console.log(sum)
}

2，输出

输出有两种方法：print()和console.log()，两种均可

3，结束读取入参

结束读取入参只需要使用break跳出循环即可

while (1) {
    var nums = readline()
    if (nums == '0 0') break // 通过break跳出读取参数的循环
    var numarr = nums.split(' ')
    var a = parseInt(numarr[0])
    var b = parseInt(numarr[1])
    console.log(a + b)
}

字符串处理相关

• 常用的split函数一定要记得，如果分割符为空字符串或被分割的字符串中没有指定的分割符，则返回这个字符串本身，比如：

'a b'.split('') // 'a b'
'a b'.split(',') // 'a b'

• 碰到无视大小写的题目，要会用转大小写的函数toLowerCase和toUpperCase

'aJs4'.toLowerCase() // 'ajs4'
'aJs4'.toUpperCase() // 'AJS4'

• 关于字符串遍历，乖乖用for吧，不要对字符串使用forEach，否则会报错
• 常用的字符串截取函数要信手拈来，三个：slice(start, end)，substring(start, end)，substr(start,length)，其中slice跟substring效果一样，包含start，但是不包含end，slice还可以用于数组，见如下示例代码：

[1,2,3,4].slice(1, 3) // [2,3]
'abcd'.slice(0, 3) // 'abc'
'abcd'.substring(0, 3) // 'abc'
'abcdefgh'.substr(2, 3) // 'cde'

• 字符串中查找某个字符或者字符串，可以用indexOf函数，该函数同样可以作用于数组，如果没有找到，则返回-1

'abcd'.indexOf('k') // -1
'abcd'.indexOf('bc') // 1
[1,2,3,4].indexOf(3) // 2

• 数字转字符串，这个比较简单，可用 加上空字符串和toString()函数，用toString()函数的使用，一定要使用括号将数字括起来；另外toString()还有转进制的作用，可将将10进制的数字转成指定的进制的字符串

2.toString() // 报错
(2).toString() // '2'
(2.3).toString() // '2.3'

(20.3).toString(16) // '14.4ccccccccccd'
(31).toString(16) // '1f'
'w'.toString(16) // 'w'

'' + 2 // '2'
'' + 2.3 // '2.3'

• 字符串转数字就比较复杂，可以用两个函数parseInt()和parseFloat()，parseInt可以传两个参数，第二个参数为可选，不传的话一般默认为10，代表进制，将指定进制的字符串转成10进制的数字

parseInt('we') // NaN
// 从第一个数字字符串开始识别
parseInt('2we') // 2
// 这个有点特殊，碰到'0x'开头的数字会默认当成16进制的数字转换
parseInt('0xa') // 10
parseInt('21', 8) // 17
parseInt('21', 9) // 19

parseFloat('kkm') // NaN
parseFloat('3.4') // 3.4
// parseFloat无法进行进制转换
parseFloat('12.4c', 16) // 12.4
parseFloat('12.44.33') // 12.44

• 字符和ASCII码的互相转换

var str = "A";
str.charCodeAt();  // 65
var str1 = 'abc';
str1.charCodeAt(1);  // 98

String.formCharCode(97);  // 'a'
String.fromCharCode(100);  // 'd'

几个常见的特殊ACSII码值：换行（10），回车（13），空格（32）

• 字符串转数组，可以利用split()函数将字符串转成字符的数组

'ab3d'.split('') // ['a', 'b', '3', 'd']

• 关于字符串的排序问题，字符串的Paiute是根据ACSII码的大小尽心排序的，如果比较的字符串的长度大于1，则会顺位一个一个比较，直到比较出结果为止，如果完全一样则返回相等

'abc' > 'abb' // true
'abc' > 'ab' // true
// 所有大写字母的ASCII码都比小写字母小
'a' > 'C' // true
'6' > '5' // true

数字处理相关

• 浮点数数保留小数位的处理方法，可以用toFixed()实现，通过四舍五入实现，不传值的话默认四舍五入保留整数；需要注意的是，该函数返回的值是字符串

2.34.toFixed() // '2'
2.54.toFixed() // '3'
2.5455.toFixed(1) // '2.5'
// 控制精度向下取
Math.floor(15.7784514000 * 100)/100 //15.77

• 浮点数进行取整的方法

// 丢弃小数部分，取整数部分，相当于下取整，Math.floor();
parseInt(2.34) // 2
// 向上取整，小数只要存在，就整数部分+1
Math.ceil(0.3) // 1
// 四舍五入取整
Math.round(2.53) // 3
// 向下取整，小数直接去掉，小数部分无论多大，整数部分都不+1
Math.floor(2.89)  // 2

对象处理相关

• 对象的遍历

var obj = {
	a: 1,
	b: 3,
	d: 5
}
for (let key in obj) {
	console.log(key + '---' + obj[key])
}

数组处理相关

• 数组指定位置删除元素

splice 语法
arrayObject.splice(index,howmany,item1,…,itemX)

入参

参数	描述
index	必需。整数，规定添加/删除项目的位置，使用负数可从数组结尾处规定位置。
howmany	必需。要删除的项目数量。如果设置为 0，则不会删除项目。
item1, …, itemX	可选。向数组添加的新项目。

出参

类型	描述
Array	包含被删除项目的新数组，如果有的话。

注意：
splice() 方法会直接对数组进行修改。

[2,3,4,2].splice(1, 2) // 删除后数组变为[2,2]

• 数组指定位置增加元素

[2,3,4,5].splice(2, 0, 'a') // 增加后的数组为 [2,3,'a',4,5]

• 数据内的元素合并，数组转字符串

let a = [1,2,4,'a','d']
a.join('') // '124ad'
a.join(',') // '1,2,4,a,d'

• 数组元素转向

let a = [1,2,4,'a','d']
a.reverse() // [ 'd', 'a', 4, 2, 1 ]

• 数组的累加或者累乘，reduce函数的使用

语法
array.reduce(function(total, currentValue, currentIndex, arr), initialValue)

参数	描述
total	必需。初始值, 或者上一次计算结束后的返回值。
currentValue	必需。当前处理元素
currentIndex	可选。当前元素的索引
arr	可选。当前元素所属的数组对象
initialValue	可选。传递给函数的初始值

// 求一个数组的和
var arr = [1,2,3,4]
var sum = arr.reduce(function(a,b){
	return a+b
})
console.log(sum) // 10

循环相关

• 嵌套循环中使用自定义标签跳出指定循环，比如下面的嵌套循环就不会打印大于4的数字，因为内部循环一到5就跳到外层循环了（start为自定义的字符串，代表冒号后的循环）

start:
for (var m=0; m<2; m++) {
	for (var n=0; n<10; n++) {
		if (n === 5) {
			continue start
		}
		console.log(n)
	}
}

算法相关

• 冒泡排序

function range(colArr) {
    for (let m=0; m<colArr.length; m++) {
        for (let n=0; n<colArr.length-1-m; n++) {
            if (colArr[n+1] < colArr[n]) {
                let temp = colArr[n]
                colArr[n] = colArr[n+1]
                colArr[n+1] = temp
            }
        }
    }
}

• 求所有质因子

function colZhizi(num) {
	let colNum = parseInt(num)
	let arr = []
	for (let i=2; i<=Math.sqrt(colNum); i++) {
		while (colNum%i === 0) {
			arr.push(i)
			colNum = colNum / i
		}
	}
	if (colNum > 1) arr.push(colNum) 
	return arr
}

• 去重函数

function delRe(arr) {
	let reArr = []
	for (let m=0; m<arr.length; m++) {
		if(reArr.indexOf(arr[m]) < 0) reArr.push(arr[m])
	}
	return reArr
}

• 去重加排序

function delReAndRange(arr) {
	let reArr = []
	bbq:
	for (let m=0; m<arr.length; m++) {
		for (let n=0; n<reArr.length; n++) {
			if (reArr[n] > arr[m]) {
				reArr.splice(n, 0, arr[m])
				continue bbq
			}else if (reArr[n] === arr[m]) {
				continue bbq
			}
			
		}
		reArr.push(arr[m])
	}
	return reArr
}

• 数组的妙用 —— 去重和排序：根据数组的特性，index值是从小到大的，并且唯一，可以利用来进行去重和排序；不过这个方法有限制，处理的数据必须都是大于或等于0的数，且处理的数据中最大的数不宜过大。见下面一个例子：

// 对下面一组数进行去重和排序（从小到大）
var nums = [3,4,6,7,4,3,6,7,9,9,0,5,4,2,1,11,2,45,29]

let ret = []
for (let i=0; i<nums.length; i++) {
	ret[nums[i]] = 1
}

let arr = []
for (let i=0; i<ret.length; i++) {
	if (ret[i] === 1) arr.push(i)
}
console.log(arr) // [ 0, 1, 2, 3, 4, 5, 6, 7, 9, 11, 29, 45 ]

• 反转算法

function reverseStr(str) {
    str = str.split('').reverse().join('')
    return str;
}