//ES6字符串模板语法;
let
tt =
'tyu'
let
text =
`你好上岛咖啡精神可嘉福克斯地方是
${
tt
}
时代峰峻神盾局六块腹肌`
//运算
let
o =
1;
let
u =
2;
let
ii =
`
${
o+
u
}
`;
let
tg =
`你好上岛咖啡精神可嘉福克斯地方是
${
ii
}
时代峰峻神盾局六块腹肌`
var
arr = [
'u',
'u',
'i',
'ioi',
'ds',
'fs',
'fs',
'gh',
'tgfh'];
if(
arr.
indexOf(
'i')){
console.
log(
arr.
indexOf(
"i"));
}
else{
console.
log(
2);
}
//arr中是否有U
if(
arr.
includes(
"gh")){
console.
log(
1);
}
else{
console.
log(
2);
}
//tg中结尾是否有U 只针对字符串
if(
tg.
endsWith(
"你")){
console.
log(
1);
}
else
if(
tg.
endsWith(
"肌")){
console.
log(
11);
}
else{
console.
log(
2);
}
//tg中开头是否有U 只针对字符串
if(
tg.
startsWith(
"你")){
console.
log(
1);
}
else{
console.
log(
2);
}
//字符串复制 repeat()
console.
log(
tg.
repeat(
4));
//进制转换
//二 Bianry
let
binary=
0B010101;
console.
log(
binary);
//八 Octal
let
Octal =
00666;
//判断是否为数字
console.
log(
Number.
isFinite(
10));
console.
log(
Number.MAX_SAFE_INTEGER);
console.
log(
Number.MIN_SAFE_INTEGER);
//数组去重,重点在于判断条件,新组中是否已存在该数据
var
arr1 = [
'u',
'u',
'i',
'ioi',
'ds',
'fs',
'fs',
'gh',
'tgfh'],
arr2 = [];
for(
let
i =
0;
i<
arr1.
length;
i++){
if(!
arr2.
includes(
arr1[
i])){
arr2.
push(
arr1[
i]);
}
else{
}
}
// console.log(arr2);
//eval()将字符串转换成数组
//from将json转换成数组
// Arr.from()
//主动抛出异常 throw new Error("")
//ES6 的新数据结构 set 特点:自动去重 针对数组
let
setArr =
new
Set(
arr);
// console.log(arr);
// console.log(setArr);
for (
val
of
setArr){
// console.log(val);
}
//增加值 add 查找 has 删除 clear 值的数量size
//weakSet 针对对象 学习的时候并未给出取值方法
let
weakSet =
new
WeakSet();
let
obj = {
a:
'1',
b:
'2',
c:
'3'};
weakSet.
add(
obj);
// console.log(weakSet);
// ES6 map 数据结构 已知的数据结构为 json 、set
// 取值 get 删除特定 delete 删除全部 clear 增加值set 值的数量size 查找 has
var
map =
new
Map();
map.
set(
obj,
'iii');
console.
log(
map);
map.
set(
'dfff',
obj);
console.
log(
map);
console.
log(
map.
get(
'dfff'));
console.
log(
map.
delete(
'dfff'));
console.
log(
map);
//proxy 代理 ES6 增强对象和函数 先行执行特性
let
obj1 = {
add
:
function(){
console.
log(
3);
},
name:
'tttty'
}
let
proxy =
new
Proxy({
add
:
function(){
console.
log(
3);
},
name:
'tttty'
},{
get
:
function(
target,
key,
property){
console.
log(
2);
return
target[
key];
//先行执行get而target为传过来的第一个参数对象
},
set
:
function(
target,
key,
value,
receiver){
console.
log(
"对proxy的值进行预先处理");
return
target[
key] =
value;
//改变根值,若不返回改变则根植不变
}
});
// so
// console.log(proxy.name);
proxy.
add();
//promise 多重回调优化,使用then进行下一步操作
//三步曲
let
state =
1;
function
step (
resolve,
reject){
console.
log(
'开始');
if(
state==
1){
resolve(
'完成');
step2()
//一层回调
}
else{
reject(
'出错');
}
}
function
step2 (
resolve,
reject){
console.
log(
'开始1');
if(
state==
1){
resolve(
'完成1');
step3()
//二层回调
}
else{
reject(
'出错1');
}
}
function
step3 (
resolve,
reject){
console.
log(
'开始12');
if(
state==
1){
resolve(
'完成12');
}
else{
reject(
'出错12');
}
}
//一般写法
function
state1(){
step();
//里面有二重回调嵌套,数据结构不够简洁,逻辑不够清晰
}
//使用promise对多重嵌套回调函数进行执行,优点:数据结构简洁,逻辑清晰
new
Promise(
step)
.
then(
function(
val){
console.
log(
val);
return
new
Promise(
step2);
//返回执行下一步函数,一步错误,就不再执行下一步,
})
.
then(
function(
val){
console.
log(
val);
return
new
Promise(
step3);
})
.
then(
function(
val){
console.
log(
val);
});
// ES6 类 此类非element上的target.class
//声明一个类,类里面多个函数不用逗号隔开,直接写就可以了
class
Coder {
name(
val){
console.
log(
val);
return
val;
}
skill(){
console.
log(
this.
name(
'I miss you too'))
}
//此方法为类的参数,并不是方法的参数
constructor(
a,
b){
this.
a =
a;
this.
b =
b;
}
add(){
return
this.
a+
this.
b;
}
}
//对类进行实例化
let
test =
new
Coder;
//执行
test.
name(
"ttt");
//类里面的一个方法需要调用另外一个方法,就需要被调用函数做返回值,使调用者获取到返回值进行操作
test.
skill();
//用类里面的方法,使用类的参数
let
ttt =
new
Coder(
1,
3);
console.
log(
ttt.
add());
//类和类的继承,作用类似于对象继承,不过比对象继承更简单 例:
// 新声明一个类,继承了Coder类
class
hh
extends
Coder{}
//实例新类
let
newClass =
new
hh;
newClass.
name(
"kao ");
//ES6的模块化 export 输出 export default 默认输出 import 引入