private namespace rss;
private namespace xml;
    
public function ErrorExamples() {
  	use namespace rss;
   	use namespace xml;
	trace(hello());
}
    
rss function hello():String {
      	return "hola";
    }
    
    xml function hello():String {
        return "foo";
    }

通过使用具体的引用来纠正不明确的引用。下面的示例 使用 namespace::function 这种格式指定所要使用的命名空间：

public function ErrorExamples() {
    
    trace(rss::hello());
    trace(xml::hello());
}

public override function foo():void{};

如果所要引用的类没有在使用的命名空间中定义或未定义为公共，也会出现该错误：

public class Foo{}

class D { function xx() { return 22; } }
var d:D = new D();
var x = new d.xx(); // 错误，方法不能用作构造函数
function yy() { this.a = 22; }
var z = new yy(); // 无错误，全局函数可以用作构造函数。

public function set gamma(g:Number):Number;

下面的语句是 有效的：

public function set gamma(g:Number):void;

在下面的示例中，第 3 行会生成错误，因为不存在为 xx 定义的 setter 函数：

class D { function get xx() { return 22; } }
var d:D = new D();
d.xx = 44; // 错误，属性是只读的

public int z;// 应为“public var z:int;”

import flash.utils.trace;
trace "hello"

switch(x)
{
trace(2);
case 0:  trace(0); 
break
}

var sum:int = 1 + 2 + ;

如果错误是“_ 之前应有左括号”，则表示条件表达式中可能遗漏括号，如下面的示例（有意出错）所示：

var fact:int = 1 * 2 * 3;
if fact > 2 {
	var bigger:Boolean = true;
}

var x = (5 > 2) ? 
trace(x)

文件 a.as 中包含以下代码，它试图包含文件 b.as：

import foo.bar.baz;
include "b.as"
trace(2);

文件 b.as 包含以下代码，它试图包含文件 a.as：

include "a.as"

class a extends b { }
class b extends a { }

可能使用的是超级类型，但需要的是子类型。例如：

class A {}
var a:A = new A(); 
class B extends A { function f() }
var b : B = a // 错误

最后一个语句会出错，因为该语句尝试将类型 A 的对象赋给类型 B 的变量。

同样，下面定义的 foo() 函数采用了类型为 B 的参数。语句 foo(a); 会出错，因为该语句试图使用类型为 A 的参数：

function foo(x:B) { }
foo(a);

此外，下面的语句也会出错，因为 foo2() 的返回值必须为类型 B：

function foo2():B { return new A(); }

var i:int = 44;
var str:String = i.assortment;

huh = 55;

class A { static function goo(x:int,y:int) 
{ return(x+y); } }

下面的语句可能会出错，因为该语句提供了三个参数：

A.goo(1,2,3);

下面的代码示例可以正确地将变量 x 转换为相同类型：

function test()
{
	var x:int = 3;
	for(var x:int = 33; x < 55; x++)
	trace(x);
	for(var x:int = 11; x < 33; x++)
	trace(x)
}

下面的代码示例会生成错误，因为变量声明和 for 循环中的类型转换是不同的：

function test()
{
	var x:String = "The answer is";
	for(var x:int = 33; x < 55; x++) // 错误
	trace(x);
	for(var x:unit = 11; x < 33; x++) // 错误
	trace(x)
}

interface A {  public function f();  };
class C implements A,A {
public function f() { trace("f"); }
}

正确的实现语句应为 class C implements A {。

function topLevel() { trace("top"); }
topLevel = function() { trace("replacement works in ~");} // 错误

function f(x):int
{
if (x)
    	return 2;
else
    	return 3;
} // 无错误

但是，下面的函数 g(x) 会生成该错误，因为 switch 语句并非总是返回值。

function g(x:int):int
{
switch(x)
{
      	case 1: return 1;
      	case 2: return 2:
}
// return 2;//取消注释可清除该错误
}

只有函数声明的返回类型不是 void 时，才启用此检查。

p.huh = 55;