标签：zha ever 数据格式 多少 复杂数据类型 key tin 除了 添加
##声明
let 不支持重复声明（重复声明会报错）
let 与 var的区别
1.变量提升
2.通过var声明的变量不存在块级作用域（不受{}控制）
##数据类型
基本数据类型(5+1)
1.undifined
2.null
3.number
4.boolean
5.string
6.symbol(ems6添加(5+1)定义独一无二的值)
复杂数据类型
object 对象，引用
1.undefined
1.1 变量没有声明，直接打印，会报错，如果使用typeof打印，则输出undefined
1.2 函数没有返回值
1.3 访问一个值被设置为undefined的变量
1.4 访问不存在的属性
2.null
2.1 null的数据类型为object,与undifined的区别:undifined表示有容器，没有值，而null表示值都没有
2.2 ECMA在进行不精确地情况下比较：
null == undefined == 表示 等于 === 表示 全等
2.3 null 表示 啥都没有 undefiner表示 此处应该有值
3.boolean
//true false
3.1 任何数据类型都可以转换为boolean类型,任何非0非空的字符串都会转为true.
3.2 空字符串:"" 两个引号中啥都没有
会被转化为boolean的类型
1.``,‘‘,""
2.0
3.NaN(not a number)
4.false
5.null
6.undefined
4.number
可以进行+ - * /运算 但是注意使用+
//infinity 无限大 2的1024次方
//NaN不与任何值相等
//有一个来判断是否为非数的方法isNaN
5.string
//字符串模板 （`...`）
##数据类型的转换
1.数据类型的转换
1.1 隐式转换
1.2 显式转换
例：4 - 4 ; "5" - 5; "abc" - NaN; "" - 0; null - 0;
true - 1; false - 0; undefined - NaN;
2.对非布尔值求布尔值
3.转为字符串
字符串 + 任何字符串 - string
字符串 - * / % number - number
4.强制转换类型
1.parseInt
2.parseFloat
3.number
字符串用1.2转化为NaN，用3转化为0
5.强制转换为string
6.强制转换为boolean
变量前加!,!!可以快速转换为布尔值
##运算符
1.赋值 = += -=
2.一元运算符
//++ -- 在变量后先赋值，后自增/减，在变量前，先自增/减，再赋值
3.逻辑运算符
||,&&不仅会返回真假，如果两个数都是true，还会返回第二个操作数
4.比较运算符
"a">"b" 比较ASCII码
"a" - 97
"A" - 65
5.三目运算符
表达式1?表达式2:表达式3;
##流程控制
顺序结构，选择结构
if(条件){
...
}else{
...
}
swich(变量名){
case 1(全等比较):
...
break;
case 2(全等比较):
...
break;
case 3(全等比较):
...
break;
case 4(全等比较):
...
break;
case default(上述入口都不满足):
...
break;
}
##循环
//for(初始化;测试;递增){
...
}
for : 1243-243-243...;
//while(表达式){
//循环体
}
//do{
//循环体
}while(条件);
先执行一次循环体
##打断循环
1.break 结束整个循环
2.continue 结束当前循环进入下一次循环
##循环嵌套
for(...){
for(...){
if(...){}
}
}
##数据结构
计算机存储和组织数据的方式，最常见的就是数组，数据结构将多个数据有效的排列在一起
##创建数组
1.字面量
let arr = [];
2.构造函数（使用较少）
let arr = new Array[];
元素类型：可以使任意数据类型;
let arr = [1,2,"三","abc"]；
例：arr[0] = 1;
arr[1] = 1;
arr[2] = 1;
arr[5] = 1;
输出:[1,,1,1,<3 empty items>,1]
##栈 堆
1.栈 简单(原始)数据类型，存储栈区，大小固定
2.堆 复杂（引用）数据类型，存储在堆区
简单值与复杂值的比较（值与值的比较，堆与堆得比较）；
例：
let arr1 =[1,2,3];
let arr2 =[1,2,3];
console.log(arr1 == arr2); - false(比较堆)
let arr3 = arr1;
console.log(arr1 == arr3); - true
清空数组:
arr.length = 0;
删除元素:
delete arr[x];删除第x项元素,不改变数组的长度,删除项以空保存
##解构
复杂数据类型分解成普通数据类型，=左右两边相等
let arr1 = [1,2];
let [value1,value2] = arr1;
##遍历
1.for
for(let i=0;i<arr.length;i++){
console.log(arr[i])
}
优化:每次for循环都会计算arr.length，可以再表达式1中将arr.length的值赋给一个变量；
2.for of
for(let item of arr){
console.log(item);
}
3.for in..适用于对象
for(let index in arr){
console.log(`第${index}的值式${arr[index]}`)
}
4.forEach 不可以break,continue,return
arr.forEach(function(item,index){
//可传入2个元素，顺序是元素、下标
console.log(`第${index}项元素师${item}`)
});
##二维数组
let arr = [1,2,3,[4,5,6]]; //长度为4
ES6扩展运算符:
解开数组...[]
##数组的运算方法
1.push() pop ()
push() //在末尾添加
pop() //删除末尾项
2.unshift() shift()
unshift() 在第0项前面添加
shift() 删除第0项
3.截取 slice
let arr1 = [1,2,3,4,5,6];
let arr2 = arr1.slice(1,5);
(1,5)开始下标和结束下标，输出的不包含结束下标的数，不会影响原数组；
arr.slice[0] 所有数
4.万能法，剪接 splice
let arr1 = [1,2,3,4,5,6];
arr1.splice(0,0,1,2);
//添加：从第0项开始，删除0个数，添加item1，item2；
arr1.splice(0,3);
//删除：从第0项开始，删除3项；
arr1.splice(1,1,"item");
//替换：从第X项开始，删除1项，替换为item；
##reverse 倒叙输出
arr1.revsrse();
##sort 排序
arr1.sort((a,b)=>a-b);//从小到大升序排列
arr1.sort((a,b)=>b-a);//从大到小升序排列
##concat()连接
let arr3 = arr1.concat(arr2);
//将两个数组连接，原数组不会改变
##位置方法: indexof()
let arr1 = [1,2,3,4];
console.log(indexof(4));
返回元素下标，返回出来的数十全等，如果没有该项元素，则返回-1；
##数组和字符串相互转换
1.jion数组转字符串
let arr1 = [1,2,3,4];
let str = arr.jion("-");
console.log(str) - 1-2-3-4;类型为string;
2.字符串转数组 split
let str ="hellow world";
str.split(" "); 以" "进行分割；
3.排序（除了sort方法）
1.选择
第一项与后面的所有项依次比较大小
2.冒泡
数组有多少个元素就比较(arr.lengh-1)轮
#集合
set() 不允许包含重复值
//映射 ....map()
let arr = [1,2,3];
let newArr = arr.map(function(item){
return item*2;
});
console.log(newArr) [2,4,6]
//过滤filter()
用法与上述相同，过滤奇偶数这些
//some() every()
用法与上述相同，判断元素性质 some表示有就输出true
every 需要每个元素都满足这个性质才输出true;
#函数
为什么需要函数:
1.复用，避免重复书写
2.代码维护
3.参数
4.返回值
5.团队开发
//声明函数
function fn(){
...
}
声明式函数的函数提升：先声明，再调用，也可以执行
//函数表达式：
let fn = function(){
console.log(`~~`);
}
立即执行函数，（匿名函数）
//参数
let 寄快递 = 快递公司（货物（形式参数））{
console.log(`收到的是${货物}`)
}
寄快递（`小猪佩奇`）实际参数
//声明时有形参，没有传实参. undefined(不穿实参)
//arguments 伪数组对象，计算实参个数
let fn1 = function(a){
console.log(a);
console.log(arguments[0]); 1
console.log(argument[1]); 100
console.log(argument[2]); undefined
}
fn1(1,100);
伪数组：没有数组的方法
//函数的返回值
undefined 没有返回值就返回；
let fn = function(){
return 100;
}
console.log(fn());
//函数的执行
变量在使用前未声明，它就是一个全局变量；
执行上下文
function test(){
console.log(111);
}
var test;
test = 5;
console.log(test); // 5
console.log(typeof test); // number
test(); // 111 5()
//查看是谁调用了函数 caller
在node 中查看 是 Function
在浏览器终端中查看是 null
//默认参数
let fn = function(a=1,b=2){
console.log(a,b);
}
//不定参数 rest
rest 剩余的参数全部被rest接受，保留在一个数组里;
let fn = (getV1,getV2,rest)=>{
console.log(getV1,getV2,rest);
}
fn("a","b","c","d","e");
得到 ‘a‘,‘b‘,[‘c‘,‘d‘,‘e‘]
//argument计算实参个数
//箭头函数
let fn = () =>{...};//箭头函数不能用this;
如果只有一个形参，则省略（），没有形参或多个形参不能省略
//当()里只有一个return，"return"省略
let fn = (a) => a;
//函数是一等公民，如果变量与函数同时提升，那么函数提升在变量之前；
//作用域
先执行函数内部的变量
//在函数中获取另一个函数的返回值
1.将A函数的值赋给一个全局变量，在B函数中访问该全局变量；
2.通过函数的返回值；
3.在A函数中调用B函数，通过实参的值接受；
//回调函数
1.将A函数作为参数给B函数，B函数里去调用A函数，A函数叫作回调函数
let fnA = function(){
console.log(`我是一个回调函数`);
}
let fnB = function(getA){
getA;
}
fnB(fnA);//注意fnA没有括号
2.回调函数可以和其他实参一起被传入
//随机数 （0-1但是取不到1）
let number = Math.random();
consle.log(number);
如果需要取一个范围内的随机整数(min,max)
则将代码改为：
let fn_sjs = function(min,max){
let number = Math.random()*(max-min)+min;
return number;
}
如果只传入一个实参，则改为
let fn-sjs = function(min,max){
if(!max){
[max,min] = [min,1]; //将新参解构，传入的参数赋给max,则随机数的范围为1~输入的数
}
let number = Math.random()*(max-min)+min;
return number;
}
//函数的三要素
1.功能（function）
2.参数
3.返回值
#对象
//数组是一组数据的有序集合，对象是一组数据的无序集合
//属性：对象要使用的数据
//方法：拥有的操作
##创建对象
1.构造函数（使用较少）
let obj = new object();
obj.name = "zhangsan";
obj.age = 18;
console.log(obj);
{name:"zhangsan",age:18}
键：值 对（成对出现）
2.字面量
let obj = {};//定义一个空对象
obj.name = "zhangsan";
obj.age = 18;
console.log(obj);
{name:"zhangsan",age:18}
let obj ={
name = "zhangsan";
age = 18;
}
obj.job = "it"//新增
注意：如果值不是一个功能，键跟值统称为属性
console.log(obj["age"]);//[]里面也可以是变量
##方法
let obj = {
name = "zhangsan",
age = 18,
fn_talk:function(){
console.log(`嘿嘿`);
}
}//当键对应的值是一个function时，就说该数据是对象的方法
//调用方法
xxx.方法();
obj.fn_talk();
//删除
delete obj.fn_talk;//注意不加().加了()表示调用
//添加
obj.fn_eat = function{
console.log(`我在吃饭`);
}
//语法糖…^_^
1.值（数据）放在变量中，对象里有个键，变量同名，简写
例：
let name = "zhangsan";
let obj = {
name,
}
fn_talk:function(){
console.log(`嘿嘿`);
}简写为fn-talk(){...};
##对象的遍历
let obj = {
name : "zhangsan",
age : 18,
}
for(let key in obj){
console.log(key,obj[key]);
}
for in 不能获取symbol键
//获取所有键
let allKeys = Reflect.ownKeys(obj);
//获取symbol键
let symbolKey = object.getOwnPropertySymbols(obj);
//对象可以嵌套 ，但是最好把对象套在数组里
##对象解构
let obj = {
name = "zhangsan",
age = 18
}
let {name:getName,age:getAge};
##对象传参
接受（形参也必须是对象），好处是不用11对应传参
##JSON数据格式（长得像对象的字符串）
1.把对象转为字符串
let str = JSON.stringify(OBJ);
2.把JSON字符串转为对象
let returnobj = JSON.parse(str);
标签：zha ever 数据格式 多少 复杂数据类型 key tin 除了 添加
原文地址：https://www.cnblogs.com/yueliang--/p/9533093.html
