冒泡排序法：
学习一个算法，首先要了解他的原理：
所谓的冒泡法，就像水中的气泡一样，越往上气泡越大，同理，数组中的数值从左到右越往右越大。这就需要用到判断，如果左边的比紧挨着他的右边的数值大，则让他们两个交换，实现从小到大排列，思路合理开始执行！
<script>
var arr1 = [23, 32, 123, 3, 4,];
for (var j = 0; j <= arr1.length - 1 ; j++) {
for (var i = 0; i <= arr1.length - 1 ; i++) {
var middle = 0;
if (arr1[i] > arr1[i + 1]) {
middle = arr1[i];
arr1[i] = arr1[i + 1];
arr1[i + 1] = middle;
}
}
}
console.log(arr1);
</script>
数组去重法
// 实现思路：新建一个数组，遍历要去重的数组，
// 当值不在新数组的时候（indexOf 为 -1）就加入该新数组中；
function unique(arr){
var newArr = [];
for(var i = 0; i < arr.length; i++){
if(newArr.indexOf(arr[i]) == -1){
newArr.push(arr[i])
}
}
return newArr;
}
var arr = [1,2,2,3,4,4,5,1,3];
var newArr = unique(arr);
console.log(newArr);
=============一条完美的分割线=============
function unique(arr){
// Set数据结构，它类似于数组，其成员的值都是唯一的
return Array.from(new Set(arr));
// 利用Array.from将Set结构转换成数组
}
var arr = [1,2,2,3,5,3,6,5];
var res = unique(arr)
console.log(res );
数组扁平化
const res = [1,2,[3,4,[5,6]]]
// flat()方法
// 参数:指定要提取嵌套数组的结构深度，默认值为1。
const item = res.flat(2);
// 递归方法
const arr = [ ] // 注意定义arr的时候要放在外面
const sum = ary=>{
for(let i=0;i<ary.length;i++){
if(Array.isArray(ary[i])){
sum(ary[i])
}else{
arr.push(ary[i])
}
}
return arr
}
斐波那契数列
funxtion fibonacci(n){
if(n<=1) return 1;
let i = n+1-2;
let arr = [1,1];
while(i>0){
let a = arr[arr.length-2],
b = arr[arr.length-1];
arr.push(a+b);
i--;
}
return arr[arr.length-1]
}
==============
function cci(conent){
function fn(conent,curr=1,next=1){
if(conent == 0){
return curr
}else{
return fn(conent-1,next,curr+next)
}
}
return fn(conent)
}
有效括号
给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。 注意空字符串可被认为是有效字符串。
示例:
输入: "()"
输出: true
// 方法一
/**
* @param {string} s
* @return {boolean}
*/
const isValid = (s) => {
while(true) {
let len = s.length
// 将字符串按照匹配对，挨个替换为''
s = s.replace('{}', '').replace('[]', '').replace('()', '')
// 有两种情况s.length会等于len
// 1. s匹配完了，变成了空字符串
// 2. s无法继续匹配，导致其长度和一开始的len一样，比如({],一开始len是3，匹配完还是3，说明不用继续匹配了，结果就是false
if (s.length === len) {
return len === 0
}
}
}
// 方法二
/**
* @param {string} s
* @return {boolean}
*/
var isValid = function(s) {
let stack = [];
for(let i = 0; i < s.length; i++) {
let ch = s.charAt(i);
if(ch == '(' || ch == '[' || ch == '{')
stack.push(ch);
if(!stack.length) return false;
if(ch == ')' && stack.pop() !== '(') return false;
if(ch == ']' && stack.pop() !== '[' ) return false;
if(ch == '}' && stack.pop() !== '{') return false;
}
return stack.length === 0;
};
思考题
// 题目描述：下面代码中 a 在什么情况下会打印 1？
var a = ?
if(a==1 && a==2 && a==3){
console.log(1);
}
// 答案一
var a = {
i:0,
toString:function(){
return a.i++;
}
}
// 解释：
// 如果原始类型和对象比较，对象会转为原始类型的值在进行比较。
// 对象转换为原始类型的值，先调用对象的 valueOf 方法，
// 如果返回的还是对象，再接着调用 toString 方法
// 答案二
var a = [1,2,3]
a.join = a.shift;
// 解释：
// 比较巧妙的方式，array也是对象，
// 对于数组对象，toString 方法返回一个字符串，该字符串由数组中的 每个元素的
// toString() 方法返回值，再经过调用 join() 方法连接（由逗号隔开）组成。
// 数组 toString 方法会调用本身的 join() 方法，这里把自己的 join() 方法
// 改写为 shift() 方法，每次返回第一个元素，而且每次数组删除第一个值,正好可以使判断成立。
// 答案三
var val = 0;
Object.defineProperty(window,'a',{
get:function(){
return ++val;
}
})
// 解释：
// 全局变量也相当于 window 上定义的一个属性，这里用 defineProperty
// 定义了 a 和 get 也使其动态返回值，
评论区