JavaScript小技能：变量

//let 语句声明一个块级作用域的本地变量，并且可选的将其初始化为一个值。
let a;
let name = 'Simon';

let x,y,z=3;//只有最后一个变量z 被赋值了3

//给多个变量赋值
//Longhand
let a, b, c;
a = 5;
b = 8;
c = 12;
//Shorthand 简写
let [a, b, c] = [5, 8, 12];

// myLetVariable 在这里 *不能* 被引用

for (let myLetVariable = 0; myLetVariable < 5; myLetVariable++) {
  // myLetVariable 只能在这里引用
}

// myLetVariable 在这里 *不能* 被引用

const Pi = 3.14; // 设置 Pi 的值

var a;
var name = "simon";
// myVarVariable 在这里 *能* 被引用

for (var myVarVariable = 0; myVarVariable < 5; myVarVariable++) {
  // myVarVariable 整个函数中都能被引用
}

// myVarVariable 在这里 *能* 被引用

//JavaScript 与其他语言的（如 Java）的重要区别是在 JavaScript 中语句块（blocks）是没有作用域的，只有函数有作用域。因此如果在一个复合语句中（如 if 控制结构中）使用 var 声明一个变量，那么它的作用域是整个函数（复合语句在函数中）。 

//但是从 ECMAScript Edition 6 开始将有所不同的， let 和 const 关键字允许你创建块作用域的变量。

let myString = 'Hello';

parseInt("123", 10); // 123
parseInt("010", 10); // 10
parseInt("11", 2); // 3,把一个二进制数字字符串转换成整数值
//parseFloat() 只应用于解析十进制数字
//一元运算符 + 也可以把数字字符串转换成数值：
+ "42";   // 42
+ "010";  // 10
+ "0x10"; // 16
//parseInt() 和 parseFloat() 函数会尝试逐个解析字符串中的字符，直到遇上一个无法被解析成数字的字符，然后返回该字符前所有数字字符组成的数字。
//但是运算符 "+"对字符串的转换方式与之不同， 只要字符串含有无法被解析成数字的字符，该字符串就将被转换成 NaN。

//将变量转换成布尔类型
//1. false、0、空字符串（""）、NaN、null 和 undefined 被转换为 false
//2. 除了以上情况，其他值被转换为 true。
//可以使用 Boolean() 函数进行显式转换：
Boolean(''); // false
Boolean(234); // true
//JavaScript 会在需要一个布尔变量时隐式完成这个转换操作，比如在 if 条件语句中。

   var d = new Date();

//1）    获得当前年份    d.getYear()
//2）    获得年份的全称    d.getFullYear()
//3）    获得月份    d.getMonth()
//4）    获得日期    d.getDate()
//5）    获得星期    d.getDay()
//6）    获得时间    d.getHours()
//7）    获得分钟    d.getMinutes()
//8）    获得秒钟    d.getSeconds()

Math.sin(3.5);
var circumference = 2 * Math.PI * r;     
//1）       ceil()    向上取整
//2）       floor()   向下取整
//3）       round()   四舍五入

 var str = new String("abc");
//通过访问字符串的 length（编码单元的个数）属性，可以得到它的长度。
"hello".length; // 5 
//字符串也有 methods（方法）能让你操作字符串和获取字符串的信息。
"hello".charAt(0); // "h"  charAt(下标) 
"hello, world".replace("world", "mars"); // "hello, mars"
"hello".toUpperCase(); // "HELLO"
//          indexOf()
//          substring()
//          concat()
//          split()

parseInt("hello", 10); // NaN
"test"/123
//把 NaN 作为参数进行任何数学运算，结果也会是 NaN：
NaN + 5; //NaN
//使用内置函数 isNaN() 来判断一个变量是否为 NaN：
isNaN(NaN); // true

//使用内置函数 isFinite() 来判断一个变量是否是一个有穷数， 如果类型为Infinity, -Infinity 或 NaN 则返回 false：
isFinite(1/0); // false
isFinite(Infinity); // false
isFinite(-Infinity); // false
isFinite(NaN); // false

isFinite(0); // true

let myVariable = document.querySelector('h1');
alert('hello!');

  function   函数名称(参数列表){
      
    函数体
     }
 //一个 JavaScript 函数可以包含 0 个或多个已命名的变量。
 var fun = new Function("a","b"," return a+b;");//return 语句返回一个值并结束函数
 //JavaScript 允许你创建匿名函数
 var fun = function (a,b){
      return a+b;
           }
 // 注意：Function 类型没有重载，并且 fun 和fun(1,2)结果完全不同;

//匿名函数
document.querySelector('html').onclick = function() {
    alert('别戳我，我怕疼。');
}

//箭头函数
document.querySelector('html').addEventListener('click', () => {
  alert('别戳我，我怕疼。');
});

//Longhand
function add(num1, num2) {
   return num1 + num2;
}
//Shorthand
const add = (num1, num2) => num1 + num2;

function avg() {//可以接收任意个数的参数
    var sum = 0;
    for (var i = 0, j = arguments.length; i < j; i++) {
        sum += arguments[i];
    }
    return sum / arguments.length;
}
avg(2, 3, 4, 5); // 3.5

function avg(...args) {//所有被传入该函数的参数都被变量 args 所持有。
  var sum = 0;
  for (let value of args) {//将 for 循环替换为 for...of 循环来参数args
    sum += value;
  }
  return sum / args.length;
}

avg(2, 3, 4, 5); // 3.5

apply(thisArg, argsArray)
//1. thisArg在 func 函数运行时使用的 this 值。请注意，this 可能不是该方法看到的实际值：如果这个函数处于非严格模式下，则指定为 null 或 undefined 时会自动替换为指向全局对象，原始值会被包装。
//2. 一个数组或者类数组对象，其中的数组元素将作为单独的参数传给 func 函数。如果该参数的值为 null 或  undefined，则表示不需要传入任何参数。从 ECMAScript 5 开始可以使用类数组对象。

//传给 apply() 的第二个参数是一个数组，它将被当作 avg() 的参数列表使用
avg.apply(null, [2, 3, 4, 5]); // 3.5

const numbers = [5, 6, 2, 3, 7];
const max = Math.max.apply(null, numbers);

var charsInBody = (function countChars(elm) {
    if (elm.nodeType == 3) { // 文本节点
        return elm.nodeValue.length;
    }
    var count = 0;
    for (var i = 0, child; child = elm.childNodes[i]; i++) {
        count += countChars(child);
    }
    return count;
})(document.body);//命名立即调用的函数表达式（IIFE——Immediately Invoked Function Expression）

var obj = new Object();// js方式创建一个对象
var obj = {};//对象字面量（object literal）

   var oo = {
        name:"hello",
        age:123,
        getName:function(){
       return oo.name;
            }
       
    }
   alert(oo.getName());

   var obj = new Object();
   obj.name = "hello";//对象的属性可以通过链式（chain）表示方法访问
// 括号表示法 (bracket notation)
   obj['name'] = 'Simon';
   obj.for = 'Simon'; // 语法错误，因为 for 是一个预留关键字。从 ECMAScript 5 开始，预留关键字可以作为对象的属性名
   obj["for"] = 'Simon'; // 工作正常
   obj.age = 123;
   obj.getName = function (){
       return obj.name;
            }
   alert(obj.name);
   alert(obj.getName());

   var arr = new Array();
    arr[0]  = 123;
    arr[1] = "hello";
    arr[5] = "aaaa";

var arr2 = [1,2,3,"hello",,,"aa",];
alert(arr2.length);// IE中长度为8，火狐7

//为了交换两个变量，通常使用第三个变量。
let x = 'Hello', y = 55;
//Longhand
const temp = x;
x = y;
y = temp;
//Shorthand
[x, y] = [y, x];

var a = ["dog", "cat", "hen"];
a[100] = "fox";
a.length; // 101

a.push(item);//在数组后追加元素

for (const currentValue of a) {
  // Do something with currentValue
}
//不推荐使用 for...in 循环历数组,因为它遍历的是数组的索引。如果直接向 Array.prototype 添加了新的属性，使用这样的循环这些属性也同样会被遍历。
for (var i in a) {
  // 操作 a[i]
}

["dog", "cat", "hen"].forEach(function(currentValue, index, array) {
  // 操作 currentValue 或者 array[index]
});

const months = ['Jan', 'March', 'April', 'June'];
months.splice(1, 0, 'Feb');
// inserts at index 1
console.log(months);
// expected output: Array ["Jan", "Feb", "March", "April", "June"]

months.splice(4, 1, 'May');
// replaces 1 element at index 4
console.log(months);
// expected output: Array ["Jan", "Feb", "March", "April", "May"]