// Example extracted from dartlang.org

import ''dart:async'';
import ''dart:math'' show Random;

main() async {
  print(''Compute π using the Monte Carlo method.'');
  await for (var estimate in computePi()) {
    print(''π ≅ $estimate'');
  }
}

/// Generates a stream of increasingly accurate estimates of π.
Stream<double> computePi({int batch: 1000000}) async* {
  var total = 0;
  var count = 0;
  while (true) {
    var points = generateRandom().take(batch);
    var inside = points.where((p) =&gt; p.isInsideUnitCircle);
    total += batch;
    count += inside.length;
    var ratio = count / total;
    // Area of a circle is A = π⋅r², therefore π = A/r².
    // So, when given random points with x ∈ ,
    // y ∈ , the ratio of those inside a unit circle
    // should approach π / 4. Therefore, the value of π
    // should be:
    yield ratio * 4;
  }
}

Iterable<point> generateRandom([int seed]) sync* {
  final random = new Random(seed);
  while (true) {
    yield new Point(random.nextDouble(), random.nextDouble());
  }
}

class Point {
  final double x, y;
  const Point(this.x, this.y);
  bool get isInsideUnitCircle =&gt; x * x + y * y <p> </p><p> 开始使用Dart</p><h2>TypeScript</h2><p>TypeScript 是 JavaScript 的超集；有效的 JavaScript 程序也是有效的 TypeScript 程序，但后者添加了静态类型。其编译器也可以充当从 ES2015+ 到当前实现的转译器，所以你总能获得最新的功能。</p><p>不同于许多其他语言，TypeScript 保持 JavaScript 的精神完好无缺，只增加了功能来提高代码的可靠性。这些是类型注释，以及其他类型相关的功能，使得编写 JavaScript 更加愉快，这得益于启用了静态分析器等专门的工具来帮助重构过程。另外，类型的添加改进了应用程序不同组件之间的接口。</p><p>类型推断受到支持，因此你不必从一开始就编写所有的类型。你可以编写快速解决方案，然后添加所有的类型以获取对代码的信心。</p><p>TypeScript 也支持高级的类型，如 intersection（交集） 类型 、 union（并集、联合） 类型、 类型别名、 可区分联合（discriminated union）和类型保护。你可以在 TypeScript 文档 站点的 高级类型 页面中查看所有这些类型。</p><p>如果你使用 React，则还可以通过添加 React 类型来支持 JSX。</p><pre>class Person {
    private name: string;
    private age: number;
    private salary: number;

    constructor(name: string, age: number, salary: number) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    toString(): string {
        return `${this.name} (${this.age}) (${this.salary})`;
    }
}

module Main exposing (..)

import Html exposing (..)


-- MAIN


main : Program Never Model Msg
main =
    Html.program
        { init = init
        , update = update
        , view = view
        , subscriptions = subscriptions
        }



-- INIT


type alias Model = String


init : ( Model, Cmd Msg )
init = ( "Hello World!", Cmd.none )


-- UPDATE


type Msg
    = DoNothing


update : Msg -> Model -> ( Model, Cmd Msg )
update msg model =
    case msg of
        DoNothing ->
            ( model, Cmd.none )


-- VIEW


view : Model -> Html Msg
view model =
    p [] [text model]


-- SUBSCRIPTIONS


subscriptions : Model -> Sub Msg
subscriptions model =
    Sub.none

module Main where

import Prelude
import Data.Foldable (fold)
import TryPureScript

main =
    render $ fold
      [ h1 (text "Try PureScript!")
      , p (text "Try out the examples below, or create your own!")
      , h2 (text "Examples")
      , list (map fromExample examples)
      ]
  where
    fromExample { title, gist } =
      link ("?gist="  gist) (text title)

    examples =
      [ { title: "Algebraic Data Types"
        , gist: "37c3c97f47a43f20c548"
        }
      , { title: "Loops"
        , gist: "cfdabdcd085d4ac3dc46"
        }
      , { title: "Operators"
        , gist: "3044550f29a7c5d3d0d0"
        }
      ]

一.数组的使用

1.创建数组

（1）一维数组

（2）多维数组

2.元素的获取

（1）一维数组

（2）多维数组

3.元素的设置

（1）一维数组

（2）多维数组

注：JavaScript中的数组是可以动态改变大小的，因此可以直接给一个不存在的下标设置元素值

4.数组中的方法

（1）concat

（2）join

（3）slice

（4）push,pop

（5）unshift,shift

（6）reverse

（7）sort

（8）splice

二.对象的创建与属性的操作

1.创建对象

2.增加属性，使用.操作符

3.属性的访问

4.对象直接量定义方法，利用{}

三.类

1.类的定义

function 模拟

function ClassName(){

}*/

提示：建议采用下面的形式来定义一个js中的类，可以和普通的function进行区分；建议类名首字母大写，以便更好的和普通的function进行区分

var ClassName=function(){

}

举例：

           //定义一个Book类，这个function还承担了模拟构造函数的工作
           //在使用new操作符创建Book类的对象时，这个function中的代码会被执行
           //this代表当前对象，下面执行book1的时候this指book1，执行book2的时候this指book2     
            var Book =function(name){
               //定义公有有的属性
                this.name= name;
               //定义公有的方法
               this.getName = function(){
                    returnthis.name;
                };
               this.setName = function(nname){
                   this.name = nname;
                };
            };     
            functionootest(){
               var book1 = new Book("AJAX");//这个new操作符相当于先创建了一个简单对象，调用了类的构造函数
                var book2= new Book("AJAX2");
               alert(book1.getName());
               alert(book2.getName());
               book1.setName("Java");
               alert(book1.getName());        
            }
 

改进之后的，使用上了原型,prototype

              var Book =function(name){
               //共有属性在构造方法里面定义，通过this关键字
                this.name= name;
                if(typeofBook._init ==="undefined"){
                   //共有方法在构造方法外定义，通过原型定义
                    Book.prototype.setName = function(nname){
                    this.name= nname;
                     };
                    Book.prototype.getName = function(){
                    return this.name;
                     };
                }
                Book._init= true;
            };
   
            functionootest(){  
               var book1 = new Book("AJAX");//这个new操作符相当于先创建了一个简单对象，调用了类的构造函数
               var book2= new Book("AJAX2");
               alert(book1.getName());
               alert(book2.getName());
               book1.setName("Java");
               alert(book1.getName());
          }
 

2.类的属性和方法的定义

(1)私有的属性和方法的定义及调用

                 //普通的方法
                var priObj = new function(){
                    var priname ="wang";
                    this.getName = function(){
                        return priname;
                    };
                    this.setName=function(nname){
                        priname = nname;
                    };
                };
       
               //利用匿名方法直接调用的方式,来实现一个对象拥有私有的信息
                var priObj = (function(name){
                    var priname = name;
                    return{
                        getName:function(){
                            return priname;
                        },setName:function(nname){
                            priname = nname;
                        }
                    };
                })("wang");

(2)定义公有的静态属性

            Book.staticValue = 10;
            //定义公有的静态方法
            Book.changeValue = function(){
                Book.staticValue++;
            };
 

改进之后的，使用上了原型,prototype

  var Book =function(name){
               //共有属性在构造方法里面定义，通过this关键字
                this.name= name;
                if(typeofBook._init ==="undefined"){
                   //共有方法在构造方法外定义，通过原型定义
                    Book.prototype.setName = function(nname){
                    this.name= nname;
                     };
                    Book.prototype.getName = function(){
                    return this.name;
                     };
                    Book.prototype.getCount = function(){
                    addCount();
                    return count;
                     };
                }
                Book._init= true;

(3)利用局部变量来模拟私有属性和方法

	var count= 0;
                varaddCount = function(){
                   count++;
                };
            };
    
            functionootest(){
                //根据类名反射生成对象，只知道Book,只要要传的参数"wang"
                var book =reflect("Book",["wang"]);
               alert(book.getName());
                //判断一个对象是否拥有某个属性
               //hasOwnProperty这个方法只能判断在对象上直接定义的属性，对于继承来的属性不能直接判断
                var bool =book.hasOwnProperty("name");
               alert(bool);
                //需要有一个替代方法，让getName这种继承的属性也能被判断
                var bool2 =book.hasProperty("getName");
               alert(bool2);
               
               //遍历book对象上的所有属性
                for(varproName in book){
                   alert(book[proName]);
                }
               
               //如果我们需要获得一个对象上,所有属性值不是function的属性
                varproArray = [];
                for(varproName in book){
                    vartemp = book[proName];
                   if(typeof temp !== "function"){
                       proArray.push(proName);
                    }
                }
               alert(proArray);

四.创建命名空间

1.方法:createNameSpace("SpaceName");

我想再创建一个Book类，为了避免与刚刚创建的Book冲突,因此需要一个命名空间,使新建的Book在此命名空间中,它就相当于一个包,也可以理解为 这两个Book类的路径不一样了.

  //我需要一个叫做com.wang的命名空间，然后这个Book类属于这个命名空间
    createNameSpace("com.wang");
  //定义com.wang这个命名空间上的 Book类
   com.wang.Book = function(){
                    
     }
   varcomwangBook = new com.wang.Book ();
               
   };    

2.创建命名空间上的辅助方法

functioncreateNameSpace(nameSpace){
                 //com.wang，如果需要建立命名空间，实际上就是要保证有一个com的对象，并且com中有一个wang的属性值，这个属性值也是一个对象
                  varattrs = nameSpace.split(".");

(1)判断根节点对象是否存在，不存在才进行创建

                 var obj;
                  try{
                      obj= eval(attrs[0]);
                 }catch(e){
                     window[attrs[0]] = [];
                      obj= window[attrs[0]];
                  }

(2)对根节点对象（命名空间）下面的子孙对象进行逐一的遍历判断，如果不存在，就进行创建

   for (vari = 1;i<attrs.length ; i++){
                    if(obj[attrs[i]] === undefined){
                        obj[attrs[i]] = {};
                     }
                    
                    //修改当前对象，继续进行遍历
                     obj =obj[attrs[i]];
                 }
              }

(3)扩展Object类的方法,判断当前对象是否有某个属性

  Object.prototype.hasProperty=function(){
                   return(this && this[proName])!== undefined;
                }

(4)反射创建对象方法

    //第一个参数是类名
          //第二个参数是创建对象需要的所有参数组成的数组
           functionreflect(className,args){
               try{
                  //如何把字符串类型的className转换成对应的一个函数
                   varrClass = eval(className);
                  //为了创建对象需要的所有参数在一个数组里面["1","2"];
                  //最终我们调用new创建的时候,参数表的写法应该("1","2");
                   varoargs = args.join(",");
                   var obj= new rClass(oargs);
                   returnobj;
               }catch(e){
                   returnnull;
               }         
           }