var obj = {

    k:v,

    k:v,

    k:v,

};

/* 

现实生活中:万物皆对象 对象是一个具体事物 看得见摸得着的实物



对象是一组无序的相关属性和方法的集合 所有事物的是对象



对象是由属性和方法组成的

属性：事物的特征 在对象中用属性来表示(常用名词)

方法：事物的行为 在对象中用方法来表示(常用动词)



对象的字面量:就是花括号{} 里面包含了表达这个具体实物(对象)的属性和方法

*/

//创建一个空的对象

var obj = {

uname:'张三',

age:'男',

sayHi: function () {

    console.log('Hi!');

    console.log(this.uname + "向你说您好");

}

}

// 1.我们在创建对象时我们采用键值对的形式 键 属性名 : 属性 属性值

// 2.多个属性或者方法中间用逗号隔开

// 3.方法冒号后面跟的是一个匿名函数



// 使用对象

// 1)调用对象的属性 我们采取 对象名.属性名

console.log(obj.uname);

// 2)调用对象也可以 对象名['属性名']

console.log(obj['age']);

// 3)调用对象的方法 对象.方法名

obj.sayHi();

obj.age = 19;

obj.height = 180;

delete obj.sex;

// 利用new object 创建对象

var obj = new Object();//创建了一个空对象

obj.name = '张三';

obj.age = 18;

obj.sex = '男';

obj.sayHi = function() {

    console.log('Hi~');

}

//1.我们是利用等号赋值的方法给对象 属性和方法 赋值

//2.每个 属性和方法 用分号结束



// 调用

console.log(obj.name);

console.log(obj['sex']);

obj.sayHi();

// 我们为什么需要使用函数

// 就是因我们前面两种创建对象的方式一次只能创建一次对象

var ldh = {

    uname: '刘德华',

    age: 55,

    sing = function() {

        console.log('冰雨');

    }

}

var zxy = {

    uname: '张学友',

    age: 58,

    sing = function() {

        console.log('李香兰');

    }

}

// 因为我们一次创建一个对象 里面有很多的属性和方法是大量相同的 我们只能复制

// 因此我们可以利用函数的方法 重复这些相同的代码 

// 又因为这个函数不一样 里面封装的不是普通代码 而是对象

// 函数 可以把我们对象里面一些相同的属性和方法抽象出来封装到函数里面

function createStar(uname, age, sex) {

    //创建一个空对象

    var Star = new Object();

    //添加属性和方法，属性可以接受参数的值

    Star.name = uname;

    Star.age = age;

    Star.sex = sex;



    Star.sing = function(sang) {

        console.log(sang);

    }

    //将对象做为函数的返回值

    return Star;

}



var p1 = createStar("张三",18,"男");

// 利用构造函数创建对象

// 我们需要创建四大天王的对象 相同的属性： 名字 年龄 性别 相同的方法 ： 唱歌

// 构造函数的语法格式

/*

function 构造函数名() {

    this.属性 = 值;

    this.方法 = fucntion() {}

}

// 调用构造函数

new 构造函数名();

*/



function Star(uname, age, sex) {

    this.name = uname;

    this.age = age;

    this.sex = sex;



    this.sing = function(sang) {

        console.log(sang);

    }

}

var ldh = new Star('刘德华', 18, '男');

console.log(typeof ldh);//object

console.log(ldh.name);

console.log(ldh.age);

console.log(ldh.sex);

ldh.sing('冰雨');

// 1.构造函数首字母必须大写

// 2.构造函数不需要return就能返回结果

// 3.调用函数返回的是一个对象

var zxy = new Star('张学友', 29, '男')

console.log(zxy);

// 4.我们调用构造函数必须使用new

//循环遍历输出每一项

for(var k in obj){

    console.log(k + "项的属性值" + obj[k]);

}

//遍历对象

var obj = {

    uname: '王二狗',

    age: 18,

    sex: '男'

}

console.log(obj.uname);

console.log(obj.age);

console.log(obj.sex);

//但是一个一个输出很累



// 因此我们引出 for...in...语句 --用于对数组或者对象的属性进行循环操作



/*

基本格式：

for (变量 in 对象) {



}



*/

for (k in obj) {

    console.log(k); //k变量输出 得到的是属性名

    console.log(obj[k]); //obj[k] 输出对象各属性的属性值 切记不要用obj.k 那样就变成输出 k 属性名的属性值了 ---!!!:k是变量不加''

}

var a = 5;

var b = a; //将 a 内部存储的数据 5 复制了一份

a = 10;

console.log(a);

console.log(b);

// 因此 a 和 b 发生改变，都不会互相影响

// 复杂数据类型

var p1 = {

    name: "zs",

    age: 18,

    sex: "male"

}

var p = p1; //p1 将内部存储的指向对象原型的地址复制给了 p

// 两个变量之间是一个联动的关系，一个变化，会引起另一个变化

p.name = "ls";

console.log(p);

console.log(p1);



// 数组和函数存储在变量中时，也是存储的地址

var arr = [1,2,3,4];

var arr2 =arr;

arr[4] = 5;

console.log(arr);

console.log(arr2);

// Math数学对象 不是一个构造函数 所以我们不需要用new来调用 而是直接使用里面的属性和方法即可

console.log(Math.PI); //一个属性值 圆周率

console.log(Math.max(99, 199, 299)); //299

console.log(Math.max(-10, -20, -30)); //-10

console.log(Math.max(-10, -20, '加个字符串')); //NaN

console.log(Math.max()); //-Infinity

console.log(Math.min(99, 199, 299)); //99

console.log(Math.min()); //Infinity

// 字面量方法

// var arr = [1,2,3];



// 数组也是对象，可以通过构造函数生存

//空数组

var arr = new Array();

//添加数据，可以传参数

var arr2 = new Array(1,2,3);

var arr3 = new Array("zs","ls","ww");

console.log(arr);

console.log(arr2);

console.log(arr3);



// 检测数组的数据类型

console.log(typeof(arr));//object

console.log(typeof(arr2));//object

console.log(typeof(arr3));//object

var arr = [1,2,3];

var arr1 = new Array(1,2,3)

var a = {};

// 检测某个实例对象是否属于某个对象类型

console.log(arr instanceof Array);//true

console.log(arr1 instanceof Array);//true

console.log(a instanceof Array);//true



function fun () {

    console.log(1);

}

console.log(fun instanceof Function);//true

// 字面量方法

var arr = [1,2,3,4];



// toString() 方法：可以转字符串

console.log(arr.toString());//1,2,3,4

// 字面量方法

var arr = [1,2,3,4];



// 首尾操作方法

// 尾推,参数是随意的，有一个或者多个

console.log(arr.push(5,6,7,8)); //8(数组长度)

console.log(arr);//[1,2,3,4,5,6,7,8]

console.log(arr.push([5,6,7,8])); //5(数组长度)

console.log(arr);//[1,2,3,4,Array(4)]

// 字面量方法

var arr = [1,2,3,4];



//尾删，删除最后一项数据

// 不需要传参

console.log(arr.pop());//4(被删除的那一项数据)

console.log(arr);//[1,2,3]

// 字面量方法

var arr = [1,2,3,4];



// 首删，删除第一项数据，不需要传参

console.log(arr.shift());//1

console.log(arr);//[2,3,4]

// 字面量方法

var arr = [1,2,3,4];



// 首添，参数与 push 方法类似

console.log(arr.unshift(-1,0));//6

console.log(arr);//[-1,0,1,2,3,4]

// 字面量方法

var arr = [1,2,3,4];



// 将数组的第一项移动到最后一项

// 删除第一项

// 将删除的项到最后一项

arr.push(arr.shift());

console.log(arr);//[2,3,4,1]

arr.push(arr.shift());

console.log(arr);//[3,4,1,2]

arr.push(arr.shift());

console.log(arr);//[4,1,2,3]

arr.push(arr.shift());

console.log(arr);//[1,2,3,4]

// 字面量方法

var arr = [1,2,3,4];

// 合并方法

// 参数:数组 数组的变量 零散的值

// 返回值:一个新的拼接后的数组

var arr1 = arr.concat([5,6,7]);

console.log(arr);//[1,2,3,4]

console.log(arr1);//[1,2,3,4,5,6,7]

// 字面量方法

var arr = [1,2,3,4,5,6,7,8,9,10];



// 拆分方法

// 参数为正

var arr1 = arr.slice(3,7);//[4,5,6,7] 

// 参数为负数

var arr1 = arr.slice(-7,-1);//[5,6,7,8,9] 

// 参数出现问题的情况

var arr1 = arr.slice(-1,-7);//[] 取不到会出现空值

// 只书写一个参数

var arr1 = arr.slice(-7);//[4,5,6,7,8,9,10] 从倒数第七个开始取

var arr1 = arr.slice(8);//[9,10] 从下标为8的数开始取

// 字面量方法

var arr = [1,2,3,4,5,6,7,8,9,10];



// 拆分方法

// 参数为正

var arr1 = arr.slice(3,7);//[4,5,6,7]

// 参数为负数

var arr1 = arr.slice(-7,-1);//[5,6,7,8,9]

// 参数出现问题的情况

var arr1 = arr.slice(-1,-7);//[] 取不到会出现空值

// 只书写一个参数

var arr1 = arr.slice(-7);//[4,5,6,7,8,9,10] 从倒数第七个开始取

var arr1 = arr.slice(8);//[9,10] 从下标为8的数开始取

// 字面量方法

var arr = [1,2,3,4,5,6,7,8,9,10,4,5];



// 查找某个元素在数组中从前往后第一次 出现位置的下标

console.log(arr.indexOf(4));//3 (数字4的下标)

// 查找某个元素在数组中从前往后最后一次出现位置的下标

console.log(arr.lastIndexOf(4));//10

console.log(arr.lastIndexOf(11));//-1 (代表数组中不存在11这个数据)

// 字面量方法

var arr = [1,2,3,4,5,6,7,8,9,10];



// 数组倒序

console.log(arr.reverse());//[10,9,8,7,6,5,4,3,2,1]

// 字面量方法

var arr = [1,2,3,4,5,6,7,8,9,10,20,30];

// 排序,默认按照字符编码顺序来排序

arr.sort();

console.log(arr);//[1,10,2,20,3,30,4,5,6,7,8,9] (如果不添加函数)



// 添加一个比较函数

arr.sort(function(a,b) {

    if (a > b) {

        return -1;//表示 a 要排在 b 前面

    } else if (a < b) {

        return 1;//表示 a 要排在 b后面

    } else {

        return 0;;//表示 a 和 b 保持原样,不换位置

    }

});

console.log(arr);//[30,20,10,9,8,7,6,5,4,3,2,1] (添加函数之后)

// 想要从小到大排序只要将函数 大于小于 号,反向即可

var arr = [1,2,3,4,5,6,7,8,9,10,20,30];



// 转字符串方法

var str = arr.join();

console.log(str);//1,2,3,4,5,6,7,8,9,10,20,30

var str = arr.join("*");

console.log(str);//1*2*3*4*5*6*7*8*9*10*20*30

var str = arr.join("");

console.log(str);//123456789102030

var arr = [1,2,3,4,5,6,7,8,9,10,20,30];



// 方式1 推荐

arr = [];



// 方式2

arr.length = 0;



// 方式 3

arr.splice(0,arr.length);

// 基本数据类型：没有属性值和方法

// 对象数据类型：有属性和方法

// 但是：字符串是可以调用一些属性和方法

var str = "这是一个字符串";

var str2 = str.slice(3,5);

console.log(str2);//个字



// 基本包装类型,基本类型的数据在进行一些特殊操作时,会暂时被包装成一个对象,结束后再被销毁

// 字符串也有一种根据构造函数创建方法

var str3 = new String("abcdef");

console.log(str);//这是一个字符串

console.log(str3);//Sring{"abcdef"}



// 模拟计算机的工作

var str4 = new String(str);

// 字符串临时被计算机包装成字符串对象

var str2 = str4.slice(3,5);

str4 = null;

// 定义一个字符串   

var a = "abc";

a = "cde";

// 字符串是不可变的,当 a 被重新赋值时,原来的值 "abc" 依旧在电脑内存中

// 在 JavaScript 解释器 固定时间释放内存的时候可能会被处理掉

// 大量拼接字符串也效率问题

var sum = "";

for(var i = 1; i <= 10000000; i++) {

    sum += i;

}

console.log(sum);

// 定义一个字符串

var str = "这是一个字符串,abc,   $%#";



// 长度属性

console.log(str.length);//18



// charAt() 返回指定的下标位置的字符

console.log(str.charAt(6));//串 (字符串对象是一种伪数组,所以需要从 0 开始数)



// indexOf() 返回子串在原始字符串中第一次出现位置的下标

console.log(str.indexOf("字"));//4

console.log(str.indexOf("字符串"));//4

console.log(str.indexOf("字 符串"));//-1



// concat() 字符串拼接

var str2 = str.concat("哈哈哈","普通");

console.log(str);//这是一个字符串,abc,   $%#

console.log(str2);//这是一个字符串,abc,   $%#哈哈哈普通



// split() 分割字符串成一个数组

var arr = str.split("")//一个一个字符分割

console.log(arr);

var arr = str.split(",")//按逗号进行分割

console.log(arr);



// 字符串内容倒置

var arr = str.split("")//一个一个字符分割

arr.reverse();

strn = arr.join("");

console.log(strn);

// 用连续打点方式化简

var arr = str.split("").reverse().join("")

console.log(arr);

// 大小写转换

var str1 = str.toUpperCase();

console.log(str);//这是一个字符串,abc,   $%#

console.log(str1);//这是一个字符串,ABC,   $%#

var str2 = str1.toLowerCase();

console.log(str2);//这是一个字符串,abc,   $%#

console.log(str1);//这是一个字符串,ABC,   $%# --字符串本身不会发生改变

// 截取字符串:三种

// slice(start,end) 从开始位置截取到结束位置,但是不包含结束位置

var str1 = str.slice(3,7);

console.log(str1);//个字符串

var str1 = str.slice(-7);

console.log(str1);//,   $%#



// substr() 方法可在字符串中抽取从 start 下标开始的指定数目的字符

var str2 = str.substr(6);

console.log(str2);//串,abc,   $%#

var str2 = str.substr(6,3);

console.log(str2);//串,a



// substring() 参数必须为整数 小的数当做开始位置，大的当作结束位置

var str3 = str.substring(3,7);

console.log(str3);//个字符串

function 函数名 (参数) {

    封装的结构体;

}

        // 函数：封装了一段可以重复调用执行的代码块，通过代码块可以实现大量代码的重复使用



        // 1、声明一个累加求和函数



        // num1~num2之间所有数之和

        function getSum(num1,num2) {

            var sum = 0;

            for (var i = num1; i <= num2; i++) {

                sum += i;

            }

            console.log(sum);

        }



        // 2、调用函数

        getSum(1,100);

        getSum(11,1100);

        getSum(321,1212);

var num1 = Number(prompt("请输入第一个数："));

var num2 = Number(prompt("请输入第二个数："));

function sum(a,b) {

    return a + b;

}

console.log(sum(num1,num2));

// 1、return 终止函数

function getSum(num1, num2) {

    return num1 + num2;

    console.log('return除了返回值还起到终止函数的作用，所以在return后面的代码均不执行！');

}

console.log(getSum(10, 20));



// 2、return 只能返回一个值

function fn(num1,num2) {

    return num1, num2; //返回的结果是最后一个值

}

console.log(fn(10, 20));



// 3、 我们求任意两个数 加减乘除 的结果

function getResult(num1, num2) {

    return ['求和:' + (num1 + num2), '求差:' + (num1 - num2), '求积:' + (num1 * num2), '求商:' + (num1 / num2)];

}

re = getResult(10, 20);

console.log(re);

        // 想要输出多个值可以利用数组

// 4、我们的函数如果有return 则返回的是 return后面的值 如果函数没有 return 则返回undefined

// 函数的两种声明方式

// 1、利用函数关键字自定义函数(命名函数)

function fn() {

    

}

fn();

// 2、函数表达式(匿名函数)

// var 变量名 = function() {};

var fun = function(aru) {

    console.log('我是函数表达式');

    console.log(aru);

}

fun('我是默默!');

// (1)fun是变量名 不是函数名

// (2)函数表达式声明方式跟声明变量差不多，只不过变量里面存的是值 而 函数表达式里面存的是函数

// 函数是一种数据类型，可以当成其他函数的参数

setInterval(function() {

    console.log(1);

},1000)

//每隔 1s 输出一个 1

/*

当我们不确定有多少个参数传递的时候 可以用arguments来获取 在JS中 arguments其实是当前函数的

一个内置对象 所有函数都内置了一个arguments对象 arguments对象中存储了传递的所有实参

*/

//    arguments的使用

function fn() {

console.log(arguments); //里面存储了所有的实参

}

fn(1, 2, 3);



/* 

arguments展示形式是一个伪数组，因此可以进行遍历，伪数组有如下特点：

具有length属性

按照索引方式存储数据

不具有数组的 push pop 等方法

*/

function getMax() {

    var max = arguments[0];

    var arry = arguments;

    for (var i = 0; i < arry.length; i++) {

        if (arry[i] > max) {

            max = arry[i];

        }

    }

    return max;

}



console.log(getMax(1, 2, 5, 11, 3));

console.log(getMax(1, 2, 5, 11, 3, 100, 111));

console.log(getMax(1, 2, 5, 11, 3, 1212, 22, 222, 2333));

// 函数，如果 传入的参数1，返回1，如果传入的是 1 以上的数字，让他返回参数 + 函数调用上一项

function fun (a) {

    if (a === 1) {

        return 1;

    } else {

        return a + fun(a - 1);

    }

}

// 调用函数

console.log(fun(1));

console.log(fun(2));

console.log(fun(3));

console.log(fun(100));

// 这样我们就用递归做出了 n 以内数累加求和的函数

// 斐波那契数列(每一项等于前两项之和 1,1,2,3,5,8,13,21,34,55 ···)

// 参数：正整数

// 返回值：对应的整数位置的斐波那契数列的值

function fibo(a) {

    if (a === 1 || a === 2) {

        return 1;

    } else {

        return fibo(a - 1) + fibo(a - 2);

    }

}

console.log(fibo(1));

console.log(fibo(2));

console.log(fibo(3));

console.log(fibo(4));

// js现阶段没有块级作用域 js作用域：局部作用域 全局作用域 现阶段我们js没有块级作用域

// js在ES6的时候新增块级作用域的概念

// 块级作用域就是{}中的区域



if (3 > 2) {

    var num1 = 10;

}

console.log(num1);//10



/* 

    说明js没有块级作用域，外部可以调用{}内声明的变量

 */

/* 

1、只要是代码就至少有一个作用域

2、写在函数内部的局部作用域

3、如果函数中还有函数，那么在这个作用域中就又可以诞生一个作用域

4、根据在内部函数可以访问外部函数变量的这种机制，用链式查找决定哪些数据能被内部函数访问，

    就被称作作用域链

*/



// 作用域链 ： 内部函数访问外部函数的变量 采取的是链式查找的方式来决定取哪个值 这种结构我们称作用域链

// 就近原则

var num = 10;



function fn() {//外部函数

var num = 20;



function fun() {//内部函数

    console.log(num);//20

}



fun();



}

fn();

function fn() {

    a = 2;

}

console.log(a);//2

/*

1、

console.log(num);报错

*/



// 2、

console.log(num);//undefined

var num = 10;



// 3、

fn();//11



function fn() {

    console.log(11);

}

// 4、

/*

fun();//报错

var fun = function() { 

    console.log(22);

}

*/



/* 

1、我们js引擎运行js 分为两步： 预解析 代码执行

(1) 预解析 js引擎会把js 里面所有的 var 和 function 提升到当前作用域的最前面

(2) 代码执行 按照代码书写的顺序从上往下执行



2、预解析分为   变量预解析(变量提升) 函数与解析(函数提升)

(1) 变量提升 就是把所有的变量声明提升到当前的作用域最前面 不提升赋值操作

(2) 函数提升 把所有的函数声明提升到当前作用域的最前边 不调用函数

*/

// 关键字定义的方式，不能立即执行

// function fun() {

//     console.log(1);

// }();



// 函数表达式，可以立即调用

var foo = function () {

    console.log(2);

}();

// 通过前面添加操作符可以将我们的函数矮化成表达式

+ function fun() {

    console.log(1);

}();

- function fun() {

    console.log(1);

}();

(function fun() {

    console.log(1);

})();

!function fun() {

    console.log(1);

}();

var arr = [];//创建一个空的数组

var arr1 = [1, 2, '数组', true, undefined, true];

var arr = ['red', 'orange', 'blue',];//索引号按顺序0 1 2...

console.log(arr[0]);    //red

console.log(arr[1]);    //orange

console.log(arr[2]);    //blue

console.log(arr[3]);    //undefined

// 从代码中我们可以发现，从数组中取出每一个元素时，代码是重复的，不一样的是代码的索引值在增加

// 因此我们有更简便的方法一次调用数组中的多个元素

var arr = [1, 2, '数组', true];

console.log(arr[5]);//undefined

arr[2] = 'haha';

console.log(arr[2]);//'haha'

console.log(arr.length);

console.log(arr[arr.length-1]);

var arr = [1, 3, 5, 7];

arr.length = 10;

console.log(arr);

var arr = [1, 3, 5, 7];

arr[14] = 6;

console.log(arr);

console.log(arr.length);//15

var arr = [1, 3, 5, 7];

arr.length = 3

console.log(arr);//[1，3，4]

console.log(arr.length);//3

//遍历数组就是把数组的元素从头到尾访问一遍

var arry = ['red','blue','green']

for(var i = 0; i < 3; i++){

    console.log(arry[i]);

}

//1.因为索引号从0开始，所以计数器i必须从0开始

//2.输出时计数器i当索引号使用



// 通用写法

var arry = ['red','blue','green']

for(var i = 0; i < arry.length; i++){ //也可以写成： i <= arry.length - 1

    console.log(arry[i]);

}

var arry = [2, 6, 7, 9, 11];

var sum = 0;

var average = 0;

for (var i = 0; i < arry.length; i++) {

    sum += arry[i];

}

average = sum / arry.length;

console.log(sum,average);//同时输出多个变量用逗号隔开

一 取后两位 为例：

四舍五入

1.toFixed()

Number的toFixed()方法可把 Number 四舍五入为指定小数位数的数字。

const test = 1.12 / 3   // 0.37333333333333335

console.log(test.toFixed(2))  // 0.37

复制代码

注意：
.兼容问题

/**

 * firefox/chrome ie某些版本中，对于小数最后一位为 5 时进位不正确(不进位)。

 * 修复方式即判断最后一位为 5 的，改成 6， 再调用 toFixed

 */

function(number, precision) {

    const str = number + '';

    const len = str.length;

    let last = str[len - 1]  // 或者 str.substr(len - 1, len);

    if(last == '5') {

        let = '6';

        str = str.substr(0, len - 1) + last;

        return (str - 0).toFixed(precision)

    } else {

        return number.toFixed(precision)

    }

}



或者为：

function toFixed(number, precision) {

    const tempCount = Math.pow(10, precision);

    let target = number * tempCount + 0.5;

    target = parseInt(des, 10) / tempCount;

    return target + '';

}



复制代码

.精确问题

/**

 * toFixed 有时候会碰到如下精度缺失问题

 * 可以使用下面例子的方法解决

 * 或者 (test * 100).toFixed(2) + '%';

 */

const test = 1.12 / 3   // 0.37333333333333335

console.log(test.toFixed(4))  // 0.3733

console.log((test).toFixed(4) * 100 + '%')  // 37.330000000000005%



复制代码

2. Math.round()

/**

 * 利用Math.round  

 * 保留两位小数

 */

  function toDecimal(num) {

    let tar = parseFloat(num);

    if (isNaN(tar)) { return };

    tar = Math.round(num * 100) / 100;

  }





/**

 * 利用Math.round 强制保留两位小数 10 则为 10.00

 * 保留两位小数

 */



function toDecimal(num) {

    let tar = parseFloat(num);

    if (isNaN(tar)) {return};

    tar = Math.round(num * 100) / 100;

    

    let tarStr = tar.toString();

    let decIndexOf = tarStr.indexOf('.');

    if(decIndexOf < 0) {

        tarStr += '.';

        decInexOf = tarStr.length;

    }

    while (tarStr.length <= decIndexOf + 2) {

        tarStr += '0';

    }

    return tarStr;

}



复制代码

不四舍五入

1.先把小数取整 在计算

    const test = 1.12 / 3   // 0.37333333333333335

    Math.floor(test * 100) / 100  // floor 是向下取整 0.37

复制代码

2.使用正则表达式

    const test = 1.12 / 3   // 0.37333333333333335

    let target = test + ''  // test.toString()

    target = target.match(/^\d+(?:\.\d{0, 2}?/) 

    //输出结果为 0.37。但整数如 10 必须写为10.0000

    // 如果是负数，先转换为正数再计算，最后转回负数

var arr = [1,2,3,4,5];

var str = arr+''; //1,2,3,4,5

var str = '777';

var num = str * 1; //777



var str = '777';

var num = str - 0; //777

var str = '666';

var num = str * 1; // 666

var num = ~~4.2144235; //  4



var num = 293.9457352 >> 0; //  293

var bool = !!null; //  false

var bool = !!'null'; //  true



var bool = !!undefined; //  false

var bool = !!'undefined'; //  true



var bool = !!0; //  false

var bool = !!'0'; //  true



var bool=!!''; // true

var bool=!![]; // true

var bool=!!{}; // true



var bool=!!new Boolean('false'); // true

var bool=!!new Boolean('true'); // true

var obj = {a:789};

if(obj.a){  //obj.b ==>789

console.log('运行了') //可以运行

}



if(obj.b){   //obj.b ==>undefined

console.log('运行了') //没有运行

}



var obj2 = {a:false};

if(obj2.a){  //obj.b ==>false

console.log('运行了') //没有运行

}

// 不严谨,如果值为0,undefined,false,null... 也会判断为false

var obj = {a:789};

if('a' in obj){ // 'a' in obj ==>true

console.log('运行了') //可以运行

}



if('b' in obj){// 'a' in obj ==>false

console.log('运行了') //没有运行

}

var obj = {a:789};

if(obj.hasOwnProperty('a')){   //==>true

console.log('运行了') //可以运行

}



if(obj.hasOwnProperty('b')){  //==>false

console.log('运行了') //没有运行

}

try{

      System.out.println("try");

      System.exit(0);

}catch (Exception e){

}finally {

      System.out.println("finally");

}

public static void bar2()

    {

        try {

            System.out.println("try");

            int a = 5 / 0;

        } catch (Exception e){

            System.out.println("catch");

            throw new NullPointerException();

        }finally {

            System.out.println("finally");

     }



public static void main(String[] args){

        try {

            bar2();

        }catch (Exception e){

            System.out.println("out catch");

        }

    }



执行结果

try

catch

finally

out catch

public static void main(String[] args){        

   int i = bar3();

   System.out.println(""+i);

}



try{

    return 1;

} catch (Exception e){

    System.out.println("catch");

} finally{

    System.out.println("finally");

}

return 0;



输出：

catch

finally

1



但是无法在finaly中改变返回值

public static int bar3(){

        int a = 4;

        try{

            return a;

        } catch (Exception e){

            System.out.println("catch");

        } finally{

            a++;

            System.out.println("finally");

        }

        return a;

    }



输出：

finally

4

 int m = foo();

        System.out.println(""+m);

        int n = bar();

        System.out.println(""+n);



    }





    public static int foo() {

        try{

            int a = 5 / 0;

        } catch (Exception e){

            System.out.println("catch");

            return 1;

        } finally{

            System.out.println("finally");

            return 2;

        }



    }



    public static int bar()

    {

        try {

            System.out.println("try");

            return 1;

        }finally {

            System.out.println("finally");

            return 2;

        }

    }



输出：

catch

finally

2

try

finally

2

 public static int bar2()

    {

        try {

            System.out.println("try");

            int a = 5 / 0;

        } catch (Exception e){

            System.out.println("catch");

            throw new NullPointerException();

        }finally {

            System.out.println("finally");

            return 1;



        }

    }

本来是想将时间复杂度和空间复杂度的内容，放到后面的算法系列，但后想想，其实复杂度的审视应该是贯彻于整个开发过程之中的，应该是属于更大概念的“代码规范”的一部分，而不应局限在某个算法上。当然本文仅是以能用能理解为主，并不会深入到推倒公式的那种程度。

分析

当一个问题的算法被确定以后，那么接下来最重要的当然是评估该算法所用时间和占用内存资源的问题了，如果其运行时间超出了我们所能接受的底线，或者资源的占用多到当前设备不能满足的程度，那么对于我们来说，这个算法就是无用的，即使它能够正确的运行。

相比于执行完程序再事后统计其所用时间和占用空间的方法，理论层面的复杂度分析更有优势，主要表现在两点：

1、算法运行所在的设备，配置不同、运行环境的不同，都会给算法本身运行的实际时间和空间的计算带来偏差；

2、测试数据规模的大小，数据本身的特殊性与否，也会使实际的运行结果不具有普适性，不容易正确的反应算法的性能的一个真实情况。

那怎么从理论层面来分析复杂度呢？

大O标记法

关于 大O 标记法的相关描述，我就直接引用「数据结构与算法分析」的内容了：

一般来说，估计算法资源消耗所需的分析是一个理论问题，因此需要一套正式的系统架构，我们先从某些数学定义开始。

如果存在正常数 c 和 $n_0$n0 使得当N ≥ $n_0$n0 时，T(N) ≤ c f(N)，则记为T(N) = O( f(N) )。

定义的目的是建立一种相对的级别。给定两个函数，通常存在一些点，在这些点上一个函数的值小于另一个函数的值，因此，一般地宣称，比如说f(N) < g(N) ，是没有什么意义的。于是，我们比较它们的相对增长率。当将相对增长率应用到算法分析时，我们将会明白为什么它是重要的度量。

虽然对于较小的 N 值，1000N 要比 $N^2$N2 大，但 $N^2$N2 以更快的速度增长，因此 $N^2$N2 最终将是更大的函数。在这种情况下，N = 1000 是转折点。定义是说，最后总会存在某个点 $n_0$n0 ，从它以后 c · f(N) 总是至少与 T(N) 一样大，从而若忽略常数因子，则 f(N) 至少与 T(N)一样大。

在我们的例子中，T(N) = 1000N，f(N) = $N^2$N2，$n_0$n0 = 1000 而 c=1。我们也可以让 $n_0$n0 = 10 而 c = 100。因此，可以说 1000N = O($N^2$N2)。这种记法称之为 大O标记法。人们常常不说“...级的”，而是说“大O...”。

同理还有下面的几个定义：

还有一点需要知道的是，当 T(N) = O( f(N) ) 时，我们是在保证函数 T(N) 是在以不快于 f(N)的速度增长，因此 f(N) 是T(N)的一个上界。这意味着 f(N) = Ω( T(N) )，于是我们说T(N)是f(N)的一个下界。”

时间复杂度分析

下面我们来看一段非常简单的代码

1    private static int getNum(int n) {

2        int currentNum = 0;

3        for(int i = 0; i < n; i++) {

4            currentNum += i*i;

5        }

6        return currentNum;

7    

在分析时，我们可以忽略调用方法、变量的声明和返回值的开销，所以我们只需要分析第2、3、4行的时间开销：

第2行占用1个时间单元；第4行的1次执行实际占用3个时间单元（1次乘法、1次加法、一次赋值），但是这么精确的计算是没有意义的，对于我们分析大O的结果也是无关紧要的，而且随着程序的复杂度提高这种方式也会变得越来越不可操作，（推导过程就省略了，直接上结论了，本节主要是用法层面）.

所以我们也记第4行的1次执行时间开销为1个时间单元，则 n 次执行开销为 n 个时间单元；同理第3行执行 n 次的时间开销也为 n 个时间单元，所以执行总开销为 (2n + 1) 个时间单元。所以f(N) = 2n+1，根据上文T(N) = c · f(N)到T(N) = O(2n + 1)的大O表示过程知道，我们可以抛弃一些前导的常数和抛弃低阶项，所以T(N) = O(N)。

知道了分析方法，下面我们再来看看其他复杂度的代码

1    private static void getNum(int n) {

2        int currentNum = 0;

3        for(int i = 0; i < n; i++) {

4            for(int j = 0; j < n; j++) {

5                currentNum++;

6            }

7        }

8   

通过上面代码我们可知：第2行1个单元时间，第3行 n 个单元时间，第4行 $n^2$n2 个单元时间，第5行 $n^2$n2 个单元时间，所以总时间开销f(N) = 2·$n^2$n2 + n + 1，所以复杂度T(N) = O($N^2$N2)，当然O(N^3^)都是同理的。

1    private static void getNum(int n) {

2        int currentNum = 0;

3        for(int k = 0; k < n; k++) {

4            currentNum++;

5        }

6        for(int i = 0; i < n; i++) {

7            for(int j = 0; j < n; j++) {

8                currentNum++;

9            }

       }

   

通过上面代码我们可知：第2行1个单元时间，第3行 n 个单元时间，第4行 n 个单元时间，第6行 n 个单元时间，第7行 $n^2$n2 个单元时间，第8行 $n^2$n2 个单元时间，所以总时间开销f(N) = 2·$n^2$n2+3·n + 1，所以复杂度T(N) = O($N^2$N2)。

1        if(condition) {

2            S1

3        } else {

4            S2

5        }

这是一段伪代码，在这里主要是分析 if 语句的复杂度，在一个 if 语句中，它的运行时间从不超过判断condition的运行时间加上 S1 和 S2 中运行时间长者的总的运行时间。

1    private static void getNum(int n) {

2        int currentNum = 0;

3        currentNum++;

4        if(currentNum > 0) {

5            currentNum--;

6        }

7    

通过上面的代码我们可知，第2行1个时间单元，第3行1个时间单元，第4行1个时间单元，第5行1个时间单元，所以总开销4个时间单元，所以复杂度T(N) = O(1)，注意这里不是O(4)哦。

1    private static void getNum(int n, int m) {

2        int currentNum = 0;

3        for(int i = 0; i < n; i++) {

4            currentNum++;

5        }

6        for(int j = 0; j < m; j++) {

7            currentNum++;

8        }

9  

通过上面的代码我们可知，第2行是1个单元时间，第3行是 n 个单元时间，第4行是 n 个单元时间，第6行是 m 个单元时间，第7行是 m 个时间单元，所以总的时间开销f(N) = 2·n +2·m + 1，所以复杂度T(N) = O(n+m)，同理，O(m·n)的复杂度也是同样分析。

1    private static void getNum(int n) {

2        int currentNum = 1;

3        while (currentNum <= n) {

4            currentNum *= 2;

5        }

6    

通过上面的代码我们可知，第2行需要1个单元时间；第3行每次执行需要1个单元时间，那么现在需要执行多少次呢？通过分析我们知道当 2$^次$次=n时 while 循环结束，所以次数 = $log_2n$log2n，所以第3行总需要 $log_2n$log2n 个单元时间；第4行同理也需要 $log_2n$log2n 个单元时间，所以总时间开销f(N) = 2·$log_2n$log2n + 1，所以复杂度T(N) = O(logn)，注意的是这里不但省略了常数，系数，还省略了底哦。

1    private static void getNum(int n) {

2        int currentNum = 1;

3        for(int i = 0; i < n; i++, currentNum = 1) {

4            while (currentNum <= n) {

5                currentNum *= 2;

6            }

7        }

8   

通过上面的代码我们可知，第2行1个单元时间，第3行 n 个单元时间，第4行根据上文我们需要n·$log_2n$log2n个单元时间，第5行也需要n·$log_2n$log2n个单元时间，所以总时间花销f(N) = 2·n·$log_2n$log2n + n + 1，所以复杂度T(N) = O(n·logn)。

空间复杂度分析

上面我们简单介绍了几种常见的时间复杂度，空间的复杂度比时间复杂度要简单许多，下面就来分析一下空间的复杂度：

空间复杂度考量的是算法所需要的存储空间问题，一般情况下，一个程序在机器上执行时，除了需要存储程序本身的指令、常数、变量和输入数据外，还需要存储对数据操作的存储单元，若输入数据所占空间只取决于问题本身，和算法无关，这样只需要分析该算法在实现时所需的辅助单元即可。

1    private static void getNum(int n) {

2        int i = 0;

3        for(; i<n; i++){

4            i*=2;

5        }

6    

通过上面的代码我们知道，第2行我们只需要1个空间单元；第3行、第4行不需要额外的辅助空间单元，所以空间复杂度S(N) = O(1)，注意不是只有1个空间单元才是O(1)哦，如果空间单元是常量阶的复杂度都是O(1)哦。

1    private static void getNum(int n) {

2        int i = 0;

3        int[] array = new int[n];

4        for(; i<array.length; i++){

5            i*=2;

6        }

7    

根据上面的代码我们可知，第2行需要1个空间单元；第3行需要 n 个空间单元；第4行、第5行不需要额外的空间单元，所以总消耗f(n) = n + 1，所以空间复杂度S(N) = O(n)，其他情况的分析与时间复杂度分析方法一样，在这里就不详细介绍了。

好了，本文到这里就结束了，关于时间复杂度和空间复杂度的介绍应该够平时所需了。如果本文对你有用，来点个赞吧，大家的肯定也是阿呆i坚持写作的动力。

参考 1、数据结构与算法分析：机械工业出版社

如过临界区执行时间过长，使用自旋锁是不合适的。忙等的线程白白占用 CPU 资源。

1. OSSpinLock ：

编译器会报警告，大家已经不使用了，在某些场景下已经不安全了，主要是发生在低优先级的线程拿到锁时，高优先级线程进入忙等状态，消耗大量 CPU 时间，从而导致低优先级线程拿不到 CPU 时间，也就无法完成任务并释放锁，这被称为优先级反转

新版 iOS 中，系统维护了 5 个不同的线程优先级/QoS: background，utility，default，user-initiated，user-interactive。

高优先级线程始终会在低优先级线程前执行，一个线程不会受到比它更低优先级线程的干扰。

这种线程调度算法会产生潜在的优先级反转问题，从而破坏了 spin lock。

2. os_unfair_lock:

os_unfair_lock 是苹果官方推荐的替换OSSpinLock的方案，但是它在iOS10.0以上的系统才可以调用，解决了优先级反转问题

两种自旋锁的使用

// 需要导入的头文件
#import 
#import 
#import 
// 自旋锁 实现
- (void)OSSpinLock {
    if (@available(iOS 10.0, *)) {  // iOS 10以后解决了优先级反转问题
        
        os_unfair_lock_t unfairLock = &(OS_UNFAIR_LOCK_INIT);
        NSLog(@"线程1 准备上锁");
        os_unfair_lock_lock(unfairLock);
        sleep(4);
        NSLog(@"线程1执行");
        os_unfair_lock_unlock(unfairLock);
        NSLog(@"线程1 解锁成功");
    } else { // 会造成优先级反转，不建议使用
        __block OSSpinLock oslock = OS_SPINLOCK_INIT;
        
        //线程2
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0), ^{
            NSLog(@"线程2 befor lock");
            OSSpinLockLock(&oslock);
            NSLog(@"线程2执行");
            sleep(3);
            OSSpinLockUnlock(&oslock);
            NSLog(@"线程2 unlock");
        });
        
        //线程1
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
            NSLog(@"线程1 befor lock");
            OSSpinLockLock(&oslock);
            NSLog(@"线程1 sleep");
            sleep(3);
            NSLog(@"线程1执行");
            OSSpinLockUnlock(&oslock);
            NSLog(@"线程1 unlock");
        });
        
        // 可以看出不同的队列优先级，执行的顺序不同，优先级越高，越早被执行
    }
}

读写锁：

上文有说到，读写锁又称共享-互斥锁

1. pthread_rwlock：

pthread_rwlock经常用于文件等数据的读写操作，需要导入头文件#import

iOS中的读写安全方案需要注意一下场景

• 同一时间，只能有1个线程进行写的操作


• 同一时间，允许有多个线程进行读的操作


• 同一时间，不允许既有写的操作，又有读的操作

//初始化锁
pthread_rwlock_t lock;
pthread_rwlock_init(&_lock, NULL);

//读加锁
pthread_rwlock_rdlock(&_lock);
//读尝试加锁
pthread_rwlock_trywrlock(&_lock)

//写加锁
pthread_rwlock_wrlock(&_lock);
//写尝试加锁
pthread_rwlock_trywrlock(&_lock)

//解锁
pthread_rwlock_unlock(&_lock);
//销毁
pthread_rwlock_destroy(&_lock);

用法：实现多读单写

#import 
@interface pthread_rwlockDemo ()
@property (assign, nonatomic) pthread_rwlock_t lock;
@end

@implementation pthread_rwlockDemo

- (instancetype)init
{
    self = [super init];
    if (self) {
        // 初始化锁
        pthread_rwlock_init(&_lock, NULL);
    }
    return self;
}

- (void)otherTest{
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    
    for (int i = 0; i < 10; i++) {
        dispatch_async(queue, ^{
            [self read];
        });
        dispatch_async(queue, ^{
            [self write];
        });
    }
}
- (void)read {
    pthread_rwlock_rdlock(&_lock);
    sleep(1);
    NSLog(@"%s", __func__);
    pthread_rwlock_unlock(&_lock);
}
- (void)write
{
    pthread_rwlock_wrlock(&_lock);
    sleep(1);
    NSLog(@"%s", __func__);
    pthread_rwlock_unlock(&_lock);
}
- (void)dealloc
{
    pthread_rwlock_destroy(&_lock);
}
@end

递归锁:
递归锁有一个特点，就是同一个线程可以加锁N次而不会引发死锁。

1. pthread_mutex(recursive):
pthread_mutex_t锁是默认是非递归的。可以通过设置PTHREAD_MUTEX_RECURSIVE属性，将pthread_mutex_t锁设置为递归锁。

pthread_mutex_t lock;
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init(&lock, &attr);
pthread_mutexattr_destroy(&attr);
pthread_mutex_lock(&lock);
pthread_mutex_unlock(&lock);

2. NSRecursiveLock:
NSRecursiveLock是对mutex递归锁的封装，API跟NSLock基本一致

#import "RecursiveLockDemo.h"
@interface RecursiveLockDemo()
@property (nonatomic,strong) NSRecursiveLock *ticketLock;
@end
@implementation RecursiveLockDemo
//卖票
- (void)sellingTickets{
[self.ticketLock lock];
[super sellingTickets];
[self.ticketLock unlock];
}
@end

条件锁:
1. NSCondition:
定义：

@interface NSCondition : NSObject  {
@private
    void *_priv;
}
- (void)wait;
- (BOOL)waitUntilDate:(NSDate *)limit;
- (void)signal;
- (void)broadcast;

遵循NSLocking协议，使用的时候同样是lock,unlock加解锁，wait是傻等，waitUntilDate:方法是等一会，都会阻塞掉线程，signal是唤起一个在等待的线程，broadcast是广播全部唤起。

NSCondition *lock = [[NSCondition alloc] init];
//Son 线程
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    [lock lock];
    while (No Money) {
        [lock wait];
    }
    NSLog(@"The money has been used up.");
    [lock unlock];
});

 //Father线程
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    [lock lock];
    NSLog(@"Work hard to make money.");
    [lock signal];
    [lock unlock];
 });

2.NSConditionLock:
NSConditionLock是对NSCondition的进一步封装，可以设置具体的条件值
定义：

@interface NSConditionLock : NSObject  {
@private
    void *_priv;
}
- (instancetype)initWithCondition:(NSInteger)condition NS_DESIGNATED_INITIALIZER;
@property (readonly) NSInteger condition;
- (void)lockWhenCondition:(NSInteger)condition;
- (BOOL)tryLock;
- (BOOL)tryLockWhenCondition:(NSInteger)condition;  // 
- (void)unlockWithCondition:(NSInteger)condition;
- (BOOL)lockBeforeDate:(NSDate *)limit;
- (BOOL)lockWhenCondition:(NSInteger)condition beforeDate:(NSDate *)limit;

用法 ：

@interface NSConditionLockDemo()
@property (strong, nonatomic) NSConditionLock *conditionLock;
@end
@implementation NSConditionLockDemo
- (instancetype)init
{
if (self = [super init]) {
self.conditionLock = [[NSConditionLock alloc] initWithCondition:1];
}
return self;
}

- (void)otherTest
{
[[[NSThread alloc] initWithTarget:self selector:@selector(__one) object:nil] start];
[[[NSThread alloc] initWithTarget:self selector:@selector(__two) object:nil] start];
}

- (void)__one
{
[self.conditionLock lock];
NSLog(@"__one");
sleep(1);
[self.conditionLock unlockWithCondition:2];
}

- (void)__two
{
[self.conditionLock lockWhenCondition:2];
NSLog(@"__two");
[self.conditionLock unlockWithCondition:3];
}
@end

里面有三个常用的方法

* 1、- (instancetype)initWithCondition:(NSInteger)condition;  //初始化Condition，并且设置状态值
* 2、- (void)lockWhenCondition:(NSInteger)condition;   //当状态值为condition的时候加锁
* 3、- (void)unlockWithCondition:(NSInteger)condition;   //当状态值为condition的时候解锁

信号量 dispatch_semaphore:
在加锁的过程中，如过线程 1 已经获取了锁，并在执行任务过程中，那么其他线程会被阻塞，直到线程 1 任务结束后完成释放锁。

实现原理 ：
信号量的 wait 最终调用到这里

int sem_wait (sem_t *sem) {  
  int *futex = (int *) sem;
  if (atomic_decrement_if_positive (futex) > 0)
    return 0;
  int err = lll_futex_wait (futex, 0);
    return -1;
)

首先把信号值减一，并判断是否大于 0，如过大于 0 说明不用等待，立即返回。
否则线程进入睡眠主动让出时间片，让出时间片会导致操作系统切换到另一个线程，这种上下文的切换也耗时，大概 10 微妙，而且还要切回来，如过等待时间很短，那么等待耗时还没有切换耗时长，很不划算。

自旋锁和信号量的实现简单，所以加锁和解锁的效率高

总结
其实本文写的都是一些再基础不过的内容，在平时阅读一些开源项目的时候经常会遇到一些保持线程同步的方式，因为场景不同可能选型不同，这篇就做一下简单的记录吧~我相信读完这篇你应该能根据不同场景选择合适的锁了吧、能够道出自旋锁和互斥锁的区别了吧。

性能排序:
1、os_unfair_lock
2、OSSpinLock
3、dispatch_semaphore
4、pthread_mutex
5、dispatch_queue(DISPATCH_QUEUE_SERIAL)
6、NSLock
7、NSCondition
8、pthread_mutex(recursive)
9、NSRecursiveLock
10、NSConditionLock
11、@synchronized

转自：https://www.jianshu.com/p/eaab05cf0e1c