6000 * (Math.random() + 1);

var initTime = 6000 * (Math.random() + 0.33333);
if (initTime < 6000) {
  initTime += 4000;
}
//或者

function iTime() {
  var initTime = 6000 * (Math.random() + 0.33333);
  if (initTime < 6000) {
    return (initTime += 4000);
  }
  return initTime;
}

iTime();

//# 启动app
app.launchApp("京东读书");

//暂停运行5秒
sleep(5000);

如果触发一次, 就次数`total += 1`;
if (total == 300) {
  //toast('看完300页了,准备打卡去')
  //建议此时不停,不知道时间够不够,继续刷一会
}

if (total >= 300 && totalTime >= 30 * 6000) {
  //条件满足,停止刷页
  stop();
  //跳转打卡页面
} else {
  //继续刷页
}

while (!click("扫一扫"));

if (text("某个文本").exists()) {
  //要支持的动作
}

//暂停1秒
sleep(1000);

var sendButton = text("发送").findOne();
sendButton.click();

desc("搜索").findOne().click();

function turnPage(){
    ...
}

//检查无障碍服务开启情况
auto.waitFor();
//显示控制台
console.show();
//设置脚本适合的宽高
setScreenMetrics(720, 1440);
//打开京东读书app
app.launchApp("京东读书");
toast("开始打卡");

//等待启动
sleep(2000);

//跳过
if (text("跳过").exists()) {
  //点击控件
  text("跳过").findOne().click();
  sleep(2000);
}

//检测升级
if (text("下次再说").exists()) {
  //点击控件
  text("下次再说").findOne().click();
  sleep(2000);
}

//点击控件,跳转书架
id("main_tab_bookshelf").findOne().click();
sleep(1000);

//准备开始图书

//随机时间
var initTime = 6000 * (Math.random() + 0.33333);
if (initTime < 6000) {
  initTime += 4000;
}

//已读完时,左上角出现关闭阅读
if (text("关闭阅读").exists()) {
  //点击控件
  text("关闭阅读").findOne().click();
  sleep(2000);
  //长按第一本书,左下角删除,弹出确认删除,点击第二个删除.sleep(2000),右上角完成,继续阅读()
  let index;
  deleteBook();
  //继续阅读
  //删掉之后,加上已阅读200页,重新开始,又会阅读300页.
  this.index = index;

  readBook();
} else {
  //执行自动阅读
  readBook();
}

//执行阅读主步骤
mianStep()

function mianStep(){
    readeBook()
    if(text("关闭阅读").exists()){
    //点击控件
    text("关闭阅读").findOne().click()
    sleep(2000)
    //长按第一本书,左下角删除,弹出确认删除,点击第二个删除.sleep(2000),右上角完成,继续阅读()
    let index
    deleteBook()
    //继续阅读
    //删掉之后,加上已阅读200页,重新开始,又会阅读300页.
    this.index = i
    mianStep()
}

//自动阅读
function readBook(){
    toast("开始阅读")
    //选择第一本
    id("i_reader_folder").indexInParent(0).findOne().click()
    sleep(3000)
    //执行点击
    clickPage()
}

//点击阅读
function clickPages(){
    //点击300页
    for(let {i=0}=index; i<300; i++){
    randomClick()
    //间隔时间
    sleep(initTime)
    }
}

//定时器版
// for(var i=0; i<5; i++){
//     setTimeout(randomClick(),initTime)
// }

//随机点坐标
function randomClick(){
//随机坐标,各缩减20px,防止误触
x = random(500, 700)
y = random(20, 1420)
//点击随机坐标区域翻页
click(x, y)
}


//删除已读数目
function deleteBook(){
    //长按图书,坐标就是第一本书的位置
    //press(x, y, 1500)
    id("i_reader_folder").indexInParent(0).findOne().longClick()
    //删除图书
    text("删除").findOne().click()
    //要确认删除了
    id("confirm").findOne().click()
    //右上角完成
    text("完成").findOne().click()
}



//点击打卡文本
click(text["立即打卡"])

//打印结束
toast("打卡结束")

//定义一个混入对象
var myMixin = {
    created: function(){
        this.hello()
    },
    methods: {
        hello: function(){
            console.log('hello from mixin")
        }
    }
}

//定义一个使用混入对象的组件
var Component = Vue.extend({
    mixins: [myMixin]
})

var component = new Component() //=> 'hello from mixin'

var mixin = {
  data: function () {
    return {
      message: "hello",
      foo: "abc",
    };
  },
};
new Vue({
  mixins: [mixin],
  data: function () {
    return {
      message: "goodbye",
      bar: "def",
    };
  },
  created: function () {
    console.log(this.$data);
    // => { message: 'goodbye', foo:'abc', bar: 'def'}
  },
});

var mixin = {
  created: function () {
    console.log("混入对象钩子被调用");
  },
};

new Vue({
  mixins: [mixin],
  created: function () {
    console.log("组件钩子被调用");
  },
});

//=> '混入对象钩子被调用'
//=> '组件钩子被调用'

var mixin = {
  methods: {
    foo: function () {
      console.log("foo");
    },
    conficting: function () {
      console.log("from mixin");
    },
  },
};

var vm = new Vue({
  mixins: [mixin],
  methods: {
    bar: function () {
      console.log("bar");
    },
    conficting: function () {
      console.log("from self");
    },
  },
});

vm.foo(); // => "foo"
vm.bar(); // => "bar"
vm.conflicting(); // => "from self"

// 为自定义的选项 'myOption' 注入一个处理器。
Vue.mixin({
  created: function () {
    var myOption = this.$options.myOption;
    if (myOption) {
      console.log(myOption);
    }
  },
});

new Vue({
  myOption: "hello!",
});
// => "hello!"

Vue.config.optionMergeStrategies.myOption = function (toVal, fromVal) {
  // 返回合并后的值
};

var strategies = Vue.config.optionMergeStrategies;
strategies.myOption = strategies.methods;

const merge = Vue.config.optionMergeStrategies.computed;
Vue.config.optionMergeStrategies.vuex = function (toVal, fromVal) {
  if (!toVal) return fromVal;
  if (!fromVal) return toVal;
  return {
    getters: merge(toVal.getters, fromVal.getters),
    state: merge(toVal.state, fromVal.state),
    actions: merge(toVal.actions, fromVal.actions),
  };
};

//注册一个全局自定义指令v-focus
Vue.directive("focus", {
  //当被绑定的元素插入到DOM中时...
  inserted: function (el) {
    //聚焦元素
    el.focus();
  },
});

directives: {
    focus: {
        //指令的定义
        inserted: function(el){
            el.focus()
        }
    }
}

<input v-focus>

//html
<div id="hook-arguments-example" v-demo:foo.a.b="message"></div>

//js
Vue.directive('demo', {
  bind: function (el, binding, vnode) {
    var s = JSON.stringify
    el.innerHTML =
      'name: '       + s(binding.name) + '<br>' +
      'value: '      + s(binding.value) + '<br>' +
      'expression: ' + s(binding.expression) + '<br>' +
      'argument: '   + s(binding.arg) + '<br>' +
      'modifiers: '  + s(binding.modifiers) + '<br>' +
      'vnode keys: ' + Object.keys(vnode).join(', ')
  }
})

new Vue({
  el: '#hook-arguments-example',
  data: {
    message: 'hello!'
  }
})

<div id="baseexample">
    <p>Scroll down this page</p>
    <p v-pin="200">Stick me 200px from the top of the page<p>
</div>

Vue.directive('pin', {
    bind: function(el, bingding, vnode){
        el.style.position = 'fixed'
        el.style.top = binding.value + 'px'
    }
})

new Vue({
    el: '#baseexample"
})

<div id="dynamicexample">
    <p>Scroll down this page</p>
    <p v-pin:[direction]="200">I am pinned onto the page at 200px to the left.<p>
</div>

Vue.directive("pin", {
  bind: function (el, binding, vnode) {
    el.style.position = "fixed";
    var s = binding.arg == "left" ? "left" : "top";
    el.style[s] = binding.value + "px";
  },
});

new Vue({
  el: "#dynamicexample",
  data: function () {
    return {
      direction: "left",
    };
  },
});

Vue.directive("color-swatch", function (el, binding) {
  el.style.backgroundColor = binding.value;
});

//html
<div v-demo="{ color: 'white', text: 'hello!' }"></div>;
//js
Vue.directive("demo", function (el, binding) {
  console.log(binding.value.color); // => "white"
  console.log(binding.value.text); // => "hello!"
});

Vue.use(MyPlugin, { someOption: true });

MyPlugin.install = function (Vue, options) {
  //1. 添加全局方法或属性
  Vue.myGlobalMethod = function () {
    //逻辑..
  };

  //2.添加全局资源
  Vue.directive("my-directive", {
    bind(el, binding, vnode, oldVnode) {
      //逻辑
    },
    //...
  });

  //3. 注入组件选项
  Vue.mixin({
    created: function () {
      //逻辑...
    },
    //...
  });

  //4. 添加实例方法
  Vue.prototype.$myMethod = function (methodOptions) {
    //逻辑...
  };
};

<!-- 在双花括号中 -->
{{ message | capitalize }}

<!-- 在 `v-bind` 中 -->
<div v-bind:id="rawId | formatId"></div>

filters: {
  capitalize: function (value) {
    if (!value) return ''
    value = value.toString()
    return value.charAt(0).toUpperCase() + value.slice(1)
  }
}

Vue.filter("capitalize", function (value) {
  if (!value) return "";
  value = value.toString();
  return value.charAt(0).toUpperCase() + value.slice(1);
});

new Vue({
  // ...
});

{
  {
    message | filterA | filterB;
  }
}

{
  {
    message | filterA("arg1", arg2);
  }
}

<style>
@media (min-width: 700px) and (orientation: landscape){
  // 大于700px执行display：none
    .sidebar {
        display: none;
        }
    }
</style>

var canvas = getElementById("canvas");
var context = canvas.getContext("2d");
//使用context进行绘制

<body>
<canvas id="canvas" sytle="border: 1px solid #aaa;display: block;margin: 50px auto;"></canvas>
<script>
    window.onload = function(){
        var canvas = document.getElementById("canvas")
        canvas.width: 1024;
        canvas.height: 768;
        if(canvas.getContext("2d")){
            //如果浏览器支持canvas,可以使用
            var context = canvas.getContext("2d")
        }else{
            alert('当前浏览器不支持,请使用谷歌浏览器')
        }
    }
</script>
</body>

let pageWidth = document.documentElement.clientWidth;
let pageHeight = document.documentElement.clientHeight;

canvas.width = pageWidth;
canvas.height = pageHeight;

var context = canvas.getContext("2d");
conext.beginPath(); //开始第一段绘制,与其他绘制可以区别开
context.moveTo(100, 100); //以画布左上角为原点,从坐标(100,100)开始
context.lineTO(700, 700); //把线画到(700,700)位置
context.lineTO(100, 700); //折到(100,700)位置
context.lineTO(100, 100); //线段完成封闭,形成三角形
context.closePath(); //结束本段状态

context.fillStyle = "rgab(168,168,168)"; //设置三角形填充颜色
context.fill(); //执行填充颜色

context.lineWidth = 5; //设置线段宽度
context.strokeStyle = "red"; //设置线段颜色
context.stroke; //执行绘图

conext.beginPath(); //开始第二段绘制,与其他绘制可以区别开
context.moveTo(200, 100); //以画布左上角为原点,从坐标(200,100)开始
context.lineTO(700, 600); //把线画到(700,600)位置
context.closePath(); //结束本段状态

context.strokeStyle = "blue"; //设置线段颜色
context.stroke; //执行第二段绘图

<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <title>JS Bin</title>
</head>
<body>
<canvas id="canvas"></canvas>
    <div id="actions"class="actions x">

        <svg id="pen"class="icon">
            <use xlink:href="#icon-pencil"></use>
        </svg>

        <svg id="eraser"class="icon">
            <use xlink:href="#icon-eraser"></use>
        </svg>

        <svg id="clear"class="icon">
            <use xlink:href="#icon-delete"></use>
        </svg>

        <svg id="download"class="icon">
            <use xlink:href="#icon-download"></use>
        </svg>


    <ul class='colorCir'>
        <li id="black"class="black"></li>
        <li id="red"class="red"></li>
        <li id="yellow"class="yellow"></li>
        <li id="blue"class="blue"></li>
    </ul>

    <ul class='lineWidth'>
        <li id="thin" class="thin"></li>
        <li id="thick" class="thick"></li>
    </ul>
    </div>
</body>
</html>

*{
    margin:0;
    padding:0;
}
body{
    background:#eee
}
ul,ol{
    list-style: none;
}

.colorCir{
    top:60px;
    left:20px;
    position: fixed;
}
.colorCir li{
    border: 1px solid grey;
    height:20px;
    width: 20px;
    border-radius: 50%;
    margin-bottom:10px;
}

.colorCir .red{
    background:red;
}
.colorCir .yellow{
    background:yellow;
}
.colorCir .blue{
    background:blue;
}
.colorCir .black{
    background:black;
}

.colorCir .red.active{
    transform: scale(1.2);
    transition: all 0.3s;
}
.colorCir .yellow.active{
    transform: scale(1.2);
    transition: all 0.3s;
}
.colorCir .blue.active{
    transform: scale(1.2);
    transition: all 0.3s;
}
.colorCir .black.active{
    transform: scale(1.2);
    transition: all 0.3s;
}

.icon {
    width: 1em; height: 1em;
    vertical-align: -0.15em;
    fill: currentColor;
    overflow: hidden;
 }

body{
    overflow: hidden;
}
#canvas{
    display: block;
    position: fixed;
    top:0px;
    left:0px;
}

.actions{
    position: fixed;
    top:0px;
    left:0px;
    padding-top:20px;
    padding-left:15px;
}
.actions svg{
    width:1.5em;
    height:1.5em;
    transition: all 0.3s;
    margin:0 5px;
}

.actions svg.active{
    fill:red;
    transform: scale(1.2);
}

.lineWidth{
    position: relative;
    left:-10px;
    top:140px;
}

.lineWidth .thin{
    height:0px;
    width:40px;
    border-top:2px solid black;
    margin:15px;
}

.lineWidth .thick{
    height:0px;
    width:40px;
    border-top:6px solid black;
    margin:15px;
}

.lineWidth .thin.active{
    transform: scale(1.2);
}

.lineWidth .thick.active{
    transform: scale(1.2);
}

var canvas = document.getElementById("canvas");
var context = canvas.getContext("2d");

var using = false;
var lastPoint = {
  x: undefined,
  y: undefined,
};

/*画板逻辑 */
autoSetSize(canvas);

listenToUser(canvas);

/********/
//画笔、橡皮擦按钮替换
var eraserEnabled = false;

pen.onclick = function () {
  eraserEnabled = false;
  pen.classList.add("active");
  eraser.classList.remove("active");
};
eraser.onclick = function () {
  eraserEnabled = true;
  eraser.classList.add("active");
  pen.classList.remove("active");
};

//颜色替换并高亮
red.onclick = function () {
  context.fillStyle = "red";
  context.strokeStyle = "red";
  red.classList.add("active");
  yellow.classList.remove("active");
  blue.classList.remove("active");
  black.classList.remove("active");
};
yellow.onclick = function () {
  context.fillStyle = "yellow";
  context.strokeStyle = "yellow";
  yellow.classList.add("active");
  red.classList.remove("active");
  blue.classList.remove("active");
  black.classList.remove("active");
};
blue.onclick = function () {
  context.fillStyle = "blue";
  context.strokeStyle = "blue";
  blue.classList.add("active");
  yellow.classList.remove("active");
  red.classList.remove("active");
  black.classList.remove("active");
};
black.onclick = function () {
  context.fillStyle = "black";
  context.strokeStyle = "black";
  black.classList.add("active");
  yellow.classList.remove("active");
  blue.classList.remove("active");
  red.classList.remove("active");
};
/********/

thin.onclick = function () {
  thin.classList.add("active");
  thick.classList.remove("active");
  context.lineWidth = 2;
};

thick.onclick = function () {
  thick.classList.add("active");
  thin.classList.remove("active");
  context.lineWidth = 4;
};

clear.onclick = function () {
  context.clearRect(0, 0, canvas.clientWidth, canvas.clientHeight);
};

download.onclick = function () {
  var url = canvas.toDataURL("image/png");
  var a = document.createElement("a");
  document.body.appendChild(a);
  a.href = url;
  a.download = "my drawing";
  a.click();
};

//drawLine
function drawLine(x1, y1, x2, y2) {
  context.beginPath();
  context.moveTo(x1, y1);
  context.lineTo(x2, y2);
  context.stroke();
  context.closePath();
}

//drawCir
function drawCir(x, y) {
  context.beginPath();
  context.arc(x, y, 0.1, 0, Math.PI * 2);
  context.fill();
}

//重置canvas画板宽高
function setCanvasSize() {
  var pageWidth = document.documentElement.clientWidth;
  var pageHeight = document.documentElement.clientHeight;

  canvas.width = pageWidth;
  canvas.height = pageHeight;
}

//自动设置canvas画板宽高
function autoSetSize() {
  setCanvasSize();
  window.onresize = function () {
    setCanvasSize();
  };
}
function preventBehavior(e) {
  e.preventDefault();
}

document.addEventListener("touchmove", preventBehavior, false);

function listenToUser() {
  //特性检测
  if (document.body.ontouchstart !== undefined) {
    //是触屏设备
    canvas.ontouchstart = function (aaa) {
      var x = aaa.touches[0].clientX;
      var y = aaa.touches[0].clientY;
      using = true;
      lastPoint = { x: x, y: y };
      if (eraserEnabled) {
        context.clearRect(x - 10, y - 10, 20, 20);
      } else {
        drawCir(x, y);
      }
    };
    //
    canvas.ontouchmove = function (aaa) {
      var x = aaa.touches[0].clientX;
      var y = aaa.touches[0].clientY;
      var newPoint = { x: x, y: y };
      if (using) {
        if (eraserEnabled) {
          context.clearRect(x - 10, y - 10, 20, 20);
        } else {
          drawCir(x, y);
          drawLine(lastPoint.x, lastPoint.y, newPoint.x, newPoint.y);
          lastPoint = newPoint;
        }
      }
    };
    canvas.ontouchend = function (aaa) {
      using = false;
    };
  } else {
    //不是触屏设备
    canvas.onmousedown = function (aaa) {
      var x = aaa.clientX;
      var y = aaa.clientY;
      using = true;
      lastPoint = { x: x, y: y };
      if (eraserEnabled) {
        context.clearRect(x - 10, y - 10, 20, 20);
      } else {
        drawCir(x, y);
      }
    };

    //鼠标移动监听
    canvas.onmousemove = function (aaa) {
      var x = aaa.clientX;
      var y = aaa.clientY;
      var newPoint = { x: x, y: y };
      if (using) {
        if (eraserEnabled) {
          context.clearRect(x - 10, y - 10, 20, 20);
        } else {
          drawCir(x, y);
          drawLine(lastPoint.x, lastPoint.y, newPoint.x, newPoint.y);
          lastPoint = newPoint;
        }
      }
    };
    //鼠标松开监听
    canvas.onmouseup = function (aaa) {
      using = false;
    };
  }
}

npm install chart.js --save

<script src="https://cdn.bootcss.com/Chart.js/2.8.0-rc.1/Chart.bundle.min.js"></script>

import Chart from 'chart.js';
var myChart = new Chart(ctx, {...});

<body>
<canvas id="myChart" width="400" height="400"></canvas>
</body>

<script>
// 获取我们要选择的canvas元素的上下文

var ctx = document.getElementById("myChart").getContext("2d");
var myNewChart = new Chart(ctx, {...});


// 使用jQuery获取上下文-使用jQuery的.get（）方法。
var ctx = $("#myChart").get(0).getContext("2d");

// 这将获取jQuery集合中第一个返回的节点。
var myNewChart = new Chart(ctx);
</script>

Chart.defaults.global.responsive = true;

var myLineChart = new Chart(ctx, {
  type: "line",
  data: data,
  options: options,
});

var data = {
  //横坐标显示的值
  labels: [2014, 2015, 2016, 2017, 2018, 2019],
  datasets: [
    {
      //第一条线表示优酷
      label: "优酷",
      //设定data数值,表示每年用户总量
      data: [100, 200, 400, 800, 1600],
    },
    {
      //第二条线表示YouTube
      label: "YouTube",
      data: [50, 100, 200, 400, 600],
    },
  ],
};

var options = {
  //设置缩放
  scales: {
    //设置Y轴
    yAxes: [
      {
        //刻度
        ticks: {
          //固定最大最小
          min: 0,
          max: 2000,

          //建议最大最小
          suggestedMin: 0,
          suggestedMax: 2000,

          //跨度
          stepSize: 400,

          //用回调函数设置单位
          callback: function (value, index, values) {
            return value + "人";
          },
        },
      },
    ],
  },
};

var options = {
    //设置标题
    title: {
        display: true,
        text: '阿银',
        fontColor: 'black',
        fontSize: '24',
        position: 'top'
    },
    legend: {
        //设置图例
        position: 'left',
        display: true
    },
    animation: {
        //动态效果,为0时禁用动画
        duration: 1000,
        easing: 'easeOutQuart'
    }

var data = {
    labels: [2014,2015,2016,2017,2018,2019],
    datasets: [
        {
            label:  '优酷',
            data: [100,200,400,800,1600],
            //线段颜色
            borderColor: 'red',
            //线宽
            borderWidth: 3,
            //背景色是否填充
            fill: true,
            //背景色
            backgroundColor: 'rgba(128,0,0,0.5),
            //线段曲率,为0显示折线
            lineTension: 0,
            //折点的造型,默认是圆点.可选三角,方块,星星
            pointStyle: 'rect'
        },{
            label: 'YouTube',
            data: [50,100,200,400,600]
        }
    ]
}

var data = {
  labels: [2014, 2015, 2016, 2017, 2018],
  datasets: [
    {
      label: "优酷",
      data: [100, 200, 400, 800, 1600],
      //为每个条形单独设置颜色
      backgroundColor: ["red", "orange", "yellow", "green", "blue"],
    },
    {
      label: "YouTube",
      data: [50, 100, 200, 400, 600],
    },
  ],
};

options: {
        scales: {
            xAxes: [{
                //设置覆盖
                stacked: true
            }],
            yAxes: [{
                //设置覆盖
                stacked: true
            }]
        }
    }

var mixedChart = new Chart(ctx, {
  type: "bar",
  data: {
    datasets: [
      {
        label: "优酷",
        data: [100, 200, 400, 800, 1600],
      },
      {
        label: "YouTube",
        data: [50, 100, 200, 400, 600],
        //再改成线图
        type: "line",
        //防止填充遮盖到条形图
        fill: false,
      },
    ],
    labels: [2014, 2015, 2016, 2017, 2018],
  },
  options: options,
});

type = "radar";
var data = {
  labels: ["力量", "速度", "经验", "防守", "技术", "发球"],
  datasets: [
    {
      label: "帝国の破坏龙-马龙",
      data: [5, 5, 5, 5, 5, 5],
      backgroundColor: "rgba(247,247,9,0.2)",
    },
    {
      label: "帝国の绝凶虎-张继科",
      data: [4, 5, 5, 5, 5, 5],
      backgroundColor: "rgba(238,61,17,0.2)",
    },
  ],
};

var options = {
  scale: {
    ticks: {
      suggestedMin: 0,
      suggestedMax: 5,
      stepSize: 1,
    },
  },
  title: {
    display: true,
    text: "桌球帝国战力值",
    fontSize: "24",
  },
};

data = {
  datasets: [
    {
      data: [30, 20, 30],
      backgroundColor: ["green", "red", "yellow"],
    },
  ],

  labels: ["马龙", "张继科", "王浩"],
};

var options = {
  //50-用于甜甜圈，0-用于饼图
  cutoutPercentage: 80,
  title: {
    display: true,
    text: "桌球帝国战力值",
    fontSize: "24",
  },
};

//将文件编译到dist文件夹下
tsc --outDir dist helloworld.ts

//使用代码初始化,生成tsconfig.json
tsc --init

//修改文件内属性
//设置输出文件夹dist
"outDir": "./dist"
//设置源代码文件夹
"rootDir": "./src"

tsc - w;

let name: string = "Tom";
console.log("My name is" + name);
name = 100; //编译错误,类型不匹配

//any类型让编译器忽略检测
let name: any = "Tom";
console.log("My name is" + name);
name = 100;
console.log("My name is" + name);

//常量的定义语法
const name: type = initial_value;

//数据库连接串
const dbstr: string = "ip=192.168.2.1;port=5433;uid=ayin;pwd=123123;";
console.log(dbstr);

//数组常量
const DATA: number[] = [100, 200, 300];
console.log(DATA);

// DATA = [10,20,30]; //编译错误

//数组地址并未改变,值可以改变
//正常赋值
DATA[0] = 10;
DATA[1] = 20;
DATA[2] = 30;
console.log(DATA); //[10,20,30]

//数组元素增加
DATA[3] = 40;

//定义数组
let data: string[] = ["金", "木", "水", "火"];
console.log(data); //['金','木','水','火']
console.log(data[0]); //金

//追加赋值
data[4] = "土";

//越界赋值
data[10] = "风";

//定义三行五列的数组
let data: number[][] = [
  [1, 2, 3, 4, 5],
  [10, 20, 30, 40, 50],
  [100, 200, 300, 400, 500],
];

//打印第一行数组
console.log(data[0]); // [1,2,3,4,5]

//打印第一行第一个元素
console.log(data[0][0]); // 1

//使用枚举
enum Sex {
    MALE,
    FEMALE,
    UNKNOWN
}

let member_sex: Sex = Sex.FEMALE //默认为FEMALE
console.log(member_sex) //输出1
console.log(Sex[member_sex]) //输出FEMALE

//判断中枚举需要在传入对象前加字符+
switch (+member_sex){
    case Sex.MALE:
        console.log("男")
        break
    case Sex.FEMALE:
        console.log("女")
        break
    case Sex.UNKNOWN:
        console.log("未知")
        break
}

//或者将判断套入函数中
function checkSex(sex: Sex){
    let result:string = ''
    switch (sex){
    case Sex.MALE:
        console.log("男")
        break
    case Sex.FEMALE:
        console.log("女")
        break
    case Sex.UNKNOWN:
        console.log("未知")
        break
}
    return result
}