分类 默认分类 下的文章

sass语法

4.继承
sass中，选择器继承可以让选择器继承另一个选择器的所有样式，并联合声明。使用选择器的继承，要使用关键词@extend，后面紧跟需要继承的选择器。

//sass style
//-------------------------------
h1{
  border: 4px solid #ff9aa9;
}
.speaker{
      @extend h1;
      border-width: 2px;
}

//css style
//-------------------------------
h1,.speaker{
      border: 4px solid #ff9aa9;
}
.speaker{
      border-width: 2px;
}

sass语法

1.文件后缀名

//文件后缀名为sass的语法
body
  background: #eee
  font-size:12px
p
  background: #0982c1

//文件后缀名为scss的语法  
body{
    background: #eee;
    font-size:12px;
}
p{
  background: #0982c1;
}

2.导入
sass的导入(@import)规则和CSS的有所不同，编译时会将@import的scss文件合并进来只生成一个CSS文件。但是如果你在sass文件中导入css文件如@import 'reset.css'，那效果跟普通CSS导入样式文件一样，导入的css文件不会合并到编译后的文件中，而是以@import方式存在。
所有的sass导入文件都可以忽略后缀名.scss。一般来说基础的文件命名方法以_开头，如_mixin.scss。这种文件在导入的时候可以不写下划线，可写成@import "mixin"。

被导入sass文件a.scss：

//a.scss
//-------------------------------
body {
      background: #eee;
}

需要导入样式的sass文件b.scss：

@import "reset.css";
@import "a";
p{
  background: #0982c1;
}

转译出来的b.css样式：

@import "reset.css";
body{
     background: #eee;
}
p{
  background: #0982c1;
}

根据上面的代码可以看出，b.scss编译后，reset.css继续保持import的方式，而a.scss则被整合进来了

3.嵌套(Nesting)
sass的嵌套包括两种：一种是选择器的嵌套；另一种是属性的嵌套。我们一般说起或用到的都是选择器的嵌套。
选择器嵌套
所谓选择器嵌套指的是在一个选择器中嵌套另一个选择器来实现继承，从而增强了sass文件的结构性和可读性。在选择器嵌套中，可以使用&表示父元素选择器。

//sass style
//-------------------------------
#top_nav{
      line-height: 40px;
      text-transform: capitalize;
      background-color:#333;
li{
    float:left;
  }
a{
    display: block;
    padding: 0 10px;
    color: #fff;

&:hover{
  color:#ddd;
  }
 }
}

//css style
//-------------------------------
#top_nav{
      line-height: 40px;
      text-transform: capitalize;
      background-color:#333;
}  
#top_nav li{
      float:left;
}
#top_nav a{
      display: block;
      padding: 0 10px;
      color: #fff;
}
#top_nav a:hover{
      color:#ddd;
}

属性嵌套
所谓属性嵌套指的是有些属性拥有同一个开始单词，如border-width，border-color都是以border开头。

//sass style
//-------------------------------
.fakeshadow {
      border: {
        style: solid;
      left: {
        width: 4px;
        color: #888;
      }
     right: {
        width: 2px;
        color: #ccc;
     }
   }
 }

//css style
//-------------------------------
.fakeshadow {
      border-style: solid;
      border-left-width: 4px;
      border-left-color: #888;
      border-right-width: 2px;
      border-right-color: #ccc; 
}

当然这只是个属性嵌套的例子，如果实际这样使用，那估计得疯掉

TypeScript

1、装饰器（Decorators）为我们在类的声明及成员上通过元编程语法添加标注提供了一种方式。必须要启用。
tsconfig.json:
{

"compilerOptions": {
    "target": "ES5",
    "experimentalDecorators": true
}

}

2、装饰器是一种特殊类型的声明，它能够被附加到类声明，方法， 访问符，属性或参数上。 装饰器使用@expression这种形式，expression求值后必须为一个函数，它会在运行时被调用，被装饰的声明信息做为参数传入。

3、TypeScript支持为带有装饰器的声明生成元数据。 你需要在命令行或 tsconfig.json里启用emitDecoratorMetadata编译器选项。
tsconfig.json:
{

"compilerOptions": {
    "target": "ES5",
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true
}

}

4、模块在其自身的作用域里执行，而不是在全局作用域里；这意味着定义在一个模块里的变量，函数，类等等在模块外部是不可见的，除非你明确地使用export形式之一导出它们。相反，如果想使用其它模块导出的变量，函数，类，接口等的时候，你必须要导入它们，可以使用 import形式之一
导出：
class ZipCodeValidator implements StringValidator { isAcceptable(s: string) { return s.length === 5 && numberRegexp.test(s); } } export { ZipCodeValidator }; export { ZipCodeValidator as mainValidator };
导入：
import { ZipCodeValidator } from "./ZipCodeValidator";
let myValidator = new ZipCodeValidator();
可以对导入内容重命名
import { ZipCodeValidator as ZCV } from "./ZipCodeValidator";let myValidator = new ZCV();

TypeScript 基本语法

TypeScript 是微软开发的 JavaScript 的超集，TypeScript兼容JavaScript，可以载入JavaScript代码然后运行。TypeScript与JavaScript相比进步的地方 包括：加入注释，让编译器理解所支持的对象和函数，编译器会移除注释，不会增加开销；增加一个完整的类结构，使之更新是传统的面向对象语言。
TypeScript 微软官方网站 http://www.typescriptlang.org/
TypeScript 源码 http://typescript.codeplex.com
1.基本数据类型
Boolean
//Booleanvar isDone:boolean = false;
Number
//Numbervar width:number = 100;
String
//Stringvar name:string = "hello";
Array
//Arrayvar list:number[] = [1, 2, 3];
var list:Array=[1, 2, 3];
Enum
//EnumenumColor{Red, Green, Blue}
varc: Color = Color.Red;
alert(c);//默认值从0开始，alert(0);//可以手动指定值enumColor1{Red = 1, Green, Blue}
var c1: Color1 = Color1.Green;
alert(c1);//alert(2)//根据值查找名称enumColor2{Red = 1, Green=2, Blue=4}
var c2: string = Color2[4];
alert(c2);//alert(Blue)
Any
//不确定类型，退出编译检查var notSure: any = 4;
notSure = "maybe a string instead";
notSure = false; // okay, definitely a boolean//不确定数组元素类型var anylist:any[] = [1, true, "free"];
anylist[1] = 100;
Void
//空白functionwarnUser(): void {

alert(123);

}
2.类
基本语法
classAnimal{

animalName:string;

constructor(name:string) {
    this.animalName = name;
}

sayHello() {
    alert(this.animalName + ": Hello");
}

}

var tom = new Animal("Tom");
tom.sayHello();//alert(Tom:Hello)
继承
classAnimal{

animalName:string;

constructor(name:string) {
    this.animalName = name;
}

sayHello() {
    alert(this.animalName + ": Hello");
}

}

classCatextendsAnimal{

//重写sayHello方法
sayHello() {
    alert(this.animalName + "(Cat)：" + "Hello");
}

}

classMouseextendsAnimal{

sayHello() {
    alert(this.animalName + "(Mouse)：" + "Hello");
}

}

var tom:Animal = newCat("Tom");
tom.sayHello();//alert(Tom(Cat):Hello)var jerry:Animal = newMouse("Jerry");
jerry.sayHello();//alert(Jerry(Mouse):Hello)
修饰符
当我们把animalName 改为private
classAnimal{

private animalName:string;//默认是public

constructor(name:string) {
    this.animalName = name;
}
//...

}

classCatextendsAnimal{

//重写sayHello方法
sayHello() {
    alert(this.animalName + "(Cat)：" + "Hello");//Error 编译不通过
}

}
get，set 访问器
classAnimal {

private _animalName:string;//默认是publicgetanimalName():string{
    returnthis._animalName;
}

setanimalName(name:string):string{
    this._animalName = name;
}

//...

}
静态属性
//静态属性classTable{

static width = 100;
static height = 200;

}

var width = Table.width;
alert(width);//alert(100)
3.接口
基本语法
interface ICar {

color:string;

}

class Bus implements ICar {

color:string;
constructor() {
    this.color = "Blue";
}

}

var bus = new Bus();
alert(bus.color);
继承接口
//继承接口interface Shape {

color: string;

}

interface PenStroke {

penWidth: number;

}

interface Square extends Shape, PenStroke {

sideLength: number;

}
可选属性
interface ICar {

color:string;
safetyDevice?:any;//实现类无需实现

}

functionMoveCar(car:ICar){

if(car.safetyDevice)
{
    alert("The car is safe");
}
else
{
    alert("The car is not safe");
}

}
4.模块（Modules）
作用：1.防止命名空间冲突；2.将一个功能模块很容易的划分到不同文件中，更容易维护；
基本语法
module MyDemo {

exportinterface IDemo {

}

exportclass Demo implements IDemo {

}

}
别名
module Shapes {

exportmodule Polygons {
    exportclassTriangle{ }
    exportclassSquare{ }
}

}

import polygons = Shapes.Polygons;
var sq = new polygons.Square(); // 类似于 'new Shapes.Polygons.Square()'
5.函数（Function）
基本语法
function add(x:number, y:number):number {

return x + y;

}
// or
var myAdd = function (x:number, y:number):number {

return x + y;

};
完整的函数类型
var myAdd:(x:number, y:number)=>number =

function (x:number, y:number):number {
    return x + y;
};

为了增强可读性，给参数x、y具有实际的意义，可以这样写
var myAdd:(baseValue:number, increment:number)=>number =

function (x:number, y:number):number {
    return x + y;
};

第二部分number 是一个返回类型，如果无需返回类型，请使用 'void'
第三部分的function 参数类型，根据上下文类型进行推断，可以省略
var myAdd:(baseValue:number, increment:number)=>number =

function (x, y) {
    return x + y;
};

可选参数
//可选参数functionbuildName(firstName:string, lastName?:string) {

if (lastName)
    return firstName + " " + lastName;
elsereturn firstName;

}
var result1 = buildName("Bob");
默认参数
//默认参数functionbuildNameDefaultValue(firstName: string, lastName = "Smith"){

    return firstName + " " + lastName;

}
var result1 = buildNameDefaultValue("Bob");
可变参数
例如在C#中，方法参数定义使用param int[],调用方法时，就可以传递多个int类型的参数
在TypeScript中
function buildNameRest(firstName:string, ...restOfName:string[]) {

return firstName + " " + restOfName.join(" ");

}

var employeeName = buildNameRest("Joseph", "Samuel", "Lucas", "MacKinzie")
Lambads 和this关键字
var people={

name:["张三","李四","王五","赵六"],
getName:function(){
    returnfunction(){
        var i=Math.floor(Math.random()*4);
        return {
            n:this.name[i]
        }
    }
}

}

var pname=people.getName();
alert("名字："+pname().n);
调用发现getName中的this关键字指向的是getName,访问不到外部的name属性
所以我们修改为：
var people = {

name: ["张三", "李四", "王五", "赵六"],
getName: function () {
    return  ()=> {
        var i = Math.floor(Math.random() * 4);
        return {
            n: this.name[i]
        }
    }
}

}

var pname = people.getName();
alert("名字：" + pname().n);
重载
//重载functionstudent(name:string):string;
functionstudent(age:number):number;
functionstudent(numberorage:any):any{

if (numberorage && typeof (numberorage) == "string")
    alert("姓名");
else
    alert("年龄");

}
student("Tom");//alert("姓名")
student(15);//alert("年龄")
6.泛型
基本语法
function identity(arg: T): T {

return arg;

}

//数组泛型
function identity(arg: T[]): T[] {

console.log(arg.length);

}
泛型类型（通用的函数类型）
function identity(arg:T):T {

return arg;

}
var myIdentity:(arg:T)=>T = identity;//T也可使用其他字母表示
//也可以这么写
//var myIdentity:{(arg:T): T} = identity;
接口泛型
interface GenericIdentityFn {

<T>(arg:T): T;

}

function identity(arg:T):T {

return arg;

}

var myIdentity:GenericIdentityFn = identity;
泛型类
classGenericNumber {

zeroValue:T;
add:(x:T, y:T) => T;

}

var myGenericNumber = new GenericNumber();
myGenericNumber.zeroValue = 0;
myGenericNumber.add = function(x, y){

return x + y;

};
泛型约束
interface Lengthwise {

length: number;

}

functionloggingIdentity(arg:T):T{

console.log(arg.length);
return arg;

}

loggingIdentity(3);//error
loggingIdentity({length: 10, value: 3}); //只要类型包含length属性即可
泛型类约束
classFindable
{

//...

}
functionfind(n: T, s: Findable) {

// ...

}
7.合并
合并接口
interface Box {

height: number;
width: number;

}

interface Box {

scale: number;

}

var box: Box = {height: 5, width: 6, scale: 10};
合并模块
module Animals {

exportclass Zebra { }

}

module Animals {

exportinterface Legged { numberOfLegs: number; }
exportclass Dog { }

}

//相当于
module Animals {

exportinterface Legged { numberOfLegs: number; }

exportclass Zebra { }
exportclass Dog { }

}
合并模块和类
classAlbum{

label:Album.AlbumLabel;

}
module Album {

exportclassAlbumLabel{
}

}
合并模块和函数
functionbuildLabel(name:string):string{

return buildLabel.prefix + name + buildLabel.suffix;

}

module buildLabel {

exportvar suffix = "";
exportvar prefix = "Hello, ";

}

alert(buildLabel("Sam Smith"));
合并模块与枚举
enum Color {

red = 1,
green = 2,
blue = 4

}

module Color {

exportfunctionmixColor(colorName:string) {
    if (colorName == "yellow") {
        return Color.red + Color.green;
    }
    elseif (colorName == "white") {
        return Color.red + Color.green + Color.blue;
    }
    elseif (colorName == "magenta") {
        return Color.red + Color.blue;
    }
    elseif (colorName == "cyan") {
        return Color.green + Color.blue;
    }
}

}
不能合并
类与类不能合并
接口与类不能合并
变量与类不能合并
转载请注明出处：http://www.cnblogs.com/xcong/p/4570235.html

typescript封装JS的Callback

  1. JS原型

    plus.nativeUI.prompt("请输入内容",function(e){

        return e.index == 0 ? e.value : "";
});
  2. 改写成TS服务
Prompt(msg: string): Promise<string> {
        return new Promise<string>(
            (string) => {
                plus.nativeUI.prompt(msg, (e: any) => string (
                    e.index == 0 ? e.value : ""
                ));
            });
    }

  1. 调用

    plus.Prompt("请输入").then((s: string)=>(alert(s)));

应该还有更好的方法，学习中.．．

  1. 1
  2. ...
  3. 3
  4. 4
  5. 5
  6. 6
  7. 7
  8. 8