变量声明-TS学习笔记(2)

ts之变量声明以及语法细节,ts小白初学ing sum(1,2)如果后面不写类型的话,得到的是any类型函数的返回值类型是可以推导的,也可以通过以下方式进行定义// 匿名函数,最好不要添加对应的类型,一般根据上下文进行推导}) 阅读详情

let和const是JavaScript里相对较新的变量声明方式。 像我们之前提到过的,let在很多方面与var是相似的,但是可以帮助大家避免在JavaScript里常见一些问题。 const是对let的一个增强,它能阻止对一个变量再次赋值。

因为TypeScript是JavaScript的超集,所以它本身就支持let和const。 下面我们会详细说明这些新的声明方式以及为什么推荐使用它们来代替var。

  • var 声明

一直以来我们都是通过var关键字定义JavaScript变量。

var a = 10;

大家都能理解,这里定义了一个名为a值为10的变量。

我们也可以在函数内部定义变量:

function f() {
    var message = "Hello, world!";

    return message;
}

并且我们也可以在其它函数内部访问相同的变量。

function f() {
    var a = 10;
    return function g() {
        var b = a + 1;
        return b;
    }
}
var g = f();
g(); // returns 11;

上面的例子里,g可以获取到f函数里定义的a变量。 每当g被调用时,它都可以访问到f里的a变量。 即使当g在f已经执行完后才被调用,它仍然可以访问及修改a。

function f() {
    var a = 1;

    a = 2;
    var b = g();
    a = 3;

    return b;

    function g() {
        return a;
    }
}

f(); // returns 2
  • 作用域规则

对于熟悉其它语言的人来说,var声明有些奇怪的作用域规则。 看下面的例子:

function f(shouldInitialize: boolean) {
    if (shouldInitialize) {
        var x = 10;
    }

    return x;
}

f(true);  // returns '10'
f(false); // returns 'undefined'

有些读者可能要多看几遍这个例子。 变量x是定义在if语句里面,但是我们却可以在语句的外面访问它。 这是因为var声明可以在包含它的函数,模块,命名空间或全局作用域内部任何位置被访问,包含它的代码块对此没有什么影响。 有些人称此为var作用域或函数作用域。 函数参数也使用函数作用域。

这些作用域规则可能会引发一些错误。 其中之一就是,多次声明同一个变量并不会报错:

function sumMatrix(matrix: number[][]) {
    var sum = 0;
    for (var i = 0; i < matrix.length; i++) {
        var currentRow = matrix[i];
        for (var i = 0; i < currentRow.length; i++) {
            sum += currentRow[i];
        }
    }

    return sum;
}

这里很容易看出一些问题,里层的for循环会覆盖变量i,因为所有i都引用相同的函数作用域内的变量。 有经验的开发者们很清楚,这些问题可能在代码审查时漏掉,引发无穷的麻烦。

  • 变量获取怪异之处
for (var i = 0; i < 10; i++) {
    setTimeout(function() { console.log(i); }, 100 * i);
}

代码会返回结果是:

10
10
10
10
10
10
10
10
10
10

setTimeout会在若干毫秒的延时后执行一个函数(等待其它代码执行完毕)。并且是在for循环结束后。 for循环结束后,i的值为10。 所以当函数被调用的时候,它会打印出10!

一个通常的解决方法是使用立即执行的函数表达式(IIFE)来捕获每次迭代时i的值:

for (var i = 0; i < 10; i++) {
    // capture the current state of 'i'
    // by invoking a function with its current value
    (function(i) {
        setTimeout(function() { console.log(i); }, 100 * i);
    })(i);
}

这种奇怪的形式我们已经司空见惯了。 参数i会覆盖for循环里的i,但是因为我们起了同样的名字,所以我们不用怎么改for循环体里的代码。

  • let 声明

现在你已经知道了var存在一些问题,这恰好说明了为什么用let语句来声明变量。 除了名字不同外,let与var的写法一致。

let hello = "Hello!";

主要的区别不在语法上,而是语义,我们接下来会深入研究。

  • 块作用域

当用let声明一个变量,它使用的是词法作用域或块作用域。 不同于使用var声明的变量那样可以在包含它们的函数外访问,块作用域变量在包含它们的块或for循环之外是不能访问的。

function f(input: boolean) {
    let a = 100;

    if (input) {
        // 仍然可以引用 'a'
        let b = a + 1;
        return b;
    }

    // Error: 'b' 并不存在这里
    return b;
}

这里我们定义了2个变量a和b。 a的作用域是f函数体内,而b的作用域是if语句块里。

在catch语句里声明的变量也具有同样的作用域规则。

try {
    throw "oh no!";
}
catch (e) {
    console.log("Oh well.");
}

 //Error: 'e' 不存在
console.log(e);

拥有块级作用域的变量的另一个特点是,它们不能在被声明之前读或写。 虽然这些变量始终“存在”于它们的作用域里,但在直到声明它的代码之前的区域都属于时间死区。 它只是用来说明我们不能在let语句之前访问它们,幸运的是TypeScript可以告诉我们这些信息。

a++; // illegal to use 'a' before it's declared;
let a;

注意一点,我们仍然可以在一个拥有块作用域变量被声明前获取它。 只是我们不能在变量声明前去调用那个函数。 如果生成代码目标为ES2015,现代的运行时会抛出一个错误;然而,现今TypeScript是不会报错的。

function foo() {
    // okay to capture 'a'
    return a;
}

// 不能在'a'被声明前调用'foo'
// 运行时应该抛出错误
foo();

let a;
  • 重定义及屏蔽

我们提过使用var声明时,它不在乎你声明多少次;你只会得到1个。

function f(x) {
    var x;
    var x;

    if (true) {
        var x;
    }
}

在上面的例子里,所有x的声明实际上都引用一个相同的x,并且这是完全有效的代码。 这经常会成为bug的来源。 好的是,let声明就不会这么宽松了。

let x = 10;
let x = 20; // 错误,不能在1个作用域里多次声明`x`

并不是要求两个均是块级作用域的声明TypeScript才会给出一个错误的警告。

function f(x) {
    let x = 100; // error: interferes with parameter declaration
}

function g() {
    let x = 100;
    var x = 100; // error: 不能2次声明 'x'
}

并不是说块级作用域变量不能在函数作用域内声明。 而是块级作用域变量需要在不用的块里声明。

function f(condition, x) {
    if (condition) {
        let x = 100;
        return x;
    }

    return x;
}

f(false, 0); // returns 0
f(true, 0);  // returns 100

在一个嵌套作用域里引入一个新名字的行为称做屏蔽。 它是一把双刃剑,它可能会不小心地引入新问题,同时也可能会解决一些错误。 例如,假设我们现在用let重写之前的sumMatrix函数。

function sumMatrix(matrix: number[][]) {
    let sum = 0;
    for (let i = 0; i < matrix.length; i++) {
        var currentRow = matrix[i];
        for (let i = 0; i < currentRow.length; i++) {
            sum += currentRow[i];
        }
    }

    return sum;
}

这个版本的循环能得到正确的结果,因为内层循环的i可以屏蔽掉外层循环的i。

通常来讲应该避免使用屏蔽,因为我们需要写出清晰的代码。 同时也有些场景适合利用它,你需要好好打算一下。

  • 块级作用域变量的获取

在我们最初谈及获取用var声明的变量时,我们简略地探究了一下在获取到了变量之后它的行为是怎样的。 直观地讲,每次进入一个作用域时,它创建了一个变量的环境。 就算作用域内代码已经执行完毕,这个环境与其捕获的变量依然存在。

function theCityThatAlwaysSleeps() {
    let getCity;

    if (true) {
        let city = "Seattle";
        getCity = function() {
            return city;
        }
    }

    return getCity();
}

因为我们已经在city的环境里获取到了city,所以就算if语句执行结束后我们仍然可以访问它。

回想一下前面setTimeout的例子,我们最后需要使用立即执行的函数表达式来获取每次for循环迭代里的状态。 实际上,我们做的是为获取到的变量创建了一个新的变量环境。 这样做挺痛苦的,但是幸运的是,你不必在TypeScript里这样做了。

当let声明出现在循环体里时拥有完全不同的行为。 不仅是在循环里引入了一个新的变量环境,而是针对每次迭代都会创建这样一个新作用域。 这就是我们在使用立即执行的函数表达式时做的事,所以在setTimeout例子里我们仅使用let声明就可以了。

for (let i = 0; i < 10 ; i++) {
    setTimeout(function() {console.log(i); }, 100 * i);
}

会输出与预料一致的结果:

0
1
2
3
4
5
6
7
8
9

const 声明

const 声明是声明变量的另一种方式。

const numLivesForCat = 9;
它们与let声明相似,但是就像它的名字所表达的,它们被赋值后不能再改变。 换句话说,它们拥有与let相同的作用域规则,但是不能对它们重新赋值。

这很好理解,它们引用的值是不可变的。

const numLivesForCat = 9;
const kitty = {
    name: "Aurora",
    numLives: numLivesForCat,
}

// Error
kitty = {
    name: "Danielle",
    numLives: numLivesForCat
};

// all "okay"
kitty.name = "Rory";
kitty.name = "Kitty";
kitty.name = "Cat";
kitty.numLives--;

除非你使用特殊的方法去避免,实际上const变量的内部状态是可修改的。 幸运的是,TypeScript允许你将对象的成员设置成只读的。 接口一章有详细说明。

  • let vs. const

现在我们有两种作用域相似的声明方式,我们自然会问到底应该使用哪个。 与大多数泛泛的问题一样,答案是:依情况而定。

使用最小特权原则,所有变量除了你计划去修改的都应该使用const。 基本原则就是如果一个变量不需要对它写入,那么其它使用这些代码的人也不能够写入它们,并且要思考为什么会需要对这些变量重新赋值。 使用const也可以让我们更容易的推测数据的流动。

另一方面,用户很喜欢let的简洁性。 这个手册大部分地方都使用了let。

跟据你的自己判断,如果合适的话,与团队成员商议一下。 Fortunately, TypeScript allows you to specify that members of an object are readonly. The chapter on Interfaces has the details.

解构

  • 解构数组

最简单的解构莫过于数组的解构赋值了:

let input = [1, 2];
let [first, second] = input;
console.log(first); // outputs 1
console.log(second); // outputs 2

这创建了2个命名变量 first 和 second。 相当于使用了索引,但更为方便:

first = input[0];
second = input[1];

解构作用于已声明的变量会更好:

// swap variables 交换变量
[first, second] = [second, first];

作用于函数参数:

function f([first, second]: [number, number]) {
    console.log(first);
    console.log(second);
}
f(input);

你可以使用…name语法创建一个剩余变量列表:

let [first, ...rest] = [1, 2, 3, 4];
console.log(first); // outputs 1
console.log(rest); // outputs [ 2, 3, 4 ]

当然,由于是JavaScript, 你可以忽略你不关心的尾随元素:

let [first] = [1, 2, 3, 4];
console.log(first); // outputs 1

或其它元素:

let [, second, , fourth] = [1, 2, 3, 4];

对象解构

你也可以解构对象:

let o = {
    a: "foo",
    b: 12,
    c: "bar"
}
let {a, b} = o;

这通过 o.a and o.b 创建了 a 和 b 。 注意,如果你不需要 c 你可以忽略它。

就像数组解构,你可以用没有声明的赋值:

({a, b} = {a: "baz", b: 101});

注意,我们需要用括号将它括起来,因为Javascript通常会将以 { 起始的语句解析为一个块。

  • 属性重命名

你也可以给属性以不同的名字:

let {a: newName1, b: newName2} = o;
这里的语法开始变得混乱。 你可以将 a: newName1 读做 “a 作为 newName1”。 方向是从左到右,好像你写成了以下样子:

let newName1 = o.a;
let newName2 = o.b;

令人困惑的是,这里的冒号不是指示类型的。 如果你想指定它的类型, 仍然需要在其后写上完整的模式。

let {a, b}: {a: string, b: number} = o;

默认值

默认值可以让你在属性为 undefined 时使用缺省值:

function keepWholeObject(wholeObject: {a: string, b?: number}) {
    let {a, b = 1001} = wholeObject;
}

现在,即使 b 为 undefined , keepWholeObject 函数的变量 wholeObject 的属性 a 和 b 都会有值。

  • 函数声明

解构也能用于函数声明。 看以下简单的情况:

type C = {a: string, b?: number}
function f({a, b}: C): void {
    // ...
}

但是,通常情况下更多的是指定默认值,解构默认值有些棘手。 首先,你需要知道在设置默认值之前设置其类型。

function f({a, b} = {a: "", b: 0}): void {
    // ...
}
f(); // ok, default to {a: "", b: 0}

其次,你需要知道在解构属性上给予一个默认或可选的属性用来替换主初始化列表。 要知道 C 的定义有一个 b 可选属性:

function f({a, b = 0} = {a: ""}): void {
    // ...
}
f({a: "yes"}) // ok, default b = 0
f() // ok, default to {a: ""}, which then defaults b = 0
f({}) // error, 'a' is required if you supply an argument

要小心使用解构。 从前面的例子可以看出,就算是最简单的解构也会有很多问题。 尤其当存在深层嵌套解构的时候,就算这时没有堆叠在一起的重命名,默认值和类型注解,也是令人难以理解的。 解构表达式要尽量保持小而简单。 你自己也可以直接使用解构将会生成的赋值表达式。

【TS语法|基础入门】《前端的未来——TypeScript》掌握TS基础语法 本文是我在学习TS课程中的一些学习笔记和听课记录,从这一期开始将正式进入TS的语法内容,本节内容紧接上一期【起步了解】《前端的未来——TypeScript》了解TS的工作流程的内容,重点介绍TS的基础语法。创作不易!多多关照! 阅读详情

相关推荐

【TypeScript】 ts基本语法

JavaScript(也称为ECMAScript)诞生时是一种简单的浏览器脚本语言。当它被发明时,它被期望用于在网页中嵌入简短的代码片段。这些片段通常不超过几十行。因此,早期的 Web 浏览器执行此类代码的速度非常慢。但是,随着时间的推移,JS 变得越来越流行,并且 Web 开发者开始使用它来创造交互式体验。Web 浏览器开发者通过优化执行引擎(动态编译)和扩展可以完成的功能(添加API)来应对 JS 日益增加的使用量,这反过来又使 Web 开发者更多地使用 JS。

weixin_42914989的博客 2654

angular 4版本小知识点----方便自己看

使用 Angular CLI 创建一个名为 heroes 的新组件。 ng generate component hero-detail 这个命令会做这些事: 创建目录 src/app/hero-detail。 在这个目录中会生成四个文件: 作为组件样式的 CSS 文件。 作为组件模板的 HTML 文件。 存放组件类 HeroDetailComponent 的 TypeScript 文件...

qq_20876425的博客 602

告别Colmap!在ROS2 Humble上,用Fast-LIVO2直接为3D Gaussian Splatting准备数据全流程

本文详细介绍了在ROS2 Humble环境下,使用Fast-LIVO2为3D Gaussian Splatting(3DGS)准备数据的全流程。通过优化Fast-LIVO2配置、实时数据同步机制和3DGS训练参数,显著提升了三维重建效率和质量,相比传统Colmap流程节省95%以上的预处理时间。适用于Ubuntu22.04系统,适合机器人及自动驾驶领域的三维重建应用。

weixin_28688385的博客 590

Angular2中如何使用jquery

Angular2是以TypeScript语言作为默认编码语言,所以你看到的全部都是.ts结尾的文件。 那什么是TypeScript 首先,它是一个编译型语言;既然是编译型,那么你像重构、导航、智能提醒这种工具属性就可以发挥出来,所以你会发现使用VS CODE来写Angular简直就是绝配。 同时,TypeScript还带来一些ES6/7才有特性,比如let、const

请叫我神的博客 1万+

px3 有感分析

px3 后续分析

qq_39707917的博客 3117

强化学习-动态规划

动态规划(dynamic programming)是程序设计算法中非常重要的内容,能够高效解决一些经典问题,例如背包问题和最短路径规划。动态规划的基本思想是将待求解问题分解成若干个子问题,先求解子问题,然后从这些子问题的解得到目标问题的解。动态规划会保存已解决的子问题的答案,在求解目标问题的过程中,需要这些子问题答案时就可以直接利用,避免重复计算。本章介绍如何用动态规划的思想来求解在马尔可夫决策过程中的最优策略。

qq_45481856的博客 2115

高德地图-快速上手-图层示例在angular里的实现

高德地图 快速上手 示例 地址: https://lbs.amap.com/api/javascript-api/guide/abc/quickstart 高德官方图层: https://lbs.amap.com/api/javascript-api/guide/layers/official-layers 图层 默认情况下,地图只显示标准底图,如需要叠加别的图层,可以通过map.add方法添加图层: <div id='map' style='width:1000px; height:600px;ma

web 987

保姆级教程:用GPU-Burn给你的NVIDIA Tesla服务器做个“压力体检”(附温度功耗监控脚本)

本文提供了一份详细的GPU服务器压力测试指南,重点介绍如何使用GPU-Burn工具对NVIDIA Tesla服务器进行全面的性能测试和温度功耗监控。从环境部署、多GPU测试策略到专业级监控指标解析,帮助运维人员构建标准化的GPU健康评估体系,确保AI训练和科学计算等关键业务的稳定性。

weixin_30619101的博客 397

【Angular】变量、常量声明与解构

常量 angular中 全局变量在类的外面,@Component()的上面声明 一旦赋值就不可以再改变值了;但是如果声明的变量是对象,对象里的属性值是可以被重新赋值的             变量声明方式       Angular中变量声明有两种方式,一种是let,另一种是var 作用域       let:只在块级作用域内有效       var:只在包含它的函数,模块中有效

王如霜 9523

2017全国大学生电子设计大赛B题 | 板球控制系统(四)机械设计相关

转载请注明出处。   转眼2019了诶,可能有些同学又该问了,哇向阳哥,你这个鸽子放的好,转眼大半年了一年都没更新,我也知道啊,说好的源码呢,挖的机械的坑呢?咕咕咕咕我也不想啊,我这不是懒吗!过年有空了,又到了收红包泡妹子玩游戏.......呸,学习准备比赛码代码的时候了,终于有点空闲,于是乎今晚先把机械的大坑填了。     咱话先说在最前面。机械这玩意,靠经验,也考想象力,更要命的还是出了...

王向阳的博客 3万+

STM32F103开发实战:如何用CubeMX+CLion调整Flash起始地址(附完整CMake配置)

本文详细介绍了在STM32F103开发中如何使用CubeMX和CLion工具链调整Flash起始地址,包括链接脚本修改、系统文件配置和CMake工程适配。通过实战步骤和完整配置示例,帮助开发者实现固件双备份、OTA升级等高级功能,提升嵌入式开发效率。

5b6n7m8的博客 211

angular 2.0中新出现的声明方式const,let

变量声明最近在研究angular 2.0,在写一个test的时候,发现了他申明变量的方式尽然没有见过,是这样的:const HEROES: Hero[] = [ { id: 11, name: 'Mr. Nice' }, { id: 12, name: 'Narco' }, { id: 13, name: 'Bombasto' }, { id: 14,

王鹤的博客 6167

RK3568平台开发系列讲解(外设篇)CAN的使用

📢 本篇章带大家快速了解CAN的使用。

内核笔记 2356

【TS】九天学会TS语法——2.TypeScript基本类型及变量声明

TS一共有六种基本类型,分别是number、string、boolean、any、void以及undefined。number:表示数字类型,包括整数和浮点数。string:表示字符串类型,可以使用单引号或双引号。boolean:表示布尔类型,只有 true 和 false 两个值。any:表示任意类型,可以赋值为任何类型的值。void:表示空类型,通常用于函数没有返回值的情况。");// 执行一些计算,但不返回任何值undefined:表示一个变量已经被声明,但尚未被赋值。

m0_59873661的博客 1214

大唐杯5G考前冲刺篇(回顾全文重点必看)

大唐杯习题复习指南

nimo观察者 1万+

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

【Typescript教程03】TS基本类型与变量声明

本文摘要: 《TypeScript教程-第3章》详细讲解了TS的基本类型和变量声明。重点介绍了number、string、boolean和symbol四种原始类型的特性和用法,对比let、const、var三种变量声明方式的作用域与特性差异。通过典型类型错误示例说明TS的类型检查机制,并提供10道高频面试题及解析,涵盖类型推断、联合类型等核心概念。本章为TS类型系统的基础内容,强调静态类型检查的优势,帮助开发者构建更安全可靠的代码。

silverclayz的技术分享 1193

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

【TS基础】变量声明

变量声明 let和const是JavaScript里相对较新的变量声明方式。 像我们之前提到过的, let在很多方面与var是相似的,但是可以帮助大家避免在JavaScript里常见一些问题。const是对let的一个增强,它能阻止对一个变量再次赋值。 因为TypeScript是JavaScript的超集,所以它本身就支持let和const。 下面我们会详细说明这些新的声明方式以及为什么推荐使用它们来代替var。 var 声明 一直以来我们都是通过var关键字定义JavaScript变量。 var a =

Milk~每天分享一点点,技术进步一点点 756

锂电池充电器电路设计 里面有电路

锂电池充电器电路设计 里面有电路 3.7V升压到5V电路设计。

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

TypeScript语法基础:变量声明

本文是我在学习TS课程中的一些学习笔记和听课记录,从这一期开始将正式进入TS的【变量声明】部分,本节内容紧接上一期【TS语法|基础入门】《前端的未来——TypeScript》了解TS的基础数据类型的内容,重点介绍TS的变量声明。创作不易!多多关照!

XSL_HR的博客 5948

TS学习笔记二:基础类型及变量声明

本节介绍TypeScript中的基础类型及变量声明方式的说明。TypeScript支持与JavaScript几乎相同的数据类型,此外还提供了实用的枚举类型方便我们使用。基础类型包括:数字,字符串,结构体,布尔值等。

Java、前端、小程序学习笔记、问题汇总、项目实例分享,有需要请联系。 1800

【TS语法学习】主要数据类型与变量声明时的类型注解

了解学习TypeScript中的基本数据类型,如何声明,怎样添加类型注解

Summer_Uncle的博客 1692

鸿蒙TypeScript入门学习第4天:【TS变量声明】

变量是一种使用方便的占位符,用于引用计算机内存地址。我们可以把变量看做存储数据的容器。变量使用前必须先声明,我们可以使用 var 来声明变量。

鸿蒙的技术博客 1433

【TS】JS/TS 类型转换、变量声明、解构与展开,以及五个 falsy 值

类型转化: 任意类型转字符串 String(x) (全局函数) x.toString() (局限性大,2个不能用)(ts:数字转字符串,用这个) x + '' (这个更常用) 任意类型转布尔 Boolean(x)(全局函数)(ts:用这个) !!x (老手用这个) 但,不要总想把一些东西变成布尔,或许可以直接判断在不在:if (x!==undefined) ...

sparks42的博客 7930

TS入门——变量声明、基础类型、类型断言、初识接口

在接口中进行对象的形状的描述后,后续由这个变量类型为这个接口时,对象中的属性必须按照接口的规则来定义。7、any:当我们在编程过程对于一个变量在后续的使用中的类型不确定时,就可以设为any类型,它表示任意类型,对变量进行操作后,返回的类型也是任意类型。4、数组:规定类型,后面跟着方括号表示为数组,后续给这个数组赋值时,里面的数据都是定义的类型,数组长度不限。声明的关键字依旧是var、let、const,声明变量时要指定类型,后续赋值的数据就得是这个类型的。类型断言有两种方式:一种是尖括号,一种是as语法。

gyutdcu的博客 1363

TS学习2 TS 基本语法-ts2

TypeScript 基础语法 TypeScript 程序由以下几个部分组成: 模块 函数 变量 语句和表达式 注释 TypeScript 基础类型 数据类型 关键字 描述 任意类型 any 声明为 any 的变量可以赋予任意类型的值。 数字类型 number 双精度 64 位浮点值。它可以用来表示整数和分数。let binaryLiteral: number = 0b...

廖金龙的博客 3505

TS(三):变量声明、函数

变量声明 var let const const是对let的一个增强,它能阻止对一个变量再次赋值 函数 function 函数名(参数1: 类型, 参数2: 类型): 返回值类型(void 无返回值){ /* CODE */}function getInfo(name: string, age: number): string { return name + age; } 可选参数 定义参数可传可不传(需要定义在必传参数之后)function getInfo(name: string, a

You瞧谁不起 - 道不尽世间的沧桑,诉不完人生的悲凉 1514

【TS笔记】变量声明

变量声明

m0_56688210的博客 2349
上一篇: TypeScript数据类型-TS学习笔记(1)
下一篇: IONIC2 踩坑记-(一)官方教程
github_36339094
博客等级 码龄10年 0粉丝 10原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值