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";
    }

Berichtigen Sie einen mehrdeutigen Verweis, indem Sie den Verweis genauer bezeichnen. Im folgenden Beispiel wird die Form namespace::function verwendet, um festzulegen, welcher Namespace verwendet werden soll:

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

public override function foo():void{};

Diese Fehlermeldung kann auch auftreten, wenn die verwiesene Klasse nicht in einem bereits verwendeten oder nicht als public deklarierten Namespace definiert ist:

public class Foo{}

class D { function xx() { return 22; } }
var d:D = new D();
var x = new d.xx(); // Fehler, Methode kann nicht als Konstruktor verwendet werden
function yy() { this.a = 22; }
var z = new yy(); // kein Fehler, globale Funktionen können als Konstruktoren verwendet werden.

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

Der folgende Code hingegen ist gültig:

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

In dem folgenden Beispiel erzeugt Zeile 3 eine Fehlermeldung, da keine set-Funktion für xx definiert ist:

class D { function get xx() { return 22; } }
var d:D = new D();
d.xx = 44; // Fehler, Eigenschaft kann nur gelesen werden

public int z;// sollte 'public var z:int;' sein

import flash.utils.trace;
trace "hello"

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

var sum:int = 1 + 2 + ;

Wenn die Fehlermeldung "Linke Klammer vor _ erwartet" lautet, haben Sie eventuell eine Klammer bei einem bedingten Ausdruck vergessen, wie im folgenden beabsichtigt falschen Beispiel:

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

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

Die Datei "a.as" enthält den folgenden Code, der versucht, die Datei "b.as" einzuschließen:

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

Die Datei "b.as" enthält den folgenden Code, der versucht, die Datei "a.as" einzuschließen:

include "a.as"

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

Vielleicht verwenden Sie einen übergeordneten Typ, wo ein untergeordneter Typ erwartet wird. Beispiel:

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

Die letzte Anweisung erzeugt eine Fehlermeldung, weil sie versucht, ein Objekt des Datentyps A einer Variablen des Datentyps B zuzuweisen.

Ähnlich definiert der folgende Code die Funktion foo(), die einen Parameter des Datentyps B enthält. Die Anweisung foo(a); erzeugt eine Fehlermeldung, weil sie versucht, einen Parameter des Datentyps A zu verwenden:

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

Auch folgende Anweisung erzeugt eine Fehlermeldung, weil der für foo2() zurückgegebene Wert den Datentyp B aufweisen muss:

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); } }

Die folgende Anweisung würde eine Fehlermeldung erzeugen, weil sie drei Argumente bereitstellt:

A.goo(1,2,3);

Das folgende Codebeispiel wandelt die Variable x korrekt in den gleichen Datentyp um:

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)
}

Das folgende Codebeispiel erzeugt eine Fehlermeldung, da die Datentypumwandlung in der Variablendeklaration und die for-Schleifen unterschiedlich sind:

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

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

Die korrekt implementierte Anweisung würde class C implements A { lauten.

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

function f(x):int
{
if (x)
    	return 2;
else
    	return 3;
} // kein Fehler

Jedoch wird diese Fehlermeldung von der folgenden Funktion g(x) erzeugt, da die switch-Anweisung nicht immer einen Wert zurückgibt.

function g(x:int):int
{
switch(x)
{
      	case 1: return 1;
      	case 2: return 2:
}
// return 2;//Kommentierung entfernen, um den Fehler zu entfernen
}

Diese Überprüfung wird nur dann aktiviert, wenn die Funktion einen anderen Rückgabetyp als void deklariert.

p.huh = 55;