arr | 易学教程

js字节流与字符串、base64、ArrayBuffer和数组的转换

阅读更多关于 js字节流与字符串、base64、ArrayBuffer和数组的转换

1、uint8Array转string function uint8ArrayToString(fileData){ var dataString = ""; for (var i = 0; i < fileData.length; i++) { dataString += String.fromCharCode(fileData[i]); } return dataString } var arr = [48,48,48,48] uint8ArrayToString(arr) //"0000" 2、string装uint8Array function stringToUint8Array(str){ var arr = []; for (var i = 0, j = str.length; i < j; ++i) { arr.push(str.charCodeAt(i)); } var tmpUint8Array = new Uint8Array(arr); return tmpUint8Array } stringToUint8Array('12313132') // Uint8Array(8) [49, 50, 51, 49, 51, 49, 51, 50] 3、 int转byte[] function intTobytes(n) { var bytes = []; for

扩展运算与解构赋值

阅读更多关于扩展运算与解构赋值

扩展运算 //对象扩展 args = {...obj,...obj} //数组扩展 args = [...arr,...arr] //函数赋值 function f(...values){ console.log(values.length); } f(1,2); //2 f(1,2,3,4); //4 // || function f(x, y, z) {} f(...[arr]) //去重 [...new Set(arr)]; // [1, 2, 3, 4] [...new Set('ababbc')].join(''); // "abc" 字符串去重函数 function f(...values){ console.log(values.length); const [a, b, c] = values } f(1,2); //2 f(1,2,3,4); //4 //不定参数用来表示不确定参数个数，具名参数只能放在参数组的最后，并且有且只有一个不定参数。 function addNumbers(x,y,z){ return x+y+z; } var numbers = [1,2,3,4]; addNumbers(...numbers); //6 //函数调用中，扩展运算符（...）将一个数组，变为参数序列解构赋值 //数组解构 var arr = [2, 'this is

js数组遍历和对象遍历

阅读更多关于 js数组遍历和对象遍历

js数组遍历和对象遍历针对js各种遍历作一个总结分析，从类型用处：分数组遍历和对象遍历；还有性能，优缺点等。 JS数组遍历： 1，普通for循环，经常用的数组遍历 var arr = [1,2,0,3,9]; for ( var i = 0; i <arr.length; i++){ console.log(arr[i]); } 2，优化版for循环:使用变量，将长度缓存起来，避免重复获取长度，数组很大时优化效果明显 for(var j = 0,len = arr.length; j < len; j++){ console.log(arr[j]); } 3，forEach，ES5推出的,数组自带的循环，主要功能是遍历数组，实际性能比for还弱 arr.forEach(function(value,i){ 　　console.log('forEach遍历:'+i+'--'+value); }) forEach这种方法也有一个小缺陷：你不能使用 break 语句中断循环，也不能使用 return 语句返回到外层函数。 4,map遍历，map即是 “映射”的意思用法与 forEach 相似 arr.map(function(value,index){ console.log('map遍历:'+index+'--'+value); }); map遍历支持使用return语句

js--冒泡排序

阅读更多关于 js--冒泡排序

javascript-数据类型

阅读更多关于 javascript-数据类型

#数组/字符串基础操作 [] '' new regexp() ##数组 var arr=[] 创建数组元素不限 arr.length 返回数组长度 arr.push(data) 末尾添加元素,返回数组长度 arr.pop() 移除末尾元素,返回被移除元素 arr.unshift(data) 开头添加元素,返回数组长度 arr.shift() 移除开头元素,返回被移除元素 arr.splice(index,number) 移除number个元素,从index开始,返回被移除 arr.toString() 转换成字符串,并返回字符串 arr.join('*') 元素以*为间隔,转换成字符串,并返回字符串,默认',' arr.reverse()数组反转 arr.sort(function(x,y){return x-y}) 升序排序,y-x倒叙,默认是字符编码排序 ##字符串 var str='abcEDF123' str.length 返回长度 str.toUpperCase() 转大写 str.toLowerCase() 转小写 str.charAt(index) 索引查字符str[index] str.charCodeAt(index)索引查字符的编码 str.indexOf(s,index) 字符查第一个索引位置 str.subString(startindex

Go 日志

阅读更多关于 Go 日志

golang 的log包使用起来挺简单，这里做一些简单介绍。示例： package main import ( "log" ) func main() { arr := []int{1, 2} log.Print("Print array ", arr, "\n") log.Println("Println array", arr) log.Printf("Printf array with item [%d,%d]\n", arr[0], arr[1]) } 结果： 2018/12/14 18:42:02 Print array [1 2] 2018/12/14 18:42:02 Println array [1 2] 2018/12/14 18:42:02 Printf array with item [1,2] log.Fatal 、log.Fatalln、log.Fatalf 示例： log.Fatal("Fatal array ", arr, "\n") log.Fatalln("Fatalln array", arr) log.Fatalf("Fatalf array with item [%d,%d]\n", arr[0], arr[1]) 对于 log.Fatal 接口，会先将日志内容打印到标准输出，接着调用系统的 os.exit(1) 接口退出程序并返回状态 1

算法 - 快速排序 - 经典快排 | 随机快排

阅读更多关于算法 - 快速排序 - 经典快排 | 随机快排

经典快排经典快排的思路是选取数组的最后一个数 x，按照问题一的思路把整个数组划分成小于等于 x | 大于 x 两个部分，将 x 和大于 x 部分数组的第一个元素交换位置。此时整个数组划分成小于等于 x | x | 大于 x 三个部分，也就是这一次排序将 x 值排好位置。再分别对小于等于 x 和大于 x 中的数组递归划分，直到划分成一个数，此时所有元素也完成排序。按照问题二的思路可以对经典快排做改进，使得每次划分数组成为小于 x | 等于 x | 大于 x 三个部分，通过这种排序方式可以一次划分多个 x 值的位置，排序效率得到提高。但是，经典快排出现问题与数据状况有关。每次选择 x 值都是数组的最后一个数，如果遇到 [1,2,3,4,5] 或者 [5,4,3,2,1] 这种数组，算法时间复杂度将变成 O(n^2)。随机快排随机快排是经典快排的一种改进，通过生成随机下标 i，选择 a[i] 和最后一个数 x 进行交换，再使用经典快排。此时的事件就是一个概率事件，需要使用期望来估计算法的时间复杂度。仍以 [1,2,3,4,5] 为例，经过随机快排初始变换，可以形成下列五种情况，数据状况的影响有效降低。在长期期望下，随机快排算法的时间复杂度为 O(N*logN)。由于每次划分数据都需要记录 =x 数组的下标范围，因此额外的空间复杂度为 O(logN)。

Math.floor(Math.random() * array.length)

阅读更多关于 Math.floor(Math.random() * array.length)

Math.floor(Math.random() * array.length) 返回长度内的索引 eg: changeLimit () { 　　function getArrayItems(arr, num) { 　　　　const temp_array = []; 　　　　for(let index in arr) { 　　　　　　temp_array.push(arr[index]); 　　　　} 　　　　const return_array = []; 　　　　for (let i = 0; i<num; i++) { 　　　　　　if(temp_array.length>0) { 　　　　　　　　const arrIndex = Math.floor(Math.random()*temp_array.length); 　　　　　　　　return_array[i] = temp_array[arrIndex]; 　　　　　　　　temp_array.splice(arrIndex, 1); 　　　　　　} else { 　　　　　　　　break; 　　　　　　} 　　　　} 　　　　return return_array; 　　} 　　this.randomMovieList = getArrayItems(this.movieList, 5); } 来源： https

java排序 -- 堆排序

阅读更多关于 java排序 -- 堆排序

堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆；每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。堆排序的基本思想是：将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。一般升序采用大顶堆，降序采用小顶堆。核心代码：　 public static void heapSort ( int [] arr) { //初始化调整堆 for ( int i = arr.length / 2 ; i >= 0 ; i--) { adjustHeap(arr,i,arr.length); } for ( int i = arr.length- 1 ; i > 0 ; i--) { swap(arr, 0 ,i); adjustHeap(arr, 0 ,i); } } /** * 调整堆 * @param arr * @param parent * @param length 未排序的序列长度 */ private static void adjustHeap ( int [] arr, int parent, int length) { int temp = arr

java-数据结构-大顶堆和小顶堆

阅读更多关于 java-数据结构-大顶堆和小顶堆

java-数据结构-大顶堆和小顶堆概念 1)堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为O(nlogn)，它也是不稳定排序。 2)堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆, 注意 : 没有要求结点的左孩子的值和右孩子的值的大小关系。 3)每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆大顶堆举例说明大顶堆特点： arr[i] >= arr[2*i+1] && arr[i] >= arr[2*i+2] // i 对应第几个节点，i从0开始编号小顶堆举例说明小顶堆： arr[i] <= arr[2*i+1] && arr[i] <= arr[2*i+2] // i 对应第几个节点，i从0开始编号一般升序采用大顶堆，降序采用小顶堆堆排序基本思想堆排序的基本思想是： 1)将待排序序列构造成一个大顶堆 2)此时，整个序列的最大值就是堆顶的根节点。 3)将其与末尾元素进行交换，此时末尾就为最大值。 4)然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。 package com . tree ; import java . text . SimpleDateFormat ; import java . util .

订阅 arr