not - typescript object

no se puede volver a declarar la variable de ámbito de bloque(mecanografiado)

Question

Estoy construyendo una aplicación de nodo, y dentro de cada archivo en .js solía hacer esto para requerir en varios paquetes.

let co = require("co");

Pero conseguir

¿Entonces, usando el mecanografiado parece que solo puede haber una de esas declaraciones / requisitos en todo el proyecto? Estoy confundido acerca de esto, ya que pensé que let estaba en el archivo actual.

Acabo de tener un proyecto que estaba funcionando, pero después de un refactor ahora estoy recibiendo estos errores por todas partes.

Alguien puede explicar?

Answer 1

Con respecto al error en sí, let se usa para declarar variables locales que existen en ámbitos de bloque en lugar de ámbitos de función. También es más estricto que var , por lo que no puede hacer cosas como esta:

if (condition) {
let a = 1;
...
let a = 2;
}

También tenga en cuenta que las cláusulas de case dentro de los bloques de switch no crean sus propios ámbitos de bloque, por lo que no puede volver a declarar la misma variable local en varios case sin usar {} para crear un bloque cada uno.

En cuanto a la importación, es probable que obtenga este error porque TypeScript no reconoce sus archivos como módulos reales, y aparentemente las definiciones a nivel de modelo terminan siendo definiciones globales para él.

Intente importar un módulo externo de la forma ES6 estándar, que no contiene una asignación explícita, y debe hacer que TypeScript reconozca sus archivos correctamente como módulos:

import * as co from "./co"

Esto todavía dará como resultado un error de compilación si ya tiene algo llamado co , como se esperaba. Por ejemplo, esto va a ser un error:

import * as co from "./co"; // Error: import definition conflicts with local definition
let co = 1;

Si recibe un error "no se puede encontrar el módulo co" ...

TypeScript ejecuta una verificación de tipo completa en los módulos, por lo que si no tiene definiciones de TS para el módulo que está intentando importar (por ejemplo, porque es un módulo JS sin archivos de definición), puede declarar su módulo en un .d.ts archivo de definición que no contiene exportaciones a nivel de módulo:

declare module "co" {
declare var co: any;
export = co;
}

Answer 2

La mejor explicación que pude obtener es de la publicación de Tamas Piro .

TLDR; TypeScript utiliza las tipificaciones DOM para el entorno de ejecución global. En su caso, hay una propiedad ''co'' en el objeto de la ventana global.

Para resolver esto:

1. Cambie el nombre de la variable o
2. Use módulos TypeScript y agregue una exportación vacía {}:

export{};

o

3. Configure las opciones de su compilador al no agregar tipificaciones DOM:

Edite tsconfig.json en el directorio del proyecto TypeScript.

{
"compilerOptions": {
"lib": ["es6"]
}
}

Answer 3

Recibí este error al actualizar

gulp-typecript 3.0.2 → 3.1.0

Poniéndolo de nuevo a 3.0.2 lo arregló

Answer 4

Recibí este error similar al compilar mi aplicación Node.JS Typecript:

node_modules/@types/node/index.d.ts:83:15 - error TS2451: Cannot redeclare block-scoped variable ''custom''.

La solución fue eliminar esto:

"files": [
"./node_modules/@types/node/index.d.ts"
]

y para reemplazarlo con esto:

"compilerOptions": {
"types": ["node"]
}

Answer 5

Tengo el mismo problema, y ​​mi solución se ve así:

// *./module1/module1.ts*
export module Module1 {
export class Module1{
greating(){ return ''hey from Module1''}
}
}
// *./module2/module2.ts*
import {Module1} from ''./../module1/module1'';
export module Module2{
export class Module2{
greating(){
let m1 = new Module1.Module1()
return ''hey from Module2 + and from loaded Model1: ''+ m1.greating();
}
}
}

Ahora podemos usarlo en el lado del servidor:

// *./server.ts*
/// <reference path="./typings/node/node.d.ts"/>
import {Module2} from ''./module2/module2'';
export module Server {
export class Server{
greating(){
let m2 = new Module2.Module2();
return "hello from server & loaded modules: " + m2.greating();
}
}
}
exports.Server = Server;
// ./app.js
var Server = require(''./server'').Server.Server;
var server = new Server();
console.log(server.greating());

Y en el lado del cliente también:

// *./public/javscripts/index/index.ts*
import {Module2} from ''./../../../module2/module2'';
document.body.onload = function(){
let m2 = new Module2.Module2();
alert(m2.greating());
}
// ./views/index.jade
extends layout
block content
h1= title
p Welcome to #{title}
script(src=''main.js'')
//
the main.js-file created by gulp-task ''browserify'' below in the gulpfile.js

Y, por supuesto, un trago para todo esto:

// *./gulpfile.js*
var gulp = require(''gulp''),
ts = require(''gulp-typescript''),
runSequence = require(''run-sequence''),
browserify = require(''gulp-browserify''),
rename = require(''gulp-rename'');
gulp.task(''default'', function(callback) {
gulp.task(''ts1'', function() {
return gulp.src([''./module1/module1.ts''])
.pipe(ts())
.pipe(gulp.dest(''./module1''))
});
gulp.task(''ts2'', function() {
return gulp.src([''./module2/module2.ts''])
.pipe(ts())
.pipe(gulp.dest(''./module2''))
});
gulp.task(''ts3'', function() {
return gulp.src([''./public/javascripts/index/index.ts''])
.pipe(ts())
.pipe(gulp.dest(''./public/javascripts/index''))
});
gulp.task(''browserify'', function() {
return gulp.src(''./public/javascripts/index/index.js'', { read: false })
.pipe(browserify({
insertGlobals: true
}))
.pipe(rename(''main.js''))
.pipe(gulp.dest(''./public/javascripts/''))
});
runSequence(''ts1'', ''ts2'', ''ts3'', ''browserify'', callback);
})

Actualizado. Por supuesto, no es necesario compilar archivos de mecanografía por separado. runSequence([''ts1'', ''ts2'', ''ts3''], ''browserify'', callback) funciona perfecto.

Answer 6

Use IIFE(Immediately Invoked Function Expression) , IIFE

(function () {
all your code is here...
})();