bootstrap - ¿Qué hace este código Javascript?
title css (4)
He estado buscando en los archivos de script de Sharepoint y he encontrado este bit que no entiendo:
function ULSTYE() {
var o = new Object;
o.ULSTeamName = "Microsoft SharePoint Foundation";
o.ULSFileName = "SP.UI.Dialog.debug.js";
return o;
}
SP.UI.$create_DialogOptions = function() {
ULSTYE:; <----------------------------- WTF?
return new SP.UI.DialogOptions();
}
En realidad, cada definición de función en este archivo comienza con el mismo ULSTYE:; Línea justo después de la abrazadera de apertura. ¿Alguien puede explicar qué hace la primera línea en la segunda función?
Firefox / Firebug, por ejemplo, interpreta esta función como algo que tampoco puedo entender:
function () {
ULSTYE: {
}
return new (SP.UI.DialogOptions);
}
Y pensé que sabía Javascript a través de ... ;) Debe ser una característica oscura que nunca utilicé en el pasado y, obviamente, rara vez es utilizada por otros también.
¿No es sólo una etiqueta de declaración ? El hecho de que la etiqueta tenga el mismo nombre que la función anterior no significa nada, creo.
Después de preguntarme por esto durante mucho tiempo, finalmente me senté y lo resolví. Todo es parte de un mecanismo relativamente sofisticado para recopilar información de diagnóstico en el cliente que incluye la capacidad de enviar una pila de llamadas javascript (incluido el nombre de la función y el archivo javascript) al servidor.
Eche un vistazo a las primeras 250 líneas del archivo init.debug.js que se encuentra en
% Archivos de programa% / Archivos comunes / Microsoft Shared / Web Server Extensions / 14 / TEMPLATE / LAYOUTS / 1033 / init.debug.js
Este archivo define todas las funciones de la implementación ''ULS'' en el cliente.
Por supuesto, deberá tener instalado SharePoint 2010 para que el archivo exista en su máquina local.
ACTUALIZACIÓN: la siguiente es una descripción general de cómo funciona el mecanismo. La implementación real hace más que esto.
Considere la siguiente página html con algunos js incluidos, cada uno de los cuales se puede llamar el uno al otro.
<html>
<head>
<script type="text/javascript" src="ErrorHandling.js"></script>
<script type="text/javascript" src="File1.js"></script>
<script type="text/javascript" src="File2.js"></script>
</head>
<body>
<button onclick="DoStuff()">Do stuff</button>
</body>
</html>
Tenemos dos archivos de inclusión js, File1.js
function ULSabc() { var o = new Object; o.File = "File1.js"; return o; }
/* ULSabc is the unique label for this js file. Each function in
this file can be decorated with a label corresponding with the same name */
function DoStuff() {
ULSabc: ;
//label matches name of function above
DoMoreStuff();
}
y File2.js
function ULSdef() { var o = new Object; o.File = "File2.js"; return o; }
function DoMoreStuff() {
ULSdef: ;
DoEvenMoreStuff();
}
function DoEvenMoreStuff() {
ULSdef: ;
try {
//throw an error
throw "Testing";
} catch (e) {
//handle the error by displaying the callstack
DisplayCallStack(e);
}
}
Ahora, digamos que nuestro archivo ErrorHandling se ve así
function GetFunctionInfo(fn) {
var info = "";
if (fn) {
//if we have a function, convert it to a string
var fnTxt = fn.toString();
//find the name of the function by removing the ''function'' and ()
var fnName = fnTxt.substring(0, fnTxt.indexOf("(")).substring(8);
info += "Function: " + fnName;
//next use a regular expression to find a match for ''ULS???:''
//which is the label within the function
var match = fnTxt.match(/ULS[^/s;]*:/);
if (match) {
var ULSLabel = match[0];
//if our function definition contains a label, strip off the
// : and add () to make it into a function we can call eval on
ULSLabel = ULSLabel.substring(0, ULSLabel.length - 1) + "()";
//eval our function that is defined at the top of our js file
var fileInfo = eval(ULSLabel);
if (fileInfo && fileInfo.File) {
//add the .File property of the returned object to the info
info += " => Script file: " + fileInfo.File;
}
}
}
return info;
}
function DisplayCallStack(e) {
//first get a reference to the function that call this
var caller = DisplayCallStack.caller;
var stack = "Error! " + e + "/r/n";
//recursively loop through the caller of each function,
//collecting the function name and script file as we go
while (caller) {
stack += GetFunctionInfo(caller) + "/r/n";
caller = caller.caller;
}
//alert the callstack, but we could alternately do something
//else like send the info to the server via XmlHttp.
alert(stack);
}
Cuando hacemos clic en el botón en la página, nuestro archivo de comandos llamará a través de cada una de las funciones y terminará en DisplayCallStack, en cuyo punto recursivamente recorrerá y recopilará el seguimiento de la pila.
Error! Testing
Function: DoEvenMoreStuff => Script file: File2.js
Function: DoMoreStuff => Script file: File2.js
Function: DoStuff => Script file: File1.js
Function: onclick
El primer bit define una función que crea un objeto con un par de propiedades y lo devuelve. Creo que todos estamos claros en eso. :-)
El segundo bit, sin embargo, no está utilizando esa función. Es definir una etiqueta con el mismo nombre. Aunque utiliza la misma secuencia de caracteres, no es una referencia a la función anterior. La interpretación de Firefox tiene tanto sentido como cualquier otra cosa, porque una etiqueta debe ir seguida de algo a lo que pueda referirse.
Para obtener más información sobre las declaraciones etiquetadas, consulte la Sección 12.12 de la especificación .
Fuera de tema : evitaría usar código de esta fuente. Quienquiera que lo haya escrito es aparentemente bastante nuevo en JavaScript y no muestra mucha señal de que sepa lo que está haciendo. Por ejemplo, han dejado el () apagado de la new Object() llamada de new Object() , y aunque eso está permitido, es algo bastante peligroso. Podrían argumentar que lo estaban haciendo para ahorrar espacio, pero si lo estuvieran, sería mejor que usaran un objeto literal:
function ULSTYE() {
return {
ULSTeamName: "Microsoft SharePoint Foundation",
ULSFileName: "SP.UI.Dialog.debug.js"
};
}
Nunca hay muchas razones para escribir un new Object() en absoluto; {} es funcionalmente idéntico.
Y, por supuesto, no hay ninguna justificación para el segundo bit en absoluto. :-)
Parece que crea un objeto vacío que debe rellenarse con algunos datos, pero debido al generador de código que crea este código, no se elimina, por lo que permanece vacío.